@blaxel/core 0.2.49-preview.111 → 0.2.49

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

@@ -36,4 +36,5 @@ __exportStar(require("./filesystem/index.js"), exports);
 __exportStar(require("./codegen/index.js"), exports);
 __exportStar(require("./sandbox.js"), exports);
 __exportStar(require("./types.js"), exports);
+__exportStar(require("./interpreter.js"), exports);
 // Re-export everything from client except ClientOptions to avoid conflict

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

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeInterpreter = void 0;
+const logger_js_1 = require("../common/logger.js");
+const settings_js_1 = require("../common/settings.js");
+const sandbox_js_1 = require("./sandbox.js");
+class CodeInterpreter extends sandbox_js_1.SandboxInstance {
+    static DEFAULT_IMAGE = "blaxel/jupyter-server";
+    static DEFAULT_PORTS = [
+        { name: "jupyter", target: 8888, protocol: "HTTP" },
+    ];
+    static DEFAULT_LIFECYCLE = {
+        expirationPolicies: [{ type: "ttl-idle", value: "30m", action: "delete" }],
+    };
+    _sandboxConfig;
+    constructor(sandbox) {
+        super(sandbox);
+        this._sandboxConfig = sandbox;
+    }
+    static async get(sandboxName) {
+        const base = await sandbox_js_1.SandboxInstance.get(sandboxName);
+        // Create a minimal config - the base instance already has the sandbox data
+        // We'll rely on the process property for URL/headers access
+        const config = {
+            metadata: base.metadata,
+            spec: base.spec,
+            status: base.status,
+            events: base.events,
+        };
+        return new CodeInterpreter(config);
+    }
+    static async create(sandbox, { safe = true } = {}) {
+        const payload = {
+            image: CodeInterpreter.DEFAULT_IMAGE,
+            ports: CodeInterpreter.DEFAULT_PORTS,
+            lifecycle: CodeInterpreter.DEFAULT_LIFECYCLE,
+        };
+        const allowedCopyKeys = new Set(["name", "envs", "memory", "region", "headers"]);
+        if (sandbox && typeof sandbox === "object") {
+            if (Array.isArray(sandbox)) {
+                // Skip arrays
+            }
+            else if ("metadata" in sandbox || "spec" in sandbox) {
+                // It's a Sandbox object
+                const sandboxObj = sandbox;
+                if (sandboxObj.metadata?.name) {
+                    payload["name"] = sandboxObj.metadata.name;
+                }
+                if (sandboxObj.spec?.runtime) {
+                    if (sandboxObj.spec.runtime.envs) {
+                        payload["envs"] = sandboxObj.spec.runtime.envs;
+                    }
+                    if (sandboxObj.spec.runtime.memory) {
+                        payload["memory"] = sandboxObj.spec.runtime.memory;
+                    }
+                }
+                if (sandboxObj.spec?.region) {
+                    payload["region"] = sandboxObj.spec.region;
+                }
+            }
+            else if ("name" in sandbox || "image" in sandbox || "memory" in sandbox) {
+                // It's a SandboxCreateConfiguration or dict-like object
+                const sandboxDict = sandbox;
+                for (const k of allowedCopyKeys) {
+                    const value = sandboxDict[k];
+                    if (value !== null && value !== undefined) {
+                        payload[k] = value;
+                    }
+                }
+            }
+        }
+        const baseInstance = await sandbox_js_1.SandboxInstance.create(payload, { safe });
+        // Create config from the instance - preserve any forceUrl/headers if provided in input
+        const config = {
+            metadata: baseInstance.metadata,
+            spec: baseInstance.spec,
+            status: baseInstance.status,
+            events: baseInstance.events,
+        };
+        // Preserve forceUrl and headers from input if it was a dict-like object
+        if (sandbox && typeof sandbox === "object" && !Array.isArray(sandbox)) {
+            if ("forceUrl" in sandbox && typeof sandbox.forceUrl === "string") {
+                config.forceUrl = sandbox.forceUrl;
+            }
+            if ("headers" in sandbox && typeof sandbox.headers === "object") {
+                config.headers = sandbox.headers;
+            }
+            if ("params" in sandbox && typeof sandbox.params === "object") {
+                config.params = sandbox.params;
+            }
+        }
+        return new CodeInterpreter(config);
+    }
+    get _jupyterUrl() {
+        return this.process.url;
+    }
+    static OutputMessage = class {
+        text;
+        timestamp;
+        isStderr;
+        constructor(text, timestamp, isStderr) {
+            this.text = text;
+            this.timestamp = timestamp;
+            this.isStderr = isStderr;
+        }
+    };
+    static Result = class {
+        constructor(kwargs = {}) {
+            for (const [k, v] of Object.entries(kwargs)) {
+                this[k] = v;
+            }
+        }
+    };
+    static ExecutionError = class {
+        name;
+        value;
+        traceback;
+        constructor(name, value, traceback) {
+            this.name = name;
+            this.value = value;
+            this.traceback = traceback;
+        }
+    };
+    static Logs = class {
+        stdout = [];
+        stderr = [];
+    };
+    static Execution = class {
+        results = [];
+        logs = new CodeInterpreter.Logs();
+        error = null;
+        executionCount = null;
+    };
+    static Context = class {
+        id;
+        constructor(id) {
+            this.id = id;
+        }
+        static fromJson(data) {
+            return new CodeInterpreter.Context(String(data.id || data.context_id || ""));
+        }
+    };
+    _parseOutput(execution, output, onStdout, onStderr, onResult, onError) {
+        let data;
+        try {
+            data = JSON.parse(output);
+        }
+        catch {
+            // Fallback: treat as stdout text-only message
+            execution.logs.stdout.push(output);
+            if (onStdout) {
+                return onStdout(new CodeInterpreter.OutputMessage(output, null, false));
+            }
+            return null;
+        }
+        let dataType = "";
+        if (typeof data.type === "string") {
+            dataType = data.type;
+        }
+        else if (data.type !== null &&
+            data.type !== undefined &&
+            typeof data.type !== "object") {
+            const typeValue = data.type;
+            dataType = String(typeValue);
+        }
+        const restData = { ...data };
+        delete restData.type;
+        if (dataType === "result") {
+            const result = new CodeInterpreter.Result(restData);
+            execution.results.push(result);
+            if (onResult) {
+                return onResult(result);
+            }
+        }
+        else if (dataType === "stdout") {
+            let text = "";
+            if (typeof data.text === "string") {
+                text = data.text;
+            }
+            else if (data.text !== null &&
+                data.text !== undefined &&
+                typeof data.text !== "object") {
+                const textValue = data.text;
+                text = String(textValue);
+            }
+            execution.logs.stdout.push(text);
+            if (onStdout) {
+                return onStdout(new CodeInterpreter.OutputMessage(text, typeof data.timestamp === "number" ? data.timestamp : null, false));
+            }
+        }
+        else if (dataType === "stderr") {
+            let text = "";
+            if (typeof data.text === "string") {
+                text = data.text;
+            }
+            else if (data.text !== null &&
+                data.text !== undefined &&
+                typeof data.text !== "object") {
+                const textValue = data.text;
+                text = String(textValue);
+            }
+            execution.logs.stderr.push(text);
+            if (onStderr) {
+                return onStderr(new CodeInterpreter.OutputMessage(text, typeof data.timestamp === "number" ? data.timestamp : null, true));
+            }
+        }
+        else if (dataType === "error") {
+            let errorName = "";
+            if (typeof data.name === "string") {
+                errorName = data.name;
+            }
+            else if (data.name !== null &&
+                data.name !== undefined &&
+                typeof data.name !== "object") {
+                const nameValue = data.name;
+                errorName = String(nameValue);
+            }
+            execution.error = new CodeInterpreter.ExecutionError(errorName, data.value, data.traceback);
+            if (onError) {
+                return onError(execution.error);
+            }
+        }
+        else if (dataType === "number_of_executions") {
+            execution.executionCount =
+                typeof data.execution_count === "number" ? data.execution_count : null;
+        }
+        return null;
+    }
+    async runCode(code, options = {}) {
+        const { language = null, context = null, onStdout, onStderr, onResult, onError, envs = null, timeout = null, } = options;
+        const DEFAULT_TIMEOUT = 60.0;
+        if (language && context) {
+            throw new Error("You can provide context or language, but not both at the same time.");
+        }
+        const readTimeout = timeout === 0 ? null : timeout ?? DEFAULT_TIMEOUT;
+        const contextId = context?.id ?? null;
+        const body = {
+            code,
+            context_id: contextId,
+            language,
+            env_vars: envs,
+        };
+        const execution = new CodeInterpreter.Execution();
+        const headers = this._sandboxConfig.forceUrl
+            ? this._sandboxConfig.headers
+            : settings_js_1.settings.headers;
+        const controller = new AbortController();
+        let timeoutId = null;
+        // Set up timeout
+        if (readTimeout !== null) {
+            timeoutId = setTimeout(() => {
+                controller.abort();
+            }, readTimeout * 1000);
+        }
+        try {
+            const response = await fetch(`${this._jupyterUrl}/port/8888/execute`, {
+                method: "POST",
+                headers: {
+                    ...headers,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (response.status >= 400) {
+                let bodyText = "<unavailable>";
+                try {
+                    bodyText = await response.text();
+                }
+                catch {
+                    // Ignore errors
+                }
+                const method = "POST";
+                const url = `${this._jupyterUrl}/port/8888/execute`;
+                const reason = response.statusText;
+                const details = "Execution failed\n" +
+                    `- method: ${method}\n- url: ${url}\n- status: ${response.status} ${reason}\n` +
+                    `- response-headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}\n- body:\n${bodyText}`;
+                logger_js_1.logger.debug(details);
+                throw new Error(details);
+            }
+            if (!response.body) {
+                throw new Error("No response body");
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            try {
+                while (true) {
+                    const result = await reader.read();
+                    if (result.done)
+                        break;
+                    const value = result.value;
+                    if (value instanceof Uint8Array) {
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split(/\r?\n/);
+                        buffer = lines.pop() || "";
+                        for (const line of lines) {
+                            if (!line)
+                                continue;
+                            try {
+                                this._parseOutput(execution, line, onStdout, onStderr, onResult, onError);
+                            }
+                            catch {
+                                // Fallback: treat as stdout text-only message
+                                execution.logs.stdout.push(line);
+                                if (onStdout) {
+                                    onStdout(new CodeInterpreter.OutputMessage(line, null, false));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        catch (error) {
+            if (error &&
+                typeof error === "object" &&
+                "name" in error &&
+                error.name === "AbortError") {
+                throw new Error("Request timeout");
+            }
+            throw error;
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+        return execution;
+    }
+    async createCodeContext(options = {}) {
+        const { cwd = null, language = null, requestTimeout = null } = options;
+        const data = {};
+        if (language) {
+            data.language = language;
+        }
+        if (cwd) {
+            data.cwd = cwd;
+        }
+        const headers = this._sandboxConfig.forceUrl
+            ? this._sandboxConfig.headers
+            : settings_js_1.settings.headers;
+        const controller = new AbortController();
+        let timeoutId = null;
+        if (requestTimeout !== null) {
+            timeoutId = setTimeout(() => {
+                controller.abort();
+            }, requestTimeout * 1000);
+        }
+        try {
+            const response = await fetch(`${this._jupyterUrl}/port/8888/contexts`, {
+                method: "POST",
+                headers: {
+                    ...headers,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(data),
+                signal: controller.signal,
+            });
+            if (response.status >= 400) {
+                let bodyText = "<unavailable>";
+                try {
+                    bodyText = await response.text();
+                }
+                catch {
+                    // Ignore errors
+                }
+                const method = "POST";
+                const url = `${this._jupyterUrl}/port/8888/contexts`;
+                const reason = response.statusText;
+                const details = "Create context failed\n" +
+                    `- method: ${method}\n- url: ${url}\n- status: ${response.status} ${reason}\n` +
+                    `- response-headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}\n- body:\n${bodyText}`;
+                logger_js_1.logger.debug(details);
+                throw new Error(details);
+            }
+            const responseData = (await response.json());
+            return CodeInterpreter.Context.fromJson(responseData);
+        }
+        catch (error) {
+            if (error &&
+                typeof error === "object" &&
+                "name" in error &&
+                error.name === "AbortError") {
+                throw new Error("Request timeout");
+            }
+            throw error;
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+}
+exports.CodeInterpreter = CodeInterpreter;

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

@@ -42,10 +42,6 @@ class McpTool {
         this.client = new index_js_1.Client({
             name: this.name,
             version: "1.0.0",
-        }, {
-            capabilities: {
-                tools: {},
-            },
         });
     }
     get fallbackUrl() {

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

@@ -3,3 +3,4 @@ export * from "./filesystem/index.js";
 export * from "./codegen/index.js";
 export * from "./sandbox.js";
 export * from "./types.js";
+export * from "./interpreter.js";

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

@@ -0,0 +1,71 @@
+import { Sandbox, SandboxLifecycle, Port } from "../client/types.gen.js";
+import { SandboxInstance } from "./sandbox.js";
+import { SandboxConfiguration, SandboxCreateConfiguration } from "./types.js";
+export declare class CodeInterpreter extends SandboxInstance {
+    static readonly DEFAULT_IMAGE = "blaxel/jupyter-server";
+    static readonly DEFAULT_PORTS: Port[];
+    static readonly DEFAULT_LIFECYCLE: SandboxLifecycle;
+    private _sandboxConfig;
+    constructor(sandbox: SandboxConfiguration);
+    static get(sandboxName: string): Promise<CodeInterpreter>;
+    static create(sandbox?: Sandbox | SandboxCreateConfiguration | Record<string, any> | null, { safe }?: {
+        safe?: boolean;
+    }): Promise<CodeInterpreter>;
+    get _jupyterUrl(): string;
+    static OutputMessage: {
+        new (text: string, timestamp: number | null, isStderr: boolean): {
+            text: string;
+            timestamp: number | null;
+            isStderr: boolean;
+        };
+    };
+    static Result: {
+        new (kwargs?: Record<string, unknown>): {
+            [key: string]: unknown;
+        };
+    };
+    static ExecutionError: {
+        new (name: string, value: any, traceback: any): {
+            name: string;
+            value: any;
+            traceback: any;
+        };
+    };
+    static Logs: {
+        new (): {
+            stdout: string[];
+            stderr: string[];
+        };
+    };
+    static Execution: {
+        new (): {
+            results: InstanceType<typeof CodeInterpreter.Result>[];
+            logs: InstanceType<typeof CodeInterpreter.Logs>;
+            error: InstanceType<typeof CodeInterpreter.ExecutionError> | null;
+            executionCount: number | null;
+        };
+    };
+    static Context: {
+        new (id: string): {
+            id: string;
+        };
+        fromJson(data: Record<string, any>): InstanceType<typeof CodeInterpreter.Context>;
+    };
+    private _parseOutput;
+    runCode(code: string, options?: {
+        language?: string | null;
+        context?: InstanceType<typeof CodeInterpreter.Context> | null;
+        onStdout?: (msg: InstanceType<typeof CodeInterpreter.OutputMessage>) => void;
+        onStderr?: (msg: InstanceType<typeof CodeInterpreter.OutputMessage>) => void;
+        onResult?: (result: InstanceType<typeof CodeInterpreter.Result>) => void;
+        onError?: (error: InstanceType<typeof CodeInterpreter.ExecutionError>) => void;
+        envs?: Record<string, string> | null;
+        timeout?: number | null;
+        requestTimeout?: number | null;
+    }): Promise<InstanceType<typeof CodeInterpreter.Execution>>;
+    createCodeContext(options?: {
+        cwd?: string | null;
+        language?: string | null;
+        requestTimeout?: number | null;
+    }): Promise<InstanceType<typeof CodeInterpreter.Context>>;
+}