@ai-sdk/workflow 2.0.59 → 2.0.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "2.0.59",
+  "version": "2.0.61",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -36,9 +36,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.22",
-    "@ai-sdk/provider-utils": "5.0.54",
-    "ai": "7.0.128",
+    "@ai-sdk/provider": "4.0.23",
+    "@ai-sdk/provider-utils": "5.0.55",
+    "ai": "7.0.129",
     "ajv": "^8.20.0"
   },
   "devDependencies": {
@@ -46,7 +46,7 @@
     "@vercel/ai-tsconfig": "0.0.0",
     "@workflow/vitest": "5.0.0-beta.42",
     "tsdown": "^0.23.0",
-    "typescript": "5.8.3",
+    "typescript": "6.0.3",
     "vitest": "4.1.6",
     "workflow": "5.0.0-beta.42",
     "zod": "4.4.3"

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

@@ -105,6 +105,7 @@ export async function buildModelStepResult(
   const {
     content: rawContent,
     reasoning: reasoningParts,
+    performance: modelCallPerformance,
     responseMetadata,
     warnings,
   } = raw;
@@ -303,16 +304,23 @@ export async function buildModelStepResult(
         },
         totalTokens: 0,
       } as LanguageModelUsage),
-    performance: {
-      effectiveOutputTokensPerSecond: 0,
-      outputTokensPerSecond: undefined,
-      inputTokensPerSecond: undefined,
-      effectiveTotalTokensPerSecond: 0,
-      stepTimeMs: 0,
-      responseTimeMs: 0,
-      toolExecutionMs: {},
-      timeToFirstOutputMs: undefined,
-    },
+    performance:
+      modelCallPerformance == null
+        ? {
+            effectiveOutputTokensPerSecond: 0,
+            outputTokensPerSecond: undefined,
+            inputTokensPerSecond: undefined,
+            effectiveTotalTokensPerSecond: 0,
+            stepTimeMs: 0,
+            responseTimeMs: 0,
+            toolExecutionMs: {},
+            timeToFirstOutputMs: undefined,
+          }
+        : {
+            ...modelCallPerformance,
+            stepTimeMs: modelCallPerformance.responseTimeMs,
+            toolExecutionMs: {},
+          },
     warnings,
     request: {
       body: '',

package/src/do-stream-step.ts

@@ -22,6 +22,7 @@ import {
 import type {
   ModelCallFinish as StreamFinish,
   ModelCallOptions as DoStreamStepOptions,
+  ModelCallPerformance,
   ModelCallRawContentPart as DoStreamStepRawContentPart,
   ModelCallResult as DoStreamStepResult,
   ModelCallStreamPart,
@@ -212,6 +213,7 @@ export async function doStreamStep(
     | { id?: string; timestamp?: Date; modelId?: string }
     | undefined;
   let warnings: unknown[] | undefined;
+  let performance: ModelCallPerformance | undefined;
   let terminalError: unknown;
   let hasTerminalError = false;
   const ongoingToolCallToolNames = new Map<string, string>();
@@ -400,6 +402,7 @@ export async function doStreamStep(
               | Record<string, unknown>
               | undefined,
           };
+          performance = part.performance;
           break;
         case 'model-call-start':
           warnings = part.warnings;
@@ -456,6 +459,7 @@ export async function doStreamStep(
       content,
       reasoning: reasoningParts,
       responseMetadata,
+      performance,
       warnings,
     },
     providerExecutedToolResults,

package/src/model-call.ts

@@ -9,6 +9,7 @@ import type {
   Experimental_LanguageModelStreamPart,
   FinishReason,
   LanguageModelUsage,
+  StepResultPerformance,
   StopCondition,
   ToolCallRepairFunction,
   ToolChoice,
@@ -99,6 +100,11 @@ export interface ModelCallFinish {
   providerMetadata?: Record<string, unknown>;
 }
 
+export type ModelCallPerformance = Omit<
+  StepResultPerformance,
+  'stepTimeMs' | 'toolExecutionMs'
+>;
+
 export type ModelCallRawContentPart =
   | Extract<
       LanguageModelV4Content,
@@ -175,6 +181,8 @@ export interface ModelCallRawResult {
     request?: { body?: unknown };
     responseTimeMs: number;
   };
+  /** Present on streamed results produced after performance tracking was added. */
+  performance?: ModelCallPerformance;
   warnings?: unknown[];
 }
 

package/src/serializable-schema.ts

@@ -20,6 +20,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import { dynamicTool, tool, type ToolSet } from 'ai';
 import Ajv from 'ajv';
+import Ajv2020 from 'ajv/dist/2020.js';
 
 /**
  * Serializable tool definition — plain objects only, safe for workflow steps.
@@ -142,7 +143,36 @@ function resolveToolDescription<TOOLS extends ToolSet>({
 export function resolveSerializableTools(
   tools: Record<string, SerializableToolDef>,
 ): ToolSet {
-  const ajv = new Ajv();
+  const ajvOptions = {
+    strict: false,
+    validateFormats: false,
+  } as const;
+  const ajv = new Ajv(ajvOptions);
+  const ajv2020 = new Ajv2020(ajvOptions);
+
+  const createValidatedInputSchema = (inputSchema: JSONSchema7) => {
+    const schemaDialect =
+      typeof inputSchema.$schema === 'string'
+        ? inputSchema.$schema.replace(/#$/, '')
+        : undefined;
+    const schemaAjv =
+      schemaDialect === 'https://json-schema.org/draft/2020-12/schema'
+        ? ajv2020
+        : ajv;
+    const validateFn = schemaAjv.compile(inputSchema);
+
+    return jsonSchema(inputSchema, {
+      validate: value => {
+        if (validateFn(value)) {
+          return { success: true, value: value as any };
+        }
+        return {
+          success: false,
+          error: new Error(schemaAjv.errorsText(validateFn.errors)),
+        };
+      },
+    });
+  };
 
   return Object.fromEntries(
     Object.entries(tools).map(([name, t]) => {
@@ -175,30 +205,17 @@ export function resolveSerializableTools(
       }
 
       if (t.type === 'dynamic') {
-        const validateFn = ajv.compile(t.inputSchema);
-
         return [
           name,
           dynamicTool({
             description: t.description,
             inputExamples: t.inputExamples,
             providerOptions: t.providerOptions,
-            inputSchema: jsonSchema(t.inputSchema, {
-              validate: value => {
-                if (validateFn(value)) {
-                  return { success: true, value };
-                }
-                return {
-                  success: false,
-                  error: new Error(ajv.errorsText(validateFn.errors)),
-                };
-              },
-            }),
+            inputSchema: createValidatedInputSchema(t.inputSchema),
           }),
         ];
       }
 
-      const validateFn = ajv.compile(t.inputSchema);
       const functionTool = {
         title: t.title,
         metadata: t.metadata,
@@ -206,17 +223,7 @@ export function resolveSerializableTools(
         strict: t.strict,
         inputExamples: t.inputExamples,
         providerOptions: t.providerOptions,
-        inputSchema: jsonSchema(t.inputSchema, {
-          validate: value => {
-            if (validateFn(value)) {
-              return { success: true, value: value as any };
-            }
-            return {
-              success: false,
-              error: new Error(ajv.errorsText(validateFn.errors)),
-            };
-          },
-        }),
+        inputSchema: createValidatedInputSchema(t.inputSchema),
       };
 
       return [

package/src/workflow-agent.ts

@@ -1950,6 +1950,7 @@ export class WorkflowAgent<
         input: collected.toolCall.input,
         reason: collected.approvalResponse.reason,
         providerExecuted: collected.toolCall.providerExecuted === true,
+        existingToolResult: collected.existingToolResult,
       }),
     );
 
@@ -2092,7 +2093,10 @@ export class WorkflowAgent<
       for (const denial of deniedToolApprovals) {
         // Provider-executed denials are forwarded to the provider via the
         // preserved approval response below, not turned into a local result.
-        if (denial.providerExecuted) {
+        if (
+          denial.providerExecuted ||
+          denial.existingToolResult !== undefined
+        ) {
           continue;
         }
         toolResultContent.push({
@@ -2161,10 +2165,13 @@ export class WorkflowAgent<
       // Write tool results and step boundaries to the stream so the UI
       // can transition approved/denied tool parts to the correct state
       // and properly separate them from the subsequent model step.
-      if (options.writable && toolResultContent.length > 0) {
-        const deniedResults = toolResultContent
-          .filter(r => r.output.type === 'execution-denied')
-          .map(r => ({ toolCallId: r.toolCallId }));
+      const deniedResults = deniedToolApprovals
+        .filter(denial => !denial.providerExecuted)
+        .map(denial => ({ toolCallId: denial.toolCallId }));
+      if (
+        options.writable &&
+        (toolResultContent.length > 0 || deniedResults.length > 0)
+      ) {
         await writeApprovalToolResults(
           options.writable,
           approvedRawResults,