@ai-sdk/workflow 2.0.28 → 2.0.30

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @ai-sdk/workflow
 
+## 2.0.30
+
+### Patch Changes
+
+- Updated dependencies [615ac89]
+  - ai@7.0.99
+
+## 2.0.29
+
+### Patch Changes
+
+- 72d9e05: fix(workflow): preserve provider-executed tool results across terminal, deferred, and paused responses
+- Updated dependencies [5ec21a6]
+- Updated dependencies [db59d78]
+- Updated dependencies [7469a3b]
+- Updated dependencies [f87bf07]
+- Updated dependencies [bc5cb7a]
+- Updated dependencies [a5f449a]
+- Updated dependencies [813bb36]
+- Updated dependencies [c43e4b7]
+  - @ai-sdk/provider@4.0.14
+  - ai@7.0.98
+  - @ai-sdk/provider-utils@5.0.40
+
 ## 2.0.28
 
 ### Patch Changes

package/dist/index.js

@@ -23,6 +23,85 @@ import {
   verifyToolApprovalSignature
 } from "ai/internal";
 
+// src/add-tool-results-to-conversation.ts
+function addToolResultsToConversation({
+  messages,
+  toolResults,
+  providerExecutedToolCallIds,
+  providerExecutedToolResultPositions = []
+}) {
+  var _a;
+  const providerResultIds = /* @__PURE__ */ new Set([
+    ...providerExecutedToolCallIds,
+    ...providerExecutedToolResultPositions.map((position) => position.toolCallId)
+  ]);
+  const providerResults = /* @__PURE__ */ new Map();
+  const clientResults = [];
+  let assistantMessageIndex = -1;
+  let assistantMessage;
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (message.role === "assistant") {
+      assistantMessageIndex = index;
+      assistantMessage = message;
+      break;
+    }
+  }
+  for (const toolResult of toolResults) {
+    if (providerResultIds.has(toolResult.toolCallId)) {
+      const results = (_a = providerResults.get(toolResult.toolCallId)) != null ? _a : [];
+      results.push(toolResult);
+      providerResults.set(toolResult.toolCallId, results);
+    } else {
+      clientResults.push(toolResult);
+    }
+  }
+  if (providerResults.size > 0) {
+    if (assistantMessage != null) {
+      let content = [...assistantMessage.content];
+      for (const position of [...providerExecutedToolResultPositions].sort(
+        (a, b) => a.contentIndex - b.contentIndex
+      )) {
+        const results = providerResults.get(position.toolCallId);
+        if (results == null || results.length === 0) {
+          continue;
+        }
+        const [result, ...remainingResults] = results;
+        content.splice(position.contentIndex, 0, result);
+        if (remainingResults.length === 0) {
+          providerResults.delete(position.toolCallId);
+        } else {
+          providerResults.set(position.toolCallId, remainingResults);
+        }
+      }
+      const contentWithFallbackResults = [];
+      for (const part of content) {
+        contentWithFallbackResults.push(part);
+        if (part.type !== "tool-call") {
+          continue;
+        }
+        const results = providerResults.get(part.toolCallId);
+        if (results == null) {
+          continue;
+        }
+        providerResults.delete(part.toolCallId);
+        contentWithFallbackResults.push(...results);
+      }
+      for (const results of providerResults.values()) {
+        contentWithFallbackResults.push(...results);
+      }
+      assistantMessage.content = contentWithFallbackResults;
+    }
+  }
+  if (clientResults.length > 0) {
+    messages.push({
+      role: "tool",
+      content: clientResults
+    });
+  }
+  return assistantMessageIndex < 0 ? [] : messages.slice(assistantMessageIndex);
+}
+
 // src/create-language-model-tool-result-output.ts
 import {
   createDefaultDownloadFunction,
@@ -420,7 +499,13 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
               toolCallId: part.toolCallId,
               toolName: part.toolName,
               result: part.output,
-              isError: false
+              isError: false,
+              dynamic: part.dynamic,
+              providerMetadata: part.providerMetadata
+            });
+            content.push({
+              type: "provider-tool-result",
+              toolCallId: part.toolCallId
             });
           }
           break;
@@ -431,7 +516,13 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
               toolCallId: errorPart.toolCallId,
               toolName: errorPart.toolName,
               result: errorPart.error,
-              isError: true
+              isError: true,
+              dynamic: errorPart.dynamic,
+              providerMetadata: errorPart.providerMetadata
+            });
+            content.push({
+              type: "provider-tool-result",
+              toolCallId: errorPart.toolCallId
             });
           }
           break;
