@workglow/ai 0.2.6 → 0.2.8

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;
         }
@@ -454,7 +467,15 @@ var ModelConfigSchema = {
     provider_config: {
       type: "object",
       properties: {
-        credential_key: { type: "string", format: "credential", "x-ui-hidden": true }
+        credential_key: { type: "string", format: "credential", "x-ui-hidden": true },
+        native_dimensions: {
+          type: "integer",
+          description: "Native output vector dimensions for embedding models"
+        },
+        mrl: {
+          type: "boolean",
+          description: "Whether the model supports Matryoshka Representation Learning"
+        }
       },
       additionalProperties: true,
       default: {}
@@ -648,6 +669,7 @@ registerInputCompactor("model", async (value, _format, registry) => {
 
 // src/provider/AiProvider.ts
 import { globalServiceRegistry as globalServiceRegistry3, WORKER_MANAGER as WORKER_MANAGER2 } from "@workglow/util/worker";
+var DEFAULT_AI_PROVIDER_WORKER_IDLE_TIMEOUT_MS = 15 * 60 * 1000;
 function resolveAiProviderGpuQueueConcurrency(concurrency) {
   if (concurrency === undefined) {
     return 1;
@@ -695,7 +717,13 @@ class AiProvider {
     const registry = getAiProviderRegistry();
     if (!isInline && options.worker) {
       const workerManager = globalServiceRegistry3.get(WORKER_MANAGER2);
-      workerManager.registerWorker(this.name, options.worker);
+      if (typeof options.worker === "function") {
+        workerManager.registerWorker(this.name, options.worker, {
+          idleTimeoutMs: options.workerIdleTimeoutMs ?? DEFAULT_AI_PROVIDER_WORKER_IDLE_TIMEOUT_MS
+        });
+      } else {
+        workerManager.registerWorker(this.name, options.worker);
+      }
       for (const taskType of this.taskTypes) {
         registry.registerAsWorkerRunFn(this.name, taskType);
         registry.registerAsWorkerStreamFn(this.name, taskType);
@@ -744,6 +772,10 @@ class AiProvider {
   }
   async onInitialize(_options) {}
   async dispose() {}
+  createSession(_model) {
+    return crypto.randomUUID();
+  }
+  async disposeSession(_sessionId) {}
   async afterRegister(_options) {}
 }
 
@@ -767,74 +799,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/BackgroundRemovalTask.ts
+import { CreateWorkflow, Workflow } from "@workglow/task-graph";
 
 // src/task/base/AiTaskSchemas.ts
 var TypeLanguage = (annotations = {}) => ({
@@ -993,8 +959,8 @@ var TypeCategory = {
   description: "Classification category with label and score"
 };
 
-// src/task/base/StreamingAiTask.ts
-import { getStreamingPorts, TaskConfigurationError as TaskConfigurationError3 } from "@workglow/task-graph";
+// src/task/base/AiVisionTask.ts
+import { convertImageDataToUseableForm } from "@workglow/util/media";
 
 // src/task/base/AiTask.ts
 import {
@@ -1049,6 +1015,18 @@ class AiTask extends Task {
     const jobInput = await this.getJobInput(input);
     const strategy = getAiProviderRegistry().getStrategy(model);
     const output = await strategy.execute(jobInput, executeContext, this.runConfig.runnerId);
+    if (executeContext.resourceScope) {
+      const registry = getAiProviderRegistry();
+      const provider = registry.getProvider(model.provider);
+      const unloadFn = provider?.getRunFn("UnloadModelTask");
+      if (unloadFn) {
+        const modelPath = model.provider_config?.model_path ?? model.model;
+        const resourceKey = `ai:${model.provider}:${modelPath}`;
+        executeContext.resourceScope.register(resourceKey, async () => {
+          await unloadFn({ model }, model, () => {}, AbortSignal.timeout(30000));
+        });
+      }
+    }
     return output;
   }
   async getJobInput(input) {
@@ -1072,6 +1050,10 @@ class AiTask extends Task {
         jobInput.outputSchema = taskOutputSchema;
       }
     }
+    const sessionId = input.sessionId;
+    if (sessionId) {
+      jobInput.sessionId = sessionId;
+    }
     return jobInput;
   }
   async createJob(input, queueName) {
@@ -1087,786 +1069,84 @@ class AiTask extends Task {
     });
     return job;
   }
-  async getDefaultQueueName(input) {
-    const model = input.model;
-    return model?.provider;
-  }
-  async executeReactive(input, output, context) {
-    const model = input.model;
-    if (model && typeof model === "object" && model.provider) {
-      const taskType = this.constructor.runtype ?? this.constructor.type;
-      const reactiveFn = getAiProviderRegistry().getReactiveRunFn(model.provider, taskType);
-      if (reactiveFn) {
-        return reactiveFn(input, output, model);
-      }
-    }
-    return super.executeReactive(input, output, context);
-  }
-  async validateInput(input) {
-    const inputSchema = this.inputSchema();
-    if (typeof inputSchema === "boolean") {
-      if (inputSchema === false) {
-        throw new TaskConfigurationError2(`AiTask: Input schema is 'false' and accepts no inputs`);
-      }
-      return true;
-    }
-    const modelTaskProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema)?.startsWith("model:"));
-    for (const [key] of modelTaskProperties) {
-      const model = input[key];
-      if (typeof model === "object" && model !== null) {
-        const tasks = model.tasks;
-        if (Array.isArray(tasks) && tasks.length > 0 && !tasks.includes(this.type)) {
-          const modelId = model.model_id ?? "(inline config)";
-          throw new TaskConfigurationError2(`AiTask: Model "${modelId}" for '${key}' is not compatible with task '${this.type}'. ` + `Model supports: [${tasks.join(", ")}]`);
-        }
-      } else if (model !== undefined && model !== null) {
-        throw new TaskConfigurationError2(`AiTask: Invalid model for '${key}' - expected ModelConfig object but got ${typeof model}. ` + `Ensure the model ID was registered in the ModelRepository before running the task.`);
-      }
-    }
-    const modelPlainProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema) === "model");
-    for (const [key] of modelPlainProperties) {
-      const model = input[key];
-      if (model !== undefined && model !== null && typeof model !== "object") {
-        throw new TaskConfigurationError2(`AiTask: Invalid model for '${key}' - expected ModelConfig object but got ${typeof model}. ` + `Ensure the model ID was registered in the ModelRepository before running the task.`);
-      }
-    }
-    return super.validateInput(input);
-  }
-  async narrowInput(input, registry) {
-    const inputSchema = this.inputSchema();
-    if (typeof inputSchema === "boolean") {
-      if (inputSchema === false) {
-        throw new TaskConfigurationError2(`AiTask: Input schema is 'false' and accepts no inputs`);
-      }
-      return input;
-    }
-    const modelTaskProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema)?.startsWith("model:"));
-    if (modelTaskProperties.length > 0) {
-      const modelRepo = registry.get(MODEL_REPOSITORY);
-      const taskModels = await modelRepo.findModelsByTask(this.type) ?? [];
-      for (const [key] of modelTaskProperties) {
-        const requestedModel = input[key];
-        if (typeof requestedModel === "string") {
-          const found = taskModels?.find((m) => m.model_id === requestedModel);
-          if (!found) {
-            input[key] = undefined;
-          }
-        } else if (typeof requestedModel === "object" && requestedModel !== null) {
-          const model = requestedModel;
-          const tasks = model.tasks;
-          if (Array.isArray(tasks) && tasks.length > 0 && !tasks.includes(this.type)) {
-            input[key] = undefined;
-          }
-        }
-      }
-    }
-    return input;
-  }
-}
-
-// src/task/base/StreamingAiTask.ts
-class StreamingAiTask extends AiTask {
-  static type = "StreamingAiTask";
-  async* executeStream(input, context) {
-    const model = input.model;
-    if (!model || typeof model !== "object") {
-      throw new TaskConfigurationError3("StreamingAiTask: Model was not resolved to ModelConfig - this indicates a bug in the resolution system");
-    }
-    const jobInput = await this.getJobInput(input);
-    const strategy = getAiProviderRegistry().getStrategy(model);
-    const outSchema = this.outputSchema();
-    const ports = getStreamingPorts(outSchema);
-    let defaultPort = "text";
-    if (ports.length > 0) {
-      defaultPort = ports[0].port;
-    } else {
-      if (typeof outSchema === "object" && outSchema.properties) {
-        const firstProp = Object.keys(outSchema.properties)[0];
-        if (firstProp)
-          defaultPort = firstProp;
-      }
-    }
-    for await (const event of strategy.executeStream(jobInput, context, this.runConfig.runnerId)) {
-      if (event.type === "text-delta") {
-        yield { ...event, port: event.port ?? defaultPort };
-      } else if (event.type === "object-delta") {
-        yield { ...event, port: event.port ?? defaultPort };
-      } else {
-        yield event;
-      }
-    }
-  }
-}
-
-// src/task/ToolCallingTask.ts
-function taskTypesToTools(taskNames, registry) {
-  const constructors = getTaskConstructors(registry);
-  return taskNames.map((name) => {
-    const ctor = constructors.get(name);
-    if (!ctor) {
-      throw new Error(`taskTypesToTools: Unknown task type "${name}" — not found in task constructors registry (ServiceRegistry: ${registry ? "custom" : "default"})`);
-    }
-    const configSchema = "configSchema" in ctor && typeof ctor.configSchema === "function" ? ctor.configSchema() : undefined;
-    return {
-      name: ctor.type,
-      description: ctor.description ?? "",
-      inputSchema: ctor.inputSchema(),
-      outputSchema: ctor.outputSchema(),
-      ...configSchema ? { configSchema } : {},
-      taskType: name
-    };
-  });
-}
-var ToolDefinitionSchema = {
-  type: "object",
-  properties: {
-    name: {
-      type: "string",
-      title: "Name",
-      description: "The tool name"
-    },
-    description: {
-      type: "string",
-      title: "Description",
-      description: "A description of what the tool does"
-    },
-    inputSchema: {
-      type: "object",
-      title: "Input Schema",
-      description: "JSON Schema describing the tool's input parameters",
-      additionalProperties: true
-    },
-    outputSchema: {
-      type: "object",
-      title: "Output Schema",
-      description: "JSON Schema describing what the tool returns",
-      additionalProperties: true
-    },
-    configSchema: {
-      type: "object",
-      title: "Config Schema",
-      description: "JSON Schema describing the task's configuration options (not sent to the LLM)",
-      additionalProperties: true
-    },
-    config: {
-      type: "object",
-      title: "Config",
-      description: "Concrete configuration values for the backing task (not sent to the LLM)",
-      additionalProperties: true
-    }
-  },
-  required: ["name", "description", "inputSchema"],
-  additionalProperties: true
-};
-var ToolCallSchema = {
-  type: "object",
-  properties: {
-    id: {
-      type: "string",
-      title: "ID",
-      description: "Unique identifier for this tool call"
-    },
-    name: {
-      type: "string",
-      title: "Name",
-      description: "The name of the tool to invoke"
-    },
-    input: {
-      type: "object",
-      title: "Input",
-      description: "The input arguments for the tool call",
-      additionalProperties: true
-    }
-  },
-  required: ["id", "name", "input"],
-  additionalProperties: false
-};
-var modelSchema = TypeModel("model:ToolCallingTask");
-var ToolCallingInputSchema = {
-  type: "object",
-  properties: {
-    model: modelSchema,
-    prompt: {
-      oneOf: [
-        { type: "string", title: "Prompt", description: "The prompt to send to the model" },
-        {
-          type: "array",
-          title: "Prompt",
-          description: "The prompt as an array of strings or content blocks",
-          items: {
-            oneOf: [
-              { type: "string" },
-              {
-                type: "object",
-                properties: {
-                  type: { type: "string", enum: ["text", "image", "audio"] }
-                },
-                required: ["type"],
-                additionalProperties: true
-              }
-            ]
-          }
-        }
-      ],
-      title: "Prompt",
-      description: "The prompt to send to the model"
-    },
-    systemPrompt: {
-      type: "string",
-      title: "System Prompt",
-      description: "Optional system instructions for the model"
-    },
-    messages: {
-      type: "array",
-      title: "Messages",
-      description: "Full conversation history for multi-turn interactions. When provided, used instead of prompt to construct the messages array sent to the provider.",
-      items: {
-        type: "object",
-        properties: {
-          role: { type: "string", enum: ["user", "assistant", "tool"] },
-          content: {}
-        },
-        required: ["role", "content"],
-        additionalProperties: true
-      }
-    },
-    tools: {
-      type: "array",
-      format: "tasks",
-      title: "Tools",
-      description: "Tool definitions available for the model to call",
-      items: {
-        oneOf: [
-          { type: "string", format: "tasks", description: "Task type name" },
-          ToolDefinitionSchema
-        ]
-      }
-    },
-    toolChoice: {
-      type: "string",
-      title: "Tool Choice",
-      description: 'Controls tool selection: "auto" (model decides), "none" (no tools), "required" (must call a tool), or a specific tool name',
-      "x-ui-group": "Configuration"
-    },
-    maxTokens: {
-      type: "number",
-      title: "Max Tokens",
-      description: "The maximum number of tokens to generate",
-      minimum: 1,
-      "x-ui-group": "Configuration"
-    },
-    temperature: {
-      type: "number",
-      title: "Temperature",
-      description: "The temperature to use for sampling",
-      minimum: 0,
-      maximum: 2,
-      "x-ui-group": "Configuration"
-    }
-  },
-  required: ["model", "prompt", "tools"],
-  additionalProperties: false
-};
-var ToolCallingOutputSchema = {
-  type: "object",
-  properties: {
-    text: {
-      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;
-  }
-}
-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 {};
-  }
-  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}"`);
-        })
-      });
-    } 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
-    };
-  }
-  let effectiveCall = toolCall;
-  if (hooks?.beforeToolCall) {
-    const decision = await hooks.beforeToolCall(toolCall, source);
-    if (decision.action === "deny") {
-      return {
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        output: { error: decision.reason ?? "Tool call denied by hook" },
-        isError: true
-      };
-    }
-    if (decision.action === "modify") {
-      effectiveCall = { ...toolCall, input: decision.input };
-    }
-  }
-  try {
-    let output;
-    switch (source.type) {
-      case "registry": {
-        const ctor = getTaskConstructors2(context.registry).get(source.taskType);
-        if (!ctor) {
-          throw new Error(`Task type "${source.taskType}" not found in TaskRegistry`);
-        }
-        const taskConfig = source.config ?? {};
-        const task = context.own(new ctor({}, taskConfig));
-        output = await task.run(effectiveCall.input) ?? {};
-        break;
-      }
-      case "function": {
-        output = await source.run(effectiveCall.input);
-        break;
-      }
-    }
-    let result = {
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      output,
-      isError: false
-    };
-    if (hooks?.afterToolCall) {
-      result = await hooks.afterToolCall(toolCall, result);
-    }
-    return result;
-  } catch (err) {
-    const error = err instanceof Error ? err : new Error(String(err));
-    if (hooks?.onToolError) {
-      const action = await hooks.onToolError(toolCall, error);
-      if (action.action === "result") {
-        return {
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          output: action.output,
-          isError: false
-        };
-      }
-    }
-    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 getDefaultQueueName(input) {
+    const model = input.model;
+    return model?.provider;
   }
-  async execute(input, context) {
-    let result;
-    for await (const event of this.agentLoop(input, context)) {
-      if (event.type === "finish") {
-        result = event.data;
+  async executeReactive(input, output, context) {
+    const model = input.model;
+    if (model && typeof model === "object" && model.provider) {
+      const taskType = this.constructor.runtype ?? this.constructor.type;
+      const reactiveFn = getAiProviderRegistry().getReactiveRunFn(model.provider, taskType);
+      if (reactiveFn) {
+        return reactiveFn(input, output, model);
       }
     }
-    if (!result) {
-      throw new Error("AgentTask: loop ended without producing output");
-    }
-    return result;
+    return super.executeReactive(input, output, context);
   }
-  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;
-          }
-        }
+  async validateInput(input) {
+    const inputSchema = this.inputSchema();
+    if (typeof inputSchema === "boolean") {
+      if (inputSchema === false) {
+        throw new TaskConfigurationError2(`AiTask: Input schema is 'false' and accepts no inputs`);
       }
-      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;
+      return true;
+    }
+    const modelTaskProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema)?.startsWith("model:"));
+    for (const [key] of modelTaskProperties) {
+      const model = input[key];
+      if (typeof model === "object" && model !== null) {
+        const tasks = model.tasks;
+        if (Array.isArray(tasks) && tasks.length > 0 && !tasks.includes(this.type)) {
+          const modelId = model.model_id ?? "(inline config)";
+          throw new TaskConfigurationError2(`AiTask: Model "${modelId}" for '${key}' is not compatible with task '${this.type}'. ` + `Model supports: [${tasks.join(", ")}]`);
         }
+      } else if (model !== undefined && model !== null) {
+        throw new TaskConfigurationError2(`AiTask: Invalid model for '${key}' - expected ModelConfig object but got ${typeof model}. ` + `Ensure the model ID was registered in the ModelRepository before running the task.`);
       }
-      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 }
-      });
+    const modelPlainProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema) === "model");
+    for (const [key] of modelPlainProperties) {
+      const model = input[key];
+      if (model !== undefined && model !== null && typeof model !== "object") {
+        throw new TaskConfigurationError2(`AiTask: Invalid model for '${key}' - expected ModelConfig object but got ${typeof model}. ` + `Ensure the model ID was registered in the ModelRepository before running the task.`);
+      }
     }
