@stackline/tool-router 1.0.0

package/dist/index.js

@@ -0,0 +1,1102 @@
+/*! @stackline/tool-router v1.0.0 | MIT */
+
+// src/errors.js
+var ToolRouterError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.name = "ToolRouterError";
+    this.code = code;
+    if (details !== void 0) this.details = details;
+  }
+};
+function fail(code, message, details) {
+  throw new ToolRouterError(code, message, details);
+}
+
+// src/safe.js
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function isUnsafeKey(key) {
+  return typeof key === "string" && UNSAFE_KEYS.has(key);
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function ownValue(value, key) {
+  if (!isObject(value) && typeof value !== "function") return void 0;
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor && Object.prototype.hasOwnProperty.call(descriptor, "value") ? descriptor.value : void 0;
+}
+function ownEnumerableEntries(value) {
+  if (!isObject(value)) return [];
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const entries = [];
+  for (const key of Object.keys(descriptors)) {
+    const descriptor = descriptors[key];
+    if (!descriptor.enumerable || !Object.prototype.hasOwnProperty.call(descriptor, "value")) continue;
+    if (isUnsafeKey(key)) continue;
+    entries.push([key, descriptor.value]);
+  }
+  return entries;
+}
+function stringValue(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function stringList(value, limit = 256) {
+  if (!Array.isArray(value)) return [];
+  const result = [];
+  for (let index = 0; index < value.length && result.length < limit; index++) {
+    const item = ownValue(value, String(index));
+    if (typeof item === "string" && item.length > 0) result.push(item);
+  }
+  return result;
+}
+function positiveInteger(value, fallback, maximum, label) {
+  if (value === void 0) return fallback;
+  if (!Number.isInteger(value) || value < 1 || value > maximum) {
+    fail("ERR_TOOL_ROUTER_OPTION", `${label} must be an integer between 1 and ${maximum}`);
+  }
+  return value;
+}
+function finiteNumber(value, fallback, minimum, maximum, label) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum) {
+    fail("ERR_TOOL_ROUTER_OPTION", `${label} must be a finite number between ${minimum} and ${maximum}`);
+  }
+  return value;
+}
+
+// src/adapters.js
+var TOOL_FORMATS = Object.freeze([
+  "canonical",
+  "mcp",
+  "openai-chat",
+  "openai-responses",
+  "anthropic",
+  "gemini"
+]);
+function explicitFormat(format) {
+  if (format === void 0 || format === "auto") return void 0;
+  if (!TOOL_FORMATS.includes(format)) {
+    fail("ERR_TOOL_FORMAT", `Unsupported tool format: ${String(format)}`);
+  }
+  return format;
+}
+function detectToolFormat(tool) {
+  if (!isObject(tool)) fail("ERR_TOOL_DEFINITION", "Tool definition must be an object");
+  const type = ownValue(tool, "type");
+  const nestedFunction = ownValue(tool, "function");
+  if (type === "function" && isObject(nestedFunction)) return "openai-chat";
+  if (type === "function" && typeof ownValue(tool, "name") === "string") return "openai-responses";
+  if (ownValue(tool, "input_schema") !== void 0) return "anthropic";
+  if (ownValue(tool, "inputSchema") !== void 0) return "mcp";
+  if (ownValue(tool, "parameters") !== void 0) return "gemini";
+  if (typeof ownValue(tool, "name") === "string") return "canonical";
+  fail("ERR_TOOL_FORMAT", "Unable to detect the tool definition format");
+}
+function sourceForFormat(tool, format) {
+  if (format === "openai-chat") {
+    const nested = ownValue(tool, "function");
+    if (!isObject(nested)) fail("ERR_TOOL_DEFINITION", "OpenAI Chat tool.function must be an object");
+    return nested;
+  }
+  return tool;
+}
+function schemaForFormat(source, format) {
+  if (format === "mcp" || format === "canonical") {
+    return ownValue(source, "inputSchema") === void 0 ? ownValue(source, "schema") : ownValue(source, "inputSchema");
+  }
+  if (format === "anthropic") return ownValue(source, "input_schema");
+  return ownValue(source, "parameters");
+}
+function outputSchemaForFormat(source, format) {
+  if (format === "mcp" || format === "canonical") return ownValue(source, "outputSchema");
+  return void 0;
+}
+function inferNamespace(name) {
+  for (const separator of ["__", ".", "/"]) {
+    const index = name.indexOf(separator);
+    if (index > 0) return name.slice(0, index);
+  }
+  return "";
+}
+function normalizeTool(tool, options = {}) {
+  if (!isObject(tool)) fail("ERR_TOOL_DEFINITION", "Tool definition must be an object");
+  if (!isObject(options)) fail("ERR_TOOL_ROUTER_OPTION", "Normalization options must be an object");
+  const format = explicitFormat(options.format) || detectToolFormat(tool);
+  const source = sourceForFormat(tool, format);
+  const name = stringValue(ownValue(source, "name"));
+  if (name.length === 0) fail("ERR_TOOL_NAME", "Tool name must be a non-empty string");
+  if (name.length > 512) fail("ERR_TOOL_NAME", "Tool name must not exceed 512 characters");
+  const description = stringValue(ownValue(source, "description"));
+  const explicitNamespace = stringValue(ownValue(tool, "namespace")) || stringValue(ownValue(source, "namespace"));
+  const namespace = explicitNamespace || inferNamespace(name);
+  const explicitId = stringValue(ownValue(tool, "id")) || stringValue(ownValue(source, "id"));
+  const id = explicitId || (namespace ? `${namespace}:${name}` : name);
+  const tags = stringList(ownValue(tool, "tags")).concat(stringList(ownValue(source, "tags")));
+  const aliases = stringList(ownValue(tool, "aliases")).concat(stringList(ownValue(source, "aliases")));
+  return Object.freeze({
+    aliases: Object.freeze(Array.from(new Set(aliases))),
+    description,
+    format,
+    id,
+    inputSchema: schemaForFormat(source, format),
+    name,
+    namespace,
+    original: tool,
+    outputSchema: outputSchemaForFormat(source, format),
+    tags: Object.freeze(Array.from(new Set(tags)))
+  });
+}
+function unwrapTools(input) {
+  if (Array.isArray(input)) return input;
+  if (!isObject(input)) fail("ERR_TOOL_CATALOG", "Tool catalog must be an array or provider envelope");
+  const tools = ownValue(input, "tools");
+  if (Array.isArray(tools)) return tools;
+  const declarations = ownValue(input, "functionDeclarations");
+  if (Array.isArray(declarations)) return declarations;
+  fail("ERR_TOOL_CATALOG", "Tool catalog envelope must contain tools or functionDeclarations");
+}
+function normalizeTools(input, options = {}) {
+  if (!isObject(options)) fail("ERR_TOOL_ROUTER_OPTION", "Normalization options must be an object");
+  const outer = unwrapTools(input);
+  const maxTools = positiveInteger(options.maxTools, 1e5, 1e6, "maxTools");
+  if (outer.length > maxTools) {
+    fail("ERR_TOOL_CATALOG_SIZE", `Tool catalog exceeds maxTools (${maxTools})`);
+  }
+  const flattened = [];
+  for (let index = 0; index < outer.length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(outer, String(index));
+    if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, "value")) continue;
+    const value = descriptor.value;
+    if (isObject(value) && Array.isArray(ownValue(value, "functionDeclarations"))) {
+      const declarations = ownValue(value, "functionDeclarations");
+      if (declarations.length > maxTools - flattened.length) {
+        fail("ERR_TOOL_CATALOG_SIZE", `Tool catalog exceeds maxTools (${maxTools})`);
+      }
+      for (let inner = 0; inner < declarations.length; inner++) {
+        const innerDescriptor = Object.getOwnPropertyDescriptor(declarations, String(inner));
+        if (innerDescriptor && Object.prototype.hasOwnProperty.call(innerDescriptor, "value")) {
+          flattened.push(normalizeTool(innerDescriptor.value, { format: "gemini" }));
+        }
+      }
+    } else {
+      flattened.push(normalizeTool(value, options));
+    }
+  }
+  return flattened;
+}
+
+// src/schema.js
+var TEXT_KEYS = /* @__PURE__ */ new Set(["title", "description", "$comment", "format", "pattern", "const"]);
+var COLLECTION_KEYS = /* @__PURE__ */ new Set(["enum", "examples", "required"]);
+function collectSchemaText(schema, options = {}) {
+  if (!isObject(schema) && typeof schema !== "boolean") return "";
+  const maxDepth = options.maxSchemaDepth === void 0 ? 24 : options.maxSchemaDepth;
+  const maxNodes = options.maxSchemaNodes === void 0 ? 1e4 : options.maxSchemaNodes;
+  const maxTextLength = options.maxTextLength === void 0 ? 65536 : options.maxTextLength;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const parts = [];
+  let nodes = 0;
+  let length = 0;
+  function consumeNode() {
+    nodes += 1;
+    if (nodes > maxNodes) fail("ERR_TOOL_SCHEMA_SIZE", `Tool schema exceeds maxSchemaNodes (${maxNodes})`);
+  }
+  function append(value) {
+    if (typeof value !== "string" && typeof value !== "number") return;
+    const text = String(value);
+    if (text.length === 0 || length >= maxTextLength) return;
+    const remaining = maxTextLength - length;
+    const piece = text.slice(0, remaining);
+    parts.push(piece);
+    length += piece.length + 1;
+  }
+  function visit(value, depth, parentKey) {
+    if (depth > maxDepth) fail("ERR_TOOL_SCHEMA_DEPTH", `Tool schema exceeds maxSchemaDepth (${maxDepth})`);
+    consumeNode();
+    if (!isObject(value)) return;
+    if (seen.has(value)) return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      if (value.length > maxNodes - nodes) {
+        fail("ERR_TOOL_SCHEMA_SIZE", `Tool schema exceeds maxSchemaNodes (${maxNodes})`);
+      }
+      for (let index = 0; index < value.length; index++) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, "value")) continue;
+        if (COLLECTION_KEYS.has(parentKey)) {
+          consumeNode();
+          append(descriptor.value);
+        } else visit(descriptor.value, depth + 1, parentKey);
+      }
+      return;
+    }
+    const entries = ownEnumerableEntries(value);
+    if (entries.length > maxNodes - nodes) {
+      fail("ERR_TOOL_SCHEMA_SIZE", `Tool schema exceeds maxSchemaNodes (${maxNodes})`);
+    }
+    for (const [key, child] of entries) {
+      if (parentKey === "properties" || parentKey === "$defs" || parentKey === "definitions") append(key);
+      if (TEXT_KEYS.has(key)) {
+        consumeNode();
+        append(child);
+      } else if (COLLECTION_KEYS.has(key) && Array.isArray(child)) visit(child, depth + 1, key);
+      else visit(child, depth + 1, key);
+    }
+  }
+  visit(schema, 0, "");
+  return parts.join(" ");
+}
+function estimateJsonTokens(value, options = {}) {
+  const maxDepth = options.maxDepth === void 0 ? 64 : options.maxDepth;
+  const maxNodes = options.maxNodes === void 0 ? 1e5 : options.maxNodes;
+  const seen = /* @__PURE__ */ new WeakSet();
+  let nodes = 0;
+  function stringLength(text) {
+    return JSON.stringify(text).length;
+  }
+  function measure(current, depth) {
+    if (depth > maxDepth) fail("ERR_TOOL_VALUE_DEPTH", `Tool definition exceeds maxDepth (${maxDepth})`);
+    nodes += 1;
+    if (nodes > maxNodes) fail("ERR_TOOL_VALUE_SIZE", `Tool definition exceeds maxNodes (${maxNodes})`);
+    if (current === null) return 4;
+    if (typeof current === "string") return stringLength(current);
+    if (typeof current === "number") return Number.isFinite(current) ? String(current).length : 4;
+    if (typeof current === "boolean") return current ? 4 : 5;
+    if (typeof current === "bigint") fail("ERR_TOOL_VALUE_TYPE", "Tool definition cannot contain bigint values");
+    if (typeof current === "undefined" || typeof current === "function" || typeof current === "symbol") return 0;
+    if (seen.has(current)) fail("ERR_TOOL_CYCLIC", "Tool definition must be JSON-serializable");
+    seen.add(current);
+    let length = 2;
+    let count = 0;
+    if (Array.isArray(current)) {
+      if (current.length > maxNodes - nodes) {
+        fail("ERR_TOOL_VALUE_SIZE", `Tool definition exceeds maxNodes (${maxNodes})`);
+      }
+      for (let index = 0; index < current.length; index++) {
+        const descriptor = Object.getOwnPropertyDescriptor(current, String(index));
+        const child = descriptor && Object.prototype.hasOwnProperty.call(descriptor, "value") ? descriptor.value : null;
+        length += measure(child, depth + 1) + (count > 0 ? 1 : 0);
+        count += 1;
+      }
+    } else {
+      const entries = ownEnumerableEntries(current);
+      if (entries.length > maxNodes - nodes) {
+        fail("ERR_TOOL_VALUE_SIZE", `Tool definition exceeds maxNodes (${maxNodes})`);
+      }
+      for (const [key, child] of entries) {
+        const measured = measure(child, depth + 1);
+        if (measured === 0 && (child === void 0 || typeof child === "function" || typeof child === "symbol")) continue;
+        length += stringLength(key) + 1 + measured + (count > 0 ? 1 : 0);
+        count += 1;
+      }
+    }
+    seen.delete(current);
+    return length;
+  }
+  return Math.max(1, Math.ceil(measure(value, 0) / 4));
+}
+
+// src/tokenize.js
+var COMBINING_MARKS = /[\u0300-\u036f]/g;
+var CAMEL_BOUNDARY = /([\p{Ll}\p{N}])([\p{Lu}])/gu;
+var ACRONYM_BOUNDARY = /([\p{Lu}]+)([\p{Lu}][\p{Ll}])/gu;
+var WORDS = /[\p{L}\p{N}]+/gu;
+var CJK = /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uac00-\ud7af]/u;
+function normalizeText(input) {
+  if (typeof input !== "string") return "";
+  let value = input;
+  if (typeof value.normalize === "function") value = value.normalize("NFKD");
+  return value.replace(COMBINING_MARKS, "").replace(ACRONYM_BOUNDARY, "$1 $2").replace(CAMEL_BOUNDARY, "$1 $2").toLocaleLowerCase("en-US");
+}
+function normalizeIdentifier(input) {
+  return normalizeText(input).replace(/[^\p{L}\p{N}]+/gu, "");
+}
+function tokenize(input, options = {}) {
+  const maxTokenLength = options.maxTokenLength === void 0 ? 64 : options.maxTokenLength;
+  if (!Number.isInteger(maxTokenLength) || maxTokenLength < 2 || maxTokenLength > 256) {
+    fail("ERR_TOOL_ROUTER_OPTION", "maxTokenLength must be an integer between 2 and 256");
+  }
+  const normalized = normalizeText(input);
+  const words = normalized.match(WORDS) || [];
+  const tokens = [];
+  for (const word of words) {
+    const token = word.slice(0, maxTokenLength);
+    if (token.length > 1 || CJK.test(token)) tokens.push(token);
+    if (token.length > 2 && CJK.test(token)) {
+      const characters = Array.from(token);
+      for (let index = 0; index < characters.length - 1; index++) {
+        tokens.push(`${characters[index]}${characters[index + 1]}`);
+      }
+    }
+  }
+  return tokens;
+}
+function tokenTrigrams(token) {
+  const characters = Array.from(`  ${token} `);
+  const result = [];
+  for (let index = 0; index <= characters.length - 3; index++) {
+    result.push(characters.slice(index, index + 3).join(""));
+  }
+  return result;
+}
+function boundedEditDistance(left, right, maximum) {
+  const a = Array.from(left);
+  const b = Array.from(right);
+  if (Math.abs(a.length - b.length) > maximum) return maximum + 1;
+  if (a.length === 0) return Math.min(b.length, maximum + 1);
+  if (b.length === 0) return Math.min(a.length, maximum + 1);
+  let previous = new Array(b.length + 1);
+  for (let index = 0; index <= b.length; index++) previous[index] = index;
+  for (let row = 1; row <= a.length; row++) {
+    const current = new Array(b.length + 1);
+    current[0] = row;
+    let rowMinimum = current[0];
+    for (let column = 1; column <= b.length; column++) {
+      const substitution = previous[column - 1] + (a[row - 1] === b[column - 1] ? 0 : 1);
+      const insertion = current[column - 1] + 1;
+      const deletion = previous[column] + 1;
+      current[column] = Math.min(substitution, insertion, deletion);
+      rowMinimum = Math.min(rowMinimum, current[column]);
+    }
+    if (rowMinimum > maximum) return maximum + 1;
+    previous = current;
+  }
+  return previous[b.length];
+}
+
+// src/router.js
+var FIELD_NAMES = Object.freeze(["name", "namespace", "aliases", "tags", "description", "schema"]);
+var DEFAULT_WEIGHTS = Object.freeze({
+  aliases: 7,
+  description: 2,
+  name: 10,
+  namespace: 8,
+  schema: 1,
+  tags: 5
+});
+var DEFAULT_SYNONYM_GROUPS = Object.freeze([
+  ["cancel", "close", "delete", "remove"],
+  ["create", "add", "make", "new", "open", "schedule"],
+  ["download", "fetch", "get", "read", "retrieve"],
+  ["find", "discover", "look", "lookup", "query", "search"],
+  ["list", "browse", "show"],
+  ["send", "deliver", "post", "publish"],
+  ["update", "change", "edit", "modify", "set"],
+  ["available", "availability", "free"],
+  ["conversation", "conversations", "message", "messages"],
+  ["document", "documents", "file", "files", "page", "pages"]
+]);
+function resolveWeights(input) {
+  const weights = /* @__PURE__ */ Object.create(null);
+  for (const field of FIELD_NAMES) {
+    const value = input && Object.prototype.hasOwnProperty.call(input, field) ? input[field] : DEFAULT_WEIGHTS[field];
+    weights[field] = finiteNumber(value, DEFAULT_WEIGHTS[field], 0, 100, `fieldWeights.${field}`);
+  }
+  return Object.freeze(weights);
+}
+function resolveSynonyms(input) {
+  if (input !== void 0 && input !== false && !isObject(input)) {
+    fail("ERR_TOOL_ROUTER_OPTION", "synonyms must be false or an object of string arrays");
+  }
+  const synonyms = /* @__PURE__ */ new Map();
+  function connect(words) {
+    const unique = Array.from(new Set(words.filter((word) => typeof word === "string" && word.length > 1)));
+    for (const word of unique) {
+      let related = synonyms.get(word);
+      if (!related) {
+        related = /* @__PURE__ */ new Set();
+        synonyms.set(word, related);
+      }
+      for (const candidate of unique) if (candidate !== word) related.add(candidate);
+    }
+  }
+  if (input !== false) for (const group of DEFAULT_SYNONYM_GROUPS) connect(group);
+  if (isObject(input)) {
+    for (const [word, values] of ownEnumerableEntries(input)) {
+      const normalizedWord = tokenize(word)[0];
+      if (!normalizedWord) continue;
+      if (typeof values !== "string" && !Array.isArray(values)) {
+        fail("ERR_TOOL_ROUTER_OPTION", `synonyms.${word} must be a string or array of strings`);
+      }
+      const normalizedValues = [];
+      for (const value of stringList(typeof values === "string" ? [values] : values)) {
+        normalizedValues.push(...tokenize(value));
+      }
+      connect([normalizedWord, ...normalizedValues]);
+    }
+  }
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const [word, related] of synonyms) result[word] = Object.freeze(Array.from(related));
+  return Object.freeze(result);
+}
+function resolveOptions(options = {}) {
+  if (options === null || typeof options !== "object") {
+    fail("ERR_TOOL_ROUTER_OPTION", "Router options must be an object");
+  }
+  const tokenizer = options.tokenizer === void 0 ? tokenize : options.tokenizer;
+  if (typeof tokenizer !== "function") fail("ERR_TOOL_ROUTER_OPTION", "tokenizer must be a function");
+  const onDuplicate = options.onDuplicate === void 0 ? "error" : options.onDuplicate;
+  if (onDuplicate !== "error" && onDuplicate !== "replace") {
+    fail("ERR_TOOL_ROUTER_OPTION", "onDuplicate must be error or replace");
+  }
+  return Object.freeze({
+    b: finiteNumber(options.b, 0.75, 0, 1, "b"),
+    fieldWeights: resolveWeights(options.fieldWeights),
+    format: options.format,
+    fuzzy: options.fuzzy === void 0 ? true : Boolean(options.fuzzy),
+    k1: finiteNumber(options.k1, 1.2, 0.1, 5, "k1"),
+    maxExpansions: positiveInteger(options.maxExpansions, 12, 100, "maxExpansions"),
+    maxQueryLength: positiveInteger(options.maxQueryLength, 4096, 65536, "maxQueryLength"),
+    maxSchemaDepth: positiveInteger(options.maxSchemaDepth, 24, 256, "maxSchemaDepth"),
+    maxSchemaNodes: positiveInteger(options.maxSchemaNodes, 1e4, 1e6, "maxSchemaNodes"),
+    maxTextLength: positiveInteger(options.maxTextLength, 65536, 1e6, "maxTextLength"),
+    maxTools: positiveInteger(options.maxTools, 1e5, 1e6, "maxTools"),
+    minFuzzyLength: positiveInteger(options.minFuzzyLength, 4, 32, "minFuzzyLength"),
+    onDuplicate,
+    synonyms: resolveSynonyms(options.synonyms),
+    tokenizer
+  });
+}
+function countTokens(tokens) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of tokens) counts.set(token, (counts.get(token) || 0) + 1);
+  return counts;
+}
+function nameSearchText(name) {
+  return `${name} ${normalizeIdentifier(name)}`;
+}
+function nameAcronyms(name) {
+  const words = tokenize(name).filter((word) => word.length > 0);
+  const acronyms = /* @__PURE__ */ new Set();
+  if (words.length > 1) {
+    acronyms.add(words.map((word) => Array.from(word)[0]).join(""));
+    for (let start = 0; start < words.length - 1; start++) {
+      for (let end = start + 2; end <= Math.min(words.length, start + 6); end++) {
+        acronyms.add(words.slice(start, end).map((word) => Array.from(word)[0]).join(""));
+      }
+    }
+  }
+  return acronyms;
+}
+function queryAcronyms(query) {
+  const acronyms = [];
+  const matches = query.match(/\b[A-Z][A-Z0-9]{1,7}\b/g) || [];
+  for (const match of matches) acronyms.push(`acr:${match.toLocaleLowerCase("en-US")}`);
+  return acronyms;
+}
+function toSet(value) {
+  if (value === void 0) return void 0;
+  const list = typeof value === "string" ? [value] : value;
+  if (!Array.isArray(list)) fail("ERR_TOOL_ROUTER_OPTION", "Search filters must be strings or arrays of strings");
+  return new Set(stringList(list, 1e4));
+}
+function compileFilters(options) {
+  const ids = toSet(options.ids);
+  const namespaces = toSet(options.namespaces);
+  const formats = toSet(options.formats);
+  const tags = toSet(options.tags);
+  const filter = options.filter;
+  if (filter !== void 0 && typeof filter !== "function") {
+    fail("ERR_TOOL_ROUTER_OPTION", "filter must be a function");
+  }
+  return (record) => {
+    if (ids && !ids.has(record.id)) return false;
+    if (namespaces && !namespaces.has(record.namespace)) return false;
+    if (formats && !formats.has(record.format)) return false;
+    if (tags) {
+      for (const tag of tags) if (!record.tags.includes(tag)) return false;
+    }
+    return filter === void 0 || Boolean(filter(record));
+  };
+}
+function publicMatch(document, score, matchedTerms, matchedFields, queryCoverage, pinned = false) {
+  return Object.freeze({
+    estimatedTokens: document.estimatedTokens,
+    id: document.record.id,
+    matchedFields: Object.freeze(Array.from(matchedFields).sort()),
+    matchedTerms: Object.freeze(Array.from(matchedTerms).sort()),
+    name: document.record.name,
+    pinned,
+    queryCoverage,
+    record: document.record,
+    score: score === null ? null : Number(score.toFixed(6)),
+    tool: document.record.original
+  });
+}
+var ToolRouter = class _ToolRouter {
+  constructor(tools = [], options = {}) {
+    this._options = resolveOptions(options);
+    this._documents = /* @__PURE__ */ new Map();
+    this._postings = /* @__PURE__ */ new Map();
+    this._prefixes = /* @__PURE__ */ new Map();
+    this._trigrams = /* @__PURE__ */ new Map();
+    this._fieldTotals = /* @__PURE__ */ Object.create(null);
+    for (const field of FIELD_NAMES) this._fieldTotals[field] = 0;
+    this._estimatedTokens = 0;
+    if (Array.isArray(tools) && tools.length === 0) return;
+    this.add(tools);
+  }
+  get size() {
+    return this._documents.size;
+  }
+  get options() {
+    return this._options;
+  }
+  add(tools, options = {}) {
+    const catalog = isObject(tools) && (Array.isArray(ownValue(tools, "tools")) || Array.isArray(ownValue(tools, "functionDeclarations"))) ? tools : Array.isArray(tools) ? tools : [tools];
+    const records = normalizeTools(catalog, {
+      format: options.format === void 0 ? this._options.format : options.format,
+      maxTools: this._options.maxTools
+    });
+    const prepared = records.map((record) => this._prepare(record));
+    const incoming = /* @__PURE__ */ new Set();
+    for (const document of prepared) {
+      if (incoming.has(document.record.id)) {
+        fail("ERR_TOOL_DUPLICATE", `Duplicate tool id in batch: ${document.record.id}`);
+      }
+      incoming.add(document.record.id);
+      if (this._documents.has(document.record.id) && this._options.onDuplicate === "error") {
+        fail("ERR_TOOL_DUPLICATE", `Tool id already exists: ${document.record.id}`);
+      }
+    }
+    let resultingSize = this._documents.size;
+    for (const id of incoming) if (!this._documents.has(id)) resultingSize += 1;
+    if (resultingSize > this._options.maxTools) {
+      fail("ERR_TOOL_CATALOG_SIZE", `Tool catalog exceeds maxTools (${this._options.maxTools})`);
+    }
+    for (const document of prepared) {
+      if (this._documents.has(document.record.id)) this._removeDocument(document.record.id);
+      this._addDocument(document);
+    }
+    return this;
+  }
+  remove(ids) {
+    const list = Array.isArray(ids) ? ids : [ids];
+    let removed = 0;
+    for (const id of list) {
+      if (typeof id !== "string") fail("ERR_TOOL_NAME", "Tool id must be a string");
+      const resolved = this._resolveDocument(id);
+      if (resolved && this._removeDocument(resolved.record.id)) removed += 1;
+    }
+    return removed;
+  }
+  replace(tools, options = {}) {
+    const fresh = new _ToolRouter([], this._options);
+    fresh.add(tools, options);
+    this._documents = fresh._documents;
+    this._postings = fresh._postings;
+    this._prefixes = fresh._prefixes;
+    this._trigrams = fresh._trigrams;
+    this._fieldTotals = fresh._fieldTotals;
+    this._estimatedTokens = fresh._estimatedTokens;
+    return this;
+  }
+  clear() {
+    this._documents.clear();
+    this._postings.clear();
+    this._prefixes.clear();
+    this._trigrams.clear();
+    for (const field of FIELD_NAMES) this._fieldTotals[field] = 0;
+    this._estimatedTokens = 0;
+    return this;
+  }
+  has(idOrName) {
+    return Boolean(this._resolveDocument(idOrName));
+  }
+  get(idOrName) {
+    const document = this._resolveDocument(idOrName);
+    return document ? document.record : void 0;
+  }
+  list() {
+    return Array.from(this._documents.values(), (document) => document.record);
+  }
+  stats() {
+    return Object.freeze({
+      estimatedTokens: this._estimatedTokens,
+      fields: Object.freeze({ ...this._fieldTotals }),
+      terms: this._postings.size,
+      tools: this.size
+    });
+  }
+  search(query, options = {}) {
+    if (typeof query !== "string") fail("ERR_TOOL_QUERY", "Search query must be a string");
+    if (query.length > this._options.maxQueryLength) {
+      fail("ERR_TOOL_QUERY_SIZE", `Search query exceeds maxQueryLength (${this._options.maxQueryLength})`);
+    }
+    const limit = positiveInteger(options.limit, 5, 1e3, "limit");
+    const minScore = finiteNumber(options.minScore, 0.01, 0, Number.MAX_SAFE_INTEGER, "minScore");
+    const queryTokens = this._tokenize(query).concat(queryAcronyms(query));
+    if (queryTokens.length === 0 || this.size === 0) return [];
+    const queryCounts = countTokens(queryTokens);
+    const candidates = /* @__PURE__ */ new Map();
+    const matches = compileFilters(options);
+    const filterCache = /* @__PURE__ */ new Map();
+    for (const [queryToken, queryFrequency] of queryCounts) {
+      const expansions = this._expand(queryToken);
+      const tokenCandidates = /* @__PURE__ */ new Map();
+      for (const [term, expansionWeight] of expansions) {
+        const posting = this._postings.get(term);
+        if (!posting) continue;
+        const documentFrequency = posting.size;
+        const inverseFrequency = Math.log(1 + (this.size - documentFrequency + 0.5) / (documentFrequency + 0.5));
+        for (const [id, frequencies] of posting) {
+          const document = this._documents.get(id);
+          if (!document) continue;
+          let allowed = filterCache.get(id);
+          if (allowed === void 0) {
+            allowed = matches(document.record);
+            filterCache.set(id, allowed);
+          }
+          if (!allowed) continue;
+          let weightedFrequency = 0;
+          const fields = [];
+          for (const field of FIELD_NAMES) {
+            const frequency = frequencies[field] || 0;
+            if (frequency === 0 || this._options.fieldWeights[field] === 0) continue;
+            const averageLength = this._fieldTotals[field] / Math.max(1, this.size);
+            const normalization = 1 - this._options.b + this._options.b * (document.fieldLengths[field] / averageLength);
+            weightedFrequency += this._options.fieldWeights[field] * frequency / normalization;
+            fields.push(field);
+          }
+          if (weightedFrequency === 0) continue;
+          const saturation = weightedFrequency * (this._options.k1 + 1) / (weightedFrequency + this._options.k1);
+          const contribution = inverseFrequency * saturation * expansionWeight * (1 + Math.log(queryFrequency));
+          let tokenState = tokenCandidates.get(id);
+          if (!tokenState) {
+            tokenState = { contribution: 0, fields: /* @__PURE__ */ new Set(), terms: /* @__PURE__ */ new Set() };
+            tokenCandidates.set(id, tokenState);
+          }
+          if (contribution > tokenState.contribution) {
+            tokenState.contribution = contribution;
+            tokenState.fields = new Set(fields);
+          } else if (contribution === tokenState.contribution) {
+            for (const field of fields) tokenState.fields.add(field);
+          }
+          tokenState.terms.add(term);
+        }
+      }
+      for (const [id, tokenState] of tokenCandidates) {
+        let state = candidates.get(id);
+        if (!state) {
+          state = {
+            fields: /* @__PURE__ */ new Set(),
+            queryTerms: /* @__PURE__ */ new Set(),
+            score: 0,
+            terms: /* @__PURE__ */ new Set()
+          };
+          candidates.set(id, state);
+        }
+        state.score += tokenState.contribution;
+        state.queryTerms.add(queryToken);
+        for (const term of tokenState.terms) state.terms.add(term);
+        for (const field of tokenState.fields) state.fields.add(field);
+      }
+    }
+    const normalizedQuery = normalizeIdentifier(query);
+    const ranked = [];
+    for (const [id, state] of candidates) {
+      const document = this._documents.get(id);
+      let score = state.score;
+      if (normalizedQuery && document.identifiers.has(normalizedQuery)) score += 12;
+      else if (normalizedQuery && document.identifiersText.includes(normalizedQuery)) score += 2;
+      for (const queryToken of queryCounts.keys()) {
+        if (document.nameTokens.has(queryToken)) score += 1.5;
+        if (document.namespaceTokens.has(queryToken)) score += 2;
+      }
+      const coverage = state.queryTerms.size / queryCounts.size;
+      score = score * (0.65 + 0.35 * coverage) + coverage;
+      if (score < minScore) continue;
+      ranked.push({ document, score, state, coverage });
+    }
+    ranked.sort((left, right) => right.score - left.score || left.document.record.name.localeCompare(right.document.record.name) || left.document.record.id.localeCompare(right.document.record.id));
+    const results = [];
+    let tokens = 0;
+    const tokenBudget = options.maxEstimatedTokens === void 0 ? Infinity : finiteNumber(options.maxEstimatedTokens, Infinity, 1, Number.MAX_SAFE_INTEGER, "maxEstimatedTokens");
+    for (const item of ranked) {
+      if (results.length >= limit) break;
+      if (tokens + item.document.estimatedTokens > tokenBudget) continue;
+      results.push(publicMatch(
+        item.document,
+        item.score,
+        item.state.terms,
+        item.state.fields,
+        Number(item.coverage.toFixed(6))
+      ));
+      tokens += item.document.estimatedTokens;
+    }
+    return results;
+  }
+  select(query, options = {}) {
+    return this.search(query, options).map((match) => match.tool);
+  }
+  route(query, options = {}) {
+    const maxTools = positiveInteger(options.maxTools, 5, 1e3, "maxTools");
+    const tokenBudget = options.maxEstimatedTokens === void 0 ? Infinity : finiteNumber(options.maxEstimatedTokens, Infinity, 1, Number.MAX_SAFE_INTEGER, "maxEstimatedTokens");
+    const selected = [];
+    const selectedIds = /* @__PURE__ */ new Set();
+    let estimatedTokens = 0;
+    let budgetExceeded = false;
+    const pinned = options.pinned === void 0 ? [] : typeof options.pinned === "string" ? [options.pinned] : options.pinned;
+    if (!Array.isArray(pinned)) fail("ERR_TOOL_ROUTER_OPTION", "pinned must be a string or array of strings");
+    for (const id of pinned) {
+      if (selected.length >= maxTools) break;
+      const document = this._resolveDocument(id);
+      if (!document || selectedIds.has(document.record.id)) continue;
+      selected.push(publicMatch(document, null, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), 0, true));
+      selectedIds.add(document.record.id);
+      estimatedTokens += document.estimatedTokens;
+      if (estimatedTokens > tokenBudget) budgetExceeded = true;
+    }
+    const candidates = this.search(query, {
+      ...options,
+      limit: Math.min(1e3, Math.max(maxTools, maxTools * 4)),
+      maxEstimatedTokens: void 0
+    });
+    for (const match of candidates) {
+      if (selected.length >= maxTools) break;
+      if (selectedIds.has(match.id)) continue;
+      if (estimatedTokens + match.estimatedTokens > tokenBudget) continue;
+      selected.push(match);
+      selectedIds.add(match.id);
+      estimatedTokens += match.estimatedTokens;
+    }
+    const fallback = options.fallback === void 0 ? "none" : options.fallback;
+    if (!["none", "first", "all"].includes(fallback)) {
+      fail("ERR_TOOL_ROUTER_OPTION", "fallback must be none, first, or all");
+    }
+    if (selected.length === 0 && fallback !== "none") {
+      const matches = compileFilters(options);
+      const documents = Array.from(this._documents.values()).filter((document) => matches(document.record)).sort((left, right) => left.record.id.localeCompare(right.record.id));
+      const fallbackLimit = fallback === "first" ? 1 : maxTools;
+      for (const document of documents) {
+        if (selected.length >= fallbackLimit) break;
+        if (estimatedTokens + document.estimatedTokens > tokenBudget) continue;
+        selected.push(publicMatch(document, null, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), 0));
+        selectedIds.add(document.record.id);
+        estimatedTokens += document.estimatedTokens;
+      }
+    }
+    const reduction = this._estimatedTokens === 0 ? 0 : Math.max(0, 1 - estimatedTokens / this._estimatedTokens);
+    return Object.freeze({
+      budgetExceeded,
+      catalogEstimatedTokens: this._estimatedTokens,
+      catalogSize: this.size,
+      estimatedTokens,
+      matches: Object.freeze(selected),
+      records: Object.freeze(selected.map((match) => match.record)),
+      selectedCount: selected.length,
+      tokenReduction: Number(reduction.toFixed(6)),
+      tools: Object.freeze(selected.map((match) => match.tool))
+    });
+  }
+  _prepare(record) {
+    const schemaText = collectSchemaText(record.inputSchema, this._options);
+    const fields = {
+      aliases: record.aliases.join(" "),
+      description: record.description,
+      name: nameSearchText(record.name),
+      namespace: record.namespace,
+      schema: schemaText,
+      tags: record.tags.join(" ")
+    };
+    const fieldTokens = /* @__PURE__ */ Object.create(null);
+    const fieldLengths = /* @__PURE__ */ Object.create(null);
+    const identifiers = /* @__PURE__ */ new Set([normalizeIdentifier(record.name)]);
+    for (const alias of record.aliases) identifiers.add(normalizeIdentifier(alias));
+    if (record.namespace) identifiers.add(normalizeIdentifier(`${record.namespace} ${record.name}`));
+    identifiers.delete("");
+    let textLength = 0;
+    for (const field of FIELD_NAMES) {
+      textLength += fields[field].length;
+      if (fields[field].length > this._options.maxTextLength || textLength > this._options.maxTextLength * 2) {
+        fail("ERR_TOOL_TEXT_SIZE", `Tool ${record.id} exceeds maxTextLength (${this._options.maxTextLength})`);
+      }
+      const tokens = this._tokenize(fields[field]);
+      fieldTokens[field] = countTokens(tokens);
+      fieldLengths[field] = tokens.length;
+    }
+    for (const acronym of nameAcronyms(record.name)) {
+      const term = `acr:${acronym}`;
+      fieldTokens.name.set(term, (fieldTokens.name.get(term) || 0) + 1);
+      fieldLengths.name += 1;
+    }
+    return {
+      estimatedTokens: estimateJsonTokens(record.original),
+      fieldLengths,
+      fieldTokens,
+      identifiers,
+      identifiersText: Array.from(identifiers).join(" "),
+      nameTokens: new Set(this._tokenize(record.name)),
+      namespaceTokens: new Set(this._tokenize(record.namespace)),
+      record
+    };
+  }
+  _tokenize(text) {
+    const result = this._options.tokenizer(text);
+    if (!Array.isArray(result)) fail("ERR_TOOL_TOKENIZER", "tokenizer must return an array of strings");
+    const tokens = [];
+    for (const token of result) {
+      if (typeof token !== "string") fail("ERR_TOOL_TOKENIZER", "tokenizer results must be strings");
+      if (token.length > 0 && token.length <= 256) tokens.push(token);
+    }
+    return tokens;
+  }
+  _addDocument(document) {
+    this._documents.set(document.record.id, document);
+    this._estimatedTokens += document.estimatedTokens;
+    for (const field of FIELD_NAMES) {
+      this._fieldTotals[field] += document.fieldLengths[field];
+      for (const [term, frequency] of document.fieldTokens[field]) {
+        let posting = this._postings.get(term);
+        const isNewTerm = !posting;
+        if (!posting) {
+          posting = /* @__PURE__ */ new Map();
+          this._postings.set(term, posting);
+        }
+        let frequencies = posting.get(document.record.id);
+        if (!frequencies) {
+          frequencies = /* @__PURE__ */ Object.create(null);
+          posting.set(document.record.id, frequencies);
+        }
+        frequencies[field] = frequency;
+        if (isNewTerm) this._addLexiconTerm(term);
+      }
+    }
+  }
+  _removeDocument(id) {
+    const document = this._documents.get(id);
+    if (!document) return false;
+    this._documents.delete(id);
+    this._estimatedTokens -= document.estimatedTokens;
+    for (const field of FIELD_NAMES) {
+      this._fieldTotals[field] -= document.fieldLengths[field];
+      for (const term of document.fieldTokens[field].keys()) {
+        const posting = this._postings.get(term);
+        if (!posting) continue;
+        posting.delete(id);
+        if (posting.size === 0) {
+          this._postings.delete(term);
+          this._removeLexiconTerm(term);
+        }
+      }
+    }
+    return true;
+  }
+  _addLexiconTerm(term) {
+    const maximum = Math.min(8, term.length);
+    for (let length = 2; length <= maximum; length++) {
+      const prefix = term.slice(0, length);
+      let terms = this._prefixes.get(prefix);
+      if (!terms) {
+        terms = /* @__PURE__ */ new Set();
+        this._prefixes.set(prefix, terms);
+      }
+      terms.add(term);
+    }
+    for (const trigram of new Set(tokenTrigrams(term))) {
+      let terms = this._trigrams.get(trigram);
+      if (!terms) {
+        terms = /* @__PURE__ */ new Set();
+        this._trigrams.set(trigram, terms);
+      }
+      terms.add(term);
+    }
+  }
+  _removeLexiconTerm(term) {
+    const maximum = Math.min(8, term.length);
+    for (let length = 2; length <= maximum; length++) {
+      const prefix = term.slice(0, length);
+      const terms = this._prefixes.get(prefix);
+      if (!terms) continue;
+      terms.delete(term);
+      if (terms.size === 0) this._prefixes.delete(prefix);
+    }
+    for (const trigram of new Set(tokenTrigrams(term))) {
+      const terms = this._trigrams.get(trigram);
+      if (!terms) continue;
+      terms.delete(term);
+      if (terms.size === 0) this._trigrams.delete(trigram);
+    }
+  }
+  _expand(queryToken) {
+    const expanded = /* @__PURE__ */ new Map();
+    this._addLiteralExpansions(expanded, queryToken, 1);
+    const synonyms = this._options.synonyms[queryToken];
+    if (synonyms) {
+      for (const synonym of synonyms) this._addLiteralExpansions(expanded, synonym, 0.72);
+    }
+    if (expanded.size > 0 || !this._options.fuzzy || queryToken.length < this._options.minFuzzyLength) {
+      return new Map(Array.from(expanded).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])).slice(0, this._options.maxExpansions));
+    }
+    const queryTrigrams = new Set(tokenTrigrams(queryToken));
+    const overlap = /* @__PURE__ */ new Map();
+    for (const trigram of queryTrigrams) {
+      const terms = this._trigrams.get(trigram);
+      if (!terms) continue;
+      for (const term of terms) overlap.set(term, (overlap.get(term) || 0) + 1);
+    }
+    const candidates = [];
+    const maximumDistance = queryToken.length <= 5 ? 1 : 2;
+    for (const [term, shared] of overlap) {
+      const termTrigrams = new Set(tokenTrigrams(term));
+      const similarity = shared / (queryTrigrams.size + termTrigrams.size - shared);
+      if (similarity < 0.25) continue;
+      const distance = boundedEditDistance(queryToken, term, maximumDistance);
+      if (distance > maximumDistance) continue;
+      const editSimilarity = 1 - distance / Math.max(queryToken.length, term.length);
+      candidates.push({ term, weight: 0.55 + 0.25 * editSimilarity, similarity });
+    }
+    candidates.sort((left, right) => right.similarity - left.similarity || right.weight - left.weight || left.term.localeCompare(right.term));
+    for (const candidate of candidates.slice(0, this._options.maxExpansions)) {
+      expanded.set(candidate.term, candidate.weight);
+    }
+    return expanded;
+  }
+  _addLiteralExpansions(expanded, token, weight) {
+    if (this._postings.has(token)) expanded.set(token, Math.max(weight, expanded.get(token) || 0));
+    if (token.length < 3) return;
+    const prefix = token.slice(0, Math.min(8, token.length));
+    const prefixTerms = this._prefixes.get(prefix);
+    if (!prefixTerms) return;
+    const ordered = Array.from(prefixTerms).filter((term) => term.startsWith(token) && term !== token).sort((left, right) => Math.abs(left.length - token.length) - Math.abs(right.length - token.length) || left.localeCompare(right));
+    for (const term of ordered.slice(0, this._options.maxExpansions)) {
+      expanded.set(term, Math.max(weight * 0.78, expanded.get(term) || 0));
+    }
+  }
+  _resolveDocument(idOrName) {
+    if (typeof idOrName !== "string") return void 0;
+    const exact = this._documents.get(idOrName);
+    if (exact) return exact;
+    let match;
+    for (const document of this._documents.values()) {
+      if (document.record.name !== idOrName) continue;
+      if (!match || document.record.id.localeCompare(match.record.id) < 0) match = document;
+    }
+    return match;
+  }
+};
+function createToolRouter(tools = [], options = {}) {
+  return new ToolRouter(tools, options);
+}
+function routeTools(tools, query, options = {}) {
+  const routerOptions = options.router || {};
+  const routeOptions = { ...options };
+  delete routeOptions.router;
+  return createToolRouter(tools, routerOptions).route(query, routeOptions);
+}
+function estimateToolTokens(tool) {
+  return estimateJsonTokens(tool);
+}
+function defineTool(tool) {
+  return normalizeTool(tool).original;
+}
+
+// src/search-tool.js
+var SEARCH_SCHEMA = Object.freeze({
+  additionalProperties: false,
+  properties: {
+    limit: {
+      description: "Maximum number of matching tool summaries to return.",
+      maximum: 25,
+      minimum: 1,
+      type: "integer"
+    },
+    query: {
+      description: "Capability, action, service, or resource needed for the task.",
+      minLength: 1,
+      type: "string"
+    }
+  },
+  required: ["query"],
+  type: "object"
+});
+function definitionFor(target, name, description) {
+  if (target === "openai-responses") {
+    return { type: "function", name, description, parameters: SEARCH_SCHEMA };
+  }
+  if (target === "openai-chat") {
+    return { type: "function", function: { name, description, parameters: SEARCH_SCHEMA } };
+  }
+  if (target === "anthropic") return { name, description, input_schema: SEARCH_SCHEMA };
+  if (target === "gemini") return { name, description, parameters: SEARCH_SCHEMA };
+  if (target === "mcp") return { name, description, inputSchema: SEARCH_SCHEMA };
+  if (target === "canonical") return { name, description, inputSchema: SEARCH_SCHEMA };
+  fail("ERR_TOOL_FORMAT", `Unsupported search tool target: ${String(target)}`);
+}
+function createToolSearch(router, options = {}) {
+  if (!router || typeof router.search !== "function") {
+    fail("ERR_TOOL_ROUTER", "createToolSearch requires a ToolRouter instance");
+  }
+  const target = options.target === void 0 ? "canonical" : options.target;
+  const name = options.name === void 0 ? "search_tools" : options.name;
+  const description = options.description === void 0 ? "Find the smallest set of available tools relevant to a capability or task." : options.description;
+  if (typeof name !== "string" || name.length === 0) fail("ERR_TOOL_NAME", "Search tool name must be a non-empty string");
+  if (typeof description !== "string") fail("ERR_TOOL_DEFINITION", "Search tool description must be a string");
+  const defaultLimit = options.limit === void 0 ? 5 : options.limit;
+  if (!Number.isInteger(defaultLimit) || defaultLimit < 1 || defaultLimit > 25) {
+    fail("ERR_TOOL_ROUTER_OPTION", "Search tool limit must be an integer between 1 and 25");
+  }
+  const definition = definitionFor(target, name, description);
+  return Object.freeze({
+    definition,
+    execute(input) {
+      if (!input || typeof input !== "object" || typeof input.query !== "string" || input.query.length === 0) {
+        fail("ERR_TOOL_QUERY", "Search tool input.query must be a non-empty string");
+      }
+      const limit = input.limit === void 0 ? defaultLimit : input.limit;
+      if (!Number.isInteger(limit) || limit < 1 || limit > 25) {
+        fail("ERR_TOOL_QUERY", "Search tool input.limit must be an integer between 1 and 25");
+      }
+      const matches = router.search(input.query, { limit });
+      return Object.freeze({
+        catalogSize: router.size,
+        query: input.query,
+        tools: Object.freeze(matches.map((match) => Object.freeze({
+          description: match.record.description,
+          id: match.id,
+          name: match.name,
+          namespace: match.record.namespace || void 0,
+          score: match.score,
+          tags: match.record.tags
+        })))
+      });
+    }
+  });
+}
+
+// src/index.js
+var index_default = Object.freeze({
+  TOOL_FORMATS,
+  ToolRouter,
+  ToolRouterError,
+  createToolRouter,
+  createToolSearch,
+  defineTool,
+  detectToolFormat,
+  estimateToolTokens,
+  normalizeIdentifier,
+  normalizeText,
+  normalizeTool,
+  normalizeTools,
+  routeTools,
+  tokenize
+});
+export {
+  TOOL_FORMATS,
+  ToolRouter,
+  ToolRouterError,
+  createToolRouter,
+  createToolSearch,
+  index_default as default,
+  defineTool,
+  detectToolFormat,
+  estimateToolTokens,
+  normalizeIdentifier,
+  normalizeText,
+  normalizeTool,
+  normalizeTools,
+  routeTools,
+  tokenize
+};
+//# sourceMappingURL=index.js.map