ai 7.0.106 → 7.0.108

package/dist/internal/index.d.ts

@@ -1721,6 +1721,8 @@ type ToolApprovalConfiguration<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Co
     [key in keyof TOOLS]?: ToolApprovalStatus | SingleToolApprovalFunction<InferToolInput<TOOLS[key]>, InferToolContext<TOOLS[key]>, RUNTIME_CONTEXT>;
 };
 
+type ResolvedToolCallers = Record<string, ReadonlyArray<string>>;
+
 declare const symbol$1: unique symbol;
 declare class InvalidToolInputError extends AISDKError {
     private readonly [symbol$1];
@@ -1761,6 +1763,7 @@ declare class NoSuchToolError extends AISDKError {
  * @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.
  */
 type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
     instructions: Instructions | undefined;
@@ -1775,6 +1778,7 @@ type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
         toolName: string;
     }) => PromiseLike<JSONSchema7>;
     error: NoSuchToolError | InvalidToolInputError;
+    abortSignal?: AbortSignal;
 }) => Promise<LanguageModelV4ToolCall | null>;
 
 type ToolOutput<TOOLS extends ToolSet> = TypedToolResult<TOOLS> | TypedToolError<TOOLS>;
@@ -2679,15 +2683,25 @@ declare function createRestrictedTelemetryDispatcher<TOOLS extends ToolSet, RUNT
     includeToolsContext?: IncludedToolsContext<TOOLS>;
 }): RestrictedTelemetryDispatcher<TOOLS, RUNTIME_CONTEXT, OUTPUT>;
 
