@flutchai/flutch-sdk 0.6.12 → 0.7.0

package/README.md

@@ -229,6 +229,35 @@ curl http://localhost:3000/registry
 
 ## Advanced Usage
 
+### Tool search for agents with many tools
+
+Every bound tool's schema is sent on every turn. With dozens of tools that is most of the prompt, and models pick the wrong tool more often past 30–50 of them. Turn on tool search and the model sees a few tools plus `search_tools`, and finds the rest when a task needs them:
+
+```typescript
+import { isToolSearchCall } from "@flutchai/flutch-sdk";
+
+const modelConfig = {
+  modelId,
+  toolsConfig,
+  toolSearch: { enabled: true, alwaysLoaded: ["list_sites", "list_products"] },
+};
+const model = await modelInitializer.initializeChatModel(modelConfig);
+
+// In the tools node: search runs in the SDK, against the same catalog.
+if (isToolSearchCall(toolCall.name)) {
+  const { content } = await modelInitializer.searchTools(
+    modelConfig,
+    toolCall.args,
+    config
+  );
+  messages.push(
+    new ToolMessage({ content, tool_call_id: toolCall.id, name: toolCall.name })
+  );
+}
+```
+
+Pass the same config to `searchTools` that built the model — it names the catalog. Found tools are read from the conversation history, so the graph keeps no extra state. Claude through the Anthropic Messages API loads found tools as deferred definitions (`defer_loading` + `tool_reference`) and keeps the prompt cache; other providers bind the core tools plus the found ones each turn. `alwaysLoaded` also takes a comma-separated string; `maxResults` (default 5) and `minTools` (default 15) tune it.
+
 ### Using GraphTypeUtils
 
 ```typescript

package/dist/index.cjs

@@ -21,6 +21,8 @@ var dispatch = require('@langchain/core/callbacks/dispatch');
 var tools = require('@langchain/core/tools');
 var axios2 = require('axios');
 var manager = require('@langchain/core/callbacks/manager');
+var runnables = require('@langchain/core/runnables');
+var zod = require('zod');
 var openai = require('@langchain/openai');
 var aws = require('@langchain/aws');
 var core$1 = require('cohere-ai/core');
@@ -7086,6 +7088,314 @@ exports.McpRuntimeHttpClient = _ts_decorate25([
   ])
 ], exports.McpRuntimeHttpClient);
 
+// src/tools/tool-search/tool-search.catalog.ts
+var K1 = 1.2;
+var B = 0.75;
+var NAME_WEIGHT = 3;
+var STEM_LENGTH = 5;
+var HIT_DESCRIPTION_CHARS = 240;
+function toolSearchTerms(text) {
+  return text.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((word) => word.length > 1).map((word) => word.slice(0, STEM_LENGTH));
+}
+__name(toolSearchTerms, "toolSearchTerms");
+function schemaParams(schema) {
+  const json = schema;
+  const properties = json?.properties ?? json?.shape ?? {};
+  return Object.entries(properties).flatMap(([name, property]) => property?.description ? [
+    name,
+    property.description
+  ] : [
+    name
+  ]);
+}
+__name(schemaParams, "schemaParams");
+function shortDescription(description) {
+  const flat = description.replace(/\s+/g, " ").trim();
+  if (flat.length <= HIT_DESCRIPTION_CHARS) return flat;
+  const cut = flat.slice(0, HIT_DESCRIPTION_CHARS);
+  const sentenceEnd = cut.lastIndexOf(". ");
+  return sentenceEnd > HIT_DESCRIPTION_CHARS / 2 ? cut.slice(0, sentenceEnd + 1) : `${cut.trimEnd()}\u2026`;
+}
+__name(shortDescription, "shortDescription");
+var ToolSearchCatalog = class {
+  static {
+    __name(this, "ToolSearchCatalog");
+  }
+  entries;
+  documents;
+  lengths;
+  averageLength;
+  documentFrequency = /* @__PURE__ */ new Map();
+  constructor(tools) {
+    this.entries = tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description ?? "",
+      params: schemaParams(tool.schema)
+    }));
+    this.documents = this.entries.map((entry) => {
+      const nameTerms = toolSearchTerms(entry.name);
+      const terms = [
+        ...Array.from({
+          length: NAME_WEIGHT
+        }, () => nameTerms).flat(),
+        ...toolSearchTerms(entry.description),
+        ...entry.params.flatMap(toolSearchTerms)
+      ];
+      const counts = /* @__PURE__ */ new Map();
+      for (const term of terms) counts.set(term, (counts.get(term) ?? 0) + 1);
+      return counts;
+    });
+    this.lengths = this.documents.map((counts) => Array.from(counts.values()).reduce((sum, n) => sum + n, 0));
+    this.averageLength = this.lengths.reduce((sum, n) => sum + n, 0) / Math.max(this.lengths.length, 1);
+    for (const counts of this.documents) {
+      for (const term of counts.keys()) {
+        this.documentFrequency.set(term, (this.documentFrequency.get(term) ?? 0) + 1);
+      }
+    }
+  }
+  get size() {
+    return this.entries.length;
+  }
+  has(name) {
+    return this.entries.some((entry) => entry.name === name);
+  }
+  /**
+  * The best `limit` tools for a query, best first. A query that names a tool
+  * exactly returns that tool first whatever its score. Tools that share no
+  * word with the query are never returned.
+  */
+  search(query, limit) {
+    const terms = Array.from(new Set(toolSearchTerms(query)));
+    const exact = query.split(/[\s,]+/).map((word) => word.trim()).filter((word) => this.has(word));
+    const total = this.entries.length;
+    const scored = this.entries.map((entry, index) => {
+      const counts = this.documents[index];
+      const length = this.lengths[index];
+      let score = 0;
+      for (const term of terms) {
+        const frequency = counts.get(term);
+        if (!frequency) continue;
+        const df = this.documentFrequency.get(term) ?? 0;
+        const idf = Math.log(1 + (total - df + 0.5) / (df + 0.5));
+        score += idf * frequency * (K1 + 1) / (frequency + K1 * (1 - B + B * length / this.averageLength));
+      }
+      if (exact.includes(entry.name)) score += 1e3;
+      return {
+        entry,
+        score
+      };
+    }).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score);
+    return scored.slice(0, Math.max(1, limit)).map(({ entry }) => ({
+      name: entry.name,
+      description: shortDescription(entry.description)
+    }));
+  }
+  /**
+  * What the catalog covers, as name prefixes with counts:
+  * "funnel_* (4), recipe_* (5), rl_* (41)". Goes into the search tool's
+  * description so the model knows a search is worth making. Sorted, so the
+  * description — and the prompt cache — stays the same between requests.
+  */
+  summary(maxGroups = 20) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of this.entries) {
+      const prefix = entry.name.includes("_") ? `${entry.name.split("_")[0]}_*` : entry.name;
+      groups.set(prefix, (groups.get(prefix) ?? 0) + 1);
+    }
+    const sorted = Array.from(groups.entries()).sort(([a], [b]) => a.localeCompare(b));
+    const shown = sorted.slice(0, maxGroups).map(([prefix, count]) => count > 1 ? `${prefix} (${count})` : prefix);
+    return sorted.length > maxGroups ? `${shown.join(", ")}, \u2026` : shown.join(", ");
+  }
+};
+
+// src/tools/tool-search/tool-search.result.ts
+var TOOL_SEARCH_NAME = "search_tools";
+function isToolSearchCall(name) {
+  return name === TOOL_SEARCH_NAME;
+}
+__name(isToolSearchCall, "isToolSearchCall");
+function formatToolSearchResult(hits) {
+  if (hits.length === 0) {
+    return JSON.stringify({
+      tools: [],
+      note: "No tools matched. Search again with other words: what the tool does, the object it works on, or a name prefix."
+    });
+  }
+  return JSON.stringify({
+    tools: hits,
+    note: "These tools are available now. Call them directly."
+  });
+}
+__name(formatToolSearchResult, "formatToolSearchResult");
+function parseToolSearchResult(content) {
+  const text = contentText(content);
+  if (!text) return [];
+  try {
+    const parsed = JSON.parse(text);
+    return (parsed.tools ?? []).map((tool) => tool?.name).filter((name) => typeof name === "string");
+  } catch {
+    return [];
+  }
+}
+__name(parseToolSearchResult, "parseToolSearchResult");
+function contentText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => typeof part === "string" ? part : part && typeof part === "object" && "text" in part ? String(part.text) : "").join("");
+  }
+  return "";
+}
+__name(contentText, "contentText");
+function loadedToolNames(messages) {
+  const searchCallIds = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    const calls = message.tool_calls;
+    for (const call of calls ?? []) {
+      if (isToolSearchCall(call.name) && call.id) searchCallIds.add(call.id);
+    }
+  }
+  const loaded = [];
+  for (const message of messages) {
+    if (message._getType() !== "tool") continue;
+    const tool = message;
+    const isSearch = isToolSearchCall(tool.name) || tool.tool_call_id !== void 0 && searchCallIds.has(tool.tool_call_id);
+    if (!isSearch) continue;
+    for (const name of parseToolSearchResult(tool.content)) {
+      if (!loaded.includes(name)) loaded.push(name);
+    }
+  }
+  return loaded;
+}
+__name(loadedToolNames, "loadedToolNames");
+var DEFAULT_TOOL_SEARCH_RESULTS = 5;
+var DEFAULT_TOOL_SEARCH_MIN_TOOLS = 15;
+function toolSearchApplies(options, toolCount) {
+  return !!options?.enabled && toolCount >= (options.minTools ?? DEFAULT_TOOL_SEARCH_MIN_TOOLS);
+}
+__name(toolSearchApplies, "toolSearchApplies");
+function splitTools(tools, options, extraCore = []) {
+  const listed = typeof options.alwaysLoaded === "string" ? options.alwaysLoaded.split(",") : options.alwaysLoaded ?? [];
+  const always = /* @__PURE__ */ new Set([
+    ...listed.map((name) => name.trim()).filter(Boolean),
+    ...extraCore.map((tool) => tool.name)
+  ]);
+  return {
+    core: tools.filter((tool) => always.has(tool.name)),
+    deferred: tools.filter((tool) => !always.has(tool.name))
+  };
+}
+__name(splitTools, "splitTools");
+function createToolSearchTool(catalog, maxResults = DEFAULT_TOOL_SEARCH_RESULTS) {
+  return new tools.DynamicStructuredTool({
+    name: TOOL_SEARCH_NAME,
+    description: `Find more tools. You see only some of your tools; ${catalog.size} more are found by search: ${catalog.summary()}. Describe the task in a few words (what to do and with what, e.g. "customer review quotes by theme"), or give exact tool names. Found tools become callable right away and stay available for the rest of the conversation. Search before saying you cannot do something.`,
+    schema: zod.z.object({
+      query: zod.z.string().describe("What the tool should do, in a few words, or tool names separated by commas"),
+      limit: zod.z.number().int().min(1).max(20).optional().describe(`How many tools to return (default ${maxResults})`)
+    }),
+    func: /* @__PURE__ */ __name(async ({ query, limit }) => formatToolSearchResult(catalog.search(query, limit ?? maxResults)), "func")
+  });
+}
+__name(createToolSearchTool, "createToolSearchTool");
+function deferredCopy(tool) {
+  const copy = Object.create(tool);
+  copy.extras = {
+    ...tool.extras ?? {},
+    defer_loading: true
+  };
+  return copy;
+}
+__name(deferredCopy, "deferredCopy");
+function bindToolsWithSearch(params) {
+  const { model, core, deferred, searchTool, mode, bindOptions } = params;
+  const bind = /* @__PURE__ */ __name((tools) => bindOptions ? model.bindTools(tools, bindOptions) : model.bindTools(tools), "bind");
+  if (mode === "deferred") {
+    return bind([
+      searchTool,
+      ...core,
+      ...deferred.map(deferredCopy)
+    ]);
+  }
+  const byName = new Map(deferred.map((tool) => [
+    tool.name,
+    tool
+  ]));
+  const bound = /* @__PURE__ */ new Map();
+  const forHistory = /* @__PURE__ */ __name((messages) => {
+    const found = loadedToolNames(messages).filter((name) => byName.has(name));
+    const key = found.join(",");
+    let runnable = bound.get(key);
+    if (!runnable) {
+      runnable = bind([
+        ...core,
+        searchTool,
+        ...found.map((name) => byName.get(name))
+      ]);
+      bound.set(key, runnable);
+    }
+    return runnable;
+  }, "forHistory");
+  return runnables.RunnableLambda.from(async (input, config) => {
+    const messages = Array.isArray(input) ? input : [];
+    return forHistory(messages).invoke(input, config);
+  }).withConfig({
+    runName: "ToolSearchModel"
+  });
+}
+__name(bindToolsWithSearch, "bindToolsWithSearch");
+
+// src/tools/tool-search/tool-reference.fetch.ts
+function rewriteToolReferences(body) {
+  if (!body.includes(TOOL_SEARCH_NAME)) return body;
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return body;
+  }
+  const known = new Set((parsed.tools ?? []).map((tool) => tool.name));
+  const searchIds = /* @__PURE__ */ new Set();
+  for (const message of parsed.messages ?? []) {
+    if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
+    for (const block of message.content) {
+      if (block.type === "tool_use" && block.name === TOOL_SEARCH_NAME && block.id) {
+        searchIds.add(block.id);
+      }
+    }
+  }
+  if (searchIds.size === 0) return body;
+  let changed = false;
+  for (const message of parsed.messages ?? []) {
+    if (message.role !== "user" || !Array.isArray(message.content)) continue;
+    for (const block of message.content) {
+      if (block.type !== "tool_result" || !block.tool_use_id) continue;
+      if (!searchIds.has(block.tool_use_id)) continue;
+      const names = parseToolSearchResult(block.content).filter((name) => known.has(name));
+      if (names.length === 0) continue;
+      block.content = names.map((name) => ({
+        type: "tool_reference",
+        tool_name: name
+      }));
+      changed = true;
+    }
+  }
+  return changed ? JSON.stringify(parsed) : body;
+}
+__name(rewriteToolReferences, "rewriteToolReferences");
+function withToolReferences(inner) {
+  return (input, init) => {
+    if (init && typeof init.body === "string") {
+      const body = rewriteToolReferences(init.body);
+      if (body !== init.body) return inner(input, {
+        ...init,
+        body
+      });
+    }
+    return inner(input, init);
+  };
+}
+__name(withToolReferences, "withToolReferences");
+
 // src/models/enums.ts
 var ModelProvider = /* @__PURE__ */ (function(ModelProvider2) {
   ModelProvider2["MISTRAL"] = "mistral";
@@ -7452,6 +7762,8 @@ var ModelInitializer = class _ModelInitializer {
   modelConfigCache = /* @__PURE__ */ new Map();
   // Cache for model instances to avoid recreating identical models
   modelInstanceCache = /* @__PURE__ */ new Map();
+  // Tool-search catalogs, keyed like the model instance that uses them
+  toolSearchCatalogs = /* @__PURE__ */ new Map();
   static DEFAULT_ENV_MAP = {
     [ModelProvider.OPENAI]: "OPENAI_API_KEY",
     [ModelProvider.ANTHROPIC]: "ANTHROPIC_API_KEY",
@@ -7527,7 +7839,8 @@ var ModelInitializer = class _ModelInitializer {
     const withMcp = config.mcpServers && config.mcpServers.length > 0 ? `${base}:mcp:${JSON.stringify(config.mcpServers)}` : base;
     const withSampling = config.supportsSamplingParams === void 0 ? withMcp : `${withMcp}:sp:${config.supportsSamplingParams}`;
     const withCache = config.promptCache === void 0 && config.promptCacheTtl === void 0 ? withSampling : `${withSampling}:pc:${config.promptCache ?? "auto"}:${config.promptCacheTtl ?? "default"}`;
-    return config.effort === void 0 ? withCache : `${withCache}:eff:${config.effort}`;
+    const withEffort = config.effort === void 0 ? withCache : `${withCache}:eff:${config.effort}`;
+    return config.toolSearch?.enabled ? `${withEffort}:ts:${JSON.stringify(config.toolSearch)}` : withEffort;
   }
   // Chat model creators
   chatModelCreators = {
@@ -7561,10 +7874,13 @@ var ModelInitializer = class _ModelInitializer {
         },
         anthropicApiKey: apiToken || this.resolveApiKey(ModelProvider.ANTHROPIC),
         ...routerURL && {
-          anthropicApiUrl: routerURL,
-          clientOptions: {
-            fetch: flutchFetch
-          }
+          anthropicApiUrl: routerURL
+        },
+        // Tool search results become `tool_reference` blocks on the wire
+        // (LangChain cannot express them). A request without a search passes
+        // through untouched.
+        clientOptions: {
+          fetch: withToolReferences(routerURL ? flutchFetch : fetch)
         }
       });
     },
@@ -7808,7 +8124,11 @@ var ModelInitializer = class _ModelInitializer {
         // Converse takes cache control as a per-call option; the Anthropic
         // client already got it as a constructor field, and handing it the
         // same value twice would put an unknown key in its call options.
-        finalConfig.useBedrock ? promptCacheControl : void 0
+        finalConfig.useBedrock ? promptCacheControl : void 0,
+        config.toolSearch?.enabled ? {
+          options: config.toolSearch,
+          cacheKey
+        } : void 0
       );
       this.modelInstanceCache.set(cacheKey, boundModel);
       return boundModel;
@@ -7834,8 +8154,9 @@ var ModelInitializer = class _ModelInitializer {
   * - Runnable when tools are bound (model.bindTools returns Runnable)
   * - BaseChatModel when no tools
   */
-  async bindToolsToModel(model, toolsConfig, customTools, mcpServers, mcpContext, promptCacheControl) {
+  async bindToolsToModel(model, toolsConfig, customTools, mcpServers, mcpContext, promptCacheControl, toolSearch) {
     const allTools = [];
+    const mcpToolsFound = [];
     const enabledToolsConfig = (toolsConfig || []).filter((tc) => tc.enabled !== false);
     const hasInlineServers = !!(mcpServers && mcpServers.length > 0);
     if (enabledToolsConfig.length > 0 || hasInlineServers) {
@@ -7845,6 +8166,7 @@ var ModelInitializer = class _ModelInitializer {
         const mcpTools = await mcpToolFilter.getFilteredTools(enabledToolsConfig, mcpServers, mcpContext);
         this.logger.debug(`Successfully fetched ${mcpTools.length} tools with dynamic schemas from MCP Runtime`);
         allTools.push(...mcpTools);
+        mcpToolsFound.push(...mcpTools);
       } catch (error) {
         this.logger.error(`Failed to fetch tools from MCP Runtime: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -7858,11 +8180,86 @@ var ModelInitializer = class _ModelInitializer {
       const boundOptions = {
         cache_control: promptCacheControl
       };
+      if (toolSearch && toolSearchApplies(toolSearch.options, allTools.length)) {
+        const { core, deferred } = splitTools(mcpToolsFound, toolSearch.options, customTools ?? []);
+        if (deferred.length > 0) {
+          const maxResults = toolSearch.options.maxResults ?? DEFAULT_TOOL_SEARCH_RESULTS;
+          const catalog = new ToolSearchCatalog(deferred);
+          this.toolSearchCatalogs.set(toolSearch.cacheKey, {
+            catalog,
+            maxResults
+          });
+          const mode = model instanceof anthropic.ChatAnthropic ? "deferred" : "rebind";
+          this.logger.debug(`Tool search (${mode}): ${core.length + (customTools?.length ?? 0)} tools in sight, ${deferred.length} found on demand`);
+          return bindToolsWithSearch({
+            model,
+            core: [
+              ...core,
+              ...customTools ?? []
+            ],
+            deferred,
+            searchTool: createToolSearchTool(catalog, maxResults),
+            mode,
+            bindOptions: promptCacheControl ? boundOptions : void 0
+          });
+        }
+      }
       const modelWithTools = promptCacheControl ? model.bindTools(allTools, boundOptions) : model.bindTools(allTools);
       return modelWithTools;
     }
     return model;
   }
