@fre4x/comfyui 1.0.60 → 1.0.62

package/dist/index.js

@@ -6801,40 +6801,13 @@ var require_dist = __commonJS({
 
 // src/index.ts
 import * as fs from "node:fs/promises";
+import * as crypto from "node:crypto";
 import { realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../packages/shared/dist/errors.js
-function createApiError(message, statusCode) {
-  let hint = "Check your network connection and retry.";
-  let type = "Service Error";
-  if (statusCode === 429) {
-    type = "Rate Limit";
-    hint = "Request volume is too high. Suggestion: Wait briefly before retrying or reduce concurrent calls.";
-  } else if (statusCode === 401 || statusCode === 403) {
-    type = "Authentication Error";
-    hint = "The request could not be authorized. Suggestion: Verify your API key or token in the environment configuration.";
-  } else if (statusCode && statusCode >= 500) {
-    type = "Upstream Error";
-    hint = "The remote service is experiencing temporary issues. Suggestion: Try again in a few minutes.";
-  } else if (statusCode === 404) {
-    type = "Not Found";
-    hint = "The requested information could not be found. Suggestion: Check if the ID, Ticker, or query parameters are correct.";
-  }
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text: `${type}: ${message}
-
-**Next Action**: ${hint}`
-      }
-    ]
-  };
-}
 function createValidationError(field, message) {
   return {
     isError: true,
@@ -6876,6 +6849,20 @@ Suggestion: If the problem persists, check server logs.`
   };
 }
 
+// ../packages/shared/dist/format.js
+function formatListItems(items, renderer, emptyMessage = "_No results found._") {
+  if (items.length === 0)
+    return emptyMessage;
+  return items.map((item, i) => renderer(item, i)).join("\n\n");
+}
+function formatPaginationFooter(offset, limit, total) {
+  const start = offset + 1;
+  const end = Math.min(offset + limit, total);
+  return `
+---
+_Showing ${start}\u2013${end} of ${total}. Use \`offset: ${offset + limit}\` for the next page._`;
+}
+
 // ../node_modules/zod/index.js
 var zod_exports = {};
 __export(zod_exports, {
@@ -30582,801 +30569,237 @@ var MOCK_FIXTURES = {
   }
 };
 
-// src/index.ts
-var zNamespace = zod_exports;
-var z3 = zNamespace.z ?? zNamespace.default ?? zNamespace;
-var COMFYUI_SERVER_URL = process.env.COMFYUI_SERVER_URL || "http://localhost:8188";
-var COMFYUI_WORKFLOWS_DIR = process.env.COMFYUI_WORKFLOWS_DIR || path.join(homedir(), ".fre4x-comfyui", "workflows");
-var PACKAGE_VERSION = getPackageVersion(import.meta.url);
-var BYTES_PER_GIB = 1024 ** 3;
-var PaginationMetadataSchema = z3.object({
-  total_count: z3.number(),
-  limit: z3.number(),
-  offset: z3.number(),
-  has_more: z3.boolean()
-});
-var SystemInfoSchema = z3.object({
-  system: z3.object({
-    os: z3.string(),
-    python_version: z3.string(),
-    embedded_python: z3.boolean()
-  }),
-  devices: z3.array(
-    z3.object({
-      name: z3.string(),
-      type: z3.string(),
-      index: z3.number(),
-      vram_total: z3.number(),
-      vram_free: z3.number()
-    })
-  )
-});
-var ObjectInfoSchema = z3.object({
-  nodes: z3.record(z3.string(), z3.unknown()),
-  pagination: PaginationMetadataSchema.optional()
-});
-var HistoryImageSchema = z3.object({
-  filename: z3.string(),
-  subfolder: z3.string(),
-  type: z3.string(),
-  view_url: z3.string().url()
-});
-var WorkflowResponseSchema = z3.object({
-  prompt_id: z3.string(),
-  number: z3.number(),
-  node_errors: z3.record(z3.string(), z3.unknown()),
-  status: z3.string().optional(),
-  completed: z3.boolean().optional(),
-  timed_out: z3.boolean().optional(),
-  elapsed_seconds: z3.number().optional(),
-  image_count: z3.number().optional(),
-  images: z3.array(HistoryImageSchema).optional(),
-  history_entry: z3.record(z3.string(), z3.unknown()).nullable().optional()
-});
-var HistorySchema = z3.object({
-  history: z3.record(z3.string(), z3.unknown()),
-  pagination: PaginationMetadataSchema.optional()
-});
-var WaitForWorkflowSchema = z3.object({
-  prompt_id: z3.string(),
-  status: z3.string(),
-  completed: z3.boolean(),
-  timed_out: z3.boolean(),
-  elapsed_seconds: z3.number(),
-  image_count: z3.number(),
-  images: z3.array(HistoryImageSchema),
-  history_entry: z3.record(z3.string(), z3.unknown()).nullable()
-});
-var WorkflowTagSchema = z3.string().min(1).max(50);
-var EditableWorkflowValueSchema = z3.union([
-  z3.string(),
-  z3.number(),
-  z3.boolean()
+// src/converter.ts
+var WIDGET_TYPES = /* @__PURE__ */ new Set(["INT", "FLOAT", "STRING", "BOOLEAN"]);
+var UI_CONTROL_VALUES = /* @__PURE__ */ new Set([
+  "fixed",
+  "increment",
+  "decrement",
+  "randomize"
 ]);
-var WorkflowEditableInputSchema = z3.object({
-  node_id: z3.string(),
-  node_class: z3.string(),
-  input_name: z3.string(),
-  value_type: z3.enum(["string", "number", "boolean", "enum"]),
-  current_value: EditableWorkflowValueSchema,
-  options: z3.array(z3.string()).default([])
-});
-var StoredWorkflowMetadataSchema = z3.object({
-  id: z3.string(),
-  name: z3.string(),
-  description: z3.string().optional(),
-  tags: z3.array(WorkflowTagSchema),
-  created_at: z3.string(),
-  updated_at: z3.string(),
-  node_count: z3.number(),
-  editable_input_count: z3.number(),
-  source: z3.enum(["local", "mock"])
-});
-var StoredWorkflowSchema = z3.object({
-  workflow: StoredWorkflowMetadataSchema,
-  prompt: z3.record(z3.string(), z3.unknown()),
-  editable_inputs: z3.array(WorkflowEditableInputSchema)
-});
-var WorkflowListSchema = z3.object({
-  workflows: z3.array(StoredWorkflowMetadataSchema),
-  pagination: PaginationMetadataSchema.optional()
-});
-var WorkflowOverrideSchema = z3.object({
-  node_id: z3.string().min(1).describe("Node ID to override."),
-  input_name: z3.string().min(1).describe("Input field name to override."),
-  value: EditableWorkflowValueSchema.describe("Replacement scalar value.")
-});
-var RunStoredWorkflowSchema = WorkflowResponseSchema.extend({
-  workflow_id: z3.string(),
-  workflow_name: z3.string(),
-  applied_overrides: z3.array(WorkflowOverrideSchema)
-});
-var QueueSchema = z3.object({
-  queue_running: z3.array(z3.unknown()),
-  queue_pending: z3.array(z3.unknown())
-});
-var ViewUrlSchema = z3.object({
-  url: z3.string().url()
-});
-var NoArgsSchema = z3.object({}).strict();
-var ListObjectInfoInputSchema = z3.object({
-  node_class: z3.string().optional().describe(
-    "Specific node class to inspect (for example 'KSampler')."
-  ),
-  limit: z3.number().int().min(1).max(100).default(50).describe("Pagination limit."),
-  offset: z3.number().int().min(0).default(0).describe("Pagination offset.")
-}).strict();
-var ExecuteWorkflowInputSchema = z3.object({
-  prompt: z3.record(z3.string(), z3.unknown()).describe("Workflow in ComfyUI API JSON format."),
-  client_id: z3.string().optional().describe("Optional unique client identifier."),
-  await: z3.boolean().default(false).describe("Wait for completion before returning."),
-  timeout: z3.number().int().min(1).max(600).default(120).describe("Wait timeout in seconds.")
-}).strict();
-var GetHistoryInputSchema = z3.object({
-  prompt_id: z3.string().optional().describe("Specific prompt ID to retrieve. Omit for full history."),
-  limit: z3.number().int().min(1).max(100).default(20).describe("Pagination limit."),
-  offset: z3.number().int().min(0).default(0).describe("Pagination offset.")
-}).strict();
-var GetViewUrlInputSchema = z3.object({
-  filename: z3.string().min(1).describe("Name of the file to view."),
-  subfolder: z3.string().optional().describe("Subfolder within the output directory."),
-  type: z3.enum(["output", "input", "temp"]).default("output").describe("Storage type.")
-}).strict();
-var ListWorkflowsInputSchema = z3.object({
-  limit: z3.number().int().min(1).max(100).default(50).describe("Pagination limit."),
-  offset: z3.number().int().min(0).default(0).describe("Pagination offset.")
-}).strict();
-var SearchWorkflowsInputSchema = z3.object({
-  query: z3.string().min(1).describe("Search text for name, tags, or description."),
-  limit: z3.number().int().min(1).max(100).default(50).describe("Pagination limit."),
-  offset: z3.number().int().min(0).default(0).describe("Pagination offset.")
-}).strict();
-var GetWorkflowInputSchema = z3.object({
-  workflow_id: z3.string().min(1).describe("Stored workflow ID.")
-}).strict();
-var SaveWorkflowInputSchema = z3.object({
-  workflow_id: z3.string().min(1).optional().describe("Optional stable workflow ID."),
-  name: z3.string().min(1).describe("Human-readable workflow name."),
-  description: z3.string().optional().describe("Optional workflow summary."),
-  tags: z3.array(WorkflowTagSchema).default([]).describe("Optional workflow tags."),
-  prompt: z3.record(z3.string(), z3.unknown()).describe("Workflow in ComfyUI API JSON format."),
-  overwrite: z3.boolean().default(false).describe("Overwrite an existing workflow with the same ID.")
-}).strict();
-var RunWorkflowInputSchema = z3.object({
-  workflow_id: z3.string().min(1).describe("Stored workflow ID to execute."),
-  overrides: z3.array(WorkflowOverrideSchema).default([]).describe("Editable input overrides to apply before execution."),
-  client_id: z3.string().optional().describe("Optional unique client identifier."),
-  await: z3.boolean().default(false).describe("Wait for completion before returning."),
-  timeout: z3.number().int().min(1).max(600).default(120).describe("Wait timeout in seconds."),
-  require_images: z3.boolean().default(false).describe("When awaiting, require generated images before return.")
-}).strict();
-var WaitForWorkflowInputSchema = z3.object({
-  prompt_id: z3.string().min(1).describe("Prompt ID to wait for."),
-  timeout_seconds: z3.number().int().min(1).max(600).default(120).describe("Maximum wait time in seconds."),
-  poll_interval_ms: z3.number().int().min(100).max(1e4).default(1e3).describe("Polling interval in milliseconds."),
-  require_images: z3.boolean().default(false).describe("Wait until images are available too.")
-}).strict();
-var ComfyApiError = class extends Error {
-  constructor(message, statusCode, details) {
-    super(message);
-    this.statusCode = statusCode;
-    this.details = details;
-    this.name = "ComfyApiError";
-  }
-};
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function ensureRecord(value, label) {
-  if (!isRecord(value)) {
-    throw new Error(`Invalid ${label} response from ComfyUI.`);
-  }
-  return value;
-}
-function isEditableWorkflowValue(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-function slugifyWorkflowId(value) {
-  const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return slug.length > 0 ? slug : "workflow";
-}
-function getWorkflowFilePath(workflowId) {
-  return path.join(COMFYUI_WORKFLOWS_DIR, `${workflowId}.json`);
+function isWebUIFormat(json2) {
+  return typeof json2 === "object" && json2 !== null && Array.isArray(json2.nodes) && Array.isArray(json2.links);
 }
-async function ensureWorkflowStoreDir() {
-  await fs.mkdir(COMFYUI_WORKFLOWS_DIR, { recursive: true });
+function isLinkData(link) {
+  return Array.isArray(link) && link.length >= 6 && typeof link[0] === "number" && typeof link[1] === "number" && typeof link[2] === "number" && typeof link[3] === "number" && typeof link[4] === "number" && typeof link[5] === "string";
 }
-async function readStoredWorkflowFile(workflowId) {
-  try {
-    const content = await fs.readFile(
-      getWorkflowFilePath(workflowId),
-      "utf8"
-    );
-    return StoredWorkflowSchema.parse(JSON.parse(content));
-  } catch (error48) {
-    if (isRecord(error48) && error48.code === "ENOENT") {
-      return void 0;
-    }
-    throw error48;
+function getOrderedInputEntries(group, orderedNames) {
+  if (!group) {
+    return [];
   }
-}
-async function writeStoredWorkflowFile(workflow) {
-  await ensureWorkflowStoreDir();
-  await fs.writeFile(
-    getWorkflowFilePath(workflow.workflow.id),
-    `${JSON.stringify(workflow, null, 2)}
-`,
-    "utf8"
-  );
-}
-async function listStoredWorkflowFiles() {
-  await ensureWorkflowStoreDir();
-  const entries = await fs.readdir(COMFYUI_WORKFLOWS_DIR, {
-    withFileTypes: true
-  });
-  const workflows = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".json")) {
+  const seen = /* @__PURE__ */ new Set();
+  const orderedEntries = [];
+  for (const inputName of orderedNames ?? []) {
+    const inputDefinition = group[inputName];
+    if (!inputDefinition) {
       continue;
     }
-    const content = await fs.readFile(
-      path.join(COMFYUI_WORKFLOWS_DIR, entry.name),
-      "utf8"
-    );
-    workflows.push(StoredWorkflowSchema.parse(JSON.parse(content)));
-  }
-  workflows.sort(
-    (left, right) => right.workflow.updated_at.localeCompare(left.workflow.updated_at)
-  );
-  return workflows;
-}
-function unwrapNamedNode(nodeClass, value) {
-  if (!isRecord(value)) {
-    return value;
-  }
-  if (nodeClass in value) {
-    return value[nodeClass];
-  }
-  return value;
-}
-function getErrorMessageFromDetails(details) {
-  if (!isRecord(details)) {
-    return void 0;
+    orderedEntries.push([inputName, inputDefinition]);
+    seen.add(inputName);
   }
-  const errorValue = details.error;
-  if (typeof errorValue === "string") {
-    return errorValue;
-  }
-  if (isRecord(errorValue) && typeof errorValue.message === "string") {
-    return errorValue.message;
-  }
-  return void 0;
-}
-function getNodeErrors(details) {
-  if (!isRecord(details) || !isRecord(details.node_errors)) {
-    return void 0;
+  for (const [inputName, inputDefinition] of Object.entries(group)) {
+    if (seen.has(inputName)) {
+      continue;
+    }
+    orderedEntries.push([inputName, inputDefinition]);
   }
-  return details.node_errors;
-}
-function normalizeSystemInfo(source) {
-  const record2 = ensureRecord(source, "system info");
-  const systemRecord = ensureRecord(record2.system, "system info.system");
-  const devicesValue = Array.isArray(record2.devices) ? record2.devices : [];
-  return {
-    system: {
-      os: typeof systemRecord.os === "string" ? systemRecord.os : "unknown",
-      python_version: typeof systemRecord.python_version === "string" ? systemRecord.python_version : "unknown",
-      embedded_python: systemRecord.embedded_python === true
-    },
-    devices: devicesValue.map((device) => {
-      const deviceRecord = ensureRecord(device, "system info.devices[]");
-      return {
-        name: typeof deviceRecord.name === "string" ? deviceRecord.name : "unknown",
-        type: typeof deviceRecord.type === "string" ? deviceRecord.type : "unknown",
-        index: typeof deviceRecord.index === "number" ? deviceRecord.index : -1,
-        vram_total: typeof deviceRecord.vram_total === "number" ? deviceRecord.vram_total : 0,
-        vram_free: typeof deviceRecord.vram_free === "number" ? deviceRecord.vram_free : 0
-      };
-    })
-  };
-}
-function formatGiB(bytes) {
-  return `${(bytes / BYTES_PER_GIB).toFixed(1)} GiB`;
+  return orderedEntries;
 }
-function formatJsonCodeBlock(value) {
-  return `\`\`\`json
-${JSON.stringify(value, null, 2)}
-\`\`\``;
+function getWidgetTypeName(inputTypeData) {
+  return Array.isArray(inputTypeData) ? "COMBO" : String(inputTypeData).toUpperCase();
 }
-function formatMarkdownBulletList(items) {
-  return items.length > 0 ? items.map((item) => `- ${item}`).join("\n") : "- none";
-}
-async function sleep(ms) {
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
-function getEnumLikeOptions(value) {
-  if (!Array.isArray(value) || value.length === 0) {
-    return [];
-  }
-  const firstEntry = value[0];
-  if (!Array.isArray(firstEntry)) {
-    return [];
-  }
-  return firstEntry.filter(
-    (entry) => typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean"
-  );
+function isWidgetInput(inputTypeData) {
+  const typeName = getWidgetTypeName(inputTypeData);
+  return typeName === "COMBO" || WIDGET_TYPES.has(typeName);
 }
-function buildViewUrl(filename, type, subfolder) {
-  const params = new URLSearchParams({
-    filename,
-    type
-  });
-  if (subfolder) {
-    params.set("subfolder", subfolder);
+function isSkippableUiArtifact(value, expectedTypeName) {
+  if (expectedTypeName !== "STRING" && typeof value === "string" && UI_CONTROL_VALUES.has(value)) {
+    return true;
   }
-  return new URL(`/view?${params.toString()}`, COMFYUI_SERVER_URL).toString();
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function fetchNodeDefinition(nodeClass) {
-  if (IS_MOCK) {
-    return MOCK_FIXTURES.object_info[nodeClass];
-  }
-  try {
-    const rawInfo = await fetchComfyJson(
-      `/object_info/${encodeURIComponent(nodeClass)}`
-    );
-    return unwrapNamedNode(nodeClass, rawInfo);
-  } catch (error48) {
-    if (error48 instanceof ComfyApiError && error48.statusCode === 404) {
-      return void 0;
-    }
-    throw error48;
+function normalizeWidgetValue(value, typeName, extraInfo) {
+  const defaultValue = extraInfo?.default;
+  const shouldUseDefaultForNumeric = (typeName === "INT" || typeName === "FLOAT") && (value === "" || value === void 0 || value === null);
+  if (shouldUseDefaultForNumeric && defaultValue !== void 0) {
+    return defaultValue;
   }
+  return value;
 }
-async function deriveEditableWorkflowInputs(prompt) {
-  const nodeDefinitions = /* @__PURE__ */ new Map();
-  const editableInputs = [];
-  for (const [nodeId, nodeValue] of Object.entries(prompt)) {
-    if (!isRecord(nodeValue)) {
-      continue;
-    }
-    const nodeClass = typeof nodeValue.class_type === "string" ? nodeValue.class_type : void 0;
-    const inputs = isRecord(nodeValue.inputs) ? nodeValue.inputs : void 0;
-    if (!nodeClass || !inputs) {
-      continue;
-    }
-    if (!nodeDefinitions.has(nodeClass)) {
-      nodeDefinitions.set(
-        nodeClass,
-        await fetchNodeDefinition(nodeClass)
-      );
-    }
-    const nodeDefinition = nodeDefinitions.get(nodeClass);
-    const nodeInputRecord = isRecord(nodeDefinition) && isRecord(nodeDefinition.input) ? nodeDefinition.input : void 0;
-    const requiredInputs = isRecord(nodeInputRecord?.required) ? nodeInputRecord.required : void 0;
-    const optionalInputs = isRecord(nodeInputRecord?.optional) ? nodeInputRecord.optional : void 0;
-    for (const [inputName, inputValue] of Object.entries(inputs)) {
-      if (!isEditableWorkflowValue(inputValue)) {
-        continue;
+function convertWebUIToAPI(webUIJson, objectInfo) {
+  const prompt = {};
+  const links = webUIJson.links || [];
+  const nodes = webUIJson.nodes || [];
+  const linkMap = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    if (isLinkData(link)) {
+      linkMap.set(link[0], link);
+    }
+  }
+  for (const node of nodes) {
+    if (!node.id || !node.type) continue;
+    const objInfo = objectInfo[node.type];
+    if (!objInfo) continue;
+    const nodeIdStr = String(node.id);
+    const promptNode = {
+      class_type: node.type,
+      inputs: {}
+    };
+    const connectedInputNames = /* @__PURE__ */ new Set();
+    if (Array.isArray(node.inputs)) {
+      for (const input of node.inputs) {
+        if (input.name && input.link !== null && input.link !== void 0) {
+          const linkData = linkMap.get(input.link);
+          if (Array.isArray(linkData) && linkData.length >= 6) {
+            const originNodeId = String(linkData[1]);
+            const originSlot = linkData[2];
+            promptNode.inputs[input.name] = [
+              originNodeId,
+              originSlot
+            ];
+            connectedInputNames.add(input.name);
+          }
+        }
       }
-      const definition = requiredInputs?.[inputName] ?? optionalInputs?.[inputName];
-      const options = getEnumLikeOptions(definition).map(String);
-      const valueType = typeof inputValue === "boolean" ? "boolean" : typeof inputValue === "number" ? "number" : options.length > 0 ? "enum" : "string";
-      editableInputs.push({
-        node_id: nodeId,
-        node_class: nodeClass,
-        input_name: inputName,
-        value_type: valueType,
-        current_value: inputValue,
-        options
-      });
     }
-  }
-  return editableInputs;
-}
-function cloneWorkflowPrompt(prompt) {
-  return JSON.parse(JSON.stringify(prompt));
-}
-function applyWorkflowOverrides(prompt, editableInputs, overrides) {
-  const nextPrompt = cloneWorkflowPrompt(prompt);
-  const editableKeys = new Set(
-    editableInputs.map((input) => `${input.node_id}.${input.input_name}`)
-  );
-  for (const override of overrides) {
-    const key = `${override.node_id}.${override.input_name}`;
-    if (!editableKeys.has(key)) {
-      throw new Error(
-        `Override ${key} is not editable for this stored workflow.`
+    if (objInfo) {
+      const widgets = Array.isArray(node.widgets_values) ? node.widgets_values : [];
+      let widgetIndex = 0;
+      const processInputGroup = (group, orderedNames) => {
+        for (const [inputName, inputDataRaw] of getOrderedInputEntries(
+          group,
+          orderedNames
+        )) {
+          const [inputTypeData, inputExtraInfo] = inputDataRaw;
+          if (!isWidgetInput(inputTypeData)) {
+            continue;
+          }
+          const typeName = getWidgetTypeName(inputTypeData);
+          while (widgetIndex < widgets.length && isSkippableUiArtifact(widgets[widgetIndex], typeName)) {
+            widgetIndex++;
+          }
+          const isConnectedWidget = connectedInputNames.has(inputName);
+          if (widgetIndex >= widgets.length) {
+            if (!isConnectedWidget && inputExtraInfo?.default !== void 0) {
+              promptNode.inputs[inputName] = inputExtraInfo.default;
+            }
+            continue;
+          }
+          const value = normalizeWidgetValue(
+            widgets[widgetIndex],
+            typeName,
+            inputExtraInfo
+          );
+          widgetIndex++;
+          if (!isConnectedWidget) {
+            promptNode.inputs[inputName] = value;
+          }
+        }
+      };
+      processInputGroup(
+        objInfo.input?.required,
+        objInfo.input_order?.required
       );
-    }
-    const node = nextPrompt[override.node_id];
-    if (!isRecord(node) || !isRecord(node.inputs)) {
-      throw new Error(
-        `Stored workflow node ${override.node_id} is invalid.`
+      processInputGroup(
+        objInfo.input?.optional,
+        objInfo.input_order?.optional
       );
     }
-    node.inputs[override.input_name] = override.value;
+    prompt[nodeIdStr] = promptNode;
   }
-  return nextPrompt;
+  return prompt;
 }
-function summarizeOptionLines(inputSection) {
-  if (!inputSection) {
-    return [];
+
+// src/index.ts
+var zNamespace = zod_exports;
+var z3 = zNamespace.z ?? zNamespace.default ?? zNamespace;
+var COMFYUI_SERVER_URL = process.env.COMFYUI_SERVER_URL || "http://localhost:8188";
+var PACKAGE_VERSION = getPackageVersion(import.meta.url);
+var ComfyApiError = class extends Error {
+  constructor(message, statusCode, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "ComfyApiError";
   }
-  return Object.entries(inputSection).flatMap(([inputName, definition]) => {
-    const options = getEnumLikeOptions(definition);
-    if (options.length === 0) {
-      return [];
-    }
-    return [`${inputName}: ${options.map(String).join(", ")}`];
-  });
-}
-function summarizeSystemInfoText(structuredContent) {
-  const deviceSummary = formatMarkdownBulletList(
-    structuredContent.devices.map(
-      (device) => `[${device.index}] ${device.name} (${device.type}, ${formatGiB(device.vram_free)} free / ${formatGiB(device.vram_total)} total VRAM)`
-    )
-  );
-  return [
-    "# ComfyUI System Info",
-    "",
-    `ComfyUI server is running on ${structuredContent.system.os} with ${structuredContent.devices.length} device(s).`,
-    "",
-    "## Summary",
-    formatMarkdownBulletList([
-      `OS: ${structuredContent.system.os}`,
-      `Python: ${structuredContent.system.python_version}`,
-      `Embedded Python: ${structuredContent.system.embedded_python ? "yes" : "no"}`,
-      `Devices: ${structuredContent.devices.length}`
-    ]),
-    "",
-    "## Devices",
-    deviceSummary,
-    "",
-    "## JSON",
-    formatJsonCodeBlock(structuredContent)
-  ].join("\n");
-}
-function summarizeNodeDefinitionText(nodeClass, nodeDefinition) {
-  if (!isRecord(nodeDefinition)) {
-    return `Schema retrieved for node: ${nodeClass}`;
-  }
-  const inputRecord = isRecord(nodeDefinition.input) ? nodeDefinition.input : void 0;
-  const requiredInputs = isRecord(inputRecord?.required) ? inputRecord.required : void 0;
-  const optionalInputs = isRecord(inputRecord?.optional) ? inputRecord.optional : void 0;
-  const outputNames = Array.isArray(nodeDefinition.output) ? nodeDefinition.output.filter(
-    (output) => typeof output === "string"
-  ) : [];
-  const optionLines = [
-    ...summarizeOptionLines(requiredInputs),
-    ...summarizeOptionLines(optionalInputs)
-  ];
-  return [
-    "# ComfyUI Node Definition",
-    "",
-    `Schema retrieved for node: ${nodeClass}`,
-    "",
-    "## Summary",
-    formatMarkdownBulletList([
-      `Node Class: ${nodeClass}`,
-      `Display Name: ${typeof nodeDefinition.display_name === "string" ? nodeDefinition.display_name : typeof nodeDefinition.name === "string" ? nodeDefinition.name : nodeClass}`,
-      `Category: ${typeof nodeDefinition.category === "string" ? nodeDefinition.category : "unknown"}`,
-      `Required Inputs: ${requiredInputs ? Object.keys(requiredInputs).join(", ") || "none" : "none"}`,
-      `Optional Inputs: ${optionalInputs ? Object.keys(optionalInputs).join(", ") || "none" : "none"}`,
-      `Outputs: ${outputNames.join(", ") || "none"}`
-    ]),
-    "",
-    optionLines.length > 0 ? `## Enumerated Options
-${optionLines.map((line) => `- ${line}`).join("\n")}
-` : "",
-    "## JSON",
-    formatJsonCodeBlock({
-      nodes: { [nodeClass]: nodeDefinition }
-    }),
-    ""
-  ].filter(Boolean).join("\n");
-}
-function summarizeHistoryEntryText(promptId, entry) {
-  if (!isRecord(entry)) {
-    return `History retrieved for job: ${promptId}`;
-  }
-  const statusRecord = isRecord(entry.status) ? entry.status : void 0;
-  const outputsRecord = isRecord(entry.outputs) ? entry.outputs : void 0;
-  const imageRefs = [];
-  if (outputsRecord) {
-    for (const output of Object.values(outputsRecord)) {
-      if (!isRecord(output) || !Array.isArray(output.images)) {
-        continue;
-      }
-      for (const image of output.images) {
-        if (!isRecord(image) || typeof image.filename !== "string") {
-          continue;
-        }
-        const subfolder = typeof image.subfolder === "string" && image.subfolder ? `${image.subfolder}/` : "";
-        imageRefs.push(`${subfolder}${image.filename}`);
-      }
-    }
-  }
-  return [
-    "# ComfyUI History Entry",
-    "",
-    `History retrieved for job: ${promptId}`,
-    "",
-    "## Summary",
-    formatMarkdownBulletList([
-      `Prompt ID: ${promptId}`,
-      `Status: ${typeof statusRecord?.status_str === "string" ? statusRecord.status_str : "unknown"}`,
-      `Completed: ${statusRecord?.completed === true ? "yes" : statusRecord?.completed === false ? "no" : "unknown"}`,
-      `Images: ${imageRefs.length}`
-    ]),
-    "",
-    "## Images",
-    formatMarkdownBulletList(imageRefs),
-    "",
-    "## JSON",
-    formatJsonCodeBlock({
-      history: { [promptId]: entry }
-    })
-  ].join("\n");
+};
+var WorkflowInputError = class extends Error {
+  constructor(message, field, kind = "validation") {
+    super(message);
+    this.field = field;
+    this.kind = kind;
+    this.name = "WorkflowInputError";
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
 }
-function extractHistoryImages(entry) {
-  if (!isRecord(entry) || !isRecord(entry.outputs)) {
+function summarizeNodeErrors(nodeErrors) {
+  if (!isRecord(nodeErrors)) {
     return [];
   }
-  const images = [];
-  for (const output of Object.values(entry.outputs)) {
-    if (!isRecord(output) || !Array.isArray(output.images)) {
+  const lines = [];
+  for (const [nodeId, rawNodeError] of Object.entries(nodeErrors)) {
+    if (!isRecord(rawNodeError)) {
       continue;
     }
-    for (const image of output.images) {
-      if (!isRecord(image) || typeof image.filename !== "string" || typeof image.type !== "string") {
+    const classType = typeof rawNodeError.class_type === "string" ? ` (${rawNodeError.class_type})` : "";
+    const rawErrors = Array.isArray(rawNodeError.errors) ? rawNodeError.errors : [];
+    const missingInputs = [];
+    const otherMessages = [];
+    for (const rawError of rawErrors) {
+      if (!isRecord(rawError)) {
         continue;
       }
-      const subfolder = typeof image.subfolder === "string" ? image.subfolder : "";
-      images.push({
-        filename: image.filename,
-        subfolder,
-        type: image.type,
-        view_url: buildViewUrl(
-          image.filename,
-          image.type,
-          subfolder || void 0
-        )
-      });
+      const errorType = rawError.type;
+      const errorMessage = rawError.message;
+      const errorDetails = rawError.details;
+      if (errorType === "required_input_missing" && typeof errorDetails === "string") {
+        missingInputs.push(errorDetails);
+        continue;
+      }
+      if (typeof errorMessage === "string") {
+        otherMessages.push(
+          typeof errorDetails === "string" && errorDetails.length > 0 ? `${errorMessage}: ${errorDetails}` : errorMessage
+        );
+      }
+    }
+    const parts = [];
+    if (missingInputs.length > 0) {
+      parts.push(`missing inputs: ${missingInputs.join(", ")}`);
+    }
+    if (otherMessages.length > 0) {
+      parts.push(otherMessages.join("; "));
+    }
+    if (parts.length > 0) {
+      lines.push(`Node ${nodeId}${classType}: ${parts.join("; ")}`);
     }
   }
-  return images;
-}
-function getHistoryStatus(entry) {
-  if (!isRecord(entry) || !isRecord(entry.status)) {
-    return "unknown";
-  }
-  return typeof entry.status.status_str === "string" ? entry.status.status_str : "unknown";
+  return lines;
 }
-function isHistoryCompleted(entry) {
-  if (!isRecord(entry) || !isRecord(entry.status)) {
-    return false;
+function summarizeComfyErrorDetails(details) {
+  if (!isRecord(details)) {
+    return "";
   }
-  if (entry.status.completed === true) {
-    return true;
+  const lines = [];
+  const errorDetails = isRecord(details.error) ? details.error : void 0;
+  if (typeof errorDetails?.message === "string") {
+    lines.push(errorDetails.message);
+  } else if (typeof details.message === "string") {
+    lines.push(details.message);
   }
-  return entry.status.status_str === "error";
-}
-function summarizeWaitForWorkflowText(structuredContent) {
-  return [
-    "# ComfyUI Workflow Wait Result",
-    "",
-    "## Summary",
-    formatMarkdownBulletList([
-      `Prompt ID: ${structuredContent.prompt_id}`,
-      `Status: ${structuredContent.status}`,
-      `Completed: ${structuredContent.completed ? "yes" : "no"}`,
-      `Timed Out: ${structuredContent.timed_out ? "yes" : "no"}`,
-      `Elapsed Seconds: ${structuredContent.elapsed_seconds}`,
-      `Images: ${structuredContent.image_count}`
-    ]),
-    "",
-    "## Images",
-    formatMarkdownBulletList(
-      structuredContent.images.map(
-        (image) => `${image.subfolder ? `${image.subfolder}/` : ""}${image.filename} (${image.type}) -> ${image.view_url}`
-      )
-    ),
-    "",
-    "## JSON",
-    formatJsonCodeBlock(structuredContent)
-  ].join("\n");
-}
-function summarizeWorkflowListText(heading, workflows, pagination) {
-  return [
-    heading,
-    "",
-    "## Pagination",
-    formatMarkdownBulletList([
-      `Returned: ${workflows.length}`,
-      `Total: ${pagination.total_count}`,
-      `Limit: ${pagination.limit}`,
-      `Offset: ${pagination.offset}`,
-      `Has More: ${pagination.has_more ? "yes" : "no"}`
-    ]),
-    "",
-    "## Workflows",
-    formatMarkdownBulletList(
-      workflows.map(
-        (workflow) => `${workflow.id} \u2014 ${workflow.name} | tags: ${workflow.tags.join(", ") || "none"} | editable inputs: ${workflow.editable_input_count}`
-      )
-    ),
-    "",
-    "## JSON",
-    formatJsonCodeBlock({
-      workflows,
-      pagination
-    })
-  ].join("\n");
-}
-function summarizeStoredWorkflowText(workflow) {
-  return [
-    "# ComfyUI Stored Workflow",
-    "",
-    "## Summary",
-    formatMarkdownBulletList([
-      `Workflow ID: ${workflow.workflow.id}`,
-      `Name: ${workflow.workflow.name}`,
-      `Description: ${workflow.workflow.description ?? "none"}`,
-      `Tags: ${workflow.workflow.tags.join(", ") || "none"}`,
-      `Created At: ${workflow.workflow.created_at}`,
-      `Updated At: ${workflow.workflow.updated_at}`,
-      `Node Count: ${workflow.workflow.node_count}`,
-      `Editable Inputs: ${workflow.workflow.editable_input_count}`,
-      `Source: ${workflow.workflow.source}`
-    ]),
-    "",
-    "## Editable Inputs",
-    formatMarkdownBulletList(
-      workflow.editable_inputs.map(
-        (input) => `${input.node_id}.${input.input_name} (${input.node_class}, ${input.value_type}) = ${String(
-          input.current_value
-        )}${input.options.length > 0 ? ` | options: ${input.options.join(", ")}` : ""}`
-      )
-    ),
-    "",
-    "## JSON",
-    formatJsonCodeBlock(workflow)
-  ].join("\n");
-}
-function summarizeSavedWorkflowText(workflow) {
-  return [
-    "# ComfyUI Workflow Saved",
-    "",
-    "## Summary",
-    formatMarkdownBulletList([
-      `Workflow ID: ${workflow.workflow.id}`,
-      `Name: ${workflow.workflow.name}`,
-      `Tags: ${workflow.workflow.tags.join(", ") || "none"}`,
-      `Editable Inputs: ${workflow.workflow.editable_input_count}`
-    ]),
-    "",
-    "## Next Step",
-    `Call comfyui_run_workflow with workflow_id="${workflow.workflow.id}" and optional overrides to reuse it.`,
-    "",
-    "## JSON",
-    formatJsonCodeBlock(workflow)
-  ].join("\n");
-}
-async function waitForWorkflowResult(params) {
-  const startTime = Date.now();
-  const timeoutMs = params.timeout_seconds * 1e3;
-  let latestEntry;
-  while (Date.now() - startTime <= timeoutMs) {
-    latestEntry = await fetchHistoryEntry(params.prompt_id);
-    if (latestEntry !== void 0) {
-      const images = extractHistoryImages(latestEntry);
-      const completed = isHistoryCompleted(latestEntry);
-      if (completed && (!params.require_images || images.length > 0)) {
-        return {
-          prompt_id: params.prompt_id,
-          status: getHistoryStatus(latestEntry),
-          completed: true,
-          timed_out: false,
-          elapsed_seconds: Number(
-            ((Date.now() - startTime) / 1e3).toFixed(3)
-          ),
-          image_count: images.length,
-          images,
-          history_entry: ensureRecord(latestEntry, "history entry")
-        };
-      }
-    }
-    await sleep(params.poll_interval_ms);
+  const nodeLines = summarizeNodeErrors(details.node_errors);
+  if (nodeLines.length > 0) {
+    lines.push(...nodeLines);
   }
-  const timeoutImages = latestEntry !== void 0 ? extractHistoryImages(latestEntry) : [];
-  return {
-    prompt_id: params.prompt_id,
-    status: latestEntry !== void 0 ? getHistoryStatus(latestEntry) : "not_found",
-    completed: latestEntry !== void 0 ? isHistoryCompleted(latestEntry) : false,
-    timed_out: true,
-    elapsed_seconds: Number(((Date.now() - startTime) / 1e3).toFixed(3)),
-    image_count: timeoutImages.length,
-    images: timeoutImages,
-    history_entry: latestEntry !== void 0 ? ensureRecord(latestEntry, "history entry") : null
-  };
-}
-async function createStoredWorkflowRecord(params) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const editableInputs = await deriveEditableWorkflowInputs(params.prompt);
-  const workflowId = params.workflow_id ? slugifyWorkflowId(params.workflow_id) : slugifyWorkflowId(params.name);
-  return {
-    workflow: {
-      id: workflowId,
-      name: params.name,
-      description: params.description,
-      tags: params.tags,
-      created_at: params.existing?.workflow.created_at ?? now,
-      updated_at: now,
-      node_count: Object.keys(params.prompt).length,
-      editable_input_count: editableInputs.length,
-      source: params.source
-    },
-    prompt: params.prompt,
-    editable_inputs: editableInputs
-  };
-}
-async function submitWorkflow(args) {
-  const result = IS_MOCK ? MOCK_FIXTURES.prompt_response : await fetchComfyJson(
-    "/prompt",
-    {
-      method: "POST",
-      body: JSON.stringify({
-        prompt: args.prompt,
-        client_id: args.client_id
-      })
-    }
-  );
-  return {
-    prompt_id: result.prompt_id,
-    number: result.number,
-    node_errors: result.node_errors
-  };
-}
-function summarizeWorkflowResponseText(result) {
-  const hasErrors = Object.keys(result.node_errors).length > 0;
-  return [
-    "# ComfyUI Workflow Submission",
-    "",
-    "## Summary",
-    formatMarkdownBulletList([
-      `Status: ${hasErrors ? "Submitted with node errors" : "Successfully queued"}`,
-      `Prompt ID: ${result.prompt_id}`,
-      `Queue Number: ${result.number}`,
-      `Node Errors: ${Object.keys(result.node_errors).length}`
-    ]),
-    "",
-    "## Next Step",
-    hasErrors ? "Fix the reported node_errors before retrying this workflow." : `Next step: call comfyui_get_history with prompt_id="${result.prompt_id}" to monitor outputs.`,
-    "",
-    "## JSON",
-    formatJsonCodeBlock({
-      prompt_id: result.prompt_id,
-      number: result.number,
-      node_errors: result.node_errors
-    })
-  ].join("\n");
+  return lines.join("\n");
 }
-function createAgentFacingResult(text, structuredContent) {
-  const normalizedText = text.trim();
-  if (normalizedText.length === 0) {
-    throw new Error(
-      "Tool response text must be non-empty. Do not rely on structuredContent alone because many MCP clients expose content.text to the model first."
-    );
+function formatWorkflowNodeErrors(nodeErrors) {
+  const nodeLines = summarizeNodeErrors(nodeErrors);
+  if (nodeLines.length === 0) {
+    return "Workflow submission failed validation.";
   }
-  return {
-    content: [
-      {
-        type: "text",
-        text: normalizedText
-      }
-    ],
-    structuredContent
-  };
+  return ["Workflow submission failed validation.", ...nodeLines].join("\n");
 }
 async function fetchComfyJson(apiPath, options) {
   const url2 = new URL(apiPath, COMFYUI_SERVER_URL).toString();
@@ -31385,666 +30808,857 @@ async function fetchComfyJson(apiPath, options) {
     response = await fetch(url2, {
       ...options,
       headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
+        Accept: "application/json",
+        ...options?.headers || {}
       }
     });
-  } catch {
-    throw new ComfyApiError(
-      "Failed to connect to ComfyUI. Verify the server is running and COMFYUI_SERVER_URL is correct.",
-      503
+  } catch (error48) {
+    throw new Error(
+      `Failed to connect to ComfyUI server at ${COMFYUI_SERVER_URL}: ${error48 instanceof Error ? error48.message : String(error48)}`
     );
   }
-  const contentType = response.headers.get("content-type") || "";
+  if (response.status === 404) {
+    throw new ComfyApiError(`Not found: ${apiPath}`, 404, null);
+  }
+  const text = await response.text();
   let body;
-  if (contentType.includes("application/json")) {
-    body = await response.json();
-  } else {
-    body = await response.text();
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+    throw new ComfyApiError(
+      `Invalid JSON response from ComfyUI: ${text.slice(0, 100)}`,
+      response.status,
+      text
+    );
   }
   if (!response.ok) {
     throw new ComfyApiError(
-      getErrorMessageFromDetails(body) || "The ComfyUI service returned an error.",
+      "The ComfyUI service returned an error.",
       response.status,
       body
     );
   }
   return body;
 }
-async function fetchHistoryEntry(promptId) {
-  if (IS_MOCK) {
-    return MOCK_FIXTURES.history[promptId];
-  }
-  try {
-    return await fetchComfyJson(
-      `/history/${encodeURIComponent(promptId)}`
-    );
-  } catch (error48) {
-    if (error48 instanceof ComfyApiError && error48.statusCode === 404) {
-      return void 0;
-    }
-    throw error48;
-  }
+async function fetchImageBase64(filename, type, subfolder) {
+  const params = new URLSearchParams({ filename, type });
+  if (subfolder) params.set("subfolder", subfolder);
+  const url2 = new URL(
+    `/view?${params.toString()}`,
+    COMFYUI_SERVER_URL
+  ).toString();
+  const response = await fetch(url2);
+  if (!response.ok)
+    throw new Error(`Failed to fetch image: ${response.statusText}`);
+  const arrayBuffer = await response.arrayBuffer();
+  const mimeType = response.headers.get("content-type") || "image/png";
+  return {
+    data: Buffer.from(arrayBuffer).toString("base64"),
+    mimeType
+  };
 }
 function handleComfyError(error48) {
   if (error48 instanceof ZodError) {
     return createValidationError(
-      error48.issues[0]?.path.join(".") || "arguments",
+      "arguments",
       error48.issues[0]?.message || "Invalid input."
     );
   }
+  if (error48 instanceof WorkflowInputError) {
+    return error48.kind === "not_found" ? createNotFoundError(error48.message) : createValidationError(error48.field, error48.message);
+  }
   if (error48 instanceof ComfyApiError) {
-    const nodeErrors = getNodeErrors(error48.details);
-    if (nodeErrors) {
-      const details = JSON.stringify(nodeErrors, null, 2);
-      return createValidationError(
-        "prompt",
-        `${error48.message}
-node_errors:
-${details}`
-      );
-    }
-    return createApiError(error48.message, error48.statusCode);
+    const detailSummary = summarizeComfyErrorDetails(error48.details);
+    return {
+      content: [
+        {
+          type: "text",
+          text: detailSummary.length > 0 ? `${error48.message}
+${detailSummary}` : error48.message
+        }
+      ],
+      structuredContent: error48.details || {},
+      isError: true
+    };
   }
   return createInternalError(error48);
 }
-async function handleGetSystemInfo() {
-  try {
-    const rawStats = IS_MOCK ? MOCK_FIXTURES.system_stats : await fetchComfyJson("/system_stats");
-    const structuredContent = normalizeSystemInfo(rawStats);
-    return createAgentFacingResult(
-      summarizeSystemInfoText(structuredContent),
-      structuredContent
+async function validateWorkflowPath(targetPath) {
+  const resolvedPath = path.resolve(targetPath);
+  const allowedRoots = getWorkflowDirectories();
+  const isAllowed = allowedRoots.some(
+    (root) => resolvedPath.startsWith(path.resolve(root))
+  );
+  if (!isAllowed) {
+    throw new WorkflowInputError(
+      `Access denied: ${targetPath} is outside allowed workflow directories.`,
+      "workflow_file_path"
     );
-  } catch (error48) {
-    return handleComfyError(error48);
   }
-}
-async function handleListObjectInfo(args) {
   try {
-    const rawInfo = IS_MOCK ? args.node_class ? MOCK_FIXTURES.object_info[args.node_class] : MOCK_FIXTURES.object_info : await fetchComfyJson(
-      args.node_class ? `/object_info/${encodeURIComponent(args.node_class)}` : "/object_info"
+    await fs.access(resolvedPath);
+    return resolvedPath;
+  } catch {
+    throw new WorkflowInputError(
+      `Workflow file not found: ${targetPath}`,
+      "workflow_file_path",
+      "not_found"
     );
-    if (args.node_class) {
-      if (rawInfo === void 0) {
-        return createNotFoundError(`Node class ${args.node_class}`);
-      }
-      const nodeDefinition = unwrapNamedNode(args.node_class, rawInfo);
-      return createAgentFacingResult(
-        summarizeNodeDefinitionText(args.node_class, nodeDefinition),
-        {
-          nodes: { [args.node_class]: nodeDefinition }
+  }
+}
+function getWorkflowDirectories(extraPath) {
+  const directories = [
+    path.join(
+      homedir(),
+      "comfy",
+      "ComfyUI",
+      "user",
+      "default",
+      "workflows"
+    ),
+    path.join(homedir(), ".fre4x-comfyui", "workflows"),
+    path.join(process.cwd(), "workflows")
+  ];
+  if (extraPath) {
+    directories.push(extraPath);
+  }
+  return directories;
+}
+function getWorkflowNameCandidates(name) {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  if (trimmed.endsWith(".json")) {
+    return [trimmed];
+  }
+  return [trimmed, `${trimmed}.json`];
+}
+function normalizeWorkflowFileName(fileName) {
+  const trimmed = fileName.trim();
+  if (trimmed.length === 0) {
+    throw new WorkflowInputError(
+      "Filename cannot be empty.",
+      "output_file_name"
+    );
+  }
+  if (path.basename(trimmed) !== trimmed) {
+    throw new WorkflowInputError(
+      "Filename must not include directory separators.",
+      "output_file_name"
+    );
+  }
+  return trimmed.endsWith(".json") ? trimmed : `${trimmed}.json`;
+}
+function isConnectionValue(value) {
+  return Array.isArray(value) && value.length >= 2 && (typeof value[0] === "string" || typeof value[0] === "number") && typeof value[1] === "number";
+}
+async function getObjectInfo() {
+  return IS_MOCK ? MOCK_FIXTURES.object_info : await fetchComfyJson(
+    "/object_info"
+  );
+}
+async function resolveWorkflowReference(args) {
+  if (args.workflow_file_path) {
+    const targetPath = args.workflow_file_path;
+    if (path.basename(targetPath) === targetPath) {
+      const candidates = getWorkflowNameCandidates(targetPath);
+      for (const dir of getWorkflowDirectories()) {
+        for (const candidate of candidates) {
+          const candidatePath = path.join(dir, candidate);
+          try {
+            const content = await fs.readFile(
+              candidatePath,
+              "utf8"
+            );
+            return {
+              targetPath: candidatePath,
+              content
+            };
+          } catch {
+          }
         }
+      }
+      throw new WorkflowInputError(
+        `Workflow file not found: ${targetPath}`,
+        "workflow_file_path",
+        "not_found"
       );
     }
-    const nodes = ensureRecord(rawInfo, "object_info");
-    const entries = Object.entries(nodes);
-    const paginated = applyPagination(entries, args);
-    const structuredContent = {
-      nodes: Object.fromEntries(paginated.items),
-      pagination: {
-        total_count: paginated.total,
-        limit: paginated.limit,
-        offset: paginated.offset,
-        has_more: paginated.hasMore
-      }
+    const validatedPath = await validateWorkflowPath(targetPath);
+    return {
+      targetPath: validatedPath,
+      content: await fs.readFile(validatedPath, "utf8")
     };
-    return createAgentFacingResult(
-      [
-        "# ComfyUI Node Definitions",
-        "",
-        "## Pagination",
-        formatMarkdownBulletList([
-          `Returned: ${paginated.items.length}`,
-          `Total: ${paginated.total}`,
-          `Limit: ${paginated.limit}`,
-          `Offset: ${paginated.offset}`,
-          `Has More: ${paginated.hasMore ? "yes" : "no"}`
-        ]),
-        "",
-        "## Node Classes In This Page",
-        formatMarkdownBulletList(
-          paginated.items.map(([nodeClass]) => nodeClass)
-        ),
-        "",
-        "## Next Step",
-        paginated.hasMore ? `Use offset=${paginated.offset + paginated.limit} to retrieve the next page.` : "This page contains the final set of node classes for the current query.",
-        "If you need a usable workflow field list, call comfyui_list_object_info again with node_class set to the exact node name.",
-        "",
-        "## JSON",
-        formatJsonCodeBlock(structuredContent)
-      ].join("\n"),
-      structuredContent
+  }
+  if (args.workflow_id) {
+    const requestedId = args.workflow_id.trim();
+    if (requestedId.length === 0) {
+      throw new WorkflowInputError(
+        "Workflow ID cannot be empty.",
+        "workflow_id"
+      );
+    }
+    for (const dir of getWorkflowDirectories()) {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isFile() || !entry.name.endsWith(".json")) {
+            continue;
+          }
+          const fullPath = path.join(dir, entry.name);
+          const defaultId = getWorkflowId(fullPath);
+          if (requestedId === defaultId || requestedId === entry.name.replace(/\.json$/, "")) {
+            return {
+              targetPath: fullPath,
+              content: await fs.readFile(fullPath, "utf8")
+            };
+          }
+        }
+      } catch {
+      }
+    }
+    throw new WorkflowInputError(
+      `Workflow ID not found: ${args.workflow_id}`,
+      "workflow_id",
+      "not_found"
+    );
+  }
+  throw new WorkflowInputError(
+    "Must provide either workflow_file_path or workflow_id.",
+    "workflow_id"
+  );
+}
+async function normalizeWorkflowPrompt(workflow) {
+  if (!isRecord(workflow)) {
+    throw new WorkflowInputError(
+      "Workflow must be a JSON object.",
+      "workflow"
+    );
+  }
+  let sourceFormat = "api";
+  let normalizedWorkflow = workflow;
+  if (isWebUIFormat(normalizedWorkflow)) {
+    sourceFormat = "webui";
+    normalizedWorkflow = convertWebUIToAPI(
+      normalizedWorkflow,
+      await getObjectInfo()
+    );
+  }
+  const prompt = isRecord(normalizedWorkflow.prompt) && normalizedWorkflow.prompt ? normalizedWorkflow.prompt : normalizedWorkflow;
+  if (!isRecord(prompt)) {
+    throw new WorkflowInputError(
+      "Workflow prompt must be a JSON object.",
+      "workflow"
     );
+  }
+  return {
+    prompt,
+    sourceFormat
+  };
+}
+async function loadWorkflow(args) {
+  const { targetPath, content } = await resolveWorkflowReference(args);
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
   } catch (error48) {
-    return handleComfyError(error48);
+    throw new WorkflowInputError(
+      `Invalid JSON in ${targetPath}: ${error48 instanceof Error ? error48.message : String(error48)}`,
+      args.workflow_file_path ? "workflow_file_path" : "workflow_id"
+    );
+  }
+  const { prompt, sourceFormat } = await normalizeWorkflowPrompt(parsed);
+  return {
+    targetPath,
+    prompt,
+    sourceFormat
+  };
+}
+function inferEditableRole(nodeId, classType, inputName, consumerMap) {
+  if (classType === "CLIPTextEncode" && inputName === "text") {
+    const consumers = consumerMap.get(nodeId) ?? [];
+    if (consumers.some((consumer) => consumer.inputName === "positive")) {
+      return "positive_prompt";
+    }
+    if (consumers.some((consumer) => consumer.inputName === "negative")) {
+      return "negative_prompt";
+    }
+    return "prompt_text";
+  }
+  switch (inputName) {
+    case "seed":
+      return "seed";
+    case "steps":
+      return "steps";
+    case "cfg":
+      return "cfg";
+    case "sampler_name":
+      return "sampler";
+    case "scheduler":
+      return "scheduler";
+    case "denoise":
+      return "denoise";
+    case "width":
+      return "width";
+    case "height":
+      return "height";
+    case "batch_size":
+      return "batch_size";
+    case "ckpt_name":
+      return "checkpoint";
+    case "filename_prefix":
+      return "filename_prefix";
+    case "text":
+      return "text";
+    default:
+      return void 0;
   }
 }
-async function handleExecuteWorkflow(args) {
+function formatValuePreview(value) {
+  if (typeof value === "string") {
+    return value.length > 100 ? `${value.slice(0, 97)}...` : value;
+  }
   try {
-    const result = await submitWorkflow(args);
-    const structuredContent = {
-      prompt_id: result.prompt_id,
-      number: result.number,
-      node_errors: result.node_errors
-    };
-    if (args.await && Object.keys(result.node_errors).length === 0) {
-      const waitResult = await waitForWorkflowResult({
-        prompt_id: result.prompt_id,
-        timeout_seconds: args.timeout,
-        poll_interval_ms: 1e3,
-        require_images: false
+    const serialized = JSON.stringify(value);
+    if (!serialized) {
+      return String(value);
+    }
+    return serialized.length > 100 ? `${serialized.slice(0, 97)}...` : serialized;
+  } catch {
+    return String(value);
+  }
+}
+function analyzeEditableInputs(prompt) {
+  const consumerMap = /* @__PURE__ */ new Map();
+  for (const [nodeId, rawNode] of Object.entries(prompt)) {
+    if (!isRecord(rawNode) || !isRecord(rawNode.inputs)) {
+      continue;
+    }
+    const classType = typeof rawNode.class_type === "string" ? rawNode.class_type : "";
+    for (const [inputName, value] of Object.entries(rawNode.inputs)) {
+      if (!isConnectionValue(value)) {
+        continue;
+      }
+      const sourceNodeId = String(value[0]);
+      const consumers = consumerMap.get(sourceNodeId) ?? [];
+      consumers.push({
+        inputName,
+        classType,
+        nodeId
+      });
+      consumerMap.set(sourceNodeId, consumers);
+    }
+  }
+  const editableInputs = [];
+  for (const [nodeId, rawNode] of Object.entries(prompt)) {
+    if (!isRecord(rawNode) || !isRecord(rawNode.inputs)) {
+      continue;
+    }
+    const classType = typeof rawNode.class_type === "string" ? rawNode.class_type : "";
+    for (const [inputName, value] of Object.entries(rawNode.inputs)) {
+      if (isConnectionValue(value)) {
+        continue;
+      }
+      editableInputs.push({
+        path: `${nodeId}.inputs.${inputName}`,
+        node_id: nodeId,
+        class_type: classType,
+        input_name: inputName,
+        value,
+        value_preview: formatValuePreview(value),
+        role: inferEditableRole(
+          nodeId,
+          classType,
+          inputName,
+          consumerMap
+        )
       });
-      const awaitedContent = {
-        ...structuredContent,
-        status: waitResult.status,
-        completed: waitResult.completed,
-        timed_out: waitResult.timed_out,
-        elapsed_seconds: waitResult.elapsed_seconds,
-        image_count: waitResult.image_count,
-        images: waitResult.images,
-        history_entry: waitResult.history_entry
-      };
-      return createAgentFacingResult(
-        [
-          summarizeWorkflowResponseText(awaitedContent),
-          "",
-          "## Await Result",
-          summarizeWaitForWorkflowText(waitResult)
-        ].join("\n"),
-        awaitedContent
-      );
     }
-    return createAgentFacingResult(
-      summarizeWorkflowResponseText(result),
-      structuredContent
-    );
-  } catch (error48) {
-    return handleComfyError(error48);
   }
+  return editableInputs.sort(
+    (left, right) => left.path.localeCompare(right.path, void 0, { numeric: true })
+  );
 }
-async function handleListWorkflows(args) {
+function formatEditableInputsText(editableInputs) {
+  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}`;
+  });
+}
+function deriveSavedWorkflowFileName(sourcePath, requestedName) {
+  if (requestedName) {
+    return normalizeWorkflowFileName(requestedName);
+  }
+  if (sourcePath) {
+    return normalizeWorkflowFileName(path.basename(sourcePath));
+  }
+  return `workflow-${Date.now()}.json`;
+}
+function applyOverrides(prompt, overrides) {
+  for (const [key, value] of Object.entries(overrides)) {
+    const parts = key.split(".");
+    let current = prompt;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (typeof current[part] !== "object" || current[part] === null) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+  }
+}
+var InspectNodeSchema = paginationSchema.extend({
+  node_class: z3.string().optional().describe(
+    "Specific node class to inspect. If omitted, lists all available nodes."
+  ),
+  query: z3.string().optional().describe(
+    "Search term to filter the list of available nodes by name or category."
+  )
+});
+var DiscoverWorkflowsSchema = paginationSchema.extend({
+  directory_path: z3.string().optional().describe("Custom directory path to scan for workflows.")
+});
+var WorkflowRunSchema = z3.object({
+  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"}'
+  ),
+  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.")
+});
+var GetWorkflowSchema = z3.object({
+  workflow_file_path: z3.string().optional().describe("Workflow path or filename to inspect."),
+  workflow_id: z3.string().optional().describe("Workflow identifier returned by discovery."),
+  include_prompt: z3.boolean().default(false).describe("Include normalized API JSON in structuredContent.")
+});
+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."),
+  output_file_name: z3.string().optional().describe("Filename to write under ./workflows."),
+  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.")
+});
+var WaitForWorkflowSchema = z3.object({
+  prompt_id: z3.string().describe("The prompt_id of the submitted workflow."),
+  timeout: z3.number().int().min(1).default(120).describe("Wait timeout in seconds.")
+});
+async function handleInspectNode(args) {
   try {
-    const workflows = (await listStoredWorkflowFiles()).map(
-      (workflow) => workflow.workflow
+    const rawInfo = IS_MOCK ? MOCK_FIXTURES.object_info : await fetchComfyJson(
+      "/object_info"
     );
-    const paginated = applyPagination(workflows, args);
-    const structuredContent = {
-      workflows: paginated.items,
-      pagination: {
-        total_count: paginated.total,
-        limit: paginated.limit,
-        offset: paginated.offset,
-        has_more: paginated.hasMore
+    if (args.node_class) {
+      const node = rawInfo[args.node_class];
+      if (!node)
+        return createNotFoundError(`Node class ${args.node_class}`);
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(node, null, 2) }
+        ],
+        structuredContent: node
+      };
+    }
+    let classes = Object.keys(rawInfo);
+    if (args.query) {
+      const query = args.query.toLowerCase();
+      classes = classes.filter((c) => {
+        const node = rawInfo[c];
+        const searchStr = `${c} ${node?.display_name || ""} ${node?.category || ""}`.toLowerCase();
+        return searchStr.includes(query);
+      });
+    }
+    const paginated = applyPagination(classes, args);
+    const resultNodes = {};
+    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 }],
+      structuredContent: {
+        nodes: resultNodes,
+        pagination: {
+          total: paginated.total,
+          offset: paginated.offset,
+          limit: paginated.limit,
+          has_more: paginated.hasMore
+        }
       }
     };
-    return createAgentFacingResult(
-      summarizeWorkflowListText(
-        "# ComfyUI Stored Workflows",
-        structuredContent.workflows,
-        structuredContent.pagination
-      ),
-      structuredContent
-    );
   } catch (error48) {
     return handleComfyError(error48);
   }
 }
-async function handleSearchWorkflows(args) {
-  try {
-    const normalizedQuery = args.query.trim().toLowerCase();
-    const matching = (await listStoredWorkflowFiles()).map((workflow) => workflow.workflow).filter(
-      (workflow) => [
-        workflow.id,
-        workflow.name,
-        workflow.description ?? "",
-        workflow.tags.join(" ")
-      ].join(" ").toLowerCase().includes(normalizedQuery)
-    );
-    const paginated = applyPagination(matching, args);
-    const structuredContent = {
+function getWorkflowId(absolutePath) {
+  return crypto.createHash("sha256").update(absolutePath).digest("hex").substring(0, 8);
+}
+async function handleDiscoverWorkflows(args) {
+  const pathsToScan = [
+    path.join(
+      homedir(),
+      "comfy",
+      "ComfyUI",
+      "user",
+      "default",
+      "workflows"
+    ),
+    path.join(homedir(), ".fre4x-comfyui", "workflows"),
+    path.join(process.cwd(), "workflows")
+  ];
+  if (args.directory_path) pathsToScan.push(args.directory_path);
+  const foundWorkflows = [];
+  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;
+            }
+            foundWorkflows.push({
+              id,
+              name,
+              path: fullPath,
+              isWebUI
+            });
+          } catch (e) {
+            foundWorkflows.push({
+              id: defaultId,
+              name: defaultName,
+              path: fullPath,
+              error: String(e)
+            });
+          }
+        }
+      }
+    } catch (_e) {
+    }
+  }
+  if (foundWorkflows.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No workflows found in searched directories.`
+        }
+      ],
+      structuredContent: {
+        workflows: [],
+        searched_paths: pathsToScan
+      }
+    };
+  }
+  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
+  )}` : "");
+  return {
+    content: [{ type: "text", text }],
+    structuredContent: {
       workflows: paginated.items,
       pagination: {
-        total_count: paginated.total,
-        limit: paginated.limit,
+        total: paginated.total,
         offset: paginated.offset,
+        limit: paginated.limit,
         has_more: paginated.hasMore
       }
-    };
-    return createAgentFacingResult(
-      summarizeWorkflowListText(
-        `# ComfyUI Workflow Search
-
-Query: ${args.query}`,
-        structuredContent.workflows,
-        structuredContent.pagination
-      ),
-      structuredContent
-    );
-  } catch (error48) {
-    return handleComfyError(error48);
-  }
+    }
+  };
 }
-async function handleGetWorkflow(args) {
-  try {
-    const workflow = await readStoredWorkflowFile(args.workflow_id);
-    if (!workflow) {
-      return createNotFoundError(`Workflow ${args.workflow_id}`);
+async function waitForWorkflowResult(prompt_id, timeout_seconds) {
+  const start = Date.now();
+  const end = start + timeout_seconds * 1e3;
+  while (Date.now() < end) {
+    const history = IS_MOCK ? MOCK_FIXTURES.history : await fetchComfyJson(
+      `/history/${prompt_id}`
+    ).catch(() => ({}));
+    if (history?.[prompt_id]) {
+      return history[prompt_id];
     }
-    return createAgentFacingResult(
-      summarizeStoredWorkflowText(workflow),
-      workflow
-    );
-  } catch (error48) {
-    return handleComfyError(error48);
+    await new Promise((r) => setTimeout(r, 1e3));
   }
+  throw new Error(`Timeout waiting for workflow ${prompt_id}`);
 }
-async function handleSaveWorkflow(args) {
+async function handleWaitForWorkflow(args) {
   try {
-    const workflowId = args.workflow_id ? slugifyWorkflowId(args.workflow_id) : slugifyWorkflowId(args.name);
-    const existing = await readStoredWorkflowFile(workflowId);
-    if (existing && !args.overwrite) {
-      return createValidationError(
-        "workflow_id",
-        `Workflow ${workflowId} already exists. Pass overwrite=true to replace it.`
-      );
-    }
-    const workflow = await createStoredWorkflowRecord({
-      workflow_id: workflowId,
-      name: args.name,
-      description: args.description,
-      tags: args.tags,
-      prompt: args.prompt,
-      source: IS_MOCK ? "mock" : "local",
-      existing
-    });
-    await writeStoredWorkflowFile(workflow);
-    return createAgentFacingResult(
-      summarizeSavedWorkflowText(workflow),
-      workflow
+    const historyEntry = await waitForWorkflowResult(
+      args.prompt_id,
+      args.timeout
     );
+    const outputsRecord = historyEntry.outputs || {};
+    const content = [];
+    let summaryText = `Workflow ${args.prompt_id} completed.
+`;
+    for (const [, output] of Object.entries(outputsRecord)) {
+      if (output && Array.isArray(output.images)) {
+        for (const image of output.images) {
+          if (image.filename && image.type) {
+            if (!IS_MOCK) {
+              try {
+                const base643 = await fetchImageBase64(
+                  image.filename,
+                  image.type,
+                  image.subfolder
+                );
+                content.push({
+                  type: "image",
+                  data: base643.data,
+                  mimeType: base643.mimeType
+                });
+                summaryText += `Fetched image: ${image.filename}
+`;
+              } catch (e) {
+                summaryText += `Failed to fetch image ${image.filename}: ${String(e)}
+`;
+              }
+            } else {
+              summaryText += `Mock image: ${image.filename}
+`;
+            }
+          }
+        }
+      }
+    }
+    content.unshift({ type: "text", text: summaryText });
+    return {
+      content,
+      structuredContent: historyEntry
+    };
   } catch (error48) {
     return handleComfyError(error48);
   }
 }
-async function handleRunWorkflow(args) {
+async function handleGetWorkflow(args) {
   try {
-    const workflow = await readStoredWorkflowFile(args.workflow_id);
-    if (!workflow) {
-      return createNotFoundError(`Workflow ${args.workflow_id}`);
-    }
-    const prompt = applyWorkflowOverrides(
-      workflow.prompt,
-      workflow.editable_inputs,
-      args.overrides
-    );
-    const submission = await submitWorkflow({
-      prompt,
-      client_id: args.client_id
-    });
+    const loadedWorkflow = await loadWorkflow(args);
+    const editableInputs = analyzeEditableInputs(loadedWorkflow.prompt);
+    const workflowId = getWorkflowId(loadedWorkflow.targetPath);
+    const text = [
+      `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");
     const structuredContent = {
-      prompt_id: submission.prompt_id,
-      number: submission.number,
-      node_errors: submission.node_errors,
-      workflow_id: workflow.workflow.id,
-      workflow_name: workflow.workflow.name,
-      applied_overrides: args.overrides
+      workflow_id: workflowId,
+      path: loadedWorkflow.targetPath,
+      source_format: loadedWorkflow.sourceFormat,
+      editable_inputs: editableInputs
     };
-    if (args.await && Object.keys(submission.node_errors).length === 0) {
-      const waitResult = await waitForWorkflowResult({
-        prompt_id: submission.prompt_id,
-        timeout_seconds: args.timeout,
-        poll_interval_ms: 1e3,
-        require_images: args.require_images
-      });
-      Object.assign(structuredContent, {
-        status: waitResult.status,
-        completed: waitResult.completed,
-        timed_out: waitResult.timed_out,
-        elapsed_seconds: waitResult.elapsed_seconds,
-        image_count: waitResult.image_count,
-        images: waitResult.images,
-        history_entry: waitResult.history_entry
-      });
-      return createAgentFacingResult(
-        [
-          "# ComfyUI Stored Workflow Run",
-          "",
-          "## Summary",
-          formatMarkdownBulletList([
-            `Workflow ID: ${workflow.workflow.id}`,
-            `Workflow Name: ${workflow.workflow.name}`,
-            `Prompt ID: ${submission.prompt_id}`,
-            `Applied Overrides: ${args.overrides.length}`
-          ]),
-          "",
-          summarizeWorkflowResponseText(structuredContent),
-          "",
-          "## Await Result",
-          summarizeWaitForWorkflowText(waitResult),
-          "",
-          "## JSON",
-          formatJsonCodeBlock(structuredContent)
-        ].join("\n"),
-        structuredContent
-      );
+    if (args.include_prompt) {
+      structuredContent.prompt = loadedWorkflow.prompt;
     }
-    return createAgentFacingResult(
-      [
-        "# ComfyUI Stored Workflow Run",
-        "",
-        "## Summary",
-        formatMarkdownBulletList([
-          `Workflow ID: ${workflow.workflow.id}`,
-          `Workflow Name: ${workflow.workflow.name}`,
-          `Prompt ID: ${submission.prompt_id}`,
-          `Applied Overrides: ${args.overrides.length}`
-        ]),
-        "",
-        summarizeWorkflowResponseText(structuredContent),
-        "",
-        "## JSON",
-        formatJsonCodeBlock(structuredContent)
-      ].join("\n"),
+    return {
+      content: [{ type: "text", text }],
       structuredContent
-    );
+    };
   } catch (error48) {
     return handleComfyError(error48);
   }
 }
-async function handleGetHistory(args) {
+async function handleSaveWorkflow(args) {
   try {
-    const rawHistory = IS_MOCK ? args.prompt_id ? MOCK_FIXTURES.history[args.prompt_id] : MOCK_FIXTURES.history : await fetchComfyJson(
-      args.prompt_id ? `/history/${encodeURIComponent(args.prompt_id)}` : "/history"
-    );
-    if (args.prompt_id) {
-      if (rawHistory === void 0) {
-        return createNotFoundError(`Prompt history ${args.prompt_id}`);
+    let prompt;
+    let sourcePath;
+    if (args.workflow !== void 0) {
+      const normalized = await normalizeWorkflowPrompt(args.workflow);
+      prompt = normalized.prompt;
+    } else {
+      if (!args.workflow_file_path && !args.workflow_id) {
+        return createValidationError(
+          "workflow",
+          "Provide workflow JSON or an existing workflow reference."
+        );
       }
-      return createAgentFacingResult(
-        summarizeHistoryEntryText(args.prompt_id, rawHistory),
-        {
-          history: { [args.prompt_id]: rawHistory }
-        }
+      const loadedWorkflow = await loadWorkflow(args);
+      prompt = loadedWorkflow.prompt;
+      sourcePath = loadedWorkflow.targetPath;
+    }
+    if (args.overrides) {
+      applyOverrides(prompt, args.overrides);
+    }
+    const workflowsDir = path.join(process.cwd(), "workflows");
+    await fs.mkdir(workflowsDir, { recursive: true });
+    const outputFileName = deriveSavedWorkflowFileName(
+      sourcePath,
+      args.output_file_name
+    );
+    const outputPath = path.join(workflowsDir, outputFileName);
+    let existedBeforeSave = false;
+    try {
+      await fs.access(outputPath);
+      existedBeforeSave = true;
+    } catch {
+      existedBeforeSave = false;
+    }
+    if (existedBeforeSave && !args.overwrite) {
+      return createValidationError(
+        "output_file_name",
+        `File already exists: ${outputFileName}. Set overwrite=true to replace it.`
       );
     }
-    const history = ensureRecord(rawHistory, "history");
-    const entries = Object.entries(history);
-    const paginated = applyPagination(entries, args);
+    await fs.writeFile(
+      outputPath,
+      `${JSON.stringify(prompt, null, 2)}
+`,
+      "utf8"
+    );
+    const editableInputs = analyzeEditableInputs(prompt);
+    const workflowId = getWorkflowId(outputPath);
     const structuredContent = {
-      history: Object.fromEntries(paginated.items),
-      pagination: {
-        total_count: paginated.total,
-        limit: paginated.limit,
-        offset: paginated.offset,
-        has_more: paginated.hasMore
-      }
+      workflow_id: workflowId,
+      path: outputPath,
+      source_path: sourcePath,
+      overwritten: existedBeforeSave,
+      editable_inputs: editableInputs
     };
-    return createAgentFacingResult(
-      [
-        "# ComfyUI History",
-        "",
-        "## Pagination",
-        formatMarkdownBulletList([
-          `Returned: ${paginated.items.length}`,
-          `Total: ${paginated.total}`,
-          `Limit: ${paginated.limit}`,
-          `Offset: ${paginated.offset}`,
-          `Has More: ${paginated.hasMore ? "yes" : "no"}`
-        ]),
-        "",
-        "## Prompt IDs In This Page",
-        formatMarkdownBulletList(
-          paginated.items.map(([promptId]) => promptId)
-        ),
-        "",
-        "## Next Step",
-        paginated.hasMore ? `Use offset=${paginated.offset + paginated.limit} to retrieve the next page.` : "This page contains the final set of history entries for the current query.",
-        "",
-        "## JSON",
-        formatJsonCodeBlock(structuredContent)
-      ].join("\n"),
-      structuredContent
-    );
-  } catch (error48) {
-    return handleComfyError(error48);
-  }
-}
-async function handleWaitForWorkflow(args) {
-  try {
-    const structuredContent = await waitForWorkflowResult(args);
-    return createAgentFacingResult(
-      summarizeWaitForWorkflowText(structuredContent),
+    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 = [
+      `Saved workflow ${workflowId} to ${outputPath}.`,
+      persistedChanges,
+      `Editable inputs (${editableInputs.length}):`,
+      formatEditableInputsText(editableInputs)
+    ].join("\n");
+    return {
+      content: [{ type: "text", text }],
       structuredContent
-    );
+    };
   } catch (error48) {
     return handleComfyError(error48);
   }
 }
-async function handleGetQueue() {
+async function handleWorkflowRun(args) {
   try {
-    const queue = IS_MOCK ? MOCK_FIXTURES.queue : await fetchComfyJson("/queue");
-    const queueRecord = ensureRecord(queue, "queue");
-    const structuredContent = {
-      queue_running: Array.isArray(queueRecord.queue_running) ? queueRecord.queue_running : [],
-      queue_pending: Array.isArray(queueRecord.queue_pending) ? queueRecord.queue_pending : []
+    const { prompt } = await loadWorkflow(args);
+    const promptObj = { ...prompt };
+    if (args.overrides) {
+      applyOverrides(promptObj, args.overrides);
+    }
+    const clientId = `mcp-${Date.now()}`;
+    const result = IS_MOCK ? MOCK_FIXTURES.prompt_response : await fetchComfyJson("/prompt", {
+      method: "POST",
+      body: JSON.stringify({
+        prompt: promptObj,
+        client_id: clientId
+      })
+    });
+    if (result.node_errors && Object.keys(result.node_errors).length > 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatWorkflowNodeErrors(result.node_errors)
+          }
+        ],
+        structuredContent: result,
+        isError: true
+      };
+    }
+    if (args.await) {
+      return await handleWaitForWorkflow({
+        prompt_id: result.prompt_id,
+        timeout: args.timeout
+      });
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Workflow submitted. prompt_id: ${result.prompt_id}, queue: ${result.number}`
+        }
+      ],
+      structuredContent: result
     };
-    return createAgentFacingResult(
-      [
-        "# ComfyUI Queue",
-        "",
-        "## Summary",
-        formatMarkdownBulletList([
-          `Running Jobs: ${structuredContent.queue_running.length}`,
-          `Pending Jobs: ${structuredContent.queue_pending.length}`
-        ]),
-        "",
-        "## JSON",
-        formatJsonCodeBlock(structuredContent)
-      ].join("\n"),
-      structuredContent
-    );
   } catch (error48) {
     return handleComfyError(error48);
   }
 }
-async function handleGetViewUrl(args) {
-  const url2 = buildViewUrl(args.filename, args.type, args.subfolder);
-  return createAgentFacingResult(
-    [
-      "# ComfyUI View URL",
-      "",
-      "## Summary",
-      formatMarkdownBulletList([
-        `Filename: ${args.filename}`,
-        `Subfolder: ${args.subfolder ?? "(root)"}`,
-        `Type: ${args.type}`,
-        `URL: ${url2}`
-      ]),
-      "",
-      "## JSON",
-      formatJsonCodeBlock({ url: url2 })
-    ].join("\n"),
-    { url: url2 }
-  );
-}
 function createServer() {
   const server = new McpServer({
     name: "@fre4x/comfyui",
     version: PACKAGE_VERSION
   });
-  server.registerTool(
-    "comfyui_get_system_info",
-    {
-      title: "Get ComfyUI System Info",
-      description: "Get ComfyUI server status, hardware info, and VRAM usage.",
-      inputSchema: NoArgsSchema,
-      outputSchema: SystemInfoSchema,
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: true
-      }
-    },
-    handleGetSystemInfo
+  server.tool(
+    "comfyui_inspect_node",
+    "Inspect a ComfyUI node or list all nodes.",
+    InspectNodeSchema.shape,
+    handleInspectNode
   );
-  server.registerTool(
-    "comfyui_list_object_info",
-    {
-      title: "List ComfyUI Node Definitions",
-      description: "Get definitions of available node classes, with optional node lookup and pagination.",
-      inputSchema: ListObjectInfoInputSchema,
-      outputSchema: ObjectInfoSchema,
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: true
-      }
-    },
-    handleListObjectInfo
+  server.tool(
+    "comfyui_discover_workflows",
+    "Scan standard directories for .json workflow files.",
+    DiscoverWorkflowsSchema.shape,
+    handleDiscoverWorkflows
   );
-  server.registerTool(
-    "comfyui_execute_workflow",
-    {
-      title: "Execute ComfyUI Workflow",
-      description: "Submit a ComfyUI workflow in API JSON format and return its prompt_id.",
-      inputSchema: ExecuteWorkflowInputSchema,
-      outputSchema: WorkflowResponseSchema,
-      annotations: {
-        openWorldHint: true
-      }
-    },
-    handleExecuteWorkflow
-  );
-  server.registerTool(
-    "comfyui_list_workflows",
-    {
-      title: "List Stored Workflows",
-      description: "List stored ComfyUI workflows with pagination.",
-      inputSchema: ListWorkflowsInputSchema,
-      outputSchema: WorkflowListSchema,
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: true
-      }
-    },
-    handleListWorkflows
-  );
-  server.registerTool(
-    "comfyui_search_workflows",
-    {
-      title: "Search Stored Workflows",
-      description: "Search stored ComfyUI workflows by name, tags, or description.",
-      inputSchema: SearchWorkflowsInputSchema,
-      outputSchema: WorkflowListSchema,
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: true
-      }
-    },
-    handleSearchWorkflows
+  server.tool(
+    "comfyui_workflow_run",
+    "Run a workflow from a file path or ID, applying overrides, and optionally returning images.",
+    WorkflowRunSchema.shape,
+    handleWorkflowRun
   );
-  server.registerTool(
+  server.tool(
     "comfyui_get_workflow",
-    {
-      title: "Get Stored Workflow",
-      description: "Get a stored ComfyUI workflow and its editable inputs.",
-      inputSchema: GetWorkflowInputSchema,
-      outputSchema: StoredWorkflowSchema,
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: true
-      }
-    },
+    "Inspect a stored workflow and list editable inputs.",
+    GetWorkflowSchema.shape,
     handleGetWorkflow
   );
-  server.registerTool(
+  server.tool(
     "comfyui_save_workflow",
-    {
-      title: "Save Workflow",
-      description: "Save a ComfyUI workflow for later reuse.",
-      inputSchema: SaveWorkflowInputSchema,
-      outputSchema: StoredWorkflowSchema,
-      annotations: {
-        openWorldHint: true
-      }
-    },
+    "Save a workflow into ./workflows with optional edits.",
+    SaveWorkflowSchema.shape,
     handleSaveWorkflow
   );
-  server.registerTool(
-    "comfyui_run_workflow",
-    {
-      title: "Run Stored Workflow",
-      description: "Run a stored workflow with optional overrides.",
-      inputSchema: RunWorkflowInputSchema,
-      outputSchema: RunStoredWorkflowSchema,
-      annotations: {
-        openWorldHint: true
-      }
-    },
-    handleRunWorkflow
-  );
-  server.registerTool(
-    "comfyui_get_history",
-    {
-      title: "Get ComfyUI History",
-      description: "Get execution history or a specific workflow result, with pagination for list mode.",
-      inputSchema: GetHistoryInputSchema,
-      outputSchema: HistorySchema,
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: true
-      }
-    },
-    handleGetHistory
-  );
-  server.registerTool(
+  server.tool(
     "comfyui_wait_for_workflow",
-    {
-      title: "Wait for ComfyUI Workflow",
-      description: "Wait for a workflow result with timeout-based polling.",
-      inputSchema: WaitForWorkflowInputSchema,
-      outputSchema: WaitForWorkflowSchema,
-      annotations: {
-        openWorldHint: true
-      }
-    },
+    "Wait for a submitted workflow to finish and fetch its images.",
+    WaitForWorkflowSchema.shape,
     handleWaitForWorkflow
   );
-  server.registerTool(
-    "comfyui_get_queue",
-    {
-      title: "Get ComfyUI Queue",
-      description: "Get the current pending and running jobs in the ComfyUI queue.",
-      inputSchema: NoArgsSchema,
-      outputSchema: QueueSchema,
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: true
-      }
-    },
-    handleGetQueue
-  );
-  server.registerTool(
-    "comfyui_get_view_url",
-    {
-      title: "Get ComfyUI View URL",
-      description: "Build the direct URL for a generated file in ComfyUI.",
-      inputSchema: GetViewUrlInputSchema,
-      outputSchema: ViewUrlSchema,
-      annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: true
-      }
-    },
-    handleGetViewUrl
-  );
   return server;
 }
 function isMainModule(url2) {