-declare function parseToolCall<TOOLS extends ToolSet>({ toolCall, tools, repairToolCall, refineToolInput, messages, instructions, }: {
+declare function parseToolCall<TOOLS extends ToolSet>({ toolCall, tools, repairToolCall, refineToolInput, messages, instructions, abortSignal, }: {
     toolCall: LanguageModelV4ToolCall;
     tools: TOOLS | undefined;
     repairToolCall: ToolCallRepairFunction<TOOLS> | undefined;
     refineToolInput?: ToolInputRefinement<TOOLS> | undefined;
     instructions: Instructions | undefined;
     messages: ModelMessage[];
+    abortSignal?: AbortSignal;
 }): Promise<TypedToolCall<TOOLS>>;
 
+/** Create discovery state for one generation, never for a shared tool instance. */
+declare function createToolSearchState({ tools, toolCallers, }: {
+    tools: ToolSet | undefined;
+    toolCallers: ResolvedToolCallers | undefined;
+}): (activeTools: ToolSet | undefined, options?: {
+    toolsContext?: InferToolSetContext<ToolSet>;
+    experimental_sandbox?: Experimental_SandboxSession;
+}) => ToolSet | undefined;
+
 type CollectedToolApprovals<TOOLS extends ToolSet> = {
     approvalRequest: ToolApprovalRequest;
     approvalResponse: ToolApprovalResponse;
@@ -2750,4 +2764,4 @@ declare function toResponseMessages<TOOLS extends ToolSet>({ content: inputConte
     tools: TOOLS | undefined;
 }): Promise<Array<AssistantModelMessage | ToolModelMessage>>;
 
-export { type CollectedToolApprovals, DefaultStepResult, type DownloadFunction, addLanguageModelUsage, asLanguageModelUsage, collectToolApprovals, convertToLanguageModelPrompt, createAsyncIterableStream, createDefaultDownloadFunction, createNullLanguageModelUsage, createRestrictedTelemetryDispatcher, createTelemetryDispatcher, createToolModelOutput, downloadAssets, mapToolResultOutput, mergeAbortSignals, mergeCallbacks, parseToolCall, prepareLanguageModelCallOptions as prepareCallSettings, prepareLanguageModelCallOptions, prepareRetries, prepareToolChoice, prepareTools, resolveLanguageModel, signToolApproval, standardizePrompt, toResponseMessages, validateApprovedToolApprovals, verifyToolApprovalSignature };
+export { type CollectedToolApprovals, DefaultStepResult, type DownloadFunction, addLanguageModelUsage, asLanguageModelUsage, collectToolApprovals, convertToLanguageModelPrompt, createAsyncIterableStream, createDefaultDownloadFunction, createNullLanguageModelUsage, createRestrictedTelemetryDispatcher, createTelemetryDispatcher, createToolModelOutput, createToolSearchState, downloadAssets, mapToolResultOutput, mergeAbortSignals, mergeCallbacks, parseToolCall, prepareLanguageModelCallOptions as prepareCallSettings, prepareLanguageModelCallOptions, prepareRetries, prepareToolChoice, prepareTools, resolveLanguageModel, signToolApproval, standardizePrompt, toResponseMessages, validateApprovedToolApprovals, verifyToolApprovalSignature };

package/dist/internal/index.js

@@ -91,7 +91,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.106" : "0.0.0-test";
+var VERSION = true ? "7.0.108" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -1066,7 +1066,7 @@ async function createToolModelOutput({
   toolCallId,
   input,
   output,
-  tool,
+  tool: tool2,
   errorMode
 }) {
   if (errorMode === "text") {
@@ -1074,8 +1074,8 @@ async function createToolModelOutput({
   } else if (errorMode === "json") {
     return { type: "error-json", value: toJSONValue(output) };
   }
-  if (tool == null ? void 0 : tool.toModelOutput) {
-    return await tool.toModelOutput({ toolCallId, input, output });
+  if (tool2 == null ? void 0 : tool2.toModelOutput) {
+    return await tool2.toModelOutput({ toolCallId, input, output });
   }
   return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: toJSONValue(output) };
 }
@@ -1115,25 +1115,25 @@ async function prepareTools({
     return void 0;
   }
   const languageModelTools = [];
-  for (const [name12, tool] of orderToolEntries({ tools, toolOrder })) {
-    const toolType = tool.type;
+  for (const [name12, tool2] of orderToolEntries({ tools, toolOrder })) {
+    const toolType = tool2.type;
     switch (toolType) {
       case void 0:
       case "dynamic":
       case "function": {
         const description = resolveToolDescription({
-          tool,
+          tool: tool2,
           toolName: name12,
           toolsContext,
           experimental_sandbox: sandbox
         });
-        const providerOptions = tool.providerOptions;
-        const inputExamples = tool.inputExamples;
-        const strict = tool.strict;
+        const providerOptions = tool2.providerOptions;
+        const inputExamples = tool2.inputExamples;
+        const strict = tool2.strict;
         languageModelTools.push({
           type: "function",
           name: name12,
-          inputSchema: await asSchema(tool.inputSchema).jsonSchema,
+          inputSchema: await asSchema(tool2.inputSchema).jsonSchema,
           ...description != null ? { description } : {},
           ...inputExamples != null ? { inputExamples } : {},
           ...providerOptions != null ? { providerOptions } : {},
@@ -1145,8 +1145,8 @@ async function prepareTools({
         languageModelTools.push({
           type: "provider",
           name: name12,
-          id: tool.id,
-          args: tool.args
+          id: tool2.id,
+          args: tool2.args
         });
         break;
       }
@@ -1173,12 +1173,12 @@ function orderToolEntries({
   return [...orderedTools, ...unorderedTools];
 }
 function resolveToolDescription({
-  tool,
+  tool: tool2,
   toolName,
   toolsContext,
   experimental_sandbox: sandbox
 }) {
-  return tool.description === void 0 ? void 0 : typeof tool.description === "string" ? tool.description : tool.description({
+  return tool2.description === void 0 ? void 0 : typeof tool2.description === "string" ? tool2.description : tool2.description({
     context: toolsContext[toolName],
     experimental_sandbox: sandbox
   });
@@ -2126,6 +2126,9 @@ function asImageModelV4(model) {
   });
 }
 
+// src/model/as-language-model-v4.ts
+import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
+
 // src/model/as-language-model-v3.ts
 function asLanguageModelV3(model) {
   if (model.specificationVersion === "v3") {
@@ -2213,11 +2216,131 @@ function asLanguageModelV4(model) {
   const v3Model = model.specificationVersion === "v2" ? asLanguageModelV3(model) : model;
   return new Proxy(v3Model, {
     get(target, prop) {
-      if (prop === "specificationVersion") return "v4";
-      return target[prop];
+      switch (prop) {
+        case "specificationVersion":
+          return "v4";
+        case "doGenerate":
+          return async (options) => {
+            const result = await target.doGenerate({
+              ...options,
+              prompt: convertV4PromptToV3(options.prompt)
+            });
+            return {
+              ...result,
+              content: result.content.map(convertV3ContentToV4)
+            };
+          };
+        case "doStream":
+          return async (options) => {
+            const result = await target.doStream({
+              ...options,
+              prompt: convertV4PromptToV3(options.prompt)
+            });
+            return {
+              ...result,
+              stream: convertV3StreamToV4(result.stream)
+            };
+          };
+        default:
+          return target[prop];
+      }
     }
   });
 }
+function convertV4PromptToV3(prompt) {
+  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;
+        }
+      })
+    };
+  });
+}
+function convertV4FileDataToV3(data) {
+  switch (data.type) {
+    case "data":
+      return data.data;
+    case "url":
+      return data.url;
+    case "reference":
+    case "text":
+      return data;
+  }
+}
+function convertV4ToolResultOutputToV3(output) {
+  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",
+            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",
+            url: part.data.url.toString(),
+            providerOptions: part.providerOptions
+          };
+        case "reference":
+          return {
+            type: "file-id",
+            fileId: part.data.reference,
+            providerOptions: part.providerOptions
+          };
+        case "text":
+          return part;
+      }
+    })
+  };
+}
+function convertV3ContentToV4(content) {
+  return content.type === "file" ? {
+    ...content,
+    data: { type: "data", data: content.data }
+  } : content;
+}
+function convertV3StreamToV4(stream) {
+  return stream.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        controller.enqueue(
+          chunk.type === "file" ? {
+            ...chunk,
+            data: { type: "data", data: chunk.data }
+          } : chunk
+        );
+      }
+    })
+  );
+}
 
 // src/model/as-reranking-model-v4.ts
 function asRerankingModelV4(model) {
@@ -2968,7 +3091,8 @@ async function parseToolCall({
   repairToolCall,
   refineToolInput,
   messages,
-  instructions
+  instructions,
+  abortSignal
 }) {
   try {
     if (tools == null) {
@@ -2991,20 +3115,26 @@ async function parseToolCall({
       }
       let repairedToolCall = null;
       try {
-        repairedToolCall = await repairToolCall({
-          toolCall,
-          tools,
-          inputSchema: async ({ toolName }) => {
-            var _a12;
-            const inputSchema = (_a12 = getOwn(tools, toolName)) == null ? void 0 : _a12.inputSchema;
-            return await asSchema2(inputSchema).jsonSchema;
-          },
-          instructions,
-          system: instructions,
-          messages,
-          error
+        abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+        repairedToolCall = await waitForPromiseWithAbortSignal({
+          promise: repairToolCall({
+            toolCall,
+            tools,
+            inputSchema: async ({ toolName }) => {
+              var _a12;
+              const inputSchema = (_a12 = getOwn(tools, toolName)) == null ? void 0 : _a12.inputSchema;
+              return await asSchema2(inputSchema).jsonSchema;
+            },
+            instructions,
+            system: instructions,
+            messages,
+            error,
+            abortSignal
+          }),
+          abortSignal
         });
       } catch (repairError) {
+        abortSignal == null ? void 0 : abortSignal.throwIfAborted();
         throw new ToolCallRepairError({
           cause: repairError,
           originalError: error
@@ -3013,15 +3143,18 @@ async function parseToolCall({
       if (repairedToolCall == null) {
         throw error;
       }
-      return await refineParsedToolCallInput({
+      const parsedRepairedToolCall = await refineParsedToolCallInput({
         toolCall: await doParseToolCall({ toolCall: repairedToolCall, tools }),
         refineToolInput
       });
+      abortSignal == null ? void 0 : abortSignal.throwIfAborted();
+      return parsedRepairedToolCall;
     }
   } catch (error) {
+    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
     const parsedInput = await safeParseJSON({ text: toolCall.input });
     const input = parsedInput.success ? parsedInput.value : toolCall.input;
-    const tool = getOwn(tools, toolCall.toolName);
+    const tool2 = getOwn(tools, toolCall.toolName);
     return {
       type: "tool-call",
       toolCallId: toolCall.toolCallId,
@@ -3030,13 +3163,41 @@ async function parseToolCall({
       dynamic: true,
       invalid: true,
       error,
-      title: tool == null ? void 0 : tool.title,
+      title: tool2 == null ? void 0 : tool2.title,
       providerExecuted: toolCall.providerExecuted,
       providerMetadata: toolCall.providerMetadata,
-      ...(tool == null ? void 0 : tool.metadata) != null ? { toolMetadata: tool.metadata } : {}
+      ...(tool2 == null ? void 0 : tool2.metadata) != null ? { toolMetadata: tool2.metadata } : {}
     };
   }
 }
+async function waitForPromiseWithAbortSignal({
+  promise,
+  abortSignal
+}) {
+  if (abortSignal == null) {
+    return await promise;
+  }
+  return await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      abortSignal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(abortSignal.reason);
+    };
+    Promise.resolve(promise).then((value) => {
+      cleanup();
+      resolve(value);
+    }).catch((error) => {
+      cleanup();
+      reject(error);
+    });
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+    if (abortSignal.aborted) {
+      onAbort();
+    }
+  });
+}
 async function refineParsedToolCallInput({
   toolCall,
   refineToolInput
@@ -3074,8 +3235,8 @@ async function doParseToolCall({
   tools
 }) {
   const toolName = toolCall.toolName;
-  const tool = getOwn(tools, toolName);
-  if (tool == null) {
+  const tool2 = getOwn(tools, toolName);
+  if (tool2 == null) {
     if (toolCall.providerExecuted && toolCall.dynamic) {
       return await parseProviderExecutedDynamicToolCall(toolCall);
     }
@@ -3084,7 +3245,7 @@ async function doParseToolCall({
       availableTools: Object.keys(tools)
     });
   }
-  const schema = asSchema2(tool.inputSchema);
+  const schema = asSchema2(tool2.inputSchema);
   const parseResult = toolCall.input.trim() === "" ? await safeValidateTypes2({ value: {}, schema }) : await safeParseJSON({ text: toolCall.input, schema });
   if (parseResult.success === false) {
     throw new InvalidToolInputError({
@@ -3093,16 +3254,16 @@ async function doParseToolCall({
       cause: parseResult.error
     });
   }
-  return tool.type === "dynamic" ? {
+  return tool2.type === "dynamic" ? {
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
     toolName: toolCall.toolName,
     input: parseResult.value,
     providerExecuted: toolCall.providerExecuted,
     providerMetadata: toolCall.providerMetadata,
-    ...tool.metadata != null ? { toolMetadata: tool.metadata } : {},
+    ...tool2.metadata != null ? { toolMetadata: tool2.metadata } : {},
     dynamic: true,
-    title: tool.title
+    title: tool2.title
   } : {
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
@@ -3110,11 +3271,119 @@ async function doParseToolCall({
     input: parseResult.value,
     providerExecuted: toolCall.providerExecuted,
     providerMetadata: toolCall.providerMetadata,
-    ...tool.metadata != null ? { toolMetadata: tool.metadata } : {},
-    title: tool.title
+    ...tool2.metadata != null ? { toolMetadata: tool2.metadata } : {},
+    title: tool2.title
   };
 }
 
+// src/tool-search/prepare-tool-search.ts
+import {
+  experimental_getToolCaller as experimental_getToolCaller2
+} from "@ai-sdk/provider-utils";
+
+// src/generate-text/tool-caller-configuration.ts
+import {
+  experimental_getToolCaller
+} from "@ai-sdk/provider-utils";
+var DIRECT_TOOL_CALL = "AI_SDK_DIRECT_TOOL_CALL";
+
+// src/tool-search/tool-search.ts
+import { jsonSchema, tool } from "@ai-sdk/provider-utils";
+var toolSearchSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.toolSearch");
+function isToolSearch(tool2) {
+  return tool2[toolSearchSymbol] === true;
+}
+
+// src/tool-search/prepare-tool-search.ts
+function createToolSearchState({
+  tools,
+  toolCallers
+}) {
+  const searchTools = Object.entries(tools != null ? tools : {}).filter(
+    ([, tool2]) => tool2.deferLoading || isToolSearch(tool2)
+  );
+  if (searchTools.length === 0) {
+    return (activeTools) => activeTools;
+  }
+  const discovered = /* @__PURE__ */ new Set();
+  const getCallers = (name12) => {
+    var _a12;
+    return (_a12 = getOwn(toolCallers, name12)) != null ? _a12 : [DIRECT_TOOL_CALL];
+  };
+  for (const [name12, tool2] of searchTools) {
+    const callers = getCallers(name12);
+    if (callers.some((name13) => {
+      if (name13 === DIRECT_TOOL_CALL) {
+        return false;
+      }
+      const caller = experimental_getToolCaller2(tools == null ? void 0 : tools[name13]);
+      return (caller == null ? void 0 : caller.type) !== "local" || caller.prepareModelMessage == null;
+    }) || isToolSearch(tool2) && tool2.deferLoading) {
+      throw new InvalidArgumentError({
+        parameter: "tools",
+        value: name12,
+        message: `tool "${name12}" must be callable directly or through code mode with toolDiscovery: 'conversation'. The search tool itself must not defer loading.`
+      });
+    }
+  }
+  return (activeTools, { toolsContext = {}, experimental_sandbox } = {}) => {
+    if (activeTools == null) {
+      return void 0;
+    }
+    const entries = Object.entries(activeTools);
+    return Object.fromEntries(
+      entries.filter(([name12, tool2]) => !tool2.deferLoading || discovered.has(name12)).map(([searchName, tool2]) => {
+        if (!isToolSearch(tool2)) {
+          return [searchName, tool2];
+        }
+        const callers = getCallers(searchName).filter(
+          (name12) => name12 === DIRECT_TOOL_CALL || Object.hasOwn(activeTools, name12)
+        );
+        const candidates = entries.filter(
+          ([name12, candidate]) => candidate.deferLoading && !isToolSearch(candidate) && callers.some((caller) => getCallers(name12).includes(caller))
+        );
+        return [
+          searchName,
+          {
+            ...tool2,
+            execute: ({ query }) => {
+              const terms = [...new Set(tokenize(query))];
+              const matches = candidates.map(([name12, candidate]) => {
+                const description = resolveToolDescription({
+                  tool: candidate,
+                  toolName: name12,
+                  toolsContext,
+                  experimental_sandbox
+                });
+                const nameTerms = tokenize(name12);
+                const descriptionTerms = tokenize(description != null ? description : "");
+                const score = terms.reduce(
+                  (score2, term) => score2 + (nameTerms.includes(term) ? 2 : 0) + (descriptionTerms.includes(term) ? 1 : 0),
+                  0
+                );
+                return { name: name12, description, score };
+              }).filter((match) => match.score > 0).sort((a, b) => b.score - a.score).slice(0, 5);
+              for (const { name: name12 } of matches) {
+                discovered.add(name12);
+              }
+              return {
+                tools: matches.map(({ name: name12, description }) => ({
+                  name: name12,
+                  ...description == null ? {} : { description }
+                }))
+              };
+            }
+          }
+        ];
+      })
+    );
+  };
+}
+function tokenize(text) {
+  var _a12;
+  return (_a12 = text.replace(/([a-z\d])([A-Z])/g, "$1 $2").toLowerCase().match(/[\p{L}\p{N}]+/gu)) != null ? _a12 : [];
+}
+
 // src/generate-text/collect-tool-approvals.ts
 function collectToolApprovals({
   messages
@@ -3196,7 +3465,7 @@ function collectToolApprovals({
 import { convertBase64ToUint8Array } from "@ai-sdk/provider-utils";
 
 // src/util/canonical-hash.ts
-import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
+import { convertUint8ArrayToBase64 as convertUint8ArrayToBase642 } from "@ai-sdk/provider-utils";
 var encoder = new TextEncoder();
 function canonicalJSON(value) {
   if (value === null || value === void 0) {
@@ -3215,7 +3484,7 @@ function canonicalJSON(value) {
   return `{${entries.join(",")}}`;
 }
 function toBase64url(bytes) {
-  return convertUint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+  return convertUint8ArrayToBase642(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
 async function hashCanonical(value) {
   const digest = await crypto.subtle.digest(
@@ -3347,7 +3616,7 @@ async function resolveToolApproval({
     );
   }
   const toolName = toolCall.toolName;
-  const tool = getOwn(tools, toolName);
+  const tool2 = getOwn(tools, toolName);
   const input = toolCall.input;
   const userDefinedToolApprovalStatus = getOwn(toolApproval, toolName);
   if (userDefinedToolApprovalStatus != null) {
@@ -3357,24 +3626,24 @@ async function resolveToolApproval({
       toolContext: await validateToolContext({
         toolName,
         context: getOwn(toolsContext, toolName),
-        contextSchema: tool == null ? void 0 : tool.contextSchema
+        contextSchema: tool2 == null ? void 0 : tool2.contextSchema
       }),
       runtimeContext
     }) : userDefinedToolApprovalStatus;
     return normalizeToolApprovalStatus(approvalStatus);
   }
-  if ((tool == null ? void 0 : tool.needsApproval) == null) {
+  if ((tool2 == null ? void 0 : tool2.needsApproval) == null) {
     return { type: "not-applicable" };
   }
-  const needsApproval = typeof tool.needsApproval === "function" ? await tool.needsApproval(input, {
+  const needsApproval = typeof tool2.needsApproval === "function" ? await tool2.needsApproval(input, {
     toolCallId: toolCall.toolCallId,
     messages,
     context: await validateToolContext({
       toolName,
       context: getOwn(toolsContext, toolName),
-      contextSchema: tool == null ? void 0 : tool.contextSchema
+      contextSchema: tool2 == null ? void 0 : tool2.contextSchema
     })
-  }) : tool.needsApproval;
+  }) : tool2.needsApproval;
   return needsApproval ? { type: "user-approval" } : { type: "not-applicable" };
 }
 function normalizeToolApprovalStatus(status) {
@@ -3397,7 +3666,7 @@ async function validateApprovedToolApprovals({
   const invalid = [];
   for (const approval of approvedToolApprovals) {
     const { toolCall, approvalRequest } = approval;
-    const tool = getOwn(tools, toolCall.toolName);
+    const tool2 = getOwn(tools, toolCall.toolName);
     if (toolApprovalSecret != null) {
       if (approvalRequest.signature == null) {
         throw new InvalidToolApprovalSignatureError({
@@ -3422,10 +3691,10 @@ async function validateApprovedToolApprovals({
         });
       }
     }
-    if (isExecutableTool(tool) && tool.inputSchema != null) {
+    if (isExecutableTool(tool2) && tool2.inputSchema != null) {
       const validation = await safeValidateTypes3({
         value: toolCall.input,
-        schema: asSchema3(tool.inputSchema)
+        schema: asSchema3(tool2.inputSchema)
       });
       if (!validation.success) {
         invalid.push({
@@ -3679,6 +3948,7 @@ export {
   createRestrictedTelemetryDispatcher,
   createTelemetryDispatcher,
   createToolModelOutput,
+  createToolSearchState,
   downloadAssets,
   mapToolResultOutput,
   mergeAbortSignals,