@ai-sdk/workflow 1.0.0-beta.1 → 1.0.0-beta.100

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.100",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
@@ -26,17 +26,17 @@
     }
   },
   "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.90"
+    "ajv": "^8.20.0",
+    "@ai-sdk/provider": "4.0.0-beta.19",
+    "@ai-sdk/provider-utils": "5.0.0-beta.49",
+    "ai": "7.0.0-beta.182"
   },
   "devDependencies": {
-    "@types/node": "20.17.24",
+    "@types/node": "22.19.19",
     "@workflow/vitest": "4.0.1",
-    "tsup": "^8",
+    "tsup": "^8.5.1",
     "typescript": "5.8.3",
-    "workflow": "4.2.0",
+    "workflow": "4.2.4",
     "zod": "3.25.76",
     "@vercel/ai-tsconfig": "0.0.0"
   },
@@ -44,15 +44,17 @@
     "zod": "^3.25.76 || ^4.1.8"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "homepage": "https://ai-sdk.dev/docs",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vercel/ai.git"
+    "url": "https://github.com/vercel/ai",
+    "directory": "packages/workflow"
   },
   "bugs": {
     "url": "https://github.com/vercel/ai/issues"

package/src/create-language-model-tool-result-output.ts

@@ -0,0 +1,85 @@
+import type { LanguageModelV4ToolResultOutput } from '@ai-sdk/provider';
+import type { Tool } from '@ai-sdk/provider-utils';
+import type { ModelMessage } from 'ai';
+import {
+  createDefaultDownloadFunction,
+  createToolModelOutput,
+  downloadAssets,
+  mapToolResultOutput,
+  type DownloadFunction,
+} from 'ai/internal';
+
+/**
+ * Converts a single tool result into a provider-level
+ * `LanguageModelV4ToolResultOutput`, honoring the tool's optional
+ * `toModelOutput` hook.
+ *
+ * Unlike `generateText`/`streamText`, `WorkflowAgent` assembles the
+ * `LanguageModelV4` prompt incrementally — appending one tool result at a time
+ * — instead of building AI-level `ModelMessage`s and converting the whole
+ * prompt once via `convertToLanguageModelPrompt`. This helper performs the
+ * equivalent per-result conversion using the shared `ai/internal` primitives:
+ *
+ *   1. `createToolModelOutput` — applies `tool.toModelOutput` (or the
+ *      text/json/error fallback).
+ *   2. `downloadAssets` — for `content`-type outputs, downloads any file/image
+ *      assets so URLs become bytes the provider can consume.
+ *   3. `mapToolResultOutput` — maps the AI-level `ToolResultOutput` to the
+ *      provider-level output and converts legacy file types.
+ */
+export async function createLanguageModelToolResultOutput({
+  toolCallId,
+  toolName,
+  input,
+  output,
+  tool,
+  errorMode,
+  supportedUrls,
+  download = createDefaultDownloadFunction(),
+  provider,
+}: {
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  output: unknown;
+  tool: Tool | undefined;
+  errorMode: 'none' | 'text' | 'json';
+  supportedUrls: Record<string, RegExp[]>;
+  download?: DownloadFunction;
+  provider?: string;
+}): Promise<LanguageModelV4ToolResultOutput> {
+  const modelOutput = await createToolModelOutput({
+    toolCallId,
+    input,
+    output,
+    tool,
+    errorMode,
+  });
+
+  const downloadedAssets =
+    modelOutput.type === 'content'
+      ? await downloadAssets(
+          [
+            {
+              role: 'tool',
+              content: [
+                {
+                  type: 'tool-result',
+                  toolCallId,
+                  toolName,
+                  output: modelOutput,
+                },
+              ],
+            } satisfies ModelMessage,
+          ],
+          download,
+          supportedUrls,
+        )
+      : {};
+
+  return mapToolResultOutput({
+    output: modelOutput,
+    provider,
+    downloadedAssets,
+  });
+}

package/src/do-stream-step.ts

@@ -2,9 +2,11 @@ import type {
   LanguageModelV4CallOptions,
   LanguageModelV4Prompt,
 } from '@ai-sdk/provider';
+import type { Context } from '@ai-sdk/provider-utils';
 import {
-  type Experimental_LanguageModelStreamPart as ModelCallStreamPart,
   experimental_streamLanguageModelCall as streamModelCall,
+  gateway,
+  type Experimental_LanguageModelStreamPart as ModelCallStreamPart,
   type FinishReason,
   type LanguageModel,
   type LanguageModelUsage,
@@ -15,14 +17,11 @@ import {
   type ToolChoice,
   type ToolSet,
 } from 'ai';
-import { gateway } from 'ai';
-import type { ProviderOptions, TelemetrySettings } from './workflow-agent.js';
+import type { ProviderOptions } 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';
 
 export type ModelStopCondition = StopCondition<NoInfer<ToolSet>, any>;
@@ -55,9 +54,15 @@ export interface DoStreamStepOptions {
   providerOptions?: ProviderOptions;
   toolChoice?: ToolChoice<ToolSet>;
   includeRawChunks?: boolean;
-  experimental_telemetry?: TelemetrySettings;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
   responseFormat?: LanguageModelV4CallOptions['responseFormat'];
+  runtimeContext?: Context;
+  toolsContext?: Record<string, Context | undefined>;
+  /**
+   * The step number for the returned StepResult. Defaults to 0 for direct
+   * callers; stream iterators pass their current index. See #15151.
+   */
+  stepNumber?: number;
 }
 
 /**
@@ -87,33 +92,24 @@ 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,
-) {
+): Promise<{
+  toolCalls: ParsedToolCall[];
+  finish: StreamFinish | undefined;
+  step: StepResult<ToolSet, any>;
+  chunks?: unknown[];
+  providerExecutedToolResults: Map<string, ProviderExecutedToolResult>;
+}> {
   '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,11 +122,12 @@ 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.
     messages: conversationPrompt as unknown as ModelMessage[],
+    allowSystemInMessages: true,
     tools,
     toolChoice: options?.toolChoice,
     includeRawChunks: options?.includeRawChunks,
@@ -159,6 +156,7 @@ export async function doStreamStep(
   // Aggregation for StepResult
   let text = '';
   const reasoningParts: Array<{ text: string }> = [];
+  const chunks: unknown[] = [];
   let responseMetadata:
     | { id?: string; timestamp?: Date; modelId?: string }
     | undefined;
@@ -169,6 +167,14 @@ export async function doStreamStep(
 
   try {
     for await (const part of modelStream) {
+      if (
+        part.type !== 'model-call-start' &&
+        part.type !== 'model-call-end' &&
+        part.type !== 'model-call-response-metadata'
+      ) {
+        chunks.push(part);
+      }
+
       switch (part.type) {
         case 'text-delta':
           text += part.text;
@@ -250,14 +256,15 @@ export async function doStreamStep(
 
   const step: StepResult<ToolSet, any> = {
     callId: 'workflow-agent',
-    stepNumber: 0,
+    stepNumber: options?.stepNumber ?? 0,
     model: {
       provider: responseMetadata?.modelId?.split(':')[0] ?? 'unknown',
       modelId: responseMetadata?.modelId ?? 'unknown',
     },
     functionId: undefined,
     metadata: undefined,
-    context: undefined,
+    runtimeContext: options?.runtimeContext ?? {},
+    toolsContext: options?.toolsContext ?? {},
     content: [
       ...(text ? [{ type: 'text' as const, text }] : []),
       ...toolCalls
@@ -318,8 +325,21 @@ export async function doStreamStep(
         },
         totalTokens: 0,
       } as LanguageModelUsage),
+    performance: {
+      effectiveOutputTokensPerSecond: 0,
+      outputTokensPerSecond: undefined,
+      inputTokensPerSecond: undefined,
+      effectiveTotalTokensPerSecond: 0,
+      stepTimeMs: 0,
+      responseTimeMs: 0,
+      toolExecutionMs: {},
+      timeToFirstOutputMs: undefined,
+    },
     warnings,
-    request: { body: '' },
+    request: {
+      body: '',
+      messages: [], // TODO implement step request messages
+    },
     response: {
       id: responseMetadata?.id ?? 'unknown',
       timestamp: responseMetadata?.timestamp ?? new Date(),
@@ -333,6 +353,7 @@ export async function doStreamStep(
     toolCalls,
     finish,
     step,
+    chunks,
     providerExecutedToolResults,
   };
 }

package/src/index.ts

@@ -17,16 +17,19 @@ export {
   type PrepareStepInfo,
   type PrepareStepResult,
   type ProviderOptions,
-  type StreamTextOnAbortCallback,
-  type StreamTextOnErrorCallback,
-  type StreamTextOnFinishCallback,
+  type WorkflowAgentOnAbortCallback,
+  type WorkflowAgentOnEndCallback,
+  type WorkflowAgentOnErrorCallback,
+  type WorkflowAgentOnFinishCallback,
+  type WorkflowAgentOnStepEndCallback,
+  type WorkflowAgentOnStepFinishCallback,
   type StreamTextTransform,
-  type TelemetrySettings,
+  type TelemetryOptions,
   type ToolCallRepairFunction,
   type WorkflowAgentOnStartCallback,
   type WorkflowAgentOnStepStartCallback,
-  type WorkflowAgentOnToolCallStartCallback,
-  type WorkflowAgentOnToolCallFinishCallback,
+  type WorkflowAgentOnToolExecutionStartCallback,
+  type WorkflowAgentOnToolExecutionEndCallback,
 } from './workflow-agent.js';
 
 export {

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 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',
@@ -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: selectedResponse.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-${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();
           },
         }),
-      }),
-    });
-  };
-}
-
-/**
- * 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/serializable-schema.ts

@@ -23,6 +23,8 @@ export type SerializableToolDef = {
   inputSchema: JSONSchema7;
   /** Present on provider tools (e.g. anthropic.tools.webSearch). */
   type?: 'provider';
+  /** Provider tool is executed by the provider. */
+  isProviderExecuted?: boolean;
   /** Provider tool ID, e.g. 'anthropic.web_search_20250305'. */
   id?: `${string}.${string}`;
   /** Provider tool configuration args (maxUses, allowedDomains, etc.). */
@@ -41,7 +43,7 @@ export function serializeToolSet(
   return Object.fromEntries(
     Object.entries(tools).map(([name, t]) => {
       const def: SerializableToolDef = {
-        description: t.description,
+        description: t.description as string, // TODO support tools with function descriptions
         inputSchema: asSchema(t.inputSchema).jsonSchema as JSONSchema7,
       };
 
@@ -49,6 +51,7 @@ export function serializeToolSet(
       // them as provider-executed tools (e.g. anthropic webSearch).
       if ((t as any).type === 'provider') {
         def.type = 'provider';
+        def.isProviderExecuted = (t as any).isProviderExecuted ?? false;
         def.id = (t as any).id;
         def.args = (t as any).args;
       }
@@ -81,6 +84,7 @@ export function resolveSerializableTools(
             type: 'provider' as const,
             id: t.id!,
             args: t.args ?? {},
+            isProviderExecuted: t.isProviderExecuted ?? false,
             inputSchema: jsonSchema(t.inputSchema),
           }),
         ];