@ai-sdk/workflow 0.0.0-bf6e4b15-20260402200305

package/dist/index.mjs

@@ -0,0 +1,1261 @@
+// src/workflow-agent.ts
+import {
+  Output
+} from "ai";
+import {
+  convertToLanguageModelPrompt,
+  mergeAbortSignals,
+  standardizePrompt
+} from "ai/internal";
+import { mergeCallbacks } from "ai/internal";
+
+// src/do-stream-step.ts
+import {
+  experimental_streamModelCall as streamModelCall
+} from "ai";
+import { gateway } from "ai";
+
+// src/serializable-schema.ts
+import { asSchema, jsonSchema } from "@ai-sdk/provider-utils";
+import { tool } from "ai";
+import Ajv from "ajv";
+function serializeToolSet(tools) {
+  return Object.fromEntries(
+    Object.entries(tools).map(([name, t]) => [
+      name,
+      {
+        description: t.description,
+        inputSchema: asSchema(t.inputSchema).jsonSchema
+      }
+    ])
+  );
+}
+function resolveSerializableTools(tools) {
+  const ajv = new Ajv();
+  return Object.fromEntries(
+    Object.entries(tools).map(([name, t]) => {
+      const validateFn = ajv.compile(t.inputSchema);
+      return [
+        name,
+        tool({
+          description: t.description,
+          inputSchema: jsonSchema(t.inputSchema, {
+            validate: (value) => {
+              if (validateFn(value)) {
+                return { success: true, value };
+              }
+              return {
+                success: false,
+                error: new Error(ajv.errorsText(validateFn.errors))
+              };
+            }
+          })
+        })
+      ];
+    })
+  );
+}
+
+// src/do-stream-step.ts
+async function doStreamStep(conversationPrompt, modelInit, writable, serializedTools, options) {
+  "use step";
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  let model;
+  if (typeof modelInit === "string") {
+    model = gateway.languageModel(modelInit);
+  } else if (typeof modelInit === "function") {
+    model = await modelInit();
+  } else {
+    throw new Error(
+      'Invalid "model initialization" argument. Must be a string or a function that returns a LanguageModel instance.'
+    );
+  }
+  const tools = serializedTools ? resolveSerializableTools(serializedTools) : void 0;
+  const { stream: modelStream } = await streamModelCall({
+    model,
+    // streamModelCall expects Prompt (ModelMessage[]) but we pass the
+    // pre-converted LanguageModelV4Prompt. standardizePrompt inside
+    // streamModelCall handles both formats.
+    messages: conversationPrompt,
+    tools,
+    toolChoice: options == null ? void 0 : options.toolChoice,
+    includeRawChunks: options == null ? void 0 : options.includeRawChunks,
+    providerOptions: options == null ? void 0 : options.providerOptions,
+    abortSignal: options == null ? void 0 : options.abortSignal,
+    headers: options == null ? void 0 : options.headers,
+    maxOutputTokens: options == null ? void 0 : options.maxOutputTokens,
+    temperature: options == null ? void 0 : options.temperature,
+    topP: options == null ? void 0 : options.topP,
+    topK: options == null ? void 0 : options.topK,
+    presencePenalty: options == null ? void 0 : options.presencePenalty,
+    frequencyPenalty: options == null ? void 0 : options.frequencyPenalty,
+    stopSequences: options == null ? void 0 : options.stopSequences,
+    seed: options == null ? void 0 : options.seed,
+    repairToolCall: options == null ? void 0 : options.repairToolCall
+  });
+  const toolCalls = [];
+  const providerExecutedToolResults = /* @__PURE__ */ new Map();
+  let finish;
+  let text = "";
+  const reasoningParts = [];
+  let responseMetadata;
+  let warnings;
+  const writer = writable == null ? void 0 : writable.getWriter();
+  try {
+    for await (const part of modelStream) {
+      switch (part.type) {
+        case "text-delta":
+          text += part.text;
+          break;
+        case "reasoning-delta":
+          reasoningParts.push({ text: part.text });
+          break;
+        case "tool-call": {
+          const toolCallPart = part;
+          toolCalls.push({
+            type: "tool-call",
+            toolCallId: toolCallPart.toolCallId,
+            toolName: toolCallPart.toolName,
+            input: toolCallPart.input,
+            providerExecuted: toolCallPart.providerExecuted,
+            providerMetadata: toolCallPart.providerMetadata,
+            dynamic: toolCallPart.dynamic,
+            invalid: toolCallPart.invalid,
+            error: toolCallPart.error
+          });
+          break;
+        }
+        case "tool-result":
+          if (part.providerExecuted) {
+            providerExecutedToolResults.set(part.toolCallId, {
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              result: part.output,
+              isError: false
+            });
+          }
+          break;
+        case "tool-error": {
+          const errorPart = part;
+          if (errorPart.providerExecuted) {
+            providerExecutedToolResults.set(errorPart.toolCallId, {
+              toolCallId: errorPart.toolCallId,
+              toolName: errorPart.toolName,
+              result: errorPart.error,
+              isError: true
+            });
+          }
+          break;
+        }
+        case "model-call-end":
+          finish = {
+            finishReason: part.finishReason,
+            rawFinishReason: part.rawFinishReason,
+            usage: part.usage,
+            providerMetadata: part.providerMetadata
+          };
+          break;
+        case "model-call-start":
+          warnings = part.warnings;
+          break;
+        case "model-call-response-metadata":
+          responseMetadata = part;
+          break;
+      }
+      if (writer) {
+        await writer.write(part);
+      }
+    }
+  } finally {
+    writer == null ? void 0 : writer.releaseLock();
+  }
+  const reasoningText = reasoningParts.map((r) => r.text).join("") || void 0;
+  const step = {
+    callId: "workflow-agent",
+    stepNumber: 0,
+    model: {
+      provider: (_b = (_a = responseMetadata == null ? void 0 : responseMetadata.modelId) == null ? void 0 : _a.split(":")[0]) != null ? _b : "unknown",
+      modelId: (_c = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _c : "unknown"
+    },
+    functionId: void 0,
+    metadata: void 0,
+    experimental_context: void 0,
+    content: [
+      ...text ? [{ type: "text", text }] : [],
+      ...toolCalls.filter((tc) => !tc.invalid).map((tc) => ({
+        type: "tool-call",
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        input: tc.input,
+        ...tc.dynamic ? { dynamic: true } : {}
+      }))
+    ],
+    text,
+    reasoning: reasoningParts.map((r) => ({
+      type: "reasoning",
+      text: r.text
+    })),
+    reasoningText,
+    files: [],
+    sources: [],
+    toolCalls: toolCalls.filter((tc) => !tc.invalid).map((tc) => ({
+      type: "tool-call",
+      toolCallId: tc.toolCallId,
+      toolName: tc.toolName,
+      input: tc.input,
+      ...tc.dynamic ? { dynamic: true } : {}
+    })),
+    staticToolCalls: [],
+    dynamicToolCalls: toolCalls.filter((tc) => !tc.invalid && tc.dynamic).map((tc) => ({
+      type: "tool-call",
+      toolCallId: tc.toolCallId,
+      toolName: tc.toolName,
+      input: tc.input,
+      dynamic: true
+    })),
+    toolResults: [],
+    staticToolResults: [],
+    dynamicToolResults: [],
+    finishReason: (_d = finish == null ? void 0 : finish.finishReason) != null ? _d : "other",
+    rawFinishReason: finish == null ? void 0 : finish.rawFinishReason,
+    usage: (_e = finish == null ? void 0 : finish.usage) != null ? _e : {
+      inputTokens: 0,
+      inputTokenDetails: {
+        noCacheTokens: void 0,
+        cacheReadTokens: void 0,
+        cacheWriteTokens: void 0
+      },
+      outputTokens: 0,
+      outputTokenDetails: {
+        textTokens: void 0,
+        reasoningTokens: void 0
+      },
+      totalTokens: 0
+    },
+    warnings,
+    request: { body: "" },
+    response: {
+      id: (_f = responseMetadata == null ? void 0 : responseMetadata.id) != null ? _f : "unknown",
+      timestamp: (_g = responseMetadata == null ? void 0 : responseMetadata.timestamp) != null ? _g : /* @__PURE__ */ new Date(),
+      modelId: (_h = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _h : "unknown",
+      messages: []
+    },
+    providerMetadata: (_i = finish == null ? void 0 : finish.providerMetadata) != null ? _i : {}
+  };
+  return {
+    toolCalls,
+    finish,
+    step,
+    providerExecutedToolResults
+  };
+}
+
+// src/stream-text-iterator.ts
+async function* streamTextIterator({
+  prompt,
+  tools = {},
+  writable,
+  model,
+  stopConditions,
+  maxSteps,
+  onStepFinish,
+  onStepStart,
+  onError,
+  prepareStep,
+  generationSettings,
+  toolChoice,
+  experimental_context,
+  experimental_telemetry,
+  includeRawChunks = false,
+  repairToolCall,
+  responseFormat
+}) {
+  var _a;
+  let conversationPrompt = [...prompt];
+  let currentModel = model;
+  let currentGenerationSettings = generationSettings != null ? generationSettings : {};
+  let currentToolChoice = toolChoice;
+  let currentContext = experimental_context;
+  let currentActiveTools;
+  const steps = [];
+  let done = false;
+  let isFirstIteration = true;
+  let stepNumber = 0;
+  let lastStep;
+  let lastStepWasToolCalls = false;
+  const effectiveMaxSteps = maxSteps != null ? maxSteps : Infinity;
+  while (!done) {
+    if (stepNumber >= effectiveMaxSteps) {
+      break;
+    }
+    if ((_a = currentGenerationSettings.abortSignal) == null ? void 0 : _a.aborted) {
+      break;
+    }
+    if (prepareStep) {
+      const prepareResult = await prepareStep({
+        model: currentModel,
+        stepNumber,
+        steps,
+        messages: conversationPrompt,
+        experimental_context: currentContext
+      });
+      if (prepareResult.model !== void 0) {
+        currentModel = prepareResult.model;
+      }
+      if (prepareResult.messages !== void 0) {
+        conversationPrompt = [...prepareResult.messages];
+      }
+      if (prepareResult.system !== void 0) {
+        if (conversationPrompt.length > 0 && conversationPrompt[0].role === "system") {
+          conversationPrompt[0] = {
+            role: "system",
+            content: prepareResult.system
+          };
+        } else {
+          conversationPrompt.unshift({
+            role: "system",
+            content: prepareResult.system
+          });
+        }
+      }
+      if (prepareResult.experimental_context !== void 0) {
+        currentContext = prepareResult.experimental_context;
+      }
+      if (prepareResult.activeTools !== void 0) {
+        currentActiveTools = prepareResult.activeTools;
+      }
+      if (prepareResult.maxOutputTokens !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          maxOutputTokens: prepareResult.maxOutputTokens
+        };
+      }
+      if (prepareResult.temperature !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          temperature: prepareResult.temperature
+        };
+      }
+      if (prepareResult.topP !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          topP: prepareResult.topP
+        };
+      }
+      if (prepareResult.topK !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          topK: prepareResult.topK
+        };
+      }
+      if (prepareResult.presencePenalty !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          presencePenalty: prepareResult.presencePenalty
+        };
+      }
+      if (prepareResult.frequencyPenalty !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          frequencyPenalty: prepareResult.frequencyPenalty
+        };
+      }
+      if (prepareResult.stopSequences !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          stopSequences: prepareResult.stopSequences
+        };
+      }
+      if (prepareResult.seed !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          seed: prepareResult.seed
+        };
+      }
+      if (prepareResult.maxRetries !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          maxRetries: prepareResult.maxRetries
+        };
+      }
+      if (prepareResult.headers !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          headers: prepareResult.headers
+        };
+      }
+      if (prepareResult.providerOptions !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          providerOptions: prepareResult.providerOptions
+        };
+      }
+      if (prepareResult.toolChoice !== void 0) {
+        currentToolChoice = prepareResult.toolChoice;
+      }
+    }
+    if (onStepStart) {
+      await onStepStart({
+        stepNumber,
+        model: currentModel,
+        messages: conversationPrompt
+      });
+    }
+    try {
+      const effectiveTools = currentActiveTools && currentActiveTools.length > 0 ? filterToolSet(tools, currentActiveTools) : tools;
+      const serializedTools = serializeToolSet(effectiveTools);
+      const { toolCalls, finish, step, providerExecutedToolResults } = await doStreamStep(
+        conversationPrompt,
+        currentModel,
+        writable,
+        serializedTools,
+        {
+          ...currentGenerationSettings,
+          toolChoice: currentToolChoice,
+          includeRawChunks,
+          experimental_telemetry,
+          repairToolCall,
+          responseFormat
+        }
+      );
+      isFirstIteration = false;
+      stepNumber++;
+      steps.push(step);
+      lastStep = step;
+      lastStepWasToolCalls = false;
+      const finishReason = finish == null ? void 0 : finish.finishReason;
+      if (finishReason === "tool-calls") {
+        lastStepWasToolCalls = true;
+        conversationPrompt.push({
+          role: "assistant",
+          content: toolCalls.map((toolCall) => {
+            const sanitizedMetadata = sanitizeProviderMetadataForToolCall(
+              toolCall.providerMetadata
+            );
+            return {
+              type: "tool-call",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.input,
+              ...sanitizedMetadata != null ? { providerOptions: sanitizedMetadata } : {}
+            };
+          })
+        });
+        const toolResults = yield {
+          toolCalls,
+          messages: conversationPrompt,
+          step,
+          context: currentContext,
+          providerExecutedToolResults
+        };
+        conversationPrompt.push({
+          role: "tool",
+          content: toolResults
+        });
+        if (stopConditions) {
+          const stopConditionList = Array.isArray(stopConditions) ? stopConditions : [stopConditions];
+          if (stopConditionList.some((test) => test({ steps }))) {
+            done = true;
+          }
+        }
+      } else if (finishReason === "stop") {
+        const textContent = step.content.filter(
+          (item) => item.type === "text"
+        );
+        if (textContent.length > 0) {
+          conversationPrompt.push({
+            role: "assistant",
+            content: textContent
+          });
+        }
+        done = true;
+      } else if (finishReason === "length") {
+        done = true;
+      } else if (finishReason === "content-filter") {
+        done = true;
+      } else if (finishReason === "error") {
+        done = true;
+      } else if (finishReason === "other") {
+        done = true;
+      } else if (finishReason === "unknown") {
+        done = true;
+      } else if (!finishReason) {
+        done = true;
+      } else {
+        throw new Error(
+          `Unexpected finish reason: ${typeof (finish == null ? void 0 : finish.finishReason) === "object" ? JSON.stringify(finish == null ? void 0 : finish.finishReason) : finish == null ? void 0 : finish.finishReason}`
+        );
+      }
+      if (onStepFinish) {
+        await onStepFinish(step);
+      }
+    } catch (error) {
+      if (onError) {
+        await onError({ error });
+      }
+      throw error;
+    }
+  }
+  if (lastStep && !lastStepWasToolCalls) {
+    yield {
+      toolCalls: [],
+      messages: conversationPrompt,
+      step: lastStep,
+      context: currentContext
+    };
+  }
+  return conversationPrompt;
+}
+function filterToolSet(tools, activeTools) {
+  const filtered = {};
+  for (const toolName of activeTools) {
+    if (toolName in tools) {
+      filtered[toolName] = tools[toolName];
+    }
+  }
+  return filtered;
+}
+function sanitizeProviderMetadataForToolCall(metadata) {
+  if (metadata == null) return void 0;
+  const meta = metadata;
+  if ("openai" in meta && meta.openai != null) {
+    const { openai, ...restProviders } = meta;
+    const openaiMeta = openai;
+    const { itemId: _itemId, ...restOpenai } = openaiMeta;
+    const hasOtherOpenaiFields = Object.keys(restOpenai).length > 0;
+    const hasOtherProviders = Object.keys(restProviders).length > 0;
+    if (hasOtherOpenaiFields && hasOtherProviders) {
+      return { ...restProviders, openai: restOpenai };
+    } else if (hasOtherOpenaiFields) {
+      return { openai: restOpenai };
+    } else if (hasOtherProviders) {
+      return restProviders;
+    }
+    return void 0;
+  }
+  return meta;
+}
+
+// src/workflow-agent.ts
+var WorkflowAgent = class {
+  constructor(options) {
+    var _a, _b;
+    this.model = options.model;
+    this.tools = (_a = options.tools) != null ? _a : {};
+    this.instructions = (_b = options.instructions) != null ? _b : options.system;
+    this.toolChoice = options.toolChoice;
+    this.telemetry = options.experimental_telemetry;
+    this.experimentalContext = options.experimental_context;
+    this.prepareStep = options.prepareStep;
+    this.constructorOnStepFinish = options.onStepFinish;
+    this.constructorOnFinish = options.onFinish;
+    this.constructorOnStart = options.experimental_onStart;
+    this.constructorOnStepStart = options.experimental_onStepStart;
+    this.constructorOnToolCallStart = options.experimental_onToolCallStart;
+    this.constructorOnToolCallFinish = options.experimental_onToolCallFinish;
+    this.prepareCall = options.prepareCall;
+    this.generationSettings = {
+      maxOutputTokens: options.maxOutputTokens,
+      temperature: options.temperature,
+      topP: options.topP,
+      topK: options.topK,
+      presencePenalty: options.presencePenalty,
+      frequencyPenalty: options.frequencyPenalty,
+      stopSequences: options.stopSequences,
+      seed: options.seed,
+      maxRetries: options.maxRetries,
+      abortSignal: options.abortSignal,
+      headers: options.headers,
+      providerOptions: options.providerOptions
+    };
+  }
+  generate() {
+    throw new Error("Not implemented");
+  }
+  async stream(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    let effectiveModel = this.model;
+    let effectiveInstructions = (_a = options.system) != null ? _a : this.instructions;
+    let effectiveMessages = options.messages;
+    let effectiveGenerationSettings = { ...this.generationSettings };
+    let effectiveExperimentalContext = (_b = options.experimental_context) != null ? _b : this.experimentalContext;
+    let effectiveToolChoiceFromPrepare = (_c = options.toolChoice) != null ? _c : this.toolChoice;
+    let effectiveTelemetryFromPrepare = (_d = options.experimental_telemetry) != null ? _d : this.telemetry;
+    if (this.prepareCall) {
+      const prepared = await this.prepareCall({
+        model: effectiveModel,
+        tools: this.tools,
+        instructions: effectiveInstructions,
+        toolChoice: effectiveToolChoiceFromPrepare,
+        experimental_telemetry: effectiveTelemetryFromPrepare,
+        experimental_context: effectiveExperimentalContext,
+        messages: effectiveMessages,
+        ...effectiveGenerationSettings
+      });
+      if (prepared.model !== void 0) effectiveModel = prepared.model;
+      if (prepared.instructions !== void 0)
+        effectiveInstructions = prepared.instructions;
+      if (prepared.messages !== void 0)
+        effectiveMessages = prepared.messages;
+      if (prepared.experimental_context !== void 0)
+        effectiveExperimentalContext = prepared.experimental_context;
+      if (prepared.toolChoice !== void 0)
+        effectiveToolChoiceFromPrepare = prepared.toolChoice;
+      if (prepared.experimental_telemetry !== void 0)
+        effectiveTelemetryFromPrepare = prepared.experimental_telemetry;
+      if (prepared.maxOutputTokens !== void 0)
+        effectiveGenerationSettings.maxOutputTokens = prepared.maxOutputTokens;
+      if (prepared.temperature !== void 0)
+        effectiveGenerationSettings.temperature = prepared.temperature;
+      if (prepared.topP !== void 0)
+        effectiveGenerationSettings.topP = prepared.topP;
+      if (prepared.topK !== void 0)
+        effectiveGenerationSettings.topK = prepared.topK;
+      if (prepared.presencePenalty !== void 0)
+        effectiveGenerationSettings.presencePenalty = prepared.presencePenalty;
+      if (prepared.frequencyPenalty !== void 0)
+        effectiveGenerationSettings.frequencyPenalty = prepared.frequencyPenalty;
+      if (prepared.stopSequences !== void 0)
+        effectiveGenerationSettings.stopSequences = prepared.stopSequences;
+      if (prepared.seed !== void 0)
+        effectiveGenerationSettings.seed = prepared.seed;
+      if (prepared.headers !== void 0)
+        effectiveGenerationSettings.headers = prepared.headers;
+      if (prepared.providerOptions !== void 0)
+        effectiveGenerationSettings.providerOptions = prepared.providerOptions;
+    }
+    const prompt = await standardizePrompt({
+      system: effectiveInstructions,
+      messages: effectiveMessages
+    });
+    const modelPrompt = await convertToLanguageModelPrompt({
+      prompt,
+      supportedUrls: {},
+      download: options.experimental_download
+    });
+    const effectiveAbortSignal = mergeAbortSignals(
+      (_e = options.abortSignal) != null ? _e : effectiveGenerationSettings.abortSignal,
+      options.timeout != null ? AbortSignal.timeout(options.timeout) : void 0
+    );
+    const mergedGenerationSettings = {
+      ...effectiveGenerationSettings,
+      ...options.maxOutputTokens !== void 0 && {
+        maxOutputTokens: options.maxOutputTokens
+      },
+      ...options.temperature !== void 0 && {
+        temperature: options.temperature
+      },
+      ...options.topP !== void 0 && { topP: options.topP },
+      ...options.topK !== void 0 && { topK: options.topK },
+      ...options.presencePenalty !== void 0 && {
+        presencePenalty: options.presencePenalty
+      },
+      ...options.frequencyPenalty !== void 0 && {
+        frequencyPenalty: options.frequencyPenalty
+      },
+      ...options.stopSequences !== void 0 && {
+        stopSequences: options.stopSequences
+      },
+      ...options.seed !== void 0 && { seed: options.seed },
+      ...options.maxRetries !== void 0 && {
+        maxRetries: options.maxRetries
+      },
+      ...effectiveAbortSignal !== void 0 && {
+        abortSignal: effectiveAbortSignal
+      },
+      ...options.headers !== void 0 && { headers: options.headers },
+      ...options.providerOptions !== void 0 && {
+        providerOptions: options.providerOptions
+      }
+    };
+    const mergedOnStepFinish = mergeCallbacks(
+      this.constructorOnStepFinish,
+      options.onStepFinish
+    );
+    const mergedOnFinish = mergeCallbacks(
+      this.constructorOnFinish,
+      options.onFinish
+    );
+    const mergedOnStart = mergeCallbacks(
+      this.constructorOnStart,
+      options.experimental_onStart
+    );
+    const mergedOnStepStart = mergeCallbacks(
+      this.constructorOnStepStart,
+      options.experimental_onStepStart
+    );
+    const mergedOnToolCallStart = mergeCallbacks(
+      this.constructorOnToolCallStart,
+      options.experimental_onToolCallStart
+    );
+    const mergedOnToolCallFinish = mergeCallbacks(
+      this.constructorOnToolCallFinish,
+      options.experimental_onToolCallFinish
+    );
+    const effectiveToolChoice = effectiveToolChoiceFromPrepare;
+    const effectiveTelemetry = effectiveTelemetryFromPrepare;
+    const effectiveTools = options.activeTools && options.activeTools.length > 0 ? filterTools(this.tools, options.activeTools) : this.tools;
+    let experimentalContext = effectiveExperimentalContext;
+    const steps = [];
+    let lastStepToolCalls = [];
+    let lastStepToolResults = [];
+    if (mergedOnStart) {
+      await mergedOnStart({
+        model: effectiveModel,
+        messages: effectiveMessages
+      });
+    }
+    const executeToolWithCallbacks = async (toolCall, tools, messages2, context) => {
+      if (mergedOnToolCallStart) {
+        await mergedOnToolCallStart({
+          toolCall: {
+            type: "tool-call",
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            input: toolCall.input
+          }
+        });
+      }
+      let result;
+      try {
+        result = await executeTool(toolCall, tools, messages2, context);
+      } catch (err) {
+        if (mergedOnToolCallFinish) {
+          await mergedOnToolCallFinish({
+            toolCall: {
+              type: "tool-call",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.input
+            },
+            error: err
+          });
+        }
+        throw err;
+      }
+      if (mergedOnToolCallFinish) {
+        const isError = result.output && "type" in result.output && (result.output.type === "error-text" || result.output.type === "error-json");
+        await mergedOnToolCallFinish({
+          toolCall: {
+            type: "tool-call",
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            input: toolCall.input
+          },
+          ...isError ? {
+            error: "value" in result.output ? result.output.value : void 0
+          } : {
+            result: result.output && "value" in result.output ? result.output.value : void 0
+          }
+        });
+      }
+      return result;
+    };
+    if ((_f = mergedGenerationSettings.abortSignal) == null ? void 0 : _f.aborted) {
+      if (options.onAbort) {
+        await options.onAbort({ steps });
+      }
+      return {
+        messages: options.messages,
+        steps,
+        toolCalls: [],
+        toolResults: [],
+        experimental_output: void 0
+      };
+    }
+    const iterator = streamTextIterator({
+      model: effectiveModel,
+      tools: effectiveTools,
+      writable: options.writable,
+      prompt: modelPrompt,
+      stopConditions: options.stopWhen,
+      maxSteps: options.maxSteps,
+      onStepFinish: mergedOnStepFinish,
+      onStepStart: mergedOnStepStart,
+      onError: options.onError,
+      prepareStep: (_g = options.prepareStep) != null ? _g : this.prepareStep,
+      generationSettings: mergedGenerationSettings,
+      toolChoice: effectiveToolChoice,
+      experimental_context: experimentalContext,
+      experimental_telemetry: effectiveTelemetry,
+      includeRawChunks: (_h = options.includeRawChunks) != null ? _h : false,
+      repairToolCall: options.experimental_repairToolCall,
+      responseFormat: await ((_i = options.experimental_output) == null ? void 0 : _i.responseFormat)
+    });
+    let finalMessages;
+    let encounteredError;
+    let wasAborted = false;
+    try {
+      let result = await iterator.next();
+      while (!result.done) {
+        if ((_j = mergedGenerationSettings.abortSignal) == null ? void 0 : _j.aborted) {
+          wasAborted = true;
+          if (options.onAbort) {
+            await options.onAbort({ steps });
+          }
+          break;
+        }
+        const {
+          toolCalls,
+          messages: iterMessages,
+          step,
+          context,
+          providerExecutedToolResults
+        } = result.value;
+        if (step) {
+          steps.push(step);
+        }
+        if (context !== void 0) {
+          experimentalContext = context;
+        }
+        if (toolCalls.length > 0) {
+          const nonProviderToolCalls = toolCalls.filter(
+            (tc) => !tc.providerExecuted
+          );
+          const providerToolCalls = toolCalls.filter((tc) => tc.providerExecuted);
+          const executableToolCalls = nonProviderToolCalls.filter((tc) => {
+            const tool2 = effectiveTools[tc.toolName];
+            return !tool2 || typeof tool2.execute === "function";
+          });
+          const clientSideToolCalls = nonProviderToolCalls.filter((tc) => {
+            const tool2 = effectiveTools[tc.toolName];
+            return tool2 && typeof tool2.execute !== "function";
+          });
+          if (clientSideToolCalls.length > 0) {
+            const executableResults = await Promise.all(
+              executableToolCalls.map(
+                (toolCall) => executeToolWithCallbacks(
+                  toolCall,
+                  effectiveTools,
+                  iterMessages,
+                  experimentalContext
+                )
+              )
+            );
+            const providerResults = providerToolCalls.map(
+              (toolCall) => resolveProviderToolResult(
+                toolCall,
+                providerExecutedToolResults
+              )
+            );
+            const resolvedResults = [...executableResults, ...providerResults];
+            const allToolCalls = toolCalls.map((tc) => ({
+              type: "tool-call",
+              toolCallId: tc.toolCallId,
+              toolName: tc.toolName,
+              input: tc.input
+            }));
+            const allToolResults = resolvedResults.map((r) => {
+              var _a2;
+              return {
+                type: "tool-result",
+                toolCallId: r.toolCallId,
+                toolName: r.toolName,
+                input: (_a2 = toolCalls.find((tc) => tc.toolCallId === r.toolCallId)) == null ? void 0 : _a2.input,
+                output: "value" in r.output ? r.output.value : void 0
+              };
+            });
+            if (resolvedResults.length > 0) {
+              iterMessages.push({
+                role: "tool",
+                content: resolvedResults
+              });
+            }
+            const messages2 = iterMessages;
+            if (mergedOnFinish && !wasAborted) {
+              const lastStep = steps[steps.length - 1];
+              await mergedOnFinish({
+                steps,
+                messages: messages2,
+                text: (_k = lastStep == null ? void 0 : lastStep.text) != null ? _k : "",
+                finishReason: (_l = lastStep == null ? void 0 : lastStep.finishReason) != null ? _l : "other",
+                totalUsage: aggregateUsage(steps),
+                experimental_context: experimentalContext,
+                experimental_output: void 0
+              });
+            }
+            return {
+              messages: messages2,
+              steps,
+              toolCalls: allToolCalls,
+              toolResults: allToolResults,
+              experimental_output: void 0
+            };
+          }
+          const clientToolResults = await Promise.all(
+            nonProviderToolCalls.map(
+              (toolCall) => executeToolWithCallbacks(
+                toolCall,
+                effectiveTools,
+                iterMessages,
+                experimentalContext
+              )
+            )
+          );
+          const providerToolResults = providerToolCalls.map(
+            (toolCall) => resolveProviderToolResult(toolCall, providerExecutedToolResults)
+          );
+          const toolResults = toolCalls.map((tc) => {
+            const clientResult = clientToolResults.find(
+              (r) => r.toolCallId === tc.toolCallId
+            );
+            if (clientResult) return clientResult;
+            const providerResult = providerToolResults.find(
+              (r) => r.toolCallId === tc.toolCallId
+            );
+            if (providerResult) return providerResult;
+            return {
+              type: "tool-result",
+              toolCallId: tc.toolCallId,
+              toolName: tc.toolName,
+              output: { type: "text", value: "" }
+            };
+          });
+          lastStepToolCalls = toolCalls.map((tc) => ({
+            type: "tool-call",
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            input: tc.input
+          }));
+          lastStepToolResults = toolResults.map((r) => {
+            var _a2;
+            return {
+              type: "tool-result",
+              toolCallId: r.toolCallId,
+              toolName: r.toolName,
+              input: (_a2 = toolCalls.find((tc) => tc.toolCallId === r.toolCallId)) == null ? void 0 : _a2.input,
+              output: "value" in r.output ? r.output.value : void 0
+            };
+          });
+          result = await iterator.next(toolResults);
+        } else {
+          lastStepToolCalls = [];
+          lastStepToolResults = [];
+          result = await iterator.next([]);
+        }
+      }
+      if (result.done) {
+        finalMessages = result.value;
+      }
+    } catch (error) {
+      encounteredError = error;
+      if (error instanceof Error && error.name === "AbortError") {
+        wasAborted = true;
+        if (options.onAbort) {
+          await options.onAbort({ steps });
+        }
+      } else if (options.onError) {
+        await options.onError({ error });
+      }
+    }
+    const messages = finalMessages != null ? finalMessages : options.messages;
+    let experimentalOutput = void 0;
+    if (options.experimental_output && steps.length > 0) {
+      const lastStep = steps[steps.length - 1];
+      const text = lastStep.text;
+      if (text) {
+        try {
+          experimentalOutput = await options.experimental_output.parseCompleteOutput(
+            { text },
+            {
+              response: lastStep.response,
+              usage: lastStep.usage,
+              finishReason: lastStep.finishReason
+            }
+          );
+        } catch (parseError) {
+          if (!encounteredError) {
+            encounteredError = parseError;
+          }
+        }
+      }
+    }
+    if (mergedOnFinish && !wasAborted) {
+      const lastStep = steps[steps.length - 1];
+      await mergedOnFinish({
+        steps,
+        messages,
+        text: (_m = lastStep == null ? void 0 : lastStep.text) != null ? _m : "",
+        finishReason: (_n = lastStep == null ? void 0 : lastStep.finishReason) != null ? _n : "other",
+        totalUsage: aggregateUsage(steps),
+        experimental_context: experimentalContext,
+        experimental_output: experimentalOutput
+      });
+    }
+    if (encounteredError) {
+      throw encounteredError;
+    }
+    return {
+      messages,
+      steps,
+      toolCalls: lastStepToolCalls,
+      toolResults: lastStepToolResults,
+      experimental_output: experimentalOutput
+    };
+  }
+};
+function aggregateUsage(steps) {
+  var _a, _b, _c, _d;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for (const step of steps) {
+    inputTokens += (_b = (_a = step.usage) == null ? void 0 : _a.inputTokens) != null ? _b : 0;
+    outputTokens += (_d = (_c = step.usage) == null ? void 0 : _c.outputTokens) != null ? _d : 0;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens
+  };
+}
+function filterTools(tools, activeTools) {
+  const filtered = {};
+  for (const toolName of activeTools) {
+    if (toolName in tools) {
+      filtered[toolName] = tools[toolName];
+    }
+  }
+  return filtered;
+}
+function getErrorMessage(error) {
+  if (error == null) {
+    return "unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}
+function resolveProviderToolResult(toolCall, providerExecutedToolResults) {
+  const streamResult = providerExecutedToolResults == null ? void 0 : providerExecutedToolResults.get(toolCall.toolCallId);
+  if (!streamResult) {
+    console.warn(
+      `[WorkflowAgent] Provider-executed tool "${toolCall.toolName}" (${toolCall.toolCallId}) did not receive a result from the stream. This may indicate a provider issue.`
+    );
+    return {
+      type: "tool-result",
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      output: {
+        type: "text",
+        value: ""
+      }
+    };
+  }
+  const result = streamResult.result;
+  const isString = typeof result === "string";
+  return {
+    type: "tool-result",
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    output: isString ? streamResult.isError ? { type: "error-text", value: result } : { type: "text", value: result } : streamResult.isError ? {
+      type: "error-json",
+      value: result
+    } : {
+      type: "json",
+      value: result
+    }
+  };
+}
+async function executeTool(toolCall, tools, messages, experimentalContext) {
+  const tool2 = tools[toolCall.toolName];
+  if (!tool2) throw new Error(`Tool "${toolCall.toolName}" not found`);
+  if (typeof tool2.execute !== "function") {
+    throw new Error(
+      `Tool "${toolCall.toolName}" does not have an execute function. Client-side tools should be filtered before calling executeTool.`
+    );
+  }
+  const parsedInput = toolCall.input;
+  try {
+    const { execute } = tool2;
+    const toolResult = await execute(parsedInput, {
+      toolCallId: toolCall.toolCallId,
+      // Pass the conversation messages to the tool so it has context about the conversation
+      messages,
+      // Pass experimental context to the tool
+      experimental_context: experimentalContext
+    });
+    const output = typeof toolResult === "string" ? { type: "text", value: toolResult } : { type: "json", value: toolResult };
+    return {
+      type: "tool-result",
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      output
+    };
+  } catch (error) {
+    return {
+      type: "tool-result",
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      output: {
+        type: "error-text",
+        value: getErrorMessage(error)
+      }
+    };
+  }
+}
+
+// src/to-ui-message-chunk.ts
+import { generateId } from "ai";
+function toUIMessageChunk(part) {
+  var _a;
+  switch (part.type) {
+    case "text-start":
+      return {
+        type: "text-start",
+        id: part.id,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    case "text-delta":
+      return {
+        type: "text-delta",
+        id: part.id,
+        delta: part.text,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    case "text-end":
+      return {
+        type: "text-end",
+        id: part.id,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    case "reasoning-start":
+      return {
+        type: "reasoning-start",
+        id: part.id,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    case "reasoning-delta":
+      return {
+        type: "reasoning-delta",
+        id: part.id,
+        delta: part.text,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    case "reasoning-end":
+      return {
+        type: "reasoning-end",
+        id: part.id,
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    case "file": {
+      const file = part.file;
+      return {
+        type: "file",
+        mediaType: file.mediaType,
+        url: `data:${file.mediaType};base64,${file.base64}`
+      };
+    }
+    case "source": {
+      if (part.sourceType === "url") {
+        return {
+          type: "source-url",
+          sourceId: part.id,
+          url: part.url,
+          title: part.title,
+          ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+        };
+      }
+      if (part.sourceType === "document") {
+        return {
+          type: "source-document",
+          sourceId: part.id,
+          mediaType: part.mediaType,
+          title: part.title,
+          filename: part.filename,
+          ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+        };
+      }
+      return void 0;
+    }
+    case "tool-input-start":
+      return {
+        type: "tool-input-start",
+        toolCallId: part.id,
+        toolName: part.toolName,
+        ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {}
+      };
+    case "tool-input-delta":
+      return {
+        type: "tool-input-delta",
+        toolCallId: part.id,
+        inputTextDelta: part.delta
+      };
+    case "tool-call": {
+      const toolCallPart = part;
+      if (toolCallPart.invalid) {
+        return {
+          type: "tool-input-error",
+          toolCallId: toolCallPart.toolCallId,
+          toolName: toolCallPart.toolName,
+          input: toolCallPart.input,
+          errorText: toolCallPart.error instanceof Error ? toolCallPart.error.message : String((_a = toolCallPart.error) != null ? _a : "Invalid tool call")
+        };
+      }
+      return {
+        type: "tool-input-available",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        input: part.input,
+        ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+        ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+      };
+    }
+    case "tool-result":
+      return {
+        type: "tool-output-available",
+        toolCallId: part.toolCallId,
+        output: part.output
+      };
+    case "tool-error":
+      return {
+        type: "tool-output-error",
+        toolCallId: part.toolCallId,
+        errorText: part.error instanceof Error ? part.error.message : String(part.error)
+      };
+    case "error": {
+      const error = part.error;
+      return {
+        type: "error",
+        errorText: error instanceof Error ? error.message : String(error)
+      };
+    }
+    // These don't produce UI chunks
+    case "tool-input-end":
+    case "model-call-start":
+    case "model-call-response-metadata":
+    case "model-call-end":
+    case "raw":
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function createModelCallToUIChunkTransform() {
+  return new TransformStream({
+    start: (controller) => {
+      controller.enqueue({ type: "start", messageId: generateId() });
+      controller.enqueue({ type: "start-step" });
+    },
+    flush: (controller) => {
+      controller.enqueue({ type: "finish-step" });
+      controller.enqueue({ type: "finish" });
+    },
+    transform: (part, controller) => {
+      const uiChunk = toUIMessageChunk(part);
+      if (uiChunk) {
+        controller.enqueue(uiChunk);
+      }
+    }
+  });
+}
+export {
+  Output,
+  WorkflowAgent,
+  createModelCallToUIChunkTransform,
+  toUIMessageChunk
+};
+//# sourceMappingURL=index.mjs.map