llm-switcher 1.6.5 → 1.6.7

package/toolvocab.mjs

@@ -220,7 +220,55 @@ export function sanitizeToolName(name, { allowHyphens = true } = {}) {
  *
  * A list with no tools, or one where nothing can be confused, leaves every call untouched.
  */
-export function createToolVocab(declared) {
+export function createToolNameMap(names, options = {}) {
+  const originals = [...new Set(names.filter(n => typeof n === 'string' && n))].sort();
+  const forward = new Map();
+  const reverse = new Map();
+  // Reserve unchanged names before allocating aliases, independent of declaration order.
+  for (const name of originals) {
+    if (sanitizeToolName(name, options) === name) { forward.set(name, name); reverse.set(name, name); }
+  }
+  for (const name of originals) {
+    if (forward.has(name)) continue;
+    const base = sanitizeToolName(name, options);
+    let alias = base;
+    for (let salt = 0; reverse.has(alias); salt++) {
+      const hash = crypto.createHash('sha256').update(`${name}\0${salt}`).digest('hex').slice(0, 12);
+      alias = `${base.slice(0, 51)}_${hash}`;
+    }
+    forward.set(name, alias); reverse.set(alias, name);
+  }
+  return { forward, reverse, name: n => forward.get(n) || sanitizeToolName(n, options) };
+}
+
+export function toolNameMapForIR(ir, options = {}) {
+  const names = [...(ir.tools || []).map(t => t.name),
+    ...(ir.messages || []).flatMap(m => [...(m.toolCalls || []).map(t => t.name), ...(m.name ? [m.name] : [])]),
+    ...(ir.toolChoice?.name ? [ir.toolChoice.name] : [])];
+  return createToolNameMap(names, options);
+}
+
+// Rewrite exact name mentions once, using the same collision-resolved map as declarations.
+// A longer identifier containing a name is not a mention of that tool.
+export function rewriteToolNameMentions(text, names) {
+  if (typeof text !== 'string') return text;
+  const changed = [...names].filter(([from, to]) => from && from !== to);
+  if (!changed.length) return text;
+  const lookup = new Map(changed);
+  const alternatives = changed.map(([from]) => from).sort((a, b) => b.length - a.length)
+    .map(n => n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  const pattern = new RegExp(`(?<![A-Za-z0-9_-])(?:${alternatives.join('|')})(?![A-Za-z0-9_-])`, 'g');
+  return text.replace(pattern, name => lookup.get(name));
+}
+
+// Only ToolSearch's query names other tools. Arbitrary tool arguments are caller data.
+export function rewriteToolSearchArgs(name, args, names) {
+  if (name !== 'ToolSearch' || !args || typeof args !== 'object' || Array.isArray(args) || typeof args.query !== 'string') return args;
+  const query = rewriteToolNameMentions(args.query, names);
+  return query === args.query ? args : { ...args, query };
+}
+
+export function createToolVocab(declared, { allowHyphens = true, names = [] } = {}) {
   // Only a tool the caller executes can be a rename target. A tool the provider runs answers in
   // band and its result reaches the caller without the caller executing anything; handing such a
   // call back as a client tool moves the work, silently, to the machine the user is sitting at.
@@ -229,17 +277,12 @@ export function createToolVocab(declared) {
   const byName = new Map();
   const candidates = [];
   const shortenedToOriginal = new Map();
+  const aliases = createToolNameMap([...tools.map(t => t.name), ...names], { allowHyphens });
 
   for (const t of tools) {
     const caps = capabilitiesOf(t.name);
-    const safeChat = sanitizeToolName(t.name, { allowHyphens: true });
-    const safeVertex = sanitizeToolName(t.name, { allowHyphens: false });
-    if (safeChat !== t.name) {
-      shortenedToOriginal.set(safeChat, t.name);
-    }
-    if (safeVertex !== t.name) {
-      shortenedToOriginal.set(safeVertex, t.name);
-    }
+    const alias = aliases.forward.get(t.name);
+    if (alias !== t.name) shortenedToOriginal.set(alias, t.name);
     const entry = { tool: t, name: t.name, namespace: namespaceOf(t.name), caps };
     // Keyed by the exact spelling: a client checks tool names exactly, so `read` is not the same
     // tool as `Read` to it, and that difference is the whole reason this layer exists.
@@ -283,7 +326,7 @@ export function createToolVocab(declared) {
 
   function args(upstream, argsJson) {
     const fixedName = name(upstream);
-    if (!useful && !shortenedToOriginal.has(String(upstream || ''))) return argsJson;
+    if (!useful && !shortenedToOriginal.has(String(upstream || '')) && !needsArgsRewrite(upstream)) return argsJson;
     const target = byName.get(fixedName);
     if (!target) return argsJson;
     let parsed;
@@ -292,15 +335,20 @@ export function createToolVocab(declared) {
     } catch {
       return argsJson;   // a truncated payload is passed through: changing bytes helps nobody
     }
-    const repaired = repairArgs(parsed, target.tool);
+    const repaired = rewriteToolSearchArgs(fixedName, repairArgs(parsed, target.tool), shortenedToOriginal);
     if (repaired === parsed) return argsJson;
     return JSON.stringify(repaired);
   }
 
+  function needsArgsRewrite(upstream) {
+    return name(upstream) === 'ToolSearch' && byName.has('ToolSearch') && shortenedToOriginal.size > 0;
+  }
+
   return {
     name,
     args,
     isShortened,
+    needsArgsRewrite,
     /** Both halves at once, for a call that is already whole. */
     repair(upstream, argsJson) {
       const fixedName = name(upstream);