@blaxel/core 0.2.49-dev.214 → 0.2.49-dev1

package/dist/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/telemetry/telemetry.js

@@ -0,0 +1,80 @@
+"use strict";
+// @blaxel/core/src/telemetry/interface.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetryRegistry = void 0;
+exports.startSpan = startSpan;
+exports.withSpan = withSpan;
+exports.flush = flush;
+/**
+ * No-operation implementation of Span
+ */
+class NoopSpan {
+    setAttribute() { }
+    setAttributes() { }
+    recordException() { }
+    setStatus() { }
+    end() { }
+    getContext() { return null; }
+}
+/**
+ * No-operation implementation of TelemetryProvider
+ */
+class NoopTelemetryProvider {
+    startSpan() {
+        return new NoopSpan();
+    }
+    flush() {
+        return Promise.resolve();
+    }
+}
+/**
+ * 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;
+    }
+}
+// Export singleton instance
+exports.telemetryRegistry = TelemetryRegistry.getInstance();
+// Convenience functions that delegate to the provider
+/**
+ * Create a span with the registered provider
+ */
+function startSpan(name, options) {
+    return exports.telemetryRegistry.getProvider().startSpan(name, options);
+}
+async function withSpan(name, fn, options) {
+    const span = startSpan(name, options);
+    try {
+        const result = await fn();
+        span.end();
+        return result;
+    }
+    catch (error) {
+        span.recordException(error);
+        span.end();
+        throw error;
+    }
+}
+async function flush() {
+    await exports.telemetryRegistry.getProvider().flush();
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,11 @@
+import { Function } from "../client/client.js";
+import { ToolOptions } from "./mcpTool.js";
+import { Tool } from "./types.js";
+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/tools/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolMetadata = exports.blTool = exports.blTools = exports.BLTools = exports.getTool = void 0;
+const index_js_1 = require("../cache/index.js");
+const client_js_1 = require("../client/client.js");
+const internal_js_1 = require("../common/internal.js");
+const mcpTool_js_1 = require("./mcpTool.js");
+const getTool = async (name, options) => {
+    return await (0, mcpTool_js_1.getMcpTool)(name, options);
+};
+exports.getTool = getTool;
+class BLTools {
+    toolNames;
+    constructor(toolNames) {
+        this.toolNames = toolNames;
+    }
+}
+exports.BLTools = BLTools;
+const blTools = (names) => {
+    return new BLTools(names);
+};
+exports.blTools = blTools;
+const blTool = (name) => {
+    return new BLTools([name]);
+};
+exports.blTool = blTool;
+const getToolMetadata = async (tool) => {
+    const forcedUrl = (0, internal_js_1.getForcedUrl)('function', tool);
+    if (forcedUrl) {
+        return {
+            metadata: {
+                name: tool,
+            },
+            spec: {
+                runtime: {
+                    type: "mcp",
+                },
+            },
+        };
+    }
+    const cacheData = await (0, index_js_1.findFromCache)("Function", tool);
+    if (cacheData) {
+        return cacheData;
+    }
+    const { data } = await (0, client_js_1.getFunction)({
+        path: {
+            functionName: tool,
+        },
+    });
+    return data || null;
+};
+exports.getToolMetadata = getToolMetadata;

package/dist/tools/mcpTool.d.ts

@@ -0,0 +1,28 @@
+import { Tool } from "./types.js";
+export type ToolOptions = {
+    ms?: number;
+    meta?: Record<string, unknown> | undefined;
+};
+export declare class McpTool {
+    private name;
+    private type;
+    private pluralType;
+    private client;
+    private transport?;
+    private timer?;
+    private ms;
+    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>;
+}
+export declare const getMcpTool: (name: string, options?: ToolOptions | number) => Promise<Tool[]>;

package/dist/tools/mcpTool.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMcpTool = exports.McpTool = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const env_js_1 = require("../common/env.js");
+const internal_js_1 = require("../common/internal.js");
+const logger_js_1 = require("../common/logger.js");
+const settings_js_1 = require("../common/settings.js");
+const index_js_2 = require("../index.js");
+const client_js_1 = require("../mcp/client.js");
+const telemetry_js_1 = require("../telemetry/telemetry.js");
+const zodSchema_js_1 = require("./zodSchema.js");
+const McpToolCache = new Map();
+class McpTool {
+    name;
+    type;
+    pluralType;
+    client;
+    transport;
+    timer;
+    ms;
+    meta;
+    startPromise;
+    constructor(name, options = { ms: 5000 }) {
+        this.name = name;
+        this.type = "function";
+        this.pluralType = "functions";
+        if (name.startsWith("sandbox/") || name.startsWith("sandboxes/")) {
+            this.name = name.split("/")[1];
+            this.type = "sandbox";
+            this.pluralType = "sandboxes";
+        }
+        if (env_js_1.env.BL_CLOUD) {
+            this.ms = 0;
+        }
+        else {
+            this.ms = typeof options === "number" ? options : options.ms || 5000;
+        }
+        this.meta = (typeof options === "object" && options.meta) || undefined;
+        this.client = new index_js_1.Client({
+            name: this.name,
+            version: "1.0.0",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+    }
+    get fallbackUrl() {
+        if (this.externalUrl != this.url) {
+            return this.externalUrl;
+        }
+        return null;
+    }
+    get externalUrl() {
+        return new URL(`${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/${this.pluralType}/${this.name}`);
+    }
+    get internalUrl() {
+        const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, this.type, this.name);
+        return new URL(`${settings_js_1.settings.runInternalProtocol}://bl-${settings_js_1.settings.env}-${hash}.${settings_js_1.settings.runInternalHostname}`);
+    }
+    get forcedUrl() {
+        return (0, internal_js_1.getForcedUrl)(this.type, this.name);
+    }
+    get url() {
+        if (this.forcedUrl)
+            return this.forcedUrl;
+        if (settings_js_1.settings.runInternalHostname)
+            return this.internalUrl;
+        return this.externalUrl;
+    }
+    async start() {
+        logger_js_1.logger.debug(`MCP:${this.name}:start`);
+        this.stopCloseTimer();
+        this.startPromise = this.startPromise || (async () => {
+            await (0, index_js_2.authenticate)();
+            try {
+                logger_js_1.logger.debug(`MCP:${this.name}:Connecting::${this.url.toString()}`);
+                this.transport = new client_js_1.BlaxelMcpClientTransport(this.url.toString(), settings_js_1.settings.headers, { retry: { max: 0 } });
+                await this.client.connect(this.transport);
+                logger_js_1.logger.debug(`MCP:${this.name}:Connected`);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    logger_js_1.logger.error(`MCP ${this.name} connection failed: ${err.message}`, {
+                        error: err.message,
+                        stack: err.stack,
+                        mcpName: this.name,
+                        url: this.url
+                    });
+                }
+                if (!this.fallbackUrl) {
+                    throw err;
+                }
+                logger_js_1.logger.debug(`MCP:${this.name}:Connecting to fallback`);
+                this.transport = new client_js_1.BlaxelMcpClientTransport(this.fallbackUrl.toString(), settings_js_1.settings.headers);
+                await this.client.connect(this.transport);
+                logger_js_1.logger.debug(`MCP:${this.name}:Connected to fallback`);
+            }
+        })();
+        return await this.startPromise;
+    }
+    async close(now = false) {
+        logger_js_1.logger.debug(`MCP:${this.name}:Close in ${now ? 0 : this.ms}ms`);
+        if (now || !this.ms) {
+            if (this.timer) {
+                clearTimeout(this.timer);
+            }
+            delete this.startPromise;
+            return this.client.close();
+        }
+        this.timer = setTimeout(() => {
+            logger_js_1.logger.debug(`MCP:${this.name}:CloseTimer`);
+            delete this.startPromise;
+            this.client.close().catch((err) => {
+                if (err instanceof Error) {
+                    logger_js_1.logger.error(`MCP ${this.name} close failed: ${err.message}`, {
+                        error: err.message,
+                        stack: err.stack,
+                        mcpName: this.name
+                    });
+                }
+            });
+        }, now ? 0 : this.ms);
+    }
+    stopCloseTimer() {
+        logger_js_1.logger.debug(`MCP:${this.name}:StopCloseTimer`);
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+    }
+    async listTools() {
+        const span = (0, telemetry_js_1.startSpan)(this.name, {
+            attributes: {
+                "span.type": "tool.list",
+            },
+        });
+        try {
+            logger_js_1.logger.debug(`MCP:${this.name}:Listing tools`);
+            await this.start();
+            const { tools } = (await this.client.listTools());
+            await this.close();
+            const result = tools.map((tool) => {
+                return {
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: (0, zodSchema_js_1.schemaToZodSchema)(tool.inputSchema),
+                    originalSchema: tool.inputSchema,
+                    call: (input) => {
+                        return this.call(tool.name, input);
+                    },
+                };
+            });
+            span.setAttribute("tool.list.result", JSON.stringify(result));
+            return result;
+        }
+        catch (err) {
+            span.setStatus("error");
+            span.recordException(err);
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    }
+    async call(toolName, args) {
+        const span = (0, telemetry_js_1.startSpan)(this.name + "." + toolName, {
+            attributes: {
+                "span.type": "tool.call",
+                "tool.name": toolName,
+                "tool.args": JSON.stringify(args),
+            },
+        });
+        try {
+            logger_js_1.logger.debug(`MCP:${this.name}:Tool calling`, toolName, JSON.stringify(args));
+            logger_js_1.logger.debug(`MCP:${this.name}:Tool calling:start`);
+            await this.start();
+            logger_js_1.logger.debug(`MCP:${this.name}:Tool calling:start2`);
+            const result = await this.client.callTool({
+                name: toolName,
+                arguments: args,
+                _meta: this.meta
+            });
+            logger_js_1.logger.debug(`MCP:${this.name}:Tool calling:result`);
+            await this.close();
+            logger_js_1.logger.debug(`MCP:${this.name}:Tool result`, toolName, JSON.stringify(args));
+            span.setAttribute("tool.call.result", JSON.stringify(result));
+            return result;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                logger_js_1.logger.error(`MCP tool call failed: ${err.message}`, {
+                    error: err.message,
+                    stack: err.stack,
+                    mcpName: this.name,
+                    toolName,
+                    args: JSON.stringify(args)
+                });
+            }
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    }
+}
+exports.McpTool = McpTool;
+const getMcpTool = async (name, options) => {
+    let tool = McpToolCache.get(name);
+    if (!tool) {
+        logger_js_1.logger.debug(`MCP:${name}:Creating new tool`);
+        tool = new McpTool(name, options);
+        McpToolCache.set(name, tool);
+    }
+    return await tool.listTools();
+};
+exports.getMcpTool = getMcpTool;

package/dist/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/tools/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tools/zodSchema.d.ts

@@ -0,0 +1,9 @@
+import z from "zod";
+import { FunctionSchema } from "../client/index.js";
+/**
+ * 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>;

package/dist/tools/zodSchema.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaToZodSchema = void 0;
+const zod_1 = __importDefault(require("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.
+ */
+const schemaToZodSchema = (schema) => {
+    const shape = {};
+    if (schema.properties) {
+        Object.entries(schema.properties).forEach(([key, param]) => {
+            let zodType;
+            switch (param.type) {
+                case "boolean":
+                    zodType = zod_1.default.boolean();
+                    break;
+                case "number":
+                case "integer":
+                    zodType = zod_1.default.number();
+                    break;
+                case "null":
+                    zodType = zod_1.default.null();
+                    break;
+                case "array":
+                    zodType = zod_1.default.array((0, exports.schemaToZodSchema)(param.items || {}));
+                    break;
+                case "object":
+                    zodType = (0, exports.schemaToZodSchema)(param);
+                    break;
+                default:
+                    zodType = zod_1.default.string();
+            }
+            if (param.description) {
+                zodType = zodType.describe(param.description);
+            }
+            shape[key] =
+                param.required || schema.required?.includes(key)
+                    ? zodType
+                    : zodType.optional();
+        });
+    }
+    return zod_1.default.object(shape);
+};
+exports.schemaToZodSchema = schemaToZodSchema;

package/dist/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/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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.49-dev.214",
+  "version": "0.2.49-dev1",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -74,7 +74,7 @@
     "vite": "^5.2.0",
     "vitest": "^1.5.0"
   },
-  "commit": "3cd25c395e498b34304684d4d76a906f2cef14a9",
+  "commit": "3523e3d6b67057292fade1b12e304be6456fd2bc",
   "scripts": {
     "lint": "eslint src/",
     "dev": "tsc --watch",