@fre4x/comfyui 1.0.65 → 1.1.0-beta.1

package/README.md

@@ -60,6 +60,9 @@ If you want a single call that submits and waits, pass `await: true` with a
 `timeout` value in seconds to `comfyui_workflow_run`. For lower-level control,
 use `comfyui_wait_for_workflow` with `prompt_id` and `timeout`.
 
+`comfyui_workflow_run` accepts either a stored workflow reference
+(`workflow_id` / `workflow_file_path`) or an inline `workflow` JSON object.
+
 ## Stored Workflow Reuse
 
 The stored-workflow tools let you avoid re-sending large API JSON blobs and give
@@ -71,20 +74,32 @@ agents a stable local edit loop.
 4. Reuse it with `comfyui_workflow_run`
 
 `comfyui_workflow_run` and `comfyui_save_workflow` both accept dot-notation
-overrides in this form:
+overrides in canonical `node.inputs.field` form, plus shorter aliases like
+`node.seed`, `node.text`, `node.positive_prompt`, and, for Web UI workflows,
+`node.widgets[index]`.
 
 ```json
 {
   "workflow_id": "pony-portrait-v1",
   "overrides": {
-    "2.inputs.seed": 67890,
-    "6.inputs.text": "cinematic dragon portrait"
+    "2.seed": 67890,
+    "6.positive_prompt": "cinematic dragon portrait"
   },
   "await": true,
   "timeout": 90
 }
 ```
 
+If your client serializes nested arguments first, `overrides` may also be sent
+as a JSON string:
+
+```json
+{
+  "workflow_id": "pony-portrait-v1",
+  "overrides": "{\"2.seed\":67890,\"6.positive_prompt\":\"cinematic dragon portrait\"}"
+}
+```
+
 To inspect editable inputs and semantic hints for agent editing:
 
 ```json
@@ -94,14 +109,18 @@ To inspect editable inputs and semantic hints for agent editing:
 }
 ```
 
