@ai-sdk/workflow 1.0.0-canary.39 → 1.0.0-canary.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "1.0.0-canary.39",
+  "version": "1.0.0-canary.41",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
@@ -28,15 +28,15 @@
   "dependencies": {
     "ajv": "^8.18.0",
     "@ai-sdk/provider": "4.0.0-canary.16",
-    "@ai-sdk/provider-utils": "5.0.0-canary.33",
-    "ai": "7.0.0-canary.124"
+    "@ai-sdk/provider-utils": "5.0.0-canary.34",
+    "ai": "7.0.0-canary.125"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
     "@workflow/vitest": "4.0.1",
     "tsup": "^8",
     "typescript": "5.8.3",
-    "workflow": "4.2.0",
+    "workflow": "4.2.4",
     "zod": "3.25.76",
     "@vercel/ai-tsconfig": "0.0.0"
   },

package/src/do-stream-step.ts

@@ -2,6 +2,7 @@ import type {
   LanguageModelV4CallOptions,
   LanguageModelV4Prompt,
 } from '@ai-sdk/provider';
+import type { Context } from '@ai-sdk/provider-utils';
 import {
   experimental_streamLanguageModelCall as streamModelCall,
   gateway,
@@ -56,6 +57,8 @@ export interface DoStreamStepOptions {
   telemetry?: TelemetryOptions;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
   responseFormat?: LanguageModelV4CallOptions['responseFormat'];
+  runtimeContext?: Context;
+  toolsContext?: Record<string, Context | undefined>;
 }
 
 /**
@@ -241,8 +244,8 @@ export async function doStreamStep(
     },
     functionId: undefined,
     metadata: undefined,
-    runtimeContext: undefined,
-    toolsContext: {},
+    runtimeContext: options?.runtimeContext ?? {},
+    toolsContext: options?.toolsContext ?? {},
     content: [
       ...(text ? [{ type: 'text' as const, text }] : []),
       ...toolCalls

package/src/stream-text-iterator.ts

@@ -3,6 +3,7 @@ import type {
   LanguageModelV4Prompt,
   LanguageModelV4ToolResultPart,
 } from '@ai-sdk/provider';
+import type { Context } from '@ai-sdk/provider-utils';
 import {
   experimental_filterActiveTools as filterActiveTools,
   type Experimental_LanguageModelStreamPart as ModelCallStreamPart,
@@ -43,8 +44,10 @@ export interface StreamTextIteratorYieldValue {
   messages: LanguageModelV4Prompt;
   /** The step result from the current step */
   step?: StepResult<ToolSet, any>;
-  /** The current experimental context */
-  context?: unknown;
+  /** The current runtime context shared across the agent loop */
+  runtimeContext?: Context;
+  /** The current per-tool context, keyed by tool name */
+  toolsContext?: Record<string, Context | undefined>;
   /** Provider-executed tool results (keyed by tool call ID) */
   providerExecutedToolResults?: Map<string, ProviderExecutedToolResult>;
 }
