@ai-sdk/workflow 2.0.71 → 2.0.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "2.0.71",
+  "version": "2.0.73",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -37,12 +37,12 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.27",
-    "@ai-sdk/provider-utils": "5.0.59",
-    "ai": "7.0.139",
+    "@ai-sdk/provider-utils": "5.0.60",
+    "ai": "7.0.141",
     "ajv": "^8.20.0"
   },
   "devDependencies": {
-    "@ai-sdk/otel": "1.0.139",
+    "@ai-sdk/otel": "1.0.141",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/sdk-trace-base": "2.7.1",
     "@types/node": "22.19.19",

package/src/build-model-step-result.ts

@@ -42,7 +42,12 @@ export async function buildModelStepResult(
           break;
         case 'tool-call': {
           const call = toolCalls[part.toolCallIndex];
-          providerContent.push({ ...call, input: '', type: 'tool-call' });
+          const { inputSchemaInput: _inputSchemaInput, ...publicCall } = call;
+          providerContent.push({
+            ...publicCall,
+            input: '',
+            type: 'tool-call',
+          });
           break;
         }
         case 'provider-tool-result':

package/src/do-generate-step.ts

@@ -162,6 +162,17 @@ async function generateModelCall(
     performance: { responseTimeMs },
   });
   abortSignal?.throwIfAborted();
+  const repairedToolCallIds = new Set<string>();
+  const repairToolCall = options.repairToolCall;
+  const trackedRepairToolCall = repairToolCall
+    ? async (repairOptions: Parameters<typeof repairToolCall>[0]) => {
+        const repaired = await repairToolCall(repairOptions);
+        if (repaired != null) {
+          repairedToolCallIds.add(repairOptions.toolCall.toolCallId);
+        }
+        return repaired;
+      }
+    : undefined;
   const toolCalls = await Promise.all(
     response.content
       .filter(part => part.type === 'tool-call')
@@ -169,7 +180,9 @@ async function generateModelCall(
         parseToolCall({
           toolCall,
           tools,
-          repairToolCall: options.repairToolCall,
+          repairToolCall: trackedRepairToolCall as Parameters<
+            typeof parseToolCall
+          >[0]['repairToolCall'],
           instructions:
             modelPrompt
               .filter(message => message.role === 'system')
@@ -269,6 +282,7 @@ async function generateModelCall(
     },
     providerExecutedToolResults,
     toolInputLifecycleEvents,
+    repairedToolCallIds: [...repairedToolCallIds],
   };
 }
 

package/src/do-stream-step.ts

@@ -116,6 +116,17 @@ async function streamModelStep(
   // Tools are serialized before crossing the step boundary because zod schemas
   // contain functions that can't be serialized by the workflow runtime.
   const toolInputLifecycleEvents: ToolInputLifecycleEvent[] = [];
+  const repairedToolCallIds = new Set<string>();
+  const repairToolCall = options?.repairToolCall;
+  const trackedRepairToolCall = repairToolCall
+    ? async (repairOptions: Parameters<typeof repairToolCall>[0]) => {
+        const repaired = await repairToolCall(repairOptions);
+        if (repaired != null) {
+          repairedToolCallIds.add(repairOptions.toolCall.toolCallId);
+        }
+        return repaired;
+      }
+    : undefined;
   const tools = serializedTools
     ? resolveSerializableTools(serializedTools)
     : undefined;
@@ -196,7 +207,7 @@ async function streamModelStep(
           frequencyPenalty: options?.frequencyPenalty,
           stopSequences: options?.stopSequences,
           seed: options?.seed,
-          repairToolCall: options?.repairToolCall,
+          repairToolCall: trackedRepairToolCall,
           download: options?.download,
           ...languageModelCallTelemetry,
         }),
@@ -449,7 +460,21 @@ async function streamModelStep(
             toolCallId: part.toolCall.toolCallId,
             ...(part.signature != null ? { signature: part.signature } : {}),
           });
-        } else {
+        } else if (
+          // The original schema must validate and normalize these calls outside
+          // the step before they become available to UI stream consumers. The
+          // matching `tool-error` for an invalid call (emitted by
+          // streamModelCall immediately after the `tool-call`) is deferred as
+          // well, so `writeDeferredToolCalls` stays the sole emitter.
+          // Otherwise the UI stream would receive a duplicate `tool-error`
+          // chunk, and the one written here would arrive before its deferred
+          // `tool-call`.
+          !(
+            (part.type === 'tool-call' ||
+              (part.type === 'tool-error' && !part.providerExecuted)) &&
+            serializedTools?.[part.toolName]?.hasOwnValidator
+          )
+        ) {
           await writer.write(part);
         }
       }
