@blaxel/core 0.2.70 → 0.2.71-dev.105

package/dist/esm/agents/index.js

@@ -3,8 +3,7 @@ import { getAgent } from "../client/index.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';
-class BlAgent {
+export class BlAgent {
     agentName;
     constructor(agentName) {
         this.agentName = agentName;
@@ -54,42 +53,25 @@ class BlAgent {
     }
     async run(input, headers = {}, params = {}) {
         logger.debug(`Agent Calling: ${this.agentName}`);
-        const span = startSpan(this.agentName, {
-            attributes: {
-                "agent.name": this.agentName,
-                "agent.args": JSON.stringify(input),
-                "span.type": "agent.run",
-            },
-            isRoot: false,
-        });
         try {
             const response = await this.call(this.url, input, headers, params);
-            span.setAttribute("agent.run.result", await response.text());
             return await response.text();
         }
         catch (err) {
             if (err instanceof Error) {
                 if (!this.fallbackUrl) {
-                    span.setAttribute("agent.run.error", err.stack);
                     throw err;
                 }
                 try {
                     const response = await this.call(this.fallbackUrl, input, headers, params);
-                    span.setAttribute("agent.run.result", await response.text());
                     return await response.text();
                 }
                 catch (err) {
-                    if (err instanceof Error) {
-                        span.setAttribute("agent.run.error", err.stack);
-                    }
                     throw err;
                 }
             }
             throw err;
         }
-        finally {
-            span.end();
-        }
     }
 }
 export const blAgent = (agentName) => {

package/dist/esm/common/autoload.js

@@ -21,6 +21,28 @@ for (const interceptor of responseInterceptors) {
 }
 // Initialize Sentry for SDK error tracking immediately when module loads
 initSentry();
+// Background H2 connection warming (Node.js only)
+const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+/* eslint-disable */
+const isBrowser = typeof globalThis !== "undefined" && globalThis?.window !== undefined;
+if (isNode && !isBrowser) {
+    try {
+        // Pre-warm edge H2 for the configured region so the first
+        // SandboxInstance.create() gets an instant session via the pool.
+        // The control-plane client (api.blaxel.ai) stays on regular fetch
+        // which already benefits from undici's built-in connection pooling.
+        const region = settings.region;
+        if (region) {
+            import("./h2pool.js").then(({ h2Pool }) => {
+                const edgeSuffix = settings.env === "prod" ? "bl.run" : "runv2.blaxel.dev";
+                h2Pool.warm(`any.${region}.${edgeSuffix}`);
+            }).catch(() => { });
+        }
+    }
+    catch {
+        // Silently ignore warming failures
+    }
+}
 // Allow to set custom configuration for browser environment
 export function initialize(config) {
     settings.setConfig(config);
@@ -34,3 +56,11 @@ export function initialize(config) {
 export function authenticate() {
     return settings.authenticate();
 }
+/**
+ * Close all pooled H2 connections. Call this for explicit cleanup
+ * (e.g. in test teardown or before process exit).
+ */
+export async function closeConnections() {
+    const { h2Pool } = await import("./h2pool.js");
+    h2Pool.closeAll();
+}

package/dist/esm/common/h2fetch.js

@@ -0,0 +1,202 @@
+const H2_REQUEST_TIMEOUT_MS = 10_000;
+/**
+ * Creates a fetch()-compatible function that sends requests over an existing
+ * HTTP/2 session. Falls back to global fetch() if the session is closed,
+ * destroyed, or if the H2 request times out.
+ */
+export function createH2Fetch(session) {
+    return (input) => {
+        if (session.closed || session.destroyed) {
+            return globalThis.fetch(input);
+        }
+        return _h2Request(session, input);
+    };
+}
+/**
+ * Creates a fetch()-compatible function backed by the H2 session pool.
+ *
+ * Non-blocking: checks the pool cache synchronously. If a warm session is
+ * available it's used immediately; otherwise the request goes through
+ * regular fetch with zero delay (the pool keeps warming in the background
+ * so subsequent calls get H2).
+ */
+export function createPoolBackedH2Fetch(pool, domain) {
+    return (input) => {
+        const session = pool.tryGet(domain);
+        if (session) {
+            return _h2Request(session, input);
+        }
+        return globalThis.fetch(input);
+    };
+}
+/**
+ * Low-level H2 request that takes raw URL + init, skipping Request construction.
+ * Used by SandboxAction.h2Fetch() for direct calls from subsystems.
+ */
+export function h2RequestDirect(session, url, init) {
+    if (session.closed || session.destroyed) {
+        return globalThis.fetch(url, init);
+    }
+    const parsed = new URL(url);
+    const method = init?.method || "GET";
+    const h2Headers = {
+        ":method": method,
+        ":path": parsed.pathname + parsed.search,
+        ":authority": parsed.host,
+    };
+    if (init?.headers) {
+        const entries = init.headers instanceof Headers
+            ? init.headers.entries()
+            : Array.isArray(init.headers)
+                ? init.headers.values()
+                : Object.entries(init.headers).values();
+        for (const [key, value] of entries) {
+            const k = key.toLowerCase();
+            if (k === "host")
+                continue;
+            h2Headers[k] = value;
+        }
+    }
+    let body;
+    if (init?.body) {
+        if (typeof init.body === "string") {
+            body = Buffer.from(init.body);
+        }
+        else if (Buffer.isBuffer(init.body)) {
+            body = init.body;
+        }
+        else if (init.body instanceof ArrayBuffer) {
+            body = Buffer.from(init.body);
+        }
+        else if (init.body instanceof Uint8Array) {
+            body = Buffer.from(init.body.buffer, init.body.byteOffset, init.body.byteLength);
+        }
+        else {
+            // FormData, ReadableStream, Blob, etc. can't be serialized to Buffer
+            // for manual H2 framing — fall back to regular fetch.
+            return globalThis.fetch(url, init);
+        }
+        if (!h2Headers["content-length"]) {
+            h2Headers["content-length"] = body.byteLength;
+        }
+    }
+    return _h2Send(session, h2Headers, body, init?.signal ?? null, url, init);
+}
+async function _h2Request(session, input) {
+    const url = new URL(input.url);
+    const method = input.method || "GET";
+    const h2Headers = {
+        ":method": method,
+        ":path": url.pathname + url.search,
+        ":authority": url.host,
+    };
+    for (const [key, value] of input.headers.entries()) {
+        if (key === "host")
+            continue;
+        h2Headers[key] = value;
+    }
+    let body;
+    if (input.body) {
+        body = Buffer.from(await input.arrayBuffer());
+        if (!h2Headers["content-length"]) {
+            h2Headers["content-length"] = body.byteLength;
+        }
+    }
+    return _h2Send(session, h2Headers, body, input.signal, input.url, {
+        method,
+        headers: input.headers,
+        body,
+    });
+}
+function _h2Send(session, h2Headers, body, signal, fallbackUrl, fallbackInit) {
+    return new Promise((resolve, reject) => {
+        let req;
+        try {
+            req = session.request(h2Headers);
+        }
+        catch {
+            return globalThis.fetch(fallbackUrl, fallbackInit).then(resolve, reject);
+        }
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            req.close();
+            globalThis.fetch(fallbackUrl, fallbackInit).then(resolve, reject);
+        }, H2_REQUEST_TIMEOUT_MS);
+        if (signal) {
+            if (signal.aborted) {
+                clearTimeout(timer);
+                req.close();
+                reject(new DOMException("The operation was aborted.", "AbortError"));
+                return;
+            }
+            signal.addEventListener("abort", () => {
+                clearTimeout(timer);
+                req.close();
+                if (!settled) {
+                    settled = true;
+                    reject(new DOMException("The operation was aborted.", "AbortError"));
+                }
+            }, { once: true });
+        }
+        let settled = false;
+        req.on("response", (headers) => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            settled = true;
+            const status = headers[":status"] ?? 200;
+            const resHeaders = new Headers();
+            for (const [k, v] of Object.entries(headers)) {
+                if (k.startsWith(":"))
+                    continue;
+                if (v === undefined)
+                    continue;
+                resHeaders.set(k, Array.isArray(v) ? v.join(", ") : String(v));
+            }
+            let streamClosed = false;
+            const readable = new ReadableStream({
+                start(controller) {
+                    req.on("data", (chunk) => {
+                        if (!streamClosed)
+                            controller.enqueue(new Uint8Array(chunk));
+                    });
+                    req.on("end", () => {
+                        if (!streamClosed) {
+                            streamClosed = true;
+                            controller.close();
+                        }
+                    });
+                    req.on("error", (err) => {
+                        if (!streamClosed) {
+                            streamClosed = true;
+                            controller.error(err);
+                        }
+                    });
+                    signal?.addEventListener("abort", () => {
+                        req.close();
+                        if (!streamClosed) {
+                            streamClosed = true;
+                            controller.error(new DOMException("The operation was aborted.", "AbortError"));
+                        }
+                    }, { once: true });
+                },
+            });
+            resolve(new Response(readable, { status, headers: resHeaders }));
+        });
+        req.on("error", () => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            settled = true;
+            globalThis.fetch(fallbackUrl, fallbackInit).then(resolve, reject);
+        });
+        if (body) {
+            req.end(body);
+        }
+        else {
+            req.end();
+        }
+    });
+}

package/dist/esm/common/h2pool.js

@@ -0,0 +1,101 @@
+/**
+ * Singleton H2 session pool keyed by edge domain.
+ *
+ * - `warm(domain)` starts a background connection (fire-and-forget).
+ * - `get(domain)` returns a live session immediately if cached, or awaits
+ *   an in-flight warming, or establishes a fresh one.
+ * - Closed / destroyed sessions are automatically evicted.
+ */
+class H2Pool {
+    sessions = new Map();
+    inflight = new Map();
+    _establish = null;
+    /**
+     * Lazily resolve the establish function so the http2 / tls / dns modules
+     * are only imported in Node.js environments.
+     */
+    async establish(domain) {
+        if (!this._establish) {
+            const { establishH2 } = await import("./h2warm.js");
+            this._establish = establishH2;
+        }
+        return this._establish(domain);
+    }
+    /**
+     * Fire-and-forget background warming. Safe to call multiple times for
+     * the same domain — only one connection attempt per domain at a time.
+     */
+    warm(domain) {
+        const existing = this.sessions.get(domain);
+        if (existing && !existing.closed && !existing.destroyed)
+            return;
+        if (this.inflight.has(domain))
+            return;
+        const p = this.establish(domain)
+            .then((session) => {
+            this.sessions.set(domain, session);
+            return session;
+        })
+            .catch(() => null)
+            .finally(() => {
+            this.inflight.delete(domain);
+        });
+        this.inflight.set(domain, p);
+    }
+    /**
+     * Synchronous cache check. Returns a live cached session or `null`.
+     * Never blocks, never establishes — use for non-blocking fast paths.
+     */
+    tryGet(domain) {
+        const cached = this.sessions.get(domain);
+        if (cached && !cached.closed && !cached.destroyed)
+            return cached;
+        this.sessions.delete(domain);
+        return null;
+    }
+    /**
+     * Get a live H2 session for `domain`. Returns immediately from cache,
+     * joins an in-flight warming, or starts a new one.
+     */
+    async get(domain) {
+        const fast = this.tryGet(domain);
+        if (fast)
+            return fast;
+        // Join in-flight warming if one exists
+        const pending = this.inflight.get(domain);
+        if (pending) {
+            const session = await pending;
+            if (session && !session.closed && !session.destroyed)
+                return session;
+        }
+        // Start fresh, deduplicating concurrent callers via inflight
+        // Re-check: another caller may have started a fresh one while we awaited
+        const existingInflight = this.inflight.get(domain);
+        if (existingInflight)
+            return existingInflight;
+        const freshCached = this.tryGet(domain);
+        if (freshCached)
+            return freshCached;
+        const p = this.establish(domain)
+            .then((session) => {
+            this.sessions.set(domain, session);
+            return session;
+        })
+            .catch(() => null)
+            .finally(() => {
+            this.inflight.delete(domain);
+        });
+        this.inflight.set(domain, p);
+        return p;
+    }
+    /** Close all sessions (for cleanup). */
+    closeAll() {
+        for (const [, session] of this.sessions) {
+            if (!session.closed && !session.destroyed)
+                session.close();
+        }
+        this.sessions.clear();
+        this.inflight.clear();
+    }
+}
+export const h2Pool = new H2Pool();

package/dist/esm/common/h2warm.js

@@ -0,0 +1,48 @@
+import dns from "dns/promises";
+import http2 from "http2";
+import tls from "tls";
+export async function establishH2(sniHostname) {
+    let timedOut = false;
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            timedOut = true;
+            reject(new Error("H2 warm-up timed out"));
+        }, 5000);
+    });
+    const attempt = _establishH2(sniHostname).then((session) => {
+        // If the timeout already fired, destroy the orphaned session immediately
+        if (timedOut) {
+            session.destroy();
+        }
+        return session;
+    });
+    return Promise.race([attempt, timeout]).finally(() => clearTimeout(timer));
+}
+async function _establishH2(sniHostname) {
+    const { address } = await dns.lookup(sniHostname);
+    const tlsSocket = tls.connect({
+        host: address,
+        port: 443,
+        servername: sniHostname,
+        ALPNProtocols: ["h2"],
+    });
+    const session = http2.connect(`https://${sniHostname}:443`, {
+        createConnection: () => tlsSocket,
+    });
+    await new Promise((resolve, reject) => {
+        session.on("connect", resolve);
+        session.on("error", (err) => {
+            // Ensure the TLS socket is cleaned up on connection error
+            if (!tlsSocket.destroyed)
+                tlsSocket.destroy();
+            reject(err);
+        });
+    });
+    // Complete the SETTINGS exchange so the first real request has zero
+    // protocol overhead. This RTT is hidden by the parallel createSandbox() call.
+    await new Promise((resolve) => session.ping(() => resolve()));
+    // Unref so the session doesn't prevent process exit
+    session.unref();
+    return session;
+}

