@workglow/tasks 0.1.2 → 0.2.1

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,19 +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);
 }
@@ -7334,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",
@@ -7491,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 {
@@ -7574,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",
@@ -7717,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";
@@ -7725,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;
   }
@@ -7736,7 +8257,7 @@ class McpPromptGetTask extends Task24 {
     return {
       type: "object",
       properties: {
-        ...TaskConfigSchema6["properties"],
+        ...TaskConfigSchema8["properties"],
         server: TypeMcpServer(mcpServerConfigSchema2),
         prompt_name: {
           type: "string",
@@ -7755,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);
@@ -7813,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: [
@@ -7849,7 +8374,7 @@ var contentItemSchema = {
     }
   ]
 };
-var inputSchema22 = {
+var inputSchema23 = {
   type: "object",
   properties: {},
   additionalProperties: false
@@ -7868,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;
@@ -7886,7 +8436,7 @@ class McpResourceReadTask extends Task25 {
     return {
       type: "object",
       properties: {
-        ...TaskConfigSchema7["properties"],
+        ...TaskConfigSchema9["properties"],
         server: TypeMcpServer(mcpServerConfigSchema2),
         resource_uri: {
           type: "string",
@@ -7914,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",
@@ -8057,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;
   }
@@ -8075,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",
@@ -8210,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";
@@ -8218,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;
   }
@@ -8229,7 +8816,7 @@ class McpToolCallTask extends Task27 {
     return {
       type: "object",
       properties: {
-        ...TaskConfigSchema8["properties"],
+        ...TaskConfigSchema10["properties"],
         server: TypeMcpServer(mcpServerConfigSchema2),
         tool_name: {
           type: "string",
@@ -8248,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);
@@ -8321,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" }
@@ -8348,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;
@@ -8363,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: {
@@ -8400,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;
@@ -8415,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: {
@@ -8454,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;
@@ -8470,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: {
@@ -8502,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;
@@ -8517,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: {
@@ -8549,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;
@@ -8564,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: {
@@ -8606,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;
@@ -8621,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: {
@@ -8663,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;
@@ -8678,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: {
@@ -8716,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;
@@ -8735,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: {
@@ -8767,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;
@@ -8782,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: {
@@ -8814,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;
@@ -8829,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: {
@@ -8857,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;
@@ -8872,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: {
@@ -8900,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;
@@ -8915,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: {
@@ -8943,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;
@@ -8958,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: {
@@ -8987,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;
@@ -9002,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: {
@@ -9031,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;
@@ -9046,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: {
@@ -9074,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;
@@ -9089,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: {
@@ -9117,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;
@@ -9132,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: {
@@ -9167,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;
@@ -9194,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: {
@@ -9229,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;
@@ -9253,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({
@@ -9283,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;
@@ -9298,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({
@@ -9333,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;
@@ -9350,7 +9939,1224 @@ class VectorScaleTask extends Task48 {
     return { result: createTypedArrayFrom5([vector], values) };
   }
 }
-Workflow50.prototype.vectorScale = CreateWorkflow49(VectorScaleTask);
+Workflow52.prototype.vectorScale = CreateWorkflow51(VectorScaleTask);
+// src/task/image/ImageSchemas.ts
+import { FromSchemaDefaultOptions } from "@workglow/util/schema";
+var ImageBinaryType = null;
+var ImageBinarySchemaOptions = {
+  ...FromSchemaDefaultOptions,
+  deserialize: [
+    {
+      pattern: { type: "object", format: "image:ImageBinary" },
+      output: ImageBinaryType
+    }
+  ]
+};
+var ImageBinarySchema = (annotations = {}) => ({
+  type: "object",
+  properties: {
+    data: {
+      type: "array",
+      items: { type: "number", format: "Uint8Clamped" },
+      format: "Uint8ClampedArray",
+      title: "Data",
+      description: "Pixel data of the image"
+    },
+    width: {
+      type: "integer",
+      minimum: 1,
+      title: "Width",
+      description: "Width in pixels"
+    },
+    height: {
+      type: "integer",
+      minimum: 1,
+      title: "Height",
+      description: "Height in pixels"
+    },
+    channels: {
+      type: "integer",
+      enum: [1, 3, 4],
+      title: "Channels",
+      description: "1 (gray), 3 (RGB), or 4 (RGBA)"
+    }
+  },
+  additionalProperties: false,
+  required: ["data", "width", "height", "channels"],
+  format: "image:ImageBinary",
+  title: "Image",
+  description: "Raw pixel image data",
+  ...annotations
+});
+var ColorSchema = (annotations = {}) => ({
+  type: "object",
+  properties: {
+    r: { type: "integer", minimum: 0, maximum: 255, title: "Red" },
+    g: { type: "integer", minimum: 0, maximum: 255, title: "Green" },
+    b: { type: "integer", minimum: 0, maximum: 255, title: "Blue" },
+    a: { type: "integer", minimum: 0, maximum: 255, title: "Alpha", default: 255 }
+  },
+  required: ["r", "g", "b"],
+  additionalProperties: false,
+  ...annotations
+});
+// src/task/image/ImageResizeTask.ts
+import {
+  CreateWorkflow as CreateWorkflow52,
+  Task as Task51,
+  Workflow as Workflow53
+} from "@workglow/task-graph";
+var inputSchema45 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    width: { type: "integer", title: "Width", description: "Target width in pixels", minimum: 1 },
+    height: {
+      type: "integer",
+      title: "Height",
+      description: "Target height in pixels",
+      minimum: 1
+    }
+  },
+  required: ["image", "width", "height"],
+  additionalProperties: false
+};
+var outputSchema44 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Resized image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageResizeTask extends Task51 {
+  static type = "ImageResizeTask";
+  static category = "Image";
+  static title = "Resize Image";
+  static description = "Resizes an image using nearest-neighbor sampling";
+  static inputSchema() {
+    return inputSchema45;
+  }
+  static outputSchema() {
+    return outputSchema44;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, width: dstW, height: dstH } = input2;
+    const { data: src, width: srcW, height: srcH, channels } = image;
+    const dst = new Uint8ClampedArray(dstW * dstH * channels);
+    for (let dy = 0;dy < dstH; dy++) {
+      const srcY = Math.min(Math.floor(dy * srcH / dstH), srcH - 1);
+      for (let dx = 0;dx < dstW; dx++) {
+        const srcX = Math.min(Math.floor(dx * srcW / dstW), srcW - 1);
+        const srcIdx = (srcY * srcW + srcX) * channels;
+        const dstIdx = (dy * dstW + dx) * channels;
+        for (let c = 0;c < channels; c++) {
+          dst[dstIdx + c] = src[srcIdx + c];
+        }
+      }
+    }
+    return {
+      image: { data: dst, width: dstW, height: dstH, channels }
+    };
+  }
+}
+Workflow53.prototype.imageResize = CreateWorkflow52(ImageResizeTask);
+// src/task/image/ImageCropTask.ts
+import {
+  CreateWorkflow as CreateWorkflow53,
+  Task as Task52,
+  Workflow as Workflow54
+} from "@workglow/task-graph";
+var inputSchema46 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    x: { type: "integer", title: "X", description: "Left offset", minimum: 0 },
+    y: { type: "integer", title: "Y", description: "Top offset", minimum: 0 },
+    width: { type: "integer", title: "Width", description: "Crop width", minimum: 1 },
+    height: { type: "integer", title: "Height", description: "Crop height", minimum: 1 }
+  },
+  required: ["image", "x", "y", "width", "height"],
+  additionalProperties: false
+};
+var outputSchema45 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Cropped image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageCropTask extends Task52 {
+  static type = "ImageCropTask";
+  static category = "Image";
+  static title = "Crop Image";
+  static description = "Crops an image to a rectangular region";
+  static inputSchema() {
+    return inputSchema46;
+  }
+  static outputSchema() {
+    return outputSchema45;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, x: rawX, y: rawY, width: rawW, height: rawH } = input2;
+    const { data: src, width: srcW, height: srcH, channels } = image;
+    if (srcW < 1 || srcH < 1) {
+      throw new RangeError("Cannot crop an empty image");
+    }
+    if (rawX < 0 || rawX >= srcW || rawY < 0 || rawY >= srcH) {
+      throw new RangeError("Crop origin is outside the source image bounds");
+    }
+    const x = rawX;
+    const y = rawY;
+    const w = Math.min(rawW, srcW - x);
+    const h = Math.min(rawH, srcH - y);
+    const dst = new Uint8ClampedArray(w * h * channels);
+    const rowBytes = w * channels;
+    for (let row = 0;row < h; row++) {
+      const srcOffset = ((y + row) * srcW + x) * channels;
+      const dstOffset = row * rowBytes;
+      dst.set(src.subarray(srcOffset, srcOffset + rowBytes), dstOffset);
+    }
+    return { image: { data: dst, width: w, height: h, channels } };
+  }
+}
+Workflow54.prototype.imageCrop = CreateWorkflow53(ImageCropTask);
+// src/task/image/ImageRotateTask.ts
+import {
+  CreateWorkflow as CreateWorkflow54,
+  Task as Task53,
+  Workflow as Workflow55
+} from "@workglow/task-graph";
+var inputSchema47 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    angle: {
+      type: "integer",
+      enum: [90, 180, 270],
+      title: "Angle",
+      description: "Rotation angle in degrees (clockwise)"
+    }
+  },
+  required: ["image", "angle"],
+  additionalProperties: false
+};
+var outputSchema46 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Rotated image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageRotateTask extends Task53 {
+  static type = "ImageRotateTask";
+  static category = "Image";
+  static title = "Rotate Image";
+  static description = "Rotates an image by 90, 180, or 270 degrees clockwise";
+  static inputSchema() {
+    return inputSchema47;
+  }
+  static outputSchema() {
+    return outputSchema46;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, angle } = input2;
+    const { data: src, width: srcW, height: srcH, channels } = image;
+    const swap = angle === 90 || angle === 270;
+    const dstW = swap ? srcH : srcW;
+    const dstH = swap ? srcW : srcH;
+    const dst = new Uint8ClampedArray(dstW * dstH * channels);
+    for (let sy = 0;sy < srcH; sy++) {
+      for (let sx = 0;sx < srcW; sx++) {
+        let dx, dy;
+        if (angle === 90) {
+          dx = srcH - 1 - sy;
+          dy = sx;
+        } else if (angle === 180) {
+          dx = srcW - 1 - sx;
+          dy = srcH - 1 - sy;
+        } else {
+          dx = sy;
+          dy = srcW - 1 - sx;
+        }
+        const srcIdx = (sy * srcW + sx) * channels;
+        const dstIdx = (dy * dstW + dx) * channels;
+        for (let c = 0;c < channels; c++) {
+          dst[dstIdx + c] = src[srcIdx + c];
+        }
+      }
+    }
+    return {
+      image: { data: dst, width: dstW, height: dstH, channels }
+    };
+  }
+}
+Workflow55.prototype.imageRotate = CreateWorkflow54(ImageRotateTask);
+// src/task/image/ImageFlipTask.ts
+import {
+  CreateWorkflow as CreateWorkflow55,
+  Task as Task54,
+  Workflow as Workflow56
+} from "@workglow/task-graph";
+var inputSchema48 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    direction: {
+      type: "string",
+      enum: ["horizontal", "vertical"],
+      title: "Direction",
+      description: "Flip direction"
+    }
+  },
+  required: ["image", "direction"],
+  additionalProperties: false
+};
+var outputSchema47 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Flipped image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageFlipTask extends Task54 {
+  static type = "ImageFlipTask";
+  static category = "Image";
+  static title = "Flip Image";
+  static description = "Flips an image horizontally or vertically";
+  static inputSchema() {
+    return inputSchema48;
+  }
+  static outputSchema() {
+    return outputSchema47;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, direction } = input2;
+    const { data: src, width, height, channels } = image;
+    const dst = new Uint8ClampedArray(src.length);
+    const rowBytes = width * channels;
+    if (direction === "vertical") {
+      for (let y = 0;y < height; y++) {
+        const srcOffset = y * rowBytes;
+        const dstOffset = (height - 1 - y) * rowBytes;
+        dst.set(src.subarray(srcOffset, srcOffset + rowBytes), dstOffset);
+      }
+    } else {
+      for (let y = 0;y < height; y++) {
+        for (let x = 0;x < width; x++) {
+          const srcIdx = (y * width + x) * channels;
+          const dstIdx = (y * width + (width - 1 - x)) * channels;
+          for (let c = 0;c < channels; c++) {
+            dst[dstIdx + c] = src[srcIdx + c];
+          }
+        }
+      }
+    }
+    return { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow56.prototype.imageFlip = CreateWorkflow55(ImageFlipTask);
+// src/task/image/ImageGrayscaleTask.ts
+import {
+  CreateWorkflow as CreateWorkflow56,
+  Task as Task55,
+  Workflow as Workflow57
+} from "@workglow/task-graph";
+var inputSchema49 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema48 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Grayscale image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageGrayscaleTask extends Task55 {
+  static type = "ImageGrayscaleTask";
+  static category = "Image";
+  static title = "Grayscale";
+  static description = "Converts an image to grayscale using luminance";
+  static inputSchema() {
+    return inputSchema49;
+  }
+  static outputSchema() {
+    return outputSchema48;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    if (channels === 1) {
+      return { image: { data: new Uint8ClampedArray(src), width, height, channels: 1 } };
+    }
+    const pixelCount = width * height;
+    const dst = new Uint8ClampedArray(pixelCount);
+    for (let i = 0;i < pixelCount; i++) {
+      const idx = i * channels;
+      dst[i] = src[idx] * 77 + src[idx + 1] * 150 + src[idx + 2] * 29 >> 8;
+    }
+    return { image: { data: dst, width, height, channels: 1 } };
+  }
+}
+Workflow57.prototype.imageGrayscale = CreateWorkflow56(ImageGrayscaleTask);
+// src/task/image/ImageBorderTask.ts
+import {
+  CreateWorkflow as CreateWorkflow57,
+  Task as Task56,
+  Workflow as Workflow58
+} from "@workglow/task-graph";
+var inputSchema50 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    borderWidth: {
+      type: "integer",
+      title: "Border Width",
+      description: "Border width in pixels",
+      minimum: 1,
+      default: 1
+    },
+    color: ColorSchema({ title: "Color", description: "Border color" })
+  },
+  required: ["image", "color"],
+  additionalProperties: false
+};
+var outputSchema49 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Image with border" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageBorderTask extends Task56 {
+  static type = "ImageBorderTask";
+  static category = "Image";
+  static title = "Add Border";
+  static description = "Adds a colored border around an image";
+  static inputSchema() {
+    return inputSchema50;
+  }
+  static outputSchema() {
+    return outputSchema49;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, borderWidth: bw = 1, color } = input2;
+    const { data: src, width: srcW, height: srcH, channels: srcCh } = image;
+    const outCh = 4;
+    const dstW = srcW + bw * 2;
+    const dstH = srcH + bw * 2;
+    const dst = new Uint8ClampedArray(dstW * dstH * outCh);
+    const r = color.r;
+    const g = color.g;
+    const b = color.b;
+    const a = color.a ?? 255;
+    for (let i = 0;i < dst.length; i += outCh) {
+      dst[i] = r;
+      dst[i + 1] = g;
+      dst[i + 2] = b;
+      dst[i + 3] = a;
+    }
+    for (let y = 0;y < srcH; y++) {
+      for (let x = 0;x < srcW; x++) {
+        const srcIdx = (y * srcW + x) * srcCh;
+        const dstIdx = ((y + bw) * dstW + (x + bw)) * outCh;
+        dst[dstIdx] = src[srcIdx];
+        dst[dstIdx + 1] = srcCh >= 3 ? src[srcIdx + 1] : src[srcIdx];
+        dst[dstIdx + 2] = srcCh >= 3 ? src[srcIdx + 2] : src[srcIdx];
+        dst[dstIdx + 3] = srcCh === 4 ? src[srcIdx + 3] : 255;
+      }
+    }
+    return {
+      image: { data: dst, width: dstW, height: dstH, channels: outCh }
+    };
+  }
+}
+Workflow58.prototype.imageBorder = CreateWorkflow57(ImageBorderTask);
+// src/task/image/ImageTransparencyTask.ts
+import {
+  CreateWorkflow as CreateWorkflow58,
+  Task as Task57,
+  Workflow as Workflow59
+} from "@workglow/task-graph";
+var inputSchema51 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    opacity: {
+      type: "number",
+      title: "Opacity",
+      description: "Opacity level (0.0 = fully transparent, 1.0 = fully opaque)",
+      minimum: 0,
+      maximum: 1
+    }
+  },
+  required: ["image", "opacity"],
+  additionalProperties: false
+};
+var outputSchema50 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Image with adjusted transparency" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageTransparencyTask extends Task57 {
+  static type = "ImageTransparencyTask";
+  static category = "Image";
+  static title = "Set Transparency";
+  static description = "Adjusts the opacity of an image";
+  static inputSchema() {
+    return inputSchema51;
+  }
+  static outputSchema() {
+    return outputSchema50;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, opacity } = input2;
+    const { data: src, width, height, channels: srcCh } = image;
+    const pixelCount = width * height;
+    const dst = new Uint8ClampedArray(pixelCount * 4);
+    const alphaScale = Math.round(opacity * 255);
+    for (let i = 0;i < pixelCount; i++) {
+      const srcIdx = i * srcCh;
+      const dstIdx = i * 4;
+      dst[dstIdx] = src[srcIdx];
+      dst[dstIdx + 1] = srcCh >= 3 ? src[srcIdx + 1] : src[srcIdx];
+      dst[dstIdx + 2] = srcCh >= 3 ? src[srcIdx + 2] : src[srcIdx];
+      const srcAlpha = srcCh === 4 ? src[srcIdx + 3] : 255;
+      dst[dstIdx + 3] = (srcAlpha * alphaScale + 127) / 255;
+    }
+    return {
+      image: { data: dst, width, height, channels: 4 }
+    };
+  }
+}
+Workflow59.prototype.imageTransparency = CreateWorkflow58(ImageTransparencyTask);
+// src/task/image/ImageBlurTask.ts
+import {
+  CreateWorkflow as CreateWorkflow59,
+  Task as Task58,
+  Workflow as Workflow60
+} from "@workglow/task-graph";
+var inputSchema52 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    radius: {
+      type: "integer",
+      title: "Radius",
+      description: "Blur radius (1-10)",
+      minimum: 1,
+      maximum: 10,
+      default: 1
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema51 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Blurred image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageBlurTask extends Task58 {
+  static type = "ImageBlurTask";
+  static category = "Image";
+  static title = "Blur Image";
+  static description = "Applies a box blur to an image";
+  static inputSchema() {
+    return inputSchema52;
+  }
+  static outputSchema() {
+    return outputSchema51;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, radius = 1 } = input2;
+    const { data: src, width, height, channels } = image;
+    const kernelSize = radius * 2 + 1;
+    const tmp = new Uint8ClampedArray(src.length);
+    for (let y = 0;y < height; y++) {
+      for (let c = 0;c < channels; c++) {
+        let sum = 0;
+        for (let k = -radius;k <= radius; k++) {
+          const x = Math.max(0, Math.min(k, width - 1));
+          sum += src[(y * width + x) * channels + c];
+        }
+        tmp[y * width * channels + c] = sum / kernelSize + 0.5 | 0;
+        for (let x = 1;x < width; x++) {
+          const addX = Math.min(x + radius, width - 1);
+          const removeX = Math.max(x - radius - 1, 0);
+          sum += src[(y * width + addX) * channels + c] - src[(y * width + removeX) * channels + c];
+          tmp[(y * width + x) * channels + c] = sum / kernelSize + 0.5 | 0;
+        }
+      }
+    }
+    const dst = new Uint8ClampedArray(src.length);
+    for (let x = 0;x < width; x++) {
+      for (let c = 0;c < channels; c++) {
+        let sum = 0;
+        for (let k = -radius;k <= radius; k++) {
+          const y = Math.max(0, Math.min(k, height - 1));
+          sum += tmp[(y * width + x) * channels + c];
+        }
+        dst[x * channels + c] = sum / kernelSize + 0.5 | 0;
+        for (let y = 1;y < height; y++) {
+          const addY = Math.min(y + radius, height - 1);
+          const removeY = Math.max(y - radius - 1, 0);
+          sum += tmp[(addY * width + x) * channels + c] - tmp[(removeY * width + x) * channels + c];
+          dst[(y * width + x) * channels + c] = sum / kernelSize + 0.5 | 0;
+        }
+      }
+    }
+    return { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow60.prototype.imageBlur = CreateWorkflow59(ImageBlurTask);
+// src/task/image/ImageWatermarkTask.ts
+import {
+  CreateWorkflow as CreateWorkflow60,
+  Task as Task59,
+  Workflow as Workflow61
+} from "@workglow/task-graph";
+var inputSchema53 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    spacing: {
+      type: "integer",
+      title: "Spacing",
+      description: "Pattern spacing in pixels",
+      minimum: 8,
+      default: 64
+    },
+    opacity: {
+      type: "number",
+      title: "Opacity",
+      description: "Watermark opacity (0.0-1.0)",
+      minimum: 0,
+      maximum: 1,
+      default: 0.3
+    },
+    pattern: {
+      type: "string",
+      enum: ["diagonal-lines", "grid", "dots"],
+      title: "Pattern",
+      description: "Watermark pattern type",
+      default: "diagonal-lines"
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema52 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Watermarked image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageWatermarkTask extends Task59 {
+  static type = "ImageWatermarkTask";
+  static category = "Image";
+  static title = "Add Watermark";
+  static description = "Adds a repeating pattern watermark to an image";
+  static inputSchema() {
+    return inputSchema53;
+  }
+  static outputSchema() {
+    return outputSchema52;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, spacing = 64, opacity = 0.3, pattern = "diagonal-lines" } = input2;
+    const { data: src, width, height, channels: srcCh } = image;
+    const outCh = 4;
+    const dst = new Uint8ClampedArray(width * height * outCh);
+    const lineWidth = 2;
+    const dotRadius = Math.max(2, spacing >> 3);
+    const dotRadiusSq = dotRadius * dotRadius;
+    const half = spacing >> 1;
+    const alpha = Math.round(opacity * 255);
+    for (let y = 0;y < height; y++) {
+      for (let x = 0;x < width; x++) {
+        const srcIdx = (y * width + x) * srcCh;
+        const dstIdx = (y * width + x) * outCh;
+        const sr = src[srcIdx];
+        const sg = srcCh >= 3 ? src[srcIdx + 1] : sr;
+        const sb = srcCh >= 3 ? src[srcIdx + 2] : sr;
+        const sa = srcCh === 4 ? src[srcIdx + 3] : 255;
+        let isPattern = false;
+        if (pattern === "diagonal-lines") {
+          isPattern = (x + y) % spacing < lineWidth;
+        } else if (pattern === "grid") {
+          isPattern = x % spacing < lineWidth || y % spacing < lineWidth;
+        } else {
+          const dx = x % spacing - half;
+          const dy = y % spacing - half;
+          isPattern = dx * dx + dy * dy < dotRadiusSq;
+        }
+        if (isPattern) {
+          const blend = alpha;
+          const invBlend = 255 - blend;
+          dst[dstIdx] = (sr * invBlend + 255 * blend + 127) / 255;
+          dst[dstIdx + 1] = (sg * invBlend + 255 * blend + 127) / 255;
+          dst[dstIdx + 2] = (sb * invBlend + 255 * blend + 127) / 255;
+          dst[dstIdx + 3] = sa;
+        } else {
+          dst[dstIdx] = sr;
+          dst[dstIdx + 1] = sg;
+          dst[dstIdx + 2] = sb;
+          dst[dstIdx + 3] = sa;
+        }
+      }
+    }
+    return {
+      image: { data: dst, width, height, channels: outCh }
+    };
+  }
+}
+Workflow61.prototype.imageWatermark = CreateWorkflow60(ImageWatermarkTask);
+// src/task/image/ImagePixelateTask.ts
+import {
+  CreateWorkflow as CreateWorkflow61,
+  Task as Task60,
+  Workflow as Workflow62
+} from "@workglow/task-graph";
+var inputSchema54 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    blockSize: {
+      type: "integer",
+      title: "Block Size",
+      description: "Size of each pixelation block",
+      minimum: 2,
+      default: 8
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema53 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Pixelated image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImagePixelateTask extends Task60 {
+  static type = "ImagePixelateTask";
+  static category = "Image";
+  static title = "Pixelate Image";
+  static description = "Pixelates an image by averaging blocks of pixels";
+  static inputSchema() {
+    return inputSchema54;
+  }
+  static outputSchema() {
+    return outputSchema53;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { image, blockSize = 8 } = input2;
+    const { data: src, width, height, channels } = image;
+    const dst = new Uint8ClampedArray(src.length);
+    for (let by = 0;by < height; by += blockSize) {
+      const blockH = Math.min(blockSize, height - by);
+      for (let bx = 0;bx < width; bx += blockSize) {
+        const blockW = Math.min(blockSize, width - bx);
+        const blockArea = blockW * blockH;
+        const sums = new Array(channels).fill(0);
+        for (let y = by;y < by + blockH; y++) {
+          for (let x = bx;x < bx + blockW; x++) {
+            const idx = (y * width + x) * channels;
+            for (let c = 0;c < channels; c++) {
+              sums[c] += src[idx + c];
+            }
+          }
+        }
+        const avg = sums.map((s) => s / blockArea + 0.5 | 0);
+        for (let y = by;y < by + blockH; y++) {
+          for (let x = bx;x < bx + blockW; x++) {
+            const idx = (y * width + x) * channels;
+            for (let c = 0;c < channels; c++) {
+              dst[idx + c] = avg[c];
+            }
+          }
+        }
+      }
+    }
+    return { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow62.prototype.imagePixelate = CreateWorkflow61(ImagePixelateTask);
+// src/task/image/ImageInvertTask.ts
+import {
+  CreateWorkflow as CreateWorkflow62,
+  Task as Task61,
+  Workflow as Workflow63
+} from "@workglow/task-graph";
+var inputSchema55 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema54 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Inverted image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageInvertTask extends Task61 {
+  static type = "ImageInvertTask";
+  static category = "Image";
+  static title = "Invert Colors";
+  static description = "Inverts the colors of an image";
+  static inputSchema() {
+    return inputSchema55;
+  }
+  static outputSchema() {
+    return outputSchema54;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const dst = new Uint8ClampedArray(src.length);
+    if (channels === 4) {
+      for (let i = 0;i < src.length; i += 4) {
+        dst[i] = 255 - src[i];
+        dst[i + 1] = 255 - src[i + 1];
+        dst[i + 2] = 255 - src[i + 2];
+        dst[i + 3] = src[i + 3];
+      }
+    } else {
+      for (let i = 0;i < src.length; i++) {
+        dst[i] = 255 - src[i];
+      }
+    }
+    return { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow63.prototype.imageInvert = CreateWorkflow62(ImageInvertTask);
+// src/task/image/ImageBrightnessTask.ts
+import {
+  CreateWorkflow as CreateWorkflow63,
+  Task as Task62,
+  Workflow as Workflow64
+} from "@workglow/task-graph";
+var inputSchema56 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    amount: {
+      type: "number",
+      title: "Amount",
+      description: "Brightness adjustment (-255 to 255)",
+      minimum: -255,
+      maximum: 255,
+      default: 0
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema55 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Brightness-adjusted image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageBrightnessTask extends Task62 {
+  static type = "ImageBrightnessTask";
+  static category = "Image";
+  static title = "Adjust Brightness";
+  static description = "Adjusts the brightness of an image";
+  static inputSchema() {
+    return inputSchema56;
+  }
+  static outputSchema() {
+    return outputSchema55;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const amount = input2.amount ?? 0;
+    const dst = new Uint8ClampedArray(src.length);
+    if (channels === 4) {
+      for (let i = 0;i < src.length; i += 4) {
+        dst[i] = src[i] + amount;
+        dst[i + 1] = src[i + 1] + amount;
+        dst[i + 2] = src[i + 2] + amount;
+        dst[i + 3] = src[i + 3];
+      }
+    } else {
+      for (let i = 0;i < src.length; i++) {
+        dst[i] = src[i] + amount;
+      }
+    }
+    return { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow64.prototype.imageBrightness = CreateWorkflow63(ImageBrightnessTask);
+// src/task/image/ImageContrastTask.ts
+import {
+  CreateWorkflow as CreateWorkflow64,
+  Task as Task63,
+  Workflow as Workflow65
+} from "@workglow/task-graph";
+var inputSchema57 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    amount: {
+      type: "number",
+      title: "Amount",
+      description: "Contrast adjustment (-100 to 100)",
+      minimum: -100,
+      maximum: 100,
+      default: 0
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema56 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Contrast-adjusted image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageContrastTask extends Task63 {
+  static type = "ImageContrastTask";
+  static category = "Image";
+  static title = "Adjust Contrast";
+  static description = "Adjusts the contrast of an image";
+  static inputSchema() {
+    return inputSchema57;
+  }
+  static outputSchema() {
+    return outputSchema56;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const amount = input2.amount ?? 0;
+    const factor = 259 * (amount + 255) / (255 * (259 - amount));
+    const lut = new Uint8ClampedArray(256);
+    for (let i = 0;i < 256; i++) {
+      lut[i] = factor * (i - 128) + 128;
+    }
+    const dst = new Uint8ClampedArray(src.length);
+    if (channels === 4) {
+      for (let i = 0;i < src.length; i += 4) {
+        dst[i] = lut[src[i]];
+        dst[i + 1] = lut[src[i + 1]];
+        dst[i + 2] = lut[src[i + 2]];
+        dst[i + 3] = src[i + 3];
+      }
+    } else {
+      for (let i = 0;i < src.length; i++) {
+        dst[i] = lut[src[i]];
+      }
+    }
+    return { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow65.prototype.imageContrast = CreateWorkflow64(ImageContrastTask);
+// src/task/image/ImageSepiaTask.ts
+import {
+  CreateWorkflow as CreateWorkflow65,
+  Task as Task64,
+  Workflow as Workflow66
+} from "@workglow/task-graph";
+var inputSchema58 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema57 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Sepia-toned image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageSepiaTask extends Task64 {
+  static type = "ImageSepiaTask";
+  static category = "Image";
+  static title = "Sepia Tone";
+  static description = "Applies a sepia tone filter to an image";
+  static inputSchema() {
+    return inputSchema58;
+  }
+  static outputSchema() {
+    return outputSchema57;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const dst = new Uint8ClampedArray(src.length);
+    const pixelCount = width * height;
+    for (let i = 0;i < pixelCount; i++) {
+      const idx = i * channels;
+      const r = channels === 1 ? src[idx] : src[idx];
+      const g = channels === 1 ? src[idx] : src[idx + 1];
+      const b = channels === 1 ? src[idx] : src[idx + 2];
+      const outR = r * 402 + g * 787 + b * 194 >> 10;
+      const outG = r * 357 + g * 702 + b * 172 >> 10;
+      const outB = r * 279 + g * 547 + b * 134 >> 10;
+      dst[idx] = outR > 255 ? 255 : outR;
+      if (channels >= 3) {
+        dst[idx + 1] = outG > 255 ? 255 : outG;
+        dst[idx + 2] = outB > 255 ? 255 : outB;
+      }
+      if (channels === 4) {
+        dst[idx + 3] = src[idx + 3];
+      }
+    }
+    return { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow66.prototype.imageSepia = CreateWorkflow65(ImageSepiaTask);
+// src/task/image/ImageThresholdTask.ts
+import {
+  CreateWorkflow as CreateWorkflow66,
+  Task as Task65,
+  Workflow as Workflow67
+} from "@workglow/task-graph";
+var inputSchema59 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    threshold: {
+      type: "integer",
+      title: "Threshold",
+      description: "Threshold value (0-255)",
+      minimum: 0,
+      maximum: 255,
+      default: 128
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema58 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Thresholded binary image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageThresholdTask extends Task65 {
+  static type = "ImageThresholdTask";
+  static category = "Image";
+  static title = "Threshold";
+  static description = "Converts an image to binary black and white";
+  static inputSchema() {
+    return inputSchema59;
+  }
+  static outputSchema() {
+    return outputSchema58;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const threshold = input2.threshold ?? 128;
+    const pixelCount = width * height;
+    const dst = new Uint8ClampedArray(pixelCount);
+    for (let i = 0;i < pixelCount; i++) {
+      const idx = i * channels;
+      let gray;
+      if (channels === 1) {
+        gray = src[idx];
+      } else {
+        gray = src[idx] * 77 + src[idx + 1] * 150 + src[idx + 2] * 29 >> 8;
+      }
+      dst[i] = gray >= threshold ? 255 : 0;
+    }
+    return { image: { data: dst, width, height, channels: 1 } };
+  }
+}
+Workflow67.prototype.imageThreshold = CreateWorkflow66(ImageThresholdTask);
+// src/task/image/ImagePosterizeTask.ts
+import {
+  CreateWorkflow as CreateWorkflow67,
+  Task as Task66,
+  Workflow as Workflow68
+} from "@workglow/task-graph";
+var inputSchema60 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    levels: {
+      type: "integer",
+      title: "Levels",
+      description: "Number of color levels per channel (2-32)",
+      minimum: 2,
+      maximum: 32,
+      default: 4
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+var outputSchema59 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Posterized image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImagePosterizeTask extends Task66 {
+  static type = "ImagePosterizeTask";
+  static category = "Image";
+  static title = "Posterize";
+  static description = "Reduces the number of color levels in an image";
+  static inputSchema() {
+    return inputSchema60;
+  }
+  static outputSchema() {
+    return outputSchema59;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const levels = input2.levels ?? 4;
+    const step = 255 / (levels - 1);
+    const lut = new Uint8ClampedArray(256);
+    for (let i = 0;i < 256; i++) {
+      lut[i] = Math.round(Math.round(i / step) * step);
+    }
+    const dst = new Uint8ClampedArray(src.length);
+    if (channels === 4) {
+      for (let i = 0;i < src.length; i += 4) {
+        dst[i] = lut[src[i]];
+        dst[i + 1] = lut[src[i + 1]];
+        dst[i + 2] = lut[src[i + 2]];
+        dst[i + 3] = src[i + 3];
+      }
+    } else {
+      for (let i = 0;i < src.length; i++) {
+        dst[i] = lut[src[i]];
+      }
+    }
+    return { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow68.prototype.imagePosterize = CreateWorkflow67(ImagePosterizeTask);
+// src/task/image/ImageTintTask.ts
+import {
+  CreateWorkflow as CreateWorkflow68,
+  Task as Task67,
+  Workflow as Workflow69
+} from "@workglow/task-graph";
+var inputSchema61 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Source image" }),
+    color: ColorSchema({ title: "Color", description: "Tint color" }),
+    amount: {
+      type: "number",
+      title: "Amount",
+      description: "Tint strength (0.0 = no tint, 1.0 = full tint color)",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5
+    }
+  },
+  required: ["image", "color"],
+  additionalProperties: false
+};
+var outputSchema60 = {
+  type: "object",
+  properties: {
+    image: ImageBinarySchema({ title: "Image", description: "Tinted image" })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class ImageTintTask extends Task67 {
+  static type = "ImageTintTask";
+  static category = "Image";
+  static title = "Tint Image";
+  static description = "Applies a color tint to an image";
+  static inputSchema() {
+    return inputSchema61;
+  }
+  static outputSchema() {
+    return outputSchema60;
+  }
+  async executeReactive(input2, _output, _context) {
+    const { data: src, width, height, channels } = input2.image;
+    const { r: tr, g: tg, b: tb } = input2.color;
+    const amount = input2.amount ?? 0.5;
+    const invAmount = 1 - amount;
+    const tintR = tr * amount;
+    const tintG = tg * amount;
+    const tintB = tb * amount;
+    const pixelCount = width * height;
+    if (channels === 1) {
+      const dst2 = new Uint8ClampedArray(pixelCount * 3);
+      for (let i = 0;i < pixelCount; i++) {
+        const gray = src[i];
+        dst2[i * 3] = gray * invAmount + tintR;
+        dst2[i * 3 + 1] = gray * invAmount + tintG;
+        dst2[i * 3 + 2] = gray * invAmount + tintB;
+      }
+      return { image: { data: dst2, width, height, channels: 3 } };
+    }
+    const dst = new Uint8ClampedArray(src.length);
+    for (let i = 0;i < pixelCount; i++) {
+      const idx = i * channels;
+      dst[idx] = src[idx] * invAmount + tintR;
+      dst[idx + 1] = src[idx + 1] * invAmount + tintG;
+      dst[idx + 2] = src[idx + 2] * invAmount + tintB;
+      if (channels === 4) {
+        dst[idx + 3] = src[idx + 3];
+      }
+    }
+    return { image: { data: dst, width, height, channels } };
+  }
+}
+Workflow69.prototype.imageTint = CreateWorkflow68(ImageTintTask);
 
 // src/common.ts
 import { TaskRegistry } from "@workglow/task-graph";
@@ -9359,6 +11165,8 @@ var registerCommonTasks = () => {
     DebugLogTask,
     DelayTask,
     FetchUrlTask,
+    HumanApprovalTask,
+    HumanInputTask,
     InputTask,
     JavaScriptTask,
     JsonTask,
@@ -9404,28 +11212,45 @@ var registerCommonTasks = () => {
     JsonPathTask,
     TemplateTask,
     DateFormatTask,
-    RegexTask
+    RegexTask,
+    ImageResizeTask,
+    ImageCropTask,
+    ImageRotateTask,
+    ImageFlipTask,
+    ImageGrayscaleTask,
+    ImageBorderTask,
+    ImageTransparencyTask,
+    ImageBlurTask,
+    ImageWatermarkTask,
+    ImagePixelateTask,
+    ImageInvertTask,
+    ImageBrightnessTask,
+    ImageContrastTask,
+    ImageSepiaTask,
+    ImageThresholdTask,
+    ImagePosterizeTask,
+    ImageTintTask
   ];
   tasks.map(TaskRegistry.registerTask);
   return tasks;
 };
 // src/task/FileLoaderTask.server.ts
 import {
-  CreateWorkflow as CreateWorkflow51,
-  TaskAbortedError as TaskAbortedError3,
-  Workflow as Workflow52
+  CreateWorkflow as CreateWorkflow70,
+  TaskAbortedError as TaskAbortedError5,
+  Workflow as Workflow71
 } 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 CreateWorkflow69,
+  Task as Task68,
+  TaskAbortedError as TaskAbortedError4,
+  Workflow as Workflow70
 } from "@workglow/task-graph";
 import Papa from "papaparse";
-var inputSchema44 = {
+var inputSchema62 = {
   type: "object",
   properties: {
     url: {
@@ -9445,7 +11270,7 @@ var inputSchema44 = {
   required: ["url"],
   additionalProperties: false
 };
-var outputSchema44 = {
+var outputSchema61 = {
   type: "object",
   properties: {
     text: {
@@ -9496,45 +11321,43 @@ var outputSchema44 = {
   additionalProperties: false
 };
 
-class FileLoaderTask extends Task49 {
+class FileLoaderTask extends Task68 {
   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 inputSchema62;
   }
   static outputSchema() {
-    return outputSchema44;
+    return outputSchema61;
   }
   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 {
@@ -9857,7 +11680,7 @@ class FileLoaderTask extends Task49 {
     });
   }
 }
-Workflow51.prototype.fileLoader = CreateWorkflow50(FileLoaderTask);
+Workflow70.prototype.fileLoader = CreateWorkflow69(FileLoaderTask);
 
 // src/task/FileLoaderTask.server.ts
 class FileLoaderTask2 extends FileLoaderTask {
@@ -9867,7 +11690,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://")) {
@@ -9876,19 +11699,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 {
@@ -9913,12 +11736,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 {
@@ -9940,14 +11763,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 {
@@ -9969,14 +11792,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 {
@@ -10000,12 +11823,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") {
@@ -10044,9 +11867,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);
+Workflow71.prototype.fileLoader = CreateWorkflow70(FileLoaderTask2);
 
 // src/bun.ts
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -10070,6 +11893,7 @@ export {
   setGlobalMcpServerRepository,
   searchMcpRegistryPage,
   searchMcpRegistry,
+  resolveHumanConnector,
   resolveAuthSecrets,
   registerMcpTaskDeps,
   registerMcpServer,
@@ -10147,6 +11971,7 @@ export {
   McpResourceReadTask,
   McpPromptGetTask,
   McpListTask,
+  McpElicitationConnector,
   MCP_TASK_DEPS,
   MCP_SERVER_REPOSITORY,
   MCP_SERVERS,
@@ -10156,6 +11981,28 @@ export {
   JavaScriptTask,
   InputTask,
   InMemoryMcpServerRepository,
+  ImageWatermarkTask,
+  ImageTransparencyTask,
+  ImageTintTask,
+  ImageThresholdTask,
+  ImageSepiaTask,
+  ImageRotateTask,
+  ImageResizeTask,
+  ImagePosterizeTask,
+  ImagePixelateTask,
+  ImageInvertTask,
+  ImageGrayscaleTask,
+  ImageFlipTask,
+  ImageCropTask,
+  ImageContrastTask,
+  ImageBrightnessTask,
+  ImageBorderTask,
+  ImageBlurTask,
+  ImageBinarySchemaOptions,
+  ImageBinarySchema,
+  HumanInputTask,
+  HumanApprovalTask,
+  HUMAN_CONNECTOR,
   FileLoaderTask2 as FileLoaderTask,
   FetchUrlTask,
   FetchUrlJob,
@@ -10163,7 +12010,8 @@ export {
   DebugLogTask,
   DateFormatTask,
   CredentialStoreOAuthProvider,
+  ColorSchema,
   ArrayTask
 };
 
-//# debugId=3039619901B143F864756E2164756E21
+//# debugId=BA94302B77638A1964756E2164756E21