@@ -500,6 +525,7 @@ async function streamModelStep(
     },
     providerExecutedToolResults,
     toolInputLifecycleEvents,
+    repairedToolCallIds: [...repairedToolCallIds],
     ...(hasTerminalError ? { terminalError } : {}),
   };
 }

package/src/model-call-iterator.ts

@@ -1,12 +1,20 @@
 import type {
   LanguageModelV4CallOptions,
   LanguageModelV4Prompt,
+  LanguageModelV4ToolCall,
   LanguageModelV4ToolResultPart,
   SharedV4ProviderOptions,
 } from '@ai-sdk/provider';
-import type { Context } from '@ai-sdk/provider-utils';
+import {
+  asSchema,
+  getErrorMessage,
+  safeParseJSON,
+  type Context,
+} from '@ai-sdk/provider-utils';
 import {
   experimental_filterActiveTools as filterActiveTools,
+  InvalidToolInputError,
+  isDeepEqualData,
   type ActiveTools,
   type Experimental_SandboxSession as SandboxSession,
   type Instructions,
@@ -20,6 +28,8 @@ import {
 import {
   createRestrictedTelemetryDispatcher,
   createToolSearchState,
+  filterIncludedContext,
+  parseToolCall,
 } from 'ai/internal';
 import { buildModelStepResult } from './build-model-step-result.js';
 import { doGenerateStep } from './do-generate-step.js';
@@ -39,7 +49,11 @@ import {
 } from './add-tool-results-to-conversation.js';
 import { toModelResponseMessages } from './to-model-response-messages.js';
 import { resolveToolContext } from './resolve-tool-context.js';
-import { serializeToolSet } from './serializable-schema.js';
+import {
+  resolveSerializableTools,
+  serializeToolSet,
+  type SerializableToolDef,
+} from './serializable-schema.js';
 import type {
   GenerationSettings,
   PrepareStepCallback,
@@ -392,6 +406,12 @@ export async function* modelCallIterator({
               recordInputs: telemetry?.recordInputs,
               recordOutputs: telemetry?.recordOutputs,
               stepNumber,
+              includeRuntimeContext: telemetry?.includeRuntimeContext,
+              // Exclude unselected fields before serializing the step input.
+              runtimeContext: filterIncludedContext({
+                context: currentRuntimeContext,
+                includeContext: telemetry?.includeRuntimeContext,
+              }),
             }
           : undefined,
       };
@@ -423,12 +443,41 @@ export async function* modelCallIterator({
       }
 
       const {
-        toolCalls,
+        toolCalls: serializedToolCalls,
         finish,
         raw,
         providerExecutedToolResults,
         toolInputLifecycleEvents,
+        repairedToolCallIds,
       } = modelCallResult;
+      const toolCalls = await validateToolCallInputs({
+        toolCalls: serializedToolCalls,
+        tools: effectiveTools,
+        serializedTools,
+        repairToolCall,
+        repairedToolCallIds: new Set(repairedToolCallIds),
+        instructions:
+          conversationPrompt
+            .filter(message => message.role === 'system')
+            .map(message => message.content)
+            .join('\n') || initialInstructions,
+        messages: stepInputMessages.filter(
+          message => message.role !== 'system',
+        ),
+        abortSignal: currentGenerationSettings.abortSignal,
+      });
+      if (mode === 'stream' && writable != null) {
+        // Replace the tool-call chunk deferred inside the model step with the
+        // original schema's validated, normalized, or repaired result.
+        await writeDeferredToolCalls(
+          writable,
+          toolCalls.filter(
+            (_, index) =>
+              serializedTools[serializedToolCalls[index].toolName]
+                ?.hasOwnValidator,
+          ),
+        );
+      }
       await invokeToolInputLifecycleCallbacks({
         events: toolInputLifecycleEvents ?? [],
         toolCalls,
@@ -664,6 +713,172 @@ export async function* modelCallIterator({
   return conversationPrompt;
 }
 
+async function validateToolCallInputs({
+  toolCalls,
+  tools,
+  serializedTools,
+  repairToolCall,
+  repairedToolCallIds,
+  instructions,
+  messages,
+  abortSignal,
+}: {
+  toolCalls: ParsedToolCall[];
+  tools: ToolSet;
+  serializedTools: Record<string, SerializableToolDef>;
+  repairToolCall?: ToolCallRepairFunction<ToolSet>;
+  repairedToolCallIds: Set<string>;
+  instructions?: Instructions;
+  messages: ModelMessage[];
+  abortSignal?: AbortSignal;
+}): Promise<ParsedToolCall[]> {
+  return Promise.all(
+    toolCalls.map(async toolCall => {
+      if (toolCall.invalid || toolCall.providerExecuted) {
+        return toolCall;
+      }
+
+      const tool = tools[toolCall.toolName];
+      if (tool == null) {
+        return toolCall;
+      }
+
+      const inputSchema = asSchema(tool.inputSchema);
+      if (inputSchema.validate == null) {
+        return toolCall;
+      }
+
+      let repairedInput: { value: unknown } | undefined;
+      const parsedToolCall = await parseToolCall({
+        toolCall: {
+          type: 'tool-call',
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          input:
+            JSON.stringify(toolCall.input) ??
+            (toolCall.input == null ? '' : String(toolCall.input)),
+          providerExecuted: toolCall.providerExecuted,
+          providerMetadata: toolCall.providerMetadata,
+        } satisfies LanguageModelV4ToolCall,
+        tools,
+        // A call that was already repaired inside the model step is not
+        // repaired again, matching parseToolCall's single repair attempt.
+        repairToolCall:
+          repairToolCall == null || repairedToolCallIds.has(toolCall.toolCallId)
+            ? undefined
+            : async options => {
+                const repairedToolCall = await repairToolCallInStep({
+                  repairToolCall,
+                  serializedTools,
+                  toolCall: options.toolCall,
+                  error: {
+                    toolName: options.toolCall.toolName,
+                    toolInput: options.toolCall.input,
+                    message: getErrorMessage(options.error),
+                  },
+                  instructions,
+                  messages: options.messages,
+                });
+                if (repairedToolCall != null) {
+                  const parsedRepairedInput =
+                    repairedToolCall.input.trim() === ''
+                      ? { success: true as const, value: {} }
+                      : await safeParseJSON({
+                          text: repairedToolCall.input,
+                        });
+                  if (parsedRepairedInput.success) {
+                    repairedInput = { value: parsedRepairedInput.value };
+                  }
+                }
+                return repairedToolCall;
+              },
+        instructions,
+        messages,
+        abortSignal,
+      });
+
+      const inputSchemaInput = repairedInput ?? { value: toolCall.input };
+
+      return {
+        ...toolCall,
+        ...parsedToolCall,
+        ...(!parsedToolCall.invalid &&
+        !isDeepEqualData(inputSchemaInput.value, parsedToolCall.input)
+          ? { inputSchemaInput: inputSchemaInput.value }
+          : {}),
+      };
+    }),
+  );
+}
+
+/**
+ * Runs `repairToolCall` inside a step. The callback may be a `'use step'`
+ * function, so its arguments must be serializable: the tools and the
+ * `inputSchema` accessor are rebuilt here instead of crossing the boundary
+ * from the workflow body.
+ */
+async function repairToolCallInStep({
+  repairToolCall,
+  serializedTools,
+  toolCall,
+  error,
+  instructions,
+  messages,
+}: {
+  repairToolCall: ToolCallRepairFunction<ToolSet>;
+  serializedTools: Record<string, SerializableToolDef>;
+  toolCall: LanguageModelV4ToolCall;
+  error: { toolName: string; toolInput: string; message: string };
+  instructions?: Instructions;
+  messages: ModelMessage[];
+}): Promise<LanguageModelV4ToolCall | null> {
+  'use step';
+  const tools = resolveSerializableTools(serializedTools);
+  return repairToolCall({
+    toolCall,
+    tools,
+    inputSchema: async ({ toolName }) =>
+      asSchema(tools[toolName]?.inputSchema).jsonSchema,
+    instructions,
+    system: instructions,
+    messages,
+    // Errors are passed as plain data and rebuilt so that
+    // `InvalidToolInputError.isInstance` keeps working in the callback.
+    error: new InvalidToolInputError({
+      toolName: error.toolName,
+      toolInput: error.toolInput,
+      cause: new Error(error.message),
+      message: error.message,
+    }),
+  });
+}
+
+async function writeDeferredToolCalls(
+  writable: WritableStream<ModelCallStreamPart<ToolSet>>,
+  toolCalls: ParsedToolCall[],
+) {
+  'use step';
+  const writer = writable.getWriter();
+  try {
+    for (const toolCall of toolCalls) {
+      await writer.write(toolCall as ModelCallStreamPart<ToolSet>);
+      // Match streamModelCall, which follows an invalid call with a tool-error.
+      if (toolCall.invalid && !toolCall.providerExecuted) {
+        await writer.write({
+          type: 'tool-error',
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          input: toolCall.input,
+          error: getErrorMessage(toolCall.error),
+          dynamic: true,
+        } as ModelCallStreamPart<ToolSet>);
+      }
+    }
+  } finally {
+    writer.releaseLock();
+  }
+}
+
 async function invokeToolInputLifecycleCallbacks({
   events,
   toolCalls,
@@ -734,7 +949,7 @@ async function invokeToolInputLifecycleCallbacks({
         break;
       case 'available': {
         const toolCall = toolCallsById.get(toolCallId);
-        if (toolCall == null) {
+        if (toolCall == null || toolCall.invalid) {
           break;
         }
         await tool.onInputAvailable?.({

package/src/model-call-telemetry.ts

@@ -104,7 +104,7 @@ export async function runModelCallWithTelemetry({
     reasoning: options?.reasoning,
     providerOptions: options?.providerOptions,
     output: undefined,
-    runtimeContext: {},
+    runtimeContext: telemetry.runtimeContext ?? {},
     toolsContext: {},
   } as never);
   await dispatcher.onStepStart?.({
@@ -120,7 +120,7 @@ export async function runModelCallWithTelemetry({
     steps: [],
     providerOptions: options?.providerOptions,
     output: undefined,
-    runtimeContext: {},
+    runtimeContext: telemetry.runtimeContext ?? {},
     toolsContext: {},
   } as never);
 
@@ -157,7 +157,7 @@ export async function runModelCallWithTelemetry({
       callId,
       tools,
       stepNumber: telemetry.stepNumber,
-      runtimeContext: {},
+      runtimeContext: telemetry.runtimeContext ?? {},
       toolsContext: {},
     },
   );

package/src/model-call.ts

@@ -5,12 +5,14 @@ import type {
   LanguageModelV4Source,
   SharedV4ProviderMetadata,
 } from '@ai-sdk/provider';
+import type { Context } from '@ai-sdk/provider-utils';
 import type {
   Experimental_LanguageModelStreamPart,
   FinishReason,
   LanguageModelUsage,
   StepResultPerformance,
   StopCondition,
+  TelemetryOptions,
   ToolCallRepairFunction,
   ToolChoice,
   ToolSet,
@@ -28,6 +30,8 @@ export type ModelCallStreamPart<TTools extends ToolSet = ToolSet> =
       approvalId: string;
       toolCallId: string;
       signature?: string;
+      /** Raw input before the original tool schema transformed it. */
+      inputSchemaInput?: unknown;
     }
   | { type: 'reset-step' };
 
@@ -91,6 +95,9 @@ export interface ModelCallTelemetry {
   recordInputs?: boolean;
   recordOutputs?: boolean;
   stepNumber: number;
+  includeRuntimeContext?: TelemetryOptions['includeRuntimeContext'];
+  /** Runtime context filtered before crossing the durable step boundary. */
+  runtimeContext?: Context;
 }
 
 /**
@@ -108,6 +115,8 @@ export interface ParsedToolCall {
   dynamic?: boolean;
   invalid?: boolean;
   error?: unknown;
+  /** Raw input before the original tool schema validated and transformed it. */
+  inputSchemaInput?: unknown;
 }
 
 /**
@@ -219,6 +228,11 @@ export type ModelCallResult =
        * tool input lifecycle callback replay was added.
        */
       toolInputLifecycleEvents?: ToolInputLifecycleEvent[];
+      /**
+       * Tool call ids that `repairToolCall` already repaired inside the step,
+       * so deferred validation does not repair them a second time.
+       */
+      repairedToolCallIds?: string[];
       /** Present when the model stream emitted an error part or generation failed. */
       terminalError?: unknown;
     };

package/src/serializable-schema.ts

@@ -36,6 +36,8 @@ export type SerializableToolDef = {
   inputExamples?: Array<{ input: unknown }>;
   /** Provider-specific options attached to the tool definition. */
   providerOptions?: Tool['providerOptions'];
+  /** Whether the original input schema has its own runtime validator. */
+  hasOwnValidator?: boolean;
   /** Input lifecycle callbacks that must be invoked outside the step. */
   hasOnInputStart?: boolean;
   hasOnInputDelta?: boolean;
@@ -69,6 +71,7 @@ export function serializeToolSet<TOOLS extends ToolSet>(
 ): Record<string, SerializableToolDef> {
   return Object.fromEntries(
     Object.entries(tools).map(([name, t]) => {
+      const inputSchema = asSchema(t.inputSchema);
       const def: SerializableToolDef = {
         title: t.title,
         metadata: t.metadata,
@@ -78,12 +81,16 @@ export function serializeToolSet<TOOLS extends ToolSet>(
           toolsContext,
           experimental_sandbox: sandbox,
         }),
-        inputSchema: asSchema(t.inputSchema).jsonSchema as JSONSchema7,
+        inputSchema: inputSchema.jsonSchema as JSONSchema7,
         strict: t.strict,
         inputExamples: t.inputExamples,
         providerOptions: t.providerOptions,
       };
 
+      if (inputSchema.validate != null) {
+        def.hasOwnValidator = true;
+      }
+
       if (t.type === 'dynamic') {
         def.type = 'dynamic';
       }
@@ -159,9 +166,9 @@ function formatAjvError(error: ErrorObject): string {
 /**
  * Reconstructs tool objects from serializable tool definitions inside a step.
  *
- * Wraps each tool's JSON Schema with `jsonSchema()` and validates tool call
- * arguments against the schema using Ajv. This provides runtime type safety
- * equivalent to using zod schemas directly with the AI SDK.
+ * Wraps each tool's JSON Schema with `jsonSchema()`. Tools without their own
+ * validator are validated with Ajv. Tools with their own validator are
+ * validated after the workflow step, where the original schema is available.
  */
 export function resolveSerializableTools(
   tools: Record<string, SerializableToolDef>,
@@ -198,6 +205,11 @@ export function resolveSerializableTools(
     });
   };
 
+  const createInputSchema = (tool: SerializableToolDef) =>
+    tool.hasOwnValidator
+      ? jsonSchema(tool.inputSchema)
+      : createValidatedInputSchema(tool.inputSchema);
+
   return Object.fromEntries(
     Object.entries(tools).map(([name, t]) => {
       // Provider tools are executed server-side — pass them through
@@ -235,7 +247,7 @@ export function resolveSerializableTools(
             description: t.description,
             inputExamples: t.inputExamples,
             providerOptions: t.providerOptions,
-            inputSchema: createValidatedInputSchema(t.inputSchema),
+            inputSchema: createInputSchema(t),
           }),
         ];
       }
@@ -247,7 +259,7 @@ export function resolveSerializableTools(
         strict: t.strict,
         inputExamples: t.inputExamples,
         providerOptions: t.providerOptions,
-        inputSchema: createValidatedInputSchema(t.inputSchema),
+        inputSchema: createInputSchema(t),
       };
 
       return [

package/src/test/concurrency-workflows.ts

@@ -0,0 +1,66 @@
+import { tool, type ModelMessage } from 'ai';
+import { createHook } from 'workflow';
+import { z } from 'zod/v4';
+import { mockTextModel } from '../providers/mock.js';
+import { WorkflowAgent } from '../workflow-agent.js';
+
+async function completeAction(id: string) {
+  'use step';
+  return id;
+}
+
+export async function resumeSequentialApprovals(mode: 'generate' | 'stream') {
+  'use workflow';
+  const events: string[] = [];
+  const agent = new WorkflowAgent({
+    model: mockTextModel('Done.'),
+    toolCallConcurrency: 1,
+    tools: {
+      action: tool({
+        inputSchema: z.object({ id: z.string() }),
+        needsApproval: true,
+        execute: async ({ id }) => {
+          events.push(`start:${id}`);
+          if (id === 'first') {
+            using hook = createHook<string>();
+            await hook;
+          }
+          const result = await completeAction(id);
+          events.push(`end:${id}`);
+          return result;
+        },
+      }),
+    },
+  });
+  const ids = ['first', 'second'];
+  const messages: ModelMessage[] = [
+    { role: 'user', content: 'Run the tools.' },
+    {
+      role: 'assistant',
+      content: ids.flatMap(id => [
+        {
+          type: 'tool-call' as const,
+          toolCallId: id,
+          toolName: 'action',
+          input: { id },
+        },
+        {
+          type: 'tool-approval-request' as const,
+          toolCallId: id,
+          approvalId: `approval-${id}`,
+        },
+      ]),
+    },
+    {
+      role: 'tool',
+      content: [...ids].reverse().map(id => ({
+        type: 'tool-approval-response' as const,
+        approvalId: `approval-${id}`,
+        approved: true,
+      })),
+    },
+  ];
+  if (mode === 'generate') await agent.generate({ messages });
+  else await agent.stream({ messages });
+  return events;
+}

package/src/test/telemetry-workflows.ts

@@ -10,11 +10,24 @@ async function getGlobalTelemetryIntegrationCount(): Promise<number | null> {
   return globalThis.AI_SDK_TELEMETRY_INTEGRATIONS?.length ?? null;
 }
 
-export async function agentStreamWithGlobalTelemetry(prompt: string) {
+export async function agentStreamWithGlobalTelemetry(
+  prompt: string,
+  includeTraceIdentity?: boolean,
+) {
   'use workflow';
   const agent = new WorkflowAgent({
     model: mockTextModel(`Echo: ${prompt}`),
-    telemetry: { functionId: 'telemetry-test' },
+    telemetry: {
+      functionId: 'telemetry-test',
+      includeRuntimeContext:
+        includeTraceIdentity == null
+          ? undefined
+          : { traceIdentity: includeTraceIdentity },
+    },
+    runtimeContext: {
+      traceIdentity: { sessionId: 'chat_1', userId: 'user_1' },
+      secret: 'must not cross the model-step boundary',
+    },
   });
   const result = await agent.stream({
     messages: [{ role: 'user', content: prompt }],
@@ -29,11 +42,24 @@ export async function agentStreamWithGlobalTelemetry(prompt: string) {
   };
 }
 
-export async function agentGenerateWithGlobalTelemetry(prompt: string) {
+export async function agentGenerateWithGlobalTelemetry(
+  prompt: string,
+  includeTraceIdentity?: boolean,
+) {
   'use workflow';
   const agent = new WorkflowAgent({
     model: mockTextModel(`Echo: ${prompt}`),
-    telemetry: { functionId: 'telemetry-test' },
+    telemetry: {
+      functionId: 'telemetry-test',
+      includeRuntimeContext:
+        includeTraceIdentity == null
+          ? undefined
+          : { traceIdentity: includeTraceIdentity },
+    },
+    runtimeContext: {
+      traceIdentity: { sessionId: 'chat_1', userId: 'user_1' },
+      secret: 'must not cross the model-step boundary',
+    },
   });
   const result = await agent.generate({
     messages: [{ role: 'user', content: prompt }],