@blaxel/core 0.2.73 → 0.2.74

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.73";
-const BUILD_COMMIT = "ca69d9d46e02efafefc83f2fe96e377b857b493a";
+const BUILD_VERSION = "0.2.74";
+const BUILD_COMMIT = "796e20f3a5a0e5f67783655f1d75250b32fd8694";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;

package/dist/esm/sandbox/interpreter.js

@@ -29,54 +29,40 @@ export class CodeInterpreter extends SandboxInstance {
         return new CodeInterpreter(config);
     }
     static async create(sandbox, { safe = true } = {}) {
-        const payload = {
+        // Build a SandboxCreateConfiguration with CodeInterpreter defaults
+        const defaults = {
             image: CodeInterpreter.DEFAULT_IMAGE,
             ports: CodeInterpreter.DEFAULT_PORTS,
             lifecycle: CodeInterpreter.DEFAULT_LIFECYCLE,
         };
-        const allowedCopyKeys = new Set(["name", "envs", "memory", "region", "headers", "labels"]);
-        if (sandbox && typeof sandbox === "object") {
-            if (Array.isArray(sandbox)) {
-                // Skip arrays
-            }
-            else if ("metadata" in sandbox || "spec" in sandbox) {
-                // It's a Sandbox object
+        let merged;
+        if (sandbox && typeof sandbox === "object" && !Array.isArray(sandbox)) {
+            if ("metadata" in sandbox || "spec" in sandbox) {
+                // It's a Sandbox object - inject defaults into spec
                 const sandboxObj = sandbox;
-                if (sandboxObj.metadata.name) {
-                    payload["name"] = sandboxObj.metadata.name;
-                }
-                if (sandboxObj.metadata.labels) {
-                    payload["labels"] = sandboxObj.metadata.labels;
-                }
-                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;
-                }
+                merged = {
+                    ...sandboxObj,
+                    spec: {
+                        ...sandboxObj.spec,
+                        runtime: {
+                            image: defaults.image,
+                            ports: defaults.ports,
+                            ...sandboxObj.spec?.runtime,
+                        },
+                        lifecycle: sandboxObj.spec?.lifecycle || defaults.lifecycle,
+                    },
+                };
             }
-            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;
-                    }
-                }
+            else {
+                // It's a SandboxCreateConfiguration or dict-like object - merge with defaults
+                merged = { ...defaults, ...sandbox };
             }
         }
-        // Auto-fill region with BL_REGION if not set
-        if (!payload["region"] && settings.region) {
-            payload["region"] = settings.region;
+        else {
+            merged = defaults;
         }
-        const baseInstance = await SandboxInstance.create(payload, { safe });
-        // Create config from the instance - preserve any forceUrl/headers if provided in input
+        const baseInstance = await super.create(merged, { safe });
+        // Create config from the instance
         const config = {
             metadata: baseInstance.metadata,
             spec: baseInstance.spec,
@@ -84,7 +70,7 @@ export class CodeInterpreter extends SandboxInstance {
             events: baseInstance.events,
             h2Session: baseInstance.h2Session,
         };
-        // Preserve forceUrl and headers from input if it was a dict-like object
+        // Preserve forceUrl, headers, and params from input if provided
         if (sandbox && typeof sandbox === "object" && !Array.isArray(sandbox)) {
             if ("forceUrl" in sandbox && typeof sandbox.forceUrl === "string") {
                 config.forceUrl = sandbox.forceUrl;
@@ -98,6 +84,9 @@ export class CodeInterpreter extends SandboxInstance {
         }
         return new CodeInterpreter(config);
     }
+    static async createIfNotExists(sandbox) {
+        return await super.createIfNotExists(sandbox);
+    }
     get _jupyterUrl() {
         return this.process.url;
     }

package/dist/esm/sandbox/sandbox.js

@@ -243,7 +243,7 @@ export class SandboxInstance {
     }
     static async createIfNotExists(sandbox) {
         try {
-            return await SandboxInstance.create(sandbox);
+            return await this.create(sandbox);
         }
         catch (e) {
             if (typeof e === "object" && e !== null && "code" in e && (e.code === 409 || e.code === 'SANDBOX_ALREADY_EXISTS')) {
@@ -252,11 +252,11 @@ export class SandboxInstance {
                     throw new Error("Sandbox name is required");
                 }
                 // Get the existing sandbox to check its status
-                const sandboxInstance = await SandboxInstance.get(name);
+                const sandboxInstance = await this.get(name);
                 // If the sandbox is TERMINATED, treat it as not existing
                 if (sandboxInstance.status === "TERMINATED") {
                     // Create a new sandbox - backend will handle cleanup of the terminated one
-                    return await SandboxInstance.create(sandbox);
+                    return await this.create(sandbox);
                 }
                 // Otherwise return the existing running sandbox
                 return sandboxInstance;