@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/mcp-server/toolCardinality.js

@@ -0,0 +1,78 @@
+import { estimateCompressionTokens } from "../services/compression/stats.ts";
+function scopeMatches(grantedScope, requiredScope) {
+  if (grantedScope === "*" || grantedScope === requiredScope) {
+    return true;
+  }
+  if (grantedScope.endsWith("*")) {
+    const prefix = grantedScope.slice(0, -1);
+    return requiredScope.startsWith(prefix);
+  }
+  return false;
+}
+function scopeIntersects(toolScopes, allowScopes) {
+  for (const ts of toolScopes) {
+    for (const as of allowScopes) {
+      if (scopeMatches(as, ts)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function filterEntries(entries, profile) {
+  const allowScopes = profile.allowScopes ?? [];
+  const allowTools = profile.allowTools ?? [];
+  const denyTools = profile.denyTools ?? [];
+  const denySet = new Set(denyTools);
+  const allowToolSet = new Set(allowTools);
+  const hasFilter = allowScopes.length > 0 || allowTools.length > 0;
+  const filtered = entries.filter((entry) => {
+    if (denySet.has(entry.name)) return false;
+    if (!hasFilter) return true;
+    if (allowToolSet.has(entry.name)) return true;
+    if (allowScopes.length > 0 && (entry.scopes?.length ?? 0) > 0) {
+      return scopeIntersects(entry.scopes, allowScopes);
+    }
+    return false;
+  });
+  const max = profile.maxTools;
+  if (max === void 0 || max < 0 || filtered.length <= max) {
+    return filtered;
+  }
+  const prioritised = filtered.filter((e) => allowToolSet.has(e.name)).sort((a, b) => a.name.localeCompare(b.name));
+  const rest = filtered.filter((e) => !allowToolSet.has(e.name)).sort((a, b) => a.name.localeCompare(b.name));
+  return [...prioritised, ...rest].slice(0, max);
+}
+function reduceToolManifest(manifest, profile) {
+  if (Array.isArray(manifest)) {
+    return filterEntries(manifest, profile);
+  }
+  const entries = Object.values(manifest);
+  const filtered = filterEntries(entries, profile);
+  return Object.fromEntries(filtered.map((e) => [e.name, e]));
+}
+function estimateManifestTokens(manifest) {
+  const entries = Array.isArray(manifest) ? manifest : Object.values(manifest);
+  if (entries.length === 0) return 0;
+  return entries.reduce((sum, entry) => {
+    const nameTokens = estimateCompressionTokens(entry.name);
+    const descTokens = estimateCompressionTokens(entry.description ?? "");
+    return sum + nameTokens + descTokens;
+  }, 0);
+}
+function readMcpToolProfileFromEnv(env) {
+  const parse = (value) => value ? value.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  const denyTools = parse(env["MCP_TOOL_DENY"]);
+  const allowTools = parse(env["MCP_TOOL_ALLOW"]);
+  if (denyTools.length === 0 && allowTools.length === 0) return null;
+  return {
+    name: "env",
+    ...denyTools.length > 0 ? { denyTools } : {},
+    ...allowTools.length > 0 ? { allowTools } : {}
+  };
+}
+export {
+  estimateManifestTokens,
+  readMcpToolProfileFromEnv,
+  reduceToolManifest
+};

package/open-sse/mcp-server/toolSearch/catalog.js

@@ -0,0 +1,66 @@
+import { MCP_TOOLS } from "../schemas/tools.ts";
+import { memoryTools } from "../tools/memoryTools.ts";
+import { skillTools } from "../tools/skillTools.ts";
+import { agentSkillTools } from "../tools/agentSkillTools.ts";
+import { poolTools } from "../tools/poolTools.ts";
+import { gamificationTools } from "../tools/gamificationTools.ts";
+import { pluginTools } from "../tools/pluginTools.ts";
+import { notionTools } from "../tools/notionTools.ts";
+import { obsidianTools } from "../tools/obsidianTools.ts";
+import { compressionTools } from "../tools/compressionTools.ts";
+function normalizeEntry(raw) {
+  const name = typeof raw.name === "string" ? raw.name : null;
+  const description = typeof raw.description === "string" ? raw.description : "";
+  if (!name) return null;
+  const scopes = Array.isArray(raw.scopes) ? raw.scopes.filter((s) => typeof s === "string") : [];
+  return { name, description, scopes, inputSchema: raw.inputSchema };
+}
+function collectFromArray(arr) {
+  const result = [];
+  for (const item of arr) {
+    const entry = normalizeEntry(item);
+    if (entry) result.push(entry);
+  }
+  return result;
+}
+function collectFromRecord(rec) {
+  return collectFromArray(Object.values(rec));
+}
+function collectAny(collection) {
+  if (Array.isArray(collection)) return collectFromArray(collection);
+  if (collection && typeof collection === "object") {
+    return collectFromRecord(collection);
+  }
+  return [];
+}
+function getAllToolDefinitions() {
+  const collections = [
+    MCP_TOOLS,
+    memoryTools,
+    skillTools,
+    agentSkillTools,
+    poolTools,
+    gamificationTools,
+    pluginTools,
+    notionTools,
+    obsidianTools,
+    // compressionTools holds omniroute_ccr_retrieve, which is NOT in MCP_TOOLS — without it
+    // a `tool_search("compression")` would miss that tool. The other 5 overlap MCP_TOOLS and
+    // are resolved by the dedup-by-name below (first wins).
+    compressionTools
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const collection of collections) {
+    for (const entry of collectAny(collection)) {
+      if (!seen.has(entry.name)) {
+        seen.add(entry.name);
+        result.push(entry);
+      }
+    }
+  }
+  return result;
+}
+export {
+  getAllToolDefinitions
+};

package/open-sse/mcp-server/toolSearch/handler.js

@@ -0,0 +1,20 @@
+import { getAllToolDefinitions } from "./catalog.ts";
+import { searchTools } from "./search.ts";
+import { zodToTsSignature } from "./signature.ts";
+function handleToolSearch(args) {
+  const entries = getAllToolDefinitions().filter((t) => t.name !== "omniroute_tool_search");
+  const hits = searchTools(entries, args.query, args.limit ?? 8);
+  return {
+    query: args.query,
+    count: hits.length,
+    tools: hits.map((h) => ({
+      name: h.name,
+      description: h.description,
+      scopes: [...h.scopes],
+      signature: zodToTsSignature(h.name, h.inputSchema)
+    }))
+  };
+}
+export {
+  handleToolSearch
+};

package/open-sse/mcp-server/toolSearch/index.js

@@ -0,0 +1,10 @@
+import { zodToTsSignature } from "./signature.ts";
+import { searchTools } from "./search.ts";
+import { getAllToolDefinitions } from "./catalog.ts";
+import { handleToolSearch } from "./handler.ts";
+export {
+  getAllToolDefinitions,
+  handleToolSearch,
+  searchTools,
+  zodToTsSignature
+};

package/open-sse/mcp-server/toolSearch/register.js

@@ -0,0 +1,21 @@
+import { toolSearchInput } from "../schemas/toolSearch.ts";
+import { handleToolSearch } from "./handler.ts";
+function registerToolSearchTool(server, withScopeEnforcement) {
+  server.registerTool(
+    "omniroute_tool_search",
+    {
+      description: "Search MCP tools by keyword; returns compact one-line TS signatures for token-efficient discovery.",
+      inputSchema: toolSearchInput
+    },
+    withScopeEnforcement("omniroute_tool_search", (args) => {
+      const parsed = toolSearchInput.parse(args ?? {});
+      const result = handleToolSearch(parsed);
+      return Promise.resolve({
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      });
+    })
+  );
+}
+export {
+  registerToolSearchTool
+};

package/open-sse/mcp-server/toolSearch/search.js

@@ -0,0 +1,55 @@
+const NAME_PHRASE_BONUS = 25;
+const NAME_TOKEN_BONUS = 6;
+const DESC_PHRASE_BONUS = 20;
+const DESC_TOKEN_BONUS = 3;
+const MIN_LIMIT = 1;
+const MAX_LIMIT = 25;
+function countOccurrences(haystack, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
+function scoreEntry(entry, normalizedQuery, tokens) {
+  const nameLower = entry.name.toLowerCase();
+  const descLower = entry.description.toLowerCase();
+  let score = 0;
+  if (nameLower.includes(normalizedQuery)) {
+    score += NAME_PHRASE_BONUS;
+  }
+  for (const token of tokens) {
+    score += countOccurrences(nameLower, token) * NAME_TOKEN_BONUS;
+  }
+  if (descLower.includes(normalizedQuery)) {
+    score += DESC_PHRASE_BONUS;
+  }
+  for (const token of tokens) {
+    score += countOccurrences(descLower, token) * DESC_TOKEN_BONUS;
+  }
+  return score;
+}
+function searchTools(entries, query, limit = 8) {
+  const clampedLimit = Math.max(MIN_LIMIT, Math.min(MAX_LIMIT, limit));
+  const normalizedQuery = query.trim().toLowerCase();
+  if (!normalizedQuery) return [];
+  const tokens = normalizedQuery.split(/\s+/).filter(Boolean);
+  const scored = [];
+  for (const entry of entries) {
+    const score = scoreEntry(entry, normalizedQuery, tokens);
+    if (score > 0) {
+      scored.push({ ...entry, score });
+    }
+  }
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+  });
+  return scored.slice(0, clampedLimit);
+}
+export {
+  searchTools
+};

package/open-sse/mcp-server/toolSearch/signature.js

@@ -0,0 +1,67 @@
+function unwrap(field) {
+  const t = field.type ?? field._def?.type;
+  if (t === "optional" || t === "default" || t === "nullable") {
+    const inner = field._def?.innerType;
+    if (inner && typeof inner === "object") return unwrap(inner);
+  }
+  return field;
+}
+function isOptional(field) {
+  const t = field.type ?? field._def?.type;
+  return t === "optional";
+}
+function zodTypeToTs(field, depth = 0) {
+  const core = unwrap(field);
+  const t = core.type ?? core._def?.type;
+  if (t === "string") return "string";
+  if (t === "number") return "number";
+  if (t === "boolean") return "boolean";
+  if (t === "enum") {
+    const entries = core._def?.entries;
+    if (entries && typeof entries === "object") {
+      const vals = Object.keys(entries);
+      return vals.map((v) => `'${v}'`).join(" | ");
+    }
+    return "string";
+  }
+  if (t === "array") {
+    const element = core._def?.element;
+    if (element && typeof element === "object") {
+      return `${zodTypeToTs(element, depth)}[]`;
+    }
+    return "unknown[]";
+  }
+  if (t === "object" && depth < 2) {
+    const shape = core.shape ?? core._def?.shape;
+    if (shape && typeof shape === "object") {
+      const fields = Object.entries(shape).map(([k, v]) => {
+        const opt = isOptional(v) ? "?" : "";
+        return `${k}${opt}: ${zodTypeToTs(v, depth + 1)}`;
+      }).join("; ");
+      return `{ ${fields} }`;
+    }
+  }
+  return "unknown";
+}
+function zodToTsSignature(name, inputSchema) {
+  if (!inputSchema) return `${name}()`;
+  try {
+    const schema = inputSchema;
+    const t = schema.type ?? schema._def?.type;
+    if (t !== "object") return `${name}()`;
+    const shape = schema.shape ?? schema._def?.shape;
+    if (!shape || typeof shape !== "object" || Object.keys(shape).length === 0) {
+      return `${name}()`;
+    }
+    const fields = Object.entries(shape).map(([k, v]) => {
+      const opt = isOptional(v) ? "?" : "";
+      return `${k}${opt}: ${zodTypeToTs(v)}`;
+    }).join("; ");
+    return `${name}(args: { ${fields} })`;
+  } catch {
+    return `${name}(args: object)`;
+  }
+}
+export {
+  zodToTsSignature
+};