@blaxel/core 0.2.50-dev.215 → 0.2.50-preview.115

package/dist/cjs-browser/authentication/clientcredentials.js

@@ -54,13 +54,10 @@ class ClientCredentials extends credentials_js_1.Credentials {
         }
         catch (error) {
             if (retry > 0) {
-                console.error(`Authentication failed, retrying... (${4 - retry}/3)`, error);
                 await this.sleep(1000);
                 return this.processWithRetry(retry - 1);
             }
-            this.currentPromise = null;
-            const originalMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Authentication failed after 4 attempts: ${originalMessage}`, { cause: error });
+            throw error;
         }
     }
     async process() {

package/dist/cjs-browser/common/internal.js

@@ -5,8 +5,6 @@ exports.getAlphanumericLimitedHash = getAlphanumericLimitedHash;
 exports.getGlobalUniqueHash = getGlobalUniqueHash;
 exports.pluralize = pluralize;
 exports.getForcedUrl = getForcedUrl;
-exports.getWorkloadTypeShort = getWorkloadTypeShort;
-exports.generateInternalUrl = generateInternalUrl;
 const env_js_1 = require("./env.js");
 // Pure JS MD5 implementation that matches standard crypto MD5
 function md5(input) {
@@ -188,41 +186,3 @@ function getForcedUrl(type, name) {
     }
     return null;
 }
-function getWorkloadTypeShort(type) {
-    const lowerType = type.toLowerCase();
-    switch (lowerType) {
-        case 'agent':
-        case 'agents':
-            return 'agt';
-        case 'mcp':
-        case 'mcps':
-        case 'function':
-        case 'functions':
-            return 'mcp';
-        case 'sandbox':
-        case 'sandboxes':
-            return 'sbx';
-        case 'job':
-        case 'jobs':
-            return 'job';
-        case 'model':
-        case 'models':
-            return 'mdl';
-        default:
-            // fallback to first 3 letters of type
-            return lowerType.substring(0, 3);
-    }
-}
-function generateInternalUrl(workspace, type, name, env, protocol, hostname, blCloud, workspaceId) {
-    if (blCloud && workspaceId) {
-        // New cloud format: bl-ENV-WORKLOAD_CALLED_NAME-WORKLOAD_TYPE_SHORT-WORKSPACE_ID
-        const workloadTypeShort = getWorkloadTypeShort(type);
-        const subdomain = `bl-${env}-${name}-${workloadTypeShort}-${workspaceId}`;
-        return `${protocol}://${subdomain}.${hostname}`;
-    }
-    else {
-        // Legacy format: bl-ENV-HASH.internalhostname
-        const hash = getGlobalUniqueHash(workspace, type, name);
-        return `${protocol}://bl-${env}-${hash}.${hostname}`;
-    }
-}

package/dist/cjs-browser/common/settings.js

