@ai-sdk/workflow 2.0.28 → 2.0.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "2.0.28",
+  "version": "2.0.29",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -31,9 +31,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.13",
-    "@ai-sdk/provider-utils": "5.0.39",
-    "ai": "7.0.97",
+    "@ai-sdk/provider": "4.0.14",
+    "@ai-sdk/provider-utils": "5.0.40",
+    "ai": "7.0.98",
     "ajv": "^8.20.0"
   },
   "devDependencies": {

package/src/add-tool-results-to-conversation.ts

@@ -0,0 +1,108 @@
+import type {
+  LanguageModelV4Prompt,
+  LanguageModelV4ToolResultPart,
+} from '@ai-sdk/provider';
+
+export interface ProviderExecutedToolResultPosition {
+  toolCallId: string;
+  contentIndex: number;
+}
+
+export function addToolResultsToConversation({
+  messages,
+  toolResults,
+  providerExecutedToolCallIds,
+  providerExecutedToolResultPositions = [],
+}: {
+  messages: LanguageModelV4Prompt;
+  toolResults: LanguageModelV4ToolResultPart[];
+  providerExecutedToolCallIds: Set<string>;
+  providerExecutedToolResultPositions?: ProviderExecutedToolResultPosition[];
+}) {
+  const providerResultIds = new Set([
+    ...providerExecutedToolCallIds,
+    ...providerExecutedToolResultPositions.map(position => position.toolCallId),
+  ]);
+  const providerResults = new Map<string, LanguageModelV4ToolResultPart[]>();
+  const clientResults: LanguageModelV4ToolResultPart[] = [];
+  let assistantMessageIndex = -1;
+  let assistantMessage:
+    | Extract<LanguageModelV4Prompt[number], { role: 'assistant' }>
+    | undefined;
+
+  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 = providerResults.get(toolResult.toolCallId) ?? [];
+      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: typeof assistantMessage.content = [];
+
+      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);
+}

package/src/do-stream-step.ts

@@ -46,6 +46,8 @@ export interface ProviderExecutedToolResult {
   toolName: string;
   result: unknown;
   isError?: boolean;
+  dynamic?: boolean;
+  providerMetadata?: SharedV4ProviderMetadata;
 }
 
 /**
@@ -115,6 +117,10 @@ export type DoStreamStepRawContentPart =
   | {
       type: 'tool-call';
       toolCallIndex: number;
+    }
+  | {
+      type: 'provider-tool-result';
+      toolCallId: string;
     };
 
 /**
@@ -407,6 +413,12 @@ export async function doStreamStep(
               toolName: part.toolName,
               result: part.output,
               isError: false,
+              dynamic: part.dynamic,
+              providerMetadata: part.providerMetadata,
+            });
+            content.push({
+              type: 'provider-tool-result',
+              toolCallId: part.toolCallId,
             });
           }
           break;
@@ -420,6 +432,12 @@ export async function doStreamStep(
               toolName: errorPart.toolName,
               result: errorPart.error,
               isError: true,
+              dynamic: errorPart.dynamic,
+              providerMetadata: errorPart.providerMetadata,
+            });
+            content.push({
+              type: 'provider-tool-result',
+              toolCallId: errorPart.toolCallId,
             });
           }
           break;

package/src/stream-text-iterator.ts

@@ -30,6 +30,10 @@ import {
   type StreamFinish,
   type ToolInputLifecycleEvent,
 } from './do-stream-step.js';
+import {
+  addToolResultsToConversation,
+  type ProviderExecutedToolResultPosition,
+} from './add-tool-results-to-conversation.js';
 import { resolveToolContext } from './resolve-tool-context.js';
 import { serializeToolSet } from './serializable-schema.js';
 import type {
@@ -92,6 +96,8 @@ export interface StreamTextIteratorYieldValue {
   toolsContext?: Record<string, Context | undefined>;
   /** Provider-executed tool results (keyed by tool call ID) */
   providerExecutedToolResults?: Map<string, ProviderExecutedToolResult>;
+  /** Original positions of provider-executed results in assistant content. */
+  providerExecutedToolResultPositions?: ProviderExecutedToolResultPosition[];
   /** The sandbox selected for the current step. */
   experimental_sandbox?: SandboxSession;
 }