@@ -570,7 +661,7 @@ async function* streamTextIterator({
   responseFormat,
   experimental_sandbox: sandbox
 }) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
   let conversationPrompt = [...prompt];
   let currentModel = model;
   let currentGenerationSettings = generationSettings != null ? generationSettings : {};
@@ -583,7 +674,8 @@ async function* streamTextIterator({
   let _isFirstIteration = true;
   let stepNumber = 0;
   let lastStep;
-  let lastStepWasToolCalls = false;
+  let lastStepWasYielded = false;
+  const pendingDeferredToolCallIds = /* @__PURE__ */ new Set();
   let wasAborted = false;
   let terminalError;
   let hasTerminalError = false;
@@ -741,11 +833,17 @@ async function* streamTextIterator({
         toolsContext: currentToolsContext,
         experimental_sandbox: stepSandbox
       });
-      const step = buildStepResult(raw, toolCalls, finish, {
-        stepNumber,
-        runtimeContext: currentRuntimeContext,
-        toolsContext: currentToolsContext
-      });
+      const step = buildStepResult(
+        raw,
+        toolCalls,
+        finish,
+        providerExecutedToolResults,
+        {
+          stepNumber,
+          runtimeContext: currentRuntimeContext,
+          toolsContext: currentToolsContext
+        }
+      );
       await ((_j = telemetryDispatcher.onLanguageModelCallEnd) == null ? void 0 : _j.call(telemetryDispatcher, {
         callId: step.callId,
         provider: (_g = (_f = step.model) == null ? void 0 : _f.provider) != null ? _g : "unknown",
@@ -760,13 +858,26 @@ async function* streamTextIterator({
       stepNumber++;
       steps.push(step);
       lastStep = step;
-      lastStepWasToolCalls = false;
+      lastStepWasYielded = false;
       const finishReason = finish == null ? void 0 : finish.finishReason;
+      const isToolExecutionAllowed = finishReason === "tool-calls" || finishReason === "stop";
+      for (const toolCall of toolCalls) {
+        if (toolCall.providerExecuted && ((_k = serializedTools[toolCall.toolName]) == null ? void 0 : _k.supportsDeferredResults) && !providerExecutedToolResults.has(toolCall.toolCallId)) {
+          pendingDeferredToolCallIds.add(toolCall.toolCallId);
+        }
+      }
+      for (const toolCallId of providerExecutedToolResults.keys()) {
+        pendingDeferredToolCallIds.delete(toolCallId);
+      }
+      const shouldProcessTools = isToolExecutionAllowed && (toolCalls.length > 0 || providerExecutedToolResults.size > 0);
       if (hasTerminalError) {
         done = true;
-      } else if (finishReason === "tool-calls") {
-        lastStepWasToolCalls = true;
-        const assistantContent = getAssistantMessageContent(step);
+      } else if (shouldProcessTools) {
+        lastStepWasYielded = true;
+        const {
+          content: assistantContent,
+          providerExecutedToolResultPositions
+        } = getAssistantMessageContent(step);
         const includedToolCallIds = new Set(
           assistantContent.flatMap(
             (part) => part.type === "tool-call" ? [part.toolCallId] : []
@@ -786,25 +897,42 @@ async function* streamTextIterator({
           runtimeContext: currentRuntimeContext,
           toolsContext: currentToolsContext,
           experimental_sandbox: stepSandbox,
-          providerExecutedToolResults
+          providerExecutedToolResults,
+          providerExecutedToolResultPositions
         };
-        conversationPrompt.push({
-          role: "tool",
-          content: toolResults
+        const responseMessages = addToolResultsToConversation({
+          messages: conversationPrompt,
+          toolResults,
+          providerExecutedToolCallIds: /* @__PURE__ */ new Set([
+            ...toolCalls.flatMap(
+              (toolCall) => toolCall.providerExecuted ? [toolCall.toolCallId] : []
+            ),
+            ...providerExecutedToolResults.keys()
+          ]),
+          providerExecutedToolResultPositions
         });
-        if (stopConditions) {
-          const stopConditionList = Array.isArray(stopConditions) ? stopConditions : [stopConditions];
-          if (stopConditionList.some((test) => test({ steps }))) {
-            done = true;
-          }
-        }
-      } else if (finishReason === "stop") {
-        const assistantContent = getAssistantMessageContent(step);
+        step.response.messages.push(
+          ...responseMessages
+        );
+        const stopConditionList = stopConditions == null ? [] : Array.isArray(stopConditions) ? stopConditions : [stopConditions];
+        const stopConditionMet = stopConditionList.some(
+          (test) => test({ steps })
+        );
+        const hasClientToolCalls = toolCalls.some(
+          (toolCall) => !toolCall.providerExecuted
+        );
+        done = stopConditionMet || !hasClientToolCalls && pendingDeferredToolCallIds.size === 0;
+      } else if (finishReason === "stop" || finishReason === "tool-calls") {
+        const { content: assistantContent } = getAssistantMessageContent(step);
         if (assistantContent.length > 0) {
-          conversationPrompt.push({
+          const assistantMessage = {
             role: "assistant",
             content: assistantContent
-          });
+          };
+          conversationPrompt.push(assistantMessage);
+          step.response.messages.push(
+            assistantMessage
+          );
         }
         done = true;
       } else if (finishReason === "length") {
@@ -828,7 +956,7 @@ async function* streamTextIterator({
       if (resolvedOnStepEnd) {
         await resolvedOnStepEnd(step);
       }
-      await ((_k = telemetryDispatcher.onStepEnd) == null ? void 0 : _k.call(telemetryDispatcher, normalizeStepForTelemetry(step)));
+      await ((_l = telemetryDispatcher.onStepEnd) == null ? void 0 : _l.call(telemetryDispatcher, normalizeStepForTelemetry(step)));
     } catch (error) {
       if (onError) {
         await onError({ error });
@@ -836,7 +964,7 @@ async function* streamTextIterator({
       throw error;
     }
   }
-  if (lastStep && !lastStepWasToolCalls) {
+  if (lastStep && !lastStepWasYielded) {
     yield {
       toolCalls: [],
       messages: conversationPrompt,
@@ -933,7 +1061,7 @@ function normalizeStepForTelemetry(step) {
     model: (_a = step.model) != null ? _a : { provider: "unknown", modelId: "unknown" }
   };
 }
-function buildStepResult(raw, toolCalls, finish, opts) {
+function buildStepResult(raw, toolCalls, finish, providerExecutedToolResults, opts) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
   const {
     content: rawContent,
@@ -1003,8 +1131,41 @@ function buildStepResult(raw, toolCalls, finish, opts) {
         }
         break;
       }
+      case "provider-tool-result": {
+        const result = providerExecutedToolResults.get(part.toolCallId);
+        if (result == null) {
+          break;
+        }
+        const toolCall = toolCalls.find(
+          (toolCall2) => toolCall2.toolCallId === result.toolCallId
+        );
+        const common = {
+          toolCallId: result.toolCallId,
+          toolName: result.toolName,
+          input: toolCall == null ? void 0 : toolCall.input,
+          providerExecuted: true,
+          ...result.dynamic === true || (toolCall == null ? void 0 : toolCall.dynamic) === true ? { dynamic: true } : {},
+          ...result.providerMetadata != null ? { providerMetadata: result.providerMetadata } : {},
+          ...(toolCall == null ? void 0 : toolCall.toolMetadata) != null ? { toolMetadata: toolCall.toolMetadata } : {}
+        };
+        content.push(
+          result.isError ? {
+            type: "tool-error",
+            ...common,
+            error: result.result
+          } : {
+            type: "tool-result",
+            ...common,
+            output: result.result
+          }
+        );
+        break;
+      }
     }
   }
+  const toolResults = content.filter(
+    (part) => part.type === "tool-result"
+  );
   return {
     callId: "workflow-agent",
     stepNumber: opts.stepNumber,
@@ -1028,9 +1189,9 @@ function buildStepResult(raw, toolCalls, finish, opts) {
     toolCalls: validToolCalls,
     staticToolCalls: validToolCalls.filter((tc) => tc.dynamic !== true),
     dynamicToolCalls: validToolCalls.filter((tc) => tc.dynamic),
-    toolResults: [],
-    staticToolResults: [],
-    dynamicToolResults: [],
+    toolResults,
+    staticToolResults: toolResults.filter((result) => result.dynamic !== true),
+    dynamicToolResults: toolResults.filter((result) => result.dynamic === true),
     finishReason: (_f = finish == null ? void 0 : finish.finishReason) != null ? _f : "other",
     rawFinishReason: finish == null ? void 0 : finish.rawFinishReason,
     usage: (_g = finish == null ? void 0 : finish.usage) != null ? _g : {
@@ -1074,11 +1235,14 @@ function buildStepResult(raw, toolCalls, finish, opts) {
 }
 function getAssistantMessageContent(step) {
   const content = [];
+  const providerExecutedToolResultPositions = [];
+  let contentIndex = 0;
   for (const part of step.content) {
     switch (part.type) {
       case "text":
         if (part.text.length > 0) {
           content.push({ type: "text", text: part.text });
+          contentIndex++;
         }
         break;
       case "file":
@@ -1090,13 +1254,25 @@ function getAssistantMessageContent(step) {
             providerOptions: part.providerMetadata
           } : {}
         });
+        contentIndex++;
         break;
       case "tool-call":
         content.push(toAssistantToolCallContent(part));
+        contentIndex++;
+        break;
+      case "tool-result":
+      case "tool-error":
+        if (part.providerExecuted) {
+          providerExecutedToolResultPositions.push({
+            toolCallId: part.toolCallId,
+            contentIndex
+          });
+          contentIndex++;
+        }
         break;
     }
   }
-  return content;
+  return { content, providerExecutedToolResultPositions };
 }
 function toAssistantToolCallContent(toolCall) {
   const sanitizedMetadata = sanitizeProviderMetadataForToolCall(
@@ -1139,10 +1315,18 @@ function addToolResultsToStep(step, executedResults) {
   if (step == null || executedResults.length === 0) {
     return;
   }
-  const toolOutputs = executedResults.map((result) => {
+  const existingProviderResultIds = new Set(
+    step.content.flatMap(
+      (part) => (part.type === "tool-result" || part.type === "tool-error") && part.providerExecuted ? [part.toolCallId] : []
+    )
+  );
+  const toolOutputs = executedResults.flatMap((result) => {
     const toolCall = step.toolCalls.find(
       (toolCall2) => toolCall2.toolCallId === result.modelResult.toolCallId
     );
+    if (existingProviderResultIds.has(result.modelResult.toolCallId)) {
+      return [];
+    }
     const common = {
       toolCallId: result.modelResult.toolCallId,
       toolName: result.modelResult.toolName,
@@ -1150,15 +1334,17 @@ function addToolResultsToStep(step, executedResults) {
       ...(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
-    };
+    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(
@@ -1817,8 +2003,10 @@ var WorkflowAgent = class {
           runtimeContext: yieldedRuntimeContext,
           toolsContext: yieldedToolsContext,
           experimental_sandbox: stepSandbox,
-          providerExecutedToolResults
+          providerExecutedToolResults,
+          providerExecutedToolResultPositions
         } = result.value;
+        const capturedProviderToolResults = providerExecutedToolResults != null ? providerExecutedToolResults : /* @__PURE__ */ new Map();
         const toolExecutionSandbox = stepSandbox != null ? stepSandbox : sandbox;
         const currentStepNumber = steps.length;
         if (step) {
@@ -1830,7 +2018,7 @@ var WorkflowAgent = class {
         if (yieldedToolsContext !== void 0) {
           toolsContext = yieldedToolsContext;
         }
-        if (toolCalls.length > 0) {
+        if (toolCalls.length > 0 || capturedProviderToolResults.size > 0) {
           const invalidToolCalls = toolCalls.filter((tc) => tc.invalid === true);
           const validToolCalls = toolCalls.filter((tc) => tc.invalid !== true);
           const nonProviderToolCalls = validToolCalls.filter(
@@ -1839,6 +2027,28 @@ var WorkflowAgent = class {
           const providerToolCalls = validToolCalls.filter(
             (tc) => tc.providerExecuted
           );
+          const providerToolCallsForResults = [
+            ...providerToolCalls,
+            ...[...capturedProviderToolResults.values()].flatMap(
+              (providerResult) => {
+                var _a2;
+                return providerToolCalls.some(
+                  (toolCall) => toolCall.toolCallId === providerResult.toolCallId
+                ) ? [] : [
+                  {
+                    type: "tool-call",
+                    toolCallId: providerResult.toolCallId,
+                    toolName: providerResult.toolName,
+                    input: (_a2 = toolCalls.find(
+                      (toolCall) => toolCall.toolCallId === providerResult.toolCallId
+                    )) == null ? void 0 : _a2.input,
+                    providerExecuted: true,
+                    dynamic: providerResult.dynamic
+                  }
+                ];
+              }
+            )
+          ];
           const approvalNeeded = await Promise.all(
             nonProviderToolCalls.map(async (tc) => {
               const tool2 = effectiveTools[tc.toolName];
@@ -1880,11 +2090,11 @@ var WorkflowAgent = class {
               )
             );
             const providerResultEntries = await Promise.all(
-              providerToolCalls.map(async (toolCall) => ({
+              providerToolCallsForResults.map(async (toolCall) => ({
                 toolCall,
                 result: await resolveProviderToolResult(
                   toolCall,
-                  providerExecutedToolResults,
+                  capturedProviderToolResults,
                   effectiveTools,
                   download
                 )
@@ -1905,9 +2115,7 @@ var WorkflowAgent = class {
             const providerResults = providerResultEntries.flatMap(
               ({ result: result2 }) => result2 == null ? [] : [result2]
             );
-            const continuationInvalidResults = invalidToolCalls.map(
-              createInvalidToolResult
-            );
+            const continuationInvalidResults = invalidToolCalls.filter((toolCall) => !toolCall.providerExecuted).map(createInvalidToolResult);
             const resolvedResults = [
               ...executableResults.map((result2) => result2.modelResult),
               ...providerResults.map((result2) => result2.modelResult),
@@ -1933,12 +2141,19 @@ var WorkflowAgent = class {
               };
             });
             addToolResultsToStep(step, executedResults);
-            if (resolvedResults.length > 0) {
-              iterMessages.push({
-                role: "tool",
-                content: resolvedResults
-              });
-            }
+            const responseMessages = addToolResultsToConversation({
+              messages: iterMessages,
+              toolResults: resolvedResults,
+              providerExecutedToolCallIds: new Set(
+                providerToolCallsForResults.map(
+                  (toolCall) => toolCall.toolCallId
+                )
+              ),
+              providerExecutedToolResultPositions
+            });
+            step == null ? void 0 : step.response.messages.push(
+              ...responseMessages
+            );
             const messages2 = iterMessages;
             const lastStep2 = steps[steps.length - 1];
             const totalUsage2 = aggregateUsage(steps);
@@ -2041,11 +2256,11 @@ var WorkflowAgent = class {
             )
           );
           const providerToolResultEntries = await Promise.all(
-            providerToolCalls.map(async (toolCall) => ({
+            providerToolCallsForResults.map(async (toolCall) => ({
               toolCall,
               result: await resolveProviderToolResult(
                 toolCall,
-                providerExecutedToolResults,
+                capturedProviderToolResults,
                 effectiveTools,
                 download
               )
@@ -2066,9 +2281,7 @@ var WorkflowAgent = class {
           const providerToolResults = providerToolResultEntries.flatMap(
             ({ result: result2 }) => result2 == null ? [] : [result2]
           );
-          const continuationInvalidToolResults = invalidToolCalls.map(
-            createInvalidToolResult
-          );
+          const continuationInvalidToolResults = invalidToolCalls.filter((toolCall) => !toolCall.providerExecuted).map(createInvalidToolResult);
           const executedToolResults = toolCalls.flatMap((tc) => {
             const clientResult = clientToolResults.find(
               (r) => r.modelResult.toolCallId === tc.toolCallId
@@ -2080,6 +2293,14 @@ var WorkflowAgent = class {
             if (providerResult) return [providerResult];
             return [];
           });
+          const currentToolCallIds = new Set(
+            toolCalls.map((toolCall) => toolCall.toolCallId)
+          );
+          executedToolResults.push(
+            ...providerToolResults.filter(
+              (result2) => !currentToolCallIds.has(result2.modelResult.toolCallId)
+            )
+          );
           const continuationToolResults = toolCalls.flatMap((tc) => {
             const invalidResult = continuationInvalidToolResults.find(
               (r) => r.toolCallId === tc.toolCallId
@@ -2091,6 +2312,11 @@ var WorkflowAgent = class {
             if (executedResult) return [executedResult.modelResult];
             return [];
           });
+          continuationToolResults.push(
+            ...providerToolResults.flatMap(
+              (result2) => currentToolCallIds.has(result2.modelResult.toolCallId) ? [] : [result2.modelResult]
+            )
+          );
           if (options.writable) {
             await writeToolResults(
               options.writable,
@@ -2461,7 +2687,7 @@ async function resolveProviderToolResult(toolCall, providerExecutedToolResults,
     };
   }
   const result = streamResult.result;
-  const errorMode = streamResult.isError ? typeof result === "string" ? "text" : "json" : "none";
+  const errorMode = streamResult.isError ? "json" : "none";
   return {
     modelResult: {
       type: "tool-result",
@@ -2476,7 +2702,8 @@ async function resolveProviderToolResult(toolCall, providerExecutedToolResults,
         errorMode,
         supportedUrls: {},
         download
-      })
+      }),
+      ...streamResult.providerMetadata != null ? { providerOptions: streamResult.providerMetadata } : {}
     },
     rawOutput: result,
     isError: streamResult.isError === true