cellium-mcp-client 1.1.7 → 2.0.2

package/README.md

@@ -1,10 +1,11 @@
 # @cellium/mcp-client
 
-A Model Context Protocol (MCP) server that proxies requests to remote Cellium processor servers.
+A Model Context Protocol (MCP) server that provides both HTTP streaming and stdio transports to connect remote Cellium processor servers with MCP clients like Codex.
 
 ## Features
 
-- **HTTP Proxy**: Proxies MCP requests to remote Cellium servers via HTTP
+- **Dual Transport Support**: Both HTTP streaming and stdio transport for maximum compatibility
+- **Auto-Detection**: Automatically chooses appropriate transport based on execution context
 - **Authentication**: Token-based authentication with format `user:username:hash`
 - **Robust Connection Management**: Automatic reconnection with configurable retry logic
 - **MCP Protocol Compliance**: Uses official `@modelcontextprotocol/sdk`
@@ -27,6 +28,9 @@ npx @cellium/mcp-client
 
 ### Command Line Interface
 
+#### HTTP Streaming Mode (Default)
+Perfect for direct connections to the MCP server:
+
 ```bash
 # Using environment variable for token
 export CELLIUM_MCP_TOKEN="user:your-username:your-hash"
@@ -35,19 +39,46 @@ cellium-mcp-client
 # Using command line option
 cellium-mcp-client --token "user:your-username:your-hash"
 
-# With custom endpoint and verbose logging
+# With custom endpoint, port, and verbose logging
 cellium-mcp-client \
   --token "user:your-username:your-hash" \
-  --endpoint "https://mcp.cellium.dev/mcp" \
+  --endpoint "https://mcp.cellium.dev/http-stream" \
+  --port 3001 \
   --verbose \
   --retry-attempts 5 \
   --retry-delay 2000
 ```
 
-### Configuration with Cody/Other MCP Clients
+#### Stdio Mode (Command-Based MCP Clients)
+Perfect for command-based MCP clients like Codex:
+
+```bash
+# Explicit stdio mode
+cellium-mcp-client --stdio --token "user:your-username:your-hash"
+
+# Auto-detection when run by MCP clients (stdin is piped)
+# This happens automatically when launched via MCP client configuration
+```
+
+### Configuration with Codex/Other MCP Clients
+
+#### Option 1: Direct HTTP Connection (Recommended for modern clients)
+```toml
+[mcp_servers.cellium]
+url = "http://localhost:3001"
+enabled = true
+```
 
-Add to your MCP client configuration:
+#### Option 2: Command-Based with Stdio Transport (Universal compatibility)
+```toml
+[mcp_servers.cellium]
+command = "npx"
+args = ["-y", "@cellium/mcp-client", "--stdio"]
+env = { CELLIUM_MCP_TOKEN = "user:your-username:your-hash" }
+enabled = true
+```
 
+#### Option 3: Command-Based with HTTP Auto-Start
 ```toml
 [mcp_servers.cellium]
 command = "npx"
@@ -64,17 +95,30 @@ import pino from 'pino';
 
 const logger = pino();
 
-const client = new CelliumMCPClient({
+// HTTP Streaming Mode
+const httpClient = new CelliumMCPClient({
+  token: 'user:your-username:your-hash',
+  endpoint: 'https://mcp.cellium.dev/http-stream',
+  httpPort: 3001,
+  logger,
+  retryAttempts: 3,
+  retryDelay: 1000,
+  useStdio: false
+});
+
+// Stdio Mode
+const stdioClient = new CelliumMCPClient({
   token: 'user:your-username:your-hash',
-  endpoint: 'https://mcp.cellium.dev/mcp',
+  endpoint: 'https://mcp.cellium.dev/http-stream',
   logger,
   retryAttempts: 3,
-  retryDelay: 1000
+  retryDelay: 1000,
+  useStdio: true
 });
 
 await client.connect();
+await client.serve();
 
-// The client will now proxy MCP requests to the remote server
 // Handle shutdown gracefully
 process.on('SIGINT', async () => {
   await client.disconnect();
@@ -87,11 +131,35 @@ process.on('SIGINT', async () => {
 | Option | Environment Variable | Description | Default |
 |--------|---------------------|-------------|---------|
 | `--token` | `CELLIUM_MCP_TOKEN` | Authentication token (required) | - |
-| `--endpoint` | - | Server endpoint URL | `https://mcp.cellium.dev/mcp` |
+| `--endpoint` | - | Server endpoint URL | `http://localhost:3000/http-stream` |
+| `--port` | - | HTTP streaming port | `3001` |
+| `--stdio` | - | Force stdio transport | Auto-detected |
 | `--verbose` | - | Enable verbose logging | `false` |
