@blaxel/core 0.2.43-dev.196 → 0.2.43-dev.199

package/dist/cjs-browser/types/sandbox/sandbox.d.ts

@@ -0,0 +1,33 @@
+import { Sandbox as SandboxModel } from "../client/index.js";
+import { SandboxFileSystem } from "./filesystem/index.js";
+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, SandboxUpdateMetadata, SessionWithToken } from "./types.js";
+export declare class SandboxInstance {
+    private sandbox;
+    fs: SandboxFileSystem;
+    network: SandboxNetwork;
+    process: SandboxProcess;
+    previews: SandboxPreviews;
+    sessions: SandboxSessions;
+    constructor(sandbox: SandboxConfiguration);
+    get metadata(): import("../client/types.gen.js").Metadata | undefined;
+    get status(): string | undefined;
+    get events(): import("../client/types.gen.js").CoreEvents | undefined;
+    get spec(): import("../client/types.gen.js").SandboxSpec | undefined;
+    wait({ maxWait, interval }?: {
+        maxWait?: number;
+        interval?: number;
+    }): Promise<this>;
+    static create(sandbox?: SandboxModel | SandboxCreateConfiguration, { safe }?: {
+        safe?: boolean;
+    }): Promise<SandboxInstance>;
+    static get(sandboxName: string): Promise<SandboxInstance>;
+    static list(): Promise<SandboxInstance[]>;
+    static delete(sandboxName: string): Promise<SandboxModel>;
+    static updateMetadata(sandboxName: string, metadata: SandboxUpdateMetadata): Promise<SandboxInstance>;
+    static createIfNotExists(sandbox: SandboxModel | SandboxCreateConfiguration): Promise<SandboxInstance>;
+    static fromSession(session: SessionWithToken): Promise<SandboxInstance>;
+}

package/dist/cjs-browser/types/sandbox/session.d.ts

@@ -0,0 +1,27 @@
+import { Sandbox } from "../client/index.js";
+import { SessionCreateOptions, SessionWithToken } from "./types.js";
+export declare class SandboxSessions {
+    private sandbox;
+    constructor(sandbox: Sandbox);
+    get sandboxName(): string;
+    create(options?: SessionCreateOptions): Promise<SessionWithToken>;
+    createIfExpired(options?: SessionCreateOptions, delta?: number): Promise<{
+        name: string;
+        url: string;
+        token: string;
+        expiresAt: string | Date;
+    }>;
+    list(): Promise<{
+        name: string;
+        url: string;
+        token: string;
+        expiresAt: string | Date;
+    }[]>;
+    get(name: string): Promise<{
+        url: string;
+        token: string;
+        expiresAt: string | Date;
+    }>;
+    delete(name: string): Promise<import("../client/types.gen.js").Preview>;
+    getToken(previewName: string): Promise<import("../client/types.gen.js").PreviewToken | null>;
+}

package/dist/cjs-browser/types/sandbox/types.d.ts

@@ -0,0 +1,52 @@
+import { Port, Sandbox, SandboxLifecycle, VolumeAttachment } from "../client/types.gen";
+import { PostProcessResponse, ProcessRequest } from "./client";
+export interface SessionCreateOptions {
+    expiresAt?: Date;
+    responseHeaders?: Record<string, string>;
+    requestHeaders?: Record<string, string>;
+}
+export interface SessionWithToken {
+    name: string;
+    url: string;
+    token: string;
+    expiresAt: Date;
+}
+export interface EnvVar {
+    name: string;
+    value: string;
+}
+export interface VolumeBinding {
+    name: string;
+    mountPath: string;
+    readOnly?: boolean;
+}
+export type SandboxConfiguration = {
+    forceUrl?: string;
+    headers?: Record<string, string>;
+    params?: Record<string, string>;
+} & Sandbox;
+export type SandboxUpdateMetadata = {
+    labels?: Record<string, string>;
+    displayName?: string;
+};
+export type SandboxCreateConfiguration = {
+    name?: string;
+    image?: string;
+    memory?: number;
+    ports?: (Port | Record<string, any>)[];
+    envs?: EnvVar[];
+    volumes?: (VolumeBinding | VolumeAttachment)[];
+    ttl?: string;
+    expires?: Date;
+    region?: string;
+    lifecycle?: SandboxLifecycle;
+};
+export declare function normalizePorts(ports?: (Port | Record<string, any>)[]): Port[] | undefined;
+export declare function normalizeEnvs(envs?: EnvVar[]): EnvVar[] | undefined;
+export declare function normalizeVolumes(volumes?: (VolumeBinding | VolumeAttachment)[]): VolumeAttachment[] | undefined;
+export type ProcessRequestWithLog = ProcessRequest & {
+    onLog?: (log: string) => void;
+};
+export type ProcessResponseWithLog = PostProcessResponse & {
+    close: () => void;
+};

