Any ComfyUI workflow runs as a job, from the inputs its catalog entry declares
CI / test (push) Successful in 9m7s

A model's catalog entry now says what its workflow takes and makes:
comfyui.inputs, each a placeholder of its name with a type (text, int,
float, bool, choice, image, mask, audio, video, file), bounds, choices
and a default; and comfyui.output, which gains video, audio and files
beside pictures and meshes. POST /v1/workflows/runs with {model, inputs}
checks a request against them before a job is written — a required input
left out, an unknown one, a number out of bounds, a song sent as a
picture, another owner's file id are each refused with what was wrong —
and the job worker replays it to a replica, where the files go into
ComfyUI's input directory, the workflow is filled and run, and the first
file of the model's output kind is the job's result. /v1/models lists
each ComfyUI model's workflow, so a client can build its form.

A PNG result carries the licence in an iTXt chunk, as a GLB does in
asset.extras. A file whose server named no type is typed by its name
before its bytes, so a WAV is audio/wav, not audio/wave.

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-11 14:28:15 +02:00
1 parent b43e66c95e
commit b6bfc33ef7
20 files changed
+1660 -44

No files matched your search

+83 -15
View File
@@ -108,6 +108,11 @@ type Params struct {
}
func (p Params) value(name string) (any, bool) {
// A workflow's own input of a built-in's name is the request's: an input
// named prompt is the prompt a run was given.
if v, ok := p.Extra[name]; ok {
return v, true
}
switch name {
case "checkpoint":
return p.Checkpoint, p.Checkpoint != ""
@@ -130,8 +135,44 @@ func (p Params) value(name string) (any, bool) {
case "image":
return p.Image, p.Image != ""
}
v, ok := p.Extra[name]
return v, ok
return nil, false
}
// Builtin are the placeholders Params fills by itself, which a workflow may
// use without declaring them as inputs.
var Builtin = []string{"checkpoint", "prompt", "negative_prompt", "width", "height", "n", "seed", "steps", "guidance", "image"}
// Placeholders are the names a template's placeholders use, each once,
// sorted, and whether each has a default of its own.
func (t *Template) Placeholders() map[string]bool {
out := map[string]bool{}
var walk func(v any)
walk = func(v any) {
switch v := v.(type) {
case map[string]any:
for _, x := range v {
walk(x)
}
case []any:
for _, x := range v {
walk(x)
}
case string:
for s := v; ; {
i := strings.Index(s, "{{")
j := strings.Index(s, "}}")
if i < 0 || j < i {
return
}
name, _, hasDef := strings.Cut(s[i+2:j], "|")
name = strings.TrimSpace(name)
out[name] = out[name] || hasDef
s = s[j+2:]
}
}
}
walk(t.graph)
return out
}
// Fill is the workflow for one request.
@@ -398,9 +439,17 @@ func (c *Client) fetch(ctx context.Context, base, apiKey string, h historyEntry)
return nil, err
}
img.Name = f.Filename
if t := typeByName(f.Filename); t != "" && (img.ContentType == "" ||
strings.HasPrefix(img.ContentType, "application/octet-stream") || strings.HasPrefix(img.ContentType, "text/plain")) {
img.ContentType = t
// A type the server did not say is the file's by its name,
// else by its first bytes.
if generic(img.ContentType) {
if t := typeByName(f.Filename); t != "" {
img.ContentType = t
} else {
img.ContentType = http.DetectContentType(img.Data)
}
}
if img.ContentType == "image/png" {
img.Data = withoutPNGText(img.Data)
}
out = append(out, img)
}
@@ -497,14 +546,12 @@ func (c *Client) get(ctx context.Context, u, apiKey string) (Image, error) {
if resp.StatusCode != http.StatusOK {
return Image{}, &Error{Msg: fmt.Sprintf("ComfyUI answered %d for a file it made", resp.StatusCode)}
}
ct := resp.Header.Get("Content-Type")
if ct == "" || ct == "application/octet-stream" {
ct = http.DetectContentType(b)
}
if ct == "image/png" {
b = withoutPNGText(b)
}
return Image{Data: b, ContentType: ct}, nil
return Image{Data: b, ContentType: resp.Header.Get("Content-Type")}, nil
}
// generic is a type that says nothing of what a file is.
func generic(ct string) bool {
return ct == "" || strings.HasPrefix(ct, "application/octet-stream") || strings.HasPrefix(ct, "text/plain")
}
// withoutPNGText is a PNG without its text chunks. ComfyUI writes the whole
@@ -604,12 +651,33 @@ func typeByName(name string) string {
return "application/ply"
case ".png":
return "image/png"
case ".jpg", ".jpeg":
return "image/jpeg"
case ".webp":
return "image/webp"
case ".gif":
return "image/gif"
case ".mp4":
return "video/mp4"
case ".webm":
return "video/webm"
case ".mov":
return "video/quicktime"
case ".wav":
return "audio/wav"
case ".mp3":
return "audio/mpeg"
case ".flac":
return "audio/flac"
case ".ogg", ".opus":
return "audio/ogg"
}
return ""
}
// Upload puts a picture in ComfyUI's input directory, where a LoadImage node
// reads it, and returns the name it was given there.
// Upload puts a file in ComfyUI's input directory, where a loader node reads
// it — LoadImage, LoadAudio, LoadVideo, whatever the workflow uses: ComfyUI's
// /upload/image takes any file — and returns the name it was given there.
func (c *Client) Upload(ctx context.Context, base, apiKey, name string, data []byte) (string, error) {
base = strings.TrimRight(base, "/")
var body bytes.Buffer