-    return defs;
+    return super.validateInput(input);
   }
-  trimMessages(messages, maxContextMessages) {
-    if (!maxContextMessages || messages.length <= maxContextMessages) {
-      return messages;
+  async narrowInput(input, registry) {
+    const inputSchema = this.inputSchema();
+    if (typeof inputSchema === "boolean") {
+      if (inputSchema === false) {
+        throw new TaskConfigurationError2(`AiTask: Input schema is 'false' and accepts no inputs`);
+      }
+      return input;
     }
-    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;
+    const modelTaskProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema)?.startsWith("model:"));
+    if (modelTaskProperties.length > 0) {
+      const modelRepo = registry.get(MODEL_REPOSITORY);
+      const taskModels = await modelRepo.findModelsByTask(this.type) ?? [];
+      for (const [key] of modelTaskProperties) {
+        const requestedModel = input[key];
+        if (typeof requestedModel === "string") {
+          const found = taskModels?.find((m) => m.model_id === requestedModel);
+          if (!found) {
+            input[key] = undefined;
+          }
+        } else if (typeof requestedModel === "object" && requestedModel !== null) {
+          const model = requestedModel;
+          const tasks = model.tasks;
+          if (Array.isArray(tasks) && tasks.length > 0 && !tasks.includes(this.type)) {
+            input[key] = undefined;
+          }
+        }
+      }
     }
-    return [messages[0], ...tail.slice(startIdx)];
+    return input;
   }
 }
