ai 6.0.91 → 6.0.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.91",
+  "version": "6.0.93",
   "description": "AI SDK by Vercel - The AI Toolkit for TypeScript and JavaScript",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "1.9.0",
-    "@ai-sdk/gateway": "3.0.50",
+    "@ai-sdk/gateway": "3.0.51",
     "@ai-sdk/provider": "3.0.8",
     "@ai-sdk/provider-utils": "4.0.15"
   },

package/src/generate-text/execute-tool-call.ts

@@ -4,12 +4,28 @@ import { assembleOperationName } from '../telemetry/assemble-operation-name';
 import { recordErrorOnSpan, recordSpan } from '../telemetry/record-span';
 import { selectTelemetryAttributes } from '../telemetry/select-telemetry-attributes';
 import { TelemetrySettings } from '../telemetry/telemetry-settings';
+import { now } from '../util/now';
+import {
+  GenerateTextOnToolCallFinishCallback,
+  GenerateTextOnToolCallStartCallback,
+} from './generate-text';
 import { TypedToolCall } from './tool-call';
 import { ToolOutput } from './tool-output';
 import { ToolSet } from './tool-set';
 import { TypedToolResult } from './tool-result';
 import { TypedToolError } from './tool-error';
 
+/**
+ * Executes a single tool call and manages its lifecycle callbacks.
+ *
+ * This function handles the complete tool execution flow:
+ * 1. Invokes `onToolCallStart` callback before execution
+ * 2. Executes the tool's `execute` function with proper context
+ * 3. Handles streaming outputs via `onPreliminaryToolResult`
+ * 4. Invokes `onToolCallFinish` callback with success or error result
+ *
+ * @returns The tool output (result or error), or undefined if the tool has no execute function.
+ */
 export async function executeToolCall<TOOLS extends ToolSet>({
   toolCall,
   tools,
@@ -18,7 +34,11 @@ export async function executeToolCall<TOOLS extends ToolSet>({
   messages,
   abortSignal,
   experimental_context,
+  stepNumber,
+  model,
   onPreliminaryToolResult,
+  onToolCallStart,
+  onToolCallFinish,
 }: {
   toolCall: TypedToolCall<TOOLS>;
   tools: TOOLS | undefined;
@@ -27,7 +47,11 @@ export async function executeToolCall<TOOLS extends ToolSet>({
   messages: ModelMessage[];
   abortSignal: AbortSignal | undefined;
   experimental_context: unknown;
+  stepNumber?: number;
+  model?: { provider: string; modelId: string };
   onPreliminaryToolResult?: (result: TypedToolResult<TOOLS>) => void;
+  onToolCallStart?: GenerateTextOnToolCallStartCallback<TOOLS>;
+  onToolCallFinish?: GenerateTextOnToolCallFinishCallback<TOOLS>;
 }): Promise<ToolOutput<TOOLS> | undefined> {
   const { toolName, toolCallId, input } = toolCall;
   const tool = tools?.[toolName];
@@ -56,6 +80,23 @@ export async function executeToolCall<TOOLS extends ToolSet>({
     fn: async span => {
       let output: unknown;
 
+      try {
+        await onToolCallStart?.({
+          stepNumber,
+          model,
+          toolCall,
+          messages,
+          abortSignal,
+          functionId: telemetry?.functionId,
+          metadata: telemetry?.metadata as Record<string, unknown> | undefined,
+          experimental_context,
+        });
+      } catch (_ignored) {
+        // Errors in callbacks should not break the generation flow.
+      }
+
+      const startTime = now();
+
       try {
         const stream = executeTool({
           execute: tool.execute!.bind(tool),
@@ -81,6 +122,28 @@ export async function executeToolCall<TOOLS extends ToolSet>({
           }
         }
       } catch (error) {
+        const durationMs = now() - startTime;
+
+        try {
+          await onToolCallFinish?.({
+            stepNumber,
+            model,
+            toolCall,
+            messages,
+            abortSignal,
+            success: false,
+            error,
+            durationMs,
+            functionId: telemetry?.functionId,
+            metadata: telemetry?.metadata as
+              | Record<string, unknown>
+              | undefined,
+            experimental_context,
+          });
+        } catch (_ignored) {
+          // Errors in callbacks should not break the generation flow.
+        }
+
         recordErrorOnSpan(span, error);
         return {
           type: 'tool-error',
@@ -95,6 +158,26 @@ export async function executeToolCall<TOOLS extends ToolSet>({
         } as TypedToolError<TOOLS>;
       }
 
+      const durationMs = now() - startTime;
+
+      try {
+        await onToolCallFinish?.({
+          stepNumber,
+          model,
+          toolCall,
+          messages,
+          abortSignal,
+          success: true,
+          output,
+          durationMs,
+          functionId: telemetry?.functionId,
+          metadata: telemetry?.metadata as Record<string, unknown> | undefined,
+          experimental_context,
+        });
+      } catch (_ignored) {
+        // Errors in callbacks should not break the generation flow.
+      }
+
       try {
         span.setAttributes(
           await selectTelemetryAttributes({