ai 7.0.105 → 7.0.107

package/dist/internal/index.d.ts

@@ -787,7 +787,7 @@ type DownloadFunction = (options: Array<{
  * Default download function.
  * Downloads the file if it is not supported by the model.
  */
-declare const createDefaultDownloadFunction: (download?: typeof download) => DownloadFunction;
+declare const createDefaultDownloadFunction: (download?: typeof download, abortSignal?: AbortSignal) => DownloadFunction;
 
 /**
  * A generated file.
@@ -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];
@@ -2550,10 +2552,11 @@ declare global {
     var AI_SDK_TELEMETRY_INTEGRATIONS: Telemetry[] | undefined;
 }
 
-declare function convertToLanguageModelPrompt({ prompt, supportedUrls, download, provider, }: {
+declare function convertToLanguageModelPrompt({ prompt, supportedUrls, download, abortSignal, provider, }: {
     prompt: StandardizedPrompt;
     supportedUrls: Record<string, RegExp[]>;
     download: DownloadFunction | undefined;
+    abortSignal?: AbortSignal;
     provider?: string;
 }): Promise<LanguageModelV4Prompt>;
 /**
@@ -2687,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;
@@ -2749,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.105" : "0.0.0-test";
+var VERSION = true ? "7.0.107" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -138,9 +138,9 @@ var download = async ({
 };
 
 // src/util/download/download-function.ts
-var createDefaultDownloadFunction = (download2 = download) => (requestedDownloads) => Promise.all(
+var createDefaultDownloadFunction = (download2 = download, abortSignal) => (requestedDownloads) => Promise.all(
   requestedDownloads.map(
-    async (requestedDownload) => requestedDownload.isUrlSupportedByModel ? null : await download2(requestedDownload)
+    async (requestedDownload) => requestedDownload.isUrlSupportedByModel ? null : await download2({ ...requestedDownload, abortSignal })
   )
 );
 
@@ -430,14 +430,15 @@ var MissingToolResultsError = class extends (_b3 = AISDKError3, _a3 = symbol3, _
 async function convertToLanguageModelPrompt({
   prompt,
   supportedUrls,
-  download: download2 = createDefaultDownloadFunction(),
+  download: download2,
+  abortSignal,
   // `provider` is only needed here to convert legacy tool output types via `mapToolResultOutput`.
   // TODO: remove in v8 when "file-id" and "image-file-id" types are removed
   provider
 }) {
   const downloadedAssets = await downloadAssets(
     prompt.messages,
-    download2,
+    download2 != null ? download2 : createDefaultDownloadFunction(void 0, abortSignal),
     supportedUrls
   );
   const approvalIdToToolCallId = /* @__PURE__ */ new Map();
@@ -1061,32 +1062,29 @@ function getMediaTypeFromUrl(url, fallbackMediaType = "application/octet-stream"
 
 // src/prompt/create-tool-model-output.ts
 import { getErrorMessage } from "@ai-sdk/provider";
-import {
-  parseJSON
-} from "@ai-sdk/provider-utils";
 async function createToolModelOutput({
   toolCallId,
   input,
   output,
-  tool,
+  tool: tool2,
   errorMode
 }) {
   if (errorMode === "text") {
     return { type: "error-text", value: getErrorMessage(output) };
   } else if (errorMode === "json") {
-    return { type: "error-json", value: await toJSONValue(output) };
+    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: await toJSONValue(output) };
+  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: toJSONValue(output) };
 }
-async function toJSONValue(value) {
+function toJSONValue(value) {
   if (value === void 0) {
     return null;
   }
   const serialized = JSON.stringify(value);
-  return serialized === void 0 ? null : await parseJSON({ text: serialized });
+  return serialized === void 0 ? null : JSON.parse(serialized);
 }
 
 // src/prompt/prepare-tool-choice.ts
@@ -1117,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 } : {},
@@ -1147,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;
       }
@@ -1175,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
   });
@@ -3023,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,
@@ -3032,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 } : {}
     };
   }
 }
@@ -3076,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);
     }
@@ -3086,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({
@@ -3095,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,
@@ -3112,9 +3110,117 @@ 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
@@ -3349,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) {
@@ -3359,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) {
@@ -3399,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({
@@ -3424,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({
@@ -3681,6 +3787,7 @@ export {
   createRestrictedTelemetryDispatcher,
   createTelemetryDispatcher,
   createToolModelOutput,
+  createToolSearchState,
   downloadAssets,
   mapToolResultOutput,
   mergeAbortSignals,