cellium-mcp-client 2.0.8 → 2.0.10

package/dist/client.d.ts

@@ -31,6 +31,11 @@ export declare class CelliumMCPClient {
     private setupServer;
     private getSafeErrorResponse;
     private makeHttpRequest;
+    private getErrorStatusCode;
+    private createClassifiedRequestError;
+    private extractBackendReason;
+    private classifyDenialCondition;
+    private getSafeDeniedMessage;
     connect(): Promise<void>;
     private setupTransportEventListeners;
     serve(): Promise<void>;

package/dist/client.js

@@ -307,6 +307,12 @@ class CelliumMCPClient {
     }
     getSafeErrorResponse(methodName, error) {
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        const classification = this.classifyDenialCondition({
+            statusCode: this.getErrorStatusCode(error),
+            message: errorMessage
+        });
+        const safeDeniedMessage = this.getSafeDeniedMessage(classification, errorMessage);
+        const responseErrorMessage = classification.isDenial ? safeDeniedMessage : errorMessage;
         switch (methodName) {
             case 'tools/list':
                 return { tools: [] };
@@ -316,7 +322,7 @@ class CelliumMCPClient {
                 return {
                     content: [{
                             type: 'text',
-                            text: `Error calling tool: ${errorMessage}`
+                            text: `Error calling tool: ${safeDeniedMessage}`
                         }],
                     isError: true
                 };
@@ -325,13 +331,13 @@ class CelliumMCPClient {
                     contents: [{
                             uri: '',
                             mimeType: 'text/plain',
-                            text: `Error reading resource: ${errorMessage}`
+                            text: `Error reading resource: ${safeDeniedMessage}`
                         }]
                 };
             case 'ping':
                 return {};
             default:
-                return { error: errorMessage };
+                return { error: responseErrorMessage };
         }
     }
     async makeHttpRequest(method, params) {
@@ -409,7 +415,19 @@ class CelliumMCPClient {
                 duration
             });
             if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                const classification = this.classifyDenialCondition({
+                    statusCode: response.status,
+                    message: response.statusText,
+                    responseText
+                });
+                const backendReason = this.extractBackendReason(responseText);
+                const safeMessage = this.getSafeDeniedMessage({ ...classification, reason: backendReason ?? classification.reason }, `HTTP ${response.status}: ${response.statusText}`);
+                throw this.createClassifiedRequestError(safeMessage, {
+                    statusCode: response.status,
+                    denialCategory: classification.category,
+                    denialReason: backendReason ?? classification.reason,
+                    rawResponseSnippet: responseText.substring(0, 1000)
+                });
             }
             let jsonResponse;
             try {
@@ -432,12 +450,30 @@ class CelliumMCPClient {
                 jsonrpcId: jsonResponse.id
             });
             if (jsonResponse.error) {
+                const classification = this.classifyDenialCondition({
+                    statusCode: response.status,
+                    message: jsonResponse.error?.message,
+                    responseText,
+                    remoteError: jsonResponse.error
+                });
+                const backendReason = this.extractBackendReason(jsonResponse.error) ?? this.extractBackendReason(responseText);
+                const safeMessage = this.getSafeDeniedMessage({ ...classification, reason: backendReason ?? classification.reason }, 'Remote server error');
                 this.config.logger.error({
                     requestId,
                     method,
-                    serverError: jsonResponse.error
+                    statusCode: response.status,
+                    serverError: jsonResponse.error,
+                    denialCategory: classification.category,
+                    denialReason: backendReason ?? classification.reason,
+                    rawResponseSnippet: responseText.substring(0, 1000)
                 }, 'Remote server returned error');
-                throw new Error(`Remote server error: ${jsonResponse.error.message}`);
+                throw this.createClassifiedRequestError(safeMessage, {
+                    statusCode: response.status,
+                    denialCategory: classification.category,
+                    denialReason: backendReason ?? classification.reason,
+                    rawResponseSnippet: responseText.substring(0, 1000),
+                    remoteError: jsonResponse.error
+                });
             }
             // Mark as connected on first successful response for http-stream endpoints
             if (!this.isConnected && this.config.endpoint.includes('/http-stream')) {
@@ -449,6 +485,7 @@ class CelliumMCPClient {
         }
         catch (error) {
             const duration = Date.now() - startTime;
+            const classifiedError = error;
             this.config.logger.error({
                 error: error instanceof Error ? {
                     name: error.name,
@@ -458,12 +495,107 @@ class CelliumMCPClient {
                 requestId,
                 method,
                 duration,
-                endpoint: endpoint
+                endpoint: endpoint,
+                statusCode: classifiedError?.statusCode,
+                denialCategory: classifiedError?.denialCategory,
+                denialReason: classifiedError?.denialReason,
+                rawResponseSnippet: classifiedError?.rawResponseSnippet,
+                remoteError: classifiedError?.remoteError
             }, 'HTTP request to remote server failed');
             this.isConnected = false; // Mark as disconnected on error
             throw error;
         }
     }
+    getErrorStatusCode(error) {
+        if (!error || typeof error !== 'object') {
+            return undefined;
+        }
+        const possibleStatus = error.statusCode;
+        return typeof possibleStatus === 'number' ? possibleStatus : undefined;
+    }
+    createClassifiedRequestError(message, details) {
+        const classifiedError = new Error(message);
+        Object.assign(classifiedError, details);
+        return classifiedError;
+    }
+    extractBackendReason(input) {
+        if (!input) {
+            return undefined;
+        }
+        const normalize = (value) => {
+            if (typeof value !== 'string') {
+                return undefined;
+            }
+            const trimmed = value.trim();
+            return trimmed.length > 0 ? trimmed.substring(0, 300) : undefined;
+        };
+        if (typeof input === 'string') {
+            const direct = normalize(input);
+            if (direct) {
+                try {
+                    const parsed = JSON.parse(input);
+                    return normalize(parsed?.error?.message)
+                        ?? normalize(parsed?.error?.data?.reason)
+                        ?? normalize(parsed?.error?.data?.message)
+                        ?? normalize(parsed?.message)
+                        ?? normalize(parsed?.reason)
+                        ?? direct;
+                }
+                catch {
+                    return direct;
+                }
+            }
+            return undefined;
+        }
+        if (typeof input === 'object') {
+            const value = input;
+            return normalize(value?.error?.message)
+                ?? normalize(value?.error?.data?.reason)
+                ?? normalize(value?.error?.data?.message)
+                ?? normalize(value?.message)
+                ?? normalize(value?.reason)
+                ?? normalize(value?.detail)
+                ?? normalize(value?.error_description);
+        }
+        return undefined;
+    }
+    classifyDenialCondition(params) {
+        const backendReason = this.extractBackendReason(params.remoteError)
+            ?? this.extractBackendReason(params.responseText)
+            ?? this.extractBackendReason(params.message);
+        const text = `${params.message ?? ''} ${params.responseText ?? ''} ${backendReason ?? ''}`.toLowerCase();
+        const statusCode = params.statusCode;
+        const hasSessionPattern = /(session|concurrent|too many.*session|max.*session)/i.test(text);
+        const hasQuotaPattern = /(quota|rate.?limit|too many requests|credit|usage.*limit|limit exceeded)/i.test(text);
+        const hasPermissionPattern = /(forbidden|access denied|permission denied|insufficient permissions?|not authorized|not allowed|requires? (?:a )?(?:higher )?(?:plan|tier|subscription)|upgrade (?:your )?(?:plan|subscription)|subscription (?:required|inactive|expired)|plan (?:required|does not include)|tier (?:required|does not include))/i.test(text);
+        const hasAuthPattern = /(unauthorized|invalid token|expired token|authentication|auth failed|bearer)/i.test(text);
+        if (statusCode === 401 || hasAuthPattern) {
+            return { isDenial: true, category: 'auth', reason: backendReason, statusCode };
+        }
+        if (hasSessionPattern) {
+            return { isDenial: true, category: 'session_limit', reason: backendReason, statusCode };
+        }
+        if (statusCode === 429 || hasQuotaPattern) {
+            return { isDenial: true, category: 'quota', reason: backendReason, statusCode };
+        }
+        if (statusCode === 403 || hasPermissionPattern) {
+            return { isDenial: true, category: 'permission_tier', reason: backendReason, statusCode };
+        }
+        return { isDenial: false, reason: backendReason, statusCode };
+    }
+    getSafeDeniedMessage(classification, fallbackMessage) {
+        if (!classification.isDenial) {
+            return fallbackMessage;
+        }
+        const categoryLabel = {
+            auth: 'authentication failed',
+            session_limit: 'session limit reached',
+            permission_tier: 'permission or subscription tier restriction',
+            quota: 'quota or rate limit exceeded'
+        };
+        const prefix = categoryLabel[classification.category];
+        return `Request denied (${prefix})`;
+    }
     async connect() {
         try {
             const transportMode = this.config.useStdio ? 'stdio' : 'http-streaming';
@@ -658,12 +790,55 @@ class CelliumMCPClient {
             statusText: response.statusText,
             duration
         });
+        const responseText = await response.text();
         if (!response.ok) {
-            throw new Error(`Connection test failed: HTTP ${response.status}`);
+            const classification = this.classifyDenialCondition({
+                statusCode: response.status,
+                message: response.statusText,
+                responseText
+            });
+            const backendReason = this.extractBackendReason(responseText);
+            const safeMessage = this.getSafeDeniedMessage({ ...classification, reason: backendReason ?? classification.reason }, `HTTP ${response.status}: ${response.statusText}`);
+            this.config.logger.error({
+                statusCode: response.status,
+                statusText: response.statusText,
+                denialCategory: classification.category,
+                denialReason: backendReason ?? classification.reason,
+                rawResponseSnippet: responseText.substring(0, 1000)
+            }, 'Connection test received non-OK response');
+            throw new Error(`Connection test failed: ${safeMessage}`);
+        }
+        let result;
+        try {
+            result = JSON.parse(responseText);
+        }
+        catch (parseError) {
+            this.config.logger.error({
+                statusCode: response.status,
+                parseError: parseError instanceof Error ? parseError.message : parseError,
+                rawResponseSnippet: responseText.substring(0, 1000)
+            }, 'Connection test response was not valid JSON');
+            throw new Error('Connection test failed: Invalid JSON response from server');
         }
-        const result = await response.json();
         if (result.error) {
-            throw new Error(`Connection test failed: ${result.error.message}`);
+            const backendReason = this.extractBackendReason(result.error) ?? this.extractBackendReason(responseText);
+            const rawErrorMessage = backendReason
+                ?? (typeof result.error?.message === 'string' ? result.error.message : 'Remote server error');
+            const classification = this.classifyDenialCondition({
+                statusCode: response.status,
+                message: rawErrorMessage,
+                responseText,
+                remoteError: result.error
+            });
+            const safeMessage = this.getSafeDeniedMessage({ ...classification, reason: backendReason ?? classification.reason }, 'Remote server returned an error during startup');
+            this.config.logger.error({
+                statusCode: response.status,
+                denialCategory: classification.category,
+                denialReason: backendReason ?? classification.reason,
+                remoteError: result.error,
+                rawResponseSnippet: responseText.substring(0, 1000)
+            }, 'Connection test returned JSON-RPC error');
+            throw new Error(`Connection test failed: ${safeMessage}`);
         }
         this.config.logger.debug({ duration }, 'Connection test successful');
     }

package/package.json

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