@mcp-ts/sdk 1.6.1 → 2.0.0

package/src/server/storage/types.ts

@@ -5,15 +5,15 @@ import type {
     OAuthClientInformationMixed,
 } from '@modelcontextprotocol/sdk/shared/auth.js';
 
-export interface SessionData {
+export interface Session {
     sessionId: string;
     serverId?: string; // Database server ID for mapping
     serverName?: string;
     serverUrl: string;
-    transportType: 'sse' | 'streamable_http';
+    transportType: 'sse' | 'streamable-http';
     callbackUrl: string;
     createdAt: number;
-    identity: string;
+    userId: string;
     headers?: Record<string, string>;
     /**
      * Session status marker used for TTL transitions:
@@ -36,15 +36,15 @@ export interface SetClientOptions {
     client?: MCPClient;
     serverUrl?: string;
     callbackUrl?: string;
-    transportType?: 'sse' | 'streamable_http';
-    identity?: string;
+    transportType?: 'sse' | 'streamable-http';
+    userId?: string;
     headers?: Record<string, string>;
 }
 
 /**
- * Interface for MCP Session Storage Backends
+ * Interface for MCP session stores.
  */
-export interface StorageBackend {
+export interface SessionStore {
     /**
      * Optional initialization (e.g., database connection)
      */
@@ -55,49 +55,46 @@ export interface StorageBackend {
      */
     generateSessionId(): string;
 
-    /**
-     * Stores or updates a session
-     */
     /**
      * Creates a new session. Throws if session already exists.
      * @param session - Session data to create
      * @param ttl - Optional TTL in seconds (defaults to backend's default)
      */
-    createSession(session: SessionData, ttl?: number): Promise<void>;
+    create(session: Session, ttl?: number): Promise<void>;
 
     /**
      * Updates an existing session with partial data. Throws if session does not exist.
-     * @param identity - User identity
+     * @param userId - User identifier
      * @param sessionId - Session identifier
      * @param data - Partial session data to update
      * @param ttl - Optional TTL in seconds (defaults to backend's default)
      */
-    updateSession(identity: string, sessionId: string, data: Partial<SessionData>, ttl?: number): Promise<void>;
+    update(userId: string, sessionId: string, data: Partial<Session>, ttl?: number): Promise<void>;
 
     /**
      * Retrieves a session
      */
-    getSession(identity: string, sessionId: string): Promise<SessionData | null>;
+    get(userId: string, sessionId: string): Promise<Session | null>;
 
     /**
-     * Gets full session data for all of an identity's sessions
+     * Gets full session data for all sessions owned by a user
      */
-    getIdentitySessionsData(identity: string): Promise<SessionData[]>;
+    list(userId: string): Promise<Session[]>;
 
     /**
      * Removes a session
      */
-    removeSession(identity: string, sessionId: string): Promise<void>;
+    delete(userId: string, sessionId: string): Promise<void>;
 
     /**
-     * Gets all sessions IDs of an identity
+     * Gets all session IDs owned by a user
      */
-    getIdentityMcpSessions(identity: string): Promise<string[]>;
+    listIds(userId: string): Promise<string[]>;
 
     /**
      * Gets all session IDs across all users (Admin)
      */
-    getAllSessionIds(): Promise<string[]>;
+    listAllIds(): Promise<string[]>;
 
     /**
      * Clears all sessions (Admin)
@@ -107,7 +104,7 @@ export interface StorageBackend {
     /**
      * Clean up expired sessions
      */
-    cleanupExpiredSessions(): Promise<void>;
+    cleanupExpired(): Promise<void>;
 
     /**
      * Disconnect from storage backend

package/src/shared/errors.ts

@@ -123,7 +123,7 @@ export class ToolExecutionError extends McpError {
  */
 export const 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',

package/src/shared/index.ts

@@ -52,7 +52,7 @@ export type {
   SessionListResult,
   ConnectResult,
   DisconnectResult,
-  RestoreSessionResult,
+  GetSessionResult,
   FinishAuthResult,
   ListToolsRpcResult,
   ListPromptsResult,
@@ -98,7 +98,6 @@ export {
 export {
   SchemaCompressor,
   type CompactTool,
-  type CompressionStats,
 } from './schema-compressor.js';
 
 export {

package/src/shared/meta-tools.ts

@@ -337,7 +337,7 @@ export async function executeMetaTool(
 
         if (found.length > 0) {
           lines.push(...found.map((t, i) =>
-            `${i + 1}. **${t.name}** (server: ${t.serverName}, serverId: ${t.serverId})\n   ${t.description}`
+            `${i + 1}. **${t.name}** (serverName: ${t.serverName}, serverId: ${t.serverId})\n   ${t.description}`
           ));
         }
         
@@ -380,7 +380,7 @@ export async function executeMetaTool(
         : servers
             .map(
               (server, i) =>
-                `${i + 1}. **${server.serverName}** (serverId: ${server.serverId}, sessionId: ${server.sessionId})\n` +
+                `${i + 1}. **${server.serverName}** (serverId: ${server.serverId})\n` +
                 `   Tool count: ${server.toolCount}`
             )
             .join('\n');
@@ -518,14 +518,12 @@ function formatToolSummaries(
     description: string;
     serverName: string;
     serverId: string;
-    estimatedTokens: number;
   }>
 ): string[] {
   return tools.map(
     (t, i) =>
-      `${i + 1}. **${t.name}** (server: ${t.serverName}, serverId: ${t.serverId})\n` +
-      `   ${t.description}\n` +
-      `   Estimated tokens: ${t.estimatedTokens}`
+      `${i + 1}. **${t.name}** (serverName: ${t.serverName}, serverId: ${t.serverId})\n` +
+      `   ${t.description}`
   );
 }
 

package/src/shared/schema-compressor.ts

@@ -1,14 +1,13 @@
 /**
- * SchemaCompressor — Utilities for reducing tool schema token overhead.
+ * SchemaCompressor — Utilities for compact tool representations.
  *
  * Provides compact representations of tools (name + description only,
- * no inputSchema) and token savings estimation.
+ * no inputSchema).
  *
  * @packageDocumentation
  */
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { ToolIndex } from './tool-index.js';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -28,17 +27,6 @@ export interface CompactTool {
   parameterHint?: string;
 }
 
-export interface CompressionStats {
-  /** Estimated tokens for the *full* tool list. */
-  fullTokens: number;
-  /** Estimated tokens for the *compact* tool list. */
-  compactTokens: number;
-  /** Absolute token savings. */
-  savedTokens: number;
-  /** Percentage savings as a human-readable string, e.g. "82.3%". */
-  savingsPercent: string;
-}
-
 // ---------------------------------------------------------------------------
 // SchemaCompressor
 // ---------------------------------------------------------------------------
@@ -93,32 +81,4 @@ export 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: Tool[]): CompressionStats {
-    let fullTokens = 0;
-    let compactTokens = 0;
-
-    for (const tool of tools) {
-      fullTokens += ToolIndex.estimateTokens(tool);
-
-      // Compact form: name + description + parameterHint
-      const compact = SchemaCompressor.toCompact(tool);
-      const text = [compact.name, compact.description ?? '', compact.parameterHint ?? ''].join(' ');
-      // Simple estimation for compact: ~4 chars per token for plain text
-      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}%`,
-    };
-  }
 }

package/src/shared/tool-index.ts

@@ -28,8 +28,6 @@ export interface ToolSummary {
   serverId: string;
   /** Session the tool belongs to */
   sessionId: string;
-  /** Estimated token cost of the full inputSchema */
-  estimatedTokens: number;
 }
 
 /** Server-level summary derived from indexed tools. */
@@ -106,41 +104,6 @@ export interface ToolIndexOptions {
   keywordWeight?: number;
 }
 
-// ---------------------------------------------------------------------------
-// Token Estimation
-// ---------------------------------------------------------------------------
-
-/**
- * Character-class weights for accurate-ish token estimation without a real
- * tokenizer.  Empirically calibrated against cl100k_base on typical JSON
- * Schema payloads.
- *
- * | Char class        | Approx chars per token |
- * |--------------------|------------------------|
- * | Whitespace / punct | 1–2                    |
- * | English words      | ~4                     |
- * | JSON keys/values   | ~3.5                   |
- *
- * We walk the string once and accumulate a weighted character count, then
- * divide by a calibrated divisor.
- */
-const CALIBRATION_DIVISOR = 3.6;
-
-function classifyChar(ch: string): number {
-  const code = ch.charCodeAt(0);
-  // whitespace / common JSON structural chars  →  high token density
-  if (code <= 0x20 || ch === '{' || ch === '}' || ch === '[' || ch === ']' || ch === ':' || ch === ',') return 1.0;
-  // digits and symbols
-  if (code >= 0x21 && code <= 0x2f) return 1.5;
-  if (code >= 0x30 && code <= 0x39) return 2.0;
-  // uppercase (often JSON keys)
-  if (code >= 0x41 && code <= 0x5a) return 3.5;
-  // lowercase (natural language in descriptions)
-  if (code >= 0x61 && code <= 0x7a) return 4.0;
-  // everything else (unicode, emojis, etc.)
-  return 2.5;
-}
-
 // ---------------------------------------------------------------------------
 // ToolIndex
 // ---------------------------------------------------------------------------
@@ -170,9 +133,6 @@ export class ToolIndex {
   /** BM25: average document length across the entire index. */
   private avgDocLength = 0;
 
-  /** Cached total estimated token cost across all indexed tools. */
-  private totalTokenCost = 0;
-
   private options: Required<ToolIndexOptions>;
 
   constructor(options: ToolIndexOptions = {}) {
@@ -199,7 +159,6 @@ export class ToolIndex {
     this.embeddings.clear();
     this.docLengths.clear();
     this.avgDocLength = 0;
-    this.totalTokenCost = 0;
 
     // 1. Populate tool map + search text
     const allTokenSets: Map<string, Set<string>> = new Map();
@@ -212,21 +171,19 @@ export 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,
       });
-      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 = new Map<string, number>();
       const uniqueTokens = new Set<string>();
 
@@ -578,60 +535,107 @@ export class ToolIndex {
     return count;
   }
 
-  /** Total estimated token cost of all indexed tool schemas. */
-  getTotalTokenCost(): number {
-    return this.totalTokenCost;
-  }
-
   // -----------------------------------------------------------------------
-  // Static Helpers
+  // Internals
   // -----------------------------------------------------------------------
 
-  /**
-   * 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: Tool): number {
+  /** Build a single searchable string from tool metadata. */
+  private buildSearchableText(tool: Tool): string {
     const parts: string[] = [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]);
+    if (tool.inputSchema && typeof tool.inputSchema === 'object') {
+      this.collectSchemaSearchText(tool.inputSchema, parts);
     }
 
-    return Math.ceil(weightedLen / (1 / CALIBRATION_DIVISOR));
+    return parts.join(' ');
   }
 
-  // -----------------------------------------------------------------------
-  // Internals
-  // -----------------------------------------------------------------------
+  /** Recursively collect JSON Schema argument names and descriptions. */
+  private collectSchemaSearchText(
+    schema: unknown,
+    parts: string[],
+    seen = new WeakSet<object>()
+  ): void {
+    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;
+    }
 
-  /** Build a single searchable string from tool metadata. */
-  private buildSearchableText(tool: Tool): string {
-    const parts: string[] = [tool.name];
-    if (tool.description) parts.push(tool.description);
+    const schemaObject = schema as Record<string, unknown>;
+    this.pushStringValue(schemaObject.description, parts);
+    this.pushStringValue(schemaObject.title, parts);
 
-    // Include property names and descriptions from schema
-    if (tool.inputSchema && typeof tool.inputSchema === 'object') {
-      const schema = tool.inputSchema as Record<string, unknown>;
-      const props = schema.properties as Record<string, { description?: string }> | undefined;
-      if (props) {
-        for (const [key, val] of Object.entries(props)) {
-          parts.push(key);
-          if (val && typeof val === 'object' && val.description) {
-            parts.push(val.description);
-          }
+    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(' ');
+  private pushStringValue(value: unknown, parts: string[]): void {
+    if (typeof value === 'string' && value.trim()) {
+      parts.push(value);
+    }
   }
 
   private getDocumentKey(tool: IndexedTool): string {
@@ -662,6 +666,7 @@ export class ToolIndex {
       .replace(/([a-z])([A-Z])/g, '$1 $2')
       // Split snake_case / kebab-case
       .replace(/[_-]/g, ' ')
+      .toLowerCase()
       // Remove non-alphanumeric (except spaces)
       .replace(/[^a-z0-9\s]/g, '')
       // Split on whitespace

package/src/shared/tool-router.ts

@@ -290,30 +290,6 @@ export class ToolRouter {
     return [...this.activeGroups];
   }
 
-  // -----------------------------------------------------------------------
-  // Stats & Introspection
-  // -----------------------------------------------------------------------
-
-  /** Total token cost of all tools if loaded without filtering. */
-  getTotalTokenCost(): number {
-    return this.index.getTotalTokenCost();
-  }
-
-  /** Estimate token cost of the currently filtered tool set. */
-  async getFilteredTokenCost(): Promise<number> {
-    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(): number {
     return this.allTools.length;

package/src/shared/types.ts

@@ -166,7 +166,7 @@ export type ToolInfo = {
 };
 
 // Transport type
-export type TransportType = 'sse' | 'streamable_http';
+export type TransportType = 'sse' | 'streamable-http';
 
 // SSE/RPC types
 export type McpRpcMethod =
@@ -174,8 +174,8 @@ export type McpRpcMethod =
   | 'disconnect'
   | 'listTools'
   | 'callTool'
-  | 'getSessions'
-  | 'restoreSession'
+  | 'listSessions'
+  | 'getSession'
   | 'finishAuth'
   | 'listPrompts'
   | 'getPrompt'
@@ -275,7 +275,7 @@ export interface DisconnectResult {
   success: boolean;
 }
 
-export interface RestoreSessionResult {
+export interface GetSessionResult {
   success: boolean;
   toolCount: number;
 }