@ai-sdk/workflow 1.0.0-beta.9 → 1.0.0-beta.95

package/dist/index.mjs

@@ -1,19 +1,82 @@
 // src/workflow-agent.ts
 import {
-  Output
+  getErrorMessage,
+  validateTypes
+} from "@ai-sdk/provider-utils";
+import {
+  Output,
+  experimental_filterActiveTools as filterActiveTools2
 } from "ai";
 import {
+  createRestrictedTelemetryDispatcher as createRestrictedTelemetryDispatcher2,
+  collectToolApprovals,
   convertToLanguageModelPrompt,
   mergeAbortSignals,
   mergeCallbacks,
-  standardizePrompt
+  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
+  experimental_streamLanguageModelCall as streamModelCall,
+  gateway
 } from "ai";
-import { gateway } from "ai";
 
 // src/serializable-schema.ts
 import { asSchema, jsonSchema } from "@ai-sdk/provider-utils";
@@ -22,12 +85,15 @@ 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;
       }
@@ -39,7 +105,7 @@ function resolveSerializableTools(tools) {
   const ajv = new Ajv();
   return Object.fromEntries(
     Object.entries(tools).map(([name, t]) => {
-      var _a;
+      var _a, _b;
       if (t.type === "provider") {
         return [
           name,
@@ -47,6 +113,7 @@ function resolveSerializableTools(tools) {
             type: "provider",
             id: t.id,
             args: (_a = t.args) != null ? _a : {},
+            isProviderExecuted: (_b = t.isProviderExecuted) != null ? _b : false,
             inputSchema: jsonSchema(t.inputSchema)
           })
         ];
@@ -76,7 +143,7 @@ function resolveSerializableTools(tools) {
 // src/do-stream-step.ts
 async function doStreamStep(conversationPrompt, modelInit, writable, serializedTools, options) {
   "use step";
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
   const model = typeof modelInit === "string" ? gateway.languageModel(modelInit) : modelInit;
   const tools = serializedTools ? resolveSerializableTools(serializedTools) : void 0;
   const { stream: modelStream } = await streamModelCall({
@@ -85,6 +152,7 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
     // 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,
@@ -106,11 +174,15 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
   let finish;
   let text = "";
   const reasoningParts = [];
+  const chunks = [];
   let responseMetadata;
   let warnings;
   const writer = writable == null ? void 0 : writable.getWriter();
   try {
     for await (const part of modelStream) {
+      if (part.type !== "model-call-start" && part.type !== "model-call-end" && part.type !== "model-call-response-metadata") {
+        chunks.push(part);
+      }
       switch (part.type) {
         case "text-delta":
           text += part.text;
@@ -180,14 +252,15 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
   const reasoningText = reasoningParts.map((r) => r.text).join("") || void 0;
   const step = {
     callId: "workflow-agent",
-    stepNumber: 0,
+    stepNumber: (_a = options == null ? void 0 : options.stepNumber) != null ? _a : 0,
     model: {
-      provider: (_b = (_a = responseMetadata == null ? void 0 : responseMetadata.modelId) == null ? void 0 : _a.split(":")[0]) != null ? _b : "unknown",
-      modelId: (_c = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _c : "unknown"
+      provider: (_c = (_b = responseMetadata == null ? void 0 : responseMetadata.modelId) == null ? void 0 : _b.split(":")[0]) != null ? _c : "unknown",
+      modelId: (_d = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _d : "unknown"
     },
     functionId: void 0,
     metadata: void 0,
-    context: void 0,
+    runtimeContext: (_e = options == null ? void 0 : options.runtimeContext) != null ? _e : {},
+    toolsContext: (_f = options == null ? void 0 : options.toolsContext) != null ? _f : {},
     content: [
       ...text ? [{ type: "text", text }] : [],
       ...toolCalls.filter((tc) => !tc.invalid).map((tc) => ({
@@ -224,9 +297,9 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
     toolResults: [],
     staticToolResults: [],
     dynamicToolResults: [],
-    finishReason: (_d = finish == null ? void 0 : finish.finishReason) != null ? _d : "other",
+    finishReason: (_g = finish == null ? void 0 : finish.finishReason) != null ? _g : "other",
     rawFinishReason: finish == null ? void 0 : finish.rawFinishReason,
-    usage: (_e = finish == null ? void 0 : finish.usage) != null ? _e : {
+    usage: (_h = finish == null ? void 0 : finish.usage) != null ? _h : {
       inputTokens: 0,
       inputTokenDetails: {
         noCacheTokens: void 0,
@@ -240,20 +313,35 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
       },
       totalTokens: 0
     },
+    performance: {
+      effectiveOutputTokensPerSecond: 0,
+      outputTokensPerSecond: void 0,
+      inputTokensPerSecond: void 0,
+      effectiveTotalTokensPerSecond: 0,
+      stepTimeMs: 0,
+      responseTimeMs: 0,
+      toolExecutionMs: {},
+      timeToFirstOutputMs: void 0
+    },
     warnings,
-    request: { body: "" },
+    request: {
+      body: "",
+      messages: []
+      // TODO implement step request messages
+    },
     response: {
-      id: (_f = responseMetadata == null ? void 0 : responseMetadata.id) != null ? _f : "unknown",
-      timestamp: (_g = responseMetadata == null ? void 0 : responseMetadata.timestamp) != null ? _g : /* @__PURE__ */ new Date(),
-      modelId: (_h = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _h : "unknown",
+      id: (_i = responseMetadata == null ? void 0 : responseMetadata.id) != null ? _i : "unknown",
+      timestamp: (_j = responseMetadata == null ? void 0 : responseMetadata.timestamp) != null ? _j : /* @__PURE__ */ new Date(),
+      modelId: (_k = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _k : "unknown",
       messages: []
     },
-    providerMetadata: (_i = finish == null ? void 0 : finish.providerMetadata) != null ? _i : {}
+    providerMetadata: (_l = finish == null ? void 0 : finish.providerMetadata) != null ? _l : {}
   };
   return {
     toolCalls,
     finish,
     step,
+    chunks,
     providerExecutedToolResults
   };
 }
@@ -265,25 +353,27 @@ async function* streamTextIterator({
   writable,
   model,
   stopConditions,
-  maxSteps,
+  onStepEnd,
   onStepFinish,
   onStepStart,
   onError,
   prepareStep,
   generationSettings,
   toolChoice,
-  experimental_context,
-  experimental_telemetry,
+  runtimeContext,
+  toolsContext,
+  telemetry,
   includeRawChunks = false,
   repairToolCall,
   responseFormat
 }) {
-  var _a;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   let conversationPrompt = [...prompt];
   let currentModel = model;
   let currentGenerationSettings = generationSettings != null ? generationSettings : {};
   let currentToolChoice = toolChoice;
-  let currentContext = experimental_context;
+  let currentRuntimeContext = runtimeContext != null ? runtimeContext : {};
+  let currentToolsContext = toolsContext != null ? toolsContext : {};
   let currentActiveTools;
   const steps = [];
   let done = false;
@@ -291,11 +381,12 @@ async function* streamTextIterator({
   let stepNumber = 0;
   let lastStep;
   let lastStepWasToolCalls = false;
-  const effectiveMaxSteps = maxSteps != null ? maxSteps : Infinity;
+  const telemetryDispatcher = createRestrictedTelemetryDispatcher({
+    telemetry,
+    includeRuntimeContext: telemetry == null ? void 0 : telemetry.includeRuntimeContext,
+    includeToolsContext: telemetry == null ? void 0 : telemetry.includeToolsContext
+  });
   while (!done) {
-    if (stepNumber >= effectiveMaxSteps) {
-      break;
-    }
     if ((_a = currentGenerationSettings.abortSignal) == null ? void 0 : _a.aborted) {
       break;
     }
@@ -305,15 +396,16 @@ async function* streamTextIterator({
         stepNumber,
         steps,
         messages: conversationPrompt,
-        experimental_context: currentContext
+        runtimeContext: currentRuntimeContext,
+        toolsContext: currentToolsContext
       });
-      if (prepareResult.model !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.model) !== void 0) {
         currentModel = prepareResult.model;
       }
-      if (prepareResult.messages !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.messages) !== void 0) {
         conversationPrompt = [...prepareResult.messages];
       }
-      if (prepareResult.system !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.system) !== void 0) {
         if (conversationPrompt.length > 0 && conversationPrompt[0].role === "system") {
           conversationPrompt[0] = {
             role: "system",
@@ -326,79 +418,82 @@ async function* streamTextIterator({
           });
         }
       }
-      if (prepareResult.experimental_context !== void 0) {
-        currentContext = prepareResult.experimental_context;
+      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.activeTools !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.activeTools) !== void 0) {
         currentActiveTools = prepareResult.activeTools;
       }
-      if (prepareResult.maxOutputTokens !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.maxOutputTokens) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           maxOutputTokens: prepareResult.maxOutputTokens
         };
       }
-      if (prepareResult.temperature !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.temperature) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           temperature: prepareResult.temperature
         };
       }
-      if (prepareResult.topP !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.topP) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           topP: prepareResult.topP
         };
       }
-      if (prepareResult.topK !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.topK) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           topK: prepareResult.topK
         };
       }
-      if (prepareResult.presencePenalty !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.presencePenalty) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           presencePenalty: prepareResult.presencePenalty
         };
       }
-      if (prepareResult.frequencyPenalty !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.frequencyPenalty) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           frequencyPenalty: prepareResult.frequencyPenalty
         };
       }
-      if (prepareResult.stopSequences !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.stopSequences) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           stopSequences: prepareResult.stopSequences
         };
       }
-      if (prepareResult.seed !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.seed) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           seed: prepareResult.seed
         };
       }
-      if (prepareResult.maxRetries !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.maxRetries) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           maxRetries: prepareResult.maxRetries
         };
       }
-      if (prepareResult.headers !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.headers) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           headers: prepareResult.headers
         };
       }
