@blaxel/core 0.2.89 → 0.2.90-preview.182

package/dist/esm/common/autoload.js

@@ -2,10 +2,12 @@ import { client } from "../client/client.gen.js";
 import { interceptors } from "../client/interceptors.js";
 import { responseInterceptors } from "../client/responseInterceptor.js";
 import { client as clientSandbox } from "../sandbox/client/client.gen.js";
+import { controlPlaneFetch } from "./controlPlaneFetch.js";
 import { settings } from "./settings.js";
 export { ensureAutoloaded } from "./lazyInit.js";
 client.setConfig({
     baseUrl: settings.baseUrl,
+    fetch: controlPlaneFetch,
 });
 // Register request interceptors
 for (const interceptor of interceptors) {
@@ -50,6 +52,7 @@ export function initialize(config) {
     settings.setConfig(config);
     client.setConfig({
         baseUrl: settings.baseUrl,
+        fetch: controlPlaneFetch,
     });
     clientSandbox.setConfig({
         baseUrl: settings.baseUrl,

package/dist/esm/common/controlPlaneFetch.js

@@ -0,0 +1,51 @@
+import { createPoolBackedH2Fetch } from "./h2fetch.js";
+import { h2Pool } from "./h2pool.js";
+import { settings } from "./settings.js";
+const h2FetchByHost = new Map();
+// Node's global fetch dispatcher only negotiates HTTP/2 by default starting
+// with undici 8 (Node 26+); undici 7 (Node 24) and undici 6 (Node 22) still
+// ALPN to HTTP/1.1 for fetch, verified empirically against api.blaxel.ai. On
+// undici >= 8 the pooled wrapper is redundant, so we prefer the native path.
+export function undiciSupportsNativeH2(undiciVersion) {
+    const major = Number(undiciVersion?.split(".")[0] ?? 0);
+    return major >= 8;
+}
+// `process`/`process.versions` is absent on Cloudflare Workers and other
+// non-Node runtimes, and `process.versions.undici` is undefined on Bun/Deno;
+// all of those resolve to `false` and keep the wrapper as the fallback.
+export const nativeFetchSupportsH2 = typeof process !== "undefined" && undiciSupportsNativeH2(process.versions?.undici);
+export function shouldUseControlPlaneH2(url, h2Disabled, proxyConfigured = false, nativeH2 = false, forceWrapper = false) {
+    if (h2Disabled || proxyConfigured)
+        return false;
+    if (url.protocol !== "https:")
+        return false;
+    // Token refresh is sequential and unauthenticated; it cannot contribute to
+    // the create burst TLS storm, and device-mode refresh currently relies on the
+    // native fetch path.
+    if (url.pathname.endsWith("/oauth/token"))
+        return false;
+    if (!(url.hostname.endsWith("blaxel.ai") || url.hostname.endsWith("blaxel.dev"))) {
+        return false;
+    }
+    // Native fetch already negotiates HTTP/2: skip the redundant wrapper unless
+    // explicitly forced (e.g. to exercise the pooled path on a modern runtime).
+    if (nativeH2 && !forceWrapper)
+        return false;
+    return true;
+}
+export function controlPlaneFetch(input) {
+    const url = new URL(input.url);
+    const proxyConfigured = Boolean(settings.config.proxy);
+    // Global disableH2 still wins; disableControlPlaneH2 opts out of just the
+    // control-plane wrapper while leaving data-plane H2 in place.
+    const h2Disabled = settings.disableH2 || settings.disableControlPlaneH2;
+    if (!shouldUseControlPlaneH2(url, h2Disabled, proxyConfigured, nativeFetchSupportsH2, settings.forceControlPlaneH2)) {
+        return globalThis.fetch(input);
+    }
+    let h2Fetch = h2FetchByHost.get(url.hostname);
+    if (!h2Fetch) {
+        h2Fetch = createPoolBackedH2Fetch(h2Pool, url.hostname);
+        h2FetchByHost.set(url.hostname, h2Fetch);
+    }
+    return h2Fetch(input);
+}

package/dist/esm/common/lazyInit.js

@@ -1,5 +1,6 @@
 import { client } from "../client/client.gen.js";
 import { client as clientSandbox } from "../sandbox/client/client.gen.js";
+import { controlPlaneFetch } from "./controlPlaneFetch.js";
 import { initSentry } from "./sentry.js";
 import { settings } from "./settings.js";
 let autoloaded = false;
@@ -33,7 +34,7 @@ export function ensureAutoloaded() {
     // Keep the clients' baseUrl in sync with the now-resolved env. Without
     // this, the module-load `client.setConfig({ baseUrl })` would be stuck on
     // the prod default for users who rely on `config.yaml` (no env vars).
-    client.setConfig({ baseUrl: settings.baseUrl });
+    client.setConfig({ baseUrl: settings.baseUrl, fetch: controlPlaneFetch });
     clientSandbox.setConfig({ baseUrl: settings.baseUrl });
     // Initialize Sentry for SDK error tracking.
     initSentry();
@@ -44,9 +45,9 @@ export function ensureAutoloaded() {
     if (isNode && !isBrowser && !settings.disableH2) {
         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.
+            // SandboxInstance.create() gets an instant data-plane session via the
+            // pool. Control-plane H2 is intentionally not warmed; its cold burst
+            // relies on pool deduplication instead.
             const region = settings.region;
             if (region) {
                 import("./h2pool.js").then(({ h2Pool }) => {

package/dist/esm/common/settings.js

@@ -22,8 +22,8 @@ function missingCredentialsMessage() {
     return "No Blaxel credentials found. Set the BL_API_KEY and BL_WORKSPACE environment variables, or run `bl login`.";
 }
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.2.89";
-const BUILD_COMMIT = "c481e2f6670b3cef6832875dbc9f2bc6b0b198f4";
+const BUILD_VERSION = "0.2.90-preview.182";
+const BUILD_COMMIT = "78dad6b3e2d47dcf5d8464b9688b0829ddc3369c";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-04-16";
 // Cache for config.yaml tracking value
@@ -244,6 +244,31 @@ class Settings {
         }
         return isDenoRuntime();
     }
+    // Control-plane-only escape hatch: disables the control-plane H2 wrapper
+    // without affecting data-plane (edge) H2. `disableH2` is the global override
+    // and is checked separately by callers, so it always wins.
+    get disableControlPlaneH2() {
+        if (typeof this.config.disableControlPlaneH2 === "boolean") {
+            return this.config.disableControlPlaneH2;
+        }
+        const value = env.BL_DISABLE_CONTROL_PLANE_H2;
+        if (value) {
+            return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+        }
+        return false;
+    }
+    // Forces the control-plane H2 wrapper on even when native fetch already
+    // supports H2 (undici >= 7). `disableH2`/`disableControlPlaneH2` still win.
+    get forceControlPlaneH2() {
+        if (typeof this.config.forceControlPlaneH2 === "boolean") {
+            return this.config.forceControlPlaneH2;
+        }
+        const value = env.BL_FORCE_CONTROL_PLANE_H2;
+        if (value) {
+            return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+        }
+        return false;
+    }
     get maxConcurrentH2Requests() {
         if (typeof this.config.maxConcurrentH2Requests === "number") {
             return this.config.maxConcurrentH2Requests;