@blaxel/core 0.2.25-dev.175 → 0.2.25-preview.56

package/dist/mcp/client.d.ts

@@ -9,17 +9,10 @@ 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>, options?: {
-        retry: {
-            max?: number;
-            delay?: number;
-        };
-    });
+    constructor(url: string, headers?: Record<string, string>);
     start(): Promise<void>;
     private _connect;
     get isConnected(): boolean;

package/dist/mcp/client.js

@@ -21,6 +21,8 @@ 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));
 /**
@@ -32,15 +34,11 @@ class BlaxelMcpClientTransport {
     _url;
     _headers;
     _isBrowser;
-    _retry_max;
-    _retry_delay;
     onclose;
     onerror;
     onmessage;
-    constructor(url, headers, options) {
+    constructor(url, headers) {
         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;
     }
@@ -49,22 +47,21 @@ class BlaxelMcpClientTransport {
             throw new Error("Blaxel already started! If using Client class, note that connect() calls start() automatically.");
         }
         let attempts = 0;
-        const maxAttempts = Math.max(1, this._retry_max + 1); // Ensure at least 1 attempt
-        while (attempts < maxAttempts) {
+        while (attempts < MAX_RETRIES) {
             try {
                 await this._connect();
                 return;
             }
             catch (error) {
-                attempts++;
                 if (error instanceof Error) {
                     logger_js_1.logger.warn(error.stack ?? error.message);
                 }
-                if (attempts >= maxAttempts) {
+                attempts++;
+                if (attempts === MAX_RETRIES) {
                     throw error;
                 }
-                logger_js_1.logger.debug(`WebSocket connection attempt ${attempts} failed, retrying in ${this._retry_delay}ms...`);
-                await delay(this._retry_delay);
+                logger_js_1.logger.debug(`WebSocket connection attempt ${attempts} failed, retrying in ${RETRY_DELAY_MS}ms...`);
+                await delay(RETRY_DELAY_MS);
             }
         }
     }
@@ -89,25 +86,7 @@ class BlaxelMcpClientTransport {
                     });
                 }
                 this._socket.onerror = (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);
+                    console.error(event);
                     const error = this._isBrowser
                         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                         ? new Error(`WebSocket error: ${event.message}`)
@@ -195,8 +174,7 @@ class BlaxelMcpClientTransport {
     }
     async send(message) {
         let attempts = 0;
-        const maxAttempts = Math.max(1, this._retry_max + 1); // Ensure at least 1 attempt
-        while (attempts < maxAttempts) {
+        while (attempts < MAX_RETRIES) {
             try {
                 if (!this._socket || !this.isConnected) {
                     if (!this._socket) {
@@ -235,11 +213,11 @@ class BlaxelMcpClientTransport {
             }
             catch (error) {
                 attempts++;
-                if (attempts >= maxAttempts) {
+                if (attempts === MAX_RETRIES) {
                     throw error;
                 }
-                logger_js_1.logger.warn(`WebSocket send attempt ${attempts} failed, retrying in ${this._retry_delay}ms...`);
-                await delay(this._retry_delay);
+                logger_js_1.logger.warn(`WebSocket send attempt ${attempts} failed, retrying in ${RETRY_DELAY_MS}ms...`);
+                await delay(RETRY_DELAY_MS);
             }
         }
     }

package/dist/sandbox/action.js

@@ -66,10 +66,8 @@ class SandboxAction {
         return (0, internal_js_1.getForcedUrl)('sandbox', this.name);
     }
     get url() {
-        if (this.forcedUrl) {
-            const url = this.forcedUrl.toString();
-            return url.endsWith('/') ? url.slice(0, -1) : url;
-        }
+        if (this.forcedUrl)
+            return this.forcedUrl.toString();
         // Uncomment and use this when agent and mcp are available in mk3
         // Update all requests made in this package to use fallbackUrl when internalUrl is not working
         // if (settings.runInternalHostname) return this.internalUrl;

package/dist/sandbox/sandbox.js

@@ -37,40 +37,9 @@ class SandboxInstance {
     get spec() {
         return this.sandbox.spec;
     }
+    /* eslint-disable */
     async wait({ maxWait = 60000, interval = 1000 } = {}) {
-        const startTime = Date.now();
-        while (this.sandbox.status !== "DEPLOYED") {
-            await new Promise((resolve) => setTimeout(resolve, interval));
-            try {
-                const { data } = await (0, index_js_1.getSandbox)({
-                    path: {
-                        sandboxName: this.sandbox.metadata?.name ?? "",
-                    },
-                    throwOnError: true,
-                });
-                logger_js_1.logger.debug(`Waiting for sandbox to be deployed, status: ${data.status}`);
-                this.sandbox = data;
-            }
-            catch (e) {
-                logger_js_1.logger.error("Could not retrieve sandbox", e);
-            }
-            if (this.sandbox.status === "FAILED") {
-                throw new Error("Sandbox failed to deploy");
-            }
-            if (Date.now() - startTime > maxWait) {
-                throw new Error("Sandbox did not deploy in time");
-            }
-        }
-        if (this.sandbox.status === "DEPLOYED") {
-            try {
-                // This is a hack for sometime receiving a 502,
-                // need to remove this once we have a better way to handle this
-                await this.fs.ls("/");
-            }
-            catch {
-                // pass
-            }
-        }
+        logger_js_1.logger.warn("⚠️  Warning: sandbox.wait() is deprecated. You don't need to wait for the sandbox to be deployed anymore.");
         return this;
     }
     static async create(sandbox) {
@@ -119,7 +88,10 @@ class SandboxInstance {
             body: sandbox,
             throwOnError: true,
         });
