ai 7.0.106 → 7.0.107

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];
@@ -2688,6 +2690,15 @@ declare function parseToolCall<TOOLS extends ToolSet>({ toolCall, tools, repairT
     messages: ModelMessage[];
 }): 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 +2761,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.107" : "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
   });
@@ -3021,7 +3021,7 @@ async function parseToolCall({
   } catch (error) {
     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,10 +3030,10 @@ 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 } : {}
     };
   }
 }
@@ -3074,8 +3074,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 +3084,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 +3093,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 +3110,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
@@ -3347,7 +3455,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 +3465,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 +3505,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 +3530,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 +3787,7 @@ export {
   createRestrictedTelemetryDispatcher,
   createTelemetryDispatcher,
   createToolModelOutput,
+  createToolSearchState,
   downloadAssets,
   mapToolResultOutput,
   mergeAbortSignals,