ai 6.0.301 → 6.0.303

package/src/global.ts

@@ -2,8 +2,20 @@ import type { ProviderV3 } from '@ai-sdk/provider';
 import type { LogWarningsFunction } from './logger/log-warnings';
 import type { TelemetryIntegration } from './telemetry/telemetry-integration';
 
-// add AI SDK default provider to the globalThis object
+// Each installed copy contributes its own types without conflicting with other
+// versions. This is a type-only key; no symbol is created at runtime.
+declare const aiSdkGlobalsKey: unique symbol;
+
 declare global {
+  interface AISDKGlobalTypes {
+    [aiSdkGlobalsKey]: {
+      provider: ProviderV3;
+      logWarnings: LogWarningsFunction;
+      telemetry: TelemetryIntegration;
+    };
+  }
+
+  // Keep these registry-based declarations identical across major versions.
   /**
    * The default provider to use for the AI SDK.
    * String model ids are resolved to the default provider and model id.
@@ -12,7 +24,9 @@ declare global {
    *
    * @see https://ai-sdk.dev/docs/ai-sdk-core/provider-management#global-provider-configuration
    */
-  var AI_SDK_DEFAULT_PROVIDER: ProviderV3 | undefined;
+  var AI_SDK_DEFAULT_PROVIDER:
+    | AISDKGlobalTypes[keyof AISDKGlobalTypes]['provider']
+    | undefined;
 
   /**
    * The warning logger to use for the AI SDK.
@@ -21,7 +35,10 @@ declare global {
    *
    * If set to false, no warnings are logged.
    */
-  var AI_SDK_LOG_WARNINGS: LogWarningsFunction | undefined | false;
+  var AI_SDK_LOG_WARNINGS:
+    | AISDKGlobalTypes[keyof AISDKGlobalTypes]['logWarnings']
+    | undefined
+    | false;
 
   /**
    * Globally registered telemetry integrations for the AI SDK.
@@ -32,5 +49,7 @@ declare global {
    * Prefer using `registerTelemetryIntegration()` from `'ai'` instead of
    * assigning this directly.
    */
-  var AI_SDK_TELEMETRY_INTEGRATIONS: TelemetryIntegration[] | undefined;
+  var AI_SDK_TELEMETRY_INTEGRATIONS:
+    | Array<AISDKGlobalTypes[keyof AISDKGlobalTypes]['telemetry']>
+    | undefined;
 }

package/src/model/as-language-model-v3.ts

@@ -99,5 +99,9 @@ function convertV2UsageToV3(usage: LanguageModelV2Usage): LanguageModelV3Usage {
       text: undefined,
       reasoning: usage.reasoningTokens,
     },
+    raw:
+      usage.totalTokens == null
+        ? undefined
+        : { totalTokens: usage.totalTokens },
   };
 }

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

