ai 7.0.120 → 7.0.123

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

@@ -5,6 +5,7 @@ import {
   type Resolvable,
 } from '@ai-sdk/provider-utils';
 import { EmptyResponseBodyError } from '@ai-sdk/provider';
+import { InvalidArgumentError } from '../error/invalid-argument-error';
 import type { UIMessageChunk } from '../ui-message-stream/ui-message-chunks';
 import type { ChatTransport } from './chat-transport';
 import { createUIApiCallError } from './create-ui-api-call-error';
@@ -247,9 +248,24 @@ export abstract class HttpChatTransport<
       requestMetadata: options.metadata,
     });
 
-    const api =
-      preparedRequest?.api ??
-      appendPathToUrl(this.api, `/${options.chatId}/stream`);
+    let api = preparedRequest?.api;
+    if (api == null) {
+      // encodeURIComponent leaves dot segments unchanged, and URL parsers
+      // normalize them even when their dots are percent-encoded.
+      if (options.chatId === '.' || options.chatId === '..') {
+        throw new InvalidArgumentError({
+          parameter: 'chatId',
+          value: options.chatId,
+          message:
+            'Chat IDs must not be "." or ".." when using the default reconnect URL.',
+        });
+      }
+
+      api = appendPathToUrl(
+        this.api,
+        `/${encodeURIComponent(options.chatId)}/stream`,
+      );
+    }
     const headers =
       preparedRequest?.headers !== undefined
         ? normalizeHeaders(preparedRequest.headers)

package/src/ui/last-assistant-message-is-complete-with-tool-calls.ts

