A job says how far along it is; a ComfyUI model brings its custom nodes

G2: the gate keeps a websocket open to its ComfyUI under a client id of its
own, puts that id on every workflow it lets through — ComfyUI tells only
the client that queued a workflow how it goes — and keeps the last word on
each: the node running, its step of how many. It answers at
/progress/{prompt_id}. While a job's request waits, the router reads the
queue (queued, n ahead) and the gate (running, node, step, percent) and
writes it into the job, which a client reads back. Only into a job of the
same key: a tag naming another's job writes nothing.

G3, the rest of the plumbing: comfyui.nodes names custom nodes by https
repository and full commit, with the PyPI packages they need. The gate puts
each in the replica's own custom_nodes at that commit and installs the
packages beside the replica, constrained to the versions ComfyUI's
environment already has, which it never changes. The catalog refuses a
branch for a commit and anything but package specs for requirements. An
OBJ a node saves leaves the gateway as a GLB, colours kept, so every mesh
can carry its licence.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ilker ManapandClaude Opus 5.5 committed 2026-10-10 18:46:44 +02:00
1 parent c87e413360
commit 88781cfcfe
14 files changed
+1064 -6

No files matched your search

+64 -1
View File
@@ -7,8 +7,10 @@ import (
"encoding/hex"
"encoding/json"
"fmt"
"maps"
"net/url"
"path"
"regexp"
"slices"
"strings"
"time"
@@ -550,6 +552,51 @@ type ComfyUI struct {
// at /v1/images/generations, or meshes, asked for as a job at
// /v1/3d/generations from a picture.
Output string `json:"output,omitempty" koanf:"output"`
// Nodes are custom nodes the workflow needs, put in each replica's own
// custom_nodes at the commit named.
Nodes []CustomNode `json:"nodes,omitempty" koanf:"nodes"`
}
// CustomNode is a ComfyUI node from a git repository.
type CustomNode struct {
// Repo is the repository, https only.
Repo string `json:"repo" koanf:"repo"`
// Commit is the full commit the node is used at: a branch moves, and a
// node that changed under a model is a model that changed unasked.
Commit string `json:"commit" koanf:"commit"`
// Requirements are the PyPI packages the node needs that ComfyUI does
// not have, by name and version range only. They are installed beside
// the replica, never into ComfyUI's environment, at the versions that
// environment already has of anything it shares.
Requirements []string `json:"requirements,omitempty" koanf:"requirements"`
}
// NodesEnv carries a ComfyUI model's custom nodes to the agent, which hands
// them to the gate.
const NodesEnv = "LLMGW_COMFYUI_NODES"
var (
fullCommit = regexp.MustCompile(`^[0-9a-f]{40}$`)
packageSpec = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]*(\[[A-Za-z0-9,._-]+\])?\s*([<>=!~]=?\s*[A-Za-z0-9.*+!_-]+\s*,?\s*)*$`)
)
func (n CustomNode) validate(model string) error {
u, err := url.Parse(n.Repo)
if err != nil || u.Scheme != "https" || u.Host == "" || u.User != nil {
return fmt.Errorf("model %q: custom node %q is not an https repository", model, n.Repo)
}
if !fullCommit.MatchString(n.Commit) {
return fmt.Errorf("model %q: custom node %s needs its full commit (40 hex), not %q: a branch moves",
model, n.Repo, n.Commit)
}
for _, r := range n.Requirements {
// A package and a version range: an option or a URL would install
// from somewhere other than PyPI.
if !packageSpec.MatchString(strings.TrimSpace(r)) {
return fmt.Errorf("model %q: custom node %s requirement %q is not a package with a version range", model, n.Repo, r)
}
}
return nil
}
// ComfyWorkflow is what a ComfyUI model's replicas are sent: the workflow
@@ -604,6 +651,13 @@ func (m Model) validateComfyUI() error {
if err := checkWorkflow(m.Name, w); err != nil {
return err
}
if m.ComfyUI != nil {
for _, n := range m.ComfyUI.Nodes {
if err := n.validate(m.Name); err != nil {
return err
}
}
}
if out := m.comfyOutput(); out != OutputPictures && out != OutputMeshes {
return fmt.Errorf("model %q: comfyui.output %q is not pictures or meshes", m.Name, out)
}
@@ -1126,6 +1180,15 @@ func (m Model) EngineProfile(name string) (engines.Profile, bool) {
if p.Name != name {
continue
}
env := p.Env
if p.Engine == EngineComfyUI && m.ComfyUI != nil && len(m.ComfyUI.Nodes) > 0 {
nodes, _ := json.Marshal(m.ComfyUI.Nodes)
env = maps.Clone(p.Env)
if env == nil {
env = map[string]string{}
}
env[NodesEnv] = string(nodes)
}
return engines.Profile{
Name: p.Name,
Engine: p.Engine,
@@ -1135,7 +1198,7 @@ func (m Model) EngineProfile(name string) (engines.Profile, bool) {
GPUsPerNode: p.GPUsPerNode,
Nodes: p.Nodes,
Args: slices.Clone(p.Args),
Env: p.Env,
Env: env,
ModelPath: m.SourceOf(p),
ServedModelName: m.Name,
Adapters: m.engineAdapters(),
+32
View File
@@ -49,3 +49,35 @@ func TestAComfyUIModelIsRefusedWhatItCannotDo(t *testing.T) {
t.Errorf("a set with its checkpoint named was refused: %v", err)
}
}
func TestACustomNodeIsPinnedAndItsPackagesArePackages(t *testing.T) {
node := func(n CustomNode) Model {
return comfyModel("hf:stabilityai/TripoSR/model.ckpt", &ComfyUI{Workflow: "w.json", Output: OutputMeshes,
Nodes: []CustomNode{n}})
}
ok := CustomNode{Repo: "https://github.com/flowtyone/ComfyUI-Flowty-TripoSR",
Commit: "0123456789abcdef0123456789abcdef01234567", Requirements: []string{"omegaconf", "trimesh>=4,<5", "scikit-image"}}
cat, err := New([]Model{node(ok)})
if err != nil {
t.Fatal(err)
}
m, _ := cat.Resolve("flux")
p, _ := m.EngineProfile("gpu")
if !strings.Contains(p.Env[NodesEnv], "ComfyUI-Flowty-TripoSR") || !m.MakesMeshes() || m.MakesImages() {
t.Errorf("env %v meshes %v pictures %v", p.Env, m.MakesMeshes(), m.MakesImages())
}
for name, n := range map[string]CustomNode{
"a branch": {Repo: ok.Repo, Commit: "main"},
"http": {Repo: "http://example.com/n", Commit: ok.Commit},
"an option": {Repo: ok.Repo, Commit: ok.Commit, Requirements: []string{"--index-url=https://evil"}},
"a url": {Repo: ok.Repo, Commit: ok.Commit, Requirements: []string{"x @ https://evil/x.whl"}},
} {
if _, err := New([]Model{node(n)}); err == nil {
t.Errorf("%s: accepted", name)
}
}
noWorkflow := comfyModel("hf:a/b/c.ckpt", &ComfyUI{Output: OutputMeshes})
if _, err := New([]Model{noWorkflow}); err == nil || !strings.Contains(err.Error(), "names its workflow") {
t.Errorf("a mesh model without a workflow: %v", err)
}
}