ai 7.0.106 → 7.0.108

package/src/generate-text/stream-language-model-call.ts

@@ -373,6 +373,7 @@ export async function streamLanguageModelCall<
       messages: standardizedPrompt.messages,
       repairToolCall,
       refineToolInput,
+      abortSignal,
       callId: effectiveCallId,
       provider: resolvedModel.provider,
       modelId: resolvedModel.modelId,
@@ -400,6 +401,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
   messages,
   repairToolCall,
   refineToolInput,
+  abortSignal,
   callId,
   provider,
   modelId,
@@ -414,6 +416,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
   messages: ModelMessage[];
   repairToolCall: ToolCallRepairFunction<TOOLS> | undefined;
   refineToolInput: ToolInputRefinement<TOOLS> | undefined;
+  abortSignal: AbortSignal | undefined;
   callId: string;
   provider: string;
   modelId: string;
@@ -637,40 +640,47 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
             callbacks: onLanguageModelCallEnd,
           });
 
-          // Preserve the completed model call's usage, metadata, and
-          // performance even when response validation below surfaces a
-          // semantic error.
-          controller.enqueue({
-            type: 'model-call-end',
-            finishReason: chunk.finishReason.unified,
-            rawFinishReason: chunk.finishReason.raw,
-            usage,
-            providerMetadata: chunk.providerMetadata,
-            performance,
-          });
-
           const enforcedToolChoice =
             toolChoice.type === 'required' || toolChoice.type === 'tool'
               ? toolChoice
               : undefined;
 
-          if (
+          const toolChoiceViolationError =
             enforcedToolChoice != null &&
             ![...toolCallsByToolCallId.values()].some(
               toolCall =>
                 enforcedToolChoice.type === 'required' ||
                 toolCall.toolName === enforcedToolChoice.toolName,
             )
-          ) {
+              ? new ToolChoiceViolationError({
+                  toolChoice: enforcedToolChoice,
+                  finishReason: chunk.finishReason.unified,
+                  provider,
+                  modelId,
+                  content: rawModelCallContent,
+                })
+              : undefined;
+
+          // Preserve the completed model call's usage, metadata, and
+          // performance even when response validation below surfaces a
+          // semantic error. Prevent invalid tool calls from being executed
+          // when the model-call-end event reaches the tool executor.
+          controller.enqueue({
+            type: 'model-call-end',
+            finishReason:
+              toolChoiceViolationError == null
+                ? chunk.finishReason.unified
+                : 'error',
+            rawFinishReason: chunk.finishReason.raw,
+            usage,
+            providerMetadata: chunk.providerMetadata,
+            performance,
+          });
+
+          if (toolChoiceViolationError != null) {
             controller.enqueue({
               type: 'error',
-              error: new ToolChoiceViolationError({
-                toolChoice: enforcedToolChoice,
-                finishReason: chunk.finishReason.unified,
-                provider,
-                modelId,
-                content: rawModelCallContent,
-              }),
+              error: toolChoiceViolationError,
             });
             break;
           }
@@ -688,6 +698,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
               refineToolInput,
               instructions,
               messages,
+              abortSignal,
             });
 
             toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);

package/src/generate-text/stream-text.ts

@@ -2675,7 +2675,7 @@ class DefaultStreamTextResult<
               tools: stepExecutionTools as TOOLS,
               stepInputMessages: stepMessages,
               abortSignal,
-              runtimeContext,
+              toolsContext,
             });
 
           // Create child spans under the current step context.

package/src/generate-text/tool-call-repair-function.ts

@@ -17,6 +17,7 @@ import type { ToolSet } from '@ai-sdk/provider-utils';
  * @param options.tools - The tools that are available.
  * @param options.inputSchema - A function that returns the JSON Schema for a tool.
  * @param options.error - The error that occurred while parsing the tool call.
+ * @param options.abortSignal - An optional signal for cancelling the repair.
  */
 export type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
   instructions: Instructions | undefined;
@@ -29,4 +30,5 @@ export type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
   tools: TOOLS;
   inputSchema: (options: { toolName: string }) => PromiseLike<JSONSchema7>;
   error: NoSuchToolError | InvalidToolInputError;
+  abortSignal?: AbortSignal;
 }) => Promise<LanguageModelV4ToolCall | null>;

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/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/model/as-language-model-v4.ts

