@ai-sdk/workflow 1.0.66 → 1.0.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "1.0.66",
+  "version": "1.0.67",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",

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,
@@ -48,6 +49,7 @@ export interface DoStreamStepOptions {
   seed?: number;
   maxRetries?: number;
   abortSignal?: AbortSignal;
+  timeoutAt?: number;
   headers?: Record<string, string | undefined>;
   reasoning?: LanguageModelV4CallOptions['reasoning'];
   providerOptions?: ProviderOptions;
@@ -99,20 +101,42 @@ export interface DoStreamStepRawResult {
   warnings?: unknown[];
 }
 
+export type DoStreamStepResult =
+  | { aborted: true }
+  | {
+      aborted?: false;
+      toolCalls: ParsedToolCall[];
+      finish: StreamFinish | undefined;
+      raw: DoStreamStepRawResult;
+      providerExecutedToolResults: Map<string, ProviderExecutedToolResult>;
+    };
+
 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'
@@ -151,7 +175,7 @@ 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({
+  const modelStream = await streamModelCall({
     model,
     // streamModelCall expects Prompt (ModelMessage[]) but we pass the
     // pre-converted LanguageModelV4Prompt. standardizePrompt inside
@@ -162,7 +186,7 @@ export async function doStreamStep(
     toolChoice: options?.toolChoice,
     includeRawChunks: options?.includeRawChunks,
     providerOptions: options?.providerOptions,
-    abortSignal: options?.abortSignal,
+    abortSignal,
     headers: options?.headers,
     reasoning: options?.reasoning,
     output,
@@ -175,7 +199,19 @@ export async function doStreamStep(
     stopSequences: options?.stopSequences,
     seed: options?.seed,
     repairToolCall: options?.repairToolCall,
-  });
+  })
+    .then(result => result.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[] = [];
@@ -270,10 +306,23 @@ export async function doStreamStep(
         await writer.write(part);
       }
     }
+  } 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,

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

@@ -1,11 +1,98 @@
-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,
+                },
+              ]
+            : [
+                ...prefix,
+                {
+                  type: 'tool-call',
+                  toolCallId: `call-${responseIndex + 1}`,
+                  toolName: response.toolName,
+                  input: response.input,
+                },
+                {
+                  type: 'finish',
+                  finishReason: { unified: 'tool-calls', raw: undefined },
+                  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

@@ -8,36 +8,7 @@ export type MockResponseDescriptor =
  * 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 +16,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,11 @@ export interface StreamTextIteratorYieldValue {
   experimental_sandbox?: SandboxSession;
 }
 
+export interface StreamTextIteratorAbortedValue {
+  aborted: true;
+  messages: LanguageModelV4Prompt;
+}
+
 // This runs in the workflow context
 export async function* streamTextIterator({
   prompt,
@@ -112,6 +117,7 @@ export async function* streamTextIterator({
   toolsContext,
   telemetry,
   includeRawChunks = false,
+  timeoutAt,
   repairToolCall,
   responseFormat,
   experimental_sandbox: sandbox,
@@ -135,12 +141,13 @@ 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,
   LanguageModelV4ToolResultPart[]
 > {
   let conversationPrompt = [...prompt]; // Create a mutable copy
@@ -158,6 +165,7 @@ export async function* streamTextIterator({
   let stepNumber = 0;
   let lastStep: StepResult<any, any> | undefined;
   let lastStepWasToolCalls = false;
+  let wasAborted = false;
 
   // TODO(#12164): replace this AI-core telemetry bridge with a
   // WorkflowAgent-specific typed dispatcher. `streamTextIterator` widens
@@ -319,20 +327,28 @@ 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;
+      }
+
       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).
@@ -488,6 +504,10 @@ export async function* streamTextIterator({
     };
   }
 
+  if (wasAborted) {
+    return { aborted: true, messages: conversationPrompt };
+  }
+
   return conversationPrompt;
 }
 

package/src/workflow-agent.ts

@@ -7,6 +7,7 @@ import type {
 } from '@ai-sdk/provider';
 import {
   getErrorMessage,
+  isAbortError,
   validateTypes,
   withUserAgentSuffix,
   type Context,
@@ -39,7 +40,6 @@ import {
   createRestrictedTelemetryDispatcher,
   collectToolApprovals,
   convertToLanguageModelPrompt,
-  mergeAbortSignals,
   mergeCallbacks,
   standardizePrompt,
   validateApprovedToolApprovals,
@@ -1788,10 +1788,10 @@ export class WorkflowAgent<
       download,
     });
 
-    const effectiveAbortSignal = mergeAbortSignals(
-      options.abortSignal ?? effectiveGenerationSettings.abortSignal,
-      options.timeout,
-    );
+    const effectiveAbortSignal =
+      options.abortSignal ?? effectiveGenerationSettings.abortSignal;
+    const timeoutAt =
+      options.timeout == null ? undefined : Date.now() + options.timeout;
 
     // Merge generation settings: constructor defaults < prepareCall < stream options
     const mergedGenerationSettings: GenerationSettings = {
@@ -2157,6 +2157,7 @@ export class WorkflowAgent<
       toolsContext,
       telemetry: effectiveTelemetry,
       includeRawChunks: options.includeRawChunks ?? false,
+      timeoutAt,
       repairToolCall: (options.repairToolCall ??
         options.experimental_repairToolCall ??
         this.repairToolCall) as ToolCallRepairFunction<ToolSet> | undefined,
@@ -2519,14 +2520,24 @@ export class WorkflowAgent<
         }
       }
 
-      // When the iterator completes normally, result.value contains the final conversation prompt
+      // When the iterator completes normally, result.value contains the final
+      // conversation prompt. Aborts inside the retryable model step are
+      // returned as data so the workflow runtime does not retry them.
       if (result.done) {
-        finalMessages = result.value;
+        if (Array.isArray(result.value)) {
+          finalMessages = result.value;
+        } else {
+          finalMessages = result.value.messages;
+          wasAborted = true;
+          if (options.onAbort) {
+            await options.onAbort({ steps });
+          }
+        }
       }
     } catch (error) {
       encounteredError = error;
       // Check if this is an abort error
-      if (error instanceof Error && error.name === 'AbortError') {
+      if (isAbortError(error)) {
         wasAborted = true;
         if (options.onAbort) {
           await options.onAbort({ steps });