@ai-sdk/workflow 1.0.0-beta.2 → 1.0.0-beta.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.21",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
@@ -28,8 +28,8 @@
   "dependencies": {
     "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.91"
+    "@ai-sdk/provider-utils": "5.0.0-beta.22",
+    "ai": "7.0.0-beta.106"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/do-stream-step.ts

@@ -16,12 +16,11 @@ import {
   type ToolSet,
 } from 'ai';
 import { gateway } from 'ai';
-import type { ProviderOptions, TelemetrySettings } from './workflow-agent.js';
+import type { ProviderOptions, TelemetryOptions } from './workflow-agent.js';
 import {
   resolveSerializableTools,
   type SerializableToolDef,
 } from './serializable-schema.js';
-import type { CompatibleLanguageModel } from './types.js';
 
 export type { Experimental_LanguageModelStreamPart as ModelCallStreamPart } from 'ai';
 
@@ -55,7 +54,7 @@ export interface DoStreamStepOptions {
   providerOptions?: ProviderOptions;
   toolChoice?: ToolChoice<ToolSet>;
   includeRawChunks?: boolean;
-  experimental_telemetry?: TelemetrySettings;
+  experimental_telemetry?: TelemetryOptions;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
   responseFormat?: LanguageModelV4CallOptions['responseFormat'];
 }
@@ -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.
@@ -257,7 +241,8 @@ export async function doStreamStep(
     },
     functionId: undefined,
     metadata: undefined,
-    context: undefined,
+    runtimeContext: undefined,
+    toolsContext: {},
     content: [
       ...(text ? [{ type: 'text' as const, text }] : []),
       ...toolCalls

package/src/index.ts

@@ -17,11 +17,12 @@ 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 TelemetryOptions,
   type ToolCallRepairFunction,
   type WorkflowAgentOnStartCallback,
   type WorkflowAgentOnStepStartCallback,

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

@@ -3,14 +3,15 @@ import type {
   LanguageModelV4Prompt,
   LanguageModelV4ToolResultPart,
 } from '@ai-sdk/provider';
-import type {
-  Experimental_LanguageModelStreamPart as ModelCallStreamPart,
-  ModelMessage,
-  StepResult,
-  StreamTextOnStepFinishCallback,
-  ToolCallRepairFunction,
-  ToolChoice,
-  ToolSet,
+import {
+  type Experimental_LanguageModelStreamPart as ModelCallStreamPart,
+  type LanguageModel,
+  type ModelMessage,
+  type StepResult,
+  type ToolCallRepairFunction,
+  type ToolChoice,
+  type ToolSet,
+  experimental_filterActiveTools as filterActiveTools,
 } from 'ai';
 import {
   doStreamStep,
@@ -22,11 +23,11 @@ import { serializeToolSet } from './serializable-schema.js';
 import type {
   GenerationSettings,
   PrepareStepCallback,
-  StreamTextOnErrorCallback,
-  TelemetrySettings,
+  WorkflowAgentOnErrorCallback,
+  WorkflowAgentOnStepFinishCallback,
+  TelemetryOptions,
   WorkflowAgentOnStepStartCallback,
 } from './workflow-agent.js';
-import type { CompatibleLanguageModel } from './types.js';
 
 // Re-export for consumers
 export type { ProviderExecutedToolResult } from './do-stream-step.js';
@@ -55,7 +56,6 @@ export async function* streamTextIterator({
   writable,
   model,
   stopConditions,
-  maxSteps,
   onStepFinish,
   onStepStart,
   onError,
@@ -71,20 +71,16 @@ 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>;
   experimental_context?: unknown;
-  experimental_telemetry?: TelemetrySettings;
+  experimental_telemetry?: TelemetryOptions;
   includeRawChunks?: boolean;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
   responseFormat?: LanguageModelV4CallOptions['responseFormat'];
@@ -94,10 +90,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;
@@ -110,16 +103,7 @@ export async function* streamTextIterator({
   let lastStep: StepResult<any, any> | undefined;
   let lastStepWasToolCalls = false;
 
-  // Default maxSteps to Infinity to preserve backwards compatibility
-  // (agent loops until completion unless explicitly limited)
-  const effectiveMaxSteps = maxSteps ?? Infinity;
-
   while (!done) {
-    // Check if we've exceeded the maximum number of steps
-    if (stepNumber >= effectiveMaxSteps) {
-      break;
-    }
-
     // Check for abort signal
     if (currentGenerationSettings.abortSignal?.aborted) {
       break;
@@ -248,6 +232,7 @@ export async function* streamTextIterator({
         stepNumber,
         model: currentModel,
         messages: conversationPrompt as unknown as ModelMessage[],
+        steps: [...steps],
       });
     }
 
@@ -255,7 +240,10 @@ export async function* streamTextIterator({
       // Filter tools if activeTools is specified
       const effectiveTools =
         currentActiveTools && currentActiveTools.length > 0
-          ? filterToolSet(tools, currentActiveTools)
+          ? (filterActiveTools({
+              tools,
+              activeTools: currentActiveTools,
+            }) ?? tools)
           : tools;
 
       // Serialize tools before crossing the step boundary — zod schemas
@@ -399,19 +387,6 @@ export async function* streamTextIterator({
   return conversationPrompt;
 }
 
-/**
- * Filter a tool set to only include the specified active tools.
- */
-function filterToolSet(tools: ToolSet, activeTools: string[]): ToolSet {
-  const filtered: ToolSet = {};
-  for (const toolName of activeTools) {
-    if (toolName in tools) {
-      filtered[toolName] = tools[toolName];
-    }
-  }
-  return filtered;
-}
-
 /**
  * Strip OpenAI's itemId from providerMetadata (requires reasoning items we don't preserve).
  * Preserves all other provider metadata (e.g., Gemini's thoughtSignature).

package/src/telemetry.ts

@@ -1,4 +1,4 @@
-import type { TelemetrySettings } from './workflow-agent.js';
+import type { TelemetryOptions } from './workflow-agent.js';
 
 // Minimal OTel type shims so we don't depend on @opentelemetry/api at compile time.
 type Attributes = Record<string, unknown>;
@@ -62,7 +62,7 @@ async function ensureOtelApi(): Promise<OtelApi | null> {
  * Returns a no-op–equivalent `null` when telemetry is disabled, so callers
  * don't need a separate init step.
  */
-function getTracer(telemetry?: TelemetrySettings): Tracer | null {
+function getTracer(telemetry?: TelemetryOptions): Tracer | null {
   if (!telemetry?.isEnabled || !otelApi) return null;
   if (telemetry.tracer) return telemetry.tracer as Tracer;
   return otelApi.trace.getTracer('ai');
@@ -76,7 +76,7 @@ function getTracer(telemetry?: TelemetrySettings): Tracer | null {
  */
 function assembleOperationName(
   operationId: string,
-  telemetry?: TelemetrySettings,
+  telemetry?: TelemetryOptions,
 ): Attributes {
   return {
     'operation.name': `${operationId}${
@@ -94,7 +94,7 @@ function assembleOperationName(
  */
 function buildAttributes(
   operationId: string,
-  telemetry: TelemetrySettings | undefined,
+  telemetry: TelemetryOptions | undefined,
   extra?: Attributes,
 ): Attributes {
   if (!telemetry?.isEnabled) return {};
@@ -154,7 +154,7 @@ function recordErrorOnSpan(span: Span, error: unknown): void {
  */
 export async function recordSpan<T>(options: {
   name: string;
-  telemetry?: TelemetrySettings;
+  telemetry?: TelemetryOptions;
   attributes?: Attributes;
   fn: (span?: Span) => PromiseLike<T> | T;
 }): Promise<T> {