@fre4x/comfyui 1.0.58 → 1.0.59

package/dist/index.js

@@ -3223,8 +3223,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path) {
-      let input = path;
+    function removeDotSegments(path2) {
+      let input = path2;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3423,8 +3423,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path && path !== "/" ? path : void 0;
+        const [path2, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path2 && path2 !== "/" ? path2 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6786,12 +6786,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs, exportName) {
+    function addFormats(ajv, list, fs2, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs[f]);
+        ajv.addFormat(f, fs2[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -6800,7 +6800,10 @@ var require_dist = __commonJS({
 });
 
 // src/index.ts
+import * as fs from "node:fs/promises";
 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
@@ -6873,16 +6876,6 @@ Suggestion: If the problem persists, check server logs.`
   };
 }
 
-// ../packages/shared/dist/format.js
-function formatField(label, value) {
-  if (value === null || value === void 0 || value === "")
-    return "";
-  return `**${label}:** ${value}`;
-}
-function formatFields(fields) {
-  return fields.map(([label, value]) => formatField(label, value)).filter(Boolean).join("  \n");
-}
-
 // ../node_modules/zod/index.js
 var zod_exports = {};
 __export(zod_exports, {
@@ -7893,10 +7886,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8279,11 +8272,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -8466,7 +8459,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path = []) => {
+  const processError = (error49, path2 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8476,7 +8469,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path2, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8508,8 +8501,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path2) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -20486,13 +20479,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path = ref.slice(1).split("/").filter(Boolean);
-  if (path.length === 0) {
+  const path2 = ref.slice(1).split("/").filter(Boolean);
+  if (path2.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path[0] === defsKey) {
-    const key = path[1];
+  if (path2[0] === defsKey) {
+    const key = path2[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -21284,8 +21277,8 @@ function getErrorMap2() {
 
 // ../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path, errorMaps, issueData } = params;
-  const fullPath = [...path, ...issueData.path || []];
+  const { data, path: path2, errorMaps, issueData } = params;
+  const fullPath = [...path2, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -21400,11 +21393,11 @@ var errorUtil;
 
 // ../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path, key) {
+  constructor(parent, value, path2, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path;
+    this._path = path2;
     this._key = key;
   }
   get path() {
@@ -30530,7 +30523,16 @@ var MOCK_FIXTURES = {
           ckpt_name: [
             [
               "v1-5-pruned-emaonly.ckpt",
-              "sd_xl_base_1.0.safetensors"
+              "sd_xl_base_1.0.safetensors",
+              "cyberrealisticPony_v160.safetensors",
+              "harukiMIX_ponyV23.safetensors",
+              "harukiMIX_ponyV40.safetensors",
+              "ponyRealism_V22.safetensors",
+              "ponyRealism_V23.safetensors",
+              "ponyDiffusion_V6XL.safetensors",
+              "realvisxlV50.safetensors",
+              "juggernautXL_v9.safetensors",
+              "waiNSFWIllustrious_v120.safetensors"
             ],
             {}
           ]
@@ -30584,6 +30586,7 @@ var MOCK_FIXTURES = {
 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({
@@ -30612,15 +30615,82 @@ 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())
+  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()
+]);
+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())
@@ -30638,7 +30708,9 @@ var ListObjectInfoInputSchema = z3.object({
 }).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.")
+  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."),
@@ -30650,6 +30722,40 @@ var GetViewUrlInputSchema = z3.object({
   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);
@@ -30667,6 +30773,63 @@ function ensureRecord(value, label) {
   }
   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`);
+}
+async function ensureWorkflowStoreDir() {
+  await fs.mkdir(COMFYUI_WORKFLOWS_DIR, { recursive: true });
+}
+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;
+  }
+}
+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")) {
+      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;
@@ -30720,6 +30883,17 @@ function normalizeSystemInfo(source) {
 function formatGiB(bytes) {
   return `${(bytes / BYTES_PER_GIB).toFixed(1)} GiB`;
 }
+function formatJsonCodeBlock(value) {
+  return `\`\`\`json
+${JSON.stringify(value, null, 2)}
+\`\`\``;
+}
+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 [];
@@ -30732,6 +30906,98 @@ function getEnumLikeOptions(value) {
     (entry) => typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean"
   );
 }
+function buildViewUrl(filename, type, subfolder) {
+  const params = new URLSearchParams({
+    filename,
+    type
+  });
+  if (subfolder) {
+    params.set("subfolder", subfolder);
+  }
+  return new URL(`/view?${params.toString()}`, COMFYUI_SERVER_URL).toString();
+}
+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;
+  }
+}
+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;
+      }
+      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.`
+      );
+    }
+    const node = nextPrompt[override.node_id];
+    if (!isRecord(node) || !isRecord(node.inputs)) {
+      throw new Error(
+        `Stored workflow node ${override.node_id} is invalid.`
+      );
+    }
+    node.inputs[override.input_name] = override.value;
+  }
+  return nextPrompt;
+}
 function summarizeOptionLines(inputSection) {
   if (!inputSection) {
     return [];
@@ -30741,26 +31007,33 @@ function summarizeOptionLines(inputSection) {
     if (options.length === 0) {
       return [];
     }
-    const preview = options.slice(0, 5).map(String).join(", ");
-    const suffix = options.length > 5 ? `, ... (${options.length} total)` : "";
-    return [`${inputName}: ${preview}${suffix}`];
+    return [`${inputName}: ${options.map(String).join(", ")}`];
   });
 }
 function summarizeSystemInfoText(structuredContent) {
-  const deviceSummary = structuredContent.devices.length === 0 ? "_No devices reported._" : structuredContent.devices.map(
-    (device) => `- [${device.index}] ${device.name} (${device.type}, ${formatGiB(device.vram_free)} free / ${formatGiB(device.vram_total)} total VRAM)`
-  ).join("\n");
+  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).`,
-    formatFields([
-      ["Python", structuredContent.system.python_version],
-      [
-        "Embedded Python",
-        structuredContent.system.embedded_python ? "yes" : "no"
-      ]
+    "",
+    "## 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}`
+    "",
+    "## Devices",
+    deviceSummary,
+    "",
+    "## JSON",
+    formatJsonCodeBlock(structuredContent)
   ].join("\n");
 }
 function summarizeNodeDefinitionText(nodeClass, nodeDefinition) {
@@ -30778,28 +31051,28 @@ function summarizeNodeDefinitionText(nodeClass, nodeDefinition) {
     ...summarizeOptionLines(optionalInputs)
   ];
   return [
+    "# ComfyUI Node Definition",
+    "",
     `Schema retrieved for node: ${nodeClass}`,
-    formatFields([
-      [
-        "Display Name",
-        typeof nodeDefinition.display_name === "string" ? nodeDefinition.display_name : typeof nodeDefinition.name === "string" ? nodeDefinition.name : nodeClass
-      ],
-      [
-        "Category",
-        typeof nodeDefinition.category === "string" ? nodeDefinition.category : null
-      ],
-      [
-        "Required Inputs",
-        requiredInputs ? Object.keys(requiredInputs).join(", ") || "none" : "none"
-      ],
-      [
-        "Optional Inputs",
-        optionalInputs ? Object.keys(optionalInputs).join(", ") || null : null
-      ],
-      ["Outputs", outputNames.join(", ") || null]
+    "",
+    "## 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")}` : ""
+    "",
+    optionLines.length > 0 ? `## Enumerated Options
+${optionLines.map((line) => `- ${line}`).join("\n")}
+` : "",
+    "## JSON",
+    formatJsonCodeBlock({
+      nodes: { [nodeClass]: nodeDefinition }
+    }),
+    ""
   ].filter(Boolean).join("\n");
 }
 function summarizeHistoryEntryText(promptId, entry) {
@@ -30824,35 +31097,268 @@ function summarizeHistoryEntryText(promptId, entry) {
     }
   }
   return [
+    "# ComfyUI History Entry",
+    "",
     `History retrieved for job: ${promptId}`,
-    formatFields([
-      [
-        "Status",
-        typeof statusRecord?.status_str === "string" ? statusRecord.status_str : "unknown"
-      ],
-      [
-        "Completed",
-        statusRecord?.completed === true ? "yes" : statusRecord?.completed === false ? "no" : "unknown"
-      ],
-      [
-        "Images",
-        imageRefs.length > 0 ? imageRefs.slice(0, 5).join(", ") : "none reported"
-      ]
-    ])
+    "",
+    "## 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");
+}
+function extractHistoryImages(entry) {
+  if (!isRecord(entry) || !isRecord(entry.outputs)) {
+    return [];
+  }
+  const images = [];
+  for (const output of Object.values(entry.outputs)) {
+    if (!isRecord(output) || !Array.isArray(output.images)) {
+      continue;
+    }
+    for (const image of output.images) {
+      if (!isRecord(image) || typeof image.filename !== "string" || typeof image.type !== "string") {
+        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
+        )
+      });
+    }
+  }
+  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";
+}
+function isHistoryCompleted(entry) {
+  if (!isRecord(entry) || !isRecord(entry.status)) {
+    return false;
+  }
+  if (entry.status.completed === true) {
+    return true;
+  }
+  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 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 [
-    formatFields([
-      [
-        "Status",
-        hasErrors ? "Submitted with node errors" : "Successfully queued"
-      ],
-      ["Prompt ID", result.prompt_id],
-      ["Queue Number", result.number]
+    "# 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}`
     ]),
