cellium-mcp-client 1.1.0 → 1.1.2

package/dist/cli.js

@@ -11,7 +11,7 @@ const program = new commander_1.Command();
 program
     .name('cellium-mcp-client')
     .description('MCP client for connecting to remote Cellium processor server')
-    .version('1.1.0')
+    .version('1.1.2')
     .option('-t, --token <token>', 'Authentication token (format: user:username:hash)')
     .option('-e, --endpoint <url>', 'Server endpoint URL', 'http://localhost:3000/mcp')
     .option('-v, --verbose', 'Enable verbose logging')

package/dist/client.js

@@ -30,6 +30,17 @@ const PingSchema = zod_1.z.object({
     method: zod_1.z.literal('ping'),
     params: zod_1.z.object({}).optional()
 });
+const InitializeSchema = zod_1.z.object({
+    method: zod_1.z.literal('initialize'),
+    params: zod_1.z.object({
+        protocolVersion: zod_1.z.string(),
+        capabilities: zod_1.z.object({}).passthrough()
+    })
+});
+const InitializedNotificationSchema = zod_1.z.object({
+    method: zod_1.z.literal('notifications/initialized'),
+    params: zod_1.z.object({}).optional()
+});
 class CelliumMCPClient {
     config;
     localServer;
@@ -54,39 +65,100 @@ class CelliumMCPClient {
         this.setupServer();
     }
     setupServer() {
-        // Register a dynamic tool handler that forwards all tool calls to remote server
-        this.localServer.registerTool('cellium-proxy-tool', {
-            description: 'Proxy tool for Cellium server - handles all tool calls dynamically'
-        }, async (_args) => {
-            // This won't actually be called since we override the request handlers directly
-            return { content: [{ type: 'text', text: 'Proxy tool' }] };
+        // Handle MCP initialization
+        this.localServer.server.setRequestHandler(InitializeSchema, async (_request) => {
+            this.config.logger.debug('Received initialize request');
+            return {
+                protocolVersion: '2024-11-05',
+                capabilities: {
+                    tools: {},
+                    resources: {}
+                },
+                serverInfo: {
+                    name: 'cellium-mcp-client',
+                    version: '1.1.2'
+                }
+            };
         });
         // Override the underlying server's tool request handlers to proxy to remote
         this.localServer.server.setRequestHandler(ToolsListSchema, async () => {
-            this.config.logger.debug('Proxying tools/list to remote server');
-            const result = await this.makeHttpRequest('tools/list', {});
-            return result;
+            try {
+                this.config.logger.debug('Proxying tools/list to remote server');
+                const result = await this.makeHttpRequest('tools/list', {});
+                this.config.logger.debug({ result }, 'tools/list result from remote server');
+                return result;
+            }
+            catch (error) {
+                this.config.logger.error({ error }, 'Error proxying tools/list');
+                // Return empty tools list instead of throwing to prevent transport closure
+                return { tools: [] };
+            }
         });
         this.localServer.server.setRequestHandler(ToolsCallSchema, async (request) => {
-            this.config.logger.debug({ toolName: request.params?.name }, 'Proxying tool call to remote server');
-            const result = await this.makeHttpRequest('tools/call', request.params);
-            return result;
+            try {
+                this.config.logger.debug({ toolName: request.params?.name }, 'Proxying tool call to remote server');
+                const result = await this.makeHttpRequest('tools/call', request.params);
+                return result;
+            }
+            catch (error) {
+                this.config.logger.error({ error, toolName: request.params?.name }, 'Error proxying tool call');
+                // Return error result instead of throwing
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error calling tool: ${error instanceof Error ? error.message : 'Unknown error'}`
+                        }],
+                    isError: true
+                };
+            }
         });
         // Handle resources as well
         this.localServer.server.setRequestHandler(ResourcesListSchema, async () => {
-            this.config.logger.debug('Proxying resources/list to remote server');
-            const result = await this.makeHttpRequest('resources/list', {});
-            return result;
+            try {
+                this.config.logger.debug('Proxying resources/list to remote server');
+                const result = await this.makeHttpRequest('resources/list', {});
+                return result;
+            }
+            catch (error) {
+                this.config.logger.error({ error }, 'Error proxying resources/list');
+                // Return empty resources list instead of throwing
+                return { resources: [] };
+            }
         });
         this.localServer.server.setRequestHandler(ResourcesReadSchema, async (request) => {
-            this.config.logger.debug({ uri: request.params?.uri }, 'Proxying resources/read to remote server');
-            const result = await this.makeHttpRequest('resources/read', request.params);
-            return result;
+            try {
+                this.config.logger.debug({ uri: request.params?.uri }, 'Proxying resources/read to remote server');
+                const result = await this.makeHttpRequest('resources/read', request.params);
+                return result;
+            }
+            catch (error) {
+                this.config.logger.error({ error, uri: request.params?.uri }, 'Error proxying resources/read');
+                // Return error result instead of throwing
+                return {
+                    contents: [{
+                            uri: request.params?.uri || '',
+                            mimeType: 'text/plain',
+                            text: `Error reading resource: ${error instanceof Error ? error.message : 'Unknown error'}`
+                        }]
+                };
+            }
         });
         // Handle ping
         this.localServer.server.setRequestHandler(PingSchema, async () => {
-            const result = await this.makeHttpRequest('ping', {});
-            return result;
+            try {
+                const result = await this.makeHttpRequest('ping', {});
+                return result;
+            }
+            catch (error) {
+                this.config.logger.error({ error }, 'Error proxying ping');
+                // Return empty result instead of throwing
+                return {};
+            }
+        });
+        // Handle other common MCP methods
+        this.localServer.server.setNotificationHandler(InitializedNotificationSchema, async () => {
+            this.config.logger.debug('Received initialized notification');
+            // No response needed for notifications
         });
     }
     async makeHttpRequest(method, params) {

package/package.json

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