@blaxel/core 0.2.25 → 0.2.26

package/dist/mcp/client.d.ts

@@ -9,10 +9,17 @@ export declare class BlaxelMcpClientTransport implements Transport {
     private _url;
     private _headers;
     private _isBrowser;
+    private _retry_max;
+    private _retry_delay;
     onclose?: () => void;
     onerror?: (error: Error) => void;
     onmessage?: (message: JSONRPCMessage) => void;
-    constructor(url: string, headers?: Record<string, string>);
+    constructor(url: string, headers?: Record<string, string>, options?: {
+        retry: {
+            max?: number;
+            delay?: number;
+        };
+    });
     start(): Promise<void>;
     private _connect;
     get isConnected(): boolean;

package/dist/mcp/client.js

@@ -21,8 +21,6 @@ if (!isBrowser) {
     }
 }
 //const SUBPROTOCOL = "mcp";
-const MAX_RETRIES = 3;
-const RETRY_DELAY_MS = 1000;
 // Helper function to wait
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
@@ -34,11 +32,15 @@ class BlaxelMcpClientTransport {
     _url;
     _headers;
     _isBrowser;
+    _retry_max;
+    _retry_delay;
     onclose;
     onerror;
     onmessage;
-    constructor(url, headers) {
+    constructor(url, headers, options) {
         this._url = new URL(url.replace("http", "ws"));
+        this._retry_max = options?.retry?.max ?? 3;
+        this._retry_delay = options?.retry?.delay ?? 1000;
         this._headers = headers ?? {};
         this._isBrowser = isBrowser;
     }
@@ -47,21 +49,22 @@ class BlaxelMcpClientTransport {
             throw new Error("Blaxel already started! If using Client class, note that connect() calls start() automatically.");
         }
         let attempts = 0;
-        while (attempts < MAX_RETRIES) {
+        const maxAttempts = Math.max(1, this._retry_max + 1); // Ensure at least 1 attempt
+        while (attempts < maxAttempts) {
             try {
                 await this._connect();
                 return;
             }
             catch (error) {
+                attempts++;
                 if (error instanceof Error) {
                     logger_js_1.logger.warn(error.stack ?? error.message);
                 }
-                attempts++;
-                if (attempts === MAX_RETRIES) {
+                if (attempts >= maxAttempts) {
                     throw error;
                 }
-                logger_js_1.logger.debug(`WebSocket connection attempt ${attempts} failed, retrying in ${RETRY_DELAY_MS}ms...`);
-                await delay(RETRY_DELAY_MS);
+                logger_js_1.logger.debug(`WebSocket connection attempt ${attempts} failed, retrying in ${this._retry_delay}ms...`);
+                await delay(this._retry_delay);
             }
         }
     }
@@ -86,7 +89,25 @@ class BlaxelMcpClientTransport {
                     });
                 }
                 this._socket.onerror = (event) => {
-                    console.error(event);
+                    // Log websocket error with meaningful information instead of raw event
+                    const errorInfo = {
+                        type: 'WebSocket Error',
+                        url: this._url.toString(),
+                        readyState: this._socket?.readyState,
+                        browser: this._isBrowser,
+                        // Extract any available error details from the event
+                        eventType: event && typeof event === 'object' && 'type' in event
+                            ? String(event.type)
+                            : 'unknown',
+                        // Browser events might have different properties than Node.js
+                        message: this._isBrowser && event && typeof event === 'object' && 'message' in event
+                            ? String(event.message)
+                            : undefined,
+                        error: !this._isBrowser && event && typeof event === 'object' && 'error' in event
+                            ? String(event.error)
+                            : undefined
+                    };
+                    logger_js_1.logger.error('WebSocket connection error', errorInfo);
                     const error = this._isBrowser
                         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                         ? new Error(`WebSocket error: ${event.message}`)
@@ -174,7 +195,8 @@ class BlaxelMcpClientTransport {
     }
     async send(message) {
         let attempts = 0;
-        while (attempts < MAX_RETRIES) {
+        const maxAttempts = Math.max(1, this._retry_max + 1); // Ensure at least 1 attempt
+        while (attempts < maxAttempts) {
             try {
                 if (!this._socket || !this.isConnected) {
                     if (!this._socket) {
@@ -213,11 +235,11 @@ class BlaxelMcpClientTransport {
             }
             catch (error) {
                 attempts++;
-                if (attempts === MAX_RETRIES) {
+                if (attempts >= maxAttempts) {
                     throw error;
                 }
-                logger_js_1.logger.warn(`WebSocket send attempt ${attempts} failed, retrying in ${RETRY_DELAY_MS}ms...`);
-                await delay(RETRY_DELAY_MS);
+                logger_js_1.logger.warn(`WebSocket send attempt ${attempts} failed, retrying in ${this._retry_delay}ms...`);
+                await delay(this._retry_delay);
             }
         }
     }

package/dist/tools/mcpTool.js

@@ -74,13 +74,18 @@ class McpTool {
             await (0, index_js_2.authenticate)();
             try {
                 logger_js_1.logger.debug(`MCP:${this.name}:Connecting::${this.url.toString()}`);
-                this.transport = new client_js_1.BlaxelMcpClientTransport(this.url.toString(), settings_js_1.settings.headers);
+                this.transport = new client_js_1.BlaxelMcpClientTransport(this.url.toString(), settings_js_1.settings.headers, { retry: { max: 0 } });
                 await this.client.connect(this.transport);
                 logger_js_1.logger.debug(`MCP:${this.name}:Connected`);
             }
             catch (err) {
                 if (err instanceof Error) {
-                    logger_js_1.logger.error(err.stack);
+                    logger_js_1.logger.error(`MCP ${this.name} connection failed: ${err.message}`, {
+                        error: err.message,
+                        stack: err.stack,
+                        mcpName: this.name,
+                        url: this.url
+                    });
                 }
                 if (!this.fallbackUrl) {
                     throw err;
@@ -107,7 +112,11 @@ class McpTool {
             delete this.startPromise;
             this.client.close().catch((err) => {
                 if (err instanceof Error) {
-                    logger_js_1.logger.error(err.stack);
+                    logger_js_1.logger.error(`MCP ${this.name} close failed: ${err.message}`, {
+                        error: err.message,
+                        stack: err.stack,
+                        mcpName: this.name
+                    });
                 }
             });
         }, now ? 0 : this.ms);
@@ -178,7 +187,13 @@ class McpTool {
         }
         catch (err) {
             if (err instanceof Error) {
-                logger_js_1.logger.error(err.stack);
+                logger_js_1.logger.error(`MCP tool call failed: ${err.message}`, {
+                    error: err.message,
+                    stack: err.stack,
+                    mcpName: this.name,
+                    toolName,
+                    args: JSON.stringify(args)
+                });
             }
             throw err;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.25",
+  "version": "0.2.26",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",