@blaxel/core 0.2.50-dev.215 → 0.2.50

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

@@ -180,41 +180,3 @@ export function getForcedUrl(type, name) {
     }
     return null;
 }
-export 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);
-    }
-}
-export 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/esm-browser/common/settings.js

@@ -7,7 +7,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","commit":"a4290fe191702ee91d8ae3fcc45c094d86be553c"};
             return packageJson.version || "unknown";
         }
         else {
@@ -59,7 +59,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","commit":"a4290fe191702ee91d8ae3fcc45c094d86be553c"};
             // Check for commit in various possible locations
             const commit = packageJson.commit || packageJson.buildInfo?.commit;
             if (commit) {
@@ -162,9 +162,6 @@ class Settings {
     get blCloud() {
         return env.BL_CLOUD === "true";
     }
-    get workspaceId() {
-        return env.BL_WORKSPACE_ID || "";
-    }
     get generation() {
         return env.BL_GENERATION || "";
     }

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

@@ -1,4 +1,4 @@
-import { generateInternalUrl, getForcedUrl } from "../common/internal.js";
+import { getForcedUrl, getGlobalUniqueHash } from "../common/internal.js";
 import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
 import { startSpan } from '../telemetry/telemetry.js';
@@ -17,8 +17,8 @@ class BlJob {
         return new URL(`${settings.runUrl}/${settings.workspace}/jobs/${this.jobName}`);
     }
     get internalUrl() {
-        const url = generateInternalUrl(settings.workspace, "job", this.jobName, settings.env, settings.runInternalProtocol, settings.runInternalHostname, settings.blCloud, settings.workspaceId);
-        return new URL(url);
+        const hash = getGlobalUniqueHash(settings.workspace, "job", this.jobName);
+        return new URL(`${settings.runInternalProtocol}://bl-${settings.env}-${hash}.${settings.runInternalHostname}`);
     }
     get forcedUrl() {
         return getForcedUrl('job', this.jobName);

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

@@ -2,43 +2,12 @@ import { authenticate } from '../common/autoload.js';
 import { env } from '../common/env.js';
 import { flush } from '../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.BL_EXECUTION_DATA_URL) {
             const args = this.parseCommandLineArgs();
             return args;
         }
-        const response = await this.fetchWithRetry(env.BL_EXECUTION_DATA_URL);
+        const response = await fetch(env.BL_EXECUTION_DATA_URL);
         const data = await response.json();
         return data.tasks[this.index] ?? {};
     }

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

@@ -1,5 +1,5 @@
 import { createClient } from "@hey-api/client-fetch";
-import { generateInternalUrl, getForcedUrl } from "../common/internal.js";
+import { getForcedUrl, getGlobalUniqueHash } from "../common/internal.js";
 import { settings } from "../common/settings.js";
 import { client as defaultClient } from "./client/client.gen.js";
 export class ResponseError extends Error {
@@ -44,7 +44,8 @@ export class SandboxAction {
         return this.sandbox.metadata?.url ?? `${settings.runUrl}/${settings.workspace}/sandboxes/${this.name}`;
     }
     get internalUrl() {
-        return generateInternalUrl(settings.workspace, "sandbox", this.name, settings.env, settings.runInternalProtocol, settings.runInternalHostname, settings.blCloud, settings.workspaceId);
+        const hash = getGlobalUniqueHash(settings.workspace, "sandbox", this.name);
+        return `${settings.runInternalProtocol}://bl-${settings.env}-${hash}.${settings.runInternalHostname}`;
     }
     get client() {
         if (this.sandbox.forceUrl) {

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

@@ -2,16 +2,11 @@ import { v4 as uuidv4 } from "uuid";
 import { createSandbox, deleteSandbox, getSandbox, listSandboxes, updateSandbox } from "../client/index.js";
 import { logger } from "../common/logger.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 { WebSocketClient } from "./websocket/index.js";
 import { normalizeEnvs, normalizePorts, normalizeVolumes } from "./types.js";
 export class SandboxInstance {
     sandbox;
@@ -21,32 +16,14 @@ export 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 WebSocketClient({
-                url,
-                headers: sandbox.headers,
-            });
-            // Initialize WebSocket-based action handlers
-            this.process = new SandboxProcessWebSocket(sandbox, this.wsClient);
-            this.fs = new SandboxFileSystemWebSocket(sandbox, this.process, this.wsClient);
-            this.network = new SandboxNetworkWebSocket(sandbox, this.wsClient);
-            this.codegen = new SandboxCodegenWebSocket(sandbox, this.wsClient);
-        }
-        else {
-            // Default to HTTP-based action handlers
-            this.process = new SandboxProcess(sandbox);
-            this.fs = new SandboxFileSystem(sandbox, this.process);
-            this.network = new SandboxNetwork(sandbox);
-            this.codegen = new SandboxCodegen(sandbox);
-        }
-        // These are always HTTP-based
+        this.process = new SandboxProcess(sandbox);
+        this.fs = new SandboxFileSystem(sandbox, this.process);
+        this.network = new SandboxNetwork(sandbox);
         this.previews = new SandboxPreviews(sandbox);
         this.sessions = new SandboxSessions(sandbox);
+        this.codegen = new SandboxCodegen(sandbox);
     }
     get metadata() {
         return this.sandbox.metadata;
@@ -65,17 +42,10 @@ export class SandboxInstance {
         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-${uuidv4().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 ||
@@ -85,8 +55,7 @@ export 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)
@@ -95,7 +64,6 @@ export class SandboxInstance {
                 sandbox.image = defaultImage;
             if (!sandbox.memory)
                 sandbox.memory = defaultMemory;
-            connectionType = sandbox.connectionType;
             const ports = normalizePorts(sandbox.ports);
             const envs = normalizeEnvs(sandbox.envs);
             const volumes = normalizeVolumes(sandbox.volumes);
@@ -144,16 +112,7 @@ export 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 {
@@ -163,34 +122,20 @@ export class SandboxInstance {
         }
         return instance;
     }
-    static async get(sandboxName, connectionType) {
+    static async get(sandboxName) {
         const { data } = await 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 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 deleteSandbox({
             path: {
                 sandboxName,
@@ -220,10 +165,8 @@ export 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/esm-browser/tools/mcpTool.js

@@ -1,6 +1,6 @@
 import { Client as ModelContextProtocolClient } from "@modelcontextprotocol/sdk/client/index.js";
 import { env } from "../common/env.js";
-import { generateInternalUrl, getForcedUrl } from "../common/internal.js";
+import { getForcedUrl, getGlobalUniqueHash } from "../common/internal.js";
 import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
 import { authenticate } from "../index.js";
@@ -51,8 +51,8 @@ export class McpTool {
         return new URL(`${settings.runUrl}/${settings.workspace}/${this.pluralType}/${this.name}`);
     }
     get internalUrl() {
-        const url = generateInternalUrl(settings.workspace, this.type, this.name, settings.env, settings.runInternalProtocol, settings.runInternalHostname, settings.blCloud, settings.workspaceId);
-        return new URL(url);
+        const hash = getGlobalUniqueHash(settings.workspace, this.type, this.name);
+        return new URL(`${settings.runInternalProtocol}://bl-${settings.env}-${hash}.${settings.runInternalHostname}`);
     }
     get forcedUrl() {
         return getForcedUrl(this.type, this.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.50-dev.215",
+  "version": "0.2.50",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -74,7 +74,7 @@
     "vite": "^5.2.0",
     "vitest": "^1.5.0"
   },
-  "commit": "833c34cbba3735060a62bdd3594fa917160f3d3c",
+  "commit": "a4290fe191702ee91d8ae3fcc45c094d86be553c",
   "scripts": {
     "lint": "eslint src/",
     "dev": "tsc --watch",

package/dist/cjs/sandbox/codegen/codegen-ws.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxCodegenWebSocket = void 0;
-const action_js_1 = require("../action.js");
-class SandboxCodegenWebSocket extends action_js_1.SandboxAction {
-    wsClient;
-    constructor(sandbox, wsClient) {
-        super(sandbox);
-        this.wsClient = wsClient;
-    }
-    async fastapply(path, codeEdit, model) {
-        const data = await this.wsClient.send("codegen:fastapply", {
-            path,
-            codeEdit,
-            model,
-        });
-        return data;
-    }
-    async reranking(path, query, scoreThreshold, tokenLimit, filePattern) {
-        const data = await this.wsClient.send("codegen:reranking", {
-            path,
-            query,
-            scoreThreshold,
-            tokenLimit,
-            filePattern,
-        });
-        return data;
-    }
-}
-exports.SandboxCodegenWebSocket = SandboxCodegenWebSocket;

package/dist/cjs/sandbox/filesystem/filesystem-ws.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxFileSystemWebSocket = void 0;
-const action_js_1 = require("../action.js");
-const filesystem_js_1 = require("./filesystem.js");
-class SandboxFileSystemWebSocket extends action_js_1.SandboxAction {
-    process;
-    wsClient;
-    httpClient;
-    constructor(sandbox, process, wsClient) {
-        super(sandbox);
-        this.process = process;
-        this.wsClient = wsClient;
-        // Create HTTP client for fallback operations
-        this.httpClient = new filesystem_js_1.SandboxFileSystem(sandbox, process);
-    }
-    async mkdir(path, permissions = "0755") {
-        path = this.formatPath(path);
-        const data = await this.wsClient.send("filesystem:create", {
-            path,
-            isDirectory: true,
-            permissions,
-        });
-        return data;
-    }
-    async write(path, content) {
-        path = this.formatPath(path);
-        const data = await this.wsClient.send("filesystem:create", {
-            path,
-            content,
-            isDirectory: false,
-        });
-        return data;
-    }
-    async writeBinary(path, content) {
-        return this.httpClient.writeBinary(path, content);
-    }
-    async writeTree(files, destinationPath = null) {
-        const path = this.formatPath(destinationPath ?? "");
-        const filesMap = files.reduce((acc, file) => {
-            acc[file.path] = file.content;
-            return acc;
-        }, {});
-        const data = await this.wsClient.send("filesystem:tree:create", {
-            path,
-            files: filesMap,
-        });
-        return data;
-    }
-    async read(path) {
-        path = this.formatPath(path);
-        const data = await this.wsClient.send("filesystem:get", { path });
-        return data.content;
-    }
-    async readBinary(path) {
-        // Binary downloads are better suited for HTTP
-        // Fall back to HTTP client for binary operations
-        return this.httpClient.readBinary(path);
-    }
-    async download(src, destinationPath, options = {}) {
-        // File downloads are better suited for HTTP
-        // Fall back to HTTP client
-        return this.httpClient.download(src, destinationPath, options);
-    }
-    async rm(path, recursive = false) {
-        path = this.formatPath(path);
-        const data = await this.wsClient.send("filesystem:delete", {
-            path,
-            recursive,
-        });
-        return data;
-    }
-    async ls(path) {
-        path = this.formatPath(path);
-        const data = await this.wsClient.send("filesystem:get", { path });
-        return data;
-    }
-    async cp(source, destination, { maxWait = 180000 } = {}) {
-        // Copy operation is typically done via process execution
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        let process = await this.process.exec({
-            command: `cp -r ${source} ${destination}`,
-        });
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
-        process = await this.process.wait(process.pid, { maxWait, interval: 100 });
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        if (process.status === "failed") {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            throw new Error(`Could not copy ${source} to ${destination} cause: ${process.logs}`);
-        }
-        return {
-            message: "Files copied",
-            source,
-            destination,
-        };
-    }
-    watch(path, callback, options) {
-        // File watching uses HTTP streaming which is already optimized
-        // Fall back to HTTP client
-        return this.httpClient.watch(path, callback, options);
-    }
-    formatPath(path) {
-        return path;
-    }
-}
-exports.SandboxFileSystemWebSocket = SandboxFileSystemWebSocket;

package/dist/cjs/sandbox/network/network-ws.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxNetworkWebSocket = void 0;
-const action_js_1 = require("../action.js");
-class SandboxNetworkWebSocket extends action_js_1.SandboxAction {
-    wsClient;
-    constructor(sandbox, wsClient) {
-        super(sandbox);
-        this.wsClient = wsClient;
-    }
-}
-exports.SandboxNetworkWebSocket = SandboxNetworkWebSocket;

package/dist/cjs/sandbox/process/process-ws.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxProcessWebSocket = void 0;
-const action_js_1 = require("../action.js");
-const process_js_1 = require("./process.js");
-class SandboxProcessWebSocket extends action_js_1.SandboxAction {
-    wsClient;
-    httpClient;
-    constructor(sandbox, wsClient) {
-        super(sandbox);
-        this.wsClient = wsClient;
-        // Create HTTP client for fallback operations
-        this.httpClient = new process_js_1.SandboxProcess(sandbox);
-    }
-    streamLogs(identifier, options) {
-        const streamId = this.wsClient.sendStream("process:logs:stream:start", { identifier }, (data) => {
-            // Handle streaming log data
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            if (data && data.log) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                const log = String(data.log);
-                // Parse log format: "stdout:" or "stderr:" prefix
-                if (log.startsWith('stdout:')) {
-                    const stdout = log.slice(7);
-                    options.onStdout?.(stdout);
-                    options.onLog?.(stdout);
-                }
-                else if (log.startsWith('stderr:')) {
-                    const stderr = log.slice(7);
-                    options.onStderr?.(stderr);
-                    options.onLog?.(stderr);
-                }
-                else {
-                    options.onLog?.(log);
-                }
-            }
-        }, () => {
-            // Stream ended
-        });
-        return {
-            close: () => this.wsClient.cancelStream(streamId),
-        };
-    }
-    async exec(process) {
-        let onLog;
-        if ('onLog' in process && process.onLog) {
-            onLog = process.onLog;
-            delete process.onLog;
-        }
-        // Store original wait_for_completion setting
-        const shouldWaitForCompletion = process.waitForCompletion;
-        // Always start process without wait_for_completion to avoid server-side blocking
-        if (shouldWaitForCompletion && onLog) {
-            process.waitForCompletion = false;
-        }
-        const data = await this.wsClient.send("process:execute", process);
-        let result = data;
-        // Handle wait_for_completion with parallel log streaming
-        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 });
-            }
-            finally {
-                // Clean up log streaming
-                if (streamControl) {
-                    streamControl.close();
-                }
-            }
-        }
-        else {
-            // For non-blocking execution, set up log streaming immediately if requested
-            if (onLog) {
-                const streamControl = this.streamLogs(result.pid, { onLog });
-                return {
-                    ...result,
-                    close() {
-                        if (streamControl) {
-                            streamControl.close();
-                        }
-                    },
-                };
-            }
-        }
-        return { ...result, close: () => { } };
-    }
-    async wait(identifier, { maxWait = 60000, interval = 1000 } = {}) {
-        const startTime = Date.now();
-        let status = "running";
-        let data = await this.get(identifier);
-        while (status === "running") {
-            await new Promise((resolve) => setTimeout(resolve, interval));
-            try {
-                data = await this.get(identifier);
-                status = data.status ?? "running";
-            }
-            catch {
-                break;
-            }
-            if (Date.now() - startTime > maxWait) {
-                throw new Error("Process did not finish in time");
-            }
-        }
-        return data;
-    }
-    async get(identifier) {
-        const data = await this.wsClient.send("process:get", { identifier });
-        return data;
-    }
-    async list() {
-        const data = await this.wsClient.send("process:list", {});
-        return data.processes || [];
-    }
-    async stop(identifier) {
-        const data = await this.wsClient.send("process:stop", { identifier });
-        return data;
-    }
-    async kill(identifier) {
-        const data = await this.wsClient.send("process:kill", { identifier });
-        return data;
-    }
-    async logs(identifier, type = "all") {
-        const data = await this.wsClient.send("process:logs", {
-            identifier,
-        });
-        if (type === "all") {
-            return data.logs || "";
-        }
-        else if (type === "stdout") {
-            return data.stdout || "";
-        }
-        else if (type === "stderr") {
-            return data.stderr || "";
-        }
-        throw new Error("Unsupported log type");
-    }
-}
-exports.SandboxProcessWebSocket = SandboxProcessWebSocket;