ai 7.0.128 → 7.0.130

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

@@ -1099,7 +1099,9 @@ export async function generateText<
               > = {};
               const blockedToolCallIds = new Set<string>();
 
-              const generatedFileDataCache = new WeakMap();
+              const generatedFileDataCache: Parameters<
+                typeof convertLanguageModelContent
+              >[0]['generatedFileDataCache'] = new WeakMap();
               const modelCallContent = await convertLanguageModelContent({
                 content: currentModelResponse.content,
                 toolCalls: stepToolCalls,

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

@@ -1849,16 +1849,30 @@ class DefaultStreamTextResult<
 
     // resilient stream that handles abort signals and errors:
     const reader = stitchableStream.stream.getReader();
+    const cancelOnAbort = () => {
+      // Result promises must settle before any potentially stalled callback.
+      this.rejectResultPromises(abortSignal?.reason);
+      // Cancelling the reader releases a pending read immediately, even when
+      // the provider body or its cancellation promise does not settle.
+      void reader.cancel(abortSignal?.reason).catch(() => {});
+    };
+    const removeAbortListener = () =>
+      abortSignal?.removeEventListener('abort', cancelOnAbort);
     let stream = new ReadableStream<InternalTextStreamPart<TOOLS>>({
       async start(controller) {
         // send start event:
         controller.enqueue({ type: 'start' });
+        abortSignal?.addEventListener('abort', cancelOnAbort, { once: true });
+        if (abortSignal?.aborted) {
+          cancelOnAbort();
+        }
       },
 
       async pull(controller) {
         // abort handling:
         async function abort() {
           isAborted = true;
+          removeAbortListener();
 
           await notify({
             event: {
@@ -1885,18 +1899,20 @@ class DefaultStreamTextResult<
         try {
           const { done, value } = await reader.read();
 
-          if (done) {
-            controller.close();
+          if (abortSignal?.aborted) {
+            await abort();
             return;
           }
 
-          if (abortSignal?.aborted) {
-            await abort();
+          if (done) {
+            removeAbortListener();
+            controller.close();
             return;
           }
 
           controller.enqueue(value);
         } catch (error) {
+          removeAbortListener();
           if (isAbortError(error) && abortSignal?.aborted) {
             await abort();
           } else {
@@ -1907,7 +1923,8 @@ class DefaultStreamTextResult<
       },
 
       cancel(reason) {
-        return stitchableStream.stream.cancel(reason);
+        removeAbortListener();
+        return reader.cancel(reason);
       },
     });
 

package/src/generate-text/tool-approval-signature.ts

@@ -3,12 +3,15 @@ import { hashCanonical, toBase64url } from '../util/canonical-hash';
 
 const encoder = new TextEncoder();
 
-function fromBase64url(str: string): Uint8Array {
+function fromBase64url(str: string) {
   return convertBase64ToUint8Array(str);
 }
 
 async function importKey(secret: string | Uint8Array): Promise<CryptoKey> {
-  const keyData = typeof secret === 'string' ? encoder.encode(secret) : secret;
+  const keyData =
+    typeof secret === 'string'
+      ? encoder.encode(secret)
+      : (secret as Uint8Array<ArrayBuffer>);
   return crypto.subtle.importKey(
     'raw',
     keyData,
@@ -26,7 +29,7 @@ function buildPayload(
   toolCallId: string,
   toolName: string,
   inputDigest: string,
-): Uint8Array {
+) {
   return encoder.encode(
     JSON.stringify([
       'ai-sdk-tool-approval-v1',
@@ -49,7 +52,7 @@ function buildLegacyPayload(
   toolCallId: string,
   toolName: string,
   inputDigest: string,
-): Uint8Array {
+) {
   return encoder.encode(
     `${approvalId}\n${toolCallId}\n${toolName}\n${inputDigest}`,
   );

package/src/global.ts

@@ -18,7 +18,8 @@ declare global {
   /**
    * The warning logger to use for the AI SDK.
    *
-   * If not set, the default logger is the console.warn function.
+   * If not set, warnings use process.emitWarning when available, otherwise
+   * console.warn. Deprecations are emitted once per code by the default logger.
    *
    * If set to false, no warnings are logged.
    */

package/src/logger/deprecations.ts

@@ -0,0 +1,72 @@
+// These codes are stable identifiers. Do not rename or reuse an existing code.
+const deprecationCodes = new Map<string, string>([
+  ['generateObject', 'AISDK_DEP_GENERATE_OBJECT'],
+  ['streamObject', 'AISDK_DEP_STREAM_OBJECT'],
+  ['experimental_generateSpeech', 'AISDK_DEP_EXPERIMENTAL_GENERATE_SPEECH'],
+  ['experimental_transcribe', 'AISDK_DEP_EXPERIMENTAL_TRANSCRIBE'],
+  ['"image" content part', 'AISDK_DEP_IMAGE_CONTENT_PART'],
+  [
+    '"tool-result" content of type "file-data"',
+    'AISDK_DEP_TOOL_RESULT_FILE_DATA',
+  ],
+  [
+    '"tool-result" content of type "file-url"',
+    'AISDK_DEP_TOOL_RESULT_FILE_URL',
+  ],
+  ['"tool-result" content of type "file-id"', 'AISDK_DEP_TOOL_RESULT_FILE_ID'],
+  [
+    '"tool-result" content of type "file-reference"',
+    'AISDK_DEP_TOOL_RESULT_FILE_REFERENCE',
+  ],
+  [
+    '"tool-result" content of type "image-data"',
+    'AISDK_DEP_TOOL_RESULT_IMAGE_DATA',
+  ],
+  [
+    '"tool-result" content of type "image-url"',
+    'AISDK_DEP_TOOL_RESULT_IMAGE_URL',
+  ],
+  [
+    '"tool-result" content of type "image-file-id"',
+    'AISDK_DEP_TOOL_RESULT_IMAGE_FILE_ID',
+  ],
+  [
+    '"tool-result" content of type "image-file-reference"',
+    'AISDK_DEP_TOOL_RESULT_IMAGE_FILE_REFERENCE',
+  ],
+  [
+    'rawInput in output-error UI message parts',
+    'AISDK_DEP_UI_MESSAGE_RAW_INPUT',
+  ],
+]);
+
+/**
+ * Escape punctuation and UTF-16 code units without losing case or collapsing
+ * distinct settings. Underscores are escaped too, so `__` separates code parts.
+ */
+function encodeCodePart(value: string): string {
+  return value.replace(
+    /[^a-zA-Z0-9]/g,
+    character =>
+      `_${character.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`,
+  );
+}
+
+export function getDeprecationCode({
+  setting,
+  provider,
+}: {
+  setting: string;
+  provider?: string;
+}): string {
+  if (provider == null) {
+    return (
+      deprecationCodes.get(setting) ??
+      `AISDK_DEP_SETTING_${encodeCodePart(setting)}`
+    );
+  }
+
+  // Provider codes are scoped to the provider, but not to a particular model or
+  // message. This works for third-party providers without changing their spec.
+  return `AISDK_DEP_PROVIDER_${encodeCodePart(provider)}__${encodeCodePart(setting)}`;
+}

package/src/logger/log-warnings.ts

@@ -1,4 +1,5 @@
 import type { Warning } from '../types';
+import { getDeprecationCode } from './deprecations';
 
 /**
  * A function for logging warnings.
@@ -87,21 +88,24 @@ export const FIRST_WARNING_INFO_MESSAGE =
   'AI SDK Warning System: To turn off warning logging, set the AI_SDK_LOG_WARNINGS global to false.';
 
 let hasLoggedBefore = false;
+const emittedDeprecationCodes = new Set<string>();
 
 function emitWarning({
   message,
   type,
+  code,
 }: {
   message: string;
   type: 'DeprecationWarning' | 'Warning';
+  code?: string;
 }) {
   if (
     typeof process !== 'undefined' &&
     typeof process.emitWarning === 'function'
   ) {
-    process.emitWarning(message, { type });
+    process.emitWarning(message, code == null ? { type } : { type, code });
   } else {
-    console.warn(message);
+    console.warn(code == null ? message : `[${code}] ${message}`);
   }
 }
 
@@ -111,7 +115,9 @@ function emitWarning({
  * The behavior can be customized via the `AI_SDK_LOG_WARNINGS` global variable:
  * - If set to `false`, warnings are suppressed.
  * - If set to a function, that function is called with the warnings.
- * - Otherwise, warnings are logged to the console using `console.warn`.
+ * - Otherwise, warnings use `process.emitWarning` when available, falling back
+ *   to `console.warn`. Deprecations have stable codes and are emitted once per
+ *   code by the default logger. Custom loggers receive every warning.
  *
  * @param options - The options containing warnings and context.
  * @param options.warnings - The warnings to log.
@@ -148,6 +154,20 @@ export const logWarnings: LogWarningsFunction = options => {
 
   // default behavior: log warnings via process.emitWarning if available, otherwise console.warn
   for (const warning of options.warnings) {
+    const code =
+      warning.type === 'deprecated'
+        ? getDeprecationCode({
+            setting: warning.setting,
+            provider: options.provider,
+          })
+        : undefined;
+    if (code != null) {
+      if (emittedDeprecationCodes.has(code)) {
+        continue;
+      }
+      emittedDeprecationCodes.add(code);
+    }
+
     const message = formatWarning({
       warning,
       provider: options.provider,
@@ -156,6 +176,7 @@ export const logWarnings: LogWarningsFunction = options => {
     emitWarning({
       message,
       type: warning.type === 'deprecated' ? 'DeprecationWarning' : 'Warning',
+      code,
     });
   }
 };
@@ -165,4 +186,5 @@ export const logWarnings: LogWarningsFunction = options => {
  */
 export const resetLogWarningsState = () => {
   hasLoggedBefore = false;
+  emittedDeprecationCodes.clear();
 };

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/prompt/convert-to-language-model-prompt.ts

@@ -123,7 +123,13 @@ export async function convertToLanguageModelPrompt({
       }
 
       lastCombinedMessage.content.push(...message.content);
-      lastCombinedMessage.providerOptions = message.providerOptions;
+      lastCombinedMessage.providerOptions =
+        lastContentPart == null
+          ? mergeObjects(
+              lastCombinedMessage.providerOptions,
+              message.providerOptions,
+            )
+          : message.providerOptions;
     } else {
       combinedMessages.push(message);
     }

package/src/realtime/encode-realtime-frame.ts

@@ -3,14 +3,19 @@ export const REALTIME_MAX_FRAME_BYTES = 128 * 1024;
 export const REALTIME_MAX_BUFFERED_BYTES = 128 * 1024;
 
 export type EncodedRealtimeFrame = {
-  data: string | ArrayBuffer | ArrayBufferView | Blob;
+  data: string | ArrayBuffer | ArrayBufferView<ArrayBuffer> | Blob;
   byteLength: number;
 };
 
 /** Serialize once, measuring the exact payload passed to the browser. */
 export function encodeRealtimeFrame(value: unknown): EncodedRealtimeFrame {
-  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value))
+  if (value instanceof ArrayBuffer)
     return { data: value, byteLength: value.byteLength };
+  if (ArrayBuffer.isView(value))
+    return {
+      data: value as ArrayBufferView<ArrayBuffer>,
+      byteLength: value.byteLength,
+    };
   if (value instanceof Blob) return { data: value, byteLength: value.size };
   const data = typeof value === 'string' ? value : JSON.stringify(value);
   if (data === undefined)

package/src/transcribe/index.ts

@@ -1,5 +1,6 @@
 import type { TranscriptionResult } from './transcribe-result';
 import { transcribe } from './transcribe';
+import { logWarnings } from '../logger/log-warnings';
 
 export { transcribe } from './transcribe';
 export { streamTranscribe as experimental_streamTranscribe } from './stream-transcribe';
@@ -20,7 +21,18 @@ export type {
 /**
  * @deprecated Use `transcribe` instead.
  */
-const experimental_transcribe = transcribe;
+const experimental_transcribe: typeof transcribe = options => {
+  logWarnings({
+    warnings: [
+      {
+        type: 'deprecated',
+        setting: 'experimental_transcribe',
+        message: 'Use transcribe instead.',
+      },
+    ],
+  });
+  return transcribe(options);
+};
 export { experimental_transcribe };
 
 /**

package/src/types/index.ts

@@ -7,6 +7,7 @@ export type { ImageModelResponseMetadata } from './image-model-response-metadata
 export type { JSONValue } from './json-value';
 export type {
   CallWarning,
+  CallWarningRegistry,
   FinishReason,
   LanguageModel,
   ToolChoice,

package/src/types/language-model.ts

@@ -80,11 +80,19 @@ export type FinishReason =
   | 'error'
   | 'other';
 
+/**
+ * Registry for call warning variants. Packages that expose additional warning
+ * protocols can augment this interface.
+ */
+export interface CallWarningRegistry {
+  sharedV4: SharedV4Warning;
+}
+
 /**
  * Warning from the model provider for this call. The call will proceed, but e.g.
  * some settings might not be supported, which can lead to suboptimal results.
  */
-export type CallWarning = SharedV4Warning;
+export type CallWarning = CallWarningRegistry[keyof CallWarningRegistry];
 
 /**
  * A source that has been used as input to generate the response.

package/src/types/usage.ts

@@ -123,6 +123,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: {
@@ -151,9 +157,24 @@ export function addLanguageModelUsage(
       ),
     },
     totalTokens: addTokenCounts(usage1.totalTokens, usage2.totalTokens),
+    ...(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

@@ -315,7 +315,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;
@@ -1010,13 +1015,16 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
 
       isError = true;
 
-      // Network errors such as disconnected, timeout, etc.
-      if (
-        err instanceof TypeError &&
-        (err.message.toLowerCase().includes('fetch') ||
-          err.message.toLowerCase().includes('network'))
-      ) {
-        isDisconnect = true;
+      if (err instanceof TypeError) {
+        const message = err.message.toLowerCase();
+
+        isDisconnect =
+          // Chromium request failures; Node.js fetch failures.
+          message.includes('fetch') ||
+          // Firefox request failures; Chromium response-body failures.
+          message.includes('network') ||
+          // Safari/WebKit request and response-body failures.
+          message === 'load failed';
       }
 
       if (isDisconnect) {

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

@@ -33,6 +33,7 @@ import {
   type ToolUIPart,
   type UIMessage,
 } from './ui-messages';
+import { isToolPartFromUnavailableTool } from './unavailable-tool';
 import { warnIfUIMessageHasDeprecatedRawInput } from './warn-if-ui-message-has-deprecated-raw-input';
 /**
  * Converts an array of UI messages from useChat into an array of ModelMessages that can be used
@@ -85,6 +86,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': {
@@ -284,14 +318,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: getOwn(options?.tools, toolName),
                         errorMode:
                           part.state === 'output-error' ? 'json' : 'none',
                       }),
@@ -403,14 +436,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: getOwn(options?.tools, toolName),
                           errorMode:
                             toolPart.state === 'output-error' ? 'text' : 'none',
                         }),

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

@@ -13,10 +13,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-text-stream.ts

@@ -5,7 +5,11 @@ export async function processTextStream({
   stream: ReadableStream<Uint8Array>;
   onTextPart: (chunk: string) => Promise<void> | void;
 }): Promise<void> {
-  const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+  const reader = stream
+    .pipeThrough(
+      new TextDecoderStream() as ReadableWritablePair<string, Uint8Array>,
+    )
+    .getReader();
   while (true) {
     const { done, value } = await reader.read();
     if (done) {

package/src/ui/text-stream-chat-transport.ts

@@ -17,7 +17,9 @@ export class TextStreamChatTransport<
     stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
   ): ReadableStream<UIMessageChunk> {
     return transformTextToUiMessageStream({
-      stream: stream.pipeThrough(new TextDecoderStream()),
+      stream: stream.pipeThrough(
+        new TextDecoderStream() as ReadableWritablePair<string, Uint8Array>,
+      ),
     });
   }
 }

package/src/ui/ui-messages.ts

@@ -421,6 +421,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;
+}