ai 7.0.106 → 7.0.107

package/docs/03-ai-sdk-core/19-tool-search.mdx

@@ -10,8 +10,10 @@ definition into its initial context. Register tools with `deferLoading: true`;
 search matches their names and descriptions and makes them available on the
 **next model step**.
 
-Use it with `generateText`, `streamText`, or `ToolLoopAgent`. The factory takes no
-arguments; the model supplies a search query.
+Use it with `generateText`, `streamText`, `ToolLoopAgent`, or `WorkflowAgent` from
+`@ai-sdk/workflow`. The factory takes no arguments; the model supplies a search
+query. `WorkflowAgent` supports direct tool calling; the other APIs also support
+cache-preserving code mode.
 
 ## Direct Tool Calling
 

package/docs/07-reference/01-ai-sdk-core/23-tool-search.mdx

@@ -7,8 +7,9 @@ description: Search deferred tools and load their definitions on demand for dire
 
 Creates a tool that searches the surrounding generation's deferred tools by name
 and description. The factory takes no arguments. Use it with `generateText`,
-`streamText`, or `ToolLoopAgent`, either with direct tool calling or with code mode
-configured with `toolDiscovery: 'conversation'`.
+`streamText`, `ToolLoopAgent`, or `WorkflowAgent` from `@ai-sdk/workflow`.
+`WorkflowAgent` supports direct tool calling. The other APIs also support code
+mode configured with `toolDiscovery: 'conversation'`.
 
 ```ts
 import { toolSearch } from 'ai';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.106",
+  "version": "7.0.107",
   "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.86",
+    "@ai-sdk/gateway": "4.0.87",
     "@ai-sdk/provider": "4.0.17",
-    "@ai-sdk/provider-utils": "5.0.44"
+    "@ai-sdk/provider-utils": "5.0.45"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.87",
-    "@ai-sdk/deepseek": "3.0.48",
-    "@ai-sdk/google": "4.0.75",
-    "@ai-sdk/groq": "4.0.45",
-    "@ai-sdk/huggingface": "2.0.52",
-    "@ai-sdk/moonshotai": "3.0.53",
-    "@ai-sdk/openai": "4.0.70",
+    "@ai-sdk/amazon-bedrock": "5.0.88",
+    "@ai-sdk/deepseek": "3.0.49",
+    "@ai-sdk/google": "4.0.76",
+    "@ai-sdk/groq": "4.0.46",
+    "@ai-sdk/huggingface": "2.0.53",
+    "@ai-sdk/moonshotai": "3.0.54",
+    "@ai-sdk/openai": "4.0.71",
     "@ai-sdk/test-server": "2.0.1",
-    "@ai-sdk/xai": "5.0.3",
+    "@ai-sdk/xai": "5.0.4",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/generate-speech/generate-speech.ts

@@ -155,14 +155,19 @@ export async function generateSpeech({
     model: resolvedModel.modelId,
   });
 
+  const detectedMediaType = detectMediaType({
+    data: result.audio,
+    topLevelType: 'audio',
+  });
+
   return new DefaultSpeechResult({
     audio: new DefaultGeneratedAudioFile({
       data: result.audio,
       mediaType:
-        detectMediaType({
-          data: result.audio,
-          topLevelType: 'audio',
-        }) ?? 'audio/mp3',
+        detectedMediaType ??
+        getResponseAudioMediaType(result.response.headers) ??
+        getOutputFormatMediaType(outputFormat) ??
+        'audio/mp3',
     }),
     warnings: result.warnings,
     responses: [result.response],
@@ -170,6 +175,41 @@ export async function generateSpeech({
   });
 }
 
+function getResponseAudioMediaType(
+  headers: Record<string, string> | undefined,
+): string | undefined {
+  const mediaType = Object.entries(headers ?? {}).find(
+    ([name]) => name.toLowerCase() === 'content-type',
+  )?.[1];
+
+  if (mediaType == null) {
+    return undefined;
+  }
+
+  const normalizedMediaType = mediaType.split(';', 1)[0].trim().toLowerCase();
+
+  if (normalizedMediaType.length === 0) {
+    return undefined;
+  }
+
+  return normalizedMediaType.startsWith('audio/')
+    ? normalizedMediaType
+    : undefined;
+}
+
+function getOutputFormatMediaType(outputFormat: string | undefined) {
+  if (outputFormat == null) {
+    return undefined;
+  }
+
+  const normalizedOutputFormat = outputFormat.trim().toLowerCase();
+
+  return normalizedOutputFormat === 'pcm' ||
+    normalizedOutputFormat === 'audio/pcm'
+    ? 'audio/pcm'
+    : undefined;
+}
+
 class DefaultSpeechResult implements SpeechResult {
   readonly audio: GeneratedAudioFile;
   readonly warnings: Array<Warning>;

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

@@ -118,6 +118,7 @@ import type {
   OnToolExecutionEndCallback,
   OnToolExecutionStartCallback,
 } from './tool-execution-events';
+import { validateToolContext } from './validate-tool-context';
 import type { ToolInputRefinement } from './tool-input-refinement';
 import type { ToolOrder } from './tool-order';
 import type { ToolOutput } from './tool-output';
@@ -1183,23 +1184,34 @@ export async function generateText<
                   continue;
                 }
 
-                if (tool.onInputStart != null) {
-                  await tool.onInputStart({
-                    toolCallId: toolCall.toolCallId,
-                    messages: stepMessages,
-                    abortSignal: mergedAbortSignal,
-                    context: runtimeContext,
+                if (
+                  tool.onInputStart != null ||
+                  tool.onInputAvailable != null
+                ) {
+                  const context = await validateToolContext({
+                    toolName: toolCall.toolName,
+                    context: getOwn(toolsContext, toolCall.toolName),
+                    contextSchema: tool.contextSchema,
                   });
-                }
 
-                if (tool?.onInputAvailable != null) {
-                  await tool.onInputAvailable({
-                    input: toolCall.input,
-                    toolCallId: toolCall.toolCallId,
-                    messages: stepMessages,
-                    abortSignal: mergedAbortSignal,
-                    context: runtimeContext,
-                  });
+                  if (tool.onInputStart != null) {
+                    await tool.onInputStart({
+                      toolCallId: toolCall.toolCallId,
+                      messages: stepMessages,
+                      abortSignal: mergedAbortSignal,
+                      context,
+                    });
+                  }
+
+                  if (tool.onInputAvailable != null) {
+                    await tool.onInputAvailable({
+                      input: toolCall.input,
+                      toolCallId: toolCall.toolCallId,
+                      messages: stepMessages,
+                      abortSignal: mergedAbortSignal,
+                      context,
+                    });
+                  }
                 }
 
                 const toolApprovalStatus = await resolveToolApproval({

package/src/generate-text/invoke-tool-callbacks-from-stream.ts

@@ -1,4 +1,8 @@
-import type { Context, ModelMessage, ToolSet } from '@ai-sdk/provider-utils';
+import type {
+  InferToolSetContext,
+  ModelMessage,
+  ToolSet,
+} from '@ai-sdk/provider-utils';
 import { createIdMap } from '../util/create-id-map';
 import { getOwn } from '../util/get-own';
 import type { LanguageModelStreamPart } from './stream-language-model-call';
@@ -6,30 +10,61 @@ import {
   isStreamRetryAttemptBoundaryPart,
   type StreamRetryAttemptBoundaryPart,
 } from './stream-retry-attempt-boundary';
+import { validateToolContext } from './validate-tool-context';
 
 type ToolCallbackStreamPart<TOOLS extends ToolSet> =
   | LanguageModelStreamPart<TOOLS>
   | StreamRetryAttemptBoundaryPart;
 
-export function invokeToolCallbacksFromStream<
-  TOOLS extends ToolSet,
-  RUNTIME_CONTEXT extends Context,
->({
+export function invokeToolCallbacksFromStream<TOOLS extends ToolSet>({
   stream,
   tools,
   stepInputMessages,
   abortSignal,
-  runtimeContext,
+  toolsContext,
 }: {
   stream: ReadableStream<ToolCallbackStreamPart<TOOLS>>;
   tools: TOOLS | undefined;
   stepInputMessages: Array<ModelMessage>;
   abortSignal: AbortSignal | undefined;
-  runtimeContext: RUNTIME_CONTEXT;
+  toolsContext: InferToolSetContext<TOOLS>;
 }): ReadableStream<ToolCallbackStreamPart<TOOLS>> {
   if (tools == null) return stream;
 
-  const ongoingToolCallToolNames: Record<string, string> = createIdMap();
+  let ongoingToolCalls: Record<
+    string,
+    {
+      toolName: string;
+      validatedContext: Promise<unknown> | undefined;
+    }
+  > = createIdMap();
+
+  const getValidatedContext = ({
+    toolCallId,
+    toolName,
+  }: {
+    toolCallId: string;
+    toolName: string;
+  }): Promise<unknown> => {
+    const ongoingToolCall = ongoingToolCalls[toolCallId];
+
+    if (ongoingToolCall?.validatedContext != null) {
+      return ongoingToolCall.validatedContext;
+    }
+
+    const tool = getOwn(tools, toolName);
+    const validatedContext = validateToolContext({
+      toolName,
+      context: getOwn(toolsContext, toolName),
+      contextSchema: tool?.contextSchema,
+    });
+
+    if (ongoingToolCall != null) {
+      ongoingToolCall.validatedContext = validatedContext;
+    }
+
+    return validatedContext;
+  };
 
   return stream.pipeThrough(
     new TransformStream({
@@ -37,12 +72,16 @@ export function invokeToolCallbacksFromStream<
         controller.enqueue(chunk);
 
         if (isStreamRetryAttemptBoundaryPart(chunk)) {
+          ongoingToolCalls = createIdMap();
           return;
         }
 
         switch (chunk.type) {
           case 'tool-input-start': {
-            ongoingToolCallToolNames[chunk.id] = chunk.toolName;
+            ongoingToolCalls[chunk.id] = {
+              toolName: chunk.toolName,
+              validatedContext: undefined,
+            };
 
             const tool = getOwn(tools, chunk.toolName);
             if (tool?.onInputStart != null) {
@@ -50,7 +89,10 @@ export function invokeToolCallbacksFromStream<
                 toolCallId: chunk.id,
                 messages: stepInputMessages,
                 abortSignal,
-                context: runtimeContext,
+                context: await getValidatedContext({
+                  toolCallId: chunk.id,
+                  toolName: chunk.toolName,
+                }),
               });
             }
 
@@ -58,7 +100,7 @@ export function invokeToolCallbacksFromStream<
           }
 
           case 'tool-input-delta': {
-            const toolName = ongoingToolCallToolNames[chunk.id];
+            const toolName = ongoingToolCalls[chunk.id]?.toolName;
             const tool = getOwn(tools, toolName);
 
             if (tool?.onInputDelta != null) {
@@ -67,7 +109,10 @@ export function invokeToolCallbacksFromStream<
                 toolCallId: chunk.id,
                 messages: stepInputMessages,
                 abortSignal,
-                context: runtimeContext,
+                context: await getValidatedContext({
+                  toolCallId: chunk.id,
+                  toolName,
+                }),
               });
             }
 
@@ -75,19 +120,26 @@ export function invokeToolCallbacksFromStream<
           }
 
           case 'tool-call': {
-            const toolName = ongoingToolCallToolNames[chunk.toolCallId];
+            const toolName = ongoingToolCalls[chunk.toolCallId]?.toolName;
             const tool = getOwn(tools, toolName);
 
-            delete ongoingToolCallToolNames[chunk.toolCallId];
-
             if (!chunk.invalid && tool?.onInputAvailable != null) {
+              const validatedContext = getValidatedContext({
+                toolCallId: chunk.toolCallId,
+                toolName,
+              });
+
+              delete ongoingToolCalls[chunk.toolCallId];
+
               await tool.onInputAvailable({
                 input: chunk.input,
                 toolCallId: chunk.toolCallId,
                 messages: stepInputMessages,
                 abortSignal,
-                context: runtimeContext,
+                context: await validatedContext,
               });
+            } else {
+              delete ongoingToolCalls[chunk.toolCallId];
             }
           }
         }

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