ai 7.0.126 → 7.0.128

package/src/registry/index.ts

@@ -1,3 +1,6 @@
+import type { ProviderV3, ProviderV4 } from '@ai-sdk/provider';
+import type { DecisionProviderRegistry } from './provider-registry';
+
 export { customProvider } from './custom-provider';
 export { NoSuchProviderError } from './no-such-provider-error';
 export {
@@ -6,4 +9,13 @@ export {
 } from './provider-registry';
 export type { ProviderRegistryProvider } from './provider-registry';
 
-export type { EvaluationProviderRegistry as Experimental_EvaluationProviderRegistry } from './provider-registry';
+export type { DecisionProviderRegistry as Experimental_DecisionProviderRegistry } from './provider-registry';
+
+/** @deprecated Use `Experimental_DecisionProviderRegistry` instead. */
+export type Experimental_EvaluationProviderRegistry<
+  PROVIDERS extends Record<string, ProviderV4 | ProviderV3> = Record<
+    string,
+    ProviderV4 | ProviderV3
+  >,
+  SEPARATOR extends string = ':',
+> = DecisionProviderRegistry<PROVIDERS, SEPARATOR>;

package/src/registry/no-such-provider-error.ts

@@ -26,6 +26,8 @@ export class NoSuchProviderError extends NoSuchModelError {
       | 'speechModel'
       | 'rerankingModel'
       | 'videoModel'
+      | 'decisionModel'
+      /** @deprecated Use `decisionModel` instead. */
       | 'evaluationModel';
     providerId: string;
     availableProviders: string[];

package/src/registry/provider-registry.ts

@@ -1,5 +1,5 @@
 import {
-  type Experimental_EvaluationModelV4 as EvaluationModelV4,
+  type Experimental_DecisionModelV4 as DecisionModelV4,
   type EmbeddingModelV4,
   type Experimental_VideoModelV3,
   type Experimental_VideoModelV4,
@@ -14,8 +14,12 @@ import {
   type SpeechModelV4,
   type TranscriptionModelV4,
 } from '@ai-sdk/provider';
-import type { EvaluationProvider } from '../evaluate/evaluation-provider';
-import { resolveEvaluationModel } from '../model/resolve-model';
+import type { DecisionModel } from '../decide/decision-result';
+import type { DecisionProvider } from '../decide/decision-provider';
+import {
+  resolveDecisionModel,
+  asEvaluationModel,
+} from '../model/resolve-model';
 import { wrapImageModel } from '../middleware/wrap-image-model';
 import { wrapLanguageModel } from '../middleware/wrap-language-model';
 import { asProviderV4 } from '../model/as-provider-v4';
@@ -38,7 +42,7 @@ type RegistryModelType =
   | 'speechModel'
   | 'rerankingModel'
   | 'videoModel'
-  | 'evaluationModel';
+  | 'decisionModel';
 
 type ProviderVideoModelIdentifier<PROVIDER> = PROVIDER extends {
   videoModel: (...args: infer ARGS) => unknown;
@@ -46,28 +50,40 @@ type ProviderVideoModelIdentifier<PROVIDER> = PROVIDER extends {
   ? ExtractLiteralUnion<ARGS[0]>
   : never;
 
-type ProviderEvaluationModelIdentifier<PROVIDER> = PROVIDER extends {
-  evaluationModel: (...args: infer ARGS) => unknown;
+type ProviderDecisionModelIdentifier<PROVIDER> = PROVIDER extends {
+  decisionModel: (...args: infer ARGS) => unknown;
 }
   ? ExtractLiteralUnion<ARGS[0]>
-  : never;
+  : PROVIDER extends { evaluationModel: (...args: infer ARGS) => unknown }
+    ? ExtractLiteralUnion<ARGS[0]>
+    : never;
 
-/** Registry with experimental evaluation access, separate from the stable interface. */
-export type EvaluationProviderRegistry<
+/** Registry with experimental decision access, separate from the stable interface. */
+export type DecisionProviderRegistry<
   PROVIDERS extends Record<string, ProviderV4 | ProviderV3> = Record<
     string,
     ProviderV4 | ProviderV3
   >,
   SEPARATOR extends string = ':',
 > = ProviderRegistryProvider<PROVIDERS, SEPARATOR> & {
+  decisionModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string
+      ? `${KEY & string}${SEPARATOR}${ProviderDecisionModelIdentifier<PROVIDERS[KEY]>}`
+      : never,
+  ): DecisionModelV4;
+  decisionModel<KEY extends keyof PROVIDERS>(
+    id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
+  ): DecisionModelV4;
+  /** @deprecated Use `decisionModel` instead. */
   evaluationModel<KEY extends keyof PROVIDERS>(
     id: KEY extends string
-      ? `${KEY & string}${SEPARATOR}${ProviderEvaluationModelIdentifier<PROVIDERS[KEY]>}`
+      ? `${KEY & string}${SEPARATOR}${ProviderDecisionModelIdentifier<PROVIDERS[KEY]>}`
       : never,
-  ): EvaluationModelV4;
+  ): DecisionModelV4 & { doEvaluate: DecisionModelV4['doDecide'] };
+  /** @deprecated Use `decisionModel` instead. */
   evaluationModel<KEY extends keyof PROVIDERS>(
     id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never,
-  ): EvaluationModelV4;
+  ): DecisionModelV4 & { doEvaluate: DecisionModelV4['doDecide'] };
 };
 
 export interface ProviderRegistryProvider<
@@ -178,7 +194,7 @@ export function createProviderRegistry<
       | LanguageModelMiddleware[];
     imageModelMiddleware?: ImageModelMiddleware | ImageModelMiddleware[];
   } = {},
-): EvaluationProviderRegistry<PROVIDERS, SEPARATOR> {
+): DecisionProviderRegistry<PROVIDERS, SEPARATOR> {
   const registry = new DefaultProviderRegistry<PROVIDERS, SEPARATOR>({
     separator,
     languageModelMiddleware,
@@ -206,12 +222,12 @@ class DefaultProviderRegistry<
 >
   implements
     ProviderRegistryProvider<PROVIDERS, SEPARATOR>,
-    EvaluationProviderRegistry<PROVIDERS, SEPARATOR>
+    DecisionProviderRegistry<PROVIDERS, SEPARATOR>
 {
   private providers: Partial<
     Record<
       keyof PROVIDERS,
-      ProviderV4 & ProviderWithOptionalVideoModel & EvaluationProvider
+      ProviderV4 & ProviderWithOptionalVideoModel & DecisionProvider
     >
   > = Object.create(null);
   private separator: SEPARATOR;
@@ -248,9 +264,10 @@ class DefaultProviderRegistry<
       provider as ProviderWithOptionalVideoModel
     ).videoModel?.bind(provider);
 
-    const evaluationModel = (
-      provider as EvaluationProvider
-    ).evaluationModel?.bind(provider);
+    const decisionProvider = provider as DecisionProvider;
+    const decisionModel = (
+      decisionProvider.decisionModel ?? decisionProvider.evaluationModel
+    )?.bind(provider);
 
     const registeredProvider =
       videoModel == null
@@ -261,9 +278,9 @@ class DefaultProviderRegistry<
               asVideoModelV4(videoModel(modelId)),
           });
 
-    // Keep v4 instances intact. Adapted providers need the original evaluation receiver.
-    if (registeredProvider !== provider && evaluationModel != null) {
-      Object.assign(registeredProvider, { evaluationModel });
+    // Keep v4 instances intact. Adapted providers need the original decision receiver.
+    if (registeredProvider !== provider && decisionModel != null) {
+      Object.assign(registeredProvider, { decisionModel });
     }
     this.providers[id] = registeredProvider;
   }
@@ -271,7 +288,7 @@ class DefaultProviderRegistry<
   private getProvider(
     id: string,
     modelType: RegistryModelType,
-  ): ProviderV4 & ProviderWithOptionalVideoModel & EvaluationProvider {
+  ): ProviderV4 & ProviderWithOptionalVideoModel & DecisionProvider {
     const provider = this.providers[id as keyof PROVIDERS];
 
     if (provider == null) {
@@ -427,18 +444,28 @@ class DefaultProviderRegistry<
     return asVideoModelV4(model);
   }
 
-  evaluationModel<KEY extends keyof PROVIDERS>(
+  decisionModel<KEY extends keyof PROVIDERS>(
     id: `${KEY & string}${SEPARATOR}${string}`,
-  ): EvaluationModelV4 {
-    const [providerId, modelId] = this.splitId(id, 'evaluationModel');
-    const provider = this.getProvider(providerId, 'evaluationModel');
-    const model = provider.evaluationModel?.(modelId);
+  ): DecisionModelV4 {
+    const [providerId, modelId] = this.splitId(id, 'decisionModel');
+    const provider = this.getProvider(providerId, 'decisionModel');
+    const factory:
+      | ((modelId: string) => Exclude<DecisionModel, string>)
+      | undefined = provider.decisionModel ?? provider.evaluationModel;
+    const model = factory?.call(provider, modelId);
 
     if (model == null) {
-      throw new NoSuchModelError({ modelId: id, modelType: 'evaluationModel' });
+      throw new NoSuchModelError({ modelId: id, modelType: 'decisionModel' });
     }
 
-    return resolveEvaluationModel(model);
+    return resolveDecisionModel(model);
+  }
+
+  /** @deprecated Use `decisionModel` instead. */
+  evaluationModel<KEY extends keyof PROVIDERS>(
+    id: `${KEY & string}${SEPARATOR}${string}`,
+  ) {
+    return asEvaluationModel(this.decisionModel(id));
   }
 
   files<KEY extends keyof PROVIDERS>(id: KEY & string): FilesV4 {

package/src/telemetry/create-telemetry-dispatcher.ts

@@ -142,10 +142,18 @@ export function createTelemetryDispatcher({
 
   const mergeTelemetryCallback = <KEY extends TelemetryCallbackKey>(
     key: KEY,
+    deprecatedKey?: keyof Telemetry,
   ): Callback<TelemetryEvent<KEY>> | undefined => {
     const integrationCallbacks = (
       integrations
-        .map(integration => integration[key]?.bind(integration))
+        .map(integration => {
+          const callback =
+            integration[key] ??
+            (deprecatedKey == null ? undefined : integration[deprecatedKey]);
+          return typeof callback === 'function'
+            ? callback.bind(integration)
+            : undefined;
+        })
         .filter(Boolean) as Array<
         Callback<InferTelemetryEvent<TelemetryEvent<KEY>>>
       >
@@ -222,16 +230,20 @@ export function createTelemetryDispatcher({
     onEmbedEnd: mergeTelemetryCallback('onEmbedEnd'),
     onRerankStart: mergeTelemetryCallback('onRerankStart'),
     onRerankEnd: mergeTelemetryCallback('onRerankEnd'),
-    experimental_onEvaluateStart: mergeTelemetryCallback(
+    experimental_onDecideStart: mergeTelemetryCallback(
+      'experimental_onDecideStart',
       'experimental_onEvaluateStart',
     ),
-    experimental_onEvaluationModelCallStart: mergeTelemetryCallback(
+    experimental_onDecisionModelCallStart: mergeTelemetryCallback(
+      'experimental_onDecisionModelCallStart',
       'experimental_onEvaluationModelCallStart',
     ),
-    experimental_onEvaluationModelCallEnd: mergeTelemetryCallback(
+    experimental_onDecisionModelCallEnd: mergeTelemetryCallback(
+      'experimental_onDecisionModelCallEnd',
       'experimental_onEvaluationModelCallEnd',
     ),
-    experimental_onEvaluateEnd: mergeTelemetryCallback(
+    experimental_onDecideEnd: mergeTelemetryCallback(
+      'experimental_onDecideEnd',
       'experimental_onEvaluateEnd',
     ),
     experimental_onStreamTranscriptionStart: mergeTelemetryCallback(

package/src/telemetry/telemetry.ts

@@ -6,11 +6,11 @@ import type {
   EmbeddingModelCallStartEvent,
 } from '../embed/embed-events';
 import type {
-  EvaluateEndEvent,
-  EvaluateStartEvent,
-  EvaluationModelCallEndEvent,
-  EvaluationModelCallStartEvent,
-} from '../evaluate/evaluate-events';
+  DecideEndEvent,
+  DecideStartEvent,
+  DecisionModelCallEndEvent,
+  DecisionModelCallStartEvent,
+} from '../decide/decide-events';
 import type {
   GenerateObjectEndEvent,
   GenerateObjectStartEvent,
@@ -116,10 +116,10 @@ export interface TelemetryDispatcher {
   onEmbedEnd?: Callback<EmbeddingModelCallEndEvent>;
   onRerankStart?: Callback<RerankingModelCallStartEvent>;
   onRerankEnd?: Callback<RerankingModelCallEndEvent>;
-  experimental_onEvaluateStart?: Callback<EvaluateStartEvent>;
-  experimental_onEvaluationModelCallStart?: Callback<EvaluationModelCallStartEvent>;
-  experimental_onEvaluationModelCallEnd?: Callback<EvaluationModelCallEndEvent>;
-  experimental_onEvaluateEnd?: Callback<EvaluateEndEvent>;
+  experimental_onDecideStart?: Callback<DecideStartEvent>;
+  experimental_onDecisionModelCallStart?: Callback<DecisionModelCallStartEvent>;
+  experimental_onDecisionModelCallEnd?: Callback<DecisionModelCallEndEvent>;
+  experimental_onDecideEnd?: Callback<DecideEndEvent>;
   experimental_onStreamTranscriptionStart?: Callback<StreamTranscriptionStartEvent>;
   experimental_onStreamTranscriptionEnd?: Callback<StreamTranscriptionEndEvent>;
   onEnd?: Callback<OperationEndEvent>;
@@ -245,29 +245,45 @@ export interface Telemetry {
    */
   onRerankEnd?: Callback<InferTelemetryEvent<RerankingModelCallEndEvent>>;
 
-  /** Called when an experimental evaluation operation begins. */
+  /** @deprecated Use `experimental_onDecideStart` instead. */
   experimental_onEvaluateStart?: Callback<
-    InferTelemetryEvent<EvaluateStartEvent>
+    InferTelemetryEvent<DecideStartEvent>
   >;
 
+  /** @deprecated Use `experimental_onDecisionModelCallStart` instead. */
+  experimental_onEvaluationModelCallStart?: Callback<
+    InferTelemetryEvent<DecisionModelCallStartEvent>
+  >;
+
+  /** @deprecated Use `experimental_onDecisionModelCallEnd` instead. */
+  experimental_onEvaluationModelCallEnd?: Callback<
+    InferTelemetryEvent<DecisionModelCallEndEvent>
+  >;
+
+  /** @deprecated Use `experimental_onDecideEnd` instead. */
+  experimental_onEvaluateEnd?: Callback<InferTelemetryEvent<DecideEndEvent>>;
+
+  /** Called when an experimental decision operation begins. */
+  experimental_onDecideStart?: Callback<InferTelemetryEvent<DecideStartEvent>>;
+
   /**
-   * Called immediately before an experimental evaluation model call begins.
+   * Called immediately before an experimental decision model call begins.
    * The logical model call includes any provider retries.
    */
-  experimental_onEvaluationModelCallStart?: Callback<
-    InferTelemetryEvent<EvaluationModelCallStartEvent>
+  experimental_onDecisionModelCallStart?: Callback<
+    InferTelemetryEvent<DecisionModelCallStartEvent>
   >;
 
   /**
-   * Called after an experimental evaluation model response has been validated.
+   * Called after an experimental decision model response has been validated.
    * The logical model call includes any provider retries.
    */
-  experimental_onEvaluationModelCallEnd?: Callback<
-    InferTelemetryEvent<EvaluationModelCallEndEvent>
+  experimental_onDecisionModelCallEnd?: Callback<
+    InferTelemetryEvent<DecisionModelCallEndEvent>
   >;
 
-  /** Called when an experimental evaluation operation completes. */
-  experimental_onEvaluateEnd?: Callback<InferTelemetryEvent<EvaluateEndEvent>>;
+  /** Called when an experimental decision operation completes. */
+  experimental_onDecideEnd?: Callback<InferTelemetryEvent<DecideEndEvent>>;
 
   /** Called when an experimental streaming transcription operation begins. */
   experimental_onStreamTranscriptionStart?: Callback<

package/src/telemetry/tracing-channel.ts

@@ -12,7 +12,7 @@ export type TelemetryTracingEventType =
   | 'generateSpeech'
   | 'transcribe'
   | 'streamTranscribe'
-  | 'experimental_evaluate';
+  | 'experimental_decide';
 
 export type TelemetryTracingChannelMessage<EVENT = unknown> = {
   readonly type: TelemetryTracingEventType;

package/src/test/decision-mock-model-v4.ts

@@ -0,0 +1,35 @@
+import type { Experimental_DecisionModelV4 as DecisionModelV4 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class DecisionMockModelV4 implements DecisionModelV4 {
+  readonly specificationVersion = 'v4';
+  readonly provider: string;
+  readonly modelId: string;
+  readonly supportedQuestionTypes: DecisionModelV4['supportedQuestionTypes'];
+  doDecide: DecisionModelV4['doDecide'];
+
+  /** @deprecated Use `doDecide` instead. */
+  doEvaluate(options: Parameters<DecisionModelV4['doDecide']>[0]) {
+    return this.doDecide(options);
+  }
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    supportedQuestionTypes = ['choice', 'score', 'boolean'],
+    doDecide,
+    doEvaluate,
+  }: {
+    provider?: string;
+    modelId?: string;
+    supportedQuestionTypes?: DecisionModelV4['supportedQuestionTypes'];
+    doDecide?: DecisionModelV4['doDecide'];
+    /** @deprecated Use `doDecide` instead. */
+    doEvaluate?: DecisionModelV4['doDecide'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.supportedQuestionTypes = supportedQuestionTypes;
+    this.doDecide = doDecide ?? doEvaluate ?? notImplemented;
+  }
+}

package/src/tool-search/prepare-tool-search.ts

@@ -11,7 +11,11 @@ import {
 } from '../generate-text/tool-caller-configuration';
 import { resolveToolDescription } from '../prompt/prepare-tools';
 import { getOwn } from '../util/get-own';
-import { isToolSearch } from './tool-search';
+import {
+  getToolSearchFunction,
+  getToolSearchMaxResults,
+  isToolSearch,
+} from './tool-search';
 
 /** Create discovery state for one generation, never for a shared tool instance. */
 export function createToolSearchState({
@@ -90,41 +94,57 @@ export function createToolSearchState({
             searchName,
             {
               ...tool,
-              execute: ({ query }: { query: string }) => {
+              execute: async ({ query }: { query: string }) => {
+                const availableTools = candidates.map(([name, candidate]) => {
+                  const description = resolveToolDescription({
+                    tool: candidate,
+                    toolName: name,
+                    toolsContext,
+                    experimental_sandbox,
+                  });
+                  return {
+                    name,
+                    ...(description == null ? {} : { description }),
+                  };
+                });
+                const toolsByName = new Map(
+                  availableTools.map(tool => [tool.name, tool]),
+                );
+                const customSearch = getToolSearchFunction(tool);
                 const terms = [...new Set(tokenize(query))];
-                const matches = candidates
-                  .map(([name, candidate]) => {
-                    const description = resolveToolDescription({
-                      tool: candidate,
-                      toolName: name,
-                      toolsContext,
-                      experimental_sandbox,
-                    });
-                    const nameTerms = tokenize(name);
-                    const descriptionTerms = tokenize(description ?? '');
-                    const score = terms.reduce(
-                      (score, term) =>
-                        score +
-                        (nameTerms.includes(term) ? 2 : 0) +
-                        (descriptionTerms.includes(term) ? 1 : 0),
-                      0,
-                    );
-                    return { name, description, score };
+                const rankedNames = customSearch
+                  ? await customSearch({
+                      query,
+                      tools: availableTools.map(tool => ({ ...tool })),
+                    })
+                  : availableTools
+                      .map(({ name, description }) => {
+                        const nameTerms = tokenize(name);
+                        const descriptionTerms = tokenize(description ?? '');
+                        const score = terms.reduce(
+                          (score, term) =>
+                            score +
+                            (nameTerms.includes(term) ? 2 : 0) +
+                            (descriptionTerms.includes(term) ? 1 : 0),
+                          0,
+                        );
+                        return { name, score };
+                      })
+                      .filter(match => match.score > 0)
+                      .sort((a, b) => b.score - a.score)
+                      .map(match => match.name);
+                const matches = [...new Set(rankedNames)]
+                  .flatMap(name => {
+                    const match = toolsByName.get(name);
+                    return match == null ? [] : [match];
                   })
-                  .filter(match => match.score > 0)
-                  .sort((a, b) => b.score - a.score)
-                  .slice(0, 5);
+                  .slice(0, getToolSearchMaxResults(tool));
 
                 for (const { name } of matches) {
                   discovered.add(name);
                 }
 
-                return {
-                  tools: matches.map(({ name, description }) => ({
-                    name,
-                    ...(description == null ? {} : { description }),
-                  })),
-                };
+                return { tools: matches };
               },
             },
           ];

package/src/tool-search/tool-search.ts

@@ -1,6 +1,16 @@
 import { jsonSchema, tool, type Tool } from '@ai-sdk/provider-utils';
+import { InvalidArgumentError } from '../error/invalid-argument-error';
 
 const toolSearchSymbol = Symbol.for('vercel.ai.toolSearch');
+const toolSearchFunctionSymbol = Symbol.for('vercel.ai.toolSearch.search');
+const toolSearchMaxResultsSymbol = Symbol.for(
+  'vercel.ai.toolSearch.maxResults',
+);
+
+type ToolSearchFunction = (options: {
+  query: string;
+  tools: Array<{ name: string; description?: string }>;
+}) => string[] | PromiseLike<string[]>;
 
 type ToolSearchInput = { query: string };
 type ToolSearchOutput = {
@@ -12,13 +22,36 @@ type ToolSearchOutput = {
  * binds the search registry and makes matches available on the next step.
  * Use directly or through code mode with `toolDiscovery: 'conversation'`.
  */
-export function toolSearch(): Tool<ToolSearchInput, ToolSearchOutput> & {
+export function toolSearch({
+  search,
+  maxResults = 5,
+}: {
+  /**
+   * Search eligible deferred tools and return their names in ranked order.
+   * Supports synchronous and asynchronous callbacks. Unknown names and
+   * duplicates are ignored before applying the result limit.
+   */
+  search?: ToolSearchFunction;
+  /**
+   * Maximum number of matching tools returned per search.
+   *
+   * @default 5
+   */
+  maxResults?: number;
+} = {}): Tool<ToolSearchInput, ToolSearchOutput> & {
   type: 'function';
 } {
+  if (!Number.isSafeInteger(maxResults) || maxResults < 1) {
+    throw new InvalidArgumentError({
+      parameter: 'maxResults',
+      value: maxResults,
+      message: 'maxResults must be a positive safe integer.',
+    });
+  }
+
   return Object.assign(
     tool({
-      description:
-        'Search for tools by keywords in their names and descriptions. Returns up to five matching tools. Matches become available on the next model step, after this execution finishes. Wait for their tool definitions before calling the discovered tools. If no tools match, try different keywords.',
+      description: `${search == null ? 'Search for tools by keywords in their names and descriptions.' : 'Search for tools matching a query.'} Returns up to ${maxResults === 5 ? 'five' : maxResults} matching tools. Matches become available on the next model step, after this execution finishes. Wait for their tool definitions before calling the discovered tools. If no tools match, try different keywords.`,
       inputSchema: jsonSchema<ToolSearchInput>({
         type: 'object',
         properties: { query: { type: 'string', minLength: 1 } },
@@ -48,10 +81,31 @@ export function toolSearch(): Tool<ToolSearchInput, ToolSearchOutput> & {
         throw new Error('toolSearch must be bound by an AI SDK generation.');
       },
     }),
-    { type: 'function' as const, [toolSearchSymbol]: true },
+    {
+      type: 'function' as const,
+      [toolSearchSymbol]: true,
+      [toolSearchFunctionSymbol]: search,
+      [toolSearchMaxResultsSymbol]: maxResults,
+    },
   );
 }
 
+export function getToolSearchMaxResults(tool: Tool): number {
+  return (
+    (tool as Tool & { [toolSearchMaxResultsSymbol]?: number })[
+      toolSearchMaxResultsSymbol
+    ] ?? 5
+  );
+}
+
+export function getToolSearchFunction(
+  tool: Tool,
+): ToolSearchFunction | undefined {
+  return (tool as Tool & { [toolSearchFunctionSymbol]?: ToolSearchFunction })[
+    toolSearchFunctionSymbol
+  ];
+}
+
 export function isToolSearch(tool: Tool): boolean {
   return (
     (tool as Tool & { [toolSearchSymbol]?: boolean })[toolSearchSymbol] === true

package/src/transcribe/transcribe.ts

@@ -256,7 +256,7 @@ export async function transcribe({
           model: resolvedModel.modelId,
         });
 
-        if (!result.text) {
+        if (result.text == null) {
           throw new NoTranscriptGeneratedError({
             responses: [result.response],
           });

package/src/ui/chat.ts

@@ -849,11 +849,18 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       responseMessageIndex === -1
         ? lastMessage
         : this.state.messages[responseMessageIndex];
+    // the continued stream can start with either
+    // 1) input deltas
+    // 2) or the result of an answered tool approval request
+    // Keep the tool part so in case 2, those chunks can find their tool call
     const resumableResponseMessage =
       trigger === 'resume-stream' &&
       responseMessage?.role === 'assistant' &&
       responseMessage.parts.some(
-        part => isToolUIPart(part) && part.state === 'input-streaming',
+        part =>
+          isToolUIPart(part) &&
+          (part.state === 'input-streaming' ||
+            part.state === 'approval-responded'),
       )
         ? this.state.snapshot(responseMessage)
         : undefined;
@@ -952,6 +959,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       await consumeStream({
         stream: processUIMessageStream({
           stream,
+          resetStateOnMessageIdChange: trigger === 'resume-stream',
           onToolCall: this.onToolCall,
           onData: this.onData,
           messageMetadataSchema: this.messageMetadataSchema,

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

@@ -120,6 +120,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
   onError,
   onToolCall,
   onData,
+  resetStateOnMessageIdChange = false,
 }: {
   // input stream is not fully typed yet:
   stream: ReadableStream<UIMessageChunk>;
@@ -136,6 +137,8 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
     }) => Promise<void>,
   ) => Promise<void>;
   onError: ErrorHandler;
+  // During resume, a different message ID identifies a separate response.
+  resetStateOnMessageIdChange?: boolean;
 }): ReadableStream<InferUIMessageChunk<UI_MESSAGE>> {
   return stream.pipeThrough(
     new TransformStream<UIMessageChunk, InferUIMessageChunk<UI_MESSAGE>>({
@@ -953,6 +956,24 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
             }
 
             case 'start': {
+              if (
+                resetStateOnMessageIdChange &&
+                chunk.messageId != null &&
+                chunk.messageId !== state.message.id
+              ) {
+                // Start the separate response with empty parts and metadata.
+                // Reset the active-part maps too, so earlier chunks stay with
+                // the previous response. Keep the state object for its callers.
+                Object.assign(
+                  state,
+                  createStreamingUIMessageState({
+                    lastMessage: undefined,
+                    messageId: chunk.messageId,
+                  }),
+                  { finishReason: undefined },
+                );
+              }
+
               if (chunk.messageId != null) {
                 state.message.id = chunk.messageId;
               }