@ai-sdk/workflow 0.0.0-07500555-20260730161446

package/dist/index.js

@@ -0,0 +1,2530 @@
+// src/workflow-agent.ts
+import {
+  getErrorMessage,
+  validateTypes,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
+import {
+  Output,
+  experimental_filterActiveTools as filterActiveTools2
+} from "ai";
+import {
+  createRestrictedTelemetryDispatcher as createRestrictedTelemetryDispatcher2,
+  collectToolApprovals,
+  convertToLanguageModelPrompt,
+  mergeAbortSignals,
+  mergeCallbacks,
+  standardizePrompt,
+  validateApprovedToolApprovals
+} from "ai/internal";
+
+// src/create-language-model-tool-result-output.ts
+import {
+  createDefaultDownloadFunction,
+  createToolModelOutput,
+  downloadAssets,
+  mapToolResultOutput
+} from "ai/internal";
+async function createLanguageModelToolResultOutput({
+  toolCallId,
+  toolName,
+  input,
+  output,
+  tool: tool2,
+  errorMode,
+  supportedUrls,
+  download = createDefaultDownloadFunction(),
+  provider
+}) {
+  const modelOutput = await createToolModelOutput({
+    toolCallId,
+    input,
+    output,
+    tool: tool2,
+    errorMode
+  });
+  const downloadedAssets = modelOutput.type === "content" ? await downloadAssets(
+    [
+      {
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId,
+            toolName,
+            output: modelOutput
+          }
+        ]
+      }
+    ],
+    download,
+    supportedUrls
+  ) : {};
+  return mapToolResultOutput({
+    output: modelOutput,
+    provider,
+    downloadedAssets
+  });
+}
+
+// src/stream-text-iterator.ts
+import {
+  experimental_filterActiveTools as filterActiveTools
+} from "ai";
+import { createRestrictedTelemetryDispatcher } from "ai/internal";
+
+// src/do-stream-step.ts
+import {
+  experimental_streamLanguageModelCall as streamModelCall,
+  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]) => {
+      var _a;
+      const def = {
+        description: t.description,
+        // TODO support tools with function descriptions
+        inputSchema: asSchema(t.inputSchema).jsonSchema
+      };
+      if (t.type === "provider") {
+        def.type = "provider";
+        def.isProviderExecuted = (_a = t.isProviderExecuted) != null ? _a : false;
+        def.id = t.id;
+        def.args = t.args;
+      }
+      return [name, def];
+    })
+  );
+}
+function resolveSerializableTools(tools) {
+  const ajv = new Ajv();
+  return Object.fromEntries(
+    Object.entries(tools).map(([name, t]) => {
+      var _a, _b;
+      if (t.type === "provider") {
+        return [
+          name,
+          tool({
+            type: "provider",
+            id: t.id,
+            args: (_a = t.args) != null ? _a : {},
+            isProviderExecuted: (_b = t.isProviderExecuted) != null ? _b : false,
+            inputSchema: jsonSchema(t.inputSchema)
+          })
+        ];
+      }
+      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";
+  const model = typeof modelInit === "string" ? gateway.languageModel(modelInit) : modelInit;
+  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,
+    allowSystemInMessages: true,
+    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,
+    reasoning: options == null ? void 0 : options.reasoning,
+    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();
+  }
+  return {
+    toolCalls,
+    finish,
+    raw: {
+      text,
+      reasoning: reasoningParts,
+      responseMetadata,
+      warnings
+    },
+    providerExecutedToolResults
+  };
+}
+
+// src/stream-text-iterator.ts
+async function* streamTextIterator({
+  prompt,
+  tools = {},
+  writable,
+  model,
+  stopConditions,
+  onStepEnd,
+  onStepFinish,
+  onStepStart,
+  onError,
+  prepareStep,
+  generationSettings,
+  toolChoice,
+  runtimeContext,
+  toolsContext,
+  telemetry,
+  includeRawChunks = false,
+  repairToolCall,
+  responseFormat,
+  experimental_sandbox: sandbox
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  let conversationPrompt = [...prompt];
+  let currentModel = model;
+  let currentGenerationSettings = generationSettings != null ? generationSettings : {};
+  let currentToolChoice = toolChoice;
+  let currentRuntimeContext = runtimeContext != null ? runtimeContext : {};
+  let currentToolsContext = toolsContext != null ? toolsContext : {};
+  let currentActiveTools;
+  const steps = [];
+  let done = false;
+  let _isFirstIteration = true;
+  let stepNumber = 0;
+  let lastStep;
+  let lastStepWasToolCalls = false;
+  const telemetryDispatcher = createRestrictedTelemetryDispatcher({
+    telemetry,
+    includeRuntimeContext: telemetry == null ? void 0 : telemetry.includeRuntimeContext,
+    includeToolsContext: telemetry == null ? void 0 : telemetry.includeToolsContext
+  });
+  while (!done) {
+    if ((_a = currentGenerationSettings.abortSignal) == null ? void 0 : _a.aborted) {
+      break;
+    }
+    let stepSandbox = sandbox;
+    if (prepareStep) {
+      const prepareResult = await prepareStep({
+        model: currentModel,
+        stepNumber,
+        steps,
+        messages: conversationPrompt,
+        runtimeContext: currentRuntimeContext,
+        toolsContext: currentToolsContext,
+        experimental_sandbox: sandbox
+      });
+      stepSandbox = (_b = prepareResult == null ? void 0 : prepareResult.experimental_sandbox) != null ? _b : sandbox;
+      if ((prepareResult == null ? void 0 : prepareResult.model) !== void 0) {
+        currentModel = prepareResult.model;
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.messages) !== void 0) {
+        conversationPrompt = [...prepareResult.messages];
+      }
+      if ((prepareResult == null ? void 0 : 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 == null ? void 0 : prepareResult.runtimeContext) !== void 0) {
+        currentRuntimeContext = prepareResult.runtimeContext;
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.toolsContext) !== void 0) {
+        currentToolsContext = prepareResult.toolsContext;
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.activeTools) !== void 0) {
+        currentActiveTools = prepareResult.activeTools;
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.maxOutputTokens) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          maxOutputTokens: prepareResult.maxOutputTokens
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.temperature) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          temperature: prepareResult.temperature
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.topP) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          topP: prepareResult.topP
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.topK) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          topK: prepareResult.topK
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.presencePenalty) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          presencePenalty: prepareResult.presencePenalty
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.frequencyPenalty) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          frequencyPenalty: prepareResult.frequencyPenalty
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.stopSequences) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          stopSequences: prepareResult.stopSequences
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.seed) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          seed: prepareResult.seed
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.maxRetries) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          maxRetries: prepareResult.maxRetries
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.headers) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          headers: prepareResult.headers
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.reasoning) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          reasoning: prepareResult.reasoning
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.providerOptions) !== void 0) {
+        currentGenerationSettings = {
+          ...currentGenerationSettings,
+          providerOptions: prepareResult.providerOptions
+        };
+      }
+      if ((prepareResult == null ? void 0 : prepareResult.toolChoice) !== void 0) {
+        currentToolChoice = prepareResult.toolChoice;
+      }
+    }
+    if (onStepStart) {
+      await onStepStart({
+        stepNumber,
+        model: currentModel,
+        messages: conversationPrompt,
+        steps: [...steps],
+        runtimeContext: currentRuntimeContext,
+        toolsContext: currentToolsContext
+      });
+    }
+    const stepStartModelInfo = getModelInfo(currentModel);
+    await ((_c = telemetryDispatcher.onStepStart) == null ? void 0 : _c.call(telemetryDispatcher, {
+      callId: "workflow-agent",
+      provider: stepStartModelInfo.provider,
+      modelId: stepStartModelInfo.modelId,
+      stepNumber,
+      system: void 0,
+      messages: conversationPrompt,
+      tools,
+      toolChoice: currentToolChoice,
+      activeTools: currentActiveTools,
+      steps: steps.map(normalizeStepForTelemetry),
+      providerOptions: currentGenerationSettings.providerOptions,
+      output: void 0,
+      runtimeContext: currentRuntimeContext,
+      toolsContext: currentToolsContext
+    }));
+    try {
+      const effectiveTools = currentActiveTools && currentActiveTools.length > 0 ? (_d = filterActiveTools({
+        tools,
+        activeTools: currentActiveTools
+      })) != null ? _d : tools : tools;
+      const serializedTools = serializeToolSet(effectiveTools);
+      const modelCallInfo = getModelInfo(currentModel);
+      await ((_e = telemetryDispatcher.onLanguageModelCallStart) == null ? void 0 : _e.call(telemetryDispatcher, {
+        callId: "workflow-agent",
+        provider: modelCallInfo.provider,
+        modelId: modelCallInfo.modelId,
+        system: void 0,
+        messages: conversationPrompt,
+        tools: serializedTools == null ? void 0 : Object.values(serializedTools).map((tool2) => ({ ...tool2 })),
+        maxOutputTokens: currentGenerationSettings.maxOutputTokens,
+        temperature: currentGenerationSettings.temperature,
+        topP: currentGenerationSettings.topP,
+        topK: currentGenerationSettings.topK,
+        presencePenalty: currentGenerationSettings.presencePenalty,
+        frequencyPenalty: currentGenerationSettings.frequencyPenalty,
+        stopSequences: currentGenerationSettings.stopSequences,
+        seed: currentGenerationSettings.seed,
+        reasoning: currentGenerationSettings.reasoning,
+        providerOptions: currentGenerationSettings.providerOptions,
+        headers: currentGenerationSettings.headers
+      }));
+      const { toolCalls, finish, raw, providerExecutedToolResults } = await doStreamStep(
+        conversationPrompt,
+        currentModel,
+        writable,
+        serializedTools,
+        {
+          ...currentGenerationSettings,
+          toolChoice: currentToolChoice,
+          includeRawChunks,
+          repairToolCall,
+          responseFormat
+        }
+      );
+      const step = buildStepResult(raw, toolCalls, finish, {
+        stepNumber,
+        runtimeContext: currentRuntimeContext,
+        toolsContext: currentToolsContext
+      });
+      await ((_j = telemetryDispatcher.onLanguageModelCallEnd) == null ? void 0 : _j.call(telemetryDispatcher, {
+        callId: step.callId,
+        provider: (_g = (_f = step.model) == null ? void 0 : _f.provider) != null ? _g : "unknown",
+        modelId: (_i = (_h = step.model) == null ? void 0 : _h.modelId) != null ? _i : "unknown",
+        finishReason: step.finishReason,
+        usage: step.usage,
+        content: step.content,
+        responseId: step.response.id
+      }));
+      _isFirstIteration = false;
+      stepNumber++;
+      steps.push(step);
+      lastStep = step;
+      lastStepWasToolCalls = false;
+      const finishReason = finish == null ? void 0 : finish.finishReason;
+      if (finishReason === "tool-calls") {
+        lastStepWasToolCalls = true;
+        const textContent = step.content.filter(
+          (item) => item.type === "text"
+        );
+        conversationPrompt.push({
+          role: "assistant",
+          content: [
+            ...textContent,
+            ...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,
+          runtimeContext: currentRuntimeContext,
+          toolsContext: currentToolsContext,
+          experimental_sandbox: stepSandbox,
+          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}`
+        );
+      }
+      const resolvedOnStepEnd = onStepEnd != null ? onStepEnd : onStepFinish;
+      if (resolvedOnStepEnd) {
+        await resolvedOnStepEnd(step);
+      }
+      await ((_k = telemetryDispatcher.onStepEnd) == null ? void 0 : _k.call(telemetryDispatcher, normalizeStepForTelemetry(step)));
+    } catch (error) {
+      if (onError) {
+        await onError({ error });
+      }
+      throw error;
+    }
+  }
+  if (lastStep && !lastStepWasToolCalls) {
+    yield {
+      toolCalls: [],
+      messages: conversationPrompt,
+      step: lastStep,
+      runtimeContext: currentRuntimeContext,
+      toolsContext: currentToolsContext,
+      experimental_sandbox: sandbox
+    };
+  }
+  return conversationPrompt;
+}
+function getModelInfo(model) {
+  var _a;
+  return typeof model === "string" ? { provider: (_a = model.split("/")[0]) != null ? _a : "gateway", modelId: model } : { provider: model.provider, modelId: model.modelId };
+}
+function normalizeStepForTelemetry(step) {
+  var _a;
+  return {
+    ...step,
+    model: (_a = step.model) != null ? _a : { provider: "unknown", modelId: "unknown" }
+  };
+}
+function buildStepResult(raw, toolCalls, finish, opts) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const { text, reasoning: reasoningParts, responseMetadata, warnings } = raw;
+  const reasoningText = reasoningParts.map((r) => r.text).join("") || void 0;
+  const validToolCalls = toolCalls.filter((tc) => !tc.invalid).map((tc) => ({
+    type: "tool-call",
+    toolCallId: tc.toolCallId,
+    toolName: tc.toolName,
+    input: tc.input,
+    ...tc.dynamic ? { dynamic: true } : {}
+  }));
+  return {
+    callId: "workflow-agent",
+    stepNumber: opts.stepNumber,
+    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,
+    runtimeContext: (_d = opts.runtimeContext) != null ? _d : {},
+    toolsContext: (_e = opts.toolsContext) != null ? _e : {},
+    content: [
+      ...text ? [{ type: "text", text }] : [],
+      ...validToolCalls
+    ],
+    text,
+    reasoning: reasoningParts.map((r) => ({
+      type: "reasoning",
+      text: r.text
+    })),
+    reasoningText,
+    files: [],
+    sources: [],
+    toolCalls: validToolCalls,
+    staticToolCalls: [],
+    dynamicToolCalls: validToolCalls.filter((tc) => tc.dynamic),
+    toolResults: [],
+    staticToolResults: [],
+    dynamicToolResults: [],
+    finishReason: (_f = finish == null ? void 0 : finish.finishReason) != null ? _f : "other",
+    rawFinishReason: finish == null ? void 0 : finish.rawFinishReason,
+    usage: (_g = finish == null ? void 0 : finish.usage) != null ? _g : {
+      inputTokens: 0,
+      inputTokenDetails: {
+        noCacheTokens: void 0,
+        cacheReadTokens: void 0,
+        cacheWriteTokens: void 0
+      },
+      outputTokens: 0,
+      outputTokenDetails: {
+        textTokens: void 0,
+        reasoningTokens: void 0
+      },
+      totalTokens: 0
+    },
+    performance: {
+      effectiveOutputTokensPerSecond: 0,
+      outputTokensPerSecond: void 0,
+      inputTokensPerSecond: void 0,
+      effectiveTotalTokensPerSecond: 0,
+      stepTimeMs: 0,
+      responseTimeMs: 0,
+      toolExecutionMs: {},
+      timeToFirstOutputMs: void 0
+    },
+    warnings,
+    request: {
+      body: "",
+      messages: []
+      // TODO implement step request messages
+    },
+    response: {
+      id: (_h = responseMetadata == null ? void 0 : responseMetadata.id) != null ? _h : "unknown",
+      timestamp: (_i = responseMetadata == null ? void 0 : responseMetadata.timestamp) != null ? _i : /* @__PURE__ */ new Date(),
+      modelId: (_j = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _j : "unknown",
+      messages: []
+    },
+    providerMetadata: (_k = finish == null ? void 0 : finish.providerMetadata) != null ? _k : {}
+  };
+}
+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, _c, _d, _e;
+    this.id = options.id;
+    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.telemetry;
+    this.runtimeContext = options.runtimeContext;
+    this.toolsContext = options.toolsContext;
+    this.stopWhen = options.stopWhen;
+    this.activeTools = options.activeTools;
+    this.output = options.output;
+    this.repairToolCall = (_c = options.repairToolCall) != null ? _c : options.experimental_repairToolCall;
+    this.experimentalDownload = options.experimental_download;
+    this.experimentalSandbox = options.experimental_sandbox;
+    this.prepareStep = options.prepareStep;
+    this.constructorOnStepEnd = (_d = options.onStepEnd) != null ? _d : options.onStepFinish;
+    const { onFinish, onEnd = onFinish } = options;
+    this.constructorOnEnd = onEnd;
+    this.constructorOnStart = options.experimental_onStart;
+    this.constructorOnStepStart = options.experimental_onStepStart;
+    this.constructorOnToolExecutionStart = options.onToolExecutionStart;
+    this.constructorOnToolExecutionEnd = options.onToolExecutionEnd;
+    this.prepareCall = options.prepareCall;
+    this.allowSystemInMessages = (_e = options.allowSystemInMessages) != null ? _e : false;
+    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,
+      reasoning: options.reasoning,
+      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, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S;
+    const { onFinish, onEnd = onFinish } = options;
+    let effectiveModel = this.model;
+    let effectiveInstructions = (_a = options.system) != null ? _a : this.instructions;
+    let effectivePrompt = options.prompt;
+    let effectiveMessages = options.messages;
+    let effectiveGenerationSettings = { ...this.generationSettings };
+    let effectiveRuntimeContext = (_c = (_b = options.runtimeContext) != null ? _b : this.runtimeContext) != null ? _c : {};
+    let effectiveToolsContext = (_e = (_d = options.toolsContext) != null ? _d : this.toolsContext) != null ? _e : {};
+    let effectiveToolChoiceFromPrepare = (_f = options.toolChoice) != null ? _f : this.toolChoice;
+    let effectiveTelemetryFromPrepare = (_g = options.telemetry) != null ? _g : this.telemetry;
+    const resolvedMessagesForPrepareCall = (_h = effectiveMessages != null ? effectiveMessages : typeof effectivePrompt === "string" ? [{ role: "user", content: effectivePrompt }] : effectivePrompt) != null ? _h : [];
+    if (this.prepareCall) {
+      const prepared = await this.prepareCall({
+        model: effectiveModel,
+        tools: this.tools,
+        instructions: effectiveInstructions,
+        toolChoice: effectiveToolChoiceFromPrepare,
+        telemetry: effectiveTelemetryFromPrepare,
+        runtimeContext: effectiveRuntimeContext,
+        toolsContext: effectiveToolsContext,
+        messages: resolvedMessagesForPrepareCall,
+        ...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;
+        effectivePrompt = void 0;
+      }
+      if (prepared.runtimeContext !== void 0)
+        effectiveRuntimeContext = prepared.runtimeContext;
+      if (prepared.toolsContext !== void 0)
+        effectiveToolsContext = prepared.toolsContext;
+      if (prepared.toolChoice !== void 0)
+        effectiveToolChoiceFromPrepare = prepared.toolChoice;
+      if (prepared.telemetry !== void 0)
+        effectiveTelemetryFromPrepare = prepared.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.reasoning !== void 0)
+        effectiveGenerationSettings.reasoning = prepared.reasoning;
+      if (prepared.providerOptions !== void 0)
+        effectiveGenerationSettings.providerOptions = prepared.providerOptions;
+    }
+    const effectiveTelemetry = effectiveTelemetryFromPrepare;
+    const telemetryDispatcher = createRestrictedTelemetryDispatcher2({
+      telemetry: effectiveTelemetry,
+      includeRuntimeContext: effectiveTelemetry == null ? void 0 : effectiveTelemetry.includeRuntimeContext,
+      includeToolsContext: effectiveTelemetry == null ? void 0 : effectiveTelemetry.includeToolsContext
+    });
+    const prompt = await standardizePrompt({
+      system: effectiveInstructions,
+      allowSystemInMessages: this.allowSystemInMessages,
+      ...effectivePrompt != null ? { prompt: effectivePrompt } : { messages: effectiveMessages }
+    });
+    const download = (_i = options.experimental_download) != null ? _i : this.experimentalDownload;
+    const sandbox = (_j = options.experimental_sandbox) != null ? _j : this.experimentalSandbox;
+    const collectedApprovals = collectToolApprovals({
+      messages: prompt.messages
+    });
+    const approvedToolApprovals = collectedApprovals.approvedToolApprovals.map(
+      (collected) => ({
+        toolCallId: collected.toolCall.toolCallId,
+        toolName: collected.toolCall.toolName,
+        input: collected.toolCall.input,
+        reason: collected.approvalResponse.reason,
+        providerExecuted: collected.toolCall.providerExecuted === true,
+        collected
+      })
+    );
+    const deniedToolApprovals = collectedApprovals.deniedToolApprovals.map(
+      (collected) => ({
+        toolCallId: collected.toolCall.toolCallId,
+        toolName: collected.toolCall.toolName,
+        input: collected.toolCall.input,
+        reason: collected.approvalResponse.reason,
+        providerExecuted: collected.toolCall.providerExecuted === true
+      })
+    );
+    const providerExecutedApprovalIds = new Set(
+      [
+        ...collectedApprovals.approvedToolApprovals,
+        ...collectedApprovals.deniedToolApprovals
+      ].filter((collected) => collected.toolCall.providerExecuted === true).map((collected) => collected.approvalResponse.approvalId)
+    );
+    if (approvedToolApprovals.length > 0 || deniedToolApprovals.length > 0) {
+      const _toolResultMessages = [];
+      const toolResultContent = [];
+      const approvedRawResults = [];
+      for (const approval of approvedToolApprovals) {
+        if (approval.providerExecuted) {
+          continue;
+        }
+        const tool2 = this.tools[approval.toolName];
+        if (tool2 && typeof tool2.execute === "function") {
+          if (!tool2.needsApproval) {
+            const reason = `Tool "${approval.toolName}" does not require approval`;
+            toolResultContent.push({
+              type: "tool-result",
+              toolCallId: approval.toolCallId,
+              toolName: approval.toolName,
+              output: await createLanguageModelToolResultOutput({
+                toolCallId: approval.toolCallId,
+                toolName: approval.toolName,
+                input: approval.input,
+                output: reason,
+                tool: tool2,
+                errorMode: "text",
+                supportedUrls: {},
+                download
+              })
+            });
+            continue;
+          }
+          let revalidationReason;
+          try {
+            const { deniedToolApprovals: policyDenied } = await validateApprovedToolApprovals({
+              approvedToolApprovals: [approval.collected],
+              tools: this.tools,
+              toolApproval: void 0,
+              messages: prompt.messages,
+              toolsContext: effectiveToolsContext,
+              runtimeContext: effectiveRuntimeContext
+            });
+            if (policyDenied.length > 0) {
+              revalidationReason = (_k = policyDenied[0].approvalResponse.reason) != null ? _k : "Tool approval denied";
+            }
+          } catch (error) {
+            revalidationReason = getErrorMessage(error);
+          }
+          if (revalidationReason != null) {
+            toolResultContent.push({
+              type: "tool-result",
+              toolCallId: approval.toolCallId,
+              toolName: approval.toolName,
+              output: await createLanguageModelToolResultOutput({
+                toolCallId: approval.toolCallId,
+                toolName: approval.toolName,
+                input: approval.input,
+                output: revalidationReason,
+                tool: tool2,
+                errorMode: "text",
+                supportedUrls: {},
+                download
+              })
+            });
+            continue;
+          }
+          try {
+            const { execute } = tool2;
+            const resolvedContext = await resolveToolContext({
+              toolName: approval.toolName,
+              tool: tool2,
+              toolsContext: effectiveToolsContext
+            });
+            const toolCallEvent = {
+              type: "tool-call",
+              toolCallId: approval.toolCallId,
+              toolName: approval.toolName,
+              input: approval.input
+            };
+            const messages2 = prompt.messages;
+            await ((_l = telemetryDispatcher.onToolExecutionStart) == null ? void 0 : _l.call(telemetryDispatcher, {
+              toolCall: toolCallEvent,
+              stepNumber: 0,
+              messages: messages2,
+              toolContext: resolvedContext
+            }));
+            const startTime = Date.now();
+            const executeApprovedTool = () => execute(approval.input, {
+              toolCallId: approval.toolCallId,
+              messages: [],
+              context: resolvedContext,
+              experimental_sandbox: sandbox
+            });
+            const toolResult = telemetryDispatcher.executeTool != null ? await telemetryDispatcher.executeTool({
+              callId: "workflow-agent",
+              toolCallId: approval.toolCallId,
+              execute: executeApprovedTool
+            }) : await executeApprovedTool();
+            await ((_m = telemetryDispatcher.onToolExecutionEnd) == null ? void 0 : _m.call(telemetryDispatcher, {
+              toolCall: toolCallEvent,
+              stepNumber: 0,
+              durationMs: Date.now() - startTime,
+              messages: messages2,
+              toolContext: resolvedContext,
+              success: true,
+              output: toolResult
+            }));
+            toolResultContent.push({
+              type: "tool-result",
+              toolCallId: approval.toolCallId,
+              toolName: approval.toolName,
+              output: await createLanguageModelToolResultOutput({
+                toolCallId: approval.toolCallId,
+                toolName: approval.toolName,
+                input: approval.input,
+                output: toolResult,
+                tool: tool2,
+                errorMode: "none",
+                supportedUrls: {},
+                download
+              })
+            });
+            approvedRawResults.push({
+              toolCallId: approval.toolCallId,
+              toolName: approval.toolName,
+              input: approval.input,
+              output: toolResult
+            });
+          } catch (error) {
+            const errorMessage = getErrorMessage(error);
+            await ((_n = telemetryDispatcher.onToolExecutionEnd) == null ? void 0 : _n.call(telemetryDispatcher, {
+              toolCall: {
+                type: "tool-call",
+                toolCallId: approval.toolCallId,
+                toolName: approval.toolName,
+                input: approval.input
+              },
+              stepNumber: 0,
+              durationMs: 0,
+              messages: prompt.messages,
+              toolContext: void 0,
+              success: false,
+              error
+            }));
+            toolResultContent.push({
+              type: "tool-result",
+              toolCallId: approval.toolCallId,
+              toolName: approval.toolName,
+              output: await createLanguageModelToolResultOutput({
+                toolCallId: approval.toolCallId,
+                toolName: approval.toolName,
+                input: approval.input,
+                output: errorMessage,
+                tool: tool2,
+                errorMode: "text",
+                supportedUrls: {},
+                download
+              })
+            });
+            approvedRawResults.push({
+              toolCallId: approval.toolCallId,
+              toolName: approval.toolName,
+              input: approval.input,
+              output: errorMessage
+            });
+          }
+        }
+      }
+      for (const denial of deniedToolApprovals) {
+        if (denial.providerExecuted) {
+          continue;
+        }
+        toolResultContent.push({
+          type: "tool-result",
+          toolCallId: denial.toolCallId,
+          toolName: denial.toolName,
+          output: {
+            type: "execution-denied",
+            reason: denial.reason
+          }
+        });
+      }
+      const cleanedMessages = [];
+      for (const msg of prompt.messages) {
+        if (msg.role === "assistant" && Array.isArray(msg.content)) {
+          const filtered = msg.content.filter(
+            (p) => p.type !== "tool-approval-request" || providerExecutedApprovalIds.has(p.approvalId)
+          );
+          if (filtered.length > 0) {
+            cleanedMessages.push({ ...msg, content: filtered });
+          }
+        } else if (msg.role === "tool") {
+          const filtered = msg.content.flatMap((p) => {
+            if (p.type !== "tool-approval-response") {
+              return [p];
+            }
+            if (!providerExecutedApprovalIds.has(p.approvalId)) {
+              return [];
+            }
+            return [{ ...p, providerExecuted: true }];
+          });
+          if (filtered.length > 0) {
+            cleanedMessages.push({ ...msg, content: filtered });
+          }
+        } else {
+          cleanedMessages.push(msg);
+        }
+      }
+      if (toolResultContent.length > 0) {
+        cleanedMessages.push({
+          role: "tool",
+          content: toolResultContent
+        });
+      }
+      prompt.messages = cleanedMessages;
+      if (options.writable && toolResultContent.length > 0) {
+        const deniedResults = toolResultContent.filter((r) => r.output.type === "execution-denied").map((r) => ({ toolCallId: r.toolCallId }));
+        await writeApprovalToolResults(
+          options.writable,
+          approvedRawResults,
+          deniedResults
+        );
+      }
+    }
+    const modelPrompt = await convertToLanguageModelPrompt({
+      prompt,
+      supportedUrls: {},
+      download
+    });
+    const effectiveAbortSignal = mergeAbortSignals(
+      (_o = options.abortSignal) != null ? _o : effectiveGenerationSettings.abortSignal,
+      options.timeout
+    );
+    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.reasoning !== void 0 && { reasoning: options.reasoning },
+      ...options.providerOptions !== void 0 && {
+        providerOptions: options.providerOptions
+      }
+    };
+    mergedGenerationSettings.headers = withUserAgentSuffix(
+      (_p = mergedGenerationSettings.headers) != null ? _p : {},
+      "ai-sdk-agent/workflow"
+    );
+    const mergedOnStepEnd = mergeCallbacks(
+      this.constructorOnStepEnd,
+      (_q = options.onStepEnd) != null ? _q : options.onStepFinish
+    );
+    const mergedOnEnd = mergeCallbacks(
+      this.constructorOnEnd,
+      onEnd
+    );
+    const mergedOnStart = mergeCallbacks(
+      this.constructorOnStart,
+      options.experimental_onStart
+    );
+    const mergedOnStepStart = mergeCallbacks(
+      this.constructorOnStepStart,
+      options.experimental_onStepStart
+    );
+    const mergedOnToolExecutionStart = mergeCallbacks(
+      this.constructorOnToolExecutionStart,
+      options.onToolExecutionStart
+    );
+    const mergedOnToolExecutionEnd = mergeCallbacks(
+      this.constructorOnToolExecutionEnd,
+      options.onToolExecutionEnd
+    );
+    const effectiveToolChoice = effectiveToolChoiceFromPrepare;
+    const effectiveActiveTools = (_r = options.activeTools) != null ? _r : this.activeTools;
+    const effectiveTools = effectiveActiveTools && effectiveActiveTools.length > 0 ? (_s = filterActiveTools2({
+      tools: this.tools,
+      activeTools: effectiveActiveTools
+    })) != null ? _s : this.tools : this.tools;
+    const effectiveModelInfo = getModelInfo2(effectiveModel);
+    let runtimeContext = effectiveRuntimeContext;
+    let toolsContext = effectiveToolsContext;
+    const steps = [];
+    let lastStepToolCalls = [];
+    let lastStepToolResults = [];
+    if (mergedOnStart) {
+      await mergedOnStart({
+        model: effectiveModel,
+        messages: prompt.messages,
+        runtimeContext,
+        toolsContext
+      });
+    }
+    await ((_v = telemetryDispatcher.onStart) == null ? void 0 : _v.call(telemetryDispatcher, {
+      callId: "workflow-agent",
+      operationId: "ai.workflowAgent.stream",
+      provider: effectiveModelInfo.provider,
+      modelId: effectiveModelInfo.modelId,
+      system: void 0,
+      messages: prompt.messages,
+      tools: effectiveTools,
+      toolChoice: effectiveToolChoice,
+      activeTools: effectiveActiveTools,
+      maxOutputTokens: mergedGenerationSettings.maxOutputTokens,
+      temperature: mergedGenerationSettings.temperature,
+      topP: mergedGenerationSettings.topP,
+      topK: mergedGenerationSettings.topK,
+      presencePenalty: mergedGenerationSettings.presencePenalty,
+      frequencyPenalty: mergedGenerationSettings.frequencyPenalty,
+      stopSequences: mergedGenerationSettings.stopSequences,
+      seed: mergedGenerationSettings.seed,
+      maxRetries: (_t = mergedGenerationSettings.maxRetries) != null ? _t : 2,
+      timeout: void 0,
+      headers: mergedGenerationSettings.headers,
+      reasoning: mergedGenerationSettings.reasoning,
+      providerOptions: mergedGenerationSettings.providerOptions,
+      output: (_u = options.output) != null ? _u : this.output,
+      runtimeContext,
+      toolsContext
+    }));
+    const executeToolWithCallbacks = async (toolCall, tools, messages2, perToolContexts, currentStepNumber = 0, stepSandbox) => {
+      var _a2, _b2, _c2, _d2;
+      const toolCallEvent = {
+        type: "tool-call",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        input: toolCall.input
+      };
+      const tool2 = tools[toolCall.toolName];
+      const resolvedContext = tool2 ? await resolveToolContext({
+        toolName: toolCall.toolName,
+        tool: tool2,
+        toolsContext: perToolContexts
+      }) : void 0;
+      const modelMessages = getToolCallbackMessages(messages2);
+      if (mergedOnToolExecutionStart) {
+        await mergedOnToolExecutionStart({
+          toolCall: toolCallEvent,
+          stepNumber: currentStepNumber,
+          messages: modelMessages,
+          toolContext: resolvedContext
+        });
+      }
+      await ((_a2 = telemetryDispatcher.onToolExecutionStart) == null ? void 0 : _a2.call(telemetryDispatcher, {
+        toolCall: toolCallEvent,
+        stepNumber: currentStepNumber,
+        messages: modelMessages,
+        toolContext: resolvedContext
+      }));
+      const startTime = Date.now();
+      let result;
+      try {
+        const execute = () => executeTool(
+          toolCall,
+          tools,
+          messages2,
+          resolvedContext,
+          download,
+          stepSandbox
+        );
+        result = telemetryDispatcher.executeTool != null ? await telemetryDispatcher.executeTool({
+          callId: "workflow-agent",
+          toolCallId: toolCall.toolCallId,
+          execute
+        }) : await execute();
+      } catch (err) {
+        const durationMs2 = Date.now() - startTime;
+        if (mergedOnToolExecutionEnd) {
+          await mergedOnToolExecutionEnd({
+            toolCall: toolCallEvent,
+            stepNumber: currentStepNumber,
+            durationMs: durationMs2,
+            messages: modelMessages,
+            toolContext: resolvedContext,
+            success: false,
+            error: err
+          });
+        }
+        await ((_b2 = telemetryDispatcher.onToolExecutionEnd) == null ? void 0 : _b2.call(telemetryDispatcher, {
+          toolCall: toolCallEvent,
+          stepNumber: currentStepNumber,
+          durationMs: durationMs2,
+          messages: modelMessages,
+          toolContext: resolvedContext,
+          success: false,
+          error: err
+        }));
+        throw err;
+      }
+      const durationMs = Date.now() - startTime;
+      if (mergedOnToolExecutionEnd) {
+        if (result.isError) {
+          await mergedOnToolExecutionEnd({
+            toolCall: toolCallEvent,
+            stepNumber: currentStepNumber,
+            durationMs,
+            messages: modelMessages,
+            toolContext: resolvedContext,
+            success: false,
+            error: result.rawOutput
+          });
+        } else {
+          await mergedOnToolExecutionEnd({
+            toolCall: toolCallEvent,
+            stepNumber: currentStepNumber,
+            durationMs,
+            messages: modelMessages,
+            toolContext: resolvedContext,
+            success: true,
+            output: result.rawOutput
+          });
+        }
+      }
+      if (result.isError) {
+        await ((_c2 = telemetryDispatcher.onToolExecutionEnd) == null ? void 0 : _c2.call(telemetryDispatcher, {
+          toolCall: toolCallEvent,
+          stepNumber: currentStepNumber,
+          durationMs,
+          messages: modelMessages,
+          toolContext: resolvedContext,
+          success: false,
+          error: result.rawOutput
+        }));
+      } else {
+        await ((_d2 = telemetryDispatcher.onToolExecutionEnd) == null ? void 0 : _d2.call(telemetryDispatcher, {
+          toolCall: toolCallEvent,
+          stepNumber: currentStepNumber,
+          durationMs,
+          messages: modelMessages,
+          toolContext: resolvedContext,
+          success: true,
+          output: result.rawOutput
+        }));
+      }
+      return result;
+    };
+    const recordProviderExecutedToolTelemetry = async (toolCall, result, messages2, currentStepNumber) => {
+      var _a2, _b2;
+      const toolCallEvent = {
+        type: "tool-call",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        input: toolCall.input
+      };
+      const modelMessages = getToolCallbackMessages(messages2);
+      await ((_a2 = telemetryDispatcher.onToolExecutionStart) == null ? void 0 : _a2.call(telemetryDispatcher, {
+        toolCall: toolCallEvent,
+        stepNumber: currentStepNumber,
+        messages: modelMessages,
+        toolContext: void 0
+      }));
+      await ((_b2 = telemetryDispatcher.onToolExecutionEnd) == null ? void 0 : _b2.call(telemetryDispatcher, {
+        toolCall: toolCallEvent,
+        stepNumber: currentStepNumber,
+        durationMs: 0,
+        messages: modelMessages,
+        toolContext: void 0,
+        ...result.isError ? {
+          success: false,
+          error: result.rawOutput
+        } : {
+          success: true,
+          output: result.rawOutput
+        }
+      }));
+    };
+    if ((_w = mergedGenerationSettings.abortSignal) == null ? void 0 : _w.aborted) {
+      if (options.onAbort) {
+        await options.onAbort({ steps });
+      }
+      return {
+        messages: prompt.messages,
+        steps,
+        toolCalls: [],
+        toolResults: [],
+        finishReason: "other",
+        totalUsage: aggregateUsage(steps),
+        output: void 0
+      };
+    }
+    const iterator = streamTextIterator({
+      model: effectiveModel,
+      tools: effectiveTools,
+      writable: options.writable,
+      prompt: modelPrompt,
+      stopConditions: (_x = options.stopWhen) != null ? _x : this.stopWhen,
+      onStepEnd: mergedOnStepEnd,
+      onStepStart: mergedOnStepStart,
+      onError: options.onError,
+      prepareStep: (_y = options.prepareStep) != null ? _y : this.prepareStep,
+      generationSettings: mergedGenerationSettings,
+      toolChoice: effectiveToolChoice,
+      runtimeContext,
+      toolsContext,
+      telemetry: effectiveTelemetry,
+      includeRawChunks: (_z = options.includeRawChunks) != null ? _z : false,
+      repairToolCall: (_B = (_A = options.repairToolCall) != null ? _A : options.experimental_repairToolCall) != null ? _B : this.repairToolCall,
+      responseFormat: await ((_D = (_C = options.output) != null ? _C : this.output) == null ? void 0 : _D.responseFormat),
+      experimental_sandbox: sandbox
+    });
+    let finalMessages;
+    let encounteredError;
+    let wasAborted = false;
+    try {
+      let result = await iterator.next();
+      while (!result.done) {
+        if ((_E = mergedGenerationSettings.abortSignal) == null ? void 0 : _E.aborted) {
+          wasAborted = true;
+          if (options.onAbort) {
+            await options.onAbort({ steps });
+          }
+          break;
+        }
+        const {
+          toolCalls,
+          messages: iterMessages,
+          step,
+          runtimeContext: yieldedRuntimeContext,
+          toolsContext: yieldedToolsContext,
+          experimental_sandbox: stepSandbox,
+          providerExecutedToolResults
+        } = result.value;
+        const toolExecutionSandbox = stepSandbox != null ? stepSandbox : sandbox;
+        const currentStepNumber = steps.length;
+        if (step) {
+          steps.push(step);
+        }
+        if (yieldedRuntimeContext !== void 0) {
+          runtimeContext = yieldedRuntimeContext;
+        }
+        if (yieldedToolsContext !== void 0) {
+          toolsContext = yieldedToolsContext;
+        }
+        if (toolCalls.length > 0) {
+          const invalidToolCalls = toolCalls.filter((tc) => tc.invalid === true);
+          const validToolCalls = toolCalls.filter((tc) => tc.invalid !== true);
+          const nonProviderToolCalls = validToolCalls.filter(
+            (tc) => !tc.providerExecuted
+          );
+          const providerToolCalls = validToolCalls.filter(
+            (tc) => tc.providerExecuted
+          );
+          const approvalNeeded = await Promise.all(
+            nonProviderToolCalls.map(async (tc) => {
+              const tool2 = effectiveTools[tc.toolName];
+              if (!tool2) return false;
+              if (tool2.needsApproval == null) return false;
+              if (typeof tool2.needsApproval === "boolean")
+                return tool2.needsApproval;
+              const resolvedContext = await resolveToolContext({
+                toolName: tc.toolName,
+                tool: tool2,
+                toolsContext
+              });
+              return tool2.needsApproval(tc.input, {
+                toolCallId: tc.toolCallId,
+                messages: iterMessages,
+                context: resolvedContext
+              });
+            })
+          );
+          const executableToolCalls = nonProviderToolCalls.filter((tc, i) => {
+            const tool2 = effectiveTools[tc.toolName];
+            return (!tool2 || typeof tool2.execute === "function") && !approvalNeeded[i];
+          });
+          const pausedToolCalls = nonProviderToolCalls.filter((tc, i) => {
+            const tool2 = effectiveTools[tc.toolName];
+            return tool2 && typeof tool2.execute !== "function" || approvalNeeded[i];
+          });
+          if (pausedToolCalls.length > 0) {
+            const executableResults = await Promise.all(
+              executableToolCalls.map(
+                (toolCall) => executeToolWithCallbacks(
+                  toolCall,
+                  effectiveTools,
+                  iterMessages,
+                  toolsContext,
+                  currentStepNumber,
+                  toolExecutionSandbox
+                )
+              )
+            );
+            const providerResults = await Promise.all(
+              providerToolCalls.map(
+                (toolCall) => resolveProviderToolResult(
+                  toolCall,
+                  providerExecutedToolResults,
+                  effectiveTools,
+                  download
+                )
+              )
+            );
+            await Promise.all(
+              providerToolCalls.map(
+                (toolCall, index) => recordProviderExecutedToolTelemetry(
+                  toolCall,
+                  providerResults[index],
+                  iterMessages,
+                  currentStepNumber
+                )
+              )
+            );
+            const continuationInvalidResults = invalidToolCalls.map(
+              createInvalidToolResult
+            );
+            const resolvedResults = [
+              ...executableResults.map((result2) => result2.modelResult),
+              ...providerResults.map((result2) => result2.modelResult),
+              ...continuationInvalidResults
+            ];
+            const executedResults = [...executableResults, ...providerResults];
+            const allToolCalls = toolCalls.map((tc) => ({
+              type: "tool-call",
+              toolCallId: tc.toolCallId,
+              toolName: tc.toolName,
+              input: tc.input
+            }));
+            const allToolResults = executedResults.map((r) => {
+              var _a2;
+              return {
+                type: "tool-result",
+                toolCallId: r.modelResult.toolCallId,
+                toolName: r.modelResult.toolName,
+                input: (_a2 = toolCalls.find(
+                  (tc) => tc.toolCallId === r.modelResult.toolCallId
+                )) == null ? void 0 : _a2.input,
+                output: r.rawOutput
+              };
+            });
+            if (resolvedResults.length > 0) {
+              iterMessages.push({
+                role: "tool",
+                content: resolvedResults
+              });
+            }
+            const messages2 = iterMessages;
+            const lastStep2 = steps[steps.length - 1];
+            const totalUsage2 = aggregateUsage(steps);
+            const finishReason2 = (_F = lastStep2 == null ? void 0 : lastStep2.finishReason) != null ? _F : "other";
+            if (mergedOnEnd && !wasAborted) {
+              await mergedOnEnd({
+                steps,
+                messages: messages2,
+                text: (_G = lastStep2 == null ? void 0 : lastStep2.text) != null ? _G : "",
+                finishReason: finishReason2,
+                usage: totalUsage2,
+                totalUsage: totalUsage2,
+                runtimeContext,
+                toolsContext,
+                output: void 0
+              });
+            }
+            if (!wasAborted && steps.length > 0) {
+              const telemetrySteps = steps.map(normalizeStepForTelemetry2);
+              const lastTelemetryStep = telemetrySteps[telemetrySteps.length - 1];
+              await ((_H = telemetryDispatcher.onEnd) == null ? void 0 : _H.call(telemetryDispatcher, {
+                ...lastTelemetryStep,
+                steps: telemetrySteps,
+                usage: totalUsage2,
+                totalUsage: totalUsage2
+              }));
+            }
+            if (options.writable) {
+              const approvalToolCalls = pausedToolCalls.filter((_, i) => {
+                const tcIndex = nonProviderToolCalls.indexOf(
+                  pausedToolCalls[i]
+                );
+                return approvalNeeded[tcIndex];
+              });
+              if (approvalToolCalls.length > 0) {
+                await writeApprovalRequests(
+                  options.writable,
+                  approvalToolCalls.map((tc) => ({
+                    toolCallId: tc.toolCallId,
+                    toolName: tc.toolName
+                  }))
+                );
+              }
+            }
+            if (options.writable) {
+              const sendFinish = (_I = options.sendFinish) != null ? _I : true;
+              const preventClose = (_J = options.preventClose) != null ? _J : false;
+              if (sendFinish || !preventClose) {
+                await closeStream(options.writable, preventClose, sendFinish);
+              }
+            }
+            return {
+              messages: messages2,
+              steps,
+              toolCalls: allToolCalls,
+              toolResults: allToolResults,
+              finishReason: finishReason2,
+              totalUsage: totalUsage2,
+              output: void 0
+            };
+          }
+          const clientToolResults = await Promise.all(
+            nonProviderToolCalls.map(
+              (toolCall) => executeToolWithCallbacks(
+                toolCall,
+                effectiveTools,
+                iterMessages,
+                toolsContext,
+                currentStepNumber,
+                toolExecutionSandbox
+              )
+            )
+          );
+          const providerToolResults = await Promise.all(
+            providerToolCalls.map(
+              (toolCall) => resolveProviderToolResult(
+                toolCall,
+                providerExecutedToolResults,
+                effectiveTools,
+                download
+              )
+            )
+          );
+          await Promise.all(
+            providerToolCalls.map(
+              (toolCall, index) => recordProviderExecutedToolTelemetry(
+                toolCall,
+                providerToolResults[index],
+                iterMessages,
+                currentStepNumber
+              )
+            )
+          );
+          const continuationInvalidToolResults = invalidToolCalls.map(
+            createInvalidToolResult
+          );
+          const executedToolResults = toolCalls.flatMap((tc) => {
+            const clientResult = clientToolResults.find(
+              (r) => r.modelResult.toolCallId === tc.toolCallId
+            );
+            if (clientResult) return [clientResult];
+            const providerResult = providerToolResults.find(
+              (r) => r.modelResult.toolCallId === tc.toolCallId
+            );
+            if (providerResult) return [providerResult];
+            return [];
+          });
+          const continuationToolResults = toolCalls.flatMap((tc) => {
+            const invalidResult = continuationInvalidToolResults.find(
+              (r) => r.toolCallId === tc.toolCallId
+            );
+            if (invalidResult) return [invalidResult];
+            const executedResult = executedToolResults.find(
+              (r) => r.modelResult.toolCallId === tc.toolCallId
+            );
+            if (executedResult) return [executedResult.modelResult];
+            return [];
+          });
+          if (options.writable) {
+            await writeToolResultsWithStepBoundary(
+              options.writable,
+              executedToolResults.map((r) => {
+                var _a2;
+                return {
+                  toolCallId: r.modelResult.toolCallId,
+                  toolName: r.modelResult.toolName,
+                  input: (_a2 = toolCalls.find(
+                    (tc) => tc.toolCallId === r.modelResult.toolCallId
+                  )) == null ? void 0 : _a2.input,
+                  output: r.rawOutput
+                };
+              })
+            );
+          }
+          lastStepToolCalls = toolCalls.map((tc) => ({
+            type: "tool-call",
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            input: tc.input
+          }));
+          lastStepToolResults = executedToolResults.map((r) => {
+            var _a2;
+            return {
+              type: "tool-result",
+              toolCallId: r.modelResult.toolCallId,
+              toolName: r.modelResult.toolName,
+              input: (_a2 = toolCalls.find(
+                (tc) => tc.toolCallId === r.modelResult.toolCallId
+              )) == null ? void 0 : _a2.input,
+              output: r.rawOutput
+            };
+          });
+          result = await iterator.next(continuationToolResults);
+        } 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 });
+      }
+      await ((_K = telemetryDispatcher.onError) == null ? void 0 : _K.call(telemetryDispatcher, error));
+    }
+    const messages = finalMessages != null ? finalMessages : prompt.messages;
+    const effectiveOutput = (_L = options.output) != null ? _L : this.output;
+    let experimentalOutput = void 0;
+    if (effectiveOutput && steps.length > 0) {
+      const lastStep2 = steps[steps.length - 1];
+      const text = lastStep2.text;
+      if (text) {
+        try {
+          experimentalOutput = await effectiveOutput.parseCompleteOutput(
+            { text },
+            {
+              response: lastStep2.response,
+              usage: lastStep2.usage,
+              finishReason: lastStep2.finishReason
+            }
+          );
+        } catch (parseError) {
+          if (!encounteredError) {
+            encounteredError = parseError;
+          }
+        }
+      }
+    }
+    const lastStep = steps[steps.length - 1];
+    const totalUsage = aggregateUsage(steps);
+    const finishReason = (_M = lastStep == null ? void 0 : lastStep.finishReason) != null ? _M : "other";
+    if (mergedOnEnd && !wasAborted) {
+      await mergedOnEnd({
+        steps,
+        messages,
+        text: (_N = lastStep == null ? void 0 : lastStep.text) != null ? _N : "",
+        finishReason,
+        usage: totalUsage,
+        totalUsage,
+        runtimeContext,
+        toolsContext,
+        output: experimentalOutput
+      });
+    }
+    if (!wasAborted && steps.length > 0) {
+      const telemetrySteps = steps.map(normalizeStepForTelemetry2);
+      const lastTelemetryStep = telemetrySteps[telemetrySteps.length - 1];
+      await ((_O = telemetryDispatcher.onEnd) == null ? void 0 : _O.call(telemetryDispatcher, {
+        ...lastTelemetryStep,
+        steps: telemetrySteps,
+        usage: totalUsage,
+        totalUsage
+      }));
+    }
+    if (encounteredError) {
+      if (options.writable) {
+        const sendFinish = (_P = options.sendFinish) != null ? _P : true;
+        const preventClose = (_Q = options.preventClose) != null ? _Q : false;
+        if (sendFinish || !preventClose) {
+          await closeStream(options.writable, preventClose, sendFinish);
+        }
+      }
+      throw encounteredError;
+    }
+    if (options.writable) {
+      const sendFinish = (_R = options.sendFinish) != null ? _R : true;
+      const preventClose = (_S = options.preventClose) != null ? _S : false;
+      if (sendFinish || !preventClose) {
+        await closeStream(options.writable, preventClose, sendFinish);
+      }
+    }
+    return {
+      messages,
+      steps,
+      toolCalls: lastStepToolCalls,
+      toolResults: lastStepToolResults,
+      finishReason,
+      totalUsage,
+      output: experimentalOutput
+    };
+  }
+};
+function getModelInfo2(model) {
+  var _a;
+  return typeof model === "string" ? { provider: (_a = model.split("/")[0]) != null ? _a : "gateway", modelId: model } : { provider: model.provider, modelId: model.modelId };
+}
+function normalizeStepForTelemetry2(step) {
+  var _a;
+  return {
+    ...step,
+    model: (_a = step.model) != null ? _a : { provider: "unknown", modelId: "unknown" }
+  };
+}
+async function closeStream(writable, preventClose, sendFinish) {
+  "use step";
+  if (sendFinish) {
+    const writer = writable.getWriter();
+    try {
+      await writer.write({ type: "finish" });
+    } finally {
+      writer.releaseLock();
+    }
+  }
+  if (!preventClose) {
+    await writable.close();
+  }
+}
+async function writeApprovalRequests(writable, toolCalls) {
+  "use step";
+  const writer = writable.getWriter();
+  try {
+    for (const tc of toolCalls) {
+      await writer.write({
+        type: "tool-approval-request",
+        approvalId: `approval-${tc.toolCallId}`,
+        toolCallId: tc.toolCallId
+      });
+    }
+  } finally {
+    writer.releaseLock();
+  }
+}
+async function writeToolResultsWithStepBoundary(writable, results) {
+  "use step";
+  const writer = writable.getWriter();
+  try {
+    for (const r of results) {
+      await writer.write({
+        type: "tool-result",
+        toolCallId: r.toolCallId,
+        toolName: r.toolName,
+        input: r.input,
+        output: r.output
+      });
+    }
+    await writer.write({ type: "finish-step" });
+    await writer.write({ type: "start-step" });
+  } finally {
+    writer.releaseLock();
+  }
+}
+async function writeApprovalToolResults(writable, approvedResults, deniedResults) {
+  "use step";
+  const writer = writable.getWriter();
+  try {
+    for (const r of approvedResults) {
+      await writer.write({
+        type: "tool-result",
+        toolCallId: r.toolCallId,
+        toolName: r.toolName,
+        input: r.input,
+        output: r.output
+      });
+    }
+    for (const r of deniedResults) {
+      await writer.write({
+        type: "tool-output-denied",
+        toolCallId: r.toolCallId
+      });
+    }
+    await writer.write({ type: "finish-step" });
+    await writer.write({ type: "start-step" });
+  } finally {
+    writer.releaseLock();
+  }
+}
+async function resolveToolContext({
+  toolName,
+  tool: tool2,
+  toolsContext
+}) {
+  const contextSchema = tool2.contextSchema;
+  const entry = toolsContext == null ? void 0 : toolsContext[toolName];
+  if (contextSchema == null) {
+    return entry;
+  }
+  return await validateTypes({
+    value: entry,
+    schema: contextSchema,
+    context: { field: "tool context", entityName: toolName }
+  });
+}
+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
+  };
+}
+async function resolveProviderToolResult(toolCall, providerExecutedToolResults, tools, download) {
+  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 {
+      modelResult: {
+        type: "tool-result",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: {
+          type: "text",
+          value: ""
+        }
+      },
+      rawOutput: "",
+      isError: false
+    };
+  }
+  const result = streamResult.result;
+  const errorMode = streamResult.isError ? typeof result === "string" ? "text" : "json" : "none";
+  return {
+    modelResult: {
+      type: "tool-result",
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      output: await createLanguageModelToolResultOutput({
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        input: toolCall.input,
+        output: result,
+        tool: tools == null ? void 0 : tools[toolCall.toolName],
+        errorMode,
+        supportedUrls: {},
+        download
+      })
+    },
+    rawOutput: result,
+    isError: streamResult.isError === true
+  };
+}
+function createInvalidToolResult(toolCall) {
+  return {
+    type: "tool-result",
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    output: {
+      type: "error-text",
+      value: getErrorMessage(toolCall.error)
+    }
+  };
+}
+function getToolCallbackMessages(messages) {
+  var _a;
+  const withoutAssistantToolCall = ((_a = messages.at(-1)) == null ? void 0 : _a.role) === "assistant" ? messages.slice(0, -1) : messages;
+  return withoutAssistantToolCall;
+}
+async function executeTool(toolCall, tools, messages, context, download, sandbox) {
+  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;
+  let toolResult;
+  try {
+    const { execute } = tool2;
+    toolResult = await execute(parsedInput, {
+      toolCallId: toolCall.toolCallId,
+      // Pass the conversation messages to the tool so it has context about the conversation
+      messages,
+      // Pass per-tool context to the tool (resolved from `toolsContext`)
+      context,
+      experimental_sandbox: sandbox
+    });
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    return {
+      modelResult: {
+        type: "tool-result",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: await createLanguageModelToolResultOutput({
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          input: parsedInput,
+          output: errorMessage,
+          tool: tool2,
+          errorMode: "text",
+          supportedUrls: {},
+          download
+        })
+      },
+      rawOutput: errorMessage,
+      isError: true
+    };
+  }
+  return {
+    modelResult: {
+      type: "tool-result",
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      output: await createLanguageModelToolResultOutput({
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        input: parsedInput,
+        output: toolResult,
+        tool: tool2,
+        errorMode: "none",
+        supportedUrls: {},
+        download
+      })
+    },
+    rawOutput: toolResult,
+    isError: false
+  };
+}
+
+// src/to-ui-message-chunk.ts
+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: {
+      const passthroughPart = part;
+      if (passthroughPart.type === "tool-approval-request") {
+        return {
+          type: "tool-approval-request",
+          approvalId: passthroughPart.approvalId,
+          toolCallId: passthroughPart.toolCallId
+        };
+      }
+      if (passthroughPart.type === "finish-step" || passthroughPart.type === "start-step" || passthroughPart.type === "tool-output-denied") {
+        return passthroughPart;
+      }
+      return void 0;
+    }
+  }
+}
+function createModelCallToUIChunkTransform() {
+  return new TransformStream({
+    start: (controller) => {
+      controller.enqueue({ type: "start" });
+      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);
+      }
+    }
+  });
+}
+
+// src/workflow-chat-transport.ts
+import {
+  parseJsonEventStream,
+  uiMessageChunkSchema
+} from "ai";
+import {
+  convertAsyncIteratorToReadableStream,
+  getErrorMessage as getErrorMessage2
+} from "@ai-sdk/provider-utils";
+import { createAsyncIterableStream } from "ai/internal";
+
+// src/normalize-ui-message-stream.ts
+var newPartFrameState = () => ({
+  open: /* @__PURE__ */ new Set(),
+  ended: /* @__PURE__ */ new Set()
+});
+function* repairPart(kind, id, chunk, state, startType) {
+  if (kind === "start") {
+    if (state.open.has(id) || state.ended.has(id)) {
+      return;
+    }
+    state.open.add(id);
+    yield chunk;
+    return;
+  }
+  if (state.ended.has(id)) {
+    return;
+  }
+  if (!state.open.has(id)) {
+    state.open.add(id);
+    yield { type: startType, id };
+  }
+  if (kind === "end") {
+    state.open.delete(id);
+    state.ended.add(id);
+  }
+  yield chunk;
+}
+async function* normalizeUIMessageStreamParts(source) {
+  const text = newPartFrameState();
+  const reasoning = newPartFrameState();
+  for await (const chunk of source) {
+    switch (chunk.type) {
+      case "finish-step":
+        text.open.clear();
+        text.ended.clear();
+        reasoning.open.clear();
+        reasoning.ended.clear();
+        yield chunk;
+        break;
+      case "text-start":
+        yield* repairPart("start", chunk.id, chunk, text, "text-start");
+        break;
+      case "text-delta":
+        yield* repairPart("delta", chunk.id, chunk, text, "text-start");
+        break;
+      case "text-end":
+        yield* repairPart("end", chunk.id, chunk, text, "text-start");
+        break;
+      case "reasoning-start":
+        yield* repairPart(
+          "start",
+          chunk.id,
+          chunk,
+          reasoning,
+          "reasoning-start"
+        );
+        break;
+      case "reasoning-delta":
+        yield* repairPart(
+          "delta",
+          chunk.id,
+          chunk,
+          reasoning,
+          "reasoning-start"
+        );
+        break;
+      case "reasoning-end":
+        yield* repairPart("end", chunk.id, chunk, reasoning, "reasoning-start");
+        break;
+      default:
+        yield chunk;
+    }
+  }
+}
+
+// src/workflow-chat-transport.ts
+function createOrphanFilter() {
+  const seenStartedIds = /* @__PURE__ */ new Set();
+  const seenStartedToolCallIds = /* @__PURE__ */ new Set();
+  let warnedOnce = false;
+  function warnOnce(orphanKind, orphanRef) {
+    if (warnedOnce) return;
+    warnedOnce = true;
+    console.warn(
+      `[WorkflowChatTransport] Dropping orphan UI chunk (${orphanKind} for id "${orphanRef}") on resume \u2014 the resume position landed mid-part. The dropped chunk(s) reference a part whose start chunk wasn't in the resumed window. To preserve the full message, configure your stream endpoint to rewind to a step boundary before returning the readable. See: https://workflow.dev/docs/ai/resumable-streams#mid-part-resumes`
+    );
+  }
+  function shouldDrop(chunk) {
+    switch (chunk.type) {
+      case "text-start":
+      case "reasoning-start":
+        seenStartedIds.add(chunk.id);
+        return false;
+      case "tool-input-start":
+      // `tool-input-available` / `tool-input-error` are self-contained: the
+      // AI SDK creates the tool part from them directly (non-streamed tool
+      // calls are emitted as a bare `tool-input-available`), so they must
+      // never be dropped. They also carry the full input, so they recover a
+      // tool call whose `tool-input-start` fell outside the resumed window.
+      case "tool-input-available":
+      case "tool-input-error":
+        seenStartedToolCallIds.add(chunk.toolCallId);
+        return false;
+      case "text-delta":
+      case "text-end":
+      case "reasoning-delta":
+      case "reasoning-end":
+        if (seenStartedIds.has(chunk.id)) return false;
+        warnOnce(chunk.type, chunk.id);
+        return true;
+      case "tool-input-delta":
+      case "tool-approval-request":
+      case "tool-output-available":
+      case "tool-output-error":
+      case "tool-output-denied":
+        if (seenStartedToolCallIds.has(chunk.toolCallId)) return false;
+        warnOnce(chunk.type, chunk.toolCallId);
+        return true;
+      default:
+        return false;
+    }
+  }
+  return { shouldDrop };
+}
+var WorkflowChatTransport = class {
+  /**
+   * Creates a new WorkflowChatTransport instance.
+   *
+   * @param options - Configuration options for the transport
+   * @param options.api - API endpoint for chat requests (defaults to '/api/chat')
+   * @param options.fetch - Custom fetch implementation (defaults to global fetch)
+   * @param options.onChatSendMessage - Callback after sending messages
+   * @param options.onChatEnd - Callback when chat stream ends
+   * @param options.maxConsecutiveErrors - Maximum consecutive errors for reconnection
+   * @param options.prepareSendMessagesRequest - Function to prepare send messages request
+   * @param options.prepareReconnectToStreamRequest - Function to prepare reconnect request
+   */
+  constructor(options = {}) {
+    var _a, _b, _c, _d;
+    this.api = (_a = options.api) != null ? _a : "/api/chat";
+    this.fetch = (_b = options.fetch) != null ? _b : fetch.bind(globalThis);
+    this.onChatSendMessage = options.onChatSendMessage;
+    this.onChatEnd = options.onChatEnd;
+    this.maxConsecutiveErrors = (_c = options.maxConsecutiveErrors) != null ? _c : 3;
+    this.initialStartIndex = (_d = options.initialStartIndex) != null ? _d : 0;
+    this.prepareSendMessagesRequest = options.prepareSendMessagesRequest;
+    this.prepareReconnectToStreamRequest = options.prepareReconnectToStreamRequest;
+  }
+  /**
+   * Sends messages to the chat endpoint and returns a stream of response chunks.
+   *
+   * This method handles the entire chat lifecycle including:
+   * - Sending messages to the /api/chat endpoint
+   * - Streaming response chunks
+   * - Automatic reconnection if the stream is interrupted
+   *
+   * @param options - Options for sending messages
+   * @param options.trigger - The type of message submission ('submit-message' or 'regenerate-message')
+   * @param options.chatId - Unique identifier for this chat session
+   * @param options.messageId - Optional message ID for tracking specific messages
+   * @param options.messages - Array of UI messages to send
+   * @param options.abortSignal - Optional AbortSignal to cancel the request
+   *
+   * @returns A ReadableStream of UIMessageChunk objects containing the response
+   * @throws Error if the fetch request fails or returns a non-OK status
+   */
+  async sendMessages(options) {
+    return convertAsyncIteratorToReadableStream(
+      normalizeUIMessageStreamParts(this.sendMessagesIterator(options))
+    );
+  }
+  async *sendMessagesIterator(options) {
+    var _a, _b, _c;
+    const { chatId, messages, abortSignal, trigger, messageId } = options;
+    let gotFinish = false;
+    let chunkIndex = 0;
+    const requestConfig = this.prepareSendMessagesRequest ? await this.prepareSendMessagesRequest({
+      id: chatId,
+      messages,
+      requestMetadata: options.metadata,
+      body: options.body,
+      credentials: void 0,
+      headers: options.headers,
+      api: this.api,
+      trigger,
+      messageId
+    }) : void 0;
+    const url = (_a = requestConfig == null ? void 0 : requestConfig.api) != null ? _a : this.api;
+    const response = await this.fetch(url, {
+      method: "POST",
+      body: JSON.stringify(
+        (_b = requestConfig == null ? void 0 : requestConfig.body) != null ? _b : { messages, ...options.body }
+      ),
+      headers: requestConfig == null ? void 0 : requestConfig.headers,
+      credentials: requestConfig == null ? void 0 : requestConfig.credentials,
+      signal: abortSignal
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(
+        `Failed to fetch chat: ${response.status} ${await response.text()}`
+      );
+    }
+    const workflowRunId = response.headers.get("x-workflow-run-id");
+    if (!workflowRunId) {
+      throw new Error(
+        'Workflow run ID not found in "x-workflow-run-id" response header'
+      );
+    }
+    await ((_c = this.onChatSendMessage) == null ? void 0 : _c.call(this, response, options));
+    try {
+      const chunkStream = parseJsonEventStream({
+        stream: response.body,
+        schema: uiMessageChunkSchema
+      });
+      for await (const chunk of createAsyncIterableStream(chunkStream)) {
+        if (!chunk.success) {
+          throw chunk.error;
+        }
+        chunkIndex++;
+        yield chunk.value;
+        if (chunk.value.type === "finish") {
+          gotFinish = true;
+        }
+      }
+    } catch (error) {
+      console.error("Error in chat POST stream", error);
+    }
+    if (gotFinish) {
+      await this.onFinish(gotFinish, { chatId, chunkIndex });
+    } else {
+      yield* this.reconnectToStreamIterator(options, workflowRunId, chunkIndex);
+    }
+  }
+  /**
+   * Reconnects to an existing chat stream that was previously interrupted.
+   *
+   * This method is useful for resuming a chat session after network issues,
+   * page refreshes, or Vercel Function timeouts.
+   *
+   * @param options - Options for reconnecting to the stream
+   * @param options.chatId - The chat ID to reconnect to
+   *
+   * @returns A ReadableStream of UIMessageChunk objects
+   * @throws Error if the reconnection request fails or returns a non-OK status
+   */
+  async reconnectToStream(options) {
+    const reconnectIterator = normalizeUIMessageStreamParts(
+      this.reconnectToStreamIterator(options)
+    );
+    return convertAsyncIteratorToReadableStream(reconnectIterator);
+  }
+  async *reconnectToStreamIterator(options, workflowRunId, initialChunkIndex = 0) {
+    var _a, _b;
+    let chunkIndex = initialChunkIndex;
+    const explicitStartIndex = (_a = options.startIndex) != null ? _a : this.initialStartIndex;
+    let useExplicitStartIndex = initialChunkIndex === 0 && explicitStartIndex !== 0;
+    const defaultApi = `${this.api}/${encodeURIComponent(workflowRunId != null ? workflowRunId : options.chatId)}/stream`;
+    const requestConfig = this.prepareReconnectToStreamRequest ? await this.prepareReconnectToStreamRequest({
+      id: options.chatId,
+      requestMetadata: options.metadata,
+      body: void 0,
+      credentials: void 0,
+      headers: void 0,
+      api: defaultApi
+    }) : void 0;
+    const baseUrl = (_b = requestConfig == null ? void 0 : requestConfig.api) != null ? _b : defaultApi;
+    let gotFinish = false;
+    let consecutiveErrors = 0;
+    let replayFromStart = false;
+    const orphanFilter = useExplicitStartIndex && explicitStartIndex < 0 ? createOrphanFilter() : null;
+    while (!gotFinish) {
+      const startIndex = useExplicitStartIndex ? explicitStartIndex : replayFromStart ? 0 : chunkIndex;
+      const url = `${baseUrl}?startIndex=${startIndex}`;
+      const response = await this.fetch(url, {
+        headers: requestConfig == null ? void 0 : requestConfig.headers,
+        credentials: requestConfig == null ? void 0 : requestConfig.credentials,
+        signal: options.abortSignal
+      });
+      if (!response.ok || !response.body) {
+        throw new Error(
+          `Failed to fetch chat: ${response.status} ${await response.text()}`
+        );
+      }
+      if (useExplicitStartIndex && explicitStartIndex > 0) {
+        chunkIndex = explicitStartIndex;
+      } else if (useExplicitStartIndex && explicitStartIndex < 0) {
+        const tailIndexHeader = response.headers.get(
+          "x-workflow-stream-tail-index"
+        );
+        const tailIndex = tailIndexHeader !== null ? parseInt(tailIndexHeader, 10) : NaN;
+        if (!Number.isNaN(tailIndex)) {
+          chunkIndex = Math.max(0, tailIndex + 1 + explicitStartIndex);
+        } else {
+          console.warn(
+            `[WorkflowChatTransport] Negative initialStartIndex is configured (${explicitStartIndex}) but the reconnection endpoint did not return a valid "x-workflow-stream-tail-index" header. Retries will replay the stream from the beginning. See: https://workflow.dev/docs/ai/resumable-streams#resuming-from-the-end-of-the-stream`
+          );
+          replayFromStart = true;
+        }
+      }
+      useExplicitStartIndex = false;
+      try {
+        const chunkStream = parseJsonEventStream({
+          stream: response.body,
+          schema: uiMessageChunkSchema
+        });
+        for await (const chunk of createAsyncIterableStream(chunkStream)) {
+          if (!chunk.success) {
+            throw chunk.error;
+          }
+          chunkIndex++;
+          if (orphanFilter == null ? void 0 : orphanFilter.shouldDrop(chunk.value)) continue;
+          yield chunk.value;
+          if (chunk.value.type === "finish") {
+            gotFinish = true;
+          }
+        }
+        consecutiveErrors = 0;
+      } catch (error) {
+        console.error("Error in chat GET reconnectToStream", error);
+        consecutiveErrors++;
+        if (consecutiveErrors >= this.maxConsecutiveErrors) {
+          throw new Error(
+            `Failed to reconnect after ${this.maxConsecutiveErrors} consecutive errors. Last error: ${getErrorMessage2(error)}`
+          );
+        }
+      }
+    }
+    await this.onFinish(gotFinish, { chatId: options.chatId, chunkIndex });
+  }
+  async onFinish(gotFinish, { chatId, chunkIndex }) {
+    var _a;
+    if (gotFinish) {
+      await ((_a = this.onChatEnd) == null ? void 0 : _a.call(this, { chatId, chunkIndex }));
+    } else {
+      throw new Error("No finish chunk received");
+    }
+  }
+};
+export {
+  Output,
+  WorkflowAgent,
+  WorkflowChatTransport,
+  createModelCallToUIChunkTransform,
+  normalizeUIMessageStreamParts,
+  toUIMessageChunk
+};
+//# sourceMappingURL=index.js.map