@workglow/tasks 0.1.1 → 0.2.0

package/dist/bun.js

@@ -593,7 +593,11 @@ class ArrayTask extends GraphAsTask {
     const combinations = this.generateCombinations(inputObject, inputIds);
     const tasks = combinations.map((combination) => {
       const { id, title, ...rest } = this.config;
-      const task = new this.constructor({ ...this.defaults, ...this.runInputData, ...combination }, { ...rest, id: `${id}_${uuid4()}` }, this.runConfig);
+      const task = new this.constructor({
+        ...rest,
+        id: `${id}_${uuid4()}`,
+        defaults: { ...this.defaults, ...this.runInputData, ...combination }
+      }, this.runConfig);
       return task;
     });
     this.subGraph.addTasks(tasks);
@@ -723,7 +727,7 @@ class DebugLogTask extends Task10 {
   }
 }
 var debugLog = (input, config = {}) => {
-  const task = new DebugLogTask({}, config);
+  const task = new DebugLogTask(config);
   return task.run(input);
 };
 Workflow11.prototype.debugLog = CreateWorkflow10(DebugLogTask);
@@ -795,7 +799,7 @@ class DelayTask extends Task11 {
   }
 }
 var delay = (input, config = { delay: 1 }) => {
-  const task = new DelayTask({}, config);
+  const task = new DelayTask(config);
   return task.run(input);
 };
 Workflow12.prototype.delay = CreateWorkflow11(DelayTask);
@@ -808,6 +812,7 @@ import {
 } from "@workglow/job-queue";
 import {
   CreateWorkflow as CreateWorkflow12,
+  Entitlements,
   getJobQueueFactory,
   getTaskQueueRegistry,
   JobTaskFailedError,
@@ -1070,6 +1075,18 @@ class FetchUrlTask extends Task12 {
   static title = "Fetch";
   static description = "Fetches data from a URL with progress tracking and automatic retry handling";
   static hasDynamicSchemas = true;
+  static entitlements() {
+    return {
+      entitlements: [
+        { id: Entitlements.NETWORK_HTTP, reason: "Fetches data from URLs via HTTP/HTTPS" },
+        {
+          id: Entitlements.CREDENTIAL,
+          reason: "May use Bearer token authentication",
+          optional: true
+        }
+      ]
+    };
+  }
   static configSchema() {
     return fetchUrlTaskConfigSchema;
   }
@@ -1142,7 +1159,7 @@ class FetchUrlTask extends Task12 {
       }
       const registeredQueue = await this.resolveOrCreateQueue(queueName);
       if (executeContext.signal.aborted) {
-        throw executeContext.signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+        throw executeContext.signal.reason ?? new AbortSignalJobError("The operation was aborted");
       }
       const handle = await registeredQueue.client.submit(jobInput, {
         jobRunId: this.runConfig.runnerId,
@@ -1159,7 +1176,7 @@ class FetchUrlTask extends Task12 {
       });
       try {
         if (executeContext.signal.aborted) {
-          throw executeContext.signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+          throw executeContext.signal.reason ?? new AbortSignalJobError("The operation was aborted");
         }
         const output = await handle.waitFor();
         return output;
@@ -1237,18 +1254,455 @@ class FetchUrlTask extends Task12 {
   }
 }
 var fetchUrl = async (input, config = {}) => {
-  const result = await new FetchUrlTask({}, config).run(input);
+  const result = await new FetchUrlTask(config).run(input);
   return result;
 };
 Workflow13.prototype.fetch = CreateWorkflow12(FetchUrlTask);
-// src/task/InputTask.ts
+// src/task/HumanApprovalTask.ts
+import {
+  CreateWorkflow as CreateWorkflow14,
+  Task as Task14,
+  TaskAbortedError as TaskAbortedError3,
+  TaskConfigSchema as TaskConfigSchema5,
+  Workflow as Workflow15
+} from "@workglow/task-graph";
+import { uuid4 as uuid43 } from "@workglow/util";
+
+// src/task/HumanInputTask.ts
 import {
   CreateWorkflow as CreateWorkflow13,
   Task as Task13,
+  TaskAbortedError as TaskAbortedError2,
+  TaskConfigSchema as TaskConfigSchema4,
+  TaskConfigurationError as TaskConfigurationError2,
   Workflow as Workflow14
 } from "@workglow/task-graph";
+import { createServiceToken, uuid4 as uuid42 } from "@workglow/util";
+var HUMAN_CONNECTOR = createServiceToken("HUMAN_CONNECTOR");
+var humanInputTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema4["properties"],
+    targetHumanId: {
+      type: "string",
+      title: "Target Human",
+      description: "Identifier of the human to ask (e.g. 'default', 'admin', 'user:alice')",
+      default: "default"
+    },
+    kind: {
+      type: "string",
+      title: "Kind",
+      description: "Interaction kind: notify (one-way), display (show content), elicit (request input)",
+      enum: ["notify", "display", "elicit"],
+      default: "elicit"
+    },
+    contentSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: true,
+      title: "Content Schema",
+      description: "JSON schema describing the content/form to present",
+      "x-ui-hidden": true
+    },
+    message: {
+      type: "string",
+      title: "Message",
+      description: "Explanatory message shown to the human",
+      "x-ui-editor": "textarea"
+    },
+    mode: {
+      type: "string",
+      title: "Mode",
+      description: "Interaction mode",
+      enum: ["single", "multi-turn"],
+      default: "single"
+    },
+    metadata: {
+      type: "object",
+      additionalProperties: true,
+      "x-ui-hidden": true
+    }
+  },
+  additionalProperties: false
+};
+var defaultInputSchema = {
+  type: "object",
+  properties: {
+    prompt: {
+      type: "string",
+      title: "Prompt",
+      description: "Dynamic prompt text merged into the request message"
+    },
+    contentData: {
+      type: "object",
+      additionalProperties: true,
+      title: "Content Data",
+      description: "Data to display (for notify/display kinds)",
+      "x-ui-hidden": true
+    },
+    context: {
+      type: "object",
+      additionalProperties: true,
+      title: "Context",
+      description: "Dynamic context data merged into the request metadata",
+      "x-ui-hidden": true
+    }
+  },
+  additionalProperties: false
+};
+var defaultOutputSchema = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      title: "Action",
+      description: "The human's action: accept, decline, or cancel",
+      enum: ["accept", "decline", "cancel"]
+    }
+  },
+  additionalProperties: true
+};
+
+class HumanInputTask extends Task13 {
+  static type = "HumanInputTask";
+  static category = "Flow Control";
+  static title = "Human Input";
+  static description = "Sends an interaction (notification, display, or input request) to a human";
+  static cacheable = false;
+  static hasDynamicSchemas = true;
+  static configSchema() {
+    return humanInputTaskConfigSchema;
+  }
+  static inputSchema() {
+    return defaultInputSchema;
+  }
+  static outputSchema() {
+    return defaultOutputSchema;
+  }
+  outputSchema() {
+    if (this.config?.contentSchema && (this.config.kind ?? "elicit") === "elicit") {
+      const configSchema = this.config.contentSchema;
+      const existingProps = configSchema.properties ?? {};
+      const additionalProperties = configSchema.additionalProperties ?? false;
+      const actionProp = {
+        type: "string",
+        title: "Action",
+        description: "The human's action: accept, decline, or cancel",
+        enum: ["accept", "decline", "cancel"]
+      };
+      const result = {
+        type: "object",
+        properties: { ...existingProps, action: actionProp },
+        required: ["action"],
+        additionalProperties
+      };
+      return result;
+    }
+    return this.constructor.outputSchema();
+  }
+  async execute(input, context) {
+    const connector = resolveHumanConnector(context);
+    const kind = this.config.kind ?? "elicit";
+    const mode = this.config.mode ?? "single";
+    const requestId = uuid42();
+    const message = input.prompt ? this.config.message ? `${this.config.message}
+
+${input.prompt}` : input.prompt : this.config.message ?? "";
+    const emptySchema = {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+    const request = {
+      requestId,
+      targetHumanId: this.config.targetHumanId ?? "default",
+      kind,
+      message,
+      contentSchema: this.config.contentSchema ?? emptySchema,
+      contentData: input.contentData,
+      expectsResponse: kind === "elicit",
+      mode: kind === "elicit" ? mode : "single",
+      metadata: input.context ? { ...this.config.metadata, ...input.context } : this.config.metadata
+    };
+    if (context.signal.aborted) {
+      throw new TaskAbortedError2("Task aborted before sending human interaction");
+    }
+    let response;
+    try {
+      response = await connector.send(request, context.signal);
+    } catch (err) {
+      if (context.signal.aborted) {
+        throw new TaskAbortedError2("Task aborted during human interaction");
+      }
+      throw err;
+    }
+    if (kind === "elicit" && mode === "multi-turn" && !response.done) {
+      if (typeof connector.followUp !== "function") {
+        throw new TaskConfigurationError2('HumanInputTask is configured for "multi-turn" mode but the registered ' + "IHumanConnector does not implement followUp()");
+      }
+      while (!response.done) {
+        if (context.signal.aborted) {
+          throw new TaskAbortedError2("Task aborted during multi-turn conversation");
+        }
+        try {
+          response = await connector.followUp(request, response, context.signal);
+        } catch (err) {
+          if (context.signal.aborted) {
+            throw new TaskAbortedError2("Task aborted during multi-turn conversation");
+          }
+          throw err;
+        }
+      }
+    }
+    return { ...response.content, action: response.action };
+  }
+}
+function resolveHumanConnector(context) {
+  if (!context.registry.has(HUMAN_CONNECTOR)) {
+    throw new TaskConfigurationError2("No IHumanConnector registered. Register one via " + "registry.registerInstance(HUMAN_CONNECTOR, connector) before running a human-in-the-loop task.");
+  }
+  return context.registry.get(HUMAN_CONNECTOR);
+}
+Workflow14.prototype.humanInput = CreateWorkflow13(HumanInputTask);
+
+// src/task/HumanApprovalTask.ts
+var humanApprovalConfigSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema5["properties"],
+    targetHumanId: {
+      type: "string",
+      title: "Target Human",
+      description: "Identifier of the human to ask for approval",
+      default: "default"
+    },
+    message: {
+      type: "string",
+      title: "Message",
+      description: "Explanatory message shown to the approver",
+      "x-ui-editor": "textarea"
+    },
+    metadata: {
+      type: "object",
+      additionalProperties: true,
+      "x-ui-hidden": true
+    }
+  },
+  additionalProperties: false
+};
+var inputSchema13 = {
+  type: "object",
+  properties: {
+    prompt: {
+      type: "string",
+      title: "Prompt",
+      description: "Dynamic prompt text merged into the approval message"
+    },
+    context: {
+      type: "object",
+      additionalProperties: true,
+      title: "Context",
+      description: "Dynamic context data merged into the request metadata",
+      "x-ui-hidden": true
+    }
+  },
+  additionalProperties: false
+};
+var approvalRequestedSchema = {
+  type: "object",
+  properties: {
+    approved: {
+      type: "boolean",
+      title: "Approved",
+      description: "Whether the request is approved"
+    },
+    reason: {
+      type: "string",
+      title: "Reason",
+      description: "Optional explanation for the decision"
+    }
+  },
+  required: ["approved"]
+};
+var approvalOutputSchema = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      title: "Action",
+      description: "The human's action: accept, decline, or cancel",
+      enum: ["accept", "decline", "cancel"]
+    },
+    approved: {
+      type: "boolean",
+      title: "Approved",
+      description: "Whether the human approved the request"
+    },
+    reason: {
+      type: "string",
+      title: "Reason",
+      description: "Optional explanation for the decision"
+    }
+  },
+  required: ["action", "approved"],
+  additionalProperties: false
+};
+
+class HumanApprovalTask extends Task14 {
+  static type = "HumanApprovalTask";
+  static category = "Flow Control";
+  static title = "Human Approval";
+  static description = "Pauses execution to request approval from a human (approve/deny) via MCP elicitation";
+  static cacheable = false;
+  static configSchema() {
+    return humanApprovalConfigSchema;
+  }
+  static inputSchema() {
+    return inputSchema13;
+  }
+  static outputSchema() {
+    return approvalOutputSchema;
+  }
+  async execute(input, context) {
+    const connector = resolveHumanConnector(context);
+    const requestId = uuid43();
+    const message = input.prompt ? this.config.message ? `${this.config.message}
+
+${input.prompt}` : input.prompt : this.config.message ?? "";
+    const request = {
+      requestId,
+      targetHumanId: this.config.targetHumanId ?? "default",
+      kind: "elicit",
+      message,
+      contentSchema: approvalRequestedSchema,
+      contentData: undefined,
+      expectsResponse: true,
+      mode: "single",
+      metadata: input.context ? { ...this.config.metadata, ...input.context } : this.config.metadata
+    };
+    if (context.signal.aborted) {
+      throw new TaskAbortedError3("Task aborted before requesting human approval");
+    }
+    let response;
+    try {
+      response = await connector.send(request, context.signal);
+    } catch (err) {
+      if (context.signal.aborted) {
+        throw new TaskAbortedError3("Task aborted during human approval");
+      }
+      throw err;
+    }
+    if (response.action === "accept" && response.content) {
+      return {
+        action: response.action,
+        approved: response.content.approved === true,
+        reason: response.content.reason
+      };
+    }
+    return {
+      action: response.action,
+      approved: false,
+      ...response.content?.reason !== undefined ? { reason: response.content.reason } : {}
+    };
+  }
+}
+Workflow15.prototype.humanApproval = CreateWorkflow14(HumanApprovalTask);
+// src/task/McpElicitationConnector.ts
+function defaultAbortError() {
+  const err = new Error("The operation was aborted");
+  err.name = "AbortError";
+  return err;
+}
+function toMcpRequestedSchema(schema) {
+  const props = schema.properties ?? {};
+  const required = schema.required;
+  return {
+    type: "object",
+    properties: props,
+    ...required ? { required } : {}
+  };
+}
+
+class McpElicitationConnector {
+  server;
+  constructor(server) {
+    this.server = server;
+  }
+  async send(request, signal) {
+    switch (request.kind) {
+      case "notify":
+        return this.handleNotify(request, signal);
+      case "display":
+        return this.handleDisplay(request, signal);
+      case "elicit":
+        return this.handleElicit(request, signal);
+      default:
+        return this.handleElicit(request, signal);
+    }
+  }
+  async followUp(request, _previousResponse, signal) {
+    return this.send(request, signal);
+  }
+  async handleNotify(request, signal) {
+    if (signal.aborted) {
+      throw signal.reason ?? defaultAbortError();
+    }
+    await this.server.sendLoggingMessage({
+      level: "info",
+      data: request.contentData ?? request.message,
+      logger: request.targetHumanId
+    });
+    if (signal.aborted) {
+      throw signal.reason ?? defaultAbortError();
+    }
+    return {
+      requestId: request.requestId,
+      action: "accept",
+      content: undefined,
+      done: true
+    };
+  }
+  async handleDisplay(request, signal) {
+    if (signal.aborted) {
+      throw signal.reason ?? defaultAbortError();
+    }
+    await this.server.sendLoggingMessage({
+      level: "info",
+      data: {
+        message: request.message,
+        content: request.contentData,
+        schema: request.contentSchema
+      },
+      logger: request.targetHumanId
+    });
+    if (signal.aborted) {
+      throw signal.reason ?? defaultAbortError();
+    }
+    return {
+      requestId: request.requestId,
+      action: "accept",
+      content: undefined,
+      done: true
+    };
+  }
+  async handleElicit(request, signal) {
+    const mcpResult = await this.server.elicitInput({
+      mode: "form",
+      message: request.message,
+      requestedSchema: toMcpRequestedSchema(request.contentSchema)
+    }, { signal });
+    return {
+      requestId: request.requestId,
+      action: mcpResult.action,
+      content: mcpResult.action === "accept" ? mcpResult.content : undefined,
+      done: true
+    };
+  }
+}
+// src/task/InputTask.ts
+import { CreateWorkflow as CreateWorkflow15, Task as Task15, Workflow as Workflow16 } from "@workglow/task-graph";
 