@@ -7,6 +7,7 @@ import {
 import type { FinishReason } from '../types/language-model';
 import type { UIMessageChunk } from '../ui-message-stream/ui-message-chunks';
 import { consumeStream } from '../util/consume-stream';
+import { createResolvablePromise } from '../util/create-resolvable-promise';
 import { SerialJobExecutor } from '../util/serial-job-executor';
 import type { ChatTransport } from './chat-transport';
 import { convertFileListToFileUIParts } from './convert-file-list-to-file-ui-parts';
@@ -135,12 +136,19 @@ export type ChatStatus = 'submitted' | 'streaming' | 'ready' | 'error';
 type ActiveResponse<UI_MESSAGE extends UIMessage> = {
   state: StreamingUIMessageState<UI_MESSAGE>;
   abortController: AbortController;
+  completionPromise: Promise<void>;
 };
 
 type ActiveResumeRequest = {
   abortController: AbortController;
+  completionPromise: Promise<void>;
 };
 
+type MakeRequestOptions = {
+  trigger: 'submit-message' | 'resume-stream' | 'regenerate-message';
+  messageId?: string;
+} & ChatRequestOptions;
+
 export interface ChatState<UI_MESSAGE extends UIMessage> {
   status: ChatStatus;
 
@@ -266,6 +274,8 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     | StreamingUIMessageState<UI_MESSAGE>
     | undefined = undefined;
   private jobExecutor = new SerialJobExecutor();
+  private activeStopCount = 0;
+  private stopGeneration = 0;
 
   constructor({
     generateId = generateIdFunc,
@@ -314,7 +324,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;
@@ -567,21 +582,23 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
         this.status !== 'submitted' &&
         this.sendAutomaticallyWhen
       ) {
-        this.shouldSendAutomatically().then(shouldSend => {
-          if (shouldSend) {
-            // no await to avoid deadlocking
+        const shouldSend = await this.shouldSendAutomatically();
+
+        if (shouldSend) {
+          // no await to avoid deadlocking
+          void this.runAutomaticRequest(() => {
             const messageId =
               messageIndex === -1
                 ? this.lastMessage?.id
                 : messages[messageIndex].id;
 
-            this.makeRequestForToolApproval({
+            return this.makeRequestForToolApproval({
               messageId,
               messageIndex,
               ...options,
             });
-          }
-        });
+          }, shouldSend);
+        }
       }
     });
 
@@ -621,16 +638,20 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
         this.status !== 'submitted' &&
         this.sendAutomaticallyWhen
       ) {
-        this.shouldSendAutomatically().then(shouldSend => {
-          if (shouldSend) {
-            // no await to avoid deadlocking
-            this.makeRequest({
-              trigger: 'submit-message',
-              messageId: this.lastMessage?.id,
-              ...options,
-            });
-          }
-        });
+        const shouldSend = await this.shouldSendAutomatically();
+
+        if (shouldSend) {
+          // no await to avoid deadlocking
+          void this.runAutomaticRequest(
+            () =>
+              this.makeRequest({
+                trigger: 'submit-message',
+                messageId: this.lastMessage?.id,
+                ...options,
+              }),
+            shouldSend,
+          );
+        }
       }
     });
 
@@ -638,11 +659,31 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
   addToolResult = this.addToolOutput;
 
   /**
-   * Abort the current request immediately, keep the generated tokens if any.
+   * Abort the current request, keep the generated tokens if any, and wait for
+   * the request pipeline to finish.
    */
   stop = async () => {
-    this.activeResumeRequest?.abortController.abort();
-    this.activeResponse?.abortController.abort();
+    this.activeStopCount++;
+    this.stopGeneration++;
+
+    try {
+      const activeResumeRequest = this.activeResumeRequest;
+      const activeResponse = this.activeResponse;
+
+      activeResumeRequest?.abortController.abort();
+      activeResponse?.abortController.abort();
+
+      await Promise.all([
+        activeResumeRequest?.completionPromise,
+        activeResponse?.completionPromise,
+      ]);
+
+      // Stream cancellation can complete while a processing job is still
+      // blocked in onToolCall. Drain that job and any message update it queued.
+      await this.jobExecutor.waitForIdle();
+    } finally {
+      this.activeStopCount--;
+    }
   };
 
   private async shouldSendAutomatically(): Promise<boolean> {
@@ -660,6 +701,30 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     return result as boolean;
   }
 
+  private async runAutomaticRequest(
+    request: () => Promise<void>,
+    shouldSend?: boolean,
+  ): Promise<void> {
+    const stopGeneration = this.stopGeneration;
+    const startedWhileStopping = this.activeStopCount > 0;
+
+    if (!(shouldSend ?? (await this.shouldSendAutomatically()))) {
+      return;
+    }
+
+    // A stop invalidates automatic requests that were pending when it started,
+    // including requests queued by callback-driven tool updates.
+    if (
+      startedWhileStopping ||
+      stopGeneration !== this.stopGeneration ||
+      this.activeStopCount > 0
+    ) {
+      return;
+    }
+
+    await request();
+  }
+
   private async makeRequestForToolApproval({
     messageId,
     messageIndex,
@@ -690,23 +755,38 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     }
   }
 
-  private async makeRequest({
+  private async makeRequest(options: MakeRequestOptions) {
+    const completion = createResolvablePromise<void>();
+
+    try {
+      await this.makeRequestImpl({
+        ...options,
+        completionPromise: completion.promise,
+      });
+    } finally {
+      completion.resolve();
+    }
+  }
+
+  private async makeRequestImpl({
     trigger,
     metadata,
     headers,
     body,
     messageId,
-  }: {
-    trigger: 'submit-message' | 'resume-stream' | 'regenerate-message';
-    messageId?: string;
-  } & ChatRequestOptions) {
+    completionPromise,
+  }: MakeRequestOptions & {
+    completionPromise: Promise<void>;
+  }) {
     if (trigger !== 'resume-stream') {
       this.resumableStreamState = undefined;
     }
 
     const abortController = new AbortController();
     const activeResumeRequest =
-      trigger === 'resume-stream' ? { abortController } : undefined;
+      trigger === 'resume-stream'
+        ? { abortController, completionPromise }
+        : undefined;
 
     if (activeResumeRequest) {
       this.activeResumeRequest?.abortController.abort();
@@ -825,6 +905,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
                 messageId: this.generateId(),
               }),
         abortController,
+        completionPromise,
       } as ActiveResponse<UI_MESSAGE>;
 
       activeResponse = response;