+| `--debug` | - | Enable debug mode with extensive logging | `false` |
 | `--retry-attempts` | - | Number of retry attempts | `3` |
 | `--retry-delay` | - | Delay between retries (ms) | `1000` |
 
+## Transport Modes
+
+### HTTP Streaming Transport
+- **Use case**: Direct connections from modern MCP clients
+- **Benefits**: Persistent connections, multiple concurrent sessions, better scalability
+- **Connection**: Client connects directly to `http://localhost:3001` (or configured port)
+- **Communication**: Server-Sent Events (SSE) for real-time streaming
+
+### Stdio Transport
+- **Use case**: Command-based MCP clients (like traditional Codex configurations)
+- **Benefits**: Universal compatibility, no port conflicts, standard MCP pattern
+- **Connection**: MCP client launches process and communicates via stdin/stdout
+- **Communication**: Standard input/output pipes
+
+### Auto-Detection Logic
+The client automatically chooses the appropriate transport:
+
+1. **Explicit stdio**: `--stdio` flag forces stdio transport
+2. **Auto-detected stdio**: When stdin is piped (command-based execution)
+3. **Default HTTP**: All other cases use HTTP streaming transport
+
 ## Authentication Token Format
 
 The authentication token must follow the format: `user:username:hash`
@@ -106,16 +174,17 @@ Example: `user:john-doe:a1b2c3d4e5f6...`
 ## Architecture
 
 ```
-┌─────────────────┐   stdio    ┌─────────────────┐   HTTPS    ┌─────────────────┐
-│                 │◄──────────►│                 │◄──────────►│                 │
-│  Code Editor /  │    MCP     │ cellium-mcp-    │    HTTP    │ Cellium Server  │
-│  AI Assistant   │  Protocol  │ client (Proxy)  │   Requests │   (Remote)      │
-│   (Cody, etc.)  │            │                 │            │                 │
-└─────────────────┘            └─────────────────┘            └─────────────────┘
+┌─────────────────┐   HTTP/Stdio   ┌─────────────────┐   HTTPS    ┌─────────────────┐
+│                 │◄──────────────►│                 │◄──────────►│                 │
+│     Codex /     │   Streaming    │ cellium-mcp-    │    HTTP    │ Cellium Server  │
+│  AI Assistant   │   or Pipes     │ client (Proxy)  │   Requests │   (Remote)      │
+│   (Cody, etc.)  │   MCP Protocol │                 │            │                 │
+└─────────────────┘                └─────────────────┘            └─────────────────┘
 ```
 
-The client acts as an **MCP server proxy** between local MCP clients (like Cody) and the remote Cellium processor server, handling:
-- **MCP Protocol**: Full stdio-based MCP server implementation
+The client acts as a **dual-transport MCP server** that proxies requests between MCP clients and the remote Cellium processor server, handling:
+- **HTTP Streaming Transport**: Provides streamable HTTP interface for direct client connection
+- **Stdio Transport**: Traditional stdin/stdout communication for command-based clients
 - **Authentication**: Token-based authentication with remote server
 - **Request Proxying**: Converts MCP requests to HTTP requests to remote server
 - **Error Handling**: Graceful handling of connection failures
@@ -144,8 +213,9 @@ npm run dev
 ### Connection Issues
 
 1. **Invalid token format**: Ensure your token follows the `user:username:hash` format
-2. **Network connectivity**: Check if `https://mcp.cellium.dev/mcp` is accessible
+2. **Network connectivity**: Check if `https://mcp.cellium.dev/http-stream` is accessible
 3. **Authentication failed**: Verify your token is valid and not expired
+4. **Port already in use**: Change the `--port` option if port 3001 is already in use
 
 ### Verbose Logging
 
@@ -159,8 +229,18 @@ cellium-mcp-client --verbose --token "your-token"
 
 - `Authentication token required`: Set `CELLIUM_MCP_TOKEN` or use `--token`
 - `Invalid token format`: Check token follows `user:username:hash` pattern  
-- `Not connected to remote server`: Connection to SSE endpoint failed
+- `Not connected to remote server`: Connection to HTTP streaming endpoint failed
 - `Request timeout`: Remote server didn't respond within 30 seconds
