ai 7.0.122 → 7.0.123

package/docs/09-troubleshooting/12-use-chat-an-error-occurred.mdx

@@ -49,14 +49,16 @@ return createUIMessageStreamResponse({
 });
 ```
 
-In case you are using `createDataStreamResponse`, you can use the `onError` function when calling `toDataStreamResponse`:
+In case you are using `createUIMessageStream`, you can pass the `onError` function to it:
 
 ```tsx
-const response = createDataStreamResponse({
-  // ...
-  async execute(dataStream) {
+const response = createUIMessageStreamResponse({
+  stream: createUIMessageStream({
     // ...
-  },
-  onError: errorHandler,
+    async execute({ writer }) {
+      // ...
+    },
+    onError: errorHandler,
+  }),
 });
 ```

package/docs/09-troubleshooting/50-react-maximum-update-depth-exceeded.mdx

@@ -23,17 +23,17 @@ Use the `throttle` option to throttle the UI updates:
 ### `useChat`
 
 ```tsx filename="page.tsx" highlight="2-3"
-const { messages, ... } = useChat({
+const { messages } = useChat({
   // Throttle the messages and data updates to 50ms:
-  throttle: 50
-})
+  throttle: 50,
+});
 ```
 
 ### `useCompletion`
 
 ```tsx filename="page.tsx" highlight="2-3"
-const { completion, ... } = useCompletion({
+const { completion } = useCompletion({
   // Throttle the completion and data updates to 50ms:
-  throttle: 50
-})
+  throttle: 50,
+});
 ```

package/docs/09-troubleshooting/70-high-memory-usage-with-images.mdx

@@ -17,7 +17,7 @@ This is especially noticeable when using `experimental_download` to process imag
 
 ## Background
 
-By default, the AI SDK includes the full request messages plus request and response bodies in the step results. When processing images, the request messages and request body can contain base64-encoded image data, which can be very large (a single image can be 1MB+ when base64 encoded). If you process many images and keep references to the results, this data accumulates in memory.
+When enabled with the `include` option, the AI SDK includes the full request messages plus request and response bodies in the step results. When processing images, the request messages and request body can contain base64-encoded image data, which can be very large (a single image can be 1MB+ when base64 encoded). If you process many images and keep references to the results, this data accumulates in memory.
 
 For example, processing 100 images of 500KB each would include ~50MB+ of request body data in memory.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.122",
+  "version": "7.0.123",
   "type": "module",
   "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",
@@ -42,20 +42,20 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.100",
-    "@ai-sdk/provider": "4.0.19",
-    "@ai-sdk/provider-utils": "5.0.51"
+    "@ai-sdk/gateway": "4.0.101",
+    "@ai-sdk/provider": "4.0.20",
+    "@ai-sdk/provider-utils": "5.0.52"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.100",
-    "@ai-sdk/deepseek": "3.0.56",
-    "@ai-sdk/google": "4.0.85",
-    "@ai-sdk/groq": "4.0.52",
-    "@ai-sdk/huggingface": "2.0.59",
-    "@ai-sdk/moonshotai": "3.0.60",
-    "@ai-sdk/openai": "4.0.80",
-    "@ai-sdk/test-server": "2.0.2",
-    "@ai-sdk/xai": "5.0.12",
+    "@ai-sdk/amazon-bedrock": "5.0.102",
+    "@ai-sdk/deepseek": "3.0.57",
+    "@ai-sdk/google": "4.0.86",
+    "@ai-sdk/groq": "4.0.53",
+    "@ai-sdk/huggingface": "2.0.60",
+    "@ai-sdk/moonshotai": "3.0.61",
+    "@ai-sdk/openai": "4.0.82",
+    "@ai-sdk/test-server": "2.0.3",
+    "@ai-sdk/xai": "5.0.13",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",
@@ -63,7 +63,7 @@
     "@types/node": "22.19.19",
     "@vercel/ai-tsconfig": "0.0.0",
     "esbuild": "^0.28.1",
-    "tsup": "^8.5.1",
+    "tsdown": "^0.23.0",
     "tsx": "4.23.12",
     "typescript": "5.8.3",
     "zod": "3.25.76"
@@ -113,9 +113,9 @@
     "grok"
   ],
   "scripts": {
-    "build": "pnpm clean && tsup --tsconfig tsconfig.build.json",
-    "build:watch": "pnpm clean && tsup --watch --tsconfig tsconfig.build.json",
-    "clean": "del-cli dist docs *.tsbuildinfo",
+    "build": "pnpm clean && tsdown",
+    "build:watch": "pnpm clean && tsdown --watch",
+    "clean": "del-cli docs *.tsbuildinfo",
     "type-check": "tsc --build",
     "test": "pnpm test:node && pnpm test:edge",
     "test:update": "pnpm test:node -u",

package/src/agent/create-agent-ui-stream-response.ts

@@ -33,6 +33,7 @@ import { createAgentUIStream } from './create-agent-ui-stream';
  * @param headers - Additional headers for the response. Optional.
  * @param status - The status code for the response. Optional.
  * @param statusText - The status text for the response. Optional.
+ * @param keepAliveMs - Optional interval for sending SSE keep-alive comments.
  * @param consumeSseStream - Whether to consume the SSE stream. Optional.
  *
  * @returns The response object.
@@ -47,6 +48,7 @@ export async function createAgentUIStreamResponse<
   headers,
   status,
   statusText,
+  keepAliveMs,
   consumeSseStream,
   ...options
 }: {
@@ -68,6 +70,7 @@ export async function createAgentUIStreamResponse<
     headers,
     status,
     statusText,
+    keepAliveMs,
     consumeSseStream,
     stream: await createAgentUIStream(options),
   });

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

@@ -35,6 +35,7 @@ import { createAgentUIStream } from './create-agent-ui-stream';
  * @param headers - Additional headers for the response. Optional.
  * @param status - The status code for the response. Optional.
  * @param statusText - The status text for the response. Optional.
+ * @param keepAliveMs - Optional interval for sending SSE keep-alive comments.
  * @param consumeSseStream - Whether to consume the SSE stream. Optional.
  */
 export async function pipeAgentUIStreamToResponse<
@@ -48,6 +49,7 @@ export async function pipeAgentUIStreamToResponse<
   headers,
   status,
   statusText,
+  keepAliveMs,
   consumeSseStream,
   ...options
 }: {
@@ -71,6 +73,7 @@ export async function pipeAgentUIStreamToResponse<
     headers,
     status,
     statusText,
+    keepAliveMs,
     consumeSseStream,
     stream: await createAgentUIStream(options),
   });

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

@@ -82,7 +82,7 @@ export function pruneMessages({
     const keptToolCallIds: Set<string> = new Set();
     const keptApprovalIds: Set<string> = new Set();
 
-    if (keepLastMessagesCount != null) {
+    if (keepLastMessagesCount != null && keepLastMessagesCount !== 0) {
       for (const message of messages.slice(-keepLastMessagesCount)) {
         if (
           (message.role === 'assistant' || message.role === 'tool') &&

package/src/middleware/extract-reasoning-middleware.ts

@@ -116,20 +116,15 @@ export function extractReasoningMiddleware({
                 return;
               }
 
-              if (
-                chunk.type === 'text-end' &&
-                delayedTextStarts[chunk.id] != null
-              ) {
-                controller.enqueue(delayedTextStarts[chunk.id]);
-                delete delayedTextStarts[chunk.id];
-              }
-
-              if (chunk.type !== 'text-delta') {
+              if (chunk.type !== 'text-delta' && chunk.type !== 'text-end') {
                 controller.enqueue(chunk);
                 return;
               }
 
-              if (reasoningExtractions[chunk.id] == null) {
+              if (
+                chunk.type === 'text-delta' &&
+                reasoningExtractions[chunk.id] == null
+              ) {
                 reasoningExtractions[chunk.id] = {
                   isFirstReasoning: true,
                   isFirstText: true,
@@ -143,7 +138,14 @@ export function extractReasoningMiddleware({
 
               const activeExtraction = reasoningExtractions[chunk.id];
 
-              activeExtraction.buffer += chunk.delta;
+              if (activeExtraction == null) {
+                if (delayedTextStarts[chunk.id] != null) {
+                  controller.enqueue(delayedTextStarts[chunk.id]);
+                  delete delayedTextStarts[chunk.id];
+                }
+                controller.enqueue(chunk);
+                return;
+              }
 
               function getReasoningId() {
                 return (activeExtraction.reasoningId ??= `reasoning-${reasoningIdCounter++}`);
@@ -199,6 +201,20 @@ export function extractReasoningMiddleware({
                 }
               }
 
+              if (chunk.type === 'text-end') {
+                publish(activeExtraction.buffer);
+                activeExtraction.buffer = '';
+
+                if (delayedTextStarts[chunk.id] != null) {
+                  controller.enqueue(delayedTextStarts[chunk.id]);
+                  delete delayedTextStarts[chunk.id];
+                }
+                controller.enqueue(chunk);
+                return;
+              }
+
+              activeExtraction.buffer += chunk.delta;
+
               do {
                 const nextTag = activeExtraction.isReasoning
                   ? closingTag

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

@@ -59,16 +59,28 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
 
   warnIfUIMessageHasDeprecatedRawInput(messages);
 
-  if (options?.ignoreIncompleteToolCalls) {
-    messages = messages.map(message => ({
+  // A later user message supersedes unresolved approval requests. Keeping
+  // those requests would leave unmatched tool calls at the user boundary.
+  const lastUserMessageIndex = messages.reduce(
+    (lastIndex, message, index) =>
+      message.role === 'user' ? index : lastIndex,
+    -1,
+  );
+
+  if (options?.ignoreIncompleteToolCalls || lastUserMessageIndex > 0) {
+    messages = messages.map((message, messageIndex) => ({
       ...message,
       parts: message.parts.filter(
         part =>
           !isToolUIPart(part) ||
-          part.state === 'approval-responded' ||
-          (part.state === 'output-available' && part.preliminary !== true) ||
-          part.state === 'output-error' ||
-          part.state === 'output-denied',
+          ((part.state !== 'approval-requested' ||
+            messageIndex >= lastUserMessageIndex) &&
+            (!options?.ignoreIncompleteToolCalls ||
+              part.state === 'approval-responded' ||
+              (part.state === 'output-available' &&
+                part.preliminary !== true) ||
+              part.state === 'output-error' ||
+              part.state === 'output-denied')),
       ),
     }));
   }

package/src/ui-message-stream/create-sse-stream-with-keep-alive.ts

@@ -0,0 +1,89 @@
+const STREAM_OPEN_COMMENT = ': stream-open\n\n';
+const KEEP_ALIVE_COMMENT = ': keep-alive\n\n';
+
+export function createSseStreamWithKeepAlive({
+  stream,
+  keepAliveMs,
+}: {
+  stream: ReadableStream<string>;
+  keepAliveMs: number | undefined;
+}): ReadableStream<string> {
+  if (keepAliveMs == null) {
+    return stream;
+  }
+
+  if (
+    !Number.isFinite(keepAliveMs) ||
+    keepAliveMs <= 0 ||
+    keepAliveMs > 2_147_483_647
+  ) {
+    throw new Error(
+      'keepAliveMs must be a positive finite timer duration no greater than 2147483647',
+    );
+  }
+
+  const reader = stream.getReader();
+  let keepAliveTimeout: ReturnType<typeof setTimeout> | undefined;
+  let isCancelled = false;
+
+  const clearKeepAliveTimeout = () => {
+    clearTimeout(keepAliveTimeout);
+    keepAliveTimeout = undefined;
+  };
+
+  const scheduleKeepAlive = (
+    controller: ReadableStreamDefaultController<string>,
+  ) => {
+    clearKeepAliveTimeout();
+    keepAliveTimeout = setTimeout(() => {
+      if (isCancelled) {
+        return;
+      }
+
+      if (controller.desiredSize != null && controller.desiredSize > 0) {
+        controller.enqueue(KEEP_ALIVE_COMMENT);
+      }
+
+      scheduleKeepAlive(controller);
+    }, keepAliveMs);
+  };
+
+  return new ReadableStream<string>({
+    start(controller) {
+      controller.enqueue(STREAM_OPEN_COMMENT);
+      scheduleKeepAlive(controller);
+    },
+
+    pull(controller) {
+      return reader.read().then(
+        result => {
+          clearKeepAliveTimeout();
+
+          if (isCancelled) {
+            return;
+          }
+
+          if (result.done) {
+            controller.close();
+          } else {
+            controller.enqueue(result.value);
+            scheduleKeepAlive(controller);
+          }
+        },
+        error => {
+          clearKeepAliveTimeout();
+
+          if (!isCancelled) {
+            throw error;
+          }
+        },
+      );
+    },
+
+    async cancel(reason) {
+      isCancelled = true;
+      clearKeepAliveTimeout();
+      await reader.cancel(reason);
+    },
+  });
+}

package/src/ui-message-stream/create-ui-message-stream-response.ts

@@ -1,4 +1,5 @@
 import { prepareHeaders } from '../util/prepare-headers';
+import { createSseStreamWithKeepAlive } from './create-sse-stream-with-keep-alive';
 import { JsonToSseTransformStream } from './json-to-sse-transform-stream';
 import { UI_MESSAGE_STREAM_HEADERS } from './ui-message-stream-headers';
 import type { UIMessageChunk } from './ui-message-chunks';
@@ -12,6 +13,7 @@ import type { UIMessageStreamResponseInit } from './ui-message-stream-response-i
  * @param options.statusText - The HTTP status text for the response.
  * @param options.headers - Additional HTTP headers to include in the response.
  * @param options.stream - The UI message chunk stream to send.
+ * @param options.keepAliveMs - Optional interval for sending SSE keep-alive comments.
  * @param options.consumeSseStream - Optional callback to consume a copy of the SSE stream independently.
  *
  * @returns A `Response` object with the UI message stream as the body.
@@ -21,11 +23,15 @@ export function createUIMessageStreamResponse({
   statusText,
   headers,
   stream,
+  keepAliveMs,
   consumeSseStream,
 }: UIMessageStreamResponseInit & {
   stream: ReadableStream<UIMessageChunk>;
 }): Response {
-  let sseStream = stream.pipeThrough(new JsonToSseTransformStream());
+  let sseStream = createSseStreamWithKeepAlive({
+    stream: stream.pipeThrough(new JsonToSseTransformStream()),
+    keepAliveMs,
+  });
 
   // when the consumeSseStream is provided, we need to tee the stream
   // and send the second part to the consumeSseStream function

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

@@ -1,6 +1,7 @@
 import type { ServerResponse } from 'node:http';
 import { prepareHeaders } from '../util/prepare-headers';
 import { writeToServerResponse } from '../util/write-to-server-response';
+import { createSseStreamWithKeepAlive } from './create-sse-stream-with-keep-alive';
 import { JsonToSseTransformStream } from './json-to-sse-transform-stream';
 import { UI_MESSAGE_STREAM_HEADERS } from './ui-message-stream-headers';
 import type { UIMessageChunk } from './ui-message-chunks';
@@ -15,6 +16,7 @@ import type { UIMessageStreamResponseInit } from './ui-message-stream-response-i
  * @param options.statusText - The HTTP status text for the response.
  * @param options.headers - Additional HTTP headers to include in the response.
  * @param options.stream - The UI message chunk stream to send.
+ * @param options.keepAliveMs - Optional interval for sending SSE keep-alive comments.
  * @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.
  */
@@ -24,12 +26,16 @@ export function pipeUIMessageStreamToResponse({
   statusText,
   headers,
   stream,
+  keepAliveMs,
   consumeSseStream,
 }: {
   response: ServerResponse;
   stream: ReadableStream<UIMessageChunk>;
 } & UIMessageStreamResponseInit): Promise<void> {
-  let sseStream = stream.pipeThrough(new JsonToSseTransformStream());
+  let sseStream = createSseStreamWithKeepAlive({
+    stream: stream.pipeThrough(new JsonToSseTransformStream()),
+    keepAliveMs,
+  });
 
   // when the consumeSseStream is provided, we need to tee the stream
   // and send the second part to the consumeSseStream function

package/src/ui-message-stream/ui-message-stream-response-init.ts

@@ -3,6 +3,13 @@
  * Extends the standard `ResponseInit` with additional streaming options.
  */
 export type UIMessageStreamResponseInit = ResponseInit & {
+  /**
+   * Optional interval in milliseconds for sending SSE keep-alive comments.
+   * When set, an opening comment is sent immediately and additional comments
+   * are sent after the stream has been idle for the configured interval.
+   */
+  keepAliveMs?: number;
+
   /**
    * Optional callback to consume a copy of the SSE stream independently.
    * This is useful for logging, debugging, or processing the stream in parallel.