@blaxel/core 0.2.33 → 0.2.35-preview.78

package/dist/common/settings.d.ts

@@ -7,6 +7,7 @@ export type Config = {
 declare class Settings {
     credentials: Credentials;
     config: Config;
+    private _version;
     constructor();
     setConfig(config: Config): void;
     get env(): string;
@@ -15,6 +16,7 @@ declare class Settings {
     get workspace(): string;
     get authorization(): string;
     get token(): string;
+    get version(): string;
     get headers(): Record<string, string>;
     get name(): string;
     get type(): string;

package/dist/common/settings.js

@@ -3,9 +3,74 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.settings = void 0;
 const index_js_1 = require("../authentication/index.js");
 const env_js_1 = require("../common/env.js");
+// Function to get package version
+function getPackageVersion() {
+    try {
+        // Try to require package.json (Node.js only, gracefully fails in browser)
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const packageJson = {"version":"0.2.35-preview.78","commit":"cb365d439aca12c16cca6b102c2a800d351e6f0c"};
+        return packageJson.version || "unknown";
+    }
+    catch {
+        // Fallback for browser environments or if require fails
+        return "unknown";
+    }
+}
+// Function to get OS and architecture
+function getOsArch() {
+    try {
+        // Node.js environment
+        if (typeof process !== 'undefined' && process.platform && process.arch) {
+            const platform = process.platform === 'win32' ? 'windows' :
+                process.platform === 'darwin' ? 'darwin' :
+                    process.platform === 'linux' ? 'linux' : process.platform;
+            return `${platform}/${process.arch}`;
+        }
+    }
+    catch {
+        // Fall through to browser detection
+    }
+    // Browser environment - use fixed detection
+    try {
+        // @ts-ignore - navigator is available in browser environments
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (typeof navigator !== 'undefined' && navigator?.platform) {
+            // @ts-ignore - navigator.platform is available in browser environments
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            const navPlatform = navigator.platform.toLowerCase();
+            const platform = navPlatform.includes('win') ? 'windows' :
+                navPlatform.includes('mac') ? 'darwin' :
+                    navPlatform.includes('linux') ? 'linux' : 'browser';
+            const arch = navPlatform.includes('64') ? 'amd64' : 'unknown';
+            return `${platform}/${arch}`;
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return "browser/unknown";
+}
+// Function to get commit hash
+function getCommitHash() {
+    try {
+        // Try to require package.json and look for commit field (set during build)
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const packageJson = {"version":"0.2.35-preview.78","commit":"cb365d439aca12c16cca6b102c2a800d351e6f0c"};
+        // Check for commit in various possible locations
+        const commit = packageJson.commit || packageJson.buildInfo?.commit;
+        if (commit) {
+            return commit.length > 7 ? commit.substring(0, 7) : commit;
+        }
+    }
+    catch {
+        // Fallback for browser environments or if require fails
+    }
+    return "unknown";
+}
 class Settings {
     credentials;
     config;
+    _version = null;
     constructor() {
         this.credentials = (0, index_js_1.authentication)();
         this.config = {
@@ -59,10 +124,19 @@ class Settings {
         }
         return this.credentials.token;
     }
+    get version() {
+        if (this._version === null) {
+            this._version = getPackageVersion();
+        }
+        return this._version;
+    }
     get headers() {
+        const osArch = getOsArch();
+        const commitHash = getCommitHash();
         return {
             "x-blaxel-authorization": this.authorization,
             "x-blaxel-workspace": this.workspace || "",
+            "User-Agent": `blaxel/sdk/typescript/${this.version} (${osArch}) blaxel/${commitHash}`,
         };
     }
     get name() {

package/dist/index.d.ts

@@ -14,3 +14,4 @@ export * from "./sandbox/index.js";
 export * from "./telemetry/telemetry.js";
 export * from "./tools/index.js";
 export * from "./tools/types.js";
+export * from "./volume/index.js";

package/dist/index.js

@@ -30,3 +30,4 @@ __exportStar(require("./sandbox/index.js"), exports);
 __exportStar(require("./telemetry/telemetry.js"), exports);
 __exportStar(require("./tools/index.js"), exports);
 __exportStar(require("./tools/types.js"), exports);
+__exportStar(require("./volume/index.js"), exports);

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/sandbox/action.js

@@ -66,8 +66,10 @@ class SandboxAction {
         return (0, internal_js_1.getForcedUrl)('sandbox', this.name);
     }
     get url() {
-        if (this.forcedUrl)
-            return this.forcedUrl.toString();
+        if (this.forcedUrl) {
+            const url = this.forcedUrl.toString();
+            return url.endsWith('/') ? url.slice(0, -1) : url;
+        }
         // 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/client/types.gen.js

@@ -1,4 +1,3 @@
 "use strict";
-/* eslint-disable */
 // This file is auto-generated by @hey-api/openapi-ts
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sandbox/process/process.js

@@ -36,6 +36,9 @@ class SandboxProcess extends action_js_1.SandboxAction {
                     const lines = buffer.split(/\r?\n/);
                     buffer = lines.pop();
                     for (const line of lines) {
+                        if (line.startsWith("[keepalive]")) {
+                            continue;
+                        }
                         if (line.startsWith('stdout:')) {
                             options.onStdout?.(line.slice(7));
                             options.onLog?.(line.slice(7));
@@ -81,11 +84,8 @@ class SandboxProcess extends action_js_1.SandboxAction {
         this.handleResponseError(response, data, error);
         let result = data;
         // Handle wait_for_completion with parallel log streaming
-        if (shouldWaitForCompletion) {
-            let streamControl;
-            if (onLog) {
-                streamControl = this.streamLogs(result.pid, { onLog });
-            }
+        if (shouldWaitForCompletion && onLog) {
+            const streamControl = this.streamLogs(result.pid, { onLog });
             try {
                 // Wait for process completion
                 result = await this.wait(result.pid, { interval: 500, maxWait: 1000 * 60 * 60 });

package/dist/sandbox/sandbox.d.ts

@@ -4,7 +4,7 @@ import { SandboxNetwork } from "./network/index.js";
 import { SandboxPreviews } from "./preview.js";
 import { SandboxProcess } from "./process/index.js";
 import { SandboxSessions } from "./session.js";
-import { SandboxConfiguration, SandboxCreateConfiguration, SessionWithToken } from "./types.js";
+import { SandboxConfiguration, SandboxCreateConfiguration, SandboxUpdateMetadata, SessionWithToken } from "./types.js";
 export declare class SandboxInstance {
     private sandbox;
     fs: SandboxFileSystem;
@@ -16,15 +16,18 @@ export declare class SandboxInstance {
     get metadata(): import("../client/types.gen.js").Metadata | undefined;
     get status(): string | undefined;
     get events(): import("../client/types.gen.js").CoreEvents | undefined;
-    get spec(): import("../client/types.gen.js").CoreSpec | undefined;
+    get spec(): import("../client/types.gen.js").SandboxSpec | undefined;
     wait({ maxWait, interval }?: {
         maxWait?: number;
         interval?: number;
     }): Promise<this>;
-    static create(sandbox?: SandboxModel | SandboxCreateConfiguration): Promise<SandboxInstance>;
+    static create(sandbox?: SandboxModel | SandboxCreateConfiguration, { safe }?: {
+        safe?: boolean;
+    }): Promise<SandboxInstance>;
     static get(sandboxName: string): Promise<SandboxInstance>;
     static list(): Promise<SandboxInstance[]>;
     static delete(sandboxName: string): Promise<SandboxModel>;
+    static updateMetadata(sandboxName: string, metadata: SandboxUpdateMetadata): Promise<SandboxInstance>;
     static createIfNotExists(sandbox: SandboxModel | SandboxCreateConfiguration): Promise<SandboxInstance>;
     static fromSession(session: SessionWithToken): Promise<SandboxInstance>;
 }

package/dist/sandbox/sandbox.js

@@ -4,6 +4,7 @@ exports.SandboxInstance = void 0;
 const uuid_1 = require("uuid");
 const index_js_1 = require("../client/index.js");
 const logger_js_1 = require("../common/logger.js");
+const settings_js_1 = require("../common/settings.js");
 const index_js_2 = require("./filesystem/index.js");
 const index_js_3 = require("./network/index.js");
 const preview_js_1 = require("./preview.js");
@@ -37,48 +38,18 @@ 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) {
+    static async create(sandbox, { safe = true } = {}) {
+        const env = settings_js_1.settings.env;
         const defaultName = `sandbox-${(0, uuid_1.v4)().replace(/-/g, '').substring(0, 8)}`;
-        const defaultImage = "blaxel/prod-base:latest";
+        const defaultImage = `blaxel/${env}-base:latest`;
         const defaultMemory = 4096;
-        // Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports/envs keys
-        if (!sandbox || 'name' in sandbox || 'image' in sandbox || 'memory' in sandbox || 'ports' in sandbox || 'envs' in sandbox) {
+        // Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports/envs/volumes keys
+        if (!sandbox || 'name' in sandbox || 'image' in sandbox || 'memory' in sandbox || 'ports' in sandbox || 'envs' in sandbox || 'volumes' in sandbox) {
             if (!sandbox)
                 sandbox = {};
             if (!sandbox.name)
@@ -89,25 +60,37 @@ class SandboxInstance {
                 sandbox.memory = defaultMemory;
             const ports = (0, types_js_1.normalizePorts)(sandbox.ports);
             const envs = (0, types_js_1.normalizeEnvs)(sandbox.envs);
+            const volumes = (0, types_js_1.normalizeVolumes)(sandbox.volumes);
+            const ttl = sandbox.ttl;
+            const expires = sandbox.expires;
+            const region = sandbox.region;
             sandbox = {
                 metadata: { name: sandbox.name },
                 spec: {
+                    region: region,
                     runtime: {
                         image: sandbox.image,
                         memory: sandbox.memory,
                         ports: ports,
                         envs: envs,
-                        generation: "mk3"
-                    }
+                        generation: "mk3",
+                    },
+                    volumes: volumes
                 }
             };
+            if (ttl) {
+                sandbox.spec.runtime.ttl = ttl;
+            }
+            if (expires) {
+                sandbox.spec.runtime.expires = expires.toISOString();
+            }
         }
         sandbox = sandbox;
         if (!sandbox.metadata) {
-            sandbox.metadata = { name: crypto.randomUUID().replace(/-/g, '') };
+            sandbox.metadata = { name: defaultName };
         }
         if (!sandbox.spec) {
-            sandbox.spec = { runtime: { image: "blaxel/prod-base:latest" } };
+            sandbox.spec = { runtime: { image: defaultImage, memory: defaultMemory } };
         }
         if (!sandbox.spec.runtime) {
             sandbox.spec.runtime = { image: defaultImage, memory: defaultMemory };
@@ -119,7 +102,15 @@ 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
+        if (safe) {
+            try {
+                await instance.fs.ls('/');
+            }
+            catch { }
+        }
+        return instance;
     }
     static async get(sandboxName) {
         const { data } = await (0, index_js_1.getSandbox)({
@@ -143,18 +134,29 @@ class SandboxInstance {
         });
         return data;
     }
+    static async updateMetadata(sandboxName, metadata) {
+        const sandbox = await SandboxInstance.get(sandboxName);
+        const body = { ...sandbox.sandbox, metadata: { ...sandbox.metadata, ...metadata } };
+        const { data } = await (0, index_js_1.updateSandbox)({
+            path: { sandboxName },
+            body,
+            throwOnError: true,
+        });
+        const instance = new SandboxInstance(data);
+        return instance;
+    }
     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/sandbox/session.js

@@ -20,6 +20,7 @@ class SandboxSessions {
             spec: {
                 port: 443,
                 public: false,
+                expires: expiresAt.toISOString(),
                 requestHeaders: options.requestHeaders,
                 responseHeaders: options.responseHeaders,
             },
@@ -51,7 +52,7 @@ class SandboxSessions {
         // If no valid session exists, create a new one
         if (allSessions.length > 0) {
             sessionData = allSessions[0];
-            if (sessionData.expiresAt < threshold) {
+            if (new Date(sessionData.expiresAt) < threshold) {
                 await this.delete(sessionData.name);
                 sessionData = await this.create(options);
             }
@@ -69,6 +70,8 @@ class SandboxSessions {
             },
             throwOnError: true,
         });
+        if (data === null)
+            return [];
         return await Promise.all(data.filter((preview) => preview.metadata?.name?.includes("session-")).map(async (preview) => {
             const token = await this.getToken(preview.metadata?.name ?? "");
             return {

package/dist/sandbox/types.d.ts

@@ -1,4 +1,4 @@
-import { Port, Sandbox } from "../client/types.gen";
+import { Port, Sandbox, VolumeAttachment } from "../client/types.gen";
 import { PostProcessResponse, ProcessRequest } from "./client";
 export interface SessionCreateOptions {
     expiresAt?: Date;
@@ -15,20 +15,34 @@ export interface EnvVar {
     name: string;
     value: string;
 }
+export interface VolumeBinding {
+    name: string;
+    mountPath: string;
+    readOnly?: boolean;
+}
 export type SandboxConfiguration = {
     forceUrl?: string;
     headers?: Record<string, string>;
     params?: Record<string, string>;
 } & Sandbox;
+export type SandboxUpdateMetadata = {
+    labels?: Record<string, string>;
+    displayName?: string;
+};
 export type SandboxCreateConfiguration = {
     name?: string;
     image?: string;
     memory?: number;
     ports?: (Port | Record<string, any>)[];
     envs?: EnvVar[];
+    volumes?: (VolumeBinding | VolumeAttachment)[];
+    ttl?: string;
+    expires?: Date;
+    region?: string;
 };
 export declare function normalizePorts(ports?: (Port | Record<string, any>)[]): Port[] | undefined;
 export declare function normalizeEnvs(envs?: EnvVar[]): EnvVar[] | undefined;
+export declare function normalizeVolumes(volumes?: (VolumeBinding | VolumeAttachment)[]): VolumeAttachment[] | undefined;
 export type ProcessRequestWithLog = ProcessRequest & {
     onLog?: (log: string) => void;
 };

package/dist/sandbox/types.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizePorts = normalizePorts;
 exports.normalizeEnvs = normalizeEnvs;
+exports.normalizeVolumes = normalizeVolumes;
 function normalizePorts(ports) {
     if (!ports || ports.length === 0) {
         return undefined;
@@ -50,3 +51,31 @@ function normalizeEnvs(envs) {
     }
     return envObjects;
 }
+function normalizeVolumes(volumes) {
+    if (!volumes || volumes.length === 0) {
+        return undefined;
+    }
+    const volumeObjects = [];
+    for (const volume of volumes) {
+        if (typeof volume === 'object' && volume !== null) {
+            // Validate that the object has the required keys
+            if (!('name' in volume) || !('mountPath' in volume)) {
+                throw new Error(`Volume binding object must have 'name' and 'mountPath' keys: ${JSON.stringify(volume)}`);
+            }
+            if (typeof volume.name !== 'string' || typeof volume.mountPath !== 'string') {
+                throw new Error(`Volume binding 'name' and 'mountPath' must be strings: ${JSON.stringify(volume)}`);
+            }
+            // Convert VolumeBinding to VolumeAttachment format
+            const volumeAttachment = {
+                name: volume.name,
+                mountPath: volume.mountPath,
+                readOnly: 'readOnly' in volume ? volume.readOnly : false
+            };
+            volumeObjects.push(volumeAttachment);
+        }
+        else {
+            throw new Error(`Invalid volume type: ${typeof volume}. Expected object with 'name' and 'mountPath' keys.`);
+        }
+    }
+    return volumeObjects;
+}

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/dist/volume/index.d.ts

@@ -0,0 +1,23 @@
+import { Volume } from "../client/index.js";
+export interface VolumeCreateConfiguration {
+    name?: string;
+    displayName?: string;
+    size?: number;
+    region?: string;
+}
+export declare class VolumeInstance {
+    private volume;
+    constructor(volume: Volume);
+    get metadata(): import("../client/types.gen.js").Metadata | undefined;
+    get spec(): import("../client/types.gen.js").VolumeSpec | undefined;
+    get status(): string | undefined;
+    get name(): string | undefined;
+    get displayName(): string | undefined;
+    get size(): number | undefined;
+    get region(): string | undefined;
+    static create(config: VolumeCreateConfiguration | Volume): Promise<VolumeInstance>;
+    static get(volumeName: string): Promise<VolumeInstance>;
+    static list(): Promise<VolumeInstance[]>;
+    static delete(volumeName: string): Promise<Volume>;
+    static createIfNotExists(config: VolumeCreateConfiguration | Volume): Promise<VolumeInstance>;
+}