@workglow/ai 0.1.2 → 0.2.1

package/dist/browser.js

@@ -4,7 +4,8 @@ import {
   Job,
   JobStatus,
   PermanentJobError,
-  RetryableJobError
+  RetryableJobError,
+  withJobErrorDiagnostics
 } from "@workglow/job-queue";
 import { getLogger } from "@workglow/util/worker";
 
@@ -137,16 +138,13 @@ function setAiProviderRegistry(pr) {
 
 // src/job/AiJob.ts
 var DEFAULT_AI_TIMEOUT_MS = 120000;
-var LOCAL_MODEL_DEFAULT_TIMEOUT_MS = 600000;
+var LOCAL_INFERENCE_DEFAULT_TIMEOUT_MS = 300000;
 function resolveAiJobTimeoutMs(aiProvider, explicitMs) {
   if (explicitMs !== undefined) {
     return explicitMs;
   }
-  if (aiProvider === "LOCAL_LLAMACPP") {
-    return LOCAL_MODEL_DEFAULT_TIMEOUT_MS;
-  }
-  if (aiProvider === "HF_TRANSFORMERS_ONNX" || aiProvider.startsWith("HF_TRANSFORMERS_ONNX")) {
-    return LOCAL_MODEL_DEFAULT_TIMEOUT_MS;
+  if (aiProvider === "LOCAL_LLAMACPP" || aiProvider === "HF_TRANSFORMERS_ONNX") {
+    return LOCAL_INFERENCE_DEFAULT_TIMEOUT_MS;
   }
   return DEFAULT_AI_TIMEOUT_MS;
 }
@@ -159,39 +157,39 @@ function classifyProviderError(err, taskType, provider) {
     const m = message.match(/\b([45]\d{2})\b/);
     return m ? parseInt(m[1], 10) : undefined;
   })();
-  if (err instanceof DOMException && err.name === "AbortError") {
-    return new AbortSignalJobError(`Provider call aborted for ${taskType} (${provider})`);
+  if (err instanceof Error && err.name === "AbortError") {
+    return new AbortSignalJobError(withJobErrorDiagnostics(`Provider call aborted for ${taskType} (${provider})`, err));
   }
-  if (err instanceof DOMException && err.name === "TimeoutError") {
-    return new AbortSignalJobError(`Provider call timed out for ${taskType} (${provider})`);
+  if (err instanceof Error && err.name === "TimeoutError") {
+    return new AbortSignalJobError(withJobErrorDiagnostics(`Provider call timed out for ${taskType} (${provider})`, err));
   }
   if (message.includes("Pipeline download aborted") || message.includes("Operation aborted") || message.includes("operation was aborted") || message.includes("The operation was aborted")) {
-    return new AbortSignalJobError(`Provider call aborted for ${taskType} (${provider}): ${message}`);
+    return new AbortSignalJobError(withJobErrorDiagnostics(`Provider call aborted for ${taskType} (${provider}): ${message}`, err));
   }
   if (message.startsWith("HFT_NULL_PROCESSOR:")) {
-    return new RetryableJobError(message);
+    return new RetryableJobError(withJobErrorDiagnostics(message, err));
   }
   if (status === 429) {
     const retryAfterMatch = message.match(/retry.after[:\s]*(\d+)/i);
     const retryMs = retryAfterMatch ? parseInt(retryAfterMatch[1], 10) * 1000 : 30000;
-    return new RetryableJobError(`Rate limited by ${provider} for ${taskType}: ${message}`, new Date(Date.now() + retryMs));
+    return new RetryableJobError(withJobErrorDiagnostics(`Rate limited by ${provider} for ${taskType}: ${message}`, err), new Date(Date.now() + retryMs));
   }
   if (status === 401 || status === 403) {
-    return new PermanentJobError(`Authentication failed for ${provider} (${taskType}): ${message}`);
+    return new PermanentJobError(withJobErrorDiagnostics(`Authentication failed for ${provider} (${taskType}): ${message}`, err));
   }
   if (status === 400 || status === 404) {
-    return new PermanentJobError(`Invalid request to ${provider} for ${taskType}: ${message}`);
+    return new PermanentJobError(withJobErrorDiagnostics(`Invalid request to ${provider} for ${taskType}: ${message}`, err));
   }
   if (status && status >= 500) {
-    return new RetryableJobError(`Server error from ${provider} for ${taskType} (HTTP ${status}): ${message}`);
+    return new RetryableJobError(withJobErrorDiagnostics(`Server error from ${provider} for ${taskType} (HTTP ${status}): ${message}`, err));
   }
   if (message.includes("ECONNREFUSED") || message.includes("ECONNRESET") || message.includes("ETIMEDOUT") || message.includes("fetch failed") || message.includes("network") || err instanceof TypeError && message.includes("fetch")) {
-    return new RetryableJobError(`Network error calling ${provider} for ${taskType}: ${message}`);
+    return new RetryableJobError(withJobErrorDiagnostics(`Network error calling ${provider} for ${taskType}: ${message}`, err));
   }
   if (message.includes("timed out") || message.includes("timeout")) {
-    return new RetryableJobError(`Timeout calling ${provider} for ${taskType}: ${message}`);
+    return new RetryableJobError(withJobErrorDiagnostics(`Timeout calling ${provider} for ${taskType}: ${message}`, err));
   }
-  return new PermanentJobError(`Provider ${provider} failed for ${taskType}: ${message}`);
+  return new PermanentJobError(withJobErrorDiagnostics(`Provider ${provider} failed for ${taskType}: ${message}`, err));
 }
 
 class AiJob extends Job {
@@ -297,12 +295,14 @@ class DirectExecutionStrategy {
 }
 
 // src/execution/QueuedExecutionStrategy.ts
-import { ConcurrencyLimiter, JobQueueClient, JobQueueServer } from "@workglow/job-queue";
-import { InMemoryQueueStorage } from "@workglow/storage";
 import {
-  getTaskQueueRegistry,
-  TaskConfigurationError
-} from "@workglow/task-graph";
+  AbortSignalJobError as AbortSignalJobError2,
+  ConcurrencyLimiter,
+  JobQueueClient,
+  JobQueueServer
+} from "@workglow/job-queue";
+import { InMemoryQueueStorage } from "@workglow/storage";
+import { getTaskQueueRegistry, TaskConfigurationError } from "@workglow/task-graph";
 class QueuedExecutionStrategy {
   queueName;
   concurrency;
@@ -315,7 +315,7 @@ class QueuedExecutionStrategy {
   }
   async execute(jobInput, context, runnerId) {
     if (context.signal.aborted) {
-      throw context.signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+      throw context.signal.reason ?? new AbortSignalJobError2("The operation was aborted");
     }
     const registeredQueue = await this.ensureQueue();
     const { client } = registeredQueue;
@@ -334,7 +334,7 @@ class QueuedExecutionStrategy {
     });
     try {
       if (context.signal.aborted) {
-        throw context.signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+        throw context.signal.reason ?? new AbortSignalJobError2("The operation was aborted");
       }
       const output = await handle.waitFor();
       return output;
@@ -408,18 +408,106 @@ class QueuedExecutionStrategy {
   }
 }
 
+// src/task/ToolCallingUtils.ts
+import { getLogger as getLogger2 } from "@workglow/util/worker";
+function buildToolDescription(tool) {
+  let desc = tool.description;
+  if (tool.outputSchema && typeof tool.outputSchema === "object") {
+    desc += `
+
+Returns: ${JSON.stringify(tool.outputSchema)}`;
+  }
+  return desc;
+}
+function isAllowedToolName(name, allowedTools) {
+  return allowedTools.some((t) => t.name === name);
+}
+function filterValidToolCalls(toolCalls, allowedTools) {
+  return toolCalls.filter((tc) => {
+    if (tc.name && isAllowedToolName(tc.name, allowedTools)) {
+      return true;
+    }
+    getLogger2().warn(`Filtered out tool call with unknown name "${tc.name ?? "(missing)"}"`, {
+      callId: tc.id,
+      toolName: tc.name
+    });
+    return false;
+  });
+}
+
 // src/model/InMemoryModelRepository.ts
 import { InMemoryTabularStorage } from "@workglow/storage";
 
 // src/model/ModelRepository.ts
 import { EventEmitter } from "@workglow/util";
+import { compileSchema } from "@workglow/util/schema";
+
+// src/model/ModelSchema.ts
+var ModelConfigSchema = {
+  type: "object",
+  properties: {
+    model_id: { type: "string" },
+    tasks: { type: "array", items: { type: "string" }, "x-ui-editor": "multiselect" },
+    title: { type: "string" },
+    description: { type: "string", "x-ui-editor": "textarea" },
+    provider: { type: "string" },
+    provider_config: {
+      type: "object",
+      properties: {
+        credential_key: { type: "string", format: "credential", "x-ui-hidden": true }
+      },
+      additionalProperties: true,
+      default: {}
+    },
+    metadata: { type: "object", default: {}, "x-ui-hidden": true }
+  },
+  required: ["provider", "provider_config"],
+  format: "model",
+  additionalProperties: true
+};
+var ModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties
+  },
+  required: [
+    "model_id",
+    "tasks",
+    "provider",
+    "title",
+    "description",
+    "provider_config",
+    "metadata"
+  ],
+  format: "model",
+  additionalProperties: false
+};
+var ModelPrimaryKeyNames = ["model_id"];
 
+// src/model/ModelRepository.ts
 class ModelRepository {
   modelTabularRepository;
   constructor(modelTabularRepository) {
     this.modelTabularRepository = modelTabularRepository;
   }
   events = new EventEmitter;
+  compiledValidationSchema;
+  getValidationSchema() {
+    return ModelRecordSchema;
+  }
+  validateModelRecord(model) {
+    if (!this.compiledValidationSchema) {
+      this.compiledValidationSchema = compileSchema(this.getValidationSchema());
+    }
+    const result = this.compiledValidationSchema.validate(model);
+    if (!result.valid) {
+      const errorMessages = result.errors.map((e) => {
+        const path = e.data?.pointer || "";
+        return `${e.message}${path ? ` (${path})` : ""}`;
+      });
+      throw new Error(`Invalid model record: ${errorMessages.join(", ")}`);
+    }
+  }
   async setupDatabase() {
     await this.modelTabularRepository.setupDatabase?.();
   }
@@ -436,10 +524,25 @@ class ModelRepository {
     return this.events.waitOn(name);
   }
   async addModel(model) {
+    this.validateModelRecord(model);
+    const existing = await this.modelTabularRepository.get({ model_id: model.model_id });
+    if (existing) {
+      throw new Error(`Model with id "${model.model_id}" already exists`);
+    }
     await this.modelTabularRepository.put(model);
     this.events.emit("model_added", model);
     return model;
   }
+  async updateModel(model) {
+    this.validateModelRecord(model);
+    const existing = await this.modelTabularRepository.get({ model_id: model.model_id });
+    if (!existing) {
+      throw new Error(`Model with id "${model.model_id}" not found`);
+    }
+    await this.modelTabularRepository.put(model);
+    this.events.emit("model_updated", model);
+    return model;
+  }
   async removeModel(model_id) {
     const model = await this.modelTabularRepository.get({ model_id });
     if (!model) {
@@ -498,48 +601,6 @@ class ModelRepository {
   }
 }
 
-// src/model/ModelSchema.ts
-var ModelConfigSchema = {
-  type: "object",
-  properties: {
-    model_id: { type: "string" },
-    tasks: { type: "array", items: { type: "string" }, "x-ui-editor": "multiselect" },
-    title: { type: "string" },
-    description: { type: "string", "x-ui-editor": "textarea" },
-    provider: { type: "string" },
-    provider_config: {
-      type: "object",
-      properties: {
-        credential_key: { type: "string", format: "credential", "x-ui-hidden": true }
-      },
-      additionalProperties: true,
-      default: {}
-    },
-    metadata: { type: "object", default: {}, "x-ui-hidden": true }
-  },
-  required: ["provider", "provider_config"],
-  format: "model",
-  additionalProperties: true
-};
-var ModelRecordSchema = {
-  type: "object",
-  properties: {
-    ...ModelConfigSchema.properties
-  },
-  required: [
-    "model_id",
-    "tasks",
-    "provider",
-    "title",
-    "description",
-    "provider_config",
-    "metadata"
-  ],
-  format: "model",
-  additionalProperties: false
-};
-var ModelPrimaryKeyNames = ["model_id"];
-
 // src/model/InMemoryModelRepository.ts
 class InMemoryModelRepository extends ModelRepository {
   constructor() {
@@ -555,9 +616,7 @@ import {
   registerInputResolver
 } from "@workglow/util";
 var MODEL_REPOSITORY = createServiceToken("model.repository");
-if (!globalServiceRegistry2.has(MODEL_REPOSITORY)) {
-  globalServiceRegistry2.register(MODEL_REPOSITORY, () => new InMemoryModelRepository, true);
-}
+globalServiceRegistry2.registerIfAbsent(MODEL_REPOSITORY, () => new InMemoryModelRepository, true);
 function getGlobalModelRepository() {
   return globalServiceRegistry2.get(MODEL_REPOSITORY);
 }
@@ -588,10 +647,7 @@ registerInputCompactor("model", async (value, _format, registry) => {
 });
 
 // src/provider/AiProvider.ts
-import {
-  globalServiceRegistry as globalServiceRegistry3,
-  WORKER_MANAGER as WORKER_MANAGER2
-} from "@workglow/util/worker";
+import { globalServiceRegistry as globalServiceRegistry3, WORKER_MANAGER as WORKER_MANAGER2 } from "@workglow/util/worker";
 function resolveAiProviderGpuQueueConcurrency(concurrency) {
   if (concurrency === undefined) {
     return 1;
@@ -711,8 +767,74 @@ class QueuedAiProvider extends AiProvider {
 // src/task/index.ts
 import { TaskRegistry } from "@workglow/task-graph";
 
-// src/task/BackgroundRemovalTask.ts
-import { CreateWorkflow, Workflow } from "@workglow/task-graph";
+// src/task/AgentTask.ts
+import { CreateWorkflow as CreateWorkflow2, Task 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/base/AiTaskSchemas.ts
 var TypeLanguage = (annotations = {}) => ({
@@ -871,11 +993,12 @@ var TypeCategory = {
   description: "Classification category with label and score"
 };
 
-// src/task/base/AiVisionTask.ts
-import { convertImageDataToUseableForm } from "@workglow/util/media";
+// src/task/base/StreamingAiTask.ts
+import { getStreamingPorts, TaskConfigurationError as TaskConfigurationError3 } from "@workglow/task-graph";
 
 // src/task/base/AiTask.ts
 import {
+  Entitlements,
   Task,
   TaskConfigSchema,
   TaskConfigurationError as TaskConfigurationError2,
@@ -894,6 +1017,27 @@ var aiTaskConfigSchema = {
 
 class AiTask extends Task {
   static type = "AiTask";
+  static hasDynamicEntitlements = true;
+  static entitlements() {
+    return {
+      entitlements: [{ id: Entitlements.AI_INFERENCE, reason: "Runs AI model inference" }]
+    };
+  }
+  entitlements() {
+    const base = [
+      { id: Entitlements.AI_INFERENCE, reason: "Runs AI model inference" }
+    ];
+    const runModel = this.runInputData?.model;
+    const modelId = typeof runModel === "string" ? runModel : typeof this.defaults.model === "string" ? this.defaults.model : undefined;
+    if (modelId) {
+      base.push({
+        id: Entitlements.AI_MODEL,
+        reason: `Uses model ${modelId}`,
+        resources: [modelId]
+      });
+    }
+    return { entitlements: base };
+  }
   static configSchema() {
     return aiTaskConfigSchema;
   }
@@ -956,71 +1100,773 @@ class AiTask extends Task {
         return reactiveFn(input, output, model);
       }
     }
-    return super.executeReactive(input, output, context);
+    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, propSchema] 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;
   }
-  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.`);
+  static outputSchema() {
+    return AgentOutputSchema;
+  }
+  async execute(input, context) {
+    let result;
+    for await (const event of this.agentLoop(input, context)) {
+      if (event.type === "finish") {
+        result = event.data;
       }
     }
-    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.`);
-      }
+    if (!result) {
+      throw new Error("AgentTask: loop ended without producing output");
     }
-    return super.validateInput(input);
+    return result;
   }
-  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`);
+  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;
       }
-      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, propSchema] of modelTaskProperties) {
-        const requestedModel = input[key];
-        if (typeof requestedModel === "string") {
-          const found = taskModels?.find((m) => m.model_id === requestedModel);
-          if (!found) {
-            input[key] = undefined;
+      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 (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;
+        } else if (event.type === "finish") {
+          const data = event.data;
+          iterationText = data?.text ?? iterationText;
+          if (data?.toolCalls && data.toolCalls.length > 0) {
+            toolCalls = data.toolCalls;
           }
         }
       }
+      finalText = iterationText;
+      messages.push(assistantMessage(iterationText, toolCalls));
+      if (input.stopTool) {
+        const stopCall = toolCalls.find((tc) => tc.name === input.stopTool);
+        if (stopCall) {
+          structuredOutput = stopCall.input;
+          break;
+        }
+      }
+      if (!hasToolCalls(toolCalls)) {
+        break;
+      }
+      const results = await executeToolCalls(toolCalls, toolSources, context, hooks, maxConcurrency);
+      messages.push(toolMessage(results));
     }
-    return input;
+    const output = {
+      text: finalText,
+      messages,
+      iterations: messages.filter((m) => m.role === "assistant").length,
+      toolCallCount: countAssistantToolUses(messages),
+      ...structuredOutput !== undefined ? { structuredOutput } : {}
+    };
+    yield { type: "finish", data: output };
+  }
+  resolveToolSources(input, context) {
+    return buildToolSources(input.tools, context.registry);
+  }
+  resolveToolDefs(toolSources, stopTool) {
+    const defs = toolSourceDefinitions(toolSources);
+    if (stopTool && !defs.some((d) => d.name === stopTool)) {
+      defs.push({
+        name: stopTool,
+        description: "Call this tool when you have completed the task. Pass your final structured result as the input.",
+        inputSchema: { type: "object", additionalProperties: true }
+      });
+    }
+    return defs;
+  }
+  trimMessages(messages, maxContextMessages) {
+    if (!maxContextMessages || messages.length <= maxContextMessages) {
+      return messages;
+    }
+    getLogger4().debug(`AgentTask: Trimming context from ${messages.length} to ${maxContextMessages} messages`);
+    const tail = messages.slice(1);
+    let startIdx = tail.length - (maxContextMessages - 1);
+    if (startIdx < 0)
+      startIdx = 0;
+    while (startIdx > 0 && startIdx < tail.length && tail[startIdx].role === "tool") {
+      startIdx -= 1;
+    }
+    return [messages[0], ...tail.slice(startIdx)];
   }
 }
+var agent = (input, config) => {
+  return new AgentTask(config).run(input);
+};
+Workflow2.prototype.agent = CreateWorkflow2(AgentTask);
+
+// src/task/BackgroundRemovalTask.ts
+import { CreateWorkflow as CreateWorkflow3, Workflow as Workflow3 } from "@workglow/task-graph";
 
 // src/task/base/AiVisionTask.ts
+import { convertImageDataToUseableForm } from "@workglow/util/media";
 class AiVisionTask extends AiTask {
   static type = "AiVisionTask";
   async getJobInput(input) {
@@ -1041,7 +1887,7 @@ class AiVisionTask extends AiTask {
 }
 
 // src/task/BackgroundRemovalTask.ts
-var modelSchema = TypeModel("model:BackgroundRemovalTask");
+var modelSchema3 = TypeModel("model:BackgroundRemovalTask");
 var processedImageSchema = {
   type: "string",
   contentEncoding: "base64",
@@ -1053,7 +1899,7 @@ var BackgroundRemovalInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema
+    model: modelSchema3
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -1080,24 +1926,24 @@ class BackgroundRemovalTask extends AiVisionTask {
   }
 }
 var backgroundRemoval = (input, config) => {
-  return new BackgroundRemovalTask({}, config).run(input);
+  return new BackgroundRemovalTask(config).run(input);
 };
-Workflow.prototype.backgroundRemoval = CreateWorkflow(BackgroundRemovalTask);
+Workflow3.prototype.backgroundRemoval = CreateWorkflow3(BackgroundRemovalTask);
 
 // src/task/ChunkRetrievalTask.ts
 import { TypeKnowledgeBase } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow3, Task as Task2, Workflow as Workflow3 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow5, Task as Task3, Workflow as Workflow5 } from "@workglow/task-graph";
 import {
   isTypedArray,
   TypedArraySchema as TypedArraySchema2
 } from "@workglow/util/schema";
 
 // src/task/TextEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow2, Workflow as Workflow2 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow4, Workflow as Workflow4 } from "@workglow/task-graph";
 import {
   TypedArraySchema
 } from "@workglow/util/schema";
-var modelSchema2 = TypeModel("model:TextEmbeddingTask");
+var modelSchema4 = TypeModel("model:TextEmbeddingTask");
 var TextEmbeddingInputSchema = {
   type: "object",
   properties: {
@@ -1106,7 +1952,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema2
+    model: modelSchema4
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1136,9 +1982,9 @@ class TextEmbeddingTask extends AiTask {
   }
 }
 var textEmbedding = async (input, config) => {
-  return new TextEmbeddingTask({}, config).run(input);
+  return new TextEmbeddingTask(config).run(input);
 };
-Workflow2.prototype.textEmbedding = CreateWorkflow2(TextEmbeddingTask);
+Workflow4.prototype.textEmbedding = CreateWorkflow4(TextEmbeddingTask);
 
 // src/task/ChunkRetrievalTask.ts
 var inputSchema = {
@@ -1263,7 +2109,7 @@ var outputSchema = {
   additionalProperties: false
 };
 
-class ChunkRetrievalTask extends Task2 {
+class ChunkRetrievalTask extends Task3 {
   static type = "ChunkRetrievalTask";
   static category = "RAG";
   static title = "Chunk Retrieval";
@@ -1291,8 +2137,8 @@ class ChunkRetrievalTask extends Task2 {
       if (!model) {
         throw new Error("Model is required when query is a string. Please provide a model with format 'model:TextEmbeddingTask'.");
       }
-      const embeddingTask = context.own(new TextEmbeddingTask({ text: query, model }));
-      const embeddingResult = await embeddingTask.run();
+      const embeddingTask = context.own(new TextEmbeddingTask);
+      const embeddingResult = await embeddingTask.run({ text: query, model });
       queryVectors = Array.isArray(embeddingResult.vector) ? embeddingResult.vector : [embeddingResult.vector];
     } else if (isTypedArray(query) || Array.isArray(query) && query.every(isTypedArray)) {
       queryVectors = Array.isArray(query) ? query : [query];
@@ -1328,13 +2174,13 @@ class ChunkRetrievalTask extends Task2 {
   }
 }
 var chunkRetrieval = (input, config) => {
-  return new ChunkRetrievalTask({}, config).run(input);
+  return new ChunkRetrievalTask(config).run(input);
 };
-Workflow3.prototype.chunkRetrieval = CreateWorkflow3(ChunkRetrievalTask);
+Workflow5.prototype.chunkRetrieval = CreateWorkflow5(ChunkRetrievalTask);
 
 // src/task/ChunkToVectorTask.ts
 import { ChunkRecordSchema } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow4, Task as Task3, Workflow as Workflow4 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow6, Task as Task4, Workflow as Workflow6 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema3
 } from "@workglow/util/schema";
@@ -1409,7 +2255,7 @@ var outputSchema2 = {
   additionalProperties: false
 };
 
-class ChunkToVectorTask extends Task3 {
+class ChunkToVectorTask extends Task4 {
   static type = "ChunkToVectorTask";
   static category = "Document";
   static title = "Chunk to Vector";
@@ -1458,13 +2304,13 @@ class ChunkToVectorTask extends Task3 {
   }
 }
 var chunkToVector = (input, config) => {
-  return new ChunkToVectorTask({}, config).run(input);
+  return new ChunkToVectorTask(config).run(input);
 };
-Workflow4.prototype.chunkToVector = CreateWorkflow4(ChunkToVectorTask);
+Workflow6.prototype.chunkToVector = CreateWorkflow6(ChunkToVectorTask);
 
 // src/task/ChunkVectorHybridSearchTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase2 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow5, Task as Task4, Workflow as Workflow5 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow7, Task as Task5, Workflow as Workflow7 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema4
 } from "@workglow/util/schema";
@@ -1577,7 +2423,7 @@ var outputSchema3 = {
   additionalProperties: false
 };
 
-class ChunkVectorHybridSearchTask extends Task4 {
+class ChunkVectorHybridSearchTask extends Task5 {
   static type = "ChunkVectorHybridSearchTask";
   static category = "RAG";
   static title = "Hybrid Search";
@@ -1628,13 +2474,13 @@ class ChunkVectorHybridSearchTask extends Task4 {
   }
 }
 var hybridSearch = async (input, config) => {
-  return new ChunkVectorHybridSearchTask({}, config).run(input);
+  return new ChunkVectorHybridSearchTask(config).run(input);
 };
-Workflow5.prototype.hybridSearch = CreateWorkflow5(ChunkVectorHybridSearchTask);
+Workflow7.prototype.hybridSearch = CreateWorkflow7(ChunkVectorHybridSearchTask);
 
 // src/task/ChunkVectorSearchTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase3 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow6, Task as Task5, Workflow as Workflow6 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow8, Task as Task6, Workflow as Workflow8 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util/schema";
@@ -1717,7 +2563,7 @@ var outputSchema4 = {
   additionalProperties: false
 };
 
-class ChunkVectorSearchTask extends Task5 {
+class ChunkVectorSearchTask extends Task6 {
   static type = "ChunkVectorSearchTask";
   static category = "Vector Store";
   static title = "Vector Store Search";
@@ -1747,13 +2593,13 @@ class ChunkVectorSearchTask extends Task5 {
   }
 }
 var vectorStoreSearch = (input, config) => {
-  return new ChunkVectorSearchTask({}, config).run(input);
+  return new ChunkVectorSearchTask(config).run(input);
 };
-Workflow6.prototype.vectorStoreSearch = CreateWorkflow6(ChunkVectorSearchTask);
+Workflow8.prototype.vectorStoreSearch = CreateWorkflow8(ChunkVectorSearchTask);
 
 // src/task/ChunkVectorUpsertTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase4 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow7, Task as Task6, Workflow as Workflow7 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow9, Task as Task7, Workflow as Workflow9 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema6
 } from "@workglow/util/schema";
@@ -1807,7 +2653,7 @@ var outputSchema5 = {
   additionalProperties: false
 };
 
-class ChunkVectorUpsertTask extends Task6 {
+class ChunkVectorUpsertTask extends Task7 {
   static type = "ChunkVectorUpsertTask";
   static category = "Vector Store";
   static title = "Add to Vector Store";
@@ -1865,21 +2711,17 @@ class ChunkVectorUpsertTask extends Task6 {
   }
 }
 var chunkVectorUpsert = (input, config) => {
-  return new ChunkVectorUpsertTask({}, config).run(input);
+  return new ChunkVectorUpsertTask(config).run(input);
 };
-Workflow7.prototype.chunkVectorUpsert = CreateWorkflow7(ChunkVectorUpsertTask);
+Workflow9.prototype.chunkVectorUpsert = CreateWorkflow9(ChunkVectorUpsertTask);
 
 // src/task/ContextBuilderTask.ts
 import { estimateTokens } from "@workglow/knowledge-base";
-import {
-  CreateWorkflow as CreateWorkflow9,
-  Task as Task7,
-  Workflow as Workflow9
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow11, Task as Task8, Workflow as Workflow11 } from "@workglow/task-graph";
 
 // src/task/CountTokensTask.ts
-import { CreateWorkflow as CreateWorkflow8, Workflow as Workflow8 } from "@workglow/task-graph";
-var modelSchema3 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow10, Workflow as Workflow10 } from "@workglow/task-graph";
+var modelSchema5 = TypeModel("model");
 var CountTokensInputSchema = {
   type: "object",
   properties: {
@@ -1888,7 +2730,7 @@ var CountTokensInputSchema = {
       title: "Text",
       description: "The text to count tokens for"
     },
-    model: modelSchema3
+    model: modelSchema5
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1920,9 +2762,9 @@ class CountTokensTask extends AiTask {
   }
 }
 var countTokens = async (input, config) => {
-  return new CountTokensTask({}, config).run(input);
+  return new CountTokensTask(config).run(input);
 };
-Workflow8.prototype.countTokens = CreateWorkflow8(CountTokensTask);
+Workflow10.prototype.countTokens = CreateWorkflow10(CountTokensTask);
 
 // src/task/ContextBuilderTask.ts
 var ContextFormat = {
@@ -1932,7 +2774,7 @@ var ContextFormat = {
   MARKDOWN: "markdown",
   JSON: "json"
 };
-var modelSchema4 = TypeModel("model", {
+var modelSchema6 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting (optional, falls back to estimation)"
 });
@@ -1996,7 +2838,7 @@ var inputSchema6 = {
 
 `
     },
-    model: modelSchema4
+    model: modelSchema6
   },
   required: ["chunks"],
   additionalProperties: false
@@ -2029,7 +2871,7 @@ var outputSchema6 = {
   additionalProperties: false
 };
 
-class ContextBuilderTask extends Task7 {
+class ContextBuilderTask extends Task8 {
   static type = "ContextBuilderTask";
   static category = "RAG";
   static title = "Context Builder";
@@ -2056,7 +2898,7 @@ class ContextBuilderTask extends Task7 {
     } = input;
     let countFn = async (text) => estimateTokens(text);
     if (input.model) {
-      const countTask = context.own(new CountTokensTask({ model: input.model }));
+      const countTask = context.own(new CountTokensTask({ defaults: { model: input.model } }));
       countFn = async (text) => {
         try {
           const result = await countTask.run({ text });
@@ -2220,20 +3062,17 @@ class ContextBuilderTask extends Task7 {
   }
 }
 var contextBuilder = (input, config) => {
-  return new ContextBuilderTask({}, config).run(input);
+  return new ContextBuilderTask(config).run(input);
 };
-Workflow9.prototype.contextBuilder = CreateWorkflow9(ContextBuilderTask);
+Workflow11.prototype.contextBuilder = CreateWorkflow11(ContextBuilderTask);
 
 // src/task/DocumentEnricherTask.ts
-import {
-  getChildren,
-  hasChildren
-} from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow12, Task as Task8, Workflow as Workflow12 } from "@workglow/task-graph";
+import { getChildren, hasChildren } from "@workglow/knowledge-base";
+import { CreateWorkflow as CreateWorkflow14, Task as Task9, Workflow as Workflow14 } from "@workglow/task-graph";
 
 // src/task/TextNamedEntityRecognitionTask.ts
-import { CreateWorkflow as CreateWorkflow10, Workflow as Workflow10 } from "@workglow/task-graph";
-var modelSchema5 = TypeModel("model:TextNamedEntityRecognitionTask");
+import { CreateWorkflow as CreateWorkflow12, Workflow as Workflow12 } from "@workglow/task-graph";
+var modelSchema7 = TypeModel("model:TextNamedEntityRecognitionTask");
 var TextNamedEntityRecognitionInputSchema = {
   type: "object",
   properties: {
@@ -2252,7 +3091,7 @@ var TextNamedEntityRecognitionInputSchema = {
       "x-ui-group": "Configuration",
       "x-ui-group-open": false
     },
-    model: modelSchema5
+    model: modelSchema7
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2305,53 +3144,13 @@ class TextNamedEntityRecognitionTask extends AiTask {
   }
 }
 var textNamedEntityRecognition = (input, config) => {
-  return new TextNamedEntityRecognitionTask({}, config).run(input);
+  return new TextNamedEntityRecognitionTask(config).run(input);
 };
-Workflow10.prototype.textNamedEntityRecognition = CreateWorkflow10(TextNamedEntityRecognitionTask);
-
-// src/task/TextSummaryTask.ts
-import { CreateWorkflow as CreateWorkflow11, Workflow as Workflow11 } from "@workglow/task-graph";
-
-// src/task/base/StreamingAiTask.ts
-import {
-  getStreamingPorts,
-  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;
-      }
-    }
-  }
-}
+Workflow12.prototype.textNamedEntityRecognition = CreateWorkflow12(TextNamedEntityRecognitionTask);
 
 // src/task/TextSummaryTask.ts
-var modelSchema6 = TypeModel("model:TextSummaryTask");
+import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
+var modelSchema8 = TypeModel("model:TextSummaryTask");
 var TextSummaryInputSchema = {
   type: "object",
   properties: {
@@ -2360,7 +3159,7 @@ var TextSummaryInputSchema = {
       title: "Text",
       description: "The text to summarize"
     },
-    model: modelSchema6
+    model: modelSchema8
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2392,9 +3191,9 @@ class TextSummaryTask extends StreamingAiTask {
   }
 }
 var textSummary = async (input, config) => {
-  return new TextSummaryTask({}, config).run(input);
+  return new TextSummaryTask(config).run(input);
 };
-Workflow11.prototype.textSummary = CreateWorkflow11(TextSummaryTask);
+Workflow13.prototype.textSummary = CreateWorkflow13(TextSummaryTask);
 
 // src/task/DocumentEnricherTask.ts
 var inputSchema7 = {
@@ -2466,7 +3265,7 @@ var outputSchema7 = {
   additionalProperties: false
 };
 
-class DocumentEnricherTask extends Task8 {
+class DocumentEnricherTask extends Task9 {
   static type = "DocumentEnricherTask";
   static category = "Document";
   static title = "Document Enricher";
@@ -2494,7 +3293,7 @@ class DocumentEnricherTask extends Task8 {
     let summaryCount = 0;
     let entityCount = 0;
     const extract = extractEntities && nerModel ? async (text) => {
-      const result = await context.own(new TextNamedEntityRecognitionTask({ text, model: nerModel })).run();
+      const result = await context.own(new TextNamedEntityRecognitionTask).run({ text, model: nerModel });
       return result.entities.map((e) => ({
         type: e.entity,
         text: e.word,
@@ -2623,17 +3422,17 @@ class DocumentEnricherTask extends Task8 {
   }
 }
 var documentEnricher = (input, config) => {
-  return new DocumentEnricherTask({}, config).run(input);
+  return new DocumentEnricherTask(config).run(input);
 };
-Workflow12.prototype.documentEnricher = CreateWorkflow12(DocumentEnricherTask);
+Workflow14.prototype.documentEnricher = CreateWorkflow14(DocumentEnricherTask);
 
 // src/task/DownloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
-var modelSchema7 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
+var modelSchema9 = TypeModel("model");
 var DownloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema7
+    model: modelSchema9
   },
   required: ["model"],
   additionalProperties: false
@@ -2641,7 +3440,7 @@ var DownloadModelInputSchema = {
 var DownloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema7
+    model: modelSchema9
   },
   required: ["model"],
   additionalProperties: false
@@ -2660,8 +3459,8 @@ class DownloadModelTask extends AiTask {
   }
   static cacheable = false;
   files = [];
-  constructor(input, config = {}) {
-    super(input, config);
+  constructor(config = {}) {
+    super(config);
     this.on("progress", this.processProgress.bind(this));
     this.on("start", () => {
       this.files = [];
@@ -2693,13 +3492,13 @@ class DownloadModelTask extends AiTask {
   }
 }
 var downloadModel = (input, config) => {
-  return new DownloadModelTask({}, config).run(input);
+  return new DownloadModelTask(config).run(input);
 };
-Workflow13.prototype.downloadModel = CreateWorkflow13(DownloadModelTask);
+Workflow15.prototype.downloadModel = CreateWorkflow15(DownloadModelTask);
 
 // src/task/FaceDetectorTask.ts
-import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
-var modelSchema8 = TypeModel("model:FaceDetectorTask");
+import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
+var modelSchema10 = TypeModel("model:FaceDetectorTask");
 var TypeBoundingBox2 = {
   type: "object",
   properties: {
@@ -2772,7 +3571,7 @@ var FaceDetectorInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema8,
+    model: modelSchema10,
     minDetectionConfidence: {
       type: "number",
       minimum: 0,
@@ -2824,13 +3623,13 @@ class FaceDetectorTask extends AiVisionTask {
   }
 }
 var faceDetector = (input, config) => {
-  return new FaceDetectorTask({}, config).run(input);
+  return new FaceDetectorTask(config).run(input);
 };
-Workflow14.prototype.faceDetector = CreateWorkflow14(FaceDetectorTask);
+Workflow16.prototype.faceDetector = CreateWorkflow16(FaceDetectorTask);
 
 // src/task/FaceLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
-var modelSchema9 = TypeModel("model:FaceLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
+var modelSchema11 = TypeModel("model:FaceLandmarkerTask");
 var TypeLandmark = {
   type: "object",
   properties: {
@@ -2902,7 +3701,7 @@ var FaceLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema9,
+    model: modelSchema11,
     numFaces: {
       type: "number",
       minimum: 1,
@@ -2986,13 +3785,13 @@ class FaceLandmarkerTask extends AiVisionTask {
   }
 }
 var faceLandmarker = (input, config) => {
-  return new FaceLandmarkerTask({}, config).run(input);
+  return new FaceLandmarkerTask(config).run(input);
 };
-Workflow15.prototype.faceLandmarker = CreateWorkflow15(FaceLandmarkerTask);
+Workflow17.prototype.faceLandmarker = CreateWorkflow17(FaceLandmarkerTask);
 
 // src/task/GestureRecognizerTask.ts
-import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
-var modelSchema10 = TypeModel("model:GestureRecognizerTask");
+import { CreateWorkflow as CreateWorkflow18, Workflow as Workflow18 } from "@workglow/task-graph";
+var modelSchema12 = TypeModel("model:GestureRecognizerTask");
 var TypeLandmark2 = {
   type: "object",
   properties: {
@@ -3084,7 +3883,7 @@ var GestureRecognizerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema10,
+    model: modelSchema12,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3154,13 +3953,13 @@ class GestureRecognizerTask extends AiVisionTask {
   }
 }
 var gestureRecognizer = (input, config) => {
-  return new GestureRecognizerTask({}, config).run(input);
+  return new GestureRecognizerTask(config).run(input);
 };
-Workflow16.prototype.gestureRecognizer = CreateWorkflow16(GestureRecognizerTask);
+Workflow18.prototype.gestureRecognizer = CreateWorkflow18(GestureRecognizerTask);
 
 // src/task/HandLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
-var modelSchema11 = TypeModel("model:HandLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow19, Workflow as Workflow19 } from "@workglow/task-graph";
+var modelSchema13 = TypeModel("model:HandLandmarkerTask");
 var TypeLandmark3 = {
   type: "object",
   properties: {
@@ -3229,7 +4028,7 @@ var HandLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema11,
+    model: modelSchema13,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3299,9 +4098,9 @@ class HandLandmarkerTask extends AiVisionTask {
   }
 }
 var handLandmarker = (input, config) => {
-  return new HandLandmarkerTask({}, config).run(input);
+  return new HandLandmarkerTask(config).run(input);
 };
-Workflow17.prototype.handLandmarker = CreateWorkflow17(HandLandmarkerTask);
+Workflow19.prototype.handLandmarker = CreateWorkflow19(HandLandmarkerTask);
 
 // src/task/HierarchicalChunkerTask.ts
 import {
@@ -3310,9 +4109,9 @@ import {
   getChildren as getChildren2,
   hasChildren as hasChildren2
 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow18, Task as Task9, Workflow as Workflow18 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow20, Task as Task10, Workflow as Workflow20 } from "@workglow/task-graph";
 import { uuid4 } from "@workglow/util";
-var modelSchema12 = TypeModel("model", {
+var modelSchema14 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting"
 });
@@ -3356,7 +4155,7 @@ var inputSchema8 = {
       description: "Strategy for chunking",
       default: "hierarchical"
     },
-    model: modelSchema12
+    model: modelSchema14
   },
   required: ["doc_id", "documentTree"],
   additionalProperties: false
@@ -3391,7 +4190,7 @@ var outputSchema8 = {
   additionalProperties: false
 };
 
-class HierarchicalChunkerTask extends Task9 {
+class HierarchicalChunkerTask extends Task10 {
   static type = "HierarchicalChunkerTask";
   static category = "Document";
   static title = "Hierarchical Chunker";
@@ -3426,7 +4225,7 @@ class HierarchicalChunkerTask extends Task9 {
     };
     let countFn = async (text) => estimateTokens2(text);
     if (input.model) {
-      const countTask = context.own(new CountTokensTask({ model: input.model }));
+      const countTask = context.own(new CountTokensTask({ defaults: { model: input.model } }));
       countFn = async (text) => {
         try {
           const result = await countTask.run({ text });
@@ -3533,16 +4332,13 @@ class HierarchicalChunkerTask extends Task9 {
   }
 }
 var hierarchicalChunker = (input, config) => {
-  return new HierarchicalChunkerTask({}, config).run(input);
+  return new HierarchicalChunkerTask(config).run(input);
 };
-Workflow18.prototype.hierarchicalChunker = CreateWorkflow18(HierarchicalChunkerTask);
+Workflow20.prototype.hierarchicalChunker = CreateWorkflow20(HierarchicalChunkerTask);
 
 // src/task/HierarchyJoinTask.ts
-import {
-  ChunkRecordArraySchema,
-  TypeKnowledgeBase as TypeKnowledgeBase5
-} from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow19, Task as Task10, Workflow as Workflow19 } from "@workglow/task-graph";
+import { ChunkRecordArraySchema, TypeKnowledgeBase as TypeKnowledgeBase5 } from "@workglow/knowledge-base";
+import { CreateWorkflow as CreateWorkflow21, Task as Task11, Workflow as Workflow21 } from "@workglow/task-graph";
 var inputSchema9 = {
   type: "object",
   properties: {
@@ -3617,7 +4413,7 @@ var outputSchema9 = {
   additionalProperties: false
 };
 
-class HierarchyJoinTask extends Task10 {
+class HierarchyJoinTask extends Task11 {
   static type = "HierarchyJoinTask";
   static category = "RAG";
   static title = "Hierarchy Join";
@@ -3709,18 +4505,18 @@ class HierarchyJoinTask extends Task10 {
   }
 }
 var hierarchyJoin = (input, config) => {
-  return new HierarchyJoinTask({}, config).run(input);
+  return new HierarchyJoinTask(config).run(input);
 };
-Workflow19.prototype.hierarchyJoin = CreateWorkflow19(HierarchyJoinTask);
+Workflow21.prototype.hierarchyJoin = CreateWorkflow21(HierarchyJoinTask);
 
 // src/task/ImageClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow20, Workflow as Workflow20 } from "@workglow/task-graph";
-var modelSchema13 = TypeModel("model:ImageClassificationTask");
+import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
+var modelSchema15 = TypeModel("model:ImageClassificationTask");
 var ImageClassificationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema13,
+    model: modelSchema15,
     categories: {
       type: "array",
       items: {
@@ -3772,21 +4568,21 @@ class ImageClassificationTask extends AiVisionTask {
   }
 }
 var imageClassification = (input, config) => {
-  return new ImageClassificationTask({}, config).run(input);
+  return new ImageClassificationTask(config).run(input);
 };
-Workflow20.prototype.imageClassification = CreateWorkflow20(ImageClassificationTask);
+Workflow22.prototype.imageClassification = CreateWorkflow22(ImageClassificationTask);
 
 // src/task/ImageEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow21, Workflow as Workflow21 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema7
 } from "@workglow/util/schema";
-var modelSchema14 = TypeModel("model:ImageEmbeddingTask");
+var modelSchema16 = TypeModel("model:ImageEmbeddingTask");
 var ImageEmbeddingInputSchema = {
   type: "object",
   properties: {
     image: TypeSingleOrArray(TypeImageInput),
-    model: modelSchema14
+    model: modelSchema16
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -3816,18 +4612,18 @@ class ImageEmbeddingTask extends AiVisionTask {
   }
 }
 var imageEmbedding = (input, config) => {
-  return new ImageEmbeddingTask({}, config).run(input);
+  return new ImageEmbeddingTask(config).run(input);
 };
-Workflow21.prototype.imageEmbedding = CreateWorkflow21(ImageEmbeddingTask);
+Workflow23.prototype.imageEmbedding = CreateWorkflow23(ImageEmbeddingTask);
 
 // src/task/ImageSegmentationTask.ts
-import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
-var modelSchema15 = TypeModel("model:ImageSegmentationTask");
+import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
+var modelSchema17 = TypeModel("model:ImageSegmentationTask");
 var ImageSegmentationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema15,
+    model: modelSchema17,
     threshold: {
       type: "number",
       title: "Threshold",
@@ -3904,13 +4700,13 @@ class ImageSegmentationTask extends AiVisionTask {
   }
 }
 var imageSegmentation = (input, config) => {
-  return new ImageSegmentationTask({}, config).run(input);
+  return new ImageSegmentationTask(config).run(input);
 };
-Workflow22.prototype.imageSegmentation = CreateWorkflow22(ImageSegmentationTask);
+Workflow24.prototype.imageSegmentation = CreateWorkflow24(ImageSegmentationTask);
 
 // src/task/ImageToTextTask.ts
-import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
-var modelSchema16 = TypeModel("model:ImageToTextTask");
+import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
+var modelSchema18 = TypeModel("model:ImageToTextTask");
 var generatedTextSchema = {
   type: "string",
   title: "Text",
@@ -3920,7 +4716,7 @@ var ImageToTextInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema16,
+    model: modelSchema18,
     maxTokens: {
       type: "number",
       title: "Max Tokens",
@@ -3959,17 +4755,17 @@ class ImageToTextTask extends AiVisionTask {
   }
 }
 var imageToText = (input, config) => {
-  return new ImageToTextTask({}, config).run(input);
+  return new ImageToTextTask(config).run(input);
 };
-Workflow23.prototype.imageToText = CreateWorkflow23(ImageToTextTask);
+Workflow25.prototype.imageToText = CreateWorkflow25(ImageToTextTask);
 
 // src/task/ModelInfoTask.ts
-import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
-var modelSchema17 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
+var modelSchema19 = TypeModel("model");
 var ModelInfoInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema17,
+    model: modelSchema19,
     detail: {
       type: "string",
       enum: ["cached_status", "files", "files_with_metadata"],
@@ -3982,7 +4778,7 @@ var ModelInfoInputSchema = {
 var ModelInfoOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema17,
+    model: modelSchema19,
     is_local: { type: "boolean" },
     is_remote: { type: "boolean" },
     supports_browser: { type: "boolean" },
@@ -4030,12 +4826,12 @@ class ModelInfoTask extends AiTask {
   }
 }
 var modelInfo = (input, config) => {
-  return new ModelInfoTask({}, config).run(input);
+  return new ModelInfoTask(config).run(input);
 };
-Workflow24.prototype.modelInfo = CreateWorkflow24(ModelInfoTask);
+Workflow26.prototype.modelInfo = CreateWorkflow26(ModelInfoTask);
 
 // src/task/ModelSearchTask.ts
-import { CreateWorkflow as CreateWorkflow25, Task as Task11, Workflow as Workflow25 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow27, Task as Task12, Workflow as Workflow27 } from "@workglow/task-graph";
 var ModelSearchInputSchema = {
   type: "object",
   properties: {
@@ -4100,7 +4896,7 @@ var ModelSearchOutputSchema = {
   additionalProperties: false
 };
 
-class ModelSearchTask extends Task11 {
+class ModelSearchTask extends Task12 {
   static type = "ModelSearchTask";
   static category = "AI Model";
   static title = "Model Search";
@@ -4124,13 +4920,13 @@ class ModelSearchTask extends Task11 {
   }
 }
 var modelSearch = (input, config) => {
-  return new ModelSearchTask({}, config).run(input);
+  return new ModelSearchTask(config).run(input);
 };
-Workflow25.prototype.modelSearch = CreateWorkflow25(ModelSearchTask);
+Workflow27.prototype.modelSearch = CreateWorkflow27(ModelSearchTask);
 
 // src/task/ObjectDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
-var modelSchema18 = TypeModel("model:ObjectDetectionTask");
+import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
+var modelSchema20 = TypeModel("model:ObjectDetectionTask");
 var detectionSchema = {
   type: "object",
   properties: {
@@ -4155,7 +4951,7 @@ var ObjectDetectionInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema18,
+    model: modelSchema20,
     labels: {
       type: "array",
       items: {
@@ -4207,13 +5003,13 @@ class ObjectDetectionTask extends AiVisionTask {
   }
 }
 var objectDetection = (input, config) => {
-  return new ObjectDetectionTask({}, config).run(input);
+  return new ObjectDetectionTask(config).run(input);
 };
-Workflow26.prototype.objectDetection = CreateWorkflow26(ObjectDetectionTask);
+Workflow28.prototype.objectDetection = CreateWorkflow28(ObjectDetectionTask);
 
 // src/task/PoseLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow27, Workflow as Workflow27 } from "@workglow/task-graph";
-var modelSchema19 = TypeModel("model:PoseLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow29, Workflow as Workflow29 } from "@workglow/task-graph";
+var modelSchema21 = TypeModel("model:PoseLandmarkerTask");
 var TypePoseLandmark = {
   type: "object",
   properties: {
@@ -4292,7 +5088,7 @@ var PoseLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema19,
+    model: modelSchema21,
     numPoses: {
       type: "number",
       minimum: 1,
@@ -4369,12 +5165,12 @@ class PoseLandmarkerTask extends AiVisionTask {
   }
 }
 var poseLandmarker = (input, config) => {
-  return new PoseLandmarkerTask({}, config).run(input);
+  return new PoseLandmarkerTask(config).run(input);
 };
-Workflow27.prototype.poseLandmarker = CreateWorkflow27(PoseLandmarkerTask);
+Workflow29.prototype.poseLandmarker = CreateWorkflow29(PoseLandmarkerTask);
 
 // src/task/QueryExpanderTask.ts
-import { CreateWorkflow as CreateWorkflow28, Task as Task12, Workflow as Workflow28 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow30, Task as Task13, Workflow as Workflow30 } from "@workglow/task-graph";
 var QueryExpansionMethod = {
   MULTI_QUERY: "multi-query",
   HYDE: "hyde",
@@ -4442,7 +5238,7 @@ var outputSchema10 = {
   additionalProperties: false
 };
 
-class QueryExpanderTask extends Task12 {
+class QueryExpanderTask extends Task13 {
   static type = "QueryExpanderTask";
   static category = "RAG";
   static title = "Query Expander";
@@ -4582,16 +5378,16 @@ class QueryExpanderTask extends Task12 {
   }
 }
 var queryExpander = (input, config) => {
-  return new QueryExpanderTask({}, config).run(input);
+  return new QueryExpanderTask(config).run(input);
 };
-Workflow28.prototype.queryExpander = CreateWorkflow28(QueryExpanderTask);
+Workflow30.prototype.queryExpander = CreateWorkflow30(QueryExpanderTask);
 
 // src/task/RerankerTask.ts
-import { CreateWorkflow as CreateWorkflow30, Task as Task13, Workflow as Workflow30 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow32, Task as Task14, Workflow as Workflow32 } from "@workglow/task-graph";
 
 // src/task/TextClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow29, Workflow as Workflow29 } from "@workglow/task-graph";
-var modelSchema20 = TypeModel("model:TextClassificationTask");
+import { CreateWorkflow as CreateWorkflow31, Workflow as Workflow31 } from "@workglow/task-graph";
+var modelSchema22 = TypeModel("model:TextClassificationTask");
 var TextClassificationInputSchema = {
   type: "object",
   properties: {
@@ -4618,7 +5414,7 @@ var TextClassificationInputSchema = {
       description: "The maximum number of categories to return",
       "x-ui-group": "Configuration"
     },
-    model: modelSchema20
+    model: modelSchema22
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -4666,9 +5462,9 @@ class TextClassificationTask extends AiTask {
   }
 }
 var textClassification = (input, config) => {
-  return new TextClassificationTask({}, config).run(input);
+  return new TextClassificationTask(config).run(input);
 };
-Workflow29.prototype.textClassification = CreateWorkflow29(TextClassificationTask);
+Workflow31.prototype.textClassification = CreateWorkflow31(TextClassificationTask);
 
 // src/task/RerankerTask.ts
 var inputSchema11 = {
@@ -4763,7 +5559,7 @@ var outputSchema11 = {
   additionalProperties: false
 };
 
-class RerankerTask extends Task13 {
+class RerankerTask extends Task14 {
   static type = "RerankerTask";
   static category = "RAG";
   static title = "Reranker";
@@ -4814,8 +5610,8 @@ class RerankerTask extends Task13 {
     }
     const items = await Promise.all(chunks.map(async (chunk, index) => {
       const pairText = `${query} [SEP] ${chunk}`;
-      const task = context.own(new TextClassificationTask({ text: pairText, model, maxCategories: 2 }));
-      const result = await task.run();
+      const task = context.own(new TextClassificationTask({ defaults: { model } }));
+      const result = await task.run({ text: pairText, maxCategories: 2 });
       const crossScore = this.extractCrossEncoderScore(result.categories);
       return {
         chunk,
@@ -4890,13 +5686,13 @@ class RerankerTask extends Task13 {
   }
 }
 var reranker = (input, config) => {
-  return new RerankerTask({}, config).run(input);
+  return new RerankerTask(config).run(input);
 };
-Workflow30.prototype.reranker = CreateWorkflow30(RerankerTask);
+Workflow32.prototype.reranker = CreateWorkflow32(RerankerTask);
 
 // src/task/StructuralParserTask.ts
 import { StructuralParser } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow31, Task as Task14, Workflow as Workflow31 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow33, Task as Task15, Workflow as Workflow33 } from "@workglow/task-graph";
 import { uuid4 as uuid42 } from "@workglow/util";
 var inputSchema12 = {
   type: "object",
@@ -4954,7 +5750,7 @@ var outputSchema12 = {
   additionalProperties: false
 };
 
-class StructuralParserTask extends Task14 {
+class StructuralParserTask extends Task15 {
   static type = "StructuralParserTask";
   static category = "Document";
   static title = "Structural Parser";
@@ -4995,17 +5791,17 @@ class StructuralParserTask extends Task14 {
   }
 }
 var structuralParser = (input, config) => {
-  return new StructuralParserTask({}, config).run(input);
+  return new StructuralParserTask(config).run(input);
 };
-Workflow31.prototype.structuralParser = CreateWorkflow31(StructuralParserTask);
+Workflow33.prototype.structuralParser = CreateWorkflow33(StructuralParserTask);
 
 // src/task/StructuredGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow32, Workflow as Workflow32 } from "@workglow/task-graph";
-var modelSchema21 = TypeModel("model:StructuredGenerationTask");
+import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
+var modelSchema23 = TypeModel("model:StructuredGenerationTask");
 var StructuredGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema21,
+    model: modelSchema23,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5066,12 +5862,12 @@ class StructuredGenerationTask extends StreamingAiTask {
   }
 }
 var structuredGeneration = (input, config) => {
-  return new StructuredGenerationTask({}, config).run(input);
+  return new StructuredGenerationTask(config).run(input);
 };
-Workflow32.prototype.structuredGeneration = CreateWorkflow32(StructuredGenerationTask);
+Workflow34.prototype.structuredGeneration = CreateWorkflow34(StructuredGenerationTask);
 
 // src/task/TextChunkerTask.ts
-import { CreateWorkflow as CreateWorkflow33, Task as Task15, Workflow as Workflow33 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow35, Task as Task16, Workflow as Workflow35 } from "@workglow/task-graph";
 var ChunkingStrategy = {
   FIXED: "fixed",
   SENTENCE: "sentence",
@@ -5140,7 +5936,7 @@ var outputSchema13 = {
   additionalProperties: false
 };
 
-class TextChunkerTask extends Task15 {
+class TextChunkerTask extends Task16 {
   static type = "TextChunkerTask";
   static category = "Document";
   static title = "Text Chunker";
@@ -5318,13 +6114,13 @@ class TextChunkerTask extends Task15 {
   }
 }
 var textChunker = (input, config) => {
-  return new TextChunkerTask({}, config).run(input);
+  return new TextChunkerTask(config).run(input);
 };
-Workflow33.prototype.textChunker = CreateWorkflow33(TextChunkerTask);
+Workflow35.prototype.textChunker = CreateWorkflow35(TextChunkerTask);
 
 // src/task/TextFillMaskTask.ts
-import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
-var modelSchema22 = TypeModel("model:TextFillMaskTask");
+import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
+var modelSchema24 = TypeModel("model:TextFillMaskTask");
 var TextFillMaskInputSchema = {
   type: "object",
   properties: {
@@ -5333,7 +6129,7 @@ var TextFillMaskInputSchema = {
       title: "Text",
       description: "The text with a mask token to fill"
     },
-    model: modelSchema22
+    model: modelSchema24
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5386,23 +6182,23 @@ class TextFillMaskTask extends AiTask {
   }
 }
 var textFillMask = (input, config) => {
-  return new TextFillMaskTask({}, config).run(input);
+  return new TextFillMaskTask(config).run(input);
 };
-Workflow34.prototype.textFillMask = CreateWorkflow34(TextFillMaskTask);
+Workflow36.prototype.textFillMask = CreateWorkflow36(TextFillMaskTask);
 
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow35, Workflow as Workflow35 } 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 modelSchema23 = TypeModel("model:TextGenerationTask");
+var modelSchema25 = TypeModel("model:TextGenerationTask");
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema23,
+    model: modelSchema25,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5474,13 +6270,13 @@ class TextGenerationTask extends StreamingAiTask {
   }
 }
 var textGeneration = (input, config) => {
-  return new TextGenerationTask({}, config).run(input);
+  return new TextGenerationTask(config).run(input);
 };
-Workflow35.prototype.textGeneration = CreateWorkflow35(TextGenerationTask);
+Workflow37.prototype.textGeneration = CreateWorkflow37(TextGenerationTask);
 
 // src/task/TextLanguageDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
-var modelSchema24 = TypeModel("model:TextLanguageDetectionTask");
+import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
+var modelSchema26 = TypeModel("model:TextLanguageDetectionTask");
 var TextLanguageDetectionInputSchema = {
   type: "object",
   properties: {
@@ -5497,7 +6293,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema24
+    model: modelSchema26
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5545,12 +6341,12 @@ class TextLanguageDetectionTask extends AiTask {
   }
 }
 var textLanguageDetection = (input, config) => {
-  return new TextLanguageDetectionTask({}, config).run(input);
+  return new TextLanguageDetectionTask(config).run(input);
 };
-Workflow36.prototype.textLanguageDetection = CreateWorkflow36(TextLanguageDetectionTask);
+Workflow38.prototype.textLanguageDetection = CreateWorkflow38(TextLanguageDetectionTask);
 
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
 var contextSchema = {
   type: "string",
   title: "Context",
@@ -5567,13 +6363,13 @@ var textSchema = {
   description: "The generated text",
   "x-stream": "append"
 };
-var modelSchema25 = TypeModel("model:TextQuestionAnswerTask");
+var modelSchema27 = TypeModel("model:TextQuestionAnswerTask");
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: contextSchema,
     question: questionSchema,
-    model: modelSchema25
+    model: modelSchema27
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -5600,13 +6396,13 @@ class TextQuestionAnswerTask extends StreamingAiTask {
   }
 }
 var textQuestionAnswer = (input, config) => {
-  return new TextQuestionAnswerTask({}, config).run(input);
+  return new TextQuestionAnswerTask(config).run(input);
 };
-Workflow37.prototype.textQuestionAnswer = CreateWorkflow37(TextQuestionAnswerTask);
+Workflow39.prototype.textQuestionAnswer = CreateWorkflow39(TextQuestionAnswerTask);
 
 // src/task/TextRewriterTask.ts
-import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
-var modelSchema26 = TypeModel("model:TextRewriterTask");
+import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
+var modelSchema28 = TypeModel("model:TextRewriterTask");
 var TextRewriterInputSchema = {
   type: "object",
   properties: {
@@ -5620,7 +6416,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     },
-    model: modelSchema26
+    model: modelSchema28
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -5652,13 +6448,13 @@ class TextRewriterTask extends StreamingAiTask {
   }
 }
 var textRewriter = (input, config) => {
-  return new TextRewriterTask({}, config).run(input);
+  return new TextRewriterTask(config).run(input);
 };
-Workflow38.prototype.textRewriter = CreateWorkflow38(TextRewriterTask);
+Workflow40.prototype.textRewriter = CreateWorkflow40(TextRewriterTask);
 
 // src/task/TextTranslationTask.ts
-import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
-var modelSchema27 = TypeModel("model:TextTranslationTask");
+import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
+var modelSchema29 = TypeModel("model:TextTranslationTask");
 var translationTextSchema = {
   type: "string",
   title: "Text",
@@ -5685,7 +6481,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     }),
-    model: modelSchema27
+    model: modelSchema29
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -5718,12 +6514,12 @@ class TextTranslationTask extends StreamingAiTask {
   }
 }
 var textTranslation = (input, config) => {
-  return new TextTranslationTask({}, config).run(input);
+  return new TextTranslationTask(config).run(input);
 };
-Workflow39.prototype.textTranslation = CreateWorkflow39(TextTranslationTask);
+Workflow41.prototype.textTranslation = CreateWorkflow41(TextTranslationTask);
 
 // src/task/TopicSegmenterTask.ts
-import { CreateWorkflow as CreateWorkflow40, Task as Task16, Workflow as Workflow40 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow42, Task as Task17, Workflow as Workflow42 } from "@workglow/task-graph";
 var SegmentationMethod = {
   HEURISTIC: "heuristic",
   EMBEDDING_SIMILARITY: "embedding-similarity",
@@ -5798,7 +6594,7 @@ var outputSchema14 = {
   additionalProperties: false
 };
 
-class TopicSegmenterTask extends Task16 {
+class TopicSegmenterTask extends Task17 {
   static type = "TopicSegmenterTask";
   static category = "Document";
   static title = "Topic Segmenter";
@@ -6001,17 +6797,17 @@ class TopicSegmenterTask extends Task16 {
   }
 }
 var topicSegmenter = (input, config) => {
-  return new TopicSegmenterTask({}, config).run(input);
+  return new TopicSegmenterTask(config).run(input);
 };
-Workflow40.prototype.topicSegmenter = CreateWorkflow40(TopicSegmenterTask);
+Workflow42.prototype.topicSegmenter = CreateWorkflow42(TopicSegmenterTask);
 
 // src/task/UnloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
-var modelSchema28 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow43, Workflow as Workflow43 } from "@workglow/task-graph";
+var modelSchema30 = TypeModel("model");
 var UnloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema28
+    model: modelSchema30
   },
   required: ["model"],
   additionalProperties: false
@@ -6019,7 +6815,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema28
+    model: modelSchema30
   },
   required: ["model"],
   additionalProperties: false
@@ -6039,12 +6835,12 @@ class UnloadModelTask extends AiTask {
   static cacheable = false;
 }
 var unloadModel = (input, config) => {
-  return new UnloadModelTask({}, config).run(input);
+  return new UnloadModelTask(config).run(input);
 };
-Workflow41.prototype.unloadModel = CreateWorkflow41(UnloadModelTask);
+Workflow43.prototype.unloadModel = CreateWorkflow43(UnloadModelTask);
 
 // src/task/VectorQuantizeTask.ts
-import { CreateWorkflow as CreateWorkflow42, Task as Task17, Workflow as Workflow42 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow44, Task as Task18, Workflow as Workflow44 } from "@workglow/task-graph";
 import {
   normalizeNumberArray,
   TensorType,
@@ -6124,7 +6920,7 @@ var outputSchema15 = {
   additionalProperties: false
 };
 
-class VectorQuantizeTask extends Task17 {
+class VectorQuantizeTask extends Task18 {
   static type = "VectorQuantizeTask";
   static category = "Vector";
   static title = "Quantize";
@@ -6222,12 +7018,12 @@ class VectorQuantizeTask extends Task17 {
   }
 }
 var vectorQuantize = (input, config) => {
-  return new VectorQuantizeTask({}, config).run(input);
+  return new VectorQuantizeTask(config).run(input);
 };
-Workflow42.prototype.vectorQuantize = CreateWorkflow42(VectorQuantizeTask);
+Workflow44.prototype.vectorQuantize = CreateWorkflow44(VectorQuantizeTask);
 
 // src/task/VectorSimilarityTask.ts
-import { CreateWorkflow as CreateWorkflow43, GraphAsTask, Workflow as Workflow43 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow45, GraphAsTask, Workflow as Workflow45 } from "@workglow/task-graph";
 import {
   cosineSimilarity,
   hammingSimilarity,
@@ -6331,13 +7127,210 @@ class VectorSimilarityTask extends GraphAsTask {
   }
 }
 var similarity = (input, config) => {
-  return new VectorSimilarityTask({}, config).run(input);
-};
-Workflow43.prototype.similarity = CreateWorkflow43(VectorSimilarityTask);
+  return new VectorSimilarityTask(config).run(input);
+};
+Workflow45.prototype.similarity = CreateWorkflow45(VectorSimilarityTask);
+// src/task/MessageConversion.ts
+function getInputMessages(input) {
+  const messages = input.messages;
+  if (!messages || messages.length === 0)
+    return;
+  return messages;
+}
+function toOpenAIMessages(input) {
+  const messages = [];
+  if (input.systemPrompt) {
+    messages.push({ role: "system", content: input.systemPrompt });
+  }
+  const inputMessages = getInputMessages(input);
+  if (!inputMessages) {
+    if (!Array.isArray(input.prompt)) {
+      messages.push({ role: "user", content: input.prompt });
+    } else if (input.prompt.every((item) => typeof item === "string")) {
+      messages.push({ role: "user", content: input.prompt.join(`
+`) });
+    } else {
+      const parts = [];
+      for (const item of input.prompt) {
+        if (typeof item === "string") {
+          parts.push({ type: "text", text: item });
+        } else {
+          const b = item;
+          if (b.type === "text") {
+            parts.push({ type: "text", text: b.text });
+          } else if (b.type === "image") {
+            parts.push({
+              type: "image_url",
+              image_url: { url: `data:${b.mimeType};base64,${b.data}` }
+            });
+          } else if (b.type === "audio") {
+            const format = b.mimeType.replace(/^audio\//, "");
+            parts.push({
+              type: "input_audio",
+              input_audio: { data: b.data, format }
+            });
+          }
+        }
+      }
+      messages.push({ role: "user", content: parts });
+    }
+    return messages;
+  }
+  for (const msg of inputMessages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        messages.push({ role: "user", content: msg.content });
+      } else if (Array.isArray(msg.content) && msg.content.length > 0 && typeof msg.content[0]?.type === "string") {
+        const parts = [];
+        for (const block of msg.content) {
+          const b = block;
+          if (b.type === "text") {
+            parts.push({ type: "text", text: b.text });
+          } else if (b.type === "image") {
+            parts.push({
+              type: "image_url",
+              image_url: { url: `data:${b.mimeType};base64,${b.data}` }
+            });
+          } else if (b.type === "audio") {
+            const format = b.mimeType.replace(/^audio\//, "");
+            parts.push({
+              type: "input_audio",
+              input_audio: { data: b.data, format }
+            });
+          }
+        }
+        messages.push({ role: "user", content: parts });
+      } else {
+        try {
+          messages.push({ role: "user", content: JSON.stringify(msg.content) });
+        } catch {
+          messages.push({ role: "user", content: String(msg.content) });
+        }
+      }
+    } else if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        messages.push({ role: "assistant", content: msg.content.length > 0 ? msg.content : null });
+      } else if (Array.isArray(msg.content)) {
+        const textParts = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => ({
+          id: b.id,
+          type: "function",
+          function: {
+            name: b.name,
+            arguments: JSON.stringify(b.input)
+          }
+        }));
+        const entry = {
+          role: "assistant",
+          content: textParts.length > 0 ? textParts : null
+        };
+        if (toolCalls.length > 0) {
+          entry.tool_calls = toolCalls;
+        }
+        messages.push(entry);
+      }
+    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        const b = block;
+        let content;
+        if (typeof b.content === "string") {
+          content = b.content;
+        } else if (Array.isArray(b.content)) {
+          const parts = [];
+          for (const inner of b.content) {
+            if (inner.type === "text") {
+              parts.push({ type: "text", text: inner.text });
+            } else if (inner.type === "image") {
+              parts.push({
+                type: "image_url",
+                image_url: { url: `data:${inner.mimeType};base64,${inner.data}` }
+              });
+            }
+          }
+          content = parts;
+        } else {
+          content = "";
+        }
+        messages.push({
+          role: "tool",
+          content,
+          tool_call_id: b.tool_use_id
+        });
+      }
+    }
+  }
+  return messages;
+}
+function toTextFlatMessages(input) {
+  const messages = [];
+  if (input.systemPrompt) {
+    messages.push({ role: "system", content: input.systemPrompt });
+  }
+  const inputMessages = getInputMessages(input);
+  if (!inputMessages) {
+    let promptContent;
+    if (!Array.isArray(input.prompt)) {
+      promptContent = input.prompt;
+    } else {
+      promptContent = input.prompt.map((item) => {
+        if (typeof item === "string")
+          return item;
+        const b = item;
+        return b.type === "text" ? b.text : "";
+      }).filter((s) => s !== "").join(`
+`);
+    }
+    messages.push({ role: "user", content: promptContent });
+    return messages;
+  }
+  for (const msg of inputMessages) {
+    if (msg.role === "user") {
+      let content = "";
+      if (typeof msg.content === "string") {
+        content = msg.content;
+      } else if (Array.isArray(msg.content) && msg.content.length > 0 && typeof msg.content[0]?.type === "string") {
+        content = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      } else if (msg.content != null) {
+        try {
+          content = JSON.stringify(msg.content);
+        } catch {
+          content = String(msg.content);
+        }
+      }
+      messages.push({ role: "user", content });
+    } else if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        if (msg.content) {
+          messages.push({ role: "assistant", content: msg.content });
+        }
+      } else if (Array.isArray(msg.content)) {
+        const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        if (text) {
+          messages.push({ role: "assistant", content: text });
+        }
+      }
+    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        const b = block;
+        let content;
+        if (typeof b.content === "string") {
+          content = b.content;
+        } else if (Array.isArray(b.content)) {
+          content = b.content.filter((inner) => inner.type === "text").map((inner) => inner.text).join("");
+        } else {
+          content = "";
+        }
+        messages.push({ role: "tool", content });
+      }
+    }
+  }
+  return messages;
+}
 
 // src/task/index.ts
 var registerAiTasks = () => {
   const tasks = [
+    AgentTask,
     BackgroundRemovalTask,
     ChunkToVectorTask,
     CountTokensTask,
@@ -6377,6 +7370,7 @@ var registerAiTasks = () => {
     TextRewriterTask,
     TextSummaryTask,
     TextTranslationTask,
+    ToolCallingTask,
     TopicSegmenterTask,
     UnloadModelTask,
     VectorQuantizeTask,
@@ -6388,8 +7382,14 @@ var registerAiTasks = () => {
 export {
   vectorStoreSearch,
   vectorQuantize,
+  userMessage,
   unloadModel,
   topicSegmenter,
+  toolSourceDefinitions,
+  toolMessage,
+  toolCalling,
+  toTextFlatMessages,
+  toOpenAIMessages,
   textTranslation,
   textSummary,
   textRewriter,
@@ -6401,6 +7401,7 @@ export {
   textEmbedding,
   textClassification,
   textChunker,
+  taskTypesToTools,
   structuredGeneration,
   structuralParser,
   similarity,
@@ -6414,27 +7415,42 @@ export {
   objectDetection,
   modelSearch,
   modelInfo,
+  isAllowedToolName,
   imageToText,
   imageSegmentation,
   imageEmbedding,
   imageClassification,
+  imageBlockFromDataUri,
+  imageBlock,
   hybridSearch,
   hierarchyJoin,
   hierarchicalChunker,
+  hasToolCalls,
   handLandmarker,
   getGlobalModelRepository,
   getAiProviderRegistry,
   gestureRecognizer,
+  findToolSource,
+  filterValidToolCalls,
   faceLandmarker,
   faceDetector,
+  executeToolCalls,
+  executeToolCall,
   downloadModel,
   documentEnricher,
   countTokens,
+  countAssistantToolUses,
   contextBuilder,
   chunkVectorUpsert,
   chunkToVector,
   chunkRetrieval,
+  buildToolSources,
+  buildToolDescription,
   backgroundRemoval,
+  audioBlockFromDataUri,
+  audioBlock,
+  assistantMessage,
+  agent,
   VectorSimilarityTask,
   VectorQuantizeTask,
   UnloadModelTask,
@@ -6448,6 +7464,10 @@ export {
   TypeBoundingBox,
   TypeAudioInput,
   TopicSegmenterTask,
+  ToolDefinitionSchema,
+  ToolCallingTask,
+  ToolCallingOutputSchema,
+  ToolCallingInputSchema,
   TextTranslationTask,
   TextTranslationOutputSchema,
   TextTranslationInputSchema,
@@ -6551,7 +7571,10 @@ export {
   AiTask,
   AiProviderRegistry,
   AiProvider,
-  AiJob
+  AiJob,
+  AgentTask,
+  AgentOutputSchema,
+  AgentInputSchema
 };
 
-//# debugId=39A47C307F64351364756E2164756E21
+//# debugId=C73927E694BC881A64756E2164756E21