@workglow/tasks 0.0.100 → 0.0.102

package/dist/browser.js

@@ -1150,14 +1150,6 @@ Workflow12.prototype.multiply = CreateAdaptiveWorkflow(ScalarMultiplyTask, Vecto
 Workflow12.prototype.divide = CreateAdaptiveWorkflow(ScalarDivideTask, VectorDivideTask);
 Workflow12.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
@@ -1213,7 +1205,7 @@ class ArrayTask extends GraphAsTask {
     const inputObject = Object.fromEntries(arrayInputs);
     const combinations = this.generateCombinations(inputObject, inputIds);
     const tasks = combinations.map((combination) => {
-      const { id, name, ...rest } = this.config;
+      const { id, title, ...rest } = this.config;
       const task = new this.constructor({ ...this.defaults, ...this.runInputData, ...combination }, { ...rest, id: `${id}_${uuid4()}` });
       return task;
     });
@@ -1286,16 +1278,13 @@ class ArrayTaskRunner extends GraphAsTaskRunner {
   }
 }
 // src/task/DebugLogTask.ts
-import { CreateWorkflow as CreateWorkflow12, Task as Task11, Workflow as Workflow13 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow12, Task as Task11, TaskConfigSchema, Workflow as Workflow13 } from "@workglow/task-graph";
 var log_levels = ["dir", "log", "debug", "info", "warn", "error"];
 var DEFAULT_LOG_LEVEL = "log";
-var inputSchema12 = {
+var debugLogTaskConfigSchema = {
   type: "object",
   properties: {
-    console: {
-      title: "Message",
-      description: "The message to log"
-    },
+    ...TaskConfigSchema["properties"],
     log_level: {
       type: "string",
       enum: log_levels,
@@ -1306,15 +1295,15 @@ var inputSchema12 = {
   },
   additionalProperties: false
 };
+var inputSchema12 = {
+  type: "object",
+  properties: {},
+  additionalProperties: true
+};
 var outputSchema12 = {
   type: "object",
-  properties: {
-    console: {
-      title: "Messages",
-      description: "The messages logged by the task"
-    }
-  },
-  additionalProperties: false
+  properties: {},
+  additionalProperties: true
 };
 
 class DebugLogTask extends Task11 {
@@ -1323,6 +1312,11 @@ class DebugLogTask extends Task11 {
   static title = "Debug Log";
   static description = "Logs messages to the console with configurable log levels for debugging task graphs";
   static cacheable = false;
+  static passthroughInputsToOutputs = true;
+  static customizable = true;
+  static configSchema() {
+    return debugLogTaskConfigSchema;
+  }
   static inputSchema() {
     return inputSchema12;
   }
@@ -1330,13 +1324,14 @@ class DebugLogTask extends Task11 {
     return outputSchema12;
   }
   async executeReactive(input, output) {
-    const { log_level = DEFAULT_LOG_LEVEL, console: messages } = input;
-    if (log_level == "dir") {
-      console.dir(messages, { depth: null });
+    const log_level = this.config.log_level ?? DEFAULT_LOG_LEVEL;
+    const inputRecord = input;
+    if (log_level === "dir") {
+      console.dir(inputRecord, { depth: null });
     } else {
-      console[log_level](messages);
+      console[log_level](inputRecord);
     }
-    output.console = input.console;
+    Object.assign(output, inputRecord);
     return output;
   }
 }
@@ -1350,24 +1345,27 @@ import {
   CreateWorkflow as CreateWorkflow13,
   Task as Task12,
   TaskAbortedError as TaskAbortedError2,
+  TaskConfigSchema as TaskConfigSchema2,
   Workflow as Workflow14
 } from "@workglow/task-graph";
 import { sleep } from "@workglow/util";
-var inputSchema13 = {
+var delayTaskConfigSchema = {
   type: "object",
   properties: {
+    ...TaskConfigSchema2["properties"],
     delay: {
       type: "number",
       title: "Delay (ms)",
       default: 1
-    },
-    pass_through: {
-      title: "Pass Through",
-      description: "Pass through data to the output"
     }
   },
   additionalProperties: false
 };
+var inputSchema13 = {
+  type: "object",
+  properties: {},
+  additionalProperties: true
+};
 var outputSchema13 = {
   type: "object",
   properties: {},
@@ -1379,6 +1377,12 @@ class DelayTask extends Task12 {
   static category = "Utility";
   static title = "Delay";
   static description = "Delays execution for a specified duration with progress tracking";
+  static cacheable = false;
+  static passthroughInputsToOutputs = true;
+  static customizable = true;
+  static configSchema() {
+    return delayTaskConfigSchema;
+  }
   static inputSchema() {
     return inputSchema13;
   }
@@ -1386,7 +1390,7 @@ class DelayTask extends Task12 {
     return outputSchema13;
   }
   async execute(input, executeContext) {
-    const delay = input.delay ?? 0;
+    const delay = this.config.delay ?? 1;
     if (delay > 100) {
       const iterations = Math.min(100, Math.floor(delay / 16));
       const chunkSize = delay / iterations;
@@ -1400,10 +1404,10 @@ class DelayTask extends Task12 {
     } else {
       await sleep(delay);
     }
-    return input.pass_through;
+    return input;
   }
 }
-var delay = (input, config = {}) => {
+var delay = (input, config = { delay: 1 }) => {
   const task = new DelayTask({}, config);
   return task.run(input);
 };
@@ -1433,10 +1437,10 @@ class InputTask extends Task13 {
     };
   }
   inputSchema() {
-    return this.config?.extras?.inputSchema ?? this.constructor.inputSchema();
+    return this.config?.inputSchema ?? this.constructor.inputSchema();
   }
   outputSchema() {
-    return this.config?.extras?.outputSchema ?? this.constructor.outputSchema();
+    return this.config?.outputSchema ?? this.constructor.outputSchema();
   }
   async execute(input) {
     return input;
@@ -1467,7 +1471,7 @@ class InputTask extends Task13 {
 }
 Workflow15.prototype.input = CreateWorkflow14(InputTask);
 // src/task/JavaScriptTask.ts
-import { CreateWorkflow as CreateWorkflow15, Task as Task14, Workflow as Workflow16 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow15, Task as Task14, TaskConfigSchema as TaskConfigSchema3, Workflow as Workflow16 } from "@workglow/task-graph";
 
 // src/util/acorn.js
 var options;
@@ -5930,6 +5934,20 @@ Interpreter["VALUE_IN_DESCRIPTOR"] = Interpreter.VALUE_IN_DESCRIPTOR;
 Interpreter["Status"] = Interpreter.Status;
 
 // src/task/JavaScriptTask.ts
+var configSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema3["properties"],
+    javascript_code: {
+      type: "string",
+      title: "Code",
+      minLength: 1,
+      description: "JavaScript code to execute",
+      format: "code:javascript"
+    }
+  },
+  additionalProperties: false
+};
 var inputSchema14 = {
   type: "object",
   properties: {
@@ -5961,14 +5979,34 @@ class JavaScriptTask extends Task14 {
   static category = "Utility";
   static title = "JavaScript Interpreter";
   static description = "Executes JavaScript code in a sandboxed interpreter environment";
+  static customizable = true;
+  static configSchema() {
+    return configSchema;
+  }
   static inputSchema() {
     return inputSchema14;
   }
   static outputSchema() {
     return outputSchema14;
   }
+  constructor(input2 = {}, config = {}) {
+    super(input2, config);
+  }
+  inputSchema() {
+    if (this.config?.javascript_code) {
+      if (this.config.inputSchema) {
+        return this.config.inputSchema;
+      }
+      return {
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      };
+    }
+    return inputSchema14;
+  }
   async executeReactive(input2, output) {
-    if (input2.javascript_code) {
+    if (this.config.javascript_code || input2.javascript_code) {
       try {
         const inputVariables = Object.keys(input2).filter((key) => key !== "javascript_code");
         const inputVariablesString = inputVariables.map((key) => `var ${key} = ${JSON.stringify(input2[key])};`).join(`
@@ -6066,9 +6104,19 @@ import {
   CreateWorkflow as CreateWorkflow17,
   DATAFLOW_ALL_PORTS,
   Task as Task15,
+  TaskConfigSchema as TaskConfigSchema4,
   TaskConfigurationError as TaskConfigurationError3,
   Workflow as Workflow18
 } from "@workglow/task-graph";
+var lambdaTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema4["properties"],
+    execute: {},
+    executeReactive: {}
+  },
+  additionalProperties: false
+};
 var inputSchema16 = {
   type: "object",
   properties: {
@@ -6096,6 +6144,9 @@ class LambdaTask extends Task15 {
   static description = "A task that wraps a provided function and its input";
   static category = "Hidden";
   static cacheable = true;
+  static configSchema() {
+    return lambdaTaskConfigSchema;
+  }
   static inputSchema() {
     return inputSchema16;
   }
@@ -6208,10 +6259,10 @@ class OutputTask extends Task17 {
     };
   }
   inputSchema() {
-    return this.config?.extras?.inputSchema ?? this.constructor.inputSchema();
+    return this.config?.inputSchema ?? this.constructor.inputSchema();
   }
   outputSchema() {
-    return this.config?.extras?.outputSchema ?? this.constructor.outputSchema();
+    return this.config?.outputSchema ?? this.constructor.outputSchema();
   }
   async execute(input2) {
     return input2;
@@ -6539,28 +6590,32 @@ var mcpList = async (input2, config = {}) => {
 };
 Workflow22.prototype.mcpList = CreateWorkflow21(McpListTask);
 // src/task/mcp/McpPromptGetTask.ts
-import { CreateWorkflow as CreateWorkflow22, Task as Task20, Workflow as Workflow23 } from "@workglow/task-graph";
+import {
+  CreateWorkflow as CreateWorkflow22,
+  Task as Task20,
+  TaskConfigSchema as TaskConfigSchema5,
+  Workflow as Workflow23
+} from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory2,
   mcpServerConfigSchema as mcpServerConfigSchema2
 } from "@workglow/util";
-var inputSchema20 = {
+var configSchema2 = {
   type: "object",
   properties: {
+    ...TaskConfigSchema5["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"
+      description: "The name of the prompt to get",
+      format: "string:mcp-promptname"
     }
   },
   required: ["transport", "prompt_name"],
+  if: { properties: { transport: { const: "stdio" } }, required: ["transport"] },
+  then: { required: ["command"] },
+  else: { required: ["server_url"] },
   additionalProperties: false
 };
 var annotationsSchema = {
@@ -6664,7 +6719,7 @@ var contentSchema = {
     }
   ]
 };
-var outputSchema19 = {
+var fallbackOutputSchema = {
   type: "object",
   properties: {
     messages: {
@@ -6690,6 +6745,11 @@ var outputSchema19 = {
   required: ["messages"],
   additionalProperties: false
 };
+var fallbackInputSchema = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
 
 class McpPromptGetTask extends Task20 {
   static type = "McpPromptGetTask";
@@ -6697,18 +6757,71 @@ class McpPromptGetTask extends Task20 {
   static title = "MCP Get Prompt";
   static description = "Gets a prompt from an MCP server";
   static cacheable = false;
+  static customizable = true;
+  static hasDynamicSchemas = true;
   static inputSchema() {
-    return inputSchema20;
+    return fallbackInputSchema;
   }
   static outputSchema() {
-    return outputSchema19;
+    return fallbackOutputSchema;
+  }
+  static configSchema() {
+    return configSchema2;
+  }
+  inputSchema() {
+    return this.config?.inputSchema ?? fallbackInputSchema;
+  }
+  outputSchema() {
+    return this.config?.outputSchema ?? fallbackOutputSchema;
+  }
+  _schemasDiscovering = false;
+  async discoverSchemas(signal) {
+    if (this.config.inputSchema)
+      return;
+    if (this._schemasDiscovering)
+      return;
+    if (!this.config.transport || !this.config.prompt_name)
+      return;
+    this._schemasDiscovering = true;
+    try {
+      const result = await mcpList({
+        transport: this.config.transport,
+        server_url: this.config.server_url,
+        command: this.config.command,
+        args: this.config.args,
+        env: this.config.env,
+        list_type: "prompts"
+      });
+      const prompt = result.prompts?.find((p) => p.name === this.config.prompt_name);
+      if (prompt) {
+        const args = prompt.arguments ?? [];
+        const required = args.filter((a) => a.required).map((a) => a.name);
+        const properties = {};
+        for (const arg of args) {
+          properties[arg.name] = {
+            type: "string",
+            ...arg.description ? { description: arg.description } : {}
+          };
+        }
+        this.config.inputSchema = {
+          type: "object",
+          properties,
+          ...required.length > 0 ? { required } : {},
+          additionalProperties: false
+        };
+        this.emitSchemaChange();
+      }
+    } finally {
+      this._schemasDiscovering = false;
+    }
   }
   async execute(input2, context) {
-    const { client } = await mcpClientFactory2.create(input2, context.signal);
+    await this.discoverSchemas(context.signal);
+    const { client } = await mcpClientFactory2.create(this.config, context.signal);
     try {
       const result = await client.getPrompt({
-        name: input2.prompt_name,
-        arguments: input2.prompt_arguments
+        name: this.config.prompt_name,
+        arguments: input2
       });
       return {
         messages: result.messages,
@@ -6719,28 +6832,37 @@ class McpPromptGetTask extends Task20 {
     }
   }
 }
-var mcpPromptGet = async (input2, config = {}) => {
-  const result = await new McpPromptGetTask({}, config).run(input2);
-  return result;
+var mcpPromptGet = async (input2, config) => {
+  return new McpPromptGetTask({}, config).run(input2);
 };
 Workflow23.prototype.mcpPromptGet = CreateWorkflow22(McpPromptGetTask);
 // src/task/mcp/McpResourceReadTask.ts
-import { CreateWorkflow as CreateWorkflow23, Task as Task21, Workflow as Workflow24 } from "@workglow/task-graph";
+import {
+  CreateWorkflow as CreateWorkflow23,
+  Task as Task21,
+  TaskConfigSchema as TaskConfigSchema6,
+  Workflow as Workflow24
+} from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory3,
   mcpServerConfigSchema as mcpServerConfigSchema3
 } from "@workglow/util";
-var inputSchema21 = {
+var configSchema3 = {
   type: "object",
   properties: {
+    ...TaskConfigSchema6["properties"],
     ...mcpServerConfigSchema3,
     resource_uri: {
       type: "string",
       title: "Resource URI",
-      description: "The URI of the resource to read"
+      description: "The URI of the resource to read",
+      format: "string:uri:mcp-resourceuri"
     }
   },
   required: ["transport", "resource_uri"],
+  if: { properties: { transport: { const: "stdio" } }, required: ["transport"] },
+  then: { required: ["command"] },
+  else: { required: ["server_url"] },
   additionalProperties: false
 };
 var contentItemSchema = {
@@ -6769,7 +6891,12 @@ var contentItemSchema = {
     }
   ]
 };
-var outputSchema20 = {
+var inputSchema20 = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+var outputSchema19 = {
   type: "object",
   properties: {
     contents: {
@@ -6789,49 +6916,57 @@ class McpResourceReadTask extends Task21 {
   static title = "MCP Read Resource";
   static description = "Reads a resource from an MCP server";
   static cacheable = false;
+  static customizable = true;
   static inputSchema() {
-    return inputSchema21;
+    return inputSchema20;
   }
   static outputSchema() {
-    return outputSchema20;
+    return outputSchema19;
   }
-  async execute(input2, context) {
-    const { client } = await mcpClientFactory3.create(input2, context.signal);
+  static configSchema() {
+    return configSchema3;
+  }
+  async execute(_input, context) {
+    const { client } = await mcpClientFactory3.create(this.config, context.signal);
     try {
-      const result = await client.readResource({ uri: input2.resource_uri });
+      const result = await client.readResource({ uri: this.config.resource_uri });
       return { contents: result.contents };
     } finally {
       await client.close();
     }
   }
 }
-var mcpResourceRead = async (input2, config = {}) => {
-  return new McpResourceReadTask({}, config).run(input2);
+var mcpResourceRead = async (config) => {
+  return new McpResourceReadTask({}, config).run({});
 };
 Workflow24.prototype.mcpResourceRead = CreateWorkflow23(McpResourceReadTask);
 // src/task/mcp/McpToolCallTask.ts
-import { CreateWorkflow as CreateWorkflow24, Task as Task22, Workflow as Workflow25 } from "@workglow/task-graph";
+import {
+  CreateWorkflow as CreateWorkflow24,
+  Task as Task22,
+  TaskConfigSchema as TaskConfigSchema7,
+  Workflow as Workflow25
+} from "@workglow/task-graph";
 import {
   mcpClientFactory as mcpClientFactory4,
   mcpServerConfigSchema as mcpServerConfigSchema4
 } from "@workglow/util";
-var inputSchema22 = {
+var configSchema4 = {
   type: "object",
   properties: {
+    ...TaskConfigSchema7["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"
+      description: "The name of the tool to call",
+      format: "string:mcp-toolname"
     }
   },
   required: ["transport", "tool_name"],
+  if: { properties: { transport: { const: "stdio" } }, required: ["transport"] },
+  then: { required: ["command"] },
+  else: { required: ["server_url"] },
   additionalProperties: false
 };
 var annotationsSchema2 = {
@@ -6935,7 +7070,7 @@ var toolContentSchema = {
     }
   ]
 };
-var outputSchema21 = {
+var fallbackOutputSchema2 = {
   type: "object",
   properties: {
     content: {
@@ -6953,6 +7088,11 @@ var outputSchema21 = {
   required: ["content", "isError"],
   additionalProperties: false
 };
+var fallbackInputSchema2 = {
+  type: "object",
+  properties: {},
+  additionalProperties: true
+};
 
 class McpToolCallTask extends Task22 {
   static type = "McpToolCallTask";
@@ -6960,38 +7100,103 @@ class McpToolCallTask extends Task22 {
   static title = "MCP Call Tool";
   static description = "Calls a tool on an MCP server and returns the result";
   static cacheable = false;
+  static customizable = true;
+  static hasDynamicSchemas = true;
   static inputSchema() {
-    return inputSchema22;
+    return fallbackInputSchema2;
   }
   static outputSchema() {
-    return outputSchema21;
+    return fallbackOutputSchema2;
+  }
+  static configSchema() {
+    return configSchema4;
+  }
+  inputSchema() {
+    return this.config?.inputSchema ?? fallbackInputSchema2;
+  }
+  outputSchema() {
+    return this.config?.outputSchema ?? fallbackOutputSchema2;
+  }
+  _schemasDiscovering = false;
+  async discoverSchemas(signal) {
+    if (this.config.inputSchema && this.config.outputSchema)
+      return;
+    if (this._schemasDiscovering)
+      return;
+    if (!this.config.transport || !this.config.tool_name)
+      return;
+    this._schemasDiscovering = true;
+    try {
+      const result = await mcpList({
+        transport: this.config.transport,
+        server_url: this.config.server_url,
+        command: this.config.command,
+        args: this.config.args,
+        env: this.config.env,
+        list_type: "tools"
+      });
+      const tool = result.tools?.find((t) => t.name === this.config.tool_name);
+      if (tool) {
+        if (!this.config.inputSchema) {
+          this.config.inputSchema = tool.inputSchema;
+        }
+        if (!this.config.outputSchema && tool.outputSchema) {
+          this.config.outputSchema = tool.outputSchema;
+        }
+        this.emitSchemaChange();
+      }
+    } finally {
+      this._schemasDiscovering = false;
+    }
   }
   async execute(input2, context) {
-    const { client } = await mcpClientFactory4.create(input2, context.signal);
+    await this.discoverSchemas(context.signal);
+    const { client } = await mcpClientFactory4.create(this.config, context.signal);
     try {
       const result = await client.callTool({
-        name: input2.tool_name,
-        arguments: input2.tool_arguments
+        name: this.config.tool_name,
+        arguments: input2
       });
       if (!("content" in result) || !Array.isArray(result.content)) {
         throw new Error("Expected tool result with content array");
       }
+      const content = result.content;
+      const isError = result.isError === true;
+      const structuredContent = "structuredContent" in result && result.structuredContent && typeof result.structuredContent === "object" && !Array.isArray(result.structuredContent) ? result.structuredContent : undefined;
+      let parsedFromText;
+      if (!structuredContent && content.length === 1) {
+        const item = content[0];
+        if (item && typeof item === "object" && "type" in item && item.type === "text" && "text" in item) {
+          const text = String(item.text);
+          const trimmed = text.trim();
+          if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+            try {
+              const parsed = JSON.parse(text);
+              if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+                parsedFromText = parsed;
+              }
+            } catch {}
+          }
+        }
+      }
       return {
-        content: result.content,
-        isError: result.isError === true
+        content,
+        isError,
+        ...parsedFromText,
+        ...structuredContent
       };
     } finally {
       await client.close();
     }
   }
 }
-var mcpToolCall = async (input2, config = {}) => {
+var mcpToolCall = async (input2, config) => {
   return new McpToolCallTask({}, config).run(input2);
 };
 Workflow25.prototype.mcpToolCall = CreateWorkflow24(McpToolCallTask);
 // src/task/scalar/ScalarAbsTask.ts
 import { CreateWorkflow as CreateWorkflow25, Task as Task23, Workflow as Workflow26 } from "@workglow/task-graph";
-var inputSchema23 = {
+var inputSchema21 = {
   type: "object",
   properties: {
     value: {
@@ -7003,7 +7208,7 @@ var inputSchema23 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema22 = {
+var outputSchema20 = {
   type: "object",
   properties: {
     result: {
@@ -7022,10 +7227,10 @@ class ScalarAbsTask extends Task23 {
   static title = "Abs";
   static description = "Returns the absolute value of a number";
   static inputSchema() {
-    return inputSchema23;
+    return inputSchema21;
   }
   static outputSchema() {
-    return outputSchema22;
+    return outputSchema20;
   }
   async execute(input2, _context) {
     return { result: Math.abs(input2.value) };
@@ -7034,7 +7239,7 @@ class ScalarAbsTask extends Task23 {
 Workflow26.prototype.scalarAbs = CreateWorkflow25(ScalarAbsTask);
 // src/task/scalar/ScalarCeilTask.ts
 import { CreateWorkflow as CreateWorkflow26, Task as Task24, Workflow as Workflow27 } from "@workglow/task-graph";
-var inputSchema24 = {
+var inputSchema22 = {
   type: "object",
   properties: {
     value: {
@@ -7046,7 +7251,7 @@ var inputSchema24 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema23 = {
+var outputSchema21 = {
   type: "object",
   properties: {
     result: {
@@ -7065,10 +7270,10 @@ class ScalarCeilTask extends Task24 {
   static title = "Ceil";
   static description = "Returns the smallest integer greater than or equal to a number";
   static inputSchema() {
-    return inputSchema24;
+    return inputSchema22;
   }
   static outputSchema() {
-    return outputSchema23;
+    return outputSchema21;
   }
   async execute(input2, _context) {
     return { result: Math.ceil(input2.value) };
@@ -7077,7 +7282,7 @@ class ScalarCeilTask extends Task24 {
 Workflow27.prototype.scalarCeil = CreateWorkflow26(ScalarCeilTask);
 // src/task/scalar/ScalarFloorTask.ts
 import { CreateWorkflow as CreateWorkflow27, Task as Task25, Workflow as Workflow28 } from "@workglow/task-graph";
-var inputSchema25 = {
+var inputSchema23 = {
   type: "object",
   properties: {
     value: {
@@ -7089,7 +7294,7 @@ var inputSchema25 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema24 = {
+var outputSchema22 = {
   type: "object",
   properties: {
     result: {
@@ -7108,10 +7313,10 @@ class ScalarFloorTask extends Task25 {
   static title = "Floor";
   static description = "Returns the largest integer less than or equal to a number";
   static inputSchema() {
-    return inputSchema25;
+    return inputSchema23;
   }
   static outputSchema() {
-    return outputSchema24;
+    return outputSchema22;
   }
   async execute(input2, _context) {
     return { result: Math.floor(input2.value) };
@@ -7120,7 +7325,7 @@ class ScalarFloorTask extends Task25 {
 Workflow28.prototype.scalarFloor = CreateWorkflow27(ScalarFloorTask);
 // src/task/scalar/ScalarMaxTask.ts
 import { CreateWorkflow as CreateWorkflow28, Task as Task26, Workflow as Workflow29 } from "@workglow/task-graph";
-var inputSchema26 = {
+var inputSchema24 = {
   type: "object",
   properties: {
     values: {
@@ -7133,7 +7338,7 @@ var inputSchema26 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema25 = {
+var outputSchema23 = {
   type: "object",
   properties: {
     result: {
@@ -7152,10 +7357,10 @@ class ScalarMaxTask extends Task26 {
   static title = "Max";
   static description = "Returns the largest of the given numbers";
   static inputSchema() {
-    return inputSchema26;
+    return inputSchema24;
   }
   static outputSchema() {
-    return outputSchema25;
+    return outputSchema23;
   }
   async execute(input2, _context) {
     return { result: Math.max(...input2.values) };
@@ -7164,7 +7369,7 @@ class ScalarMaxTask extends Task26 {
 Workflow29.prototype.scalarMax = CreateWorkflow28(ScalarMaxTask);
 // src/task/scalar/ScalarMinTask.ts
 import { CreateWorkflow as CreateWorkflow29, Task as Task27, Workflow as Workflow30 } from "@workglow/task-graph";
-var inputSchema27 = {
+var inputSchema25 = {
   type: "object",
   properties: {
     values: {
@@ -7177,7 +7382,7 @@ var inputSchema27 = {
   required: ["values"],
   additionalProperties: false
 };
-var outputSchema26 = {
+var outputSchema24 = {
   type: "object",
   properties: {
     result: {
@@ -7196,10 +7401,10 @@ class ScalarMinTask extends Task27 {
   static title = "Min";
   static description = "Returns the smallest of the given numbers";
   static inputSchema() {
-    return inputSchema27;
+    return inputSchema25;
   }
   static outputSchema() {
-    return outputSchema26;
+    return outputSchema24;
   }
   async execute(input2, _context) {
     return { result: Math.min(...input2.values) };
@@ -7208,7 +7413,7 @@ class ScalarMinTask extends Task27 {
 Workflow30.prototype.scalarMin = CreateWorkflow29(ScalarMinTask);
 // src/task/scalar/ScalarRoundTask.ts
 import { CreateWorkflow as CreateWorkflow30, Task as Task28, Workflow as Workflow31 } from "@workglow/task-graph";
-var inputSchema28 = {
+var inputSchema26 = {
   type: "object",
   properties: {
     value: {
@@ -7220,7 +7425,7 @@ var inputSchema28 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema27 = {
+var outputSchema25 = {
   type: "object",
   properties: {
     result: {
@@ -7239,10 +7444,10 @@ class ScalarRoundTask extends Task28 {
   static title = "Round";
   static description = "Returns the value of a number rounded to the nearest integer";
   static inputSchema() {
-    return inputSchema28;
+    return inputSchema26;
   }
   static outputSchema() {
-    return outputSchema27;
+    return outputSchema25;
   }
   async execute(input2, _context) {
     return { result: Math.round(input2.value) };
@@ -7251,7 +7456,7 @@ class ScalarRoundTask extends Task28 {
 Workflow31.prototype.scalarRound = CreateWorkflow30(ScalarRoundTask);
 // src/task/scalar/ScalarTruncTask.ts
 import { CreateWorkflow as CreateWorkflow31, Task as Task29, Workflow as Workflow32 } from "@workglow/task-graph";
-var inputSchema29 = {
+var inputSchema27 = {
   type: "object",
   properties: {
     value: {
@@ -7263,7 +7468,7 @@ var inputSchema29 = {
   required: ["value"],
   additionalProperties: false
 };
-var outputSchema28 = {
+var outputSchema26 = {
   type: "object",
   properties: {
     result: {
@@ -7282,10 +7487,10 @@ class ScalarTruncTask extends Task29 {
   static title = "Truncate";
   static description = "Returns the integer part of a number by removing fractional digits";
   static inputSchema() {
-    return inputSchema29;
+    return inputSchema27;
   }
   static outputSchema() {
-    return outputSchema28;
+    return outputSchema26;
   }
   async execute(input2, _context) {
     return { result: Math.trunc(input2.value) };
@@ -7297,7 +7502,7 @@ import { CreateWorkflow as CreateWorkflow32, Task as Task30, Workflow as Workflo
 import {
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util";
-var inputSchema30 = {
+var inputSchema28 = {
   type: "object",
   properties: {
     vectors: {
@@ -7313,7 +7518,7 @@ var inputSchema30 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema29 = {
+var outputSchema27 = {
   type: "object",
   properties: {
     result: {
@@ -7332,10 +7537,10 @@ class VectorDistanceTask extends Task30 {
   static title = "Distance";
   static description = "Returns the Euclidean distance between the first two vectors";
   static inputSchema() {
-    return inputSchema30;
+    return inputSchema28;
   }
   static outputSchema() {
-    return outputSchema29;
+    return outputSchema27;
   }
   async execute(input2, _context) {
     const { vectors } = input2;
@@ -7359,7 +7564,7 @@ import { CreateWorkflow as CreateWorkflow33, Task as Task31, Workflow as Workflo
 import {
   TypedArraySchema as TypedArraySchema6
 } from "@workglow/util";
-var inputSchema31 = {
+var inputSchema29 = {
   type: "object",
   properties: {
     vectors: {
@@ -7375,7 +7580,7 @@ var inputSchema31 = {
   required: ["vectors"],
   additionalProperties: false
 };
-var outputSchema30 = {
+var outputSchema28 = {
   type: "object",
   properties: {
     result: {
@@ -7394,10 +7599,10 @@ class VectorDotProductTask extends Task31 {
   static title = "Dot Product";
   static description = "Returns the dot (inner) product of the first two vectors";
   static inputSchema() {
-    return inputSchema31;
+    return inputSchema29;
   }
   static outputSchema() {
-    return outputSchema30;
+    return outputSchema28;
   }
   async execute(input2, _context) {
     const { vectors } = input2;
@@ -7419,7 +7624,7 @@ import {
   TypedArraySchema as TypedArraySchema7,
   normalize
 } from "@workglow/util";
-var inputSchema32 = {
+var inputSchema30 = {
   type: "object",
   properties: {
     vector: TypedArraySchema7({
@@ -7430,7 +7635,7 @@ var inputSchema32 = {
   required: ["vector"],
   additionalProperties: false
 };
-var outputSchema31 = {
+var outputSchema29 = {
   type: "object",
   properties: {
     result: TypedArraySchema7({
@@ -7448,10 +7653,10 @@ class VectorNormalizeTask extends Task32 {
   static title = "Normalize";
   static description = "Returns the L2-normalized (unit length) vector";
   static inputSchema() {
-    return inputSchema32;
+    return inputSchema30;
   }
   static outputSchema() {
-    return outputSchema31;
+    return outputSchema29;
   }
   async execute(input2, _context) {
     return { result: normalize(input2.vector) };
@@ -7464,7 +7669,7 @@ import {
   createTypedArrayFrom as createTypedArrayFrom5,
   TypedArraySchema as TypedArraySchema8
 } from "@workglow/util";
-var inputSchema33 = {
+var inputSchema31 = {
   type: "object",
   properties: {
     vector: TypedArraySchema8({
@@ -7480,7 +7685,7 @@ var inputSchema33 = {
   required: ["vector", "scalar"],
   additionalProperties: false
 };
-var outputSchema32 = {
+var outputSchema30 = {
   type: "object",
   properties: {
     result: TypedArraySchema8({
@@ -7498,10 +7703,10 @@ class VectorScaleTask extends Task33 {
   static title = "Scale";
   static description = "Multiplies each element of a vector by a scalar";
   static inputSchema() {
-    return inputSchema33;
+    return inputSchema31;
   }
   static outputSchema() {
-    return outputSchema32;
+    return outputSchema30;
   }
   async execute(input2, _context) {
     const { vector, scalar } = input2;
@@ -7561,13 +7766,11 @@ export {
   registerCommonTasks,
   process,
   merge,
-  mcpTransportTypes,
   mcpToolCall,
-  mcpServerConfigSchema5 as mcpServerConfigSchema,
   mcpResourceRead,
   mcpPromptGet,
   mcpList,
-  mcpClientFactory5 as mcpClientFactory,
+  lambdaTaskConfigSchema,
   lambda,
   json,
   javaScript,
@@ -7575,7 +7778,6 @@ export {
   fetchUrl,
   delay,
   debugLog,
-  createMcpClient,
   VectorSumTask,
   VectorSubtractTask,
   VectorScaleTask,
@@ -7616,4 +7818,4 @@ export {
   ArrayTask
 };
 
-//# debugId=02B760AAB3F989C464756E2164756E21
+//# debugId=1E3D4020BD1C3CB964756E2164756E21