+- `EADDRINUSE`: Port is already in use, try a different `--port`
+
+### Connecting with Codex
+
+Make sure to connect your MCP client to the HTTP streaming server at:
+```
+http://localhost:3001
+```
+
+The server provides Server-Sent Events (SSE) streaming for real-time communication.
 
 ## License
 

package/dist/cli.js

@@ -11,9 +11,11 @@ const program = new commander_1.Command();
 program
     .name('cellium-mcp-client')
     .description('MCP client for connecting to remote Cellium processor server')
-    .version('1.1.3')
+    .version('2.0.0')
     .option('-t, --token <token>', 'Authentication token (format: user:username:hash)')
-    .option('-e, --endpoint <url>', 'Server endpoint URL', 'http://localhost:3000/mcp')
+    .option('-e, --endpoint <url>', 'Server endpoint URL', 'http://localhost:3000/http-stream')
+    .option('-p, --port <number>', 'HTTP streaming port for MCP client', '3001')
+    .option('--stdio', 'Use stdio transport (for command-based MCP clients)')
     .option('-v, --verbose', 'Enable verbose logging')
     .option('-d, --debug', 'Enable debug mode with extensive logging')
     .option('-r, --retry-attempts <num>', 'Number of retry attempts on connection failure', '3')
@@ -50,24 +52,33 @@ async function main() {
             logger.info('Example: user:myusername:abc123def456...');
             process.exit(1);
         }
