@ai-sdk/workflow 2.0.58 → 2.0.59

package/src/do-stream-step.ts

@@ -1,8 +1,5 @@
 import type {
-  JSONObject,
-  LanguageModelV4CallOptions,
   LanguageModelV4Prompt,
-  LanguageModelV4Source,
   LanguageModelV4StreamPart,
   SharedV4ProviderMetadata,
 } from '@ai-sdk/provider';
@@ -11,173 +8,41 @@ import {
   experimental_streamLanguageModelCall as streamModelCall,
   gateway,
   wrapLanguageModel,
-  type Experimental_LanguageModelStreamPart,
-  type FinishReason,
   type LanguageModel,
-  type LanguageModelUsage,
   type ModelMessage,
-  type StopCondition,
-  type ToolCallRepairFunction,
-  type ToolChoice,
   type ToolSet,
 } from 'ai';
 import { prepareRetries } from 'ai/internal';
-import type { ProviderOptions, StreamTextTransform } from './workflow-agent.js';
+import type { StreamTextTransform } from './workflow-agent.js';
 import {
   resolveSerializableTools,
   type SerializableToolDef,
 } from './serializable-schema.js';
 
-export type ModelCallStreamPart<TTools extends ToolSet = ToolSet> =
-  | Experimental_LanguageModelStreamPart<TTools>
-  | {
-      type: 'tool-approval-request';
-      approvalId: string;
-      toolCallId: string;
-      signature?: string;
-    }
-  | { type: 'reset-step' };
-
-export type ModelStopCondition = StopCondition<NoInfer<ToolSet>, any>;
-
-/**
- * Provider-executed tool result captured from the stream.
- */
-export interface ProviderExecutedToolResult {
-  toolCallId: string;
-  toolName: string;
-  result: unknown;
-  isError?: boolean;
-  dynamic?: boolean;
-  providerMetadata?: SharedV4ProviderMetadata;
-}
-
-/**
- * Options for the doStreamStep function.
- */
-export interface DoStreamStepOptions {
-  maxOutputTokens?: number;
-  temperature?: number;
-  topP?: number;
-  topK?: number;
-  presencePenalty?: number;
-  frequencyPenalty?: number;
-  stopSequences?: string[];
-  seed?: number;
-  maxRetries?: number;
-  abortSignal?: AbortSignal;
-  timeoutAt?: number;
-  headers?: Record<string, string | undefined>;
-  reasoning?: LanguageModelV4CallOptions['reasoning'];
-  providerOptions?: ProviderOptions;
-  toolChoice?: ToolChoice<ToolSet>;
-  includeRawChunks?: boolean;
-  repairToolCall?: ToolCallRepairFunction<ToolSet>;
-  responseFormat?: LanguageModelV4CallOptions['responseFormat'];
-  experimental_transform?:
-    | StreamTextTransform<ToolSet>
-    | Array<StreamTextTransform<ToolSet>>;
-}
-
-/**
- * Parsed tool call from the stream (parsed by streamModelCall's transform).
- */
-export interface ParsedToolCall {
-  type: 'tool-call';
-  toolCallId: string;
-  toolName: string;
-  input: unknown;
-  providerExecuted?: boolean;
-  providerMetadata?: SharedV4ProviderMetadata;
-  title?: string;
-  toolMetadata?: JSONObject;
-  dynamic?: boolean;
-  invalid?: boolean;
-  error?: unknown;
-}
-
-/**
- * Finish metadata from the stream.
- */
-export interface StreamFinish {
-  finishReason: FinishReason;
-  rawFinishReason: string | undefined;
-  usage: LanguageModelUsage;
-  providerMetadata?: Record<string, unknown>;
-}
-
-export type DoStreamStepRawContentPart =
-  | {
-      type: 'text';
-      text: string;
-      providerMetadata?: SharedV4ProviderMetadata;
-    }
-  | {
-      type: 'reasoning';
-      reasoningIndex: number;
-    }
-  | {
-      type: 'file';
-      data: string;
-      mediaType: string;
-      providerMetadata?: SharedV4ProviderMetadata;
-    }
-  | LanguageModelV4Source
-  | {
-      type: 'tool-call';
-      toolCallIndex: number;
-    }
-  | {
-      type: 'provider-tool-result';
-      toolCallId: string;
-    };
-
-/**
- * Compact callback replay data. The start event establishes the tool name for
- * a call, so delta events do not repeat it and available events reuse the
- * parsed input already present in `toolCalls`.
- */
-export type ToolInputLifecycleEvent =
-  | ['start', toolCallId: string, toolName: string]
-  | ['delta', toolCallId: string, inputTextDelta: string]
-  | ['available', toolCallId: string];
-
-/**
- * Minimal aggregates needed to reconstruct a `StepResult` outside the step
- * boundary. By returning only these fields (instead of a fully-populated
- * StepResult plus the raw `chunks[]` array), the durable event log doesn't
- * carry StepResult's redundant derived fields — duplicate tool-call lists,
- * `text`, `files`, `sources`, `reasoningText`, or the tool-result arrays
- * populated after execution. It also avoids the per-chunk `chunks[]` snapshot
- * the iterator never reads. The caller reconstructs the full StepResult via
- * `buildStepResult`.
- */
-export interface DoStreamStepRawResult {
-  content: DoStreamStepRawContentPart[];
-  reasoning: Array<{
-    text: string;
-    providerMetadata?: SharedV4ProviderMetadata;
-  }>;
-  responseMetadata?: { id?: string; timestamp?: Date; modelId?: string };
-  warnings?: unknown[];
-}
-
-export type DoStreamStepResult =
-  | { aborted: true }
-  | {
-      aborted?: false;
-      toolCalls: ParsedToolCall[];
-      finish: StreamFinish | undefined;
-      raw: DoStreamStepRawResult;
-      providerExecutedToolResults: Map<string, ProviderExecutedToolResult>;
-      /**
-       * Optional for compatibility with model-step results persisted before
-       * tool input lifecycle callback replay was added.
-       */
-      toolInputLifecycleEvents?: ToolInputLifecycleEvent[];
-      /** Present when the model stream emitted an error part. */
-      terminalError?: unknown;
-    };
+import type {
+  ModelCallFinish as StreamFinish,
+  ModelCallOptions as DoStreamStepOptions,
+  ModelCallRawContentPart as DoStreamStepRawContentPart,
+  ModelCallResult as DoStreamStepResult,
+  ModelCallStreamPart,
+  ParsedToolCall,
+  ProviderExecutedToolResult,
+  ToolInputLifecycleEvent,
+} from './model-call.js';
+
+// Preserve existing imports while the durable step keeps its name and payload.
+export type {
+  ModelCallFinish as StreamFinish,
+  ModelCallOptions as DoStreamStepOptions,
+  ModelCallRawContentPart as DoStreamStepRawContentPart,
+  ModelCallRawResult as DoStreamStepRawResult,
+  ModelCallResult as DoStreamStepResult,
+  ModelCallStreamPart,
+  ModelStopCondition,
+  ParsedToolCall,
+  ProviderExecutedToolResult,
+  ToolInputLifecycleEvent,
+} from './model-call.js';
 
 export async function doStreamStep(
   conversationPrompt: LanguageModelV4Prompt,
@@ -277,7 +142,21 @@ export async function doStreamStep(
           // streamModelCall expects Prompt (ModelMessage[]) but we pass the
           // pre-converted LanguageModelV4Prompt. standardizePrompt inside
           // streamModelCall handles both formats.
-          messages: conversationPrompt as unknown as ModelMessage[],
+          messages: conversationPrompt.map(message =>
+            message.role !== 'tool'
+              ? message
+              : {
+                  ...message,
+                  // Provider prompt approval responses have already been filtered by
+                  // convertToLanguageModelPrompt. Restore the marker expected by the
+                  // model-call helper when it converts these messages again.
+                  content: message.content.map(part =>
+                    part.type === 'tool-approval-response'
+                      ? { ...part, providerExecuted: true }
+                      : part,
+                  ),
+                },
+          ) as unknown as ModelMessage[],
           allowSystemInMessages: true,
           tools,
           toolChoice: options?.toolChoice,
@@ -436,6 +315,13 @@ export async function doStreamStep(
         case 'source':
           content.push(part);
           break;
+        case 'tool-approval-request':
+          content.push({
+            type: 'tool-approval-request',
+            approvalId: part.approvalId,
+            toolCallId: part.toolCall.toolCallId,
+          });
+          break;
         case 'tool-call': {
           // parseToolCall adds dynamic/invalid/error at runtime
           const toolCallPart = part as typeof part & Partial<ParsedToolCall>;
@@ -595,10 +481,7 @@ function applyStreamTransforms({
   let stopped = false;
 
   const stopStream = () => {
-    if (stopped) {
-      return;
-    }
-
+    if (stopped) return;
     stopped = true;
     void sourceReader.cancel().catch(() => {});
   };
@@ -610,14 +493,11 @@ function applyStreamTransforms({
           controller.close();
           return;
         }
-
         const { done, value } = await sourceReader.read();
-
         if (done || stopped) {
           controller.close();
           return;
         }
-
         controller.enqueue(value);
       },
       cancel(reason) {
@@ -633,7 +513,6 @@ function applyStreamTransforms({
       transform({ tools, stopStream }),
     );
   }
-
   return transformedStream;
 }
 
@@ -696,7 +575,6 @@ function upsertReasoningContentPart({
   providerMetadata?: SharedV4ProviderMetadata;
 }) {
   let partIndex = reasoningPartIndexes.get(id);
-
   if (partIndex == null) {
     partIndex =
       reasoningParts.push({
@@ -706,14 +584,7 @@ function upsertReasoningContentPart({
     reasoningPartIndexes.set(id, partIndex);
     content.push({ type: 'reasoning', reasoningIndex: partIndex });
   }
-
   const part = reasoningParts[partIndex];
-
-  if (textDelta != null) {
-    part.text += textDelta;
-  }
-
-  if (providerMetadata != null) {
-    part.providerMetadata = providerMetadata;
-  }
+  if (textDelta != null) part.text += textDelta;
+  if (providerMetadata != null) part.providerMetadata = providerMetadata;
 }

package/src/index.ts

@@ -5,6 +5,9 @@ export {
   type DownloadFunction,
   type WorkflowAgentOptions,
   type WorkflowAgentStreamOptions,
+  type WorkflowAgentCallOptions,
+  type WorkflowAgentGenerateOptions,
+  type WorkflowAgentGenerateResult,
   type WorkflowAgentStreamResult,
   type WorkflowToolApprovalSecret,
   type GenerationSettings,