-class InputTask extends Task13 {
+class InputTask extends Task15 {
   static type = "InputTask";
   static category = "Flow Control";
   static title = "Input";
@@ -1299,14 +1753,15 @@ class InputTask extends Task13 {
     yield { type: "finish", data: input };
   }
 }
-Workflow14.prototype.input = CreateWorkflow13(InputTask);
+Workflow16.prototype.input = CreateWorkflow15(InputTask);
 // src/task/JavaScriptTask.ts
 import {
-  CreateWorkflow as CreateWorkflow14,
-  Task as Task14,
-  TaskConfigSchema as TaskConfigSchema4,
+  CreateWorkflow as CreateWorkflow16,
+  Entitlements as Entitlements2,
+  Task as Task16,
+  TaskConfigSchema as TaskConfigSchema6,
   TaskInvalidInputError as TaskInvalidInputError3,
-  Workflow as Workflow15
+  Workflow as Workflow17
 } from "@workglow/task-graph";
 
 // src/util/acorn.js
@@ -5774,7 +6229,7 @@ var isValidIdentifier = (key) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
 var configSchema = {
   type: "object",
   properties: {
-    ...TaskConfigSchema4["properties"],
+    ...TaskConfigSchema6["properties"],
     javascript_code: {
       type: "string",
       title: "Code",
@@ -5785,7 +6240,7 @@ var configSchema = {
   },
   additionalProperties: false
 };
-var inputSchema13 = {
+var inputSchema14 = {
   type: "object",
   properties: {
     javascript_code: {
@@ -5811,24 +6266,32 @@ var outputSchema13 = {
   additionalProperties: false
 };
 
-class JavaScriptTask extends Task14 {
+class JavaScriptTask extends Task16 {
   static type = "JavaScriptTask";
   static category = "Utility";
   static title = "JavaScript Interpreter";
   static description = "Executes JavaScript code in a sandboxed interpreter environment";
   static customizable = true;
+  static hasDynamicSchemas = true;
+  static entitlements() {
+    return {
+      entitlements: [
+        {
+          id: Entitlements2.CODE_EXECUTION_JS,
+          reason: "Executes user-provided JavaScript code in a sandboxed interpreter"
+        }
+      ]
+    };
+  }
   static configSchema() {
     return configSchema;
   }
   static inputSchema() {
-    return inputSchema13;
+    return inputSchema14;
   }
   static outputSchema() {
     return outputSchema13;
   }
-  constructor(input2 = {}, config = {}) {
-    super(input2, config);
-  }
   inputSchema() {
     if (this.config?.javascript_code) {
       if (this.config.inputSchema) {
@@ -5840,7 +6303,7 @@ class JavaScriptTask extends Task14 {
         additionalProperties: true
       };
     }
-    return inputSchema13;
+    return inputSchema14;
   }
   async executeReactive(input2, output) {
     const code = input2.javascript_code || this.config.javascript_code;
@@ -5860,20 +6323,20 @@ class JavaScriptTask extends Task14 {
   }
 }
 var javaScript = (input2, config = {}) => {
-  return new JavaScriptTask({}, config).run(input2);
+  return new JavaScriptTask(config).run(input2);
 };
-Workflow15.prototype.javaScript = CreateWorkflow14(JavaScriptTask);
+Workflow17.prototype.javaScript = CreateWorkflow16(JavaScriptTask);
 // src/task/JsonTask.ts
 import {
   createGraphFromDependencyJSON,
   createGraphFromGraphJSON,
-  CreateWorkflow as CreateWorkflow15,
+  CreateWorkflow as CreateWorkflow17,
   Dataflow,
   GraphAsTask as GraphAsTask2,
-  TaskConfigurationError as TaskConfigurationError2,
-  Workflow as Workflow16
+  TaskConfigurationError as TaskConfigurationError3,
+  Workflow as Workflow18
 } from "@workglow/task-graph";
-var inputSchema14 = {
+var inputSchema15 = {
   type: "object",
   properties: {
     json: {
@@ -5901,7 +6364,7 @@ class JsonTask extends GraphAsTask2 {
   static title = "JSON Task";
   static description = "A task that creates and manages task graphs from JSON configurations";
   static inputSchema() {
-    return inputSchema14;
+    return inputSchema15;
   }
   static outputSchema() {
     return outputSchema14;
@@ -5925,7 +6388,7 @@ class JsonTask extends GraphAsTask2 {
         for (const dep of dependencies) {
           const sourceTask = this.subGraph.getTask(dep.id);
           if (!sourceTask) {
-            throw new TaskConfigurationError2(`Dependency id ${dep.id} not found`);
+            throw new TaskConfigurationError3(`Dependency id ${dep.id} not found`);
           }
           const df = new Dataflow(sourceTask.id, dep.output, item.id, input2);
           this.subGraph.addDataflow(df);
@@ -5936,28 +6399,28 @@ class JsonTask extends GraphAsTask2 {
   }
 }
 var json = (input2, config = {}) => {
-  return new JsonTask({}, config).run(input2);
+  return new JsonTask(config).run(input2);
 };
-Workflow16.prototype.json = CreateWorkflow15(JsonTask);
+Workflow18.prototype.json = CreateWorkflow17(JsonTask);
 // src/task/LambdaTask.ts
 import {
-  CreateWorkflow as CreateWorkflow16,
+  CreateWorkflow as CreateWorkflow18,
   DATAFLOW_ALL_PORTS,
-  Task as Task15,
-  TaskConfigSchema as TaskConfigSchema5,
-  TaskConfigurationError as TaskConfigurationError3,
-  Workflow as Workflow17
+  Task as Task17,
+  TaskConfigSchema as TaskConfigSchema7,
+  TaskConfigurationError as TaskConfigurationError4,
+  Workflow as Workflow19
 } from "@workglow/task-graph";
 var lambdaTaskConfigSchema = {
   type: "object",
   properties: {
-    ...TaskConfigSchema5["properties"],
+    ...TaskConfigSchema7["properties"],
     execute: {},
     executeReactive: {}
   },
   additionalProperties: false
 };
-var inputSchema15 = {
+var inputSchema16 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -5978,7 +6441,7 @@ var outputSchema15 = {
   additionalProperties: true
 };
 
-class LambdaTask extends Task15 {
+class LambdaTask extends Task17 {
   static type = "LambdaTask";
   static title = "Lambda Task";
   static description = "A task that wraps a provided function and its input";
@@ -5988,7 +6451,7 @@ class LambdaTask extends Task15 {
     return lambdaTaskConfigSchema;
   }
   static inputSchema() {
-    return inputSchema15;
+    return inputSchema16;
   }
   static outputSchema() {
     return outputSchema15;
@@ -5996,11 +6459,11 @@ class LambdaTask extends Task15 {
   canSerializeConfig() {
     return false;
   }
-  constructor(input2 = {}, config = {}) {
+  constructor(config = {}) {
     if (!config.execute && !config.executeReactive) {
-      throw new TaskConfigurationError3("LambdaTask must have either execute or executeReactive function in config");
+      throw new TaskConfigurationError4("LambdaTask must have either execute or executeReactive function in config");
     }
-    super(input2, config);
+    super(config);
   }
   async execute(input2, context) {
     if (typeof this.config.execute === "function") {
@@ -6017,18 +6480,18 @@ class LambdaTask extends Task15 {
 }
 function lambda(input2, config) {
   if (typeof input2 === "function") {
-    const task2 = new LambdaTask({}, {
+    const task2 = new LambdaTask({
       execute: input2
     });
     return task2.run();
   }
-  const task = new LambdaTask(input2, config);
+  const task = new LambdaTask({ ...config, defaults: input2 });
   return task.run();
 }
-Workflow17.prototype.lambda = CreateWorkflow16(LambdaTask);
+Workflow19.prototype.lambda = CreateWorkflow18(LambdaTask);
 // src/task/MergeTask.ts
-import { CreateWorkflow as CreateWorkflow17, Task as Task16, Workflow as Workflow18 } from "@workglow/task-graph";
-var inputSchema16 = {
+import { CreateWorkflow as CreateWorkflow19, Task as Task18, Workflow as Workflow20 } from "@workglow/task-graph";
+var inputSchema17 = {
   type: "object",
   properties: {},
   additionalProperties: true
@@ -6045,14 +6508,14 @@ var outputSchema16 = {
   additionalProperties: false
 };
 
-class MergeTask extends Task16 {
+class MergeTask extends Task18 {
   static type = "MergeTask";
   static category = "Utility";
   static title = "Merge";
   static description = "Merges multiple inputs into a single array output";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema16;
+    return inputSchema17;
   }
   static outputSchema() {
     return outputSchema16;
@@ -6066,24 +6529,21 @@ class MergeTask extends Task16 {
   }
 }
 var merge = (input2, config = {}) => {
-  const task = new MergeTask({}, config);
+  const task = new MergeTask(config);
   return task.run(input2);
 };
-Workflow18.prototype.merge = CreateWorkflow17(MergeTask);
+Workflow20.prototype.merge = CreateWorkflow19(MergeTask);
 // src/task/OutputTask.ts
-import {
-  CreateWorkflow as CreateWorkflow18,
-  Task as Task17,
-  Workflow as Workflow19
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow20, Task as Task19, Workflow as Workflow21 } from "@workglow/task-graph";
 
-class OutputTask extends Task17 {
+class OutputTask extends Task19 {
   static type = "OutputTask";
   static category = "Flow Control";
   static title = "Output";
   static description = "Ends the workflow";
   static hasDynamicSchemas = true;
   static cacheable = false;
+  static isGraphOutput = true;
   static inputSchema() {
     return {
       type: "object",
@@ -6128,10 +6588,10 @@ class OutputTask extends Task17 {
     yield { type: "finish", data: input2 };
   }
 }
-Workflow19.prototype.output = CreateWorkflow18(OutputTask);
+Workflow21.prototype.output = CreateWorkflow20(OutputTask);
 // src/task/SplitTask.ts
-import { CreateWorkflow as CreateWorkflow19, Task as Task18, Workflow as Workflow20 } from "@workglow/task-graph";
-var inputSchema17 = {
+import { CreateWorkflow as CreateWorkflow21, Task as Task20, Workflow as Workflow22 } from "@workglow/task-graph";
+var inputSchema18 = {
   type: "object",
   properties: {
     input: {
@@ -6147,22 +6607,18 @@ var outputSchema17 = {
   additionalProperties: true
 };
 
-class SplitTask extends Task18 {
+class SplitTask extends Task20 {
   static type = "SplitTask";
   static category = "Utility";
   static title = "Split";
   static description = "Splits an array into individual outputs, creating one output per element";
-  static hasDynamicSchemas = true;
   static cacheable = false;
   static inputSchema() {
-    return inputSchema17;
+    return inputSchema18;
   }
   static outputSchema() {
     return outputSchema17;
   }
-  outputSchema() {
-    return outputSchema17;
-  }
   async executeReactive(input2) {
     const inputValue = input2.input;
     const output = {};
@@ -6177,17 +6633,17 @@ class SplitTask extends Task18 {
   }
 }
 var split = (input2, config = {}) => {
-  const task = new SplitTask({}, config);
+  const task = new SplitTask(config);
   return task.run(input2);
 };
-Workflow20.prototype.split = CreateWorkflow19(SplitTask);
+Workflow22.prototype.split = CreateWorkflow21(SplitTask);
 // src/task/DateFormatTask.ts
 import {
-  CreateWorkflow as CreateWorkflow20,
-  Task as Task19,
-  Workflow as Workflow21
+  CreateWorkflow as CreateWorkflow22,
+  Task as Task21,
+  Workflow as Workflow23
 } from "@workglow/task-graph";
-var inputSchema18 = {
+var inputSchema19 = {
   type: "object",
   properties: {
     value: {
@@ -6230,13 +6686,13 @@ var outputSchema18 = {
   additionalProperties: false
 };
 
-class DateFormatTask extends Task19 {
+class DateFormatTask extends Task21 {
   static type = "DateFormatTask";
   static category = "Utility";
   static title = "Date Format";
   static description = "Parses and formats a date string";
   static inputSchema() {
-    return inputSchema18;
+    return inputSchema19;
   }
   static outputSchema() {
     return outputSchema18;
@@ -6272,14 +6728,14 @@ class DateFormatTask extends Task19 {
     return { result };
   }
 }
-Workflow21.prototype.dateFormat = CreateWorkflow20(DateFormatTask);
+Workflow23.prototype.dateFormat = CreateWorkflow22(DateFormatTask);
 // src/task/JsonPathTask.ts
 import {
-  CreateWorkflow as CreateWorkflow21,
-  Task as Task20,
-  Workflow as Workflow22
+  CreateWorkflow as CreateWorkflow23,
+  Task as Task22,
+  Workflow as Workflow24
 } from "@workglow/task-graph";
-var inputSchema19 = {
+var inputSchema20 = {
   type: "object",
   properties: {
     value: {
@@ -6328,13 +6784,13 @@ function resolvePath(obj, segments) {
   return resolvePath(next2, tail);
 }
 
-class JsonPathTask extends Task20 {
+class JsonPathTask extends Task22 {
   static type = "JsonPathTask";
   static category = "Utility";
   static title = "JSON Path";
   static description = "Extracts a value from an object using a dot-notation path";
   static inputSchema() {
-    return inputSchema19;
+    return inputSchema20;
   }
   static outputSchema() {
     return outputSchema19;
@@ -6345,20 +6801,20 @@ class JsonPathTask extends Task20 {
     return { result };
   }
 }
-Workflow22.prototype.jsonPath = CreateWorkflow21(JsonPathTask);
+Workflow24.prototype.jsonPath = CreateWorkflow23(JsonPathTask);
 // src/task/RegexTask.ts
 import {
-  CreateWorkflow as CreateWorkflow22,
-  Task as Task21,
+  CreateWorkflow as CreateWorkflow24,
+  Task as Task23,
   TaskInvalidInputError as TaskInvalidInputError4,
-  Workflow as Workflow23
+  Workflow as Workflow25
 } from "@workglow/task-graph";
 var MAX_BRACKET_COUNT = 100;
 function hasNestedQuantifiers(pattern) {
   const withoutClasses = pattern.replace(/\[(?:[^\]\\]|\\.)*\]/g, "X");
   return /\([^)]*[+*][^)]*\)[+*?]|\([^)]*[+*][^)]*\)\{/.test(withoutClasses);
 }
-var inputSchema20 = {
+var inputSchema21 = {
   type: "object",
   properties: {
     value: {
@@ -6400,13 +6856,13 @@ var outputSchema20 = {
   additionalProperties: false
 };
 
-class RegexTask extends Task21 {
+class RegexTask extends Task23 {
   static type = "RegexTask";
   static category = "String";
   static title = "Regex";
   static description = "Matches a string against a regular expression pattern";
   static inputSchema() {
-    return inputSchema20;
+    return inputSchema21;
   }
   static outputSchema() {
     return outputSchema20;
@@ -6438,14 +6894,14 @@ class RegexTask extends Task21 {
     };
   }
 }
-Workflow23.prototype.regex = CreateWorkflow22(RegexTask);
+Workflow25.prototype.regex = CreateWorkflow24(RegexTask);
 // src/task/TemplateTask.ts
 import {
-  CreateWorkflow as CreateWorkflow23,
-  Task as Task22,
-  Workflow as Workflow24
+  CreateWorkflow as CreateWorkflow25,
+  Task as Task24,
+  Workflow as Workflow26
 } from "@workglow/task-graph";
-var inputSchema21 = {
+var inputSchema22 = {
   type: "object",
   properties: {
     template: {
@@ -6476,13 +6932,13 @@ var outputSchema21 = {
   additionalProperties: false
 };
 
-class TemplateTask extends Task22 {
+class TemplateTask extends Task24 {
   static type = "TemplateTask";
   static category = "Utility";
   static title = "Template";
   static description = "Renders a template string with {{key}} placeholders and optional defaults";
   static inputSchema() {
-    return inputSchema21;
+    return inputSchema22;
   }
   static outputSchema() {
     return outputSchema21;
@@ -6507,7 +6963,7 @@ class TemplateTask extends Task22 {
     return { result };
   }
 }
-Workflow24.prototype.template = CreateWorkflow23(TemplateTask);
+Workflow26.prototype.template = CreateWorkflow25(TemplateTask);
 // src/util/McpClientUtil.ts
 import { Client } from "@modelcontextprotocol/sdk/client";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
@@ -7029,8 +7485,8 @@ function buildAuthConfig(flat) {
 }
 
 // src/util/McpTaskDeps.ts
-import { createServiceToken, globalServiceRegistry } from "@workglow/util";
-var MCP_TASK_DEPS = createServiceToken("@workglow/tasks/mcp");
+import { createServiceToken as createServiceToken2, globalServiceRegistry } from "@workglow/util";
+var MCP_TASK_DEPS = createServiceToken2("@workglow/tasks/mcp");
 function registerMcpTaskDeps(deps) {
   globalServiceRegistry.registerInstance(MCP_TASK_DEPS, deps);
 }
@@ -7257,18 +7713,15 @@ class InMemoryMcpServerRepository extends McpServerRepository {
 }
 // src/mcp-server/McpServerRegistry.ts
 import {
-  createServiceToken as createServiceToken2,
+  createServiceToken as createServiceToken3,
   globalServiceRegistry as globalServiceRegistry2,
+  registerInputCompactor,
   registerInputResolver
 } from "@workglow/util";
-var MCP_SERVERS = createServiceToken2("mcp-server.registry");
-var MCP_SERVER_REPOSITORY = createServiceToken2("mcp-server.repository");
-if (!globalServiceRegistry2.has(MCP_SERVERS)) {
-  globalServiceRegistry2.register(MCP_SERVERS, () => new Map, true);
-}
-if (!globalServiceRegistry2.has(MCP_SERVER_REPOSITORY)) {
-  globalServiceRegistry2.register(MCP_SERVER_REPOSITORY, () => new InMemoryMcpServerRepository, true);
-}
+var MCP_SERVERS = createServiceToken3("mcp-server.registry");
+var MCP_SERVER_REPOSITORY = createServiceToken3("mcp-server.repository");
+globalServiceRegistry2.registerIfAbsent(MCP_SERVERS, () => new Map, true);
+globalServiceRegistry2.registerIfAbsent(MCP_SERVER_REPOSITORY, () => new InMemoryMcpServerRepository, true);
 function getGlobalMcpServers() {
   return globalServiceRegistry2.get(MCP_SERVERS);
 }
@@ -7300,6 +7753,13 @@ async function resolveServerFromRegistry(id, _format, registry) {
   return record;
 }
 registerInputResolver("mcp-server", resolveServerFromRegistry);
+registerInputCompactor("mcp-server", (value) => {
+  if (typeof value === "object" && value !== null && "server_id" in value) {
+    const id = value.server_id;
+    return typeof id === "string" ? id : undefined;
+  }
+  return;
+});
 // src/mcp-server/getMcpServerConfig.ts
 function getMcpServerConfig(configOrInput) {
   const server = configOrInput.server;
@@ -7326,7 +7786,29 @@ function getMcpServerConfig(configOrInput) {
   return base;
 }
 // src/task/mcp/McpListTask.ts
-import { CreateWorkflow as CreateWorkflow24, Task as Task23, Workflow as Workflow25 } from "@workglow/task-graph";
+import {
+  CreateWorkflow as CreateWorkflow26,
+  Entitlements as Entitlements3,
+  mergeEntitlements,
+  Task as Task25,
+  Workflow as Workflow27
+} from "@workglow/task-graph";
+
+// src/util/getMcpServerTransport.ts
+function getMcpServerTransport(task) {
+  const runInputData = task.runInputData;
+  const inputServer = runInputData?.server;
+  if (typeof inputServer?.transport === "string") {
+    return inputServer.transport;
+  }
+  const configServer = task.config?.server;
+  if (typeof configServer?.transport === "string") {
+    return configServer.transport;
+  }
+  return;
+}
+
+// src/task/mcp/McpListTask.ts
 var mcpListTypes = ["tools", "resources", "prompts"];
 var iconSchema = {
   type: "object",
@@ -7483,13 +7965,35 @@ var outputSchemaAll = {
   additionalProperties: false
 };
 
-class McpListTask extends Task23 {
+class McpListTask extends Task25 {
   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 hasDynamicEntitlements = true;
+  static entitlements() {
+    return {
+      entitlements: [
+        { id: Entitlements3.MCP, reason: "Lists tools, resources, or prompts on MCP servers" }
+      ]
+    };
+  }
+  entitlements() {
+    const base = McpListTask.entitlements();
+    const transport = getMcpServerTransport(this);
+    if (transport === "stdio") {
+      return mergeEntitlements(base, {
+        entitlements: [
+          { id: Entitlements3.MCP_STDIO, reason: "Uses stdio transport to spawn local process" }
+        ]
+      });
+    }
+    return mergeEntitlements(base, {
+      entitlements: [{ id: Entitlements3.NETWORK_HTTP, reason: "Connects to MCP server over HTTP" }]
+    });
+  }
   static inputSchema() {
     const { mcpServerConfigSchema: mcpServerConfigSchema2 } = getMcpTaskDeps();
     return {
@@ -7566,15 +8070,17 @@ class McpListTask extends Task23 {
   }
 }
 var mcpList = async (input2, config = {}) => {
-  return new McpListTask({}, config).run(input2);
+  return new McpListTask(config).run(input2);
 };
-Workflow25.prototype.mcpList = CreateWorkflow24(McpListTask);
+Workflow27.prototype.mcpList = CreateWorkflow26(McpListTask);
 // src/task/mcp/McpPromptGetTask.ts
 import {
-  CreateWorkflow as CreateWorkflow25,
-  Task as Task24,
-  TaskConfigSchema as TaskConfigSchema6,
-  Workflow as Workflow26
+  CreateWorkflow as CreateWorkflow27,
+  Entitlements as Entitlements4,
+  mergeEntitlements as mergeEntitlements2,
+  Task as Task26,
+  TaskConfigSchema as TaskConfigSchema8,
+  Workflow as Workflow28
 } from "@workglow/task-graph";
 var annotationsSchema = {
   type: "object",
@@ -7709,7 +8215,7 @@ var fallbackInputSchema = {
   additionalProperties: false
 };
 
-class McpPromptGetTask extends Task24 {
+class McpPromptGetTask extends Task26 {
   static type = "McpPromptGetTask";
   static category = "MCP";
   static title = "MCP Get Prompt";
@@ -7717,6 +8223,29 @@ class McpPromptGetTask extends Task24 {
   static cacheable = false;
   static customizable = true;
   static hasDynamicSchemas = true;
+  static hasDynamicEntitlements = true;
+  static entitlements() {
+    return {
+      entitlements: [{ id: Entitlements4.MCP_PROMPT_GET, reason: "Gets prompts from MCP servers" }]
+    };
+  }
+  entitlements() {
+    const base = McpPromptGetTask.entitlements();
+    const transport = getMcpServerTransport(this);
+    if (transport === "stdio") {
+      return mergeEntitlements2(base, {
+        entitlements: [
+          { id: Entitlements4.MCP_STDIO, reason: "Uses stdio transport to spawn local process" }
+        ]
+      });
+    }
+    return mergeEntitlements2(base, {
+      entitlements: [
+        { id: Entitlements4.NETWORK_HTTP, reason: "Connects to MCP server over HTTP" },
+        { id: Entitlements4.CREDENTIAL, reason: "May require authentication", optional: true }
+      ]
+    });
+  }
   static inputSchema() {
     return fallbackInputSchema;
   }
@@ -7728,7 +8257,7 @@ class McpPromptGetTask extends Task24 {
     return {
       type: "object",
       properties: {
-        ...TaskConfigSchema6["properties"],
+        ...TaskConfigSchema8["properties"],
         server: TypeMcpServer(mcpServerConfigSchema2),
         prompt_name: {
           type: "string",
@@ -7747,43 +8276,45 @@ class McpPromptGetTask extends Task24 {
   outputSchema() {
     return this.config?.outputSchema ?? fallbackOutputSchema;
   }
-  _schemasDiscovering = false;
+  _schemasDiscoveringPromise;
   async discoverSchemas(_signal, serverConfig) {
     if (this.config.inputSchema)
       return;
-    if (this._schemasDiscovering)
-      return;
+    if (this._schemasDiscoveringPromise)
+      return this._schemasDiscoveringPromise;
     const resolved = serverConfig ?? getMcpServerConfig(this.config);
     if (!resolved.transport || !this.config.prompt_name)
       return;
-    this._schemasDiscovering = true;
-    try {
-      const result = await mcpList({
-        server: resolved,
-        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._schemasDiscoveringPromise = (async () => {
+      try {
+        const result = await mcpList({
+          server: resolved,
+          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();
         }
-        this.config.inputSchema = {
-          type: "object",
-          properties,
-          ...required.length > 0 ? { required } : {},
-          additionalProperties: false
-        };
-        this.emitSchemaChange();
+      } finally {
+        this._schemasDiscoveringPromise = undefined;
       }
-    } finally {
-      this._schemasDiscovering = false;
-    }
+    })();
+    return this._schemasDiscoveringPromise;
   }
   async execute(input2, context) {
     const serverConfig = getMcpServerConfig(this.config);
@@ -7805,15 +8336,17 @@ class McpPromptGetTask extends Task24 {
   }
 }
 var mcpPromptGet = async (input2, config) => {
-  return new McpPromptGetTask({}, config).run(input2);
+  return new McpPromptGetTask(config).run(input2);
 };
-Workflow26.prototype.mcpPromptGet = CreateWorkflow25(McpPromptGetTask);
+Workflow28.prototype.mcpPromptGet = CreateWorkflow27(McpPromptGetTask);
 // src/task/mcp/McpResourceReadTask.ts
 import {
-  CreateWorkflow as CreateWorkflow26,
-  Task as Task25,
-  TaskConfigSchema as TaskConfigSchema7,
-  Workflow as Workflow27
+  CreateWorkflow as CreateWorkflow28,
+  Entitlements as Entitlements5,
+  mergeEntitlements as mergeEntitlements3,
+  Task as Task27,
+  TaskConfigSchema as TaskConfigSchema9,
+  Workflow as Workflow29
 } from "@workglow/task-graph";
 var contentItemSchema = {
   anyOf: [
@@ -7841,7 +8374,7 @@ var contentItemSchema = {
     }
   ]
 };
-var inputSchema22 = {
+var inputSchema23 = {
   type: "object",
   properties: {},
   additionalProperties: false
@@ -7860,15 +8393,40 @@ var outputSchema22 = {
   additionalProperties: false
 };
 
-class McpResourceReadTask extends Task25 {
+class McpResourceReadTask extends Task27 {
   static type = "McpResourceReadTask";
   static category = "MCP";
   static title = "MCP Read Resource";
   static description = "Reads a resource from an MCP server";
   static cacheable = false;
   static customizable = true;
+  static hasDynamicEntitlements = true;
+  static entitlements() {
+    return {
+      entitlements: [
+        { id: Entitlements5.MCP_RESOURCE_READ, reason: "Reads resources from MCP servers" }
+      ]
+    };
+  }
+  entitlements() {
+    const base = McpResourceReadTask.entitlements();
+    const transport = getMcpServerTransport(this);
+    if (transport === "stdio") {
+      return mergeEntitlements3(base, {
+        entitlements: [
+          { id: Entitlements5.MCP_STDIO, reason: "Uses stdio transport to spawn local process" }
+        ]
+      });
+    }
+    return mergeEntitlements3(base, {
+      entitlements: [
+        { id: Entitlements5.NETWORK_HTTP, reason: "Connects to MCP server over HTTP" },
+        { id: Entitlements5.CREDENTIAL, reason: "May require authentication", optional: true }
+      ]
+    });
+  }
   static inputSchema() {
-    return inputSchema22;
+    return inputSchema23;
   }
   static outputSchema() {
     return outputSchema22;
@@ -7878,7 +8436,7 @@ class McpResourceReadTask extends Task25 {
     return {
       type: "object",
       properties: {
-        ...TaskConfigSchema7["properties"],
+        ...TaskConfigSchema9["properties"],
         server: TypeMcpServer(mcpServerConfigSchema2),
         resource_uri: {
           type: "string",
@@ -7906,11 +8464,16 @@ class McpResourceReadTask extends Task25 {
   }
 }
 var mcpResourceRead = async (config) => {
-  return new McpResourceReadTask({}, config).run({});
+  return new McpResourceReadTask(config).run({});
 };
-Workflow27.prototype.mcpResourceRead = CreateWorkflow26(McpResourceReadTask);
+Workflow29.prototype.mcpResourceRead = CreateWorkflow28(McpResourceReadTask);
 // src/task/mcp/McpSearchTask.ts
-import { CreateWorkflow as CreateWorkflow27, Task as Task26, Workflow as Workflow28 } from "@workglow/task-graph";
+import {
+  CreateWorkflow as CreateWorkflow29,
+  Entitlements as Entitlements6,
+  Task as Task28,
+  Workflow as Workflow30
+} from "@workglow/task-graph";
 var MCP_REGISTRY_BASE = "https://registry.modelcontextprotocol.io/v0.1";
 var McpSearchInputSchema = {
   type: "object",
@@ -8049,12 +8612,19 @@ async function searchMcpRegistry(query, signal) {
   return page.results;
 }
 
-class McpSearchTask extends Task26 {
+class McpSearchTask extends Task28 {
   static type = "McpSearchTask";
   static category = "MCP";
   static title = "MCP Search";
   static description = "Search the MCP server registry for servers matching a query";
   static cacheable = false;
+  static entitlements() {
+    return {
+      entitlements: [
+        { id: Entitlements6.NETWORK_HTTP, reason: "Searches the MCP server registry via HTTPS" }
+      ]
+    };
+  }
   static inputSchema() {
     return McpSearchInputSchema;
   }
@@ -8067,15 +8637,17 @@ class McpSearchTask extends Task26 {
   }
 }
 var mcpSearch = (input2, config) => {
-  return new McpSearchTask({}, config).run(input2);
+  return new McpSearchTask(config).run(input2);
 };
-Workflow28.prototype.mcpSearch = CreateWorkflow27(McpSearchTask);
+Workflow30.prototype.mcpSearch = CreateWorkflow29(McpSearchTask);
 // src/task/mcp/McpToolCallTask.ts
 import {
-  CreateWorkflow as CreateWorkflow28,
-  Task as Task27,
-  TaskConfigSchema as TaskConfigSchema8,
-  Workflow as Workflow29
+  CreateWorkflow as CreateWorkflow30,
+  Entitlements as Entitlements7,
+  mergeEntitlements as mergeEntitlements4,
+  Task as Task29,
+  TaskConfigSchema as TaskConfigSchema10,
+  Workflow as Workflow31
 } from "@workglow/task-graph";
 var annotationsSchema2 = {
   type: "object",
@@ -8202,7 +8774,7 @@ var fallbackInputSchema2 = {
   additionalProperties: true
 };
 
-class McpToolCallTask extends Task27 {
+class McpToolCallTask extends Task29 {
   static type = "McpToolCallTask";
   static category = "MCP";
   static title = "MCP Call Tool";
@@ -8210,6 +8782,29 @@ class McpToolCallTask extends Task27 {
   static cacheable = false;
   static customizable = true;
   static hasDynamicSchemas = true;
+  static hasDynamicEntitlements = true;
+  static entitlements() {
+    return {
+      entitlements: [{ id: Entitlements7.MCP_TOOL_CALL, reason: "Calls tools on MCP servers" }]
+    };
+  }
+  entitlements() {
+    const base = McpToolCallTask.entitlements();
+    const transport = getMcpServerTransport(this);
+    if (transport === "stdio") {
+      return mergeEntitlements4(base, {
+        entitlements: [
+          { id: Entitlements7.MCP_STDIO, reason: "Uses stdio transport to spawn local process" }
+        ]
+      });
+    }
+    return mergeEntitlements4(base, {
+      entitlements: [
+        { id: Entitlements7.NETWORK_HTTP, reason: "Connects to MCP server over HTTP" },
+        { id: Entitlements7.CREDENTIAL, reason: "May require authentication", optional: true }
+      ]
+    });
+  }
   static inputSchema() {
     return fallbackInputSchema2;
   }
@@ -8221,7 +8816,7 @@ class McpToolCallTask extends Task27 {
     return {
       type: "object",
       properties: {
-        ...TaskConfigSchema8["properties"],
+        ...TaskConfigSchema10["properties"],
         server: TypeMcpServer(mcpServerConfigSchema2),
         tool_name: {
           type: "string",
@@ -8240,34 +8835,36 @@ class McpToolCallTask extends Task27 {
   outputSchema() {
     return this.config?.outputSchema ?? fallbackOutputSchema2;
   }
-  _schemasDiscovering = false;
+  _schemasDiscoveringPromise;
   async discoverSchemas(_signal, serverConfig) {
     if (this.config.inputSchema && this.config.outputSchema)
       return;
-    if (this._schemasDiscovering)
-      return;
+    if (this._schemasDiscoveringPromise)
+      return this._schemasDiscoveringPromise;
     const resolved = serverConfig ?? getMcpServerConfig(this.config);
     if (!resolved.transport || !this.config.tool_name)
       return;
-    this._schemasDiscovering = true;
-    try {
-      const result = await mcpList({
-        server: resolved,
-        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._schemasDiscoveringPromise = (async () => {
+      try {
+        const result = await mcpList({
+          server: resolved,
+          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();
         }
-        this.emitSchemaChange();
+      } finally {
+        this._schemasDiscoveringPromise = undefined;
       }
-    } finally {
-      this._schemasDiscovering = false;
-    }
+    })();
+    return this._schemasDiscoveringPromise;
   }
   async execute(input2, context) {
     const serverConfig = getMcpServerConfig(this.config);
@@ -8313,16 +8910,16 @@ class McpToolCallTask extends Task27 {
   }
 }
 var mcpToolCall = async (input2, config) => {
-  return new McpToolCallTask({}, config).run(input2);
+  return new McpToolCallTask(config).run(input2);
 };
-Workflow29.prototype.mcpToolCall = CreateWorkflow28(McpToolCallTask);
+Workflow31.prototype.mcpToolCall = CreateWorkflow30(McpToolCallTask);
 // src/task/string/StringConcatTask.ts
 import {
-  CreateWorkflow as CreateWorkflow29,
-  Task as Task28,
-  Workflow as Workflow30
+  CreateWorkflow as CreateWorkflow31,
+  Task as Task30,
+  Workflow as Workflow32
 } from "@workglow/task-graph";
-var inputSchema23 = {
+var inputSchema24 = {
   type: "object",
   properties: {},
   additionalProperties: { type: "string" }
@@ -8340,13 +8937,13 @@ var outputSchema23 = {
   additionalProperties: false
 };
 
-class StringConcatTask extends Task28 {
+class StringConcatTask extends Task30 {
   static type = "StringConcatTask";
   static category = "String";
   static title = "Concat";
   static description = "Concatenates all input strings";
   static inputSchema() {
-    return inputSchema23;
+    return inputSchema24;
   }
   static outputSchema() {
     return outputSchema23;
@@ -8355,14 +8952,14 @@ class StringConcatTask extends Task28 {
     return { result: Object.values(input2).join("") };
   }
 }
-Workflow30.prototype.stringConcat = CreateWorkflow29(StringConcatTask);
+Workflow32.prototype.stringConcat = CreateWorkflow31(StringConcatTask);
 // src/task/string/StringIncludesTask.ts
 import {
-  CreateWorkflow as CreateWorkflow30,
-  Task as Task29,
-  Workflow as Workflow31
+  CreateWorkflow as CreateWorkflow32,
+  Task as Task31,
+  Workflow as Workflow33
 } from "@workglow/task-graph";
-var inputSchema24 = {
+var inputSchema25 = {
   type: "object",
   properties: {
     value: {
@@ -8392,13 +8989,13 @@ var outputSchema24 = {
   additionalProperties: false
 };
 
-class StringIncludesTask extends Task29 {
+class StringIncludesTask extends Task31 {
   static type = "StringIncludesTask";
   static category = "String";
   static title = "Includes";
   static description = "Checks if a string contains a substring";
   static inputSchema() {
-    return inputSchema24;
+    return inputSchema25;
   }
   static outputSchema() {
     return outputSchema24;
@@ -8407,14 +9004,14 @@ class StringIncludesTask extends Task29 {
     return { result: input2.value.includes(input2.search) };
   }
 }
-Workflow31.prototype.stringIncludes = CreateWorkflow30(StringIncludesTask);
+Workflow33.prototype.stringIncludes = CreateWorkflow32(StringIncludesTask);
 // src/task/string/StringJoinTask.ts
 import {
-  CreateWorkflow as CreateWorkflow31,
-  Task as Task30,
-  Workflow as Workflow32
+  CreateWorkflow as CreateWorkflow33,
+  Task as Task32,
+  Workflow as Workflow34
 } from "@workglow/task-graph";
-var inputSchema25 = {
+var inputSchema26 = {
   type: "object",
   properties: {
     values: {
@@ -8446,13 +9043,13 @@ var outputSchema25 = {
   additionalProperties: false
 };
 
-class StringJoinTask extends Task30 {
+class StringJoinTask extends Task32 {
   static type = "StringJoinTask";
   static category = "String";
   static title = "Join";
   static description = "Joins an array of strings with a separator";
   static inputSchema() {
-    return inputSchema25;
+    return inputSchema26;
   }
   static outputSchema() {
     return outputSchema25;
@@ -8462,14 +9059,14 @@ class StringJoinTask extends Task30 {
     return { result: input2.values.join(separator) };
   }
 }
-Workflow32.prototype.stringJoin = CreateWorkflow31(StringJoinTask);
+Workflow34.prototype.stringJoin = CreateWorkflow33(StringJoinTask);
 // src/task/string/StringLengthTask.ts
 import {
-  CreateWorkflow as CreateWorkflow32,
-  Task as Task31,
-  Workflow as Workflow33
+  CreateWorkflow as CreateWorkflow34,
+  Task as Task33,
+  Workflow as Workflow35
 } from "@workglow/task-graph";
-var inputSchema26 = {
+var inputSchema27 = {
   type: "object",
   properties: {
     value: {
@@ -8494,13 +9091,13 @@ var outputSchema26 = {
   additionalProperties: false
 };
 
-class StringLengthTask extends Task31 {
+class StringLengthTask extends Task33 {
   static type = "StringLengthTask";
   static category = "String";
   static title = "Length";
   static description = "Returns the length of a string";
   static inputSchema() {
-    return inputSchema26;
+    return inputSchema27;
   }
   static outputSchema() {
     return outputSchema26;
@@ -8509,14 +9106,14 @@ class StringLengthTask extends Task31 {
     return { result: input2.value.length };
   }
 }
-Workflow33.prototype.stringLength = CreateWorkflow32(StringLengthTask);
+Workflow35.prototype.stringLength = CreateWorkflow34(StringLengthTask);
 // src/task/string/StringLowerCaseTask.ts
 import {
-  CreateWorkflow as CreateWorkflow33,
-  Task as Task32,
-  Workflow as Workflow34
+  CreateWorkflow as CreateWorkflow35,
+  Task as Task34,
+  Workflow as Workflow36
 } from "@workglow/task-graph";
-var inputSchema27 = {
+var inputSchema28 = {
   type: "object",
   properties: {
     value: {
@@ -8541,13 +9138,13 @@ var outputSchema27 = {
   additionalProperties: false
 };
 
-class StringLowerCaseTask extends Task32 {
+class StringLowerCaseTask extends Task34 {
   static type = "StringLowerCaseTask";
   static category = "String";
   static title = "Lower Case";
   static description = "Converts a string to lower case";
   static inputSchema() {
-    return inputSchema27;
+    return inputSchema28;
   }
   static outputSchema() {
     return outputSchema27;
@@ -8556,14 +9153,14 @@ class StringLowerCaseTask extends Task32 {
     return { result: input2.value.toLowerCase() };
   }
 }
-Workflow34.prototype.stringLowerCase = CreateWorkflow33(StringLowerCaseTask);
+Workflow36.prototype.stringLowerCase = CreateWorkflow35(StringLowerCaseTask);
 // src/task/string/StringReplaceTask.ts
 import {
-  CreateWorkflow as CreateWorkflow34,
-  Task as Task33,
-  Workflow as Workflow35
+  CreateWorkflow as CreateWorkflow36,
+  Task as Task35,
+  Workflow as Workflow37
 } from "@workglow/task-graph";
-var inputSchema28 = {
+var inputSchema29 = {
   type: "object",
   properties: {
     value: {
@@ -8598,13 +9195,13 @@ var outputSchema28 = {
   additionalProperties: false
 };
 
-class StringReplaceTask extends Task33 {
+class StringReplaceTask extends Task35 {
   static type = "StringReplaceTask";
   static category = "String";
   static title = "Replace";
   static description = "Replaces all occurrences of a substring";
   static inputSchema() {
-    return inputSchema28;
+    return inputSchema29;
   }
   static outputSchema() {
     return outputSchema28;
@@ -8613,14 +9210,14 @@ class StringReplaceTask extends Task33 {
     return { result: input2.value.replaceAll(input2.search, input2.replace) };
   }
 }
-Workflow35.prototype.stringReplace = CreateWorkflow34(StringReplaceTask);
+Workflow37.prototype.stringReplace = CreateWorkflow36(StringReplaceTask);
 // src/task/string/StringSliceTask.ts
 import {
-  CreateWorkflow as CreateWorkflow35,
-  Task as Task34,
-  Workflow as Workflow36
+  CreateWorkflow as CreateWorkflow37,
+  Task as Task36,
+  Workflow as Workflow38
 } from "@workglow/task-graph";
-var inputSchema29 = {
+var inputSchema30 = {
   type: "object",
   properties: {
     value: {
@@ -8655,13 +9252,13 @@ var outputSchema29 = {
   additionalProperties: false
 };
 
-class StringSliceTask extends Task34 {
+class StringSliceTask extends Task36 {
   static type = "StringSliceTask";
   static category = "String";
   static title = "Slice";
   static description = "Extracts a substring by start and optional end index";
   static inputSchema() {
-    return inputSchema29;
+    return inputSchema30;
   }
   static outputSchema() {
     return outputSchema29;
@@ -8670,14 +9267,14 @@ class StringSliceTask extends Task34 {
     return { result: input2.value.slice(input2.start, input2.end) };
   }
 }
-Workflow36.prototype.stringSlice = CreateWorkflow35(StringSliceTask);
+Workflow38.prototype.stringSlice = CreateWorkflow37(StringSliceTask);
 // src/task/string/StringTemplateTask.ts
 import {
-  CreateWorkflow as CreateWorkflow36,
-  Task as Task35,
-  Workflow as Workflow37
+  CreateWorkflow as CreateWorkflow38,
+  Task as Task37,
+  Workflow as Workflow39
 } from "@workglow/task-graph";
-var inputSchema30 = {
+var inputSchema31 = {
   type: "object",
   properties: {
     template: {
@@ -8708,13 +9305,13 @@ var outputSchema30 = {
   additionalProperties: false
 };
 
-class StringTemplateTask extends Task35 {
+class StringTemplateTask extends Task37 {
   static type = "StringTemplateTask";
   static category = "String";
   static title = "Template";
   static description = "Replaces {{key}} placeholders in a template string with values";
   static inputSchema() {
-    return inputSchema30;
+    return inputSchema31;
   }
   static outputSchema() {
     return outputSchema30;
@@ -8727,14 +9324,14 @@ class StringTemplateTask extends Task35 {
     return { result };
   }
 }
-Workflow37.prototype.stringTemplate = CreateWorkflow36(StringTemplateTask);
+Workflow39.prototype.stringTemplate = CreateWorkflow38(StringTemplateTask);
 // src/task/string/StringTrimTask.ts
 import {
-  CreateWorkflow as CreateWorkflow37,
-  Task as Task36,
-  Workflow as Workflow38
+  CreateWorkflow as CreateWorkflow39,
+  Task as Task38,
+  Workflow as Workflow40
 } from "@workglow/task-graph";
-var inputSchema31 = {
+var inputSchema32 = {
   type: "object",
   properties: {
     value: {
@@ -8759,13 +9356,13 @@ var outputSchema31 = {
   additionalProperties: false
 };
 
-class StringTrimTask extends Task36 {
+class StringTrimTask extends Task38 {
   static type = "StringTrimTask";
   static category = "String";
   static title = "Trim";
   static description = "Removes leading and trailing whitespace from a string";
   static inputSchema() {
-    return inputSchema31;
+    return inputSchema32;
   }
   static outputSchema() {
     return outputSchema31;
@@ -8774,14 +9371,14 @@ class StringTrimTask extends Task36 {
     return { result: input2.value.trim() };
   }
 }
-Workflow38.prototype.stringTrim = CreateWorkflow37(StringTrimTask);
+Workflow40.prototype.stringTrim = CreateWorkflow39(StringTrimTask);
 // src/task/string/StringUpperCaseTask.ts
 import {
-  CreateWorkflow as CreateWorkflow38,
-  Task as Task37,
-  Workflow as Workflow39
+  CreateWorkflow as CreateWorkflow40,
+  Task as Task39,
+  Workflow as Workflow41
 } from "@workglow/task-graph";
-var inputSchema32 = {
+var inputSchema33 = {
   type: "object",
   properties: {
     value: {
@@ -8806,13 +9403,13 @@ var outputSchema32 = {
   additionalProperties: false
 };
 
-class StringUpperCaseTask extends Task37 {
+class StringUpperCaseTask extends Task39 {
   static type = "StringUpperCaseTask";
   static category = "String";
   static title = "Upper Case";
   static description = "Converts a string to upper case";
   static inputSchema() {
-    return inputSchema32;
+    return inputSchema33;
   }
   static outputSchema() {
     return outputSchema32;
@@ -8821,10 +9418,10 @@ class StringUpperCaseTask extends Task37 {
     return { result: input2.value.toUpperCase() };
   }
 }
-Workflow39.prototype.stringUpperCase = CreateWorkflow38(StringUpperCaseTask);
+Workflow41.prototype.stringUpperCase = CreateWorkflow40(StringUpperCaseTask);
 // src/task/scalar/ScalarAbsTask.ts
-import { CreateWorkflow as CreateWorkflow39, Task as Task38, Workflow as Workflow40 } from "@workglow/task-graph";
-var inputSchema33 = {
+import { CreateWorkflow as CreateWorkflow41, Task as Task40, Workflow as Workflow42 } from "@workglow/task-graph";
+var inputSchema34 = {
   type: "object",
   properties: {
     value: {
@@ -8849,13 +9446,13 @@ var outputSchema33 = {
   additionalProperties: false
 };
 
-class ScalarAbsTask extends Task38 {
+class ScalarAbsTask extends Task40 {
   static type = "ScalarAbsTask";
   static category = "Math";
   static title = "Abs";
   static description = "Returns the absolute value of a number";
   static inputSchema() {
-    return inputSchema33;
+    return inputSchema34;
   }
   static outputSchema() {
     return outputSchema33;
@@ -8864,10 +9461,10 @@ class ScalarAbsTask extends Task38 {
     return { result: Math.abs(input2.value) };
   }
 }
-Workflow40.prototype.scalarAbs = CreateWorkflow39(ScalarAbsTask);
+Workflow42.prototype.scalarAbs = CreateWorkflow41(ScalarAbsTask);
 // src/task/scalar/ScalarCeilTask.ts
-import { CreateWorkflow as CreateWorkflow40, Task as Task39, Workflow as Workflow41 } from "@workglow/task-graph";
-var inputSchema34 = {
+import { CreateWorkflow as CreateWorkflow42, Task as Task41, Workflow as Workflow43 } from "@workglow/task-graph";
+var inputSchema35 = {
   type: "object",
   properties: {
     value: {
@@ -8892,13 +9489,13 @@ var outputSchema34 = {
   additionalProperties: false
 };
 
-class ScalarCeilTask extends Task39 {
+class ScalarCeilTask extends Task41 {
   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 inputSchema34;
+    return inputSchema35;
   }
   static outputSchema() {
     return outputSchema34;
@@ -8907,10 +9504,10 @@ class ScalarCeilTask extends Task39 {
     return { result: Math.ceil(input2.value) };
   }
 }
-Workflow41.prototype.scalarCeil = CreateWorkflow40(ScalarCeilTask);
+Workflow43.prototype.scalarCeil = CreateWorkflow42(ScalarCeilTask);
 // src/task/scalar/ScalarFloorTask.ts
-import { CreateWorkflow as CreateWorkflow41, Task as Task40, Workflow as Workflow42 } from "@workglow/task-graph";
-var inputSchema35 = {
+import { CreateWorkflow as CreateWorkflow43, Task as Task42, Workflow as Workflow44 } from "@workglow/task-graph";
+var inputSchema36 = {
   type: "object",
   properties: {
     value: {
@@ -8935,13 +9532,13 @@ var outputSchema35 = {
   additionalProperties: false
 };
 
-class ScalarFloorTask extends Task40 {
+class ScalarFloorTask extends Task42 {
   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 inputSchema35;
+    return inputSchema36;
   }
   static outputSchema() {
     return outputSchema35;
@@ -8950,10 +9547,10 @@ class ScalarFloorTask extends Task40 {
     return { result: Math.floor(input2.value) };
   }
 }
-Workflow42.prototype.scalarFloor = CreateWorkflow41(ScalarFloorTask);
+Workflow44.prototype.scalarFloor = CreateWorkflow43(ScalarFloorTask);
 // src/task/scalar/ScalarMaxTask.ts
-import { CreateWorkflow as CreateWorkflow42, Task as Task41, Workflow as Workflow43 } from "@workglow/task-graph";
-var inputSchema36 = {
+import { CreateWorkflow as CreateWorkflow44, Task as Task43, Workflow as Workflow45 } from "@workglow/task-graph";
+var inputSchema37 = {
   type: "object",
   properties: {
     values: {
@@ -8979,13 +9576,13 @@ var outputSchema36 = {
   additionalProperties: false
 };
 
-class ScalarMaxTask extends Task41 {
+class ScalarMaxTask extends Task43 {
   static type = "ScalarMaxTask";
   static category = "Math";
   static title = "Max";
   static description = "Returns the largest of the given numbers";
   static inputSchema() {
-    return inputSchema36;
+    return inputSchema37;
   }
   static outputSchema() {
     return outputSchema36;
@@ -8994,10 +9591,10 @@ class ScalarMaxTask extends Task41 {
     return { result: Math.max(...input2.values) };
   }
 }
-Workflow43.prototype.scalarMax = CreateWorkflow42(ScalarMaxTask);
+Workflow45.prototype.scalarMax = CreateWorkflow44(ScalarMaxTask);
 // src/task/scalar/ScalarMinTask.ts
-import { CreateWorkflow as CreateWorkflow43, Task as Task42, Workflow as Workflow44 } from "@workglow/task-graph";
-var inputSchema37 = {
+import { CreateWorkflow as CreateWorkflow45, Task as Task44, Workflow as Workflow46 } from "@workglow/task-graph";
+var inputSchema38 = {
   type: "object",
   properties: {
     values: {
@@ -9023,13 +9620,13 @@ var outputSchema37 = {
   additionalProperties: false
 };
 
-class ScalarMinTask extends Task42 {
+class ScalarMinTask extends Task44 {
   static type = "ScalarMinTask";
   static category = "Math";
   static title = "Min";
   static description = "Returns the smallest of the given numbers";
   static inputSchema() {
-    return inputSchema37;
+    return inputSchema38;
   }
   static outputSchema() {
     return outputSchema37;
@@ -9038,10 +9635,10 @@ class ScalarMinTask extends Task42 {
     return { result: Math.min(...input2.values) };
   }
 }
-Workflow44.prototype.scalarMin = CreateWorkflow43(ScalarMinTask);
+Workflow46.prototype.scalarMin = CreateWorkflow45(ScalarMinTask);
 // src/task/scalar/ScalarRoundTask.ts
-import { CreateWorkflow as CreateWorkflow44, Task as Task43, Workflow as Workflow45 } from "@workglow/task-graph";
-var inputSchema38 = {
+import { CreateWorkflow as CreateWorkflow46, Task as Task45, Workflow as Workflow47 } from "@workglow/task-graph";
+var inputSchema39 = {
   type: "object",
   properties: {
     value: {
@@ -9066,13 +9663,13 @@ var outputSchema38 = {
   additionalProperties: false
 };
 
-class ScalarRoundTask extends Task43 {
+class ScalarRoundTask extends Task45 {
   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 inputSchema38;
+    return inputSchema39;
   }
   static outputSchema() {
     return outputSchema38;
@@ -9081,10 +9678,10 @@ class ScalarRoundTask extends Task43 {
     return { result: Math.round(input2.value) };
   }
 }
-Workflow45.prototype.scalarRound = CreateWorkflow44(ScalarRoundTask);
+Workflow47.prototype.scalarRound = CreateWorkflow46(ScalarRoundTask);
 // src/task/scalar/ScalarTruncTask.ts
-import { CreateWorkflow as CreateWorkflow45, Task as Task44, Workflow as Workflow46 } from "@workglow/task-graph";
-var inputSchema39 = {
+import { CreateWorkflow as CreateWorkflow47, Task as Task46, Workflow as Workflow48 } from "@workglow/task-graph";
+var inputSchema40 = {
   type: "object",
   properties: {
     value: {
@@ -9109,13 +9706,13 @@ var outputSchema39 = {
   additionalProperties: false
 };
 
-class ScalarTruncTask extends Task44 {
+class ScalarTruncTask extends Task46 {
   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 inputSchema39;
+    return inputSchema40;
   }
   static outputSchema() {
     return outputSchema39;
@@ -9124,13 +9721,13 @@ class ScalarTruncTask extends Task44 {
     return { result: Math.trunc(input2.value) };
   }
 }
-Workflow46.prototype.scalarTrunc = CreateWorkflow45(ScalarTruncTask);
+Workflow48.prototype.scalarTrunc = CreateWorkflow47(ScalarTruncTask);
 // src/task/vector/VectorDistanceTask.ts
-import { CreateWorkflow as CreateWorkflow46, Task as Task45, Workflow as Workflow47 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow48, Task as Task47, Workflow as Workflow49 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util/schema";
-var inputSchema40 = {
+var inputSchema41 = {
   type: "object",
   properties: {
     vectors: {
@@ -9159,13 +9756,13 @@ var outputSchema40 = {
   additionalProperties: false
 };
 
-class VectorDistanceTask extends Task45 {
+class VectorDistanceTask extends Task47 {
   static type = "VectorDistanceTask";
   static category = "Vector";
   static title = "Distance";
   static description = "Returns the Euclidean distance between the first two vectors";
   static inputSchema() {
-    return inputSchema40;
+    return inputSchema41;
   }
   static outputSchema() {
     return outputSchema40;
@@ -9186,13 +9783,13 @@ class VectorDistanceTask extends Task45 {
     return { result: Math.sqrt(sumPrecise(diffs)) };
   }
 }
-Workflow47.prototype.vectorDistance = CreateWorkflow46(VectorDistanceTask);
+Workflow49.prototype.vectorDistance = CreateWorkflow48(VectorDistanceTask);
 // src/task/vector/VectorDotProductTask.ts
-import { CreateWorkflow as CreateWorkflow47, Task as Task46, Workflow as Workflow48 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow49, Task as Task48, Workflow as Workflow50 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema6
 } from "@workglow/util/schema";
-var inputSchema41 = {
+var inputSchema42 = {
   type: "object",
   properties: {
     vectors: {
@@ -9221,13 +9818,13 @@ var outputSchema41 = {
   additionalProperties: false
 };
 
-class VectorDotProductTask extends Task46 {
+class VectorDotProductTask extends Task48 {
   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 inputSchema41;
+    return inputSchema42;
   }
   static outputSchema() {
     return outputSchema41;
@@ -9245,14 +9842,14 @@ class VectorDotProductTask extends Task46 {
     return { result: sumPrecise(products) };
   }
 }
-Workflow48.prototype.vectorDotProduct = CreateWorkflow47(VectorDotProductTask);
+Workflow50.prototype.vectorDotProduct = CreateWorkflow49(VectorDotProductTask);
 // src/task/vector/VectorNormalizeTask.ts
-import { CreateWorkflow as CreateWorkflow48, Task as Task47, Workflow as Workflow49 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow50, Task as Task49, Workflow as Workflow51 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema7,
   normalize
 } from "@workglow/util/schema";
-var inputSchema42 = {
+var inputSchema43 = {
   type: "object",
   properties: {
     vector: TypedArraySchema7({
@@ -9275,13 +9872,13 @@ var outputSchema42 = {
   additionalProperties: false
 };
 
-class VectorNormalizeTask extends Task47 {
+class VectorNormalizeTask extends Task49 {
   static type = "VectorNormalizeTask";
   static category = "Vector";
   static title = "Normalize";
   static description = "Returns the L2-normalized (unit length) vector";
   static inputSchema() {
-    return inputSchema42;
+    return inputSchema43;
   }
   static outputSchema() {
     return outputSchema42;
@@ -9290,14 +9887,14 @@ class VectorNormalizeTask extends Task47 {
     return { result: normalize(input2.vector) };
   }
 }
-Workflow49.prototype.vectorNormalize = CreateWorkflow48(VectorNormalizeTask);
+Workflow51.prototype.vectorNormalize = CreateWorkflow50(VectorNormalizeTask);
 // src/task/vector/VectorScaleTask.ts
-import { CreateWorkflow as CreateWorkflow49, Task as Task48, Workflow as Workflow50 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow51, Task as Task50, Workflow as Workflow52 } from "@workglow/task-graph";
 import {
   createTypedArrayFrom as createTypedArrayFrom5,
   TypedArraySchema as TypedArraySchema8
 } from "@workglow/util/schema";
-var inputSchema43 = {
+var inputSchema44 = {
   type: "object",
   properties: {
     vector: TypedArraySchema8({
@@ -9325,13 +9922,13 @@ var outputSchema43 = {
   additionalProperties: false
 };
 
-class VectorScaleTask extends Task48 {
+class VectorScaleTask extends Task50 {
   static type = "VectorScaleTask";
   static category = "Vector";
   static title = "Scale";
   static description = "Multiplies each element of a vector by a scalar";
   static inputSchema() {
-    return inputSchema43;
+    return inputSchema44;
   }
   static outputSchema() {
     return outputSchema43;
@@ -9342,7 +9939,7 @@ class VectorScaleTask extends Task48 {
     return { result: createTypedArrayFrom5([vector], values) };
   }
 }
-Workflow50.prototype.vectorScale = CreateWorkflow49(VectorScaleTask);
+Workflow52.prototype.vectorScale = CreateWorkflow51(VectorScaleTask);
 
 // src/common.ts
 import { TaskRegistry } from "@workglow/task-graph";
@@ -9351,6 +9948,8 @@ var registerCommonTasks = () => {
     DebugLogTask,
     DelayTask,
     FetchUrlTask,
+    HumanApprovalTask,
+    HumanInputTask,
     InputTask,
     JavaScriptTask,
     JsonTask,
@@ -9403,21 +10002,21 @@ var registerCommonTasks = () => {
 };
 // src/task/FileLoaderTask.server.ts
 import {
-  CreateWorkflow as CreateWorkflow51,
-  TaskAbortedError as TaskAbortedError3,
-  Workflow as Workflow52
+  CreateWorkflow as CreateWorkflow53,
+  TaskAbortedError as TaskAbortedError5,
+  Workflow as Workflow54
 } from "@workglow/task-graph";
 import { readFile } from "fs/promises";
 
 // src/task/FileLoaderTask.ts
 import {
-  CreateWorkflow as CreateWorkflow50,
-  Task as Task49,
-  TaskAbortedError as TaskAbortedError2,
-  Workflow as Workflow51
+  CreateWorkflow as CreateWorkflow52,
+  Task as Task51,
+  TaskAbortedError as TaskAbortedError4,
+  Workflow as Workflow53
 } from "@workglow/task-graph";
 import Papa from "papaparse";
-var inputSchema44 = {
+var inputSchema45 = {
   type: "object",
   properties: {
     url: {
@@ -9488,14 +10087,14 @@ var outputSchema44 = {
   additionalProperties: false
 };
 
-class FileLoaderTask extends Task49 {
+class FileLoaderTask extends Task51 {
   static type = "FileLoaderTask";
   static category = "Document";
   static title = "File Loader";
   static description = "Load documents from URLs (http://, https://)";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema44;
+    return inputSchema45;
   }
   static outputSchema() {
     return outputSchema44;
@@ -9503,30 +10102,28 @@ class FileLoaderTask extends Task49 {
   async execute(input2, context) {
     const { url, format = "auto" } = input2;
     if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
+      throw new TaskAbortedError4("Task aborted");
     }
     await context.updateProgress(0, "Detecting file format");
     const detectedFormat = this.detectFormat(url, format);
     const responseType = this.detectResponseType(detectedFormat);
     if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
+      throw new TaskAbortedError4("Task aborted");
     }
     await context.updateProgress(10, `Fetching ${detectedFormat} file from ${url}`);
-    const fetchTask = context.own(new FetchUrlTask({
+    const fetchTask = context.own(new FetchUrlTask({ queue: false }));
+    const response = await fetchTask.run({
       url,
       response_type: responseType
-    }, {
-      queue: false
-    }));
-    const response = await fetchTask.run();
+    });
     if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
+      throw new TaskAbortedError4("Task aborted");
     }
     await context.updateProgress(60, "Parsing file content");
     const title = url.split("/").pop() || url;
     const { text, json: json2, csv, image, pdf, frontmatter, size, mimeType } = await this.parseResponse(response, url, detectedFormat);
     if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
+      throw new TaskAbortedError4("Task aborted");
     }
     await context.updateProgress(100, "File loaded successfully");
     return {
@@ -9849,7 +10446,7 @@ class FileLoaderTask extends Task49 {
     });
   }
 }
-Workflow51.prototype.fileLoader = CreateWorkflow50(FileLoaderTask);
+Workflow53.prototype.fileLoader = CreateWorkflow52(FileLoaderTask);
 
 // src/task/FileLoaderTask.server.ts
 class FileLoaderTask2 extends FileLoaderTask {
@@ -9859,7 +10456,7 @@ class FileLoaderTask2 extends FileLoaderTask {
       return super.execute(input2, context);
     }
     if (context.signal.aborted) {
-      throw new TaskAbortedError3("Task aborted");
+      throw new TaskAbortedError5("Task aborted");
     }
     await context.updateProgress(0, "Detecting file format");
     if (url.startsWith("file://")) {
@@ -9868,19 +10465,19 @@ class FileLoaderTask2 extends FileLoaderTask {
     const detectedFormat = this.detectFormat(url, format);
     const title = url.split("/").pop() || url;
     if (context.signal.aborted) {
-      throw new TaskAbortedError3("Task aborted");
+      throw new TaskAbortedError5("Task aborted");
     }
     await context.updateProgress(10, `Reading ${detectedFormat} file from filesystem`);
     if (detectedFormat === "json") {
       const fileContent2 = await readFile(url, { encoding: "utf-8" });
       if (context.signal.aborted) {
-        throw new TaskAbortedError3("Task aborted");
+        throw new TaskAbortedError5("Task aborted");
       }
       await context.updateProgress(50, "Parsing JSON content");
       const jsonData = this.parseJsonContent(fileContent2);
       const content = JSON.stringify(jsonData, null, 2);
       if (context.signal.aborted) {
-        throw new TaskAbortedError3("Task aborted");
+        throw new TaskAbortedError5("Task aborted");
       }
       await context.updateProgress(100, "File loaded successfully");
       return {
@@ -9905,12 +10502,12 @@ class FileLoaderTask2 extends FileLoaderTask {
         throw new Error(`Failed to load CSV from ${url}`);
       }
       if (context.signal.aborted) {
-        throw new TaskAbortedError3("Task aborted");
+        throw new TaskAbortedError5("Task aborted");
       }
       await context.updateProgress(50, "Parsing CSV content");
       const csvData = this.parseCsvContent(fileContent2);
       if (context.signal.aborted) {
-        throw new TaskAbortedError3("Task aborted");
+        throw new TaskAbortedError5("Task aborted");
       }
       await context.updateProgress(100, "File loaded successfully");
       return {
@@ -9932,14 +10529,14 @@ class FileLoaderTask2 extends FileLoaderTask {
     if (detectedFormat === "image") {
       const fileBuffer = await readFile(url);
       if (context.signal.aborted) {
-        throw new TaskAbortedError3("Task aborted");
+        throw new TaskAbortedError5("Task aborted");
       }
       await context.updateProgress(50, "Converting image to base64");
       const mimeType2 = this.getImageMimeType(url);
       const blob = new Blob([fileBuffer], { type: mimeType2 });
       const imageData = await this.blobToBase64DataURL(blob, mimeType2);
       if (context.signal.aborted) {
-        throw new TaskAbortedError3("Task aborted");
+        throw new TaskAbortedError5("Task aborted");
       }
       await context.updateProgress(100, "File loaded successfully");
       return {
@@ -9961,14 +10558,14 @@ class FileLoaderTask2 extends FileLoaderTask {
     if (detectedFormat === "pdf") {
       const fileBuffer = await readFile(url);
       if (context.signal.aborted) {
-        throw new TaskAbortedError3("Task aborted");
+        throw new TaskAbortedError5("Task aborted");
       }
       await context.updateProgress(50, "Converting PDF to base64");
       const mimeType2 = "application/pdf";
       const blob = new Blob([fileBuffer], { type: mimeType2 });
       const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
       if (context.signal.aborted) {
-        throw new TaskAbortedError3("Task aborted");
+        throw new TaskAbortedError5("Task aborted");
       }
       await context.updateProgress(100, "File loaded successfully");
       return {
@@ -9992,12 +10589,12 @@ class FileLoaderTask2 extends FileLoaderTask {
       throw new Error(`Failed to load content from ${url}`);
     }
     if (context.signal.aborted) {
-      throw new TaskAbortedError3("Task aborted");
+      throw new TaskAbortedError5("Task aborted");
     }
     await context.updateProgress(50, `Parsing ${detectedFormat} content`);
     const mimeType = detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain";
     if (context.signal.aborted) {
-      throw new TaskAbortedError3("Task aborted");
+      throw new TaskAbortedError5("Task aborted");
     }
     await context.updateProgress(100, "File loaded successfully");
     if (detectedFormat === "markdown") {
@@ -10036,9 +10633,9 @@ class FileLoaderTask2 extends FileLoaderTask {
   }
 }
 var fileLoader = (input2, config) => {
-  return new FileLoaderTask2({}, config).run(input2);
+  return new FileLoaderTask2(config).run(input2);
 };
-Workflow52.prototype.fileLoader = CreateWorkflow51(FileLoaderTask2);
+Workflow54.prototype.fileLoader = CreateWorkflow53(FileLoaderTask2);
 
 // src/bun.ts
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -10062,6 +10659,7 @@ export {
   setGlobalMcpServerRepository,
   searchMcpRegistryPage,
   searchMcpRegistry,
+  resolveHumanConnector,
   resolveAuthSecrets,
   registerMcpTaskDeps,
   registerMcpServer,
@@ -10139,6 +10737,7 @@ export {
   McpResourceReadTask,
   McpPromptGetTask,
   McpListTask,
+  McpElicitationConnector,
   MCP_TASK_DEPS,
   MCP_SERVER_REPOSITORY,
   MCP_SERVERS,
@@ -10148,6 +10747,9 @@ export {
   JavaScriptTask,
   InputTask,
   InMemoryMcpServerRepository,
+  HumanInputTask,
+  HumanApprovalTask,
+  HUMAN_CONNECTOR,
   FileLoaderTask2 as FileLoaderTask,
   FetchUrlTask,
   FetchUrlJob,
@@ -10158,4 +10760,4 @@ export {
   ArrayTask
 };
 
-//# debugId=654086ECE48059BF64756E2164756E21
+//# debugId=DC14AA49C50E3BA564756E2164756E21