@ai-sdk/workflow 1.0.0-beta.9 → 1.0.0-beta.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-beta.95",
   "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.95"
+    "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.178"
   },
   "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,13 +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';
-
 export type { Experimental_LanguageModelStreamPart as ModelCallStreamPart } from 'ai';
 
 export type ModelStopCondition = StopCondition<NoInfer<ToolSet>, any>;
@@ -54,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;
 }
 
 /**
@@ -90,7 +96,13 @@ export async function doStreamStep(
   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)
@@ -115,6 +127,7 @@ export async function doStreamStep(
     // pre-converted LanguageModelV4Prompt. standardizePrompt inside
     // streamModelCall handles both formats.
     messages: conversationPrompt as unknown as ModelMessage[],
+    allowSystemInMessages: true,
     tools,
     toolChoice: options?.toolChoice,
     includeRawChunks: options?.includeRawChunks,
@@ -143,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;
@@ -153,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;
@@ -234,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
@@ -302,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(),
@@ -317,6 +353,7 @@ export async function doStreamStep(
     toolCalls,
     finish,
     step,
+    chunks,
     providerExecutedToolResults,
   };
 }

package/src/index.ts

@@ -18,16 +18,18 @@ export {
   type PrepareStepResult,
   type ProviderOptions,
   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

@@ -47,13 +47,13 @@ export function mockTextModel(text: string) {
 export function mockSequenceModel(responses: MockResponseDescriptor[]) {
   return mockProvider({
     doStream: async (options: any) => {
-      const idx = Math.min(
+      const responseIndex = Math.min(
         options.prompt.filter((m: any) => m.role === 'assistant').length,
         responses.length - 1,
       );
-      const r = responses[idx];
+      const selectedResponse = responses[responseIndex];
       const parts =
-        r.type === 'text'
+        selectedResponse.type === 'text'
           ? [
               { type: 'stream-start', warnings: [] },
               {
@@ -63,7 +63,7 @@ export function mockSequenceModel(responses: MockResponseDescriptor[]) {
                 timestamp: new Date(),
               },
               { type: 'text-start', id: '1' },
-              { type: 'text-delta', id: '1', delta: r.text },
+              { type: 'text-delta', id: '1', delta: selectedResponse.text },
               { type: 'text-end', id: '1' },
               {
                 type: 'finish',
@@ -84,9 +84,9 @@ export function mockSequenceModel(responses: MockResponseDescriptor[]) {
               },
               {
                 type: 'tool-call',
-                toolCallId: `call-${idx + 1}`,
-                toolName: r.toolName,
-                input: r.input,
+                toolCallId: `call-${responseIndex + 1}`,
+                toolName: selectedResponse.toolName,
+                input: selectedResponse.input,
               },
               {
                 type: 'finish',
@@ -100,7 +100,7 @@ export function mockSequenceModel(responses: MockResponseDescriptor[]) {
       return {
         stream: new ReadableStream({
           start(c) {
-            for (const p of parts as any[]) c.enqueue(p);
+            for (const streamPart of parts as any[]) c.enqueue(streamPart);
             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),
           }),
         ];