ai 7.0.105 → 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.105",
+  "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.85",
+    "@ai-sdk/gateway": "4.0.87",
     "@ai-sdk/provider": "4.0.17",
-    "@ai-sdk/provider-utils": "5.0.43"
+    "@ai-sdk/provider-utils": "5.0.45"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.86",
-    "@ai-sdk/deepseek": "3.0.47",
-    "@ai-sdk/google": "4.0.74",
-    "@ai-sdk/groq": "4.0.44",
-    "@ai-sdk/huggingface": "2.0.51",
-    "@ai-sdk/moonshotai": "3.0.52",
-    "@ai-sdk/openai": "4.0.69",
+    "@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.2",
+    "@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/batch/batch.ts

@@ -202,6 +202,7 @@ export async function startBatch<
               prompt: standardizedPrompt,
               supportedUrls,
               download: undefined,
+              abortSignal: operationAbortSignal,
               provider: batchApi.provider.split('.')[0],
             }),
             tools: preparedTools,

package/src/generate-object/generate-object.ts

@@ -379,6 +379,7 @@ export async function generateObject<
       prompt: standardizedPrompt,
       supportedUrls: await model.supportedUrls,
       download,
+      abortSignal,
       provider: model.provider.split('.')[0],
     });
 

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

@@ -612,6 +612,7 @@ class DefaultStreamObjectResult<
           prompt: standardizedPrompt,
           supportedUrls: await model.supportedUrls,
           download,
+          abortSignal,
           provider: model.provider.split('.')[0],
         }),
         providerOptions,

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';
@@ -964,6 +965,7 @@ export async function generateText<
                 },
                 supportedUrls: await stepModel.supportedUrls,
                 download,
+                abortSignal: mergedAbortSignal,
                 provider: stepModel.provider.split('.')[0],
               });
 
@@ -1182,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];
 
