@fre4x/comfyui 1.0.65 → 1.1.0-beta.2

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,20 @@ 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}'
+);
+var WorkflowTimeoutError = class extends Error {
+  constructor(promptId, timeoutSeconds, queueSnapshot) {
+    super(`Timeout waiting for workflow ${promptId}`);
+    this.promptId = promptId;
+    this.timeoutSeconds = timeoutSeconds;
+    this.queueSnapshot = queueSnapshot;
+    this.name = "WorkflowTimeoutError";
+  }
+};
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
@@ -30961,17 +30981,31 @@ ${detailSummary}` : error48.message
       isError: true
     };
   }
-  const errorMessage = error48 instanceof Error ? error48.message : String(error48);
-  if (errorMessage.includes("Timeout waiting for workflow")) {
+  if (error48 instanceof WorkflowTimeoutError) {
+    const queueSummary = formatQueueSnapshotText(error48.queueSnapshot);
+    const promptVisibility = getPromptQueueVisibility(
+      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.";
     return {
       content: [
         {
           type: "text",
-          text: `${errorMessage}.
-
-The workflow is likely still running on the server. You can re-attach to it and wait for completion by calling 'comfyui_wait_for_workflow' again with the same prompt_id.`
+          text: [
+            `${error48.message}.`,
+            queueSummary,
+            promptVisibilityText,
+            `You can re-attach by calling 'comfyui_wait_for_workflow' again with prompt_id '${error48.promptId}'.`
+          ].filter((line) => line && line.length > 0).join("\n")
         }
       ],
+      structuredContent: {
+        prompt_id: error48.promptId,
+        timeout_seconds: error48.timeoutSeconds,
+        queue: error48.queueSnapshot ?? null,
+        prompt_visible_in_queue: promptVisibility
+      },
       isError: true
     };
   }
@@ -30994,7 +31028,9 @@ function getWorkflowDirectories(extraPath) {
   if (extraPath) {
     directories.push(extraPath);
   }
-  return directories;
+  return [
+    ...new Set(directories.map((directory) => path.resolve(directory)))
+  ];
 }
 function getWorkflowNameCandidates(name) {
   const trimmed = name.trim();
@@ -31022,6 +31058,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;
@@ -31067,6 +31119,7 @@ async function resolveWorkflowReference(args) {
         "workflow_id"
       );
     }
+    const objectInfoAvailability = await tryGetObjectInfo();
     for (const dir of getWorkflowDirectories()) {
       try {
         const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -31075,11 +31128,17 @@ async function resolveWorkflowReference(args) {
             continue;
           }
           const fullPath = path.join(dir, entry.name);
-          const defaultId = getWorkflowId(fullPath);
-          if (requestedId === defaultId || requestedId === entry.name.replace(/\.json$/, "")) {
+          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: await fs.readFile(fullPath, "utf8")
+              content: inspected.content
             };
           }
         }
@@ -31097,7 +31156,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 +31164,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 +31190,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,13 +31205,83 @@ 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
   };
 }
+async function inspectWorkflowFile(fullPath, objectInfo) {
+  const content = await fs.readFile(fullPath, "utf8");
+  const defaultName = path.basename(fullPath, ".json");
+  const defaultId = getWorkflowId(fullPath);
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+  let name = defaultName;
+  if (isRecord2(parsed)) {
+    if (typeof parsed.name === "string" && parsed.name.trim().length > 0) {
+      name = parsed.name;
+    } else if (isRecord2(parsed.workflow) && typeof parsed.workflow.name === "string" && parsed.workflow.name.trim().length > 0) {
+      name = parsed.workflow.name;
+    }
+  }
+  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;
+  }
+}
 function inferEditableRole(nodeId, classType, inputName, consumerMap) {
   if (classType === "CLIPTextEncode" && inputName === "text") {
     const consumers = consumerMap.get(nodeId) ?? [];
@@ -31154,6 +31293,28 @@ function inferEditableRole(nodeId, classType, inputName, consumerMap) {
     }
     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";
+    }
+  }
   switch (inputName) {
     case "seed":
       return "seed";
@@ -31197,7 +31358,428 @@ 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 getInputOptionsSummary(inputDefinition, previewLimit = 8) {
+  if (!inputDefinition) {
+    return void 0;
+  }
+  const [typeData] = inputDefinition;
+  if (!Array.isArray(typeData)) {
+    return void 0;
+  }
+  return {
+    options_count: typeData.length,
+    options_preview: typeData.slice(0, previewLimit),
+    options_truncated: typeData.length > previewLimit
+  };
+}
+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 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 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";
+  }
+  if (entry.class_type.includes("ControlNet") || entry.class_type.includes("IPAdapter") || entry.class_type.includes("FreeU") || entry.class_type.includes("FaceDetailer")) {
+    return "control";
+  }
+  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";
+}
+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);
+  }
+  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;
+    }
+    return getPreferredOverridePath(left).localeCompare(
+      getPreferredOverridePath(right),
+      void 0,
+      { numeric: true }
+    );
+  }).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 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 formatListItems(groupSummaries, (summary) => {
+    const examples = summary.sample_paths.length > 0 ? ` | examples: ${summary.sample_paths.join(", ")}` : "";
+    return `${summary.label}: ${summary.count}${examples}`;
+  });
+}
+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);
+  }
+  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,23 +31814,186 @@ function analyzeEditableInputs(prompt) {
           node.class_type,
           inputName,
           consumerMap
+        ),
+        aliases: [],
+        expected_type: getExpectedTypeName(
+          getInputDefinition(objectInfo, prompt, nodeId, inputName)
+        ),
+        ...getInputOptionsSummary(
+          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 })
   );
 }
-function formatEditableInputsText(editableInputs) {
+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})` : "";
-    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(", ")}` : "";
+    const optionsSuffix = options.includeOptions ? formatEditableInputOptionsText(entry) : "";
+    return `${entry.path}${role}${classType}${expectedType}: ${entry.value_preview}${aliasSuffix}${optionsSuffix}`;
+  });
+}
+function validatePromptPreflight(prompt, objectInfo, widgetPathMap = {}) {
+  if (!objectInfo) {
+    return {
+      checked_inputs: 0,
+      combo_inputs: 0
+    };
+  }
+  const editableInputs = analyzeEditableInputs(
+    prompt,
+    objectInfo,
+    widgetPathMap
+  );
+  const issues = [];
+  let checkedInputs = 0;
+  let comboInputs = 0;
+  for (const entry of editableInputs) {
+    const inputDefinition = getInputDefinition(
+      objectInfo,
+      prompt,
+      entry.node_id,
+      entry.input_name
+    );
+    if (!inputDefinition) {
+      continue;
+    }
+    checkedInputs += 1;
+    if (Array.isArray(inputDefinition[0])) {
+      comboInputs += 1;
+    }
+    try {
+      validateOverrideValueType(entry.path, entry.value, inputDefinition);
+    } catch (error48) {
+      if (!(error48 instanceof WorkflowInputError)) {
+        throw error48;
+      }
+      const preferredPath = getPreferredOverridePath(entry);
+      const comboHint = formatEditableInputOptionsText(entry);
+      const issueMessage = entry.expected_type === "COMBO" && entry.options_count !== void 0 ? `${formatValuePreview(entry.value)} is not in the server-reported options for ${preferredPath}.` : error48.message;
+      issues.push(`- ${preferredPath}: ${issueMessage}${comboHint}`);
+    }
+  }
+  if (issues.length > 0) {
+    throw new WorkflowInputError(
+      `Workflow preflight failed before submission.
+${issues.join("\n")}`,
+      "workflow"
+    );
+  }
+  return {
+    checked_inputs: checkedInputs,
+    combo_inputs: comboInputs
+  };
+}
+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 (isRecord2(extraInfo)) {
+    if (extraInfo.default !== void 0) {
+      details.push(`default: ${formatValuePreview(extraInfo.default)}`);
+    }
+    if (typeof extraInfo.min === "number") {
+      details.push(`min: ${extraInfo.min}`);
+    }
+    if (typeof extraInfo.max === "number") {
+      details.push(`max: ${extraInfo.max}`);
+    }
+  }
+  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
+      )
+    ).join("\n") : "None."}`
+  );
+  lines.push(`Outputs: ${node.output.join(", ") || "None."}`);
+  return lines.join("\n");
+}
+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 `${text}
+
+${formatPaginationFooter(
+    pagination.offset,
+    pagination.limit,
+    pagination.total
+  )}`;
+}
+async function getQueueSnapshot() {
+  try {
+    return IS_MOCK ? MOCK_FIXTURES.queue : await fetchComfyJson("/queue");
+  } catch {
+    return void 0;
+  }
+}
+function formatQueueSnapshotText(queueSnapshot) {
+  if (!queueSnapshot) {
+    return "";
+  }
+  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);
 }
 function deriveSavedWorkflowFileName(sourcePath, requestedName) {
   if (requestedName) {
@@ -31259,21 +32004,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 +32052,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 +32070,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.")
@@ -31329,7 +32091,10 @@ async function handleInspectNode(args) {
       }
       return {
         content: [
-          { type: "text", text: JSON.stringify(node, null, 2) }
+          {
+            type: "text",
+            text: formatNodeDefinitionText(args.node_class, node)
+          }
         ],
         structuredContent: { ...node }
       };
@@ -31348,16 +32113,18 @@ async function handleInspectNode(args) {
     for (const c of paginated.items) {
       resultNodes[c] = rawInfo[c];
     }
-    const text = `Available nodes (${paginated.total} total):
-` + paginated.items.join(", ") + (paginated.hasMore ? `
-
-${formatPaginationFooter(
-      paginated.offset,
-      paginated.limit,
-      paginated.total
-    )}` : "");
     return {
-      content: [{ type: "text", text }],
+      content: [
+        {
+          type: "text",
+          text: formatNodeListText(paginated.items, rawInfo, {
+            total: paginated.total,
+            offset: paginated.offset,
+            limit: paginated.limit,
+            hasMore: paginated.hasMore
+          })
+        }
+      ],
       structuredContent: {
         nodes: resultNodes,
         pagination: {
@@ -31377,42 +32144,27 @@ function getWorkflowId(absolutePath) {
 }
 async function handleDiscoverWorkflows(args) {
   const pathsToScan = getWorkflowDirectories(args.directory_path);
+  const objectInfoAvailability = await tryGetObjectInfo();
   const foundWorkflows = [];
+  let skippedNonWorkflowFiles = 0;
   for (const dir of pathsToScan) {
     try {
       const entries = await fs.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && entry.name.endsWith(".json")) {
           const fullPath = path.join(dir, entry.name);
-          const defaultId = getWorkflowId(fullPath);
-          const defaultName = entry.name.replace(/\.json$/, "");
           try {
-            const content = await fs.readFile(fullPath, "utf8");
-            const json2 = JSON.parse(content);
-            const id = defaultId;
-            let name = defaultName;
-            let isWebUI = false;
-            if (typeof json2 === "object" && json2 !== null) {
-              if (Array.isArray(json2.nodes) && Array.isArray(json2.links)) {
-                isWebUI = true;
-              }
-              if (typeof json2.name === "string") name = json2.name;
-              else if (json2.workflow && typeof json2.workflow.name === "string")
-                name = json2.workflow.name;
+            const inspected = await inspectWorkflowFile(
+              fullPath,
+              objectInfoAvailability.objectInfo
+            );
+            if (inspected) {
+              foundWorkflows.push(inspected);
+            } else {
+              skippedNonWorkflowFiles += 1;
             }
-            foundWorkflows.push({
-              id,
-              name,
-              path: fullPath,
-              isWebUI
-            });
-          } catch (e) {
-            foundWorkflows.push({
-              id: defaultId,
-              name: defaultName,
-              path: fullPath,
-              error: String(e)
-            });
+          } catch {
+            skippedNonWorkflowFiles += 1;
           }
         }
       }
@@ -31420,14 +32172,14 @@ async function handleDiscoverWorkflows(args) {
     }
   }
   if (foundWorkflows.length === 0) {
-    const text2 = `No workflows found in searched directories.
+    const text = `No workflows found in searched directories.
 
 Searched paths:
 ${pathsToScan.map((p) => `- ${p}`).join("\n")}
 
 Hint: If your workflows are stored elsewhere, provide a custom path using the 'directory_path' parameter.`;
     return {
-      content: [{ type: "text", text: text2 }],
+      content: [{ type: "text", text }],
       structuredContent: {
         workflows: [],
         searched_paths: pathsToScan
@@ -31435,23 +32187,47 @@ Hint: If your workflows are stored elsewhere, provide a custom path using the 'd
     };
   }
   const paginated = applyPagination(foundWorkflows, args);
-  const text = `Found ${paginated.total} workflow files:
-` + formatListItems(paginated.items, (w) => {
-    const formatTag = w.isWebUI ? "\u{1F504} Web UI (Auto-converted on run)" : "\u2705 API Format";
-    let line = `[ID: ${w.id}] [${formatTag}] Name: "${w.name}"`;
-    if (w.error) line += ` (Error: ${w.error})`;
-    return line;
-  }) + (paginated.hasMore ? `
-
-${formatPaginationFooter(
-    paginated.offset,
-    paginated.limit,
-    paginated.total
-  )}` : "");
+  const textSections = [
+    `Found ${paginated.total} workflow files:`,
+    formatListItems(paginated.items, (workflow) => {
+      const formatTag = workflow.source_format === "webui" ? workflow.validation_status === "conversion_validated" ? "\u26A0\uFE0F Web UI graph (conversion validated)" : workflow.validation_status === "conversion_requires_node_schemas" ? "\u26A0\uFE0F Web UI graph (needs node schemas to validate)" : "\u274C Web UI graph (conversion failed)" : "\u2705 API workflow";
+      let line = `[ID: ${workflow.id}] [${formatTag}] Name: "${workflow.name}"`;
+      if (workflow.error) {
+        line += ` (Validation error: ${workflow.error})`;
+      }
+      return line;
+    })
+  ];
+  if (skippedNonWorkflowFiles > 0) {
+    textSections.push(
+      `Skipped ${skippedNonWorkflowFiles} non-workflow JSON file(s).`
+    );
+  }
+  if (objectInfoAvailability.warning) {
+    textSections.push(objectInfoAvailability.warning);
+  }
+  if (paginated.hasMore) {
+    textSections.push(
+      formatPaginationFooter(
+        paginated.offset,
+        paginated.limit,
+        paginated.total
+      )
+    );
+  }
   return {
-    content: [{ type: "text", text }],
+    content: [{ type: "text", text: textSections.join("\n\n") }],
     structuredContent: {
-      workflows: paginated.items,
+      workflows: paginated.items.map((workflow) => ({
+        id: workflow.id,
+        name: workflow.name,
+        path: workflow.path,
+        isWebUI: workflow.isWebUI,
+        source_format: workflow.source_format,
+        validation_status: workflow.validation_status,
+        ...workflow.error ? { error: workflow.error } : {}
+      })),
+      skipped_non_workflow_files: skippedNonWorkflowFiles,
       pagination: {
         total: paginated.total,
         offset: paginated.offset,
@@ -31480,7 +32256,8 @@ async function waitForWorkflowResult(prompt_id, timeout_seconds) {
     }
     await new Promise((r) => setTimeout(r, 1e3));
   }
-  throw new Error(`Timeout waiting for workflow ${prompt_id}`);
+  const queueSnapshot = await getQueueSnapshot();
+  throw new WorkflowTimeoutError(prompt_id, timeout_seconds, queueSnapshot);
 }
 async function handleWaitForWorkflow(args) {
   try {
@@ -31552,21 +32329,53 @@ 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 highSignalInputs = getHighSignalEditableInputs(editableInputs);
+    const editableInputGroups = summarizeEditableInputGroups(editableInputs);
+    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.",
-      `Editable inputs (${editableInputs.length}):`,
-      formatEditableInputsText(editableInputs)
-    ].join("\n");
+      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 structuredContent = {
       workflow_id: workflowId,
       path: loadedWorkflow.targetPath,
       source_format: loadedWorkflow.sourceFormat,
-      editable_inputs: editableInputs
+      editable_inputs: editableInputs,
+      high_signal_inputs: highSignalInputs,
+      input_groups: editableInputGroups,
+      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 +32390,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 +32408,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 +32459,57 @@ async function handleSaveWorkflow(args) {
 `,
       "utf8"
     );
-    const editableInputs = analyzeEditableInputs(prompt);
+    const updatedEditableInputs = analyzeEditableInputs(
+      prompt,
+      objectInfoAvailability.objectInfo,
+      widgetPathMap
+    );
+    const highSignalInputs = getHighSignalEditableInputs(
+      updatedEditableInputs
+    );
+    const editableInputGroups = summarizeEditableInputGroups(
+      updatedEditableInputs
+    );
+    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,
+      high_signal_inputs: highSignalInputs,
+      input_groups: editableInputGroups,
+      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(
+      `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");
     return {
       content: [{ type: "text", text }],
       structuredContent
@@ -31659,11 +32520,49 @@ 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 preflight = validatePromptPreflight(
+      promptObj,
+      objectInfo,
+      loadedWorkflow.widgetPathMap
+    );
     const clientId = `mcp-${Date.now()}`;
     const result = IS_MOCK ? MOCK_FIXTURES.prompt_response : await fetchComfyJson("/prompt", {
       method: "POST",
@@ -31690,16 +32589,25 @@ async function handleWorkflowRun(args) {
         timeout: args.timeout
       });
     }
+    const queueSnapshot = await getQueueSnapshot();
     return {
       content: [
         {
           type: "text",
-          text: `Workflow submitted. prompt_id: ${result.prompt_id}, queue: ${result.number}.
-
-To retrieve the final results or check its status later, use the 'comfyui_wait_for_workflow' tool with this prompt_id.`
+          text: [
+            `Workflow submitted. prompt_id: ${result.prompt_id}.`,
+            `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.`
+          ].filter((line) => line && line.length > 0).join("\n")
         }
       ],
-      structuredContent: { ...result }
+      structuredContent: {
+        ...result,
+        preflight,
+        ...queueSnapshot ? { queue: queueSnapshot } : {}
+      }
     };
   } catch (error48) {
     return handleComfyError(error48);