+        // Auto-detect transport mode
+        // Use stdio if explicitly requested or if stdin is piped (indicating command-based usage)
+        const useStdio = options.stdio || (!process.stdin.isTTY && process.stdout.isTTY);
+        const transportMode = useStdio ? 'stdio' : 'http-streaming';
         logger.info({
-            version: '1.1.3',
+            version: '2.0.0',
             debugMode: !!options.debug,
-            verboseMode: !!options.verbose
+            verboseMode: !!options.verbose,
+            transportMode
         }, 'Starting Cellium MCP Client');
         logger.debug({
             endpoint: options.endpoint,
+            httpPort: parseInt(options.port),
             retryAttempts: parseInt(options.retryAttempts),
             retryDelay: parseInt(options.retryDelay),
+            useStdio,
             tokenPreview: `${token.split(':')[0]}:${token.split(':')[1]}:${token.split(':')[2]?.substring(0, 8)}...`
         }, 'Configuration loaded');
         const client = new client_1.CelliumMCPClient({
             token,
             endpoint: options.endpoint,
+            httpPort: parseInt(options.port),
             logger,
             retryAttempts: parseInt(options.retryAttempts),
             retryDelay: parseInt(options.retryDelay),
-            debugMode: !!options.debug
+            debugMode: !!options.debug,
+            useStdio
         });
         // Enhanced error handling for unhandled rejections
         process.on('unhandledRejection', (reason, promise) => {

package/dist/client.d.ts

@@ -6,11 +6,14 @@ export interface CelliumMCPClientConfig {
     retryAttempts?: number;
     retryDelay?: number;
     debugMode?: boolean;
+    httpPort?: number;
+    useStdio?: boolean;
 }
 export declare class CelliumMCPClient {
     private config;
     private localServer;
     private transport?;
+    private httpServer?;
     private isConnected;
     private reconnectTimer?;
     private keepAliveInterval?;

package/dist/client.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CelliumMCPClient = void 0;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const http_1 = require("http");
+const crypto_1 = require("crypto");
 const zod_1 = require("zod");
 // Define schemas for MCP requests
 const ToolsListSchema = zod_1.z.object({
@@ -45,6 +48,7 @@ class CelliumMCPClient {
     config;
     localServer;
     transport;
+    httpServer;
     isConnected = false;
     reconnectTimer;
     keepAliveInterval;
@@ -65,16 +69,19 @@ class CelliumMCPClient {
             retryAttempts: 3,
             retryDelay: 1000,
             debugMode: false,
+            httpPort: 3001, // Default HTTP streaming port
+            useStdio: false,
             ...config
         };
         this.logDebug('Initializing CelliumMCPClient', {
             endpoint: this.config.endpoint,
+            httpPort: this.config.httpPort,
             debugMode: this.config.debugMode
         });
-        // Local server that interfaces with AI assistants via stdio
+        // Local server that interfaces with AI assistants via HTTP streaming
         this.localServer = new mcp_js_1.McpServer({
             name: 'cellium-mcp-client',
-            version: '1.1.3'
+            version: '2.0.0'
         }, {
             capabilities: {
                 tools: {},
@@ -216,7 +223,7 @@ class CelliumMCPClient {
                 },
                 serverInfo: {
                     name: 'cellium-mcp-client',
-                    version: '1.1.3'
+                    version: '2.0.0'
                 }
             };
             this.transportState.connected = true;
@@ -355,14 +362,14 @@ class CelliumMCPClient {
                 throw new Error('Cannot connect to remote Cellium server');
             }
         }
-        const mcpEndpoint = this.config.endpoint.replace('/sse', '/mcp');
+        const httpStreamEndpoint = this.config.endpoint.replace('/sse', '/http-stream');
         const requestBody = {
             jsonrpc: '2.0',
             id: requestId,
             method,
             params
         };
-        this.logDebug(`Making HTTP request to ${mcpEndpoint}`, {
+        this.logDebug(`Making HTTP request to ${httpStreamEndpoint}`, {
             requestId,
             method,
             bodySize: JSON.stringify(requestBody).length
@@ -370,12 +377,12 @@ class CelliumMCPClient {
         let response;
         let responseText;
         try {
-            response = await fetch(mcpEndpoint, {
+            response = await fetch(httpStreamEndpoint, {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${this.config.token}`,
                     'Content-Type': 'application/json',
-                    'User-Agent': 'cellium-mcp-client/1.1.3'
+                    'User-Agent': 'cellium-mcp-client/2.0.0'
                 },
                 body: JSON.stringify(requestBody)
             });
@@ -434,7 +441,7 @@ class CelliumMCPClient {
                 requestId,
                 method,
                 duration,
-                endpoint: mcpEndpoint
+                endpoint: httpStreamEndpoint
             }, 'HTTP request to remote server failed');
             this.isConnected = false; // Mark as disconnected on error
             throw error;
@@ -442,34 +449,90 @@ class CelliumMCPClient {
     }
     async connect() {
         try {
+            const transportMode = this.config.useStdio ? 'stdio' : 'http-streaming';
             this.config.logger.info({
                 endpoint: this.config.endpoint,
+                httpPort: this.config.httpPort,
                 debugMode: this.config.debugMode,
-                protocolVersion: this.mcpProtocolVersion
-            }, 'Starting Cellium MCP Server');
-            this.logDebug('Initializing stdio transport');
-            // Set up the stdio transport for local MCP server immediately
-            this.transport = new stdio_js_1.StdioServerTransport();
-            // Add transport event monitoring
-            this.setupTransportEventListeners(this.transport);
-            await this.localServer.connect(this.transport);
-            this.transportState.connected = true;
-            this.transportState.lastActivity = Date.now();
-            this.config.logger.info('MCP Server connected and ready');
-            this.logDebug('Transport connected successfully', {
-                transportType: 'stdio',
-                serverName: 'cellium-mcp-client',
-                serverVersion: '1.1.3'
-            });
-            // Keep the process alive with a minimal interval
-            // This ensures the process doesn't exit when stdin closes
-            this.keepAliveInterval = setInterval(() => {
-                this.logDebug('Keep-alive tick', {
-                    uptime: Date.now() - this.transportState.lastActivity,
-                    activeRequests: this.activeRequests.size
+                protocolVersion: this.mcpProtocolVersion,
+                transportMode
+            }, `Starting Cellium MCP Client with ${transportMode} transport`);
+            if (this.config.useStdio) {
+                // Use stdio transport for command-based MCP clients
+                this.logDebug('Initializing stdio transport');
+                this.transport = new stdio_js_1.StdioServerTransport();
+                // Add transport event monitoring if supported
+                if ('onclose' in this.transport) {
+                    this.setupTransportEventListeners(this.transport);
+                }
+                await this.localServer.connect(this.transport);
+                this.transportState.connected = true;
+                this.transportState.lastActivity = Date.now();
+                this.config.logger.info('MCP stdio transport ready - communicating via stdin/stdout');
+                this.logDebug('Stdio transport connected successfully', {
+                    transportType: 'stdio',
+                    serverName: 'cellium-mcp-client',
+                    serverVersion: '2.0.0'
+                });
+            }
+            else {
+                // Use HTTP streaming transport (original implementation)
+                this.logDebug('Initializing HTTP streaming transport');
+                // Set up the HTTP streaming transport for local MCP server
+                this.transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => (0, crypto_1.randomUUID)(),
+                    enableJsonResponse: false // Use SSE streaming for compatibility with codex
+                });
+                // Add transport event monitoring
+                this.setupTransportEventListeners(this.transport);
+                await this.localServer.connect(this.transport);
+                this.transportState.connected = true;
+                this.transportState.lastActivity = Date.now();
+                // Create HTTP server to handle requests
+                this.httpServer = (0, http_1.createServer)(async (req, res) => {
+                    try {
+                        await this.transport.handleRequest(req, res);
+                    }
+                    catch (error) {
+                        this.config.logger.error({ error }, 'Error handling HTTP request');
+                        res.statusCode = 500;
+                        res.end('Internal Server Error');
+                    }
+                });
+                // Start HTTP server
+                await new Promise((resolve, reject) => {
+                    this.httpServer.listen(this.config.httpPort, (err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            this.config.logger.info({
+                                port: this.config.httpPort,
+                                url: `http://localhost:${this.config.httpPort}`
+                            }, 'HTTP streaming server started');
+                            resolve();
+                        }
+                    });
                 });
-            }, 30000); // Check every 30 seconds
-            this.config.logger.debug('Keep-alive interval started for persistent MCP communication');
+                this.config.logger.info(`MCP HTTP Streaming Server ready at http://localhost:${this.config.httpPort}`);
+                this.logDebug('HTTP streaming transport connected successfully', {
+                    transportType: 'streamable-http',
+                    port: this.config.httpPort,
+                    serverName: 'cellium-mcp-client',
+                    serverVersion: '2.0.0'
+                });
+            }
+            // For HTTP streaming mode, keep the process alive with a minimal interval
+            // For stdio mode, the process stays alive naturally via stdin/stdout communication
+            if (!this.config.useStdio) {
+                this.keepAliveInterval = setInterval(() => {
+                    this.logDebug('Keep-alive tick', {
+                        uptime: Date.now() - this.transportState.lastActivity,
+                        activeRequests: this.activeRequests.size
+                    });
+                }, 30000); // Check every 30 seconds
+                this.config.logger.debug('Keep-alive interval started for persistent HTTP MCP communication');
+            }
             // Test connection to remote server and pre-fetch tools cache
             await this.initializeRemoteConnection();
         }
@@ -480,80 +543,79 @@ class CelliumMCPClient {
                     message: error.message,
                     stack: error.stack
                 } : error
-            }, 'Failed to start MCP server');
+            }, 'Failed to start MCP HTTP streaming server');
             this.transportState.connected = false;
             throw error;
         }
     }
     setupTransportEventListeners(transport) {
         this.logDebug('Setting up transport event listeners');
-        // Monitor transport events if available
-        try {
-            // Try to access transport events (may not be available in all SDK versions)
-            const transportAny = transport;
-            if (transportAny.on && typeof transportAny.on === 'function') {
-                transportAny.on('close', () => {
-                    this.config.logger.warn('Transport close event detected');
-                    this.transportState.connected = false;
-                });
-                transportAny.on('error', (error) => {
-                    this.config.logger.error({ error }, 'Transport error event');
-                    this.transportState.errorCount++;
-                });
-                transportAny.on('connect', () => {
-                    this.config.logger.info('Transport connect event');
-                    this.transportState.connected = true;
-                });
-                this.logDebug('Transport event listeners attached');
-            }
-            else {
-                this.logDebug('Transport does not support event listeners');
-            }
-        }
-        catch (error) {
-            this.logDebug('Could not attach transport event listeners', { error });
-        }
+        // Set up transport event handlers
+        transport.onclose = () => {
+            this.config.logger.warn('Transport close event detected');
+            this.transportState.connected = false;
+        };
+        transport.onerror = (error) => {
+            this.config.logger.error({ error }, 'Transport error event');
+            this.transportState.errorCount++;
+        };
+        this.logDebug('Transport event listeners attached');
     }
     async serve() {
-        // The MCP server is already connected via stdio in connect()
-        // Keep the process alive indefinitely for persistent MCP communication
-        // This ensures compatibility with MCP clients like Copilot that expect long-running servers
-        this.config.logger.debug({
-            transportConnected: this.transportState.connected,
-            serverName: 'cellium-mcp-client'
-        }, 'Server is now serving and will stay alive for persistent MCP communication');
-        this.logDebug('Entering serve mode - process will stay alive');
-        // Set up graceful shutdown handlers
-        process.on('SIGINT', async () => {
-            this.config.logger.info('Received SIGINT, shutting down gracefully...');
-            await this.disconnect();
-            process.exit(0);
-        });
-        process.on('SIGTERM', async () => {
-            this.config.logger.info('Received SIGTERM, shutting down gracefully...');
-            await this.disconnect();
-            process.exit(0);
-        });
-        // Return a promise that never resolves to keep the process alive
-        // The process will only exit via SIGINT/SIGTERM signals
-        return new Promise(() => {
-            // Never resolve - keep process alive for MCP communication
-            // Process will be terminated gracefully via signal handlers
-        });
+        if (this.config.useStdio) {
+            // For stdio transport, the MCP communication happens automatically via stdin/stdout
+            // The server stays alive as long as the parent process keeps it alive
+            this.config.logger.debug({
+                transportConnected: this.transportState.connected,
+                transportMode: 'stdio',
+                serverName: 'cellium-mcp-client'
+            }, 'Stdio MCP server is now serving via stdin/stdout');
+            this.logDebug('Entering serve mode - stdio transport active');
+            // For stdio mode, we don't need to keep the process alive artificially
+            // The process will stay alive as long as stdin/stdout are connected
+            // No need to return a never-resolving promise
+        }
+        else {
+            // For HTTP streaming mode, keep the process alive indefinitely
+            this.config.logger.debug({
+                transportConnected: this.transportState.connected,
+                httpPort: this.config.httpPort,
+                transportMode: 'http-streaming',
+                serverName: 'cellium-mcp-client'
+            }, 'HTTP streaming server is now serving and will stay alive for persistent MCP communication');
+            this.logDebug('Entering serve mode - HTTP server will stay alive');
+            // Set up graceful shutdown handlers
+            process.on('SIGINT', async () => {
+                this.config.logger.info('Received SIGINT, shutting down gracefully...');
+                await this.disconnect();
+                process.exit(0);
+            });
+            process.on('SIGTERM', async () => {
+                this.config.logger.info('Received SIGTERM, shutting down gracefully...');
+                await this.disconnect();
+                process.exit(0);
+            });
+            // Return a promise that never resolves to keep the process alive
+            // The process will only exit via SIGINT/SIGTERM signals
+            return new Promise(() => {
+                // Never resolve - keep process alive for HTTP streaming MCP communication
+                // Process will be terminated gracefully via signal handlers
+            });
+        }
     }
     async testConnection() {
         const startTime = Date.now();
-        const mcpEndpoint = this.config.endpoint.replace('/sse', '/mcp');
+        const httpStreamEndpoint = this.config.endpoint.replace('/sse', '/http-stream');
         this.logDebug('Testing connection', {
-            endpoint: mcpEndpoint,
+            endpoint: httpStreamEndpoint,
             hasToken: !!this.config.token
         });
-        const response = await fetch(mcpEndpoint, {
+        const response = await fetch(httpStreamEndpoint, {
             method: 'POST',
             headers: {
                 'Authorization': `Bearer ${this.config.token}`,
                 'Content-Type': 'application/json',
-                'User-Agent': 'cellium-mcp-client/1.1.3'
+                'User-Agent': 'cellium-mcp-client/2.0.0'
             },
             body: JSON.stringify({
                 jsonrpc: '2.0',
@@ -640,7 +702,7 @@ class CelliumMCPClient {
         }
     }
     async disconnect() {
-        this.config.logger.info('Disconnecting from Cellium MCP Server');
+        this.config.logger.info('Disconnecting from Cellium MCP HTTP Streaming Server');
         this.logDebug('Starting disconnect process', {
             activeRequestCount: this.activeRequests.size,
             transportConnected: this.transportState.connected
@@ -669,6 +731,15 @@ class CelliumMCPClient {
             clearInterval(this.backgroundRefreshTimer);
             this.backgroundRefreshTimer = undefined;
         }
+        // Close HTTP server
+        if (this.httpServer) {
+            await new Promise((resolve) => {
+                this.httpServer.close(() => {
+                    this.config.logger.info('HTTP streaming server closed');
+                    resolve();
+                });
+            });
+        }
         try {
             await this.localServer.close();
             this.logDebug('Local MCP server closed successfully');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cellium-mcp-client",
-  "version": "1.1.7",
+  "version": "2.0.2",
   "description": "MCP client for connecting to remote Cellium processor server",
   "main": "dist/index.js",
   "bin": {