-            if (tool?.onInputAvailable != null) {
               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/prune-messages.ts

@@ -121,6 +121,7 @@ export function pruneMessages({
       }
     }
 
+    const approvalIdToToolCallId = new Map<string, string>();
     const approvalIdToToolName = new Map<string, string>();
     for (const message of messages) {
       if (
@@ -129,6 +130,8 @@ export function pruneMessages({
       ) {
         for (const part of message.content) {
           if (part.type === 'tool-approval-request') {
+            approvalIdToToolCallId.set(part.approvalId, part.toolCallId);
+
             const toolName = toolCallIdToToolName.get(part.toolCallId);
             if (toolName != null) {
               approvalIdToToolName.set(part.approvalId, toolName);
@@ -138,6 +141,16 @@ export function pruneMessages({
       }
     }
 
+    // Approval requests depend on their originating tool call. When an
+    // approval response is in the retained messages, trace through its request
+    // so pruning does not leave a pending approval without the call to execute.
+    for (const approvalId of keptApprovalIds) {
+      const toolCallId = approvalIdToToolCallId.get(approvalId);
+      if (toolCallId != null) {
+        keptToolCallIds.add(toolCallId);
+      }
+    }
+
     messages = messages.map((message, messageIndex) => {
       if (
         (message.role !== 'assistant' && message.role !== 'tool') ||

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

@@ -306,6 +306,7 @@ export async function streamLanguageModelCall<
     },
     supportedUrls: await resolvedModel.supportedUrls,
     download,
+    abortSignal,
     provider: resolvedModel.provider.split('.')[0],
   });
 

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

@@ -968,14 +968,16 @@ function createOutputTransformStream<
   let text = '';
   let textChunk = '';
   let textProviderMetadata: ProviderMetadata | undefined = undefined;
-  let lastPublishedValue = '';
+  let lastPublishedValue: string | undefined = undefined;
+  let hasPublishedValue = false;
 
-  function resetAttemptState() {
+  function resetOutputState() {
     firstTextChunkId = undefined;
     text = '';
     textChunk = '';
     textProviderMetadata = undefined;
-    lastPublishedValue = '';
+    lastPublishedValue = undefined;
+    hasPublishedValue = false;
   }
 
   function enqueueChunk({
@@ -1020,11 +1022,15 @@ function createOutputTransformStream<
   >({
     async transform(chunk, controller) {
       if (isStreamRetryBoundaryPart(chunk)) {
-        resetAttemptState();
+        resetOutputState();
         controller.enqueue(chunk);
         return;
       }
 
+      if (chunk.type === 'start-step') {
+        resetOutputState();
+      }
+
       // ensure that we publish the last text chunk before the step finish:
       if (chunk.type === 'finish-step' && textChunk.length > 0) {
         publishTextChunk({ controller });
@@ -1096,9 +1102,10 @@ function createOutputTransformStream<
           typeof result.partial === 'string'
             ? result.partial
             : JSON.stringify(result.partial);
-        if (currentValue !== lastPublishedValue) {
+        if (!hasPublishedValue || currentValue !== lastPublishedValue) {
           publishTextChunk({ controller, partialOutput: result.partial });
           lastPublishedValue = currentValue;
+          hasPublishedValue = true;
         }
       }
     },
@@ -1414,6 +1421,8 @@ class DefaultStreamTextResult<
     const initialResponseMessages: Array<ResponseMessage> = [];
     let stepMessagesForNextStep: Array<ModelMessage> | undefined;
     let currentStepMessages: Array<ModelMessage> = [];
+    let isAborted = false;
+    let currentStepModel = model;
 
     // provider-assigned text/reasoning part IDs are only unique within a
     // single model call (e.g. Anthropic uses the content block index, which
@@ -1661,8 +1670,8 @@ class DefaultStreamTextResult<
             new DefaultStepResult({
               callId,
               stepNumber: recordedSteps.length,
-              provider: model.provider,
-              modelId: model.modelId,
+              provider: currentStepModel.provider,
+              modelId: currentStepModel.modelId,
               runtimeContext,
               toolsContext,
               content: recordedContent,
@@ -1691,8 +1700,8 @@ class DefaultStreamTextResult<
 
           logWarnings({
             warnings: recordedWarnings,
-            provider: model.provider,
-            model: model.modelId,
+            provider: currentStepModel.provider,
+            model: currentStepModel.modelId,
           });
 
           recordedSteps.push(currentStepResult);
@@ -1743,6 +1752,10 @@ class DefaultStreamTextResult<
           // aggregate results:
           self._steps.resolve(recordedSteps);
 
+          if (isAborted) {
+            return;
+          }
+
           // call onEnd callback:
           const finalStep = recordedSteps[recordedSteps.length - 1];
           const content = recordedSteps.flatMap(step => step.content);
@@ -1845,6 +1858,8 @@ class DefaultStreamTextResult<
       async pull(controller) {
         // abort handling:
         async function abort() {
+          isAborted = true;
+
           await notify({
             event: {
               callId,
@@ -1885,6 +1900,7 @@ class DefaultStreamTextResult<
           if (isAbortError(error) && abortSignal?.aborted) {
             await abort();
           } else {
+            await telemetryDispatcher.onError?.({ callId, error });
             controller.error(error);
           }
         }
@@ -2328,6 +2344,7 @@ class DefaultStreamTextResult<
           const stepModel = resolveLanguageModel(
             prepareStepResult?.model ?? model,
           );
+          currentStepModel = stepModel;
 
           const stepActiveTools = filterActiveTools({
             tools,
@@ -2658,7 +2675,7 @@ class DefaultStreamTextResult<
               tools: stepExecutionTools as TOOLS,
               stepInputMessages: stepMessages,
               abortSignal,
-              runtimeContext,
+              toolsContext,
             });
 
           // Create child spans under the current step context.
@@ -2752,7 +2769,7 @@ class DefaultStreamTextResult<
           const createStepResponse = () => ({
             id: generateId(),
             timestamp: new Date(),
-            modelId: model.modelId,
+            modelId: stepModel.modelId,
           });
           let stepResponse: {
             id: string;
@@ -3375,7 +3392,7 @@ class DefaultStreamTextResult<
           InferPartialOutput<OUTPUT>
         >({
           transform({ partialOutput }, controller) {
-            if (partialOutput != null) {
+            if (partialOutput !== undefined) {
               controller.enqueue(partialOutput);
             }
           },