-        return new SandboxInstance(data);
+        const instance = new SandboxInstance(data);
+        // TODO remove this part once we have a better way to handle this
+        // await instance.fs.ls('/')
+        return instance;
     }
     static async get(sandboxName) {
         const { data } = await (0, index_js_1.getSandbox)({
@@ -145,16 +117,16 @@ class SandboxInstance {
     }
     static async createIfNotExists(sandbox) {
         try {
-            const name = 'name' in sandbox ? sandbox.name : sandbox.metadata?.name;
-            if (!name) {
-                throw new Error("Sandbox name is required");
-            }
-            const sandboxInstance = await SandboxInstance.get(name);
-            return sandboxInstance;
+            return await SandboxInstance.create(sandbox);
         }
         catch (e) {
-            if (typeof e === "object" && e !== null && "code" in e && e.code === 404) {
-                return SandboxInstance.create(sandbox);
+            if (typeof e === "object" && e !== null && "code" in e && (e.code === 409 || e.code === 'SANDBOX_ALREADY_EXISTS')) {
+                const name = 'name' in sandbox ? sandbox.name : sandbox.metadata?.name;
+                if (!name) {
+                    throw new Error("Sandbox name is required");
+                }
+                const sandboxInstance = await SandboxInstance.get(name);
+                return sandboxInstance;
             }
             throw e;
         }

package/dist/tools/mcpTool.js

@@ -74,18 +74,13 @@ 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, { retry: { max: 0 } });
+                this.transport = new client_js_1.BlaxelMcpClientTransport(this.url.toString(), settings_js_1.settings.headers);
                 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(`MCP ${this.name} connection failed: ${err.message}`, {
-                        error: err.message,
-                        stack: err.stack,
-                        mcpName: this.name,
-                        url: this.url
-                    });
+                    logger_js_1.logger.error(err.stack);
                 }
                 if (!this.fallbackUrl) {
                     throw err;
@@ -112,11 +107,7 @@ class McpTool {
             delete this.startPromise;
             this.client.close().catch((err) => {
                 if (err instanceof Error) {
-                    logger_js_1.logger.error(`MCP ${this.name} close failed: ${err.message}`, {
-                        error: err.message,
-                        stack: err.stack,
-                        mcpName: this.name
-                    });
+                    logger_js_1.logger.error(err.stack);
                 }
             });
         }, now ? 0 : this.ms);
@@ -187,13 +178,7 @@ class McpTool {
         }
         catch (err) {
             if (err instanceof Error) {
-                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)
-                });
+                logger_js_1.logger.error(err.stack);
             }
             throw err;
         }

package/package.json

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