package/dist/esm/common/settings.js

@@ -3,8 +3,8 @@ import { authentication } from "../authentication/index.js";
 import { env } from "../common/env.js";
 import { fs, os, path } from "../common/node.js";
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.2.70";
-const BUILD_COMMIT = "a3bbb13aa4ec149d33f1662d30dfb10ce3683baf";
+const BUILD_VERSION = "0.2.71-dev.105";
+const BUILD_COMMIT = "cd4e249990c84664410df2d7158d13d6342300ed";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;

package/dist/esm/jobs/jobs.js

@@ -1,40 +1,21 @@
 import { createJobExecution, deleteJobExecution, getJobExecution, listJobExecutions, } from "../client/index.js";
 import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
-import { startSpan } from "../telemetry/telemetry.js";
-class BlJob {
+export class BlJob {
     jobName;
     constructor(jobName) {
         this.jobName = jobName;
     }
     async run(tasks, options) {
         logger.debug(`Job Calling: ${this.jobName}`);
-        const span = startSpan(this.jobName, {
-            attributes: {
-                "job.name": this.jobName,
-                "span.type": "job.run",
-            },
-            isRoot: false,
-        });
-        try {
-            const request = {
-                tasks,
-                ...(options?.env && { env: options.env }),
-                ...(options?.memory && { memory: options.memory }),
-                ...(options?.executionId && { executionId: options.executionId }),
-            };
-            const executionId = await this.createExecution(request);
-            return executionId;
-        }
-        catch (err) {
-            if (err instanceof Error) {
-                span.setAttribute("job.run.error", err.stack);
-            }
-            throw err;
-        }
-        finally {
-            span.end();
-        }
+        const request = {
+            tasks,
+            ...(options?.env && { env: options.env }),
+            ...(options?.memory && { memory: options.memory }),
+            ...(options?.executionId && { executionId: options.executionId }),
+        };
+        const executionId = await this.createExecution(request);
+        return executionId;
     }
     /**
      * Create a new execution for this job and return the execution ID

package/dist/esm/mcp/server.js

@@ -2,8 +2,6 @@ import { v4 as uuidv4 } from "uuid";
 import WebSocket, { WebSocketServer } from "ws";
 import { env } from "../common/env.js";
 import { logger } from "../common/logger.js";
-import { startSpan } from "../telemetry/telemetry.js";
-const spans = new Map();
 export class BlaxelMcpServerTransport {
     port;
     wss;
@@ -38,26 +36,10 @@ export class BlaxelMcpServerTransport {
                 ws,
             });
             this.onconnection?.(clientId);
-            ws.on("message", (data) => {
-                const span = startSpan("message", {
-                    attributes: {
-                        "mcp.client.id": clientId,
-                        "span.type": "mcp.message",
-                    },
-                    isRoot: false,
-                });
+            ws.on("message", async (data) => {
                 try {
                     const msg = JSON.parse(data.toString());
-                    this.messageHandler?.(msg, clientId);
-                    if ("method" in msg && "id" in msg && "params" in msg) {
-                        span.setAttributes({
-                            "mcp.message.parsed": true,
-                            "mcp.method": msg.method,
-                            "mcp.messageId": msg.id,
-                            "mcp.toolName": msg.params?.name,
-                        });
-                        spans.set(clientId + ":" + msg.id, span);
-                    }
+                    await this.messageHandler?.(msg, clientId);
                     // Handle msg.id safely
                     const msgId = msg.id ? String(msg.id) : "";
                     const [cId, parsedMsgId] = msgId.split(":");
@@ -65,27 +47,7 @@ export class BlaxelMcpServerTransport {
                     // Use optional chaining for safe access
                     const client = this.clients.get(cId ?? "");
                     if (client?.ws?.readyState === WebSocket.OPEN) {
-                        const msgSpan = spans.get(cId + ":" + (msg.id ?? ""));
-                        try {
-                            client.ws.send(JSON.stringify(msg));
-                            if (msgSpan) {
-                                msgSpan.setAttributes({
-                                    "mcp.message.response_sent": true,
-                                });
-                            }
-                        }
-                        catch (err) {
-                            if (msgSpan) {
-                                msgSpan.setStatus("error"); // Error status
-                                msgSpan.recordException(err);
-                            }
-                            throw err;
-                        }
-                        finally {
-                            if (msgSpan) {
-                                msgSpan.end();
-                            }
-                        }
+                        client.ws.send(JSON.stringify(msg));
                     }
                     else {
                         this.clients.delete(cId);
@@ -94,14 +56,11 @@ export class BlaxelMcpServerTransport {
                 }
                 catch (err) {
                     if (err instanceof Error) {
-                        span.setStatus("error"); // Error status
-                        span.recordException(err);
                         this.onerror?.(err);
                     }
                     else {
                         this.onerror?.(new Error(`Failed to parse message: ${String(err)}`));
                     }
-                    span.end();
                 }
             });
             ws.on("close", () => {
@@ -123,27 +82,7 @@ export class BlaxelMcpServerTransport {
             // Send to specific client
             const client = this.clients.get(cId);
             if (client?.ws?.readyState === WebSocket.OPEN) {
-                const msgSpan = spans.get(cId + ":" + msg.id);
-                try {
-                    client.ws.send(data);
-                    if (msgSpan) {
-                        msgSpan.setAttributes({
-                            "mcp.message.response_sent": true,
-                        });
-                    }
-                }
-                catch (err) {
-                    if (msgSpan) {
-                        msgSpan.setStatus("error"); // Error status
-                        msgSpan.recordException(err);
-                    }
-                    throw err;
-                }
-                finally {
-                    if (msgSpan) {
-                        msgSpan.end();
-                    }
-                }
+                client.ws.send(data);
             }
             else {
                 this.clients.delete(cId);

package/dist/esm/sandbox/action.js

@@ -1,4 +1,7 @@
 import { createClient } from "@hey-api/client-fetch";
+import { interceptors } from "../client/interceptors.js";
+import { responseInterceptors } from "../client/responseInterceptor.js";
+import { createH2Fetch, h2RequestDirect } from "../common/h2fetch.js";
 import { getForcedUrl, getGlobalUniqueHash } from "../common/internal.js";
 import { settings } from "../common/settings.js";
 import { client as defaultClient } from "./client/client.gen.js";
@@ -28,6 +31,7 @@ export class ResponseError extends Error {
 }
 export class SandboxAction {
     sandbox;
+    _h2Client = null;
     constructor(sandbox) {
         this.sandbox = sandbox;
     }
@@ -54,8 +58,37 @@ export class SandboxAction {
                 headers: this.sandbox.headers,
             });
         }
+        const session = this.sandbox.h2Session;
+        if (session && !session.closed && !session.destroyed) {
+            if (!this._h2Client) {
+                this._h2Client = createClient({
+                    fetch: createH2Fetch(session),
+                });
+                for (const interceptor of interceptors) {
+                    // @ts-expect-error - Interceptor is not typed
+                    this._h2Client.interceptors.request.use(interceptor);
+                }
+                for (const interceptor of responseInterceptors) {
+                    this._h2Client.interceptors.response.use(interceptor);
+                }
+            }
+            return this._h2Client;
+        }
+        // Invalidate cached H2 client when session is no longer usable
+        this._h2Client = null;
         return defaultClient;
     }
+    /**
+     * Routes through the H2 session when available, falling back to
+     * globalThis.fetch. Uses a direct H2 path that avoids Request allocation.
+     */
+    h2Fetch(input, init) {
+        const session = this.sandbox.h2Session;
+        if (session && !session.closed && !session.destroyed) {
+            return h2RequestDirect(session, input.toString(), init);
+        }
+        return globalThis.fetch(input, init);
+    }
     get forcedUrl() {
         if (this.sandbox.forceUrl)
             return this.sandbox.forceUrl;