@fre4x/comfyui 1.1.8 → 1.1.9

package/dist/index.js

@@ -6891,8 +6891,8 @@ var require_dist = __commonJS({
 });
 
 // src/index.ts
-import * as fs3 from "node:fs/promises";
 import { realpathSync } from "node:fs";
+import * as fs3 from "node:fs/promises";
 import path3 from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -6932,7 +6932,7 @@ function createInternalError(error48) {
         type: "text",
         text: `Internal Error: ${message}
 
-Suggestion: If the problem persists, check server logs.`
+Suggestion: Use the error details above to correct tool arguments and retry the tool call.`
       }
     ]
   };
@@ -6944,6 +6944,11 @@ function formatListItems(items, renderer, emptyMessage = "_No results found._")
     return emptyMessage;
   return items.map((item, i) => renderer(item, i)).join("\n\n");
 }
+function truncateToLimit(text, maxChars = 12e3) {
+  if (text.length <= maxChars)
+    return text;
+  return text.slice(0, maxChars) + "\n\n_...response truncated to fit context window. Use pagination to retrieve more results._";
+}
 function formatPaginationFooter(offset, limit, total) {
   const start = offset + 1;
   const end = Math.min(offset + limit, total);
@@ -30516,6 +30521,10 @@ var StdioServerTransport = class {
   }
 };
 
+// src/api.ts
+import * as fs from "node:fs/promises";
+import path from "node:path";
+
 // src/errors.ts
 var ComfyApiError = class extends Error {
   constructor(message, statusCode, details) {
@@ -30539,7 +30548,9 @@ var WorkflowInputError = class extends Error {
 };
 var WorkflowTimeoutError = class extends Error {
   constructor(promptId, timeoutSeconds, queueSnapshot) {
-    super(`Timeout waiting for workflow ${promptId}`);
+    super(
+      `Timed out waiting for prompt_id '${promptId}'. Call comfyui_wait_for_workflow again with this prompt_id`
+    );
     this.promptId = promptId;
     this.timeoutSeconds = timeoutSeconds;
     this.queueSnapshot = queueSnapshot;
@@ -30550,10 +30561,6 @@ var WorkflowTimeoutError = class extends Error {
   queueSnapshot;
 };
 
-// src/api.ts
-import * as fs from "node:fs/promises";
-import path from "node:path";
-
 // src/mock.ts
 var IS_MOCK = process.env.MOCK === "true";
 var MOCK_FIXTURES = {
@@ -30701,25 +30708,77 @@ var MOCK_FIXTURES = {
         messages: []
       }
     }
+  },
+  models: {
+    checkpoint: [
+      "v1-5-pruned-emaonly.ckpt",
+      "sd_xl_base_1.0.safetensors",
+      "cyberrealisticPony_v160.safetensors"
+    ],
+    lora: ["mock_style.safetensors", "mock_character.safetensors"],
+    vae: ["ae.safetensors", "sdxl_vae.safetensors"],
+    controlnet: ["control_v11p_sd15_canny.pth"],
+    unet: ["flux1-dev.safetensors"],
+    clip: ["clip_l.safetensors", "t5xxl_fp16.safetensors"],
+    upscale: ["RealESRGAN_x4plus.pth"]
   }
 };
 
 // src/api.ts
-var COMFYUI_SERVER_URL = process.env.COMFYUI_SERVER_URL || "http://localhost:8188";
+var MAX_UPLOAD_BYTES = 20 * 1024 * 1024;
+var MODEL_FOLDER_BY_TYPE = {
+  checkpoint: ["checkpoints"],
+  lora: ["loras"],
+  vae: ["vae"],
+  controlnet: ["controlnet"],
+  unet: ["diffusion_models", "unet"],
+  clip: ["clip"],
+  upscale: ["upscale_models"]
+};
+var MIME_BY_EXTENSION = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff"
+};
+function getComfyServerUrl() {
+  return process.env.COMFYUI_SERVER_URL || "http://localhost:8188";
+}
+function buildComfyHeaders(extra) {
+  const headers = new Headers();
+  headers.set("Accept", "application/json");
+  const apiKey = process.env.COMFY_API_KEY?.trim();
+  if (apiKey) {
+    const headerName = process.env.COMFY_API_HEADER?.trim() || "X-API-Key";
+    const value = headerName.toLowerCase() === "authorization" && !/^Bearer\s+/i.test(apiKey) ? `Bearer ${apiKey}` : apiKey;
+    headers.set(headerName, value);
+  }
+  if (extra) {
+    new Headers(extra).forEach((value, key) => {
+      headers.set(key, value);
+    });
+  }
+  return headers;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
 async function fetchComfyJson(apiPath, options) {
-  const url2 = new URL(apiPath, COMFYUI_SERVER_URL).toString();
+  const serverUrl = getComfyServerUrl();
+  const url2 = new URL(apiPath, serverUrl).toString();
   let response;
   try {
     response = await fetch(url2, {
       ...options,
-      headers: {
-        Accept: "application/json",
-        ...options?.headers || {}
-      }
+      headers: buildComfyHeaders(options?.headers)
     });
   } catch (error48) {
     throw new Error(
-      `Failed to connect to ComfyUI server at ${COMFYUI_SERVER_URL}: ${error48 instanceof Error ? error48.message : String(error48)}`
+      `Failed to connect to ComfyUI server at ${serverUrl}: ${error48 instanceof Error ? error48.message : String(error48)}`
     );
   }
   if (response.status === 404) {
@@ -30750,9 +30809,11 @@ async function fetchImageAsset(filename, type, subfolder) {
   if (subfolder) params.set("subfolder", subfolder);
   const url2 = new URL(
     `/view?${params.toString()}`,
-    COMFYUI_SERVER_URL
+    getComfyServerUrl()
   ).toString();
-  const response = await fetch(url2);
+  const response = await fetch(url2, {
+    headers: buildComfyHeaders()
+  });
   if (!response.ok)
     throw new Error(`Failed to fetch image: ${response.statusText}`);
   const arrayBuffer = await response.arrayBuffer();
@@ -30779,27 +30840,27 @@ function sanitizePathSegment(value, fallback) {
   const normalized = value.trim().replace(/[\\/]+/g, "_").replace(/\.\.+/g, "_").replace(/_+/g, "_").replace(/[^A-Za-z0-9._-]/g, "_");
   return normalized.length > 0 ? normalized : fallback;
 }
+function getWorkspaceOutputRelativePath(promptId, image) {
+  return path.join(
+    "comfyui",
+    sanitizePathSegment(promptId, "unknown-prompt"),
+    ...getSafePathSegments(image.subfolder),
+    path.basename(image.filename)
+  );
+}
 async function saveToWorkspace(promptId, image, asset) {
   const workspaceDir = getSessionWorkspaceDir();
   if (!workspaceDir) {
     return void 0;
   }
-  const safePromptId = sanitizePathSegment(promptId, "unknown-prompt");
-  const safeFileName = path.basename(image.filename);
-  const safeSubfolderSegments = getSafePathSegments(image.subfolder);
-  const relativePath = path.join(
-    "comfyui",
-    safePromptId,
-    ...safeSubfolderSegments,
-    safeFileName
-  );
+  const relativePath = getWorkspaceOutputRelativePath(promptId, image);
   const workspacePath = path.join(workspaceDir, relativePath);
   await fs.mkdir(path.dirname(workspacePath), { recursive: true });
   await fs.writeFile(workspacePath, asset.buffer);
   return {
     workspace_path: workspacePath,
     relative_path: relativePath,
-    filename: safeFileName,
+    filename: path.basename(image.filename),
     mime_type: asset.mimeType,
     subfolder: image.subfolder
   };
@@ -30830,17 +30891,58 @@ async function getQueueSnapshot() {
     return void 0;
   }
 }
+function extractPromptIdsFromQueueEntries(entries) {
+  const ids = [];
+  for (const entry of entries) {
+    if (!Array.isArray(entry) || entry.length === 0) {
+      continue;
+    }
+    if (typeof entry[1] === "string" && entry[1].length > 0) {
+      ids.push(entry[1]);
+      continue;
+    }
+    if (typeof entry[0] === "string" && entry[0].length > 0) {
+      ids.push(entry[0]);
+    }
+  }
+  return ids;
+}
+function summarizeQueue(queueSnapshot) {
+  if (!queueSnapshot) {
+    return void 0;
+  }
+  return {
+    running: queueSnapshot.queue_running.length,
+    pending: queueSnapshot.queue_pending.length,
+    running_prompt_ids: extractPromptIdsFromQueueEntries(
+      queueSnapshot.queue_running
+    ),
+    pending_prompt_ids: extractPromptIdsFromQueueEntries(
+      queueSnapshot.queue_pending
+    )
+  };
+}
 function formatQueueSnapshotText(queueSnapshot) {
   if (!queueSnapshot) {
     return "";
   }
+  if ("running" in queueSnapshot && "pending" in queueSnapshot) {
+    return `Queue snapshot: ${queueSnapshot.running} running, ${queueSnapshot.pending} pending.`;
+  }
   return `Queue snapshot: ${queueSnapshot.queue_running.length} running, ${queueSnapshot.queue_pending.length} pending.`;
 }
 function getPromptQueueVisibility(promptId, queueSnapshot) {
   if (!queueSnapshot) {
     return null;
   }
-  return JSON.stringify(queueSnapshot).includes(promptId);
+  if ("running_prompt_ids" in queueSnapshot) {
+    return queueSnapshot.running_prompt_ids.includes(promptId) || queueSnapshot.pending_prompt_ids.includes(promptId);
+  }
+  const summary = summarizeQueue(queueSnapshot);
+  if (!summary) {
+    return null;
+  }
+  return summary.running_prompt_ids.includes(promptId) || summary.pending_prompt_ids.includes(promptId);
 }
 async function waitForWorkflowResult(prompt_id, timeout_seconds) {
   const start = Date.now();
@@ -30861,9 +30963,270 @@ async function waitForWorkflowResult(prompt_id, timeout_seconds) {
     }
     await new Promise((r) => setTimeout(r, 1e3));
   }
-  const queueSnapshot = await getQueueSnapshot();
+  const queueSnapshot = summarizeQueue(await getQueueSnapshot());
   throw new WorkflowTimeoutError(prompt_id, timeout_seconds, queueSnapshot);
 }
+function parseInterruptedFlag(body) {
+  if (!body || typeof body !== "object" || !("interrupted" in body)) {
+    return void 0;
+  }
+  const interrupted = body.interrupted;
+  return typeof interrupted === "boolean" ? interrupted : void 0;
+}
+async function interruptWorkflow(options) {
+  let interrupted = true;
+  if (!IS_MOCK) {
+    const interruptBody = await fetchComfyJson("/interrupt", {
+      method: "POST",
+      ...options.promptId ? {
+        body: JSON.stringify({ prompt_id: options.promptId }),
+        headers: { "Content-Type": "application/json" }
+      } : {}
+    });
+    const parsed = parseInterruptedFlag(interruptBody);
+    if (parsed !== void 0) {
+      interrupted = parsed;
+    }
+    if (options.clearQueue) {
+      await fetchComfyJson("/queue", {
+        method: "POST",
+        body: JSON.stringify({ clear: true }),
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  }
+  const queue = summarizeQueue(await getQueueSnapshot());
+  return {
+    interrupted,
+    prompt_id: options.promptId,
+    queue_cleared: options.clearQueue,
+    ...queue ? { queue } : {}
+  };
+}
+function mimeTypeFromFilename(filename) {
+  const extension = path.extname(filename).toLowerCase();
+  return MIME_BY_EXTENSION[extension] || "image/png";
+}
+async function getUploadRoots() {
+  const candidates = [
+    process.cwd(),
+    process.env.MCP_WORKSPACE_DIR,
+    process.env.COMFYUI_UPLOAD_ROOT
+  ].filter((value) => Boolean(value));
+  const roots = [];
+  for (const candidate of candidates) {
+    try {
+      roots.push(await fs.realpath(candidate));
+    } catch {
+      roots.push(path.resolve(candidate));
+    }
+  }
+  return [...new Set(roots)];
+}
+function isPathInsideRoot(target, root) {
+  return target === root || target.startsWith(`${root}${path.sep}`);
+}
+async function resolveReadableUploadPath(filePath) {
+  let resolved;
+  try {
+    resolved = await fs.realpath(filePath);
+  } catch {
+    throw new WorkflowInputError(
+      `Image file not found: ${filePath}`,
+      "file_path",
+      "not_found"
+    );
+  }
+  const roots = await getUploadRoots();
+  if (!roots.some((root) => isPathInsideRoot(resolved, root))) {
+    throw new WorkflowInputError(
+      "file_path must be inside the workspace or COMFYUI_UPLOAD_ROOT.",
+      "file_path"
+    );
+  }
+  return resolved;
+}
+async function readPreviousRunImage(params) {
+  if (IS_MOCK) {
+    return createMockImageAsset();
+  }
+  const workspaceDir = getSessionWorkspaceDir();
+  if (workspaceDir) {
+    const candidate = path.join(
+      workspaceDir,
+      getWorkspaceOutputRelativePath(params.promptId, {
+        filename: params.filename,
+        subfolder: params.subfolder
+      })
+    );
+    try {
+      const resolved = await fs.realpath(candidate);
+      let root;
+      try {
+        root = await fs.realpath(workspaceDir);
+      } catch {
+        root = path.resolve(workspaceDir);
+      }
+      if (isPathInsideRoot(resolved, root)) {
+        return {
+          buffer: await fs.readFile(resolved),
+          mimeType: mimeTypeFromFilename(params.filename)
+        };
+      }
+    } catch {
+    }
+  }
+  return fetchImageAsset(
+    params.filename,
+    params.sourceType,
+    params.subfolder
+  );
+}
+async function readUploadImageSource(params) {
+  const sources = [
+    params.filePath ? "file_path" : void 0,
+    params.promptId ? "prompt_id" : void 0
+  ].filter((value) => Boolean(value));
+  if (sources.length !== 1) {
+    throw new WorkflowInputError(
+      "Provide exactly one image source: file_path, or prompt_id + filename from a previous run.",
+      sources[1] ?? "file_path"
+    );
+  }
+  if (params.promptId) {
+    if (!params.filename?.trim()) {
+      throw new WorkflowInputError(
+        "filename is required when uploading from a previous prompt_id.",
+        "filename"
+      );
+    }
+    const asset = await readPreviousRunImage({
+      promptId: params.promptId,
+      filename: params.filename,
+      subfolder: params.subfolder,
+      sourceType: params.sourceType ?? "output"
+    });
+    if (asset.buffer.byteLength > MAX_UPLOAD_BYTES) {
+      throw new WorkflowInputError(
+        `Image exceeds the ${MAX_UPLOAD_BYTES} byte upload limit.`,
+        "prompt_id"
+      );
+    }
+    const filename2 = sanitizePathSegment(
+      params.filename,
+      `upload-${Date.now()}.png`
+    );
+    return {
+      buffer: asset.buffer,
+      filename: filename2,
+      mimeType: asset.mimeType
+    };
+  }
+  if (!params.filePath) {
+    throw new WorkflowInputError(
+      "Provide exactly one image source: file_path, or prompt_id + filename from a previous run.",
+      "file_path"
+    );
+  }
+  const resolvedPath = await resolveReadableUploadPath(params.filePath);
+  const buffer = await fs.readFile(resolvedPath);
+  if (buffer.byteLength > MAX_UPLOAD_BYTES) {
+    throw new WorkflowInputError(
+      `Image exceeds the ${MAX_UPLOAD_BYTES} byte upload limit.`,
+      "file_path"
+    );
+  }
+  const filename = sanitizePathSegment(
+    params.filename || path.basename(resolvedPath),
+    `upload-${Date.now()}.png`
+  );
+  return {
+    buffer,
+    filename,
+    mimeType: mimeTypeFromFilename(filename)
+  };
+}
+async function uploadImage(params) {
+  if (IS_MOCK) {
+    return {
+      name: params.filename,
+      subfolder: "",
+      type: params.imageType
+    };
+  }
+  const formData = new FormData();
+  const bytes = new Uint8Array(params.buffer);
+  formData.append(
+    "image",
+    new Blob([bytes], { type: params.mimeType }),
+    params.filename
+  );
+  formData.append("type", params.imageType);
+  if (params.overwrite) {
+    formData.append("overwrite", "true");
+  }
+  const uploaded = await fetchComfyJson("/upload/image", {
+    method: "POST",
+    body: formData
+  });
+  if (uploaded && typeof uploaded === "object" && "name" in uploaded && typeof uploaded.name === "string") {
+    const record2 = uploaded;
+    return {
+      name: uploaded.name,
+      subfolder: typeof record2.subfolder === "string" ? record2.subfolder : "",
+      type: typeof record2.type === "string" ? record2.type : params.imageType
+    };
+  }
+  return {
+    name: params.filename,
+    subfolder: "",
+    type: params.imageType
+  };
+}
+async function getModelList(modelType) {
+  if (IS_MOCK) {
+    return {
+      models: MOCK_FIXTURES.models[modelType] ?? [],
+      models_endpoint_available: true
+    };
+  }
+  const models = /* @__PURE__ */ new Set();
+  let sawSuccessfulFolder = false;
+  for (const folder of MODEL_FOLDER_BY_TYPE[modelType]) {
+    try {
+      const listed = await fetchComfyJson(`/models/${folder}`);
+      if (!isStringArray(listed)) {
+        continue;
+      }
+      sawSuccessfulFolder = true;
+      for (const item of listed) {
+        models.add(item);
+      }
+    } catch (error48) {
+      if (error48 instanceof ComfyApiError && error48.statusCode === 404) {
+        continue;
+      }
+      throw error48;
+    }
+  }
+  return {
+    models: [...models].sort(
+      (left, right) => left.localeCompare(right, void 0, { numeric: true })
+    ),
+    models_endpoint_available: sawSuccessfulFolder
+  };
+}
+
+// src/types.ts
+var COMFY_MODEL_TYPES = [
+  "checkpoint",
+  "lora",
+  "vae",
+  "controlnet",
+  "unet",
+  "clip",
+  "upscale"
+];
 
 // src/workflow/common.ts
 function isRecord(value) {
@@ -30988,9 +31351,6 @@ function getInputOptionsSummary(inputDefinition, previewLimit = 8) {
     options_truncated: typeData.length > previewLimit
   };
 }
-function isPlainObject3(value) {
-  return isRecord(value) && !Array.isArray(value);
-}
 function getValueTypeName(value) {
   if (Array.isArray(value)) {
     return "array";
@@ -31001,906 +31361,1014 @@ function getValueTypeName(value) {
   return typeof value;
 }
 
-// src/workflow/load.ts
-import * as fs2 from "node:fs/promises";
-import * as crypto from "node:crypto";
-import { homedir } from "node:os";
-import path2 from "node:path";
-
-// src/converter.ts
-var WIDGET_TYPES = /* @__PURE__ */ new Set(["INT", "FLOAT", "STRING", "BOOLEAN"]);
-var UI_CONTROL_VALUES = /* @__PURE__ */ new Set([
-  "fixed",
-  "increment",
-  "decrement",
-  "randomize"
-]);
-function isRecord2(value) {
-  return typeof value === "object" && value !== null;
-}
-function isWebUIFormat(json2) {
-  return isRecord2(json2) && Array.isArray(json2.nodes) && Array.isArray(json2.links);
-}
-function isLinkData(link) {
-  return Array.isArray(link) && link.length >= 6 && typeof link[0] === "number" && typeof link[1] === "number" && typeof link[2] === "number" && typeof link[3] === "number" && typeof link[4] === "number" && typeof link[5] === "string";
+// src/workflow/editable.ts
+function isConnectionValue(value) {
+  return Array.isArray(value) && value.length >= 2 && (typeof value[0] === "string" || typeof value[0] === "number") && typeof value[1] === "number";
 }
-function getOrderedInputEntries(group, orderedNames) {
-  if (!group) {
-    return [];
+function inferEditableRole(nodeId, classType, inputName, consumerMap) {
+  if (classType === "CLIPTextEncode" && inputName === "text") {
+    const consumers = consumerMap.get(nodeId) ?? [];
+    if (consumers.some((consumer) => consumer.inputName === "positive")) {
+      return "positive_prompt";
+    }
+    if (consumers.some((consumer) => consumer.inputName === "negative")) {
+      return "negative_prompt";
+    }
+    return "prompt_text";
   }
-  const seen = /* @__PURE__ */ new Set();
-  const orderedEntries = [];
-  for (const inputName of orderedNames ?? []) {
-    const inputDefinition = group[inputName];
-    if (!inputDefinition) {
-      continue;
+  if (inputName === "value") {
+    const consumers = consumerMap.get(nodeId) ?? [];
+    const textConsumers = consumers.filter(
+      (consumer) => consumer.classType === "CLIPTextEncode" && consumer.inputName === "text"
+    );
+    if (textConsumers.length > 0) {
+      for (const consumer of textConsumers) {
+        const clipConsumers = consumerMap.get(consumer.nodeId) ?? [];
+        if (clipConsumers.some(
+          (clipConsumer) => clipConsumer.inputName === "positive"
+        )) {
+          return "positive_prompt";
+        }
+        if (clipConsumers.some(
+          (clipConsumer) => clipConsumer.inputName === "negative"
+        )) {
+          return "negative_prompt";
+        }
+      }
+      return "prompt_text";
     }
-    orderedEntries.push([inputName, inputDefinition]);
-    seen.add(inputName);
   }
-  for (const [inputName, inputDefinition] of Object.entries(group)) {
-    if (seen.has(inputName)) {
+  switch (inputName) {
+    case "seed":
+      return "seed";
+    case "steps":
+      return "steps";
+    case "cfg":
+      return "cfg";
+    case "sampler_name":
+      return "sampler";
+    case "scheduler":
+      return "scheduler";
+    case "denoise":
+      return "denoise";
+    case "width":
+      return "width";
+    case "height":
+      return "height";
+    case "batch_size":
+      return "batch_size";
+    case "ckpt_name":
+      return "checkpoint";
+    case "filename_prefix":
+      return "filename_prefix";
+    case "text":
+      return "text";
+    default:
+      return void 0;
+  }
+}
+var GLOBAL_OVERRIDE_ROLES = /* @__PURE__ */ new Set([
+  "positive_prompt",
+  "negative_prompt",
+  "seed",
+  "steps",
+  "cfg",
+  "checkpoint",
+  "width",
+  "height",
+  "denoise",
+  "sampler",
+  "scheduler",
+  "batch_size",
+  "filename_prefix"
+]);
+function collectRoleEntries(editableInputs) {
+  const roleEntries = /* @__PURE__ */ new Map();
+  for (const entry of editableInputs) {
+    if (!entry.role || !GLOBAL_OVERRIDE_ROLES.has(entry.role)) {
       continue;
     }
-    orderedEntries.push([inputName, inputDefinition]);
+    const entries = roleEntries.get(entry.role) ?? [];
+    entries.push(entry);
+    roleEntries.set(entry.role, entries);
   }
-  return orderedEntries;
+  return roleEntries;
 }
-function getWidgetTypeName(inputTypeData) {
-  return Array.isArray(inputTypeData) ? "COMBO" : String(inputTypeData).toUpperCase();
+function applyUniqueGlobalRoleAliases(editableInputs) {
+  for (const [role, entries] of collectRoleEntries(editableInputs)) {
+    if (entries.length !== 1) {
+      continue;
+    }
+    const entry = entries[0];
+    if (!entry.aliases.includes(role)) {
+      entry.aliases.push(role);
+    }
+  }
 }
-function isWidgetInput(inputTypeData) {
-  const typeName = getWidgetTypeName(inputTypeData);
-  return typeName === "COMBO" || WIDGET_TYPES.has(typeName);
-}
-function isSkippableUiArtifact(value, expectedTypeName) {
-  if (expectedTypeName !== "STRING" && typeof value === "string" && UI_CONTROL_VALUES.has(value)) {
-    return true;
-  }
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeWidgetValue(value, typeName, extraInfo) {
-  const defaultValue = extraInfo?.default;
-  const shouldUseDefaultForNumeric = (typeName === "INT" || typeName === "FLOAT") && (value === "" || value === void 0 || value === null);
-  if (shouldUseDefaultForNumeric && defaultValue !== void 0) {
-    return defaultValue;
-  }
-  return value;
-}
-function convertWebUIToAPIWithMetadata(webUIJson, objectInfo) {
-  const prompt = {};
-  const widgetPathMap = {};
-  const links = webUIJson.links || [];
-  const nodes = webUIJson.nodes || [];
-  const serverNodeIds = /* @__PURE__ */ new Set();
-  for (const node of nodes) {
-    if (!node.id || !node.type || !objectInfo[node.type]) {
-      continue;
-    }
-    serverNodeIds.add(String(node.id));
+function getEditableAliases(canonicalPath, nodeId, inputName, role, widgetPathMap) {
+  const aliases = /* @__PURE__ */ new Set([`${nodeId}.${inputName}`]);
+  if (role) {
+    aliases.add(`${nodeId}.${role}`);
   }
-  const linkMap = /* @__PURE__ */ new Map();
-  for (const link of links) {
-    if (isLinkData(link) && serverNodeIds.has(String(link[3]))) {
-      linkMap.set(link[0], link);
+  for (const [widgetPath, resolvedPath] of Object.entries(widgetPathMap)) {
+    if (resolvedPath === canonicalPath) {
+      aliases.add(widgetPath);
     }
   }
-  for (const node of nodes) {
-    if (!node.id || !node.type) continue;
-    const objInfo = objectInfo[node.type];
-    if (!objInfo) continue;
-    const nodeIdStr = String(node.id);
-    const promptNode = {
-      class_type: node.type,
-      inputs: {}
-    };
-    const connectedInputNames = /* @__PURE__ */ new Set();
-    if (Array.isArray(node.inputs)) {
-      for (const input of node.inputs) {
-        if (input.name && input.link !== null && input.link !== void 0) {
-          const linkData = linkMap.get(input.link);
-          if (Array.isArray(linkData) && linkData.length >= 6 && String(linkData[3]) === nodeIdStr) {
-            const originNodeId = String(linkData[1]);
-            const originSlot = linkData[2];
-            promptNode.inputs[input.name] = [
-              originNodeId,
-              originSlot
-            ];
-            connectedInputNames.add(input.name);
-          }
-        }
+  aliases.delete(canonicalPath);
+  return [...aliases];
+}
+function buildEditableInputIndex(editableInputs) {
+  const entriesByPath = /* @__PURE__ */ new Map();
+  const aliasToPath = /* @__PURE__ */ new Map();
+  const ambiguousAliases = /* @__PURE__ */ new Map();
+  const pathsByNode = /* @__PURE__ */ new Map();
+  for (const entry of editableInputs) {
+    entriesByPath.set(entry.path, entry);
+    const nodeEntries = pathsByNode.get(entry.node_id) ?? [];
+    nodeEntries.push(entry);
+    pathsByNode.set(entry.node_id, nodeEntries);
+    for (const alias of [entry.path, ...entry.aliases]) {
+      const existing = aliasToPath.get(alias);
+      if (!existing) {
+        aliasToPath.set(alias, entry.path);
+        continue;
       }
-    }
-    if (objInfo) {
-      const widgets = Array.isArray(node.widgets_values) ? node.widgets_values : [];
-      let widgetIndex = 0;
-      const processInputGroup = (group, orderedNames) => {
-        for (const [inputName, inputDataRaw] of getOrderedInputEntries(
-          group,
-          orderedNames
-        )) {
-          const [inputTypeData, inputExtraInfo] = inputDataRaw;
-          if (!isWidgetInput(inputTypeData)) {
-            continue;
-          }
-          const typeName = getWidgetTypeName(inputTypeData);
-          while (widgetIndex < widgets.length && isSkippableUiArtifact(widgets[widgetIndex], typeName)) {
-            widgetIndex++;
-          }
-          const isConnectedWidget = connectedInputNames.has(inputName);
-          if (widgetIndex >= widgets.length) {
-            if (!isConnectedWidget && inputExtraInfo?.default !== void 0) {
-              promptNode.inputs[inputName] = inputExtraInfo.default;
-            }
-            continue;
-          }
-          const widgetSourceIndex = widgetIndex;
-          const value = normalizeWidgetValue(
-            widgets[widgetSourceIndex],
-            typeName,
-            inputExtraInfo
-          );
-          widgetIndex++;
-          if (!isConnectedWidget) {
-            promptNode.inputs[inputName] = value;
-            widgetPathMap[`${nodeIdStr}.widgets[${widgetSourceIndex}]`] = `${nodeIdStr}.inputs.${inputName}`;
-          }
-        }
-      };
-      processInputGroup(
-        objInfo.input?.required,
-        objInfo.input_order?.required
-      );
-      processInputGroup(
-        objInfo.input?.optional,
-        objInfo.input_order?.optional
+      if (existing === entry.path) {
+        continue;
+      }
+      const ambiguous = new Set(
+        ambiguousAliases.get(alias) ?? [existing]
       );
+      ambiguous.add(entry.path);
+      ambiguousAliases.set(alias, [...ambiguous].sort());
+      aliasToPath.delete(alias);
     }
-    prompt[nodeIdStr] = promptNode;
+  }
+  for (const [role, entries] of collectRoleEntries(editableInputs)) {
+    if (entries.length <= 1) {
+      continue;
+    }
+    const paths = [...new Set(entries.map((entry) => entry.path))].sort();
+    ambiguousAliases.set(role, paths);
+    aliasToPath.delete(role);
   }
   return {
-    prompt,
-    widgetPathMap
+    entriesByPath,
+    aliasToPath,
+    ambiguousAliases,
+    pathsByNode
   };
 }
-
-// src/workflow/load.ts
-function isComfyPromptNode(value) {
-  return isRecord(value) && typeof value.class_type === "string" && isRecord(value.inputs);
+function getPathSegmentHelp(prompt, path4) {
+  const parts = path4.split(".");
+  if (parts.length === 0 || parts[0].length === 0) {
+    return void 0;
+  }
+  const nodeId = parts[0];
+  return {
+    nodeId,
+    nodeExists: isRecord(prompt[nodeId])
+  };
 }
-function isUiOnlyPromptNode(nodeId, node) {
-  return nodeId === "meta" || ["Note", "MarkdownNote", "PrimitiveNode"].includes(node.class_type);
+function describeAvailableNodePaths(editableIndex, nodeId) {
+  if (!editableIndex) {
+    return "";
+  }
+  const entries = editableIndex.pathsByNode.get(nodeId) ?? [];
+  if (entries.length === 0) {
+    return "";
+  }
+  return entries.map((entry) => {
+    const aliasSuffix = entry.aliases.length > 0 ? ` (aliases: ${entry.aliases.join(", ")})` : "";
+    return `${entry.path}${aliasSuffix}`;
+  }).join("\n");
 }
-function extractRunnablePromptNodes(prompt) {
-  const runnablePrompt = {};
-  for (const [nodeId, rawNode] of Object.entries(prompt)) {
-    if (!isComfyPromptNode(rawNode) || isUiOnlyPromptNode(nodeId, rawNode)) {
-      continue;
-    }
-    runnablePrompt[nodeId] = rawNode;
+function getPreferredOverridePath(entry) {
+  if (entry.role && entry.aliases.includes(entry.role)) {
+    return entry.role;
   }
-  if (Object.keys(runnablePrompt).length === 0) {
-    throw new WorkflowInputError(
-      "Workflow prompt does not contain any runnable ComfyUI nodes.",
-      "workflow"
-    );
+  const roleAlias = entry.role ? `${entry.node_id}.${entry.role}` : void 0;
+  if (roleAlias && entry.aliases.includes(roleAlias)) {
+    return roleAlias;
   }
-  return runnablePrompt;
+  const inputAlias = `${entry.node_id}.${entry.input_name}`;
+  if (entry.aliases.includes(inputAlias)) {
+    return inputAlias;
+  }
+  const nonWidgetAlias = entry.aliases.find(
+    (alias) => !alias.includes(".widgets[")
+  );
+  return nonWidgetAlias ?? entry.path;
 }
-function getWorkflowDirectories(extraPath) {
-  const directories = [
-    process.cwd(),
-    path2.join(process.cwd(), "workflows"),
-    path2.join(homedir(), ".fre4x-comfyui", "workflows"),
-    path2.join(
-      homedir(),
-      "comfy",
-      "ComfyUI",
-      "user",
-      "default",
-      "workflows"
-    )
-  ];
-  if (extraPath) {
-    directories.push(extraPath);
+function formatEditableInputOptionsText(entry) {
+  if (entry.options_count === void 0 || entry.options_preview === void 0 || entry.options_preview.length === 0) {
+    return "";
   }
-  return [
-    ...new Set(directories.map((directory) => path2.resolve(directory)))
-  ];
+  const preview = entry.options_preview.map((option) => formatValuePreview(option)).join(", ");
+  const truncatedSuffix = entry.options_truncated ? ", ..." : "";
+  return ` | options: ${preview}${truncatedSuffix} (${entry.options_count} total)`;
 }
-function getWorkflowNameCandidates(name) {
-  const trimmed = name.trim();
-  if (trimmed.length === 0) {
-    return [];
+function getEditableInputGroup(entry) {
+  if (entry.role === "positive_prompt" || entry.role === "negative_prompt" || entry.role === "prompt_text") {
+    return "prompts";
   }
-  if (trimmed.endsWith(".json")) {
-    return [trimmed];
+  if (entry.role === "checkpoint" || entry.input_name === "ckpt_name" || entry.input_name === "model_name" || entry.input_name === "vae_name" || entry.class_type.includes("Checkpoint") || entry.class_type.includes("VAE")) {
+    return "models";
   }
-  return [trimmed, `${trimmed}.json`];
-}
-function normalizeWorkflowFileName(fileName) {
-  const trimmed = fileName.trim();
-  if (trimmed.length === 0) {
-    throw new WorkflowInputError(
-      "Filename cannot be empty.",
-      "output_file_name"
-    );
+  if (entry.role === "seed" || entry.role === "steps" || entry.role === "cfg" || entry.role === "sampler" || entry.role === "scheduler" || entry.role === "denoise" || entry.class_type.includes("Sampler")) {
+    return "sampling";
   }
-  if (path2.isAbsolute(trimmed)) {
-    throw new WorkflowInputError(
-      "Absolute paths are not allowed.",
-      "output_file_name"
-    );
+  if (entry.role === "width" || entry.role === "height" || entry.role === "batch_size") {
+    return "image";
   }
-  return trimmed.endsWith(".json") ? trimmed : `${trimmed}.json`;
-}
-async function resolveWorkflowReference(args) {
-  if (args.workflow_file_path) {
-    const targetPath = args.workflow_file_path;
-    try {
-      const resolvedPath = path2.resolve(targetPath);
-      const content = await fs2.readFile(resolvedPath, "utf8");
-      return {
-        targetPath: resolvedPath,
-        content
-      };
-    } catch {
-      if (path2.basename(targetPath) === targetPath) {
-        const candidates = getWorkflowNameCandidates(targetPath);
-        for (const dir of getWorkflowDirectories()) {
-          for (const candidate of candidates) {
-            const candidatePath = path2.join(dir, candidate);
-            try {
-              const content = await fs2.readFile(
-                candidatePath,
-                "utf8"
-              );
-              return {
-                targetPath: candidatePath,
-                content
-              };
-            } catch {
-            }
-          }
-        }
-      }
-      throw new WorkflowInputError(
-        `Workflow file not found: ${targetPath}`,
-        "workflow_file_path",
-        "not_found"
-      );
-    }
+  if (entry.input_name === "lora_name" || entry.input_name.startsWith("strength_") || entry.class_type.includes("Lora")) {
+    return "loras";
   }
-  if (args.workflow_id) {
-    const requestedId = args.workflow_id.trim();
-    if (requestedId.length === 0) {
-      throw new WorkflowInputError(
-        "Workflow ID cannot be empty.",
-        "workflow_id"
-      );
-    }
-    const objectInfoAvailability = await tryGetObjectInfo();
-    for (const dir of getWorkflowDirectories()) {
-      try {
-        const entries = await fs2.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (!entry.isFile() || !entry.name.endsWith(".json")) {
-            continue;
-          }
-          const fullPath = path2.join(dir, entry.name);
-          const inspected = await inspectWorkflowFile(
-            fullPath,
-            objectInfoAvailability.objectInfo
-          );
-          if (!inspected) {
-            continue;
-          }
-          if (requestedId === inspected.id || requestedId === inspected.name || requestedId === entry.name.replace(/\.json$/, "")) {
-            return {
-              targetPath: fullPath,
-              content: inspected.content
-            };
-          }
-        }
-      } catch {
-      }
-    }
-    throw new WorkflowInputError(
-      `Workflow ID not found: ${args.workflow_id}`,
-      "workflow_id",
-      "not_found"
-    );
+  if (entry.class_type.includes("ControlNet") || entry.class_type.includes("IPAdapter") || entry.class_type.includes("FreeU") || entry.class_type.includes("FaceDetailer")) {
+    return "control";
   }
-  throw new WorkflowInputError(
-    "Must provide either workflow_file_path or workflow_id.",
-    "workflow_id"
-  );
+  if (entry.role === "filename_prefix" || entry.input_name === "filename" || entry.input_name === "path" || entry.input_name === "extension" || entry.class_type.includes("Save") || entry.class_type.includes("PromptSaver")) {
+    return "output";
+  }
+  return "other";
 }
-async function normalizeWorkflowPrompt(workflow, objectInfo) {
-  if (!isRecord(workflow)) {
-    throw new WorkflowInputError(
-      "Workflow must be a JSON object.",
-      "workflow"
-    );
+function getEditableInputPriority(entry) {
+  const rolePriority = {
+    positive_prompt: 300,
+    negative_prompt: 295,
+    prompt_text: 290,
+    checkpoint: 260,
+    seed: 250,
+    steps: 240,
+    cfg: 235,
+    sampler: 230,
+    scheduler: 225,
+    width: 220,
+    height: 219,
+    batch_size: 218,
+    denoise: 215,
+    filename_prefix: 190,
+    text: 180
+  };
+  let priority = rolePriority[entry.role ?? ""] ?? 0;
+  if (entry.input_name === "lora_name") {
+    priority = Math.max(priority, 170);
   }
-  let sourceFormat = "api";
-  let widgetPathMap = {};
-  let normalizedWorkflow = workflow;
-  if (isWebUIFormat(normalizedWorkflow)) {
-    if (!objectInfo) {
-      throw new WorkflowInputError(
-        "Web UI workflow normalization requires ComfyUI node definitions. Start the ComfyUI server or save the workflow in API format first.",
-        "workflow"
-      );
+  if (entry.input_name.startsWith("strength_")) {
+    priority = Math.max(priority, 160);
+  }
+  if (entry.class_type.includes("PromptSaver") || entry.class_type === "SaveImage") {
+    priority -= 70;
+  }
+  if (entry.class_type === "PrimitiveStringMultiline" && (entry.role === "positive_prompt" || entry.role === "negative_prompt")) {
+    priority += 30;
+  }
+  return priority;
+}
+function getHighSignalEditableInputs(editableInputs, limit = 12) {
+  const seen = /* @__PURE__ */ new Set();
+  const prioritized = [...editableInputs].sort((left, right) => {
+    const priorityDiff = getEditableInputPriority(right) - getEditableInputPriority(left);
+    if (priorityDiff !== 0) {
+      return priorityDiff;
     }
-    sourceFormat = "webui";
-    const converted = convertWebUIToAPIWithMetadata(
-      normalizedWorkflow,
-      objectInfo
+    return getPreferredOverridePath(left).localeCompare(
+      getPreferredOverridePath(right),
+      void 0,
+      { numeric: true }
     );
-    normalizedWorkflow = converted.prompt;
-    widgetPathMap = converted.widgetPathMap;
+  }).filter((entry) => {
+    const preferredPath = getPreferredOverridePath(entry);
+    if (seen.has(preferredPath)) {
+      return false;
+    }
+    seen.add(preferredPath);
+    return true;
+  });
+  return prioritized.slice(0, limit);
+}
+function summarizeEditableInputGroups(editableInputs) {
+  const labels = {
+    prompts: "Prompts",
+    models: "Models and checkpoints",
+    sampling: "Sampling",
+    image: "Image size and batching",
+    loras: "LoRAs and strengths",
+    control: "Conditioning and adapters",
+    output: "Output and persistence",
+    other: "Other"
+  };
+  const summaries = /* @__PURE__ */ new Map();
+  for (const entry of editableInputs) {
+    const group = getEditableInputGroup(entry);
+    const existing = summaries.get(group) ?? {
+      group,
+      label: labels[group],
+      count: 0,
+      sample_paths: []
+    };
+    existing.count += 1;
+    if (existing.sample_paths.length < 3) {
+      existing.sample_paths.push(getPreferredOverridePath(entry));
+    }
+    summaries.set(group, existing);
   }
-  const promptCandidate = isRecord(normalizedWorkflow.prompt) && normalizedWorkflow.prompt ? normalizedWorkflow.prompt : normalizedWorkflow;
-  if (!isRecord(promptCandidate)) {
-    throw new WorkflowInputError(
-      "Workflow prompt must be a JSON object.",
-      "workflow"
-    );
+  const order = [
+    "prompts",
+    "models",
+    "sampling",
+    "image",
+    "loras",
+    "control",
+    "output",
+    "other"
+  ];
+  return order.map((group) => summaries.get(group)).filter(
+    (summary) => Boolean(summary)
+  );
+}
+function formatEditableInputGroupsText(groupSummaries) {
+  if (groupSummaries.length === 0) {
+    return "No editable input groups were detected.";
   }
-  return {
-    prompt: extractRunnablePromptNodes(promptCandidate),
-    sourceFormat,
-    widgetPathMap
-  };
+  return formatListItems(groupSummaries, (summary) => {
+    const examples = summary.sample_paths.length > 0 ? ` | examples: ${summary.sample_paths.join(", ")}` : "";
+    return `${summary.label}: ${summary.count}${examples}`;
+  });
 }
-async function loadWorkflow(args, objectInfo) {
-  const { targetPath, content } = await resolveWorkflowReference(args);
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch (error48) {
-    throw new WorkflowInputError(
-      `Invalid JSON in ${targetPath}: ${error48 instanceof Error ? error48.message : String(error48)}`,
-      args.workflow_file_path ? "workflow_file_path" : "workflow_id"
-    );
+function buildOverrideExamples(editableInputs, limit = 5, options = {}) {
+  const valueMode = options.valueMode ?? "full";
+  const examples = {};
+  const preferredPaths = [];
+  for (const entry of getHighSignalEditableInputs(editableInputs, limit)) {
+    const preferredPath = getPreferredOverridePath(entry);
+    preferredPaths.push(preferredPath);
+    if (valueMode === "keys") {
+      continue;
+    }
+    examples[preferredPath] = valueMode === "preview" ? entry.value_preview : entry.value;
   }
-  const { prompt, sourceFormat, widgetPathMap } = await normalizeWorkflowPrompt(parsed, objectInfo);
   return {
-    targetPath,
-    prompt,
-    sourceFormat,
-    widgetPathMap
+    examples,
+    preferred_paths: preferredPaths
   };
 }
-async function inspectWorkflowFile(fullPath, objectInfo) {
-  const content = await fs2.readFile(fullPath, "utf8");
-  const defaultName = path2.basename(fullPath, ".json");
-  const defaultId = getWorkflowId(fullPath);
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    return void 0;
+function formatOverrideExamplesText(examples) {
+  return JSON.stringify(examples, null, 2);
+}
+function analyzeEditableInputs(prompt, objectInfo, widgetPathMap = {}) {
+  const consumerMap = /* @__PURE__ */ new Map();
+  for (const [nodeId, node] of Object.entries(prompt)) {
+    for (const [inputName, value] of Object.entries(node.inputs)) {
+      if (!isConnectionValue(value)) {
+        continue;
+      }
+      const sourceNodeId = String(value[0]);
+      const consumers = consumerMap.get(sourceNodeId) ?? [];
+      consumers.push({
+        inputName,
+        classType: node.class_type,
+        nodeId
+      });
+      consumerMap.set(sourceNodeId, consumers);
+    }
   }
-  let name = defaultName;
-  if (isRecord(parsed)) {
-    if (typeof parsed.name === "string" && parsed.name.trim().length > 0) {
-      name = parsed.name;
-    } else if (isRecord(parsed.workflow) && typeof parsed.workflow.name === "string" && parsed.workflow.name.trim().length > 0) {
-      name = parsed.workflow.name;
+  const editableInputs = [];
+  for (const [nodeId, node] of Object.entries(prompt)) {
+    for (const [inputName, value] of Object.entries(node.inputs)) {
+      if (isConnectionValue(value)) {
+        continue;
+      }
+      editableInputs.push({
+        path: `${nodeId}.inputs.${inputName}`,
+        node_id: nodeId,
+        class_type: node.class_type,
+        input_name: inputName,
+        value,
+        value_preview: formatValuePreview(value),
+        role: inferEditableRole(
+          nodeId,
+          node.class_type,
+          inputName,
+          consumerMap
+        ),
+        aliases: [],
+        expected_type: getExpectedTypeName(
+          getInputDefinition(objectInfo, prompt, nodeId, inputName)
+        ),
+        ...getInputOptionsSummary(
+          getInputDefinition(objectInfo, prompt, nodeId, inputName)
+        )
+      });
     }
   }
-  if (isWebUIFormat(parsed)) {
-    if (!objectInfo) {
-      return {
-        id: defaultId,
-        name,
-        path: fullPath,
-        source_format: "webui",
-        validation_status: "conversion_requires_node_schemas",
-        content,
-        isWebUI: true
-      };
-    }
-    try {
-      await normalizeWorkflowPrompt(parsed, objectInfo);
-      return {
-        id: defaultId,
-        name,
-        path: fullPath,
-        source_format: "webui",
-        validation_status: "conversion_validated",
-        content,
-        isWebUI: true
-      };
-    } catch (error48) {
-      return {
-        id: defaultId,
-        name,
-        path: fullPath,
-        source_format: "webui",
-        validation_status: "conversion_failed",
-        content,
-        error: summarizeErrorMessage(error48),
-        isWebUI: true
-      };
-    }
-  }
-  try {
-    await normalizeWorkflowPrompt(parsed);
-    return {
-      id: defaultId,
-      name,
-      path: fullPath,
-      source_format: "api",
-      validation_status: "ready",
-      content,
-      isWebUI: false
-    };
-  } catch {
-    return void 0;
-  }
+  const withAliases = editableInputs.map((entry) => ({
+    ...entry,
+    aliases: getEditableAliases(
+      entry.path,
+      entry.node_id,
+      entry.input_name,
+      entry.role,
+      widgetPathMap
+    )
+  }));
+  applyUniqueGlobalRoleAliases(withAliases);
+  return withAliases.sort(
+    (left, right) => left.path.localeCompare(right.path, void 0, { numeric: true })
+  );
 }
-function deriveSavedWorkflowFileName(sourcePath, requestedName) {
-  if (requestedName) {
-    return normalizeWorkflowFileName(requestedName);
+function formatWorkflowInspectionText(params) {
+  const textSections = [...params.introLines];
+  if (params.warning) {
+    textSections.push(params.warning);
   }
-  if (sourcePath) {
-    return normalizeWorkflowFileName(path2.basename(sourcePath));
+  textSections.push(
+    `High-signal overrides (${params.highSignalInputs.length}):`,
+    formatEditableInputsText(params.highSignalInputs, {
+      includeOptions: true
+    }),
+    "Editable input groups:",
+    formatEditableInputGroupsText(params.editableInputGroups)
+  );
+  if (params.verbose) {
+    textSections.push(
+      `Editable inputs (${params.editableInputs.length} total):`,
+      formatEditableInputsText(params.editableInputs)
+    );
+  } else if (params.editableInputs.length > params.highSignalInputs.length) {
+    textSections.push(
+      `Pass verbose=true to list all ${params.editableInputs.length} editable inputs.`
+    );
   }
-  return `workflow-${Date.now()}.json`;
-}
-function getWorkflowId(absolutePath) {
-  return crypto.createHash("sha256").update(absolutePath).digest("hex").substring(0, 8);
+  textSections.push(
+    `Copy-ready override keys: ${params.preferredOverridePaths.length > 0 ? params.preferredOverridePaths.join(", ") : "(none)"}`,
+    "Example values (truncated):",
+    formatOverrideExamplesText(params.overrideExamples)
+  );
+  return textSections.join("\n");
 }
-
-// src/workflow/editable.ts
-function isConnectionValue(value) {
-  return Array.isArray(value) && value.length >= 2 && (typeof value[0] === "string" || typeof value[0] === "number") && typeof value[1] === "number";
+function formatEditableInputsText(editableInputs, options = {}) {
+  if (editableInputs.length === 0) {
+    return "No literal editable inputs were detected.";
+  }
+  return formatListItems(editableInputs, (entry) => {
+    const role = entry.role ? ` [${entry.role}]` : "";
+    const classType = entry.class_type ? ` (${entry.class_type})` : "";
+    const expectedType = entry.expected_type ? ` <${entry.expected_type}>` : "";
+    const aliasSuffix = entry.aliases.length > 0 ? ` | aliases: ${entry.aliases.join(", ")}` : "";
+    const optionsSuffix = options.includeOptions ? formatEditableInputOptionsText(entry) : "";
+    return `${entry.path}${role}${classType}${expectedType}: ${entry.value_preview}${aliasSuffix}${optionsSuffix}`;
+  });
 }
-function inferEditableRole(nodeId, classType, inputName, consumerMap) {
-  if (classType === "CLIPTextEncode" && inputName === "text") {
-    const consumers = consumerMap.get(nodeId) ?? [];
-    if (consumers.some((consumer) => consumer.inputName === "positive")) {
-      return "positive_prompt";
+function formatInputDefinitionSummary(inputName, inputDefinition) {
+  const [typeData, extraInfo] = inputDefinition;
+  const typeLabel = Array.isArray(typeData) ? `COMBO (${typeData.length} options)` : String(typeData).toUpperCase();
+  const details = [];
+  if (Array.isArray(typeData)) {
+    details.push(
+      `options: ${typeData.slice(0, 5).map((option) => JSON.stringify(option)).join(", ")}${typeData.length > 5 ? ", ..." : ""}`
+    );
+  }
+  if (isRecord(extraInfo)) {
+    if (extraInfo.default !== void 0) {
+      details.push(`default: ${formatValuePreview(extraInfo.default)}`);
     }
-    if (consumers.some((consumer) => consumer.inputName === "negative")) {
-      return "negative_prompt";
+    if (typeof extraInfo.min === "number") {
+      details.push(`min: ${extraInfo.min}`);
     }
-    return "prompt_text";
-  }
-  if (inputName === "value") {
-    const consumers = consumerMap.get(nodeId) ?? [];
-    const textConsumers = consumers.filter(
-      (consumer) => consumer.classType === "CLIPTextEncode" && consumer.inputName === "text"
-    );
-    if (textConsumers.length > 0) {
-      for (const consumer of textConsumers) {
-        const clipConsumers = consumerMap.get(consumer.nodeId) ?? [];
-        if (clipConsumers.some(
-          (clipConsumer) => clipConsumer.inputName === "positive"
-        )) {
-          return "positive_prompt";
-        }
-        if (clipConsumers.some(
-          (clipConsumer) => clipConsumer.inputName === "negative"
-        )) {
-          return "negative_prompt";
-        }
-      }
-      return "prompt_text";
+    if (typeof extraInfo.max === "number") {
+      details.push(`max: ${extraInfo.max}`);
     }
   }
-  switch (inputName) {
-    case "seed":
-      return "seed";
-    case "steps":
-      return "steps";
-    case "cfg":
-      return "cfg";
-    case "sampler_name":
-      return "sampler";
-    case "scheduler":
-      return "scheduler";
-    case "denoise":
-      return "denoise";
-    case "width":
-      return "width";
-    case "height":
-      return "height";
-    case "batch_size":
-      return "batch_size";
-    case "ckpt_name":
-      return "checkpoint";
-    case "filename_prefix":
-      return "filename_prefix";
-    case "text":
-      return "text";
-    default:
-      return void 0;
-  }
+  return `${inputName} <${typeLabel}>${details.length > 0 ? ` | ${details.join(" | ")}` : ""}`;
 }
-function getEditableAliases(canonicalPath, nodeId, inputName, role, widgetPathMap) {
-  const aliases = /* @__PURE__ */ new Set([`${nodeId}.${inputName}`]);
-  if (role) {
-    aliases.add(`${nodeId}.${role}`);
-  }
-  for (const [widgetPath, resolvedPath] of Object.entries(widgetPathMap)) {
-    if (resolvedPath === canonicalPath) {
-      aliases.add(widgetPath);
-    }
+function formatNodeDefinitionText(nodeClass, node) {
+  const requiredInputs = Object.entries(node.input.required ?? {});
+  const optionalInputs = Object.entries(node.input.optional ?? {});
+  const lines = [
+    `Node: ${nodeClass}`,
+    `Display name: ${node.display_name || node.name || nodeClass}`,
+    `Category: ${node.category || "uncategorized"}`
+  ];
+  if (typeof node.description === "string" && node.description.trim().length > 0) {
+    lines.push(`Description: ${node.description.trim()}`);
   }
-  aliases.delete(canonicalPath);
-  return [...aliases];
+  lines.push(
+    `Required inputs (${requiredInputs.length}): ${requiredInputs.length > 0 ? requiredInputs.map(
+      ([inputName, inputDefinition]) => formatInputDefinitionSummary(
+        inputName,
+        inputDefinition
+      )
+    ).join("\n") : "None."}`
+  );
+  lines.push(
+    `Optional inputs (${optionalInputs.length}): ${optionalInputs.length > 0 ? optionalInputs.map(
+      ([inputName, inputDefinition]) => formatInputDefinitionSummary(
+        inputName,
+        inputDefinition
+      )
+    ).join("\n") : "None."}`
+  );
+  lines.push(`Outputs: ${node.output.join(", ") || "None."}`);
+  return lines.join("\n");
 }
-function buildEditableInputIndex(editableInputs) {
-  const entriesByPath = /* @__PURE__ */ new Map();
-  const aliasToPath = /* @__PURE__ */ new Map();
-  const ambiguousAliases = /* @__PURE__ */ new Map();
-  const pathsByNode = /* @__PURE__ */ new Map();
-  for (const entry of editableInputs) {
-    entriesByPath.set(entry.path, entry);
-    const nodeEntries = pathsByNode.get(entry.node_id) ?? [];
-    nodeEntries.push(entry);
-    pathsByNode.set(entry.node_id, nodeEntries);
-    for (const alias of [entry.path, ...entry.aliases]) {
-      const existing = aliasToPath.get(alias);
-      if (!existing) {
-        aliasToPath.set(alias, entry.path);
-        continue;
-      }
-      if (existing === entry.path) {
-        continue;
-      }
-      const ambiguous = new Set(
-        ambiguousAliases.get(alias) ?? [existing]
-      );
-      ambiguous.add(entry.path);
-      ambiguousAliases.set(alias, [...ambiguous].sort());
-      aliasToPath.delete(alias);
-    }
+function formatNodeListText(classes, rawInfo, pagination) {
+  const text = `Available nodes (${pagination.total} total):
+` + formatListItems(classes, (nodeClass) => {
+    const node = rawInfo[nodeClass];
+    const displayName = node.display_name && node.display_name !== nodeClass ? ` \u2014 ${node.display_name}` : "";
+    const category = node.category ? ` | category: ${node.category}` : "";
+    const description = typeof node.description === "string" && node.description.trim().length > 0 ? ` | ${node.description.trim()}` : "";
+    return `${nodeClass}${displayName}${category}${description}`;
+  });
+  if (!pagination.hasMore) {
+    return text;
   }
-  return {
-    entriesByPath,
-    aliasToPath,
-    ambiguousAliases,
-    pathsByNode
-  };
+  return `${text}
+
+${formatPaginationFooter(
+    pagination.offset,
+    pagination.limit,
+    pagination.total
+  )}`;
 }
-function getPathSegmentHelp(prompt, path4) {
-  const parts = path4.split(".");
-  if (parts.length === 0 || parts[0].length === 0) {
-    return void 0;
-  }
-  const nodeId = parts[0];
-  return {
-    nodeId,
-    nodeExists: isRecord(prompt[nodeId])
-  };
-}
-function describeAvailableNodePaths(editableIndex, nodeId) {
-  if (!editableIndex) {
-    return "";
-  }
-  const entries = editableIndex.pathsByNode.get(nodeId) ?? [];
-  if (entries.length === 0) {
-    return "";
-  }
-  return entries.map((entry) => {
-    const aliasSuffix = entry.aliases.length > 0 ? ` (aliases: ${entry.aliases.join(", ")})` : "";
-    return `${entry.path}${aliasSuffix}`;
-  }).join("\n");
+
+// src/workflow/load.ts
+import * as crypto from "node:crypto";
+import * as fs2 from "node:fs/promises";
+import { homedir } from "node:os";
+import path2 from "node:path";
+
+// src/converter.ts
+var WIDGET_TYPES = /* @__PURE__ */ new Set(["INT", "FLOAT", "STRING", "BOOLEAN"]);
+var UI_CONTROL_VALUES = /* @__PURE__ */ new Set([
+  "fixed",
+  "increment",
+  "decrement",
+  "randomize"
+]);
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
 }
-function getPreferredOverridePath(entry) {
-  const roleAlias = entry.role ? `${entry.node_id}.${entry.role}` : void 0;
-  if (roleAlias && entry.aliases.includes(roleAlias)) {
-    return roleAlias;
-  }
-  const inputAlias = `${entry.node_id}.${entry.input_name}`;
-  if (entry.aliases.includes(inputAlias)) {
-    return inputAlias;
-  }
-  const nonWidgetAlias = entry.aliases.find(
-    (alias) => !alias.includes(".widgets[")
-  );
-  return nonWidgetAlias ?? entry.path;
+function isWebUIFormat(json2) {
+  return isRecord2(json2) && Array.isArray(json2.nodes) && Array.isArray(json2.links);
 }
-function formatEditableInputOptionsText(entry) {
-  if (entry.options_count === void 0 || entry.options_preview === void 0 || entry.options_preview.length === 0) {
-    return "";
-  }
-  const preview = entry.options_preview.map((option) => formatValuePreview(option)).join(", ");
-  const truncatedSuffix = entry.options_truncated ? ", ..." : "";
-  return ` | options: ${preview}${truncatedSuffix} (${entry.options_count} total)`;
+function isLinkData(link) {
+  return Array.isArray(link) && link.length >= 6 && typeof link[0] === "number" && typeof link[1] === "number" && typeof link[2] === "number" && typeof link[3] === "number" && typeof link[4] === "number" && typeof link[5] === "string";
 }
-function getEditableInputGroup(entry) {
-  if (entry.role === "positive_prompt" || entry.role === "negative_prompt" || entry.role === "prompt_text") {
-    return "prompts";
-  }
-  if (entry.role === "checkpoint" || entry.input_name === "ckpt_name" || entry.input_name === "model_name" || entry.input_name === "vae_name" || entry.class_type.includes("Checkpoint") || entry.class_type.includes("VAE")) {
-    return "models";
-  }
-  if (entry.role === "seed" || entry.role === "steps" || entry.role === "cfg" || entry.role === "sampler" || entry.role === "scheduler" || entry.role === "denoise" || entry.class_type.includes("Sampler")) {
-    return "sampling";
-  }
-  if (entry.role === "width" || entry.role === "height" || entry.role === "batch_size") {
-    return "image";
-  }
-  if (entry.input_name === "lora_name" || entry.input_name.startsWith("strength_") || entry.class_type.includes("Lora")) {
-    return "loras";
+function getOrderedInputEntries(group, orderedNames) {
+  if (!group) {
+    return [];
   }
-  if (entry.class_type.includes("ControlNet") || entry.class_type.includes("IPAdapter") || entry.class_type.includes("FreeU") || entry.class_type.includes("FaceDetailer")) {
-    return "control";
+  const seen = /* @__PURE__ */ new Set();
+  const orderedEntries = [];
+  for (const inputName of orderedNames ?? []) {
+    const inputDefinition = group[inputName];
+    if (!inputDefinition) {
+      continue;
+    }
+    orderedEntries.push([inputName, inputDefinition]);
+    seen.add(inputName);
   }
-  if (entry.role === "filename_prefix" || entry.input_name === "filename" || entry.input_name === "path" || entry.input_name === "extension" || entry.class_type.includes("Save") || entry.class_type.includes("PromptSaver")) {
-    return "output";
+  for (const [inputName, inputDefinition] of Object.entries(group)) {
+    if (seen.has(inputName)) {
+      continue;
+    }
+    orderedEntries.push([inputName, inputDefinition]);
   }
-  return "other";
+  return orderedEntries;
 }
-function getEditableInputPriority(entry) {
-  const rolePriority = {
-    positive_prompt: 300,
-    negative_prompt: 295,
-    prompt_text: 290,
-    checkpoint: 260,
-    seed: 250,
-    steps: 240,
-    cfg: 235,
-    sampler: 230,
-    scheduler: 225,
-    width: 220,
-    height: 219,
-    batch_size: 218,
-    denoise: 215,
-    filename_prefix: 190,
-    text: 180
-  };
-  let priority = rolePriority[entry.role ?? ""] ?? 0;
-  if (entry.input_name === "lora_name") {
-    priority = Math.max(priority, 170);
+function getWidgetTypeName(inputTypeData) {
+  return Array.isArray(inputTypeData) ? "COMBO" : String(inputTypeData).toUpperCase();
+}
+function isWidgetInput(inputTypeData) {
+  const typeName = getWidgetTypeName(inputTypeData);
+  return typeName === "COMBO" || WIDGET_TYPES.has(typeName);
+}
+function isSkippableUiArtifact(value, expectedTypeName) {
+  if (expectedTypeName !== "STRING" && typeof value === "string" && UI_CONTROL_VALUES.has(value)) {
+    return true;
   }
-  if (entry.input_name.startsWith("strength_")) {
-    priority = Math.max(priority, 160);
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeWidgetValue(value, typeName, extraInfo) {
+  const defaultValue = extraInfo?.default;
+  const shouldUseDefaultForNumeric = (typeName === "INT" || typeName === "FLOAT") && (value === "" || value === void 0 || value === null);
+  if (shouldUseDefaultForNumeric && defaultValue !== void 0) {
+    return defaultValue;
   }
-  if (entry.class_type.includes("PromptSaver") || entry.class_type === "SaveImage") {
-    priority -= 70;
+  return value;
+}
+function convertWebUIToAPIWithMetadata(webUIJson, objectInfo) {
+  const prompt = {};
+  const widgetPathMap = {};
+  const links = webUIJson.links || [];
+  const nodes = webUIJson.nodes || [];
+  const serverNodeIds = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (!node.id || !node.type || !objectInfo[node.type]) {
+      continue;
+    }
+    serverNodeIds.add(String(node.id));
   }
-  if (entry.class_type === "PrimitiveStringMultiline" && (entry.role === "positive_prompt" || entry.role === "negative_prompt")) {
-    priority += 30;
+  const linkMap = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    if (isLinkData(link) && serverNodeIds.has(String(link[3]))) {
+      linkMap.set(link[0], link);
+    }
   }
-  return priority;
-}
-function getHighSignalEditableInputs(editableInputs, limit = 12) {
-  const seen = /* @__PURE__ */ new Set();
-  const prioritized = [...editableInputs].sort((left, right) => {
-    const priorityDiff = getEditableInputPriority(right) - getEditableInputPriority(left);
-    if (priorityDiff !== 0) {
-      return priorityDiff;
+  for (const node of nodes) {
+    if (!node.id || !node.type) continue;
+    const objInfo = objectInfo[node.type];
+    if (!objInfo) continue;
+    const nodeIdStr = String(node.id);
+    const promptNode = {
+      class_type: node.type,
+      inputs: {}
+    };
+    const connectedInputNames = /* @__PURE__ */ new Set();
+    if (Array.isArray(node.inputs)) {
+      for (const input of node.inputs) {
+        if (input.name && input.link !== null && input.link !== void 0) {
+          const linkData = linkMap.get(input.link);
+          if (Array.isArray(linkData) && linkData.length >= 6 && String(linkData[3]) === nodeIdStr) {
+            const originNodeId = String(linkData[1]);
+            const originSlot = linkData[2];
+            promptNode.inputs[input.name] = [
+              originNodeId,
+              originSlot
+            ];
+            connectedInputNames.add(input.name);
+          }
+        }
+      }
     }
-    return getPreferredOverridePath(left).localeCompare(
-      getPreferredOverridePath(right),
-      void 0,
-      { numeric: true }
-    );
-  }).filter((entry) => {
-    const preferredPath = getPreferredOverridePath(entry);
-    if (seen.has(preferredPath)) {
-      return false;
+    if (objInfo) {
+      const widgets = Array.isArray(node.widgets_values) ? node.widgets_values : [];
+      let widgetIndex = 0;
+      const processInputGroup = (group, orderedNames) => {
+        for (const [inputName, inputDataRaw] of getOrderedInputEntries(
+          group,
+          orderedNames
+        )) {
+          const [inputTypeData, inputExtraInfo] = inputDataRaw;
+          if (!isWidgetInput(inputTypeData)) {
+            continue;
+          }
+          const typeName = getWidgetTypeName(inputTypeData);
+          while (widgetIndex < widgets.length && isSkippableUiArtifact(widgets[widgetIndex], typeName)) {
+            widgetIndex++;
+          }
+          const isConnectedWidget = connectedInputNames.has(inputName);
+          if (widgetIndex >= widgets.length) {
+            if (!isConnectedWidget && inputExtraInfo?.default !== void 0) {
+              promptNode.inputs[inputName] = inputExtraInfo.default;
+            }
+            continue;
+          }
+          const widgetSourceIndex = widgetIndex;
+          const value = normalizeWidgetValue(
+            widgets[widgetSourceIndex],
+            typeName,
+            inputExtraInfo
+          );
+          widgetIndex++;
+          if (!isConnectedWidget) {
+            promptNode.inputs[inputName] = value;
+            widgetPathMap[`${nodeIdStr}.widgets[${widgetSourceIndex}]`] = `${nodeIdStr}.inputs.${inputName}`;
+          }
+        }
+      };
+      processInputGroup(
+        objInfo.input?.required,
+        objInfo.input_order?.required
+      );
+      processInputGroup(
+        objInfo.input?.optional,
+        objInfo.input_order?.optional
+      );
     }
-    seen.add(preferredPath);
-    return true;
-  });
-  return prioritized.slice(0, limit);
-}
-function summarizeEditableInputGroups(editableInputs) {
-  const labels = {
-    prompts: "Prompts",
-    models: "Models and checkpoints",
-    sampling: "Sampling",
-    image: "Image size and batching",
-    loras: "LoRAs and strengths",
-    control: "Conditioning and adapters",
-    output: "Output and persistence",
-    other: "Other"
+    prompt[nodeIdStr] = promptNode;
+  }
+  return {
+    prompt,
+    widgetPathMap
   };
-  const summaries = /* @__PURE__ */ new Map();
-  for (const entry of editableInputs) {
-    const group = getEditableInputGroup(entry);
-    const existing = summaries.get(group) ?? {
-      group,
-      label: labels[group],
-      count: 0,
-      sample_paths: []
-    };
-    existing.count += 1;
-    if (existing.sample_paths.length < 3) {
-      existing.sample_paths.push(getPreferredOverridePath(entry));
+}
+
+// src/workflow/load.ts
+function isComfyPromptNode(value) {
+  return isRecord(value) && typeof value.class_type === "string" && isRecord(value.inputs);
+}
+function isUiOnlyPromptNode(nodeId, node) {
+  return nodeId === "meta" || ["Note", "MarkdownNote", "PrimitiveNode"].includes(node.class_type);
+}
+function extractRunnablePromptNodes(prompt) {
+  const runnablePrompt = {};
+  for (const [nodeId, rawNode] of Object.entries(prompt)) {
+    if (!isComfyPromptNode(rawNode) || isUiOnlyPromptNode(nodeId, rawNode)) {
+      continue;
     }
-    summaries.set(group, existing);
+    runnablePrompt[nodeId] = rawNode;
   }
-  const order = [
-    "prompts",
-    "models",
-    "sampling",
-    "image",
-    "loras",
-    "control",
-    "output",
-    "other"
+  if (Object.keys(runnablePrompt).length === 0) {
+    throw new WorkflowInputError(
+      "Workflow prompt does not contain any runnable ComfyUI nodes.",
+      "workflow"
+    );
+  }
+  return runnablePrompt;
+}
+function getWorkflowDirectories(extraPath) {
+  const directories = [
+    process.cwd(),
+    path2.join(process.cwd(), "workflows"),
+    path2.join(homedir(), ".fre4x-comfyui", "workflows"),
+    path2.join(
+      homedir(),
+      "comfy",
+      "ComfyUI",
+      "user",
+      "default",
+      "workflows"
+    )
+  ];
+  if (extraPath) {
+    directories.push(extraPath);
+  }
+  return [
+    ...new Set(directories.map((directory) => path2.resolve(directory)))
   ];
-  return order.map((group) => summaries.get(group)).filter(
-    (summary) => Boolean(summary)
-  );
 }
-function formatEditableInputGroupsText(groupSummaries) {
-  if (groupSummaries.length === 0) {
-    return "No editable input groups were detected.";
+function getWorkflowNameCandidates(name) {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) {
+    return [];
   }
-  return formatListItems(groupSummaries, (summary) => {
-    const examples = summary.sample_paths.length > 0 ? ` | examples: ${summary.sample_paths.join(", ")}` : "";
-    return `${summary.label}: ${summary.count}${examples}`;
-  });
+  if (trimmed.endsWith(".json")) {
+    return [trimmed];
+  }
+  return [trimmed, `${trimmed}.json`];
 }
-function buildOverrideExamples(editableInputs, limit = 5) {
-  const examples = {};
-  const preferredPaths = [];
-  for (const entry of getHighSignalEditableInputs(editableInputs, limit)) {
-    const preferredPath = getPreferredOverridePath(entry);
-    examples[preferredPath] = entry.value;
-    preferredPaths.push(preferredPath);
+function normalizeWorkflowFileName(fileName) {
+  const trimmed = fileName.trim();
+  if (trimmed.length === 0) {
+    throw new WorkflowInputError(
+      "Filename cannot be empty.",
+      "output_file_name"
+    );
   }
-  return {
-    examples,
-    preferred_paths: preferredPaths
-  };
+  if (path2.isAbsolute(trimmed)) {
+    throw new WorkflowInputError(
+      "Absolute paths are not allowed.",
+      "output_file_name"
+    );
+  }
+  return trimmed.endsWith(".json") ? trimmed : `${trimmed}.json`;
 }
-function formatOverrideExamplesText(examples) {
-  return JSON.stringify(examples, null, 2);
+function getWorkflowReference(args) {
+  const explicitRefs = [
+    args.workflow_ref?.trim(),
+    args.workflow_file_path?.trim(),
+    args.workflow_id?.trim()
+  ].filter((value) => Boolean(value));
+  const uniqueRefs = [...new Set(explicitRefs)];
+  if (uniqueRefs.length > 1) {
+    throw new WorkflowInputError(
+      "Provide only one of workflow_ref, workflow_file_path, or workflow_id.",
+      "workflow_ref"
+    );
+  }
+  if (uniqueRefs.length === 1) {
+    return uniqueRefs[0];
+  }
+  const defaultWorkflow = process.env.COMFYUI_DEFAULT_WORKFLOW?.trim();
+  return defaultWorkflow && defaultWorkflow.length > 0 ? defaultWorkflow : void 0;
 }
-function analyzeEditableInputs(prompt, objectInfo, widgetPathMap = {}) {
-  const consumerMap = /* @__PURE__ */ new Map();
-  for (const [nodeId, node] of Object.entries(prompt)) {
-    for (const [inputName, value] of Object.entries(node.inputs)) {
-      if (!isConnectionValue(value)) {
-        continue;
+async function resolveWorkflowReference(args) {
+  const requested = getWorkflowReference(args);
+  if (!requested) {
+    throw new WorkflowInputError(
+      "Provide workflow_ref, a stored workflow path/id, or set COMFYUI_DEFAULT_WORKFLOW.",
+      "workflow_ref"
+    );
+  }
+  try {
+    const resolvedPath = path2.resolve(requested);
+    const content = await fs2.readFile(resolvedPath, "utf8");
+    return {
+      targetPath: resolvedPath,
+      content
+    };
+  } catch {
+  }
+  if (path2.basename(requested) === requested) {
+    const candidates = getWorkflowNameCandidates(requested);
+    for (const dir of getWorkflowDirectories()) {
+      for (const candidate of candidates) {
+        const candidatePath = path2.join(dir, candidate);
+        try {
+          const content = await fs2.readFile(candidatePath, "utf8");
+          return {
+            targetPath: candidatePath,
+            content
+          };
+        } catch {
+        }
       }
-      const sourceNodeId = String(value[0]);
-      const consumers = consumerMap.get(sourceNodeId) ?? [];
-      consumers.push({
-        inputName,
-        classType: node.class_type,
-        nodeId
-      });
-      consumerMap.set(sourceNodeId, consumers);
     }
   }
-  const editableInputs = [];
-  for (const [nodeId, node] of Object.entries(prompt)) {
-    for (const [inputName, value] of Object.entries(node.inputs)) {
-      if (isConnectionValue(value)) {
-        continue;
+  const objectInfoAvailability = await tryGetObjectInfo();
+  for (const dir of getWorkflowDirectories()) {
+    try {
+      const entries = await fs2.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) {
+          continue;
+        }
+        const fullPath = path2.join(dir, entry.name);
+        const inspected = await inspectWorkflowFile(
+          fullPath,
+          objectInfoAvailability.objectInfo
+        );
+        if (!inspected) {
+          continue;
+        }
+        if (requested === inspected.id || requested === inspected.name || requested === entry.name.replace(/\.json$/, "")) {
+          return {
+            targetPath: fullPath,
+            content: inspected.content
+          };
+        }
       }
-      editableInputs.push({
-        path: `${nodeId}.inputs.${inputName}`,
-        node_id: nodeId,
-        class_type: node.class_type,
-        input_name: inputName,
-        value,
-        value_preview: formatValuePreview(value),
-        role: inferEditableRole(
-          nodeId,
-          node.class_type,
-          inputName,
-          consumerMap
-        ),
-        aliases: [],
-        expected_type: getExpectedTypeName(
-          getInputDefinition(objectInfo, prompt, nodeId, inputName)
-        ),
-        ...getInputOptionsSummary(
-          getInputDefinition(objectInfo, prompt, nodeId, inputName)
-        )
-      });
+    } catch {
     }
   }
-  return editableInputs.map((entry) => ({
-    ...entry,
-    aliases: getEditableAliases(
-      entry.path,
-      entry.node_id,
-      entry.input_name,
-      entry.role,
-      widgetPathMap
-    )
-  })).sort(
-    (left, right) => left.path.localeCompare(right.path, void 0, { numeric: true })
+  throw new WorkflowInputError(
+    path2.isAbsolute(requested) || requested.includes(path2.sep) ? `Workflow file not found: ${requested}` : `Workflow not found: ${requested}`,
+    args.workflow_ref ? "workflow_ref" : args.workflow_file_path ? "workflow_file_path" : "workflow_id",
+    "not_found"
   );
 }
-function formatEditableInputsText(editableInputs, options = {}) {
-  if (editableInputs.length === 0) {
-    return "No literal editable inputs were detected.";
+async function normalizeWorkflowPrompt(workflow, objectInfo) {
+  if (!isRecord(workflow)) {
+    throw new WorkflowInputError(
+      "Workflow must be a JSON object.",
+      "workflow"
+    );
   }
-  return formatListItems(editableInputs, (entry) => {
-    const role = entry.role ? ` [${entry.role}]` : "";
-    const classType = entry.class_type ? ` (${entry.class_type})` : "";
-    const expectedType = entry.expected_type ? ` <${entry.expected_type}>` : "";
-    const aliasSuffix = entry.aliases.length > 0 ? ` | aliases: ${entry.aliases.join(", ")}` : "";
-    const optionsSuffix = options.includeOptions ? formatEditableInputOptionsText(entry) : "";
-    return `${entry.path}${role}${classType}${expectedType}: ${entry.value_preview}${aliasSuffix}${optionsSuffix}`;
-  });
+  let sourceFormat = "api";
+  let widgetPathMap = {};
+  let normalizedWorkflow = workflow;
+  if (isWebUIFormat(normalizedWorkflow)) {
+    if (!objectInfo) {
+      throw new WorkflowInputError(
+        "Web UI workflow normalization requires ComfyUI node definitions. Start the ComfyUI server or save the workflow in API format first.",
+        "workflow"
+      );
+    }
+    sourceFormat = "webui";
+    const converted = convertWebUIToAPIWithMetadata(
+      normalizedWorkflow,
+      objectInfo
+    );
+    normalizedWorkflow = converted.prompt;
+    widgetPathMap = converted.widgetPathMap;
+  }
+  const promptCandidate = isRecord(normalizedWorkflow.prompt) && normalizedWorkflow.prompt ? normalizedWorkflow.prompt : normalizedWorkflow;
+  if (!isRecord(promptCandidate)) {
+    throw new WorkflowInputError(
+      "Workflow prompt must be a JSON object.",
+      "workflow"
+    );
+  }
+  return {
+    prompt: extractRunnablePromptNodes(promptCandidate),
+    sourceFormat,
+    widgetPathMap
+  };
 }
-function formatInputDefinitionSummary(inputName, inputDefinition) {
-  const [typeData, extraInfo] = inputDefinition;
-  const typeLabel = Array.isArray(typeData) ? `COMBO (${typeData.length} options)` : String(typeData).toUpperCase();
-  const details = [];
-  if (Array.isArray(typeData)) {
-    details.push(
-      `options: ${typeData.slice(0, 5).map((option) => JSON.stringify(option)).join(", ")}${typeData.length > 5 ? ", ..." : ""}`
+async function loadWorkflow(args, objectInfo) {
+  const { targetPath, content } = await resolveWorkflowReference(args);
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error48) {
+    throw new WorkflowInputError(
+      `Invalid JSON in ${targetPath}: ${error48 instanceof Error ? error48.message : String(error48)}`,
+      args.workflow_file_path ? "workflow_file_path" : "workflow_id"
     );
   }
-  if (isRecord(extraInfo)) {
-    if (extraInfo.default !== void 0) {
-      details.push(`default: ${formatValuePreview(extraInfo.default)}`);
+  const { prompt, sourceFormat, widgetPathMap } = await normalizeWorkflowPrompt(parsed, objectInfo);
+  return {
+    targetPath,
+    prompt,
+    sourceFormat,
+    widgetPathMap
+  };
+}
+function buildDiscoveredOverrideKeys(prompt, objectInfo, widgetPathMap = {}) {
+  const editableInputs = analyzeEditableInputs(
+    prompt,
+    objectInfo,
+    widgetPathMap
+  );
+  return buildOverrideExamples(editableInputs, 5, { valueMode: "keys" }).preferred_paths;
+}
+async function inspectWorkflowFile(fullPath, objectInfo) {
+  const content = await fs2.readFile(fullPath, "utf8");
+  const defaultName = path2.basename(fullPath, ".json");
+  const defaultId = getWorkflowId(fullPath);
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+  let name = defaultName;
+  if (isRecord(parsed)) {
+    if (typeof parsed.name === "string" && parsed.name.trim().length > 0) {
+      name = parsed.name;
+    } else if (isRecord(parsed.workflow) && typeof parsed.workflow.name === "string" && parsed.workflow.name.trim().length > 0) {
+      name = parsed.workflow.name;
     }
-    if (typeof extraInfo.min === "number") {
-      details.push(`min: ${extraInfo.min}`);
+  }
+  if (isWebUIFormat(parsed)) {
+    if (!objectInfo) {
+      return {
+        id: defaultId,
+        name,
+        path: fullPath,
+        source_format: "webui",
+        validation_status: "conversion_requires_node_schemas",
+        content,
+        isWebUI: true
+      };
     }
-    if (typeof extraInfo.max === "number") {
-      details.push(`max: ${extraInfo.max}`);
+    try {
+      const normalized = await normalizeWorkflowPrompt(
+        parsed,
+        objectInfo
+      );
+      return {
+        id: defaultId,
+        name,
+        path: fullPath,
+        source_format: "webui",
+        validation_status: "conversion_validated",
+        content,
+        isWebUI: true,
+        override_keys: buildDiscoveredOverrideKeys(
+          normalized.prompt,
+          objectInfo,
+          normalized.widgetPathMap
+        )
+      };
+    } catch (error48) {
+      return {
+        id: defaultId,
+        name,
+        path: fullPath,
+        source_format: "webui",
+        validation_status: "conversion_failed",
+        content,
+        error: summarizeErrorMessage(error48),
+        isWebUI: true
+      };
     }
   }
-  return `${inputName} <${typeLabel}>${details.length > 0 ? ` | ${details.join(" | ")}` : ""}`;
-}
-function formatNodeDefinitionText(nodeClass, node) {
-  const requiredInputs = Object.entries(node.input.required ?? {});
-  const optionalInputs = Object.entries(node.input.optional ?? {});
-  const lines = [
-    `Node: ${nodeClass}`,
-    `Display name: ${node.display_name || node.name || nodeClass}`,
-    `Category: ${node.category || "uncategorized"}`
-  ];
-  if (typeof node.description === "string" && node.description.trim().length > 0) {
-    lines.push(`Description: ${node.description.trim()}`);
-  }
-  lines.push(
-    `Required inputs (${requiredInputs.length}): ${requiredInputs.length > 0 ? requiredInputs.map(
-      ([inputName, inputDefinition]) => formatInputDefinitionSummary(
-        inputName,
-        inputDefinition
-      )
-    ).join("\n") : "None."}`
-  );
-  lines.push(
-    `Optional inputs (${optionalInputs.length}): ${optionalInputs.length > 0 ? optionalInputs.map(
-      ([inputName, inputDefinition]) => formatInputDefinitionSummary(
-        inputName,
-        inputDefinition
+  try {
+    const normalized = await normalizeWorkflowPrompt(parsed, objectInfo);
+    return {
+      id: defaultId,
+      name,
+      path: fullPath,
+      source_format: "api",
+      validation_status: "ready",
+      content,
+      isWebUI: false,
+      override_keys: buildDiscoveredOverrideKeys(
+        normalized.prompt,
+        objectInfo,
+        normalized.widgetPathMap
       )
-    ).join("\n") : "None."}`
-  );
-  lines.push(`Outputs: ${node.output.join(", ") || "None."}`);
-  return lines.join("\n");
+    };
+  } catch {
+    return void 0;
+  }
 }
-function formatNodeListText(classes, rawInfo, pagination) {
-  const text = `Available nodes (${pagination.total} total):
-` + formatListItems(classes, (nodeClass) => {
-    const node = rawInfo[nodeClass];
-    const displayName = node.display_name && node.display_name !== nodeClass ? ` \u2014 ${node.display_name}` : "";
-    const category = node.category ? ` | category: ${node.category}` : "";
-    const description = typeof node.description === "string" && node.description.trim().length > 0 ? ` | ${node.description.trim()}` : "";
-    return `${nodeClass}${displayName}${category}${description}`;
-  });
-  if (!pagination.hasMore) {
-    return text;
+function deriveSavedWorkflowFileName(sourcePath, requestedName) {
+  if (requestedName) {
+    return normalizeWorkflowFileName(requestedName);
   }
-  return `${text}
-
-${formatPaginationFooter(
-    pagination.offset,
-    pagination.limit,
-    pagination.total
-  )}`;
+  if (sourcePath) {
+    return normalizeWorkflowFileName(path2.basename(sourcePath));
+  }
+  return `workflow-${Date.now()}.json`;
+}
+function getWorkflowId(absolutePath) {
+  return crypto.createHash("sha256").update(absolutePath).digest("hex").substring(0, 8);
 }
 
 // src/zod.ts
@@ -31909,9 +32377,8 @@ var z3 = zNamespace.z ?? zNamespace.default ?? zNamespace;
 
 // src/workflow/overrides.ts
 var INPUT_SEGMENT = "inputs";
-var OverrideRecordSchema = z3.record(z3.string(), z3.unknown());
-var OverridesSchema = z3.union([OverrideRecordSchema, z3.string()]).describe(
-  'Dot-notation overrides as an object or JSON string. e.g. {"6.seed": 7}'
+var OverridesSchema = z3.record(z3.string(), z3.unknown()).describe(
+  'Small override object only. e.g. {"positive_prompt":"...","seed":7}. Never paste full workflow JSON.'
 );
 function validateOverrideValueType(path4, value, inputDefinition) {
   if (!inputDefinition) {
@@ -32013,25 +32480,7 @@ function parseOverrides(rawOverrides) {
   if (rawOverrides === void 0) {
     return void 0;
   }
-  if (typeof rawOverrides !== "string") {
-    return rawOverrides;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(rawOverrides);
-  } catch (error48) {
-    throw new WorkflowInputError(
-      `Overrides must be a valid JSON object string: ${error48 instanceof Error ? error48.message : String(error48)}`,
-      "overrides"
-    );
-  }
-  if (!isPlainObject3(parsed)) {
-    throw new WorkflowInputError(
-      "Overrides JSON string must decode to an object.",
-      "overrides"
-    );
-  }
-  return parsed;
+  return rawOverrides;
 }
 function validatePromptPreflight(prompt, objectInfo, widgetPathMap = {}) {
   if (!objectInfo) {
@@ -32155,7 +32604,7 @@ ${detailSummary}` : error48.message
       error48.promptId,
       error48.queueSnapshot
     );
-    const promptVisibilityText = promptVisibility === true ? "The prompt is still visible in the ComfyUI queue snapshot." : promptVisibility === false ? "The prompt is not visible in the ComfyUI queue snapshot; inspect ComfyUI history or server logs if it never completes." : "ComfyUI queue state was unavailable at timeout.";
+    const promptVisibilityText = promptVisibility === true ? "The prompt is still visible in the ComfyUI queue snapshot." : promptVisibility === false ? "The prompt is not visible in the ComfyUI queue snapshot; call comfyui_wait_for_workflow again with this prompt_id, or comfyui_interrupt_workflow if the run should stop." : "ComfyUI queue state was unavailable at timeout.";
     return {
       content: [
         {
@@ -32163,8 +32612,7 @@ ${detailSummary}` : error48.message
           text: [
             `${error48.message}.`,
             queueSummary,
-            promptVisibilityText,
-            `You can re-attach by calling 'comfyui_wait_for_workflow' again with prompt_id '${error48.promptId}'.`
+            promptVisibilityText
           ].filter((line) => line && line.length > 0).join("\n")
         }
       ],
@@ -32179,6 +32627,11 @@ ${detailSummary}` : error48.message
   }
   return createInternalError(error48);
 }
+var WorkflowRefFields = {
+  workflow_ref: z3.string().optional().describe("Path, filename, or discover id."),
+  workflow_file_path: z3.string().optional().describe("Deprecated alias of workflow_ref."),
+  workflow_id: z3.string().optional().describe("Deprecated alias of workflow_ref.")
+};
 var InspectNodeSchema = paginationSchema.extend({
   node_class: z3.string().optional().describe(
     "Specific node class to inspect. If omitted, lists all available nodes."
@@ -32191,33 +32644,126 @@ var DiscoverWorkflowsSchema = paginationSchema.extend({
   directory_path: z3.string().optional().describe("Custom directory path to scan for workflows.")
 });
 var WorkflowRunSchema = z3.object({
-  workflow: z3.unknown().optional().describe("Workflow JSON object to execute immediately."),
-  workflow_file_path: z3.string().optional().describe(
-    "Path or filename of workflow JSON. Scans default dirs if simple name provided."
-  ),
-  workflow_id: z3.string().optional().describe("Workflow identifier returned by discover_workflows."),
+  ...WorkflowRefFields,
   overrides: OverridesSchema.optional(),
-  await: z3.boolean().default(true).describe("Wait for completion and return native images."),
-  timeout: z3.number().int().min(1).default(120).describe("Wait timeout in seconds.")
+  await: z3.boolean().default(true).describe(
+    "Wait briefly for images. Prefer short timeout polls if the host cuts long waits."
+  ),
+  timeout: z3.number().int().min(1).default(25).describe(
+    "Wait poll seconds (default 25). Call wait again if timed out."
+  ),
+  max_images: z3.number().int().min(0).max(8).default(2).describe(
+    "Native images to return (0=refs only). Prefer output over temp; extras stay in image_refs."
+  )
 });
 var GetWorkflowSchema = z3.object({
-  workflow_file_path: z3.string().optional().describe("Workflow path or filename to inspect."),
-  workflow_id: z3.string().optional().describe("Workflow identifier returned by discovery."),
-  include_prompt: z3.boolean().default(false).describe("Include normalized API JSON in structuredContent.")
+  ...WorkflowRefFields,
+  include_prompt: z3.boolean().default(false).describe("Include normalized API JSON in structuredContent."),
+  verbose: z3.boolean().default(false).describe("Include every editable input, not just high-signal ones.")
 });
 var SaveWorkflowSchema = z3.object({
-  workflow: z3.unknown().optional().describe("Workflow JSON object to save locally."),
-  workflow_file_path: z3.string().optional().describe("Existing workflow path or filename to save."),
-  workflow_id: z3.string().optional().describe("Existing workflow identifier to save."),
+  ...WorkflowRefFields,
   overrides: OverridesSchema.optional(),
   output_file_name: z3.string().optional().describe("Filename to write locally. (default: anchored to ./)"),
   overwrite: z3.boolean().default(false).describe("Replace an existing local file when true."),
-  include_prompt: z3.boolean().default(false).describe("Include saved API JSON in structuredContent.")
+  include_prompt: z3.boolean().default(false).describe("Include saved API JSON in structuredContent."),
+  verbose: z3.boolean().default(false).describe("Include every editable input, not just high-signal ones.")
 });
 var WaitForWorkflowSchema = z3.object({
   prompt_id: z3.string().describe("The prompt_id of the submitted workflow."),
-  timeout: z3.number().int().min(1).default(120).describe("Wait timeout in seconds.")
+  timeout: z3.number().int().min(1).default(25).describe(
+    "Wait poll seconds (default 25). Call again with the same prompt_id if timed out."
+  ),
+  max_images: z3.number().int().min(0).max(8).default(2).describe(
+    "Native images to return (0=refs only). Prefer output over temp; extras stay in image_refs."
+  )
+});
+var InterruptWorkflowSchema = z3.object({
+  prompt_id: z3.string().optional().describe("Running prompt to interrupt. Omit to stop the current job."),
+  clear_queue: z3.boolean().default(false).describe("Clear pending queue items when true.")
+});
+var UploadImageSchema = z3.object({
+  file_path: z3.string().optional().describe(
+    "Workspace image path. Use when the file is already on disk."
+  ),
+  prompt_id: z3.string().optional().describe(
+    "Previous wait/run prompt_id. Server copies that output into input without image bytes in the model."
+  ),
+  filename: z3.string().optional().describe(
+    "Required with prompt_id (ComfyUI output filename). Optional destination name for file_path."
+  ),
+  subfolder: z3.string().optional().describe("ComfyUI subfolder for a prompt_id source."),
+  source_type: z3.enum(["output", "input", "temp"]).default("output").describe("ComfyUI folder to read when using prompt_id."),
+  image_type: z3.enum(["input", "temp"]).default("input").describe("ComfyUI upload folder type."),
+  overwrite: z3.boolean().default(true).describe("Replace an existing file when true.")
+});
+var ListModelsSchema = paginationSchema.extend({
+  model_type: z3.enum(COMFY_MODEL_TYPES).default("checkpoint").describe("Model folder to list.")
 });
+function hasStoredWorkflowRef(args) {
+  return Boolean(getWorkflowReference(args));
+}
+function collectHistoryImages(outputs) {
+  const images = [];
+  for (const [nodeId, output] of Object.entries(outputs)) {
+    if (!output || !Array.isArray(output.images)) {
+      continue;
+    }
+    for (const image of output.images) {
+      if (!image.filename || !image.type) {
+        continue;
+      }
+      images.push({
+        filename: image.filename,
+        type: image.type,
+        subfolder: image.subfolder ?? "",
+        nodeId
+      });
+    }
+  }
+  return images;
+}
+function rankImageType(type) {
+  if (type === "output") {
+    return 0;
+  }
+  if (type === "temp") {
+    return 1;
+  }
+  return 2;
+}
+function selectImagesForDisplay(images, maxImages) {
+  if (maxImages <= 0) {
+    return [];
+  }
+  return [...images].sort((left, right) => {
+    const typeDiff = rankImageType(left.type) - rankImageType(right.type);
+    if (typeDiff !== 0) {
+      return typeDiff;
+    }
+    return left.nodeId.localeCompare(right.nodeId, void 0, {
+      numeric: true
+    });
+  }).slice(0, maxImages);
+}
+function formatUploadReuseHint(promptId, image) {
+  const parts = [
+    `prompt_id='${promptId}'`,
+    `filename='${image.filename}'`,
+    `source_type='${image.type}'`
+  ];
+  if (image.subfolder) {
+    parts.push(`subfolder='${image.subfolder}'`);
+  }
+  return `Reuse in img2img with comfyui_upload_image: ${parts.join(" ")}`;
+}
+function toPublicEditableInput(entry, verbose) {
+  if (verbose) {
+    return entry;
+  }
+  const { value: _value, ...rest } = entry;
+  return rest;
+}
 async function handleInspectNode(args) {
   try {
     const rawInfo = await getObjectInfo();
@@ -32248,20 +32794,28 @@ async function handleInspectNode(args) {
       });
     }
     const paginated = applyPagination(classes, args);
-    const resultNodes = {};
-    for (const c of paginated.items) {
-      resultNodes[c] = rawInfo[c];
-    }
+    const resultNodes = paginated.items.map(
+      (nodeClass) => {
+        const node = rawInfo[nodeClass];
+        return {
+          class_type: nodeClass,
+          display_name: node?.display_name || nodeClass,
+          category: node?.category || ""
+        };
+      }
+    );
     return {
       content: [
         {
           type: "text",
-          text: formatNodeListText(paginated.items, rawInfo, {
-            total: paginated.total,
-            offset: paginated.offset,
-            limit: paginated.limit,
-            hasMore: paginated.hasMore
-          })
+          text: truncateToLimit(
+            formatNodeListText(paginated.items, rawInfo, {
+              total: paginated.total,
+              offset: paginated.offset,
+              limit: paginated.limit,
+              hasMore: paginated.hasMore
+            })
+          )
         }
       ],
       structuredContent: {
@@ -32331,6 +32885,10 @@ Hint: If your workflows are stored elsewhere, provide a custom path using the 'd
       if (workflow.error) {
         line += ` (Validation error: ${workflow.error})`;
       }
+      const exampleKeys = workflow.override_keys ?? [];
+      if (exampleKeys.length > 0) {
+        line += ` | overrides: ${exampleKeys.join(", ")}`;
+      }
       return line;
     })
   ];
@@ -32361,7 +32919,8 @@ Hint: If your workflows are stored elsewhere, provide a custom path using the 'd
         isWebUI: workflow.isWebUI,
         source_format: workflow.source_format,
         validation_status: workflow.validation_status,
-        ...workflow.error ? { error: workflow.error } : {}
+        ...workflow.error ? { error: workflow.error } : {},
+        ...workflow.override_keys && workflow.override_keys.length > 0 ? { override_keys: workflow.override_keys } : {}
       })),
       skipped_non_workflow_files: skippedNonWorkflowFiles,
       pagination: {
@@ -32380,61 +32939,98 @@ async function handleWaitForWorkflow(args) {
       args.timeout
     );
     const outputsRecord = historyEntry.outputs || {};
+    const collectedImages = collectHistoryImages(outputsRecord);
+    const displayImages = selectImagesForDisplay(
+      collectedImages,
+      args.max_images
+    );
+    const displayKeys = new Set(
+      displayImages.map(
+        (image) => `${image.nodeId}\0${image.type}\0${image.subfolder}\0${image.filename}`
+      )
+    );
+    const orderedImages = [
+      ...displayImages,
+      ...collectedImages.filter(
+        (image) => !displayKeys.has(
+          `${image.nodeId}\0${image.type}\0${image.subfolder}\0${image.filename}`
+        )
+      )
+    ];
     const workspaceOutputs = [];
+    const imageRefs = [];
     const content = [];
-    let summaryText = `Workflow ${args.prompt_id} completed.
-`;
-    for (const [, output] of Object.entries(outputsRecord)) {
-      if (output && Array.isArray(output.images)) {
-        for (const image of output.images) {
-          if (image.filename && image.type) {
-            try {
-              const asset = IS_MOCK ? createMockImageAsset() : await fetchImageAsset(
-                image.filename,
-                image.type,
-                image.subfolder
-              );
-              content.push({
-                type: "image",
-                data: asset.buffer.toString("base64"),
-                mimeType: asset.mimeType
-              });
-              summaryText += `Fetched image: ${image.filename}
-`;
-              const summary = await saveToWorkspace(
-                args.prompt_id,
-                image,
-                asset
-              );
-              if (summary) {
-                workspaceOutputs.push(summary);
-                summaryText += `Copied image to workspace: ${summary.relative_path}
-`;
-              }
-            } catch (e) {
-              summaryText += `Failed to fetch image ${image.filename}: ${String(e)}
-`;
-            }
+    const summaryLines = [
+      `Workflow ${args.prompt_id} completed.`,
+      `Images available: ${collectedImages.length}; returning ${displayImages.length} native image(s) (max_images=${args.max_images}). Prefer output over temp.`
+    ];
+    for (const image of orderedImages) {
+      const imageKey = `${image.nodeId}\0${image.type}\0${image.subfolder}\0${image.filename}`;
+      const shouldFetch = displayKeys.has(imageKey);
+      const imageRef = {
+        prompt_id: args.prompt_id,
+        filename: image.filename,
+        type: image.type,
+        ...image.subfolder ? { subfolder: image.subfolder } : {}
+      };
+      if (shouldFetch) {
+        try {
+          const asset = IS_MOCK ? createMockImageAsset() : await fetchImageAsset(
+            image.filename,
+            image.type,
+            image.subfolder || void 0
+          );
+          content.push({
+            type: "image",
+            data: asset.buffer.toString("base64"),
+            mimeType: asset.mimeType
+          });
+          summaryLines.push(`Fetched image: ${image.filename}`);
+          const summary = await saveToWorkspace(
+            args.prompt_id,
+            {
+              filename: image.filename,
+              subfolder: image.subfolder
+            },
+            asset
+          );
+          if (summary) {
+            workspaceOutputs.push(summary);
+            imageRef.workspace_path = summary.workspace_path;
+            imageRef.relative_path = summary.relative_path;
+            summaryLines.push(
+              `Copied image to workspace: ${summary.relative_path}`
+            );
           }
+        } catch (error48) {
+          summaryLines.push(
+            `Failed to fetch image ${image.filename}: ${String(error48)}`
+          );
         }
       }
+      summaryLines.push(formatUploadReuseHint(args.prompt_id, image));
+      imageRefs.push(imageRef);
     }
-    if (IS_MOCK && outputsRecord) {
+    if (IS_MOCK && collectedImages.length === 0) {
       for (const [, output] of Object.entries(outputsRecord)) {
         if (output && Array.isArray(output.images)) {
           for (const image of output.images) {
-            summaryText += `Mock image: ${image.filename}
-`;
+            summaryLines.push(`Mock image: ${image.filename}`);
           }
         }
       }
     }
-    content.unshift({ type: "text", text: summaryText });
+    content.unshift({ type: "text", text: `${summaryLines.join("\n")}
+` });
     return {
       content,
       structuredContent: {
-        ...historyEntry,
-        workspace_outputs: workspaceOutputs
+        prompt_id: args.prompt_id,
+        status: historyEntry.status,
+        image_refs: imageRefs,
+        workspace_outputs: workspaceOutputs,
+        images_returned: content.filter((item) => item.type === "image").length,
+        images_available: collectedImages.length
       }
     };
   } catch (error48) {
@@ -32455,34 +33051,29 @@ async function handleGetWorkflow(args) {
     );
     const highSignalInputs = getHighSignalEditableInputs(editableInputs);
     const editableInputGroups = summarizeEditableInputGroups(editableInputs);
-    const overrideExamples = buildOverrideExamples(editableInputs);
+    const overrideExamples = buildOverrideExamples(editableInputs, 5, {
+      valueMode: "preview"
+    });
     const workflowId = getWorkflowId(loadedWorkflow.targetPath);
-    const textSections = [
-      `Workflow ${workflowId} loaded from ${loadedWorkflow.targetPath}.`,
-      loadedWorkflow.sourceFormat === "webui" ? "Source format: Web UI (normalized to API format)." : "Source format: API format."
-    ];
-    if (objectInfoAvailability.warning) {
-      textSections.push(objectInfoAvailability.warning);
-    }
-    textSections.push(
-      `High-signal overrides (${highSignalInputs.length}):`,
-      formatEditableInputsText(highSignalInputs, {
-        includeOptions: true
-      }),
-      "Editable input groups:",
-      formatEditableInputGroupsText(editableInputGroups),
-      `Editable inputs (${editableInputs.length} total):`,
-      formatEditableInputsText(editableInputs),
-      "Copy-ready override example:",
-      formatOverrideExamplesText(overrideExamples.examples)
-    );
-    const text = textSections.join("\n");
+    const text = formatWorkflowInspectionText({
+      introLines: [
+        `Workflow ${workflowId} loaded from ${loadedWorkflow.targetPath}.`,
+        loadedWorkflow.sourceFormat === "webui" ? "Source format: Web UI (normalized to API format)." : "Source format: API format."
+      ],
+      warning: objectInfoAvailability.warning,
+      highSignalInputs,
+      editableInputGroups,
+      editableInputs,
+      overrideExamples: overrideExamples.examples,
+      preferredOverridePaths: overrideExamples.preferred_paths,
+      verbose: args.verbose
+    });
+    const publicInputs = (args.verbose ? editableInputs : highSignalInputs).map((entry) => toPublicEditableInput(entry, args.verbose));
     const structuredContent = {
       workflow_id: workflowId,
       path: loadedWorkflow.targetPath,
       source_format: loadedWorkflow.sourceFormat,
-      editable_inputs: editableInputs,
-      high_signal_inputs: highSignalInputs,
+      editable_inputs: publicInputs,
       input_groups: editableInputGroups,
       override_examples: overrideExamples.examples,
       preferred_override_paths: overrideExamples.preferred_paths
@@ -32503,33 +33094,21 @@ async function handleGetWorkflow(args) {
 }
 async function handleSaveWorkflow(args) {
   try {
-    let prompt;
-    let widgetPathMap = {};
-    let sourcePath;
     const parsedOverrides = parseOverrides(args.overrides);
     const objectInfoAvailability = await tryGetObjectInfo();
-    if (args.workflow !== void 0) {
-      const normalized = await normalizeWorkflowPrompt(
-        args.workflow,
-        objectInfoAvailability.objectInfo
-      );
-      prompt = normalized.prompt;
-      widgetPathMap = normalized.widgetPathMap;
-    } else {
-      if (!args.workflow_file_path && !args.workflow_id) {
-        return createValidationError(
-          "workflow",
-          "Provide workflow JSON or an existing workflow reference."
-        );
-      }
-      const loadedWorkflow = await loadWorkflow(
-        args,
-        objectInfoAvailability.objectInfo
+    if (!hasStoredWorkflowRef(args)) {
+      return createValidationError(
+        "workflow_ref",
+        "Provide a stored workflow_ref (path, filename, or discover id)."
       );
-      prompt = loadedWorkflow.prompt;
-      sourcePath = loadedWorkflow.targetPath;
-      widgetPathMap = loadedWorkflow.widgetPathMap;
     }
+    const loadedWorkflow = await loadWorkflow(
+      args,
+      objectInfoAvailability.objectInfo
+    );
+    const prompt = loadedWorkflow.prompt;
+    const sourcePath = loadedWorkflow.targetPath;
+    const widgetPathMap = loadedWorkflow.widgetPathMap;
     const editableInputs = analyzeEditableInputs(
       prompt,
       objectInfoAvailability.objectInfo,
@@ -32584,15 +33163,19 @@ async function handleSaveWorkflow(args) {
     const editableInputGroups = summarizeEditableInputGroups(
       updatedEditableInputs
     );
-    const overrideExamples = buildOverrideExamples(updatedEditableInputs);
+    const overrideExamples = buildOverrideExamples(
+      updatedEditableInputs,
+      5,
+      { valueMode: "preview" }
+    );
     const workflowId = getWorkflowId(outputPath);
+    const publicInputs = (args.verbose ? updatedEditableInputs : highSignalInputs).map((entry) => toPublicEditableInput(entry, args.verbose));
     const structuredContent = {
       workflow_id: workflowId,
       path: outputPath,
       source_path: sourcePath,
       overwritten: existedBeforeSave,
-      editable_inputs: updatedEditableInputs,
-      high_signal_inputs: highSignalInputs,
+      editable_inputs: publicInputs,
       input_groups: editableInputGroups,
       override_examples: overrideExamples.examples,
       preferred_override_paths: overrideExamples.preferred_paths
@@ -32604,26 +33187,19 @@ async function handleSaveWorkflow(args) {
       structuredContent.prompt = prompt;
     }
     const persistedChanges = parsedOverrides && Object.keys(parsedOverrides).length > 0 ? `Persisted ${Object.keys(parsedOverrides).length} override(s).` : "No overrides were applied.";
-    const textSections = [
-      `Saved workflow ${workflowId} to ${outputPath}.`,
-      persistedChanges
-    ];
-    if (objectInfoAvailability.warning) {
-      textSections.push(objectInfoAvailability.warning);
-    }
-    textSections.push(
-      `High-signal overrides (${highSignalInputs.length}):`,
-      formatEditableInputsText(highSignalInputs, {
-        includeOptions: true
-      }),
-      "Editable input groups:",
-      formatEditableInputGroupsText(editableInputGroups),
-      `Editable inputs (${updatedEditableInputs.length} total):`,
-      formatEditableInputsText(updatedEditableInputs),
-      "Copy-ready override example:",
-      formatOverrideExamplesText(overrideExamples.examples)
-    );
-    const text = textSections.join("\n");
+    const text = formatWorkflowInspectionText({
+      introLines: [
+        `Saved workflow ${workflowId} to ${outputPath}.`,
+        persistedChanges
+      ],
+      warning: objectInfoAvailability.warning,
+      highSignalInputs,
+      editableInputGroups,
+      editableInputs: updatedEditableInputs,
+      overrideExamples: overrideExamples.examples,
+      preferredOverridePaths: overrideExamples.preferred_paths,
+      verbose: args.verbose
+    });
     return {
       content: [{ type: "text", text }],
       structuredContent
@@ -32634,30 +33210,14 @@ async function handleSaveWorkflow(args) {
 }
 async function handleWorkflowRun(args) {
   try {
-    let loadedWorkflow;
-    let objectInfo;
-    if (args.workflow !== void 0) {
-      objectInfo = await getObjectInfo();
-      const normalized = await normalizeWorkflowPrompt(
-        args.workflow,
-        objectInfo
+    if (!hasStoredWorkflowRef(args)) {
+      return createValidationError(
+        "workflow_ref",
+        "Provide a stored workflow_ref (path, filename, or discover id), or set COMFYUI_DEFAULT_WORKFLOW."
       );
-      loadedWorkflow = {
-        targetPath: "[inline workflow]",
-        prompt: normalized.prompt,
-        sourceFormat: normalized.sourceFormat,
-        widgetPathMap: normalized.widgetPathMap
-      };
-    } else {
-      if (!args.workflow_file_path && !args.workflow_id) {
-        return createValidationError(
-          "workflow",
-          "Provide workflow JSON or an existing workflow reference."
-        );
-      }
-      objectInfo = await getObjectInfo();
-      loadedWorkflow = await loadWorkflow(args, objectInfo);
     }
+    const objectInfo = await getObjectInfo();
+    const loadedWorkflow = await loadWorkflow(args, objectInfo);
     const { prompt } = loadedWorkflow;
     const promptObj = { ...prompt };
     const parsedOverrides = parseOverrides(args.overrides);
@@ -32700,10 +33260,11 @@ async function handleWorkflowRun(args) {
     if (args.await) {
       return await handleWaitForWorkflow({
         prompt_id: result.prompt_id,
-        timeout: args.timeout
+        timeout: args.timeout,
+        max_images: args.max_images
       });
     }
-    const queueSnapshot = await getQueueSnapshot();
+    const queueSnapshot = summarizeQueue(await getQueueSnapshot());
     return {
       content: [
         {
@@ -32713,7 +33274,7 @@ async function handleWorkflowRun(args) {
             `ComfyUI queue number: ${result.number} (queue number is not an ETA).`,
             `Preflight checked ${preflight.checked_inputs} literal inputs (${preflight.combo_inputs} combo-backed).`,
             formatQueueSnapshotText(queueSnapshot),
-            `To retrieve the final results or check its status later, use the 'comfyui_wait_for_workflow' tool with this prompt_id.`
+            `If host MCP timeouts cut long waits, poll with comfyui_wait_for_workflow (default ~25s) until complete.`
           ].filter((line) => line && line.length > 0).join("\n")
         }
       ],
@@ -32727,6 +33288,107 @@ async function handleWorkflowRun(args) {
     return handleComfyError(error48);
   }
 }
+async function handleInterruptWorkflow(args) {
+  try {
+    const result = await interruptWorkflow({
+      promptId: args.prompt_id,
+      clearQueue: args.clear_queue
+    });
+    const queueSummary = formatQueueSnapshotText(result.queue);
+    const targetText = args.prompt_id ? result.interrupted ? `Interrupted prompt_id '${args.prompt_id}'.` : `Prompt_id '${args.prompt_id}' is not currently running; no interrupt was sent.` : result.interrupted ? "Interrupted the currently running workflow." : "No running workflow was interrupted.";
+    const queueClearedText = result.queue_cleared ? "Pending queue cleared." : "Pending queue was left unchanged.";
+    return {
+      content: [
+        {
+          type: "text",
+          text: [targetText, queueClearedText, queueSummary].filter((line) => line && line.length > 0).join("\n")
+        }
+      ],
+      structuredContent: {
+        interrupted: result.interrupted,
+        prompt_id: result.prompt_id ?? null,
+        queue_cleared: result.queue_cleared,
+        queue: result.queue ?? null
+      }
+    };
+  } catch (error48) {
+    return handleComfyError(error48);
+  }
+}
+async function handleUploadImage(args) {
+  try {
+    const source = await readUploadImageSource({
+      filePath: args.file_path,
+      promptId: args.prompt_id,
+      filename: args.filename,
+      subfolder: args.subfolder,
+      sourceType: args.source_type
+    });
+    const uploaded = await uploadImage({
+      buffer: source.buffer,
+      filename: source.filename,
+      mimeType: source.mimeType,
+      imageType: args.image_type,
+      overwrite: args.overwrite
+    });
+    const loadImageName = uploaded.subfolder ? `${uploaded.subfolder}/${uploaded.name}` : uploaded.name;
+    return {
+      content: [
+        {
+          type: "text",
+          text: [
+            `Uploaded image '${uploaded.name}' to ComfyUI ${uploaded.type}.`,
+            `Use this filename in LoadImage overrides: ${loadImageName}`
+          ].join("\n")
+        }
+      ],
+      structuredContent: {
+        name: uploaded.name,
+        subfolder: uploaded.subfolder,
+        type: uploaded.type,
+        load_image_name: loadImageName
+      }
+    };
+  } catch (error48) {
+    return handleComfyError(error48);
+  }
+}
+async function handleListModels(args) {
+  try {
+    const listedModels = await getModelList(args.model_type);
+    const paginated = applyPagination(listedModels.models, args);
+    const footer = paginated.hasMore ? formatPaginationFooter(
+      paginated.offset,
+      paginated.limit,
+      paginated.total
+    ) : "";
+    const listed = paginated.items.length > 0 ? formatListItems(paginated.items, (model) => model) : "_No models found._";
+    const text = listedModels.models_endpoint_available ? `Available ${args.model_type} models (${paginated.total} total):
+${listed}${footer}` : `Could not list ${args.model_type} models: this ComfyUI server does not expose /models/{folder} (HTTP 404).
+Upgrade ComfyUI, or inspect combo-backed options via comfyui_inspect_node.`;
+    return {
+      content: [
+        {
+          type: "text",
+          text: truncateToLimit(text)
+        }
+      ],
+      structuredContent: {
+        model_type: args.model_type,
+        models: paginated.items,
+        models_endpoint_available: listedModels.models_endpoint_available,
+        pagination: {
+          total: paginated.total,
+          offset: paginated.offset,
+          limit: paginated.limit,
+          has_more: paginated.hasMore
+        }
+      }
+    };
+  } catch (error48) {
+    return handleComfyError(error48);
+  }
+}
 function createServer() {
   const server = new McpServer({
     name: "@fre4x/comfyui",
@@ -32746,7 +33408,7 @@ function createServer() {
   );
   server.tool(
     "comfyui_workflow_run",
-    "Run a workflow from a file path or ID, applying overrides, and optionally returning images.",
+    "Run a stored workflow_ref with small overrides.",
     WorkflowRunSchema.shape,
     handleWorkflowRun
   );
@@ -32758,7 +33420,7 @@ function createServer() {
   );
   server.tool(
     "comfyui_save_workflow",
-    "Save a workflow into ./workflows with optional edits.",
+    "Save a stored workflow_ref with optional overrides.",
     SaveWorkflowSchema.shape,
     handleSaveWorkflow
   );
@@ -32768,6 +33430,35 @@ function createServer() {
     WaitForWorkflowSchema.shape,
     handleWaitForWorkflow
   );
+  server.tool(
+    "comfyui_interrupt_workflow",
+    "Interrupt the running workflow and optionally clear the queue.",
+    InterruptWorkflowSchema.shape,
+    {
+      destructiveHint: true,
+      openWorldHint: true
+    },
+    handleInterruptWorkflow
+  );
+  server.tool(
+    "comfyui_upload_image",
+    "Upload via file_path or previous prompt_id+filename. Image bytes never pass through the model.",
+    UploadImageSchema.shape,
+    {
+      openWorldHint: true
+    },
+    handleUploadImage
+  );
+  server.tool(
+    "comfyui_list_models",
+    "List installed checkpoints, LoRAs, VAEs, and other models.",
+    ListModelsSchema.shape,
+    {
+      readOnlyHint: true,
+      openWorldHint: true
+    },
+    handleListModels
+  );
   return server;
 }
 function isMainModule(url2) {