@dorely13/ai-imagegen-cli 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { mkdir as mkdir3, readFile as readFile3, stat, writeFile as writeFile3 } from "node:fs/promises";
-import { basename, dirname as dirname3, extname, join as join4, resolve as resolve2 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile4, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import { basename, dirname as dirname5, extname, join as join5, resolve as resolve3 } from "node:path";
 
 // ../../packages/core/dist/types.js
 var ProviderError = class extends Error {
@@ -85,7 +85,9 @@ function normalizeOutputFormat(value) {
     return "jpeg";
   if (normalized === "webp")
     return "webp";
-  return "png";
+  if (normalized === "png" || normalized === "")
+    return "png";
+  throw new ProviderError({ kind: "usage", message: "Output format must be png, jpeg, or webp." });
 }
 
 // ../../packages/core/dist/image-size.js
@@ -226,20 +228,24 @@ var AUTH_ENDPOINT = "https://auth.openai.com/oauth/authorize";
 var TOKEN_ENDPOINT = "https://auth.openai.com/oauth/token";
 var CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 var SCOPE = "openid profile email offline_access";
-var RESPONSES_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+var IMAGES_ENDPOINT = "https://chatgpt.com/backend-api/codex/images";
 var DEFAULT_REDIRECT_URI = "http://localhost:1455/auth/callback";
 var LOOPBACK_PORT = 1455;
 var CALLBACK_PATH = "/auth/callback";
-var DEFAULT_IMAGE_MODEL = "gpt-image-2.5-flare";
-var DEFAULT_ORCHESTRATION_MODEL = "gpt-5.6-luna";
+var DEFAULT_IMAGE_MODEL = "gpt-image-2.6-flare";
 var DEFAULT_QUALITY = "auto";
 var REQUEST_TIMEOUT_SECONDS = 600;
-var PARTIAL_IMAGES = 2;
 var MAX_REFERENCE_IMAGES2 = 4;
 var MAX_IMAGE_COUNT2 = 4;
 var MIN_IMAGE_COUNT2 = 1;
 var FLOW_TIMEOUT_MINUTES = 10;
 var USER_AGENT = "ImageGenCli";
+var TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1e3;
+var TOKEN_REQUEST_TIMEOUT_MS = 30 * 1e3;
+var REFRESH_LOCK_FILE = "codex-refresh.lock";
+var REFRESH_LOCK_STALE_MS = 60 * 1e3;
+var REFRESH_LOCK_WAIT_MS = 90 * 1e3;
+var REFRESH_LOCK_POLL_MS = 100;
 
 // ../../packages/providers-codex/dist/pkce.js
 import { createHash, randomBytes } from "node:crypto";
@@ -282,7 +288,7 @@ function callbackPage(title, message) {
   return `<!doctype html><html><head><meta charset="utf-8"><title>${title}</title></head><body style="font-family:sans-serif;padding:2rem"><h1>${title}</h1><p>${message}</p></body></html>`;
 }
 async function waitForOAuthCallback(timeoutMs = FLOW_TIMEOUT_MINUTES * 60 * 1e3, port = LOOPBACK_PORT) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let server;
     const timer = setTimeout(() => {
       closeServer();
@@ -322,7 +328,7 @@ async function waitForOAuthCallback(timeoutMs = FLOW_TIMEOUT_MINUTES * 60 * 1e3,
         res.writeHead(200, { "content-type": "text/html" });
         res.end(callbackPage("Connected", "ImageGenCli is connected. You can close this tab."));
         closeServer();
-        resolve3({ code, state });
+        resolve4({ code, state });
       } catch (error2) {
         fail2(error2 instanceof Error ? error2 : new LoopbackError("OAuth callback failed.", "callback_error"));
       }
@@ -340,7 +346,7 @@ async function waitForOAuthCallback(timeoutMs = FLOW_TIMEOUT_MINUTES * 60 * 1e3,
 
 // ../../packages/providers-codex/dist/codex-auth.js
 var ReauthRequiredError = class extends Error {
-  constructor(message = "Codex credentials are missing or expired. Run `imagegen auth login` to reconnect.") {
+  constructor(message = "Codex credentials are missing or expired. Run `imagegen auth codex login` to reconnect.") {
     super(message);
     this.name = "ReauthRequiredError";
   }
@@ -353,10 +359,24 @@ function toTokenSet(body, fallbackRefreshToken) {
     scope: body.scope
   };
 }
+var REJECTED_GRANT_CODES = /* @__PURE__ */ new Set([
+  "invalid_grant",
+  "invalid_token",
+  "refresh_token_expired",
+  "refresh_token_reused",
+  "refresh_token_invalidated"
+]);
 async function readOAuthErrorCode(response) {
   try {
     const body = await response.json();
-    return typeof body.error === "string" ? body.error : null;
+    if (typeof body.error === "string")
+      return body.error;
+    if (typeof body.error === "object" && body.error !== null) {
+      const code = body.error["code"];
+      if (typeof code === "string")
+        return code;
+    }
+    return null;
   } catch {
     return null;
   }
@@ -365,30 +385,31 @@ async function postTokenRequest(params) {
   const response = await fetch(TOKEN_ENDPOINT, {
     method: "POST",
     headers: { "content-type": "application/x-www-form-urlencoded" },
-    body: new URLSearchParams(params)
+    body: new URLSearchParams(params),
+    signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
   });
   if (!response.ok) {
     const errorCode = await readOAuthErrorCode(response.clone());
-    if (response.status === 401 || response.status === 400 && (errorCode === "invalid_grant" || errorCode === "invalid_token")) {
-      return null;
+    if (response.status === 401 || errorCode !== null && REJECTED_GRANT_CODES.has(errorCode)) {
+      return { ok: false, reason: errorCode ?? `status ${response.status}` };
     }
-    throw new Error(`Token request failed with status ${response.status}.`);
+    throw new Error(`Token request failed with status ${response.status}${errorCode ? ` (${errorCode})` : ""}.`);
   }
   const body = await response.json();
-  return toTokenSet(body, params["refresh_token"]);
+  return { ok: true, tokens: toTokenSet(body, params["refresh_token"]) };
 }
 async function exchangeCodeForTokens(args) {
-  const tokens = await postTokenRequest({
+  const outcome = await postTokenRequest({
     grant_type: "authorization_code",
     client_id: CLIENT_ID,
     code: args.code,
     redirect_uri: args.redirectUri,
     code_verifier: args.codeVerifier
   });
-  if (!tokens) {
-    throw new ReauthRequiredError("The authorization code was rejected. Run `imagegen auth login` again.");
+  if (!outcome.ok) {
+    throw new ReauthRequiredError(`The authorization code was rejected (${outcome.reason}). Run \`imagegen auth codex login\` again.`);
   }
-  return tokens;
+  return outcome.tokens;
 }
 async function refreshTokens(refreshToken) {
   return postTokenRequest({
@@ -397,8 +418,8 @@ async function refreshTokens(refreshToken) {
     refresh_token: refreshToken
   });
 }
-function isTokenExpired(tokens, now = Date.now()) {
-  return tokens.expiresAt <= now;
+function needsRefresh(tokens, now = Date.now()) {
+  return tokens.expiresAt - TOKEN_REFRESH_MARGIN_MS <= now;
 }
 var pendingVerifiers = /* @__PURE__ */ new Map();
 function startPkceFlow(redirectUri2) {
@@ -424,65 +445,9 @@ function prunePendingVerifiers() {
   }
 }
 
-// ../../packages/providers-codex/dist/codex-token-manager.js
-var CodexTokenManager = class {
-  store;
-  pendingRefresh = null;
-  constructor(store) {
-    this.store = store;
-  }
-  async exchangeAndSave(args) {
-    const tokens = await exchangeCodeForTokens(args);
-    await this.store.save(PROVIDER_NAME, tokens);
-    return tokens;
-  }
-  async status() {
-    const tokens = await this.store.load(PROVIDER_NAME);
-    if (!tokens)
-      return { connected: false };
-    if (!isTokenExpired(tokens))
-      return { connected: true, expiresAt: tokens.expiresAt };
-    if (!tokens.refreshToken)
-      return { connected: false };
-    try {
-      const refreshed = await this.getValidAccessToken();
-      void refreshed;
-      const current = await this.store.load(PROVIDER_NAME);
-      return { connected: true, expiresAt: current?.expiresAt };
-    } catch {
-      return { connected: false };
-    }
-  }
-  async logout() {
-    await this.store.clear(PROVIDER_NAME);
-  }
-  async getValidAccessToken() {
-    const tokens = await this.store.load(PROVIDER_NAME);
-    if (!tokens)
-      throw new ReauthRequiredError();
-    if (!isTokenExpired(tokens))
-      return tokens.accessToken;
-    if (!tokens.refreshToken) {
-      await this.store.clear(PROVIDER_NAME);
-      throw new ReauthRequiredError();
-    }
-    if (!this.pendingRefresh) {
-      this.pendingRefresh = this.performRefresh(tokens.refreshToken).finally(() => {
-        this.pendingRefresh = null;
-      });
-    }
-    return this.pendingRefresh;
-  }
-  async performRefresh(refreshToken) {
-    const refreshed = await refreshTokens(refreshToken);
-    if (!refreshed) {
-      await this.store.clear(PROVIDER_NAME);
-      throw new ReauthRequiredError();
-    }
-    await this.store.save(PROVIDER_NAME, refreshed);
-    return refreshed.accessToken;
-  }
-};
+// ../../packages/providers-codex/dist/refresh-lock.js
+import { mkdir, open, rm, stat } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
 
 // ../../packages/credentials/dist/index.js
 import { homedir } from "node:os";
@@ -490,8 +455,8 @@ import { join } from "node:path";
 function asKeytar(module) {
   if (typeof module !== "object" || module === null)
     return null;
-  const record2 = module;
-  const candidate = record2["default"] ?? module;
+  const record3 = module;
+  const candidate = record3["default"] ?? module;
   if (typeof candidate.getPassword === "function" && typeof candidate.setPassword === "function" && typeof candidate.deletePassword === "function") {
     return candidate;
   }
@@ -563,9 +528,9 @@ var FileCredentialStore = class {
     return { backend: "file", location: this.filePath };
   }
   async readAll() {
-    const { readFile: readFile4 } = await import("node:fs/promises");
+    const { readFile: readFile5 } = await import("node:fs/promises");
     try {
-      const raw = await readFile4(this.filePath, "utf8");
+      const raw = await readFile5(this.filePath, "utf8");
       let value;
       try {
         value = JSON.parse(raw);
@@ -582,9 +547,9 @@ var FileCredentialStore = class {
     }
   }
   async writeAll(all) {
-    const { mkdir: mkdir4, writeFile: writeFile4, chmod } = await import("node:fs/promises");
-    const { dirname: dirname4 } = await import("node:path");
-    await mkdir4(dirname4(this.filePath), { recursive: true });
+    const { mkdir: mkdir6, writeFile: writeFile4, chmod } = await import("node:fs/promises");
+    const { dirname: dirname6 } = await import("node:path");
+    await mkdir6(dirname6(this.filePath), { recursive: true });
     await writeFile4(this.filePath, JSON.stringify(all, null, 2), {
       mode: 384
     });
@@ -602,6 +567,133 @@ function defaultCredentialFilePath() {
   return join(base, "ImageGenCli", "tokens.json");
 }
 
+// ../../packages/providers-codex/dist/refresh-lock.js
+function defaultRefreshLockPath() {
+  return join2(dirname(defaultCredentialFilePath()), REFRESH_LOCK_FILE);
+}
+function createRefreshLock(options = {}) {
+  const path = options.path ?? defaultRefreshLockPath();
+  const staleMs = options.staleMs ?? REFRESH_LOCK_STALE_MS;
+  const waitMs = options.waitMs ?? REFRESH_LOCK_WAIT_MS;
+  const pollMs = options.pollMs ?? REFRESH_LOCK_POLL_MS;
+  return async (work) => {
+    await acquire(path, staleMs, waitMs, pollMs);
+    try {
+      return await work();
+    } finally {
+      await rm(path, { force: true });
+    }
+  };
+}
+async function acquire(path, staleMs, waitMs, pollMs) {
+  await mkdir(dirname(path), { recursive: true });
+  const deadline = Date.now() + waitMs;
+  for (; ; ) {
+    try {
+      const handle = await open(path, "wx");
+      try {
+        await handle.writeFile(`${process.pid}
+`);
+      } finally {
+        await handle.close();
+      }
+      return;
+    } catch (error2) {
+      if (!isContention(error2))
+        throw error2;
+    }
+    if (await isStale(path, staleMs)) {
+      await rm(path, { force: true });
+      continue;
+    }
+    if (Date.now() >= deadline) {
+      throw new Error("Timed out waiting for another imagegen process to refresh Codex credentials.");
+    }
+    await new Promise((resolve4) => setTimeout(resolve4, pollMs + Math.random() * pollMs));
+  }
+}
+function isContention(error2) {
+  const code = error2.code;
+  return code === "EEXIST" || process.platform === "win32" && (code === "EPERM" || code === "EACCES");
+}
+async function isStale(path, staleMs) {
+  try {
+    return Date.now() - (await stat(path)).mtimeMs > staleMs;
+  } catch {
+    return false;
+  }
+}
+
+// ../../packages/providers-codex/dist/codex-token-manager.js
+var CodexTokenManager = class {
+  store;
+  pendingRefresh = null;
+  lock;
+  refresh;
+  constructor(store, options = {}) {
+    this.store = store;
+    this.lock = options.lock ?? createRefreshLock();
+    this.refresh = options.refresh ?? refreshTokens;
+  }
+  async exchangeAndSave(args) {
+    const tokens = await exchangeCodeForTokens(args);
+    await this.store.save(PROVIDER_NAME, tokens);
+    return tokens;
+  }
+  async status() {
+    if (!await this.store.load(PROVIDER_NAME))
+      return { connected: false };
+    try {
+      await this.getValidAccessToken();
+      const current = await this.store.load(PROVIDER_NAME);
+      return { connected: true, expiresAt: current?.expiresAt };
+    } catch {
+      return { connected: false };
+    }
+  }
+  async logout() {
+    await this.store.clear(PROVIDER_NAME);
+  }
+  async getValidAccessToken() {
+    const tokens = await this.store.load(PROVIDER_NAME);
+    if (!tokens)
+      throw new ReauthRequiredError();
+    if (!needsRefresh(tokens))
+      return tokens.accessToken;
+    return this.refreshFrom(tokens.accessToken);
+  }
+  // The Codex image endpoint rejected this access token before its recorded expiry.
+  async recoverFromUnauthorized(rejectedAccessToken) {
+    return this.refreshFrom(rejectedAccessToken);
+  }
+  refreshFrom(staleAccessToken) {
+    if (!this.pendingRefresh) {
+      this.pendingRefresh = this.lock(() => this.refreshLocked(staleAccessToken)).finally(() => {
+        this.pendingRefresh = null;
+      });
+    }
+    return this.pendingRefresh;
+  }
+  async refreshLocked(staleAccessToken) {
+    const current = await this.store.load(PROVIDER_NAME);
+    if (!current)
+      throw new ReauthRequiredError();
+    if (current.accessToken !== staleAccessToken && !needsRefresh(current))
+      return current.accessToken;
+    if (!current.refreshToken) {
+      await this.store.clear(PROVIDER_NAME);
+      throw new ReauthRequiredError();
+    }
+    const outcome = await this.refresh(current.refreshToken);
+    if (!outcome.ok) {
+      await this.store.clear(PROVIDER_NAME);
+      throw new ReauthRequiredError(`Codex rejected the stored refresh token (${outcome.reason}). Run \`imagegen auth codex login\` to reconnect.`);
+    }
+    await this.store.save(PROVIDER_NAME, outcome.tokens);
+    return outcome.tokens.accessToken;
+  }
+};
+
 // ../../packages/providers-codex/dist/token-store.js
 async function resolveTokenStore() {
   const store = await resolveCredentialStore();
@@ -642,13 +734,18 @@ function extractAccountId(token) {
   return accountId;
 }
 
-// ../../packages/providers-codex/dist/sse.js
+// ../../packages/providers-codex/dist/codex-client.js
+import sharp from "sharp";
+
+// ../../packages/providers-codex/dist/errors.js
 function classifyImageError(message) {
   if (!message.trim())
     return "unknown";
   const lowerRate = message.includes("input-images") && message.includes("per min") && message.toLowerCase().includes("gpt-image");
   if (lowerRate)
     return "codex_image_input_rate_limit";
+  if (/usage limit/i.test(message))
+    return "usage_limit";
   if (/rate limit|429|too many requests|please try again/i.test(message))
     return "rate_limit";
   if (/403|forbidden|cloudflare/i.test(message))
@@ -657,107 +754,26 @@ function classifyImageError(message) {
     return "image_model_invalid";
   return "api_error";
 }
-function readString(value, property) {
-  if (typeof value !== "object" || value === null)
-    return void 0;
-  const candidate = value[property];
-  return typeof candidate === "string" ? candidate : void 0;
-}
-function readEventError(event) {
-  const direct = readString(event, "message");
-  if (direct)
-    return direct;
-  if (typeof event !== "object" || event === null)
-    return void 0;
-  const record2 = event;
-  const nested = record2["error"];
-  if (typeof nested === "object" && nested !== null) {
-    const message = readString(nested, "message");
-    if (message)
-      return message;
-  }
-  const response = record2["response"];
-  if (typeof response === "object" && response !== null) {
-    const responseError = response["error"];
-    if (typeof responseError === "object" && responseError !== null) {
-      return readString(responseError, "message");
-    }
-  }
-  return void 0;
-}
-function tryReadImageItem(item) {
-  if (readString(item, "type") !== "image_generation_call")
-    return null;
-  const result = readString(item, "result");
-  if (!result)
+function readErrorMessage(body) {
+  if (!body.trim())
     return null;
-  let data;
   try {
-    data = Buffer.from(result, "base64");
-  } catch {
-    throw new Error("invalid_image_result: Codex returned an image result that was not valid base64.");
-  }
-  return { data, revisedPrompt: readString(item, "revised_prompt"), callId: readString(item, "id") };
-}
-function parseImageStreamEvents(events) {
-  let eventCount = 0;
-  let lastEventType;
-  let responseId;
-  const finish = (image) => ({
-    ...image,
-    responseId,
-    eventCount,
-    lastEventType
-  });
-  for (const raw of events) {
-    const line = raw.trim();
-    if (!line.startsWith("data:"))
-      continue;
-    const payload = line.slice("data:".length).trim();
-    if (payload === "[DONE]")
-      break;
-    let event;
-    try {
-      event = JSON.parse(payload);
-    } catch {
-      continue;
-    }
-    const type = readString(event, "type");
-    lastEventType = type ?? lastEventType;
-    eventCount += 1;
-    if (type === "response.created" && typeof event === "object" && event !== null) {
-      const inner = event["response"];
-      const id = readString(inner, "id");
-      if (id)
-        responseId = id;
-    }
-    if (type === "response.failed" || type === "error") {
-      throw new Error(`${classifyImageError(readEventError(event) ?? "")}: ${readEventError(event) ?? "Codex image generation failed."}`);
-    }
-    if (type === "response.output_item.done" && typeof event === "object" && event !== null) {
-      const item = event["item"];
-      const image = tryReadImageItem(item);
-      if (image)
-        return finish(image);
-    }
-    if (type === "response.completed" && typeof event === "object" && event !== null) {
-      const response = event["response"];
-      const id = readString(response, "id");
-      if (id)
-        responseId = id;
-      if (typeof response === "object" && response !== null) {
-        const output = response["output"];
-        if (Array.isArray(output)) {
-          for (const item of output) {
-            const image = tryReadImageItem(item);
-            if (image)
-              return finish(image);
-          }
-        }
+    const parsed = JSON.parse(body);
+    if (typeof parsed === "object" && parsed !== null) {
+      const record3 = parsed;
+      if (typeof record3["message"] === "string")
+        return record3["message"];
+      if (typeof record3["detail"] === "string")
+        return record3["detail"];
+      const error2 = record3["error"];
+      if (typeof error2 === "object" && error2 !== null && typeof error2["message"] === "string") {
+        return error2["message"];
       }
     }
+  } catch {
+    return body.slice(0, 500);
   }
-  throw new Error(`stream_completed_without_image: Codex image generation completed without returning an image. responseId=${responseId ?? "unknown"}, events=${eventCount}, lastEvent=${lastEventType ?? "none"}.`);
+  return null;
 }
 
 // ../../packages/providers-codex/dist/codex-client.js
@@ -779,112 +795,78 @@ function resolveSize(size) {
     });
   }
 }
-function baseImageTool(args) {
-  const tool = {
-    type: "image_generation",
-    model: args.imageModel,
-    action: args.action,
-    size: args.size && args.size.trim() ? args.size.trim() : "auto",
-    output_format: args.outputFormat,
+function buildBody(args) {
+  const body = {
+    prompt: args.prompt,
+    model: args.model,
+    size: args.size.size,
     background: "auto"
   };
-  if (args.partialImages > 0)
-    tool["partial_images"] = Math.min(3, Math.max(0, args.partialImages));
-  if (args.quality && args.quality.trim() && args.quality.trim().toLowerCase() !== "auto") {
-    tool["quality"] = args.quality.trim();
+  const quality = args.quality.trim();
+  if (quality && quality.toLowerCase() !== "auto")
+    body["quality"] = quality;
+  if (args.images.length > 0)
+    body["images"] = args.images.map((image) => ({ image_url: toDataUrl(image) }));
+  return body;
+}
+var MASK_INSTRUCTION = "The last image is an edit mask, not content to reproduce. Apply the requested change only where the mask is transparent. Keep every area where the mask is opaque exactly as it is in the first image.";
+async function normalizeMask(mask, source) {
+  const usage2 = (message) => new ProviderError({ kind: "usage", message });
+  let pixels;
+  let width;
+  let height;
+  let sourceWidth;
+  let sourceHeight;
+  try {
+    const decoded = await sharp(mask.data).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    ({ width, height } = decoded.info);
+    pixels = decoded.data;
+    ({ width: sourceWidth, height: sourceHeight } = await sharp(source.data).metadata());
+  } catch {
+    throw usage2("Mask and source must be readable PNG, JPEG, or WebP images.");
   }
-  if (args.outputFormat === "jpeg" && typeof args.outputCompression === "number") {
-    tool["output_compression"] = Math.min(100, Math.max(0, Math.trunc(args.outputCompression)));
+  if (width !== sourceWidth || height !== sourceHeight) {
+    throw usage2(`Mask is ${width}x${height} but the source is ${sourceWidth}x${sourceHeight}; they must match.`);
   }
-  return tool;
-}
-function buildPayload(args) {
-  const content = [{ type: "input_text", text: args.prompt }];
-  for (const reference of args.references.slice(0, MAX_REFERENCE_IMAGES2)) {
-    content.push({ type: "input_image", image_url: toDataUrl(reference), detail: "auto" });
+  let editable = false;
+  for (let i = 0; i < pixels.length; i += 4) {
+    const edit = pixels[i + 3] < 128;
+    editable ||= edit;
+    pixels.fill(edit ? 0 : 255, i, i + 4);
   }
-  return {
-    model: args.model,
-    input: [{ role: "user", content }],
-    tools: [args.tool],
-    tool_choice: { type: "image_generation" },
-    stream: true,
-    store: false
-  };
+  if (!editable)
+    throw usage2("Mask has no transparent pixels; make the area to edit transparent.");
+  const data = await sharp(pixels, { raw: { width, height, channels: 4 } }).png().toBuffer();
+  return { data, contentType: "image/png" };
 }
 var CodexImageProvider = class {
   tokens;
   name = PROVIDER_NAME;
   sizePolicy = { resolveSize: (size) => resolveSize(size) };
-  orchestrationModel;
   imageModel;
   timeoutSeconds;
-  partialImages;
   fetchImpl;
   constructor(tokens, options = {}) {
     this.tokens = tokens;
-    this.orchestrationModel = options.model ?? process.env["IMAGEGEN_CODEX_MODEL"] ?? DEFAULT_ORCHESTRATION_MODEL;
     this.imageModel = options.imageModel ?? process.env["IMAGEGEN_CODEX_IMAGE_MODEL"] ?? DEFAULT_IMAGE_MODEL;
     this.timeoutSeconds = options.timeoutSeconds ?? REQUEST_TIMEOUT_SECONDS;
-    this.partialImages = options.partialImages ?? PARTIAL_IMAGES;
     this.fetchImpl = options.fetchImpl ?? fetch;
   }
   async generate(request) {
-    const format = normalizeOutputFormat(request.format);
-    const size = this.sizePolicy.resolveSize(request.size);
-    const imageModel2 = this.resolveImageModel(request);
-    return this.runAll({
-      format,
-      imageModel: imageModel2,
-      count: normalizeCount(request.count),
-      prompt: request.prompt,
-      size,
-      build: () => buildPayload({
-        model: this.orchestrationModel,
-        prompt: request.prompt,
-        references: request.referenceImages ?? [],
-        tool: baseImageTool({
-          size: size.size,
-          quality: request.quality ?? DEFAULT_QUALITY,
-          outputFormat: format,
-          imageModel: imageModel2,
-          action: "generate",
-          partialImages: this.partialImages
-        })
-      })
-    });
+    const references = (request.referenceImages ?? []).slice(0, MAX_REFERENCE_IMAGES2);
+    return this.runAll(request, references.length > 0 ? "edits" : "generations", references);
   }
   async edit(request) {
-    const format = normalizeOutputFormat(request.format);
-    const size = this.sizePolicy.resolveSize(request.size);
-    const imageModel2 = this.resolveImageModel(request);
-    const references = [request.sourceImage, ...request.referenceImages ?? []];
-    return this.runAll({
-      format,
-      imageModel: imageModel2,
-      count: normalizeCount(request.count),
-      prompt: request.prompt,
-      size,
-      build: () => {
-        const tool = baseImageTool({
-          size: size.size,
-          quality: request.quality ?? DEFAULT_QUALITY,
-          outputFormat: format,
-          imageModel: imageModel2,
-          action: "edit",
-          partialImages: this.partialImages
-        });
-        if (request.mask) {
-          tool["input_image_mask"] = { image_url: toDataUrl(request.mask) };
-        }
-        return buildPayload({
-          model: this.orchestrationModel,
-          prompt: request.prompt,
-          references,
-          tool
-        });
-      }
-    });
+    const images = [request.sourceImage, ...request.referenceImages ?? []];
+    if (!request.mask)
+      return this.runAll(request, "edits", images.slice(0, MAX_REFERENCE_IMAGES2));
+    if (images.length + 1 > MAX_REFERENCE_IMAGES2) {
+      throw new ProviderError({ kind: "usage", message: `Codex accepts at most ${MAX_REFERENCE_IMAGES2} edit images; a mask uses one, leaving room for ${MAX_REFERENCE_IMAGES2 - 2} --reference images.` });
+    }
+    const mask = await normalizeMask(request.mask, request.sourceImage);
+    return this.runAll(request, "edits", [...images, mask], `${request.prompt}
+
+${MASK_INSTRUCTION}`);
   }
   resolveImageModel(request) {
     const model = (request.model ?? this.imageModel).trim();
@@ -896,116 +878,122 @@ var CodexImageProvider = class {
     }
     return model;
   }
-  async runAll(args) {
-    const images = [];
-    for (let i = 0; i < args.count; i += 1) {
-      images.push(await this.sendOnce(args.build(), args.format, args.prompt, args.size));
+  async runAll(request, endpoint, images, modelPrompt = request.prompt) {
+    const format = normalizeOutputFormat(request.format);
+    const size = this.sizePolicy.resolveSize(request.size);
+    const requestedModel = this.resolveImageModel(request);
+    const body = JSON.stringify(buildBody({ prompt: modelPrompt, model: requestedModel, size, quality: request.quality ?? DEFAULT_QUALITY, images }));
+    const results = [];
+    for (let i = 0, count = normalizeCount(request.count); i < count; i += 1) {
+      results.push(await this.sendOnce(endpoint, body, format, request.prompt));
+    }
+    return { provider: this.name, requestedModel, images: results };
+  }
+  async sendOnce(endpoint, body, format, prompt) {
+    let accessToken = await this.tokens.getValidAccessToken();
+    let response = await this.post(endpoint, accessToken, body);
+    if (response.status === 401) {
+      await response.body?.cancel();
+      accessToken = await this.tokens.recoverFromUnauthorized(accessToken);
+      response = await this.post(endpoint, accessToken, body);
+    }
+    const requestId = response.headers.get("x-codex-imagegen-request-id") ?? response.headers.get("x-oai-request-id") ?? response.headers.get("x-request-id") ?? void 0;
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      const kind = classifyImageError(errorText);
+      const detail = readErrorMessage(errorText);
+      const retryAfter = Number(response.headers.get("retry-after"));
+      throw new ProviderError({
+        kind,
+        message: detail ? `Codex image request returned ${response.status} (${kind}): ${detail}` : `Codex image request returned ${response.status} (${kind}).`,
+        statusCode: response.status,
+        requestId,
+        ...Number.isFinite(retryAfter) && retryAfter > 0 ? { retryAfterSeconds: retryAfter } : {}
+      });
+    }
+    const payload = record(await response.json().catch(() => null));
+    const item = Array.isArray(payload["data"]) ? record(payload["data"][0]) : {};
+    if (typeof item["b64_json"] !== "string" || !item["b64_json"]) {
+      throw new ProviderError({ kind: "no_image", message: "Codex image request returned no image data.", requestId });
     }
-    return { provider: this.name, imageModel: args.imageModel, images };
+    let data = Buffer.from(item["b64_json"], "base64");
+    let width;
+    let height;
+    try {
+      const metadata = await sharp(data).metadata();
+      if (!metadata.width || !metadata.height || !["png", "jpeg", "webp"].includes(metadata.format ?? ""))
+        throw new Error();
+      await sharp(data).stats();
+      if (metadata.format !== format)
+        data = await sharp(data).toFormat(format).toBuffer();
+      width = metadata.width;
+      height = metadata.height;
+    } catch {
+      throw new ProviderError({ kind: "malformed", message: "Codex returned an invalid raster image.", requestId });
+    }
+    return {
+      data,
+      mimeType: `image/${format}`,
+      width,
+      height,
+      prompt,
+      responseId: typeof item["generation_id"] === "string" ? item["generation_id"] : void 0,
+      // The endpoint accepts any requested model and currently names none in its response.
+      servedModel: typeof payload["model"] === "string" ? payload["model"] : void 0,
+      usage: {
+        requestId,
+        imageGeneration: payload["usage"],
+        // What the backend actually rendered; it may override requested size and quality.
+        served: { size: payload["size"], quality: payload["quality"], background: payload["background"] },
+        planLimits: readPlanLimits(response.headers)
+      }
+    };
   }
-  async sendOnce(payload, format, prompt, size) {
-    const accessToken = await this.tokens.getValidAccessToken();
-    const accountId = extractAccountId(accessToken);
+  async post(endpoint, accessToken, body) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeoutSeconds * 1e3);
-    let response;
     try {
-      response = await this.fetchImpl(RESPONSES_ENDPOINT, {
+      return await this.fetchImpl(`${IMAGES_ENDPOINT}/${endpoint}`, {
         method: "POST",
         headers: {
           authorization: `Bearer ${accessToken}`,
-          "chatgpt-account-id": accountId,
-          "OpenAI-Beta": "responses=experimental",
+          "chatgpt-account-id": extractAccountId(accessToken),
           originator: "pi",
           "user-agent": USER_AGENT,
-          accept: "text/event-stream",
+          accept: "application/json",
           "content-type": "application/json"
         },
-        body: JSON.stringify(payload),
+        body,
         signal: controller.signal
       });
     } finally {
       clearTimeout(timer);
     }
-    const requestId = response.headers.get("x-request-id") ?? response.headers.get("openai-request-id") ?? response.headers.get("request-id") ?? void 0;
-    if (!response.ok || !response.body) {
-      const body = await response.text().catch(() => "");
-      const kind = classifyImageError(body);
-      const detail = readErrorMessage(body);
-      throw new ProviderError({
-        kind,
-        message: detail ? `Codex image request returned ${response.status} (${kind}): ${detail}` : `Codex image request returned ${response.status} (${kind}).`,
-        statusCode: response.status,
-        requestId
-      });
-    }
-    const lines = await readSseLines(response.body);
-    let parsed;
-    try {
-      parsed = parseImageStreamEvents(lines);
-    } catch (error2) {
-      throw toProviderError(error2, requestId);
-    }
-    return {
-      data: parsed.data,
-      mimeType: `image/${format}`,
-      width: size.width,
-      height: size.height,
-      prompt,
-      responseId: parsed.responseId,
-      callId: parsed.callId
-    };
   }
 };
-async function readSseLines(body) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const lines = [];
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (done)
-      break;
-    buffer += decoder.decode(value, { stream: true });
-    let index = buffer.indexOf("\n");
-    while (index >= 0) {
-      const line = buffer.slice(0, index);
-      buffer = buffer.slice(index + 1);
-      if (line.startsWith("data:"))
-        lines.push(line);
-      index = buffer.indexOf("\n");
-    }
-  }
-  if (buffer.startsWith("data:"))
-    lines.push(buffer);
-  return lines;
-}
-function readErrorMessage(body) {
-  if (!body.trim())
-    return null;
-  try {
-    const parsed = JSON.parse(body);
-    if (typeof parsed === "object" && parsed !== null) {
-      const record2 = parsed;
-      if (typeof record2["message"] === "string")
-        return record2["message"];
-      if (typeof record2["detail"] === "string")
-        return record2["detail"];
-      const error2 = record2["error"];
-      if (typeof error2 === "object" && error2 !== null && typeof error2["message"] === "string") {
-        return error2["message"];
-      }
-    }
-  } catch {
-    return body.slice(0, 500);
-  }
-  return null;
-}
-function toProviderError(error2, requestId) {
-  const message = error2 instanceof Error ? error2.message : String(error2);
-  const separator = message.indexOf(":");
-  const kind = separator > 0 ? message.slice(0, separator) : "api_error";
-  return new ProviderError({ kind, message, requestId });
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function readPlanLimits(headers) {
+  const number = (name) => {
+    const value = headers.get(`x-codex-${name}`);
+    const parsed = value === null ? Number.NaN : Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  };
+  const window = (name) => {
+    const usedPercent = number(`${name}-used-percent`);
+    const windowMinutes = number(`${name}-window-minutes`);
+    if (usedPercent === void 0 || !windowMinutes)
+      return void 0;
+    return { usedPercent, windowMinutes, resetAt: number(`${name}-reset-at`) };
+  };
+  const limits = {
+    planType: headers.get("x-codex-plan-type") ?? void 0,
+    activeLimit: headers.get("x-codex-active-limit") ?? void 0,
+    primary: window("primary"),
+    secondary: window("secondary")
+  };
+  return Object.values(limits).some((value) => value !== void 0) ? limits : void 0;
 }
 
 // ../../packages/providers-codex/dist/codex-entry.js
@@ -1049,7 +1037,7 @@ function createCodexEntry() {
 }
 
 // ../../packages/providers-google/dist/gemini-client.js
-import sharp from "sharp";
+import sharp2 from "sharp";
 
 // ../../packages/providers-google/dist/image-size.js
 var DEFAULT_IMAGE_MODEL2 = "gemini-nano-banana-2.1";
@@ -1168,8 +1156,6 @@ var GeminiImageProvider = class {
     const count = request.count ?? 1;
     if (!Number.isInteger(count) || count < 1 || count > 4)
       throw error("usage", "Image count must be from 1 to 4.");
-    if (request.format && !["png", "jpeg", "jpg", "webp"].includes(request.format.trim().toLowerCase()))
-      throw error("usage", "Output format must be png, jpeg, or webp.");
     const format = normalizeOutputFormat(request.format);
     const size = resolveGeminiSize(request.size, model);
     const payload = {
@@ -1204,7 +1190,7 @@ var GeminiImageProvider = class {
     const images = [];
     for (let i = 0; i < count; i++)
       images.push(await this.send(payload, key, format, request.prompt));
-    return { provider: this.name, imageModel: model, images };
+    return { provider: this.name, requestedModel: model, images };
   }
   async send(payload, key, format, prompt) {
     const controller = new AbortController();
@@ -1244,12 +1230,12 @@ var GeminiImageProvider = class {
       if (typeof image.data !== "string" || !image.data || !/^[A-Za-z0-9+/]+={0,2}$/.test(image.data) || image.data.length % 4 !== 0)
         throw error("malformed", "Gemini returned invalid inline image data.");
       const original = Buffer.from(image.data, "base64");
-      const metadata = await sharp(original).metadata().catch(() => {
+      const metadata = await sharp2(original).metadata().catch(() => {
         throw error("malformed", "Gemini returned undecodable image bytes.");
       });
       if (!metadata.width || !metadata.height || !["png", "jpeg", "webp"].includes(metadata.format ?? "") || image.mime_type !== `image/${metadata.format}`)
         throw error("malformed", "Gemini returned an invalid image or inconsistent MIME type.");
-      const data = metadata.format === format ? original : await sharp(original).toFormat(format).toBuffer();
+      const data = metadata.format === format ? original : await sharp2(original).toFormat(format).toBuffer();
       return {
         data,
         mimeType: `image/${format}`,
@@ -1315,9 +1301,10 @@ function createGeminiEntry() {
 }
 
 // ../../packages/providers-configurable/dist/profiles.js
-import { readFile, mkdir, writeFile, rename, rm } from "node:fs/promises";
-import { dirname, join as join2 } from "node:path";
+import { readFile, mkdir as mkdir2, writeFile, rename, rm as rm2 } from "node:fs/promises";
+import { dirname as dirname2, isAbsolute, join as join3 } from "node:path";
 import { randomUUID } from "node:crypto";
+var COMFY_FIELDS = ["startCommand", "workflow", "editWorkflow"];
 var usage = (message) => new ProviderError({ kind: "usage", message });
 var profileStore = () => resolveCredentialStore();
 function validateApiKey(value) {
@@ -1333,14 +1320,25 @@ function validateProfile(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw usage("Invalid endpoint profile.");
   const p = value;
-  if (Object.keys(p).some((k) => !["name", "api", "baseUrl", "model", "auth"].includes(k)))
-    throw usage("Endpoint profiles accept only name, api, baseUrl, model, and auth; store keys through auth login.");
+  if (Object.keys(p).some((k) => !["name", "api", "baseUrl", "model", "auth", ...COMFY_FIELDS].includes(k)))
+    throw usage("Endpoint profiles accept only name, api, baseUrl, model, auth, startCommand, workflow, and editWorkflow; store keys through auth login.");
   if (typeof p.name !== "string" || !/^[a-z][a-z0-9-]{0,63}$/.test(p.name) || ["codex", "gemini"].includes(p.name))
     throw usage("Endpoint name must use lowercase letters, digits, and hyphens, and cannot be codex or gemini.");
-  if (p.api !== "openrouter" && p.api !== "openai-images")
-    throw usage("API format must be openrouter or openai-images.");
+  if (p.api !== "openrouter" && p.api !== "openai-images" && p.api !== "comfyui")
+    throw usage("API format must be openrouter, openai-images, or comfyui.");
   if (p.auth !== void 0 && p.auth !== "bearer" && p.auth !== "none")
     throw usage("Auth must be bearer or none.");
+  if (p.api === "comfyui" && p.auth === "bearer")
+    throw usage("ComfyUI profiles do not use API keys. Use --auth none.");
+  if (p.api !== "comfyui" && COMFY_FIELDS.some((k) => p[k] !== void 0))
+    throw usage("--start-command, --workflow, and --edit-workflow apply only to comfyui profiles.");
+  for (const field of COMFY_FIELDS) {
+    const value2 = p[field];
+    if (value2 !== void 0 && (typeof value2 !== "string" || !value2.trim()))
+      throw usage(`${field} must not be blank.`);
+    if (field !== "startCommand" && value2 && !isAbsolute(value2))
+      throw usage(`${field} must be an absolute path.`);
+  }
   const raw = p.baseUrl ?? (p.api === "openrouter" ? "https://openrouter.ai/api/v1" : void 0);
   let url;
   try {
@@ -1355,18 +1353,24 @@ function validateProfile(value) {
     throw usage("Base URL must use HTTPS (or loopback HTTP), without credentials, query, or fragment.");
   if (p.model !== void 0 && (typeof p.model !== "string" || !p.model.trim()))
     throw usage("Default model must not be blank.");
+  if (p.api === "comfyui" && p.model === void 0)
+    throw usage("ComfyUI profiles need --model: flux3-klein, flux3-klein-raw, or your name for the model in --workflow.");
   return {
     name: p.name,
     api: p.api,
     baseUrl: url.toString().replace(/\/+$/, ""),
-    auth: p.auth ?? "bearer",
-    ...typeof p.model === "string" ? { model: p.model.trim() } : {}
+    auth: p.auth ?? (p.api === "comfyui" ? "none" : "bearer"),
+    ...typeof p.model === "string" ? { model: p.model.trim() } : {},
+    ...Object.fromEntries(COMFY_FIELDS.flatMap((field) => {
+      const value2 = p[field];
+      return typeof value2 === "string" ? [[field, value2.trim()]] : [];
+    }))
   };
 }
 var ProfileRepository = class {
   path;
   credentials;
-  constructor(path = join2(dirname(defaultCredentialFilePath()), "providers.json"), credentials = profileStore) {
+  constructor(path = join3(dirname2(defaultCredentialFilePath()), "providers.json"), credentials = profileStore) {
     this.path = path;
     this.credentials = credentials;
   }
@@ -1431,7 +1435,7 @@ var ProfileRepository = class {
   async save(profiles) {
     const temporary = `${this.path}.${randomUUID()}.tmp`;
     try {
-      await mkdir(dirname(this.path), { recursive: true });
+      await mkdir2(dirname2(this.path), { recursive: true });
       await writeFile(temporary, JSON.stringify({ version: 1, profiles }, null, 2) + "\n", { mode: 384 });
       await rename(temporary, this.path);
     } catch {
@@ -1440,7 +1444,7 @@ var ProfileRepository = class {
         message: "Could not save endpoint configuration."
       });
     } finally {
-      await rm(temporary, { force: true }).catch(() => {
+      await rm2(temporary, { force: true }).catch(() => {
       });
     }
   }
@@ -1449,9 +1453,9 @@ async function profileKey(profile, store) {
   if (profile.auth === "none")
     return void 0;
   try {
-    const record2 = await store.load(profile.name);
-    if (record2 && typeof record2.apiKey === "string")
-      return validateApiKey(record2.apiKey);
+    const record3 = await store.load(profile.name);
+    if (record3 && typeof record3.apiKey === "string")
+      return validateApiKey(record3.apiKey);
   } catch {
   }
   throw new ProviderError({
@@ -1461,7 +1465,7 @@ async function profileKey(profile, store) {
 }
 
 // ../../packages/providers-configurable/dist/provider.js
-import sharp2 from "sharp";
+import sharp4 from "sharp";
 
 // ../../packages/providers-configurable/dist/image-size.js
 function imageSize(value, api) {
@@ -1481,13 +1485,30 @@ function imageSize(value, api) {
   if (pixels && Number.isSafeInteger(Number(pixels[1])) && Number.isSafeInteger(Number(pixels[2])) && Number(pixels[1]) > 0 && Number(pixels[2]) > 0)
     return { size: `${Number(pixels[1])}x${Number(pixels[2])}` };
   const ratio = /^(\d+(?:\.\d+)?)\s*[:/]\s*(\d+(?:\.\d+)?)$/.exec(size);
-  if (api === "openrouter" && ratio && Number(ratio[1]) > 0 && Number(ratio[2]) > 0 && Number.isFinite(Number(ratio[1]) / Number(ratio[2])))
+  if (api !== "openai-images" && ratio && Number(ratio[1]) > 0 && Number(ratio[2]) > 0 && Number.isFinite(Number(ratio[1]) / Number(ratio[2])))
     return { aspect_ratio: `${Number(ratio[1])}:${Number(ratio[2])}` };
   throw usage(api === "openai-images" ? "This API format requires WIDTHxHEIGHT or a preset; arbitrary aspect-only sizes are unsupported." : "Use WIDTHxHEIGHT, an aspect ratio, preset, or auto.");
 }
+function comfySize(value) {
+  const fields = imageSize(value, "comfyui");
+  let width, height;
+  if (fields.aspect_ratio) {
+    const [w, h] = fields.aspect_ratio.split(":").map(Number);
+    const scale = Math.sqrt(1024 * 1024 / (w * h));
+    [width, height] = [w * scale, h * scale];
+  } else if (fields.size)
+    [width, height] = fields.size.split("x").map(Number);
+  else
+    return void 0;
+  width = Math.round(width / 16) * 16;
+  height = Math.round(height / 16) * 16;
+  if (Math.min(width, height) < 256 || Math.max(width, height) > 2048)
+    throw usage("ComfyUI image edges must be from 256 to 2048 pixels.");
+  return { width, height };
+}
 
 // ../../packages/providers-configurable/dist/http.js
-var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var record2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 var EndpointHttp = class {
   fetchImpl;
   timeoutSeconds;
@@ -1511,9 +1532,9 @@ var EndpointHttp = class {
       });
       if (!response.ok) {
         const status = response.status;
-        const failure2 = record(await response.json().catch(() => null));
-        const detail = record(failure2.error);
-        const upstream = record(detail.metadata).provider_name;
+        const failure2 = record2(await response.json().catch(() => null));
+        const detail = record2(failure2.error);
+        const upstream = record2(detail.metadata).provider_name;
         const token = new Headers(init.headers).get("authorization")?.replace(/^Bearer\s+/i, "");
         const upstreamProvider = typeof upstream === "string" && /^[A-Za-z0-9][A-Za-z0-9 ._()-]{0,63}$/.test(upstream) && !(token && upstream.includes(token)) && !/(?:sk-|AIza)/.test(upstream) ? upstream : void 0;
         const retryHeader = response.headers.get("retry-after");
@@ -1537,7 +1558,7 @@ var EndpointHttp = class {
             const value = await response.json();
             if (!value || typeof value !== "object" || Array.isArray(value))
               throw new Error();
-            return record(value);
+            return record2(value);
           } catch {
             throw new ProviderError({
               kind: "malformed",
@@ -1615,6 +1636,625 @@ function openAIRequest(model, request, images, mask) {
   return { path: "images/edits", body, json: false };
 }
 
+// ../../packages/providers-configurable/dist/comfyui.js
+import { randomInt, randomUUID as randomUUID2 } from "node:crypto";
+import sharp3 from "sharp";
+
+// ../../packages/providers-configurable/dist/comfyui-workflow.js
+import { readFile as readFile2 } from "node:fs/promises";
+var TOKEN = /\{\{(\w+)\}\}/g;
+function usedTokens(graph) {
+  const used = /* @__PURE__ */ new Set();
+  for (const node of Object.values(graph))
+    for (const value of Object.values(node.inputs))
+      if (typeof value === "string")
+        for (const match of value.matchAll(TOKEN))
+          used.add(match[1]);
+  return used;
+}
+async function loadWorkflow(path) {
+  const invalid = (detail) => new ProviderError({
+    kind: "configuration",
+    message: `ComfyUI workflow ${path} ${detail}`
+  });
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile2(path, "utf8"));
+  } catch {
+    throw invalid("could not be read as JSON.");
+  }
+  const nodes = Object.values(record2(parsed));
+  if (!nodes.length || nodes.some((node) => typeof record2(node).class_type !== "string" || typeof record2(node).inputs !== "object"))
+    throw invalid("is not in API format. Export it from ComfyUI as API JSON.");
+  const graph = parsed;
+  const used = usedTokens(graph);
+  const unknown = [...used].filter((t) => !/^(prompt|seed|width|height|image[1-9]\d*)$/.test(t));
+  if (unknown.length)
+    throw invalid(`uses unknown tokens: ${unknown.join(", ")}.`);
+  if (!used.has("prompt") || !used.has("seed"))
+    throw invalid("must use {{prompt}} and {{seed}}.");
+  if (used.has("width") !== used.has("height"))
+    throw invalid("must use {{width}} and {{height}} together.");
+  const images = [...used].filter((t) => t.startsWith("image")).length;
+  for (let i = 1; i <= images; i++)
+    if (!used.has(`image${i}`))
+      throw invalid(`must number its image tokens from {{image1}} in order.`);
+  return { graph, images, sized: used.has("width") };
+}
+function fillWorkflow({ graph }, { prompt, seed, size, images }) {
+  const values = {
+    prompt,
+    seed,
+    ...size ?? {},
+    ...Object.fromEntries(images.map((image, i) => [`image${i + 1}`, image]))
+  };
+  const fill = (value) => {
+    if (typeof value !== "string")
+      return value;
+    const whole = /^\{\{(\w+)\}\}$/.exec(value);
+    if (whole)
+      return values[whole[1]];
+    return value.replace(TOKEN, (_, token) => String(values[token]));
+  };
+  return Object.fromEntries(Object.entries(graph).map(([id, node]) => [
+    id,
+    {
+      ...node,
+      inputs: Object.fromEntries(Object.entries(node.inputs).map(([key, value]) => [key, fill(value)]))
+    }
+  ]));
+}
+
+// ../../packages/providers-configurable/dist/validation.js
+function validateImageRequest(request, images) {
+  if ((request.referenceImages?.length ?? 0) > 4)
+    throw usage("At most four reference images are allowed.");
+  const count = request.count ?? 1;
+  if (!Number.isInteger(count) || count < 1 || count > 4)
+    throw usage("Image count must be from 1 to 4.");
+  for (const image of images)
+    if (!["image/png", "image/jpeg", "image/webp"].includes(image.contentType))
+      throw usage("Input images must be PNG, JPEG, or WebP.");
+  const format = (request.format ?? "png").trim().toLowerCase().replace(/^jpg$/, "jpeg");
+  if (!["png", "jpeg", "webp"].includes(format))
+    throw usage("Output format must be png, jpeg, or webp.");
+  return { count, format };
+}
+
+// ../../packages/providers-configurable/dist/flux3-klein-prompts.js
+var FLUX3_KLEIN_GENERATE_PROMPT = `You are the prompt upsampler of a text-to-image model. Expand the user's short request into ONE detailed, self-contained caption: the exact text the image model receives. Output only the caption, with no greetings, explanations, refusals, questions, Markdown, headings, JSON, coordinates, ids or angle-bracket tokens, and no quotes around it. If the input is not clearly an image request, caption a visualization of its concept. The request may begin with a "TARGET CANVAS: W:H" line: compose for that canvas (wide spreads content sideways, tall stacks it) and never mention the ratio or the canvas.
+
+Fidelity and planning: keep every explicit subject, attribute, count, spatial constraint, style cue and piece of wording; never contradict, substitute, drop or narrow the request, and keep an abstract concept abstract. Decide everything left open as ONE concrete, consistent plan; never offer alternatives or hedge. Never re-express a stated constraint through another mechanism; add camera optics (depth of field, bokeh, blur) only when asked for or implied. Without a stated style, plan an actual photograph and open with the medium convention ("Full-color outdoor photograph, ...", "Full-color indoor photograph, ...", "Studio photograph, ...", "Close-up photograph, ..."); keep "Photorealistic" for renders, and turn "photorealistic" or "realistic" requests for photos into the photograph convention. Give a photograph a few ordinary, non-ideal specifics drawn from the scene's own objects instead of the stock-photo ideal. Do not invent names, brands, logos or celebrities; keep user-named ones. A long request keeps its content but not its wording: drop appraisal and sales vocabulary, turn moods into observable physical facts, and add only new concrete content with positions. Time of day is lighting, not rendered text.
+
+Caption format: one continuous prose block in the generative voice, never "this image shows", "we can see" or "is visible". Lead with medium and style, then scene, lighting and camera, then the subjects with concrete colors, materials and state. Every person in focus gets an observable profile: ethnicity, gender, age range, skin tone ("fair skin", "brown skin"), hair and clothing. Make the layout reconstructable from words: frame-relative positions (frame-left, frame-right, upper, lower, foreground, midground, background), sentence-initial anchors ("On the left, ...", "In the background, ..."), relations (holds, faces, behind) and a consistent order; describe up to about ten instances one by one, beyond that give the exact count and arrangement. Out-of-focus or distant planes are shapes, colors and silhouettes, never identities or readable text, and the background takes about a sixth of the caption. Be definite: no hedging adverbs, no quality or emotion judgments, no closing sentence about mood; state negations as what is present. Rendered text: transcribe every wording verbatim inside double quotes in its original language and script, keep the line breaks of multi-line text, and give its typography, color and placement; author concrete, domain-correct wording when the request needs text it does not supply, and name canonical structures (calendar, keyboard, periodic table) exactly with their full layout. All prose is English; only quoted text keeps its language. Typical length is 100 to 350 words, more for complex scenes.
+
+Output only the caption.`;
+var FLUX3_KLEIN_EDIT_PROMPT = `You are the prompt upsampler of an image-editing model. You see the reference image(s), attached in order (the first image, the second image, ...), and the user's short request. Expand it into ONE detailed, self-contained instruction: the caption the editing model receives together with the same images. Output only the instruction as one continuous English prose block, with no greetings, explanations, Markdown, JSON, coordinates, ids or angle-bracket tokens. Read a vague or conversational request as the most plausible edit of the supplied images.
+
+Pick the voice by task shape. When one reference stays and gets bounded changes, write an imperative editing instruction on it ("Remove the ...", "Change the ... to ...", "Zoom in on ..."); a whole-image transformation opens with its scope ("Convert the entire image into ...", "Apply a ... filter over the entire scene", "Horizontally flip the entire image so that ...", "Shift the camera viewpoint to ...", then where the major elements should now be). When the references are drawn into a newly composed frame (combining subjects, a new scene, a garment, object or style donor), write a generation request ("Create a photograph of ...", "Create an anime-style illustration of ...", "Generate a new image featuring ...") that says what to take from each image, by ordinal, and what is newly generated.
+
+Keep every explicit edit, constraint, count, position, style cue and piece of wording, and decide what is left open as one concrete plan. Ground everything in what is actually visible: identify each referent unambiguously by its real appearance, never mention content that is not there, and use every image the user attached. State every end state concretely (which color, how large, which pose, which material) and give new content enough appearance to be generated. Cover the knock-on effects of the change (shadows, reflections, occlusion, perspective, scale, lighting) and say what fills a removed region. A zoom-in names what stays in frame and which neighbors are cropped out; an outpainting continues the scene in the same medium. Describe the change, not the whole scene, and close an editing instruction with one compact clause naming what stays unchanged; transferred people keep their identity, face and accessories unless asked otherwise. Transcribe on-image text verbatim in its original language inside double quotes, with line breaks as \\n, and match the original font, size and color when replacing it. Name recognizable public figures, brands and landmarks you can see. Directions are frame-relative; use no evaluative or quality words. Typical length is 50 to 150 words.
+
+Output only the instruction.`;
+
+// ../../packages/providers-configurable/dist/flux3-klein.js
+var FLUX3_KLEIN_CHECKPOINT = "flux3-image-klein-int8-convrot";
+var FLUX3_KLEIN_MODELS = [
+  {
+    id: "flux3-klein",
+    name: "FLUX 3 Klein, prompt expanded by its upsampler",
+    upsample: true
+  },
+  {
+    id: "flux3-klein-raw",
+    name: "FLUX 3 Klein, prompt used verbatim as the full caption",
+    upsample: false
+  }
+];
+var UPSAMPLER = "qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors";
+var ENCODER = "qwen3vl_4b_int8_convrot.safetensors";
+var VAE = "flux2-vae.safetensors";
+var WEIGHTS = [
+  {
+    node: "UNETLoader",
+    input: "unet_name",
+    folder: "diffusion_models",
+    file: `${FLUX3_KLEIN_CHECKPOINT}.safetensors`
+  },
+  {
+    node: "CLIPLoader",
+    input: "clip_name",
+    folder: "text_encoders",
+    file: ENCODER
+  },
+  {
+    node: "VAELoader",
+    input: "vae_name",
+    folder: "vae",
+    file: VAE
+  }
+];
+var flux3KleinWeights = (model) => model.upsample ? [
+  ...WEIGHTS,
+  {
+    node: "CLIPLoader",
+    input: "clip_name",
+    folder: "text_encoders",
+    file: UPSAMPLER
+  }
+] : WEIGHTS;
+function flux3KleinModel(id) {
+  const model = FLUX3_KLEIN_MODELS.find((m) => m.id === id);
+  if (!model)
+    throw usage(`Built-in ComfyUI models are ${FLUX3_KLEIN_MODELS.map((m) => m.id).join(" and ")}. Add --workflow to the profile for any other model.`);
+  return model;
+}
+var STEPS = { low: 4, medium: 8, high: 16, auto: 16 };
+function flux3KleinSteps(quality) {
+  const steps = STEPS[(quality ?? "auto").trim().toLowerCase()];
+  if (!steps)
+    throw usage("Quality must be low, medium, high, or auto.");
+  return steps;
+}
+function upsamplerRequest(job) {
+  if (job.images.length || !job.size || job.size.width === job.size.height)
+    return job.prompt;
+  const divisor = (a, b) => b ? divisor(b, a % b) : a;
+  const shared = divisor(job.size.width, job.size.height);
+  return `TARGET CANVAS: ${job.size.width / shared}:${job.size.height / shared}
+${job.prompt}`;
+}
+function flux3KleinWorkflow(job) {
+  const editing = job.images.length > 0;
+  const nodes = {
+    model: {
+      class_type: "UNETLoader",
+      inputs: {
+        unet_name: `${FLUX3_KLEIN_CHECKPOINT}.safetensors`,
+        weight_dtype: "default"
+      }
+    },
+    encoder: {
+      class_type: "CLIPLoader",
+      inputs: { clip_name: ENCODER, type: "flux3", device: "default" }
+    },
+    vae: { class_type: "VAELoader", inputs: { vae_name: VAE } }
+  };
+  job.images.forEach((image, i) => {
+    nodes[`image${i}`] = { class_type: "LoadImage", inputs: { image } };
+  });
+  if (job.upsample) {
+    nodes.upsampler_clip = {
+      class_type: "CLIPLoader",
+      inputs: { clip_name: UPSAMPLER, type: "flux3", device: "default" }
+    };
+    nodes.upsampler = {
+      class_type: "TextGenerateV2",
+      inputs: {
+        clip: ["upsampler_clip", 0],
+        prompt: upsamplerRequest(job),
+        system_prompt: editing ? FLUX3_KLEIN_EDIT_PROMPT : FLUX3_KLEIN_GENERATE_PROMPT,
+        max_length: 3584,
+        sampling_mode: "on",
+        "sampling_mode.temperature": 1,
+        "sampling_mode.top_k": 1,
+        "sampling_mode.top_p": 0.95,
+        "sampling_mode.min_p": 0,
+        "sampling_mode.repetition_penalty": 1.05,
+        "sampling_mode.presence_penalty": editing ? 0 : 1.5,
+        "sampling_mode.seed": 0,
+        thinking: false,
+        use_default_template: true,
+        mtp: "off",
+        ...Object.fromEntries(job.images.map((_, i) => [`images.image${i + 1}`, [`image${i}`, 0]]))
+      }
+    };
+    nodes.caption = {
+      class_type: "PreviewAny",
+      inputs: { source: ["upsampler", 0] }
+    };
+  }
+  nodes.positive = {
+    class_type: "CLIPTextEncode",
+    inputs: {
+      clip: ["encoder", 0],
+      text: job.upsample ? ["upsampler", 0] : job.prompt
+    }
+  };
+  nodes.negative = editing ? {
+    class_type: "ConditioningZeroOut",
+    inputs: { conditioning: ["positive", 0] }
+  } : {
+    class_type: "CLIPTextEncode",
+    inputs: { clip: ["encoder", 0], text: "" }
+  };
+  if (editing)
+    nodes.references = {
+      class_type: "ReferenceMultiLatent",
+      inputs: {
+        positive: ["positive", 0],
+        negative: ["negative", 0],
+        vae: ["vae", 0],
+        resolution: "resize",
+        "resolution.megapixels": 1,
+        ...Object.fromEntries(job.images.map((_, i) => [`images.image${i}`, [`image${i}`, 0]]))
+      }
+    };
+  if (!editing || job.size) {
+    const { width, height } = job.size ?? { width: 1024, height: 1024 };
+    nodes.latent = {
+      class_type: "EmptyFlux2LatentImage",
+      inputs: { width, height, batch_size: 1 }
+    };
+  }
+  nodes.sampler = {
+    class_type: "KSampler",
+    inputs: {
+      model: ["model", 0],
+      seed: job.seed,
+      steps: job.steps,
+      cfg: 1,
+      sampler_name: "euler",
+      scheduler: "simple",
+      denoise: 1,
+      positive: editing ? ["references", 0] : ["positive", 0],
+      negative: editing ? ["references", 1] : ["negative", 0],
+      // Without a requested size, edits keep the first reference's shape.
+      latent_image: nodes.latent ? ["latent", 0] : ["references", 2]
+    }
+  };
+  nodes.decode = {
+    class_type: "VAEDecode",
+    inputs: { samples: ["sampler", 0], vae: ["vae", 0] }
+  };
+  nodes.output = {
+    class_type: "PreviewImage",
+    inputs: { images: ["decode", 0] }
+  };
+  return nodes;
+}
+
+// ../../packages/providers-configurable/dist/comfyui.js
+var EXTENSIONS = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp"
+};
+function comboOptions(spec) {
+  if (!Array.isArray(spec))
+    return void 0;
+  const choices = spec[0] === "COMBO" ? record2(spec[1]).options : spec[0];
+  return Array.isArray(choices) ? choices : void 0;
+}
+var comboChoices = (spec) => comboOptions(spec) ?? [];
+async function sourceShape(image) {
+  try {
+    const { width, height } = await sharp3(image.data).metadata();
+    return comfySize(`${width}:${height}`);
+  } catch (e) {
+    if (e instanceof ProviderError)
+      throw e;
+    throw usage("Could not read the source image's dimensions.");
+  }
+}
+function executionFailure(messages) {
+  const failure2 = Array.isArray(messages) ? messages.find((m) => Array.isArray(m) && m[0] === "execution_error") : void 0;
+  const detail = record2(Array.isArray(failure2) ? failure2[1] : void 0);
+  const node = typeof detail.node_type === "string" ? detail.node_type : "the workflow";
+  const reason = typeof detail.exception_message === "string" ? detail.exception_message.replace(/\s+/g, " ").trim().slice(0, 300) : "";
+  const memory = /out ?of ?memory/i.test(`${detail.exception_type} ${reason}`);
+  return new ProviderError({
+    kind: "server",
+    message: `ComfyUI failed in ${node}${reason ? `: ${reason}` : "."}${memory ? " Close other GPU applications or request a smaller --size." : ""}`
+  });
+}
+async function encoded(data, format) {
+  try {
+    const result = await sharp3(data).toFormat(format).toBuffer({ resolveWithObject: true });
+    return {
+      data: result.data,
+      width: result.info.width,
+      height: result.info.height
+    };
+  } catch {
+    throw new ProviderError({
+      kind: "malformed",
+      message: "ComfyUI returned an invalid raster image."
+    });
+  }
+}
+var ComfyUIImageProvider = class {
+  name;
+  profile;
+  baseUrl;
+  defaultModel;
+  http;
+  pollIntervalMs;
+  constructor(profile, options = {}) {
+    const valid = validateProfile(profile);
+    this.profile = valid;
+    this.name = valid.name;
+    this.baseUrl = valid.baseUrl;
+    this.defaultModel = valid.model;
+    this.http = new EndpointHttp(options.fetchImpl, options.timeoutSeconds ?? 600);
+    this.pollIntervalMs = options.pollIntervalMs ?? 500;
+  }
+  sizePolicy = {
+    resolveSize: (size) => {
+      const resolved = comfySize(size);
+      if (!resolved)
+        return { size: "auto" };
+      const { width, height } = resolved;
+      return {
+        width,
+        height,
+        pixels: width * height,
+        size: `${width}x${height}`
+      };
+    }
+  };
+  generate(request) {
+    return this.run(request, request.referenceImages ?? []);
+  }
+  async edit(request) {
+    if (request.mask)
+      throw usage("ComfyUI profiles have no mask input. Describe the edit region in the prompt.");
+    return this.run(request, [
+      request.sourceImage,
+      ...request.referenceImages ?? []
+    ]);
+  }
+  get usesWorkflowFiles() {
+    return Boolean(this.profile.workflow || this.profile.editWorkflow);
+  }
+  async models() {
+    if (this.usesWorkflowFiles) {
+      const { workflow, editWorkflow } = this.profile;
+      const files = await Promise.all([workflow, editWorkflow].flatMap((f) => f ? [loadWorkflow(f)] : []));
+      return this.reachable(() => this.http.run(async (http) => {
+        for (const file of files)
+          await this.requireInputs(http, file.graph);
+        return [
+          {
+            id: this.defaultModel,
+            name: `${this.defaultModel}, from this profile's workflow files`,
+            capabilities: "reported",
+            inputModalities: editWorkflow ? ["text", "image"] : ["text"],
+            outputModalities: ["image"]
+          }
+        ];
+      }));
+    }
+    flux3KleinModel(this.defaultModel);
+    return this.reachable(() => this.http.run(async (http) => {
+      const models = [];
+      for (const { id, name, upsample } of FLUX3_KLEIN_MODELS)
+        if (!(await this.missingWeights(http, { id, name, upsample })).length)
+          models.push({
+            id,
+            name,
+            capabilities: "reported",
+            inputModalities: ["text", "image"],
+            outputModalities: ["image"]
+          });
+      return models;
+    }));
+  }
+  async run(request, images) {
+    const { count, format } = validateImageRequest(request, images);
+    const plan = this.usesWorkflowFiles ? await this.workflowPlan(request, images) : this.kleinPlan(request);
+    return this.reachable(async () => {
+      await this.http.run((http) => plan.preflight(http));
+      const uploaded = [];
+      for (const image of images)
+        uploaded.push(await this.upload(image));
+      const results = [];
+      for (let i = 0; i < count; i++)
+        results.push(await this.render(plan, uploaded, randomInt(281474976710655), format));
+      return {
+        provider: this.name,
+        requestedModel: plan.model,
+        images: results
+      };
+    });
+  }
+  kleinPlan(request) {
+    const model = flux3KleinModel((request.model ?? this.defaultModel).trim());
+    const steps = flux3KleinSteps(request.quality);
+    const size = comfySize(request.size);
+    return {
+      model: model.id,
+      preflight: async (http) => {
+        const missing = await this.missingWeights(http, model);
+        if (missing.length)
+          throw new ProviderError({
+            kind: "configuration",
+            message: `ComfyUI is missing FLUX 3 Klein weights: ${missing.join(", ")}. Download them from black-forest-labs/flux-3-image-klein-comfy into its models folder.`
+          });
+      },
+      graph: (images, seed) => flux3KleinWorkflow({
+        prompt: request.prompt,
+        upsample: model.upsample,
+        images,
+        size,
+        steps,
+        seed
+      }),
+      described: (outputs, seed) => {
+        const caption = record2(outputs.caption).text;
+        return {
+          prompt: model.upsample && Array.isArray(caption) && typeof caption[0] === "string" ? caption[0] : request.prompt,
+          servedModel: FLUX3_KLEIN_CHECKPOINT,
+          usage: { served: { steps, seed, upsampled: model.upsample } }
+        };
+      }
+    };
+  }
+  async workflowPlan(request, images) {
+    const model = this.defaultModel;
+    if (request.model && request.model.trim() !== model)
+      throw usage(`Profile ${this.name} renders ${model} from its workflow files. Update the profile to change models.`);
+    if ((request.quality ?? "auto").trim().toLowerCase() !== "auto")
+      throw usage("Workflow files set their own sampling, so only --quality auto applies.");
+    const path = images.length ? this.profile.editWorkflow : this.profile.workflow;
+    if (!path)
+      throw usage(images.length ? `Profile ${this.name} has no --edit-workflow, so it cannot take input images.` : `Profile ${this.name} has no --workflow, so it needs a source image.`);
+    const workflow = await loadWorkflow(path);
+    if (workflow.images !== images.length)
+      throw usage(`This workflow takes ${workflow.images} input images, but the request has ${images.length}.`);
+    const requested = comfySize(request.size);
+    if (requested && !workflow.sized)
+      throw usage("This workflow has fixed dimensions, so only --size auto applies.");
+    const size = !workflow.sized ? void 0 : requested ?? (images[0] ? await sourceShape(images[0]) : { width: 1024, height: 1024 });
+    return {
+      model,
+      preflight: (http) => this.requireInputs(http, workflow.graph),
+      graph: (uploaded, seed) => fillWorkflow(workflow, {
+        prompt: request.prompt,
+        seed,
+        size,
+        images: uploaded
+      }),
+      described: (_, seed) => ({
+        prompt: request.prompt,
+        servedModel: model,
+        usage: { served: { seed } }
+      })
+    };
+  }
+  async reachable(action) {
+    try {
+      return await action();
+    } catch (e) {
+      if (e instanceof ProviderError && e.kind === "transport") {
+        const start = this.profile.startCommand;
+        throw new ProviderError({
+          kind: "transport",
+          message: `ComfyUI is not reachable at ${this.baseUrl}. Start it${start ? ` with \`${start}\`` : ""} and retry.`
+        });
+      }
+      throw e;
+    }
+  }
+  // Names what a workflow file needs instead of queueing a doomed job.
+  async requireInputs(http, graph) {
+    const specs = /* @__PURE__ */ new Map();
+    const missing = /* @__PURE__ */ new Set();
+    for (const node of Object.values(graph)) {
+      if (!specs.has(node.class_type)) {
+        const info = await http.json(`${this.baseUrl}/object_info/${encodeURIComponent(node.class_type)}`);
+        specs.set(node.class_type, record2(info[node.class_type]));
+      }
+      const spec = record2(specs.get(node.class_type));
+      if (!Object.keys(spec).length) {
+        missing.add(`node type ${node.class_type}`);
+        continue;
+      }
+      const inputs = {
+        ...record2(record2(spec.input).required),
+        ...record2(record2(spec.input).optional)
+      };
+      for (const [name, value] of Object.entries(node.inputs)) {
+        if (typeof value !== "string" || value.includes("{{"))
+          continue;
+        if (comboOptions(inputs[name])?.includes(value) === false)
+          missing.add(`${value} for ${node.class_type}.${name}`);
+      }
+    }
+    if (missing.size)
+      throw new ProviderError({
+        kind: "configuration",
+        message: `ComfyUI is missing what this workflow needs: ${[...missing].join(", ")}. Install it under ComfyUI, restart the server, and retry.`
+      });
+  }
+  async missingWeights(http, model) {
+    const choices = /* @__PURE__ */ new Map();
+    const missing = [];
+    for (const weight of flux3KleinWeights(model)) {
+      if (!choices.has(weight.node)) {
+        const info = await http.json(`${this.baseUrl}/object_info/${weight.node}`);
+        const inputs = record2(record2(record2(info[weight.node]).input).required);
+        choices.set(weight.node, comboChoices(inputs[weight.input]));
+      }
+      if (!choices.get(weight.node)?.includes(weight.file))
+        missing.push(`${weight.folder}/${weight.file}`);
+    }
+    return missing;
+  }
+  // The temp folder keeps inputs out of ComfyUI's library; it clears on restart.
+  upload(image) {
+    return this.http.run(async (http) => {
+      const form = new FormData();
+      form.set("image", new Blob([new Uint8Array(image.data)], { type: image.contentType }), `imagegen-${randomUUID2()}.${EXTENSIONS[image.contentType]}`);
+      form.set("type", "temp");
+      const body = await http.json(`${this.baseUrl}/upload/image`, {
+        method: "POST",
+        body: form
+      });
+      if (typeof body.name !== "string")
+        throw new ProviderError({
+          kind: "malformed",
+          message: "ComfyUI did not return an uploaded image name."
+        });
+      return `${body.name} [temp]`;
+    });
+  }
+  render(plan, images, seed, format) {
+    return this.http.run(async (http) => {
+      const queued = await http.json(`${this.baseUrl}/prompt`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ prompt: plan.graph(images, seed) })
+      }).catch((e) => {
+        if (e instanceof ProviderError && e.statusCode === 400)
+          throw new ProviderError({
+            kind: "server",
+            statusCode: 400,
+            message: `ComfyUI rejected the ${plan.model} workflow. Check its console for the failing node, and update ComfyUI if a node is unknown.`
+          });
+        throw e;
+      });
+      if (typeof queued.prompt_id !== "string")
+        throw new ProviderError({
+          kind: "malformed",
+          message: "ComfyUI did not return a prompt ID."
+        });
+      const outputs = record2((await this.finished(http, queued.prompt_id)).outputs);
+      const saved = Object.values(outputs).map((output) => record2(output).images).find((list) => Array.isArray(list) && list.length);
+      const file = record2(Array.isArray(saved) ? saved[0] : void 0);
+      if (typeof file.filename !== "string")
+        throw new ProviderError({
+          kind: "no_image",
+          message: "ComfyUI finished without an output image."
+        });
+      const query = new URLSearchParams({
+        filename: file.filename,
+        subfolder: typeof file.subfolder === "string" ? file.subfolder : "",
+        type: typeof file.type === "string" ? file.type : "temp"
+      });
+      const data = await http.bytes(`${this.baseUrl}/view?${query}`);
+      return {
+        ...await encoded(data, format),
+        mimeType: `image/${format}`,
+        responseId: queued.prompt_id,
+        ...plan.described(outputs, seed)
+      };
+    });
+  }
+  async finished(http, id) {
+    for (; ; ) {
+      const history = await http.json(`${this.baseUrl}/history/${id}`);
+      const entry = record2(history[id]);
+      const status = record2(entry.status);
+      if (status.status_str === "error")
+        throw executionFailure(status.messages);
+      if (status.completed === true)
+        return entry;
+      await new Promise((resolve4) => setTimeout(resolve4, this.pollIntervalMs));
+    }
+  }
+};
+
 // ../../packages/providers-configurable/dist/provider.js
 var ConfigurableImageProvider = class {
   getKey;
@@ -1672,14 +2312,14 @@ var ConfigurableImageProvider = class {
           message: "Model discovery response must contain a data array."
         });
       return body.data.map((value) => {
-        const model = record(value);
+        const model = record2(value);
         if (typeof model.id !== "string")
           throw new ProviderError({
             kind: "malformed",
             message: "Discovered model has no string ID."
           });
-        const architecture = record(model.architecture);
-        const supported = record(model.supported_parameters);
+        const architecture = record2(model.architecture);
+        const supported = record2(model.supported_parameters);
         const strings = (v) => Array.isArray(v) && v.every((s) => typeof s === "string") ? v : void 0;
         return {
           id: model.id,
@@ -1698,19 +2338,12 @@ var ConfigurableImageProvider = class {
     const model = (request.model ?? this.profile.model ?? "").trim();
     if (!model)
       throw usage("Supply --model or configure a default model with providers update.");
-    if ((request.referenceImages?.length ?? 0) > 4)
-      throw usage("At most four reference images are allowed.");
-    const count = request.count ?? 1;
-    if (!Number.isInteger(count) || count < 1 || count > 4)
-      throw usage("Image count must be from 1 to 4.");
     if (mask && this.profile.api === "openrouter")
       throw usage("OpenRouter image API does not expose masks. Describe the edit region in the prompt.");
-    for (const image of [...images, ...mask ? [mask] : []])
-      if (!["image/png", "image/jpeg", "image/webp"].includes(image.contentType))
-        throw usage("Input images must be PNG, JPEG, or WebP.");
-    const format = (request.format ?? "png").trim().toLowerCase().replace(/^jpg$/, "jpeg");
-    if (!["png", "jpeg", "webp"].includes(format))
-      throw usage("Output format must be png, jpeg, or webp.");
+    const { count, format } = validateImageRequest(request, [
+      ...images,
+      ...mask ? [mask] : []
+    ]);
     const quality = request.quality?.trim().toLowerCase();
     if (quality && !/^[a-z][a-z0-9_-]*$/.test(quality))
       throw usage("Quality must be a provider-supported quality name.");
@@ -1737,7 +2370,7 @@ var ConfigurableImageProvider = class {
             kind: "malformed",
             message: "Endpoint must return exactly one image for a single-image request."
           });
-        const image = record(body.data[0]);
+        const image = record2(body.data[0]);
         let data;
         if (typeof image.b64_json === "string") {
           if (!image.b64_json || image.b64_json.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(image.b64_json))
@@ -1768,12 +2401,12 @@ var ConfigurableImageProvider = class {
             message: "Endpoint returned no image bytes or download URL."
           });
         try {
-          const metadata = await sharp2(data).metadata();
+          const metadata = await sharp4(data).metadata();
           if (!metadata.width || !metadata.height || !["png", "jpeg", "webp"].includes(metadata.format ?? "") || typeof image.media_type === "string" && image.media_type !== `image/${metadata.format}`)
             throw new Error();
-          await sharp2(data).stats();
+          await sharp4(data).stats();
           if (metadata.format !== format)
-            data = await sharp2(data).toFormat(format).toBuffer();
+            data = await sharp4(data).toFormat(format).toBuffer();
           return {
             data,
             width: metadata.width,
@@ -1789,12 +2422,15 @@ var ConfigurableImageProvider = class {
           });
         }
       }));
-    return { provider: this.name, imageModel: model, images: results };
+    return { provider: this.name, requestedModel: model, images: results };
   }
 };
+function createProfileProvider(profile) {
+  return profile.api === "comfyui" ? new ComfyUIImageProvider(profile) : new ConfigurableImageProvider(profile, async () => profileKey(profile, await profileStore()));
+}
 function createProfileEntry(profile) {
   return {
-    provider: new ConfigurableImageProvider(profile, async () => profileKey(profile, await profileStore())),
+    provider: createProfileProvider(profile),
     authStatus: async () => {
       let configured = profile.auth === "none";
       if (!configured)
@@ -1833,7 +2469,7 @@ async function readApiKey(fromStdin, input = process.stdin, output = process.std
   const wasRaw = terminal.isRaw;
   const wasFlowing = input.readableFlowing === true;
   emitKeypressEvents(input);
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let text = "";
     const cleanup = () => {
       input.removeListener("keypress", onKey);
@@ -1858,7 +2494,7 @@ async function readApiKey(fromStdin, input = process.stdin, output = process.std
       }
       if (key.name === "return" || key.name === "enter") {
         cleanup();
-        resolve3(text);
+        resolve4(text);
         return;
       }
       if (key.name === "backspace") {
@@ -1882,11 +2518,15 @@ async function readApiKey(fromStdin, input = process.stdin, output = process.std
 
 // src/help.ts
 var PROFILE_HELP = `Named endpoint profiles:
-  imagegen providers add <name> --api <openrouter|openai-images> [--base-url <url>]
-                         [--model <id>] [--auth <bearer|none>]
+  imagegen providers add <name> --api <openrouter|openai-images|comfyui>
+                         [--base-url <url>] [--model <id>] [--auth <bearer|none>]
+                         [--start-command <text>] [--workflow <file>]
+                         [--edit-workflow <file>]
   imagegen providers show <name>
   imagegen providers update <name> [--api <format>] [--base-url <url>]
                          [--model <id>] [--auth <bearer|none>]
+                         [--start-command <text>] [--workflow <file>]
+                         [--edit-workflow <file>]
   imagegen providers remove <name>
   imagegen auth <name> login [--key-stdin]
   imagegen auth <name> status [--show-path]
@@ -1894,8 +2534,9 @@ var PROFILE_HELP = `Named endpoint profiles:
   imagegen models --provider <name>
 
 OpenRouter defaults to https://openrouter.ai/api/v1. openai-images requires
---base-url including the API prefix (e.g. https://api.openai.com/v1).
-Keys use hidden terminal input or explicit --key-stdin and the existing vault/file
+--base-url including the API prefix (e.g. https://api.openai.com/v1). comfyui
+requires --base-url of its server (e.g. http://127.0.0.1:8188) and --model, and
+uses no key. Keys use hidden terminal input or explicit --key-stdin and the existing vault/file
 store. --auth none supports endpoints without keys. Config is saved in providers.json
 alongside the credential file. Origin changes clear the saved key; removing a
 profile removes its credentials. Logout preserves profile configuration.
@@ -1904,13 +2545,25 @@ Select named profiles with --provider. Model precedence: --model > profile defau
 provide one if no default is saved. models explicitly discovers model metadata;
 OpenAI-compatible model listings do not establish image capabilities.
 
-Supported protocols: OpenRouter dedicated Images API and OpenAI Images JSON /
-multipart endpoints, not arbitrary HTTP templates. Options vary by model.
+Supported protocols: OpenRouter dedicated Images API, OpenAI Images JSON /
+multipart endpoints, and local models through ComfyUI, not arbitrary HTTP
+templates. Options vary by model.
 OpenRouter accepts aspect ratios; openai-images needs pixels or presets:
 square 1024x1024, portrait 1024x1536, landscape 1536x1024, wide 1536x864.
-Auto options are omitted. Native masks require openai-images or Codex.
+Auto options are omitted. Native masks require openai-images.
 Outputs are measured and converted to PNG/JPEG/WebP without resizing. Count uses
 separate single-image requests without automatic retries or model substitution.
+
+comfyui profiles: --model names what the profile renders. Built in: flux3-klein
+expands the prompt and reports the rendered caption as prompt; flux3-klein-raw
+uses the prompt as the full caption; quality low, medium, and high run 4, 8, and
+16 steps. Any other model needs --workflow (text-to-image) and/or --edit-workflow
+(input images): ComfyUI API-format JSON using {{prompt}} and {{seed}}, optionally
+{{width}} and {{height}}, and {{image1}}, {{image2}}, ... for inputs. Workflow
+files set their own sampling, so only --quality auto applies.
+Sizes accept pixels, presets, or aspect ratios, round to multiples of 16, and need
+edges from 256 to 2048. Masks are rejected. The CLI does not start or stop ComfyUI;
+--start-command records how to start it and is quoted when it is not reachable.
 `;
 var IMAGE_OPTIONS = `Image options (generate, edit):
   --prompt <text>        Prompt text (required)
@@ -1938,32 +2591,41 @@ Gemini provider:
   Model precedence: --model > constructor imageModel > IMAGEGEN_GEMINI_IMAGE_MODEL
   > gemini-nano-banana-2.1. Calls are independent; use prior output as --source.
 
-Supported Codex models (account availability is determined by the provider):
-  gpt-image-2.5-flare     Default; fast image generation and editing
-  gpt-image-2.5-sunburst  Higher-precision image generation and editing
-  gpt-image-2            Previous model; retained for compatibility
+Codex model requests (the backend chooses what actually runs):
+  gpt-image-2.6-flare     Requested by default
+  gpt-image-2.6-sunburst  Requested with --model
+  gpt-image-2.5-flare     Requested with --model
+  gpt-image-2.5-sunburst  Requested with --model
+  gpt-image-2            Requested with --model
 
-Use full model IDs; other provider-supported IDs may also be supplied.
+Codex accepts any model ID, including made-up ones, and does not report what ran;
+its Responses route rewrites these requests to gpt-image-2-codex. Use a named
+profile such as OpenRouter when a specific model matters.
 Model precedence: --model > constructor imageModel (library callers) >
-IMAGEGEN_CODEX_IMAGE_MODEL > gpt-image-2.5-flare.
-IMAGEGEN_CODEX_MODEL configures orchestration separately; --model selects images.
-
-Codex quality: auto (default), low, medium, high; Flare/Sunburst also support
-xhigh and max. gpt-image-2 rejects xhigh/max.
+IMAGEGEN_CODEX_IMAGE_MODEL > gpt-image-2.6-flare.
+JSON results report requestedModel, and servedModel per image (null unless the
+provider names one). Codex also reports served quality, size, and background, and
+may override what was requested. A Codex --mask is sent as the last edit image with a fixed
+instruction appended to the prompt; it steers the edit but does not guarantee
+untouched pixels outside it. It must match the source size, and uses one of the
+four edit-image slots.
+IMAGEGEN_USAGE_LOG=<file> appends one prompt-free JSON usage line per result.
+
+Codex quality requests: auto (default), low, medium, high; Flare/Sunburst IDs also
+accept xhigh and max. gpt-image-2 rejects xhigh/max. The backend may serve another.
 `;
 var GENERATE_EXAMPLES = `Examples:
   imagegen generate --provider gemini --size 16:9 --prompt "a lighthouse at dawn" --out ./gemini.png
   imagegen generate --prompt "a lighthouse at dawn" --out ./lighthouse.png
-  imagegen generate --model gpt-image-2 --prompt "a lighthouse" --out ./classic.png
-  imagegen generate --model gpt-image-2.5-sunburst --quality max --prompt "a product photo" --out ./product.png
+  imagegen generate --provider openrouter --model openai/gpt-image-2.6-sunburst --quality high --prompt "a product photo" --out ./product.png
 `;
 var EDIT_EXAMPLES = `Edit options:
   --source <file>        Source image (required)
-  --mask <file>          Optional edit mask (Codex or openai-images)
+  --mask <file>          Optional edit mask; transparent pixels mark the area to edit
 
 Examples:
   imagegen edit --format webp --source ./product.png --prompt "make the product blue" --out ./blue.webp
-  imagegen edit --model gpt-image-2.5-sunburst --quality max --source ./product.png --prompt "add a ribbon" --out ./ribbon.png
+  imagegen edit --provider openrouter --model openai/gpt-image-2.6-sunburst --source ./product.png --prompt "add a ribbon" --out ./ribbon.png
 `;
 var USAGE = `imagegen - provider-agnostic image generation CLI
 
@@ -1981,6 +2643,7 @@ Usage:
   imagegen skill
   imagegen skill install --target <claude|codex|skills-dir> [--target <...>] [--force]
   imagegen help [command]
+  imagegen --version
 
 ${PROFILE_HELP}
 ${IMAGE_OPTIONS}
@@ -1996,6 +2659,7 @@ Auth options:
 
 Global:
   -h, --help             Show help and exit 0
+  --version              Print the CLI version and exit 0
 `;
 var COMMAND_HELP = {
   auth: `imagegen auth - manage provider credentials (one namespace per provider)
@@ -2102,9 +2766,9 @@ ${USAGE}`;
 }
 
 // src/skill.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join3, resolve } from "node:path";
+import { dirname as dirname3, join as join4, resolve } from "node:path";
 var SKILL_NAME = "imagegen-cli";
 var SkillExistsError = class extends Error {
   constructor(path) {
@@ -2113,15 +2777,15 @@ var SkillExistsError = class extends Error {
   }
 };
 async function skillText() {
-  return readFile2(new URL("../skill/SKILL.md", import.meta.url), "utf8");
+  return readFile3(new URL("../skill/SKILL.md", import.meta.url), "utf8");
 }
 function targetPath(target) {
-  const root = target === "claude" ? join3(homedir2(), ".claude", "skills") : target === "codex" ? join3(homedir2(), ".agents", "skills") : resolve(target);
-  return join3(root, SKILL_NAME, "SKILL.md");
+  const root = target === "claude" ? join4(homedir2(), ".claude", "skills") : target === "codex" ? join4(homedir2(), ".agents", "skills") : resolve(target);
+  return join4(root, SKILL_NAME, "SKILL.md");
 }
 async function existingText(path) {
   try {
-    return await readFile2(path, "utf8");
+    return await readFile3(path, "utf8");
   } catch (error2) {
     if (error2.code === "ENOENT") return void 0;
     throw error2;
@@ -2143,12 +2807,51 @@ async function installSkill(targets, force) {
   }
   for (const item of planned.values()) {
     if (item.status === "up-to-date") continue;
-    await mkdir2(dirname2(item.path), { recursive: true });
+    await mkdir3(dirname3(item.path), { recursive: true });
     await writeFile2(item.path, content, { encoding: "utf8", flag: item.status === "installed" ? "wx" : "w" });
   }
   return [...planned.values()];
 }
 
+// src/usage-log.ts
+import { appendFile, mkdir as mkdir4 } from "node:fs/promises";
+import { dirname as dirname4, resolve as resolve2 } from "node:path";
+var USAGE_LOG_ENV = "IMAGEGEN_USAGE_LOG";
+function usageLogEntry(request, edit, result, paths) {
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    command: edit ? "edit" : "generate",
+    provider: result.provider,
+    requestedModel: result.requestedModel,
+    requested: {
+      size: request.size ?? "auto",
+      quality: request.quality ?? "auto",
+      format: request.format ?? "png",
+      count: request.count ?? 1,
+      references: request.referenceImages?.length ?? 0,
+      mask: edit ? edit.mask !== void 0 : void 0
+    },
+    images: result.images.map((image, i) => ({
+      path: paths[i],
+      width: image.width,
+      height: image.height,
+      bytes: image.data.byteLength,
+      responseId: image.responseId,
+      servedModel: image.servedModel ?? null,
+      usage: image.usage
+    }))
+  };
+}
+async function appendUsageLog(entry) {
+  const target = process.env[USAGE_LOG_ENV]?.trim();
+  if (!target) return void 0;
+  const path = resolve2(target);
+  await mkdir4(dirname4(path), { recursive: true });
+  await appendFile(path, `${JSON.stringify(entry)}
+`, "utf8");
+  return path;
+}
+
 // src/index.ts
 var EXIT_USAGE = 2;
 var EXIT_AUTH = 3;
@@ -2171,9 +2874,13 @@ function parseArgs(argv) {
       flags.set("help", true);
       continue;
     }
+    if (arg === "--version") {
+      flags.set("version", true);
+      continue;
+    }
     if (arg.startsWith("--")) {
       const key = arg.slice(2);
-      if (!["prompt", "out", "provider", "model", "reference", "size", "quality", "format", "count", "source", "mask", "timeout", "api", "base-url", "auth", "key-stdin", "no-open", "show-path", "target", "force"].includes(key)) {
+      if (!["prompt", "out", "provider", "model", "reference", "size", "quality", "format", "count", "source", "mask", "timeout", "api", "base-url", "auth", "start-command", "workflow", "edit-workflow", "key-stdin", "no-open", "show-path", "target", "force"].includes(key)) {
         fail("usage", `Unknown option --${key}. Run imagegen help.`, EXIT_USAGE);
       }
       if (key === "key-stdin" || key === "no-open" || key === "show-path" || key === "force") {
@@ -2207,6 +2914,10 @@ function imageModel(flags) {
   if (model !== void 0 && !model) fail("usage", "--model must not be blank.", EXIT_USAGE);
   return model;
 }
+async function cliVersion() {
+  const manifest = JSON.parse(await readFile4(new URL("../package.json", import.meta.url), "utf8"));
+  return manifest.version;
+}
 function redirectUri() {
   return process.env["IMAGEGEN_CODEX_REDIRECT_URI"] ?? DEFAULT_REDIRECT_URI;
 }
@@ -2224,7 +2935,7 @@ function redirectPort(uri) {
 async function loadImageInput(path, label) {
   let data;
   try {
-    data = await readFile3(path);
+    data = await readFile4(path);
   } catch {
     fail("io", `${label} not found: ${path}`, EXIT_IO);
   }
@@ -2277,10 +2988,10 @@ function requestedProviders(flags) {
   return raw;
 }
 async function resolveOutPaths(out, providerName, multiProvider, count, format) {
-  const resolved = resolve2(out);
+  const resolved = resolve3(out);
   let isDir = false;
   try {
-    const info = await stat(resolved);
+    const info = await stat2(resolved);
     isDir = info.isDirectory();
   } catch {
     isDir = extname(resolved) === "";
@@ -2288,12 +2999,12 @@ async function resolveOutPaths(out, providerName, multiProvider, count, format)
   const extension = `.${normalizeOutputFormat(format)}`;
   const prefix = multiProvider ? `${providerName}-` : "";
   if (isDir) {
-    return Array.from({ length: count }, (_, i) => join4(resolved, `${prefix}image-${i + 1}${extension}`));
+    return Array.from({ length: count }, (_, i) => join5(resolved, `${prefix}image-${i + 1}${extension}`));
   }
   if (count > 1 || multiProvider) {
-    const dir = dirname3(resolved);
+    const dir = dirname5(resolved);
     const base = basename(resolved, extname(resolved));
-    return Array.from({ length: count }, (_, i) => join4(dir, `${prefix}${base}-${i + 1}${extension}`));
+    return Array.from({ length: count }, (_, i) => join5(dir, `${prefix}${base}-${i + 1}${extension}`));
   }
   return [resolved.endsWith(extension) ? resolved : `${resolved}${extension}`];
 }
@@ -2301,14 +3012,16 @@ function printResult(providerName, result, paths) {
   process.stdout.write(
     `${JSON.stringify({
       provider: providerName,
-      imageModel: result.imageModel,
+      requestedModel: result.requestedModel,
       images: result.images.map((image, i) => ({
         path: paths[i],
         mimeType: image.mimeType,
         width: image.width,
         height: image.height,
         prompt: image.prompt,
-        responseId: image.responseId
+        responseId: image.responseId,
+        servedModel: image.servedModel ?? null,
+        served: image.usage?.["served"]
       }))
     })}
 `
@@ -2318,7 +3031,7 @@ async function saveImages(result, paths) {
   for (let i = 0; i < result.images.length; i += 1) {
     const path = paths[i];
     try {
-      await mkdir3(dirname3(path), { recursive: true });
+      await mkdir5(dirname5(path), { recursive: true });
       await writeFile3(path, Buffer.from(result.images[i].data));
     } catch {
       fail("io", `Could not write output file: ${path}`, EXIT_IO);
@@ -2391,8 +3104,8 @@ async function runAuthLogin(providerName, flags) {
   const waiter = waitForOAuthCallback(timeoutMinutes * 60 * 1e3, port);
   if (!flags.get("no-open")) {
     try {
-      const { default: open } = await import("open");
-      await open(url);
+      const { default: open2 } = await import("open");
+      await open2(url);
     } catch {
       process.stderr.write("Could not open a browser automatically. Open this URL manually:\n");
     }
@@ -2525,10 +3238,21 @@ async function runImageRequest(request, edit, providers) {
     const paths = await resolveOutPaths(request.out, entry.provider.name, multiProvider, result.images.length, request.format ?? "png");
     await saveImages(result, paths);
     printResult(entry.provider.name, result, paths);
+    try {
+      await appendUsageLog(usageLogEntry(request, edit, result, paths));
+    } catch {
+      process.stderr.write(`${JSON.stringify({ warning: { kind: "io", message: `Could not append to ${USAGE_LOG_ENV} file.` } })}
+`);
+    }
   }
 }
 async function main() {
   const { flags, positionals } = parseArgs(process.argv.slice(2));
+  if (flags.get("version")) {
+    process.stdout.write(`${await cliVersion()}
+`);
+    return;
+  }
   if (flags.get("help") || positionals.length === 0) {
     process.stdout.write(helpFor(positionals[0]));
     return;
@@ -2572,10 +3296,14 @@ async function main() {
 `);
       } else if (sub === "add" || sub === "update") {
         const patch = {};
-        for (const [flag, key] of [["api", "api"], ["base-url", "baseUrl"], ["auth", "auth"], ["model", "model"]]) {
+        for (const [flag, key] of [["api", "api"], ["base-url", "baseUrl"], ["auth", "auth"], ["model", "model"], ["start-command", "startCommand"]]) {
           const value = flagValue(flags, flag);
           if (value !== void 0) patch[key] = value;
         }
+        for (const [flag, key] of [["workflow", "workflow"], ["edit-workflow", "editWorkflow"]]) {
+          const value = flagValue(flags, flag);
+          if (value !== void 0) patch[key] = resolve3(value);
+        }
         const profile = sub === "add" ? await repository.add({ name: subSub, ...patch }) : await repository.update(subSub, patch);
         process.stdout.write(`${JSON.stringify({ provider: profile })}
 `);
@@ -2586,8 +3314,7 @@ async function main() {
       const selected = requestedProviders(flags);
       if (!selected || selected.length !== 1) fail("usage", "Model discovery requires exactly one --provider <profile-name>.", EXIT_USAGE);
       const profile = await new ProfileRepository().get(selected[0]);
-      const provider = new ConfigurableImageProvider(profile, async () => profileKey(profile, await profileStore()));
-      process.stdout.write(`${JSON.stringify({ provider: profile.name, models: await provider.models() })}
+      process.stdout.write(`${JSON.stringify({ provider: profile.name, models: await createProfileProvider(profile).models() })}
 `);
       return;
     }