@workglow/ai 0.0.126 → 0.1.1

package/dist/bun.js

@@ -4,20 +4,36 @@ import {
   AbortSignalJobError,
   Job,
   JobStatus,
-  PermanentJobError
+  PermanentJobError,
+  RetryableJobError
 } from "@workglow/job-queue";
+import { getLogger } from "@workglow/util/worker";
 
 // src/provider/AiProviderRegistry.ts
 import { globalServiceRegistry, WORKER_MANAGER } from "@workglow/util/worker";
-
 class AiProviderRegistry {
   runFnRegistry = new Map;
   streamFnRegistry = new Map;
   reactiveRunFnRegistry = new Map;
   providers = new Map;
+  strategyResolvers = new Map;
+  defaultStrategy;
   registerProvider(provider) {
     this.providers.set(provider.name, provider);
   }
+  unregisterProvider(name) {
+    this.providers.delete(name);
+    this.strategyResolvers.delete(name);
+    for (const [, providerMap] of this.runFnRegistry) {
+      providerMap.delete(name);
+    }
+    for (const [, providerMap] of this.streamFnRegistry) {
+      providerMap.delete(name);
+    }
+    for (const [, providerMap] of this.reactiveRunFnRegistry) {
+      providerMap.delete(name);
+    }
+  }
   getProvider(name) {
     return this.providers.get(name);
   }
@@ -27,6 +43,18 @@ class AiProviderRegistry {
   getInstalledProviderIds() {
     return [...this.providers.keys()].sort();
   }
+  registerStrategyResolver(providerName, resolver) {
+    this.strategyResolvers.set(providerName, resolver);
+  }
+  getStrategy(model) {
+    const resolver = this.strategyResolvers.get(model.provider);
+    if (resolver)
+      return resolver(model);
+    if (!this.defaultStrategy) {
+      this.defaultStrategy = new DirectExecutionStrategy;
+    }
+    return this.defaultStrategy;
+  }
   getProviderIdsForTask(taskType) {
     const taskMap = this.runFnRegistry.get(taskType);
     if (!taskMap)
@@ -92,15 +120,16 @@ class AiProviderRegistry {
     const taskTypeMap = this.runFnRegistry.get(taskType);
     const runFn = taskTypeMap?.get(modelProvider);
     if (!runFn) {
-      throw new Error(`No run function found for task type ${taskType} and model provider ${modelProvider}`);
+      const installedProviders = this.getInstalledProviderIds();
+      const providersForTask = this.getProviderIdsForTask(taskType);
+      const hint = providersForTask.length > 0 ? ` Providers supporting "${taskType}": [${providersForTask.join(", ")}].` : installedProviders.length > 0 ? ` Installed providers: [${installedProviders.join(", ")}] (none support "${taskType}").` : " No providers are registered. Call provider.register() before running AI tasks.";
+      throw new Error(`No run function found for task type "${taskType}" and provider "${modelProvider}".${hint}`);
     }
     return runFn;
   }
 }
-var providerRegistry;
+var providerRegistry = new AiProviderRegistry;
 function getAiProviderRegistry() {
-  if (!providerRegistry)
-    providerRegistry = new AiProviderRegistry;
   return providerRegistry;
 }
 function setAiProviderRegistry(pr) {
@@ -108,6 +137,64 @@ function setAiProviderRegistry(pr) {
 }
 
 // src/job/AiJob.ts
+var DEFAULT_AI_TIMEOUT_MS = 120000;
+var LOCAL_MODEL_DEFAULT_TIMEOUT_MS = 600000;
+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;
+  }
+  return DEFAULT_AI_TIMEOUT_MS;
+}
+function classifyProviderError(err, taskType, provider) {
+  if (err instanceof PermanentJobError || err instanceof RetryableJobError || err instanceof AbortSignalJobError) {
+    return err;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  const status = typeof err?.status === "number" ? err.status : typeof err?.statusCode === "number" ? err.statusCode : (() => {
+    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 DOMException && err.name === "TimeoutError") {
+    return new AbortSignalJobError(`Provider call timed out for ${taskType} (${provider})`);
+  }
+  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}`);
+  }
+  if (message.startsWith("HFT_NULL_PROCESSOR:")) {
+    return new RetryableJobError(message);
+  }
+  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));
+  }
+  if (status === 401 || status === 403) {
+    return new PermanentJobError(`Authentication failed for ${provider} (${taskType}): ${message}`);
+  }
+  if (status === 400 || status === 404) {
+    return new PermanentJobError(`Invalid request to ${provider} for ${taskType}: ${message}`);
+  }
+  if (status && status >= 500) {
+    return new RetryableJobError(`Server error from ${provider} for ${taskType} (HTTP ${status}): ${message}`);
+  }
+  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}`);
+  }
+  if (message.includes("timed out") || message.includes("timeout")) {
+    return new RetryableJobError(`Timeout calling ${provider} for ${taskType}: ${message}`);
+  }
+  return new PermanentJobError(`Provider ${provider} failed for ${taskType}: ${message}`);
+}
+
 class AiJob extends Job {
   async execute(input, context) {
     if (context.signal.aborted || this.status === JobStatus.ABORTING) {
@@ -124,17 +211,19 @@ class AiJob extends Job {
       });
       const runFn = async () => {
         const fn = getAiProviderRegistry().getDirectRunFn(input.aiProvider, input.taskType);
-        if (!fn) {
-          throw new PermanentJobError(`No run function found for task type ${input.taskType} and model provider ${input.aiProvider}`);
-        }
         const model = input.taskInput.model;
-        if (context.signal?.aborted) {
+        if (context.signal.aborted) {
           throw new AbortSignalJobError("Job aborted");
         }
-        return await fn(input.taskInput, model, context.updateProgress, context.signal, input.outputSchema);
+        const timeoutMs = resolveAiJobTimeoutMs(input.aiProvider, input.timeoutMs);
+        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+        const combinedSignal = AbortSignal.any([context.signal, timeoutSignal]);
+        return await fn(input.taskInput, model, context.updateProgress, combinedSignal, input.outputSchema);
       };
       const runFnPromise = runFn();
       return await Promise.race([runFnPromise, abortPromise]);
+    } catch (err) {
+      throw classifyProviderError(err, input.taskType, input.aiProvider);
     } finally {
       if (abortHandler) {
         abortHandler();
@@ -152,35 +241,172 @@ class AiJob extends Job {
       return;
     }
     const model = input.taskInput.model;
-    yield* streamFn(input.taskInput, model, context.signal, input.outputSchema);
+    let lastFinishData;
+    const timeoutMs = resolveAiJobTimeoutMs(input.aiProvider, input.timeoutMs);
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const combinedSignal = AbortSignal.any([context.signal, timeoutSignal]);
+    try {
+      for await (const event of streamFn(input.taskInput, model, combinedSignal, input.outputSchema)) {
+        if (event.type === "finish") {
+          lastFinishData = event.data;
+        }
+        yield event;
+      }
+    } catch (err) {
+      const logger = getLogger();
+      logger.warn(`AiJob: Stream error for ${input.taskType} (${input.aiProvider}): ${err instanceof Error ? err.message : String(err)}`);
+      if (lastFinishData === undefined) {
+        yield { type: "finish", data: {} };
+      }
+      throw classifyProviderError(err, input.taskType, input.aiProvider);
+    }
   }
 }
 
-// src/task/ToolCallingUtils.ts
-import { getLogger } from "@workglow/util/worker";
-function buildToolDescription(tool) {
-  let desc = tool.description;
-  if (tool.outputSchema && typeof tool.outputSchema === "object") {
-    desc += `
-
-Returns: ${JSON.stringify(tool.outputSchema)}`;
+// src/execution/DirectExecutionStrategy.ts
+class DirectExecutionStrategy {
+  async execute(jobInput, context, runnerId) {
+    const job = new AiJob({
+      queueName: jobInput.aiProvider,
+      jobRunId: runnerId,
+      input: jobInput
+    });
+    const cleanup = job.onJobProgress((progress, message, details) => {
+      context.updateProgress(progress, message, details);
+    });
+    try {
+      return await job.execute(jobInput, {
+        signal: context.signal,
+        updateProgress: context.updateProgress
+      });
+    } finally {
+      cleanup();
+    }
   }
-  return desc;
-}
-function isAllowedToolName(name, allowedTools) {
-  return allowedTools.some((t) => t.name === name);
+  async* executeStream(jobInput, context, runnerId) {
+    const job = new AiJob({
+      queueName: jobInput.aiProvider,
+      jobRunId: runnerId,
+      input: jobInput
+    });
+    yield* job.executeStream(jobInput, {
+      signal: context.signal,
+      updateProgress: context.updateProgress
+    });
+  }
+  abort() {}
 }
-function filterValidToolCalls(toolCalls, allowedTools) {
-  return toolCalls.filter((tc) => {
-    if (tc.name && isAllowedToolName(tc.name, allowedTools)) {
-      return true;
+
+// src/execution/QueuedExecutionStrategy.ts
+import { ConcurrencyLimiter, JobQueueClient, JobQueueServer } from "@workglow/job-queue";
+import { InMemoryQueueStorage } from "@workglow/storage";
+import {
+  getTaskQueueRegistry,
+  TaskConfigurationError
+} from "@workglow/task-graph";
+class QueuedExecutionStrategy {
+  queueName;
+  concurrency;
+  autoCreate;
+  initPromise = null;
+  constructor(queueName, concurrency = 1, autoCreate = true) {
+    this.queueName = queueName;
+    this.concurrency = concurrency;
+    this.autoCreate = autoCreate;
+  }
+  async execute(jobInput, context, runnerId) {
+    if (context.signal.aborted) {
+      throw context.signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+    }
+    const registeredQueue = await this.ensureQueue();
+    const { client } = registeredQueue;
+    const handle = await client.submit(jobInput, {
+      jobRunId: runnerId,
+      maxRetries: 10
+    });
+    const onAbort = () => {
+      handle.abort().catch((err) => {
+        console.warn(`Failed to abort queued job`, err);
+      });
+    };
+    context.signal.addEventListener("abort", onAbort);
+    const cleanupProgress = handle.onProgress((progress, message, details) => {
+      context.updateProgress(progress, message, details);
+    });
+    try {
+      if (context.signal.aborted) {
+        throw context.signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+      }
+      const output = await handle.waitFor();
+      return output;
+    } finally {
+      cleanupProgress();
+      context.signal.removeEventListener("abort", onAbort);
     }
-    getLogger().warn(`Filtered out tool call with unknown name "${tc.name ?? "(missing)"}"`, {
-      callId: tc.id,
-      toolName: tc.name
+  }
+  abort() {}
+  async* executeStream(jobInput, context, runnerId) {
+    const result = await this.execute(jobInput, context, runnerId);
+    yield { type: "finish", data: result };
+  }
+  ensureQueue() {
+    if (!this.initPromise) {
+      this.initPromise = this.createQueue().catch((err) => {
+        this.initPromise = null;
+        throw err;
+      });
+    }
+    return this.initPromise;
+  }
+  async createQueue() {
+    const registry = getTaskQueueRegistry();
+    const existing = registry.getQueue(this.queueName);
+    if (existing) {
+      if (!existing.server.isRunning()) {
+        await existing.server.start();
+      }
+      return existing;
+    }
+    if (!this.autoCreate) {
+      throw new TaskConfigurationError(`Queue "${this.queueName}" is not registered and autoCreate is disabled. ` + `Register the queue before executing tasks with this provider.`);
+    }
+    const storage = new InMemoryQueueStorage(this.queueName);
+    await storage.setupDatabase();
+    const server = new JobQueueServer(AiJob, {
+      storage,
+      queueName: this.queueName,
+      limiter: new ConcurrencyLimiter(this.concurrency)
+    });
+    const client = new JobQueueClient({
+      storage,
+      queueName: this.queueName
     });
-    return false;
-  });
+    client.attach(server);
+    const registeredQueue = {
+      server,
+      client,
+      storage
+    };
+    try {
+      registry.registerQueue(registeredQueue);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("already exists")) {
+        server.stop().catch((stopErr) => {
+          console.warn("QueuedExecutionStrategy: failed to stop raced-out queue server", stopErr);
+        });
+        const raced = registry.getQueue(this.queueName);
+        if (raced) {
+          if (!raced.server.isRunning()) {
+            await raced.server.start();
+          }
+          return raced;
+        }
+      }
+      throw err;
+    }
+    await server.start();
+    return registeredQueue;
+  }
 }
 
 // src/model/InMemoryModelRepository.ts
@@ -353,6 +579,16 @@ import {
   globalServiceRegistry as globalServiceRegistry3,
   WORKER_MANAGER as WORKER_MANAGER2
 } from "@workglow/util/worker";
+function resolveAiProviderGpuQueueConcurrency(concurrency) {
+  if (concurrency === undefined) {
+    return 1;
+  }
+  if (typeof concurrency === "number") {
+    return concurrency;
+  }
+  return concurrency.gpu ?? 1;
+}
+
 class AiProvider {
   tasks;
   streamTasks;
@@ -412,7 +648,12 @@ class AiProvider {
       }
     }
     registry.registerProvider(this);
-    await this.afterRegister(options);
+    try {
+      await this.afterRegister(options);
+    } catch (err) {
+      registry.unregisterProvider(this.name);
+      throw err;
+    }
   }
   registerOnWorkerServer(workerServer) {
     if (!this.tasks) {
@@ -437,115 +678,28 @@ class AiProvider {
   async afterRegister(_options) {}
 }
 
-// src/queue/createDefaultQueue.ts
-import { ConcurrencyLimiter, JobQueueClient, JobQueueServer } from "@workglow/job-queue";
-import { InMemoryQueueStorage } from "@workglow/storage";
-import { getTaskQueueRegistry } from "@workglow/task-graph";
-async function createDefaultQueue(providerName, concurrency) {
-  const storage = new InMemoryQueueStorage(providerName);
-  await storage.setupDatabase();
-  const server = new JobQueueServer(AiJob, {
-    storage,
-    queueName: providerName,
-    limiter: new ConcurrencyLimiter(concurrency)
-  });
-  const client = new JobQueueClient({
-    storage,
-    queueName: providerName
-  });
-  client.attach(server);
-  getTaskQueueRegistry().registerQueue({ server, client, storage });
-  await server.start();
-}
-
 // src/provider/QueuedAiProvider.ts
 class QueuedAiProvider extends AiProvider {
+  queuedStrategy;
   async afterRegister(options) {
-    if (options.queue?.autoCreate !== false) {
-      await createDefaultQueue(this.name, options.queue?.concurrency ?? 1);
-    }
+    const autoCreate = options.queue?.autoCreate !== false;
+    this.queuedStrategy = new QueuedExecutionStrategy(`${this.name}_gpu`, resolveAiProviderGpuQueueConcurrency(options.queue?.concurrency), autoCreate);
+    getAiProviderRegistry().registerStrategyResolver(this.name, (model) => this.getStrategyForModel(model));
+  }
+  createQueuedStrategy(queueName, concurrency, options) {
+    const autoCreate = options.queue?.autoCreate !== false;
+    return new QueuedExecutionStrategy(queueName, concurrency, autoCreate);
+  }
+  getStrategyForModel(_model) {
+    return this.queuedStrategy;
   }
 }
 
 // src/task/index.ts
 import { TaskRegistry } from "@workglow/task-graph";
 
-// src/task/AgentTask.ts
-import {
-  CreateWorkflow as CreateWorkflow2,
-  Task,
-  Workflow as Workflow2
-} from "@workglow/task-graph";
-import { getLogger as getLogger3 } from "@workglow/util";
-
-// src/task/AgentTypes.ts
-import { parseDataUri } from "@workglow/util/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 } from "@workglow/task-graph";
-import { getLogger as getLogger2 } from "@workglow/util";
-
-// src/task/ToolCallingTask.ts
-import {
-  CreateWorkflow,
-  getTaskConstructors,
-  Workflow
-} from "@workglow/task-graph";
+// src/task/BackgroundRemovalTask.ts
+import { CreateWorkflow, Workflow } from "@workglow/task-graph";
 
 // src/task/base/AiTaskSchemas.ts
 var TypeLanguage = (annotations = {}) => ({
@@ -704,40 +858,56 @@ var TypeCategory = {
   description: "Classification category with label and score"
 };
 
-// src/task/base/StreamingAiTask.ts
-import {
-  getStreamingPorts
-} from "@workglow/task-graph";
+// src/task/base/AiVisionTask.ts
+import { convertImageDataToUseableForm } from "@workglow/util/media";
 
 // src/task/base/AiTask.ts
 import {
-  JobQueueTask,
-  TaskConfigurationError,
+  Task,
+  TaskConfigSchema,
+  TaskConfigurationError as TaskConfigurationError2,
   hasStructuredOutput
 } from "@workglow/task-graph";
 function schemaFormat(schema) {
   return typeof schema === "object" && schema !== null && "format" in schema ? schema.format : undefined;
 }
+var aiTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema["properties"]
+  },
+  additionalProperties: false
+};
 
-class AiTask extends JobQueueTask {
+class AiTask extends Task {
   static type = "AiTask";
-  constructor(input = {}, config = {}) {
-    super(input, config);
-    this.jobClass = AiJob;
+  static configSchema() {
+    return aiTaskConfigSchema;
   }
-  async getJobInput(input) {
+  async execute(input, executeContext) {
     const model = input.model;
     if (!model || typeof model !== "object") {
-      throw new TaskConfigurationError("AiTask: Model was not resolved to ModelConfig - this indicates a bug in the resolution system");
+      throw new TaskConfigurationError2("AiTask: 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 output = await strategy.execute(jobInput, executeContext, this.runConfig.runnerId);
+    return output;
+  }
+  async getJobInput(input) {
+    const model = input.model;
     const runtype = this.constructor.runtype ?? this.constructor.type;
     const jobInput = {
       taskType: runtype,
       aiProvider: model.provider,
       taskInput: input
     };
+    const taskTimeoutMs = this.config.timeout;
+    if (typeof taskTimeoutMs === "number" && taskTimeoutMs > 0) {
+      jobInput.timeoutMs = taskTimeoutMs;
+    }
     const inputOutputSchema = input.outputSchema;
-    if (inputOutputSchema && typeof inputOutputSchema === "object") {
+    if (inputOutputSchema && typeof inputOutputSchema === "object" && !Array.isArray(inputOutputSchema) && typeof inputOutputSchema.type === "string") {
       jobInput.outputSchema = inputOutputSchema;
     } else {
       const taskOutputSchema = this.outputSchema();
@@ -751,7 +921,7 @@ class AiTask extends JobQueueTask {
     const jobInput = await this.getJobInput(input);
     const resolvedQueueName = queueName ?? await this.getDefaultQueueName(input);
     if (!resolvedQueueName) {
-      throw new TaskConfigurationError("JobQueueTask: Unable to determine queue for AI provider");
+      throw new TaskConfigurationError2("AiTask: Unable to determine queue for AI provider");
     }
     const job = new AiJob({
       queueName: resolvedQueueName,
@@ -779,7 +949,7 @@ class AiTask extends JobQueueTask {
     const inputSchema = this.inputSchema();
     if (typeof inputSchema === "boolean") {
       if (inputSchema === false) {
-        throw new TaskConfigurationError(`AiTask: Input schema is 'false' and accepts no inputs`);
+        throw new TaskConfigurationError2(`AiTask: Input schema is 'false' and accepts no inputs`);
       }
       return true;
     }
@@ -789,17 +959,18 @@ class AiTask extends JobQueueTask {
       if (typeof model === "object" && model !== null) {
         const tasks = model.tasks;
         if (Array.isArray(tasks) && tasks.length > 0 && !tasks.includes(this.type)) {
-          throw new TaskConfigurationError(`AiTask: Model for '${key}' is not compatible with task '${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 TaskConfigurationError(`AiTask: Invalid model for '${key}' - expected ModelConfig 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.`);
       }
     }
     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 TaskConfigurationError(`AiTask: Invalid model for '${key}' - expected ModelConfig 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);
@@ -808,14 +979,14 @@ class AiTask extends JobQueueTask {
     const inputSchema = this.inputSchema();
     if (typeof inputSchema === "boolean") {
       if (inputSchema === false) {
-        throw new TaskConfigurationError(`AiTask: Input schema is 'false' and accepts no inputs`);
+        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);
+      const taskModels = await modelRepo.findModelsByTask(this.type) ?? [];
       for (const [key, propSchema] of modelTaskProperties) {
         const requestedModel = input[key];
         if (typeof requestedModel === "string") {
@@ -827,666 +998,29 @@ class AiTask extends JobQueueTask {
           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 jobInput = await this.getJobInput(input);
-    const queueName = await this.getDefaultQueueName(input);
-    const job = new AiJob({
-      queueName: queueName ?? this.type,
-      jobRunId: this.runConfig.runnerId,
-      input: jobInput
-    });
-    const ports = getStreamingPorts(this.outputSchema());
-    const defaultPort = ports.length > 0 ? ports[0].port : "text";
-    for await (const event of job.executeStream(jobInput, {
-      signal: context.signal,
-      updateProgress: context.updateProgress.bind(this)
-    })) {
-      if (event.type === "text-delta") {
-        yield { ...event, port: event.port ?? defaultPort };
-      } else if (event.type === "object-delta") {
-        yield { ...event, port: event.port ?? defaultPort };
-      } else {
-        yield event;
-      }
-    }
-  }
-}
-
-// src/task/ToolCallingTask.ts
-function 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}" \u2014 not found in task constructors registry (ServiceRegistry: ${registry ? "custom" : "default"})`);
-    }
-    const configSchema = "configSchema" in ctor && typeof ctor.configSchema === "function" ? ctor.configSchema() : undefined;
-    return {
-      name: ctor.type,
-      description: ctor.description ?? "",
-      inputSchema: ctor.inputSchema(),
-      outputSchema: ctor.outputSchema(),
-      ...configSchema ? { configSchema } : {},
-      taskType: name
-    };
-  });
-}
-var ToolDefinitionSchema = {
-  type: "object",
-  properties: {
-    name: {
-      type: "string",
-      title: "Name",
-      description: "The tool name"
-    },
-    description: {
-      type: "string",
-      title: "Description",
-      description: "A description of what the tool does"
-    },
-    inputSchema: {
-      type: "object",
-      title: "Input Schema",
-      description: "JSON Schema describing the tool's input parameters",
-      additionalProperties: true
-    },
-    outputSchema: {
-      type: "object",
-      title: "Output Schema",
-      description: "JSON Schema describing what the tool returns",
-      additionalProperties: true
-    },
-    configSchema: {
-      type: "object",
-      title: "Config Schema",
-      description: "JSON Schema describing the task's configuration options (not sent to the LLM)",
-      additionalProperties: true
-    },
-    config: {
-      type: "object",
-      title: "Config",
-      description: "Concrete configuration values for the backing task (not sent to the LLM)",
-      additionalProperties: true
-    }
-  },
-  required: ["name", "description", "inputSchema"],
-  additionalProperties: true
-};
-var ToolCallSchema = {
-  type: "object",
-  properties: {
-    id: {
-      type: "string",
-      title: "ID",
-      description: "Unique identifier for this tool call"
-    },
-    name: {
-      type: "string",
-      title: "Name",
-      description: "The name of the tool to invoke"
-    },
-    input: {
-      type: "object",
-      title: "Input",
-      description: "The input arguments for the tool call",
-      additionalProperties: true
-    }
-  },
-  required: ["id", "name", "input"],
-  additionalProperties: false
-};
-var modelSchema = TypeModel("model:ToolCallingTask");
-var ToolCallingInputSchema = {
-  type: "object",
-  properties: {
-    model: modelSchema,
-    prompt: {
-      oneOf: [
-        { type: "string", title: "Prompt", description: "The prompt to send to the model" },
-        {
-          type: "array",
-          title: "Prompt",
-          description: "The prompt as an array of strings or content blocks",
-          items: {
-            oneOf: [
-              { type: "string" },
-              {
-                type: "object",
-                properties: {
-                  type: { type: "string", enum: ["text", "image", "audio"] }
-                },
-                required: ["type"],
-                additionalProperties: true
-              }
-            ]
-          }
-        }
-      ],
-      title: "Prompt",
-      description: "The prompt to send to the model"
-    },
-    systemPrompt: {
-      type: "string",
-      title: "System Prompt",
-      description: "Optional system instructions for the model"
-    },
-    messages: {
-      type: "array",
-      title: "Messages",
-      description: "Full conversation history for multi-turn interactions. When provided, used instead of prompt to construct the messages array sent to the provider.",
-      items: {
-        type: "object",
-        properties: {
-          role: { type: "string", enum: ["user", "assistant", "tool"] },
-          content: {}
-        },
-        required: ["role", "content"],
-        additionalProperties: true
-      }
-    },
-    tools: {
-      type: "array",
-      format: "tasks",
-      title: "Tools",
-      description: "Tool definitions available for the model to call",
-      items: {
-        oneOf: [
-          { type: "string", format: "tasks", description: "Task type name" },
-          ToolDefinitionSchema
-        ]
-      }
-    },
-    toolChoice: {
-      type: "string",
-      title: "Tool Choice",
-      description: 'Controls tool selection: "auto" (model decides), "none" (no tools), "required" (must call a tool), or a specific tool name',
-      "x-ui-group": "Configuration"
-    },
-    maxTokens: {
-      type: "number",
-      title: "Max Tokens",
-      description: "The maximum number of tokens to generate",
-      minimum: 1,
-      "x-ui-group": "Configuration"
-    },
-    temperature: {
-      type: "number",
-      title: "Temperature",
-      description: "The temperature to use for sampling",
-      minimum: 0,
-      maximum: 2,
-      "x-ui-group": "Configuration"
-    }
-  },
-  required: ["model", "prompt", "tools"],
-  additionalProperties: false
-};
-var ToolCallingOutputSchema = {
-  type: "object",
-  properties: {
-    text: TypeSingleOrArray({
-      type: "string",
-      title: "Text",
-      description: "Any text content generated by the model",
-      "x-stream": "append"
-    }),
-    toolCalls: TypeSingleOrArray({
-      ...ToolCallSchema,
-      "x-stream": "object"
-    })
-  },
-  required: ["text", "toolCalls"],
-  additionalProperties: false
-};
-
-class ToolCallingTask extends StreamingAiTask {
-  static type = "ToolCallingTask";
-  static category = "AI Text Model";
-  static title = "Tool Calling";
-  static description = "Sends a prompt with tool definitions to a language model and returns text along with any tool calls the model requests";
-  static inputSchema() {
-    return ToolCallingInputSchema;
-  }
-  static outputSchema() {
-    return ToolCallingOutputSchema;
-  }
-}
-var toolCalling = (input, config) => {
-  return new ToolCallingTask({}, config).run(input);
-};
-Workflow.prototype.toolCalling = CreateWorkflow(ToolCallingTask);
-
-// src/task/AgentUtils.ts
-function buildToolSources(tools, registry) {
-  if (!tools || tools.length === 0)
-    return [];
-  const stringNames = tools.filter((t) => typeof t === "string");
-  const resolvedDefs = new Map(taskTypesToTools(stringNames, registry).map((d) => [d.taskType, d]));
-  const constructors = getTaskConstructors2(registry);
-  const sources = [];
-  for (const tool of tools) {
-    if (typeof tool === "string") {
-      const def = resolvedDefs.get(tool);
-      if (def) {
-        const { taskType, ...definition } = def;
-        sources.push({
-          type: "registry",
-          definition,
-          taskType
-        });
-      }
-    } else if (tool.execute) {
-      const { execute, configSchema: _cs, config: _c, ...definition } = tool;
-      sources.push({
-        type: "function",
-        definition,
-        run: execute
-      });
-    } else {
-      const ctor = constructors.get(tool.name);
-      if (ctor) {
-        const { execute: _e, configSchema: _cs, config: _c, ...definition } = tool;
-        sources.push({
-          type: "registry",
-          definition,
-          taskType: tool.name,
-          config: tool.config
-        });
-      } else {
-        const { execute: _e, configSchema: _cs, config: _c, ...definition } = tool;
-        sources.push({
-          type: "function",
-          definition,
-          run: async () => {
-            throw new Error(`No executor registered for tool "${tool.name}"`);
-          }
-        });
-      }
-    }
-  }
-  return sources;
-}
-async function executeToolCall(toolCall, sources, context, hooks) {
-  const source = findToolSource(sources, toolCall.name);
-  if (!source) {
-    getLogger2().warn(`AgentTask: Unknown tool "${toolCall.name}" \u2014 not found in tool sources`);
-    return {
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      output: { error: `Unknown tool: ${toolCall.name}` },
-      isError: true
-    };
-  }
-  let effectiveCall = toolCall;
-  if (hooks?.beforeToolCall) {
-    const decision = await hooks.beforeToolCall(toolCall, source);
-    if (decision.action === "deny") {
-      return {
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        output: { error: decision.reason ?? "Tool call denied by hook" },
-        isError: true
-      };
-    }
-    if (decision.action === "modify") {
-      effectiveCall = { ...toolCall, input: decision.input };
-    }
-  }
-  try {
-    let output;
-    switch (source.type) {
-      case "registry": {
-        const ctor = getTaskConstructors2(context.registry).get(source.taskType);
-        if (!ctor) {
-          throw new Error(`Task type "${source.taskType}" not found in TaskRegistry`);
-        }
-        const taskConfig = source.config ?? {};
-        const task = context.own(new ctor({}, taskConfig));
-        output = await task.run(effectiveCall.input) ?? {};
-        break;
-      }
-      case "function": {
-        output = await source.run(effectiveCall.input);
-        break;
-      }
-    }
-    let result = {
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      output,
-      isError: false
-    };
-    if (hooks?.afterToolCall) {
-      result = await hooks.afterToolCall(toolCall, result);
-    }
-    return result;
-  } catch (err) {
-    const error = err instanceof Error ? err : new Error(String(err));
-    if (hooks?.onToolError) {
-      const action = await hooks.onToolError(toolCall, error);
-      if (action.action === "result") {
-        return {
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          output: action.output,
-          isError: false
-        };
-      }
-    }
-    getLogger2().warn(`AgentTask: Tool "${toolCall.name}" failed: ${error.message}`);
-    return {
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      output: { error: error.message },
-      isError: true
-    };
-  }
-}
-async function executeToolCalls(toolCalls, sources, context, hooks, maxConcurrency = 5) {
-  const calls = toolCalls;
-  if (calls.length === 0)
-    return [];
-  const concurrency = Math.max(1, Math.min(maxConcurrency, calls.length));
-  const results = new Array(calls.length);
-  let cursor = 0;
-  const workers = Array.from({ length: concurrency }, async () => {
-    while (true) {
-      if (context.signal.aborted) {
-        throw context.signal.reason ?? new DOMException("The operation was aborted", "AbortError");
-      }
-      const position = cursor;
-      cursor += 1;
-      if (position >= calls.length)
-        return;
-      results[position] = await executeToolCall(calls[position], sources, context, hooks);
-    }
-  });
-  await Promise.all(workers);
-  return results;
-}
-function hasToolCalls(toolCalls) {
-  return toolCalls !== undefined && toolCalls.length > 0;
-}
-
-// src/task/AgentTask.ts
-var modelSchema2 = TypeModel("model:ToolCallingTask");
-var AgentInputSchema = {
-  type: "object",
-  properties: {
-    model: modelSchema2,
-    prompt: {
-      oneOf: [
-        { type: "string" },
-        {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              type: { type: "string", enum: ["text", "image", "audio"] }
-            },
-            required: ["type"],
-            additionalProperties: true
-          }
-        }
-      ],
-      title: "Prompt",
-      description: "The user prompt to start the agent loop. Can be a string or an array of content blocks (text, image, audio)."
-    },
-    systemPrompt: {
-      type: "string",
-      title: "System Prompt",
-      description: "Optional system instructions for the agent"
-    },
-    tools: {
-      type: "array",
-      format: "tasks",
-      title: "Tools",
-      description: "Tools available to the agent. Each entry is a task type name (string, resolved from TaskRegistry) or a full ToolDefinition object with optional config for configurable tasks.",
-      items: {
-        oneOf: [
-          { type: "string", format: "tasks", description: "Task type name" },
-          ToolDefinitionSchema
-        ]
-      }
-    },
-    stopTool: {
-      type: "string",
-      title: "Stop Tool",
-      description: "Name of a tool that signals agent completion. When called, the loop ends and the tool input becomes structuredOutput.",
-      "x-ui-group": "Configuration"
-    },
-    maxIterations: {
-      type: "number",
-      title: "Max Iterations",
-      description: "Maximum number of agent loop iterations (default: 10)",
-      minimum: 1,
-      "x-ui-group": "Configuration"
-    },
-    maxContextMessages: {
-      type: "number",
-      title: "Max Context Messages",
-      description: "Maximum messages in conversation history. Older messages are trimmed to prevent context overflow.",
-      minimum: 3,
-      "x-ui-group": "Configuration"
-    },
-    maxTokens: {
-      type: "number",
-      title: "Max Tokens",
-      description: "Maximum tokens per LLM call",
-      minimum: 1,
-      "x-ui-group": "Configuration"
-    },
-    temperature: {
-      type: "number",
-      title: "Temperature",
-      description: "Sampling temperature for LLM calls",
-      minimum: 0,
-      maximum: 2,
-      "x-ui-group": "Configuration"
-    }
-  },
-  required: ["model", "prompt"],
-  additionalProperties: false
-};
-var AgentOutputSchema = {
-  type: "object",
-  properties: {
-    text: {
-      type: "string",
-      title: "Text",
-      description: "The final text response from the agent",
-      "x-stream": "append"
-    },
-    messages: {
-      type: "array",
-      title: "Messages",
-      description: "Full conversation history including all tool calls and results",
-      items: {
-        type: "object",
-        additionalProperties: true
-      }
-    },
-    iterations: {
-      type: "number",
-      title: "Iterations",
-      description: "Number of LLM calls made during the agent loop"
-    },
-    toolCallCount: {
-      type: "number",
-      title: "Tool Call Count",
-      description: "Total number of tool calls executed"
-    },
-    structuredOutput: {
-      type: "object",
-      title: "Structured Output",
-      description: "Present when the agent terminated via a stop tool",
-      additionalProperties: true
-    }
-  },
-  required: ["text", "messages", "iterations", "toolCallCount"],
-  additionalProperties: false
-};
-
-class AgentTask extends Task {
-  static type = "AgentTask";
-  static category = "AI Agent";
-  static title = "Agent";
-  static description = "Multi-turn agentic loop that calls an LLM with tools, executes tool calls, and iterates until done";
-  static cacheable = false;
-  static inputSchema() {
-    return AgentInputSchema;
-  }
-  static outputSchema() {
-    return AgentOutputSchema;
-  }
-  async execute(input, context) {
-    let result;
-    for await (const event of this.agentLoop(input, context)) {
-      if (event.type === "finish") {
-        result = event.data;
-      }
-    }
-    if (!result) {
-      throw new Error("AgentTask: loop ended without producing output");
-    }
-    return result;
-  }
-  async* executeStream(input, context) {
-    yield* this.agentLoop(input, context);
-  }
-  async* agentLoop(input, context) {
-    const maxIterations = input.maxIterations ?? 10;
-    const hooks = this.config.hooks;
-    const maxConcurrency = this.config.maxConcurrency ?? 5;
-    const toolSources = this.resolveToolSources(input, context);
-    const toolDefs = this.resolveToolDefs(toolSources, input.stopTool);
-    const messages = [userMessage(input.prompt)];
-    let totalToolCalls = 0;
-    let finalText = "";
-    let structuredOutput;
-    for (let iteration = 0;iteration < maxIterations; iteration++) {
-      if (context.signal.aborted)
-        break;
-      if (hooks?.onIteration) {
-        const action = await hooks.onIteration(iteration, messages, { totalToolCalls });
-        if (action.action === "stop")
-          break;
-      }
-      await context.updateProgress(Math.round(iteration / maxIterations * 100), `Agent iteration ${iteration + 1}`);
-      const contextMessages = this.trimMessages(messages, input.maxContextMessages);
-      const llmTask = context.own(new ToolCallingTask({}, {}));
-      let iterationText = "";
-      let toolCalls = [];
-      for await (const event of llmTask.executeStream({
-        model: input.model,
-        prompt: input.prompt,
-        systemPrompt: input.systemPrompt,
-        tools: toolDefs,
-        messages: contextMessages,
-        maxTokens: input.maxTokens,
-        temperature: input.temperature
-      }, context)) {
-        if (event.type === "text-delta") {
-          yield { type: "text-delta", port: "text", textDelta: event.textDelta };
-          iterationText += event.textDelta;
-        } else if (event.type === "finish") {
-          const data = event.data;
-          iterationText = data?.text ?? iterationText;
-          if (data?.toolCalls) {
-            toolCalls = data.toolCalls ?? [];
-          }
-        }
-      }
-      finalText = iterationText;
-      messages.push(assistantMessage(iterationText, toolCalls));
-      if (input.stopTool) {
-        const stopCall = toolCalls.find((tc) => tc.name === input.stopTool);
-        if (stopCall) {
-          structuredOutput = stopCall.input;
-          break;
+            input[key] = undefined;
+          }
         }
       }
-      if (!hasToolCalls(toolCalls)) {
-        break;
-      }
-      const results = await executeToolCalls(toolCalls, toolSources, context, hooks, maxConcurrency);
-      totalToolCalls += results.length;
-      messages.push(toolMessage(results));
-    }
-    const output = {
-      text: finalText,
-      messages,
-      iterations: messages.filter((m) => m.role === "assistant").length,
-      toolCallCount: totalToolCalls,
-      ...structuredOutput !== undefined ? { structuredOutput } : {}
-    };
-    yield { type: "finish", data: output };
-  }
-  resolveToolSources(input, context) {
-    return buildToolSources(input.tools, context.registry);
-  }
-  resolveToolDefs(toolSources, stopTool) {
-    const defs = toolSourceDefinitions(toolSources);
-    if (stopTool && !defs.some((d) => d.name === stopTool)) {
-      defs.push({
-        name: stopTool,
-        description: "Call this tool when you have completed the task. Pass your final structured result as the input.",
-        inputSchema: { type: "object", additionalProperties: true }
-      });
     }
-    return defs;
-  }
-  trimMessages(messages, maxContextMessages) {
-    if (!maxContextMessages || messages.length <= maxContextMessages) {
-      return messages;
-    }
-    getLogger3().debug(`AgentTask: Trimming context from ${messages.length} to ${maxContextMessages} messages`);
-    const tail = messages.slice(1);
-    let startIdx = tail.length - (maxContextMessages - 1);
-    if (startIdx < 0)
-      startIdx = 0;
-    if (startIdx > 0 && startIdx < tail.length && tail[startIdx].role === "tool") {
-      startIdx -= 1;
-    }
-    return [messages[0], ...tail.slice(startIdx)];
+    return input;
   }
 }
-var agent = (input, config) => {
-  return new AgentTask({}, config).run(input);
-};
-Workflow2.prototype.agent = CreateWorkflow2(AgentTask);
-
-// src/task/BackgroundRemovalTask.ts
-import { CreateWorkflow as CreateWorkflow3, Workflow as Workflow3 } from "@workglow/task-graph";
 
 // src/task/base/AiVisionTask.ts
-import { convertImageDataToUseableForm } from "@workglow/util/media";
 class AiVisionTask extends AiTask {
   static type = "AiVisionTask";
   async getJobInput(input) {
     const jobInput = await super.getJobInput(input);
-    const registeredQueue = await this.resolveQueue(input);
-    const queueName = registeredQueue?.server.queueName;
+    const providerName = input.model.provider;
     const supports = ["Blob"];
     if (input.image) {
-      if (typeof queueName === "string" && queueName.startsWith("TENSORFLOW_MEDIAPIPE") && "ImageBitmap" in globalThis) {
+      if (typeof providerName === "string" && providerName.startsWith("TENSORFLOW_MEDIAPIPE") && "ImageBitmap" in globalThis) {
         supports.push("ImageBitmap");
-      } else if (typeof queueName === "string" && queueName.startsWith("TENSORFLOW_MEDIAPIPE") && "VideoFrame" in globalThis) {
+      } else if (typeof providerName === "string" && providerName.startsWith("TENSORFLOW_MEDIAPIPE") && "VideoFrame" in globalThis) {
         supports.push("VideoFrame");
       }
-      const image = await convertImageDataToUseableForm(input.image, supports);
+      const image = Array.isArray(input.image) ? await Promise.all(input.image.map((img) => convertImageDataToUseableForm(img, supports))) : await convertImageDataToUseableForm(input.image, supports);
       jobInput.taskInput.image = image;
     }
     return jobInput;
@@ -1494,7 +1028,7 @@ class AiVisionTask extends AiTask {
 }
 
 // src/task/BackgroundRemovalTask.ts
-var modelSchema3 = TypeModel("model:BackgroundRemovalTask");
+var modelSchema = TypeModel("model:BackgroundRemovalTask");
 var processedImageSchema = {
   type: "string",
   contentEncoding: "base64",
@@ -1506,7 +1040,7 @@ var BackgroundRemovalInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema3
+    model: modelSchema
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -1535,26 +1069,22 @@ class BackgroundRemovalTask extends AiVisionTask {
 var backgroundRemoval = (input, config) => {
   return new BackgroundRemovalTask({}, config).run(input);
 };
-Workflow3.prototype.backgroundRemoval = CreateWorkflow3(BackgroundRemovalTask);
+Workflow.prototype.backgroundRemoval = CreateWorkflow(BackgroundRemovalTask);
 
 // src/task/ChunkRetrievalTask.ts
 import { TypeKnowledgeBase } from "@workglow/knowledge-base";
-import {
-  CreateWorkflow as CreateWorkflow5,
-  Task as Task2,
-  Workflow as Workflow5
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow3, Task as Task2, Workflow as Workflow3 } from "@workglow/task-graph";
 import {
   isTypedArray,
   TypedArraySchema as TypedArraySchema2
 } from "@workglow/util/schema";
 
 // src/task/TextEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow4, Workflow as Workflow4 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow2, Workflow as Workflow2 } from "@workglow/task-graph";
 import {
   TypedArraySchema
 } from "@workglow/util/schema";
-var modelSchema4 = TypeModel("model:TextEmbeddingTask");
+var modelSchema2 = TypeModel("model:TextEmbeddingTask");
 var TextEmbeddingInputSchema = {
   type: "object",
   properties: {
@@ -1563,7 +1093,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema4
+    model: modelSchema2
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1595,7 +1125,7 @@ class TextEmbeddingTask extends AiTask {
 var textEmbedding = async (input, config) => {
   return new TextEmbeddingTask({}, config).run(input);
 };
-Workflow4.prototype.textEmbedding = CreateWorkflow4(TextEmbeddingTask);
+Workflow2.prototype.textEmbedding = CreateWorkflow2(TextEmbeddingTask);
 
 // src/task/ChunkRetrievalTask.ts
 var inputSchema = {
@@ -1787,15 +1317,11 @@ class ChunkRetrievalTask extends Task2 {
 var chunkRetrieval = (input, config) => {
   return new ChunkRetrievalTask({}, config).run(input);
 };
-Workflow5.prototype.chunkRetrieval = CreateWorkflow5(ChunkRetrievalTask);
+Workflow3.prototype.chunkRetrieval = CreateWorkflow3(ChunkRetrievalTask);
 
 // src/task/ChunkToVectorTask.ts
 import { ChunkRecordSchema } from "@workglow/knowledge-base";
-import {
-  CreateWorkflow as CreateWorkflow6,
-  Task as Task3,
-  Workflow as Workflow6
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow4, Task as Task3, Workflow as Workflow4 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema3
 } from "@workglow/util/schema";
@@ -1921,15 +1447,11 @@ class ChunkToVectorTask extends Task3 {
 var chunkToVector = (input, config) => {
   return new ChunkToVectorTask({}, config).run(input);
 };
-Workflow6.prototype.chunkToVector = CreateWorkflow6(ChunkToVectorTask);
+Workflow4.prototype.chunkToVector = CreateWorkflow4(ChunkToVectorTask);
 
 // src/task/ChunkVectorHybridSearchTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase2 } from "@workglow/knowledge-base";
-import {
-  CreateWorkflow as CreateWorkflow7,
-  Task as Task4,
-  Workflow as Workflow7
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow5, Task as Task4, Workflow as Workflow5 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema4
 } from "@workglow/util/schema";
@@ -2095,15 +1617,11 @@ class ChunkVectorHybridSearchTask extends Task4 {
 var hybridSearch = async (input, config) => {
   return new ChunkVectorHybridSearchTask({}, config).run(input);
 };
-Workflow7.prototype.hybridSearch = CreateWorkflow7(ChunkVectorHybridSearchTask);
+Workflow5.prototype.hybridSearch = CreateWorkflow5(ChunkVectorHybridSearchTask);
 
 // src/task/ChunkVectorSearchTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase3 } from "@workglow/knowledge-base";
-import {
-  CreateWorkflow as CreateWorkflow8,
-  Task as Task5,
-  Workflow as Workflow8
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow6, Task as Task5, Workflow as Workflow6 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util/schema";
@@ -2218,15 +1736,11 @@ class ChunkVectorSearchTask extends Task5 {
 var vectorStoreSearch = (input, config) => {
   return new ChunkVectorSearchTask({}, config).run(input);
 };
-Workflow8.prototype.vectorStoreSearch = CreateWorkflow8(ChunkVectorSearchTask);
+Workflow6.prototype.vectorStoreSearch = CreateWorkflow6(ChunkVectorSearchTask);
 
 // src/task/ChunkVectorUpsertTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase4 } from "@workglow/knowledge-base";
-import {
-  CreateWorkflow as CreateWorkflow9,
-  Task as Task6,
-  Workflow as Workflow9
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow7, Task as Task6, Workflow as Workflow7 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema6
 } from "@workglow/util/schema";
@@ -2340,28 +1854,28 @@ class ChunkVectorUpsertTask extends Task6 {
 var chunkVectorUpsert = (input, config) => {
   return new ChunkVectorUpsertTask({}, config).run(input);
 };
-Workflow9.prototype.chunkVectorUpsert = CreateWorkflow9(ChunkVectorUpsertTask);
+Workflow7.prototype.chunkVectorUpsert = CreateWorkflow7(ChunkVectorUpsertTask);
 
 // src/task/ContextBuilderTask.ts
 import { estimateTokens } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow11,
+  CreateWorkflow as CreateWorkflow9,
   Task as Task7,
-  Workflow as Workflow11
+  Workflow as Workflow9
 } from "@workglow/task-graph";
 
 // src/task/CountTokensTask.ts
-import { CreateWorkflow as CreateWorkflow10, Workflow as Workflow10 } from "@workglow/task-graph";
-var modelSchema5 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow8, Workflow as Workflow8 } from "@workglow/task-graph";
+var modelSchema3 = TypeModel("model");
 var CountTokensInputSchema = {
   type: "object",
   properties: {
-    text: TypeSingleOrArray({
+    text: {
       type: "string",
       title: "Text",
       description: "The text to count tokens for"
-    }),
-    model: modelSchema5
+    },
+    model: modelSchema3
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2369,11 +1883,11 @@ var CountTokensInputSchema = {
 var CountTokensOutputSchema = {
   type: "object",
   properties: {
-    count: TypeSingleOrArray({
+    count: {
       type: "number",
       title: "Token Count",
       description: "The number of tokens in the text"
-    })
+    }
   },
   required: ["count"],
   additionalProperties: false
@@ -2395,7 +1909,7 @@ class CountTokensTask extends AiTask {
 var countTokens = async (input, config) => {
   return new CountTokensTask({}, config).run(input);
 };
-Workflow10.prototype.countTokens = CreateWorkflow10(CountTokensTask);
+Workflow8.prototype.countTokens = CreateWorkflow8(CountTokensTask);
 
 // src/task/ContextBuilderTask.ts
 var ContextFormat = {
@@ -2405,7 +1919,7 @@ var ContextFormat = {
   MARKDOWN: "markdown",
   JSON: "json"
 };
-var modelSchema6 = TypeModel("model", {
+var modelSchema4 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting (optional, falls back to estimation)"
 });
@@ -2469,7 +1983,7 @@ var inputSchema6 = {
 
 `
     },
-    model: modelSchema6
+    model: modelSchema4
   },
   required: ["chunks"],
   additionalProperties: false
@@ -2695,30 +2209,26 @@ class ContextBuilderTask extends Task7 {
 var contextBuilder = (input, config) => {
   return new ContextBuilderTask({}, config).run(input);
 };
-Workflow11.prototype.contextBuilder = CreateWorkflow11(ContextBuilderTask);
+Workflow9.prototype.contextBuilder = CreateWorkflow9(ContextBuilderTask);
 
 // src/task/DocumentEnricherTask.ts
 import {
   getChildren,
   hasChildren
 } from "@workglow/knowledge-base";
-import {
-  CreateWorkflow as CreateWorkflow14,
-  Task as Task8,
-  Workflow as Workflow14
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow12, Task as Task8, Workflow as Workflow12 } from "@workglow/task-graph";
 
 // src/task/TextNamedEntityRecognitionTask.ts
-import { CreateWorkflow as CreateWorkflow12, Workflow as Workflow12 } from "@workglow/task-graph";
-var modelSchema7 = TypeModel("model:TextNamedEntityRecognitionTask");
+import { CreateWorkflow as CreateWorkflow10, Workflow as Workflow10 } from "@workglow/task-graph";
+var modelSchema5 = TypeModel("model:TextNamedEntityRecognitionTask");
 var TextNamedEntityRecognitionInputSchema = {
   type: "object",
   properties: {
-    text: TypeSingleOrArray({
+    text: {
       type: "string",
       title: "Text",
       description: "The text to extract named entities from"
-    }),
+    },
     blockList: {
       type: "array",
       items: {
@@ -2729,7 +2239,7 @@ var TextNamedEntityRecognitionInputSchema = {
       "x-ui-group": "Configuration",
       "x-ui-group-open": false
     },
-    model: modelSchema7
+    model: modelSchema5
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2737,7 +2247,7 @@ var TextNamedEntityRecognitionInputSchema = {
 var TextNamedEntityRecognitionOutputSchema = {
   type: "object",
   properties: {
-    entities: TypeSingleOrArray({
+    entities: {
       type: "array",
       items: {
         type: "object",
@@ -2763,7 +2273,7 @@ var TextNamedEntityRecognitionOutputSchema = {
       },
       title: "Entities",
       description: "The extracted named entities with their types, scores, and text"
-    })
+    }
   },
   required: ["entities"],
   additionalProperties: false
@@ -2784,20 +2294,60 @@ class TextNamedEntityRecognitionTask extends AiTask {
 var textNamedEntityRecognition = (input, config) => {
   return new TextNamedEntityRecognitionTask({}, config).run(input);
 };
-Workflow12.prototype.textNamedEntityRecognition = CreateWorkflow12(TextNamedEntityRecognitionTask);
+Workflow10.prototype.textNamedEntityRecognition = CreateWorkflow10(TextNamedEntityRecognitionTask);
 
 // src/task/TextSummaryTask.ts
-import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
-var modelSchema8 = TypeModel("model:TextSummaryTask");
+import { CreateWorkflow as CreateWorkflow11, Workflow as Workflow11 } from "@workglow/task-graph";
+
+// src/task/base/StreamingAiTask.ts
+import {
+  getStreamingPorts,
+  TaskConfigurationError as TaskConfigurationError3
+} from "@workglow/task-graph";
+class StreamingAiTask extends AiTask {
+  static type = "StreamingAiTask";
+  async* executeStream(input, context) {
+    const model = input.model;
+    if (!model || typeof model !== "object") {
+      throw new TaskConfigurationError3("StreamingAiTask: Model was not resolved to ModelConfig - this indicates a bug in the resolution system");
+    }
+    const jobInput = await this.getJobInput(input);
+    const strategy = getAiProviderRegistry().getStrategy(model);
+    const outSchema = this.outputSchema();
+    const ports = getStreamingPorts(outSchema);
+    let defaultPort = "text";
+    if (ports.length > 0) {
+      defaultPort = ports[0].port;
+    } else {
+      if (typeof outSchema === "object" && outSchema.properties) {
+        const firstProp = Object.keys(outSchema.properties)[0];
+        if (firstProp)
+          defaultPort = firstProp;
+      }
+    }
+    for await (const event of strategy.executeStream(jobInput, context, this.runConfig.runnerId)) {
+      if (event.type === "text-delta") {
+        yield { ...event, port: event.port ?? defaultPort };
+      } else if (event.type === "object-delta") {
+        yield { ...event, port: event.port ?? defaultPort };
+      } else {
+        yield event;
+      }
+    }
+  }
+}
+
+// src/task/TextSummaryTask.ts
+var modelSchema6 = TypeModel("model:TextSummaryTask");
 var TextSummaryInputSchema = {
   type: "object",
   properties: {
-    text: TypeSingleOrArray({
+    text: {
       type: "string",
       title: "Text",
       description: "The text to summarize"
-    }),
-    model: modelSchema8
+    },
+    model: modelSchema6
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2805,12 +2355,12 @@ var TextSummaryInputSchema = {
 var TextSummaryOutputSchema = {
   type: "object",
   properties: {
-    text: TypeSingleOrArray({
+    text: {
       type: "string",
       title: "Text",
       description: "The summarized text",
       "x-stream": "append"
-    })
+    }
   },
   required: ["text"],
   additionalProperties: false
@@ -2831,7 +2381,7 @@ class TextSummaryTask extends StreamingAiTask {
 var textSummary = async (input, config) => {
   return new TextSummaryTask({}, config).run(input);
 };
-Workflow13.prototype.textSummary = CreateWorkflow13(TextSummaryTask);
+Workflow11.prototype.textSummary = CreateWorkflow11(TextSummaryTask);
 
 // src/task/DocumentEnricherTask.ts
 var inputSchema7 = {
@@ -3062,15 +2612,15 @@ class DocumentEnricherTask extends Task8 {
 var documentEnricher = (input, config) => {
   return new DocumentEnricherTask({}, config).run(input);
 };
-Workflow14.prototype.documentEnricher = CreateWorkflow14(DocumentEnricherTask);
+Workflow12.prototype.documentEnricher = CreateWorkflow12(DocumentEnricherTask);
 
 // src/task/DownloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
-var modelSchema9 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
+var modelSchema7 = TypeModel("model");
 var DownloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema9
+    model: modelSchema7
   },
   required: ["model"],
   additionalProperties: false
@@ -3078,7 +2628,7 @@ var DownloadModelInputSchema = {
 var DownloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema9
+    model: modelSchema7
   },
   required: ["model"],
   additionalProperties: false
@@ -3132,11 +2682,11 @@ class DownloadModelTask extends AiTask {
 var downloadModel = (input, config) => {
   return new DownloadModelTask({}, config).run(input);
 };
-Workflow15.prototype.downloadModel = CreateWorkflow15(DownloadModelTask);
+Workflow13.prototype.downloadModel = CreateWorkflow13(DownloadModelTask);
 
 // src/task/FaceDetectorTask.ts
-import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
-var modelSchema10 = TypeModel("model:FaceDetectorTask");
+import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
+var modelSchema8 = TypeModel("model:FaceDetectorTask");
 var TypeBoundingBox2 = {
   type: "object",
   properties: {
@@ -3209,7 +2759,7 @@ var FaceDetectorInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema10,
+    model: modelSchema8,
     minDetectionConfidence: {
       type: "number",
       minimum: 0,
@@ -3263,11 +2813,11 @@ class FaceDetectorTask extends AiVisionTask {
 var faceDetector = (input, config) => {
   return new FaceDetectorTask({}, config).run(input);
 };
-Workflow16.prototype.faceDetector = CreateWorkflow16(FaceDetectorTask);
+Workflow14.prototype.faceDetector = CreateWorkflow14(FaceDetectorTask);
 
 // src/task/FaceLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
-var modelSchema11 = TypeModel("model:FaceLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
+var modelSchema9 = TypeModel("model:FaceLandmarkerTask");
 var TypeLandmark = {
   type: "object",
   properties: {
@@ -3339,7 +2889,7 @@ var FaceLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema11,
+    model: modelSchema9,
     numFaces: {
       type: "number",
       minimum: 1,
@@ -3425,11 +2975,11 @@ class FaceLandmarkerTask extends AiVisionTask {
 var faceLandmarker = (input, config) => {
   return new FaceLandmarkerTask({}, config).run(input);
 };
-Workflow17.prototype.faceLandmarker = CreateWorkflow17(FaceLandmarkerTask);
+Workflow15.prototype.faceLandmarker = CreateWorkflow15(FaceLandmarkerTask);
 
 // src/task/GestureRecognizerTask.ts
-import { CreateWorkflow as CreateWorkflow18, Workflow as Workflow18 } from "@workglow/task-graph";
-var modelSchema12 = TypeModel("model:GestureRecognizerTask");
+import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
+var modelSchema10 = TypeModel("model:GestureRecognizerTask");
 var TypeLandmark2 = {
   type: "object",
   properties: {
@@ -3521,7 +3071,7 @@ var GestureRecognizerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema12,
+    model: modelSchema10,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3593,11 +3143,11 @@ class GestureRecognizerTask extends AiVisionTask {
 var gestureRecognizer = (input, config) => {
   return new GestureRecognizerTask({}, config).run(input);
 };
-Workflow18.prototype.gestureRecognizer = CreateWorkflow18(GestureRecognizerTask);
+Workflow16.prototype.gestureRecognizer = CreateWorkflow16(GestureRecognizerTask);
 
 // src/task/HandLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow19, Workflow as Workflow19 } from "@workglow/task-graph";
-var modelSchema13 = TypeModel("model:HandLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
+var modelSchema11 = TypeModel("model:HandLandmarkerTask");
 var TypeLandmark3 = {
   type: "object",
   properties: {
@@ -3666,7 +3216,7 @@ var HandLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema13,
+    model: modelSchema11,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3738,7 +3288,7 @@ class HandLandmarkerTask extends AiVisionTask {
 var handLandmarker = (input, config) => {
   return new HandLandmarkerTask({}, config).run(input);
 };
-Workflow19.prototype.handLandmarker = CreateWorkflow19(HandLandmarkerTask);
+Workflow17.prototype.handLandmarker = CreateWorkflow17(HandLandmarkerTask);
 
 // src/task/HierarchicalChunkerTask.ts
 import {
@@ -3747,13 +3297,9 @@ import {
   getChildren as getChildren2,
   hasChildren as hasChildren2
 } from "@workglow/knowledge-base";
-import {
-  CreateWorkflow as CreateWorkflow20,
-  Task as Task9,
-  Workflow as Workflow20
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow18, Task as Task9, Workflow as Workflow18 } from "@workglow/task-graph";
 import { uuid4 } from "@workglow/util";
-var modelSchema14 = TypeModel("model", {
+var modelSchema12 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting"
 });
@@ -3797,7 +3343,7 @@ var inputSchema8 = {
       description: "Strategy for chunking",
       default: "hierarchical"
     },
-    model: modelSchema14
+    model: modelSchema12
   },
   required: ["doc_id", "documentTree"],
   additionalProperties: false
@@ -3976,18 +3522,14 @@ class HierarchicalChunkerTask extends Task9 {
 var hierarchicalChunker = (input, config) => {
   return new HierarchicalChunkerTask({}, config).run(input);
 };
-Workflow20.prototype.hierarchicalChunker = CreateWorkflow20(HierarchicalChunkerTask);
+Workflow18.prototype.hierarchicalChunker = CreateWorkflow18(HierarchicalChunkerTask);
 
 // src/task/HierarchyJoinTask.ts
 import {
   ChunkRecordArraySchema,
   TypeKnowledgeBase as TypeKnowledgeBase5
 } from "@workglow/knowledge-base";
-import {
-  CreateWorkflow as CreateWorkflow21,
-  Task as Task10,
-  Workflow as Workflow21
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow19, Task as Task10, Workflow as Workflow19 } from "@workglow/task-graph";
 var inputSchema9 = {
   type: "object",
   properties: {
@@ -4156,16 +3698,16 @@ class HierarchyJoinTask extends Task10 {
 var hierarchyJoin = (input, config) => {
   return new HierarchyJoinTask({}, config).run(input);
 };
-Workflow21.prototype.hierarchyJoin = CreateWorkflow21(HierarchyJoinTask);
+Workflow19.prototype.hierarchyJoin = CreateWorkflow19(HierarchyJoinTask);
 
 // src/task/ImageClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
-var modelSchema15 = TypeModel("model:ImageClassificationTask");
+import { CreateWorkflow as CreateWorkflow20, Workflow as Workflow20 } from "@workglow/task-graph";
+var modelSchema13 = TypeModel("model:ImageClassificationTask");
 var ImageClassificationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema15,
+    model: modelSchema13,
     categories: {
       type: "array",
       items: {
@@ -4219,23 +3761,19 @@ class ImageClassificationTask extends AiVisionTask {
 var imageClassification = (input, config) => {
   return new ImageClassificationTask({}, config).run(input);
 };
-Workflow22.prototype.imageClassification = CreateWorkflow22(ImageClassificationTask);
+Workflow20.prototype.imageClassification = CreateWorkflow20(ImageClassificationTask);
 
 // src/task/ImageEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow21, Workflow as Workflow21 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema7
 } from "@workglow/util/schema";
-var modelSchema16 = TypeModel("model:ImageEmbeddingTask");
-var embeddingSchema = TypedArraySchema7({
-  title: "Embedding",
-  description: "The image embedding vector"
-});
+var modelSchema14 = TypeModel("model:ImageEmbeddingTask");
 var ImageEmbeddingInputSchema = {
   type: "object",
   properties: {
-    image: TypeImageInput,
-    model: modelSchema16
+    image: TypeSingleOrArray(TypeImageInput),
+    model: modelSchema14
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -4243,7 +3781,10 @@ var ImageEmbeddingInputSchema = {
 var ImageEmbeddingOutputSchema = {
   type: "object",
   properties: {
-    vector: embeddingSchema
+    vector: TypeSingleOrArray(TypedArraySchema7({
+      title: "Embedding",
+      description: "The image embedding vector"
+    }))
   },
   required: ["vector"],
   additionalProperties: false
@@ -4264,16 +3805,16 @@ class ImageEmbeddingTask extends AiVisionTask {
 var imageEmbedding = (input, config) => {
   return new ImageEmbeddingTask({}, config).run(input);
 };
-Workflow23.prototype.imageEmbedding = CreateWorkflow23(ImageEmbeddingTask);
+Workflow21.prototype.imageEmbedding = CreateWorkflow21(ImageEmbeddingTask);
 
 // src/task/ImageSegmentationTask.ts
-import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
-var modelSchema17 = TypeModel("model:ImageSegmentationTask");
+import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
+var modelSchema15 = TypeModel("model:ImageSegmentationTask");
 var ImageSegmentationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema17,
+    model: modelSchema15,
     threshold: {
       type: "number",
       title: "Threshold",
@@ -4352,11 +3893,11 @@ class ImageSegmentationTask extends AiVisionTask {
 var imageSegmentation = (input, config) => {
   return new ImageSegmentationTask({}, config).run(input);
 };
-Workflow24.prototype.imageSegmentation = CreateWorkflow24(ImageSegmentationTask);
+Workflow22.prototype.imageSegmentation = CreateWorkflow22(ImageSegmentationTask);
 
 // src/task/ImageToTextTask.ts
-import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
-var modelSchema18 = TypeModel("model:ImageToTextTask");
+import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
+var modelSchema16 = TypeModel("model:ImageToTextTask");
 var generatedTextSchema = {
   type: "string",
   title: "Text",
@@ -4366,7 +3907,7 @@ var ImageToTextInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema18,
+    model: modelSchema16,
     maxTokens: {
       type: "number",
       title: "Max Tokens",
@@ -4407,18 +3948,15 @@ class ImageToTextTask extends AiVisionTask {
 var imageToText = (input, config) => {
   return new ImageToTextTask({}, config).run(input);
 };
-Workflow25.prototype.imageToText = CreateWorkflow25(ImageToTextTask);
+Workflow23.prototype.imageToText = CreateWorkflow23(ImageToTextTask);
 
 // src/task/ModelInfoTask.ts
-import {
-  CreateWorkflow as CreateWorkflow26,
-  Workflow as Workflow26
-} from "@workglow/task-graph";
-var modelSchema19 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
+var modelSchema17 = TypeModel("model");
 var ModelInfoInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema19,
+    model: modelSchema17,
     detail: {
       type: "string",
       enum: ["cached_status", "files", "files_with_metadata"],
@@ -4431,7 +3969,7 @@ var ModelInfoInputSchema = {
 var ModelInfoOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema19,
+    model: modelSchema17,
     is_local: { type: "boolean" },
     is_remote: { type: "boolean" },
     supports_browser: { type: "boolean" },
@@ -4481,10 +4019,10 @@ class ModelInfoTask extends AiTask {
 var modelInfo = (input, config) => {
   return new ModelInfoTask({}, config).run(input);
 };
-Workflow26.prototype.modelInfo = CreateWorkflow26(ModelInfoTask);
+Workflow24.prototype.modelInfo = CreateWorkflow24(ModelInfoTask);
 
 // src/task/ModelSearchTask.ts
-import { CreateWorkflow as CreateWorkflow27, Task as Task11, Workflow as Workflow27 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow25, Task as Task11, Workflow as Workflow25 } from "@workglow/task-graph";
 var ModelSearchInputSchema = {
   type: "object",
   properties: {
@@ -4575,11 +4113,11 @@ class ModelSearchTask extends Task11 {
 var modelSearch = (input, config) => {
   return new ModelSearchTask({}, config).run(input);
 };
-Workflow27.prototype.modelSearch = CreateWorkflow27(ModelSearchTask);
+Workflow25.prototype.modelSearch = CreateWorkflow25(ModelSearchTask);
 
 // src/task/ObjectDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
-var modelSchema20 = TypeModel("model:ObjectDetectionTask");
+import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
+var modelSchema18 = TypeModel("model:ObjectDetectionTask");
 var detectionSchema = {
   type: "object",
   properties: {
@@ -4604,7 +4142,7 @@ var ObjectDetectionInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema20,
+    model: modelSchema18,
     labels: {
       type: "array",
       items: {
@@ -4658,11 +4196,11 @@ class ObjectDetectionTask extends AiVisionTask {
 var objectDetection = (input, config) => {
   return new ObjectDetectionTask({}, config).run(input);
 };
-Workflow28.prototype.objectDetection = CreateWorkflow28(ObjectDetectionTask);
+Workflow26.prototype.objectDetection = CreateWorkflow26(ObjectDetectionTask);
 
 // src/task/PoseLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow29, Workflow as Workflow29 } from "@workglow/task-graph";
-var modelSchema21 = TypeModel("model:PoseLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow27, Workflow as Workflow27 } from "@workglow/task-graph";
+var modelSchema19 = TypeModel("model:PoseLandmarkerTask");
 var TypePoseLandmark = {
   type: "object",
   properties: {
@@ -4741,7 +4279,7 @@ var PoseLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema21,
+    model: modelSchema19,
     numPoses: {
       type: "number",
       minimum: 1,
@@ -4820,14 +4358,10 @@ class PoseLandmarkerTask extends AiVisionTask {
 var poseLandmarker = (input, config) => {
   return new PoseLandmarkerTask({}, config).run(input);
 };
-Workflow29.prototype.poseLandmarker = CreateWorkflow29(PoseLandmarkerTask);
+Workflow27.prototype.poseLandmarker = CreateWorkflow27(PoseLandmarkerTask);
 
 // src/task/QueryExpanderTask.ts
-import {
-  CreateWorkflow as CreateWorkflow30,
-  Task as Task12,
-  Workflow as Workflow30
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow28, Task as Task12, Workflow as Workflow28 } from "@workglow/task-graph";
 var QueryExpansionMethod = {
   MULTI_QUERY: "multi-query",
   HYDE: "hyde",
@@ -5037,26 +4571,22 @@ class QueryExpanderTask extends Task12 {
 var queryExpander = (input, config) => {
   return new QueryExpanderTask({}, config).run(input);
 };
-Workflow30.prototype.queryExpander = CreateWorkflow30(QueryExpanderTask);
+Workflow28.prototype.queryExpander = CreateWorkflow28(QueryExpanderTask);
 
 // src/task/RerankerTask.ts
-import {
-  CreateWorkflow as CreateWorkflow32,
-  Task as Task13,
-  Workflow as Workflow32
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow30, Task as Task13, Workflow as Workflow30 } from "@workglow/task-graph";
 
 // src/task/TextClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow31, Workflow as Workflow31 } from "@workglow/task-graph";
-var modelSchema22 = TypeModel("model:TextClassificationTask");
+import { CreateWorkflow as CreateWorkflow29, Workflow as Workflow29 } from "@workglow/task-graph";
+var modelSchema20 = TypeModel("model:TextClassificationTask");
 var TextClassificationInputSchema = {
   type: "object",
   properties: {
-    text: TypeSingleOrArray({
+    text: {
       type: "string",
       title: "Text",
       description: "The text to classify"
-    }),
+    },
     candidateLabels: {
       type: "array",
       items: {
@@ -5075,7 +4605,7 @@ var TextClassificationInputSchema = {
       description: "The maximum number of categories to return",
       "x-ui-group": "Configuration"
     },
-    model: modelSchema22
+    model: modelSchema20
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5083,7 +4613,7 @@ var TextClassificationInputSchema = {
 var TextClassificationOutputSchema = {
   type: "object",
   properties: {
-    categories: TypeSingleOrArray({
+    categories: {
       type: "array",
       items: {
         type: "object",
@@ -5104,7 +4634,7 @@ var TextClassificationOutputSchema = {
       },
       title: "Categories",
       description: "The classification categories with their scores"
-    })
+    }
   },
   required: ["categories"],
   additionalProperties: false
@@ -5125,7 +4655,7 @@ class TextClassificationTask extends AiTask {
 var textClassification = (input, config) => {
   return new TextClassificationTask({}, config).run(input);
 };
-Workflow31.prototype.textClassification = CreateWorkflow31(TextClassificationTask);
+Workflow29.prototype.textClassification = CreateWorkflow29(TextClassificationTask);
 
 // src/task/RerankerTask.ts
 var inputSchema11 = {
@@ -5349,15 +4879,11 @@ class RerankerTask extends Task13 {
 var reranker = (input, config) => {
   return new RerankerTask({}, config).run(input);
 };
-Workflow32.prototype.reranker = CreateWorkflow32(RerankerTask);
+Workflow30.prototype.reranker = CreateWorkflow30(RerankerTask);
 
 // src/task/StructuralParserTask.ts
 import { StructuralParser } from "@workglow/knowledge-base";
-import {
-  CreateWorkflow as CreateWorkflow33,
-  Task as Task14,
-  Workflow as Workflow33
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow31, Task as Task14, Workflow as Workflow31 } from "@workglow/task-graph";
 import { uuid4 as uuid42 } from "@workglow/util";
 var inputSchema12 = {
   type: "object",
@@ -5458,15 +4984,15 @@ class StructuralParserTask extends Task14 {
 var structuralParser = (input, config) => {
   return new StructuralParserTask({}, config).run(input);
 };
-Workflow33.prototype.structuralParser = CreateWorkflow33(StructuralParserTask);
+Workflow31.prototype.structuralParser = CreateWorkflow31(StructuralParserTask);
 
 // src/task/StructuredGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
-var modelSchema23 = TypeModel("model:StructuredGenerationTask");
+import { CreateWorkflow as CreateWorkflow32, Workflow as Workflow32 } from "@workglow/task-graph";
+var modelSchema21 = TypeModel("model:StructuredGenerationTask");
 var StructuredGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema23,
+    model: modelSchema21,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5529,14 +5055,10 @@ class StructuredGenerationTask extends StreamingAiTask {
 var structuredGeneration = (input, config) => {
   return new StructuredGenerationTask({}, config).run(input);
 };
-Workflow34.prototype.structuredGeneration = CreateWorkflow34(StructuredGenerationTask);
+Workflow32.prototype.structuredGeneration = CreateWorkflow32(StructuredGenerationTask);
 
 // src/task/TextChunkerTask.ts
-import {
-  CreateWorkflow as CreateWorkflow35,
-  Task as Task15,
-  Workflow as Workflow35
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow33, Task as Task15, Workflow as Workflow33 } from "@workglow/task-graph";
 var ChunkingStrategy = {
   FIXED: "fixed",
   SENTENCE: "sentence",
@@ -5785,20 +5307,20 @@ class TextChunkerTask extends Task15 {
 var textChunker = (input, config) => {
   return new TextChunkerTask({}, config).run(input);
 };
-Workflow35.prototype.textChunker = CreateWorkflow35(TextChunkerTask);
+Workflow33.prototype.textChunker = CreateWorkflow33(TextChunkerTask);
 
 // src/task/TextFillMaskTask.ts
-import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
-var modelSchema24 = TypeModel("model:TextFillMaskTask");
+import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
+var modelSchema22 = TypeModel("model:TextFillMaskTask");
 var TextFillMaskInputSchema = {
   type: "object",
   properties: {
-    text: TypeSingleOrArray({
+    text: {
       type: "string",
       title: "Text",
       description: "The text with a mask token to fill"
-    }),
-    model: modelSchema24
+    },
+    model: modelSchema22
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5806,7 +5328,7 @@ var TextFillMaskInputSchema = {
 var TextFillMaskOutputSchema = {
   type: "object",
   properties: {
-    predictions: TypeSingleOrArray({
+    predictions: {
       type: "array",
       items: {
         type: "object",
@@ -5832,7 +5354,7 @@ var TextFillMaskOutputSchema = {
       },
       title: "Predictions",
       description: "The predicted tokens to fill the mask with their scores and complete sequences"
-    })
+    }
   },
   required: ["predictions"],
   additionalProperties: false
@@ -5853,26 +5375,26 @@ class TextFillMaskTask extends AiTask {
 var textFillMask = (input, config) => {
   return new TextFillMaskTask({}, config).run(input);
 };
-Workflow36.prototype.textFillMask = CreateWorkflow36(TextFillMaskTask);
+Workflow34.prototype.textFillMask = CreateWorkflow34(TextFillMaskTask);
 
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
-var generatedTextSchema2 = TypeSingleOrArray({
+import { CreateWorkflow as CreateWorkflow35, Workflow as Workflow35 } from "@workglow/task-graph";
+var generatedTextSchema2 = {
   type: "string",
   title: "Text",
   description: "The generated text",
   "x-stream": "append"
-});
-var modelSchema25 = TypeModel("model:TextGenerationTask");
+};
+var modelSchema23 = TypeModel("model:TextGenerationTask");
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema25,
-    prompt: TypeSingleOrArray({
+    model: modelSchema23,
+    prompt: {
       type: "string",
       title: "Prompt",
       description: "The prompt to generate text from"
-    }),
+    },
     maxTokens: {
       type: "number",
       title: "Max Tokens",
@@ -5941,19 +5463,19 @@ class TextGenerationTask extends StreamingAiTask {
 var textGeneration = (input, config) => {
   return new TextGenerationTask({}, config).run(input);
 };
-Workflow37.prototype.textGeneration = CreateWorkflow37(TextGenerationTask);
+Workflow35.prototype.textGeneration = CreateWorkflow35(TextGenerationTask);
 
 // src/task/TextLanguageDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
-var modelSchema26 = TypeModel("model:TextLanguageDetectionTask");
+import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
+var modelSchema24 = TypeModel("model:TextLanguageDetectionTask");
 var TextLanguageDetectionInputSchema = {
   type: "object",
   properties: {
-    text: TypeSingleOrArray({
+    text: {
       type: "string",
       title: "Text",
       description: "The text to detect the language of"
-    }),
+    },
     maxLanguages: {
       type: "number",
       minimum: 0,
@@ -5962,7 +5484,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema26
+    model: modelSchema24
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5970,7 +5492,7 @@ var TextLanguageDetectionInputSchema = {
 var TextLanguageDetectionOutputSchema = {
   type: "object",
   properties: {
-    languages: TypeSingleOrArray({
+    languages: {
       type: "array",
       items: {
         type: "object",
@@ -5991,7 +5513,7 @@ var TextLanguageDetectionOutputSchema = {
       },
       title: "Languages",
       description: "The languages with their scores"
-    })
+    }
   },
   required: ["languages"],
   additionalProperties: false
@@ -6012,33 +5534,33 @@ class TextLanguageDetectionTask extends AiTask {
 var textLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask({}, config).run(input);
 };
-Workflow38.prototype.textLanguageDetection = CreateWorkflow38(TextLanguageDetectionTask);
+Workflow36.prototype.textLanguageDetection = CreateWorkflow36(TextLanguageDetectionTask);
 
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
-var contextSchema = TypeSingleOrArray({
+import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
+var contextSchema = {
   type: "string",
   title: "Context",
   description: "The context of the question"
-});
-var questionSchema = TypeSingleOrArray({
+};
+var questionSchema = {
   type: "string",
   title: "Question",
   description: "The question to answer"
-});
-var textSchema = TypeSingleOrArray({
+};
+var textSchema = {
   type: "string",
   title: "Text",
   description: "The generated text",
   "x-stream": "append"
-});
-var modelSchema27 = TypeModel("model:TextQuestionAnswerTask");
+};
+var modelSchema25 = TypeModel("model:TextQuestionAnswerTask");
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: contextSchema,
     question: questionSchema,
-    model: modelSchema27
+    model: modelSchema25
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -6067,25 +5589,25 @@ class TextQuestionAnswerTask extends StreamingAiTask {
 var textQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask({}, config).run(input);
 };
-Workflow39.prototype.textQuestionAnswer = CreateWorkflow39(TextQuestionAnswerTask);
+Workflow37.prototype.textQuestionAnswer = CreateWorkflow37(TextQuestionAnswerTask);
 
 // src/task/TextRewriterTask.ts
-import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
-var modelSchema28 = TypeModel("model:TextRewriterTask");
+import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
+var modelSchema26 = TypeModel("model:TextRewriterTask");
 var TextRewriterInputSchema = {
   type: "object",
   properties: {
-    text: TypeSingleOrArray({
+    text: {
       type: "string",
       title: "Text",
       description: "The text to rewrite"
-    }),
+    },
     prompt: {
       type: "string",
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     },
-    model: modelSchema28
+    model: modelSchema26
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -6093,12 +5615,12 @@ var TextRewriterInputSchema = {
 var TextRewriterOutputSchema = {
   type: "object",
   properties: {
-    text: TypeSingleOrArray({
+    text: {
       type: "string",
       title: "Text",
       description: "The rewritten text",
       "x-stream": "append"
-    })
+    }
   },
   required: ["text"],
   additionalProperties: false
@@ -6119,25 +5641,25 @@ class TextRewriterTask extends StreamingAiTask {
 var textRewriter = (input, config) => {
   return new TextRewriterTask({}, config).run(input);
 };
-Workflow40.prototype.textRewriter = CreateWorkflow40(TextRewriterTask);
+Workflow38.prototype.textRewriter = CreateWorkflow38(TextRewriterTask);
 
 // src/task/TextTranslationTask.ts
-import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
-var modelSchema29 = TypeModel("model:TextTranslationTask");
-var translationTextSchema = TypeSingleOrArray({
+import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
+var modelSchema27 = TypeModel("model:TextTranslationTask");
+var translationTextSchema = {
   type: "string",
   title: "Text",
   description: "The translated text",
   "x-stream": "replace"
-});
+};
 var TextTranslationInputSchema = {
   type: "object",
   properties: {
-    text: TypeSingleOrArray({
+    text: {
       type: "string",
       title: "Text",
       description: "The text to translate"
-    }),
+    },
     source_lang: TypeLanguage({
       title: "Source Language",
       description: "The source language",
@@ -6150,7 +5672,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     }),
-    model: modelSchema29
+    model: modelSchema27
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -6185,14 +5707,10 @@ class TextTranslationTask extends StreamingAiTask {
 var textTranslation = (input, config) => {
   return new TextTranslationTask({}, config).run(input);
 };
-Workflow41.prototype.textTranslation = CreateWorkflow41(TextTranslationTask);
+Workflow39.prototype.textTranslation = CreateWorkflow39(TextTranslationTask);
 
 // src/task/TopicSegmenterTask.ts
-import {
-  CreateWorkflow as CreateWorkflow42,
-  Task as Task16,
-  Workflow as Workflow42
-} from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow40, Task as Task16, Workflow as Workflow40 } from "@workglow/task-graph";
 var SegmentationMethod = {
   HEURISTIC: "heuristic",
   EMBEDDING_SIMILARITY: "embedding-similarity",
@@ -6472,15 +5990,15 @@ class TopicSegmenterTask extends Task16 {
 var topicSegmenter = (input, config) => {
   return new TopicSegmenterTask({}, config).run(input);
 };
-Workflow42.prototype.topicSegmenter = CreateWorkflow42(TopicSegmenterTask);
+Workflow40.prototype.topicSegmenter = CreateWorkflow40(TopicSegmenterTask);
 
 // src/task/UnloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow43, Workflow as Workflow43 } from "@workglow/task-graph";
-var modelSchema30 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
+var modelSchema28 = TypeModel("model");
 var UnloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema30
+    model: modelSchema28
   },
   required: ["model"],
   additionalProperties: false
@@ -6488,7 +6006,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema30
+    model: modelSchema28
   },
   required: ["model"],
   additionalProperties: false
@@ -6510,10 +6028,10 @@ class UnloadModelTask extends AiTask {
 var unloadModel = (input, config) => {
   return new UnloadModelTask({}, config).run(input);
 };
-Workflow43.prototype.unloadModel = CreateWorkflow43(UnloadModelTask);
+Workflow41.prototype.unloadModel = CreateWorkflow41(UnloadModelTask);
 
 // src/task/VectorQuantizeTask.ts
-import { CreateWorkflow as CreateWorkflow44, Task as Task17, Workflow as Workflow44 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow42, Task as Task17, Workflow as Workflow42 } from "@workglow/task-graph";
 import {
   normalizeNumberArray,
   TensorType,
@@ -6693,10 +6211,10 @@ class VectorQuantizeTask extends Task17 {
 var vectorQuantize = (input, config) => {
   return new VectorQuantizeTask({}, config).run(input);
 };
-Workflow44.prototype.vectorQuantize = CreateWorkflow44(VectorQuantizeTask);
+Workflow42.prototype.vectorQuantize = CreateWorkflow42(VectorQuantizeTask);
 
 // src/task/VectorSimilarityTask.ts
-import { CreateWorkflow as CreateWorkflow45, GraphAsTask, Workflow as Workflow45 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow43, GraphAsTask, Workflow as Workflow43 } from "@workglow/task-graph";
 import {
   cosineSimilarity,
   hammingSimilarity,
@@ -6802,208 +6320,11 @@ class VectorSimilarityTask extends GraphAsTask {
 var similarity = (input, config) => {
   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;
-}
+Workflow43.prototype.similarity = CreateWorkflow43(VectorSimilarityTask);
 
 // src/task/index.ts
 var registerAiTasks = () => {
   const tasks = [
-    AgentTask,
     BackgroundRemovalTask,
     ChunkToVectorTask,
     CountTokensTask,
@@ -7043,7 +6364,6 @@ var registerAiTasks = () => {
     TextRewriterTask,
     TextSummaryTask,
     TextTranslationTask,
-    ToolCallingTask,
     TopicSegmenterTask,
     UnloadModelTask,
     VectorQuantizeTask,
@@ -7055,14 +6375,8 @@ var registerAiTasks = () => {
 export {
   vectorStoreSearch,
   vectorQuantize,
-  userMessage,
   unloadModel,
   topicSegmenter,
-  toolSourceDefinitions,
-  toolMessage,
-  toolCalling,
-  toTextFlatMessages,
-  toOpenAIMessages,
   textTranslation,
   textSummary,
   textRewriter,
@@ -7074,12 +6388,12 @@ export {
   textEmbedding,
   textClassification,
   textChunker,
-  taskTypesToTools,
   structuredGeneration,
   structuralParser,
   similarity,
   setGlobalModelRepository,
   setAiProviderRegistry,
+  resolveAiProviderGpuQueueConcurrency,
   reranker,
   registerAiTasks,
   queryExpander,
@@ -7087,27 +6401,19 @@ 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,
@@ -7115,13 +6421,7 @@ export {
   chunkVectorUpsert,
   chunkToVector,
   chunkRetrieval,
-  buildToolSources,
-  buildToolDescription,
   backgroundRemoval,
-  audioBlockFromDataUri,
-  audioBlock,
-  assistantMessage,
-  agent,
   VectorSimilarityTask,
   VectorQuantizeTask,
   UnloadModelTask,
@@ -7135,10 +6435,6 @@ export {
   TypeBoundingBox,
   TypeAudioInput,
   TopicSegmenterTask,
-  ToolDefinitionSchema,
-  ToolCallingTask,
-  ToolCallingOutputSchema,
-  ToolCallingInputSchema,
   TextTranslationTask,
   TextTranslationOutputSchema,
   TextTranslationInputSchema,
@@ -7178,6 +6474,7 @@ export {
   SimilarityFn,
   SegmentationMethod,
   RerankerTask,
+  QueuedExecutionStrategy,
   QueuedAiProvider,
   QueryExpansionMethod,
   QueryExpanderTask,
@@ -7223,6 +6520,7 @@ export {
   FaceDetectorInputSchema,
   DownloadModelTask,
   DocumentEnricherTask,
+  DirectExecutionStrategy,
   CountTokensTask,
   CountTokensOutputSchema,
   CountTokensInputSchema,
@@ -7240,10 +6538,7 @@ export {
   AiTask,
   AiProviderRegistry,
   AiProvider,
-  AiJob,
-  AgentTask,
-  AgentOutputSchema,
-  AgentInputSchema
+  AiJob
 };
 
-//# debugId=18D97536243F610A64756E2164756E21
+//# debugId=833980E5CCD244A264756E2164756E21