@ai-sdk/workflow 1.0.66 → 1.0.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "1.0.66",
+  "version": "1.0.68",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "ajv": "^8.20.0",
-    "@ai-sdk/provider": "4.0.7",
     "@ai-sdk/provider-utils": "5.0.27",
-    "ai": "7.0.66"
+    "@ai-sdk/provider": "4.0.7",
+    "ai": "7.0.67"
   },
   "devDependencies": {
     "@types/node": "22.19.19",

package/src/do-stream-step.ts

@@ -2,6 +2,7 @@ import type {
   LanguageModelV4CallOptions,
   LanguageModelV4Prompt,
 } from '@ai-sdk/provider';
+import { isAbortError } from '@ai-sdk/provider-utils';
 import {
   experimental_streamLanguageModelCall as streamModelCall,
   gateway,
@@ -15,6 +16,7 @@ import {
   type ToolChoice,
   type ToolSet,
 } from 'ai';
+import { prepareRetries } from 'ai/internal';
 import type { ProviderOptions } from './workflow-agent.js';
 import {
   resolveSerializableTools,
@@ -48,6 +50,7 @@ export interface DoStreamStepOptions {
   seed?: number;
   maxRetries?: number;
   abortSignal?: AbortSignal;
+  timeoutAt?: number;
   headers?: Record<string, string | undefined>;
   reasoning?: LanguageModelV4CallOptions['reasoning'];
   providerOptions?: ProviderOptions;
@@ -99,20 +102,44 @@ export interface DoStreamStepRawResult {
   warnings?: unknown[];
 }
 
+export type DoStreamStepResult =
+  | { aborted: true }
+  | {
+      aborted?: false;
+      toolCalls: ParsedToolCall[];
+      finish: StreamFinish | undefined;
+      raw: DoStreamStepRawResult;
+      providerExecutedToolResults: Map<string, ProviderExecutedToolResult>;
+      /** Present when the model stream emitted an error part. */
+      terminalError?: unknown;
+    };
+
 export async function doStreamStep(
   conversationPrompt: LanguageModelV4Prompt,
   modelInit: LanguageModel,
   writable?: WritableStream<ModelCallStreamPart<ToolSet>>,
   serializedTools?: Record<string, SerializableToolDef>,
   options?: DoStreamStepOptions,
-): Promise<{
-  toolCalls: ParsedToolCall[];
-  finish: StreamFinish | undefined;
-  raw: DoStreamStepRawResult;
-  providerExecutedToolResults: Map<string, ProviderExecutedToolResult>;
-}> {
+): Promise<DoStreamStepResult> {
   'use step';
 
+  const timeout =
+    options?.timeoutAt == null ? undefined : options.timeoutAt - Date.now();
+
+  // AbortSignal.timeout(0) does not abort synchronously. Check the deadline
+  // explicitly so an expired call never reaches the model, including when a
+  // durable step is retried after the original timeout has elapsed.
+  if (options?.abortSignal?.aborted || (timeout != null && timeout <= 0)) {
+    return { aborted: true };
+  }
+
+  const abortSignal =
+    timeout == null
+      ? options?.abortSignal
+      : options?.abortSignal == null
+        ? AbortSignal.timeout(timeout)
+        : AbortSignal.any([options.abortSignal, AbortSignal.timeout(timeout)]);
+
   // Resolve model inside step (must happen here for serialization boundary)
   const model: LanguageModel =
     typeof modelInit === 'string'
@@ -148,34 +175,56 @@ export async function doStreamStep(
           },
         };
 
-  // streamModelCall handles: prompt standardization, tool preparation,
-  // model.doStream(), retry logic, and stream part transformation
-  // (tool call parsing, finish reason mapping, file wrapping).
-  const { stream: modelStream } = await streamModelCall({
-    model,
-    // streamModelCall expects Prompt (ModelMessage[]) but we pass the
-    // pre-converted LanguageModelV4Prompt. standardizePrompt inside
-    // streamModelCall handles both formats.
-    messages: conversationPrompt as unknown as ModelMessage[],
-    allowSystemInMessages: true,
-    tools,
-    toolChoice: options?.toolChoice,
-    includeRawChunks: options?.includeRawChunks,
-    providerOptions: options?.providerOptions,
-    abortSignal: options?.abortSignal,
-    headers: options?.headers,
-    reasoning: options?.reasoning,
-    output,
-    maxOutputTokens: options?.maxOutputTokens,
-    temperature: options?.temperature,
-    topP: options?.topP,
-    topK: options?.topK,
-    presencePenalty: options?.presencePenalty,
-    frequencyPenalty: options?.frequencyPenalty,
-    stopSequences: options?.stopSequences,
-    seed: options?.seed,
-    repairToolCall: options?.repairToolCall,
+  // streamModelCall handles prompt standardization, tool preparation,
+  // model.doStream(), and stream part transformation. Retries are applied
+  // around the model dispatch because streamModelCall itself does not retry.
+  const { retry } = prepareRetries({
+    maxRetries: options?.maxRetries,
+    abortSignal,
   });
+  const modelStream = await (async () => {
+    try {
+      const { stream } = await retry(() =>
+        streamModelCall({
+          model,
+          // streamModelCall expects Prompt (ModelMessage[]) but we pass the
+          // pre-converted LanguageModelV4Prompt. standardizePrompt inside
+          // streamModelCall handles both formats.
+          messages: conversationPrompt as unknown as ModelMessage[],
+          allowSystemInMessages: true,
+          tools,
+          toolChoice: options?.toolChoice,
+          includeRawChunks: options?.includeRawChunks,
+          providerOptions: options?.providerOptions,
+          abortSignal,
+          headers: options?.headers,
+          reasoning: options?.reasoning,
+          output,
+          maxOutputTokens: options?.maxOutputTokens,
+          temperature: options?.temperature,
+          topP: options?.topP,
+          topK: options?.topK,
+          presencePenalty: options?.presencePenalty,
+          frequencyPenalty: options?.frequencyPenalty,
+          stopSequences: options?.stopSequences,
+          seed: options?.seed,
+          repairToolCall: options?.repairToolCall,
+        }),
+      );
+
+      return stream;
+    } catch (error) {
+      if (abortSignal?.aborted && isAbortError(error)) {
+        return undefined;
+      }
+
+      throw error;
+    }
+  })();
+
+  if (modelStream == null) {
+    return { aborted: true };
+  }
 
   // Consume the stream: capture data and write to writable in real-time
   const toolCalls: ParsedToolCall[] = [];
@@ -192,6 +241,8 @@ export async function doStreamStep(
     | { id?: string; timestamp?: Date; modelId?: string }
     | undefined;
   let warnings: unknown[] | undefined;
+  let terminalError: unknown;
+  let hasTerminalError = false;
 
   // Acquire writer once before the loop to avoid per-chunk lock overhead
   const writer = writable?.getWriter();
@@ -269,11 +320,33 @@ export async function doStreamStep(
       if (writer) {
         await writer.write(part);
       }
+
+      if (part.type === 'error' && !hasTerminalError) {
+        // Retain the first model error as step data. Throwing here would make
+        // the durable workflow runtime retry the model step and normalize the
+        // original value before WorkflowAgent can surface it. Continue
+        // consuming so the existing finish reason and usage are preserved.
+        terminalError = part.error;
+        hasTerminalError = true;
+      }
+    }
+  } catch (error) {
+    if (abortSignal?.aborted && isAbortError(error)) {
+      return { aborted: true };
     }
+
+    throw error;
   } finally {
     writer?.releaseLock();
   }
 
+  if (
+    abortSignal?.aborted ||
+    (options?.timeoutAt != null && options.timeoutAt <= Date.now())
+  ) {
+    return { aborted: true };
+  }
+
   return {
     toolCalls,
     finish,
@@ -284,5 +357,10 @@ export async function doStreamStep(
       warnings,
     },
     providerExecutedToolResults,
+    ...(hasTerminalError ? { terminalError } : {}),
   };
 }
+
+// Model-call retries are handled above so the workflow runtime must not add
+// another retry layer around the durable step.
+doStreamStep.maxRetries = 0;

package/src/providers/mock-function-wrapper.ts

@@ -1,11 +1,108 @@
-import { MockLanguageModelV4 } from 'ai/test';
+import {
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE,
+} from '@ai-sdk/provider-utils';
+import { convertArrayToReadableStream, MockLanguageModelV4 } from 'ai/test';
+import type { MockResponseDescriptor } from './mock.js';
+
+type MockStreamOptions = Parameters<MockLanguageModelV4['doStream']>[0];
+type MockStreamResult = Awaited<ReturnType<MockLanguageModelV4['doStream']>>;
+type MockStreamPart = MockStreamResult extends {
+  stream: ReadableStream<infer PART>;
+}
+  ? PART
+  : never;
+
+const usage = {
+  inputTokens: {
+    total: 5,
+    noCache: 5,
+    cacheRead: undefined,
+    cacheWrite: undefined,
+  },
+  outputTokens: { total: 10, text: 10, reasoning: undefined },
+};
+
+class SerializableMockLanguageModel extends MockLanguageModelV4 {
+  static [WORKFLOW_SERIALIZE](model: SerializableMockLanguageModel) {
+    return { responses: model.responses };
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    responses: MockResponseDescriptor[];
+  }) {
+    return new SerializableMockLanguageModel(options.responses);
+  }
+
+  constructor(private readonly responses: MockResponseDescriptor[]) {
+    super({
+      provider: 'workflow-test',
+      modelId: 'workflow-test-model',
+      doStream: async (options: MockStreamOptions) => {
+        const responseIndex = Math.min(
+          options.prompt.filter(message => message.role === 'assistant').length,
+          responses.length - 1,
+        );
+        const response = responses[responseIndex];
+        const prefix: MockStreamPart[] = [
+          { type: 'stream-start', warnings: [] },
+          {
+            type: 'response-metadata',
+            id: 'r',
+            modelId: 'mock',
+            timestamp: new Date(),
+          },
+        ];
+        const streamParts: MockStreamPart[] =
+          response.type === 'text'
+            ? [
+                ...prefix,
+                { type: 'text-start', id: '1' },
+                { type: 'text-delta', id: '1', delta: response.text },
+                { type: 'text-end', id: '1' },
+                {
+                  type: 'finish',
+                  finishReason: { unified: 'stop', raw: 'stop' },
+                  usage,
+                },
+              ]
+            : response.type === 'tool-call'
+              ? [
+                  ...prefix,
+                  {
+                    type: 'tool-call',
+                    toolCallId: `call-${responseIndex + 1}`,
+                    toolName: response.toolName,
+                    input: response.input,
+                  },
+                  {
+                    type: 'finish',
+                    finishReason: { unified: 'tool-calls', raw: undefined },
+                    usage,
+                  },
+                ]
+              : [
+                  ...prefix,
+                  { type: 'error', error: response.error },
+                  {
+                    type: 'finish',
+                    finishReason: { unified: 'error', raw: 'error' },
+                    usage,
+                  },
+                ];
+
+        return { stream: convertArrayToReadableStream(streamParts) };
+      },
+    });
+  }
+}
 
 // Workaround for SWC plugin bug (https://github.com/vercel/workflow/issues/1365):
 // `new ClassName(...)` in a step closure doesn't get closure vars hoisted
 // correctly. Wrapping the constructor call in a plain function (imported
 // from a separate file) fixes it.
 export function mockProvider(
-  ...args: ConstructorParameters<typeof MockLanguageModelV4>
-) {
-  return new MockLanguageModelV4(...args);
+  responses: MockResponseDescriptor[],
+): MockLanguageModelV4 {
+  return new SerializableMockLanguageModel(responses);
 }

package/src/providers/mock.ts

@@ -2,42 +2,14 @@ import { mockProvider } from './mock-function-wrapper.js';
 
 export type MockResponseDescriptor =
   | { type: 'text'; text: string }
-  | { type: 'tool-call'; toolName: string; input: string };
+  | { type: 'tool-call'; toolName: string; input: string }
+  | { type: 'error'; error: unknown };
 
 /**
  * Mock model that returns a fixed text response.
  */
 export function mockTextModel(text: string) {
-  return mockProvider({
-    doStream: async () => ({
-      stream: new ReadableStream({
-        start(c) {
-          for (const v of [
-            { type: 'stream-start', warnings: [] },
-            {
-              type: 'response-metadata',
-              id: 'r',
-              modelId: 'mock',
-              timestamp: new Date(),
-            },
-            { type: 'text-start', id: '1' },
-            { type: 'text-delta', id: '1', delta: text },
-            { type: 'text-end', id: '1' },
-            {
-              type: 'finish',
-              finishReason: { unified: 'stop', raw: 'stop' },
-              usage: {
-                inputTokens: { total: 5, noCache: 5 },
-                outputTokens: { total: 10, text: 10 },
-              },
-            },
-          ] as any[])
-            c.enqueue(v);
-          c.close();
-        },
-      }),
-    }),
-  });
+  return mockProvider([{ type: 'text', text }]);
 }
 
 /**
@@ -45,66 +17,5 @@ export function mockTextModel(text: string) {
  * Determines which response to return by counting assistant messages in the prompt.
  */
 export function mockSequenceModel(responses: MockResponseDescriptor[]) {
-  return mockProvider({
-    doStream: async (options: any) => {
-      const responseIndex = Math.min(
-        options.prompt.filter((m: any) => m.role === 'assistant').length,
-        responses.length - 1,
-      );
-      const selectedResponse = responses[responseIndex];
-      const parts =
-        selectedResponse.type === 'text'
-          ? [
-              { type: 'stream-start', warnings: [] },
-              {
-                type: 'response-metadata',
-                id: 'r',
-                modelId: 'mock',
-                timestamp: new Date(),
-              },
-              { type: 'text-start', id: '1' },
-              { type: 'text-delta', id: '1', delta: selectedResponse.text },
-              { type: 'text-end', id: '1' },
-              {
-                type: 'finish',
-                finishReason: { unified: 'stop', raw: 'stop' },
-                usage: {
-                  inputTokens: { total: 5, noCache: 5 },
-                  outputTokens: { total: 10, text: 10 },
-                },
-              },
-            ]
-          : [
-              { type: 'stream-start', warnings: [] },
-              {
-                type: 'response-metadata',
-                id: 'r',
-                modelId: 'mock',
-                timestamp: new Date(),
-              },
-              {
-                type: 'tool-call',
-                toolCallId: `call-${responseIndex + 1}`,
-                toolName: selectedResponse.toolName,
-                input: selectedResponse.input,
-              },
-              {
-                type: 'finish',
-                finishReason: { unified: 'tool-calls', raw: undefined },
-                usage: {
-                  inputTokens: { total: 5, noCache: 5 },
-                  outputTokens: { total: 10, text: 10 },
-                },
-              },
-            ];
-      return {
-        stream: new ReadableStream({
-          start(c) {
-            for (const streamPart of parts as any[]) c.enqueue(streamPart);
-            c.close();
-          },
-        }),
-      };
-    },
-  });
+  return mockProvider(responses);
 }

package/src/stream-text-iterator.ts

@@ -92,6 +92,16 @@ export interface StreamTextIteratorYieldValue {
   experimental_sandbox?: SandboxSession;
 }
 
+export interface StreamTextIteratorAbortedValue {
+  aborted: true;
+  messages: LanguageModelV4Prompt;
+}
+
+export interface StreamTextIteratorErrorValue {
+  error: unknown;
+  messages: LanguageModelV4Prompt;
+}
+
 // This runs in the workflow context
 export async function* streamTextIterator({
   prompt,
@@ -112,6 +122,7 @@ export async function* streamTextIterator({
   toolsContext,
   telemetry,
   includeRawChunks = false,
+  timeoutAt,
   repairToolCall,
   responseFormat,
   experimental_sandbox: sandbox,
@@ -135,12 +146,15 @@ export async function* streamTextIterator({
   toolsContext?: Record<string, Context | undefined>;
   telemetry?: TelemetryOptions<Context, ToolSet>;
   includeRawChunks?: boolean;
+  timeoutAt?: number;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
   responseFormat?: LanguageModelV4CallOptions['responseFormat'];
   experimental_sandbox?: SandboxSession;
 }): AsyncGenerator<
   StreamTextIteratorYieldValue,
-  LanguageModelV4Prompt,
+  | LanguageModelV4Prompt
+  | StreamTextIteratorAbortedValue
+  | StreamTextIteratorErrorValue,
   LanguageModelV4ToolResultPart[]
 > {
   let conversationPrompt = [...prompt]; // Create a mutable copy
@@ -158,6 +172,9 @@ export async function* streamTextIterator({
   let stepNumber = 0;
   let lastStep: StepResult<any, any> | undefined;
   let lastStepWasToolCalls = false;
+  let wasAborted = false;
+  let terminalError: unknown;
+  let hasTerminalError = false;
 
   // TODO(#12164): replace this AI-core telemetry bridge with a
   // WorkflowAgent-specific typed dispatcher. `streamTextIterator` widens
@@ -319,20 +336,33 @@ export async function* streamTextIterator({
         headers: currentGenerationSettings.headers,
       } as never);
 
+      const streamStepResult = await doStreamStep(
+        conversationPrompt,
+        currentModel,
+        writable,
+        serializedTools,
+        {
+          ...currentGenerationSettings,
+          toolChoice: currentToolChoice,
+          includeRawChunks,
+          timeoutAt,
+          repairToolCall,
+          responseFormat,
+        },
+      );
+
+      if (streamStepResult.aborted) {
+        wasAborted = true;
+        break;
+      }
+
+      if ('terminalError' in streamStepResult) {
+        terminalError = streamStepResult.terminalError;
+        hasTerminalError = true;
+      }
+
       const { toolCalls, finish, raw, providerExecutedToolResults } =
-        await doStreamStep(
-          conversationPrompt,
-          currentModel,
-          writable,
-          serializedTools,
-          {
-            ...currentGenerationSettings,
-            toolChoice: currentToolChoice,
-            includeRawChunks,
-            repairToolCall,
-            responseFormat,
-          },
-        );
+        streamStepResult;
       // 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).
@@ -363,7 +393,12 @@ export async function* streamTextIterator({
 
       const finishReason = finish?.finishReason;
 
-      if (finishReason === 'tool-calls') {
+      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;
 
         const textContent = step.content.filter(
@@ -488,6 +523,14 @@ export async function* streamTextIterator({
     };
   }
 
+  if (wasAborted) {
+    return { aborted: true, messages: conversationPrompt };
+  }
+
+  if (hasTerminalError) {
+    return { error: terminalError, messages: conversationPrompt };
+  }
+
   return conversationPrompt;
 }
 

package/src/test/agent-e2e-workflows.ts

@@ -4,6 +4,7 @@
 import { tool } from 'ai';
 import { WorkflowAgent } from '../workflow-agent.js';
 import { mockTextModel, mockSequenceModel } from '../providers/mock.js';
+import { retryingModel } from './retrying-model.js';
 import { createTestSandbox } from './test-sandbox.js';
 import { FatalError, getWritable } from 'workflow';
 import { z } from 'zod/v4';
@@ -47,6 +48,46 @@ export async function agentBasicE2e(prompt: string) {
   };
 }
 
+export async function agentModelRetriesE2e() {
+  'use workflow';
+  const agent = new WorkflowAgent({
+    model: retryingModel(),
+    maxRetries: 2,
+  });
+  const result = await agent.stream({
+    messages: [{ role: 'user', content: 'retry the model call' }],
+    writable: getWritable(),
+  });
+  return result.steps.at(-1)?.text;
+}
+
+export async function agentStreamErrorE2e() {
+  'use workflow';
+  const terminal = {
+    type: 'credential',
+    code: 'safe-terminal-classification',
+  };
+  const callbackErrors: unknown[] = [];
+  const agent = new WorkflowAgent({
+    model: mockSequenceModel([{ type: 'error', error: terminal }]),
+  });
+
+  const result = await agent.stream({
+    messages: [{ role: 'user', content: 'trigger the terminal error' }],
+    writable: getWritable(),
+    onError: async ({ error }) => {
+      callbackErrors.push(error);
+    },
+  });
+
+  return {
+    error: result.error,
+    finishReason: result.finishReason,
+    stepCount: result.steps.length,
+    callbackErrors,
+  };
+}
+
 export async function agentToolCallE2e(a: number, b: number) {
   'use workflow';
   const agent = new WorkflowAgent({