@@ -2,7 +2,9 @@ import { isToolUIPart, type UIMessage } from './ui-messages';
 /**
  * Check if the last message is an assistant message with completed tool calls.
  * The last step of the message must have at least one tool invocation and
- * all tool invocations must have a result.
+ * all tool invocations must have a result. Completed model text may follow
+ * the tool invocation because client-side tool results update parts in place,
+ * but trailing text without a completed stream state prevents resubmission.
  */
 export function lastAssistantMessageIsCompleteWithToolCalls({
   messages,
@@ -23,13 +25,23 @@ export function lastAssistantMessageIsCompleteWithToolCalls({
     return part.type === 'step-start' ? index : lastIndex;
   }, -1);
 
-  const lastStepToolInvocations = message.parts
-    .slice(lastStepStartIndex + 1)
+  const lastStepParts = message.parts.slice(lastStepStartIndex + 1);
+
+  const lastStepToolInvocations = lastStepParts
     .filter(isToolUIPart)
     .filter(part => !part.providerExecuted);
 
+  const lastToolInvocationIndex = lastStepParts.reduce(
+    (lastIndex, part, index) =>
+      isToolUIPart(part) && !part.providerExecuted ? index : lastIndex,
+    -1,
+  );
+
   return (
     lastStepToolInvocations.length > 0 &&
+    !lastStepParts
+      .slice(lastToolInvocationIndex + 1)
+      .some(part => part.type === 'text' && part.state !== 'done') &&
     lastStepToolInvocations.every(
       part =>
         (part.state === 'output-available' && part.preliminary !== true) ||

package/src/ui/process-ui-message-stream.ts

@@ -60,22 +60,55 @@ export function createStreamingUIMessageState<UI_MESSAGE extends UIMessage>({
   lastMessage: UI_MESSAGE | undefined;
   messageId: string;
 }): StreamingUIMessageState<UI_MESSAGE> {
+  const message =
+    lastMessage?.role === 'assistant'
+      ? lastMessage
+      : ({
+          id: messageId,
+          metadata: undefined,
+          role: 'assistant',
+          parts: [] as UIMessagePart<
+            InferUIMessageData<UI_MESSAGE>,
+            InferUIMessageTools<UI_MESSAGE>
+          >[],
+        } as UI_MESSAGE);
+  const partialToolCalls: StreamingUIMessageState<UI_MESSAGE>['partialToolCalls'] =
+    createIdMap();
+  const lastStepStartIndex = message.parts.findLastIndex(
+    part => part.type === 'step-start',
+  );
+  let staticToolIndex = 0;
+
+  for (const part of message.parts.slice(lastStepStartIndex + 1)) {
+    if (!isToolUIPart(part)) {
+      continue;
+    }
+
+    const index = staticToolIndex;
+    if (isStaticToolUIPart(part)) {
+      staticToolIndex++;
+    }
+
+    if (part.state !== 'input-streaming') {
+      continue;
+    }
+
+    partialToolCalls[part.toolCallId] = {
+      text: part.rawInput ?? '',
+      index,
+      toolName:
+        part.type === 'dynamic-tool' ? part.toolName : getStaticToolName(part),
+      dynamic: part.type === 'dynamic-tool',
+      title: part.title,
+      toolMetadata: part.toolMetadata,
+    };
+  }
+
   return {
-    message:
-      lastMessage?.role === 'assistant'
-        ? lastMessage
-        : ({
-            id: messageId,
-            metadata: undefined,
-            role: 'assistant',
-            parts: [] as UIMessagePart<
-              InferUIMessageData<UI_MESSAGE>,
-              InferUIMessageTools<UI_MESSAGE>
-            >[],
-          } as UI_MESSAGE),
+    message,
     activeTextParts: createIdMap(),
     activeReasoningParts: createIdMap(),
-    partialToolCalls: createIdMap(),
+    partialToolCalls,
   };
 }
 
@@ -185,6 +218,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
               | {
                   state: 'input-streaming';
                   input: unknown;
+                  rawInput?: string;
                   providerExecuted?: boolean;
                   providerMetadata?: ProviderMetadata;
                 }
@@ -300,6 +334,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
               | {
                   state: 'input-streaming';
                   input: unknown;
+                  rawInput?: string;
                   providerMetadata?: ProviderMetadata;
                 }
               | {
@@ -340,7 +375,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
               anyPart.input = anyOptions.input;
               anyPart.output = anyOptions.output;
               anyPart.errorText = anyOptions.errorText;
-              anyPart.rawInput = anyOptions.rawInput ?? anyPart.rawInput;
+              anyPart.rawInput = anyOptions.rawInput;
               anyPart.preliminary = anyOptions.preliminary;
               if (options.title !== undefined) {
                 anyPart.title = options.title;
@@ -645,6 +680,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
                   toolName: partialToolCall.toolName,
                   state: 'input-streaming',
                   input: partialArgs,
+                  rawInput: partialToolCall.text,
                   title: partialToolCall.title,
                   toolMetadata: partialToolCall.toolMetadata,
                 });
@@ -654,6 +690,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
                   toolName: partialToolCall.toolName,
                   state: 'input-streaming',
                   input: partialArgs,
+                  rawInput: partialToolCall.text,
                   title: partialToolCall.title,
                   toolMetadata: partialToolCall.toolMetadata,
                 });

package/src/ui/ui-messages.ts

@@ -297,6 +297,13 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
   | {
       state: 'input-streaming';
       input?: DeepPartial<asUITool<TOOL>['input']> | undefined;
+      /**
+       * The raw tool input text received so far.
+       *
+       * This is used to continue input streaming when a message is persisted
+       * and later resumed.
+       */
+      rawInput?: string;
       output?: never;
       errorText?: never;
       callProviderMetadata?: ProviderMetadata;
@@ -434,6 +441,13 @@ export type DynamicToolUIPart = {
   | {
       state: 'input-streaming';
       input?: unknown;
+      /**
+       * The raw tool input text received so far.
+       *
+       * This is used to continue input streaming when a message is persisted
+       * and later resumed.
+       */
+      rawInput?: string;
       output?: never;
       errorText?: never;
       callProviderMetadata?: ProviderMetadata;

package/src/ui/validate-ui-messages.ts

@@ -154,6 +154,7 @@ const uiMessagesSchema = lazySchema(() => {
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('input-streaming'),
                   input: z.unknown().optional(),
+                  rawInput: z.string().optional(),
                   providerExecuted: z.boolean().optional(),
                   callProviderMetadata: providerMetadataSchema.optional(),
                   output: z.never().optional(),
@@ -257,6 +258,7 @@ const uiMessagesSchema = lazySchema(() => {
                   providerExecuted: z.boolean().optional(),
                   callProviderMetadata: providerMetadataSchema.optional(),
                   input: z.unknown().optional(),
+                  rawInput: z.string().optional(),
                   output: z.never().optional(),
                   errorText: z.never().optional(),
                   approval: z.never().optional(),

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/to-ui-message-chunk.ts

@@ -18,6 +18,11 @@ export type ToUIMessageChunkOptions<
   sendSources?: boolean;
   sendStart?: boolean;
   sendFinish?: boolean;
+  /**
+   * Formats stream errors, invalid tool calls, and application-executed tool
+   * errors. Provider-executed tool execution errors bypass this callback so
+   * their original error data survives model-message round trips.
+   */
   onError?: (error: unknown) => string;
   messageMetadata?: InferUIMessageMetadata<UI_MESSAGE>;
   responseMessageId?: string;
@@ -40,7 +45,7 @@ export function toUIMessageChunk<
     sendSources = false,
     sendStart = true,
     sendFinish = true,
-    onError = () => 'An error occurred.', // prevent leaking server error details to the client by default
+    onError = () => 'An error occurred.', // masks errors except provider-executed tool execution errors
     messageMetadata,
     responseMessageId,
   }: ToUIMessageChunkOptions<TOOLS, UI_MESSAGE> = {},
@@ -305,6 +310,9 @@ export function toUIMessageChunk<
     case 'tool-error': {
       const dynamic = isDynamic(part);
 
+      // Preserve provider error codes for model-message round trips and harness
+      // runtime error messages. These execution errors intentionally bypass
+      // onError; invalid tool calls and stream errors still go through it.
       return {
         type: 'tool-output-error',
         toolCallId: part.toolCallId,

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

@@ -26,7 +26,7 @@ export function toUIMessageStream<
   sendSources = false,
   sendStart = true,
   sendFinish = true,
-  onError = () => 'An error occurred.', // prevent leaking server error details to the client by default
+  onError = () => 'An error occurred.', // masks errors except provider-executed tool execution errors
   messageMetadata,
   originalMessages,
   generateMessageId,

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.

package/src/util/set-own.ts

@@ -0,0 +1,16 @@
+/**
+ * Writes an enumerable own property without invoking inherited setters such as
+ * `Object.prototype.__proto__`. Keeps the target object's prototype unchanged.
+ */
+export function setOwn<T>(
+  object: Record<string, T>,
+  key: string,
+  value: T,
+): void {
+  Object.defineProperty(object, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true,
+  });
+}