ai 6.0.248 → 6.0.250

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.248" : "0.0.0-test";
+var VERSION = true ? "6.0.250" : "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.248" : "0.0.0-test";
+var VERSION = true ? "6.0.250" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.248",
+  "version": "6.0.250",
   "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,9 +45,9 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@ai-sdk/gateway": "3.0.168",
+    "@ai-sdk/gateway": "3.0.170",
     "@ai-sdk/provider": "3.0.15",
-    "@ai-sdk/provider-utils": "4.0.44"
+    "@ai-sdk/provider-utils": "4.0.45"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",

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

@@ -488,6 +488,7 @@ class DefaultStreamObjectResult<
       }),
       tracer,
       endWhenDone: false,
+      endOnError: true,
       fn: async rootSpan => {
         const standardizedPrompt = await standardizePrompt({
           system,
@@ -567,6 +568,7 @@ class DefaultStreamObjectResult<
             }),
             tracer,
             endWhenDone: false,
+            endOnError: true,
             fn: async doStreamSpan => ({
               startTimestampMs: now(),
               doStreamSpan,

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

@@ -1760,6 +1760,7 @@ class DefaultStreamTextResult<
                 }),
                 tracer,
                 endWhenDone: false,
+                endOnError: true,
                 fn: async doStreamSpan => ({
                   startTimestampMs: now(), // get before the call
                   doStreamSpan,

package/src/telemetry/record-span.ts

@@ -12,12 +12,14 @@ export async function recordSpan<T>({
   attributes,
   fn,
   endWhenDone = true,
+  endOnError = endWhenDone,
 }: {
   name: string;
   tracer: Tracer;
   attributes: Attributes | PromiseLike<Attributes>;
   fn: (span: Span) => Promise<T>;
   endWhenDone?: boolean;
+  endOnError?: boolean;
 }) {
   return tracer.startActiveSpan(
     name,
@@ -40,8 +42,9 @@ export async function recordSpan<T>({
         try {
           recordErrorOnSpan(span, error);
         } finally {
-          // always stop the span when there is an error:
-          span.end();
+          if (endOnError) {
+            span.end();
+          }
         }
 
         throw error;

package/src/test/mock-tracer.ts

@@ -77,6 +77,7 @@ class MockSpan implements Span {
     time?: [number, number];
   }> = [];
   status?: SpanStatus;
+  endCalls = 0;
 
   readonly _spanContext: SpanContext = new MockSpanContext();
 
@@ -128,6 +129,7 @@ class MockSpan implements Span {
     return this;
   }
   end() {
+    this.endCalls++;
     return this;
   }
   isRecording() {

package/src/ui/chat-transport.ts

@@ -64,6 +64,7 @@ export interface ChatTransport<UI_MESSAGE extends UIMessage> {
    *
    * @param options - Configuration object containing:
    * @param options.chatId - Unique identifier for the chat session to reconnect to
+   * @param options.abortSignal - Signal to abort the reconnection request if needed
    * @param options.headers - Additional HTTP headers to include in the reconnection request
    * @param options.body - Additional JSON properties to include in the request body
    * @param options.metadata - Custom metadata to attach to the request
@@ -78,6 +79,8 @@ export interface ChatTransport<UI_MESSAGE extends UIMessage> {
     options: {
       /** Unique identifier for the chat session to reconnect to */
       chatId: string;
+      /** Signal to abort the reconnection request if needed */
+      abortSignal?: AbortSignal;
     } & ChatRequestOptions,
   ) => Promise<ReadableStream<UIMessageChunk> | null>;
 }

package/src/ui/chat.ts

@@ -136,6 +136,10 @@ type ActiveResponse<UI_MESSAGE extends UIMessage> = {
   abortController: AbortController;
 };
 
+type ActiveResumeRequest = {
+  abortController: AbortController;
+};
+
 export interface ChatState<UI_MESSAGE extends UIMessage> {
   status: ChatStatus;
 
@@ -255,6 +259,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
   private sendAutomaticallyWhen?: ChatInit<UI_MESSAGE>['sendAutomaticallyWhen'];
 
   private activeResponse: ActiveResponse<UI_MESSAGE> | undefined = undefined;
+  private activeResumeRequest: ActiveResumeRequest | undefined = undefined;
   private jobExecutor = new SerialJobExecutor();
 
   constructor({
@@ -585,11 +590,8 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
    * Abort the current request immediately, keep the generated tokens if any.
    */
   stop = async () => {
-    if (this.status !== 'streaming' && this.status !== 'submitted') return;
-
-    if (this.activeResponse?.abortController) {
-      this.activeResponse.abortController.abort();
-    }
+    this.activeResumeRequest?.abortController.abort();
+    this.activeResponse?.abortController.abort();
   };
 
   private async shouldSendAutomatically(): Promise<boolean> {
@@ -617,6 +619,25 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     trigger: 'submit-message' | 'resume-stream' | 'regenerate-message';
     messageId?: string;
   } & ChatRequestOptions) {
+    const abortController = new AbortController();
+    const activeResumeRequest =
+      trigger === 'resume-stream' ? { abortController } : undefined;
+
+    if (activeResumeRequest) {
+      this.activeResumeRequest?.abortController.abort();
+      this.activeResumeRequest = activeResumeRequest;
+    }
+
+    const isCurrentRequest = () =>
+      activeResumeRequest == null ||
+      this.activeResumeRequest === activeResumeRequest;
+
+    const clearActiveResumeRequest = () => {
+      if (this.activeResumeRequest === activeResumeRequest) {
+        this.activeResumeRequest = undefined;
+      }
+    };
+
     // For resume-stream, check if there's an active stream before
     // changing status. This avoids a brief flash of 'submitted' status
     // when there is no stream to resume (e.g. on page load).
@@ -625,21 +646,49 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       try {
         const reconnect = await this.transport.reconnectToStream({
           chatId: this.id,
+          abortSignal: abortController.signal,
           metadata,
           headers,
           body,
         });
 
+        if (abortController.signal.aborted || !isCurrentRequest()) {
+          await reconnect?.cancel().catch(() => {});
+          if (isCurrentRequest()) {
+            this.setStatus({ status: 'ready' });
+          }
+          clearActiveResumeRequest();
+          return;
+        }
+
         if (reconnect == null) {
+          this.setStatus({ status: 'ready' });
+          clearActiveResumeRequest();
           return; // no active stream found, so we do not resume
         }
 
         resumeStream = reconnect;
       } catch (err) {
+        if (
+          abortController.signal.aborted ||
+          (err as { name?: string }).name === 'AbortError'
+        ) {
+          if (isCurrentRequest()) {
+            this.setStatus({ status: 'ready' });
+          }
+          clearActiveResumeRequest();
+          return;
+        }
+
+        if (!isCurrentRequest()) {
+          return;
+        }
+
         if (this.onError && err instanceof Error) {
           this.onError(err);
         }
         this.setStatus({ status: 'error', error: err as Error });
+        clearActiveResumeRequest();
         return;
       }
     }
@@ -657,12 +706,12 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       const response = {
         state: createStreamingUIMessageState({
           lastMessage:
-            trigger === 'regenerate-message'
+            trigger === 'resume-stream' || trigger === 'regenerate-message'
               ? undefined
               : this.state.snapshot(lastMessage),
           messageId: this.generateId(),
         }),
-        abortController: new AbortController(),
+        abortController,
       } as ActiveResponse<UI_MESSAGE>;
 
       activeResponse = response;
@@ -697,10 +746,18 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
         }) => Promise<void>,
       ) =>
         // serialize the job execution to avoid race conditions:
-        this.jobExecutor.run(() =>
-          job({
+        this.jobExecutor.run(() => {
+          if (response.abortController.signal.aborted) {
+            return Promise.resolve();
+          }
+
+          return job({
             state: response.state,
             write: () => {
+              if (response.abortController.signal.aborted) {
+                return;
+              }
+
               // streaming is set on first write (before it should be "submitted")
               this.setStatus({ status: 'streaming' });
 
@@ -716,8 +773,8 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
                 this.state.pushMessage(response.state.message);
               }
             },
-          }),
-        );
+          });
+        });
 
       await consumeStream({
         stream: processUIMessageStream({
@@ -731,17 +788,33 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
             throw error;
           },
         }),
+        abortSignal: response.abortController.signal,
         onError: error => {
           throw error;
         },
       });
 
-      this.setStatus({ status: 'ready' });
+      if (isAbort) {
+        if (isCurrentRequest()) {
+          this.setStatus({ status: 'ready' });
+        }
+        return null;
+      }
+
+      if (isCurrentRequest()) {
+        this.setStatus({ status: 'ready' });
+      }
     } catch (err) {
       // Ignore abort errors as they are expected.
       if (isAbort || (err as any).name === 'AbortError') {
         isAbort = true;
-        this.setStatus({ status: 'ready' });
+        if (isCurrentRequest()) {
+          this.setStatus({ status: 'ready' });
+        }
+        return null;
+      }
+
+      if (!isCurrentRequest()) {
         return null;
       }
 
@@ -780,6 +853,8 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       if (this.activeResponse === activeResponse) {
         this.activeResponse = undefined;
       }
+
+      clearActiveResumeRequest();
     }
 
     // automatically send the message if the sendAutomaticallyWhen function returns true

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

@@ -247,6 +247,7 @@ export abstract class HttpChatTransport<
       method: 'GET',
       headers,
       credentials,
+      signal: options.abortSignal,
     });
 
     // no active stream found, so we do not resume

package/src/util/consume-stream.ts

@@ -13,11 +13,23 @@
 export async function consumeStream({
   stream,
   onError,
+  abortSignal,
 }: {
   stream: ReadableStream;
   onError?: (error: unknown) => void;
+  abortSignal?: AbortSignal;
 }): Promise<void> {
   const reader = stream.getReader();
+  const cancelOnAbort = () => {
+    reader.cancel().catch(() => {});
+  };
+
+  if (abortSignal?.aborted) {
+    cancelOnAbort();
+  } else {
+    abortSignal?.addEventListener('abort', cancelOnAbort, { once: true });
+  }
+
   try {
     while (true) {
       const { done } = await reader.read();
@@ -26,6 +38,7 @@ export async function consumeStream({
   } catch (error) {
     onError?.(error);
   } finally {
+    abortSignal?.removeEventListener('abort', cancelOnAbort);
     reader.releaseLock();
   }
 }