package/dist/cjs-browser/types/telemetry/telemetry.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Options for creating a span
+ */
+export interface BlaxelSpanOptions {
+    /** Key-value attributes to attach to the span */
+    attributes?: Record<string, string | number | boolean>;
+    /** Parent span context, if any */
+    parentContext?: unknown;
+    /** Whether this is a root span */
+    isRoot?: boolean;
+}
+/**
+ * Represents a telemetry span
+ */
+export interface BlaxelSpan {
+    /** Add an attribute to the span */
+    setAttribute(key: string, value: string | number | boolean): void;
+    /** Add multiple attributes to the span */
+    setAttributes(attributes: Record<string, string | number | boolean>): void;
+    /** Record an error on the span */
+    recordException(error: Error): void;
+    /** Set the status of the span */
+    setStatus(status: 'ok' | 'error', message?: string): void;
+    /** End the span */
+    end(): void;
+    /** Get the span context (for passing to child spans) */
+    getContext(): unknown;
+}
+/**
+ * Provider interface for telemetry functionality
+ */
+export interface BlaxelTelemetryProvider {
+    /** Create a new span */
+    startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
+    /** Flush the telemetry provider */
+    flush(): Promise<void>;
+}
+/**
+ * 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;
+/**
+ * Create a span with the registered provider
+ */
+export declare function startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
+export declare function withSpan<T>(name: string, fn: () => Promise<T>, options?: BlaxelSpanOptions): Promise<T>;
+export declare function flush(): Promise<void>;
+export {};

package/dist/cjs-browser/types/tools/index.d.ts

@@ -0,0 +1,12 @@
+import { Function } from "../client/client.js";
+import { ToolOptions } from "./mcpTool.js";
+import { Tool } from "./types.js";
+export type { ToolOptions };
+export declare const getTool: (name: string, options?: number | ToolOptions) => Promise<Tool[]>;
+export declare class BLTools {
+    toolNames: string[];
+    constructor(toolNames: string[]);
+}
+export declare const blTools: (names: string[]) => BLTools;
+export declare const blTool: (name: string) => BLTools;
+export declare const getToolMetadata: (tool: string) => Promise<Function | null>;

package/dist/cjs-browser/types/tools/mcpTool.d.ts

@@ -0,0 +1,33 @@
+import { BlaxelMcpClientTransport } from "../mcp/client.js";
+import { Tool } from "./types.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+export type ToolOptions = {
+    ms?: number;
+    meta?: Record<string, unknown> | undefined;
+    transport?: string;
+};
+export declare class McpTool {
+    private name;
+    private type;
+    private pluralType;
+    private client;
+    private transport?;
+    private timer?;
+    private ms;
+    private transportName?;
+    private meta;
+    private startPromise?;
+    constructor(name: string, options?: ToolOptions | number);
+    get fallbackUrl(): import("url").URL | null;
+    get externalUrl(): import("url").URL;
+    get internalUrl(): import("url").URL;
+    get forcedUrl(): import("url").URL | null;
+    get url(): import("url").URL;
+    start(): Promise<void>;
+    close(now?: boolean): Promise<void>;
+    stopCloseTimer(): void;
+    listTools(): Promise<Tool[]>;
+    call(toolName: string, args: Record<string, unknown> | undefined): Promise<unknown>;
+    getTransport(forcedUrl?: URL): Promise<BlaxelMcpClientTransport | StreamableHTTPClientTransport>;
+}
+export declare const getMcpTool: (name: string, options?: ToolOptions | number) => Promise<Tool[]>;

package/dist/cjs-browser/types/tools/types.d.ts

@@ -0,0 +1,8 @@
+import z from "zod";
+export type Tool = {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<any>;
+    originalSchema: object;
+    call(input: unknown): Promise<unknown>;
+};

package/dist/cjs-browser/types/tools/zodSchema.d.ts

@@ -0,0 +1,82 @@
+import z from "zod";
+/**
+ * Converts an array of `FunctionSchema` objects into a Zod schema for validation.
+ *
+ * @param {FunctionSchema} parameters - The parameters to convert.
+ * @returns {z.ZodObject<any>} A Zod object schema representing the parameters.
+ */
+export declare const schemaToZodSchema: (schema: FunctionSchema) => z.ZodObject<any>;
+/**
+* Function schema
+*/
+export type FunctionSchema = {
+    /**
+     * List of schemas that this schema extends
+     */
+    allOf?: Array<unknown>;
+    /**
+     * List of possible schemas, any of which this schema could be
+     */
+    anyOf?: Array<unknown>;
+    /**
+     * Description of the schema
+     */
+    description?: string;
+    /**
+     * Enum values
+     */
+    enum?: Array<string>;
+    /**
+     * Format of the schema
+     */
+    format?: string;
+    items?: FunctionSchema;
+    /**
+     * Maximum length for string types
+     */
+    maxLength?: number;
+    /**
+     * Maximum value for number types
+     */
+    maximum?: number;
+    /**
+     * Minimum length for string types
+     */
+    minLength?: number;
+    /**
+     * Minimum value for number types
+     */
+    minimum?: number;
+    /**
+     * Schema that this schema must not be
+     */
+    not?: {
+        [key: string]: unknown;
+    };
+    /**
+     * List of schemas, one of which this schema must be
+     */
+    oneOf?: Array<unknown>;
+    /**
+     * Pattern for string types
+     */
+    pattern?: string;
+    /**
+     * Properties of the schema
+     */
+    properties?: {
+        [key: string]: FunctionSchema;
+    };
+    /**
+     * Required properties of the schema
+     */
+    required?: Array<string>;
+    /**
+     * Title of the schema
+     */
+    title?: string;
+    /**
+     * Type of the schema
+     */
+    type?: string;
+};

