ai 7.0.105 → 7.0.107

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

@@ -3,6 +3,7 @@ import type {
   Experimental_VideoModelV4CallOptions,
   Experimental_VideoModelV4File,
   Experimental_VideoModelV4Result,
+  Experimental_VideoModelV4OperationStatusResult,
   Experimental_VideoModelV4OperationWebhook,
   Experimental_VideoModelV4FrameImage,
   Experimental_VideoModelV4FrameType,
@@ -287,7 +288,7 @@ export async function experimental_generateVideo({
     `ai/${VERSION}`,
   );
 
-  const { retry } = prepareRetries({
+  const { maxRetries, retry } = prepareRetries({
     maxRetries: maxRetriesArg,
     abortSignal,
   });
@@ -363,6 +364,7 @@ export async function experimental_generateVideo({
           callOptions,
           poll,
           webhook,
+          maxRetries,
           retry,
         });
       }
@@ -477,12 +479,14 @@ async function executeStartStatusFlow({
   callOptions,
   poll: pollConfig,
   webhook: webhookFactory,
+  maxRetries,
   retry,
 }: {
   model: Experimental_VideoModelV4;
   callOptions: Experimental_VideoModelV4CallOptions;
   poll?: GenerateVideoPollOptions;
   webhook?: GenerateVideoWebhookFactory;
+  maxRetries: number;
   retry: <OUTPUT>(fn: () => PromiseLike<OUTPUT>) => PromiseLike<OUTPUT>;
 }): Promise<Experimental_VideoModelV4Result> {
   // 1. If webhook and provider supports it, set up the webhook
@@ -538,6 +542,9 @@ async function executeStartStatusFlow({
   const timeoutMs = pollConfig?.timeoutMs ?? 600_000;
   const delay = pollConfig?.delay ?? defaultDelay;
   const startTime = Date.now();
+  const pollingTimeoutError = new Error(
+    `Video generation timed out after ${timeoutMs}ms.`,
+  );
 
   if (webhookReceived != null) {
     // 3a. Webhook flow: wait for webhook, then get final status
@@ -554,23 +561,67 @@ async function executeStartStatusFlow({
       // 3b. Polling flow (also used when webhooks are not supported)
       const elapsedMs = Date.now() - startTime;
       if (elapsedMs >= timeoutMs) {
-        throw new Error(`Video generation timed out after ${timeoutMs}ms.`);
+        throw pollingTimeoutError;
       }
       await delay(Math.min(intervalMs, timeoutMs - elapsedMs), {
         abortSignal: callOptions.abortSignal,
       });
       if (Date.now() - startTime >= timeoutMs) {
-        throw new Error(`Video generation timed out after ${timeoutMs}ms.`);
+        throw pollingTimeoutError;
       }
     }
 
-    const statusResult = await retry(() =>
-      model.doStatus!({
-        operation: startResult.operation,
-        abortSignal: callOptions.abortSignal,
-        headers: callOptions.headers,
-      }),
-    );
+    let statusResult: Experimental_VideoModelV4OperationStatusResult;
+    if (webhookReceived != null) {
+      statusResult = await retry(() =>
+        model.doStatus!({
+          operation: startResult.operation,
+          abortSignal: callOptions.abortSignal,
+          headers: callOptions.headers,
+        }),
+      );
+    } else {
+      const statusTimeoutController = new AbortController();
+      const statusAbortSignal = mergeAbortSignals(
+        callOptions.abortSignal,
+        statusTimeoutController.signal,
+      );
+      const statusTimeoutId = setTimeout(
+        () => statusTimeoutController.abort(pollingTimeoutError),
+        timeoutMs - (Date.now() - startTime),
+      );
+      const statusTimeoutPromise = new Promise<never>((_, reject) => {
+        statusTimeoutController.signal.addEventListener(
+          'abort',
+          () => reject(pollingTimeoutError),
+          { once: true },
+        );
+      });
+      const { retry: statusRetry } = prepareRetries({
+        maxRetries,
+        abortSignal: statusAbortSignal,
+      });
+
+      try {
+        statusResult = await Promise.race([
+          statusRetry(() =>
+            model.doStatus!({
+              operation: startResult.operation,
+              abortSignal: statusAbortSignal,
+              headers: callOptions.headers,
+            }),
+          ),
+          statusTimeoutPromise,
+        ]);
+      } catch (error) {
+        if (statusTimeoutController.signal.aborted) {
+          throw pollingTimeoutError;
+        }
+        throw error;
+      } finally {
+        clearTimeout(statusTimeoutId);
+      }
+    }
 
     if (statusResult.status === 'error') {
       throw new Error(statusResult.error);

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

@@ -19,6 +19,28 @@ function stripMarkdownCodeFenceSuffix(text: string): string {
   return text.replace(/\n?```\s*$/, '').trimEnd();
 }
 
+function getPotentialSuffixStart(text: string): number {
+  let index = text.length;
+
+  while (index > 0 && /\s/.test(text[index - 1])) {
+    index--;
+  }
+
+  let backtickCount = 0;
+  while (index > 0 && backtickCount < 3 && text[index - 1] === '`') {
+    index--;
+    backtickCount++;
+  }
+
+  if (backtickCount > 0) {
+    while (index > 0 && /\s/.test(text[index - 1])) {
+      index--;
+    }
+  }
+
+  return index;
+}
+
 /**
  * Middleware that extracts JSON from text content by stripping
  * markdown code fences and other formatting.
@@ -75,8 +97,6 @@ export function extractJsonMiddleware(options?: {
         }
       > = createIdMap();
 
-      const SUFFIX_BUFFER_SIZE = 12;
-
       return {
         stream: stream.pipeThrough(
           new TransformStream<
@@ -145,13 +165,19 @@ export function extractJsonMiddleware(options?: {
                   }
                 }
 
-                // Stream content
-                if (
-                  block.phase === 'streaming' &&
-                  block.buffer.length > SUFFIX_BUFFER_SIZE
-                ) {
-                  const toStream = block.buffer.slice(0, -SUFFIX_BUFFER_SIZE);
-                  block.buffer = block.buffer.slice(-SUFFIX_BUFFER_SIZE);
+                // Stream content while retaining anything that could still
+                // become trailing whitespace or a markdown fence suffix.
+                if (block.phase === 'streaming') {
+                  const potentialSuffixStart = getPotentialSuffixStart(
+                    block.buffer,
+                  );
+                  const toStream = block.buffer.slice(0, potentialSuffixStart);
+                  block.buffer = block.buffer.slice(potentialSuffixStart);
+
+                  if (toStream.length === 0) {
+                    return;
+                  }
+
                   controller.enqueue({
                     type: 'text-delta',
                     id: chunk.id,

package/src/middleware/simulate-streaming-middleware.ts

@@ -25,7 +25,13 @@ export function simulateStreamingMiddleware(): LanguageModelMiddleware {
             switch (part.type) {
               case 'text': {
                 if (part.text.length > 0) {
-                  controller.enqueue({ type: 'text-start', id: String(id) });
+                  controller.enqueue({
+                    type: 'text-start',
+                    id: String(id),
+                    ...(part.providerMetadata != null
+                      ? { providerMetadata: part.providerMetadata }
+                      : {}),
+                  });
                   controller.enqueue({
                     type: 'text-delta',
                     id: String(id),

package/src/middleware/wrap-provider.ts

@@ -47,5 +47,7 @@ export function wrapProvider({
     transcriptionModel: providerV4.transcriptionModel,
     speechModel: providerV4.speechModel,
     rerankingModel: providerV4.rerankingModel,
+    ...(providerV4.files != null ? { files: providerV4.files } : {}),
+    ...(providerV4.skills != null ? { skills: providerV4.skills } : {}),
   };
 }

package/src/prompt/convert-to-language-model-prompt.ts

@@ -36,7 +36,8 @@ import { MissingToolResultsError } from '../error/missing-tool-result-error';
 export async function convertToLanguageModelPrompt({
   prompt,
   supportedUrls,
-  download = createDefaultDownloadFunction(),
+  download,
+  abortSignal,
   // `provider` is only needed here to convert legacy tool output types via `mapToolResultOutput`.
   // TODO: remove in v8 when "file-id" and "image-file-id" types are removed
   provider,
@@ -44,11 +45,12 @@ export async function convertToLanguageModelPrompt({
   prompt: StandardizedPrompt;
   supportedUrls: Record<string, RegExp[]>;
   download: DownloadFunction | undefined;
+  abortSignal?: AbortSignal;
   provider?: string;
 }): Promise<LanguageModelV4Prompt> {
   const downloadedAssets = await downloadAssets(
     prompt.messages,
-    download,
+    download ?? createDefaultDownloadFunction(undefined, abortSignal),
     supportedUrls,
   );
 

package/src/prompt/create-tool-model-output.ts

@@ -1,9 +1,5 @@
 import { getErrorMessage, type JSONValue } from '@ai-sdk/provider';
-import {
-  parseJSON,
-  type Tool,
-  type ToolResultOutput,
-} from '@ai-sdk/provider-utils';
+import type { Tool, ToolResultOutput } from '@ai-sdk/provider-utils';
 
 export async function createToolModelOutput({
   toolCallId,
@@ -21,7 +17,7 @@ export async function createToolModelOutput({
   if (errorMode === 'text') {
     return { type: 'error-text', value: getErrorMessage(output) };
   } else if (errorMode === 'json') {
-    return { type: 'error-json', value: await toJSONValue(output) };
+    return { type: 'error-json', value: toJSONValue(output) };
   }
 
   if (tool?.toModelOutput) {
@@ -30,16 +26,29 @@ export async function createToolModelOutput({
 
   return typeof output === 'string'
     ? { type: 'text', value: output }
-    : { type: 'json', value: await toJSONValue(output) };
+    : { type: 'json', value: toJSONValue(output) };
 }
 
-async function toJSONValue(value: unknown): Promise<JSONValue> {
+/**
+ * Normalizes an in-process tool output to a plain JSON value
+ * (applies `toJSON`, converts `Date`, drops `undefined`, etc.)
+ * by round-tripping it through `JSON.stringify`.
+ *
+ * The parsed text is produced by `JSON.stringify` from a value that is
+ * already materialized in this process, so it is not untrusted input.
+ * `JSON.parse` is used deliberately instead of the secure parser from
+ * `@ai-sdk/provider-utils`: the secure parser rejects own `__proto__` and
+ * `constructor.prototype` keys, which are valid data in tool outputs
+ * (e.g. rows from an external API). `JSON.parse` defines `__proto__` as an
+ * own data property and never modifies the prototype chain, so preserving
+ * these keys here is safe. Do not reuse this pattern for text that comes
+ * from outside the process; use `parseJSON` / `safeParseJSON` instead.
+ */
+function toJSONValue(value: unknown): JSONValue {
   if (value === undefined) {
     return null;
   }
 
   const serialized = JSON.stringify(value);
-  return serialized === undefined
-    ? null
-    : await parseJSON({ text: serialized });
+  return serialized === undefined ? null : JSON.parse(serialized);
 }

package/src/test/mock-server-response.ts

@@ -3,7 +3,7 @@ import type { ServerResponse } from 'node:http';
 
 class MockServerResponse extends EventEmitter {
   writtenChunks: any[] = [];
-  headers: Record<string, string> = {};
+  headers: Record<string, string | string[]> = {};
   statusCode = 0;
   statusMessage = '';
   ended = false;
@@ -17,6 +17,20 @@ class MockServerResponse extends EventEmitter {
     this.ended = true;
   }
 
+  setHeaders(headers: Headers): void {
+    this.headers = {};
+
+    for (const [key, value] of headers.entries()) {
+      const existingValue = this.headers[key];
+      this.headers[key] =
+        existingValue == null
+          ? value
+          : Array.isArray(existingValue)
+            ? [...existingValue, value]
+            : [existingValue, value];
+    }
+  }
+
   writeHead(
     statusCode: number,
     arg2: string | Record<string, string>,
@@ -26,8 +40,10 @@ class MockServerResponse extends EventEmitter {
 
     if (typeof arg2 === 'string') {
       this.statusMessage = arg2;
-      this.headers = arg3 ?? {};
-    } else {
+      if (arg3 != null) {
+        this.headers = arg3;
+      }
+    } else if (arg2 != null) {
       this.statusMessage = '';
       this.headers = arg2;
     }

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

@@ -29,11 +29,9 @@ export function pipeTextStreamToResponse({
     response,
     status,
     statusText,
-    headers: Object.fromEntries(
-      prepareHeaders(headers, {
-        'content-type': 'text/plain; charset=utf-8',
-      }).entries(),
-    ),
+    headers: prepareHeaders(headers, {
+      'content-type': 'text/plain; charset=utf-8',
+    }),
     stream: stream.pipeThrough(new TextEncoderStream()),
   });
 }

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

@@ -10,6 +10,14 @@ import type { ChatTransport } from './chat-transport';
 import { createUIApiCallError } from './create-ui-api-call-error';
 import type { UIMessage } from './ui-messages';
 
+function appendPathToUrl(url: string, path: string): string {
+  const queryOrFragmentStart = url.search(/[?#]/);
+
+  return queryOrFragmentStart === -1
+    ? `${url}${path}`
+    : `${url.slice(0, queryOrFragmentStart)}${path}${url.slice(queryOrFragmentStart)}`;
+}
+
 export type PrepareSendMessagesRequest<UI_MESSAGE extends UIMessage> = (
   options: {
     id: string;
@@ -193,7 +201,7 @@ export abstract class HttpChatTransport<
     const response = await fetch(api, {
       method: 'POST',
       headers: {
-        'Content-Type': 'application/json',
+        'content-type': 'application/json',
         ...headers,
       },
       body: JSON.stringify(body),
@@ -239,7 +247,9 @@ export abstract class HttpChatTransport<
       requestMetadata: options.metadata,
     });
 
-    const api = preparedRequest?.api ?? `${this.api}/${options.chatId}/stream`;
+    const api =
+      preparedRequest?.api ??
+      appendPathToUrl(this.api, `/${options.chatId}/stream`);
     const headers =
       preparedRequest?.headers !== undefined
         ? normalizeHeaders(preparedRequest.headers)

package/src/ui/last-assistant-message-is-complete-with-approval-responses.ts

@@ -34,7 +34,7 @@ export function lastAssistantMessageIsCompleteWithApprovalResponses({
     // all tool approvals must have a response
     lastStepToolInvocations.every(
       part =>
-        part.state === 'output-available' ||
+        (part.state === 'output-available' && part.preliminary !== true) ||
         part.state === 'output-error' ||
         part.state === 'output-denied' ||
         part.state === 'approval-responded',

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

@@ -32,7 +32,8 @@ export function lastAssistantMessageIsCompleteWithToolCalls({
     lastStepToolInvocations.length > 0 &&
     lastStepToolInvocations.every(
       part =>
-        part.state === 'output-available' || part.state === 'output-error',
+        (part.state === 'output-available' && part.preliminary !== true) ||
+        part.state === 'output-error',
     )
   );
 }

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

@@ -44,9 +44,7 @@ export function pipeUIMessageStreamToResponse({
     response,
     status,
     statusText,
-    headers: Object.fromEntries(
-      prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS).entries(),
-    ),
+    headers: prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS),
     stream: sseStream.pipeThrough(new TextEncoderStream()),
   });
 }

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

@@ -65,11 +65,17 @@ export function readUIMessageStream<UI_MESSAGE extends UIMessage>({
 }): AsyncIterableStream<UI_MESSAGE> {
   let controller: ReadableStreamDefaultController<UI_MESSAGE> | undefined;
   let hasErrored = false;
+  let isCancelled = false;
+  const abortController = new AbortController();
 
   const outputStream = new ReadableStream<UI_MESSAGE>({
     start(controllerParam) {
       controller = controllerParam;
     },
+    cancel() {
+      isCancelled = true;
+      abortController.abort();
+    },
   });
 
   const state = createStreamingUIMessageState<UI_MESSAGE>({
@@ -98,17 +104,20 @@ export function readUIMessageStream<UI_MESSAGE extends UIMessage>({
         return job({
           state,
           write: () => {
-            controller?.enqueue(createUIMessageSnapshot(state.message));
+            if (!isCancelled) {
+              controller?.enqueue(createUIMessageSnapshot(state.message));
+            }
           },
         });
       },
       onError: handleError,
     }),
     onError: handleError,
+    abortSignal: abortController.signal,
   }).finally(() => {
-    // Only close if no error occurred. Calling close() on an errored controller
-    // throws "Invalid state: Controller is already closed" TypeError.
-    if (!hasErrored) {
+    // Only close if no error or cancellation occurred. Both erroring and
+    // cancelling a stream close its controller.
+    if (!hasErrored && !isCancelled) {
       controller?.close();
     }
   });

package/src/util/data-url.ts

@@ -13,6 +13,10 @@ const { atob } = globalThis;
 export function getTextFromDataUrl(dataUrl: string): string {
   const [header, base64Content] = dataUrl.split(',');
   const mediaType = header.split(';')[0].split(':')[1];
+  const charsetMatch = /(?:^|;)\s*charset\s*=\s*(?:"([^"]+)"|([^;\s]+))/i.exec(
+    header,
+  );
+  const charset = charsetMatch?.[1] ?? charsetMatch?.[2];
 
   if (mediaType == null || base64Content == null) {
     throw new InvalidArgumentError({
@@ -23,7 +27,15 @@ export function getTextFromDataUrl(dataUrl: string): string {
   }
 
   try {
-    return atob(base64Content);
+    const byteString = atob(base64Content);
+
+    if (charset == null) {
+      return byteString;
+    }
+
+    return new TextDecoder(charset).decode(
+      Uint8Array.from(byteString, byte => byte.codePointAt(0)!),
+    );
   } catch {
     throw new InvalidArgumentError({
       parameter: 'dataUrl',

package/src/util/download/download-function.ts

@@ -34,12 +34,15 @@ export type DownloadFunction = (
  * Downloads the file if it is not supported by the model.
  */
 export const createDefaultDownloadFunction =
-  (download: typeof originalDownload = originalDownload): DownloadFunction =>
+  (
+    download: typeof originalDownload = originalDownload,
+    abortSignal?: AbortSignal,
+  ): DownloadFunction =>
   requestedDownloads =>
     Promise.all(
       requestedDownloads.map(async requestedDownload =>
         requestedDownload.isUrlSupportedByModel
           ? null
-          : await download(requestedDownload),
+          : await download({ ...requestedDownload, abortSignal }),
       ),
     );

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

@@ -17,14 +17,18 @@ export function writeToServerResponse({
   response: ServerResponse;
   status?: number;
   statusText?: string;
-  headers?: Record<string, string | number | string[]>;
+  headers?: Headers;
   stream: ReadableStream<Uint8Array>;
 }): Promise<void> {
   const statusCode = status ?? 200;
+  if (headers != null) {
+    response.setHeaders(headers);
+  }
+
   if (statusText !== undefined) {
-    response.writeHead(statusCode, statusText, headers);
+    response.writeHead(statusCode, statusText);
   } else {
-    response.writeHead(statusCode, headers);
+    response.writeHead(statusCode);
   }
 
   const reader = stream.getReader();