ai 6.0.99 → 6.0.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.99",
+  "version": "6.0.101",
   "description": "AI SDK by Vercel - The AI Toolkit for TypeScript and JavaScript",
   "license": "Apache-2.0",
   "sideEffects": false,

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

@@ -1,5 +1,6 @@
 import { executeTool, ModelMessage } from '@ai-sdk/provider-utils';
 import { Tracer } from '@opentelemetry/api';
+import { notify } from '../util/notify';
 import { assembleOperationName } from '../telemetry/assemble-operation-name';
 import { recordErrorOnSpan, recordSpan } from '../telemetry/record-span';
 import { selectTelemetryAttributes } from '../telemetry/select-telemetry-attributes';
@@ -91,11 +92,7 @@ export async function executeToolCall<TOOLS extends ToolSet>({
     fn: async span => {
       let output: unknown;
 
-      try {
-        await onToolCallStart?.(baseCallbackEvent);
-      } catch (_ignored) {
-        // Errors in callbacks should not break the generation flow.
-      }
+      await notify({ event: baseCallbackEvent, callbacks: onToolCallStart });
 
       const startTime = now();
 
@@ -126,16 +123,15 @@ export async function executeToolCall<TOOLS extends ToolSet>({
       } catch (error) {
         const durationMs = now() - startTime;
 
-        try {
-          await onToolCallFinish?.({
+        await notify({
+          event: {
             ...baseCallbackEvent,
-            success: false,
+            success: false as const,
             error,
             durationMs,
-          });
-        } catch (_ignored) {
-          // Errors in callbacks should not break the generation flow.
-        }
+          },
+          callbacks: onToolCallFinish,
+        });
 
         recordErrorOnSpan(span, error);
         return {
@@ -153,16 +149,15 @@ export async function executeToolCall<TOOLS extends ToolSet>({
 
       const durationMs = now() - startTime;
 
-      try {
-        await onToolCallFinish?.({
+      await notify({
+        event: {
           ...baseCallbackEvent,
-          success: true,
+          success: true as const,
           output,
           durationMs,
-        });
-      } catch (_ignored) {
-        // Errors in callbacks should not break the generation flow.
-      }
+        },
+        callbacks: onToolCallFinish,
+      });
 
       try {
         span.setAttributes(

package/src/generate-text/generate-text.ts

@@ -15,6 +15,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import { Tracer } from '@opentelemetry/api';
 import { NoOutputGeneratedError } from '../error';
+import { notify } from '../util/notify';
 import { logWarnings } from '../logger/log-warnings';
 import { resolveLanguageModel } from '../model/resolve-model';
 import { ModelMessage } from '../prompt';
@@ -479,8 +480,8 @@ export async function generateText<
     messages,
   } as Prompt);
 
-  try {
-    await onStart?.({
+  await notify({
+    event: {
       model: modelInfo,
       system,
       prompt,
@@ -507,10 +508,9 @@ export async function generateText<
       functionId: telemetry?.functionId,
       metadata: telemetry?.metadata as Record<string, unknown> | undefined,
       experimental_context,
-    });
-  } catch (_ignored) {
-    // Errors in callbacks should not break the generation flow.
-  }
+    },
+    callbacks: onStart,
+  });
 
   const tracer = getTracer(telemetry);
 
@@ -712,8 +712,8 @@ export async function generateText<
               prepareStepResult?.providerOptions,
             );
 
-            try {
-              await onStepStart?.({
+            await notify({
+              event: {
                 stepNumber: steps.length,
                 model: stepModelInfo,
                 system: stepSystem,
@@ -734,10 +734,9 @@ export async function generateText<
                   | Record<string, unknown>
                   | undefined,
                 experimental_context,
-              });
-            } catch (_ignored) {
-              // Errors in callbacks should not break the generation flow.
-            }
+              },
+              callbacks: onStepStart,
+            });
 
             currentModelResponse = await retry(() =>
               recordSpan({
@@ -1056,7 +1055,8 @@ export async function generateText<
             });
 
             steps.push(currentStepResult);
-            await onStepFinish?.(currentStepResult);
+
+            await notify({ event: currentStepResult, callbacks: onStepFinish });
           } finally {
             if (stepTimeoutId != null) {
               clearTimeout(stepTimeoutId);
@@ -1123,33 +1123,36 @@ export async function generateText<
           } as LanguageModelUsage,
         );
 
-        await onFinish?.({
-          stepNumber: lastStep.stepNumber,
-          model: lastStep.model,
-          functionId: lastStep.functionId,
-          metadata: lastStep.metadata,
-          experimental_context: lastStep.experimental_context,
-          finishReason: lastStep.finishReason,
-          rawFinishReason: lastStep.rawFinishReason,
-          usage: lastStep.usage,
-          content: lastStep.content,
-          text: lastStep.text,
-          reasoningText: lastStep.reasoningText,
-          reasoning: lastStep.reasoning,
-          files: lastStep.files,
-          sources: lastStep.sources,
-          toolCalls: lastStep.toolCalls,
-          staticToolCalls: lastStep.staticToolCalls,
-          dynamicToolCalls: lastStep.dynamicToolCalls,
-          toolResults: lastStep.toolResults,
-          staticToolResults: lastStep.staticToolResults,
-          dynamicToolResults: lastStep.dynamicToolResults,
-          request: lastStep.request,
-          response: lastStep.response,
-          warnings: lastStep.warnings,
-          providerMetadata: lastStep.providerMetadata,
-          steps,
-          totalUsage,
+        await notify({
+          event: {
+            stepNumber: lastStep.stepNumber,
+            model: lastStep.model,
+            functionId: lastStep.functionId,
+            metadata: lastStep.metadata,
+            experimental_context: lastStep.experimental_context,
+            finishReason: lastStep.finishReason,
+            rawFinishReason: lastStep.rawFinishReason,
+            usage: lastStep.usage,
+            content: lastStep.content,
+            text: lastStep.text,
+            reasoningText: lastStep.reasoningText,
+            reasoning: lastStep.reasoning,
+            files: lastStep.files,
+            sources: lastStep.sources,
+            toolCalls: lastStep.toolCalls,
+            staticToolCalls: lastStep.staticToolCalls,
+            dynamicToolCalls: lastStep.dynamicToolCalls,
+            toolResults: lastStep.toolResults,
+            staticToolResults: lastStep.staticToolResults,
+            dynamicToolResults: lastStep.dynamicToolResults,
+            request: lastStep.request,
+            response: lastStep.response,
+            warnings: lastStep.warnings,
+            providerMetadata: lastStep.providerMetadata,
+            steps,
+            totalUsage,
+          },
+          callbacks: onFinish,
         });
 
         // parse output only if the last step was finished with "stop":

package/src/generate-text/stream-text.ts

@@ -19,6 +19,7 @@ import {
 import { Span } from '@opentelemetry/api';
 import { ServerResponse } from 'node:http';
 import { NoOutputGeneratedError } from '../error';
+import { notify } from '../util/notify';
 import { logWarnings } from '../logger/log-warnings';
 import { resolveLanguageModel } from '../model/resolve-model';
 import {
@@ -1028,7 +1029,7 @@ class DefaultStreamTextResult<TOOLS extends ToolSet, OUTPUT extends Output>
             providerMetadata: part.providerMetadata,
           });
 
-          await onStepFinish?.(currentStepResult);
+          await notify({ event: currentStepResult, callbacks: onStepFinish });
 
           logWarnings({
             warnings: recordedWarnings,
@@ -1084,33 +1085,37 @@ class DefaultStreamTextResult<TOOLS extends ToolSet, OUTPUT extends Output>
 
           // call onFinish callback:
           const finalStep = recordedSteps[recordedSteps.length - 1];
-          await onFinish?.({
-            stepNumber: finalStep.stepNumber,
-            model: finalStep.model,
-            functionId: finalStep.functionId,
-            metadata: finalStep.metadata,
-            experimental_context: finalStep.experimental_context,
-            finishReason: finalStep.finishReason,
-            rawFinishReason: finalStep.rawFinishReason,
-            totalUsage,
-            usage: finalStep.usage,
-            content: finalStep.content,
-            text: finalStep.text,
-            reasoningText: finalStep.reasoningText,
-            reasoning: finalStep.reasoning,
-            files: finalStep.files,
-            sources: finalStep.sources,
-            toolCalls: finalStep.toolCalls,
-            staticToolCalls: finalStep.staticToolCalls,
-            dynamicToolCalls: finalStep.dynamicToolCalls,
-            toolResults: finalStep.toolResults,
-            staticToolResults: finalStep.staticToolResults,
-            dynamicToolResults: finalStep.dynamicToolResults,
-            request: finalStep.request,
-            response: finalStep.response,
-            warnings: finalStep.warnings,
-            providerMetadata: finalStep.providerMetadata,
-            steps: recordedSteps,
+
+          await notify({
+            event: {
+              stepNumber: finalStep.stepNumber,
+              model: finalStep.model,
+              functionId: finalStep.functionId,
+              metadata: finalStep.metadata,
+              experimental_context: finalStep.experimental_context,
+              finishReason: finalStep.finishReason,
+              rawFinishReason: finalStep.rawFinishReason,
+              totalUsage,
+              usage: finalStep.usage,
+              content: finalStep.content,
+              text: finalStep.text,
+              reasoningText: finalStep.reasoningText,
+              reasoning: finalStep.reasoning,
+              files: finalStep.files,
+              sources: finalStep.sources,
+              toolCalls: finalStep.toolCalls,
+              staticToolCalls: finalStep.staticToolCalls,
+              dynamicToolCalls: finalStep.dynamicToolCalls,
+              toolResults: finalStep.toolResults,
+              staticToolResults: finalStep.staticToolResults,
+              dynamicToolResults: finalStep.dynamicToolResults,
+              request: finalStep.request,
+              response: finalStep.response,
+              warnings: finalStep.warnings,
+              providerMetadata: finalStep.providerMetadata,
+              steps: recordedSteps,
+            },
+            callbacks: onFinish,
           });
 
           // Add response information to the root span:
@@ -1271,8 +1276,8 @@ class DefaultStreamTextResult<TOOLS extends ToolSet, OUTPUT extends Output>
           messages,
         } as Prompt);
 
-        try {
-          await onStart?.({
+        await notify({
+          event: {
             model: modelInfo,
             system,
             prompt,
@@ -1298,10 +1303,9 @@ class DefaultStreamTextResult<TOOLS extends ToolSet, OUTPUT extends Output>
             include,
             ...callbackTelemetryProps,
             experimental_context,
-          });
-        } catch (_ignored) {
-          // Errors in callbacks should not break the generation flow.
-        }
+          },
+          callbacks: onStart,
+        });
 
         const initialMessages = initialPrompt.messages;
         const initialResponseMessages: Array<ResponseMessage> = [];
@@ -1549,8 +1553,8 @@ class DefaultStreamTextResult<TOOLS extends ToolSet, OUTPUT extends Output>
               prepareStepResult?.providerOptions,
             );
 
-            try {
-              await onStepStart?.({
+            await notify({
+              event: {
                 stepNumber: recordedSteps.length,
                 model: stepModelInfo,
                 system: stepSystem,
@@ -1568,10 +1572,9 @@ class DefaultStreamTextResult<TOOLS extends ToolSet, OUTPUT extends Output>
                 include,
                 ...callbackTelemetryProps,
                 experimental_context,
-              });
-            } catch (_ignored) {
-              // Errors in callbacks should not break the generation flow.
-            }
+              },
+              callbacks: onStepStart,
+            });
 
             const {
               result: { stream, response, request },

package/src/ui/process-ui-message-stream.ts

@@ -558,7 +558,18 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
             }
 
             case 'tool-input-error': {
-              if (chunk.dynamic) {
+              // When a part already exists for this toolCallId (e.g. from
+              // tool-input-start), honour its type so we update in place
+              // instead of creating a duplicate with a mismatched type.
+              const existingPart = state.message.parts
+                .filter(isToolUIPart)
+                .find(p => p.toolCallId === chunk.toolCallId);
+              const isDynamic =
+                existingPart != null
+                  ? existingPart.type === 'dynamic-tool'
+                  : !!chunk.dynamic;
+
+              if (isDynamic) {
                 updateDynamicToolPart({
                   toolCallId: chunk.toolCallId,
                   toolName: chunk.toolName,

package/src/util/notify.ts

@@ -0,0 +1,18 @@
+import { asArray } from './as-array';
+
+export type Listener<EVENT> = (event: EVENT) => PromiseLike<void> | void;
+
+/**
+ * Notifies all provided callbacks with the given event.
+ * Errors in callbacks do not break the generation flow.
+ */
+export async function notify<EVENT>(options: {
+  event: EVENT;
+  callbacks?: Listener<EVENT> | Array<Listener<EVENT>>;
+}): Promise<void> {
+  for (const callback of asArray(options.callbacks)) {
+    try {
+      await callback(options.event);
+    } catch (_ignored) {}
+  }
+}