ai 6.0.301 → 6.0.302

package/src/types/usage.ts

@@ -135,6 +135,12 @@ export function addLanguageModelUsage(
   usage1: LanguageModelUsage,
   usage2: LanguageModelUsage,
 ): LanguageModelUsage {
+  const raw = isNullLanguageModelUsage(usage1)
+    ? usage2.raw
+    : isNullLanguageModelUsage(usage2)
+      ? usage1.raw
+      : undefined;
+
   return {
     inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
     inputTokenDetails: {
@@ -171,9 +177,24 @@ export function addLanguageModelUsage(
       usage1.cachedInputTokens,
       usage2.cachedInputTokens,
     ),
+    ...(raw == null ? {} : { raw }),
   };
 }
 
+function isNullLanguageModelUsage(usage: LanguageModelUsage): boolean {
+  return (
+    usage.inputTokens == null &&
+    usage.inputTokenDetails?.noCacheTokens == null &&
+    usage.inputTokenDetails?.cacheReadTokens == null &&
+    usage.inputTokenDetails?.cacheWriteTokens == null &&
+    usage.outputTokens == null &&
+    usage.outputTokenDetails?.textTokens == null &&
+    usage.outputTokenDetails?.reasoningTokens == null &&
+    usage.totalTokens == null &&
+    usage.raw == null
+  );
+}
+
 function addTokenCounts(
   tokenCount1: number | undefined,
   tokenCount2: number | undefined,

package/src/ui/chat.ts

@@ -314,7 +314,12 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     status: ChatStatus;
     error?: Error;
   }) {
-    if (this.status === status) return;
+    if (this.status === status) {
+      if (this.error !== error) {
+        this.state.error = error;
+      }
+      return;
+    }
 
     this.state.status = status;
     this.state.error = error;

package/src/ui/convert-to-model-messages.ts

@@ -10,6 +10,7 @@ import {
 import type { ToolSet } from '../generate-text/tool-set';
 import { createToolModelOutput } from '../prompt/create-tool-model-output';
 import { MessageConversionError } from '../prompt/message-conversion-error';
+import { getOwn } from '../util/get-own';
 import {
   getToolName,
   isDataUIPart,
@@ -27,6 +28,7 @@ import {
   type ToolUIPart,
   type UIMessage,
 } from './ui-messages';
+import { isToolPartFromUnavailableTool } from './unavailable-tool';
 
 /**
  * Converts an array of UI messages from useChat into an array of ModelMessages that can be used
@@ -65,6 +67,39 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
     }));
   }
 
+  async function createModelOutput({
+    toolPart,
+    toolName,
+    output,
+    errorMode,
+  }: {
+    toolPart: ToolUIPart<InferUIMessageTools<UI_MESSAGE>> | DynamicToolUIPart;
+    toolName: string;
+    output: unknown;
+    errorMode: 'none' | 'text' | 'json';
+  }) {
+    const tool = getOwn(options?.tools, toolName);
+
+    if (
+      errorMode === 'none' &&
+      tool == null &&
+      isToolPartFromUnavailableTool(toolPart)
+    ) {
+      return {
+        type: 'text' as const,
+        value: 'Tool output omitted because the tool is no longer available.',
+      };
+    }
+
+    return createToolModelOutput({
+      toolCallId: toolPart.toolCallId,
+      input: toolPart.input,
+      output,
+      tool,
+      errorMode,
+    });
+  }
+
   for (const message of messages) {
     switch (message.role) {
       case 'system': {
@@ -231,14 +266,13 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                       type: 'tool-result',
                       toolCallId: part.toolCallId,
                       toolName,
-                      output: await createToolModelOutput({
-                        toolCallId: part.toolCallId,
-                        input: part.input,
+                      output: await createModelOutput({
+                        toolPart: part,
+                        toolName,
                         output:
                           part.state === 'output-error'
                             ? part.errorText
                             : part.output,
-                        tool: options?.tools?.[toolName],
                         errorMode:
                           part.state === 'output-error' ? 'json' : 'none',
                       }),
@@ -331,14 +365,13 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                         type: 'tool-result',
                         toolCallId: toolPart.toolCallId,
                         toolName,
-                        output: await createToolModelOutput({
-                          toolCallId: toolPart.toolCallId,
-                          input: toolPart.input,
+                        output: await createModelOutput({
+                          toolPart,
+                          toolName,
                           output:
                             toolPart.state === 'output-error'
                               ? toolPart.errorText
                               : toolPart.output,
-                          tool: options?.tools?.[toolName],
                           errorMode:
                             toolPart.state === 'output-error' ? 'text' : 'none',
                         }),

package/src/ui/http-chat-transport.ts

@@ -11,10 +11,12 @@ import type { UIMessage } from './ui-messages';
 
 function appendPathToUrl(url: string, path: string): string {
   const queryOrFragmentStart = url.search(/[?#]/);
+  const urlPath =
+    queryOrFragmentStart === -1 ? url : url.slice(0, queryOrFragmentStart);
+  const suffix =
+    queryOrFragmentStart === -1 ? '' : url.slice(queryOrFragmentStart);
 
-  return queryOrFragmentStart === -1
-    ? `${url}${path}`
-    : `${url.slice(0, queryOrFragmentStart)}${path}${url.slice(queryOrFragmentStart)}`;
+  return `${urlPath.endsWith('/') && path.startsWith('/') ? urlPath.slice(0, -1) : urlPath}${path}${suffix}`;
 }
 
 export type PrepareSendMessagesRequest<UI_MESSAGE extends UIMessage> = (

package/src/ui/ui-messages.ts

@@ -348,6 +348,14 @@ export type ToolUIPart<TOOLS extends UITools = UITools> = ValueOf<{
 export type DynamicToolUIPart = {
   type: 'dynamic-tool';
 
+  /**
+   * `false` when a static tool part was normalized to a dynamic tool part
+   * because its current tool schema was unavailable or incompatible.
+   *
+   * This preserves its static origin across persistence boundaries.
+   */
+  dynamic?: false;
+
   /**
    * Name of the tool that is being called.
    */

package/src/ui/unavailable-tool.ts

@@ -0,0 +1,17 @@
+import type { DynamicToolUIPart, ToolUIPart } from './ui-messages';
+
+export function markToolPartAsUnavailable(
+  part: DynamicToolUIPart,
+): DynamicToolUIPart {
+  // Preserve the static tool's provenance across persistence boundaries so
+  // model-message conversion never falls back to its unfiltered raw output.
+  part.dynamic = false;
+
+  return part;
+}
+
+export function isToolPartFromUnavailableTool(
+  part: ToolUIPart | DynamicToolUIPart,
+): boolean {
+  return part.type === 'dynamic-tool' && part.dynamic === false;
+}

package/src/ui/validate-ui-messages.ts

@@ -15,6 +15,7 @@ import {
 import { z } from 'zod/v4';
 import { InvalidArgumentError } from '../error';
 import { jsonValueSchema } from '../types/json-value';
+import { getOwn } from '../util/get-own';
 import { isDeepEqualData } from '../util/is-deep-equal-data';
 import { providerMetadataSchema } from '../types/provider-metadata';
 import type {
@@ -25,6 +26,7 @@ import type {
   ToolUIPart,
   UIMessage,
 } from './ui-messages';
+import { markToolPartAsUnavailable } from './unavailable-tool';
 
 const toolMetadataSchema: z.ZodType<JSONObject> = z.record(
   z.string(),
@@ -43,11 +45,11 @@ function isEmptyObject(value: unknown): value is Record<string, never> {
 function asDynamicToolPart(toolPart: ToolUIPart): DynamicToolUIPart {
   const { type, ...part } = toolPart;
 
-  return {
+  return markToolPartAsUnavailable({
     ...part,
     type: 'dynamic-tool',
     toolName: type.slice(5),
-  } as DynamicToolUIPart;
+  } as DynamicToolUIPart);
 }
 
 function getToolPartInputSchemaInput(
@@ -134,6 +136,7 @@ const uiMessagesSchema = lazySchema(() => {
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
+                  dynamic: z.literal(false).optional(),
                   toolName: z.string(),
                   toolCallId: z.string(),
                   toolMetadata: toolMetadataSchema.optional(),
@@ -148,6 +151,7 @@ const uiMessagesSchema = lazySchema(() => {
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
+                  dynamic: z.literal(false).optional(),
                   toolName: z.string(),
                   toolCallId: z.string(),
                   toolMetadata: toolMetadataSchema.optional(),
@@ -161,6 +165,7 @@ const uiMessagesSchema = lazySchema(() => {
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
+                  dynamic: z.literal(false).optional(),
                   toolName: z.string(),
                   toolCallId: z.string(),
                   toolMetadata: toolMetadataSchema.optional(),
@@ -174,6 +179,7 @@ const uiMessagesSchema = lazySchema(() => {
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
+                  dynamic: z.literal(false).optional(),
                   toolName: z.string(),
                   toolCallId: z.string(),
                   toolMetadata: toolMetadataSchema.optional(),
@@ -187,6 +193,7 @@ const uiMessagesSchema = lazySchema(() => {
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
+                  dynamic: z.literal(false).optional(),
                   toolName: z.string(),
                   toolCallId: z.string(),
                   toolMetadata: toolMetadataSchema.optional(),
@@ -202,6 +209,7 @@ const uiMessagesSchema = lazySchema(() => {
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
+                  dynamic: z.literal(false).optional(),
                   toolName: z.string(),
                   toolCallId: z.string(),
                   toolMetadata: toolMetadataSchema.optional(),
@@ -217,6 +225,7 @@ const uiMessagesSchema = lazySchema(() => {
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
+                  dynamic: z.literal(false).optional(),
                   toolName: z.string(),
                   toolCallId: z.string(),
                   toolMetadata: toolMetadataSchema.optional(),
@@ -451,7 +460,7 @@ async function safeValidateUIMessagesInternal<UI_MESSAGE extends UIMessage>(
               InferUIMessageTools<UI_MESSAGE>
             >;
             const toolName = toolPart.type.slice(5);
-            const tool = tools?.[toolName];
+            const tool = getOwn(tools, toolName);
             const isTerminal =
               toolPart.state === 'output-available' ||
               toolPart.state === 'output-error' ||