package/dist/cjs-browser/types/volume/index.d.ts

@@ -0,0 +1,23 @@
+import { Volume } from "../client/index.js";
+export interface VolumeCreateConfiguration {
+    name?: string;
+    displayName?: string;
+    size?: number;
+    region?: string;
+}
+export declare class VolumeInstance {
+    private volume;
+    constructor(volume: Volume);
+    get metadata(): import("../client/types.gen.js").Metadata | undefined;
+    get spec(): import("../client/types.gen.js").VolumeSpec | undefined;
+    get status(): string | undefined;
+    get name(): string | undefined;
+    get displayName(): string | undefined;
+    get size(): number | undefined;
+    get region(): string | undefined;
+    static create(config: VolumeCreateConfiguration | Volume): Promise<VolumeInstance>;
+    static get(volumeName: string): Promise<VolumeInstance>;
+    static list(): Promise<VolumeInstance[]>;
+    static delete(volumeName: string): Promise<Volume>;
+    static createIfNotExists(config: VolumeCreateConfiguration | Volume): Promise<VolumeInstance>;
+}

package/dist/cjs-browser/volume/index.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolumeInstance = void 0;
+const uuid_1 = require("uuid");
+const index_js_1 = require("../client/index.js");
+class VolumeInstance {
+    volume;
+    constructor(volume) {
+        this.volume = volume;
+    }
+    get metadata() {
+        return this.volume.metadata;
+    }
+    get spec() {
+        return this.volume.spec;
+    }
+    get status() {
+        return this.volume.status;
+    }
+    get name() {
+        return this.volume.metadata?.name;
+    }
+    get displayName() {
+        return this.volume.metadata?.displayName;
+    }
+    get size() {
+        return this.volume.spec?.size;
+    }
+    get region() {
+        return this.volume.spec?.region;
+    }
+    static async create(config) {
+        const defaultName = `volume-${(0, uuid_1.v4)().replace(/-/g, '').substring(0, 8)}`;
+        const defaultSize = 1024; // 1GB in MB
+        let volume;
+        // Handle VolumeCreateConfiguration or simple config object
+        if ('spec' in config && 'metadata' in config) {
+            // It's already a Volume object
+            volume = config;
+        }
+        else {
+            // It's a VolumeCreateConfiguration
+            const volumeConfig = config;
+            volume = {
+                metadata: {
+                    name: volumeConfig.name || defaultName,
+                    displayName: volumeConfig.displayName || volumeConfig.name || defaultName
+                },
+                spec: {
+                    size: volumeConfig.size || defaultSize,
+                    region: volumeConfig.region
+                }
+            };
+        }
+        // Ensure required fields have defaults
+        if (!volume.metadata) {
+            volume.metadata = { name: defaultName };
+        }
+        if (!volume.metadata.name) {
+            volume.metadata.name = defaultName;
+        }
+        if (!volume.spec) {
+            volume.spec = { size: defaultSize };
+        }
+        if (!volume.spec.size) {
+            volume.spec.size = defaultSize;
+        }
+        const { data } = await (0, index_js_1.createVolume)({
+            body: volume,
+            throwOnError: true,
+        });
+        return new VolumeInstance(data);
+    }
+    static async get(volumeName) {
+        const { data } = await (0, index_js_1.getVolume)({
+            path: {
+                volumeName,
+            },
+            throwOnError: true,
+        });
+        return new VolumeInstance(data);
+    }
+    static async list() {
+        const { data } = await (0, index_js_1.listVolumes)({ throwOnError: true });
+        return data.map((volume) => new VolumeInstance(volume));
+    }
+    static async delete(volumeName) {
+        const { data } = await (0, index_js_1.deleteVolume)({
+            path: {
+                volumeName,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+    static async createIfNotExists(config) {
+        try {
+            return await VolumeInstance.create(config);
+        }
+        catch (e) {
+            if (typeof e === "object" && e !== null && "code" in e && (e.code === 409 || e.code === 'VOLUME_ALREADY_EXISTS')) {
+                const name = 'name' in config ? config.name : config.metadata?.name;
+                if (!name) {
+                    throw new Error("Volume name is required");
+                }
+                const volumeInstance = await VolumeInstance.get(name);
+                return volumeInstance;
+            }
+            throw e;
+        }
+    }
+}
+exports.VolumeInstance = VolumeInstance;