@blaxel/core 0.2.18-dev.157 → 0.2.18-preview.39

package/dist/client/types.gen.d.ts

@@ -733,9 +733,7 @@ export type JobMetrics = {
 /**
  * Job specification
  */
-export type JobSpec = CoreSpec & {
-    triggers?: Triggers;
-};
+export type JobSpec = CoreSpec & unknown;
 /**
  * Jobs chart
  */
@@ -2441,7 +2439,12 @@ export type TraceIdsResponse = {
  * Trigger configuration
  */
 export type Trigger = {
-    configuration?: TriggerConfiguration;
+    /**
+     * The configuration of the trigger
+     */
+    configuration?: {
+        [key: string]: unknown;
+    };
     /**
      * The id of the trigger
      */
@@ -2451,27 +2454,6 @@ export type Trigger = {
      */
     type?: string;
 };
-/**
- * Trigger configuration
- */
-export type TriggerConfiguration = {
-    /**
-     * The authentication type of the trigger
-     */
-    authenticationType?: string;
-    /**
-     * The path of the trigger
-     */
-    path?: string;
-    /**
-     * The retry of the trigger
-     */
-    retry?: number;
-    /**
-     * The schedule of the trigger, cron expression * * * * *
-     */
-    schedule?: string;
-};
 /**
  * Triggers to use your agent
  */

package/dist/sandbox/client/types.gen.d.ts

@@ -1,23 +1,23 @@
 export type Directory = {
-    files: Array<File>;
-    name: string;
-    path: string;
+    files?: Array<File>;
+    name?: string;
+    path?: string;
     /**
      * @name Subdirectories
      */
-    subdirectories: Array<Subdirectory>;
+    subdirectories?: Array<Subdirectory>;
 };
 export type ErrorResponse = {
-    error: string;
+    error?: string;
 };
 export type File = {
-    group: string;
-    lastModified: string;
-    name: string;
-    owner: string;
-    path: string;
-    permissions: string;
-    size: number;
+    group?: string;
+    lastModified?: string;
+    name?: string;
+    owner?: string;
+    path?: string;
+    permissions?: string;
+    size?: number;
 };
 export type FileRequest = {
     content?: string;
@@ -25,14 +25,14 @@ export type FileRequest = {
     permissions?: string;
 };
 export type FileWithContent = {
-    content: string;
-    group: string;
-    lastModified: string;
-    name: string;
-    owner: string;
-    path: string;
-    permissions: string;
-    size: number;
+    content?: string;
+    group?: string;
+    lastModified?: string;
+    name?: string;
+    owner?: string;
+    path?: string;
+    permissions?: string;
+    size?: number;
 };
 export type PortMonitorRequest = {
     /**
@@ -41,9 +41,9 @@ export type PortMonitorRequest = {
     callback?: string;
 };
 export type ProcessLogs = {
-    logs: string;
-    stderr: string;
-    stdout: string;
+    logs?: string;
+    stderr?: string;
+    stdout?: string;
 };
 export type ProcessRequest = {
     command: string;
@@ -57,23 +57,22 @@ export type ProcessRequest = {
     workingDir?: string;
 };
 export type ProcessResponse = {
-    command: string;
-    completedAt: string;
-    exitCode: number;
-    logs: string;
-    name: string;
-    pid: string;
-    startedAt: string;
-    status: 'failed' | 'killed' | 'stopped' | 'running' | 'completed';
-    workingDir: string;
+    command?: string;
+    completedAt?: string;
+    exitCode?: number;
+    name?: string;
+    pid?: string;
+    startedAt?: string;
+    status?: 'failed' | 'killed' | 'stopped' | 'running' | 'completed';
+    workingDir?: string;
 };
 export type Subdirectory = {
-    name: string;
-    path: string;
+    name?: string;
+    path?: string;
 };
 export type SuccessResponse = {
-    message: string;
-    path: string;
+    message?: string;
+    path?: string;
 };
 export type DeleteFilesystemByPathData = {
     body?: never;

package/dist/sandbox/client/types.gen.js

@@ -1,3 +1,4 @@
 "use strict";
+/* eslint-disable */
 // This file is auto-generated by @hey-api/openapi-ts
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sandbox/process/process.d.ts

@@ -10,7 +10,7 @@ export declare class SandboxProcess extends SandboxAction {
     }): {
         close: () => void;
     };
-    exec(process: ProcessRequest, onLog?: (log: string) => void): Promise<PostProcessResponse>;
+    exec(process: ProcessRequest): Promise<PostProcessResponse>;
     wait(identifier: string, { maxWait, interval }?: {
         maxWait?: number;
         interval?: number;

package/dist/sandbox/process/process.js

@@ -61,44 +61,14 @@ class SandboxProcess extends action_js_1.SandboxAction {
             close: () => controller.abort(),
         };
     }
-    async exec(process, onLog) {
-        // Store original wait_for_completion setting
-        const shouldWaitForCompletion = process.waitForCompletion;
-        // Always start process without wait_for_completion to avoid server-side blocking
-        if (shouldWaitForCompletion && onLog) {
-            process.waitForCompletion = false;
-        }
+    async exec(process) {
         const { response, data, error } = await (0, index_js_1.postProcess)({
             body: process,
             baseUrl: this.url,
             client: this.client,
         });
         this.handleResponseError(response, data, error);
-        let result = data;
-        // Handle wait_for_completion with parallel log streaming
-        if (shouldWaitForCompletion) {
-            let streamControl;
-            if (onLog) {
-                streamControl = this.streamLogs(result.pid, { onLog });
-            }
-            try {
-                // Wait for process completion
-                result = await this.wait(result.pid, { interval: 50 });
-            }
-            finally {
-                // Clean up log streaming
-                if (streamControl) {
-                    streamControl.close();
-                }
-            }
-        }
-        else {
-            // For non-blocking execution, set up log streaming immediately if requested
-            if (onLog) {
-                this.streamLogs(result.pid, { onLog });
-            }
-        }
-        return result;
+        return data;
     }
     async wait(identifier, { maxWait = 60000, interval = 1000 } = {}) {
         const startTime = Date.now();

package/dist/sandbox/sandbox.d.ts

@@ -4,7 +4,7 @@ import { SandboxNetwork } from "./network/index.js";
 import { SandboxPreviews } from "./preview.js";
 import { SandboxProcess } from "./process/index.js";
 import { SandboxSessions } from "./session.js";
-import { SandboxConfiguration, SandboxCreateConfiguration, SessionWithToken } from "./types.js";
+import { SandboxConfiguration, SessionWithToken } from "./types.js";
 export declare class SandboxInstance {
     private sandbox;
     fs: SandboxFileSystem;
@@ -21,10 +21,10 @@ export declare class SandboxInstance {
         maxWait?: number;
         interval?: number;
     }): Promise<void>;
-    static create(sandbox?: SandboxModel | SandboxCreateConfiguration): Promise<SandboxInstance>;
+    static create(sandbox: SandboxModel): Promise<SandboxInstance>;
     static get(sandboxName: string): Promise<SandboxInstance>;
     static list(): Promise<SandboxInstance[]>;
     static delete(sandboxName: string): Promise<SandboxModel>;
-    static createIfNotExists(sandbox: SandboxModel | SandboxCreateConfiguration): Promise<SandboxInstance>;
+    static createIfNotExists(sandbox: SandboxModel): Promise<SandboxInstance>;
     static fromSession(session: SessionWithToken): Promise<SandboxInstance>;
 }

package/dist/sandbox/sandbox.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxInstance = void 0;
-const uuid_1 = require("uuid");
 const index_js_1 = require("../client/index.js");
 const logger_js_1 = require("../common/logger.js");
 const index_js_2 = require("./filesystem/index.js");
@@ -62,36 +61,11 @@ class SandboxInstance {
         }
     }
     static async create(sandbox) {
-        const defaultName = `sandbox-${(0, uuid_1.v4)().replace(/-/g, '').substring(0, 8)}`;
-        const defaultImage = "blaxel/prod-base:latest";
-        const defaultMemory = 4096;
-        if (!sandbox || 'name' in sandbox || 'image' in sandbox || 'memory' in sandbox) {
-            if (!sandbox)
-                sandbox = {};
-            if (!sandbox.name)
-                sandbox.name = defaultName;
-            if (!sandbox.image)
-                sandbox.image = defaultImage;
-            if (!sandbox.memory)
-                sandbox.memory = defaultMemory;
-            sandbox = {
-                metadata: { name: sandbox.name },
-                spec: { runtime: { image: sandbox.image, memory: sandbox.memory, generation: "mk3" } }
-            };
+        if (sandbox.spec?.runtime?.generation == undefined) {
+            sandbox.spec = sandbox.spec ?? { runtime: {} };
+            sandbox.spec.runtime = sandbox.spec.runtime ?? {};
+            sandbox.spec.runtime.generation = "mk3";
         }
-        sandbox = sandbox;
-        if (!sandbox.metadata) {
-            sandbox.metadata = { name: crypto.randomUUID().replace(/-/g, '') };
-        }
-        if (!sandbox.spec) {
-            sandbox.spec = { runtime: { image: "blaxel/prod-base:latest" } };
-        }
-        if (!sandbox.spec.runtime) {
-            sandbox.spec.runtime = { image: defaultImage, memory: defaultMemory };
-        }
-        sandbox.spec.runtime.image = sandbox.spec.runtime.image || defaultImage;
-        sandbox.spec.runtime.memory = sandbox.spec.runtime.memory || defaultMemory;
-        sandbox.spec.runtime.generation = sandbox.spec.runtime.generation || "mk3";
         const { data } = await (0, index_js_1.createSandbox)({
             body: sandbox,
             throwOnError: true,
@@ -122,11 +96,7 @@ class SandboxInstance {
     }
     static async createIfNotExists(sandbox) {
         try {
-            const name = 'name' in sandbox ? sandbox.name : sandbox.metadata?.name;
-            if (!name) {
-                throw new Error("Sandbox name is required");
-            }
-            const sandboxInstance = await SandboxInstance.get(name);
+            const sandboxInstance = await SandboxInstance.get(sandbox.metadata?.name ?? "");
             return sandboxInstance;
         }
         catch (e) {
@@ -138,16 +108,7 @@ class SandboxInstance {
     }
     /* eslint-disable */
     static async fromSession(session) {
-        // Create a minimal sandbox configuration for session-based access
-        const sandboxName = session.name.includes("-") ? session.name.split("-")[0] : session.name;
-        const sandbox = {
-            metadata: { name: sandboxName },
-            forceUrl: session.url,
-            headers: { "X-Blaxel-Preview-Token": session.token },
-            params: { bl_preview_token: session.token }
-        };
-        // Create instance using constructor instead of direct property assignment
-        return new SandboxInstance(sandbox);
+        return new SandboxInstance({ forceUrl: session.url, params: { bl_preview_token: session.token }, headers: { "X-Blaxel-Preview-Token": session.token } });
     }
 }
 exports.SandboxInstance = SandboxInstance;

package/dist/sandbox/types.d.ts

@@ -15,8 +15,3 @@ export type SandboxConfiguration = {
     headers?: Record<string, string>;
     params?: Record<string, string>;
 } & Sandbox;
-export type SandboxCreateConfiguration = {
-    name?: string;
-    image?: string;
-    memory?: number;
-};

package/dist/telemetry/telemetry.d.ts

@@ -20,7 +20,7 @@ export interface BlaxelSpan {
     /** Record an error on the span */
     recordException(error: Error): void;
     /** Set the status of the span */
-    setStatus(status: "ok" | "error", message?: string): void;
+    setStatus(status: 'ok' | 'error', message?: string): void;
     /** End the span */
     end(): void;
     /** Get the span context (for passing to child spans) */
@@ -34,15 +34,22 @@ export interface BlaxelTelemetryProvider {
     startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
     /** Flush the telemetry provider */
     flush(): Promise<void>;
-    /** Extract context from headers for manual context propagation */
-    extractContextFromHeaders?(headers: Record<string, string | string[]>): unknown;
 }
 /**
- * Registry for telemetry providers
+ * Registry for managing the global telemetry provider
  */
 declare class TelemetryRegistry {
+    private static instance;
     private provider;
+    private constructor();
+    static getInstance(): TelemetryRegistry;
+    /**
+     * Register a telemetry provider implementation
+     */
     registerProvider(provider: BlaxelTelemetryProvider): void;
+    /**
+     * Get the current telemetry provider
+     */
     getProvider(): BlaxelTelemetryProvider;
 }
 export declare const telemetryRegistry: TelemetryRegistry;
@@ -51,18 +58,5 @@ export declare const telemetryRegistry: TelemetryRegistry;
  */
 export declare function startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
 export declare function withSpan<T>(name: string, fn: () => Promise<T>, options?: BlaxelSpanOptions): Promise<T>;
-/**
- * Extract context from headers - useful for manual context propagation
- * when you have traceparent headers but no active span
- */
-export declare function extractContextFromHeaders(headers: Record<string, string | string[]>): unknown;
-/**
- * Create a span with extracted context from headers
- * This is useful when you need to manually establish trace context
- */
-export declare function startSpanWithHeaders(name: string, headers: Record<string, string | string[]>, options?: Omit<BlaxelSpanOptions, "parentContext">): BlaxelSpan;
-/**
- * Flush the telemetry provider
- */
 export declare function flush(): Promise<void>;
 export {};

package/dist/telemetry/telemetry.js

@@ -4,8 +4,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.telemetryRegistry = void 0;
 exports.startSpan = startSpan;
 exports.withSpan = withSpan;
-exports.extractContextFromHeaders = extractContextFromHeaders;
-exports.startSpanWithHeaders = startSpanWithHeaders;
 exports.flush = flush;
 /**
  * No-operation implementation of Span
@@ -16,9 +14,7 @@ class NoopSpan {
     recordException() { }
     setStatus() { }
     end() { }
-    getContext() {
-        return null;
-    }
+    getContext() { return null; }
 }
 /**
  * No-operation implementation of TelemetryProvider
@@ -27,25 +23,38 @@ class NoopTelemetryProvider {
     startSpan() {
         return new NoopSpan();
     }
-    async flush() { }
-    extractContextFromHeaders() {
-        return null;
+    flush() {
+        return Promise.resolve();
     }
 }
 /**
- * Registry for telemetry providers
+ * Registry for managing the global telemetry provider
  */
 class TelemetryRegistry {
+    static instance;
     provider = new NoopTelemetryProvider();
+    constructor() { }
+    static getInstance() {
+        if (!TelemetryRegistry.instance) {
+            TelemetryRegistry.instance = new TelemetryRegistry();
+        }
+        return TelemetryRegistry.instance;
+    }
+    /**
+     * Register a telemetry provider implementation
+     */
     registerProvider(provider) {
         this.provider = provider;
     }
+    /**
+     * Get the current telemetry provider
+     */
     getProvider() {
         return this.provider;
     }
 }
-// Global instance
-exports.telemetryRegistry = new TelemetryRegistry();
+// Export singleton instance
+exports.telemetryRegistry = TelemetryRegistry.getInstance();
 // Convenience functions that delegate to the provider
 /**
  * Create a span with the registered provider
@@ -66,31 +75,6 @@ async function withSpan(name, fn, options) {
         throw error;
     }
 }
-/**
- * Extract context from headers - useful for manual context propagation
- * when you have traceparent headers but no active span
- */
-function extractContextFromHeaders(headers) {
-    const provider = exports.telemetryRegistry.getProvider();
-    if (provider.extractContextFromHeaders) {
-        return provider.extractContextFromHeaders(headers);
-    }
-    return null;
-}
-/**
- * Create a span with extracted context from headers
- * This is useful when you need to manually establish trace context
- */
-function startSpanWithHeaders(name, headers, options) {
-    const extractedContext = extractContextFromHeaders(headers);
-    return startSpan(name, {
-        ...options,
-        parentContext: extractedContext || undefined,
-    });
-}
-/**
- * Flush the telemetry provider
- */
 async function flush() {
-    return exports.telemetryRegistry.getProvider().flush();
+    await exports.telemetryRegistry.getProvider().flush();
 }

package/package.json

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