@workglow/ai 0.0.116 → 0.0.118

package/dist/browser.js

@@ -421,8 +421,83 @@ class AiProvider {
 // src/task/index.ts
 import { TaskRegistry } from "@workglow/task-graph";
 
-// src/task/BackgroundRemovalTask.ts
-import { CreateWorkflow, Workflow } from "@workglow/task-graph";
+// src/task/AgentTask.ts
+import {
+  CreateWorkflow as CreateWorkflow2,
+  Task,
+  Workflow as Workflow2
+} from "@workglow/task-graph";
+import { getLogger as getLogger3 } from "@workglow/util";
+
+// src/task/AgentTypes.ts
+import { parseDataUri } from "@workglow/util";
+function imageBlock(mimeType, data) {
+  return { type: "image", mimeType, data };
+}
+function audioBlock(mimeType, data) {
+  return { type: "audio", mimeType, data };
+}
+function imageBlockFromDataUri(dataUri) {
+  const { mimeType, base64 } = parseDataUri(dataUri);
+  return { type: "image", mimeType, data: base64 };
+}
+function audioBlockFromDataUri(dataUri) {
+  const { mimeType, base64 } = parseDataUri(dataUri);
+  return { type: "audio", mimeType, data: base64 };
+}
+function userMessage(prompt) {
+  return { role: "user", content: prompt };
+}
+function assistantMessage(text, toolCalls) {
+  const content = [];
+  if (text) {
+    content.push({ type: "text", text });
+  }
+  if (toolCalls) {
+    for (const tc of toolCalls) {
+      content.push({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.name,
+        input: tc.input
+      });
+    }
+  }
+  return { role: "assistant", content };
+}
+function toolMessage(results) {
+  return {
+    role: "tool",
+    content: results.map((r) => {
+      const jsonText = JSON.stringify(r.output);
+      const content = r.mediaContent && r.mediaContent.length > 0 ? [{ type: "text", text: jsonText }, ...r.mediaContent] : jsonText;
+      return {
+        type: "tool_result",
+        tool_use_id: r.toolCallId,
+        content,
+        is_error: r.isError || undefined
+      };
+    })
+  };
+}
+function toolSourceDefinitions(sources) {
+  return sources.map((s) => s.definition);
+}
+function findToolSource(sources, name) {
+  return sources.find((s) => s.definition.name === name);
+}
+
+// src/task/AgentUtils.ts
+import { getTaskConstructors as getTaskConstructors2 } from "@workglow/task-graph";
+import { getLogger as getLogger2 } from "@workglow/util";
+
+// src/task/ToolCallingTask.ts
+import {
+  CreateWorkflow,
+  getTaskConstructors,
+  Workflow
+} from "@workglow/task-graph";
+import { getLogger } from "@workglow/util";
 
 // src/task/base/AiTaskSchemas.ts
 var TypeLanguage = (annotations = {}) => ({
@@ -581,8 +656,10 @@ var TypeCategory = {
   description: "Classification category with label and score"
 };
 
-// src/task/base/AiVisionTask.ts
-import { convertImageDataToUseableForm } from "@workglow/util";
+// src/task/base/StreamingAiTask.ts
+import {
+  getStreamingPorts
+} from "@workglow/task-graph";
 
 // src/task/base/AiTask.ts
 import {
@@ -711,7 +788,667 @@ class AiTask extends JobQueueTask {
   }
 }
 
+// src/task/base/StreamingAiTask.ts
+class StreamingAiTask extends AiTask {
+  static type = "StreamingAiTask";
+  async* executeStream(input, context) {
+    const jobInput = await this.getJobInput(input);
+    const queueName = await this.getDefaultQueueName(input);
+    const job = new AiJob({
+      queueName: queueName ?? this.type,
+      jobRunId: this.runConfig.runnerId,
+      input: jobInput
+    });
+    const ports = getStreamingPorts(this.outputSchema());
+    const defaultPort = ports.length > 0 ? ports[0].port : "text";
+    for await (const event of job.executeStream(jobInput, {
+      signal: context.signal,
+      updateProgress: context.updateProgress.bind(this)
+    })) {
+      if (event.type === "text-delta") {
+        yield { ...event, port: event.port ?? defaultPort };
+      } else if (event.type === "object-delta") {
+        yield { ...event, port: event.port ?? defaultPort };
+      } else {
+        yield event;
+      }
+    }
+  }
+}
+
+// src/task/ToolCallingTask.ts
+function buildToolDescription(tool) {
+  let desc = tool.description;
+  if (tool.outputSchema && typeof tool.outputSchema === "object") {
+    desc += `
+
+Returns: ${JSON.stringify(tool.outputSchema)}`;
+  }
+  return desc;
+}
+function isAllowedToolName(name, allowedTools) {
+  return allowedTools.some((t) => t.name === name);
+}
+function filterValidToolCalls(toolCalls, allowedTools) {
+  return toolCalls.filter((tc) => {
+    if (tc.name && isAllowedToolName(tc.name, allowedTools)) {
+      return true;
+    }
+    getLogger().warn(`Filtered out tool call with unknown name "${tc.name ?? "(missing)"}"`, {
+      callId: tc.id,
+      toolName: tc.name
+    });
+    return false;
+  });
+}
+function taskTypesToTools(taskNames, registry) {
+  const constructors = getTaskConstructors(registry);
+  return taskNames.map((name) => {
+    const ctor = constructors.get(name);
+    if (!ctor) {
+      throw new Error(`taskTypesToTools: Unknown task type "${name}" — not found in task constructors registry (ServiceRegistry: ${registry ? "custom" : "default"})`);
+    }
+    const configSchema = "configSchema" in ctor && typeof ctor.configSchema === "function" ? ctor.configSchema() : undefined;
+    return {
+      name: ctor.type,
+      description: ctor.description ?? "",
+      inputSchema: ctor.inputSchema(),
+      outputSchema: ctor.outputSchema(),
+      ...configSchema ? { configSchema } : {},
+      taskType: name
+    };
+  });
+}
+var ToolDefinitionSchema = {
+  type: "object",
+  properties: {
+    name: {
+      type: "string",
+      title: "Name",
+      description: "The tool name"
+    },
+    description: {
+      type: "string",
+      title: "Description",
+      description: "A description of what the tool does"
+    },
+    inputSchema: {
+      type: "object",
+      title: "Input Schema",
+      description: "JSON Schema describing the tool's input parameters",
+      additionalProperties: true
+    },
+    outputSchema: {
+      type: "object",
+      title: "Output Schema",
+      description: "JSON Schema describing what the tool returns",
+      additionalProperties: true
+    },
+    configSchema: {
+      type: "object",
+      title: "Config Schema",
+      description: "JSON Schema describing the task's configuration options (not sent to the LLM)",
+      additionalProperties: true
+    },
+    config: {
+      type: "object",
+      title: "Config",
+      description: "Concrete configuration values for the backing task (not sent to the LLM)",
+      additionalProperties: true
+    }
+  },
+  required: ["name", "description", "inputSchema"],
+  additionalProperties: true
+};
+var ToolCallSchema = {
+  type: "object",
+  properties: {
+    id: {
+      type: "string",
+      title: "ID",
+      description: "Unique identifier for this tool call"
+    },
+    name: {
+      type: "string",
+      title: "Name",
+      description: "The name of the tool to invoke"
+    },
+    input: {
+      type: "object",
+      title: "Input",
+      description: "The input arguments for the tool call",
+      additionalProperties: true
+    }
+  },
+  required: ["id", "name", "input"],
+  additionalProperties: false
+};
+var modelSchema = TypeModel("model:ToolCallingTask");
+var ToolCallingInputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema,
+    prompt: {
+      oneOf: [
+        { type: "string", title: "Prompt", description: "The prompt to send to the model" },
+        {
+          type: "array",
+          title: "Prompt",
+          description: "The prompt as an array of strings or content blocks",
+          items: {
+            oneOf: [
+              { type: "string" },
+              {
+                type: "object",
+                properties: {
+                  type: { type: "string", enum: ["text", "image", "audio"] }
+                },
+                required: ["type"],
+                additionalProperties: true
+              }
+            ]
+          }
+        }
+      ],
+      title: "Prompt",
+      description: "The prompt to send to the model"
+    },
+    systemPrompt: {
+      type: "string",
+      title: "System Prompt",
+      description: "Optional system instructions for the model"
+    },
+    messages: {
+      type: "array",
+      title: "Messages",
+      description: "Full conversation history for multi-turn interactions. When provided, used instead of prompt to construct the messages array sent to the provider.",
+      items: {
+        type: "object",
+        properties: {
+          role: { type: "string", enum: ["user", "assistant", "tool"] },
+          content: {}
+        },
+        required: ["role", "content"],
+        additionalProperties: true
+      }
+    },
+    tools: {
+      type: "array",
+      format: "tasks",
+      title: "Tools",
+      description: "Tool definitions available for the model to call",
+      items: {
+        oneOf: [
+          { type: "string", format: "tasks", description: "Task type name" },
+          ToolDefinitionSchema
+        ]
+      }
+    },
+    toolChoice: {
+      type: "string",
+      title: "Tool Choice",
+      description: 'Controls tool selection: "auto" (model decides), "none" (no tools), "required" (must call a tool), or a specific tool name',
+      "x-ui-group": "Configuration"
+    },
+    maxTokens: {
+      type: "number",
+      title: "Max Tokens",
+      description: "The maximum number of tokens to generate",
+      minimum: 1,
+      "x-ui-group": "Configuration"
+    },
+    temperature: {
+      type: "number",
+      title: "Temperature",
+      description: "The temperature to use for sampling",
+      minimum: 0,
+      maximum: 2,
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["model", "prompt", "tools"],
+  additionalProperties: false
+};
+var ToolCallingOutputSchema = {
+  type: "object",
+  properties: {
+    text: TypeSingleOrArray({
+      type: "string",
+      title: "Text",
+      description: "Any text content generated by the model",
+      "x-stream": "append"
+    }),
+    toolCalls: TypeSingleOrArray({
+      ...ToolCallSchema,
+      "x-stream": "object"
+    })
+  },
+  required: ["text", "toolCalls"],
+  additionalProperties: false
+};
+
+class ToolCallingTask extends StreamingAiTask {
+  static type = "ToolCallingTask";
+  static category = "AI Text Model";
+  static title = "Tool Calling";
+  static description = "Sends a prompt with tool definitions to a language model and returns text along with any tool calls the model requests";
+  static inputSchema() {
+    return ToolCallingInputSchema;
+  }
+  static outputSchema() {
+    return ToolCallingOutputSchema;
+  }
+}
+var toolCalling = (input, config) => {
+  return new ToolCallingTask({}, config).run(input);
+};
+Workflow.prototype.toolCalling = CreateWorkflow(ToolCallingTask);
+
+// src/task/AgentUtils.ts
+function buildToolSources(tools, registry) {
+  if (!tools || tools.length === 0)
+    return [];
+  const stringNames = tools.filter((t) => typeof t === "string");
+  const resolvedDefs = new Map(taskTypesToTools(stringNames, registry).map((d) => [d.taskType, d]));
+  const constructors = getTaskConstructors2(registry);
+  const sources = [];
+  for (const tool of tools) {
+    if (typeof tool === "string") {
+      const def = resolvedDefs.get(tool);
+      if (def) {
+        const { taskType, ...definition } = def;
+        sources.push({
+          type: "registry",
+          definition,
+          taskType
+        });
+      }
+    } else if (tool.execute) {
+      const { execute, configSchema: _cs, config: _c, ...definition } = tool;
+      sources.push({
+        type: "function",
+        definition,
+        run: execute
+      });
+    } else {
+      const ctor = constructors.get(tool.name);
+      if (ctor) {
+        const { execute: _e, configSchema: _cs, config: _c, ...definition } = tool;
+        sources.push({
+          type: "registry",
+          definition,
+          taskType: tool.name,
+          config: tool.config
+        });
+      } else {
+        const { execute: _e, configSchema: _cs, config: _c, ...definition } = tool;
+        sources.push({
+          type: "function",
+          definition,
+          run: async () => {
+            throw new Error(`No executor registered for tool "${tool.name}"`);
+          }
+        });
+      }
+    }
+  }
+  return sources;
+}
+async function executeToolCall(toolCall, sources, context, hooks) {
+  const source = findToolSource(sources, toolCall.name);
+  if (!source) {
+    getLogger2().warn(`AgentTask: Unknown tool "${toolCall.name}" — not found in tool sources`);
+    return {
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      output: { error: `Unknown tool: ${toolCall.name}` },
+      isError: true
+    };
+  }
+  let effectiveCall = toolCall;
+  if (hooks?.beforeToolCall) {
+    const decision = await hooks.beforeToolCall(toolCall, source);
+    if (decision.action === "deny") {
+      return {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        output: { error: decision.reason ?? "Tool call denied by hook" },
+        isError: true
+      };
+    }
+    if (decision.action === "modify") {
+      effectiveCall = { ...toolCall, input: decision.input };
+    }
+  }
+  try {
+    let output;
+    switch (source.type) {
+      case "registry": {
+        const ctor = getTaskConstructors2(context.registry).get(source.taskType);
+        if (!ctor) {
+          throw new Error(`Task type "${source.taskType}" not found in TaskRegistry`);
+        }
+        const taskConfig = source.config ?? {};
+        const task = context.own(new ctor({}, taskConfig));
+        output = await task.run(effectiveCall.input) ?? {};
+        break;
+      }
+      case "function": {
+        output = await source.run(effectiveCall.input);
+        break;
+      }
+    }
+    let result = {
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      output,
+      isError: false
+    };
+    if (hooks?.afterToolCall) {
+      result = await hooks.afterToolCall(toolCall, result);
+    }
+    return result;
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    if (hooks?.onToolError) {
+      const action = await hooks.onToolError(toolCall, error);
+      if (action.action === "result") {
+        return {
+          toolCallId: toolCall.id,
+          toolName: toolCall.name,
+          output: action.output,
+          isError: false
+        };
+      }
+    }
+    getLogger2().warn(`AgentTask: Tool "${toolCall.name}" failed: ${error.message}`);
+    return {
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      output: { error: error.message },
+      isError: true
+    };
+  }
+}
+async function executeToolCalls(toolCalls, sources, context, hooks, maxConcurrency = 5) {
+  const calls = toolCalls;
+  if (calls.length === 0)
+    return [];
+  const concurrency = Math.max(1, Math.min(maxConcurrency, calls.length));
+  const results = new Array(calls.length);
+  let cursor = 0;
+  const workers = Array.from({ length: concurrency }, async () => {
+    while (true) {
+      if (context.signal.aborted) {
+        throw context.signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+      }
+      const position = cursor;
+      cursor += 1;
+      if (position >= calls.length)
+        return;
+      results[position] = await executeToolCall(calls[position], sources, context, hooks);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function hasToolCalls(toolCalls) {
+  return toolCalls !== undefined && toolCalls.length > 0;
+}
+
+// src/task/AgentTask.ts
+var modelSchema2 = TypeModel("model:ToolCallingTask");
+var AgentInputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema2,
+    prompt: {
+      oneOf: [
+        { type: "string" },
+        {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              type: { type: "string", enum: ["text", "image", "audio"] }
+            },
+            required: ["type"],
+            additionalProperties: true
+          }
+        }
+      ],
+      title: "Prompt",
+      description: "The user prompt to start the agent loop. Can be a string or an array of content blocks (text, image, audio)."
+    },
+    systemPrompt: {
+      type: "string",
+      title: "System Prompt",
+      description: "Optional system instructions for the agent"
+    },
+    tools: {
+      type: "array",
+      format: "tasks",
+      title: "Tools",
+      description: "Tools available to the agent. Each entry is a task type name (string, resolved from TaskRegistry) or a full ToolDefinition object with optional config for configurable tasks.",
+      items: {
+        oneOf: [
+          { type: "string", format: "tasks", description: "Task type name" },
+          ToolDefinitionSchema
+        ]
+      }
+    },
+    stopTool: {
+      type: "string",
+      title: "Stop Tool",
+      description: "Name of a tool that signals agent completion. When called, the loop ends and the tool input becomes structuredOutput.",
+      "x-ui-group": "Configuration"
+    },
+    maxIterations: {
+      type: "number",
+      title: "Max Iterations",
+      description: "Maximum number of agent loop iterations (default: 10)",
+      minimum: 1,
+      "x-ui-group": "Configuration"
+    },
+    maxContextMessages: {
+      type: "number",
+      title: "Max Context Messages",
+      description: "Maximum messages in conversation history. Older messages are trimmed to prevent context overflow.",
+      minimum: 3,
+      "x-ui-group": "Configuration"
+    },
+    maxTokens: {
+      type: "number",
+      title: "Max Tokens",
+      description: "Maximum tokens per LLM call",
+      minimum: 1,
+      "x-ui-group": "Configuration"
+    },
+    temperature: {
+      type: "number",
+      title: "Temperature",
+      description: "Sampling temperature for LLM calls",
+      minimum: 0,
+      maximum: 2,
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["model", "prompt"],
+  additionalProperties: false
+};
+var AgentOutputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      title: "Text",
+      description: "The final text response from the agent",
+      "x-stream": "append"
+    },
+    messages: {
+      type: "array",
+      title: "Messages",
+      description: "Full conversation history including all tool calls and results",
+      items: {
+        type: "object",
+        additionalProperties: true
+      }
+    },
+    iterations: {
+      type: "number",
+      title: "Iterations",
+      description: "Number of LLM calls made during the agent loop"
+    },
+    toolCallCount: {
+      type: "number",
+      title: "Tool Call Count",
+      description: "Total number of tool calls executed"
+    },
+    structuredOutput: {
+      type: "object",
+      title: "Structured Output",
+      description: "Present when the agent terminated via a stop tool",
+      additionalProperties: true
+    }
+  },
+  required: ["text", "messages", "iterations", "toolCallCount"],
+  additionalProperties: false
+};
+
+class AgentTask extends Task {
+  static type = "AgentTask";
+  static category = "AI Agent";
+  static title = "Agent";
+  static description = "Multi-turn agentic loop that calls an LLM with tools, executes tool calls, and iterates until done";
+  static cacheable = false;
+  static inputSchema() {
+    return AgentInputSchema;
+  }
+  static outputSchema() {
+    return AgentOutputSchema;
+  }
+  async execute(input, context) {
+    let result;
+    for await (const event of this.agentLoop(input, context)) {
+      if (event.type === "finish") {
+        result = event.data;
+      }
+    }
+    if (!result) {
+      throw new Error("AgentTask: loop ended without producing output");
+    }
+    return result;
+  }
+  async* executeStream(input, context) {
+    yield* this.agentLoop(input, context);
+  }
+  async* agentLoop(input, context) {
+    const maxIterations = input.maxIterations ?? 10;
+    const hooks = this.config.hooks;
+    const maxConcurrency = this.config.maxConcurrency ?? 5;
+    const toolSources = this.resolveToolSources(input, context);
+    const toolDefs = this.resolveToolDefs(toolSources, input.stopTool);
+    const messages = [userMessage(input.prompt)];
+    let totalToolCalls = 0;
+    let finalText = "";
+    let structuredOutput;
+    for (let iteration = 0;iteration < maxIterations; iteration++) {
+      if (context.signal.aborted)
+        break;
+      if (hooks?.onIteration) {
+        const action = await hooks.onIteration(iteration, messages, { totalToolCalls });
+        if (action.action === "stop")
+          break;
+      }
+      await context.updateProgress(Math.round(iteration / maxIterations * 100), `Agent iteration ${iteration + 1}`);
+      const contextMessages = this.trimMessages(messages, input.maxContextMessages);
+      const llmTask = context.own(new ToolCallingTask({}, {}));
+      let iterationText = "";
+      let toolCalls = [];
+      for await (const event of llmTask.executeStream({
+        model: input.model,
+        prompt: input.prompt,
+        systemPrompt: input.systemPrompt,
+        tools: toolDefs,
+        messages: contextMessages,
+        maxTokens: input.maxTokens,
+        temperature: input.temperature
+      }, context)) {
+        if (event.type === "text-delta") {
+          yield { type: "text-delta", port: "text", textDelta: event.textDelta };
+          iterationText += event.textDelta;
+        } else if (event.type === "finish") {
+          const data = event.data;
+          iterationText = data?.text ?? iterationText;
+          if (data?.toolCalls) {
+            toolCalls = data.toolCalls ?? [];
+          }
+        }
+      }
+      finalText = iterationText;
+      messages.push(assistantMessage(iterationText, toolCalls));
+      if (input.stopTool) {
+        const stopCall = toolCalls.find((tc) => tc.name === input.stopTool);
+        if (stopCall) {
+          structuredOutput = stopCall.input;
+          break;
+        }
+      }
+      if (!hasToolCalls(toolCalls)) {
+        break;
+      }
+      const results = await executeToolCalls(toolCalls, toolSources, context, hooks, maxConcurrency);
+      totalToolCalls += results.length;
+      messages.push(toolMessage(results));
+    }
+    const output = {
+      text: finalText,
+      messages,
+      iterations: messages.filter((m) => m.role === "assistant").length,
+      toolCallCount: totalToolCalls,
+      ...structuredOutput !== undefined ? { structuredOutput } : {}
+    };
+    yield { type: "finish", data: output };
+  }
+  resolveToolSources(input, context) {
+    return buildToolSources(input.tools, context.registry);
+  }
+  resolveToolDefs(toolSources, stopTool) {
+    const defs = toolSourceDefinitions(toolSources);
+    if (stopTool && !defs.some((d) => d.name === stopTool)) {
+      defs.push({
+        name: stopTool,
+        description: "Call this tool when you have completed the task. Pass your final structured result as the input.",
+        inputSchema: { type: "object", additionalProperties: true }
+      });
+    }
+    return defs;
+  }
+  trimMessages(messages, maxContextMessages) {
+    if (!maxContextMessages || messages.length <= maxContextMessages) {
+      return messages;
+    }
+    getLogger3().debug(`AgentTask: Trimming context from ${messages.length} to ${maxContextMessages} messages`);
+    const tail = messages.slice(1);
+    let startIdx = tail.length - (maxContextMessages - 1);
+    if (startIdx < 0)
+      startIdx = 0;
+    if (startIdx > 0 && startIdx < tail.length && tail[startIdx].role === "tool") {
+      startIdx -= 1;
+    }
+    return [messages[0], ...tail.slice(startIdx)];
+  }
+}
+var agent = (input, config) => {
+  return new AgentTask({}, config).run(input);
+};
+Workflow2.prototype.agent = CreateWorkflow2(AgentTask);
+
+// src/task/BackgroundRemovalTask.ts
+import { CreateWorkflow as CreateWorkflow3, Workflow as Workflow3 } from "@workglow/task-graph";
+
 // src/task/base/AiVisionTask.ts
+import { convertImageDataToUseableForm } from "@workglow/util";
 class AiVisionTask extends AiTask {
   static type = "AiVisionTask";
   async getJobInput(input) {
@@ -733,7 +1470,7 @@ class AiVisionTask extends AiTask {
 }
 
 // src/task/BackgroundRemovalTask.ts
-var modelSchema = TypeModel("model:BackgroundRemovalTask");
+var modelSchema3 = TypeModel("model:BackgroundRemovalTask");
 var processedImageSchema = {
   type: "string",
   contentEncoding: "base64",
@@ -745,7 +1482,7 @@ var BackgroundRemovalInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema
+    model: modelSchema3
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -774,14 +1511,14 @@ class BackgroundRemovalTask extends AiVisionTask {
 var backgroundRemoval = (input, config) => {
   return new BackgroundRemovalTask({}, config).run(input);
 };
-Workflow.prototype.backgroundRemoval = CreateWorkflow(BackgroundRemovalTask);
+Workflow3.prototype.backgroundRemoval = CreateWorkflow3(BackgroundRemovalTask);
 
 // src/task/ChunkRetrievalTask.ts
 import { TypeKnowledgeBase } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow3,
-  Task,
-  Workflow as Workflow3
+  CreateWorkflow as CreateWorkflow5,
+  Task as Task2,
+  Workflow as Workflow5
 } from "@workglow/task-graph";
 import {
   isTypedArray,
@@ -789,11 +1526,11 @@ import {
 } from "@workglow/util";
 
 // src/task/TextEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow2, Workflow as Workflow2 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow4, Workflow as Workflow4 } from "@workglow/task-graph";
 import {
   TypedArraySchema
 } from "@workglow/util";
-var modelSchema2 = TypeModel("model:TextEmbeddingTask");
+var modelSchema4 = TypeModel("model:TextEmbeddingTask");
 var TextEmbeddingInputSchema = {
   type: "object",
   properties: {
@@ -802,7 +1539,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema2
+    model: modelSchema4
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -834,7 +1571,7 @@ class TextEmbeddingTask extends AiTask {
 var textEmbedding = async (input, config) => {
   return new TextEmbeddingTask({}, config).run(input);
 };
-Workflow2.prototype.textEmbedding = CreateWorkflow2(TextEmbeddingTask);
+Workflow4.prototype.textEmbedding = CreateWorkflow4(TextEmbeddingTask);
 
 // src/task/ChunkRetrievalTask.ts
 var inputSchema = {
@@ -959,7 +1696,7 @@ var outputSchema = {
   additionalProperties: false
 };
 
-class ChunkRetrievalTask extends Task {
+class ChunkRetrievalTask extends Task2 {
   static type = "ChunkRetrievalTask";
   static category = "RAG";
   static title = "Chunk Retrieval";
@@ -1026,14 +1763,14 @@ class ChunkRetrievalTask extends Task {
 var chunkRetrieval = (input, config) => {
   return new ChunkRetrievalTask({}, config).run(input);
 };
-Workflow3.prototype.chunkRetrieval = CreateWorkflow3(ChunkRetrievalTask);
+Workflow5.prototype.chunkRetrieval = CreateWorkflow5(ChunkRetrievalTask);
 
 // src/task/ChunkToVectorTask.ts
 import { ChunkRecordSchema } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow4,
-  Task as Task2,
-  Workflow as Workflow4
+  CreateWorkflow as CreateWorkflow6,
+  Task as Task3,
+  Workflow as Workflow6
 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema3
@@ -1109,7 +1846,7 @@ var outputSchema2 = {
   additionalProperties: false
 };
 
-class ChunkToVectorTask extends Task2 {
+class ChunkToVectorTask extends Task3 {
   static type = "ChunkToVectorTask";
   static category = "Document";
   static title = "Chunk to Vector";
@@ -1160,14 +1897,14 @@ class ChunkToVectorTask extends Task2 {
 var chunkToVector = (input, config) => {
   return new ChunkToVectorTask({}, config).run(input);
 };
-Workflow4.prototype.chunkToVector = CreateWorkflow4(ChunkToVectorTask);
+Workflow6.prototype.chunkToVector = CreateWorkflow6(ChunkToVectorTask);
 
 // src/task/ChunkVectorHybridSearchTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase2 } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow5,
-  Task as Task3,
-  Workflow as Workflow5
+  CreateWorkflow as CreateWorkflow7,
+  Task as Task4,
+  Workflow as Workflow7
 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema4
@@ -1281,7 +2018,7 @@ var outputSchema3 = {
   additionalProperties: false
 };
 
-class ChunkVectorHybridSearchTask extends Task3 {
+class ChunkVectorHybridSearchTask extends Task4 {
   static type = "ChunkVectorHybridSearchTask";
   static category = "RAG";
   static title = "Hybrid Search";
@@ -1334,14 +2071,14 @@ class ChunkVectorHybridSearchTask extends Task3 {
 var hybridSearch = async (input, config) => {
   return new ChunkVectorHybridSearchTask({}, config).run(input);
 };
-Workflow5.prototype.hybridSearch = CreateWorkflow5(ChunkVectorHybridSearchTask);
+Workflow7.prototype.hybridSearch = CreateWorkflow7(ChunkVectorHybridSearchTask);
 
 // src/task/ChunkVectorSearchTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase3 } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow6,
-  Task as Task4,
-  Workflow as Workflow6
+  CreateWorkflow as CreateWorkflow8,
+  Task as Task5,
+  Workflow as Workflow8
 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema5
@@ -1425,7 +2162,7 @@ var outputSchema4 = {
   additionalProperties: false
 };
 
-class ChunkVectorSearchTask extends Task4 {
+class ChunkVectorSearchTask extends Task5 {
   static type = "ChunkVectorSearchTask";
   static category = "Vector Store";
   static title = "Vector Store Search";
@@ -1457,14 +2194,14 @@ class ChunkVectorSearchTask extends Task4 {
 var vectorStoreSearch = (input, config) => {
   return new ChunkVectorSearchTask({}, config).run(input);
 };
-Workflow6.prototype.vectorStoreSearch = CreateWorkflow6(ChunkVectorSearchTask);
+Workflow8.prototype.vectorStoreSearch = CreateWorkflow8(ChunkVectorSearchTask);
 
 // src/task/ChunkVectorUpsertTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase4 } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow7,
-  Task as Task5,
-  Workflow as Workflow7
+  CreateWorkflow as CreateWorkflow9,
+  Task as Task6,
+  Workflow as Workflow9
 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema6
@@ -1519,7 +2256,7 @@ var outputSchema5 = {
   additionalProperties: false
 };
 
-class ChunkVectorUpsertTask extends Task5 {
+class ChunkVectorUpsertTask extends Task6 {
   static type = "ChunkVectorUpsertTask";
   static category = "Vector Store";
   static title = "Add to Vector Store";
@@ -1579,19 +2316,19 @@ class ChunkVectorUpsertTask extends Task5 {
 var chunkVectorUpsert = (input, config) => {
   return new ChunkVectorUpsertTask({}, config).run(input);
 };
-Workflow7.prototype.chunkVectorUpsert = CreateWorkflow7(ChunkVectorUpsertTask);
+Workflow9.prototype.chunkVectorUpsert = CreateWorkflow9(ChunkVectorUpsertTask);
 
 // src/task/ContextBuilderTask.ts
 import { estimateTokens } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow9,
-  Task as Task6,
-  Workflow as Workflow9
+  CreateWorkflow as CreateWorkflow11,
+  Task as Task7,
+  Workflow as Workflow11
 } from "@workglow/task-graph";
 
 // src/task/CountTokensTask.ts
-import { CreateWorkflow as CreateWorkflow8, Workflow as Workflow8 } from "@workglow/task-graph";
-var modelSchema3 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow10, Workflow as Workflow10 } from "@workglow/task-graph";
+var modelSchema5 = TypeModel("model");
 var CountTokensInputSchema = {
   type: "object",
   properties: {
@@ -1600,7 +2337,7 @@ var CountTokensInputSchema = {
       title: "Text",
       description: "The text to count tokens for"
     }),
-    model: modelSchema3
+    model: modelSchema5
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1634,7 +2371,7 @@ class CountTokensTask extends AiTask {
 var countTokens = async (input, config) => {
   return new CountTokensTask({}, config).run(input);
 };
-Workflow8.prototype.countTokens = CreateWorkflow8(CountTokensTask);
+Workflow10.prototype.countTokens = CreateWorkflow10(CountTokensTask);
 
 // src/task/ContextBuilderTask.ts
 var ContextFormat = {
@@ -1644,7 +2381,7 @@ var ContextFormat = {
   MARKDOWN: "markdown",
   JSON: "json"
 };
-var modelSchema4 = TypeModel("model", {
+var modelSchema6 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting (optional, falls back to estimation)"
 });
@@ -1708,7 +2445,7 @@ var inputSchema6 = {
 
 `
     },
-    model: modelSchema4
+    model: modelSchema6
   },
   required: ["chunks"],
   additionalProperties: false
@@ -1741,7 +2478,7 @@ var outputSchema6 = {
   additionalProperties: false
 };
 
-class ContextBuilderTask extends Task6 {
+class ContextBuilderTask extends Task7 {
   static type = "ContextBuilderTask";
   static category = "RAG";
   static title = "Context Builder";
@@ -1934,7 +2671,7 @@ class ContextBuilderTask extends Task6 {
 var contextBuilder = (input, config) => {
   return new ContextBuilderTask({}, config).run(input);
 };
-Workflow9.prototype.contextBuilder = CreateWorkflow9(ContextBuilderTask);
+Workflow11.prototype.contextBuilder = CreateWorkflow11(ContextBuilderTask);
 
 // src/task/DocumentEnricherTask.ts
 import {
@@ -1942,14 +2679,14 @@ import {
   hasChildren
 } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow12,
-  Task as Task7,
-  Workflow as Workflow12
+  CreateWorkflow as CreateWorkflow14,
+  Task as Task8,
+  Workflow as Workflow14
 } from "@workglow/task-graph";
 
 // src/task/TextNamedEntityRecognitionTask.ts
-import { CreateWorkflow as CreateWorkflow10, Workflow as Workflow10 } from "@workglow/task-graph";
-var modelSchema5 = TypeModel("model:TextNamedEntityRecognitionTask");
+import { CreateWorkflow as CreateWorkflow12, Workflow as Workflow12 } from "@workglow/task-graph";
+var modelSchema7 = TypeModel("model:TextNamedEntityRecognitionTask");
 var TextNamedEntityRecognitionInputSchema = {
   type: "object",
   properties: {
@@ -1968,7 +2705,7 @@ var TextNamedEntityRecognitionInputSchema = {
       "x-ui-group": "Configuration",
       "x-ui-group-open": false
     },
-    model: modelSchema5
+    model: modelSchema7
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2023,44 +2760,11 @@ class TextNamedEntityRecognitionTask extends AiTask {
 var textNamedEntityRecognition = (input, config) => {
   return new TextNamedEntityRecognitionTask({}, config).run(input);
 };
-Workflow10.prototype.textNamedEntityRecognition = CreateWorkflow10(TextNamedEntityRecognitionTask);
-
-// src/task/TextSummaryTask.ts
-import { CreateWorkflow as CreateWorkflow11, Workflow as Workflow11 } from "@workglow/task-graph";
-
-// src/task/base/StreamingAiTask.ts
-import {
-  getStreamingPorts
-} from "@workglow/task-graph";
-class StreamingAiTask extends AiTask {
-  static type = "StreamingAiTask";
-  async* executeStream(input, context) {
-    const jobInput = await this.getJobInput(input);
-    const queueName = await this.getDefaultQueueName(input);
-    const job = new AiJob({
-      queueName: queueName ?? this.type,
-      jobRunId: this.runConfig.runnerId,
-      input: jobInput
-    });
-    const ports = getStreamingPorts(this.outputSchema());
-    const defaultPort = ports.length > 0 ? ports[0].port : "text";
-    for await (const event of job.executeStream(jobInput, {
-      signal: context.signal,
-      updateProgress: context.updateProgress.bind(this)
-    })) {
-      if (event.type === "text-delta") {
-        yield { ...event, port: event.port ?? defaultPort };
-      } else if (event.type === "object-delta") {
-        yield { ...event, port: event.port ?? defaultPort };
-      } else {
-        yield event;
-      }
-    }
-  }
-}
+Workflow12.prototype.textNamedEntityRecognition = CreateWorkflow12(TextNamedEntityRecognitionTask);
 
 // src/task/TextSummaryTask.ts
-var modelSchema6 = TypeModel("model:TextSummaryTask");
+import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
+var modelSchema8 = TypeModel("model:TextSummaryTask");
 var TextSummaryInputSchema = {
   type: "object",
   properties: {
@@ -2069,7 +2773,7 @@ var TextSummaryInputSchema = {
       title: "Text",
       description: "The text to summarize"
     }),
-    model: modelSchema6
+    model: modelSchema8
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2103,7 +2807,7 @@ class TextSummaryTask extends StreamingAiTask {
 var textSummary = async (input, config) => {
   return new TextSummaryTask({}, config).run(input);
 };
-Workflow11.prototype.textSummary = CreateWorkflow11(TextSummaryTask);
+Workflow13.prototype.textSummary = CreateWorkflow13(TextSummaryTask);
 
 // src/task/DocumentEnricherTask.ts
 var inputSchema7 = {
@@ -2175,7 +2879,7 @@ var outputSchema7 = {
   additionalProperties: false
 };
 
-class DocumentEnricherTask extends Task7 {
+class DocumentEnricherTask extends Task8 {
   static type = "DocumentEnricherTask";
   static category = "Document";
   static title = "Document Enricher";
@@ -2334,15 +3038,15 @@ class DocumentEnricherTask extends Task7 {
 var documentEnricher = (input, config) => {
   return new DocumentEnricherTask({}, config).run(input);
 };
-Workflow12.prototype.documentEnricher = CreateWorkflow12(DocumentEnricherTask);
+Workflow14.prototype.documentEnricher = CreateWorkflow14(DocumentEnricherTask);
 
 // src/task/DownloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
-var modelSchema7 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
+var modelSchema9 = TypeModel("model");
 var DownloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema7
+    model: modelSchema9
   },
   required: ["model"],
   additionalProperties: false
@@ -2350,7 +3054,7 @@ var DownloadModelInputSchema = {
 var DownloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema7
+    model: modelSchema9
   },
   required: ["model"],
   additionalProperties: false
@@ -2393,11 +3097,11 @@ class DownloadModelTask extends AiTask {
 var downloadModel = (input, config) => {
   return new DownloadModelTask({}, config).run(input);
 };
-Workflow13.prototype.downloadModel = CreateWorkflow13(DownloadModelTask);
+Workflow15.prototype.downloadModel = CreateWorkflow15(DownloadModelTask);
 
 // src/task/FaceDetectorTask.ts
-import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
-var modelSchema8 = TypeModel("model:FaceDetectorTask");
+import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
+var modelSchema10 = TypeModel("model:FaceDetectorTask");
 var TypeBoundingBox2 = {
   type: "object",
   properties: {
@@ -2470,7 +3174,7 @@ var FaceDetectorInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema8,
+    model: modelSchema10,
     minDetectionConfidence: {
       type: "number",
       minimum: 0,
@@ -2524,11 +3228,11 @@ class FaceDetectorTask extends AiVisionTask {
 var faceDetector = (input, config) => {
   return new FaceDetectorTask({}, config).run(input);
 };
-Workflow14.prototype.faceDetector = CreateWorkflow14(FaceDetectorTask);
+Workflow16.prototype.faceDetector = CreateWorkflow16(FaceDetectorTask);
 
 // src/task/FaceLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
-var modelSchema9 = TypeModel("model:FaceLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
+var modelSchema11 = TypeModel("model:FaceLandmarkerTask");
 var TypeLandmark = {
   type: "object",
   properties: {
@@ -2600,7 +3304,7 @@ var FaceLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema9,
+    model: modelSchema11,
     numFaces: {
       type: "number",
       minimum: 1,
@@ -2686,11 +3390,11 @@ class FaceLandmarkerTask extends AiVisionTask {
 var faceLandmarker = (input, config) => {
   return new FaceLandmarkerTask({}, config).run(input);
 };
-Workflow15.prototype.faceLandmarker = CreateWorkflow15(FaceLandmarkerTask);
+Workflow17.prototype.faceLandmarker = CreateWorkflow17(FaceLandmarkerTask);
 
 // src/task/GestureRecognizerTask.ts
-import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
-var modelSchema10 = TypeModel("model:GestureRecognizerTask");
+import { CreateWorkflow as CreateWorkflow18, Workflow as Workflow18 } from "@workglow/task-graph";
+var modelSchema12 = TypeModel("model:GestureRecognizerTask");
 var TypeLandmark2 = {
   type: "object",
   properties: {
@@ -2782,7 +3486,7 @@ var GestureRecognizerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema10,
+    model: modelSchema12,
     numHands: {
       type: "number",
       minimum: 1,
@@ -2854,11 +3558,11 @@ class GestureRecognizerTask extends AiVisionTask {
 var gestureRecognizer = (input, config) => {
   return new GestureRecognizerTask({}, config).run(input);
 };
-Workflow16.prototype.gestureRecognizer = CreateWorkflow16(GestureRecognizerTask);
+Workflow18.prototype.gestureRecognizer = CreateWorkflow18(GestureRecognizerTask);
 
 // src/task/HandLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
-var modelSchema11 = TypeModel("model:HandLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow19, Workflow as Workflow19 } from "@workglow/task-graph";
+var modelSchema13 = TypeModel("model:HandLandmarkerTask");
 var TypeLandmark3 = {
   type: "object",
   properties: {
@@ -2927,7 +3631,7 @@ var HandLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema11,
+    model: modelSchema13,
     numHands: {
       type: "number",
       minimum: 1,
@@ -2999,7 +3703,7 @@ class HandLandmarkerTask extends AiVisionTask {
 var handLandmarker = (input, config) => {
   return new HandLandmarkerTask({}, config).run(input);
 };
-Workflow17.prototype.handLandmarker = CreateWorkflow17(HandLandmarkerTask);
+Workflow19.prototype.handLandmarker = CreateWorkflow19(HandLandmarkerTask);
 
 // src/task/HierarchicalChunkerTask.ts
 import {
@@ -3009,12 +3713,12 @@ import {
   hasChildren as hasChildren2
 } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow18,
-  Task as Task8,
-  Workflow as Workflow18
+  CreateWorkflow as CreateWorkflow20,
+  Task as Task9,
+  Workflow as Workflow20
 } from "@workglow/task-graph";
 import { uuid4 } from "@workglow/util";
-var modelSchema12 = TypeModel("model", {
+var modelSchema14 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting"
 });
@@ -3058,7 +3762,7 @@ var inputSchema8 = {
       description: "Strategy for chunking",
       default: "hierarchical"
     },
-    model: modelSchema12
+    model: modelSchema14
   },
   required: ["doc_id", "documentTree"],
   additionalProperties: false
@@ -3093,7 +3797,7 @@ var outputSchema8 = {
   additionalProperties: false
 };
 
-class HierarchicalChunkerTask extends Task8 {
+class HierarchicalChunkerTask extends Task9 {
   static type = "HierarchicalChunkerTask";
   static category = "Document";
   static title = "Hierarchical Chunker";
@@ -3237,7 +3941,7 @@ class HierarchicalChunkerTask extends Task8 {
 var hierarchicalChunker = (input, config) => {
   return new HierarchicalChunkerTask({}, config).run(input);
 };
-Workflow18.prototype.hierarchicalChunker = CreateWorkflow18(HierarchicalChunkerTask);
+Workflow20.prototype.hierarchicalChunker = CreateWorkflow20(HierarchicalChunkerTask);
 
 // src/task/HierarchyJoinTask.ts
 import {
@@ -3245,9 +3949,9 @@ import {
   TypeKnowledgeBase as TypeKnowledgeBase5
 } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow19,
-  Task as Task9,
-  Workflow as Workflow19
+  CreateWorkflow as CreateWorkflow21,
+  Task as Task10,
+  Workflow as Workflow21
 } from "@workglow/task-graph";
 var inputSchema9 = {
   type: "object",
@@ -3323,7 +4027,7 @@ var outputSchema9 = {
   additionalProperties: false
 };
 
-class HierarchyJoinTask extends Task9 {
+class HierarchyJoinTask extends Task10 {
   static type = "HierarchyJoinTask";
   static category = "RAG";
   static title = "Hierarchy Join";
@@ -3417,16 +4121,16 @@ class HierarchyJoinTask extends Task9 {
 var hierarchyJoin = (input, config) => {
   return new HierarchyJoinTask({}, config).run(input);
 };
-Workflow19.prototype.hierarchyJoin = CreateWorkflow19(HierarchyJoinTask);
+Workflow21.prototype.hierarchyJoin = CreateWorkflow21(HierarchyJoinTask);
 
 // src/task/ImageClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow20, Workflow as Workflow20 } from "@workglow/task-graph";
-var modelSchema13 = TypeModel("model:ImageClassificationTask");
+import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
+var modelSchema15 = TypeModel("model:ImageClassificationTask");
 var ImageClassificationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema13,
+    model: modelSchema15,
     categories: {
       type: "array",
       items: {
@@ -3480,14 +4184,14 @@ class ImageClassificationTask extends AiVisionTask {
 var imageClassification = (input, config) => {
   return new ImageClassificationTask({}, config).run(input);
 };
-Workflow20.prototype.imageClassification = CreateWorkflow20(ImageClassificationTask);
+Workflow22.prototype.imageClassification = CreateWorkflow22(ImageClassificationTask);
 
 // src/task/ImageEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow21, Workflow as Workflow21 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema7
 } from "@workglow/util";
-var modelSchema14 = TypeModel("model:ImageEmbeddingTask");
+var modelSchema16 = TypeModel("model:ImageEmbeddingTask");
 var embeddingSchema = TypedArraySchema7({
   title: "Embedding",
   description: "The image embedding vector"
@@ -3496,7 +4200,7 @@ var ImageEmbeddingInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema14
+    model: modelSchema16
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -3525,16 +4229,16 @@ class ImageEmbeddingTask extends AiVisionTask {
 var imageEmbedding = (input, config) => {
   return new ImageEmbeddingTask({}, config).run(input);
 };
-Workflow21.prototype.imageEmbedding = CreateWorkflow21(ImageEmbeddingTask);
+Workflow23.prototype.imageEmbedding = CreateWorkflow23(ImageEmbeddingTask);
 
 // src/task/ImageSegmentationTask.ts
-import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
-var modelSchema15 = TypeModel("model:ImageSegmentationTask");
+import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
+var modelSchema17 = TypeModel("model:ImageSegmentationTask");
 var ImageSegmentationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema15,
+    model: modelSchema17,
     threshold: {
       type: "number",
       title: "Threshold",
@@ -3613,11 +4317,11 @@ class ImageSegmentationTask extends AiVisionTask {
 var imageSegmentation = (input, config) => {
   return new ImageSegmentationTask({}, config).run(input);
 };
-Workflow22.prototype.imageSegmentation = CreateWorkflow22(ImageSegmentationTask);
+Workflow24.prototype.imageSegmentation = CreateWorkflow24(ImageSegmentationTask);
 
 // src/task/ImageToTextTask.ts
-import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
-var modelSchema16 = TypeModel("model:ImageToTextTask");
+import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
+var modelSchema18 = TypeModel("model:ImageToTextTask");
 var generatedTextSchema = {
   type: "string",
   title: "Text",
@@ -3627,7 +4331,7 @@ var ImageToTextInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema16,
+    model: modelSchema18,
     maxTokens: {
       type: "number",
       title: "Max Tokens",
@@ -3668,15 +4372,15 @@ class ImageToTextTask extends AiVisionTask {
 var imageToText = (input, config) => {
   return new ImageToTextTask({}, config).run(input);
 };
-Workflow23.prototype.imageToText = CreateWorkflow23(ImageToTextTask);
+Workflow25.prototype.imageToText = CreateWorkflow25(ImageToTextTask);
 
 // src/task/ModelInfoTask.ts
-import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
-var modelSchema17 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
+var modelSchema19 = TypeModel("model");
 var ModelInfoInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema17,
+    model: modelSchema19,
     detail: {
       type: "string",
       enum: ["cached_status", "files", "files_with_metadata"],
@@ -3689,7 +4393,7 @@ var ModelInfoInputSchema = {
 var ModelInfoOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema17,
+    model: modelSchema19,
     is_local: { type: "boolean" },
     is_remote: { type: "boolean" },
     supports_browser: { type: "boolean" },
@@ -3727,11 +4431,11 @@ class ModelInfoTask extends AiTask {
 var modelInfo = (input, config) => {
   return new ModelInfoTask({}, config).run(input);
 };
-Workflow24.prototype.modelInfo = CreateWorkflow24(ModelInfoTask);
+Workflow26.prototype.modelInfo = CreateWorkflow26(ModelInfoTask);
 
 // src/task/ObjectDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
-var modelSchema18 = TypeModel("model:ObjectDetectionTask");
+import { CreateWorkflow as CreateWorkflow27, Workflow as Workflow27 } from "@workglow/task-graph";
+var modelSchema20 = TypeModel("model:ObjectDetectionTask");
 var detectionSchema = {
   type: "object",
   properties: {
@@ -3756,7 +4460,7 @@ var ObjectDetectionInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema18,
+    model: modelSchema20,
     labels: {
       type: "array",
       items: {
@@ -3810,11 +4514,11 @@ class ObjectDetectionTask extends AiVisionTask {
 var objectDetection = (input, config) => {
   return new ObjectDetectionTask({}, config).run(input);
 };
-Workflow25.prototype.objectDetection = CreateWorkflow25(ObjectDetectionTask);
+Workflow27.prototype.objectDetection = CreateWorkflow27(ObjectDetectionTask);
 
 // src/task/PoseLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
-var modelSchema19 = TypeModel("model:PoseLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
+var modelSchema21 = TypeModel("model:PoseLandmarkerTask");
 var TypePoseLandmark = {
   type: "object",
   properties: {
@@ -3893,7 +4597,7 @@ var PoseLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema19,
+    model: modelSchema21,
     numPoses: {
       type: "number",
       minimum: 1,
@@ -3972,13 +4676,13 @@ class PoseLandmarkerTask extends AiVisionTask {
 var poseLandmarker = (input, config) => {
   return new PoseLandmarkerTask({}, config).run(input);
 };
-Workflow26.prototype.poseLandmarker = CreateWorkflow26(PoseLandmarkerTask);
+Workflow28.prototype.poseLandmarker = CreateWorkflow28(PoseLandmarkerTask);
 
 // src/task/QueryExpanderTask.ts
 import {
-  CreateWorkflow as CreateWorkflow27,
-  Task as Task10,
-  Workflow as Workflow27
+  CreateWorkflow as CreateWorkflow29,
+  Task as Task11,
+  Workflow as Workflow29
 } from "@workglow/task-graph";
 var QueryExpansionMethod = {
   MULTI_QUERY: "multi-query",
@@ -4047,7 +4751,7 @@ var outputSchema10 = {
   additionalProperties: false
 };
 
-class QueryExpanderTask extends Task10 {
+class QueryExpanderTask extends Task11 {
   static type = "QueryExpanderTask";
   static category = "RAG";
   static title = "Query Expander";
@@ -4189,18 +4893,18 @@ class QueryExpanderTask extends Task10 {
 var queryExpander = (input, config) => {
   return new QueryExpanderTask({}, config).run(input);
 };
-Workflow27.prototype.queryExpander = CreateWorkflow27(QueryExpanderTask);
+Workflow29.prototype.queryExpander = CreateWorkflow29(QueryExpanderTask);
 
 // src/task/RerankerTask.ts
 import {
-  CreateWorkflow as CreateWorkflow29,
-  Task as Task11,
-  Workflow as Workflow29
+  CreateWorkflow as CreateWorkflow31,
+  Task as Task12,
+  Workflow as Workflow31
 } from "@workglow/task-graph";
 
 // src/task/TextClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
-var modelSchema20 = TypeModel("model:TextClassificationTask");
+import { CreateWorkflow as CreateWorkflow30, Workflow as Workflow30 } from "@workglow/task-graph";
+var modelSchema22 = TypeModel("model:TextClassificationTask");
 var TextClassificationInputSchema = {
   type: "object",
   properties: {
@@ -4227,7 +4931,7 @@ var TextClassificationInputSchema = {
       description: "The maximum number of categories to return",
       "x-ui-group": "Configuration"
     },
-    model: modelSchema20
+    model: modelSchema22
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -4277,7 +4981,7 @@ class TextClassificationTask extends AiTask {
 var textClassification = (input, config) => {
   return new TextClassificationTask({}, config).run(input);
 };
-Workflow28.prototype.textClassification = CreateWorkflow28(TextClassificationTask);
+Workflow30.prototype.textClassification = CreateWorkflow30(TextClassificationTask);
 
 // src/task/RerankerTask.ts
 var inputSchema11 = {
@@ -4372,7 +5076,7 @@ var outputSchema11 = {
   additionalProperties: false
 };
 
-class RerankerTask extends Task11 {
+class RerankerTask extends Task12 {
   static type = "RerankerTask";
   static category = "RAG";
   static title = "Reranker";
@@ -4501,14 +5205,14 @@ class RerankerTask extends Task11 {
 var reranker = (input, config) => {
   return new RerankerTask({}, config).run(input);
 };
-Workflow29.prototype.reranker = CreateWorkflow29(RerankerTask);
+Workflow31.prototype.reranker = CreateWorkflow31(RerankerTask);
 
 // src/task/StructuralParserTask.ts
 import { StructuralParser } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow30,
-  Task as Task12,
-  Workflow as Workflow30
+  CreateWorkflow as CreateWorkflow32,
+  Task as Task13,
+  Workflow as Workflow32
 } from "@workglow/task-graph";
 import { uuid4 as uuid42 } from "@workglow/util";
 var inputSchema12 = {
@@ -4567,7 +5271,7 @@ var outputSchema12 = {
   additionalProperties: false
 };
 
-class StructuralParserTask extends Task12 {
+class StructuralParserTask extends Task13 {
   static type = "StructuralParserTask";
   static category = "Document";
   static title = "Structural Parser";
@@ -4610,15 +5314,15 @@ class StructuralParserTask extends Task12 {
 var structuralParser = (input, config) => {
   return new StructuralParserTask({}, config).run(input);
 };
-Workflow30.prototype.structuralParser = CreateWorkflow30(StructuralParserTask);
+Workflow32.prototype.structuralParser = CreateWorkflow32(StructuralParserTask);
 
 // src/task/StructuredGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow31, Workflow as Workflow31 } from "@workglow/task-graph";
-var modelSchema21 = TypeModel("model:StructuredGenerationTask");
+import { CreateWorkflow as CreateWorkflow33, Workflow as Workflow33 } from "@workglow/task-graph";
+var modelSchema23 = TypeModel("model:StructuredGenerationTask");
 var StructuredGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema21,
+    model: modelSchema23,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -4681,13 +5385,13 @@ class StructuredGenerationTask extends StreamingAiTask {
 var structuredGeneration = (input, config) => {
   return new StructuredGenerationTask({}, config).run(input);
 };
-Workflow31.prototype.structuredGeneration = CreateWorkflow31(StructuredGenerationTask);
+Workflow33.prototype.structuredGeneration = CreateWorkflow33(StructuredGenerationTask);
 
 // src/task/TextChunkerTask.ts
 import {
-  CreateWorkflow as CreateWorkflow32,
-  Task as Task13,
-  Workflow as Workflow32
+  CreateWorkflow as CreateWorkflow34,
+  Task as Task14,
+  Workflow as Workflow34
 } from "@workglow/task-graph";
 var ChunkingStrategy = {
   FIXED: "fixed",
@@ -4757,7 +5461,7 @@ var outputSchema13 = {
   additionalProperties: false
 };
 
-class TextChunkerTask extends Task13 {
+class TextChunkerTask extends Task14 {
   static type = "TextChunkerTask";
   static category = "Document";
   static title = "Text Chunker";
@@ -4937,11 +5641,11 @@ class TextChunkerTask extends Task13 {
 var textChunker = (input, config) => {
   return new TextChunkerTask({}, config).run(input);
 };
-Workflow32.prototype.textChunker = CreateWorkflow32(TextChunkerTask);
+Workflow34.prototype.textChunker = CreateWorkflow34(TextChunkerTask);
 
 // src/task/TextFillMaskTask.ts
-import { CreateWorkflow as CreateWorkflow33, Workflow as Workflow33 } from "@workglow/task-graph";
-var modelSchema22 = TypeModel("model:TextFillMaskTask");
+import { CreateWorkflow as CreateWorkflow35, Workflow as Workflow35 } from "@workglow/task-graph";
+var modelSchema24 = TypeModel("model:TextFillMaskTask");
 var TextFillMaskInputSchema = {
   type: "object",
   properties: {
@@ -4950,7 +5654,7 @@ var TextFillMaskInputSchema = {
       title: "Text",
       description: "The text with a mask token to fill"
     }),
-    model: modelSchema22
+    model: modelSchema24
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5005,21 +5709,21 @@ class TextFillMaskTask extends AiTask {
 var textFillMask = (input, config) => {
   return new TextFillMaskTask({}, config).run(input);
 };
-Workflow33.prototype.textFillMask = CreateWorkflow33(TextFillMaskTask);
+Workflow35.prototype.textFillMask = CreateWorkflow35(TextFillMaskTask);
 
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
 var generatedTextSchema2 = TypeSingleOrArray({
   type: "string",
   title: "Text",
   description: "The generated text",
   "x-stream": "append"
 });
-var modelSchema23 = TypeModel("model:TextGenerationTask");
+var modelSchema25 = TypeModel("model:TextGenerationTask");
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema23,
+    model: modelSchema25,
     prompt: TypeSingleOrArray({
       type: "string",
       title: "Prompt",
@@ -5093,11 +5797,11 @@ class TextGenerationTask extends StreamingAiTask {
 var textGeneration = (input, config) => {
   return new TextGenerationTask({}, config).run(input);
 };
-Workflow34.prototype.textGeneration = CreateWorkflow34(TextGenerationTask);
+Workflow36.prototype.textGeneration = CreateWorkflow36(TextGenerationTask);
 
 // src/task/TextLanguageDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow35, Workflow as Workflow35 } from "@workglow/task-graph";
-var modelSchema24 = TypeModel("model:TextLanguageDetectionTask");
+import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
+var modelSchema26 = TypeModel("model:TextLanguageDetectionTask");
 var TextLanguageDetectionInputSchema = {
   type: "object",
   properties: {
@@ -5114,7 +5818,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema24
+    model: modelSchema26
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5164,10 +5868,10 @@ class TextLanguageDetectionTask extends AiTask {
 var textLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask({}, config).run(input);
 };
-Workflow35.prototype.textLanguageDetection = CreateWorkflow35(TextLanguageDetectionTask);
+Workflow37.prototype.textLanguageDetection = CreateWorkflow37(TextLanguageDetectionTask);
 
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
 var contextSchema = TypeSingleOrArray({
   type: "string",
   title: "Context",
@@ -5184,13 +5888,13 @@ var textSchema = TypeSingleOrArray({
   description: "The generated text",
   "x-stream": "append"
 });
-var modelSchema25 = TypeModel("model:TextQuestionAnswerTask");
+var modelSchema27 = TypeModel("model:TextQuestionAnswerTask");
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: contextSchema,
     question: questionSchema,
-    model: modelSchema25
+    model: modelSchema27
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -5219,11 +5923,11 @@ class TextQuestionAnswerTask extends StreamingAiTask {
 var textQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask({}, config).run(input);
 };
-Workflow36.prototype.textQuestionAnswer = CreateWorkflow36(TextQuestionAnswerTask);
+Workflow38.prototype.textQuestionAnswer = CreateWorkflow38(TextQuestionAnswerTask);
 
 // src/task/TextRewriterTask.ts
-import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
-var modelSchema26 = TypeModel("model:TextRewriterTask");
+import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
+var modelSchema28 = TypeModel("model:TextRewriterTask");
 var TextRewriterInputSchema = {
   type: "object",
   properties: {
@@ -5237,7 +5941,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     },
-    model: modelSchema26
+    model: modelSchema28
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -5271,11 +5975,11 @@ class TextRewriterTask extends StreamingAiTask {
 var textRewriter = (input, config) => {
   return new TextRewriterTask({}, config).run(input);
 };
-Workflow37.prototype.textRewriter = CreateWorkflow37(TextRewriterTask);
+Workflow39.prototype.textRewriter = CreateWorkflow39(TextRewriterTask);
 
 // src/task/TextTranslationTask.ts
-import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
-var modelSchema27 = TypeModel("model:TextTranslationTask");
+import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
+var modelSchema29 = TypeModel("model:TextTranslationTask");
 var translationTextSchema = TypeSingleOrArray({
   type: "string",
   title: "Text",
@@ -5302,7 +6006,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     }),
-    model: modelSchema27
+    model: modelSchema29
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -5337,181 +6041,13 @@ class TextTranslationTask extends StreamingAiTask {
 var textTranslation = (input, config) => {
   return new TextTranslationTask({}, config).run(input);
 };
-Workflow38.prototype.textTranslation = CreateWorkflow38(TextTranslationTask);
-
-// src/task/ToolCallingTask.ts
-import {
-  CreateWorkflow as CreateWorkflow39,
-  getTaskConstructors,
-  Workflow as Workflow39
-} from "@workglow/task-graph";
-import { getLogger } from "@workglow/util";
-function buildToolDescription(tool) {
-  let desc = tool.description;
-  if (tool.outputSchema && typeof tool.outputSchema === "object") {
-    desc += `
-
-Returns: ${JSON.stringify(tool.outputSchema)}`;
-  }
-  return desc;
-}
-function isAllowedToolName(name, allowedTools) {
-  return allowedTools.some((t) => t.name === name);
-}
-function filterValidToolCalls(toolCalls, allowedTools) {
-  const filtered = {};
-  for (const [key, value] of Object.entries(toolCalls)) {
-    const tc = value;
-    if (tc.name && isAllowedToolName(tc.name, allowedTools)) {
-      filtered[key] = value;
-    } else {
-      getLogger().warn(`Filtered out tool call with unknown name "${tc.name ?? "(missing)"}"`, {
-        callId: key,
-        toolName: tc.name
-      });
-    }
-  }
-  return filtered;
-}
-function taskTypesToTools(taskNames, registry) {
-  const constructors = getTaskConstructors(registry);
-  return taskNames.map((name) => {
-    const ctor = constructors.get(name);
-    if (!ctor) {
-      throw new Error(`taskTypesToTools: Unknown task type "${name}" — not found in task constructors registry (ServiceRegistry: ${registry ? "custom" : "default"})`);
-    }
-    return {
-      name: ctor.type,
-      description: ctor.description ?? "",
-      inputSchema: ctor.inputSchema(),
-      outputSchema: ctor.outputSchema()
-    };
-  });
-}
-var ToolDefinitionSchema = {
-  type: "object",
-  properties: {
-    name: {
-      type: "string",
-      title: "Name",
-      description: "The tool name"
-    },
-    description: {
-      type: "string",
-      title: "Description",
-      description: "A description of what the tool does"
-    },
-    inputSchema: {
-      type: "object",
-      title: "Input Schema",
-      description: "JSON Schema describing the tool's input parameters",
-      additionalProperties: true
-    },
-    outputSchema: {
-      type: "object",
-      title: "Output Schema",
-      description: "JSON Schema describing what the tool returns",
-      additionalProperties: true
-    }
-  },
-  required: ["name", "description", "inputSchema"],
-  additionalProperties: false
-};
-var modelSchema28 = TypeModel("model:ToolCallingTask");
-var ToolCallingInputSchema = {
-  type: "object",
-  properties: {
-    model: modelSchema28,
-    prompt: TypeSingleOrArray({
-      type: "string",
-      title: "Prompt",
-      description: "The prompt to send to the model"
-    }),
-    systemPrompt: {
-      type: "string",
-      title: "System Prompt",
-      description: "Optional system instructions for the model"
-    },
-    tools: {
-      type: "array",
-      format: "tasks",
-      title: "Tools",
-      description: "Tool definitions available for the model to call",
-      items: {
-        oneOf: [
-          { type: "string", format: "tasks", description: "Task type name" },
-          ToolDefinitionSchema
-        ]
-      }
-    },
-    toolChoice: {
-      type: "string",
-      title: "Tool Choice",
-      description: 'Controls tool selection: "auto" (model decides), "none" (no tools), "required" (must call a tool), or a specific tool name',
-      "x-ui-group": "Configuration"
-    },
-    maxTokens: {
-      type: "number",
-      title: "Max Tokens",
-      description: "The maximum number of tokens to generate",
-      minimum: 1,
-      "x-ui-group": "Configuration"
-    },
-    temperature: {
-      type: "number",
-      title: "Temperature",
-      description: "The temperature to use for sampling",
-      minimum: 0,
-      maximum: 2,
-      "x-ui-group": "Configuration"
-    }
-  },
-  required: ["model", "prompt", "tools"],
-  additionalProperties: false
-};
-var ToolCallingOutputSchema = {
-  type: "object",
-  properties: {
-    text: TypeSingleOrArray({
-      type: "string",
-      title: "Text",
-      description: "Any text content generated by the model",
-      "x-stream": "append"
-    }),
-    toolCalls: TypeSingleOrArray({
-      type: "object",
-      title: "Tool Calls",
-      description: "Tool invocations requested by the model, keyed by call id",
-      additionalProperties: true,
-      "x-stream": "object"
-    })
-  },
-  required: ["text", "toolCalls"],
-  additionalProperties: false
-};
-
-class ToolCallingTask extends StreamingAiTask {
-  static type = "ToolCallingTask";
-  static category = "AI Text Model";
-  static title = "Tool Calling";
-  static description = "Sends a prompt with tool definitions to a language model and returns text along with any tool calls the model requests";
-  static inputSchema() {
-    return ToolCallingInputSchema;
-  }
-  static outputSchema() {
-    return ToolCallingOutputSchema;
-  }
-}
-var toolCalling = (input, config) => {
-  return new ToolCallingTask({}, config).run(input);
-};
-Workflow39.prototype.toolCalling = CreateWorkflow39(ToolCallingTask);
+Workflow40.prototype.textTranslation = CreateWorkflow40(TextTranslationTask);
 
 // src/task/TopicSegmenterTask.ts
 import {
-  CreateWorkflow as CreateWorkflow40,
-  Task as Task14,
-  Workflow as Workflow40
+  CreateWorkflow as CreateWorkflow41,
+  Task as Task15,
+  Workflow as Workflow41
 } from "@workglow/task-graph";
 var SegmentationMethod = {
   HEURISTIC: "heuristic",
@@ -5587,7 +6123,7 @@ var outputSchema14 = {
   additionalProperties: false
 };
 
-class TopicSegmenterTask extends Task14 {
+class TopicSegmenterTask extends Task15 {
   static type = "TopicSegmenterTask";
   static category = "Document";
   static title = "Topic Segmenter";
@@ -5792,15 +6328,15 @@ class TopicSegmenterTask extends Task14 {
 var topicSegmenter = (input, config) => {
   return new TopicSegmenterTask({}, config).run(input);
 };
-Workflow40.prototype.topicSegmenter = CreateWorkflow40(TopicSegmenterTask);
+Workflow41.prototype.topicSegmenter = CreateWorkflow41(TopicSegmenterTask);
 
 // src/task/UnloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
-var modelSchema29 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow42, Workflow as Workflow42 } from "@workglow/task-graph";
+var modelSchema30 = TypeModel("model");
 var UnloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema29
+    model: modelSchema30
   },
   required: ["model"],
   additionalProperties: false
@@ -5808,7 +6344,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema29
+    model: modelSchema30
   },
   required: ["model"],
   additionalProperties: false
@@ -5830,10 +6366,10 @@ class UnloadModelTask extends AiTask {
 var unloadModel = (input, config) => {
   return new UnloadModelTask({}, config).run(input);
 };
-Workflow41.prototype.unloadModel = CreateWorkflow41(UnloadModelTask);
+Workflow42.prototype.unloadModel = CreateWorkflow42(UnloadModelTask);
 
 // src/task/VectorQuantizeTask.ts
-import { CreateWorkflow as CreateWorkflow42, Task as Task15, Workflow as Workflow42 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow43, Task as Task16, Workflow as Workflow43 } from "@workglow/task-graph";
 import {
   normalizeNumberArray,
   TensorType,
@@ -5913,7 +6449,7 @@ var outputSchema15 = {
   additionalProperties: false
 };
 
-class VectorQuantizeTask extends Task15 {
+class VectorQuantizeTask extends Task16 {
   static type = "VectorQuantizeTask";
   static category = "Vector";
   static title = "Quantize";
@@ -6013,10 +6549,10 @@ class VectorQuantizeTask extends Task15 {
 var vectorQuantize = (input, config) => {
   return new VectorQuantizeTask({}, config).run(input);
 };
-Workflow42.prototype.vectorQuantize = CreateWorkflow42(VectorQuantizeTask);
+Workflow43.prototype.vectorQuantize = CreateWorkflow43(VectorQuantizeTask);
 
 // src/task/VectorSimilarityTask.ts
-import { CreateWorkflow as CreateWorkflow43, GraphAsTask, Workflow as Workflow43 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow44, GraphAsTask, Workflow as Workflow44 } from "@workglow/task-graph";
 import {
   cosineSimilarity,
   hammingSimilarity,
@@ -6090,7 +6626,7 @@ var SimilarityOutputSchema = {
 
 class VectorSimilarityTask extends GraphAsTask {
   static type = "VectorSimilarityTask";
-  static category = "Analysis";
+  static category = "Vector";
   static title = "Vector Similarity";
   static description = "Compares vectors using similarity functions and returns top-K ranked results";
   static cacheable = true;
@@ -6122,11 +6658,208 @@ class VectorSimilarityTask extends GraphAsTask {
 var similarity = (input, config) => {
   return new VectorSimilarityTask({}, config).run(input);
 };
-Workflow43.prototype.similarity = CreateWorkflow43(VectorSimilarityTask);
+Workflow44.prototype.similarity = CreateWorkflow44(VectorSimilarityTask);
+// src/task/MessageConversion.ts
+function getInputMessages(input) {
+  const messages = input.messages;
+  if (!messages || messages.length === 0)
+    return;
+  return messages;
+}
+function toOpenAIMessages(input) {
+  const messages = [];
+  if (input.systemPrompt) {
+    messages.push({ role: "system", content: input.systemPrompt });
+  }
+  const inputMessages = getInputMessages(input);
+  if (!inputMessages) {
+    if (!Array.isArray(input.prompt)) {
+      messages.push({ role: "user", content: input.prompt });
+    } else if (input.prompt.every((item) => typeof item === "string")) {
+      messages.push({ role: "user", content: input.prompt.join(`
+`) });
+    } else {
+      const parts = [];
+      for (const item of input.prompt) {
+        if (typeof item === "string") {
+          parts.push({ type: "text", text: item });
+        } else {
+          const b = item;
+          if (b.type === "text") {
+            parts.push({ type: "text", text: b.text });
+          } else if (b.type === "image") {
+            parts.push({
+              type: "image_url",
+              image_url: { url: `data:${b.mimeType};base64,${b.data}` }
+            });
+          } else if (b.type === "audio") {
+            const format = b.mimeType.replace(/^audio\//, "");
+            parts.push({
+              type: "input_audio",
+              input_audio: { data: b.data, format }
+            });
+          }
+        }
+      }
+      messages.push({ role: "user", content: parts });
+    }
+    return messages;
+  }
+  for (const msg of inputMessages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        messages.push({ role: "user", content: msg.content });
+      } else if (Array.isArray(msg.content) && msg.content.length > 0 && typeof msg.content[0]?.type === "string") {
+        const parts = [];
+        for (const block of msg.content) {
+          const b = block;
+          if (b.type === "text") {
+            parts.push({ type: "text", text: b.text });
+          } else if (b.type === "image") {
+            parts.push({
+              type: "image_url",
+              image_url: { url: `data:${b.mimeType};base64,${b.data}` }
+            });
+          } else if (b.type === "audio") {
+            const format = b.mimeType.replace(/^audio\//, "");
+            parts.push({
+              type: "input_audio",
+              input_audio: { data: b.data, format }
+            });
+          }
+        }
+        messages.push({ role: "user", content: parts });
+      } else {
+        try {
+          messages.push({ role: "user", content: JSON.stringify(msg.content) });
+        } catch {
+          messages.push({ role: "user", content: String(msg.content) });
+        }
+      }
+    } else if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        messages.push({ role: "assistant", content: msg.content.length > 0 ? msg.content : null });
+      } else if (Array.isArray(msg.content)) {
+        const textParts = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => ({
+          id: b.id,
+          type: "function",
+          function: {
+            name: b.name,
+            arguments: JSON.stringify(b.input)
+          }
+        }));
+        const entry = {
+          role: "assistant",
+          content: textParts.length > 0 ? textParts : null
+        };
+        if (toolCalls.length > 0) {
+          entry.tool_calls = toolCalls;
+        }
+        messages.push(entry);
+      }
+    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        const b = block;
+        let content;
+        if (typeof b.content === "string") {
+          content = b.content;
+        } else if (Array.isArray(b.content)) {
+          const parts = [];
+          for (const inner of b.content) {
+            if (inner.type === "text") {
+              parts.push({ type: "text", text: inner.text });
+            } else if (inner.type === "image") {
+              parts.push({
+                type: "image_url",
+                image_url: { url: `data:${inner.mimeType};base64,${inner.data}` }
+              });
+            }
+          }
+          content = parts;
+        } else {
+          content = "";
+        }
+        messages.push({
+          role: "tool",
+          content,
+          tool_call_id: b.tool_use_id
+        });
+      }
+    }
+  }
+  return messages;
+}
+function toTextFlatMessages(input) {
+  const messages = [];
+  if (input.systemPrompt) {
+    messages.push({ role: "system", content: input.systemPrompt });
+  }
+  const inputMessages = getInputMessages(input);
+  if (!inputMessages) {
+    let promptContent;
+    if (!Array.isArray(input.prompt)) {
+      promptContent = input.prompt;
+    } else {
+      promptContent = input.prompt.map((item) => {
+        if (typeof item === "string")
+          return item;
+        const b = item;
+        return b.type === "text" ? b.text : "";
+      }).filter((s) => s !== "").join(`
+`);
+    }
+    messages.push({ role: "user", content: promptContent });
+    return messages;
+  }
+  for (const msg of inputMessages) {
+    if (msg.role === "user") {
+      let content = "";
+      if (typeof msg.content === "string") {
+        content = msg.content;
+      } else if (Array.isArray(msg.content) && msg.content.length > 0 && typeof msg.content[0]?.type === "string") {
+        content = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      } else if (msg.content != null) {
+        try {
+          content = JSON.stringify(msg.content);
+        } catch {
+          content = String(msg.content);
+        }
+      }
+      messages.push({ role: "user", content });
+    } else if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        if (msg.content) {
+          messages.push({ role: "assistant", content: msg.content });
+        }
+      } else if (Array.isArray(msg.content)) {
+        const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        if (text) {
+          messages.push({ role: "assistant", content: text });
+        }
+      }
+    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        const b = block;
+        let content;
+        if (typeof b.content === "string") {
+          content = b.content;
+        } else if (Array.isArray(b.content)) {
+          content = b.content.filter((inner) => inner.type === "text").map((inner) => inner.text).join("");
+        } else {
+          content = "";
+        }
+        messages.push({ role: "tool", content });
+      }
+    }
+  }
+  return messages;
+}
 
 // src/task/index.ts
 var registerAiTasks = () => {
   const tasks = [
+    AgentTask,
     BackgroundRemovalTask,
     ChunkToVectorTask,
     CountTokensTask,
@@ -6177,9 +6910,14 @@ var registerAiTasks = () => {
 export {
   vectorStoreSearch,
   vectorQuantize,
+  userMessage,
   unloadModel,
   topicSegmenter,
+  toolSourceDefinitions,
+  toolMessage,
   toolCalling,
+  toTextFlatMessages,
+  toOpenAIMessages,
   textTranslation,
   textSummary,
   textRewriter,
@@ -6208,16 +6946,22 @@ export {
   imageSegmentation,
   imageEmbedding,
   imageClassification,
+  imageBlockFromDataUri,
+  imageBlock,
   hybridSearch,
   hierarchyJoin,
   hierarchicalChunker,
+  hasToolCalls,
   handLandmarker,
   getGlobalModelRepository,
   getAiProviderRegistry,
   gestureRecognizer,
+  findToolSource,
   filterValidToolCalls,
   faceLandmarker,
   faceDetector,
+  executeToolCalls,
+  executeToolCall,
   downloadModel,
   documentEnricher,
   countTokens,
@@ -6225,8 +6969,13 @@ export {
   chunkVectorUpsert,
   chunkToVector,
   chunkRetrieval,
+  buildToolSources,
   buildToolDescription,
   backgroundRemoval,
+  audioBlockFromDataUri,
+  audioBlock,
+  assistantMessage,
+  agent,
   VectorSimilarityTask,
   VectorQuantizeTask,
   UnloadModelTask,
@@ -6343,7 +7092,10 @@ export {
   AiTask,
   AiProviderRegistry,
   AiProvider,
-  AiJob
+  AiJob,
+  AgentTask,
+  AgentOutputSchema,
+  AgentInputSchema
 };
 
-//# debugId=FA713AFFB061070264756E2164756E21
+//# debugId=7632C16D204CE7AB64756E2164756E21