ai 7.0.54 → 7.0.56

package/src/generate-video/generate-video.ts

@@ -11,6 +11,7 @@ import type {
 import {
   convertBase64ToUint8Array,
   delay as defaultDelay,
+  generateId,
   withUserAgentSuffix,
   type DataContent,
   detectMediaType,
@@ -553,13 +554,23 @@ async function executeStartStatusFlow({
     }
   }
 
-  // 2. Start the generation
-  const startResult = await retry(() =>
-    model.doStart!({
-      ...callOptions,
-      webhookUrl,
-    }),
+  // 2. Start the generation. `doStart` is billable: mint one idempotency token
+  // per logical start, outside the retry closure; a caller-supplied key wins.
+  const callerIdempotencyKey = Object.entries(callOptions.headers ?? {}).find(
+    ([key, value]) =>
+      key.toLowerCase() === 'idempotency-key' && value !== undefined,
   );
+  const startCallOptions = {
+    ...callOptions,
+    headers: {
+      ...callOptions.headers,
+      ...(callerIdempotencyKey
+        ? {}
+        : { 'idempotency-key': `aisdk_vid_${generateId()}` }),
+    },
+    webhookUrl,
+  };
+  const startResult = await retry(() => model.doStart!(startCallOptions));
 
   const allWarnings = [...earlyWarnings, ...startResult.warnings];
   let operationProviderMetadata =

package/src/index.ts

@@ -32,6 +32,7 @@ export {
 
 // directory exports
 export * from './agent';
+export * from './batch';
 export * from './embed';
 export * from './error';
 export * from './generate-image';

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

@@ -135,6 +135,10 @@ type ActiveResponse<UI_MESSAGE extends UIMessage> = {
   abortController: AbortController;
 };
 
+type ActiveResumeRequest = {
+  abortController: AbortController;
+};
+
 export interface ChatState<UI_MESSAGE extends UIMessage> {
   status: ChatStatus;
 
@@ -254,6 +258,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({
@@ -584,11 +589,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> {
@@ -616,6 +618,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).
@@ -624,21 +645,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;
       }
     }
@@ -661,7 +710,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
               : this.state.snapshot(lastMessage),
           messageId: this.generateId(),
         }),
-        abortController: new AbortController(),
+        abortController,
       } as ActiveResponse<UI_MESSAGE>;
 
       activeResponse = response;
@@ -696,10 +745,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' });
 
@@ -715,8 +772,8 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
                 this.state.pushMessage(response.state.message);
               }
             },
-          }),
-        );
+          });
+        });
 
       await consumeStream({
         stream: processUIMessageStream({
@@ -730,17 +787,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;
       }
 
@@ -779,6 +852,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();
   }
 }