@@ -62,7 +65,8 @@ export async function* streamTextIterator({
   prepareStep,
   generationSettings,
   toolChoice,
-  experimental_context,
+  runtimeContext,
+  toolsContext,
   telemetry,
   includeRawChunks = false,
   repairToolCall,
@@ -79,7 +83,8 @@ export async function* streamTextIterator({
   prepareStep?: PrepareStepCallback<any>;
   generationSettings?: GenerationSettings;
   toolChoice?: ToolChoice<ToolSet>;
-  experimental_context?: unknown;
+  runtimeContext?: Context;
+  toolsContext?: Record<string, Context | undefined>;
   telemetry?: TelemetryOptions;
   includeRawChunks?: boolean;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
@@ -93,7 +98,9 @@ export async function* streamTextIterator({
   let currentModel: LanguageModel = model;
   let currentGenerationSettings = generationSettings ?? {};
   let currentToolChoice = toolChoice;
-  let currentContext = experimental_context;
+  let currentRuntimeContext: Context = runtimeContext ?? {};
+  let currentToolsContext: Record<string, Context | undefined> =
+    toolsContext ?? {};
   let currentActiveTools: string[] | undefined;
 
   const steps: StepResult<any, any>[] = [];
@@ -116,19 +123,20 @@ export async function* streamTextIterator({
         stepNumber,
         steps,
         messages: conversationPrompt,
-        experimental_context: currentContext,
+        runtimeContext: currentRuntimeContext,
+        toolsContext: currentToolsContext as never,
       });
 
       // Apply any overrides from prepareStep
-      if (prepareResult.model !== undefined) {
+      if (prepareResult?.model !== undefined) {
         currentModel = prepareResult.model;
       }
       // Apply messages override BEFORE system so the system message
       // isn't lost when messages replaces the prompt.
-      if (prepareResult.messages !== undefined) {
+      if (prepareResult?.messages !== undefined) {
         conversationPrompt = [...prepareResult.messages];
       }
-      if (prepareResult.system !== undefined) {
+      if (prepareResult?.system !== undefined) {
         // Update or prepend system message in the conversation prompt.
         // Applied AFTER messages override so the system message isn't
         // lost when messages replaces the prompt.
@@ -149,80 +157,86 @@ export async function* streamTextIterator({
           });
         }
       }
-      if (prepareResult.experimental_context !== undefined) {
-        currentContext = prepareResult.experimental_context;
+      if (prepareResult?.runtimeContext !== undefined) {
+        currentRuntimeContext = prepareResult.runtimeContext;
       }
-      if (prepareResult.activeTools !== undefined) {
+      if (prepareResult?.toolsContext !== undefined) {
+        currentToolsContext = prepareResult.toolsContext as Record<
+          string,
+          Context | undefined
+        >;
+      }
+      if (prepareResult?.activeTools !== undefined) {
         currentActiveTools = prepareResult.activeTools;
       }
       // Apply generation settings overrides
-      if (prepareResult.maxOutputTokens !== undefined) {
+      if (prepareResult?.maxOutputTokens !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           maxOutputTokens: prepareResult.maxOutputTokens,
         };
       }
-      if (prepareResult.temperature !== undefined) {
+      if (prepareResult?.temperature !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           temperature: prepareResult.temperature,
         };
       }
-      if (prepareResult.topP !== undefined) {
+      if (prepareResult?.topP !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           topP: prepareResult.topP,
         };
       }
-      if (prepareResult.topK !== undefined) {
+      if (prepareResult?.topK !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           topK: prepareResult.topK,
         };
       }
-      if (prepareResult.presencePenalty !== undefined) {
+      if (prepareResult?.presencePenalty !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           presencePenalty: prepareResult.presencePenalty,
         };
       }
-      if (prepareResult.frequencyPenalty !== undefined) {
+      if (prepareResult?.frequencyPenalty !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           frequencyPenalty: prepareResult.frequencyPenalty,
         };
       }
-      if (prepareResult.stopSequences !== undefined) {
+      if (prepareResult?.stopSequences !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           stopSequences: prepareResult.stopSequences,
         };
       }
-      if (prepareResult.seed !== undefined) {
+      if (prepareResult?.seed !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           seed: prepareResult.seed,
         };
       }
-      if (prepareResult.maxRetries !== undefined) {
+      if (prepareResult?.maxRetries !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           maxRetries: prepareResult.maxRetries,
         };
       }
-      if (prepareResult.headers !== undefined) {
+      if (prepareResult?.headers !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           headers: prepareResult.headers,
         };
       }
-      if (prepareResult.providerOptions !== undefined) {
+      if (prepareResult?.providerOptions !== undefined) {
         currentGenerationSettings = {
           ...currentGenerationSettings,
           providerOptions: prepareResult.providerOptions,
         };
       }
-      if (prepareResult.toolChoice !== undefined) {
+      if (prepareResult?.toolChoice !== undefined) {
         currentToolChoice = prepareResult.toolChoice;
       }
     }
@@ -233,6 +247,8 @@ export async function* streamTextIterator({
         model: currentModel,
         messages: conversationPrompt as unknown as ModelMessage[],
         steps: [...steps],
+        runtimeContext: currentRuntimeContext,
+        toolsContext: currentToolsContext as never,
       });
     }
 
@@ -264,6 +280,8 @@ export async function* streamTextIterator({
             telemetry,
             repairToolCall,
             responseFormat,
+            runtimeContext: currentRuntimeContext,
+            toolsContext: currentToolsContext,
           },
         );
 
@@ -308,7 +326,8 @@ export async function* streamTextIterator({
           toolCalls,
           messages: conversationPrompt,
           step,
-          context: currentContext,
+          runtimeContext: currentRuntimeContext,
+          toolsContext: currentToolsContext,
           providerExecutedToolResults,
         };
 
@@ -380,7 +399,8 @@ export async function* streamTextIterator({
       toolCalls: [],
       messages: conversationPrompt,
       step: lastStep,
-      context: currentContext,
+      runtimeContext: currentRuntimeContext,
+      toolsContext: currentToolsContext,
     };
   }
 

package/src/test/agent-e2e-workflows.ts

@@ -505,3 +505,83 @@ export async function agentToolInputSchemaE2e(a: number, b: number) {
     lastStepText: result.steps[result.steps.length - 1]?.text,
   };
 }
+
+// ============================================================================
+// runtimeContext + toolsContext (end-to-end)
+// ============================================================================
+
+/**
+ * Demonstrates the full context flow:
+ *
+ * - `runtimeContext` holds shared agent state (`tenantId`, `requestId`).
+ *   `prepareStep` reads it and tags it with the current step number;
+ *   `onFinish` receives the final value.
+ * - `toolsContext` holds per-tool, schema-validated context. The
+ *   `lookupCustomer` tool declares `contextSchema`, so its entry is
+ *   validated and the tool's `execute` only sees its own context.
+ */
+export async function agentRuntimeAndToolsContextE2e() {
+  'use workflow';
+
+  let onFinishRuntimeContext: Record<string, unknown> | undefined;
+  let onFinishToolsContext: Record<string, unknown> | undefined;
+  let toolReceivedContext: unknown;
+
+  const agent = new WorkflowAgent({
+    model: mockSequenceModel([
+      {
+        type: 'tool-call',
+        toolName: 'lookupCustomer',
+        input: JSON.stringify({ customerId: 'cust_123' }),
+      },
+      { type: 'text', text: 'Customer cust_123 is eligible.' },
+    ]),
+    tools: {
+      lookupCustomer: tool({
+        description: 'Look up customer account details.',
+        inputSchema: z.object({ customerId: z.string() }),
+        contextSchema: z.object({
+          apiKey: z.string(),
+          region: z.enum(['us', 'eu']),
+        }),
+        execute: async (input, { context }) => {
+          toolReceivedContext = context;
+          return { customerId: input.customerId, eligible: true };
+        },
+      }),
+    },
+    instructions: 'You look up customers.',
+    runtimeContext: {
+      tenantId: 'tenant_123',
+      requestId: 'req_abc',
+    },
+    toolsContext: {
+      lookupCustomer: {
+        apiKey: 'sk-test-key',
+        region: 'us',
+      },
+    },
+    prepareStep: ({ stepNumber, runtimeContext }) => ({
+      runtimeContext: { ...runtimeContext, lastStep: stepNumber },
+    }),
+    onFinish: ({ runtimeContext, toolsContext }) => {
+      onFinishRuntimeContext = runtimeContext;
+      onFinishToolsContext = toolsContext;
+    },
+  });
+
+  const result = await agent.stream({
+    messages: [
+      { role: 'user', content: 'Is customer cust_123 eligible for support?' },
+    ],
+    writable: getWritable(),
+  });
+
+  return {
+    stepCount: result.steps.length,
+    lastStepText: result.steps[result.steps.length - 1]?.text,
+    toolReceivedContext,
+    onFinishRuntimeContext,
+    onFinishToolsContext,
+  };
+}