+`comfyui_get_workflow` also returns a copy-ready `override_examples` object in
+both `content.text` and `structuredContent` so agents can paste a valid payload
+without rebuilding the shape by hand.
+
 To save a new or edited workflow locally:
 
 ```json
 {
   "workflow_file_path": "pony-portrait-v1.json",
   "overrides": {
-    "6.inputs.text": "studio lighting, ultra detailed",
-    "7.inputs.filename_prefix": "pony-portrait-agent"
+    "6.text": "studio lighting, ultra detailed",
+    "7.filename_prefix": "pony-portrait-agent"
   },
   "output_file_name": "pony-portrait-agent.json",
   "overwrite": true

package/dist/index.js

@@ -30637,8 +30637,9 @@ function normalizeWidgetValue(value, typeName, extraInfo) {
   }
   return value;
 }
-function convertWebUIToAPI(webUIJson, objectInfo) {
+function convertWebUIToAPIWithMetadata(webUIJson, objectInfo) {
   const prompt = {};
+  const widgetPathMap = {};
   const links = webUIJson.links || [];
   const nodes = webUIJson.nodes || [];
   const serverNodeIds = /* @__PURE__ */ new Set();
@@ -30703,14 +30704,16 @@ function convertWebUIToAPI(webUIJson, objectInfo) {
             }
             continue;
           }
+          const widgetSourceIndex = widgetIndex;
           const value = normalizeWidgetValue(
-            widgets[widgetIndex],
+            widgets[widgetSourceIndex],
             typeName,
             inputExtraInfo
           );
           widgetIndex++;
           if (!isConnectedWidget) {
             promptNode.inputs[inputName] = value;
+            widgetPathMap[`${nodeIdStr}.widgets[${widgetSourceIndex}]`] = `${nodeIdStr}.inputs.${inputName}`;
           }
         }
       };
@@ -30725,7 +30728,10 @@ function convertWebUIToAPI(webUIJson, objectInfo) {
     }
     prompt[nodeIdStr] = promptNode;
   }
-  return prompt;
+  return {
+    prompt,
+    widgetPathMap
+  };
 }
 
 // src/index.ts
@@ -30749,6 +30755,11 @@ var WorkflowInputError = class extends Error {
     this.name = "WorkflowInputError";
   }
 };
+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}'
+);
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
@@ -31022,6 +31033,22 @@ function isConnectionValue(value) {
 async function getObjectInfo() {
   return IS_MOCK ? MOCK_FIXTURES.object_info : await fetchComfyJson("/object_info");
 }
+function summarizeErrorMessage(error48) {
+  return error48 instanceof Error ? error48.message : String(error48);
+}
+async function tryGetObjectInfo() {
+  try {
+    return {
+      objectInfo: await getObjectInfo()
+    };
+  } catch (error48) {
+    return {
+      warning: `Node schema details unavailable from ComfyUI: ${summarizeErrorMessage(
+        error48
+      )}`
+    };
+  }
+}
 async function resolveWorkflowReference(args) {
   if (args.workflow_file_path) {
     const targetPath = args.workflow_file_path;
@@ -31097,7 +31124,7 @@ async function resolveWorkflowReference(args) {
     "workflow_id"
   );
 }
-async function normalizeWorkflowPrompt(workflow) {
+async function normalizeWorkflowPrompt(workflow, objectInfo) {
   if (!isRecord2(workflow)) {
     throw new WorkflowInputError(
       "Workflow must be a JSON object.",
@@ -31105,13 +31132,22 @@ async function normalizeWorkflowPrompt(workflow) {
     );
   }
   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";
-    normalizedWorkflow = convertWebUIToAPI(
+    const converted = convertWebUIToAPIWithMetadata(
       normalizedWorkflow,
-      await getObjectInfo()
+      objectInfo
     );
+    normalizedWorkflow = converted.prompt;
+    widgetPathMap = converted.widgetPathMap;
   }
   const promptCandidate = isRecord2(normalizedWorkflow.prompt) && normalizedWorkflow.prompt ? normalizedWorkflow.prompt : normalizedWorkflow;
   if (!isRecord2(promptCandidate)) {
@@ -31122,10 +31158,11 @@ async function normalizeWorkflowPrompt(workflow) {
   }
   return {
     prompt: extractRunnablePromptNodes(promptCandidate),
-    sourceFormat
+    sourceFormat,
+    widgetPathMap
   };
 }
-async function loadWorkflow(args) {
+async function loadWorkflow(args, objectInfo) {
   const { targetPath, content } = await resolveWorkflowReference(args);
   let parsed;
   try {
@@ -31136,11 +31173,12 @@ async function loadWorkflow(args) {
       args.workflow_file_path ? "workflow_file_path" : "workflow_id"
     );
   }
-  const { prompt, sourceFormat } = await normalizeWorkflowPrompt(parsed);
+  const { prompt, sourceFormat, widgetPathMap } = await normalizeWorkflowPrompt(parsed, objectInfo);
   return {
     targetPath,
     prompt,
-    sourceFormat
+    sourceFormat,
+    widgetPathMap
   };
 }
 function inferEditableRole(nodeId, classType, inputName, consumerMap) {
@@ -31197,7 +31235,278 @@ function formatValuePreview(value) {
     return String(value);
   }
 }
-function analyzeEditableInputs(prompt) {
+function getInputDefinition(objectInfo, prompt, nodeId, inputName) {
+  if (!objectInfo) {
+    return void 0;
+  }
+  const node = prompt[nodeId];
+  if (!node) {
+    return void 0;
+  }
+  const nodeDefinition = objectInfo[node.class_type];
+  if (!nodeDefinition) {
+    return void 0;
+  }
+  return nodeDefinition.input?.required?.[inputName] ?? nodeDefinition.input?.optional?.[inputName];
+}
+function getExpectedTypeName(inputDefinition) {
+  if (!inputDefinition) {
+    return void 0;
+  }
+  const [typeData] = inputDefinition;
+  return Array.isArray(typeData) ? "COMBO" : String(typeData).toUpperCase();
+}
+function isPlainObject3(value) {
+  return isRecord2(value) && !Array.isArray(value);
+}
+function getValueTypeName(value) {
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (value === null) {
+    return "null";
+  }
+  return typeof value;
+}
+function validateOverrideValueType(path2, value, inputDefinition) {
+  if (!inputDefinition) {
+    return;
+  }
+  const [typeData] = inputDefinition;
+  if (Array.isArray(typeData)) {
+    if (!typeData.some((option) => option === value)) {
+      throw new WorkflowInputError(
+        `Invalid override for '${path2}': expected one of ${typeData.map((option) => JSON.stringify(option)).join(", ")}, received ${JSON.stringify(value)}.`,
+        "overrides"
+      );
+    }
+    return;
+  }
+  const typeName = String(typeData).toUpperCase();
+  switch (typeName) {
+    case "INT":
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw new WorkflowInputError(
+          `Invalid override for '${path2}': expected INT, received ${getValueTypeName(
+            value
+          )}.`,
+          "overrides"
+        );
+      }
+      return;
+    case "FLOAT":
+      if (typeof value !== "number") {
+        throw new WorkflowInputError(
+          `Invalid override for '${path2}': expected FLOAT, received ${getValueTypeName(
+            value
+          )}.`,
+          "overrides"
+        );
+      }
+      return;
+    case "STRING":
+      if (typeof value !== "string") {
+        throw new WorkflowInputError(
+          `Invalid override for '${path2}': expected STRING, received ${getValueTypeName(
+            value
+          )}.`,
+          "overrides"
+        );
+      }
+      return;
+    case "BOOLEAN":
+      if (typeof value !== "boolean") {
+        throw new WorkflowInputError(
+          `Invalid override for '${path2}': expected BOOLEAN, received ${getValueTypeName(
+            value
+          )}.`,
+          "overrides"
+        );
+      }
+      return;
+    default:
+      return;
+  }
+}
+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);
+    }
+  }
+  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 (existing === entry.path) {
+        continue;
+      }
+      const ambiguous = new Set(
+        ambiguousAliases.get(alias) ?? [existing]
+      );
+      ambiguous.add(entry.path);
+      ambiguousAliases.set(alias, [...ambiguous].sort());
+      aliasToPath.delete(alias);
+    }
+  }
+  return {
+    entriesByPath,
+    aliasToPath,
+    ambiguousAliases,
+    pathsByNode
+  };
+}
+function getPathSegmentHelp(prompt, path2) {
+  const parts = path2.split(".");
+  if (parts.length === 0 || parts[0].length === 0) {
+    return void 0;
+  }
+  const nodeId = parts[0];
+  return {
+    nodeId,
+    nodeExists: isRecord2(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");
+}
+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 buildOverrideExamples(editableInputs, limit = 5) {
+  const examples = {};
+  const preferredPaths = [];
+  for (const entry of editableInputs.slice(0, limit)) {
+    const preferredPath = getPreferredOverridePath(entry);
+    examples[preferredPath] = entry.value;
+    preferredPaths.push(preferredPath);
+  }
+  return {
+    examples,
+    preferred_paths: preferredPaths
+  };
+}
+function formatOverrideExamplesText(examples) {
+  return JSON.stringify(examples, null, 2);
+}
+function resolveOverridePath(prompt, rawPath, editableIndex) {
+  if (!editableIndex) {
+    return rawPath;
+  }
+  if (editableIndex.entriesByPath.has(rawPath)) {
+    return rawPath;
+  }
+  const ambiguous = editableIndex.ambiguousAliases.get(rawPath);
+  if (ambiguous) {
+    throw new WorkflowInputError(
+      `Ambiguous override path '${rawPath}'. It could refer to: ${ambiguous.join(
+        ", "
+      )}. Use a full '<node>.inputs.<field>' path instead.`,
+      "overrides"
+    );
+  }
+  const resolved = editableIndex.aliasToPath.get(rawPath);
+  if (resolved) {
+    return resolved;
+  }
+  const rawParts = rawPath.split(".");
+  if (rawParts.length >= 3 && rawParts[1] === INPUT_SEGMENT) {
+    const pathHelp2 = getPathSegmentHelp(prompt, rawPath);
+    if (pathHelp2?.nodeId && pathHelp2.nodeExists) {
+      const validPaths = describeAvailableNodePaths(
+        editableIndex,
+        pathHelp2.nodeId
+      );
+      if (validPaths.length > 0) {
+        throw new WorkflowInputError(
+          `Unsupported override path '${rawPath}'. Only detected editable inputs can be overridden. Valid editable paths for node ${pathHelp2.nodeId}:
+${validPaths}`,
+          "overrides"
+        );
+      }
+    }
+  }
+  const pathHelp = getPathSegmentHelp(prompt, rawPath);
+  if (pathHelp?.nodeId && pathHelp.nodeExists) {
+    const validPaths = describeAvailableNodePaths(
+      editableIndex,
+      pathHelp.nodeId
+    );
+    if (validPaths.length > 0) {
+      throw new WorkflowInputError(
+        `Unknown override path '${rawPath}'. Valid editable paths for node ${pathHelp.nodeId}:
+${validPaths}`,
+        "overrides"
+      );
+    }
+  }
+  return rawPath;
+}
+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;
+}
+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)) {
@@ -31232,11 +31541,24 @@ function analyzeEditableInputs(prompt) {
           node.class_type,
           inputName,
           consumerMap
+        ),
+        aliases: [],
+        expected_type: getExpectedTypeName(
+          getInputDefinition(objectInfo, prompt, nodeId, inputName)
         )
       });
     }
   }
-  return editableInputs.sort(
+  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 })
   );
 }
@@ -31247,7 +31569,9 @@ function formatEditableInputsText(editableInputs) {
   return formatListItems(editableInputs, (entry) => {
     const role = entry.role ? ` [${entry.role}]` : "";
     const classType = entry.class_type ? ` (${entry.class_type})` : "";
-    return `${entry.path}${role}${classType}: ${entry.value_preview}`;
+    const expectedType = entry.expected_type ? ` <${entry.expected_type}>` : "";
+    const aliasSuffix = entry.aliases.length > 0 ? ` | aliases: ${entry.aliases.join(", ")}` : "";
+    return `${entry.path}${role}${classType}${expectedType}: ${entry.value_preview}${aliasSuffix}`;
   });
 }
 function deriveSavedWorkflowFileName(sourcePath, requestedName) {
@@ -31259,21 +31583,39 @@ function deriveSavedWorkflowFileName(sourcePath, requestedName) {
   }
   return `workflow-${Date.now()}.json`;
 }
-function applyOverrides(prompt, overrides) {
-  for (const [key, value] of Object.entries(overrides)) {
+function applyOverrides(prompt, overrides, options = {}) {
+  for (const [rawKey, value] of Object.entries(overrides)) {
+    const key = resolveOverridePath(prompt, rawKey, options.editableIndex);
     const parts = key.split(".");
     let current = prompt;
     for (let i = 0; i < parts.length - 1; i++) {
       const part = parts[i];
       const next = current[part];
       if (!isRecord2(next)) {
+        const pathHelp = getPathSegmentHelp(prompt, key);
+        const validPaths = pathHelp?.nodeId && pathHelp.nodeExists ? describeAvailableNodePaths(
+          options.editableIndex,
+          pathHelp.nodeId
+        ) : "";
+        const validPathSuffix = validPaths.length > 0 ? `
+Valid editable paths for node ${pathHelp?.nodeId}:
+${validPaths}` : "";
         throw new WorkflowInputError(
-          `Invalid override path: '${key}'. The segment '${part}' does not exist or is not an object. Please check the editable inputs using 'comfyui_get_workflow' to find the correct path.`,
+          `Invalid override path: '${rawKey}'. The resolved path '${key}' failed at segment '${part}'.${validPathSuffix}`,
           "overrides"
         );
       }
       current = next;
     }
+    if (parts.length === 3 && parts[1] === INPUT_SEGMENT && typeof parts[0] === "string" && typeof parts[2] === "string") {
+      const inputDefinition = getInputDefinition(
+        options.objectInfo,
+        prompt,
+        parts[0],
+        parts[2]
+      );
+      validateOverrideValueType(key, value, inputDefinition);
+    }
     current[parts[parts.length - 1]] = value;
   }
 }
@@ -31289,13 +31631,12 @@ 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."),
-  overrides: z3.record(z3.string(), z3.unknown()).optional().describe(
-    'Key-value pairs to override using dot-notation. e.g. {"6.inputs.text": "dragon"}'
-  ),
+  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.")
 });
@@ -31308,7 +31649,7 @@ 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."),
-  overrides: z3.record(z3.string(), z3.unknown()).optional().describe("Dot-notation overrides to persist before saving."),
+  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.")
@@ -31552,21 +31893,43 @@ async function handleWaitForWorkflow(args) {
 }
 async function handleGetWorkflow(args) {
   try {
-    const loadedWorkflow = await loadWorkflow(args);
-    const editableInputs = analyzeEditableInputs(loadedWorkflow.prompt);
+    const objectInfoAvailability = await tryGetObjectInfo();
+    const loadedWorkflow = await loadWorkflow(
+      args,
+      objectInfoAvailability.objectInfo
+    );
+    const editableInputs = analyzeEditableInputs(
+      loadedWorkflow.prompt,
+      objectInfoAvailability.objectInfo,
+      loadedWorkflow.widgetPathMap
+    );
+    const overrideExamples = buildOverrideExamples(editableInputs);
     const workflowId = getWorkflowId(loadedWorkflow.targetPath);
-    const text = [
+    const textSections = [
       `Workflow ${workflowId} loaded from ${loadedWorkflow.targetPath}.`,
-      loadedWorkflow.sourceFormat === "webui" ? "Source format: Web UI (normalized to API format)." : "Source format: API format.",
+      loadedWorkflow.sourceFormat === "webui" ? "Source format: Web UI (normalized to API format)." : "Source format: API format."
+    ];
+    if (objectInfoAvailability.warning) {
+      textSections.push(objectInfoAvailability.warning);
+    }
+    textSections.push(
       `Editable inputs (${editableInputs.length}):`,
-      formatEditableInputsText(editableInputs)
-    ].join("\n");
+      formatEditableInputsText(editableInputs),
+      "Copy-ready override example:",
+      formatOverrideExamplesText(overrideExamples.examples)
+    );
+    const text = textSections.join("\n");
     const structuredContent = {
       workflow_id: workflowId,
       path: loadedWorkflow.targetPath,
       source_format: loadedWorkflow.sourceFormat,
-      editable_inputs: editableInputs
+      editable_inputs: editableInputs,
+      override_examples: overrideExamples.examples,
+      preferred_override_paths: overrideExamples.preferred_paths
     };
+    if (objectInfoAvailability.warning) {
+      structuredContent.warnings = [objectInfoAvailability.warning];
+    }
     if (args.include_prompt) {
       structuredContent.prompt = loadedWorkflow.prompt;
     }
@@ -31581,10 +31944,17 @@ 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);
+      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(
@@ -31592,12 +31962,25 @@ async function handleSaveWorkflow(args) {
           "Provide workflow JSON or an existing workflow reference."
         );
       }
-      const loadedWorkflow = await loadWorkflow(args);
+      const loadedWorkflow = await loadWorkflow(
+        args,
+        objectInfoAvailability.objectInfo
+      );
       prompt = loadedWorkflow.prompt;
       sourcePath = loadedWorkflow.targetPath;
+      widgetPathMap = loadedWorkflow.widgetPathMap;
     }
-    if (args.overrides) {
-      applyOverrides(prompt, args.overrides);
+    const editableInputs = analyzeEditableInputs(
+      prompt,
+      objectInfoAvailability.objectInfo,
+      widgetPathMap
+    );
+    const editableIndex = buildEditableInputIndex(editableInputs);
+    if (parsedOverrides) {
+      applyOverrides(prompt, parsedOverrides, {
+        editableIndex,
+        objectInfo: objectInfoAvailability.objectInfo
+      });
     }
     const outputFileName = deriveSavedWorkflowFileName(
       sourcePath,
@@ -31630,25 +32013,43 @@ async function handleSaveWorkflow(args) {
 `,
       "utf8"
     );
