@workglow/tasks 0.0.96 → 0.0.97

package/dist/bun.js

@@ -1316,6 +1316,14 @@ Workflow13.prototype.multiply = CreateAdaptiveWorkflow(ScalarMultiplyTask, Vecto
 Workflow13.prototype.divide = CreateAdaptiveWorkflow(ScalarDivideTask, VectorDivideTask);
 Workflow13.prototype.sum = CreateAdaptiveWorkflow(ScalarSumTask, VectorSumTask);
 
+// src/common.ts
+import {
+  createMcpClient,
+  mcpClientFactory as mcpClientFactory5,
+  mcpServerConfigSchema as mcpServerConfigSchema5,
+  mcpTransportTypes
+} from "@workglow/util";
+
 // src/task/ArrayTask.ts
 import {
   uuid4
@@ -6451,9 +6459,705 @@ var split = (input2, config = {}) => {
   return task.run(input2);
 };
 Workflow22.prototype.split = CreateWorkflow21(SplitTask);
-// src/task/scalar/ScalarAbsTask.ts
+// src/task/mcp/McpListTask.ts
 import { CreateWorkflow as CreateWorkflow22, Task as Task19, Workflow as Workflow23 } from "@workglow/task-graph";
+import {
+  mcpClientFactory,
+  mcpServerConfigSchema
+} from "@workglow/util";
+var mcpListTypes = ["tools", "resources", "prompts"];
 var inputSchema19 = {
+  type: "object",
+  properties: {
+    ...mcpServerConfigSchema,
+    list_type: {
+      type: "string",
+      enum: mcpListTypes,
+      title: "List Type",
+      description: "The type of items to list from the MCP server"
+    }
+  },
+  required: ["transport", "list_type"],
+  additionalProperties: false
+};
+var iconSchema = {
+  type: "object",
+  properties: {
+    src: { type: "string" },
+    mimeType: { type: "string" },
+    sizes: { type: "array", items: { type: "string" } },
+    theme: { type: "string", enum: ["light", "dark"] }
+  },
+  additionalProperties: false
+};
+var outputSchemaTools = {
+  type: "object",
+  properties: {
+    tools: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          description: { type: "string" },
+          inputSchema: {
+            type: "object",
+            properties: {
+              type: { type: "string" },
+              properties: { type: "object", additionalProperties: true },
+              required: { type: "array", items: { type: "string" } }
+            },
+            additionalProperties: true
+          },
+          outputSchema: {
+            type: "object",
+            properties: {
+              type: { type: "string" },
+              properties: { type: "object", additionalProperties: true },
+              required: { type: "array", items: { type: "string" } }
+            },
+            additionalProperties: true
+          },
+          annotations: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+              readOnlyHint: { type: "boolean" },
+              destructiveHint: { type: "boolean" },
+              idempotentHint: { type: "boolean" },
+              openWorldHint: { type: "boolean" }
+            },
+            additionalProperties: false
+          },
+          execution: {
+            type: "object",
+            properties: {
+              taskSupport: {
+                type: "string",
+                enum: ["optional", "required", "forbidden"]
+              }
+            },
+            additionalProperties: false
+          },
+          _meta: { type: "object", additionalProperties: true },
+          icons: { type: "array", items: iconSchema },
+          title: { type: "string" }
+        },
+        required: ["name", "inputSchema"],
+        additionalProperties: false
+      },
+      title: "Tools",
+      description: "The tools available on the MCP server"
+    }
+  },
+  additionalProperties: false
+};
+var outputSchemaResources = {
+  type: "object",
+  properties: {
+    resources: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          uri: { type: "string" },
+          name: { type: "string" },
+          description: { type: "string" },
+          mimeType: { type: "string" },
+          annotations: {
+            type: "object",
+            properties: {
+              audience: {
+                type: "array",
+                items: { type: "string", enum: ["user", "assistant"] }
+              },
+              priority: { type: "number" },
+              lastModified: { type: "string" }
+            },
+            additionalProperties: false
+          },
+          _meta: { type: "object", additionalProperties: true },
+          icons: { type: "array", items: iconSchema },
+          title: { type: "string" }
+        },
+        required: ["uri", "name"],
+        additionalProperties: false
+      },
+      title: "Resources",
+      description: "The resources available on the MCP server"
+    }
+  },
+  additionalProperties: false
+};
+var outputSchemaPrompts = {
+  type: "object",
+  properties: {
+    prompts: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          description: { type: "string" },
+          arguments: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                description: { type: "string" },
+                required: { type: "boolean" }
+              },
+              required: ["name"],
+              additionalProperties: false
+            }
+          },
+          _meta: { type: "object", additionalProperties: true },
+          icons: { type: "array", items: iconSchema },
+          title: { type: "string" }
+        },
+        required: ["name"],
+        additionalProperties: false
+      },
+      title: "Prompts",
+      description: "The prompts available on the MCP server"
+    }
+  },
+  additionalProperties: false
+};
+var outputSchemaAll = {
+  type: "object",
+  properties: {
+    ...outputSchemaTools.properties,
+    ...outputSchemaResources.properties,
+    ...outputSchemaPrompts.properties
+  },
+  additionalProperties: false
+};
+
+class McpListTask extends Task19 {
+  static type = "McpListTask";
+  static category = "MCP";
+  static title = "MCP List";
+  static description = "Lists tools, resources, or prompts available on an MCP server";
+  static cacheable = false;
+  static hasDynamicSchemas = true;
+  static inputSchema() {
+    return inputSchema19;
+  }
+  static outputSchema() {
+    return outputSchemaAll;
+  }
+  outputSchema() {
+    const listType = this.runInputData?.list_type ?? this.defaults?.list_type ?? null;
+    if (listType === null || listType === undefined) {
+      return outputSchemaAll;
+    }
+    switch (listType) {
+      case "tools":
+        return outputSchemaTools;
+      case "resources":
+        return outputSchemaResources;
+      case "prompts":
+        return outputSchemaPrompts;
+      default:
+        return outputSchemaAll;
+    }
+  }
+  setInput(input2) {
+    if (!("list_type" in input2)) {
+      super.setInput(input2);
+      return;
+    }
+    const previousListType = this.runInputData?.list_type ?? this.defaults?.list_type ?? null;
+    super.setInput(input2);
+    const newListType = this.runInputData?.list_type ?? this.defaults?.list_type ?? null;
+    if (previousListType !== newListType) {
+      this.emitSchemaChange();
+    }
+  }
+  async execute(input2, context) {
+    const { client } = await mcpClientFactory.create(input2, context.signal);
+    try {
+      switch (input2.list_type) {
+        case "tools": {
+          const result = await client.listTools();
+          return { tools: result.tools };
+        }
+        case "resources": {
+          const result = await client.listResources();
+          return { resources: result.resources };
+        }
+        case "prompts": {
+          const result = await client.listPrompts();
+          return { prompts: result.prompts };
+        }
+        default:
+          throw new Error(`Unsupported list type: ${input2.list_type}`);
+      }
+    } finally {
+      await client.close();
+    }
+  }
+}
+var mcpList = async (input2, config = {}) => {
+  return new McpListTask({}, config).run(input2);
+};
+Workflow23.prototype.mcpList = CreateWorkflow22(McpListTask);
+// src/task/mcp/McpPromptGetTask.ts
+import { CreateWorkflow as CreateWorkflow23, Task as Task20, Workflow as Workflow24 } from "@workglow/task-graph";
+import {
+  mcpClientFactory as mcpClientFactory2,
+  mcpServerConfigSchema as mcpServerConfigSchema2
+} from "@workglow/util";
+var inputSchema20 = {
+  type: "object",
+  properties: {
+    ...mcpServerConfigSchema2,
+    prompt_name: {
+      type: "string",
+      title: "Prompt Name",
+      description: "The name of the prompt to get"
+    },
+    prompt_arguments: {
+      type: "object",
+      additionalProperties: { type: "string" },
+      title: "Prompt Arguments",
+      description: "Arguments to pass to the prompt"
+    }
+  },
+  required: ["transport", "prompt_name"],
+  additionalProperties: false
+};
+var annotationsSchema = {
+  type: "object",
+  properties: {
+    audience: {
+      type: "array",
+      items: { type: "string", enum: ["user", "assistant"] }
+    },
+    priority: { type: "number" },
+    lastModified: { type: "string" }
+  },
+  additionalProperties: false
+};
+var contentSchema = {
+  anyOf: [
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", const: "text" },
+        text: { type: "string" },
+        annotations: annotationsSchema,
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["type", "text"],
+      additionalProperties: false
+    },
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", const: "image" },
+        data: { type: "string" },
+        mimeType: { type: "string" },
+        annotations: annotationsSchema,
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["type", "data", "mimeType"],
+      additionalProperties: false
+    },
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", const: "audio" },
+        data: { type: "string" },
+        mimeType: { type: "string" },
+        annotations: annotationsSchema,
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["type", "data", "mimeType"],
+      additionalProperties: false
+    },
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", const: "resource" },
+        resource: {
+          type: "object",
+          properties: {
+            uri: { type: "string" },
+            text: { type: "string" },
+            blob: { type: "string" },
+            mimeType: { type: "string" },
+            _meta: { type: "object", additionalProperties: true }
+          },
+          required: ["uri"],
+          additionalProperties: false
+        },
+        annotations: annotationsSchema,
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["type", "resource"],
+      additionalProperties: false
+    },
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", const: "resource_link" },
+        uri: { type: "string" },
+        name: { type: "string" },
+        description: { type: "string" },
+        mimeType: { type: "string" },
+        annotations: annotationsSchema,
+        icons: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              src: { type: "string" },
+              mimeType: { type: "string" },
+              sizes: { type: "array", items: { type: "string" } },
+              theme: { type: "string", enum: ["light", "dark"] }
+            },
+            additionalProperties: false
+          }
+        },
+        title: { type: "string" },
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["type", "uri", "name"],
+      additionalProperties: false
+    }
+  ]
+};
+var outputSchema19 = {
+  type: "object",
+  properties: {
+    messages: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          role: { type: "string", enum: ["user", "assistant"] },
+          content: contentSchema
+        },
+        required: ["role", "content"],
+        additionalProperties: false
+      },
+      title: "Messages",
+      description: "The messages returned by the prompt"
+    },
+    description: {
+      type: "string",
+      title: "Description",
+      description: "The description of the prompt"
+    }
+  },
+  required: ["messages"],
+  additionalProperties: false
+};
+
+class McpPromptGetTask extends Task20 {
+  static type = "McpPromptGetTask";
+  static category = "MCP";
+  static title = "MCP Get Prompt";
+  static description = "Gets a prompt from an MCP server";
+  static cacheable = false;
+  static inputSchema() {
+    return inputSchema20;
+  }
+  static outputSchema() {
+    return outputSchema19;
+  }
+  async execute(input2, context) {
+    const { client } = await mcpClientFactory2.create(input2, context.signal);
+    try {
+      const result = await client.getPrompt({
+        name: input2.prompt_name,
+        arguments: input2.prompt_arguments
+      });
+      return {
+        messages: result.messages,
+        description: result.description
+      };
+    } finally {
+      await client.close();
+    }
+  }
+}
+var mcpPromptGet = async (input2, config = {}) => {
+  const result = await new McpPromptGetTask({}, config).run(input2);
+  return result;
+};
+Workflow24.prototype.mcpPromptGet = CreateWorkflow23(McpPromptGetTask);
+// src/task/mcp/McpResourceReadTask.ts
+import { CreateWorkflow as CreateWorkflow24, Task as Task21, Workflow as Workflow25 } from "@workglow/task-graph";
+import {
+  mcpClientFactory as mcpClientFactory3,
+  mcpServerConfigSchema as mcpServerConfigSchema3
+} from "@workglow/util";
+var inputSchema21 = {
+  type: "object",
+  properties: {
+    ...mcpServerConfigSchema3,
+    resource_uri: {
+      type: "string",
+      title: "Resource URI",
+      description: "The URI of the resource to read"
+    }
+  },
+  required: ["transport", "resource_uri"],
+  additionalProperties: false
+};
+var contentItemSchema = {
+  anyOf: [
+    {
+      type: "object",
+      properties: {
+        uri: { type: "string" },
+        text: { type: "string" },
+        mimeType: { type: "string" },
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["uri", "text"],
+      additionalProperties: false
+    },
+    {
+      type: "object",
+      properties: {
+        uri: { type: "string" },
+        blob: { type: "string" },
+        mimeType: { type: "string" },
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["uri", "blob"],
+      additionalProperties: false
+    }
+  ]
+};
+var outputSchema20 = {
+  type: "object",
+  properties: {
+    contents: {
+      type: "array",
+      items: contentItemSchema,
+      title: "Contents",
+      description: "The contents of the resource"
+    }
+  },
+  required: ["contents"],
+  additionalProperties: false
+};
+
+class McpResourceReadTask extends Task21 {
+  static type = "McpResourceReadTask";
+  static category = "MCP";
+  static title = "MCP Read Resource";
+  static description = "Reads a resource from an MCP server";
+  static cacheable = false;
+  static inputSchema() {
+    return inputSchema21;
+  }
+  static outputSchema() {
+    return outputSchema20;
+  }
+  async execute(input2, context) {
+    const { client } = await mcpClientFactory3.create(input2, context.signal);
+    try {
+      const result = await client.readResource({ uri: input2.resource_uri });
+      return { contents: result.contents };
+    } finally {
+      await client.close();
+    }
+  }
+}
+var mcpResourceRead = async (input2, config = {}) => {
+  return new McpResourceReadTask({}, config).run(input2);
+};
+Workflow25.prototype.mcpResourceRead = CreateWorkflow24(McpResourceReadTask);
+// src/task/mcp/McpToolCallTask.ts
+import { CreateWorkflow as CreateWorkflow25, Task as Task22, Workflow as Workflow26 } from "@workglow/task-graph";
+import {
+  mcpClientFactory as mcpClientFactory4,
+  mcpServerConfigSchema as mcpServerConfigSchema4
+} from "@workglow/util";
+var inputSchema22 = {
+  type: "object",
+  properties: {
+    ...mcpServerConfigSchema4,
+    tool_name: {
+      type: "string",
+      title: "Tool Name",
+      description: "The name of the tool to call"
+    },
+    tool_arguments: {
+      type: "object",
+      additionalProperties: true,
+      title: "Tool Arguments",
+      description: "Arguments to pass to the tool"
+    }
+  },
+  required: ["transport", "tool_name"],
+  additionalProperties: false
+};
+var annotationsSchema2 = {
+  type: "object",
+  properties: {
+    audience: {
+      type: "array",
+      items: { type: "string", enum: ["user", "assistant"] }
+    },
+    priority: { type: "number" },
+    lastModified: { type: "string" }
+  },
+  additionalProperties: false
+};
+var toolContentSchema = {
+  anyOf: [
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", const: "text" },
+        text: { type: "string" },
+        annotations: annotationsSchema2,
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["type", "text"],
+      additionalProperties: false
+    },
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", const: "image" },
+        data: { type: "string" },
+        mimeType: { type: "string" },
+        annotations: annotationsSchema2,
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["type", "data", "mimeType"],
+      additionalProperties: false
+    },
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", const: "audio" },
+        data: { type: "string" },
+        mimeType: { type: "string" },
+        annotations: annotationsSchema2,
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["type", "data", "mimeType"],
+      additionalProperties: false
+    },
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", const: "resource" },
+        resource: {
+          type: "object",
+          properties: {
+            uri: { type: "string" },
+            text: { type: "string" },
+            blob: { type: "string" },
+            mimeType: { type: "string" },
+            _meta: { type: "object", additionalProperties: true }
+          },
+          required: ["uri"],
+          additionalProperties: false
+        },
+        annotations: annotationsSchema2,
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["type", "resource"],
+      additionalProperties: false
+    },
+    {
+      type: "object",
+      properties: {
+        type: { type: "string", const: "resource_link" },
+        uri: { type: "string" },
+        name: { type: "string" },
+        description: { type: "string" },
+        mimeType: { type: "string" },
+        annotations: annotationsSchema2,
+        icons: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              src: { type: "string" },
+              mimeType: { type: "string" },
+              sizes: { type: "array", items: { type: "string" } },
+              theme: { type: "string", enum: ["light", "dark"] }
+            },
+            additionalProperties: false
+          }
+        },
+        title: { type: "string" },
+        _meta: { type: "object", additionalProperties: true }
+      },
+      required: ["type", "uri", "name"],
+      additionalProperties: false
+    }
+  ]
+};
+var outputSchema21 = {
+  type: "object",
+  properties: {
+    content: {
+      type: "array",
+      items: toolContentSchema,
+      title: "Content",
+      description: "The content returned by the tool"
+    },
+    isError: {
+      type: "boolean",
+      title: "Is Error",
+      description: "Whether the tool call resulted in an error"
+    }
+  },
+  required: ["content", "isError"],
+  additionalProperties: false
+};
+
+class McpToolCallTask extends Task22 {
+  static type = "McpToolCallTask";
+  static category = "MCP";
+  static title = "MCP Call Tool";
+  static description = "Calls a tool on an MCP server and returns the result";
+  static cacheable = false;
+  static inputSchema() {
+    return inputSchema22;
+  }
+  static outputSchema() {
+    return outputSchema21;
+  }
+  async execute(input2, context) {
+    const { client } = await mcpClientFactory4.create(input2, context.signal);
+    try {
+      const result = await client.callTool({
+        name: input2.tool_name,
+        arguments: input2.tool_arguments
+      });
+      if (!("content" in result) || !Array.isArray(result.content)) {
+        throw new Error("Expected tool result with content array");
+      }
+      return {
+        content: result.content,
+        isError: result.isError === true
+      };
+    } finally {
+      await client.close();
+    }
+  }
+}
+var mcpToolCall = async (input2, config = {}) => {
+  return new McpToolCallTask({}, config).run(input2);
+};
+Workflow26.prototype.mcpToolCall = CreateWorkflow25(McpToolCallTask);
+// src/task/scalar/ScalarAbsTask.ts
+import { CreateWorkflow as CreateWorkflow26, Task as Task23, Workflow as Workflow27 } from "@workglow/task-graph";
+var inputSchema23 = {
   type: "object",
   properties: {
     value: {
@@ -6465,7 +7169,7 @@ var inputSchema19 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema19 = {
+var outputSchema22 = {
   type: "object",
   properties: {
     result: {
@@ -6478,25 +7182,25 @@ var outputSchema19 = {
   additionalProperties: false
 };
 
-class ScalarAbsTask extends Task19 {
+class ScalarAbsTask extends Task23 {
   static type = "ScalarAbsTask";
   static category = "Math";
   static title = "Abs";
   static description = "Returns the absolute value of a number";
   static inputSchema() {
-    return inputSchema19;
+    return inputSchema23;
   }
   static outputSchema() {
-    return outputSchema19;
+    return outputSchema22;
   }
   async execute(input2, _context) {
     return { result: Math.abs(input2.value) };
   }
 }
-Workflow23.prototype.scalarAbs = CreateWorkflow22(ScalarAbsTask);
+Workflow27.prototype.scalarAbs = CreateWorkflow26(ScalarAbsTask);
 // src/task/scalar/ScalarCeilTask.ts
-import { CreateWorkflow as CreateWorkflow23, Task as Task20, Workflow as Workflow24 } from "@workglow/task-graph";
-var inputSchema20 = {
+import { CreateWorkflow as CreateWorkflow27, Task as Task24, Workflow as Workflow28 } from "@workglow/task-graph";
+var inputSchema24 = {
   type: "object",
   properties: {
     value: {
@@ -6508,7 +7212,7 @@ var inputSchema20 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema20 = {
+var outputSchema23 = {
   type: "object",
   properties: {
     result: {
@@ -6521,25 +7225,25 @@ var outputSchema20 = {
   additionalProperties: false
 };
 
-class ScalarCeilTask extends Task20 {
+class ScalarCeilTask extends Task24 {
   static type = "ScalarCeilTask";
   static category = "Math";
   static title = "Ceil";
   static description = "Returns the smallest integer greater than or equal to a number";
   static inputSchema() {
-    return inputSchema20;
+    return inputSchema24;
   }
   static outputSchema() {
-    return outputSchema20;
+    return outputSchema23;
   }
   async execute(input2, _context) {
     return { result: Math.ceil(input2.value) };
   }
 }
-Workflow24.prototype.scalarCeil = CreateWorkflow23(ScalarCeilTask);
+Workflow28.prototype.scalarCeil = CreateWorkflow27(ScalarCeilTask);
 // src/task/scalar/ScalarFloorTask.ts
-import { CreateWorkflow as CreateWorkflow24, Task as Task21, Workflow as Workflow25 } from "@workglow/task-graph";
-var inputSchema21 = {
+import { CreateWorkflow as CreateWorkflow28, Task as Task25, Workflow as Workflow29 } from "@workglow/task-graph";
+var inputSchema25 = {
   type: "object",
   properties: {
     value: {
@@ -6551,7 +7255,7 @@ var inputSchema21 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema21 = {
+var outputSchema24 = {
   type: "object",
   properties: {
     result: {
@@ -6564,25 +7268,25 @@ var outputSchema21 = {
   additionalProperties: false
 };
 
-class ScalarFloorTask extends Task21 {
+class ScalarFloorTask extends Task25 {
   static type = "ScalarFloorTask";
   static category = "Math";
   static title = "Floor";
   static description = "Returns the largest integer less than or equal to a number";
   static inputSchema() {
-    return inputSchema21;
+    return inputSchema25;
   }
   static outputSchema() {
-    return outputSchema21;
+    return outputSchema24;
   }
   async execute(input2, _context) {
     return { result: Math.floor(input2.value) };
   }
 }
-Workflow25.prototype.scalarFloor = CreateWorkflow24(ScalarFloorTask);
+Workflow29.prototype.scalarFloor = CreateWorkflow28(ScalarFloorTask);
 // src/task/scalar/ScalarMaxTask.ts
-import { CreateWorkflow as CreateWorkflow25, Task as Task22, Workflow as Workflow26 } from "@workglow/task-graph";
-var inputSchema22 = {
+import { CreateWorkflow as CreateWorkflow29, Task as Task26, Workflow as Workflow30 } from "@workglow/task-graph";
+var inputSchema26 = {
   type: "object",
   properties: {
     values: {
@@ -6595,7 +7299,7 @@ var inputSchema22 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema22 = {
+var outputSchema25 = {
   type: "object",
   properties: {
     result: {
@@ -6608,25 +7312,25 @@ var outputSchema22 = {
   additionalProperties: false
 };
 
-class ScalarMaxTask extends Task22 {
+class ScalarMaxTask extends Task26 {
   static type = "ScalarMaxTask";
   static category = "Math";
   static title = "Max";
   static description = "Returns the largest of the given numbers";
   static inputSchema() {
-    return inputSchema22;
+    return inputSchema26;
   }
   static outputSchema() {
-    return outputSchema22;
+    return outputSchema25;
   }
   async execute(input2, _context) {
     return { result: Math.max(...input2.values) };
   }
 }
-Workflow26.prototype.scalarMax = CreateWorkflow25(ScalarMaxTask);
+Workflow30.prototype.scalarMax = CreateWorkflow29(ScalarMaxTask);
 // src/task/scalar/ScalarMinTask.ts
-import { CreateWorkflow as CreateWorkflow26, Task as Task23, Workflow as Workflow27 } from "@workglow/task-graph";
-var inputSchema23 = {
+import { CreateWorkflow as CreateWorkflow30, Task as Task27, Workflow as Workflow31 } from "@workglow/task-graph";
+var inputSchema27 = {
   type: "object",
   properties: {
     values: {
@@ -6639,7 +7343,7 @@ var inputSchema23 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema23 = {
+var outputSchema26 = {
   type: "object",
   properties: {
     result: {
@@ -6652,25 +7356,25 @@ var outputSchema23 = {
   additionalProperties: false
 };
 
-class ScalarMinTask extends Task23 {
+class ScalarMinTask extends Task27 {
   static type = "ScalarMinTask";
   static category = "Math";
   static title = "Min";
   static description = "Returns the smallest of the given numbers";
   static inputSchema() {
-    return inputSchema23;
+    return inputSchema27;
   }
   static outputSchema() {
-    return outputSchema23;
+    return outputSchema26;
   }
   async execute(input2, _context) {
     return { result: Math.min(...input2.values) };
   }
 }
-Workflow27.prototype.scalarMin = CreateWorkflow26(ScalarMinTask);
+Workflow31.prototype.scalarMin = CreateWorkflow30(ScalarMinTask);
 // src/task/scalar/ScalarRoundTask.ts
-import { CreateWorkflow as CreateWorkflow27, Task as Task24, Workflow as Workflow28 } from "@workglow/task-graph";
-var inputSchema24 = {
+import { CreateWorkflow as CreateWorkflow31, Task as Task28, Workflow as Workflow32 } from "@workglow/task-graph";
+var inputSchema28 = {
   type: "object",
   properties: {
     value: {
@@ -6682,7 +7386,7 @@ var inputSchema24 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema24 = {
+var outputSchema27 = {
   type: "object",
   properties: {
     result: {
@@ -6695,25 +7399,25 @@ var outputSchema24 = {
   additionalProperties: false
 };
 
-class ScalarRoundTask extends Task24 {
+class ScalarRoundTask extends Task28 {
   static type = "ScalarRoundTask";
   static category = "Math";
   static title = "Round";
   static description = "Returns the value of a number rounded to the nearest integer";
   static inputSchema() {
-    return inputSchema24;
+    return inputSchema28;
   }
   static outputSchema() {
-    return outputSchema24;
+    return outputSchema27;
   }
   async execute(input2, _context) {
     return { result: Math.round(input2.value) };
   }
 }
-Workflow28.prototype.scalarRound = CreateWorkflow27(ScalarRoundTask);
+Workflow32.prototype.scalarRound = CreateWorkflow31(ScalarRoundTask);
 // src/task/scalar/ScalarTruncTask.ts
-import { CreateWorkflow as CreateWorkflow28, Task as Task25, Workflow as Workflow29 } from "@workglow/task-graph";
-var inputSchema25 = {
+import { CreateWorkflow as CreateWorkflow32, Task as Task29, Workflow as Workflow33 } from "@workglow/task-graph";
+var inputSchema29 = {
   type: "object",
   properties: {
     value: {
@@ -6725,7 +7429,7 @@ var inputSchema25 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema25 = {
+var outputSchema28 = {
   type: "object",
   properties: {
     result: {
@@ -6738,28 +7442,28 @@ var outputSchema25 = {
   additionalProperties: false
 };
 
-class ScalarTruncTask extends Task25 {
+class ScalarTruncTask extends Task29 {
   static type = "ScalarTruncTask";
   static category = "Math";
   static title = "Truncate";
   static description = "Returns the integer part of a number by removing fractional digits";
   static inputSchema() {
-    return inputSchema25;
+    return inputSchema29;
   }
   static outputSchema() {
-    return outputSchema25;
+    return outputSchema28;
   }
   async execute(input2, _context) {
     return { result: Math.trunc(input2.value) };
   }
 }
-Workflow29.prototype.scalarTrunc = CreateWorkflow28(ScalarTruncTask);
+Workflow33.prototype.scalarTrunc = CreateWorkflow32(ScalarTruncTask);
 // src/task/vector/VectorDistanceTask.ts
-import { CreateWorkflow as CreateWorkflow29, Task as Task26, Workflow as Workflow30 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow33, Task as Task30, Workflow as Workflow34 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util";
-var inputSchema26 = {
+var inputSchema30 = {
   type: "object",
   properties: {
     vectors: {
@@ -6775,7 +7479,7 @@ var inputSchema26 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema26 = {
+var outputSchema29 = {
   type: "object",
   properties: {
     result: {
@@ -6788,16 +7492,16 @@ var outputSchema26 = {
   additionalProperties: false
 };
 
-class VectorDistanceTask extends Task26 {
+class VectorDistanceTask extends Task30 {
   static type = "VectorDistanceTask";
   static category = "Vector";
   static title = "Distance";
   static description = "Returns the Euclidean distance between the first two vectors";
   static inputSchema() {
-    return inputSchema26;
+    return inputSchema30;
   }
   static outputSchema() {
-    return outputSchema26;
+    return outputSchema29;
   }
   async execute(input2, _context) {
     const { vectors } = input2;
@@ -6815,13 +7519,13 @@ class VectorDistanceTask extends Task26 {
     return { result: Math.sqrt(sumPrecise(diffs)) };
   }
 }
-Workflow30.prototype.vectorDistance = CreateWorkflow29(VectorDistanceTask);
+Workflow34.prototype.vectorDistance = CreateWorkflow33(VectorDistanceTask);
 // src/task/vector/VectorDotProductTask.ts
-import { CreateWorkflow as CreateWorkflow30, Task as Task27, Workflow as Workflow31 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow34, Task as Task31, Workflow as Workflow35 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema6
 } from "@workglow/util";
-var inputSchema27 = {
+var inputSchema31 = {
   type: "object",
   properties: {
     vectors: {
@@ -6837,7 +7541,7 @@ var inputSchema27 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema27 = {
+var outputSchema30 = {
   type: "object",
   properties: {
     result: {
@@ -6850,16 +7554,16 @@ var outputSchema27 = {
   additionalProperties: false
 };
 
-class VectorDotProductTask extends Task27 {
+class VectorDotProductTask extends Task31 {
   static type = "VectorDotProductTask";
   static category = "Vector";
   static title = "Dot Product";
   static description = "Returns the dot (inner) product of the first two vectors";
   static inputSchema() {
-    return inputSchema27;
+    return inputSchema31;
   }
   static outputSchema() {
-    return outputSchema27;
+    return outputSchema30;
   }
   async execute(input2, _context) {
     const { vectors } = input2;
@@ -6874,14 +7578,14 @@ class VectorDotProductTask extends Task27 {
     return { result: sumPrecise(products) };
   }
 }
-Workflow31.prototype.vectorDotProduct = CreateWorkflow30(VectorDotProductTask);
+Workflow35.prototype.vectorDotProduct = CreateWorkflow34(VectorDotProductTask);
 // src/task/vector/VectorNormalizeTask.ts
-import { CreateWorkflow as CreateWorkflow31, Task as Task28, Workflow as Workflow32 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow35, Task as Task32, Workflow as Workflow36 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema7,
   normalize
 } from "@workglow/util";
-var inputSchema28 = {
+var inputSchema32 = {
   type: "object",
   properties: {
     vector: TypedArraySchema7({
@@ -6892,7 +7596,7 @@ var inputSchema28 = {
   required: ["vector"],
   additionalProperties: false
 };
-var outputSchema28 = {
+var outputSchema31 = {
   type: "object",
   properties: {
     result: TypedArraySchema7({
@@ -6904,29 +7608,29 @@ var outputSchema28 = {
   additionalProperties: false
 };
 
-class VectorNormalizeTask extends Task28 {
+class VectorNormalizeTask extends Task32 {
   static type = "VectorNormalizeTask";
   static category = "Vector";
   static title = "Normalize";
   static description = "Returns the L2-normalized (unit length) vector";
   static inputSchema() {
-    return inputSchema28;
+    return inputSchema32;
   }
   static outputSchema() {
-    return outputSchema28;
+    return outputSchema31;
   }
   async execute(input2, _context) {
     return { result: normalize(input2.vector) };
   }
 }
-Workflow32.prototype.vectorNormalize = CreateWorkflow31(VectorNormalizeTask);
+Workflow36.prototype.vectorNormalize = CreateWorkflow35(VectorNormalizeTask);
 // src/task/vector/VectorScaleTask.ts
-import { CreateWorkflow as CreateWorkflow32, Task as Task29, Workflow as Workflow33 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow36, Task as Task33, Workflow as Workflow37 } from "@workglow/task-graph";
 import {
   createTypedArrayFrom as createTypedArrayFrom5,
   TypedArraySchema as TypedArraySchema8
 } from "@workglow/util";
-var inputSchema29 = {
+var inputSchema33 = {
   type: "object",
   properties: {
     vector: TypedArraySchema8({
@@ -6942,7 +7646,7 @@ var inputSchema29 = {
   required: ["vector", "scalar"],
   additionalProperties: false
 };
-var outputSchema29 = {
+var outputSchema32 = {
   type: "object",
   properties: {
     result: TypedArraySchema8({
@@ -6954,16 +7658,16 @@ var outputSchema29 = {
   additionalProperties: false
 };
 
-class VectorScaleTask extends Task29 {
+class VectorScaleTask extends Task33 {
   static type = "VectorScaleTask";
   static category = "Vector";
   static title = "Scale";
   static description = "Multiplies each element of a vector by a scalar";
   static inputSchema() {
-    return inputSchema29;
+    return inputSchema33;
   }
   static outputSchema() {
-    return outputSchema29;
+    return outputSchema32;
   }
   async execute(input2, _context) {
     const { vector, scalar } = input2;
@@ -6971,7 +7675,7 @@ class VectorScaleTask extends Task29 {
     return { result: createTypedArrayFrom5([vector], values) };
   }
 }
-Workflow33.prototype.vectorScale = CreateWorkflow32(VectorScaleTask);
+Workflow37.prototype.vectorScale = CreateWorkflow36(VectorScaleTask);
 
 // src/common.ts
 import { TaskRegistry } from "@workglow/task-graph";
@@ -7006,7 +7710,11 @@ var registerCommonTasks = () => {
     VectorMultiplyTask,
     VectorNormalizeTask,
     VectorScaleTask,
-    VectorSubtractTask
+    VectorSubtractTask,
+    McpToolCallTask,
+    McpResourceReadTask,
+    McpPromptGetTask,
+    McpListTask
   ];
   tasks.map(TaskRegistry.registerTask);
   return tasks;
@@ -7019,6 +7727,13 @@ export {
   registerCommonTasks,
   process,
   merge,
+  mcpTransportTypes,
+  mcpToolCall,
+  mcpServerConfigSchema5 as mcpServerConfigSchema,
+  mcpResourceRead,
+  mcpPromptGet,
+  mcpList,
+  mcpClientFactory5 as mcpClientFactory,
   lambda,
   json,
   javaScript,
@@ -7026,6 +7741,7 @@ export {
   fetchUrl,
   delay,
   debugLog,
+  createMcpClient,
   VectorSumTask,
   VectorSubtractTask,
   VectorScaleTask,
@@ -7050,6 +7766,10 @@ export {
   ScalarAbsTask,
   OutputTask,
   MergeTask,
+  McpToolCallTask,
+  McpResourceReadTask,
+  McpPromptGetTask,
+  McpListTask,
   LambdaTask,
   JsonTask,
   JavaScriptTask,
@@ -7062,4 +7782,4 @@ export {
   ArrayTask
 };
 
-//# debugId=A21D807CC9BF707864756E2164756E21
+//# debugId=D4A2128BDA8D6B2F64756E2164756E21