@mcp-ts/sdk 2.2.0 → 2.3.1

package/dist/{tool-router-C8hIA-tg.d.mts → tool-router-BfE_9tay.d.mts}

@@ -355,6 +355,11 @@ declare class ToolRouter {
      * If tool name is ambiguous, use namespace to specify the server.
      */
     getToolSchema(toolName: string, namespace?: string, options?: ToolLookupOptions): IndexedTool | undefined;
+    /**
+     * Resolve the full tool definition by name, ensuring the router index has
+     * been initialized first.
+     */
+    resolveToolSchema(toolName: string, namespace?: string, options?: ToolLookupOptions): Promise<IndexedTool | undefined>;
     /**
      * Get compact (schema-less) summaries for all tools.
      */

package/dist/{tool-router-CdX8e9bk.d.ts → tool-router-CP7qLk1J.d.ts}

@@ -355,6 +355,11 @@ declare class ToolRouter {
      * If tool name is ambiguous, use namespace to specify the server.
      */
     getToolSchema(toolName: string, namespace?: string, options?: ToolLookupOptions): IndexedTool | undefined;
+    /**
+     * Resolve the full tool definition by name, ensuring the router index has
+     * been initialized first.
+     */
+    resolveToolSchema(toolName: string, namespace?: string, options?: ToolLookupOptions): Promise<IndexedTool | undefined>;
     /**
      * Get compact (schema-less) summaries for all tools.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-ts/sdk",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "publishConfig": {
     "access": "public"
   },

package/src/server/index.ts

@@ -6,7 +6,7 @@
 /** Core MCP client and session management */
 export { MCPClient } from './mcp/oauth-client.js';
 export { UnauthorizedError } from '../shared/errors.js';
-export { sessions, type SessionStore } from './storage/index.js';
+export { sessions, onSessionMutation, type SessionStore } from './storage/index.js';
 export { StorageOAuthClientProvider } from './mcp/storage-oauth-provider.js';
 export { MultiSessionClient } from './mcp/multi-session-client.js';
 
@@ -44,6 +44,13 @@ export type {
   CallToolResponse,
 } from '../shared/types';
 
+export type {
+  Session,
+  SessionMutationEvent,
+  SessionMutationListener,
+  SessionMutationType,
+} from './storage/types.js';
+
 /** Re-export MCP SDK types for convenience */
 export type {
   OAuthClientMetadata,

package/src/server/storage/index.ts

@@ -5,7 +5,7 @@ import { FileStorageBackend } from './file-backend';
 import { SqliteStorage } from './sqlite-backend.js';
 import { SupabaseStorageBackend } from './supabase-backend.js';
 import { NeonStorageBackend, type NeonStorageOptions } from './neon-backend.js';
-import type { SessionStore } from './types.js';
+import type { SessionStore, Session, SessionMutationEvent, SessionMutationListener } from './types.js';
 
 // Re-export types
 export * from './types.js';
@@ -42,6 +42,65 @@ function warnIfNeonConnectionStringIsInsecure(connectionString: string): void {
 
 let storageInstance: SessionStore | null = null;
 let storagePromise: Promise<SessionStore> | null = null;
+const sessionMutationListeners = new Set<SessionMutationListener>();
+
+function emitSessionMutation(event: SessionMutationEvent): void {
+    for (const listener of sessionMutationListeners) {
+        try {
+            const result = listener(event);
+            if (result && typeof (result as Promise<void>).catch === 'function') {
+                void (result as Promise<void>).catch((error) => {
+                    console.error('[mcp-ts][Storage] Session mutation listener failed:', error);
+                });
+            }
+        } catch (error) {
+            console.error('[mcp-ts][Storage] Session mutation listener failed:', error);
+        }
+    }
+}
+
+function createSessionMutationEvent(prop: PropertyKey, args: any[]): SessionMutationEvent | null {
+    const timestamp = Date.now();
+
+    if (prop === 'create') {
+        const [session, ttl] = args as [Session, number | undefined];
+        if (!session?.userId || !session?.sessionId) return null;
+        return {
+            type: 'create',
+            userId: session.userId,
+            sessionId: session.sessionId,
+            session,
+            ttl,
+            timestamp,
+        };
+    }
+
+    if (prop === 'update') {
+        const [userId, sessionId, patch, ttl] = args as [string, string, Partial<Session>, number | undefined];
+        if (!userId || !sessionId) return null;
+        return {
+            type: 'update',
+            userId,
+            sessionId,
+            patch,
+            ttl,
+            timestamp,
+        };
+    }
+
+    if (prop === 'delete') {
+        const [userId, sessionId] = args as [string, string];
+        if (!userId || !sessionId) return null;
+        return {
+            type: 'delete',
+            userId,
+            sessionId,
+            timestamp,
+        };
+    }
+
+    return null;
+}
 
 async function initializeStorage<T extends SessionStore>(store: T): Promise<T> {
     if (typeof store.init === 'function') {
@@ -215,6 +274,17 @@ export function _setStorageInstanceForTesting(instance: SessionStore | null): vo
     }
 }
 
+export function onSessionMutation(listener: SessionMutationListener): () => void {
+    sessionMutationListeners.add(listener);
+    return () => {
+        sessionMutationListeners.delete(listener);
+    };
+}
+
+export function _resetSessionMutationListenersForTesting(): void {
+    sessionMutationListeners.clear();
+}
+
 /**
  * Global session store instance
  * Uses lazy initialization with a Proxy to handle async setup transparently
@@ -225,7 +295,12 @@ export const sessions: SessionStore = new Proxy({} as SessionStore, {
             const instance = await getStorage();
             const value = (instance as any)[prop];
             if (typeof value === 'function') {
-                return value.apply(instance, args);
+                const result = await value.apply(instance, args);
+                const event = createSessionMutationEvent(prop, args);
+                if (event) {
+                    emitSessionMutation(event);
+                }
+                return result;
             }
             return value;
         };

package/src/server/storage/types.ts

@@ -29,6 +29,20 @@ export interface Session {
     clientId?: string;
 }
 
+export type SessionMutationType = 'create' | 'update' | 'delete';
+
+export interface SessionMutationEvent {
+    type: SessionMutationType;
+    userId: string;
+    sessionId: string;
+    timestamp: number;
+    session?: Session;
+    patch?: Partial<Session>;
+    ttl?: number;
+}
+
+export type SessionMutationListener = (event: SessionMutationEvent) => void | Promise<void>;
+
 export interface SetClientOptions {
     sessionId: string;
     serverId?: string; // Database server ID

package/src/shared/meta-tools.ts

@@ -235,12 +235,23 @@ export async function executeMetaTool(
   router: ToolRouter,
   callToolFn?: CallToolFn
 ): Promise<CallToolResult | null> {
-  const resolveToolSchema = (
+  const resolveToolSchema = async (
     name: string,
     namespace?: string,
     options?: ToolLookupOptions
-  ): { tool?: IndexedTool; error?: CallToolResult } => {
+  ): Promise<{ tool?: IndexedTool; error?: CallToolResult }> => {
     try {
+      if (typeof (router as ToolRouter & { resolveToolSchema?: unknown }).resolveToolSchema === 'function') {
+        return {
+          tool: await (router as ToolRouter & {
+            resolveToolSchema: (
+              toolName: string,
+              namespace?: string,
+              options?: ToolLookupOptions
+            ) => Promise<IndexedTool | undefined>;
+          }).resolveToolSchema(name, namespace, options),
+        };
+      }
       return { tool: router.getToolSchema(name, namespace, options) };
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -307,8 +318,6 @@ export async function executeMetaTool(
       // Fast path: Check for select: prefix
       const selectMatch = query.match(/^select:(.+)$/i);
       if (selectMatch) {
-        await router.listTools({ serverId, serverName, limit: 1 });
-
         const requested = selectMatch[1]!
           .split(',')
           .map((s) => s.trim())
@@ -320,7 +329,7 @@ export async function executeMetaTool(
         const namespace = serverId ?? serverName;
 
         for (const requestedToolName of requested) {
-          const { tool, error } = resolveToolSchema(requestedToolName, namespace, {
+          const { tool, error } = await resolveToolSchema(requestedToolName, namespace, {
             allowServerNameFragment: Boolean(serverName && !serverId),
           });
           if (error) {
@@ -410,7 +419,7 @@ export async function executeMetaTool(
     case 'mcp_get_tool_schema': {
       const name = String(args.toolName ?? '');
       const namespace = String(args.serverId ?? '') || undefined;
-      const { tool, error } = resolveToolSchema(name, namespace);
+      const { tool, error } = await resolveToolSchema(name, namespace);
 
       if (error) {
         return error;
@@ -461,7 +470,7 @@ export async function executeMetaTool(
       }
 
       // Verify the tool exists in our index
-      const { tool, error } = resolveToolSchema(targetToolName, namespace);
+      const { tool, error } = await resolveToolSchema(targetToolName, namespace);
       if (error) {
         return error;
       }

package/src/shared/tool-router.ts

@@ -289,6 +289,19 @@ export class ToolRouter {
     return matches[0];
   }
 
+  /**
+   * Resolve the full tool definition by name, ensuring the router index has
+   * been initialized first.
+   */
+  async resolveToolSchema(
+    toolName: string,
+    namespace?: string,
+    options: ToolLookupOptions = {}
+  ): Promise<IndexedTool | undefined> {
+    await this.ensureInitialized();
+    return this.getToolSchema(toolName, namespace, options);
+  }
+
   /**
    * Get compact (schema-less) summaries for all tools.
    */