-    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.`
+    "",
+    "## 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");
 }
 function createAgentFacingResult(text, structuredContent) {
@@ -30905,6 +31411,21 @@ async function fetchComfyJson(apiPath, options) {
   }
   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;
+  }
+}
 function handleComfyError(error48) {
   if (error48 instanceof ZodError) {
     return createValidationError(
@@ -30970,13 +31491,29 @@ async function handleListObjectInfo(args) {
     };
     return createAgentFacingResult(
       [
-        `Retrieved ${paginated.items.length} of ${paginated.total} node definitions.`,
-        paginated.items.length > 0 ? `Node classes: ${paginated.items.slice(0, 10).map(([nodeClass]) => nodeClass).join(
-          ", "
-        )}${paginated.items.length > 10 ? ", ..." : ""}` : "",
-        paginated.hasMore ? `Use offset=${paginated.offset + paginated.limit} for more.` : "",
-        "If you need a usable workflow field list, call comfyui_list_object_info again with node_class set to the exact node name."
-      ].filter(Boolean).join("\n"),
+        "# 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
     );
   } catch (error48) {
@@ -30985,21 +31522,39 @@ async function handleListObjectInfo(args) {
 }
 async function handleExecuteWorkflow(args) {
   try {
-    const result = IS_MOCK ? MOCK_FIXTURES.prompt_response : await fetchComfyJson(
-      "/prompt",
-      {
-        method: "POST",
-        body: JSON.stringify({
-          prompt: args.prompt,
-          client_id: args.client_id
-        })
-      }
-    );
+    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 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
@@ -31008,6 +31563,195 @@ async function handleExecuteWorkflow(args) {
     return handleComfyError(error48);
   }
 }
+async function handleListWorkflows(args) {
+  try {
+    const workflows = (await listStoredWorkflowFiles()).map(
+      (workflow) => workflow.workflow
+    );
+    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
+      }
+    };
+    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 = {
+      workflows: paginated.items,
+      pagination: {
+        total_count: paginated.total,
+        limit: paginated.limit,
+        offset: paginated.offset,
+        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}`);
+    }
+    return createAgentFacingResult(
+      summarizeStoredWorkflowText(workflow),
+      workflow
+    );
+  } catch (error48) {
+    return handleComfyError(error48);
+  }
+}
+async function handleSaveWorkflow(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
+    );
+  } catch (error48) {
+    return handleComfyError(error48);
+  }
+}
+async function handleRunWorkflow(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 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
+    };
+    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
+      );
+    }
+    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"),
+      structuredContent
+    );
+  } catch (error48) {
+    return handleComfyError(error48);
+  }
+}
 async function handleGetHistory(args) {
   try {
     const rawHistory = IS_MOCK ? args.prompt_id ? MOCK_FIXTURES.history[args.prompt_id] : MOCK_FIXTURES.history : await fetchComfyJson(
@@ -31038,12 +31782,39 @@ async function handleGetHistory(args) {
     };
     return createAgentFacingResult(
       [
-        `Retrieved ${paginated.items.length} of ${paginated.total} job(s) from history.`,
-        paginated.items.length > 0 ? `Prompt IDs: ${paginated.items.slice(0, 10).map(([promptId]) => promptId).join(
-          ", "
-        )}${paginated.items.length > 10 ? ", ..." : ""}` : "",
-        paginated.hasMore ? `Use offset=${paginated.offset + paginated.limit} for more.` : ""
-      ].filter(Boolean).join("\n"),
+        "# 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),
       structuredContent
     );
   } catch (error48) {
@@ -31059,7 +31830,18 @@ async function handleGetQueue() {
       queue_pending: Array.isArray(queueRecord.queue_pending) ? queueRecord.queue_pending : []
     };
     return createAgentFacingResult(
-      `Queue status: ${structuredContent.queue_running.length} running, ${structuredContent.queue_pending.length} pending.`,
+      [
+        "# ComfyUI Queue",
+        "",
+        "## Summary",
+        formatMarkdownBulletList([
+          `Running Jobs: ${structuredContent.queue_running.length}`,
+          `Pending Jobs: ${structuredContent.queue_pending.length}`
+        ]),
+        "",
+        "## JSON",
+        formatJsonCodeBlock(structuredContent)
+      ].join("\n"),
       structuredContent
     );
   } catch (error48) {
@@ -31067,20 +31849,22 @@ async function handleGetQueue() {
   }
 }
 async function handleGetViewUrl(args) {
-  const params = new URLSearchParams({
-    filename: args.filename,
-    type: args.type
-  });
-  if (args.subfolder) {
-    params.set("subfolder", args.subfolder);
-  }
-  const url2 = new URL(
-    `/view?${params.toString()}`,
-    COMFYUI_SERVER_URL
-  ).toString();
+  const url2 = buildViewUrl(args.filename, args.type, args.subfolder);
   return createAgentFacingResult(
-    `View URL generated for ${args.filename}
-${url2}`,
+    [
+      "# 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 }
   );
 }
@@ -31132,6 +31916,77 @@ function createServer() {
     },
     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.registerTool(
+    "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
+      }
+    },
+    handleGetWorkflow
+  );
+  server.registerTool(
+    "comfyui_save_workflow",
+    {
+      title: "Save Workflow",
+      description: "Save a ComfyUI workflow for later reuse.",
+      inputSchema: SaveWorkflowInputSchema,
+      outputSchema: StoredWorkflowSchema,
+      annotations: {
+        openWorldHint: true
+      }
+    },
+    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",
     {
@@ -31147,6 +32002,19 @@ function createServer() {
     },
     handleGetHistory
   );
+  server.registerTool(
+    "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
+      }
+    },
+    handleWaitForWorkflow
+  );
   server.registerTool(
     "comfyui_get_queue",
     {