@@ -175,7 +181,8 @@ export async function* streamTextIterator({
   let _isFirstIteration = true;
   let stepNumber = 0;
   let lastStep: StepResult<any, any> | undefined;
-  let lastStepWasToolCalls = false;
+  let lastStepWasYielded = false;
+  const pendingDeferredToolCallIds = new Set<string>();
   let wasAborted = false;
   let terminalError: unknown;
   let hasTerminalError = false;
@@ -385,11 +392,17 @@ export async function* streamTextIterator({
       // Reconstruct the full StepResult outside the step boundary so the
       // durable event log doesn't carry StepResult's redundant copies (or the
       // per-chunk snapshot the step used to return).
-      const step = buildStepResult(raw, toolCalls, finish, {
-        stepNumber,
-        runtimeContext: currentRuntimeContext,
-        toolsContext: currentToolsContext,
-      });
+      const step = buildStepResult(
+        raw,
+        toolCalls,
+        finish,
+        providerExecutedToolResults,
+        {
+          stepNumber,
+          runtimeContext: currentRuntimeContext,
+          toolsContext: currentToolsContext,
+        },
+      );
 
       await telemetryDispatcher.onLanguageModelCallEnd?.({
         callId: step.callId,
@@ -408,19 +421,41 @@ export async function* streamTextIterator({
       stepNumber++;
       steps.push(step);
       lastStep = step;
-      lastStepWasToolCalls = false;
+      lastStepWasYielded = false;
 
       const finishReason = finish?.finishReason;
+      const isToolExecutionAllowed =
+        finishReason === 'tool-calls' || finishReason === 'stop';
+
+      for (const toolCall of toolCalls) {
+        if (
+          toolCall.providerExecuted &&
+          serializedTools[toolCall.toolName]?.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) {
         // The error crossed the durable step boundary as data. End the loop
         // without throwing so WorkflowAgent can preserve the existing
         // resolved-result contract and expose the original value.
         done = true;
-      } else if (finishReason === 'tool-calls') {
-        lastStepWasToolCalls = true;
+      } else if (shouldProcessTools) {
+        lastStepWasYielded = true;
 
-        const assistantContent = getAssistantMessageContent(step);
+        const {
+          content: assistantContent,
+          providerExecutedToolResultPositions,
+        } = getAssistantMessageContent(step);
         const includedToolCallIds = new Set(
           assistantContent.flatMap(part =>
             part.type === 'tool-call' ? [part.toolCallId] : [],
@@ -455,30 +490,53 @@ export async function* streamTextIterator({
           toolsContext: currentToolsContext,
           experimental_sandbox: stepSandbox,
           providerExecutedToolResults,
+          providerExecutedToolResultPositions,
         };
 
-        conversationPrompt.push({
-          role: 'tool',
-          content: toolResults,
+        const responseMessages = addToolResultsToConversation({
+          messages: conversationPrompt,
+          toolResults,
+          providerExecutedToolCallIds: new Set([
+            ...toolCalls.flatMap(toolCall =>
+              toolCall.providerExecuted ? [toolCall.toolCallId] : [],
+            ),
+            ...providerExecutedToolResults.keys(),
+          ]),
+          providerExecutedToolResultPositions,
         });
+        step.response.messages.push(
+          ...(responseMessages as unknown as typeof step.response.messages),
+        );
 
-        if (stopConditions) {
-          const stopConditionList = Array.isArray(stopConditions)
-            ? stopConditions
-            : [stopConditions];
-          if (stopConditionList.some(test => test({ steps }))) {
-            done = true;
-          }
-        }
-      } else if (finishReason === 'stop') {
+        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') {
         // Add assistant response content to the conversation
-        const assistantContent = getAssistantMessageContent(step);
+        const { content: assistantContent } = getAssistantMessageContent(step);
 
         if (assistantContent.length > 0) {
-          conversationPrompt.push({
+          const assistantMessage = {
             role: 'assistant',
             content: assistantContent,
-          });
+          } as const;
+          conversationPrompt.push(assistantMessage);
+          step.response.messages.push(
+            assistantMessage as unknown as (typeof step.response.messages)[number],
+          );
         }
 
         done = true;
@@ -519,8 +577,8 @@ export async function* streamTextIterator({
     }
   }
 
-  // Yield the final step if it wasn't already yielded (tool-calls steps are yielded inside the loop)
-  if (lastStep && !lastStepWasToolCalls) {
+  // Yield the final step if it wasn't already yielded inside the loop.
+  if (lastStep && !lastStepWasYielded) {
     yield {
       toolCalls: [],
       messages: conversationPrompt,
@@ -653,6 +711,7 @@ function buildStepResult(
   raw: DoStreamStepRawResult,
   toolCalls: ParsedToolCall[],
   finish: StreamFinish | undefined,
+  providerExecutedToolResults: Map<string, ProviderExecutedToolResult>,
   opts: {
     stepNumber: number;
     runtimeContext: Context;
@@ -740,9 +799,53 @@ function buildStepResult(
         }
         break;
       }
+      case 'provider-tool-result': {
+        const result = providerExecutedToolResults.get(part.toolCallId);
+        if (result == null) {
+          break;
+        }
+
+        const toolCall = toolCalls.find(
+          toolCall => toolCall.toolCallId === result.toolCallId,
+        );
+        const common = {
+          toolCallId: result.toolCallId,
+          toolName: result.toolName,
+          input: toolCall?.input,
+          providerExecuted: true as const,
+          ...(result.dynamic === true || toolCall?.dynamic === true
+            ? { dynamic: true as const }
+            : {}),
+          ...(result.providerMetadata != null
+            ? { providerMetadata: result.providerMetadata }
+            : {}),
+          ...(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',
+  ) as StepResult<ToolSet, any>['toolResults'];
+
   return {
     callId: 'workflow-agent',
     stepNumber: opts.stepNumber,
@@ -766,9 +869,9 @@ function buildStepResult(
     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: finish?.finishReason ?? 'other',
     rawFinishReason: finish?.rawFinishReason,
     usage:
@@ -812,19 +915,27 @@ function buildStepResult(
   } as StepResult<ToolSet, any>;
 }
 
-function getAssistantMessageContent(
-  step: StepResult<any, any>,
-): Extract<LanguageModelV4Prompt[number], { role: 'assistant' }>['content'] {
+function getAssistantMessageContent(step: StepResult<any, any>): {
+  content: Extract<
+    LanguageModelV4Prompt[number],
+    { role: 'assistant' }
+  >['content'];
+  providerExecutedToolResultPositions: ProviderExecutedToolResultPosition[];
+} {
   const content: Extract<
     LanguageModelV4Prompt[number],
     { role: 'assistant' }
   >['content'] = [];
+  const providerExecutedToolResultPositions: ProviderExecutedToolResultPosition[] =
+    [];
+  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':
@@ -839,14 +950,26 @@ function getAssistantMessageContent(
               }
             : {}),
         });
+        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: {