@@ -10,7 +10,7 @@ function getPackageVersion() {
         if (typeof require !== "undefined") {
             // 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.50-dev.215","commit":"833c34cbba3735060a62bdd3594fa917160f3d3c"};
+            const packageJson = {"version":"0.2.50-preview.115","commit":"a4290fe191702ee91d8ae3fcc45c094d86be553c"};
             return packageJson.version || "unknown";
         }
         else {
@@ -62,7 +62,7 @@ function getCommitHash() {
         if (typeof require !== "undefined") {
             // 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.50-dev.215","commit":"833c34cbba3735060a62bdd3594fa917160f3d3c"};
+            const packageJson = {"version":"0.2.50-preview.115","commit":"a4290fe191702ee91d8ae3fcc45c094d86be553c"};
             // Check for commit in various possible locations
             const commit = packageJson.commit || packageJson.buildInfo?.commit;
             if (commit) {
@@ -165,9 +165,6 @@ class Settings {
     get blCloud() {
         return env_js_1.env.BL_CLOUD === "true";
     }
-    get workspaceId() {
-        return env_js_1.env.BL_WORKSPACE_ID || "";
-    }
     get generation() {
         return env_js_1.env.BL_GENERATION || "";
     }

package/dist/cjs-browser/jobs/jobs.js

@@ -20,8 +20,8 @@ class BlJob {
         return new URL(`${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/jobs/${this.jobName}`);
     }
     get internalUrl() {
-        const url = (0, internal_js_1.generateInternalUrl)(settings_js_1.settings.workspace, "job", this.jobName, settings_js_1.settings.env, settings_js_1.settings.runInternalProtocol, settings_js_1.settings.runInternalHostname, settings_js_1.settings.blCloud, settings_js_1.settings.workspaceId);
-        return new URL(url);
+        const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, "job", this.jobName);
+        return new URL(`${settings_js_1.settings.runInternalProtocol}://bl-${settings_js_1.settings.env}-${hash}.${settings_js_1.settings.runInternalHostname}`);
     }
     get forcedUrl() {
         return (0, internal_js_1.getForcedUrl)('job', this.jobName);

package/dist/cjs-browser/jobs/start.js

@@ -5,43 +5,12 @@ const autoload_js_1 = require("../common/autoload.js");
 const env_js_1 = require("../common/env.js");
 const telemetry_js_1 = require("../telemetry/telemetry.js");
 class BlJobWrapper {
-    async fetchWithRetry(url, maxRetries = 3) {
-        let lastError;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                const response = await fetch(url);
-                // If the response is successful, return it
-                if (response.ok) {
-                    return response;
-                }
-                // If it's not the last attempt and the status is retriable, retry
-                if (attempt < maxRetries && (response.status >= 500 || response.status === 429)) {
-                    lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
-                }
-                else {
-                    // For non-retriable errors or last attempt, return the response
-                    return response;
-                }
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                // If this is the last attempt, throw the error
-                if (attempt === maxRetries) {
-                    throw lastError;
-                }
-            }
-            // Calculate exponential backoff delay: 2^attempt * 1000ms (1s, 2s, 4s)
-            const delay = Math.pow(2, attempt) * 1000;
-            await new Promise(resolve => setTimeout(resolve, delay));
-        }
-        throw lastError || new Error('Failed to fetch after retries');
-    }
     async getArguments() {
         if (!env_js_1.env.BL_EXECUTION_DATA_URL) {
             const args = this.parseCommandLineArgs();
             return args;
         }
-        const response = await this.fetchWithRetry(env_js_1.env.BL_EXECUTION_DATA_URL);
+        const response = await fetch(env_js_1.env.BL_EXECUTION_DATA_URL);
         const data = await response.json();
         return data.tasks[this.index] ?? {};
     }

package/dist/cjs-browser/sandbox/action.js

@@ -48,7 +48,8 @@ class SandboxAction {
         return this.sandbox.metadata?.url ?? `${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/sandboxes/${this.name}`;
     }
     get internalUrl() {
-        return (0, internal_js_1.generateInternalUrl)(settings_js_1.settings.workspace, "sandbox", this.name, settings_js_1.settings.env, settings_js_1.settings.runInternalProtocol, settings_js_1.settings.runInternalHostname, settings_js_1.settings.blCloud, settings_js_1.settings.workspaceId);
+        const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, "sandbox", this.name);
+        return `${settings_js_1.settings.runInternalProtocol}://bl-${settings_js_1.settings.env}-${hash}.${settings_js_1.settings.runInternalHostname}`;
     }
     get client() {
         if (this.sandbox.forceUrl) {

package/dist/cjs-browser/sandbox/sandbox.js

@@ -5,16 +5,11 @@ const uuid_1 = require("uuid");
 const index_js_1 = require("../client/index.js");
 const logger_js_1 = require("../common/logger.js");
 const index_js_2 = require("./filesystem/index.js");
-const filesystem_ws_js_1 = require("./filesystem/filesystem-ws.js");
 const index_js_3 = require("./network/index.js");
-const network_ws_js_1 = require("./network/network-ws.js");
 const preview_js_1 = require("./preview.js");
 const index_js_4 = require("./process/index.js");
-const process_ws_js_1 = require("./process/process-ws.js");
 const index_js_5 = require("./codegen/index.js");
-const codegen_ws_js_1 = require("./codegen/codegen-ws.js");
 const session_js_1 = require("./session.js");
-const index_js_6 = require("./websocket/index.js");
 const types_js_1 = require("./types.js");
 class SandboxInstance {
     sandbox;
@@ -24,32 +19,14 @@ class SandboxInstance {
     previews;
     sessions;
     codegen;
-    wsClient;
     constructor(sandbox) {
         this.sandbox = sandbox;
-        // If connection type is websocket, initialize WebSocket client and use WebSocket transport layers
-        if (sandbox.connectionType === "websocket") {
-            const url = sandbox.forceUrl || sandbox.metadata?.url || "";
-            this.wsClient = new index_js_6.WebSocketClient({
-                url,
-                headers: sandbox.headers,
-            });
-            // Initialize WebSocket-based action handlers
-            this.process = new process_ws_js_1.SandboxProcessWebSocket(sandbox, this.wsClient);
-            this.fs = new filesystem_ws_js_1.SandboxFileSystemWebSocket(sandbox, this.process, this.wsClient);
-            this.network = new network_ws_js_1.SandboxNetworkWebSocket(sandbox, this.wsClient);
-            this.codegen = new codegen_ws_js_1.SandboxCodegenWebSocket(sandbox, this.wsClient);
-        }
-        else {
-            // Default to HTTP-based action handlers
-            this.process = new index_js_4.SandboxProcess(sandbox);
-            this.fs = new index_js_2.SandboxFileSystem(sandbox, this.process);
-            this.network = new index_js_3.SandboxNetwork(sandbox);
-            this.codegen = new index_js_5.SandboxCodegen(sandbox);
-        }
-        // These are always HTTP-based
+        this.process = new index_js_4.SandboxProcess(sandbox);
+        this.fs = new index_js_2.SandboxFileSystem(sandbox, this.process);
+        this.network = new index_js_3.SandboxNetwork(sandbox);
         this.previews = new preview_js_1.SandboxPreviews(sandbox);
         this.sessions = new session_js_1.SandboxSessions(sandbox);
+        this.codegen = new index_js_5.SandboxCodegen(sandbox);
     }
     get metadata() {
         return this.sandbox.metadata;
@@ -68,17 +45,10 @@ class SandboxInstance {
         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;
     }
-    closeConnection() {
-        if (this.wsClient) {
-            this.wsClient.close();
-        }
-    }
     static async create(sandbox, { safe = true } = {}) {
         const defaultName = `sandbox-${(0, uuid_1.v4)().replace(/-/g, '').substring(0, 8)}`;
         const defaultImage = `blaxel/base-image:latest`;
         const defaultMemory = 4096;
-        // Store connection type if provided
-        let connectionType;
         // Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports/envs/volumes keys
         if (!sandbox ||
             'name' in sandbox ||
@@ -88,8 +58,7 @@ class SandboxInstance {
             'envs' in sandbox ||
             'volumes' in sandbox ||
             'lifecycle' in sandbox ||
-            'snapshotEnabled' in sandbox ||
-            'connectionType' in sandbox) {
+            'snapshotEnabled' in sandbox) {
             if (!sandbox)
                 sandbox = {};
             if (!sandbox.name)
@@ -98,7 +67,6 @@ class SandboxInstance {
                 sandbox.image = defaultImage;
             if (!sandbox.memory)
                 sandbox.memory = defaultMemory;
-            connectionType = sandbox.connectionType;
             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);
@@ -147,16 +115,7 @@ class SandboxInstance {
             body: sandbox,
             throwOnError: true,
         });
-        // Add connection type to configuration
-        const config = {
-            ...data,
-            connectionType: connectionType || "http",
-        };
-        const instance = new SandboxInstance(config);
-        // Connect WebSocket if needed
-        if (connectionType === "websocket" && instance.wsClient) {
-            await instance.wsClient.connect();
-        }
+        const instance = new SandboxInstance(data);
         // TODO remove this part once we have a better way to handle this
         if (safe) {
             try {
@@ -166,34 +125,20 @@ class SandboxInstance {
         }
         return instance;
     }
-    static async get(sandboxName, connectionType) {
+    static async get(sandboxName) {
         const { data } = await (0, index_js_1.getSandbox)({
             path: {
                 sandboxName,
             },
             throwOnError: true,
         });
-        // Add connection type to configuration
-        const config = {
-            ...data,
-            connectionType: connectionType || "http",
-        };
-        const instance = new SandboxInstance(config);
-        // Connect WebSocket if needed
-        if (connectionType === "websocket" && instance.wsClient) {
-            await instance.wsClient.connect();
-        }
-        return instance;
+        return new SandboxInstance(data);
     }
     static async list() {
         const { data } = await (0, index_js_1.listSandboxes)({ throwOnError: true });
         return data.map((sandbox) => new SandboxInstance(sandbox));
     }
-    static async delete(sandboxName, instance) {
-        // Close WebSocket connection if instance is provided
-        if (instance && instance.wsClient) {
-            instance.closeConnection();
-        }
+    static async delete(sandboxName) {
         const { data } = await (0, index_js_1.deleteSandbox)({
             path: {
                 sandboxName,
@@ -223,10 +168,8 @@ class SandboxInstance {
                 if (!name) {
                     throw new Error("Sandbox name is required");
                 }
-                // Get connection type if specified
-                const connectionType = 'connectionType' in sandbox ? sandbox.connectionType : undefined;
                 // Get the existing sandbox to check its status
-                const sandboxInstance = await SandboxInstance.get(name, connectionType);
+                const sandboxInstance = await SandboxInstance.get(name);
                 // If the sandbox is TERMINATED, treat it as not existing
                 if (sandboxInstance.status === "TERMINATED") {
                     // Create a new sandbox - backend will handle cleanup of the terminated one

package/dist/cjs-browser/tools/mcpTool.js

@@ -54,8 +54,8 @@ class McpTool {
         return new URL(`${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/${this.pluralType}/${this.name}`);
     }
     get internalUrl() {
-        const url = (0, internal_js_1.generateInternalUrl)(settings_js_1.settings.workspace, this.type, this.name, settings_js_1.settings.env, settings_js_1.settings.runInternalProtocol, settings_js_1.settings.runInternalHostname, settings_js_1.settings.blCloud, settings_js_1.settings.workspaceId);
-        return new URL(url);
+        const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, this.type, this.name);
+        return new URL(`${settings_js_1.settings.runInternalProtocol}://bl-${settings_js_1.settings.env}-${hash}.${settings_js_1.settings.runInternalHostname}`);
     }
     get forcedUrl() {
         return (0, internal_js_1.getForcedUrl)(this.type, this.name);

package/dist/cjs-browser/types/common/internal.d.ts

@@ -2,5 +2,3 @@ export declare function getAlphanumericLimitedHash(input: string, maxSize?: numb
 export declare function getGlobalUniqueHash(workspace: string, type: string, name: string): string;
 export declare function pluralize(type: string): string;
 export declare function getForcedUrl(type: string, name: string): import("url").URL | null;
-export declare function getWorkloadTypeShort(type: string): string;
-export declare function generateInternalUrl(workspace: string, type: string, name: string, env: string, protocol: string, hostname: string, blCloud: boolean, workspaceId: string): string;

package/dist/cjs-browser/types/common/settings.d.ts

@@ -23,7 +23,6 @@ declare class Settings {
     get runInternalHostname(): string;
     get runInternalProtocol(): string;
     get blCloud(): boolean;
-    get workspaceId(): string;
     get generation(): string;
     get loggerType(): string;
     authenticate(): Promise<void>;

package/dist/cjs-browser/types/sandbox/sandbox.d.ts

@@ -1,24 +1,19 @@
 import { Sandbox as SandboxModel } from "../client/index.js";
 import { SandboxFileSystem } from "./filesystem/index.js";
-import { SandboxFileSystemWebSocket } from "./filesystem/filesystem-ws.js";
 import { SandboxNetwork } from "./network/index.js";
-import { SandboxNetworkWebSocket } from "./network/network-ws.js";
 import { SandboxPreviews } from "./preview.js";
 import { SandboxProcess } from "./process/index.js";
-import { SandboxProcessWebSocket } from "./process/process-ws.js";
 import { SandboxCodegen } from "./codegen/index.js";
-import { SandboxCodegenWebSocket } from "./codegen/codegen-ws.js";
 import { SandboxSessions } from "./session.js";
 import { SandboxConfiguration, SandboxCreateConfiguration, SandboxUpdateMetadata, SessionWithToken } from "./types.js";
 export declare class SandboxInstance {
     private sandbox;
-    fs: SandboxFileSystem | SandboxFileSystemWebSocket;
-    network: SandboxNetwork | SandboxNetworkWebSocket;
-    process: SandboxProcess | SandboxProcessWebSocket;
+    fs: SandboxFileSystem;
+    network: SandboxNetwork;
+    process: SandboxProcess;
     previews: SandboxPreviews;
     sessions: SandboxSessions;
-    codegen: SandboxCodegen | SandboxCodegenWebSocket;
-    private wsClient?;
+    codegen: SandboxCodegen;
     constructor(sandbox: SandboxConfiguration);
     get metadata(): import("../client/types.gen.js").Metadata | undefined;
     get status(): string | undefined;
@@ -28,13 +23,12 @@ export declare class SandboxInstance {
         maxWait?: number;
         interval?: number;
     }): Promise<this>;
-    closeConnection(): void;
     static create(sandbox?: SandboxModel | SandboxCreateConfiguration, { safe }?: {
         safe?: boolean;
     }): Promise<SandboxInstance>;
-    static get(sandboxName: string, connectionType?: "http" | "websocket"): Promise<SandboxInstance>;
+    static get(sandboxName: string): Promise<SandboxInstance>;
     static list(): Promise<SandboxInstance[]>;
-    static delete(sandboxName: string, instance?: SandboxInstance): Promise<SandboxModel>;
+    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/cjs-browser/types/sandbox/types.d.ts

@@ -20,12 +20,10 @@ export interface VolumeBinding {
     mountPath: string;
     readOnly?: boolean;
 }
-export type ConnectionType = "http" | "websocket";
 export type SandboxConfiguration = {
     forceUrl?: string;
     headers?: Record<string, string>;
     params?: Record<string, string>;
-    connectionType?: ConnectionType;
 } & Sandbox;
 export type SandboxUpdateMetadata = {
     labels?: Record<string, string>;
@@ -43,7 +41,6 @@ export type SandboxCreateConfiguration = {
     region?: string;
     lifecycle?: SandboxLifecycle;
     snapshotEnabled?: boolean;
-    connectionType?: ConnectionType;
 };
 export declare function normalizePorts(ports?: (Port | Record<string, any>)[]): Port[] | undefined;
 export declare function normalizeEnvs(envs?: EnvVar[]): EnvVar[] | undefined;