@fre4x/comfyui 1.1.0-beta.1 → 1.1.0-beta.2

package/README.md

@@ -11,6 +11,10 @@ An MCP server to interact with ComfyUI remotely. Probe server state, inspect nod
 - `comfyui_workflow_run`: Run a stored workflow with optional overrides.
 - `comfyui_wait_for_workflow`: Wait for workflow completion with a timeout.
 
+`comfyui_discover_workflows` filters out non-workflow JSON files and distinguishes
+between API workflows and Web UI graphs whose conversion was validated against the
+live node schema.
+
 **Do not assume `structuredContent` is what the model actually sees.** Many MCP clients
 surface `content.text` to the model first and treat `structuredContent` as secondary
 machine-readable metadata. Every actionable detail that an agent needs for its next step
@@ -109,9 +113,24 @@ 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.
+`comfyui_get_workflow` and `comfyui_save_workflow` both return:
+
+- `high_signal_inputs`: the most useful prompt/model/sampler controls first
+- `input_groups`: grouped counts for prompts, models, sampling, output, etc.
+- combo-backed inputs include `options_count`, `options_preview`, and `options_truncated`
+- `override_examples`: copy-ready payloads using the preferred override aliases
+
+These appear in both `content.text` and `structuredContent` so agents can steer
+complex workflows without having to scan every literal widget first.
+
+When `comfyui_wait_for_workflow` times out, the error now includes a queue
+snapshot in both `content.text` and `structuredContent` to show whether the
+prompt is still pending or has disappeared from the server queue.
+
+`comfyui_workflow_run` also performs a preflight pass against the live
+`/object_info` schema before submission so invalid combo-backed values such as
+missing checkpoints, LoRAs, VAEs, or input filenames fail fast without entering
+the ComfyUI queue.
 
 To save a new or edited workflow locally:
 

package/dist/index.js

@@ -30760,6 +30760,15 @@ 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;
 }
@@ -30972,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
     };
   }
@@ -31005,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();
@@ -31094,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 });
@@ -31102,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
             };
           }
         }
@@ -31181,6 +31213,75 @@ async function loadWorkflow(args, objectInfo) {
     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) ?? [];
@@ -31192,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";
@@ -31256,6 +31379,20 @@ function getExpectedTypeName(inputDefinition) {
   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);
 }
@@ -31413,10 +31550,146 @@ function getPreferredOverridePath(entry) {
   );
   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 editableInputs.slice(0, limit)) {
+  for (const entry of getHighSignalEditableInputs(editableInputs, limit)) {
     const preferredPath = getPreferredOverridePath(entry);
     examples[preferredPath] = entry.value;
     preferredPaths.push(preferredPath);
@@ -31545,6 +31818,9 @@ function analyzeEditableInputs(prompt, objectInfo, widgetPathMap = {}) {
         aliases: [],
         expected_type: getExpectedTypeName(
           getInputDefinition(objectInfo, prompt, nodeId, inputName)
+        ),
+        ...getInputOptionsSummary(
+          getInputDefinition(objectInfo, prompt, nodeId, inputName)
         )
       });
     }
@@ -31562,7 +31838,7 @@ function analyzeEditableInputs(prompt, objectInfo, widgetPathMap = {}) {
     (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.";
   }
@@ -31571,9 +31847,154 @@ function formatEditableInputsText(editableInputs) {
     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(", ")}` : "";
-    return `${entry.path}${role}${classType}${expectedType}: ${entry.value_preview}${aliasSuffix}`;
+    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) {
     return normalizeWorkflowFileName(requestedName);
@@ -31670,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 }
       };
@@ -31689,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: {
@@ -31718,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;
           }
         }
       }
@@ -31761,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
@@ -31776,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,
@@ -31821,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 {
@@ -31903,6 +32339,8 @@ async function handleGetWorkflow(args) {
       objectInfoAvailability.objectInfo,
       loadedWorkflow.widgetPathMap
     );
+    const highSignalInputs = getHighSignalEditableInputs(editableInputs);
+    const editableInputGroups = summarizeEditableInputGroups(editableInputs);
     const overrideExamples = buildOverrideExamples(editableInputs);
     const workflowId = getWorkflowId(loadedWorkflow.targetPath);
     const textSections = [
@@ -31913,7 +32351,13 @@ async function handleGetWorkflow(args) {
       textSections.push(objectInfoAvailability.warning);
     }
     textSections.push(
-      `Editable inputs (${editableInputs.length}):`,
+      `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)
@@ -31924,6 +32368,8 @@ async function handleGetWorkflow(args) {
       path: loadedWorkflow.targetPath,
       source_format: loadedWorkflow.sourceFormat,
       editable_inputs: editableInputs,
+      high_signal_inputs: highSignalInputs,
+      input_groups: editableInputGroups,
       override_examples: overrideExamples.examples,
       preferred_override_paths: overrideExamples.preferred_paths
     };
@@ -32018,6 +32464,12 @@ async function handleSaveWorkflow(args) {
       objectInfoAvailability.objectInfo,
       widgetPathMap
     );
+    const highSignalInputs = getHighSignalEditableInputs(
+      updatedEditableInputs
+    );
+    const editableInputGroups = summarizeEditableInputGroups(
+      updatedEditableInputs
+    );
     const overrideExamples = buildOverrideExamples(updatedEditableInputs);
     const workflowId = getWorkflowId(outputPath);
     const structuredContent = {
@@ -32026,6 +32478,8 @@ async function handleSaveWorkflow(args) {
       source_path: sourcePath,
       overwritten: existedBeforeSave,
       editable_inputs: updatedEditableInputs,
+      high_signal_inputs: highSignalInputs,
+      input_groups: editableInputGroups,
       override_examples: overrideExamples.examples,
       preferred_override_paths: overrideExamples.preferred_paths
     };
@@ -32044,7 +32498,13 @@ async function handleSaveWorkflow(args) {
       textSections.push(objectInfoAvailability.warning);
     }
     textSections.push(
-      `Editable inputs (${updatedEditableInputs.length}):`,
+      `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)
@@ -32098,6 +32558,11 @@ async function handleWorkflowRun(args) {
         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",
@@ -32124,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);

package/package.json

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