-    const editableInputs = analyzeEditableInputs(prompt);
+    const updatedEditableInputs = analyzeEditableInputs(
+      prompt,
+      objectInfoAvailability.objectInfo,
+      widgetPathMap
+    );
+    const overrideExamples = buildOverrideExamples(updatedEditableInputs);
     const workflowId = getWorkflowId(outputPath);
     const structuredContent = {
       workflow_id: workflowId,
       path: outputPath,
       source_path: sourcePath,
       overwritten: existedBeforeSave,
-      editable_inputs: editableInputs
+      editable_inputs: updatedEditableInputs,
+      override_examples: overrideExamples.examples,
+      preferred_override_paths: overrideExamples.preferred_paths
     };
+    if (objectInfoAvailability.warning) {
+      structuredContent.warnings = [objectInfoAvailability.warning];
+    }
     if (args.include_prompt) {
       structuredContent.prompt = prompt;
     }
-    const persistedChanges = args.overrides && Object.keys(args.overrides).length > 0 ? `Persisted ${Object.keys(args.overrides).length} override(s).` : "No overrides were applied.";
-    const text = [
+    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,
-      `Editable inputs (${editableInputs.length}):`,
-      formatEditableInputsText(editableInputs)
-    ].join("\n");
+      persistedChanges
+    ];
+    if (objectInfoAvailability.warning) {
+      textSections.push(objectInfoAvailability.warning);
+    }
+    textSections.push(
+      `Editable inputs (${updatedEditableInputs.length}):`,
+      formatEditableInputsText(updatedEditableInputs),
+      "Copy-ready override example:",
+      formatOverrideExamplesText(overrideExamples.examples)
+    );
+    const text = textSections.join("\n");
     return {
       content: [{ type: "text", text }],
       structuredContent
@@ -31659,10 +32060,43 @@ async function handleSaveWorkflow(args) {
 }
 async function handleWorkflowRun(args) {
   try {
-    const { prompt } = await loadWorkflow(args);
+    let loadedWorkflow;
+    let objectInfo;
+    if (args.workflow !== void 0) {
+      objectInfo = await getObjectInfo();
+      const normalized = await normalizeWorkflowPrompt(
+        args.workflow,
+        objectInfo
+      );
+      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 { prompt } = loadedWorkflow;
     const promptObj = { ...prompt };
-    if (args.overrides) {
-      applyOverrides(promptObj, args.overrides);
+    const parsedOverrides = parseOverrides(args.overrides);
+    if (parsedOverrides) {
+      const editableInputs = analyzeEditableInputs(
+        prompt,
+        objectInfo,
+        loadedWorkflow.widgetPathMap
+      );
+      applyOverrides(promptObj, parsedOverrides, {
+        editableIndex: buildEditableInputIndex(editableInputs),
+        objectInfo
+      });
     }
     const clientId = `mcp-${Date.now()}`;
     const result = IS_MOCK ? MOCK_FIXTURES.prompt_response : await fetchComfyJson("/prompt", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fre4x/comfyui",
-  "version": "1.0.65",
+  "version": "1.1.0-beta.1",
   "description": "MCP server for ComfyUI. Execute workflows and probe server state remotely.",
   "type": "module",
   "main": "dist/index.js",