+  /**
+  * Runs a `search_tools` call. `config` must be the one the model was
+  * initialized with (same tools, same `toolSearch`): it names the catalog.
+  * Emits tool start/end events like `McpRuntimeHttpClient.executeToolWithEvents`,
+  * so the call shows as a finished step in the chat.
+  *
+  * Never throws: a failure comes back as the tool's answer.
+  */
+  async searchTools(config, args, runConfig) {
+    const parsedConfig = manager.parseCallbackConfigArg(runConfig);
+    const callbackManager = manager.CallbackManager.configure(parsedConfig.callbacks);
+    const runManager = await callbackManager?.handleToolStart({
+      name: TOOL_SEARCH_NAME,
+      lc: 1,
+      type: "not_implemented",
+      id: [
+        "langchain",
+        "tools",
+        TOOL_SEARCH_NAME
+      ]
+    }, JSON.stringify(args ?? {}), parsedConfig.runId, void 0, parsedConfig.tags, parsedConfig.metadata, TOOL_SEARCH_NAME);
+    try {
+      const key = this.generateModelCacheKey(config);
+      if (!this.toolSearchCatalogs.has(key)) {
+        await this.initializeChatModel(config);
+      }
+      const entry = this.toolSearchCatalogs.get(key);
+      const query = typeof args?.query === "string" ? args.query : "";
+      const limit = Number(args?.limit);
+      const content = !entry ? JSON.stringify({
+        error: "Tool search is not available for this agent: every tool is already loaded."
+      }) : !query.trim() ? JSON.stringify({
+        error: "query is required"
+      }) : formatToolSearchResult(entry.catalog.search(query, Number.isFinite(limit) && limit > 0 ? limit : entry.maxResults));
+      await runManager?.handleToolEnd(content);
+      return {
+        content,
+        success: !!entry && !!query.trim()
+      };
+    } catch (error) {
+      await runManager?.handleToolError(error);
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Tool search failed: ${message}`);
+      return {
+        content: JSON.stringify({
+          error: `Tool search failed: ${message}`
+        }),
+        success: false
+      };
+    }
+  }
   async initializeRerankModel(config) {
     const cacheKey = this.generateModelCacheKey(config);
     const cachedModel = this.modelInstanceCache.get(cacheKey);
@@ -8661,6 +9058,8 @@ exports.CallbackStore = CallbackStore;
 exports.ChatFeature = ChatFeature;
 exports.DEFAULT_ATTACHMENT_THRESHOLD = DEFAULT_ATTACHMENT_THRESHOLD;
 exports.DEFAULT_ROUTER_URL = DEFAULT_ROUTER_URL;
+exports.DEFAULT_TOOL_SEARCH_MIN_TOOLS = DEFAULT_TOOL_SEARCH_MIN_TOOLS;
+exports.DEFAULT_TOOL_SEARCH_RESULTS = DEFAULT_TOOL_SEARCH_RESULTS;
 exports.DEFAULT_TRACER_OPTIONS = DEFAULT_TRACER_OPTIONS;
 exports.Endpoint = Endpoint;
 exports.FileTokenStore = FileTokenStore;
@@ -8681,6 +9080,8 @@ exports.PROMPT_CACHE_MIN_VERSIONS = PROMPT_CACHE_MIN_VERSIONS;
 exports.RetrieverSearchType = RetrieverSearchType;
 exports.SAMPLING_PARAM_FREE_THRESHOLDS = SAMPLING_PARAM_FREE_THRESHOLDS;
 exports.StreamChannel = StreamChannel;
+exports.TOOL_SEARCH_NAME = TOOL_SEARCH_NAME;
+exports.ToolSearchCatalog = ToolSearchCatalog;
 exports.UIEndpoint = UIEndpoint;
 exports.UniversalCallbackService = UniversalCallbackService;
 exports.VoyageAIRerank = VoyageAIRerank;
@@ -8688,6 +9089,7 @@ exports.WithCallbacks = WithCallbacks;
 exports.WithEndpoints = WithEndpoints;
 exports.WithUIEndpoints = WithUIEndpoints;
 exports._internals = _internals;
+exports.bindToolsWithSearch = bindToolsWithSearch;
 exports.bootstrap = bootstrap;
 exports.buildEffortRequestFields = buildEffortRequestFields;
 exports.buildOAuthAuthorizationUrl = buildOAuthAuthorizationUrl;
@@ -8697,6 +9099,7 @@ exports.createEndpointDescriptors = createEndpointDescriptors;
 exports.createGraphAttachment = createGraphAttachment;
 exports.createMongoClientAdapter = createMongoClientAdapter;
 exports.createStaticMessage = createStaticMessage;
+exports.createToolSearchTool = createToolSearchTool;
 exports.decryptTokens = decryptTokens;
 exports.dispatchAttachments = dispatchAttachments;
 exports.encryptTokens = encryptTokens;
@@ -8706,6 +9109,7 @@ exports.findEndpointMethod = findEndpointMethod;
 exports.flutchFetch = flutchFetch;
 exports.flutchHeaders = flutchHeaders;
 exports.flutchMistralHook = flutchMistralHook;
+exports.formatToolSearchResult = formatToolSearchResult;
 exports.generateAttachmentSummary = generateAttachmentSummary;
 exports.generateModelCacheKey = generateModelCacheKey;
 exports.getAttachmentData = getAttachmentData;
@@ -8723,11 +9127,14 @@ exports.isInternalMode = isInternalMode;
 exports.isReasoningBlock = isReasoningBlock;
 exports.isReasoningModel = isReasoningModel;
 exports.isSendableReasoningBlock = isSendableReasoningBlock;
+exports.isToolSearchCall = isToolSearchCall;
 exports.joinTextSteps = joinTextSteps;
 exports.loadOAuthProviders = loadOAuthProviders;
+exports.loadedToolNames = loadedToolNames;
 exports.modelAcceptsSamplingParams = modelAcceptsSamplingParams;
 exports.modelSupportsPromptCache = modelSupportsPromptCache;
 exports.normalizeToolConfigs = normalizeToolConfigs;
+exports.parseToolSearchResult = parseToolSearchResult;
 exports.redactConnectionString = redactConnectionString;
 exports.registerFinanceExampleCallback = registerFinanceExampleCallback;
 exports.registerUIEndpointsFromClass = registerUIEndpointsFromClass;
@@ -8735,13 +9142,18 @@ exports.resolveOAuthProviderConfig = resolveOAuthProviderConfig;
 exports.resolvePromptCacheControl = resolvePromptCacheControl;
 exports.resolveRouterURL = resolveRouterURL;
 exports.resolveSamplingParams = resolveSamplingParams;
+exports.rewriteToolReferences = rewriteToolReferences;
 exports.sanitizeMessageReasoning = sanitizeMessageReasoning;
 exports.sanitizeReasoningForBedrock = sanitizeReasoningForBedrock;
 exports.sanitizeTraceData = sanitizeTraceData;
+exports.splitTools = splitTools;
 exports.storeAttachmentData = storeAttachmentData;
 exports.toOptionalNumber = toOptionalNumber;
+exports.toolSearchApplies = toolSearchApplies;
+exports.toolSearchTerms = toolSearchTerms;
 exports.traceApiCall = traceApiCall;
 exports.withFlutchContext = withFlutchContext;
+exports.withToolReferences = withToolReferences;
 exports.wrapCohereFetcher = wrapCohereFetcher;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map