@ai-sdk/workflow 1.0.0-beta.0 → 1.0.0-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.10",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
@@ -29,7 +29,7 @@
     "ajv": "^8.18.0",
     "@ai-sdk/provider": "4.0.0-beta.12",
     "@ai-sdk/provider-utils": "5.0.0-beta.20",
-    "ai": "7.0.0-beta.89"
+    "ai": "7.0.0-beta.96"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/do-stream-step.ts

@@ -21,7 +21,6 @@ import {
   resolveSerializableTools,
   type SerializableToolDef,
 } from './serializable-schema.js';
-import type { CompatibleLanguageModel } from './types.js';
 
 export type { Experimental_LanguageModelStreamPart as ModelCallStreamPart } from 'ai';
 
@@ -87,10 +86,7 @@ export interface StreamFinish {
 
 export async function doStreamStep(
   conversationPrompt: LanguageModelV4Prompt,
-  modelInit:
-    | string
-    | CompatibleLanguageModel
-    | (() => Promise<CompatibleLanguageModel>),
+  modelInit: LanguageModel,
   writable?: WritableStream<ModelCallStreamPart<ToolSet>>,
   serializedTools?: Record<string, SerializableToolDef>,
   options?: DoStreamStepOptions,
@@ -98,22 +94,10 @@ export async function doStreamStep(
   'use step';
 
   // Resolve model inside step (must happen here for serialization boundary)
-  let model: CompatibleLanguageModel;
-  if (typeof modelInit === 'string') {
-    model = gateway.languageModel(modelInit) as CompatibleLanguageModel;
-  } else if (typeof modelInit === 'function') {
-    model = await modelInit();
-  } else if (
-    typeof modelInit === 'object' &&
-    modelInit !== null &&
-    'modelId' in modelInit
-  ) {
-    model = modelInit;
-  } else {
-    throw new Error(
-      'Invalid "model initialization" argument. Must be a string, a LanguageModel instance, or a function that returns a LanguageModel instance.',
-    );
-  }
+  const model: LanguageModel =
+    typeof modelInit === 'string'
+      ? gateway.languageModel(modelInit)
+      : modelInit;
 
   // Reconstruct tools from serializable definitions with Ajv validation.
   // Tools are serialized before crossing the step boundary because zod schemas
@@ -126,7 +110,7 @@ export async function doStreamStep(
   // model.doStream(), retry logic, and stream part transformation
   // (tool call parsing, finish reason mapping, file wrapping).
   const { stream: modelStream } = await streamModelCall({
-    model: model as LanguageModel,
+    model,
     // streamModelCall expects Prompt (ModelMessage[]) but we pass the
     // pre-converted LanguageModelV4Prompt. standardizePrompt inside
     // streamModelCall handles both formats.

package/src/index.ts

@@ -17,9 +17,10 @@ export {
   type PrepareStepInfo,
   type PrepareStepResult,
   type ProviderOptions,
-  type StreamTextOnAbortCallback,
-  type StreamTextOnErrorCallback,
-  type StreamTextOnFinishCallback,
+  type WorkflowAgentOnAbortCallback,
+  type WorkflowAgentOnErrorCallback,
+  type WorkflowAgentOnFinishCallback,
+  type WorkflowAgentOnStepFinishCallback,
   type StreamTextTransform,
   type TelemetrySettings,
   type ToolCallRepairFunction,

package/src/providers/mock.ts

@@ -6,19 +6,55 @@ export type MockResponseDescriptor =
 
 /**
  * Mock model that returns a fixed text response.
- * Same 'use step' pattern as real providers (anthropic, openai, etc.).
- * Only captures `text` (string) — fully serializable across step boundary.
  */
 export function mockTextModel(text: string) {
-  return async () => {
-    'use step';
-    // Bind closure var at step body level so SWC plugin detects it
-    const _text = text;
-    return mockProvider({
-      doStream: async () => ({
-        stream: new ReadableStream({
-          start(c) {
-            for (const v of [
+  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();
+        },
+      }),
+    }),
+  });
+}
+
+/**
+ * Mock model that plays through a sequence of responses.
+ * Determines which response to return by counting assistant messages in the prompt.
+ */
+export function mockSequenceModel(responses: MockResponseDescriptor[]) {
+  return mockProvider({
+    doStream: async (options: any) => {
+      const idx = Math.min(
+        options.prompt.filter((m: any) => m.role === 'assistant').length,
+        responses.length - 1,
+      );
+      const r = responses[idx];
+      const parts =
+        r.type === 'text'
+          ? [
               { type: 'stream-start', warnings: [] },
               {
                 type: 'response-metadata',
@@ -27,7 +63,7 @@ export function mockTextModel(text: string) {
                 timestamp: new Date(),
               },
               { type: 'text-start', id: '1' },
-              { type: 'text-delta', id: '1', delta: _text },
+              { type: 'text-delta', id: '1', delta: r.text },
               { type: 'text-end', id: '1' },
               {
                 type: 'finish',
@@ -37,87 +73,38 @@ export function mockTextModel(text: string) {
                   outputTokens: { total: 10, text: 10 },
                 },
               },
-            ] as any[])
-              c.enqueue(v);
+            ]
+          : [
+              { type: 'stream-start', warnings: [] },
+              {
+                type: 'response-metadata',
+                id: 'r',
+                modelId: 'mock',
+                timestamp: new Date(),
+              },
+              {
+                type: 'tool-call',
+                toolCallId: `call-${idx + 1}`,
+                toolName: r.toolName,
+                input: r.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 p of parts as any[]) c.enqueue(p);
             c.close();
           },
         }),
-      }),
-    });
-  };
-}
-
-/**
- * Mock model that plays through a sequence of responses.
- * Determines which response to return by counting assistant messages in the prompt.
- * Only captures `responses` (array of plain objects) — fully serializable.
- */
-export function mockSequenceModel(responses: MockResponseDescriptor[]) {
-  return async () => {
-    'use step';
-    // Bind closure var at step body level so SWC plugin detects it
-    const _responses = responses;
-    return mockProvider({
-      doStream: async (options: any) => {
-        const idx = Math.min(
-          options.prompt.filter((m: any) => m.role === 'assistant').length,
-          _responses.length - 1,
-        );
-        const r = _responses[idx];
-        const parts =
-          r.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: r.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-${idx + 1}`,
-                  toolName: r.toolName,
-                  input: r.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 p of parts as any[]) c.enqueue(p);
-              c.close();
-            },
-          }),
-        };
-      },
-    });
-  };
+      };
+    },
+  });
 }

package/src/stream-text-iterator.ts

@@ -5,9 +5,9 @@ import type {
 } from '@ai-sdk/provider';
 import type {
   Experimental_LanguageModelStreamPart as ModelCallStreamPart,
+  LanguageModel,
   ModelMessage,
   StepResult,
-  StreamTextOnStepFinishCallback,
   ToolCallRepairFunction,
   ToolChoice,
   ToolSet,
@@ -22,11 +22,11 @@ import { serializeToolSet } from './serializable-schema.js';
 import type {
   GenerationSettings,
   PrepareStepCallback,
-  StreamTextOnErrorCallback,
+  WorkflowAgentOnErrorCallback,
+  WorkflowAgentOnStepFinishCallback,
   TelemetrySettings,
   WorkflowAgentOnStepStartCallback,
 } from './workflow-agent.js';
-import type { CompatibleLanguageModel } from './types.js';
 
 // Re-export for consumers
 export type { ProviderExecutedToolResult } from './do-stream-step.js';
@@ -71,15 +71,12 @@ export async function* streamTextIterator({
   prompt: LanguageModelV4Prompt;
   tools: ToolSet;
   writable?: WritableStream<ModelCallStreamPart<ToolSet>>;
-  model:
-    | string
-    | CompatibleLanguageModel
-    | (() => Promise<CompatibleLanguageModel>);
+  model: LanguageModel;
   stopConditions?: ModelStopCondition[] | ModelStopCondition;
   maxSteps?: number;
-  onStepFinish?: StreamTextOnStepFinishCallback<any, any>;
+  onStepFinish?: WorkflowAgentOnStepFinishCallback<any>;
   onStepStart?: WorkflowAgentOnStepStartCallback;
-  onError?: StreamTextOnErrorCallback;
+  onError?: WorkflowAgentOnErrorCallback;
   prepareStep?: PrepareStepCallback<any>;
   generationSettings?: GenerationSettings;
   toolChoice?: ToolChoice<ToolSet>;
@@ -94,10 +91,7 @@ export async function* streamTextIterator({
   LanguageModelV4ToolResultPart[]
 > {
   let conversationPrompt = [...prompt]; // Create a mutable copy
-  let currentModel:
-    | string
-    | CompatibleLanguageModel
-    | (() => Promise<CompatibleLanguageModel>) = model;
+  let currentModel: LanguageModel = model;
   let currentGenerationSettings = generationSettings ?? {};
   let currentToolChoice = toolChoice;
   let currentContext = experimental_context;
@@ -248,6 +242,7 @@ export async function* streamTextIterator({
         stepNumber,
         model: currentModel,
         messages: conversationPrompt as unknown as ModelMessage[],
+        steps: [...steps],
       });
     }