@blaxel/core 0.2.70 → 0.2.71-dev.105

package/dist/esm/sandbox/drive/drive.js

@@ -14,7 +14,7 @@ export class SandboxDrive extends SandboxAction {
             mountPath: request.mountPath,
             drivePath: request.drivePath || "/",
         };
-        const response = await fetch(`${this.url}/drives/mount`, {
+        const response = await this.h2Fetch(`${this.url}/drives/mount`, {
             method: 'POST',
             headers: {
                 ...headers,
@@ -37,7 +37,7 @@ export class SandboxDrive extends SandboxAction {
         const normalizedPath = mountPath.startsWith('/') ? mountPath : `/${mountPath}`;
         // Remove leading slash for URL (DELETE /drives/mnt/test not /drives//mnt/test)
         const urlPath = normalizedPath.substring(1);
-        const response = await fetch(`${this.url}/drives/mount/${urlPath}`, {
+        const response = await this.h2Fetch(`${this.url}/drives/mount/${urlPath}`, {
             method: 'DELETE',
             headers,
         });
@@ -52,7 +52,7 @@ export class SandboxDrive extends SandboxAction {
      */
     async list() {
         const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings.headers;
-        const response = await fetch(`${this.url}/drives/mount`, {
+        const response = await this.h2Fetch(`${this.url}/drives/mount`, {
             method: 'GET',
             headers,
         });

package/dist/esm/sandbox/filesystem/filesystem.js

@@ -98,8 +98,7 @@ export class SandboxFileSystem extends SandboxAction {
         if (this.forcedUrl) {
             url = `${this.forcedUrl.toString()}/filesystem/${path}`;
         }
-        // Make the request using fetch instead of axios for better FormData handling
-        const response = await fetch(url, {
+        const response = await this.h2Fetch(url, {
             method: 'PUT',
             headers: {
                 ...settings.headers,

package/dist/esm/sandbox/interpreter.js

@@ -1,3 +1,4 @@
+import { h2RequestDirect } from "../common/h2fetch.js";
 import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
 import { SandboxInstance } from "./sandbox.js";
@@ -23,6 +24,7 @@ export class CodeInterpreter extends SandboxInstance {
             spec: base.spec,
             status: base.status,
             events: base.events,
+            h2Session: base.h2Session,
         };
         return new CodeInterpreter(config);
     }
@@ -80,6 +82,7 @@ export class CodeInterpreter extends SandboxInstance {
             spec: baseInstance.spec,
             status: baseInstance.status,
             events: baseInstance.events,
+            h2Session: baseInstance.h2Session,
         };
         // Preserve forceUrl and headers from input if it was a dict-like object
         if (sandbox && typeof sandbox === "object" && !Array.isArray(sandbox)) {
@@ -98,6 +101,13 @@ export class CodeInterpreter extends SandboxInstance {
     get _jupyterUrl() {
         return this.process.url;
     }
+    _fetch(input, init) {
+        const session = this._sandboxConfig.h2Session;
+        if (session && !session.closed && !session.destroyed) {
+            return h2RequestDirect(session, input.toString(), init);
+        }
+        return globalThis.fetch(input, init);
+    }
     static OutputMessage = class {
         text;
         timestamp;
@@ -257,7 +267,7 @@ export class CodeInterpreter extends SandboxInstance {
             }, readTimeout * 1000);
         }
         try {
-            const response = await fetch(`${this._jupyterUrl}/port/8888/execute`, {
+            const response = await this._fetch(`${this._jupyterUrl}/port/8888/execute`, {
                 method: "POST",
                 headers: {
                     ...headers,
@@ -356,7 +366,7 @@ export class CodeInterpreter extends SandboxInstance {
             }, requestTimeout * 1000);
         }
         try {
-            const response = await fetch(`${this._jupyterUrl}/port/8888/contexts`, {
+            const response = await this._fetch(`${this._jupyterUrl}/port/8888/contexts`, {
                 method: "POST",
                 headers: {
                     ...headers,

package/dist/esm/sandbox/process/process.js

@@ -18,7 +18,7 @@ export class SandboxProcess extends SandboxAction {
         const done = (async () => {
             try {
                 const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings.headers;
-                const stream = await fetch(`${this.url}/process/${identifier}/logs/stream`, {
+                const stream = await this.h2Fetch(`${this.url}/process/${identifier}/logs/stream`, {
                     method: 'GET',
                     signal: controller.signal,
                     headers,
@@ -120,7 +120,7 @@ export class SandboxProcess extends SandboxAction {
     async execWithStreaming(processRequest, options) {
         const headers = this.sandbox.forceUrl ? this.sandbox.headers : settings.headers;
         const controller = new AbortController();
-        const response = await fetch(`${this.url}/process`, {
+        const response = await this.h2Fetch(`${this.url}/process`, {
             method: 'POST',
             signal: controller.signal,
             headers: {

package/dist/esm/sandbox/sandbox.js

@@ -21,6 +21,8 @@ export class SandboxInstance {
     codegen;
     system;
     drives;
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    h2Session;
     constructor(sandbox) {
         this.sandbox = sandbox;
         this.process = new SandboxProcess(sandbox);
@@ -31,6 +33,7 @@ export class SandboxInstance {
         this.codegen = new SandboxCodegen(sandbox);
         this.system = new SandboxSystem(sandbox);
         this.drives = new SandboxDrive(sandbox);
+        this.h2Session = null;
     }
     get metadata() {
         return this.sandbox.metadata;
@@ -47,6 +50,27 @@ export class SandboxInstance {
     get lastUsedAt() {
         return this.sandbox.lastUsedAt;
     }
+    /**
+     * Warm and attach an H2 session based on the sandbox's region.
+     * Shared by create(), get(), list(), and update helpers.
+     */
+    static async attachH2Session(instance) {
+        const region = instance.spec?.region;
+        if (!region)
+            return instance;
+        const edgeSuffix = settings.env === "prod" ? "bl.run" : "runv2.blaxel.dev";
+        const edgeDomain = `any.${region}.${edgeSuffix}`;
+        try {
+            const { h2Pool } = await import("../common/h2pool.js");
+            const h2Session = await h2Pool.get(edgeDomain);
+            instance.h2Session = h2Session;
+            instance.sandbox.h2Session = h2Session;
+        }
+        catch {
+            // H2 warming is best-effort; fall back to regular fetch
+        }
+        return instance;
+    }
     get expiresIn() {
         return this.sandbox.expiresIn;
     }
@@ -128,11 +152,24 @@ export class SandboxInstance {
         }
         sandbox.spec.runtime.image = sandbox.spec.runtime.image || defaultImage;
         sandbox.spec.runtime.memory = sandbox.spec.runtime.memory || defaultMemory;
-        const { data } = await createSandbox({
-            body: sandbox,
-            throwOnError: true,
-        });
-        const instance = new SandboxInstance(data);
+        const edgeSuffix = settings.env === "prod" ? "bl.run" : "runv2.blaxel.dev";
+        const edgeDomain = sandbox.spec?.region ? `any.${sandbox.spec.region}.${edgeSuffix}` : null;
+        // Kick off warming so h2Pool.get() can join it during the API call
+        if (edgeDomain) {
+            import("../common/h2pool.js").then(({ h2Pool }) => h2Pool.warm(edgeDomain)).catch(() => { });
+        }
+        const [{ data }, h2Session] = await Promise.all([
+            createSandbox({
+                body: sandbox,
+                throwOnError: true,
+            }),
+            edgeDomain ? import("../common/h2pool.js").then(({ h2Pool }) => h2Pool.get(edgeDomain)).catch(() => null) : Promise.resolve(null),
+        ]);
+        // Inject the H2 session into the config so subsystems can use it
+        const config = { ...data, h2Session };
+        const instance = new SandboxInstance(config);
+        instance.h2Session = h2Session;
+        // Note: H2 session already attached via Promise.all above, no need for attachH2Session()
         // TODO remove this part once we have a better way to handle this
         if (safe) {
             try {
@@ -149,11 +186,13 @@ export class SandboxInstance {
             },
             throwOnError: true,
         });
-        return new SandboxInstance(data);
+        const instance = new SandboxInstance(data);
+        return SandboxInstance.attachH2Session(instance);
     }
     static async list() {
         const { data } = await listSandboxes({ throwOnError: true });
-        return data.map((sandbox) => new SandboxInstance(sandbox));
+        const instances = data.map((sandbox) => new SandboxInstance(sandbox));
+        return Promise.all(instances.map((instance) => SandboxInstance.attachH2Session(instance)));
     }
     static async delete(sandboxName) {
         const { data } = await deleteSandbox({
@@ -165,6 +204,8 @@ export class SandboxInstance {
         return data;
     }
     async delete() {
+        // Don't close the H2 session — it's shared via h2Pool
+        this.h2Session = null;
         return await SandboxInstance.delete(this.metadata.name);
     }
     static async updateMetadata(sandboxName, metadata) {
@@ -176,7 +217,7 @@ export class SandboxInstance {
             throwOnError: true,
         });
         const instance = new SandboxInstance(data);
-        return instance;
+        return SandboxInstance.attachH2Session(instance);
     }
     static async updateTtl(sandboxName, ttl) {
         const sandbox = await SandboxInstance.get(sandboxName);
@@ -187,7 +228,7 @@ export class SandboxInstance {
             throwOnError: true,
         });
         const instance = new SandboxInstance(data);
-        return instance;
+        return SandboxInstance.attachH2Session(instance);
     }
     static async updateLifecycle(sandboxName, lifecycle) {
         const sandbox = await SandboxInstance.get(sandboxName);
@@ -198,7 +239,7 @@ export class SandboxInstance {
             throwOnError: true,
         });
         const instance = new SandboxInstance(data);
-        return instance;
+        return SandboxInstance.attachH2Session(instance);
     }
     static async createIfNotExists(sandbox) {
         try {

package/dist/esm/tools/index.js

@@ -2,6 +2,7 @@ import { findFromCache } from "../cache/index.js";
 import { getFunction } from "../client/client.js";
 import { getForcedUrl } from "../common/internal.js";
 import { getMcpTool } from "./mcpTool.js";
+export { McpTool } from "./mcpTool.js";
 export const getTool = async (name, options) => {
     return await getMcpTool(name, options);
 };

package/dist/esm/tools/mcpTool.js

@@ -6,7 +6,6 @@ import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
 import { authenticate, SandboxInstance } from "../index.js";
 import { BlaxelMcpClientTransport } from "../mcp/client.js";
-import { startSpan } from "../telemetry/telemetry.js";
 import { schemaToZodSchema } from "./zodSchema.js";
 const McpToolCache = new Map();
 export class McpTool {
@@ -138,47 +137,24 @@ export class McpTool {
         }
     }
     async listTools() {
-        const span = startSpan(this.name, {
-            attributes: {
-                "span.type": "tool.list",
-            },
+        logger.debug(`MCP:${this.name}:Listing tools`);
+        await this.start();
+        const { tools } = (await this.client.listTools());
+        await this.close();
+        const result = tools.map((tool) => {
+            return {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: schemaToZodSchema(tool.inputSchema),
+                originalSchema: tool.inputSchema,
+                call: (input) => {
+                    return this.call(tool.name, input);
+                },
+            };
         });
-        try {
-            logger.debug(`MCP:${this.name}:Listing tools`);
-            await this.start();
-            const { tools } = (await this.client.listTools());
-            await this.close();
-            const result = tools.map((tool) => {
-                return {
-                    name: tool.name,
-                    description: tool.description,
-                    inputSchema: schemaToZodSchema(tool.inputSchema),
-                    originalSchema: tool.inputSchema,
-                    call: (input) => {
-                        return this.call(tool.name, input);
-                    },
-                };
-            });
-            span.setAttribute("tool.list.result", JSON.stringify(result));
-            return result;
-        }
-        catch (err) {
-            span.setStatus("error");
-            span.recordException(err);
-            throw err;
-        }
-        finally {
-            span.end();
-        }
+        return result;
     }
     async call(toolName, args) {
-        const span = startSpan(this.name + "." + toolName, {
-            attributes: {
-                "span.type": "tool.call",
-                "tool.name": toolName,
-                "tool.args": JSON.stringify(args),
-            },
-        });
         try {
             logger.debug(`MCP:${this.name}:Tool calling`, toolName, JSON.stringify(args));
             logger.debug(`MCP:${this.name}:Tool calling:start`);
@@ -192,7 +168,6 @@ export class McpTool {
             logger.debug(`MCP:${this.name}:Tool calling:result`);
             await this.close();
             logger.debug(`MCP:${this.name}:Tool result`, toolName, JSON.stringify(args));
-            span.setAttribute("tool.call.result", JSON.stringify(result));
             return result;
         }
         catch (err) {
@@ -207,9 +182,6 @@ export class McpTool {
             }
             throw err;
         }
-        finally {
-            span.end();
-        }
     }
     async getTransport(forcedUrl) {
         if (!this.transportName) {