-      if (prepareResult.providerOptions !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.providerOptions) !== void 0) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           providerOptions: prepareResult.providerOptions
         };
       }
-      if (prepareResult.toolChoice !== void 0) {
+      if ((prepareResult == null ? void 0 : prepareResult.toolChoice) !== void 0) {
         currentToolChoice = prepareResult.toolChoice;
       }
     }
@@ -407,12 +502,53 @@ async function* streamTextIterator({
         stepNumber,
         model: currentModel,
         messages: conversationPrompt,
-        steps: [...steps]
+        steps: [...steps],
+        runtimeContext: currentRuntimeContext,
+        toolsContext: currentToolsContext
       });
     }
+    const stepStartModelInfo = getModelInfo(currentModel);
+    await ((_b = telemetryDispatcher.onStepStart) == null ? void 0 : _b.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 ? filterToolSet(tools, currentActiveTools) : tools;
+      const effectiveTools = currentActiveTools && currentActiveTools.length > 0 ? (_c = filterActiveTools({
+        tools,
+        activeTools: currentActiveTools
+      })) != null ? _c : tools : tools;
       const serializedTools = serializeToolSet(effectiveTools);
+      const modelCallInfo = getModelInfo(currentModel);
+      await ((_d = telemetryDispatcher.onLanguageModelCallStart) == null ? void 0 : _d.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,
+        providerOptions: currentGenerationSettings.providerOptions,
+        headers: currentGenerationSettings.headers
+      }));
       const { toolCalls, finish, step, providerExecutedToolResults } = await doStreamStep(
         conversationPrompt,
         currentModel,
@@ -422,11 +558,22 @@ async function* streamTextIterator({
           ...currentGenerationSettings,
           toolChoice: currentToolChoice,
           includeRawChunks,
-          experimental_telemetry,
           repairToolCall,
-          responseFormat
+          responseFormat,
+          runtimeContext: currentRuntimeContext,
+          toolsContext: currentToolsContext,
+          stepNumber
         }
       );
+      await ((_i = telemetryDispatcher.onLanguageModelCallEnd) == null ? void 0 : _i.call(telemetryDispatcher, {
+        callId: step.callId,
+        provider: (_f = (_e = step.model) == null ? void 0 : _e.provider) != null ? _f : "unknown",
+        modelId: (_h = (_g = step.model) == null ? void 0 : _g.modelId) != null ? _h : "unknown",
+        finishReason: step.finishReason,
+        usage: step.usage,
+        content: step.content,
+        responseId: step.response.id
+      }));
       _isFirstIteration = false;
       stepNumber++;
       steps.push(step);
@@ -454,7 +601,8 @@ async function* streamTextIterator({
           toolCalls,
           messages: conversationPrompt,
           step,
-          context: currentContext,
+          runtimeContext: currentRuntimeContext,
+          toolsContext: currentToolsContext,
           providerExecutedToolResults
         };
         conversationPrompt.push({
@@ -495,9 +643,11 @@ async function* streamTextIterator({
           `Unexpected finish reason: ${typeof (finish == null ? void 0 : finish.finishReason) === "object" ? JSON.stringify(finish == null ? void 0 : finish.finishReason) : finish == null ? void 0 : finish.finishReason}`
         );
       }
-      if (onStepFinish) {
-        await onStepFinish(step);
+      const resolvedOnStepEnd = onStepEnd != null ? onStepEnd : onStepFinish;
+      if (resolvedOnStepEnd) {
+        await resolvedOnStepEnd(step);
       }
+      await ((_j = telemetryDispatcher.onStepEnd) == null ? void 0 : _j.call(telemetryDispatcher, normalizeStepForTelemetry(step)));
     } catch (error) {
       if (onError) {
         await onError({ error });
@@ -510,19 +660,22 @@ async function* streamTextIterator({
       toolCalls: [],
       messages: conversationPrompt,
       step: lastStep,
-      context: currentContext
+      runtimeContext: currentRuntimeContext,
+      toolsContext: currentToolsContext
     };
   }
   return conversationPrompt;
 }
-function filterToolSet(tools, activeTools) {
-  const filtered = {};
-  for (const toolName of activeTools) {
-    if (toolName in tools) {
-      filtered[toolName] = tools[toolName];
-    }
-  }
-  return filtered;
+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 sanitizeProviderMetadataForToolCall(metadata) {
   if (metadata == null) return void 0;
@@ -548,26 +701,28 @@ function sanitizeProviderMetadataForToolCall(metadata) {
 // src/workflow-agent.ts
 var WorkflowAgent = class {
   constructor(options) {
-    var _a, _b;
+    var _a, _b, _c;
     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.experimental_telemetry;
-    this.experimentalContext = options.experimental_context;
+    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.experimentalRepairToolCall = options.experimental_repairToolCall;
     this.experimentalDownload = options.experimental_download;
     this.prepareStep = options.prepareStep;
-    this.constructorOnStepFinish = options.onStepFinish;
-    this.constructorOnFinish = options.onFinish;
+    this.constructorOnStepEnd = (_c = options.onStepEnd) != null ? _c : options.onStepFinish;
+    const { onFinish, onEnd = onFinish } = options;
+    this.constructorOnEnd = onEnd;
     this.constructorOnStart = options.experimental_onStart;
     this.constructorOnStepStart = options.experimental_onStepStart;
-    this.constructorOnToolCallStart = options.experimental_onToolCallStart;
-    this.constructorOnToolCallFinish = options.experimental_onToolCallFinish;
+    this.constructorOnToolExecutionStart = options.onToolExecutionStart;
+    this.constructorOnToolExecutionEnd = options.onToolExecutionEnd;
     this.prepareCall = options.prepareCall;
     this.generationSettings = {
       maxOutputTokens: options.maxOutputTokens,
@@ -588,24 +743,27 @@ var WorkflowAgent = class {
     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;
+    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;
+    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 effectiveExperimentalContext = (_b = options.experimental_context) != null ? _b : this.experimentalContext;
-    let effectiveToolChoiceFromPrepare = (_c = options.toolChoice) != null ? _c : this.toolChoice;
-    let effectiveTelemetryFromPrepare = (_d = options.experimental_telemetry) != null ? _d : this.telemetry;
-    const resolvedMessagesForPrepareCall = (_e = effectiveMessages != null ? effectiveMessages : typeof effectivePrompt === "string" ? [{ role: "user", content: effectivePrompt }] : effectivePrompt) != null ? _e : [];
+    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,
-        experimental_telemetry: effectiveTelemetryFromPrepare,
-        experimental_context: effectiveExperimentalContext,
+        telemetry: effectiveTelemetryFromPrepare,
+        runtimeContext: effectiveRuntimeContext,
+        toolsContext: effectiveToolsContext,
         messages: resolvedMessagesForPrepareCall,
         ...effectiveGenerationSettings
       });
@@ -616,12 +774,14 @@ var WorkflowAgent = class {
         effectiveMessages = prepared.messages;
         effectivePrompt = void 0;
       }
-      if (prepared.experimental_context !== void 0)
-        effectiveExperimentalContext = prepared.experimental_context;
+      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.experimental_telemetry !== void 0)
-        effectiveTelemetryFromPrepare = prepared.experimental_telemetry;
+      if (prepared.telemetry !== void 0)
+        effectiveTelemetryFromPrepare = prepared.telemetry;
       if (prepared.maxOutputTokens !== void 0)
         effectiveGenerationSettings.maxOutputTokens = prepared.maxOutputTokens;
       if (prepared.temperature !== void 0)
@@ -643,39 +803,196 @@ var WorkflowAgent = class {
       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: true,
+      // TODO: consider exposing this as a parameter
       ...effectivePrompt != null ? { prompt: effectivePrompt } : { messages: effectiveMessages }
     });
-    const { approvedToolApprovals, deniedToolApprovals } = collectToolApprovalsFromMessages(prompt.messages);
+    const download = (_i = options.experimental_download) != null ? _i : this.experimentalDownload;
+    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,
+        collected
+      })
+    );
+    const deniedToolApprovals = collectedApprovals.deniedToolApprovals.map(
+      (collected) => ({
+        toolCallId: collected.toolCall.toolCallId,
+        toolName: collected.toolCall.toolName,
+        input: collected.toolCall.input,
+        reason: collected.approvalResponse.reason
+      })
+    );
     if (approvedToolApprovals.length > 0 || deniedToolApprovals.length > 0) {
       const _toolResultMessages = [];
       const toolResultContent = [];
+      const approvedRawResults = [];
       for (const approval of approvedToolApprovals) {
         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 = (_j = policyDenied[0].approvalResponse.reason) != null ? _j : "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 toolResult = await execute(approval.input, {
+            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 ((_k = telemetryDispatcher.onToolExecutionStart) == null ? void 0 : _k.call(telemetryDispatcher, {
+              toolCall: toolCallEvent,
+              stepNumber: 0,
+              messages: messages2,
+              toolContext: resolvedContext
+            }));
+            const startTime = Date.now();
+            const executeApprovedTool = () => execute(approval.input, {
               toolCallId: approval.toolCallId,
               messages: [],
-              context: effectiveExperimentalContext
+              context: resolvedContext
             });
+            const toolResult = telemetryDispatcher.executeTool != null ? await telemetryDispatcher.executeTool({
+              callId: "workflow-agent",
+              toolCallId: approval.toolCallId,
+              execute: executeApprovedTool
+            }) : await executeApprovedTool();
+            await ((_l = telemetryDispatcher.onToolExecutionEnd) == null ? void 0 : _l.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: typeof toolResult === "string" ? { type: "text", value: toolResult } : { type: "json", value: toolResult }
+              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 ((_m = telemetryDispatcher.onToolExecutionEnd) == null ? void 0 : _m.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: {
-                type: "text",
-                value: getErrorMessage(error)
-              }
+              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
             });
           }
         }
@@ -719,21 +1036,10 @@ var WorkflowAgent = class {
       }
       prompt.messages = cleanedMessages;
       if (options.writable && toolResultContent.length > 0) {
-        const approvedResults = toolResultContent.filter((r) => r.output.type !== "execution-denied").map((r) => {
-          var _a2;
-          return {
-            toolCallId: r.toolCallId,
-            toolName: r.toolName,
-            input: (_a2 = approvedToolApprovals.find(
-              (a) => a.toolCallId === r.toolCallId
-            )) == null ? void 0 : _a2.input,
-            output: "value" in r.output ? r.output.value : void 0
-          };
-        });
         const deniedResults = toolResultContent.filter((r) => r.output.type === "execution-denied").map((r) => ({ toolCallId: r.toolCallId }));
         await writeApprovalToolResults(
           options.writable,
-          approvedResults,
+          approvedRawResults,
           deniedResults
         );
       }
@@ -741,11 +1047,11 @@ var WorkflowAgent = class {
     const modelPrompt = await convertToLanguageModelPrompt({
       prompt,
       supportedUrls: {},
-      download: (_f = options.experimental_download) != null ? _f : this.experimentalDownload
+      download
     });
     const effectiveAbortSignal = mergeAbortSignals(
-      (_g = options.abortSignal) != null ? _g : effectiveGenerationSettings.abortSignal,
-      options.timeout != null ? AbortSignal.timeout(options.timeout) : void 0
+      (_n = options.abortSignal) != null ? _n : effectiveGenerationSettings.abortSignal,
+      options.timeout
     );
     const mergedGenerationSettings = {
       ...effectiveGenerationSettings,
@@ -778,13 +1084,13 @@ var WorkflowAgent = class {
         providerOptions: options.providerOptions
       }
     };
-    const mergedOnStepFinish = mergeCallbacks(
-      this.constructorOnStepFinish,
-      options.onStepFinish
+    const mergedOnStepEnd = mergeCallbacks(
+      this.constructorOnStepEnd,
+      (_o = options.onStepEnd) != null ? _o : options.onStepFinish
     );
-    const mergedOnFinish = mergeCallbacks(
-      this.constructorOnFinish,
-      options.onFinish
+    const mergedOnEnd = mergeCallbacks(
+      this.constructorOnEnd,
+      onEnd
     );
     const mergedOnStart = mergeCallbacks(
       this.constructorOnStart,
@@ -794,82 +1100,200 @@ var WorkflowAgent = class {
       this.constructorOnStepStart,
       options.experimental_onStepStart
     );
-    const mergedOnToolCallStart = mergeCallbacks(
-      this.constructorOnToolCallStart,
-      options.experimental_onToolCallStart
+    const mergedOnToolExecutionStart = mergeCallbacks(
+      this.constructorOnToolExecutionStart,
+      options.onToolExecutionStart
     );
-    const mergedOnToolCallFinish = mergeCallbacks(
-      this.constructorOnToolCallFinish,
-      options.experimental_onToolCallFinish
+    const mergedOnToolExecutionEnd = mergeCallbacks(
+      this.constructorOnToolExecutionEnd,
+      options.onToolExecutionEnd
     );
     const effectiveToolChoice = effectiveToolChoiceFromPrepare;
-    const effectiveTelemetry = effectiveTelemetryFromPrepare;
-    const effectiveActiveTools = (_h = options.activeTools) != null ? _h : this.activeTools;
-    const effectiveTools = effectiveActiveTools && effectiveActiveTools.length > 0 ? filterTools(this.tools, effectiveActiveTools) : this.tools;
-    let experimentalContext = effectiveExperimentalContext;
+    const effectiveActiveTools = (_p = options.activeTools) != null ? _p : this.activeTools;
+    const effectiveTools = effectiveActiveTools && effectiveActiveTools.length > 0 ? (_q = filterActiveTools2({
+      tools: this.tools,
+      activeTools: effectiveActiveTools
+    })) != null ? _q : 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
+        messages: prompt.messages,
+        runtimeContext,
+        toolsContext
       });
     }
-    const executeToolWithCallbacks = async (toolCall, tools, messages2, context, currentStepNumber = 0) => {
+    await ((_t = telemetryDispatcher.onStart) == null ? void 0 : _t.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: (_r = mergedGenerationSettings.maxRetries) != null ? _r : 2,
+      timeout: void 0,
+      headers: mergedGenerationSettings.headers,
+      providerOptions: mergedGenerationSettings.providerOptions,
+      output: (_s = options.output) != null ? _s : this.output,
+      runtimeContext,
+      toolsContext
+    }));
+    const executeToolWithCallbacks = async (toolCall, tools, messages2, perToolContexts, currentStepNumber = 0) => {
+      var _a2, _b2, _c2, _d2;
       const toolCallEvent = {
         type: "tool-call",
         toolCallId: toolCall.toolCallId,
         toolName: toolCall.toolName,
         input: toolCall.input
       };
-      if (mergedOnToolCallStart) {
-        await mergedOnToolCallStart({
+      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
+          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 {
-        result = await executeTool(toolCall, tools, messages2, context);
+        const execute = () => executeTool(toolCall, tools, messages2, resolvedContext, download);
+        result = telemetryDispatcher.executeTool != null ? await telemetryDispatcher.executeTool({
+          callId: "workflow-agent",
+          toolCallId: toolCall.toolCallId,
+          execute
+        }) : await execute();
       } catch (err) {
         const durationMs2 = Date.now() - startTime;
-        if (mergedOnToolCallFinish) {
-          await mergedOnToolCallFinish({
+        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 (mergedOnToolCallFinish) {
-        const isError = result.output && "type" in result.output && (result.output.type === "error-text" || result.output.type === "error-json");
-        if (isError) {
-          await mergedOnToolCallFinish({
+      if (mergedOnToolExecutionEnd) {
+        if (result.isError) {
+          await mergedOnToolExecutionEnd({
             toolCall: toolCallEvent,
             stepNumber: currentStepNumber,
             durationMs,
+            messages: modelMessages,
+            toolContext: resolvedContext,
             success: false,
-            error: "value" in result.output ? result.output.value : void 0
+            error: result.rawOutput
           });
         } else {
-          await mergedOnToolCallFinish({
+          await mergedOnToolExecutionEnd({
             toolCall: toolCallEvent,
             stepNumber: currentStepNumber,
             durationMs,
+            messages: modelMessages,
+            toolContext: resolvedContext,
             success: true,
-            output: result.output && "value" in result.output ? result.output.value : void 0
+            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;
     };
-    if ((_i = mergedGenerationSettings.abortSignal) == null ? void 0 : _i.aborted) {
+    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 ((_u = mergedGenerationSettings.abortSignal) == null ? void 0 : _u.aborted) {
       if (options.onAbort) {
         await options.onAbort({ steps });
       }
@@ -886,19 +1310,19 @@ var WorkflowAgent = class {
       tools: effectiveTools,
       writable: options.writable,
       prompt: modelPrompt,
-      stopConditions: (_j = options.stopWhen) != null ? _j : this.stopWhen,
-      maxSteps: options.maxSteps,
-      onStepFinish: mergedOnStepFinish,
+      stopConditions: (_v = options.stopWhen) != null ? _v : this.stopWhen,
+      onStepEnd: mergedOnStepEnd,
       onStepStart: mergedOnStepStart,
       onError: options.onError,
-      prepareStep: (_k = options.prepareStep) != null ? _k : this.prepareStep,
+      prepareStep: (_w = options.prepareStep) != null ? _w : this.prepareStep,
       generationSettings: mergedGenerationSettings,
       toolChoice: effectiveToolChoice,
-      experimental_context: experimentalContext,
-      experimental_telemetry: effectiveTelemetry,
-      includeRawChunks: (_l = options.includeRawChunks) != null ? _l : false,
-      repairToolCall: (_m = options.experimental_repairToolCall) != null ? _m : this.experimentalRepairToolCall,
-      responseFormat: await ((_o = (_n = options.output) != null ? _n : this.output) == null ? void 0 : _o.responseFormat)
+      runtimeContext,
+      toolsContext,
+      telemetry: effectiveTelemetry,
+      includeRawChunks: (_x = options.includeRawChunks) != null ? _x : false,
+      repairToolCall: (_y = options.experimental_repairToolCall) != null ? _y : this.experimentalRepairToolCall,
+      responseFormat: await ((_A = (_z = options.output) != null ? _z : this.output) == null ? void 0 : _A.responseFormat)
     });
     let finalMessages;
     let encounteredError;
@@ -906,7 +1330,7 @@ var WorkflowAgent = class {
     try {
       let result = await iterator.next();
       while (!result.done) {
-        if ((_p = mergedGenerationSettings.abortSignal) == null ? void 0 : _p.aborted) {
+        if ((_B = mergedGenerationSettings.abortSignal) == null ? void 0 : _B.aborted) {
           wasAborted = true;
           if (options.onAbort) {
             await options.onAbort({ steps });
@@ -917,21 +1341,29 @@ var WorkflowAgent = class {
           toolCalls,
           messages: iterMessages,
           step,
-          context,
+          runtimeContext: yieldedRuntimeContext,
+          toolsContext: yieldedToolsContext,
           providerExecutedToolResults
         } = result.value;
         const currentStepNumber = steps.length;
         if (step) {
           steps.push(step);
         }
-        if (context !== void 0) {
-          experimentalContext = context;
+        if (yieldedRuntimeContext !== void 0) {
+          runtimeContext = yieldedRuntimeContext;
+        }
+        if (yieldedToolsContext !== void 0) {
+          toolsContext = yieldedToolsContext;
         }
         if (toolCalls.length > 0) {
-          const nonProviderToolCalls = toolCalls.filter(
+          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 = toolCalls.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];
@@ -939,10 +1371,15 @@ var WorkflowAgent = class {
               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: experimentalContext
+                context: resolvedContext
               });
             })
           );
@@ -961,32 +1398,56 @@ var WorkflowAgent = class {
                   toolCall,
                   effectiveTools,
                   iterMessages,
-                  experimentalContext,
+                  toolsContext,
                   currentStepNumber
                 )
               )
             );
-            const providerResults = providerToolCalls.map(
-              (toolCall) => resolveProviderToolResult(
-                toolCall,
-                providerExecutedToolResults
+            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 resolvedResults = [...executableResults, ...providerResults];
+            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 = resolvedResults.map((r) => {
+            const allToolResults = executedResults.map((r) => {
               var _a2;
               return {
                 type: "tool-result",
-                toolCallId: r.toolCallId,
-                toolName: r.toolName,
-                input: (_a2 = toolCalls.find((tc) => tc.toolCallId === r.toolCallId)) == null ? void 0 : _a2.input,
-                output: "value" in r.output ? r.output.value : void 0
+                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) {
@@ -996,18 +1457,32 @@ var WorkflowAgent = class {
               });
             }
             const messages2 = iterMessages;
-            if (mergedOnFinish && !wasAborted) {
+            if (mergedOnEnd && !wasAborted) {
               const lastStep = steps[steps.length - 1];
-              await mergedOnFinish({
+              const totalUsage = aggregateUsage(steps);
+              await mergedOnEnd({
                 steps,
                 messages: messages2,
-                text: (_q = lastStep == null ? void 0 : lastStep.text) != null ? _q : "",
-                finishReason: (_r = lastStep == null ? void 0 : lastStep.finishReason) != null ? _r : "other",
-                totalUsage: aggregateUsage(steps),
-                experimental_context: experimentalContext,
+                text: (_C = lastStep == null ? void 0 : lastStep.text) != null ? _C : "",
+                finishReason: (_D = lastStep == null ? void 0 : lastStep.finishReason) != null ? _D : "other",
+                usage: totalUsage,
+                totalUsage,
+                runtimeContext,
+                toolsContext,
                 output: void 0
               });
             }
+            if (!wasAborted && steps.length > 0) {
+              const telemetrySteps = steps.map(normalizeStepForTelemetry2);
+              const lastStep = telemetrySteps[telemetrySteps.length - 1];
+              const totalUsage = aggregateUsage(steps);
+              await ((_E = telemetryDispatcher.onEnd) == null ? void 0 : _E.call(telemetryDispatcher, {
+                ...lastStep,
+                steps: telemetrySteps,
+                usage: totalUsage,
+                totalUsage
+              }));
+            }
             if (options.writable) {
               const approvalToolCalls = pausedToolCalls.filter((_, i) => {
                 const tcIndex = nonProviderToolCalls.indexOf(
@@ -1026,8 +1501,8 @@ var WorkflowAgent = class {
               }
             }
             if (options.writable) {
-              const sendFinish = (_s = options.sendFinish) != null ? _s : true;
-              const preventClose = (_t = options.preventClose) != null ? _t : false;
+              const sendFinish = (_F = options.sendFinish) != null ? _F : true;
+              const preventClose = (_G = options.preventClose) != null ? _G : false;
               if (sendFinish || !preventClose) {
                 await closeStream(options.writable, preventClose, sendFinish);
               }
@@ -1046,40 +1521,68 @@ var WorkflowAgent = class {
                 toolCall,
                 effectiveTools,
                 iterMessages,
-                experimentalContext,
+                toolsContext,
+                currentStepNumber
+              )
+            )
+          );
+          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 providerToolResults = providerToolCalls.map(
-            (toolCall) => resolveProviderToolResult(toolCall, providerExecutedToolResults)
+          const continuationInvalidToolResults = invalidToolCalls.map(
+            createInvalidToolResult
           );
-          const toolResults = toolCalls.map((tc) => {
+          const executedToolResults = toolCalls.flatMap((tc) => {
             const clientResult = clientToolResults.find(
-              (r) => r.toolCallId === tc.toolCallId
+              (r) => r.modelResult.toolCallId === tc.toolCallId
             );
-            if (clientResult) return clientResult;
+            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 (providerResult) return providerResult;
-            return {
-              type: "tool-result",
-              toolCallId: tc.toolCallId,
-              toolName: tc.toolName,
-              output: { type: "text", value: "" }
-            };
+            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,
-              toolResults.map((r) => {
+              executedToolResults.map((r) => {
                 var _a2;
                 return {
-                  toolCallId: r.toolCallId,
-                  toolName: r.toolName,
-                  input: (_a2 = toolCalls.find((tc) => tc.toolCallId === r.toolCallId)) == null ? void 0 : _a2.input,
-                  output: "value" in r.output ? r.output.value : void 0
+                  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
                 };
               })
             );
@@ -1090,17 +1593,19 @@ var WorkflowAgent = class {
             toolName: tc.toolName,
             input: tc.input
           }));
-          lastStepToolResults = toolResults.map((r) => {
+          lastStepToolResults = executedToolResults.map((r) => {
             var _a2;
             return {
               type: "tool-result",
-              toolCallId: r.toolCallId,
-              toolName: r.toolName,
-              input: (_a2 = toolCalls.find((tc) => tc.toolCallId === r.toolCallId)) == null ? void 0 : _a2.input,
-              output: "value" in r.output ? r.output.value : void 0
+              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(toolResults);
+          result = await iterator.next(continuationToolResults);
         } else {
           lastStepToolCalls = [];
           lastStepToolResults = [];
@@ -1120,9 +1625,10 @@ var WorkflowAgent = class {
       } else if (options.onError) {
         await options.onError({ error });
       }
+      await ((_H = telemetryDispatcher.onError) == null ? void 0 : _H.call(telemetryDispatcher, error));
     }
     const messages = finalMessages != null ? finalMessages : prompt.messages;
-    const effectiveOutput = (_u = options.output) != null ? _u : this.output;
+    const effectiveOutput = (_I = options.output) != null ? _I : this.output;
     let experimentalOutput = void 0;
     if (effectiveOutput && steps.length > 0) {
       const lastStep = steps[steps.length - 1];
@@ -1144,22 +1650,36 @@ var WorkflowAgent = class {
         }
       }
     }
-    if (mergedOnFinish && !wasAborted) {
+    if (mergedOnEnd && !wasAborted) {
       const lastStep = steps[steps.length - 1];
-      await mergedOnFinish({
+      const totalUsage = aggregateUsage(steps);
+      await mergedOnEnd({
         steps,
         messages,
-        text: (_v = lastStep == null ? void 0 : lastStep.text) != null ? _v : "",
-        finishReason: (_w = lastStep == null ? void 0 : lastStep.finishReason) != null ? _w : "other",
-        totalUsage: aggregateUsage(steps),
-        experimental_context: experimentalContext,
+        text: (_J = lastStep == null ? void 0 : lastStep.text) != null ? _J : "",
+        finishReason: (_K = lastStep == null ? void 0 : lastStep.finishReason) != null ? _K : "other",
+        usage: totalUsage,
+        totalUsage,
+        runtimeContext,
+        toolsContext,
         output: experimentalOutput
       });
     }
+    if (!wasAborted && steps.length > 0) {
+      const telemetrySteps = steps.map(normalizeStepForTelemetry2);
+      const lastStep = telemetrySteps[telemetrySteps.length - 1];
+      const totalUsage = aggregateUsage(steps);
+      await ((_L = telemetryDispatcher.onEnd) == null ? void 0 : _L.call(telemetryDispatcher, {
+        ...lastStep,
+        steps: telemetrySteps,
+        usage: totalUsage,
+        totalUsage
+      }));
+    }
     if (encounteredError) {
       if (options.writable) {
-        const sendFinish = (_x = options.sendFinish) != null ? _x : true;
-        const preventClose = (_y = options.preventClose) != null ? _y : false;
+        const sendFinish = (_M = options.sendFinish) != null ? _M : true;
+        const preventClose = (_N = options.preventClose) != null ? _N : false;
         if (sendFinish || !preventClose) {
           await closeStream(options.writable, preventClose, sendFinish);
         }
@@ -1167,8 +1687,8 @@ var WorkflowAgent = class {
       throw encounteredError;
     }
     if (options.writable) {
-      const sendFinish = (_z = options.sendFinish) != null ? _z : true;
-      const preventClose = (_A = options.preventClose) != null ? _A : false;
+      const sendFinish = (_O = options.sendFinish) != null ? _O : true;
+      const preventClose = (_P = options.preventClose) != null ? _P : false;
       if (sendFinish || !preventClose) {
         await closeStream(options.writable, preventClose, sendFinish);
       }
@@ -1182,6 +1702,17 @@ var WorkflowAgent = class {
     };
   }
 };
+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) {
@@ -1255,6 +1786,22 @@ async function writeApprovalToolResults(writable, approvedResults, deniedResults
     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;
@@ -1269,59 +1816,65 @@ function aggregateUsage(steps) {
     totalTokens: inputTokens + outputTokens
   };
 }
-function filterTools(tools, activeTools) {
-  const filtered = {};
-  for (const toolName of activeTools) {
-    if (toolName in tools) {
-      filtered[toolName] = tools[toolName];
-    }
-  }
-  return filtered;
-}
-function getErrorMessage(error) {
-  if (error == null) {
-    return "unknown error";
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return JSON.stringify(error);
-}
-function resolveProviderToolResult(toolCall, providerExecutedToolResults) {
+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 {
-      type: "tool-result",
-      toolCallId: toolCall.toolCallId,
-      toolName: toolCall.toolName,
-      output: {
-        type: "text",
-        value: ""
-      }
+      modelResult: {
+        type: "tool-result",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: {
+          type: "text",
+          value: ""
+        }
+      },
+      rawOutput: "",
+      isError: false
     };
   }
   const result = streamResult.result;
-  const isString = typeof result === "string";
+  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: isString ? streamResult.isError ? { type: "error-text", value: result } : { type: "text", value: result } : streamResult.isError ? {
-      type: "error-json",
-      value: result
-    } : {
-      type: "json",
-      value: result
+    output: {
+      type: "error-text",
+      value: getErrorMessage(toolCall.error)
     }
   };
 }
-async function executeTool(toolCall, tools, messages, experimentalContext) {
+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) {
   const tool2 = tools[toolCall.toolName];
   if (!tool2) throw new Error(`Tool "${toolCall.toolName}" not found`);
   if (typeof tool2.execute !== "function") {
@@ -1330,97 +1883,57 @@ async function executeTool(toolCall, tools, messages, experimentalContext) {
     );
   }
   const parsedInput = toolCall.input;
+  let toolResult;
   try {
     const { execute } = tool2;
-    const toolResult = await execute(parsedInput, {
+    toolResult = await execute(parsedInput, {
       toolCallId: toolCall.toolCallId,
       // Pass the conversation messages to the tool so it has context about the conversation
       messages,
-      // Pass context to the tool
-      context: experimentalContext
+      // Pass per-tool context to the tool (resolved from `toolsContext`)
+      context
     });
-    const output = typeof toolResult === "string" ? { type: "text", value: toolResult } : { type: "json", value: toolResult };
-    return {
-      type: "tool-result",
-      toolCallId: toolCall.toolCallId,
-      toolName: toolCall.toolName,
-      output
-    };
   } catch (error) {
+    const errorMessage = getErrorMessage(error);
     return {
-      type: "tool-result",
-      toolCallId: toolCall.toolCallId,
-      toolName: toolCall.toolName,
-      output: {
-        type: "error-text",
-        value: getErrorMessage(error)
-      }
+      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
     };
   }
-}
-function collectToolApprovalsFromMessages(messages) {
-  var _a;
-  const lastMessage = messages.at(-1);
-  if ((lastMessage == null ? void 0 : lastMessage.role) !== "tool") {
-    return { approvedToolApprovals: [], deniedToolApprovals: [] };
-  }
-  const toolCallsByToolCallId = {};
-  for (const message of messages) {
-    if (message.role === "assistant" && Array.isArray(message.content)) {
-      for (const part of message.content) {
-        if (part.type === "tool-call") {
-          toolCallsByToolCallId[part.toolCallId] = {
-            toolName: part.toolName,
-            input: (_a = part.input) != null ? _a : part.args
-          };
-        }
-      }
-    }
-  }
-  const approvalRequestsByApprovalId = {};
-  for (const message of messages) {
-    if (message.role === "assistant" && Array.isArray(message.content)) {
-      for (const part of message.content) {
-        if (part.type === "tool-approval-request") {
-          approvalRequestsByApprovalId[part.approvalId] = {
-            approvalId: part.approvalId,
-            toolCallId: part.toolCallId
-          };
-        }
-      }
-    }
-  }
-  const existingToolResults = /* @__PURE__ */ new Set();
-  for (const part of lastMessage.content) {
-    if (part.type === "tool-result") {
-      existingToolResults.add(part.toolCallId);
-    }
-  }
-  const approvedToolApprovals = [];
-  const deniedToolApprovals = [];
-  const approvalResponses = lastMessage.content.filter(
-    (part) => part.type === "tool-approval-response"
-  );
-  for (const response of approvalResponses) {
-    const approvalRequest = approvalRequestsByApprovalId[response.approvalId];
-    if (approvalRequest == null) continue;
-    if (existingToolResults.has(approvalRequest.toolCallId)) continue;
-    const toolCall = toolCallsByToolCallId[approvalRequest.toolCallId];
-    if (toolCall == null) continue;
-    const approval = {
-      toolCallId: approvalRequest.toolCallId,
+  return {
+    modelResult: {
+      type: "tool-result",
+      toolCallId: toolCall.toolCallId,
       toolName: toolCall.toolName,
-      input: toolCall.input,
-      approvalId: response.approvalId,
-      reason: response.reason
-    };
-    if (response.approved) {
-      approvedToolApprovals.push(approval);
-    } else {
-      deniedToolApprovals.push(approval);
-    }
-  }
-  return { approvedToolApprovals, deniedToolApprovals };
+      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
@@ -1555,16 +2068,16 @@ function toUIMessageChunk(part) {
     case "raw":
       return void 0;
     default: {
-      const p = part;
-      if (p.type === "tool-approval-request") {
+      const passthroughPart = part;
+      if (passthroughPart.type === "tool-approval-request") {
         return {
           type: "tool-approval-request",
-          approvalId: p.approvalId,
-          toolCallId: p.toolCallId
+          approvalId: passthroughPart.approvalId,
+          toolCallId: passthroughPart.toolCallId
         };
       }
-      if (p.type === "finish-step" || p.type === "start-step" || p.type === "tool-output-denied") {
-        return p;
+      if (passthroughPart.type === "finish-step" || passthroughPart.type === "start-step" || passthroughPart.type === "tool-output-denied") {
+        return passthroughPart;
       }
       return void 0;
     }
@@ -1663,7 +2176,7 @@ var WorkflowChatTransport = class {
       messageId
     }) : void 0;
     const url = (_a = requestConfig == null ? void 0 : requestConfig.api) != null ? _a : this.api;
-    const res = await this.fetch(url, {
+    const response = await this.fetch(url, {
       method: "POST",
       body: JSON.stringify(
         (_b = requestConfig == null ? void 0 : requestConfig.body) != null ? _b : { messages, ...options.body }
@@ -1672,21 +2185,21 @@ var WorkflowChatTransport = class {
       credentials: requestConfig == null ? void 0 : requestConfig.credentials,
       signal: abortSignal
     });
-    if (!res.ok || !res.body) {
+    if (!response.ok || !response.body) {
       throw new Error(
-        `Failed to fetch chat: ${res.status} ${await res.text()}`
+        `Failed to fetch chat: ${response.status} ${await response.text()}`
       );
     }
-    const workflowRunId = res.headers.get("x-workflow-run-id");
+    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, res, options));
+    await ((_c = this.onChatSendMessage) == null ? void 0 : _c.call(this, response, options));
     try {
       const chunkStream = parseJsonEventStream({
-        stream: res.body,
+        stream: response.body,
         schema: uiMessageChunkSchema
       });
       for await (const chunk of createAsyncIterableStream(chunkStream)) {
@@ -1721,8 +2234,8 @@ var WorkflowChatTransport = class {
    * @throws Error if the reconnection request fails or returns a non-OK status
    */
   async reconnectToStream(options) {
-    const it = this.reconnectToStreamIterator(options);
-    return convertAsyncIteratorToReadableStream(it);
+    const reconnectIterator = this.reconnectToStreamIterator(options);
+    return convertAsyncIteratorToReadableStream(reconnectIterator);
   }
   async *reconnectToStreamIterator(options, workflowRunId, initialChunkIndex = 0) {
     var _a, _b;
@@ -1745,20 +2258,22 @@ var WorkflowChatTransport = class {
     while (!gotFinish) {
       const startIndex = useExplicitStartIndex ? explicitStartIndex : replayFromStart ? 0 : chunkIndex;
       const url = `${baseUrl}?startIndex=${startIndex}`;
-      const res = await this.fetch(url, {
+      const response = await this.fetch(url, {
         headers: requestConfig == null ? void 0 : requestConfig.headers,
         credentials: requestConfig == null ? void 0 : requestConfig.credentials,
         signal: options.abortSignal
       });
-      if (!res.ok || !res.body) {
+      if (!response.ok || !response.body) {
         throw new Error(
-          `Failed to fetch chat: ${res.status} ${await res.text()}`
+          `Failed to fetch chat: ${response.status} ${await response.text()}`
         );
       }
       if (useExplicitStartIndex && explicitStartIndex > 0) {
         chunkIndex = explicitStartIndex;
       } else if (useExplicitStartIndex && explicitStartIndex < 0) {
-        const tailIndexHeader = res.headers.get("x-workflow-stream-tail-index");
+        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);
@@ -1772,7 +2287,7 @@ var WorkflowChatTransport = class {
       useExplicitStartIndex = false;
       try {
         const chunkStream = parseJsonEventStream({
-          stream: res.body,
+          stream: response.body,
           schema: uiMessageChunkSchema
         });
         for await (const chunk of createAsyncIterableStream(chunkStream)) {