@ai-sdk/workflow 2.0.58 → 2.0.59

package/src/{stream-text-iterator.ts → model-call-iterator.ts}

@@ -6,13 +6,11 @@ import type {
 } from '@ai-sdk/provider';
 import type { Context } from '@ai-sdk/provider-utils';
 import {
-  DefaultGeneratedFile,
   experimental_filterActiveTools as filterActiveTools,
   type ActiveTools,
   type Experimental_SandboxSession as SandboxSession,
   type Instructions,
   type LanguageModel,
-  type LanguageModelUsage,
   type ModelMessage,
   type StepResult,
   type ToolCallRepairFunction,
@@ -23,20 +21,22 @@ import {
   createRestrictedTelemetryDispatcher,
   createToolSearchState,
 } from 'ai/internal';
-import {
-  type DoStreamStepRawResult,
-  doStreamStep,
-  type ModelCallStreamPart,
-  type ModelStopCondition,
-  type ParsedToolCall,
-  type ProviderExecutedToolResult,
-  type StreamFinish,
-  type ToolInputLifecycleEvent,
-} from './do-stream-step.js';
+import { buildModelStepResult } from './build-model-step-result.js';
+import { doGenerateStep } from './do-generate-step.js';
+import { doStreamStep } from './do-stream-step.js';
+import type {
+  ModelCallStreamPart,
+  ModelCallOptions,
+  ModelStopCondition,
+  ParsedToolCall,
+  ProviderExecutedToolResult,
+  ToolInputLifecycleEvent,
+} from './model-call.js';
 import {
   addToolResultsToConversation,
   type ProviderExecutedToolResultPosition,
 } from './add-tool-results-to-conversation.js';
+import { toModelResponseMessages } from './to-model-response-messages.js';
 import { resolveToolContext } from './resolve-tool-context.js';
 import { serializeToolSet } from './serializable-schema.js';
 import type {
@@ -51,7 +51,7 @@ import type {
 } from './workflow-agent.js';
 
 // Re-export for consumers
-export type { ProviderExecutedToolResult } from './do-stream-step.js';
+export type { ProviderExecutedToolResult } from './model-call.js';
 
 const prepareStepGenerationSettingKeys = [
   'maxOutputTokens',
@@ -87,7 +87,7 @@ function mergePrepareStepGenerationSettings(
  * The value yielded by the stream text iterator when tool calls are requested.
  * Contains both the tool calls and the current conversation messages.
  */
-export interface StreamTextIteratorYieldValue {
+export interface ModelCallIteratorYieldValue {
   /** The tool calls requested by the model (parsed with typed inputs) */
   toolCalls: ParsedToolCall[];
   /** The tools available for execution in the current step. */
@@ -108,19 +108,21 @@ export interface StreamTextIteratorYieldValue {
   experimental_sandbox?: SandboxSession;
 }
 
-export interface StreamTextIteratorAbortedValue {
+export interface ModelCallIteratorAbortedValue {
   aborted: true;
   messages: LanguageModelV4Prompt;
 }
 
-export interface StreamTextIteratorErrorValue {
+export interface ModelCallIteratorErrorValue {
   error: unknown;
   messages: LanguageModelV4Prompt;
 }
 
 // This runs in the workflow context
-export async function* streamTextIterator({
+export async function* modelCallIterator({
   prompt,
+  mode = 'stream',
+  include,
   initialInstructions,
   initialMessages = prompt as unknown as ModelMessage[],
   tools = {},
@@ -145,6 +147,8 @@ export async function* streamTextIterator({
   experimental_sandbox: sandbox,
 }: {
   prompt: LanguageModelV4Prompt;
+  mode?: 'generate' | 'stream';
+  include?: ModelCallOptions['include'];
   initialInstructions?: Instructions;
   initialMessages?: Array<ModelMessage>;
   tools: ToolSet;
@@ -171,10 +175,10 @@ export async function* streamTextIterator({
     | Array<StreamTextTransform<ToolSet>>;
   experimental_sandbox?: SandboxSession;
 }): AsyncGenerator<
-  StreamTextIteratorYieldValue,
+  ModelCallIteratorYieldValue,
   | LanguageModelV4Prompt
-  | StreamTextIteratorAbortedValue
-  | StreamTextIteratorErrorValue,
+  | ModelCallIteratorAbortedValue
+  | ModelCallIteratorErrorValue,
   LanguageModelV4ToolResultPart[]
 > {
   let conversationPrompt = [...prompt]; // Create a mutable copy
@@ -202,7 +206,7 @@ export async function* streamTextIterator({
   });
 
   // TODO(#12164): replace this AI-core telemetry bridge with a
-  // WorkflowAgent-specific typed dispatcher. `streamTextIterator` widens
+  // WorkflowAgent-specific typed dispatcher. `modelCallIterator` widens
   // tools/runtime context and emits Workflow-shaped events that are only
   // approximately compatible with generateText telemetry event types.
   const telemetryDispatcher = createRestrictedTelemetryDispatcher<
@@ -218,6 +222,8 @@ export async function* streamTextIterator({
   while (!done) {
     // Check for abort signal
     if (currentGenerationSettings.abortSignal?.aborted) {
+      if (mode === 'generate')
+        currentGenerationSettings.abortSignal.throwIfAborted();
       break;
     }
 
@@ -362,30 +368,43 @@ export async function* streamTextIterator({
         headers: currentGenerationSettings.headers,
       } as never);
 
-      const stepInputMessages = conversationPrompt as unknown as ModelMessage[];
-      const streamStepResult = await doStreamStep(
-        conversationPrompt,
-        currentModel,
-        writable,
-        serializedTools,
-        {
-          ...currentGenerationSettings,
-          toolChoice: currentToolChoice,
-          includeRawChunks,
-          timeoutAt,
-          repairToolCall,
-          responseFormat,
-          experimental_transform,
-        },
-      );
-
-      if (streamStepResult.aborted) {
+      const stepInputMessages = (mode === 'generate'
+        ? [...conversationPrompt]
+        : conversationPrompt) as unknown as ModelMessage[];
+      const callOptions = {
+        ...currentGenerationSettings,
+        toolChoice: currentToolChoice,
+        includeRawChunks,
+        timeoutAt,
+        repairToolCall,
+        responseFormat,
+        include,
+        experimental_transform,
+      };
+      const modelCallResult =
+        mode === 'generate'
+          ? await doGenerateStep(
+              conversationPrompt,
+              currentModel,
+              serializedTools,
+              callOptions,
+            )
+          : await doStreamStep(
+              conversationPrompt,
+              currentModel,
+              writable,
+              serializedTools,
+              callOptions,
+            );
+
+      if (modelCallResult.aborted) {
         wasAborted = true;
         break;
       }
 
-      if ('terminalError' in streamStepResult) {
-        terminalError = streamStepResult.terminalError;
+      if ('terminalError' in modelCallResult) {
+        if (mode === 'generate') throw modelCallResult.terminalError;
+        terminalError = modelCallResult.terminalError;
         hasTerminalError = true;
       }
 
@@ -395,7 +414,7 @@ export async function* streamTextIterator({
         raw,
         providerExecutedToolResults,
         toolInputLifecycleEvents,
-      } = streamStepResult;
+      } = modelCallResult;
       await invokeToolInputLifecycleCallbacks({
         events: toolInputLifecycleEvents ?? [],
         toolCalls,
@@ -408,12 +427,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(
+      const step = await buildModelStepResult(
         raw,
         toolCalls,
         finish,
         providerExecutedToolResults,
         {
+          tools: effectiveTools,
+          requestMessages:
+            mode === 'generate' && include?.requestMessages
+              ? stepInputMessages
+              : undefined,
           stepNumber,
           runtimeContext: currentRuntimeContext,
           toolsContext: currentToolsContext,
@@ -471,7 +495,7 @@ export async function* streamTextIterator({
         const {
           content: assistantContent,
           providerExecutedToolResultPositions,
-        } = getAssistantMessageContent(step);
+        } = getAssistantMessageContent(step, mode);
         const includedToolCallIds = new Set(
           assistantContent.flatMap(part =>
             part.type === 'tool-call' ? [part.toolCallId] : [],
@@ -484,7 +508,7 @@ export async function* streamTextIterator({
         // Note: providerMetadata from the tool call is mapped to providerOptions
         // in the prompt format, following the AI SDK convention. This is critical
         // for providers like Gemini that require thoughtSignature to be preserved
-        // across multi-turn tool calls.
+        // across multi-turn tool calls. Some fields are sanitized before mapping.
         conversationPrompt.push({
           role: 'assistant',
           content: [
@@ -522,7 +546,9 @@ export async function* streamTextIterator({
           providerExecutedToolResultPositions,
         });
         step.response.messages.push(
-          ...(responseMessages as unknown as typeof step.response.messages),
+          ...(mode === 'generate'
+            ? toModelResponseMessages(responseMessages)
+            : (responseMessages as unknown as typeof step.response.messages)),
         );
 
         const stopConditionList =
@@ -541,9 +567,17 @@ export async function* streamTextIterator({
         done =
           stopConditionMet ||
           (!hasClientToolCalls && pendingDeferredToolCallIds.size === 0);
-      } else if (finishReason === 'stop' || finishReason === 'tool-calls') {
+      } else if (
+        mode === 'generate' ||
+        finishReason === 'stop' ||
+        finishReason === 'tool-calls' ||
+        finishReason === 'length'
+      ) {
         // Add assistant response content to the conversation
-        const { content: assistantContent } = getAssistantMessageContent(step);
+        const { content: assistantContent } = getAssistantMessageContent(
+          step,
+          mode,
+        );
 
         if (assistantContent.length > 0) {
           const assistantMessage = {
@@ -552,13 +586,14 @@ export async function* streamTextIterator({
           } as const;
           conversationPrompt.push(assistantMessage);
           step.response.messages.push(
-            assistantMessage as unknown as (typeof step.response.messages)[number],
+            ...(mode === 'generate'
+              ? toModelResponseMessages([assistantMessage])
+              : [
+                  assistantMessage as unknown as (typeof step.response.messages)[number],
+                ]),
           );
         }
 
-        done = true;
-      } else if (finishReason === 'length') {
-        // Model hit max tokens - stop but don't throw
         done = true;
       } else if (finishReason === 'content-filter') {
         // Content filter triggered - stop but don't throw
@@ -716,239 +751,11 @@ function normalizeStepForTelemetry(step: StepResult<any, any>) {
   };
 }
 
-/**
- * Reconstruct a full `StepResult` from the minimal aggregates returned by
- * `doStreamStep`. Runs outside the step boundary so StepResult's redundant
- * fields (duplicate tool-call lists, `text`, `files`, `sources`, and
- * `reasoningText`) and the per-chunk snapshot don't cross it. Tool-result
- * arrays are initialized here and populated after execution. The shape matches
- * what the AI SDK's `streamText` exposes to callers.
- */
-function buildStepResult(
-  raw: DoStreamStepRawResult,
-  toolCalls: ParsedToolCall[],
-  finish: StreamFinish | undefined,
-  providerExecutedToolResults: Map<string, ProviderExecutedToolResult>,
-  opts: {
-    stepNumber: number;
-    runtimeContext: Context;
-    toolsContext: Record<string, Context | undefined>;
-  },
-): StepResult<ToolSet, any> {
-  const {
-    content: rawContent,
-    reasoning: reasoningParts,
-    responseMetadata,
-    warnings,
-  } = raw;
-  const reasoningText = reasoningParts.map(r => r.text).join('') || undefined;
-  const validToolCallsByIndex = new Map(
-    toolCalls.flatMap((tc, index) =>
-      tc.invalid
-        ? []
-        : [
-            [
-              index,
-              {
-                type: 'tool-call' as const,
-                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 as const } : {}),
-                ...(tc.providerExecuted ? { providerExecuted: true } : {}),
-                ...(tc.providerMetadata != null
-                  ? { providerMetadata: tc.providerMetadata }
-                  : {}),
-              },
-            ] as const,
-          ],
-    ),
-  );
-  const validToolCalls = [...validToolCallsByIndex.values()];
-  const content: StepResult<ToolSet, any>['content'] = [];
-  const files: StepResult<ToolSet, any>['files'] = [];
-  const sources: StepResult<ToolSet, any>['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 'reasoning': {
-        const reasoningPart = reasoningParts[part.reasoningIndex];
-        if (reasoningPart != null) {
-          content.push({
-            type: 'reasoning',
-            text: reasoningPart.text,
-            ...(reasoningPart.providerMetadata != null
-              ? { providerMetadata: reasoningPart.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;
-      }
-      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,
-    model: {
-      provider: responseMetadata?.modelId?.split(':')[0] ?? 'unknown',
-      modelId: responseMetadata?.modelId ?? 'unknown',
-    },
-    functionId: undefined,
-    metadata: undefined,
-    runtimeContext: opts.runtimeContext ?? {},
-    toolsContext: opts.toolsContext ?? {},
-    content,
-    text,
-    reasoning: reasoningParts.map(r => ({
-      type: 'reasoning' as const,
-      text: r.text,
-      ...(r.providerMetadata != null
-        ? { providerMetadata: r.providerMetadata }
-        : {}),
-    })),
-    reasoningText,
-    files,
-    sources,
-    toolCalls: validToolCalls,
-    staticToolCalls: validToolCalls.filter(tc => tc.dynamic !== true),
-    dynamicToolCalls: validToolCalls.filter(tc => tc.dynamic),
-    toolResults,
-    staticToolResults: toolResults.filter(result => result.dynamic !== true),
-    dynamicToolResults: toolResults.filter(result => result.dynamic === true),
-    finishReason: finish?.finishReason ?? 'other',
-    rawFinishReason: finish?.rawFinishReason,
-    usage:
-      finish?.usage ??
-      ({
-        inputTokens: 0,
-        inputTokenDetails: {
-          noCacheTokens: undefined,
-          cacheReadTokens: undefined,
-          cacheWriteTokens: undefined,
-        },
-        outputTokens: 0,
-        outputTokenDetails: {
-          textTokens: undefined,
-          reasoningTokens: undefined,
-        },
-        totalTokens: 0,
-      } as LanguageModelUsage),
-    performance: {
-      effectiveOutputTokensPerSecond: 0,
-      outputTokensPerSecond: undefined,
-      inputTokensPerSecond: undefined,
-      effectiveTotalTokensPerSecond: 0,
-      stepTimeMs: 0,
-      responseTimeMs: 0,
-      toolExecutionMs: {},
-      timeToFirstOutputMs: undefined,
-    },
-    warnings,
-    request: {
-      body: '',
-      messages: [], // TODO implement step request messages
-    },
-    response: {
-      id: responseMetadata?.id ?? 'unknown',
-      timestamp: responseMetadata?.timestamp ?? new Date(),
-      modelId: responseMetadata?.modelId ?? 'unknown',
-      messages: [],
-    },
-    providerMetadata: finish?.providerMetadata ?? {},
-  } as StepResult<ToolSet, any>;
-}
-
-function getAssistantMessageContent(step: StepResult<any, any>): {
+/** Preserve assistant ordering and positions for provider-executed results. */
+function getAssistantMessageContent(
+  step: StepResult<any, any>,
+  mode: 'generate' | 'stream',
+): {
   content: Extract<
     LanguageModelV4Prompt[number],
     { role: 'assistant' }
@@ -965,28 +772,41 @@ function getAssistantMessageContent(step: StepResult<any, any>): {
 
   for (const part of step.content) {
     switch (part.type) {
-      case 'reasoning':
+      case 'text':
+        if (part.text.length > 0) {
+          content.push({
+            type: 'text',
+            text: part.text,
+            ...(part.providerMetadata != null
+              ? { providerOptions: part.providerMetadata }
+              : {}),
+          });
+          contentIndex++;
+        }
+        break;
+      case 'reasoning': {
+        const { providerMetadata, ...messagePart } = part;
         content.push({
-          type: 'reasoning',
-          text: part.text,
-          ...(part.providerMetadata != null
-            ? {
-                providerOptions:
-                  part.providerMetadata as SharedV4ProviderOptions,
-              }
+          ...messagePart,
+          ...(providerMetadata != null
+            ? { providerOptions: providerMetadata }
             : {}),
         });
         contentIndex++;
         break;
-      case 'text':
-        if (part.text.length > 0) {
-          content.push({ type: 'text', text: part.text });
+      }
+      case 'custom':
+        if (mode === 'generate') {
+          const { providerMetadata, ...messagePart } = part;
+          content.push({ ...messagePart, providerOptions: providerMetadata });
           contentIndex++;
         }
         break;
+      case 'reasoning-file':
+        if (mode !== 'generate') break;
       case 'file':
         content.push({
-          type: 'file',
+          type: part.type,
           data: { type: 'data', data: part.file.base64 },
           mediaType: part.file.mediaType,
           ...(part.providerMetadata != null