ai 7.0.34 → 7.0.35

package/src/prompt/request-options.ts

@@ -5,7 +5,8 @@ import type { ToolSet } from '@ai-sdk/provider-utils';
  * - A number representing milliseconds
  * - An object with `totalMs` property for the total timeout in milliseconds
  * - An object with `stepMs` property for the timeout of each step in milliseconds
- * - An object with `chunkMs` property for the timeout between stream chunks (streaming only)
+ * - An object with `firstChunkMs` property for the timeout until the first content chunk of each step (streaming only)
+ * - An object with `chunkMs` property for the timeout between content chunks (streaming only)
  * - An object with `toolMs` property for the default timeout for all tool executions
  * - An object with `tools` property for per-tool timeout overrides using `{toolName}Ms` keys
  */
@@ -14,6 +15,7 @@ export type TimeoutConfiguration<TOOLS extends ToolSet> =
   | {
       totalMs?: number;
       stepMs?: number;
+      firstChunkMs?: number;
       chunkMs?: number;
       toolMs?: number;
       tools?: Partial<Record<`${keyof TOOLS & string}Ms`, number>>;
@@ -52,9 +54,25 @@ export function getStepTimeoutMs(
   return timeout.stepMs;
 }
 
+/**
+ * Extracts the first chunk timeout value in milliseconds from a TimeoutConfiguration.
+ * This timeout is for streaming only - it aborts if no content chunk is received within the specified duration.
+ *
+ * @param timeout - The timeout configuration.
+ * @returns The first chunk timeout in milliseconds, or undefined if no first chunk timeout is configured.
+ */
+export function getFirstChunkTimeoutMs(
+  timeout: TimeoutConfiguration<any> | undefined,
+): number | undefined {
+  if (timeout == null || typeof timeout === 'number') {
+    return undefined;
+  }
+  return timeout.firstChunkMs;
+}
+
 /**
  * Extracts the chunk timeout value in milliseconds from a TimeoutConfiguration.
- * This timeout is for streaming only - it aborts if no new chunk is received within the specified duration.
+ * This timeout is for streaming only - it aborts if no new content chunk is received within the specified duration.
  *
  * @param timeout - The timeout configuration.
  * @returns The chunk timeout in milliseconds, or undefined if no chunk timeout is configured.

package/src/text-stream/pipe-text-stream-to-response.ts

@@ -13,6 +13,7 @@ import { writeToServerResponse } from '../util/write-to-server-response';
  * @param options.statusText - Optional HTTP status text.
  * @param options.headers - Optional response headers.
  * @param options.stream - The text stream to pipe.
+ * @returns A promise that resolves when the stream has been written.
  */
 export function pipeTextStreamToResponse({
   response,
@@ -23,8 +24,8 @@ export function pipeTextStreamToResponse({
 }: {
   response: ServerResponse;
   stream: ReadableStream<string>;
-} & ResponseInit): void {
-  writeToServerResponse({
+} & ResponseInit): Promise<void> {
+  return writeToServerResponse({
     response,
     status,
     statusText,

package/src/ui-message-stream/pipe-ui-message-stream-to-response.ts

@@ -16,6 +16,7 @@ import type { UIMessageStreamResponseInit } from './ui-message-stream-response-i
  * @param options.headers - Additional HTTP headers to include in the response.
  * @param options.stream - The UI message chunk stream to send.
  * @param options.consumeSseStream - Optional callback to consume a copy of the SSE stream independently.
+ * @returns A promise that resolves when the stream has been written.
  */
 export function pipeUIMessageStreamToResponse({
   response,
@@ -27,7 +28,7 @@ export function pipeUIMessageStreamToResponse({
 }: {
   response: ServerResponse;
   stream: ReadableStream<UIMessageChunk>;
-} & UIMessageStreamResponseInit): void {
+} & UIMessageStreamResponseInit): Promise<void> {
   let sseStream = stream.pipeThrough(new JsonToSseTransformStream());
 
   // when the consumeSseStream is provided, we need to tee the stream
@@ -39,7 +40,7 @@ export function pipeUIMessageStreamToResponse({
     consumeSseStream({ stream: stream2 }); // no await (do not block the response)
   }
 
-  writeToServerResponse({
+  return writeToServerResponse({
     response,
     status,
     statusText,

package/src/util/create-stitchable-stream.ts

@@ -8,11 +8,21 @@ import { createResolvablePromise } from './create-resolvable-promise';
  */
 export function createStitchableStream<T>(): {
   stream: ReadableStream<T>;
-  addStream: (innerStream: ReadableStream<T>) => void;
+  addStream: (
+    innerStream: ReadableStream<T>,
+    callbacks?: {
+      onError?: (error: unknown) => void;
+      onCancel?: () => void;
+    },
+  ) => void;
   close: () => void;
   terminate: () => void;
 } {
-  let innerStreamReaders: ReadableStreamDefaultReader<T>[] = [];
+  let innerStreams: Array<{
+    reader: ReadableStreamDefaultReader<T>;
+    onError?: (error: unknown) => void;
+    onCancel?: () => void;
+  }> = [];
   let controller: ReadableStreamDefaultController<T> | null = null;
   let isClosed = false;
   let waitForNewStream = createResolvablePromise<void>();
@@ -21,34 +31,39 @@ export function createStitchableStream<T>(): {
     isClosed = true;
     waitForNewStream.resolve();
 
-    innerStreamReaders.forEach(reader => reader.cancel());
-    innerStreamReaders = [];
+    innerStreams.forEach(({ reader, onCancel }) => {
+      onCancel?.();
+      reader.cancel();
+    });
+    innerStreams = [];
     controller?.close();
   };
 
   const processPull = async () => {
     // Case 1: Outer stream is closed and no more inner streams
-    if (isClosed && innerStreamReaders.length === 0) {
+    if (isClosed && innerStreams.length === 0) {
       controller?.close();
       return;
     }
 
     // Case 2: No inner streams available, but outer stream is open
     // wait for a new inner stream to be added or the outer stream to close
-    if (innerStreamReaders.length === 0) {
+    if (innerStreams.length === 0) {
       waitForNewStream = createResolvablePromise<void>();
       await waitForNewStream.promise;
       return await processPull();
     }
 
+    const currentStream = innerStreams[0];
+
     try {
-      const { value, done } = await innerStreamReaders[0].read();
+      const { value, done } = await currentStream.reader.read();
 
       if (done) {
         // Case 3: Current inner stream is done
-        innerStreamReaders.shift(); // Remove the finished stream
+        innerStreams.shift(); // Remove the finished stream
 
-        if (innerStreamReaders.length === 0 && isClosed) {
+        if (innerStreams.length === 0 && isClosed) {
           // when closed and no more inner streams, stop pulling
           controller?.close();
         } else {
@@ -61,8 +76,9 @@ export function createStitchableStream<T>(): {
       }
     } catch (error) {
       // Case 5: Current inner stream throws an error
+      currentStream.onError?.(error);
       controller?.error(error);
-      innerStreamReaders.shift(); // Remove the errored stream
+      innerStreams.shift(); // Remove the errored stream
       terminate(); // we have errored, terminate all streams
     }
   };
@@ -74,19 +90,29 @@ export function createStitchableStream<T>(): {
       },
       pull: processPull,
       async cancel() {
-        for (const reader of innerStreamReaders) {
+        for (const { reader, onCancel } of innerStreams) {
+          onCancel?.();
           await reader.cancel();
         }
-        innerStreamReaders = [];
+        innerStreams = [];
         isClosed = true;
       },
     }),
-    addStream: (innerStream: ReadableStream<T>) => {
+    addStream: (
+      innerStream: ReadableStream<T>,
+      callbacks?: {
+        onError?: (error: unknown) => void;
+        onCancel?: () => void;
+      },
+    ) => {
       if (isClosed) {
         throw new Error('Cannot add inner stream: outer stream is closed');
       }
 
-      innerStreamReaders.push(innerStream.getReader());
+      innerStreams.push({
+        reader: innerStream.getReader(),
+        ...callbacks,
+      });
       waitForNewStream.resolve();
     },
 
@@ -98,7 +124,7 @@ export function createStitchableStream<T>(): {
       isClosed = true;
       waitForNewStream.resolve();
 
-      if (innerStreamReaders.length === 0) {
+      if (innerStreams.length === 0) {
         controller?.close();
       }
     },

package/src/util/write-to-server-response.ts

@@ -19,7 +19,7 @@ export function writeToServerResponse({
   statusText?: string;
   headers?: Record<string, string | number | string[]>;
   stream: ReadableStream<Uint8Array>;
-}): void {
+}): Promise<void> {
   const statusCode = status ?? 200;
   if (statusText !== undefined) {
     response.writeHead(statusCode, statusText, headers);
@@ -54,5 +54,5 @@ export function writeToServerResponse({
     }
   };
 
-  read();
+  return read();
 }