@ai-sdk/workflow 2.0.20 → 2.0.22

package/dist/index.js

@@ -4,7 +4,6 @@ import "./chunk-UAWBPTDW.js";
 import {
   getErrorMessage,
   isAbortError as isAbortError2,
-  validateTypes,
   withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
 import {
@@ -73,8 +72,28 @@ async function createLanguageModelToolResultOutput({
   });
 }
 
+// src/resolve-tool-context.ts
+import { validateTypes } from "@ai-sdk/provider-utils";
+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 }
+  });
+}
+
 // src/stream-text-iterator.ts
 import {
+  DefaultGeneratedFile,
   experimental_filterActiveTools as filterActiveTools
 } from "ai";
 import { createRestrictedTelemetryDispatcher } from "ai/internal";
@@ -92,7 +111,7 @@ import {
   asSchema,
   jsonSchema
 } from "@ai-sdk/provider-utils";
-import { tool } from "ai";
+import { dynamicTool, tool } from "ai";
 import Ajv from "ajv";
 function serializeToolSet(tools, {
   toolsContext = {},
@@ -102,6 +121,8 @@ function serializeToolSet(tools, {
     Object.entries(tools).map(([name, t]) => {
       var _a;
       const def = {
+        title: t.title,
+        metadata: t.metadata,
         description: resolveToolDescription({
           tool: t,
           toolName: name,
@@ -109,12 +130,26 @@ function serializeToolSet(tools, {
           experimental_sandbox: sandbox
         }),
         inputSchema: asSchema(t.inputSchema).jsonSchema,
+        strict: t.strict,
         inputExamples: t.inputExamples,
         providerOptions: t.providerOptions
       };
+      if (t.type === "dynamic") {
+        def.type = "dynamic";
+      }
+      if (t.onInputStart != null) {
+        def.hasOnInputStart = true;
+      }
+      if (t.onInputDelta != null) {
+        def.hasOnInputDelta = true;
+      }
+      if (t.onInputAvailable != null) {
+        def.hasOnInputAvailable = true;
+      }
       if (t.type === "provider") {
         def.type = "provider";
         def.isProviderExecuted = (_a = t.isProviderExecuted) != null ? _a : false;
+        def.supportsDeferredResults = t.supportsDeferredResults;
         def.id = t.id;
         def.args = t.args;
       }
@@ -137,39 +172,74 @@ function resolveSerializableTools(tools) {
   const ajv = new Ajv();
   return Object.fromEntries(
     Object.entries(tools).map(([name, t]) => {
-      var _a, _b;
+      var _a;
       if (t.type === "provider") {
+        const providerTool = {
+          type: "provider",
+          title: t.title,
+          metadata: t.metadata,
+          id: t.id,
+          args: (_a = t.args) != null ? _a : {},
+          inputSchema: jsonSchema(t.inputSchema),
+          providerOptions: t.providerOptions
+        };
         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),
-            providerOptions: t.providerOptions
+          t.isProviderExecuted ? tool({
+            ...providerTool,
+            isProviderExecuted: true,
+            supportsDeferredResults: t.supportsDeferredResults
+          }) : tool({
+            ...providerTool,
+            isProviderExecuted: false
           })
         ];
       }
-      const validateFn = ajv.compile(t.inputSchema);
-      return [
-        name,
-        tool({
-          description: t.description,
-          inputExamples: t.inputExamples,
-          providerOptions: t.providerOptions,
-          inputSchema: jsonSchema(t.inputSchema, {
-            validate: (value) => {
-              if (validateFn(value)) {
-                return { success: true, value };
+      if (t.type === "dynamic") {
+        const validateFn2 = ajv.compile(t.inputSchema);
+        return [
+          name,
+          dynamicTool({
+            description: t.description,
+            inputExamples: t.inputExamples,
+            providerOptions: t.providerOptions,
+            inputSchema: jsonSchema(t.inputSchema, {
+              validate: (value) => {
+                if (validateFn2(value)) {
+                  return { success: true, value };
+                }
+                return {
+                  success: false,
+                  error: new Error(ajv.errorsText(validateFn2.errors))
+                };
               }
-              return {
-                success: false,
-                error: new Error(ajv.errorsText(validateFn.errors))
-              };
-            }
+            })
           })
+        ];
+      }
+      const validateFn = ajv.compile(t.inputSchema);
+      const functionTool = {
+        title: t.title,
+        metadata: t.metadata,
+        description: t.description,
+        strict: t.strict,
+        inputExamples: t.inputExamples,
+        providerOptions: t.providerOptions,
+        inputSchema: jsonSchema(t.inputSchema, {
+          validate: (value) => {
+            if (validateFn(value)) {
+              return { success: true, value };
+            }
+            return {
+              success: false,
+              error: new Error(ajv.errorsText(validateFn.errors))
+            };
+          }
         })
+      };
+      return [
+        name,
+        t.type === "dynamic" ? tool({ ...functionTool, type: "dynamic" }) : tool(functionTool)
       ];
     })
   );
@@ -178,13 +248,14 @@ function resolveSerializableTools(tools) {
 // src/do-stream-step.ts
 async function doStreamStep(conversationPrompt, modelInit, writable, serializedTools, options) {
   "use step";
-  var _a;
+  var _a, _b, _c, _d, _e, _f;
   const timeout = (options == null ? void 0 : options.timeoutAt) == null ? void 0 : options.timeoutAt - Date.now();
   if (((_a = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a.aborted) || timeout != null && timeout <= 0) {
     return { aborted: true };
   }
   const abortSignal = timeout == null ? options == null ? void 0 : options.abortSignal : (options == null ? void 0 : options.abortSignal) == null ? AbortSignal.timeout(timeout) : AbortSignal.any([options.abortSignal, AbortSignal.timeout(timeout)]);
   const model = typeof modelInit === "string" ? gateway.languageModel(modelInit) : modelInit;
+  const toolInputLifecycleEvents = [];
   const tools = serializedTools ? resolveSerializableTools(serializedTools) : void 0;
   const output = (options == null ? void 0 : options.responseFormat) == null ? void 0 : {
     name: "workflow",
@@ -248,25 +319,85 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
   const toolCalls = [];
   const providerExecutedToolResults = /* @__PURE__ */ new Map();
   let finish;
-  let text = "";
+  const content = [];
+  const textPartIndexes = /* @__PURE__ */ new Map();
   const reasoningParts = [];
   let responseMetadata;
   let warnings;
   let terminalError;
   let hasTerminalError = false;
+  const ongoingToolCallToolNames = /* @__PURE__ */ new Map();
   const writer = writable == null ? void 0 : writable.getWriter();
   try {
     await (writer == null ? void 0 : writer.write({ type: "reset-step" }));
     for await (const part of modelStream) {
       switch (part.type) {
+        case "tool-input-start":
+          ongoingToolCallToolNames.set(part.id, part.toolName);
+          if (((_b = serializedTools == null ? void 0 : serializedTools[part.toolName]) == null ? void 0 : _b.hasOnInputStart) || ((_c = serializedTools == null ? void 0 : serializedTools[part.toolName]) == null ? void 0 : _c.hasOnInputDelta) || ((_d = serializedTools == null ? void 0 : serializedTools[part.toolName]) == null ? void 0 : _d.hasOnInputAvailable)) {
+            toolInputLifecycleEvents.push(["start", part.id, part.toolName]);
+          }
+          break;
+        case "tool-input-delta": {
+          const toolName = ongoingToolCallToolNames.get(part.id);
+          if (toolName != null && ((_e = serializedTools == null ? void 0 : serializedTools[toolName]) == null ? void 0 : _e.hasOnInputDelta)) {
+            toolInputLifecycleEvents.push(["delta", part.id, part.delta]);
+          }
+          break;
+        }
+        case "text-start":
+          upsertTextContentPart({
+            content,
+            textPartIndexes,
+            id: part.id,
+            providerMetadata: part.providerMetadata
+          });
+          break;
         case "text-delta":
-          text += part.text;
+          upsertTextContentPart({
+            content,
+            textPartIndexes,
+            id: part.id,
+            textDelta: part.text,
+            providerMetadata: part.providerMetadata
+          });
+          break;
+        case "text-end":
+          upsertTextContentPart({
+            content,
+            textPartIndexes,
+            id: part.id,
+            providerMetadata: part.providerMetadata
+          });
+          textPartIndexes.delete(part.id);
           break;
         case "reasoning-delta":
           reasoningParts.push({ text: part.text });
           break;
+        case "file":
+          content.push({
+            type: "file",
+            data: part.file.base64,
+            mediaType: part.file.mediaType,
+            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+          });
+          break;
+        case "source":
+          content.push(part);
+          break;
         case "tool-call": {
           const toolCallPart = part;
+          const toolCallIndex = toolCalls.length;
+          const lifecycleToolName = ongoingToolCallToolNames.get(
+            toolCallPart.toolCallId
+          );
+          ongoingToolCallToolNames.delete(toolCallPart.toolCallId);
+          if (lifecycleToolName != null && ((_f = serializedTools == null ? void 0 : serializedTools[lifecycleToolName]) == null ? void 0 : _f.hasOnInputAvailable)) {
+            toolInputLifecycleEvents.push([
+              "available",
+              toolCallPart.toolCallId
+            ]);
+          }
           toolCalls.push({
             type: "tool-call",
             toolCallId: toolCallPart.toolCallId,
@@ -274,10 +405,13 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
             input: toolCallPart.input,
             providerExecuted: toolCallPart.providerExecuted,
             providerMetadata: toolCallPart.providerMetadata,
+            title: toolCallPart.title,
+            toolMetadata: toolCallPart.toolMetadata,
             dynamic: toolCallPart.dynamic,
             invalid: toolCallPart.invalid,
             error: toolCallPart.error
           });
+          content.push({ type: "tool-call", toolCallIndex });
           break;
         }
         case "tool-result":
@@ -349,16 +483,44 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
     toolCalls,
     finish,
     raw: {
-      text,
+      content,
       reasoning: reasoningParts,
       responseMetadata,
       warnings
     },
     providerExecutedToolResults,
+    toolInputLifecycleEvents,
     ...hasTerminalError ? { terminalError } : {}
   };
 }
 doStreamStep.maxRetries = 0;
+function upsertTextContentPart({
+  content,
+  textPartIndexes,
+  id,
+  textDelta,
+  providerMetadata
+}) {
+  let partIndex = textPartIndexes.get(id);
+  if (partIndex == null) {
+    partIndex = content.push({
+      type: "text",
+      text: "",
+      ...providerMetadata != null ? { providerMetadata } : {}
+    }) - 1;
+    textPartIndexes.set(id, partIndex);
+  }
+  const part = content[partIndex];
+  if (part.type !== "text") {
+    throw new Error(`Expected text content at index ${partIndex}.`);
+  }
+  if (textDelta != null) {
+    part.text += textDelta;
+  }
+  if (providerMetadata != null) {
+    part.providerMetadata = providerMetadata;
+  }
+}
 
 // src/stream-text-iterator.ts
 var prepareStepGenerationSettingKeys = [
@@ -540,6 +702,7 @@ async function* streamTextIterator({
         providerOptions: currentGenerationSettings.providerOptions,
         headers: currentGenerationSettings.headers
       }));
+      const stepInputMessages = conversationPrompt;
       const streamStepResult = await doStreamStep(
         conversationPrompt,
         currentModel,
@@ -562,7 +725,22 @@ async function* streamTextIterator({
         terminalError = streamStepResult.terminalError;
         hasTerminalError = true;
       }
-      const { toolCalls, finish, raw, providerExecutedToolResults } = streamStepResult;
+      const {
+        toolCalls,
+        finish,
+        raw,
+        providerExecutedToolResults,
+        toolInputLifecycleEvents
+      } = streamStepResult;
+      await invokeToolInputLifecycleCallbacks({
+        events: toolInputLifecycleEvents != null ? toolInputLifecycleEvents : [],
+        toolCalls,
+        tools: effectiveTools,
+        messages: stepInputMessages,
+        abortSignal: currentGenerationSettings.abortSignal,
+        toolsContext: currentToolsContext,
+        experimental_sandbox: stepSandbox
+      });
       const step = buildStepResult(raw, toolCalls, finish, {
         stepNumber,
         runtimeContext: currentRuntimeContext,
@@ -588,27 +766,17 @@ async function* streamTextIterator({
         done = true;
       } else if (finishReason === "tool-calls") {
         lastStepWasToolCalls = true;
-        const textContent = step.content.filter(
-          (item) => item.type === "text"
+        const assistantContent = getAssistantMessageContent(step);
+        const includedToolCallIds = new Set(
+          assistantContent.flatMap(
+            (part) => part.type === "tool-call" ? [part.toolCallId] : []
+          )
         );
         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
-                } : {}
-              };
-            })
+            ...assistantContent,
+            ...toolCalls.filter((toolCall) => !includedToolCallIds.has(toolCall.toolCallId)).map(toAssistantToolCallContent)
           ]
         });
         const toolResults = yield {
@@ -631,13 +799,11 @@ async function* streamTextIterator({
           }
         }
       } else if (finishReason === "stop") {
-        const textContent = step.content.filter(
-          (item) => item.type === "text"
-        );
-        if (textContent.length > 0) {
+        const assistantContent = getAssistantMessageContent(step);
+        if (assistantContent.length > 0) {
           conversationPrompt.push({
             role: "assistant",
-            content: textContent
+            content: assistantContent
           });
         }
         done = true;
@@ -688,6 +854,74 @@ async function* streamTextIterator({
   }
   return conversationPrompt;
 }
+async function invokeToolInputLifecycleCallbacks({
+  events,
+  toolCalls,
+  tools,
+  messages,
+  abortSignal,
+  toolsContext,
+  experimental_sandbox
+}) {
+  var _a, _b, _c;
+  const toolNamesByCallId = /* @__PURE__ */ new Map();
+  const toolCallsById = new Map(
+    toolCalls.map((toolCall) => [toolCall.toolCallId, toolCall])
+  );
+  const resolvedContexts = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const [type, toolCallId, value] = event;
+    if (type === "start") {
+      toolNamesByCallId.set(toolCallId, value);
+    }
+    const toolName = type === "start" ? value : toolNamesByCallId.get(toolCallId);
+    if (toolName == null) {
+      continue;
+    }
+    const tool2 = tools[toolName];
+    if (tool2 == null) {
+      continue;
+    }
+    let resolvedContext = resolvedContexts.get(toolName);
+    if (resolvedContext == null) {
+      resolvedContext = resolveToolContext({
+        toolName,
+        tool: tool2,
+        toolsContext
+      });
+      resolvedContexts.set(toolName, resolvedContext);
+    }
+    const options = {
+      toolCallId,
+      messages,
+      abortSignal,
+      context: await resolvedContext,
+      experimental_sandbox
+    };
+    switch (type) {
+      case "start":
+        await ((_a = tool2.onInputStart) == null ? void 0 : _a.call(tool2, options));
+        break;
+      case "delta":
+        await ((_b = tool2.onInputDelta) == null ? void 0 : _b.call(tool2, {
+          ...options,
+          inputTextDelta: value
+        }));
+        break;
+      case "available": {
+        const toolCall = toolCallsById.get(toolCallId);
+        if (toolCall == null) {
+          break;
+        }
+        await ((_c = tool2.onInputAvailable) == null ? void 0 : _c.call(tool2, {
+          ...options,
+          input: toolCall.input
+        }));
+        break;
+      }
+    }
+  }
+}
 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 };
@@ -701,15 +935,76 @@ function normalizeStepForTelemetry(step) {
 }
 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 {
+    content: rawContent,
+    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 } : {}
-  }));
+  const validToolCallsByIndex = new Map(
+    toolCalls.flatMap(
+      (tc, index) => tc.invalid ? [] : [
+        [
+          index,
+          {
+            type: "tool-call",
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            input: tc.input,
+            ...tc.providerExecuted != null ? { providerExecuted: tc.providerExecuted } : {},
+            ...tc.title != null ? { title: tc.title } : {},
+            ...tc.toolMetadata != null ? { toolMetadata: tc.toolMetadata } : {},
+            ...tc.dynamic ? { dynamic: true } : {},
+            ...tc.providerExecuted ? { providerExecuted: true } : {},
+            ...tc.providerMetadata != null ? { providerMetadata: tc.providerMetadata } : {}
+          }
+        ]
+      ]
+    )
+  );
+  const validToolCalls = [...validToolCallsByIndex.values()];
+  const content = [];
+  const files = [];
+  const sources = [];
+  let text = "";
+  for (const part of rawContent) {
+    switch (part.type) {
+      case "text":
+        text += part.text;
+        content.push({
+          type: "text",
+          text: part.text,
+          ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+        });
+        break;
+      case "file": {
+        const file = new DefaultGeneratedFile({
+          data: part.data,
+          mediaType: part.mediaType,
+          providerMetadata: part.providerMetadata
+        });
+        files.push(file);
+        content.push({
+          type: "file",
+          file,
+          ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+        });
+        break;
+      }
+      case "source":
+        sources.push(part);
+        content.push(part);
+        break;
+      case "tool-call": {
+        const toolCall = validToolCallsByIndex.get(part.toolCallIndex);
+        if (toolCall != null) {
+          content.push(toolCall);
+        }
+        break;
+      }
+    }
+  }
   return {
     callId: "workflow-agent",
     stepNumber: opts.stepNumber,
@@ -721,20 +1016,17 @@ function buildStepResult(raw, toolCalls, finish, opts) {
     metadata: void 0,
     runtimeContext: (_d = opts.runtimeContext) != null ? _d : {},
     toolsContext: (_e = opts.toolsContext) != null ? _e : {},
-    content: [
-      ...text ? [{ type: "text", text }] : [],
-      ...validToolCalls
-    ],
+    content,
     text,
     reasoning: reasoningParts.map((r) => ({
       type: "reasoning",
       text: r.text
     })),
     reasoningText,
-    files: [],
-    sources: [],
+    files,
+    sources,
     toolCalls: validToolCalls,
-    staticToolCalls: [],
+    staticToolCalls: validToolCalls.filter((tc) => tc.dynamic !== true),
     dynamicToolCalls: validToolCalls.filter((tc) => tc.dynamic),
     toolResults: [],
     staticToolResults: [],
@@ -780,6 +1072,47 @@ function buildStepResult(raw, toolCalls, finish, opts) {
     providerMetadata: (_k = finish == null ? void 0 : finish.providerMetadata) != null ? _k : {}
   };
 }
+function getAssistantMessageContent(step) {
+  const content = [];
+  for (const part of step.content) {
+    switch (part.type) {
+      case "text":
+        if (part.text.length > 0) {
+          content.push({ type: "text", text: part.text });
+        }
+        break;
+      case "file":
+        content.push({
+          type: "file",
+          data: { type: "data", data: part.file.base64 },
+          mediaType: part.file.mediaType,
+          ...part.providerMetadata != null ? {
+            providerOptions: part.providerMetadata
+          } : {}
+        });
+        break;
+      case "tool-call":
+        content.push(toAssistantToolCallContent(part));
+        break;
+    }
+  }
+  return content;
+}
+function toAssistantToolCallContent(toolCall) {
+  const sanitizedMetadata = sanitizeProviderMetadataForToolCall(
+    toolCall.providerMetadata
+  );
+  return {
+    type: "tool-call",
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: toolCall.input,
+    ...toolCall.providerExecuted != null ? { providerExecuted: toolCall.providerExecuted } : {},
+    ...sanitizedMetadata != null ? {
+      providerOptions: sanitizedMetadata
+    } : {}
+  };
+}
 function sanitizeProviderMetadataForToolCall(metadata) {
   if (metadata == null) return void 0;
   const meta = metadata;
@@ -802,6 +1135,45 @@ function sanitizeProviderMetadataForToolCall(metadata) {
 }
 
 // src/workflow-agent.ts
+function addToolResultsToStep(step, executedResults) {
+  if (step == null || executedResults.length === 0) {
+    return;
+  }
+  const toolOutputs = executedResults.map((result) => {
+    const toolCall = step.toolCalls.find(
+      (toolCall2) => toolCall2.toolCallId === result.modelResult.toolCallId
+    );
+    const common = {
+      toolCallId: result.modelResult.toolCallId,
+      toolName: result.modelResult.toolName,
+      input: toolCall == null ? void 0 : toolCall.input,
+      ...(toolCall == null ? void 0 : toolCall.dynamic) === true ? { dynamic: true } : {},
+      ...(toolCall == null ? void 0 : toolCall.providerExecuted) === true ? { providerExecuted: true } : {}
+    };
+    return result.isError ? {
+      type: "tool-error",
+      ...common,
+      error: result.rawOutput
+    } : {
+      type: "tool-result",
+      ...common,
+      output: result.rawOutput
+    };
+  });
+  step.content.push(...toolOutputs);
+  const toolResults = toolOutputs.filter(
+    (result) => result.type === "tool-result"
+  );
+  step.toolResults.push(
+    ...toolResults
+  );
+  step.staticToolResults.push(
+    ...toolResults.filter((result) => result.dynamic !== true)
+  );
+  step.dynamicToolResults.push(
+    ...toolResults.filter((result) => result.dynamic === true)
+  );
+}
 var WorkflowAgent = class {
   constructor(options) {
     var _a, _b, _c, _d, _e, _f, _g;
@@ -1507,26 +1879,32 @@ var WorkflowAgent = class {
                 )
               )
             );
-            const providerResults = await Promise.all(
-              providerToolCalls.map(
-                (toolCall) => resolveProviderToolResult(
+            const providerResultEntries = await Promise.all(
+              providerToolCalls.map(async (toolCall) => ({
+                toolCall,
+                result: await resolveProviderToolResult(
                   toolCall,
                   providerExecutedToolResults,
                   effectiveTools,
                   download
                 )
-              )
+              }))
             );
             await Promise.all(
-              providerToolCalls.map(
-                (toolCall, index) => recordProviderExecutedToolTelemetry(
-                  toolCall,
-                  providerResults[index],
-                  iterMessages,
-                  currentStepNumber
-                )
+              providerResultEntries.flatMap(
+                ({ toolCall, result: result2 }) => result2 == null ? [] : [
+                  recordProviderExecutedToolTelemetry(
+                    toolCall,
+                    result2,
+                    iterMessages,
+                    currentStepNumber
+                  )
+                ]
               )
             );
+            const providerResults = providerResultEntries.flatMap(
+              ({ result: result2 }) => result2 == null ? [] : [result2]
+            );
             const continuationInvalidResults = invalidToolCalls.map(
               createInvalidToolResult
             );
@@ -1554,6 +1932,7 @@ var WorkflowAgent = class {
                 output: r.rawOutput
               };
             });
+            addToolResultsToStep(step, executedResults);
             if (resolvedResults.length > 0) {
               iterMessages.push({
                 role: "tool",
@@ -1661,26 +2040,32 @@ var WorkflowAgent = class {
               )
             )
           );
-          const providerToolResults = await Promise.all(
-            providerToolCalls.map(
-              (toolCall) => resolveProviderToolResult(
+          const providerToolResultEntries = await Promise.all(
+            providerToolCalls.map(async (toolCall) => ({
+              toolCall,
+              result: await resolveProviderToolResult(
                 toolCall,
                 providerExecutedToolResults,
                 effectiveTools,
                 download
               )
-            )
+            }))
           );
           await Promise.all(
-            providerToolCalls.map(
-              (toolCall, index) => recordProviderExecutedToolTelemetry(
-                toolCall,
-                providerToolResults[index],
-                iterMessages,
-                currentStepNumber
-              )
+            providerToolResultEntries.flatMap(
+              ({ toolCall, result: result2 }) => result2 == null ? [] : [
+                recordProviderExecutedToolTelemetry(
+                  toolCall,
+                  result2,
+                  iterMessages,
+                  currentStepNumber
+                )
+              ]
             )
           );
+          const providerToolResults = providerToolResultEntries.flatMap(
+            ({ result: result2 }) => result2 == null ? [] : [result2]
+          );
           const continuationInvalidToolResults = invalidToolCalls.map(
             createInvalidToolResult
           );
@@ -1742,6 +2127,7 @@ var WorkflowAgent = class {
               output: r.rawOutput
             };
           });
+          addToolResultsToStep(step, executedToolResults);
           result = await iterator.next(continuationToolResults);
         } else {
           lastStepToolCalls = [];
@@ -2036,22 +2422,6 @@ 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;
@@ -2069,6 +2439,10 @@ function aggregateUsage(steps) {
 async function resolveProviderToolResult(toolCall, providerExecutedToolResults, tools, download) {
   const streamResult = providerExecutedToolResults == null ? void 0 : providerExecutedToolResults.get(toolCall.toolCallId);
   if (!streamResult) {
+    const tool2 = tools == null ? void 0 : tools[toolCall.toolName];
+    if ((tool2 == null ? void 0 : tool2.type) === "provider" && tool2.isProviderExecuted && tool2.supportsDeferredResults) {
+      return void 0;
+    }
     console.warn(
       `[WorkflowAgent] Provider-executed tool "${toolCall.toolName}" (${toolCall.toolCallId}) did not receive a result from the stream. This may indicate a provider issue.`
     );