ai 6.0.302 → 6.0.303

package/dist/internal/index.js

@@ -164,7 +164,7 @@ function detectMediaType({
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "6.0.302" : "0.0.0-test";
+var VERSION = true ? "6.0.303" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/dist/internal/index.mjs

@@ -144,7 +144,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.302" : "0.0.0-test";
+var VERSION = true ? "6.0.303" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/docs/04-ai-sdk-ui/21-error-handling.mdx

@@ -49,6 +49,40 @@ globalThis.AI_SDK_LOG_WARNINGS = ({ warnings, provider, model }) => {
 };
 ```
 
+If your application loads multiple AI SDK versions in the same runtime, they all
+share `globalThis.AI_SDK_LOG_WARNINGS`. Each version calls the logger with its own
+arguments and warning types. The merged global type declarations prevent
+TypeScript declaration conflicts, but do not convert these arguments at runtime.
+A handler typed for only one version may therefore fail when another version
+calls it.
+
+Import `LogWarningsFunction` from every installed version that can call the logger
+and accept a union of their parameter types. For example, with AI SDK 7 installed
+as `ai` and AI SDK 6 installed under the package alias `ai-v6` (`npm:ai@6`):
+
+```ts
+import type { LogWarningsFunction as LogWarningsFunctionV7 } from 'ai';
+import type { LogWarningsFunction as LogWarningsFunctionV6 } from 'ai-v6';
+
+type LoggerOptions =
+  | Parameters<LogWarningsFunctionV7>[0]
+  | Parameters<LogWarningsFunctionV6>[0];
+
+const logger = ({ warnings, provider, model }: LoggerOptions) => {
+  for (const warning of warnings) {
+    console.warn('AI SDK Warning:', warning, { provider, model });
+  }
+};
+
+globalThis.AI_SDK_LOG_WARNINGS = logger;
+```
+
+Check the argument shape and warning type before accessing version-specific
+fields. If AI SDK 5 is also installed, include its
+`Experimental_LogWarningsFunction` parameter type and use `Array.isArray` to
+handle its warning array before accessing the options object used by AI SDK 6
+and 7.
+
 ## Error Handling
 
 ### Error Helper Object

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.302",
+  "version": "6.0.303",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@ai-sdk/gateway": "3.0.211",
+    "@ai-sdk/gateway": "3.0.212",
     "@ai-sdk/provider": "3.0.18",
     "@ai-sdk/provider-utils": "4.0.57"
   },

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/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,
@@ -572,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);
+        }
       }
     });
 
@@ -626,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,
+          );
+        }
       }
     });
 
@@ -643,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> {
@@ -665,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,
@@ -695,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();
@@ -830,6 +905,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
                 messageId: this.generateId(),
               }),
         abortController,
+        completionPromise,
       } as ActiveResponse<UI_MESSAGE>;
 
       activeResponse = response;
@@ -992,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/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-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);
+    });
+  }
 }