@workglow/ai 0.2.7 → 0.2.9

package/dist/node.js

@@ -55,6 +55,19 @@ class AiProviderRegistry {
     }
     return this.defaultStrategy;
   }
+  createSession(providerName, model) {
+    const provider = this.providers.get(providerName);
+    if (!provider) {
+      throw new Error(`No provider found for "${providerName}". Register the provider before creating sessions.`);
+    }
+    return provider.createSession(model);
+  }
+  async disposeSession(providerName, sessionId) {
+    const provider = this.providers.get(providerName);
+    if (provider) {
+      await provider.disposeSession(sessionId);
+    }
+  }
   getProviderIdsForTask(taskType) {
     const taskMap = this.runFnRegistry.get(taskType);
     if (!taskMap)
@@ -68,9 +81,9 @@ class AiProviderRegistry {
     this.runFnRegistry.get(taskType).set(modelProvider, runFn);
   }
   registerAsWorkerRunFn(modelProvider, taskType) {
-    const workerFn = async (input, model, update_progress, signal, outputSchema) => {
+    const workerFn = async (input, model, update_progress, signal, outputSchema, sessionId) => {
       const workerManager = globalServiceRegistry.get(WORKER_MANAGER);
-      const result = await workerManager.callWorkerFunction(modelProvider, taskType, [input, model, outputSchema], {
+      const result = await workerManager.callWorkerFunction(modelProvider, taskType, [input, model, outputSchema, sessionId], {
         signal,
         onProgress: update_progress
       });
@@ -85,9 +98,9 @@ class AiProviderRegistry {
     this.streamFnRegistry.get(taskType).set(modelProvider, streamFn);
   }
   registerAsWorkerStreamFn(modelProvider, taskType) {
-    const streamFn = async function* (input, model, signal, outputSchema) {
+    const streamFn = async function* (input, model, signal, outputSchema, sessionId) {
       const workerManager = globalServiceRegistry.get(WORKER_MANAGER);
-      yield* workerManager.callWorkerStreamFunction(modelProvider, taskType, [input, model, outputSchema], { signal });
+      yield* workerManager.callWorkerStreamFunction(modelProvider, taskType, [input, model, outputSchema, sessionId], { signal });
     };
     this.registerStreamFn(modelProvider, taskType, streamFn);
   }
@@ -215,7 +228,7 @@ class AiJob extends Job {
         const timeoutMs = resolveAiJobTimeoutMs(input.aiProvider, input.timeoutMs);
         const timeoutSignal = AbortSignal.timeout(timeoutMs);
         const combinedSignal = AbortSignal.any([context.signal, timeoutSignal]);
-        return await fn(input.taskInput, model, context.updateProgress, combinedSignal, input.outputSchema);
+        return await fn(input.taskInput, model, context.updateProgress, combinedSignal, input.outputSchema, input.sessionId);
       };
       const runFnPromise = runFn();
       return await Promise.race([runFnPromise, abortPromise]);
@@ -243,7 +256,7 @@ class AiJob extends Job {
     const timeoutSignal = AbortSignal.timeout(timeoutMs);
     const combinedSignal = AbortSignal.any([context.signal, timeoutSignal]);
     try {
-      for await (const event of streamFn(input.taskInput, model, combinedSignal, input.outputSchema)) {
+      for await (const event of streamFn(input.taskInput, model, combinedSignal, input.outputSchema, input.sessionId)) {
         if (event.type === "finish") {
           lastFinishData = event.data;
         }
@@ -308,6 +321,7 @@ class QueuedExecutionStrategy {
   concurrency;
   autoCreate;
   initPromise = null;
+  limiter;
   constructor(queueName, concurrency = 1, autoCreate = true) {
     this.queueName = queueName;
     this.concurrency = concurrency;
@@ -345,8 +359,42 @@ class QueuedExecutionStrategy {
   }
   abort() {}
   async* executeStream(jobInput, context, runnerId) {
-    const result = await this.execute(jobInput, context, runnerId);
-    yield { type: "finish", data: result };
+    if (context.signal.aborted) {
+      throw context.signal.reason ?? new AbortSignalJobError2("The operation was aborted");
+    }
+    await this.ensureQueue();
+    const limiter = this.limiter;
+    if (!limiter) {
+      throw new TaskConfigurationError(`QueuedExecutionStrategy: limiter was not initialized for queue "${this.queueName}"`);
+    }
+    await this.acquireLimiterSlot(limiter, context.signal);
+    try {
+      const job = new AiJob({
+        queueName: jobInput.aiProvider,
+        jobRunId: runnerId,
+        input: jobInput
+      });
+      yield* job.executeStream(jobInput, {
+        signal: context.signal,
+        updateProgress: context.updateProgress
+      });
+    } finally {
+      await limiter.recordJobCompletion();
+    }
+  }
+  async acquireLimiterSlot(limiter, signal) {
+    const poll = async () => {
+      while (!await limiter.canProceed()) {
+        if (signal.aborted) {
+          throw signal.reason ?? new AbortSignalJobError2("The operation was aborted");
+        }
+        const next = await limiter.getNextAvailableTime();
+        const delay = Math.max(0, next.getTime() - Date.now());
+        await new Promise((resolve) => setTimeout(resolve, Math.min(delay, 50)));
+      }
+    };
+    await poll();
+    await limiter.recordJobStart();
   }
   ensureQueue() {
     if (!this.initPromise) {
@@ -364,6 +412,7 @@ class QueuedExecutionStrategy {
       if (!existing.server.isRunning()) {
         await existing.server.start();
       }
+      this.limiter = existing.server.limiter;
       return existing;
     }
     if (!this.autoCreate) {
@@ -371,10 +420,11 @@ class QueuedExecutionStrategy {
     }
     const storage = new InMemoryQueueStorage(this.queueName);
     await storage.setupDatabase();
+    this.limiter = new ConcurrencyLimiter(this.concurrency);
     const server = new JobQueueServer(AiJob, {
       storage,
       queueName: this.queueName,
-      limiter: new ConcurrencyLimiter(this.concurrency)
+      limiter: this.limiter
     });
     const client = new JobQueueClient({
       storage,
@@ -398,6 +448,7 @@ class QueuedExecutionStrategy {
           if (!raced.server.isRunning()) {
             await raced.server.start();
           }
+          this.limiter = raced.server.limiter;
           return raced;
         }
       }
@@ -759,6 +810,10 @@ class AiProvider {
   }
   async onInitialize(_options) {}
   async dispose() {}
+  createSession(_model) {
+    return crypto.randomUUID();
+  }
+  async disposeSession(_sessionId) {}
   async afterRegister(_options) {}
 }
 
@@ -782,74 +837,8 @@ class QueuedAiProvider extends AiProvider {
 // src/task/index.ts
 import { TaskRegistry } from "@workglow/task-graph";
 
-// src/task/AgentTask.ts
-import { CreateWorkflow as CreateWorkflow2, Task as Task2, Workflow as Workflow2 } from "@workglow/task-graph";
-import { getLogger as getLogger4 } from "@workglow/util";
-
-// src/task/AgentTypes.ts
-import { parseDataUri } from "@workglow/util/media";
-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, TaskAbortedError } from "@workglow/task-graph";
-import { getLogger as getLogger3 } from "@workglow/util";
-
-// src/task/ToolCallingTask.ts
-import { CreateWorkflow, getTaskConstructors, Workflow } from "@workglow/task-graph";
+// src/task/AiChatTask.ts
+import { TaskConfigSchema as TaskConfigSchema2 } from "@workglow/task-graph";
 
 // src/task/base/AiTaskSchemas.ts
 var TypeLanguage = (annotations = {}) => ({
@@ -1099,6 +1088,10 @@ class AiTask extends Task {
         jobInput.outputSchema = taskOutputSchema;
       }
     }
+    const sessionId = input.sessionId;
+    if (sessionId) {
+      jobInput.sessionId = sessionId;
+    }
     return jobInput;
   }
   async createJob(input, queueName) {
@@ -1225,672 +1218,356 @@ class StreamingAiTask extends AiTask {
   }
 }
 
-// src/task/ToolCallingTask.ts
-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 = {
+// src/task/ChatMessage.ts
+var ContentBlockTextSchema = {
   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
+    type: { type: "string", enum: ["text"] },
+    text: { type: "string" }
+  },
+  required: ["type", "text"],
+  additionalProperties: false
+};
+var ContentBlockImageSchema = {
+  type: "object",
+  properties: {
+    type: { type: "string", enum: ["image"] },
+    mimeType: { type: "string" },
+    data: { type: "string" }
+  },
+  required: ["type", "mimeType", "data"],
+  additionalProperties: false
+};
+var ContentBlockToolUseSchema = {
+  type: "object",
+  properties: {
+    type: { type: "string", enum: ["tool_use"] },
+    id: { type: "string" },
+    name: { type: "string" },
+    input: { type: "object", additionalProperties: true }
+  },
+  required: ["type", "id", "name", "input"],
+  additionalProperties: false
+};
+var ContentBlockToolResultSchema = {
+  type: "object",
+  properties: {
+    type: { type: "string", enum: ["tool_result"] },
+    tool_use_id: { type: "string" },
+    content: {
+      type: "array",
+      items: { $ref: "#/definitions/ContentBlock" }
     },
-    config: {
-      type: "object",
-      title: "Config",
-      description: "Concrete configuration values for the backing task (not sent to the LLM)",
-      additionalProperties: true
+    is_error: { type: "boolean" }
+  },
+  required: ["type", "tool_use_id", "content"],
+  additionalProperties: false
+};
+var ContentBlockSchema = {
+  oneOf: [
+    ContentBlockTextSchema,
+    ContentBlockImageSchema,
+    ContentBlockToolUseSchema,
+    ContentBlockToolResultSchema
+  ],
+  definitions: {
+    ContentBlock: {
+      oneOf: [
+        ContentBlockTextSchema,
+        ContentBlockImageSchema,
+        ContentBlockToolUseSchema,
+        ContentBlockToolResultSchema
+      ]
     }
   },
-  required: ["name", "description", "inputSchema"],
-  additionalProperties: true
+  title: "ContentBlock",
+  description: "A single content block within a chat message"
 };
-var ToolCallSchema = {
+var ChatMessageSchema = {
   type: "object",
   properties: {
-    id: {
-      type: "string",
-      title: "ID",
-      description: "Unique identifier for this tool call"
-    },
-    name: {
+    role: { type: "string", enum: ["user", "assistant", "tool", "system"] },
+    content: {
+      type: "array",
+      items: ContentBlockSchema
+    }
+  },
+  required: ["role", "content"],
+  additionalProperties: false,
+  title: "ChatMessage",
+  description: "A single chat message with role and structured content blocks"
+};
+function isContentBlock(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  switch (v.type) {
+    case "text":
+      return typeof v.text === "string";
+    case "image":
+      return typeof v.mimeType === "string" && typeof v.data === "string";
+    case "tool_use":
+      return typeof v.id === "string" && typeof v.name === "string" && v.input !== null && typeof v.input === "object";
+    case "tool_result":
+      return typeof v.tool_use_id === "string" && Array.isArray(v.content) && v.content.every(isContentBlock);
+    default:
+      return false;
+  }
+}
+function isChatMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  const validRole = v.role === "user" || v.role === "assistant" || v.role === "tool" || v.role === "system";
+  return validRole && Array.isArray(v.content) && v.content.every(isContentBlock);
+}
+function textMessage(role, text) {
+  return { role, content: [{ type: "text", text }] };
+}
+
+// src/task/AiChatTask.ts
+import { resolveHumanConnector } from "@workglow/util";
+var modelSchema = TypeModel("model:AiChatTask");
+var chatConnectorContentSchema = {
+  type: "object",
+  properties: {
+    content: {
       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
+      title: "Message",
+      description: "Your reply (leave blank to end the conversation)"
     }
   },
-  required: ["id", "name", "input"],
   additionalProperties: false
 };
-var modelSchema = TypeModel("model:ToolCallingTask");
-var ToolCallingInputSchema = {
+var AiChatInputSchema = {
   type: "object",
   properties: {
     model: modelSchema,
     prompt: {
       oneOf: [
-        { type: "string", title: "Prompt", description: "The prompt to send to the model" },
+        { type: "string", title: "Prompt", description: "The initial user message" },
         {
           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
-              }
-            ]
-          }
+          description: "The initial user message as structured content blocks",
+          items: ContentBlockSchema
         }
       ],
       title: "Prompt",
-      description: "The prompt to send to the model"
-    },
-    systemPrompt: {
-      type: "string",
-      title: "System Prompt",
-      description: "Optional system instructions for the model"
+      description: "The first user message to start the conversation"
     },
     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
-      }
+      description: "Conversation history (managed internally by the chat loop; not a user-facing input)",
+      items: ChatMessageSchema,
+      "x-ui-hidden": 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: {
+    systemPrompt: {
       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"
+      title: "System Prompt",
+      description: "Optional system instructions for the model"
     },
     maxTokens: {
       type: "number",
       title: "Max Tokens",
-      description: "The maximum number of tokens to generate",
+      description: "Per-turn token limit",
       minimum: 1,
       "x-ui-group": "Configuration"
     },
     temperature: {
       type: "number",
       title: "Temperature",
-      description: "The temperature to use for sampling",
+      description: "Sampling temperature",
       minimum: 0,
       maximum: 2,
       "x-ui-group": "Configuration"
+    },
+    maxIterations: {
+      type: "number",
+      title: "Max Iterations",
+      description: "Safety cap on conversation turns",
+      minimum: 1,
+      default: 100,
+      "x-ui-group": "Configuration"
     }
   },
-  required: ["model", "prompt", "tools"],
+  required: ["model", "prompt"],
   additionalProperties: false
 };
-var ToolCallingOutputSchema = {
+var AiChatOutputSchema = {
   type: "object",
   properties: {
     text: {
       type: "string",
       title: "Text",
-      description: "Any text content generated by the model",
+      description: "Last assistant response",
       "x-stream": "append"
     },
-    toolCalls: {
+    messages: {
       type: "array",
-      items: ToolCallSchema,
-      title: "Tool Calls",
-      description: "Tool calls requested by the model",
+      title: "Messages",
+      description: "Full conversation history",
+      items: ChatMessageSchema,
       "x-stream": "object"
+    },
+    iterations: {
+      type: "number",
+      title: "Iterations",
+      description: "Number of completed turns"
     }
   },
-  required: ["text", "toolCalls"],
+  required: ["text", "messages", "iterations"],
   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";
+class AiChatTask extends StreamingAiTask {
+  static type = "AiChatTask";
+  static category = "AI Chat";
+  static title = "AI Chat";
+  static description = "Multi-turn chat with a language model, using a human connector to collect user input between turns.";
+  static cacheable = false;
+  static configSchema() {
+    return {
+      type: "object",
+      properties: {
+        ...TaskConfigSchema2["properties"]
+      },
+      additionalProperties: false
+    };
+  }
   static inputSchema() {
-    return ToolCallingInputSchema;
+    return AiChatInputSchema;
   }
   static outputSchema() {
-    return ToolCallingOutputSchema;
+    return AiChatOutputSchema;
   }
-}
-var toolCalling = (input, config) => {
-  return new ToolCallingTask(config).run(input);
-};
-Workflow.prototype.toolCalling = CreateWorkflow(ToolCallingTask);
-
-// src/task/AgentUtils.ts
-function resolveToolConfig(toolName, config, taskConfigSchema) {
-  if (config && !taskConfigSchema) {
-    getLogger3().warn(`AgentTask: Tool "${toolName}" provided config but task has no configSchema — config ignored`);
-    return {};
+  _sessionId;
+  async getJobInput(input) {
+    const model = input.model;
+    if (!this._sessionId) {
+      this._sessionId = getAiProviderRegistry().createSession(model.provider, model);
+    }
+    return {
+      taskType: "AiChatTask",
+      aiProvider: model.provider,
+      taskInput: input,
+      sessionId: this._sessionId
+    };
   }
-  return config;
-}
-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.type === "function" || !tool.type && tool.execute) {
-      if (!tool.execute) {
-        getLogger3().warn(`AgentTask: Tool "${tool.name}" has type "function" but no execute function — will throw on invocation`);
-      }
-      const { execute, configSchema: _cs, config: _c, type: _t, ...definition } = tool;
-      sources.push({
-        type: "function",
-        definition,
-        run: execute ?? (async () => {
-          throw new Error(`No execute function for tool "${tool.name}"`);
-        })
+  async* executeStream(input, context) {
+    this._sessionId = undefined;
+    const model = input.model;
+    if (!model || typeof model !== "object") {
+      throw new Error("AiChatTask: model was not resolved to ModelConfig");
+    }
+    const connector = resolveHumanConnector(context);
+    const history = [];
+    if (input.systemPrompt) {
+      history.push({ role: "system", content: [{ type: "text", text: input.systemPrompt }] });
+    }
+    const firstUserBlocks = typeof input.prompt === "string" ? [{ type: "text", text: input.prompt }] : input.prompt;
+    history.push({ role: "user", content: firstUserBlocks });
+    const workingInput = { ...input, messages: history };
+    await this.getJobInput(workingInput);
+    const strategy = getAiProviderRegistry().getStrategy(model);
+    const maxIterations = input.maxIterations ?? 100;
+    if (context.resourceScope && this._sessionId) {
+      const sessionId = this._sessionId;
+      context.resourceScope.register(`ai:session:${sessionId}`, async () => {
+        await getAiProviderRegistry().disposeSession(model.provider, sessionId);
       });
-    } else if (tool.type === "task") {
-      const ctor = constructors.get(tool.name);
-      if (!ctor) {
-        getLogger3().warn(`AgentTask: Tool "${tool.name}" has type "task" but is not in TaskRegistry — will throw on invocation`);
-        const { execute: _e, configSchema: _cs, config: _c, type: _t, ...definition } = tool;
-        sources.push({
-          type: "function",
-          definition,
-          run: async () => {
-            throw new Error(`Task "${tool.name}" not found in TaskRegistry`);
-          }
-        });
-      } else {
-        const safeConfig = resolveToolConfig(tool.name, tool.config, ctor.configSchema?.());
-        const { execute: _e, configSchema: _cs, config: _c, type: _t, ...definition } = tool;
-        sources.push({
-          type: "registry",
-          definition,
-          taskType: tool.name,
-          config: safeConfig
-        });
-      }
-    } else {
-      const ctor = constructors.get(tool.name);
-      if (ctor) {
-        const safeConfig = resolveToolConfig(tool.name, tool.config, ctor.configSchema?.());
-        const { execute: _e, configSchema: _cs, config: _c, type: _t, ...definition } = tool;
-        sources.push({
-          type: "registry",
-          definition,
-          taskType: tool.name,
-          config: safeConfig
-        });
-      } else {
-        const { execute: _e, configSchema: _cs, config: _c, type: _t, ...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) {
-    getLogger3().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
+    yield {
+      type: "object-delta",
+      port: "messages",
+      objectDelta: [...history]
     };
-  }
-  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`);
+    let iterations = 0;
+    let lastAssistantText = "";
+    for (let turn = 0;turn < maxIterations; turn++) {
+      const perTurnInput = { ...input, messages: [...history] };
+      const turnJobInput = await this.getJobInput(perTurnInput);
+      let assistantText = "";
+      for await (const event of strategy.executeStream(turnJobInput, context, this.runConfig.runnerId)) {
+        if (event.type === "text-delta") {
+          assistantText += event.textDelta;
+          yield {
+            ...event,
+            port: event.port ?? "text"
+          };
+        } else if (event.type === "finish") {} else {
+          yield event;
         }
-        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);
+      iterations++;
+      lastAssistantText = assistantText;
+      const assistantMsg = {
+        role: "assistant",
+        content: [{ type: "text", text: assistantText }]
+      };
+      history.push(assistantMsg);
+      yield {
+        type: "object-delta",
+        port: "messages",
+        objectDelta: [assistantMsg]
+      };
+      const request = {
+        requestId: crypto.randomUUID(),
+        targetHumanId: "default",
+        kind: "elicit",
+        message: "",
+        contentSchema: chatConnectorContentSchema,
+        contentData: undefined,
+        expectsResponse: true,
+        mode: "multi-turn",
+        metadata: { iteration: turn, taskId: this.id }
+      };
+      const response = await connector.send(request, context.signal);
+      if (response.action === "cancel" || response.action === "decline")
         break;
+      const raw = response.content?.content;
+      let userContent;
+      if (typeof raw === "string") {
+        const text = raw.trim();
+        userContent = text.length > 0 ? [{ type: "text", text: raw }] : [];
+      } else if (Array.isArray(raw)) {
+        userContent = raw;
+      } else {
+        userContent = [];
       }
+      if (userContent.length === 0)
+        break;
+      const userMsg = { role: "user", content: userContent };
+      history.push(userMsg);
+      yield {
+        type: "object-delta",
+        port: "messages",
+        objectDelta: [userMsg]
+      };
     }
-    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
-        };
+    yield {
+      type: "finish",
+      data: {
+        text: lastAssistantText,
+        messages: [...history],
+        iterations
       }
-    }
-    getLogger3().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 TaskAbortedError("The operation was aborted");
-      }
-      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;
-}
-function countAssistantToolUses(messages) {
-  let n = 0;
-  for (const m of messages) {
-    if (m.role !== "assistant")
-      continue;
-    for (const block of m.content) {
-      if (block.type === "tool_use")
-        n += 1;
-    }
-  }
-  return n;
-}
-
-// src/task/AgentTask.ts
-var MAX_CONTEXT_MESSAGES = 1000;
-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 the assistant requested (tool_use blocks in assistant messages)"
-    },
-    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 Task2 {
-  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)) {
+    for await (const event of this.executeStream(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 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: countAssistantToolUses(messages)
-        });
-        if (action.action === "stop")
-          break;
-      }
-      await context.updateProgress(Math.round(iteration / maxIterations * 100), `Agent iteration ${iteration + 1}`);
-      const contextMessages = this.trimMessages(messages, input.maxContextMessages ?? MAX_CONTEXT_MESSAGES);
-      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 === "object-delta" && event.port === "toolCalls") {
-          const items = event.objectDelta;
-          for (const item of items) {
-            const idx = toolCalls.findIndex((tc) => tc.id === item.id);
-            if (idx >= 0)
-              toolCalls[idx] = item;
-            else
-              toolCalls.push(item);
-          }
-        } else if (event.type === "finish") {
-          const data = event.data;
-          iterationText = data?.text ?? iterationText;
-          if (data?.toolCalls && data.toolCalls.length > 0) {
-            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);
-      messages.push(toolMessage(results));
-    }
-    const output = {
-      text: finalText,
-      messages,
-      iterations: messages.filter((m) => m.role === "assistant").length,
-      toolCallCount: countAssistantToolUses(messages),
-      ...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;
-    }
-    getLogger4().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;
-    while (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";
+import { CreateWorkflow, Workflow } from "@workglow/task-graph";
 
 // src/task/base/AiVisionTask.ts
 import { convertImageDataToUseableForm } from "@workglow/util/media";
@@ -1914,7 +1591,7 @@ class AiVisionTask extends AiTask {
 }
 
 // src/task/BackgroundRemovalTask.ts
-var modelSchema3 = TypeModel("model:BackgroundRemovalTask");
+var modelSchema2 = TypeModel("model:BackgroundRemovalTask");
 var processedImageSchema = {
   type: "string",
   contentEncoding: "base64",
@@ -1926,7 +1603,7 @@ var BackgroundRemovalInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema3
+    model: modelSchema2
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -1955,22 +1632,22 @@ class BackgroundRemovalTask extends AiVisionTask {
 var backgroundRemoval = (input, config) => {
   return new BackgroundRemovalTask(config).run(input);
 };
-Workflow3.prototype.backgroundRemoval = CreateWorkflow3(BackgroundRemovalTask);
+Workflow.prototype.backgroundRemoval = CreateWorkflow(BackgroundRemovalTask);
 
 // src/task/ChunkRetrievalTask.ts
 import { TypeKnowledgeBase } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow5, Task as Task3, Workflow as Workflow5 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow3, Task as Task2, Workflow as Workflow3 } from "@workglow/task-graph";
 import {
   isTypedArray,
   TypedArraySchema as TypedArraySchema2
 } from "@workglow/util/schema";
 
 // src/task/TextEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow4, Workflow as Workflow4 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow2, Workflow as Workflow2 } from "@workglow/task-graph";
 import {
   TypedArraySchema
 } from "@workglow/util/schema";
-var modelSchema4 = TypeModel("model:TextEmbeddingTask");
+var modelSchema3 = TypeModel("model:TextEmbeddingTask");
 var TextEmbeddingInputSchema = {
   type: "object",
   properties: {
@@ -1979,7 +1656,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema4
+    model: modelSchema3
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2011,7 +1688,7 @@ class TextEmbeddingTask extends AiTask {
 var textEmbedding = async (input, config) => {
   return new TextEmbeddingTask(config).run(input);
 };
-Workflow4.prototype.textEmbedding = CreateWorkflow4(TextEmbeddingTask);
+Workflow2.prototype.textEmbedding = CreateWorkflow2(TextEmbeddingTask);
 
 // src/task/ChunkRetrievalTask.ts
 var inputSchema = {
@@ -2136,7 +1813,7 @@ var outputSchema = {
   additionalProperties: false
 };
 
-class ChunkRetrievalTask extends Task3 {
+class ChunkRetrievalTask extends Task2 {
   static type = "ChunkRetrievalTask";
   static category = "RAG";
   static title = "Chunk Retrieval";
@@ -2203,11 +1880,11 @@ class ChunkRetrievalTask extends Task3 {
 var chunkRetrieval = (input, config) => {
   return new ChunkRetrievalTask(config).run(input);
 };
-Workflow5.prototype.chunkRetrieval = CreateWorkflow5(ChunkRetrievalTask);
+Workflow3.prototype.chunkRetrieval = CreateWorkflow3(ChunkRetrievalTask);
 
 // src/task/ChunkToVectorTask.ts
 import { ChunkRecordSchema } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow6, Task as Task4, Workflow as Workflow6 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow4, Task as Task3, Workflow as Workflow4 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema3
 } from "@workglow/util/schema";
@@ -2282,7 +1959,7 @@ var outputSchema2 = {
   additionalProperties: false
 };
 
-class ChunkToVectorTask extends Task4 {
+class ChunkToVectorTask extends Task3 {
   static type = "ChunkToVectorTask";
   static category = "Document";
   static title = "Chunk to Vector";
@@ -2333,11 +2010,11 @@ class ChunkToVectorTask extends Task4 {
 var chunkToVector = (input, config) => {
   return new ChunkToVectorTask(config).run(input);
 };
-Workflow6.prototype.chunkToVector = CreateWorkflow6(ChunkToVectorTask);
+Workflow4.prototype.chunkToVector = CreateWorkflow4(ChunkToVectorTask);
 
 // src/task/ChunkVectorHybridSearchTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase2 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow7, Task as Task5, Workflow as Workflow7 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow5, Task as Task4, Workflow as Workflow5 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema4
 } from "@workglow/util/schema";
@@ -2450,7 +2127,7 @@ var outputSchema3 = {
   additionalProperties: false
 };
 
-class ChunkVectorHybridSearchTask extends Task5 {
+class ChunkVectorHybridSearchTask extends Task4 {
   static type = "ChunkVectorHybridSearchTask";
   static category = "RAG";
   static title = "Hybrid Search";
@@ -2503,11 +2180,11 @@ class ChunkVectorHybridSearchTask extends Task5 {
 var hybridSearch = async (input, config) => {
   return new ChunkVectorHybridSearchTask(config).run(input);
 };
-Workflow7.prototype.hybridSearch = CreateWorkflow7(ChunkVectorHybridSearchTask);
+Workflow5.prototype.hybridSearch = CreateWorkflow5(ChunkVectorHybridSearchTask);
 
 // src/task/ChunkVectorSearchTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase3 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow8, Task as Task6, Workflow as Workflow8 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow6, Task as Task5, Workflow as Workflow6 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util/schema";
@@ -2590,7 +2267,7 @@ var outputSchema4 = {
   additionalProperties: false
 };
 
-class ChunkVectorSearchTask extends Task6 {
+class ChunkVectorSearchTask extends Task5 {
   static type = "ChunkVectorSearchTask";
   static category = "Vector Store";
   static title = "Vector Store Search";
@@ -2622,11 +2299,11 @@ class ChunkVectorSearchTask extends Task6 {
 var vectorStoreSearch = (input, config) => {
   return new ChunkVectorSearchTask(config).run(input);
 };
-Workflow8.prototype.vectorStoreSearch = CreateWorkflow8(ChunkVectorSearchTask);
+Workflow6.prototype.vectorStoreSearch = CreateWorkflow6(ChunkVectorSearchTask);
 
 // src/task/ChunkVectorUpsertTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase4 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow9, Task as Task7, Workflow as Workflow9 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow7, Task as Task6, Workflow as Workflow7 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema6
 } from "@workglow/util/schema";
@@ -2680,7 +2357,7 @@ var outputSchema5 = {
   additionalProperties: false
 };
 
-class ChunkVectorUpsertTask extends Task7 {
+class ChunkVectorUpsertTask extends Task6 {
   static type = "ChunkVectorUpsertTask";
   static category = "Vector Store";
   static title = "Add to Vector Store";
@@ -2740,15 +2417,15 @@ class ChunkVectorUpsertTask extends Task7 {
 var chunkVectorUpsert = (input, config) => {
   return new ChunkVectorUpsertTask(config).run(input);
 };
-Workflow9.prototype.chunkVectorUpsert = CreateWorkflow9(ChunkVectorUpsertTask);
+Workflow7.prototype.chunkVectorUpsert = CreateWorkflow7(ChunkVectorUpsertTask);
 
 // src/task/ContextBuilderTask.ts
 import { estimateTokens } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow11, Task as Task8, Workflow as Workflow11 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow9, Task as Task7, Workflow as Workflow9 } from "@workglow/task-graph";
 
 // src/task/CountTokensTask.ts
-import { CreateWorkflow as CreateWorkflow10, Workflow as Workflow10 } from "@workglow/task-graph";
-var modelSchema5 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow8, Workflow as Workflow8 } from "@workglow/task-graph";
+var modelSchema4 = TypeModel("model");
 var CountTokensInputSchema = {
   type: "object",
   properties: {
@@ -2757,7 +2434,7 @@ var CountTokensInputSchema = {
       title: "Text",
       description: "The text to count tokens for"
     },
-    model: modelSchema5
+    model: modelSchema4
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2791,7 +2468,7 @@ class CountTokensTask extends AiTask {
 var countTokens = async (input, config) => {
   return new CountTokensTask(config).run(input);
 };
-Workflow10.prototype.countTokens = CreateWorkflow10(CountTokensTask);
+Workflow8.prototype.countTokens = CreateWorkflow8(CountTokensTask);
 
 // src/task/ContextBuilderTask.ts
 var ContextFormat = {
@@ -2801,7 +2478,7 @@ var ContextFormat = {
   MARKDOWN: "markdown",
   JSON: "json"
 };
-var modelSchema6 = TypeModel("model", {
+var modelSchema5 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting (optional, falls back to estimation)"
 });
@@ -2865,7 +2542,7 @@ var inputSchema6 = {
 
 `
     },
-    model: modelSchema6
+    model: modelSchema5
   },
   required: ["chunks"],
   additionalProperties: false
@@ -2898,7 +2575,7 @@ var outputSchema6 = {
   additionalProperties: false
 };
 
-class ContextBuilderTask extends Task8 {
+class ContextBuilderTask extends Task7 {
   static type = "ContextBuilderTask";
   static category = "RAG";
   static title = "Context Builder";
@@ -3091,15 +2768,15 @@ class ContextBuilderTask extends Task8 {
 var contextBuilder = (input, config) => {
   return new ContextBuilderTask(config).run(input);
 };
-Workflow11.prototype.contextBuilder = CreateWorkflow11(ContextBuilderTask);
+Workflow9.prototype.contextBuilder = CreateWorkflow9(ContextBuilderTask);
 
 // src/task/DocumentEnricherTask.ts
 import { getChildren, hasChildren } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow14, Task as Task9, Workflow as Workflow14 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow12, Task as Task8, Workflow as Workflow12 } from "@workglow/task-graph";
 
 // src/task/TextNamedEntityRecognitionTask.ts
-import { CreateWorkflow as CreateWorkflow12, Workflow as Workflow12 } from "@workglow/task-graph";
-var modelSchema7 = TypeModel("model:TextNamedEntityRecognitionTask");
+import { CreateWorkflow as CreateWorkflow10, Workflow as Workflow10 } from "@workglow/task-graph";
+var modelSchema6 = TypeModel("model:TextNamedEntityRecognitionTask");
 var TextNamedEntityRecognitionInputSchema = {
   type: "object",
   properties: {
@@ -3118,7 +2795,7 @@ var TextNamedEntityRecognitionInputSchema = {
       "x-ui-group": "Configuration",
       "x-ui-group-open": false
     },
-    model: modelSchema7
+    model: modelSchema6
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -3173,11 +2850,11 @@ class TextNamedEntityRecognitionTask extends AiTask {
 var textNamedEntityRecognition = (input, config) => {
   return new TextNamedEntityRecognitionTask(config).run(input);
 };
-Workflow12.prototype.textNamedEntityRecognition = CreateWorkflow12(TextNamedEntityRecognitionTask);
+Workflow10.prototype.textNamedEntityRecognition = CreateWorkflow10(TextNamedEntityRecognitionTask);
 
 // src/task/TextSummaryTask.ts
-import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
-var modelSchema8 = TypeModel("model:TextSummaryTask");
+import { CreateWorkflow as CreateWorkflow11, Workflow as Workflow11 } from "@workglow/task-graph";
+var modelSchema7 = TypeModel("model:TextSummaryTask");
 var TextSummaryInputSchema = {
   type: "object",
   properties: {
@@ -3186,7 +2863,7 @@ var TextSummaryInputSchema = {
       title: "Text",
       description: "The text to summarize"
     },
-    model: modelSchema8
+    model: modelSchema7
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -3220,7 +2897,7 @@ class TextSummaryTask extends StreamingAiTask {
 var textSummary = async (input, config) => {
   return new TextSummaryTask(config).run(input);
 };
-Workflow13.prototype.textSummary = CreateWorkflow13(TextSummaryTask);
+Workflow11.prototype.textSummary = CreateWorkflow11(TextSummaryTask);
 
 // src/task/DocumentEnricherTask.ts
 var inputSchema7 = {
@@ -3294,7 +2971,7 @@ var outputSchema7 = {
   additionalProperties: false
 };
 
-class DocumentEnricherTask extends Task9 {
+class DocumentEnricherTask extends Task8 {
   static type = "DocumentEnricherTask";
   static category = "Document";
   static title = "Document Enricher";
@@ -3453,12 +3130,12 @@ class DocumentEnricherTask extends Task9 {
 var documentEnricher = (input, config) => {
   return new DocumentEnricherTask(config).run(input);
 };
-Workflow14.prototype.documentEnricher = CreateWorkflow14(DocumentEnricherTask);
+Workflow12.prototype.documentEnricher = CreateWorkflow12(DocumentEnricherTask);
 
 // src/task/DocumentUpsertTask.ts
 import { Document, TypeKnowledgeBase as TypeKnowledgeBase5 } from "@workglow/knowledge-base";
 import { DocumentMetadataSchema } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow15, Task as Task10, Workflow as Workflow15 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow13, Task as Task9, Workflow as Workflow13 } from "@workglow/task-graph";
 var inputSchema8 = {
   type: "object",
   properties: {
@@ -3503,7 +3180,7 @@ var outputSchema8 = {
   additionalProperties: false
 };
 
-class DocumentUpsertTask extends Task10 {
+class DocumentUpsertTask extends Task9 {
   static type = "DocumentUpsertTask";
   static category = "Vector Store";
   static title = "Add Document";
@@ -3536,15 +3213,15 @@ class DocumentUpsertTask extends Task10 {
 var documentUpsert = (input, config) => {
   return new DocumentUpsertTask(config).run(input);
 };
-Workflow15.prototype.documentUpsert = CreateWorkflow15(DocumentUpsertTask);
+Workflow13.prototype.documentUpsert = CreateWorkflow13(DocumentUpsertTask);
 
 // src/task/DownloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
-var modelSchema9 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
+var modelSchema8 = TypeModel("model");
 var DownloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema9
+    model: modelSchema8
   },
   required: ["model"],
   additionalProperties: false
@@ -3552,7 +3229,7 @@ var DownloadModelInputSchema = {
 var DownloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema9
+    model: modelSchema8
   },
   required: ["model"],
   additionalProperties: false
@@ -3606,11 +3283,11 @@ class DownloadModelTask extends AiTask {
 var downloadModel = (input, config) => {
   return new DownloadModelTask(config).run(input);
 };
-Workflow16.prototype.downloadModel = CreateWorkflow16(DownloadModelTask);
+Workflow14.prototype.downloadModel = CreateWorkflow14(DownloadModelTask);
 
 // src/task/FaceDetectorTask.ts
-import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
-var modelSchema10 = TypeModel("model:FaceDetectorTask");
+import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
+var modelSchema9 = TypeModel("model:FaceDetectorTask");
 var TypeBoundingBox2 = {
   type: "object",
   properties: {
@@ -3683,7 +3360,7 @@ var FaceDetectorInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema10,
+    model: modelSchema9,
     minDetectionConfidence: {
       type: "number",
       minimum: 0,
@@ -3737,11 +3414,11 @@ class FaceDetectorTask extends AiVisionTask {
 var faceDetector = (input, config) => {
   return new FaceDetectorTask(config).run(input);
 };
-Workflow17.prototype.faceDetector = CreateWorkflow17(FaceDetectorTask);
+Workflow15.prototype.faceDetector = CreateWorkflow15(FaceDetectorTask);
 
 // src/task/FaceLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow18, Workflow as Workflow18 } from "@workglow/task-graph";
-var modelSchema11 = TypeModel("model:FaceLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
+var modelSchema10 = TypeModel("model:FaceLandmarkerTask");
 var TypeLandmark = {
   type: "object",
   properties: {
@@ -3813,7 +3490,7 @@ var FaceLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema11,
+    model: modelSchema10,
     numFaces: {
       type: "number",
       minimum: 1,
@@ -3899,11 +3576,11 @@ class FaceLandmarkerTask extends AiVisionTask {
 var faceLandmarker = (input, config) => {
   return new FaceLandmarkerTask(config).run(input);
 };
-Workflow18.prototype.faceLandmarker = CreateWorkflow18(FaceLandmarkerTask);
+Workflow16.prototype.faceLandmarker = CreateWorkflow16(FaceLandmarkerTask);
 
 // src/task/GestureRecognizerTask.ts
-import { CreateWorkflow as CreateWorkflow19, Workflow as Workflow19 } from "@workglow/task-graph";
-var modelSchema12 = TypeModel("model:GestureRecognizerTask");
+import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
+var modelSchema11 = TypeModel("model:GestureRecognizerTask");
 var TypeLandmark2 = {
   type: "object",
   properties: {
@@ -3995,7 +3672,7 @@ var GestureRecognizerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema12,
+    model: modelSchema11,
     numHands: {
       type: "number",
       minimum: 1,
@@ -4067,11 +3744,11 @@ class GestureRecognizerTask extends AiVisionTask {
 var gestureRecognizer = (input, config) => {
   return new GestureRecognizerTask(config).run(input);
 };
-Workflow19.prototype.gestureRecognizer = CreateWorkflow19(GestureRecognizerTask);
+Workflow17.prototype.gestureRecognizer = CreateWorkflow17(GestureRecognizerTask);
 
 // src/task/HandLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow20, Workflow as Workflow20 } from "@workglow/task-graph";
-var modelSchema13 = TypeModel("model:HandLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow18, Workflow as Workflow18 } from "@workglow/task-graph";
+var modelSchema12 = TypeModel("model:HandLandmarkerTask");
 var TypeLandmark3 = {
   type: "object",
   properties: {
@@ -4140,7 +3817,7 @@ var HandLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema13,
+    model: modelSchema12,
     numHands: {
       type: "number",
       minimum: 1,
@@ -4212,7 +3889,7 @@ class HandLandmarkerTask extends AiVisionTask {
 var handLandmarker = (input, config) => {
   return new HandLandmarkerTask(config).run(input);
 };
-Workflow20.prototype.handLandmarker = CreateWorkflow20(HandLandmarkerTask);
+Workflow18.prototype.handLandmarker = CreateWorkflow18(HandLandmarkerTask);
 
 // src/task/HierarchicalChunkerTask.ts
 import {
@@ -4221,9 +3898,9 @@ import {
   getChildren as getChildren2,
   hasChildren as hasChildren2
 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow21, Task as Task11, Workflow as Workflow21 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow19, Task as Task10, Workflow as Workflow19 } from "@workglow/task-graph";
 import { uuid4 } from "@workglow/util";
-var modelSchema14 = TypeModel("model", {
+var modelSchema13 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting"
 });
@@ -4269,7 +3946,7 @@ var inputSchema9 = {
       description: "Strategy for chunking",
       default: "hierarchical"
     },
-    model: modelSchema14
+    model: modelSchema13
   },
   required: ["doc_id", "documentTree"],
   additionalProperties: false
@@ -4304,7 +3981,7 @@ var outputSchema9 = {
   additionalProperties: false
 };
 
-class HierarchicalChunkerTask extends Task11 {
+class HierarchicalChunkerTask extends Task10 {
   static type = "HierarchicalChunkerTask";
   static category = "Document";
   static title = "Hierarchical Chunker";
@@ -4448,11 +4125,11 @@ class HierarchicalChunkerTask extends Task11 {
 var hierarchicalChunker = (input, config) => {
   return new HierarchicalChunkerTask(config).run(input);
 };
-Workflow21.prototype.hierarchicalChunker = CreateWorkflow21(HierarchicalChunkerTask);
+Workflow19.prototype.hierarchicalChunker = CreateWorkflow19(HierarchicalChunkerTask);
 
 // src/task/HierarchyJoinTask.ts
 import { ChunkRecordArraySchema, TypeKnowledgeBase as TypeKnowledgeBase6 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow22, Task as Task12, Workflow as Workflow22 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow20, Task as Task11, Workflow as Workflow20 } from "@workglow/task-graph";
 var inputSchema10 = {
   type: "object",
   properties: {
@@ -4527,7 +4204,7 @@ var outputSchema10 = {
   additionalProperties: false
 };
 
-class HierarchyJoinTask extends Task12 {
+class HierarchyJoinTask extends Task11 {
   static type = "HierarchyJoinTask";
   static category = "RAG";
   static title = "Hierarchy Join";
@@ -4621,11 +4298,11 @@ class HierarchyJoinTask extends Task12 {
 var hierarchyJoin = (input, config) => {
   return new HierarchyJoinTask(config).run(input);
 };
-Workflow22.prototype.hierarchyJoin = CreateWorkflow22(HierarchyJoinTask);
+Workflow20.prototype.hierarchyJoin = CreateWorkflow20(HierarchyJoinTask);
 
 // src/task/KbToDocumentsTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase7 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow23, Task as Task13, Workflow as Workflow23 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow21, Task as Task12, Workflow as Workflow21 } from "@workglow/task-graph";
 var inputSchema11 = {
   type: "object",
   properties: {
@@ -4669,7 +4346,7 @@ var outputSchema11 = {
   additionalProperties: false
 };
 
-class KbToDocumentsTask extends Task13 {
+class KbToDocumentsTask extends Task12 {
   static type = "KbToDocumentsTask";
   static category = "Vector Store";
   static title = "Knowledge Base to Documents";
@@ -4710,16 +4387,16 @@ class KbToDocumentsTask extends Task13 {
 var kbToDocuments = (input, config) => {
   return new KbToDocumentsTask(config).run(input);
 };
-Workflow23.prototype.kbToDocuments = CreateWorkflow23(KbToDocumentsTask);
+Workflow21.prototype.kbToDocuments = CreateWorkflow21(KbToDocumentsTask);
 
 // src/task/ImageClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
-var modelSchema15 = TypeModel("model:ImageClassificationTask");
+import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
+var modelSchema14 = TypeModel("model:ImageClassificationTask");
 var ImageClassificationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema15,
+    model: modelSchema14,
     categories: {
       type: "array",
       items: {
@@ -4773,19 +4450,19 @@ class ImageClassificationTask extends AiVisionTask {
 var imageClassification = (input, config) => {
   return new ImageClassificationTask(config).run(input);
 };
-Workflow24.prototype.imageClassification = CreateWorkflow24(ImageClassificationTask);
+Workflow22.prototype.imageClassification = CreateWorkflow22(ImageClassificationTask);
 
 // src/task/ImageEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema7
 } from "@workglow/util/schema";
-var modelSchema16 = TypeModel("model:ImageEmbeddingTask");
+var modelSchema15 = TypeModel("model:ImageEmbeddingTask");
 var ImageEmbeddingInputSchema = {
   type: "object",
   properties: {
     image: TypeSingleOrArray(TypeImageInput),
-    model: modelSchema16
+    model: modelSchema15
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -4817,16 +4494,16 @@ class ImageEmbeddingTask extends AiVisionTask {
 var imageEmbedding = (input, config) => {
   return new ImageEmbeddingTask(config).run(input);
 };
-Workflow25.prototype.imageEmbedding = CreateWorkflow25(ImageEmbeddingTask);
+Workflow23.prototype.imageEmbedding = CreateWorkflow23(ImageEmbeddingTask);
 
 // src/task/ImageSegmentationTask.ts
-import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
-var modelSchema17 = TypeModel("model:ImageSegmentationTask");
+import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
+var modelSchema16 = TypeModel("model:ImageSegmentationTask");
 var ImageSegmentationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema17,
+    model: modelSchema16,
     threshold: {
       type: "number",
       title: "Threshold",
@@ -4905,11 +4582,11 @@ class ImageSegmentationTask extends AiVisionTask {
 var imageSegmentation = (input, config) => {
   return new ImageSegmentationTask(config).run(input);
 };
-Workflow26.prototype.imageSegmentation = CreateWorkflow26(ImageSegmentationTask);
+Workflow24.prototype.imageSegmentation = CreateWorkflow24(ImageSegmentationTask);
 
 // src/task/ImageToTextTask.ts
-import { CreateWorkflow as CreateWorkflow27, Workflow as Workflow27 } from "@workglow/task-graph";
-var modelSchema18 = TypeModel("model:ImageToTextTask");
+import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
+var modelSchema17 = TypeModel("model:ImageToTextTask");
 var generatedTextSchema = {
   type: "string",
   title: "Text",
@@ -4919,7 +4596,7 @@ var ImageToTextInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema18,
+    model: modelSchema17,
     maxTokens: {
       type: "number",
       title: "Max Tokens",
@@ -4960,15 +4637,15 @@ class ImageToTextTask extends AiVisionTask {
 var imageToText = (input, config) => {
   return new ImageToTextTask(config).run(input);
 };
-Workflow27.prototype.imageToText = CreateWorkflow27(ImageToTextTask);
+Workflow25.prototype.imageToText = CreateWorkflow25(ImageToTextTask);
 
 // src/task/ModelInfoTask.ts
-import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
-var modelSchema19 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
+var modelSchema18 = TypeModel("model");
 var ModelInfoInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema19,
+    model: modelSchema18,
     detail: {
       type: "string",
       enum: ["cached_status", "files", "files_with_metadata", "dimensions"],
@@ -4981,7 +4658,7 @@ var ModelInfoInputSchema = {
 var ModelInfoOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema19,
+    model: modelSchema18,
     is_local: { type: "boolean" },
     is_remote: { type: "boolean" },
     supports_browser: { type: "boolean" },
@@ -5039,10 +4716,10 @@ class ModelInfoTask extends AiTask {
 var modelInfo = (input, config) => {
   return new ModelInfoTask(config).run(input);
 };
-Workflow28.prototype.modelInfo = CreateWorkflow28(ModelInfoTask);
+Workflow26.prototype.modelInfo = CreateWorkflow26(ModelInfoTask);
 
 // src/task/ModelSearchTask.ts
-import { CreateWorkflow as CreateWorkflow29, Task as Task14, Workflow as Workflow29 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow27, Task as Task13, Workflow as Workflow27 } from "@workglow/task-graph";
 var ModelSearchInputSchema = {
   type: "object",
   properties: {
@@ -5107,7 +4784,7 @@ var ModelSearchOutputSchema = {
   additionalProperties: false
 };
 
-class ModelSearchTask extends Task14 {
+class ModelSearchTask extends Task13 {
   static type = "ModelSearchTask";
   static category = "AI Model";
   static title = "Model Search";
@@ -5133,11 +4810,11 @@ class ModelSearchTask extends Task14 {
 var modelSearch = (input, config) => {
   return new ModelSearchTask(config).run(input);
 };
-Workflow29.prototype.modelSearch = CreateWorkflow29(ModelSearchTask);
+Workflow27.prototype.modelSearch = CreateWorkflow27(ModelSearchTask);
 
 // src/task/ObjectDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow30, Workflow as Workflow30 } from "@workglow/task-graph";
-var modelSchema20 = TypeModel("model:ObjectDetectionTask");
+import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
+var modelSchema19 = TypeModel("model:ObjectDetectionTask");
 var detectionSchema = {
   type: "object",
   properties: {
@@ -5162,7 +4839,7 @@ var ObjectDetectionInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema20,
+    model: modelSchema19,
     labels: {
       type: "array",
       items: {
@@ -5216,11 +4893,11 @@ class ObjectDetectionTask extends AiVisionTask {
 var objectDetection = (input, config) => {
   return new ObjectDetectionTask(config).run(input);
 };
-Workflow30.prototype.objectDetection = CreateWorkflow30(ObjectDetectionTask);
+Workflow28.prototype.objectDetection = CreateWorkflow28(ObjectDetectionTask);
 
 // src/task/PoseLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow31, Workflow as Workflow31 } from "@workglow/task-graph";
-var modelSchema21 = TypeModel("model:PoseLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow29, Workflow as Workflow29 } from "@workglow/task-graph";
+var modelSchema20 = TypeModel("model:PoseLandmarkerTask");
 var TypePoseLandmark = {
   type: "object",
   properties: {
@@ -5299,7 +4976,7 @@ var PoseLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema21,
+    model: modelSchema20,
     numPoses: {
       type: "number",
       minimum: 1,
@@ -5378,10 +5055,10 @@ class PoseLandmarkerTask extends AiVisionTask {
 var poseLandmarker = (input, config) => {
   return new PoseLandmarkerTask(config).run(input);
 };
-Workflow31.prototype.poseLandmarker = CreateWorkflow31(PoseLandmarkerTask);
+Workflow29.prototype.poseLandmarker = CreateWorkflow29(PoseLandmarkerTask);
 
 // src/task/QueryExpanderTask.ts
-import { CreateWorkflow as CreateWorkflow32, Task as Task15, Workflow as Workflow32 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow30, Task as Task14, Workflow as Workflow30 } from "@workglow/task-graph";
 var QueryExpansionMethod = {
   MULTI_QUERY: "multi-query",
   HYDE: "hyde",
@@ -5449,7 +5126,7 @@ var outputSchema12 = {
   additionalProperties: false
 };
 
-class QueryExpanderTask extends Task15 {
+class QueryExpanderTask extends Task14 {
   static type = "QueryExpanderTask";
   static category = "RAG";
   static title = "Query Expander";
@@ -5591,14 +5268,14 @@ class QueryExpanderTask extends Task15 {
 var queryExpander = (input, config) => {
   return new QueryExpanderTask(config).run(input);
 };
-Workflow32.prototype.queryExpander = CreateWorkflow32(QueryExpanderTask);
+Workflow30.prototype.queryExpander = CreateWorkflow30(QueryExpanderTask);
 
 // src/task/RerankerTask.ts
-import { CreateWorkflow as CreateWorkflow34, Task as Task16, Workflow as Workflow34 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow32, Task as Task15, Workflow as Workflow32 } from "@workglow/task-graph";
 
 // src/task/TextClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow33, Workflow as Workflow33 } from "@workglow/task-graph";
-var modelSchema22 = TypeModel("model:TextClassificationTask");
+import { CreateWorkflow as CreateWorkflow31, Workflow as Workflow31 } from "@workglow/task-graph";
+var modelSchema21 = TypeModel("model:TextClassificationTask");
 var TextClassificationInputSchema = {
   type: "object",
   properties: {
@@ -5625,7 +5302,7 @@ var TextClassificationInputSchema = {
       description: "The maximum number of categories to return",
       "x-ui-group": "Configuration"
     },
-    model: modelSchema22
+    model: modelSchema21
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5675,7 +5352,7 @@ class TextClassificationTask extends AiTask {
 var textClassification = (input, config) => {
   return new TextClassificationTask(config).run(input);
 };
-Workflow33.prototype.textClassification = CreateWorkflow33(TextClassificationTask);
+Workflow31.prototype.textClassification = CreateWorkflow31(TextClassificationTask);
 
 // src/task/RerankerTask.ts
 var inputSchema13 = {
@@ -5770,7 +5447,7 @@ var outputSchema13 = {
   additionalProperties: false
 };
 
-class RerankerTask extends Task16 {
+class RerankerTask extends Task15 {
   static type = "RerankerTask";
   static category = "RAG";
   static title = "Reranker";
@@ -5898,11 +5575,11 @@ class RerankerTask extends Task16 {
 var reranker = (input, config) => {
   return new RerankerTask(config).run(input);
 };
-Workflow34.prototype.reranker = CreateWorkflow34(RerankerTask);
+Workflow32.prototype.reranker = CreateWorkflow32(RerankerTask);
 
 // src/task/StructuralParserTask.ts
 import { StructuralParser } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow35, Task as Task17, Workflow as Workflow35 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow33, Task as Task16, Workflow as Workflow33 } from "@workglow/task-graph";
 import { uuid4 as uuid42 } from "@workglow/util";
 var inputSchema14 = {
   type: "object",
@@ -5962,7 +5639,7 @@ var outputSchema14 = {
   additionalProperties: false
 };
 
-class StructuralParserTask extends Task17 {
+class StructuralParserTask extends Task16 {
   static type = "StructuralParserTask";
   static category = "Document";
   static title = "Structural Parser";
@@ -6005,15 +5682,16 @@ class StructuralParserTask extends Task17 {
 var structuralParser = (input, config) => {
   return new StructuralParserTask(config).run(input);
 };
-Workflow35.prototype.structuralParser = CreateWorkflow35(StructuralParserTask);
+Workflow33.prototype.structuralParser = CreateWorkflow33(StructuralParserTask);
 
 // src/task/StructuredGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
-var modelSchema23 = TypeModel("model:StructuredGenerationTask");
+import { CreateWorkflow as CreateWorkflow34, TaskConfigurationError as TaskConfigurationError4, TaskError, Workflow as Workflow34 } from "@workglow/task-graph";
+import { compileSchema as compileSchema2 } from "@workglow/util/schema";
+var modelSchema22 = TypeModel("model:StructuredGenerationTask");
 var StructuredGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema23,
+    model: modelSchema22,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -6040,6 +5718,15 @@ var StructuredGenerationInputSchema = {
       minimum: 0,
       maximum: 2,
       "x-ui-group": "Configuration"
+    },
+    maxRetries: {
+      type: "integer",
+      title: "Max Retries",
+      description: "Number of times to re-prompt the model with validation errors when its output doesn't match the schema. 0 disables retries (fail on first mismatch).",
+      minimum: 0,
+      maximum: 10,
+      default: 2,
+      "x-ui-group": "Configuration"
     }
   },
   required: ["model", "prompt", "outputSchema"],
@@ -6061,25 +5748,119 @@ var StructuredGenerationOutputSchema = {
   additionalProperties: false
 };
 
+class StructuredOutputValidationError extends TaskError {
+  static type = "StructuredOutputValidationError";
+  attempts;
+  constructor(attempts) {
+    const last = attempts[attempts.length - 1];
+    const summary = last?.errors.map((e) => `${e.path || "/"}: ${e.message}`).join("; ") ?? "";
+    super(`StructuredGenerationTask: model output failed validation after ${attempts.length} attempt(s). ` + `Last errors: ${summary}`);
+    this.attempts = attempts;
+  }
+}
+function validationErrorsFromSchemaNode(result) {
+  return result.errors.map((e) => ({ path: e.data.pointer || "", message: e.message }));
+}
+function buildRetryPrompt(originalPrompt, errors) {
+  const errorList = errors.map((e) => `  - ${e.path || "/"}: ${e.message}`).join(`
+`);
+  return `${originalPrompt}
+
+` + `Your previous response did not conform to the required JSON schema. ` + `Validation errors:
+${errorList}
+
+` + `Please respond again with a JSON object that satisfies the schema. ` + `Output ONLY the JSON object, no other text.`;
+}
+
 class StructuredGenerationTask extends StreamingAiTask {
   static type = "StructuredGenerationTask";
   static category = "AI Text Model";
   static title = "Structured Generation";
-  static description = "Generates structured JSON output conforming to a provided schema using language models";
+  static description = "Generates structured JSON output conforming to a provided schema using language models, with automatic validation and retry on mismatch";
   static inputSchema() {
     return StructuredGenerationInputSchema;
   }
   static outputSchema() {
     return StructuredGenerationOutputSchema;
   }
+  async* executeStream(input, context) {
+    let validator;
+    try {
+      validator = compileSchema2(input.outputSchema);
+    } catch (err2) {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
+      const configErr = new TaskConfigurationError4(`StructuredGenerationTask: invalid outputSchema — ${msg}`);
+      configErr.taskType = this.type;
+      configErr.taskId = this.id;
+      throw configErr;
+    }
+    const maxRetries = Math.max(0, input.maxRetries ?? 2);
+    const maxAttempts = maxRetries + 1;
+    const attempts = [];
+    let currentInput = input;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      let lastObject;
+      for await (const event of super.executeStream(currentInput, context)) {
+        if (event.type === "object-delta" && event.port === "object") {
+          const delta = event.objectDelta;
+          if (delta && !Array.isArray(delta)) {
+            lastObject = delta;
+          }
+          yield event;
+        } else if (event.type === "finish") {
+          const data = event.data;
+          const finalObject = data?.object ?? lastObject ?? {};
+          const result = validator.validate(finalObject);
+          if (result.valid) {
+            yield {
+              type: "finish",
+              data: { object: finalObject }
+            };
+            return;
+          }
+          const errors = validationErrorsFromSchemaNode(result);
+          attempts.push({ attempt, errors, object: finalObject });
+          lastObject = finalObject;
+          break;
+        } else {
+          yield event;
+        }
+      }
+      if (attempt < maxAttempts) {
+        yield {
+          type: "object-delta",
+          port: "object",
+          objectDelta: {}
+        };
+        const lastErrors = attempts[attempts.length - 1].errors;
+        currentInput = {
+          ...input,
+          prompt: buildRetryPrompt(input.prompt, lastErrors)
+        };
+      }
+    }
+    const err = new StructuredOutputValidationError(attempts);
+    err.taskType = this.type;
+    err.taskId = this.id;
+    throw err;
+  }
+  async execute(input, context) {
+    let result;
+    for await (const event of this.executeStream(input, context)) {
+      if (event.type === "finish") {
+        result = event.data;
+      }
+    }
+    return result;
+  }
 }
 var structuredGeneration = (input, config) => {
   return new StructuredGenerationTask(config).run(input);
 };
-Workflow36.prototype.structuredGeneration = CreateWorkflow36(StructuredGenerationTask);
+Workflow34.prototype.structuredGeneration = CreateWorkflow34(StructuredGenerationTask);
 
 // src/task/TextChunkerTask.ts
-import { CreateWorkflow as CreateWorkflow37, Task as Task18, Workflow as Workflow37 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow35, Task as Task17, Workflow as Workflow35 } from "@workglow/task-graph";
 var ChunkingStrategy = {
   FIXED: "fixed",
   SENTENCE: "sentence",
@@ -6148,7 +5929,7 @@ var outputSchema15 = {
   additionalProperties: false
 };
 
-class TextChunkerTask extends Task18 {
+class TextChunkerTask extends Task17 {
   static type = "TextChunkerTask";
   static category = "Document";
   static title = "Text Chunker";
@@ -6328,11 +6109,11 @@ class TextChunkerTask extends Task18 {
 var textChunker = (input, config) => {
   return new TextChunkerTask(config).run(input);
 };
-Workflow37.prototype.textChunker = CreateWorkflow37(TextChunkerTask);
+Workflow35.prototype.textChunker = CreateWorkflow35(TextChunkerTask);
 
 // src/task/TextFillMaskTask.ts
-import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
-var modelSchema24 = TypeModel("model:TextFillMaskTask");
+import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
+var modelSchema23 = TypeModel("model:TextFillMaskTask");
 var TextFillMaskInputSchema = {
   type: "object",
   properties: {
@@ -6341,7 +6122,7 @@ var TextFillMaskInputSchema = {
       title: "Text",
       description: "The text with a mask token to fill"
     },
-    model: modelSchema24
+    model: modelSchema23
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -6396,21 +6177,21 @@ class TextFillMaskTask extends AiTask {
 var textFillMask = (input, config) => {
   return new TextFillMaskTask(config).run(input);
 };
-Workflow38.prototype.textFillMask = CreateWorkflow38(TextFillMaskTask);
+Workflow36.prototype.textFillMask = CreateWorkflow36(TextFillMaskTask);
 
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
 var generatedTextSchema2 = {
   type: "string",
   title: "Text",
   description: "The generated text",
   "x-stream": "append"
 };
-var modelSchema25 = TypeModel("model:TextGenerationTask");
+var modelSchema24 = TypeModel("model:TextGenerationTask");
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema25,
+    model: modelSchema24,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -6484,11 +6265,11 @@ class TextGenerationTask extends StreamingAiTask {
 var textGeneration = (input, config) => {
   return new TextGenerationTask(config).run(input);
 };
-Workflow39.prototype.textGeneration = CreateWorkflow39(TextGenerationTask);
+Workflow37.prototype.textGeneration = CreateWorkflow37(TextGenerationTask);
 
 // src/task/TextLanguageDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
-var modelSchema26 = TypeModel("model:TextLanguageDetectionTask");
+import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
+var modelSchema25 = TypeModel("model:TextLanguageDetectionTask");
 var TextLanguageDetectionInputSchema = {
   type: "object",
   properties: {
@@ -6505,7 +6286,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema26
+    model: modelSchema25
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -6555,10 +6336,10 @@ class TextLanguageDetectionTask extends AiTask {
 var textLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask(config).run(input);
 };
-Workflow40.prototype.textLanguageDetection = CreateWorkflow40(TextLanguageDetectionTask);
+Workflow38.prototype.textLanguageDetection = CreateWorkflow38(TextLanguageDetectionTask);
 
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
 var contextSchema = {
   type: "string",
   title: "Context",
@@ -6575,13 +6356,13 @@ var textSchema = {
   description: "The generated text",
   "x-stream": "append"
 };
-var modelSchema27 = TypeModel("model:TextQuestionAnswerTask");
+var modelSchema26 = TypeModel("model:TextQuestionAnswerTask");
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: contextSchema,
     question: questionSchema,
-    model: modelSchema27
+    model: modelSchema26
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -6610,11 +6391,11 @@ class TextQuestionAnswerTask extends StreamingAiTask {
 var textQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask(config).run(input);
 };
-Workflow41.prototype.textQuestionAnswer = CreateWorkflow41(TextQuestionAnswerTask);
+Workflow39.prototype.textQuestionAnswer = CreateWorkflow39(TextQuestionAnswerTask);
 
 // src/task/TextRewriterTask.ts
-import { CreateWorkflow as CreateWorkflow42, Workflow as Workflow42 } from "@workglow/task-graph";
-var modelSchema28 = TypeModel("model:TextRewriterTask");
+import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
+var modelSchema27 = TypeModel("model:TextRewriterTask");
 var TextRewriterInputSchema = {
   type: "object",
   properties: {
@@ -6628,7 +6409,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     },
-    model: modelSchema28
+    model: modelSchema27
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -6662,11 +6443,11 @@ class TextRewriterTask extends StreamingAiTask {
 var textRewriter = (input, config) => {
   return new TextRewriterTask(config).run(input);
 };
-Workflow42.prototype.textRewriter = CreateWorkflow42(TextRewriterTask);
+Workflow40.prototype.textRewriter = CreateWorkflow40(TextRewriterTask);
 
 // src/task/TextTranslationTask.ts
-import { CreateWorkflow as CreateWorkflow43, Workflow as Workflow43 } from "@workglow/task-graph";
-var modelSchema29 = TypeModel("model:TextTranslationTask");
+import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
+var modelSchema28 = TypeModel("model:TextTranslationTask");
 var translationTextSchema = {
   type: "string",
   title: "Text",
@@ -6693,7 +6474,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     }),
-    model: modelSchema29
+    model: modelSchema28
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -6728,10 +6509,245 @@ class TextTranslationTask extends StreamingAiTask {
 var textTranslation = (input, config) => {
   return new TextTranslationTask(config).run(input);
 };
-Workflow43.prototype.textTranslation = CreateWorkflow43(TextTranslationTask);
+Workflow41.prototype.textTranslation = CreateWorkflow41(TextTranslationTask);
+
+// src/task/ToolCallingTask.ts
+import { CreateWorkflow as CreateWorkflow42, getTaskConstructors, Workflow as Workflow42 } from "@workglow/task-graph";
+import { makeFingerprint } from "@workglow/util";
+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 modelSchema29 = TypeModel("model:ToolCallingTask");
+var ToolCallingInputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema29,
+    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: ChatMessageSchema
+    },
+    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: {
+      type: "string",
+      title: "Text",
+      description: "Any text content generated by the model",
+      "x-stream": "append"
+    },
+    toolCalls: {
+      type: "array",
+      items: ToolCallSchema,
+      title: "Tool Calls",
+      description: "Tool calls requested by the model",
+      "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;
+  }
+  _computedSessionId;
+  async getJobInput(input) {
+    const jobInput = await super.getJobInput(input);
+    if (!jobInput.sessionId && input.tools && input.tools.length > 0) {
+      jobInput.sessionId = await makeFingerprint({
+        tools: input.tools,
+        systemPrompt: input.systemPrompt,
+        runnerId: this.runConfig.runnerId
+      });
+      this._computedSessionId = jobInput.sessionId;
+    }
+    return jobInput;
+  }
+  registerSessionDispose(input, context) {
+    const sessionId = this._computedSessionId;
+    if (!sessionId || !context.resourceScope)
+      return;
+    const model = input.model;
+    if (!model || typeof model !== "object")
+      return;
+    const providerName = model.provider;
+    context.resourceScope.register(`ai:session:${sessionId}`, async () => {
+      await getAiProviderRegistry().disposeSession(providerName, sessionId);
+    });
+  }
+  async execute(input, executeContext) {
+    const result = await super.execute(input, executeContext);
+    this.registerSessionDispose(input, executeContext);
+    return result;
+  }
+  async* executeStream(input, context) {
+    yield* super.executeStream(input, context);
+    this.registerSessionDispose(input, context);
+  }
+}
+var toolCalling = (input, config) => {
+  return new ToolCallingTask(config).run(input);
+};
+Workflow42.prototype.toolCalling = CreateWorkflow42(ToolCallingTask);
 
 // src/task/TopicSegmenterTask.ts
-import { CreateWorkflow as CreateWorkflow44, Task as Task19, Workflow as Workflow44 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow43, Task as Task18, Workflow as Workflow43 } from "@workglow/task-graph";
 var SegmentationMethod = {
   HEURISTIC: "heuristic",
   EMBEDDING_SIMILARITY: "embedding-similarity",
@@ -6806,7 +6822,7 @@ var outputSchema16 = {
   additionalProperties: false
 };
 
-class TopicSegmenterTask extends Task19 {
+class TopicSegmenterTask extends Task18 {
   static type = "TopicSegmenterTask";
   static category = "Document";
   static title = "Topic Segmenter";
@@ -7011,10 +7027,10 @@ class TopicSegmenterTask extends Task19 {
 var topicSegmenter = (input, config) => {
   return new TopicSegmenterTask(config).run(input);
 };
-Workflow44.prototype.topicSegmenter = CreateWorkflow44(TopicSegmenterTask);
+Workflow43.prototype.topicSegmenter = CreateWorkflow43(TopicSegmenterTask);
 
 // src/task/UnloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow45, Workflow as Workflow45 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow44, Workflow as Workflow44 } from "@workglow/task-graph";
 var modelSchema30 = TypeModel("model");
 var UnloadModelInputSchema = {
   type: "object",
@@ -7049,10 +7065,10 @@ class UnloadModelTask extends AiTask {
 var unloadModel = (input, config) => {
   return new UnloadModelTask(config).run(input);
 };
-Workflow45.prototype.unloadModel = CreateWorkflow45(UnloadModelTask);
+Workflow44.prototype.unloadModel = CreateWorkflow44(UnloadModelTask);
 
 // src/task/VectorQuantizeTask.ts
-import { CreateWorkflow as CreateWorkflow46, Task as Task20, Workflow as Workflow46 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow45, Task as Task19, Workflow as Workflow45 } from "@workglow/task-graph";
 import {
   normalizeNumberArray,
   TensorType,
@@ -7132,7 +7148,7 @@ var outputSchema17 = {
   additionalProperties: false
 };
 
-class VectorQuantizeTask extends Task20 {
+class VectorQuantizeTask extends Task19 {
   static type = "VectorQuantizeTask";
   static category = "Vector";
   static title = "Quantize";
@@ -7232,10 +7248,10 @@ class VectorQuantizeTask extends Task20 {
 var vectorQuantize = (input, config) => {
   return new VectorQuantizeTask(config).run(input);
 };
-Workflow46.prototype.vectorQuantize = CreateWorkflow46(VectorQuantizeTask);
+Workflow45.prototype.vectorQuantize = CreateWorkflow45(VectorQuantizeTask);
 
 // src/task/VectorSimilarityTask.ts
-import { CreateWorkflow as CreateWorkflow47, GraphAsTask, Workflow as Workflow47 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow46, GraphAsTask, Workflow as Workflow46 } from "@workglow/task-graph";
 import {
   cosineSimilarity,
   hammingSimilarity,
@@ -7341,7 +7357,7 @@ class VectorSimilarityTask extends GraphAsTask {
 var similarity = (input, config) => {
   return new VectorSimilarityTask(config).run(input);
 };
-Workflow47.prototype.similarity = CreateWorkflow47(VectorSimilarityTask);
+Workflow46.prototype.similarity = CreateWorkflow46(VectorSimilarityTask);
 // src/task/MessageConversion.ts
 function getInputMessages(input) {
   const messages = input.messages;
@@ -7390,66 +7406,46 @@ function toOpenAIMessages(input) {
   }
   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) });
+      const parts = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          parts.push({ type: "text", text: block.text });
+        } else if (block.type === "image") {
+          parts.push({
+            type: "image_url",
+            image_url: { url: `data:${block.mimeType};base64,${block.data}` }
+          });
         }
       }
+      messages.push({ role: "user", content: parts });
     } 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;
+      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)
         }
-        messages.push(entry);
+      }));
+      const entry = {
+        role: "assistant",
+        content: textParts.length > 0 ? textParts : null
+      };
+      if (toolCalls.length > 0) {
+        entry.tool_calls = toolCalls;
       }
-    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
+      messages.push(entry);
+    } else if (msg.role === "tool") {
       for (const block of msg.content) {
-        const b = block;
+        if (block.type !== "tool_result")
+          continue;
         let content;
-        if (typeof b.content === "string") {
-          content = b.content;
-        } else if (Array.isArray(b.content)) {
+        if (block.content.length === 1 && block.content[0].type === "text") {
+          content = block.content[0].text;
+        } else {
           const parts = [];
-          for (const inner of b.content) {
+          for (const inner of block.content) {
             if (inner.type === "text") {
               parts.push({ type: "text", text: inner.text });
             } else if (inner.type === "image") {
@@ -7460,14 +7456,8 @@ function toOpenAIMessages(input) {
             }
           }
           content = parts;
-        } else {
-          content = "";
         }
-        messages.push({
-          role: "tool",
-          content,
-          tool_call_id: b.tool_use_id
-        });
+        messages.push({ role: "tool", content, tool_call_id: block.tool_use_id });
       }
     }
   }
@@ -7497,41 +7487,18 @@ function toTextFlatMessages(input) {
   }
   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);
-        }
-      }
+      const content = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
       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 });
-        }
+      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)) {
+    } else if (msg.role === "tool") {
       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 = "";
-        }
+        if (block.type !== "tool_result")
+          continue;
+        const content = block.content.filter((inner) => inner.type === "text").map((inner) => inner.text).join("");
         messages.push({ role: "tool", content });
       }
     }
@@ -7542,7 +7509,7 @@ function toTextFlatMessages(input) {
 // src/task/index.ts
 var registerAiTasks = () => {
   const tasks = [
-    AgentTask,
+    AiChatTask,
     BackgroundRemovalTask,
     ChunkToVectorTask,
     CountTokensTask,
@@ -7596,11 +7563,8 @@ var registerAiTasks = () => {
 export {
   vectorStoreSearch,
   vectorQuantize,
-  userMessage,
   unloadModel,
   topicSegmenter,
-  toolSourceDefinitions,
-  toolMessage,
   toolCalling,
   toTextFlatMessages,
   toOpenAIMessages,
@@ -7609,6 +7573,7 @@ export {
   textRewriter,
   textQuestionAnswer,
   textNamedEntityRecognition,
+  textMessage,
   textLanguageDetection,
   textGeneration,
   textFillMask,
@@ -7630,43 +7595,33 @@ export {
   modelSearch,
   modelInfo,
   kbToDocuments,
+  isContentBlock,
+  isChatMessage,
   isAllowedToolName,
   imageToText,
   imageSegmentation,
   imageEmbedding,
   imageClassification,
-  imageBlockFromDataUri,
-  imageBlock,
   hybridSearch,
   hierarchyJoin,
   hierarchicalChunker,
-  hasToolCalls,
   handLandmarker,
   getGlobalModelRepository,
   getAiProviderRegistry,
   gestureRecognizer,
-  findToolSource,
   filterValidToolCalls,
   faceLandmarker,
   faceDetector,
-  executeToolCalls,
-  executeToolCall,
   downloadModel,
   documentUpsert,
   documentEnricher,
   countTokens,
-  countAssistantToolUses,
   contextBuilder,
   chunkVectorUpsert,
   chunkToVector,
   chunkRetrieval,
-  buildToolSources,
   buildToolDescription,
   backgroundRemoval,
-  audioBlockFromDataUri,
-  audioBlock,
-  assistantMessage,
-  agent,
   VectorSimilarityTask,
   VectorQuantizeTask,
   UnloadModelTask,
@@ -7715,6 +7670,7 @@ export {
   TextClassificationOutputSchema,
   TextClassificationInputSchema,
   TextChunkerTask,
+  StructuredOutputValidationError,
   StructuredGenerationTask,
   StructuredGenerationOutputSchema,
   StructuredGenerationInputSchema,
@@ -7778,12 +7734,14 @@ export {
   CountTokensInputSchema,
   ContextFormat,
   ContextBuilderTask,
+  ContentBlockSchema,
   ChunkingStrategy,
   ChunkVectorUpsertTask,
   ChunkVectorSearchTask,
   ChunkVectorHybridSearchTask,
   ChunkToVectorTask,
   ChunkRetrievalTask,
+  ChatMessageSchema,
   BackgroundRemovalTask,
   BackgroundRemovalOutputSchema,
   BackgroundRemovalInputSchema,
@@ -7791,9 +7749,9 @@ export {
   AiProviderRegistry,
   AiProvider,
   AiJob,
-  AgentTask,
-  AgentOutputSchema,
-  AgentInputSchema
+  AiChatTask,
+  AiChatOutputSchema,
+  AiChatInputSchema
 };
 
-//# debugId=FF0FA51260752A4C64756E2164756E21
+//# debugId=C6F40B205C02731964756E2164756E21