@blaxel/core 0.2.80-preview.138 → 0.2.80-preview.139

package/dist/esm-browser/client/interceptors.js

@@ -1,7 +1,36 @@
+import { ensureAutoloaded } from "../common/lazyInit.js";
 import { settings } from "../common/settings.js";
+// Default baseUrl baked into the generated control-plane client. Requests
+// carrying this prefix came from the module-load client config, before
+// `ensureAutoloaded()` had a chance to resolve the real env from
+// `~/.blaxel/config.yaml`.
+const DEFAULT_CONTROLPLANE_BASE_URL = "https://api.blaxel.ai/v0";
 export const interceptors = [
     // Authentication interceptor
     async (request, options) => {
+        // Trigger deferred autoload side-effects (lazy credential resolution,
+        // client baseUrl sync, Sentry init, H2 warming) on the first actual SDK
+        // use, rather than at module-import time.
+        ensureAutoloaded();
+        // If lazy env resolution just moved the effective baseUrl off the
+        // module-load default (e.g. a user with `env: dev` in config.yaml but
+        // no BL_ENV env var), the very first request was built against the
+        // stale prod URL. Rebase it to the correct environment. Subsequent
+        // requests use the updated `client.setConfig()` applied in
+        // `ensureAutoloaded()`, so this branch only fires once.
+        //
+        // This must happen before the `authenticated === false` early return:
+        // the OAuth token request issued by `ClientCredentials.authenticate()`
+        // itself is unauthenticated, and if the user calls `authenticate()`
+        // before any other SDK call it is the very first request and also
+        // needs to be rebased to the correct environment.
+        const correctBase = settings.baseUrl;
+        if (correctBase !== DEFAULT_CONTROLPLANE_BASE_URL &&
+            request.url.startsWith(DEFAULT_CONTROLPLANE_BASE_URL)) {
+            const newUrl = correctBase.replace(/\/$/, "") +
+                request.url.slice(DEFAULT_CONTROLPLANE_BASE_URL.length);
+            request = new Request(newUrl, request);
+        }
         if (options.authenticated === false) {
             return request;
         }

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

@@ -2,8 +2,8 @@ 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 { initSentry } from "./sentry.js";
 import { settings } from "./settings.js";
+export { ensureAutoloaded } from "./lazyInit.js";
 client.setConfig({
     baseUrl: settings.baseUrl,
 });
@@ -19,34 +19,15 @@ for (const interceptor of responseInterceptors) {
     client.interceptors.response.use(interceptor);
     clientSandbox.interceptors.response.use(interceptor);
 }
-// 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
-    }
-}
 /**
  * Configure the SDK programmatically at runtime, instead of relying on
  * environment variables or config files.
  *
+ * You do not need to call {@link authenticate} yourself: the SDK
+ * transparently authenticates (and refreshes tokens when needed) on every
+ * request. Only call `authenticate()` directly if you want to fail fast on
+ * invalid credentials before making any API call.
+ *
  * @example
  * // With an API key
  * initialize({ workspace: 'my-workspace', apiKey: 'bl_...' });
@@ -57,7 +38,6 @@ if (isNode && !isBrowser) {
  *   workspace: 'my-workspace',
  *   clientCredentials: { clientId: '...', clientSecret: '...' },
  * });
- * await authenticate();
  *
  * @example
  * // With client credentials (pre-encoded Base64 string)
@@ -65,7 +45,6 @@ if (isNode && !isBrowser) {
  *   workspace: 'my-workspace',
  *   clientCredentials: 'base64-encoded-string',
  * });
- * await authenticate();
  */
 export function initialize(config) {
     settings.setConfig(config);

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

@@ -0,0 +1,62 @@
+import { client } from "../client/client.gen.js";
+import { client as clientSandbox } from "../sandbox/client/client.gen.js";
+import { initSentry } from "./sentry.js";
+import { settings } from "./settings.js";
+let autoloaded = false;
+/**
+ * Perform the observable side-effects that the SDK needs for error
+ * reporting, low-latency sandbox sessions, and correct environment
+ * routing:
+ *
+ *   - Resolve credentials (which reads `~/.blaxel/config.yaml` once and
+ *     populates `BL_ENV` if the user has a dev workspace configured).
+ *   - Re-apply the control-plane and sandbox clients' `baseUrl` so they
+ *     target the now-env-aware endpoint.
+ *   - Initialize the lightweight Sentry client (registers
+ *     `uncaughtExceptionMonitor` and patches `console.error` in Node).
+ *   - Pre-warm the edge H2 connection pool for `settings.region`.
+ *
+ * These used to run at module load, but that meant `import "@blaxel/core"`
+ * alone had observable side-effects. They are now deferred until the SDK
+ * is first actually used — the request interceptor calls this on the
+ * first HTTP request.
+ */
+export function ensureAutoloaded() {
+    if (autoloaded)
+        return;
+    autoloaded = true;
+    // Trigger lazy credential resolution. This may read `~/.blaxel/config.yaml`
+    // and set `process.env.BL_ENV` if the user has a dev workspace configured,
+    // which in turn affects `settings.baseUrl`.
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    settings.credentials;
+    // 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 });
+    clientSandbox.setConfig({ baseUrl: settings.baseUrl });
+    // Initialize Sentry for SDK error tracking.
+    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
+        }
+    }
+}

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

@@ -5,8 +5,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.80-preview.138";
-const BUILD_COMMIT = "a58f8cc475d6ca3147ed31106d71a68e504c55a0";
+const BUILD_VERSION = "0.2.80-preview.139";
+const BUILD_COMMIT = "90ee846099b1f428daba9643df172bf43a5fd53e";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;
@@ -66,20 +66,32 @@ function getOsArch() {
     return "browser/unknown";
 }
 class Settings {
-    credentials;
+    _credentials;
     config;
     constructor() {
-        this.credentials = authentication();
+        // `credentials` are resolved lazily on first access so that simply
+        // importing `@blaxel/core` does not read `~/.blaxel/config.yaml`
+        // or mutate `process.env.BL_ENV`. See the `credentials` getter.
+        this._credentials = null;
         this.config = {
             proxy: "",
             apikey: "",
             workspace: "",
         };
     }
+    get credentials() {
+        if (this._credentials === null) {
+            this._credentials = authentication();
+        }
+        return this._credentials;
+    }
+    set credentials(value) {
+        this._credentials = value;
+    }
     setConfig(config) {
         this.config = config;
         if (config.apiKey) {
-            this.credentials = new ApiKey({
+            this._credentials = new ApiKey({
                 apiKey: config.apiKey,
                 workspace: config.workspace,
             });
@@ -88,7 +100,7 @@ class Settings {
             const encoded = typeof config.clientCredentials === 'string'
                 ? config.clientCredentials
                 : btoa(`${config.clientCredentials.clientId}:${config.clientCredentials.clientSecret}`);
-            this.credentials = new ClientCredentials({
+            this._credentials = new ClientCredentials({
                 clientCredentials: encoded,
                 workspace: config.workspace,
             });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blaxel/core",
-	"version": "0.2.80-preview.138",
+	"version": "0.2.80-preview.139",
 	"description": "Blaxel Core SDK for TypeScript",
 	"license": "MIT",
 	"author": "Blaxel, INC (https://blaxel.ai)",