@mcp-ts/sdk 1.6.2 → 2.0.0

package/src/server/storage/sqlite-backend.ts

@@ -1,5 +1,5 @@
 import type { Database } from 'better-sqlite3';
-import { StorageBackend, SessionData } from './types.js'; // Ensure .js extension
+import type { SessionStore, Session } from './types.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { generateSessionId } from '../../shared/utils.js';
@@ -9,7 +9,7 @@ export interface SqliteStorageOptions {
     table?: string;
 }
 
-export class SqliteStorage implements StorageBackend {
+export class SqliteStorage implements SessionStore {
     private db: Database | null = null;
     private table: string;
     private initialized = false;
@@ -37,11 +37,11 @@ export class SqliteStorage implements StorageBackend {
             this.db.exec(`
                 CREATE TABLE IF NOT EXISTS ${this.table} (
                     sessionId TEXT PRIMARY KEY,
-                    identity TEXT NOT NULL,
+                    userId TEXT NOT NULL,
                     data TEXT NOT NULL,
                     expiresAt INTEGER
                 );
-                CREATE INDEX IF NOT EXISTS idx_${this.table}_identity ON ${this.table}(identity);
+                CREATE INDEX IF NOT EXISTS idx_${this.table}_userId ON ${this.table}(userId);
             `);
 
             this.initialized = true;
@@ -66,21 +66,21 @@ export class SqliteStorage implements StorageBackend {
         return generateSessionId();
     }
 
-    async createSession(session: SessionData, ttl?: number): Promise<void> {
+    async create(session: Session, ttl?: number): Promise<void> {
         this.ensureInitialized();
-        const { sessionId, identity } = session;
+        const { sessionId, userId } = session;
 
-        if (!sessionId || !identity) {
-            throw new Error('identity and sessionId required');
+        if (!sessionId || !userId) {
+            throw new Error('userId and sessionId required');
         }
 
         const expiresAt = ttl ? Date.now() + ttl * 1000 : null;
 
         try {
             const stmt = this.db!.prepare(
-                `INSERT INTO ${this.table} (sessionId, identity, data, expiresAt) VALUES (?, ?, ?, ?)`
+                `INSERT INTO ${this.table} (sessionId, userId, data, expiresAt) VALUES (?, ?, ?, ?)`
             );
-            stmt.run(sessionId, identity, JSON.stringify(session), expiresAt);
+            stmt.run(sessionId, userId, JSON.stringify(session), expiresAt);
         } catch (error: any) {
             if (error.code === 'SQLITE_CONSTRAINT_PRIMARYKEY') {
                 throw new Error(`Session ${sessionId} already exists`);
@@ -89,70 +89,70 @@ export class SqliteStorage implements StorageBackend {
         }
     }
 
-    async updateSession(identity: string, sessionId: string, data: Partial<SessionData>, ttl?: number): Promise<void> {
+    async update(userId: string, sessionId: string, data: Partial<Session>, ttl?: number): Promise<void> {
         this.ensureInitialized();
-        if (!sessionId || !identity) {
-            throw new Error('identity and sessionId required');
+        if (!sessionId || !userId) {
+            throw new Error('userId and sessionId required');
         }
 
-        const currentSession = await this.getSession(identity, sessionId);
+        const currentSession = await this.get(userId, sessionId);
         if (!currentSession) {
-            throw new Error(`Session ${sessionId} not found for identity ${identity}`);
+            throw new Error(`Session ${sessionId} not found for userId ${userId}`);
         }
 
         const updatedSession = { ...currentSession, ...data };
         const expiresAt = ttl ? Date.now() + ttl * 1000 : null;
 
         const stmt = this.db!.prepare(
-            `UPDATE ${this.table} SET data = ?, expiresAt = ? WHERE sessionId = ? AND identity = ?`
+            `UPDATE ${this.table} SET data = ?, expiresAt = ? WHERE sessionId = ? AND userId = ?`
         );
 
-        stmt.run(JSON.stringify(updatedSession), expiresAt, sessionId, identity);
+        stmt.run(JSON.stringify(updatedSession), expiresAt, sessionId, userId);
     }
 
-    async getSession(identity: string, sessionId: string): Promise<SessionData | null> {
+    async get(userId: string, sessionId: string): Promise<Session | null> {
         this.ensureInitialized();
 
         const stmt = this.db!.prepare(
-            `SELECT data FROM ${this.table} WHERE sessionId = ? AND identity = ?`
+            `SELECT data FROM ${this.table} WHERE sessionId = ? AND userId = ?`
         );
-        const row = stmt.get(sessionId, identity) as { data: string } | undefined;
+        const row = stmt.get(sessionId, userId) as { data: string } | undefined;
 
         if (!row) return null;
-        return JSON.parse(row.data) as SessionData;
+        return JSON.parse(row.data) as Session;
     }
 
-    async getIdentitySessionsData(identity: string): Promise<SessionData[]> {
+    async list(userId: string): Promise<Session[]> {
         this.ensureInitialized();
 
         const stmt = this.db!.prepare(
-            `SELECT data FROM ${this.table} WHERE identity = ?`
+            `SELECT data FROM ${this.table} WHERE userId = ?`
         );
-        const rows = stmt.all(identity) as { data: string }[];
+        const rows = stmt.all(userId) as { data: string }[];
 
-        return rows.map(row => JSON.parse(row.data) as SessionData);
+        return rows.map(row => JSON.parse(row.data) as Session);
     }
 
-    async getIdentityMcpSessions(identity: string): Promise<string[]> {
+    async listIds(userId: string): Promise<string[]> {
         this.ensureInitialized();
 
         const stmt = this.db!.prepare(
-            `SELECT sessionId FROM ${this.table} WHERE identity = ?`
+            `SELECT sessionId FROM ${this.table} WHERE userId = ?`
         );
-        const rows = stmt.all(identity) as { sessionId: string }[];
+        const rows = stmt.all(userId) as { sessionId: string }[];
 
         return rows.map(row => row.sessionId);
     }
 
-    async removeSession(identity: string, sessionId: string): Promise<void> {
+    async delete(userId: string, sessionId: string): Promise<void> {
         this.ensureInitialized();
         const stmt = this.db!.prepare(
-            `DELETE FROM ${this.table} WHERE sessionId = ? AND identity = ?`
+            `DELETE FROM ${this.table} WHERE sessionId = ? AND userId = ?`
         );
-        stmt.run(sessionId, identity);
+        stmt.run(sessionId, userId);
     }
 
-    async getAllSessionIds(): Promise<string[]> {
+    async listAllIds(): Promise<string[]> {
         this.ensureInitialized();
         const stmt = this.db!.prepare(`SELECT sessionId FROM ${this.table}`);
         const rows = stmt.all() as { sessionId: string }[];
@@ -165,7 +165,7 @@ export class SqliteStorage implements StorageBackend {
         stmt.run();
     }
 
-    async cleanupExpiredSessions(): Promise<void> {
+    async cleanupExpired(): Promise<void> {
         this.ensureInitialized();
         const now = Date.now();
         const stmt = this.db!.prepare(

package/src/server/storage/supabase-backend.ts

@@ -1,10 +1,10 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
-import { StorageBackend, SessionData } from './types.js';
+import type { SessionStore, Session } from './types.js';
 import { SESSION_TTL_SECONDS } from '../../shared/constants.js';
 import { generateSessionId } from '../../shared/utils.js';
 import { encryptObject, decryptObject } from './crypto.js';
 
-export class SupabaseStorageBackend implements StorageBackend {
+export class SupabaseStorageBackend implements SessionStore {
     private readonly DEFAULT_TTL = SESSION_TTL_SECONDS;
 
     constructor(private supabase: SupabaseClient) {}
@@ -34,7 +34,7 @@ export class SupabaseStorageBackend implements StorageBackend {
         return generateSessionId();
     }
 
-    private mapRowToSessionData(row: any): SessionData {
+    private mapRowToSessionData(row: any): Session {
         return {
             sessionId: row.session_id,
             serverId: row.server_id,
@@ -43,7 +43,7 @@ export class SupabaseStorageBackend implements StorageBackend {
             transportType: row.transport_type,
             callbackUrl: row.callback_url,
             createdAt: new Date(row.created_at).getTime(),
-            identity: row.identity,
+            userId: row.user_id,
             headers: decryptObject(row.headers),
             active: row.active,
             clientInformation: row.client_information,
@@ -53,9 +53,9 @@ export class SupabaseStorageBackend implements StorageBackend {
         };
     }
 
-    async createSession(session: SessionData, ttl?: number): Promise<void> {
-        const { sessionId, identity } = session;
-        if (!sessionId || !identity) throw new Error('identity and sessionId required');
+    async create(session: Session, ttl?: number): Promise<void> {
+        const { sessionId, userId } = session;
+        if (!sessionId || !userId) throw new Error('userId and sessionId required');
 
         const effectiveTtl = ttl ?? this.DEFAULT_TTL;
         const expiresAt = new Date(Date.now() + effectiveTtl * 1000).toISOString();
@@ -64,14 +64,13 @@ export class SupabaseStorageBackend implements StorageBackend {
             .from('mcp_sessions')
             .insert({
                 session_id: sessionId,
-                user_id: identity, // Maps user_id to identity to support RLS using auth.uid()
+                user_id: userId, // Maps user_id to userId to support RLS using auth.uid()
                 server_id: session.serverId,
                 server_name: session.serverName,
                 server_url: session.serverUrl,
                 transport_type: session.transportType,
                 callback_url: session.callbackUrl,
                 created_at: new Date(session.createdAt || Date.now()).toISOString(),
-                identity: identity,
                 headers: encryptObject(session.headers),
                 active: session.active ?? false,
                 client_information: session.clientInformation,
@@ -90,7 +89,7 @@ export class SupabaseStorageBackend implements StorageBackend {
         }
     }
 
-    async updateSession(identity: string, sessionId: string, data: Partial<SessionData>, ttl?: number): Promise<void> {
+    async update(userId: string, sessionId: string, data: Partial<Session>, ttl?: number): Promise<void> {
         const effectiveTtl = ttl ?? this.DEFAULT_TTL;
         const expiresAt = new Date(Date.now() + effectiveTtl * 1000).toISOString();
 
@@ -115,7 +114,7 @@ export class SupabaseStorageBackend implements StorageBackend {
         const { data: updatedRows, error } = await this.supabase
             .from('mcp_sessions')
             .update(updateData)
-            .eq('identity', identity)
+            .eq('user_id', userId)
             .eq('session_id', sessionId)
             .select('id');
 
@@ -124,15 +123,15 @@ export class SupabaseStorageBackend implements StorageBackend {
         }
 
         if (!updatedRows || updatedRows.length === 0) {
-            throw new Error(`Session ${sessionId} not found for identity ${identity}`);
+            throw new Error(`Session ${sessionId} not found for userId ${userId}`);
         }
     }
 
-    async getSession(identity: string, sessionId: string): Promise<SessionData | null> {
+    async get(userId: string, sessionId: string): Promise<Session | null> {
         const { data, error } = await this.supabase
             .from('mcp_sessions')
             .select('*')
-            .eq('identity', identity)
+            .eq('user_id', userId)
             .eq('session_id', sessionId)
             .maybeSingle();
 
@@ -146,25 +145,25 @@ export class SupabaseStorageBackend implements StorageBackend {
         return this.mapRowToSessionData(data);
     }
 
-    async getIdentitySessionsData(identity: string): Promise<SessionData[]> {
+    async list(userId: string): Promise<Session[]> {
         const { data, error } = await this.supabase
             .from('mcp_sessions')
             .select('*')
-            .eq('identity', identity);
+            .eq('user_id', userId);
 
         if (error) {
-            console.error(`[SupabaseStorage] Failed to get session data for ${identity}:`, error);
+            console.error(`[SupabaseStorage] Failed to get session data for ${userId}:`, error);
             return [];
         }
 
         return data.map(row => this.mapRowToSessionData(row));
     }
 
-    async removeSession(identity: string, sessionId: string): Promise<void> {
+    async delete(userId: string, sessionId: string): Promise<void> {
         const { error } = await this.supabase
             .from('mcp_sessions')
             .delete()
-            .eq('identity', identity)
+            .eq('user_id', userId)
             .eq('session_id', sessionId);
 
         if (error) {
@@ -172,21 +171,21 @@ export class SupabaseStorageBackend implements StorageBackend {
         }
     }
 
-    async getIdentityMcpSessions(identity: string): Promise<string[]> {
+    async listIds(userId: string): Promise<string[]> {
         const { data, error } = await this.supabase
             .from('mcp_sessions')
             .select('session_id')
-            .eq('identity', identity);
+            .eq('user_id', userId);
 
         if (error) {
-            console.error(`[SupabaseStorage] Failed to get sessions for ${identity}:`, error);
+            console.error(`[SupabaseStorage] Failed to get sessions for ${userId}:`, error);
             return [];
         }
 
         return data.map(row => row.session_id);
     }
 
-    async getAllSessionIds(): Promise<string[]> {
+    async listAllIds(): Promise<string[]> {
         const { data, error } = await this.supabase
             .from('mcp_sessions')
             .select('session_id');
@@ -211,7 +210,7 @@ export class SupabaseStorageBackend implements StorageBackend {
         }
     }
 
-    async cleanupExpiredSessions(): Promise<void> {
+    async cleanupExpired(): Promise<void> {
         const { error } = await this.supabase
             .from('mcp_sessions')
             .delete()

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}%`,
-    };
-  }
 }