-var agent = (input, config) => {
-  return new AgentTask(config).run(input);
-};
-Workflow2.prototype.agent = CreateWorkflow2(AgentTask);
-
-// src/task/BackgroundRemovalTask.ts
-import { CreateWorkflow as CreateWorkflow3, Workflow as Workflow3 } from "@workglow/task-graph";
 
 // src/task/base/AiVisionTask.ts
-import { convertImageDataToUseableForm } from "@workglow/util/media";
 class AiVisionTask extends AiTask {
   static type = "AiVisionTask";
   async getJobInput(input) {
@@ -1887,7 +1167,7 @@ class AiVisionTask extends AiTask {
 }
 
 // src/task/BackgroundRemovalTask.ts
-var modelSchema3 = TypeModel("model:BackgroundRemovalTask");
+var modelSchema = TypeModel("model:BackgroundRemovalTask");
 var processedImageSchema = {
   type: "string",
   contentEncoding: "base64",
@@ -1899,7 +1179,7 @@ var BackgroundRemovalInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema3
+    model: modelSchema
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -1928,22 +1208,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 modelSchema2 = TypeModel("model:TextEmbeddingTask");
 var TextEmbeddingInputSchema = {
   type: "object",
   properties: {
@@ -1952,7 +1232,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema4
+    model: modelSchema2
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1984,7 +1264,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 = {
@@ -2109,7 +1389,7 @@ var outputSchema = {
   additionalProperties: false
 };
 
-class ChunkRetrievalTask extends Task3 {
+class ChunkRetrievalTask extends Task2 {
   static type = "ChunkRetrievalTask";
   static category = "RAG";
   static title = "Chunk Retrieval";
@@ -2176,11 +1456,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";
@@ -2255,7 +1535,7 @@ var outputSchema2 = {
   additionalProperties: false
 };
 
-class ChunkToVectorTask extends Task4 {
+class ChunkToVectorTask extends Task3 {
   static type = "ChunkToVectorTask";
   static category = "Document";
   static title = "Chunk to Vector";
@@ -2306,11 +1586,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";
@@ -2423,7 +1703,7 @@ var outputSchema3 = {
   additionalProperties: false
 };
 
-class ChunkVectorHybridSearchTask extends Task5 {
+class ChunkVectorHybridSearchTask extends Task4 {
   static type = "ChunkVectorHybridSearchTask";
   static category = "RAG";
   static title = "Hybrid Search";
@@ -2476,11 +1756,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";
@@ -2563,7 +1843,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";
@@ -2595,11 +1875,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";
@@ -2653,7 +1933,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";
@@ -2713,15 +1993,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 modelSchema3 = TypeModel("model");
 var CountTokensInputSchema = {
   type: "object",
   properties: {
@@ -2730,7 +2010,7 @@ var CountTokensInputSchema = {
       title: "Text",
       description: "The text to count tokens for"
     },
-    model: modelSchema5
+    model: modelSchema3
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2764,7 +2044,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 = {
@@ -2774,7 +2054,7 @@ var ContextFormat = {
   MARKDOWN: "markdown",
   JSON: "json"
 };
-var modelSchema6 = TypeModel("model", {
+var modelSchema4 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting (optional, falls back to estimation)"
 });
@@ -2838,7 +2118,7 @@ var inputSchema6 = {
 
 `
     },
-    model: modelSchema6
+    model: modelSchema4
   },
   required: ["chunks"],
   additionalProperties: false
@@ -2871,7 +2151,7 @@ var outputSchema6 = {
   additionalProperties: false
 };
 
-class ContextBuilderTask extends Task8 {
+class ContextBuilderTask extends Task7 {
   static type = "ContextBuilderTask";
   static category = "RAG";
   static title = "Context Builder";
@@ -3064,15 +2344,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 modelSchema5 = TypeModel("model:TextNamedEntityRecognitionTask");
 var TextNamedEntityRecognitionInputSchema = {
   type: "object",
   properties: {
@@ -3091,7 +2371,7 @@ var TextNamedEntityRecognitionInputSchema = {
       "x-ui-group": "Configuration",
       "x-ui-group-open": false
     },
-    model: modelSchema7
+    model: modelSchema5
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -3146,11 +2426,48 @@ 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 CreateWorkflow11, Workflow as Workflow11 } from "@workglow/task-graph";
+
+// src/task/base/StreamingAiTask.ts
+import { getStreamingPorts, TaskConfigurationError as TaskConfigurationError3 } from "@workglow/task-graph";
+class StreamingAiTask extends AiTask {
+  static type = "StreamingAiTask";
+  async* executeStream(input, context) {
+    const model = input.model;
+    if (!model || typeof model !== "object") {
+      throw new TaskConfigurationError3("StreamingAiTask: Model was not resolved to ModelConfig - this indicates a bug in the resolution system");
+    }
+    const jobInput = await this.getJobInput(input);
+    const strategy = getAiProviderRegistry().getStrategy(model);
+    const outSchema = this.outputSchema();
+    const ports = getStreamingPorts(outSchema);
+    let defaultPort = "text";
+    if (ports.length > 0) {
+      defaultPort = ports[0].port;
+    } else {
+      if (typeof outSchema === "object" && outSchema.properties) {
+        const firstProp = Object.keys(outSchema.properties)[0];
+        if (firstProp)
+          defaultPort = firstProp;
+      }
+    }
+    for await (const event of strategy.executeStream(jobInput, context, this.runConfig.runnerId)) {
+      if (event.type === "text-delta") {
+        yield { ...event, port: event.port ?? defaultPort };
+      } else if (event.type === "object-delta") {
+        yield { ...event, port: event.port ?? defaultPort };
+      } else {
+        yield event;
+      }
+    }
+  }
+}
 
 // src/task/TextSummaryTask.ts
-import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
-var modelSchema8 = TypeModel("model:TextSummaryTask");
+var modelSchema6 = TypeModel("model:TextSummaryTask");
 var TextSummaryInputSchema = {
   type: "object",
   properties: {
@@ -3159,7 +2476,7 @@ var TextSummaryInputSchema = {
       title: "Text",
       description: "The text to summarize"
     },
-    model: modelSchema8
+    model: modelSchema6
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -3193,7 +2510,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 = {
@@ -3267,7 +2584,7 @@ var outputSchema7 = {
   additionalProperties: false
 };
 
-class DocumentEnricherTask extends Task9 {
+class DocumentEnricherTask extends Task8 {
   static type = "DocumentEnricherTask";
   static category = "Document";
   static title = "Document Enricher";
@@ -3426,12 +2743,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: {
@@ -3476,7 +2793,7 @@ var outputSchema8 = {
   additionalProperties: false
 };
 
-class DocumentUpsertTask extends Task10 {
+class DocumentUpsertTask extends Task9 {
   static type = "DocumentUpsertTask";
   static category = "Vector Store";
   static title = "Add Document";
@@ -3509,15 +2826,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 modelSchema7 = TypeModel("model");
 var DownloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema9
+    model: modelSchema7
   },
   required: ["model"],
   additionalProperties: false
@@ -3525,7 +2842,7 @@ var DownloadModelInputSchema = {
 var DownloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema9
+    model: modelSchema7
   },
   required: ["model"],
   additionalProperties: false
@@ -3579,11 +2896,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 modelSchema8 = TypeModel("model:FaceDetectorTask");
 var TypeBoundingBox2 = {
   type: "object",
   properties: {
@@ -3656,7 +2973,7 @@ var FaceDetectorInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema10,
+    model: modelSchema8,
     minDetectionConfidence: {
       type: "number",
       minimum: 0,
@@ -3710,11 +3027,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 modelSchema9 = TypeModel("model:FaceLandmarkerTask");
 var TypeLandmark = {
   type: "object",
   properties: {
@@ -3786,7 +3103,7 @@ var FaceLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema11,
+    model: modelSchema9,
     numFaces: {
       type: "number",
       minimum: 1,
@@ -3872,11 +3189,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 modelSchema10 = TypeModel("model:GestureRecognizerTask");
 var TypeLandmark2 = {
   type: "object",
   properties: {
@@ -3968,7 +3285,7 @@ var GestureRecognizerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema12,
+    model: modelSchema10,
     numHands: {
       type: "number",
       minimum: 1,
@@ -4040,11 +3357,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 modelSchema11 = TypeModel("model:HandLandmarkerTask");
 var TypeLandmark3 = {
   type: "object",
   properties: {
@@ -4113,7 +3430,7 @@ var HandLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema13,
+    model: modelSchema11,
     numHands: {
       type: "number",
       minimum: 1,
@@ -4185,7 +3502,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 {
@@ -4194,9 +3511,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 modelSchema12 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting"
 });
@@ -4242,7 +3559,7 @@ var inputSchema9 = {
       description: "Strategy for chunking",
       default: "hierarchical"
     },
-    model: modelSchema14
+    model: modelSchema12
   },
   required: ["doc_id", "documentTree"],
   additionalProperties: false
@@ -4277,7 +3594,7 @@ var outputSchema9 = {
   additionalProperties: false
 };
 
-class HierarchicalChunkerTask extends Task11 {
+class HierarchicalChunkerTask extends Task10 {
   static type = "HierarchicalChunkerTask";
   static category = "Document";
   static title = "Hierarchical Chunker";
@@ -4421,11 +3738,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: {
@@ -4500,7 +3817,7 @@ var outputSchema10 = {
   additionalProperties: false
 };
 
-class HierarchyJoinTask extends Task12 {
+class HierarchyJoinTask extends Task11 {
   static type = "HierarchyJoinTask";
   static category = "RAG";
   static title = "Hierarchy Join";
@@ -4594,16 +3911,105 @@ 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 CreateWorkflow21, Task as Task12, Workflow as Workflow21 } from "@workglow/task-graph";
+var inputSchema11 = {
+  type: "object",
+  properties: {
+    knowledgeBase: TypeKnowledgeBase7({
+      title: "Knowledge Base",
+      description: "The knowledge base instance to list documents from"
+    }),
+    onlyStale: {
+      type: "boolean",
+      title: "Only Stale",
+      description: "If true, only return documents that have no chunks (need embedding)",
+      default: true
+    }
+  },
+  required: ["knowledgeBase"],
+  additionalProperties: false
+};
+var outputSchema11 = {
+  type: "object",
+  properties: {
+    doc_id: {
+      type: "array",
+      items: { type: "string" },
+      title: "Document IDs",
+      description: "Array of document IDs"
+    },
+    documentTree: {
+      type: "array",
+      items: { type: "object", additionalProperties: true },
+      title: "Document Trees",
+      description: "Array of document root nodes (parallel to doc_id)"
+    },
+    title: {
+      type: "array",
+      items: { type: "string" },
+      title: "Titles",
+      description: "Array of document titles (parallel to doc_id)"
+    }
+  },
+  required: ["doc_id", "documentTree", "title"],
+  additionalProperties: false
+};
+
+class KbToDocumentsTask extends Task12 {
+  static type = "KbToDocumentsTask";
+  static category = "Vector Store";
+  static title = "Knowledge Base to Documents";
+  static description = "List documents from a knowledge base, optionally filtering to only those that need embedding";
+  static cacheable = false;
+  static inputSchema() {
+    return inputSchema11;
+  }
+  static outputSchema() {
+    return outputSchema11;
+  }
+  async execute(input, context) {
+    const { knowledgeBase, onlyStale = true } = input;
+    const kb = knowledgeBase;
+    await context.updateProgress(1, "Listing documents");
+    const allDocIds = await kb.listDocuments();
+    const doc_id = [];
+    const documentTree = [];
+    const title = [];
+    for (const id of allDocIds) {
+      if (onlyStale) {
+        const chunks = await kb.getChunksForDocument(id);
+        if (chunks.length > 0) {
+          continue;
+        }
+      }
+      const doc = await kb.getDocument(id);
+      if (!doc) {
+        continue;
+      }
+      doc_id.push(id);
+      documentTree.push(doc.root);
+      title.push(doc.metadata.title);
+    }
+    return { doc_id, documentTree, title };
+  }
+}
+var kbToDocuments = (input, config) => {
+  return new KbToDocumentsTask(config).run(input);
+};
+Workflow21.prototype.kbToDocuments = CreateWorkflow21(KbToDocumentsTask);
 
 // src/task/ImageClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
-var modelSchema15 = TypeModel("model:ImageClassificationTask");
+import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
+var modelSchema13 = TypeModel("model:ImageClassificationTask");
 var ImageClassificationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema15,
+    model: modelSchema13,
     categories: {
       type: "array",
       items: {
@@ -4657,19 +4063,19 @@ class ImageClassificationTask extends AiVisionTask {
 var imageClassification = (input, config) => {
   return new ImageClassificationTask(config).run(input);
 };
-Workflow23.prototype.imageClassification = CreateWorkflow23(ImageClassificationTask);
+Workflow22.prototype.imageClassification = CreateWorkflow22(ImageClassificationTask);
 
 // src/task/ImageEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } 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 modelSchema14 = TypeModel("model:ImageEmbeddingTask");
 var ImageEmbeddingInputSchema = {
   type: "object",
   properties: {
     image: TypeSingleOrArray(TypeImageInput),
-    model: modelSchema16
+    model: modelSchema14
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -4701,16 +4107,16 @@ class ImageEmbeddingTask extends AiVisionTask {
 var imageEmbedding = (input, config) => {
   return new ImageEmbeddingTask(config).run(input);
 };
-Workflow24.prototype.imageEmbedding = CreateWorkflow24(ImageEmbeddingTask);
+Workflow23.prototype.imageEmbedding = CreateWorkflow23(ImageEmbeddingTask);
 
 // src/task/ImageSegmentationTask.ts
-import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
-var modelSchema17 = TypeModel("model:ImageSegmentationTask");
+import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
+var modelSchema15 = TypeModel("model:ImageSegmentationTask");
 var ImageSegmentationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema17,
+    model: modelSchema15,
     threshold: {
       type: "number",
       title: "Threshold",
@@ -4789,11 +4195,11 @@ class ImageSegmentationTask extends AiVisionTask {
 var imageSegmentation = (input, config) => {
   return new ImageSegmentationTask(config).run(input);
 };
-Workflow25.prototype.imageSegmentation = CreateWorkflow25(ImageSegmentationTask);
+Workflow24.prototype.imageSegmentation = CreateWorkflow24(ImageSegmentationTask);
 
 // src/task/ImageToTextTask.ts
-import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
-var modelSchema18 = TypeModel("model:ImageToTextTask");
+import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
+var modelSchema16 = TypeModel("model:ImageToTextTask");
 var generatedTextSchema = {
   type: "string",
   title: "Text",
@@ -4803,7 +4209,7 @@ var ImageToTextInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema18,
+    model: modelSchema16,
     maxTokens: {
       type: "number",
       title: "Max Tokens",
@@ -4844,18 +4250,18 @@ class ImageToTextTask extends AiVisionTask {
 var imageToText = (input, config) => {
   return new ImageToTextTask(config).run(input);
 };
-Workflow26.prototype.imageToText = CreateWorkflow26(ImageToTextTask);
+Workflow25.prototype.imageToText = CreateWorkflow25(ImageToTextTask);
 
 // src/task/ModelInfoTask.ts
-import { CreateWorkflow as CreateWorkflow27, Workflow as Workflow27 } from "@workglow/task-graph";
-var modelSchema19 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
+var modelSchema17 = TypeModel("model");
 var ModelInfoInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema19,
+    model: modelSchema17,
     detail: {
       type: "string",
-      enum: ["cached_status", "files", "files_with_metadata"],
+      enum: ["cached_status", "files", "files_with_metadata", "dimensions"],
       default: "files_with_metadata"
     }
   },
@@ -4865,7 +4271,7 @@ var ModelInfoInputSchema = {
 var ModelInfoOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema19,
+    model: modelSchema17,
     is_local: { type: "boolean" },
     is_remote: { type: "boolean" },
     supports_browser: { type: "boolean" },
@@ -4877,6 +4283,14 @@ var ModelInfoOutputSchema = {
       type: "array",
       items: { type: "string" },
       description: "Available quantization variants (e.g. fp32, fp16, q8). Only present for models with quantization options."
+    },
+    native_dimensions: {
+      type: "integer",
+      description: "Native output vector dimensions. Only present when detail is 'dimensions' and the provider can determine them."
+    },
+    mrl: {
+      type: "boolean",
+      description: "Whether the model supports Matryoshka Representation Learning. Only present when detail is 'dimensions'."
     }
   },
   required: [
@@ -4915,10 +4329,10 @@ class ModelInfoTask extends AiTask {
 var modelInfo = (input, config) => {
   return new ModelInfoTask(config).run(input);
 };
-Workflow27.prototype.modelInfo = CreateWorkflow27(ModelInfoTask);
+Workflow26.prototype.modelInfo = CreateWorkflow26(ModelInfoTask);
 
 // src/task/ModelSearchTask.ts
-import { CreateWorkflow as CreateWorkflow28, Task as Task13, Workflow as Workflow28 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow27, Task as Task13, Workflow as Workflow27 } from "@workglow/task-graph";
 var ModelSearchInputSchema = {
   type: "object",
   properties: {
@@ -5009,11 +4423,11 @@ class ModelSearchTask extends Task13 {
 var modelSearch = (input, config) => {
   return new ModelSearchTask(config).run(input);
 };
-Workflow28.prototype.modelSearch = CreateWorkflow28(ModelSearchTask);
+Workflow27.prototype.modelSearch = CreateWorkflow27(ModelSearchTask);
 
 // src/task/ObjectDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow29, Workflow as Workflow29 } from "@workglow/task-graph";
-var modelSchema20 = TypeModel("model:ObjectDetectionTask");
+import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
+var modelSchema18 = TypeModel("model:ObjectDetectionTask");
 var detectionSchema = {
   type: "object",
   properties: {
@@ -5038,7 +4452,7 @@ var ObjectDetectionInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema20,
+    model: modelSchema18,
     labels: {
       type: "array",
       items: {
@@ -5092,11 +4506,11 @@ class ObjectDetectionTask extends AiVisionTask {
 var objectDetection = (input, config) => {
   return new ObjectDetectionTask(config).run(input);
 };
-Workflow29.prototype.objectDetection = CreateWorkflow29(ObjectDetectionTask);
+Workflow28.prototype.objectDetection = CreateWorkflow28(ObjectDetectionTask);
 
 // src/task/PoseLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow30, Workflow as Workflow30 } from "@workglow/task-graph";
-var modelSchema21 = TypeModel("model:PoseLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow29, Workflow as Workflow29 } from "@workglow/task-graph";
+var modelSchema19 = TypeModel("model:PoseLandmarkerTask");
 var TypePoseLandmark = {
   type: "object",
   properties: {
@@ -5175,7 +4589,7 @@ var PoseLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema21,
+    model: modelSchema19,
     numPoses: {
       type: "number",
       minimum: 1,
@@ -5254,17 +4668,17 @@ class PoseLandmarkerTask extends AiVisionTask {
 var poseLandmarker = (input, config) => {
   return new PoseLandmarkerTask(config).run(input);
 };
-Workflow30.prototype.poseLandmarker = CreateWorkflow30(PoseLandmarkerTask);
+Workflow29.prototype.poseLandmarker = CreateWorkflow29(PoseLandmarkerTask);
 
 // src/task/QueryExpanderTask.ts
-import { CreateWorkflow as CreateWorkflow31, Task as Task14, Workflow as Workflow31 } 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",
   SYNONYMS: "synonyms",
   PARAPHRASE: "paraphrase"
 };
-var inputSchema11 = {
+var inputSchema12 = {
   type: "object",
   properties: {
     query: {
@@ -5296,7 +4710,7 @@ var inputSchema11 = {
   required: ["query"],
   additionalProperties: false
 };
-var outputSchema11 = {
+var outputSchema12 = {
   type: "object",
   properties: {
     query: {
@@ -5332,10 +4746,10 @@ class QueryExpanderTask extends Task14 {
   static description = "Expand queries to improve retrieval coverage";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema11;
+    return inputSchema12;
   }
   static outputSchema() {
-    return outputSchema11;
+    return outputSchema12;
   }
   async execute(input, context) {
     const { query, method = QueryExpansionMethod.MULTI_QUERY, numVariations = 3 } = input;
@@ -5467,14 +4881,14 @@ class QueryExpanderTask extends Task14 {
 var queryExpander = (input, config) => {
   return new QueryExpanderTask(config).run(input);
 };
-Workflow31.prototype.queryExpander = CreateWorkflow31(QueryExpanderTask);
+Workflow30.prototype.queryExpander = CreateWorkflow30(QueryExpanderTask);
 
 // src/task/RerankerTask.ts
-import { CreateWorkflow as CreateWorkflow33, Task as Task15, Workflow as Workflow33 } 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 CreateWorkflow32, Workflow as Workflow32 } from "@workglow/task-graph";
-var modelSchema22 = TypeModel("model:TextClassificationTask");
+import { CreateWorkflow as CreateWorkflow31, Workflow as Workflow31 } from "@workglow/task-graph";
+var modelSchema20 = TypeModel("model:TextClassificationTask");
 var TextClassificationInputSchema = {
   type: "object",
   properties: {
@@ -5501,7 +4915,7 @@ var TextClassificationInputSchema = {
       description: "The maximum number of categories to return",
       "x-ui-group": "Configuration"
     },
-    model: modelSchema22
+    model: modelSchema20
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5551,10 +4965,10 @@ class TextClassificationTask extends AiTask {
 var textClassification = (input, config) => {
   return new TextClassificationTask(config).run(input);
 };
-Workflow32.prototype.textClassification = CreateWorkflow32(TextClassificationTask);
+Workflow31.prototype.textClassification = CreateWorkflow31(TextClassificationTask);
 
 // src/task/RerankerTask.ts
-var inputSchema12 = {
+var inputSchema13 = {
   type: "object",
   properties: {
     query: {
@@ -5605,7 +5019,7 @@ var inputSchema12 = {
   required: ["query", "chunks"],
   additionalProperties: false
 };
-var outputSchema12 = {
+var outputSchema13 = {
   type: "object",
   properties: {
     chunks: {
@@ -5653,10 +5067,10 @@ class RerankerTask extends Task15 {
   static description = "Rerank retrieved chunks to improve relevance";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema12;
+    return inputSchema13;
   }
   static outputSchema() {
-    return outputSchema12;
+    return outputSchema13;
   }
   async execute(input, context) {
     const { query, chunks, scores = [], metadata = [], topK, method = "simple", model } = input;
@@ -5774,13 +5188,13 @@ class RerankerTask extends Task15 {
 var reranker = (input, config) => {
   return new RerankerTask(config).run(input);
 };
-Workflow33.prototype.reranker = CreateWorkflow33(RerankerTask);
+Workflow32.prototype.reranker = CreateWorkflow32(RerankerTask);
 
 // src/task/StructuralParserTask.ts
 import { StructuralParser } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow34, Task as Task16, Workflow as Workflow34 } 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 inputSchema13 = {
+var inputSchema14 = {
   type: "object",
   properties: {
     text: {
@@ -5814,7 +5228,7 @@ var inputSchema13 = {
   required: ["text", "title"],
   additionalProperties: false
 };
-var outputSchema13 = {
+var outputSchema14 = {
   type: "object",
   properties: {
     doc_id: {
@@ -5845,10 +5259,10 @@ class StructuralParserTask extends Task16 {
   static description = "Parse documents into hierarchical tree structure";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema13;
+    return inputSchema14;
   }
   static outputSchema() {
-    return outputSchema13;
+    return outputSchema14;
   }
   async execute(input, context) {
     const { text, title, format = "auto", sourceUri, doc_id: providedDocId } = input;
@@ -5881,15 +5295,15 @@ class StructuralParserTask extends Task16 {
 var structuralParser = (input, config) => {
   return new StructuralParserTask(config).run(input);
 };
-Workflow34.prototype.structuralParser = CreateWorkflow34(StructuralParserTask);
+Workflow33.prototype.structuralParser = CreateWorkflow33(StructuralParserTask);
 
 // src/task/StructuredGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow35, Workflow as Workflow35 } from "@workglow/task-graph";
-var modelSchema23 = TypeModel("model:StructuredGenerationTask");
+import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
+var modelSchema21 = TypeModel("model:StructuredGenerationTask");
 var StructuredGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema23,
+    model: modelSchema21,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5952,17 +5366,17 @@ class StructuredGenerationTask extends StreamingAiTask {
 var structuredGeneration = (input, config) => {
   return new StructuredGenerationTask(config).run(input);
 };
-Workflow35.prototype.structuredGeneration = CreateWorkflow35(StructuredGenerationTask);
+Workflow34.prototype.structuredGeneration = CreateWorkflow34(StructuredGenerationTask);
 
 // src/task/TextChunkerTask.ts
-import { CreateWorkflow as CreateWorkflow36, Task as Task17, Workflow as Workflow36 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow35, Task as Task17, Workflow as Workflow35 } from "@workglow/task-graph";
 var ChunkingStrategy = {
   FIXED: "fixed",
   SENTENCE: "sentence",
   PARAGRAPH: "paragraph",
   SEMANTIC: "semantic"
 };
-var inputSchema14 = {
+var inputSchema15 = {
   type: "object",
   properties: {
     text: {
@@ -5995,7 +5409,7 @@ var inputSchema14 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema14 = {
+var outputSchema15 = {
   type: "object",
   properties: {
     chunks: {
@@ -6031,10 +5445,10 @@ class TextChunkerTask extends Task17 {
   static description = "Splits text into chunks using various strategies (fixed, sentence, paragraph)";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema14;
+    return inputSchema15;
   }
   static outputSchema() {
-    return outputSchema14;
+    return outputSchema15;
   }
   async execute(input, context) {
     const { text, chunkSize = 512, chunkOverlap = 50, strategy = ChunkingStrategy.FIXED } = input;
@@ -6204,11 +5618,11 @@ class TextChunkerTask extends Task17 {
 var textChunker = (input, config) => {
   return new TextChunkerTask(config).run(input);
 };
-Workflow36.prototype.textChunker = CreateWorkflow36(TextChunkerTask);
+Workflow35.prototype.textChunker = CreateWorkflow35(TextChunkerTask);
 
 // src/task/TextFillMaskTask.ts
-import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
-var modelSchema24 = TypeModel("model:TextFillMaskTask");
+import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
+var modelSchema22 = TypeModel("model:TextFillMaskTask");
 var TextFillMaskInputSchema = {
   type: "object",
   properties: {
@@ -6217,7 +5631,7 @@ var TextFillMaskInputSchema = {
       title: "Text",
       description: "The text with a mask token to fill"
     },
-    model: modelSchema24
+    model: modelSchema22
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -6272,21 +5686,21 @@ class TextFillMaskTask extends AiTask {
 var textFillMask = (input, config) => {
   return new TextFillMaskTask(config).run(input);
 };
-Workflow37.prototype.textFillMask = CreateWorkflow37(TextFillMaskTask);
+Workflow36.prototype.textFillMask = CreateWorkflow36(TextFillMaskTask);
 
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } 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 modelSchema23 = TypeModel("model:TextGenerationTask");
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema25,
+    model: modelSchema23,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -6360,11 +5774,11 @@ class TextGenerationTask extends StreamingAiTask {
 var textGeneration = (input, config) => {
   return new TextGenerationTask(config).run(input);
 };
-Workflow38.prototype.textGeneration = CreateWorkflow38(TextGenerationTask);
+Workflow37.prototype.textGeneration = CreateWorkflow37(TextGenerationTask);
 
 // src/task/TextLanguageDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
-var modelSchema26 = TypeModel("model:TextLanguageDetectionTask");
+import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
+var modelSchema24 = TypeModel("model:TextLanguageDetectionTask");
 var TextLanguageDetectionInputSchema = {
   type: "object",
   properties: {
@@ -6381,7 +5795,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema26
+    model: modelSchema24
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -6431,10 +5845,10 @@ class TextLanguageDetectionTask extends AiTask {
 var textLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask(config).run(input);
 };
-Workflow39.prototype.textLanguageDetection = CreateWorkflow39(TextLanguageDetectionTask);
+Workflow38.prototype.textLanguageDetection = CreateWorkflow38(TextLanguageDetectionTask);
 
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
 var contextSchema = {
   type: "string",
   title: "Context",
@@ -6451,13 +5865,13 @@ var textSchema = {
   description: "The generated text",
   "x-stream": "append"
 };
-var modelSchema27 = TypeModel("model:TextQuestionAnswerTask");
+var modelSchema25 = TypeModel("model:TextQuestionAnswerTask");
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: contextSchema,
     question: questionSchema,
-    model: modelSchema27
+    model: modelSchema25
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -6486,11 +5900,11 @@ class TextQuestionAnswerTask extends StreamingAiTask {
 var textQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask(config).run(input);
 };
-Workflow40.prototype.textQuestionAnswer = CreateWorkflow40(TextQuestionAnswerTask);
+Workflow39.prototype.textQuestionAnswer = CreateWorkflow39(TextQuestionAnswerTask);
 
 // src/task/TextRewriterTask.ts
-import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
-var modelSchema28 = TypeModel("model:TextRewriterTask");
+import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
+var modelSchema26 = TypeModel("model:TextRewriterTask");
 var TextRewriterInputSchema = {
   type: "object",
   properties: {
@@ -6504,7 +5918,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     },
-    model: modelSchema28
+    model: modelSchema26
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -6538,11 +5952,11 @@ class TextRewriterTask extends StreamingAiTask {
 var textRewriter = (input, config) => {
   return new TextRewriterTask(config).run(input);
 };
-Workflow41.prototype.textRewriter = CreateWorkflow41(TextRewriterTask);
+Workflow40.prototype.textRewriter = CreateWorkflow40(TextRewriterTask);
 
 // src/task/TextTranslationTask.ts
-import { CreateWorkflow as CreateWorkflow42, Workflow as Workflow42 } from "@workglow/task-graph";
-var modelSchema29 = TypeModel("model:TextTranslationTask");
+import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
+var modelSchema27 = TypeModel("model:TextTranslationTask");
 var translationTextSchema = {
   type: "string",
   title: "Text",
@@ -6569,7 +5983,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     }),
-    model: modelSchema29
+    model: modelSchema27
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -6604,7 +6018,250 @@ class TextTranslationTask extends StreamingAiTask {
 var textTranslation = (input, config) => {
   return new TextTranslationTask(config).run(input);
 };
-Workflow42.prototype.textTranslation = CreateWorkflow42(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 modelSchema28 = TypeModel("model:ToolCallingTask");
+var ToolCallingInputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema28,
+    prompt: {
+      oneOf: [
+        { type: "string", title: "Prompt", description: "The prompt to send to the model" },
+        {
+          type: "array",
+          title: "Prompt",
+          description: "The prompt as an array of strings or content blocks",
+          items: {
+            oneOf: [
+              { type: "string" },
+              {
+                type: "object",
+                properties: {
+                  type: { type: "string", enum: ["text", "image", "audio"] }
+                },
+                required: ["type"],
+                additionalProperties: true
+              }
+            ]
+          }
+        }
+      ],
+      title: "Prompt",
+      description: "The prompt to send to the model"
+    },
+    systemPrompt: {
+      type: "string",
+      title: "System Prompt",
+      description: "Optional system instructions for the model"
+    },
+    messages: {
+      type: "array",
+      title: "Messages",
+      description: "Full conversation history for multi-turn interactions. When provided, used instead of prompt to construct the messages array sent to the provider.",
+      items: {
+        type: "object",
+        properties: {
+          role: { type: "string", enum: ["user", "assistant", "tool"] },
+          content: {}
+        },
+        required: ["role", "content"],
+        additionalProperties: true
+      }
+    },
+    tools: {
+      type: "array",
+      format: "tasks",
+      title: "Tools",
+      description: "Tool definitions available for the model to call",
+      items: {
+        oneOf: [
+          { type: "string", format: "tasks", description: "Task type name" },
+          ToolDefinitionSchema
+        ]
+      }
+    },
+    toolChoice: {
+      type: "string",
+      title: "Tool Choice",
+      description: 'Controls tool selection: "auto" (model decides), "none" (no tools), "required" (must call a tool), or a specific tool name',
+      "x-ui-group": "Configuration"
+    },
+    maxTokens: {
+      type: "number",
+      title: "Max Tokens",
+      description: "The maximum number of tokens to generate",
+      minimum: 1,
+      "x-ui-group": "Configuration"
+    },
+    temperature: {
+      type: "number",
+      title: "Temperature",
+      description: "The temperature to use for sampling",
+      minimum: 0,
+      maximum: 2,
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["model", "prompt", "tools"],
+  additionalProperties: false
+};
+var ToolCallingOutputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      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 CreateWorkflow43, Task as Task18, Workflow as Workflow43 } from "@workglow/task-graph";
@@ -6613,7 +6270,7 @@ var SegmentationMethod = {
   EMBEDDING_SIMILARITY: "embedding-similarity",
   HYBRID: "hybrid"
 };
-var inputSchema15 = {
+var inputSchema16 = {
   type: "object",
   properties: {
     text: {
@@ -6654,7 +6311,7 @@ var inputSchema15 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema15 = {
+var outputSchema16 = {
   type: "object",
   properties: {
     segments: {
@@ -6690,10 +6347,10 @@ class TopicSegmenterTask extends Task18 {
   static cacheable = true;
   static EMBEDDING_DIMENSIONS = 256;
   static inputSchema() {
-    return inputSchema15;
+    return inputSchema16;
   }
   static outputSchema() {
-    return outputSchema15;
+    return outputSchema16;
   }
   async execute(input, context) {
     const {
@@ -6891,11 +6548,11 @@ Workflow43.prototype.topicSegmenter = CreateWorkflow43(TopicSegmenterTask);
 
 // src/task/UnloadModelTask.ts
 import { CreateWorkflow as CreateWorkflow44, Workflow as Workflow44 } from "@workglow/task-graph";
-var modelSchema30 = TypeModel("model");
+var modelSchema29 = TypeModel("model");
 var UnloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema30
+    model: modelSchema29
   },
   required: ["model"],
   additionalProperties: false
@@ -6903,7 +6560,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema30
+    model: modelSchema29
   },
   required: ["model"],
   additionalProperties: false
@@ -6934,7 +6591,7 @@ import {
   TensorType,
   TypedArraySchema as TypedArraySchema8
 } from "@workglow/util/schema";
-var inputSchema16 = {
+var inputSchema17 = {
   type: "object",
   properties: {
     vector: {
@@ -6971,7 +6628,7 @@ var inputSchema16 = {
   required: ["vector", "targetType"],
   additionalProperties: false
 };
-var outputSchema16 = {
+var outputSchema17 = {
   type: "object",
   properties: {
     vector: {
@@ -7015,10 +6672,10 @@ class VectorQuantizeTask extends Task19 {
   static description = "Quantize vectors to reduce storage and improve performance";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema16;
+    return inputSchema17;
   }
   static outputSchema() {
-    return outputSchema16;
+    return outputSchema17;
   }
   async executeReactive(input) {
     const { vector, targetType, normalize = true } = input;
@@ -7218,6 +6875,7 @@ var similarity = (input, config) => {
   return new VectorSimilarityTask(config).run(input);
 };
 Workflow46.prototype.similarity = CreateWorkflow46(VectorSimilarityTask);
+
 // src/task/MessageConversion.ts
 function getInputMessages(input) {
   const messages = input.messages;
@@ -7418,7 +7076,6 @@ function toTextFlatMessages(input) {
 // src/task/index.ts
 var registerAiTasks = () => {
   const tasks = [
-    AgentTask,
     BackgroundRemovalTask,
     ChunkToVectorTask,
     CountTokensTask,
@@ -7436,6 +7093,7 @@ var registerAiTasks = () => {
     HandLandmarkerTask,
     HierarchicalChunkerTask,
     HierarchyJoinTask,
+    KbToDocumentsTask,
     ImageClassificationTask,
     ImageEmbeddingTask,
     ImageSegmentationTask,
@@ -7471,11 +7129,8 @@ var registerAiTasks = () => {
 export {
   vectorStoreSearch,
   vectorQuantize,
-  userMessage,
   unloadModel,
   topicSegmenter,
-  toolSourceDefinitions,
-  toolMessage,
   toolCalling,
   toTextFlatMessages,
   toOpenAIMessages,
@@ -7504,43 +7159,32 @@ export {
   objectDetection,
   modelSearch,
   modelInfo,
+  kbToDocuments,
   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,
@@ -7614,6 +7258,7 @@ export {
   ModelInfoTask,
   ModelConfigSchema,
   MODEL_REPOSITORY,
+  KbToDocumentsTask,
   InMemoryModelRepository,
   ImageToTextTask,
   ImageToTextOutputSchema,
@@ -7645,6 +7290,7 @@ export {
   DocumentUpsertTask,
   DocumentEnricherTask,
   DirectExecutionStrategy,
+  DEFAULT_AI_PROVIDER_WORKER_IDLE_TIMEOUT_MS,
   CountTokensTask,
   CountTokensOutputSchema,
   CountTokensInputSchema,
@@ -7662,10 +7308,7 @@ export {
   AiTask,
   AiProviderRegistry,
   AiProvider,
-  AiJob,
-  AgentTask,
-  AgentOutputSchema,
-  AgentInputSchema
+  AiJob
 };
 
-//# debugId=E87783958D33A7FE64756E2164756E21
+//# debugId=44C200F7AF4AF24D64756E2164756E21