@mcp-ts/sdk 1.6.2 → 2.0.0

package/dist/shared/index.mjs

@@ -154,7 +154,7 @@ var ToolExecutionError = class extends McpError {
 };
 var RpcErrorCodes = {
   EXECUTION_ERROR: "EXECUTION_ERROR",
-  MISSING_IDENTITY: "MISSING_IDENTITY",
+  MISSING_USER_ID: "MISSING_USER_ID",
   UNAUTHORIZED: "UNAUTHORIZED",
   NO_CONNECTION: "NO_CONNECTION",
   UNKNOWN_METHOD: "UNKNOWN_METHOD",
@@ -211,17 +211,7 @@ function findToolByName(connections, toolName) {
 }
 
 // src/shared/tool-index.ts
-var CALIBRATION_DIVISOR = 3.6;
-function classifyChar(ch) {
-  const code = ch.charCodeAt(0);
-  if (code <= 32 || ch === "{" || ch === "}" || ch === "[" || ch === "]" || ch === ":" || ch === ",") return 1;
-  if (code >= 33 && code <= 47) return 1.5;
-  if (code >= 48 && code <= 57) return 2;
-  if (code >= 65 && code <= 90) return 3.5;
-  if (code >= 97 && code <= 122) return 4;
-  return 2.5;
-}
-var ToolIndex = class _ToolIndex {
+var ToolIndex = class {
   constructor(options = {}) {
     /** All indexed tools keyed by name (supports duplicates). */
     __publicField(this, "tools", /* @__PURE__ */ new Map());
@@ -239,8 +229,6 @@ var ToolIndex = class _ToolIndex {
     __publicField(this, "docLengths", /* @__PURE__ */ new Map());
     /** BM25: average document length across the entire index. */
     __publicField(this, "avgDocLength", 0);
-    /** Cached total estimated token cost across all indexed tools. */
-    __publicField(this, "totalTokenCost", 0);
     __publicField(this, "options");
     this.options = {
       embedFn: options.embedFn ?? void 0,
@@ -263,7 +251,6 @@ var ToolIndex = class _ToolIndex {
     this.embeddings.clear();
     this.docLengths.clear();
     this.avgDocLength = 0;
-    this.totalTokenCost = 0;
     const allTokenSets = /* @__PURE__ */ new Map();
     let totalLength = 0;
     for (const tool of tools) {
@@ -272,19 +259,17 @@ var ToolIndex = class _ToolIndex {
         this.tools.set(tool.name, []);
       }
       this.tools.get(tool.name).push(tool);
-      const estimatedTokens = _ToolIndex.estimateTokens(tool);
       this.toolSummaries.set(docKey, {
         name: tool.name,
         description: tool.description ?? "",
         serverName: tool.serverName,
         serverId: tool.serverId,
-        sessionId: tool.sessionId,
-        estimatedTokens
+        sessionId: tool.sessionId
       });
-      this.totalTokenCost += estimatedTokens;
-      const text = this.buildSearchableText(tool).toLowerCase();
+      const rawText = this.buildSearchableText(tool);
+      const text = rawText.toLowerCase();
       this.searchTexts.set(docKey, text);
-      const tokens = this.tokenize(text);
+      const tokens = this.tokenize(rawText);
       const tf = /* @__PURE__ */ new Map();
       const uniqueTokens = /* @__PURE__ */ new Set();
       for (const tok of tokens) {
@@ -548,30 +533,6 @@ var ToolIndex = class _ToolIndex {
     }
     return count;
   }
-  /** Total estimated token cost of all indexed tool schemas. */
-  getTotalTokenCost() {
-    return this.totalTokenCost;
-  }
-  // -----------------------------------------------------------------------
-  // Static Helpers
-  // -----------------------------------------------------------------------
-  /**
-   * Estimate token count of a tool's full schema (name + description + inputSchema).
-   *
-   * Uses character-class weighted counting calibrated against cl100k_base.
-   * Accuracy is typically within ±10% for JSON Schema payloads.
-   */
-  static estimateTokens(tool) {
-    const parts = [tool.name];
-    if (tool.description) parts.push(tool.description);
-    if (tool.inputSchema) parts.push(JSON.stringify(tool.inputSchema));
-    const text = parts.join(" ");
-    let weightedLen = 0;
-    for (let i = 0; i < text.length; i++) {
-      weightedLen += 1 / classifyChar(text[i]);
-    }
-    return Math.ceil(weightedLen / (1 / CALIBRATION_DIVISOR));
-  }
   // -----------------------------------------------------------------------
   // Internals
   // -----------------------------------------------------------------------
@@ -580,18 +541,74 @@ var ToolIndex = class _ToolIndex {
     const parts = [tool.name];
     if (tool.description) parts.push(tool.description);
     if (tool.inputSchema && typeof tool.inputSchema === "object") {
-      const schema = tool.inputSchema;
-      const props = schema.properties;
-      if (props) {
-        for (const [key, val] of Object.entries(props)) {
-          parts.push(key);
-          if (val && typeof val === "object" && val.description) {
-            parts.push(val.description);
-          }
+      this.collectSchemaSearchText(tool.inputSchema, parts);
+    }
+    return parts.join(" ");
+  }
+  /** Recursively collect JSON Schema argument names and descriptions. */
+  collectSchemaSearchText(schema, parts, seen = /* @__PURE__ */ new WeakSet()) {
+    if (!schema || typeof schema !== "object") return;
+    if (seen.has(schema)) return;
+    seen.add(schema);
+    if (Array.isArray(schema)) {
+      for (const item of schema) {
+        this.collectSchemaSearchText(item, parts, seen);
+      }
+      return;
+    }
+    const schemaObject = schema;
+    this.pushStringValue(schemaObject.description, parts);
+    this.pushStringValue(schemaObject.title, parts);
+    const properties = schemaObject.properties;
+    if (properties && typeof properties === "object" && !Array.isArray(properties)) {
+      for (const [propertyName, propertySchema] of Object.entries(properties)) {
+        parts.push(propertyName);
+        this.collectSchemaSearchText(propertySchema, parts, seen);
+      }
+    }
+    const patternProperties = schemaObject.patternProperties;
+    if (patternProperties && typeof patternProperties === "object" && !Array.isArray(patternProperties)) {
+      for (const [propertyPattern, propertySchema] of Object.entries(patternProperties)) {
+        parts.push(propertyPattern);
+        this.collectSchemaSearchText(propertySchema, parts, seen);
+      }
+    }
+    const dependentSchemas = schemaObject.dependentSchemas;
+    if (dependentSchemas && typeof dependentSchemas === "object" && !Array.isArray(dependentSchemas)) {
+      for (const [propertyName, dependentSchema] of Object.entries(dependentSchemas)) {
+        parts.push(propertyName);
+        this.collectSchemaSearchText(dependentSchema, parts, seen);
+      }
+    }
+    for (const key of [
+      "items",
+      "additionalProperties",
+      "contains",
+      "propertyNames",
+      "if",
+      "then",
+      "else",
+      "not"
+    ]) {
+      this.collectSchemaSearchText(schemaObject[key], parts, seen);
+    }
+    for (const key of ["allOf", "anyOf", "oneOf", "prefixItems"]) {
+      this.collectSchemaSearchText(schemaObject[key], parts, seen);
+    }
+    for (const key of ["$defs", "definitions"]) {
+      const definitions = schemaObject[key];
+      if (definitions && typeof definitions === "object" && !Array.isArray(definitions)) {
+        for (const [definitionName, definitionSchema] of Object.entries(definitions)) {
+          parts.push(definitionName);
+          this.collectSchemaSearchText(definitionSchema, parts, seen);
         }
       }
     }
-    return parts.join(" ");
+  }
+  pushStringValue(value, parts) {
+    if (typeof value === "string" && value.trim()) {
+      parts.push(value);
+    }
   }
   getDocumentKey(tool) {
     return `${tool.sessionId}::${tool.serverId}::${tool.name}`;
@@ -612,7 +629,7 @@ var ToolIndex = class _ToolIndex {
   }
   /** Simple whitespace + camelCase + snake_case tokenizer. */
   tokenize(text) {
-    return text.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((t) => t.length > 1);
+    return text.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((t) => t.length > 1);
   }
   /** Cosine similarity between two vectors. */
   cosineSimilarity(a, b) {
@@ -667,27 +684,6 @@ var SchemaCompressor = class _SchemaCompressor {
     const limited = options?.maxTools ? tools.slice(0, options.maxTools) : tools;
     return limited.map((t) => _SchemaCompressor.toCompact(t));
   }
-  /**
-   * Estimate token savings from using compact vs full tool schemas.
-   */
-  static estimateSavings(tools) {
-    let fullTokens = 0;
-    let compactTokens = 0;
-    for (const tool of tools) {
-      fullTokens += ToolIndex.estimateTokens(tool);
-      const compact = _SchemaCompressor.toCompact(tool);
-      const text = [compact.name, compact.description ?? "", compact.parameterHint ?? ""].join(" ");
-      compactTokens += Math.ceil(text.length / 4);
-    }
-    const saved = fullTokens - compactTokens;
-    const pct = fullTokens > 0 ? (saved / fullTokens * 100).toFixed(1) : "0.0";
-    return {
-      fullTokens,
-      compactTokens,
-      savedTokens: saved,
-      savingsPercent: `${pct}%`
-    };
-  }
 };
 
 // src/shared/meta-tools.ts
@@ -883,7 +879,7 @@ async function executeMetaTool(toolName, args, router, callToolFn) {
         const lines = [];
         if (found.length > 0) {
           lines.push(...found.map(
-            (t, i) => `${i + 1}. **${t.name}** (server: ${t.serverName}, serverId: ${t.serverId})
+            (t, i) => `${i + 1}. **${t.name}** (serverName: ${t.serverName}, serverId: ${t.serverId})
    ${t.description}`
           ));
         }
@@ -911,7 +907,7 @@ async function executeMetaTool(toolName, args, router, callToolFn) {
         serverName: query || void 0
       });
       const text = servers.length === 0 ? "No connected servers found." : servers.map(
-        (server, i) => `${i + 1}. **${server.serverName}** (serverId: ${server.serverId}, sessionId: ${server.sessionId})
+        (server, i) => `${i + 1}. **${server.serverName}** (serverId: ${server.serverId})
    Tool count: ${server.toolCount}`
       ).join("\n");
       return {
@@ -1018,9 +1014,8 @@ async function executeMetaTool(toolName, args, router, callToolFn) {
 }
 function formatToolSummaries(tools) {
   return tools.map(
-    (t, i) => `${i + 1}. **${t.name}** (server: ${t.serverName}, serverId: ${t.serverId})
-   ${t.description}
-   Estimated tokens: ${t.estimatedTokens}`
+    (t, i) => `${i + 1}. **${t.name}** (serverName: ${t.serverName}, serverId: ${t.serverId})
+   ${t.description}`
   );
 }
 function isMetaTool(toolName) {
@@ -1163,26 +1158,6 @@ var ToolRouter = class {
   getActiveGroups() {
     return [...this.activeGroups];
   }
-  // -----------------------------------------------------------------------
-  // Stats & Introspection
-  // -----------------------------------------------------------------------
-  /** Total token cost of all tools if loaded without filtering. */
-  getTotalTokenCost() {
-    return this.index.getTotalTokenCost();
-  }
-  /** Estimate token cost of the currently filtered tool set. */
-  async getFilteredTokenCost() {
-    const tools = await this.getFilteredTools();
-    let total = 0;
-    for (const tool of tools) {
-      total += ToolIndex.estimateTokens(tool);
-    }
-    return total;
-  }
-  /** Get compression stats showing savings from current strategy. */
-  getCompressionStats() {
-    return SchemaCompressor.estimateSavings(this.allTools);
-  }
   /** Number of total indexed tools. */
   get totalToolCount() {
     return this.allTools.length;