@@ -1,8 +1,20 @@
-import type {
-  LanguageModelV2,
-  LanguageModelV3,
-  LanguageModelV4,
+import {
+  type LanguageModelV2,
+  type LanguageModelV3,
+  type LanguageModelV3Content,
+  type LanguageModelV3DataContent,
+  type LanguageModelV3Prompt,
+  type LanguageModelV3StreamPart,
+  type LanguageModelV3ToolResultOutput,
+  type LanguageModelV4,
+  type LanguageModelV4CallOptions,
+  type LanguageModelV4Content,
+  type LanguageModelV4Prompt,
+  type LanguageModelV4StreamPart,
+  type LanguageModelV4ToolResultOutput,
+  type SharedV4FileData,
 } from '@ai-sdk/provider';
+import { convertUint8ArrayToBase64 } from '@ai-sdk/provider-utils';
 import { asLanguageModelV3 } from './as-language-model-v3';
 
 export function asLanguageModelV4(
@@ -18,8 +30,156 @@ export function asLanguageModelV4(
 
   return new Proxy(v3Model, {
     get(target, prop: keyof LanguageModelV3) {
-      if (prop === 'specificationVersion') return 'v4';
-      return target[prop];
+      switch (prop) {
+        case 'specificationVersion':
+          return 'v4';
+        case 'doGenerate':
+          return async (options: LanguageModelV4CallOptions) => {
+            const result = await target.doGenerate({
+              ...options,
+              prompt: convertV4PromptToV3(options.prompt),
+            });
+
+            return {
+              ...result,
+              content: result.content.map(convertV3ContentToV4),
+            };
+          };
+        case 'doStream':
+          return async (options: LanguageModelV4CallOptions) => {
+            const result = await target.doStream({
+              ...options,
+              prompt: convertV4PromptToV3(options.prompt),
+            });
+
+            return {
+              ...result,
+              stream: convertV3StreamToV4(result.stream),
+            };
+          };
+        default:
+          return target[prop];
+      }
     },
   }) as unknown as LanguageModelV4;
 }
+
+function convertV4PromptToV3(
+  prompt: LanguageModelV4Prompt,
+): LanguageModelV3Prompt {
+  return prompt.map(message => {
+    if (message.role === 'system') {
+      return message;
+    }
+
+    return {
+      ...message,
+      content: message.content.map(part => {
+        switch (part.type) {
+          case 'file':
+            return {
+              ...part,
+              data: convertV4FileDataToV3(part.data),
+            };
+          case 'tool-result':
+            return {
+              ...part,
+              output: convertV4ToolResultOutputToV3(part.output),
+            };
+          default:
+            return part;
+        }
+      }),
+    };
+  }) as LanguageModelV3Prompt;
+}
+
+function convertV4FileDataToV3(
+  data: SharedV4FileData,
+): LanguageModelV3DataContent {
+  switch (data.type) {
+    case 'data':
+      return data.data;
+    case 'url':
+      return data.url;
+    case 'reference':
+    case 'text':
+      // pass through unsupported types as is
+      return data as unknown as LanguageModelV3DataContent;
+  }
+}
+
+function convertV4ToolResultOutputToV3(
+  output: LanguageModelV4ToolResultOutput,
+): LanguageModelV3ToolResultOutput {
+  if (output.type !== 'content') {
+    return output;
+  }
+
+  return {
+    ...output,
+    value: output.value.map(part => {
+      if (part.type !== 'file') {
+        return part;
+      }
+
+      switch (part.data.type) {
+        case 'data':
+          return {
+            type: 'file-data' as const,
+            data:
+              typeof part.data.data === 'string'
+                ? part.data.data
+                : convertUint8ArrayToBase64(part.data.data),
+            mediaType: part.mediaType,
+            filename: part.filename,
+            providerOptions: part.providerOptions,
+          };
+        case 'url':
+          return {
+            type: 'file-url' as const,
+            url: part.data.url.toString(),
+            providerOptions: part.providerOptions,
+          };
+        case 'reference':
+          return {
+            type: 'file-id' as const,
+            fileId: part.data.reference,
+            providerOptions: part.providerOptions,
+          };
+        case 'text':
+          return part;
+      }
+    }),
+  } as LanguageModelV3ToolResultOutput;
+}
+
+function convertV3ContentToV4(
+  content: LanguageModelV3Content,
+): LanguageModelV4Content {
+  return content.type === 'file'
+    ? {
+        ...content,
+        data: { type: 'data', data: content.data },
+      }
+    : content;
+}
+
+function convertV3StreamToV4(
+  stream: ReadableStream<LanguageModelV3StreamPart>,
+): ReadableStream<LanguageModelV4StreamPart> {
+  return stream.pipeThrough(
+    new TransformStream<LanguageModelV3StreamPart, LanguageModelV4StreamPart>({
+      transform(chunk, controller) {
+        controller.enqueue(
+          chunk.type === 'file'
+            ? {
+                ...chunk,
+                data: { type: 'data', data: chunk.data },
+              }
+            : chunk,
+        );
+      },
+    }),
+  );
+}

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/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/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();