@@ -987,14 +1068,16 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     }
 
     // automatically send the message if the sendAutomaticallyWhen function returns true
-    if (!isError && (await this.shouldSendAutomatically())) {
-      await this.makeRequest({
-        trigger: 'submit-message',
-        messageId: this.lastMessage?.id,
-        metadata,
-        headers,
-        body,
-      });
+    if (!isAbort && !isError) {
+      await this.runAutomaticRequest(() =>
+        this.makeRequest({
+          trigger: 'submit-message',
+          messageId: this.lastMessage?.id,
+          metadata,
+          headers,
+          body,
+        }),
+      );
     }
   }
 }

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/process-ui-message-stream.ts

@@ -120,6 +120,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
   onError,
   onToolCall,
   onData,
+  resetStateOnMessageIdChange = false,
 }: {
   // input stream is not fully typed yet:
   stream: ReadableStream<UIMessageChunk>;
@@ -136,6 +137,8 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
     }) => Promise<void>,
   ) => Promise<void>;
   onError: ErrorHandler;
+  // During resume, a different message ID identifies a separate response.
+  resetStateOnMessageIdChange?: boolean;
 }): ReadableStream<InferUIMessageChunk<UI_MESSAGE>> {
   return stream.pipeThrough(
     new TransformStream<UIMessageChunk, InferUIMessageChunk<UI_MESSAGE>>({
@@ -878,6 +881,24 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
             }
 
             case 'start': {
+              if (
+                resetStateOnMessageIdChange &&
+                chunk.messageId != null &&
+                chunk.messageId !== state.message.id
+              ) {
+                // Start the separate response with empty parts and metadata.
+                // Reset the active-part maps too, so earlier chunks stay with
+                // the previous response. Keep the state object for its callers.
+                Object.assign(
+                  state,
+                  createStreamingUIMessageState({
+                    lastMessage: undefined,
+                    messageId: chunk.messageId,
+                  }),
+                  { finishReason: undefined },
+                );
+              }
+
               if (chunk.messageId != null) {
                 state.message.id = chunk.messageId;
               }

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' ||

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

@@ -95,6 +95,7 @@ export function readUIMessageStream<UI_MESSAGE extends UIMessage>({
   consumeStream({
     stream: processUIMessageStream({
       stream,
+      resetStateOnMessageIdChange: true,
       runUpdateMessageJob(
         job: (options: {
           state: StreamingUIMessageState<UI_MESSAGE>;

package/src/util/serial-job-executor.ts

@@ -3,6 +3,7 @@ import type { Job } from './job';
 export class SerialJobExecutor {
   private queue: Array<Job> = [];
   private isProcessing = false;
+  private idleWaiters: Array<() => void> = [];
 
   private async processQueue() {
     if (this.isProcessing) {
@@ -11,12 +12,18 @@ export class SerialJobExecutor {
 
     this.isProcessing = true;
 
-    while (this.queue.length > 0) {
-      await this.queue[0]();
-      this.queue.shift();
-    }
+    try {
+      while (this.queue.length > 0) {
+        await this.queue[0]();
+        this.queue.shift();
+      }
+    } finally {
+      this.isProcessing = false;
 
-    this.isProcessing = false;
+      for (const resolve of this.idleWaiters.splice(0)) {
+        resolve();
+      }
+    }
   }
 
   async run(job: Job): Promise<void> {
@@ -33,4 +40,14 @@ export class SerialJobExecutor {
       void this.processQueue();
     });
   }
+
+  async waitForIdle(): Promise<void> {
+    if (!this.isProcessing && this.queue.length === 0) {
+      return;
+    }
+
+    await new Promise<void>(resolve => {
+      this.idleWaiters.push(resolve);
+    });
+  }
 }