@mcp-ts/sdk 2.4.4 → 2.4.5

package/package.json

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

package/src/server/handlers/sse-handler.ts

@@ -38,7 +38,7 @@ import { UnauthorizedError } from '../../shared/errors.js';
 import { isConnectionEvent, isRpcResponseEvent } from '../../shared/event-routing.js';
 import { parseOAuthState } from '../../shared/utils.js';
 import { MCPClient } from '../mcp/oauth-client.js';
-import { sessions } from '../storage/index.js';
+import { sessions, generateServerId } from '../storage/index.js';
 
 // ============================================
 // Types & Interfaces
@@ -256,7 +256,7 @@ export class SSEConnectionManager {
     // Tool name format: tool_<serverId>_<toolName> - with 12 char serverId leaves 46 chars for tool name
     const serverId = params.serverId && params.serverId.length <= 12
       ? params.serverId
-      : await sessions.generateSessionId();
+      : generateServerId();
 
     // Check for existing connections
     const existingSessions = await sessions.list(this.userId);

package/src/server/mcp/oauth-client.ts

@@ -360,7 +360,15 @@ export class MCPClient {
     if (!existingSession && this.serverId && this.serverUrl && this.callbackUrl) {
       this.createdAt = Date.now();
       const updatedAt = this.createdAt;
-      console.log(`[MCPClient] Creating pending session ${this.sessionId} for connection setup`);
+      this._onObservabilityEvent.fire({
+        type: 'mcp:client:session_created',
+        level: 'info',
+        message: `Creating pending session ${this.sessionId} for connection setup`,
+        sessionId: this.sessionId,
+        serverId: this.serverId,
+        timestamp: Date.now(),
+        id: nanoid(),
+      });
       await sessions.create({
         sessionId: this.sessionId,
         userId: this.userId,
@@ -542,7 +550,15 @@ export class MCPClient {
 
       // Refresh session metadata on every successful connect so active sessions
       // record ongoing usage and don't look dormant to session cleanup jobs.
-      console.log(`[MCPClient] Saving active session ${this.sessionId} (connect success)`);
+      this._onObservabilityEvent.fire({
+        type: 'mcp:client:session_saved',
+        level: 'info',
+        message: `Saving active session ${this.sessionId} (connect success)`,
+        sessionId: this.sessionId,
+        serverId: this.serverId,
+        timestamp: Date.now(),
+        id: nanoid(),
+      });
       await this.saveSession('active');
     } catch (error) {
       /** Handle Authentication Errors */
@@ -580,7 +596,15 @@ export class MCPClient {
         }
 
         this.emitStateChange('AUTHENTICATING');
-        console.log(`[MCPClient] Saving pending OAuth session ${this.sessionId}`);
+        this._onObservabilityEvent.fire({
+          type: 'mcp:client:session_saved',
+          level: 'info',
+          message: `Saving pending OAuth session ${this.sessionId}`,
+          sessionId: this.sessionId,
+          serverId: this.serverId,
+          timestamp: Date.now(),
+          id: nanoid(),
+        });
         await this.saveSession('pending');
 
         if (this.serverId) {
@@ -686,34 +710,30 @@ export class MCPClient {
           authenticatedStateEmitted = true;
         }
 
-        this.emitProgress('Creating authenticated client...');
-
-        this.client = new Client(
-          {
-            name: MCP_CLIENT_NAME,
-            version: MCP_CLIENT_VERSION,
-          },
-          {
-            capabilities: {
-              extensions: {
-                'io.modelcontextprotocol/ui': {
-                  mimeTypes: ['text/html+mcp'],
-                },
-              },
-            } as McpAppClientCapabilities
-          }
-        );
-
         this.emitStateChange('CONNECTING');
 
-        /** We explicitly try to connect with the transport we just auth'd with first */
+        // The SDK Client may still have a transport attached from a prior
+        // connect() that failed with UnauthorizedError; close it first so
+        // we can negotiate a fresh session with the newly-exchanged tokens.
+        if (this.client.transport) {
+          try { await this.client.close(); } catch {}
+        }
+
         await this.client.connect(this.transport);
 
         /** Connection succeeded — lock in the transport type */
         this.transportType = currentType;
 
         this.emitStateChange('CONNECTED');
-        console.log(`[MCPClient] Saving active session ${this.sessionId} (OAuth complete)`);
+        this._onObservabilityEvent.fire({
+          type: 'mcp:client:session_saved',
+          level: 'info',
+          message: `Saving active session ${this.sessionId} (OAuth complete)`,
+          sessionId: this.sessionId,
+          serverId: this.serverId,
+          timestamp: Date.now(),
+          id: nanoid(),
+        });
         await this.saveSession('active');
 
         return; // Success, exit function
@@ -767,10 +787,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async listTools(): Promise<ListToolsResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
-
     this.emitStateChange('DISCOVERING');
 
     try {
@@ -814,9 +830,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async callTool(toolName: string, toolArgs: Record<string, unknown>): Promise<CallToolResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
 
     const request: CallToolRequest = {
       method: 'tools/call',
@@ -877,10 +890,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async listPrompts(): Promise<ListPromptsResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
-
     this.emitStateChange('DISCOVERING');
 
     try {
@@ -913,9 +922,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async getPrompt(name: string, args?: Record<string, string>): Promise<GetPromptResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
 
     const request: GetPromptRequest = {
       method: 'prompts/get',
@@ -936,10 +942,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async listResources(): Promise<ListResourcesResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
-
     this.emitStateChange('DISCOVERING');
 
     try {
@@ -971,9 +973,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async readResource(uri: string): Promise<ReadResourceResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
 
     const request: ReadResourceRequest = {
       method: 'resources/read',
@@ -1031,7 +1030,16 @@ export class MCPClient {
     try {
       await this.ensureSession();
     } catch (error) {
-      console.warn('[MCPClient] Initialization failed during clearSession:', error);
+      this._onObservabilityEvent.fire({
+        type: 'mcp:client:error',
+        level: 'warn',
+        message: 'Initialization failed during clearSession',
+        sessionId: this.sessionId,
+        serverId: this.serverId,
+        payload: { error: String(error) },
+        timestamp: Date.now(),
+        id: nanoid(),
+      });
     }
 
     if (this.oauthProvider) {

package/src/server/storage/index.ts

@@ -9,7 +9,7 @@ import type { SessionStore, Session, SessionMutationEvent, SessionMutationListen
 
 // Re-export types
 export * from './types.js';
-export { generateSessionId } from '../../shared/utils.js';
+export { generateSessionId, generateServerId } from '../../shared/utils.js';
 export { RedisStorageBackend, MemoryStorageBackend, FileStorageBackend, SqliteStorage, SupabaseStorageBackend, NeonStorageBackend };
 
 export function createSupabaseStorageBackend(client: any): SupabaseStorageBackend {

package/src/shared/utils.ts

@@ -1,17 +1,10 @@
-import { customAlphabet } from 'nanoid';
+import { customAlphabet, nanoid } from 'nanoid';
 
 const OAUTH_STATE_SEPARATOR = '.';
 
-/** first char: letters only (required by OpenAI) */
-const firstChar = customAlphabet(
-    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
-    1
-);
-
-/** remaining chars: alphanumeric */
-const rest = customAlphabet(
-    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
-    11
+const serverIdAlphabet = customAlphabet(
+    'abcdefghijklmnopqrstuvwxyz0123456789',
+    12
 );
 
 /**
@@ -32,11 +25,20 @@ export function sanitizeServerLabel(name: string): string {
 }
 
 /**
- * Generates a standard 12-character session ID compliant with external tool restrictions.
- * First character is always a letter.
+ * Generates a session ID with a human-readable prefix for easy identification.
+ * Format: sess_<21-char nanoid> (26 chars total).
+ * Not used in tool names, so length is not constrained.
  */
 export function generateSessionId(): string {
-    return firstChar() + rest();
+    return 'sess_' + nanoid(21);
+}
+
+/**
+ * Generates a short server ID suitable for use in tool names.
+ * 12-char alphanumeric string that keeps tool_<serverId>_<toolName> under 64 chars.
+ */
+export function generateServerId(): string {
+    return serverIdAlphabet();
 }
 
 export interface ParsedOAuthState {