@blaxel/core 0.2.0-dev1

package/dist/sandbox/sandbox.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxInstance = void 0;
+const index_js_1 = require("../client/index.js");
+const logger_js_1 = require("../common/logger.js");
+const filesystem_js_1 = require("./filesystem.js");
+const network_js_1 = require("./network.js");
+const process_js_1 = require("./process.js");
+class SandboxInstance {
+    sandbox;
+    fs;
+    network;
+    process;
+    constructor(sandbox) {
+        this.sandbox = sandbox;
+        this.fs = new filesystem_js_1.SandboxFileSystem(sandbox);
+        this.network = new network_js_1.SandboxNetwork(sandbox);
+        this.process = new process_js_1.SandboxProcess(sandbox);
+    }
+    get metadata() {
+        return this.sandbox.metadata;
+    }
+    get status() {
+        return this.sandbox.status;
+    }
+    get events() {
+        return this.sandbox.events;
+    }
+    get spec() {
+        return this.sandbox.spec;
+    }
+    async wait({ maxWait = 60000, interval = 1000 } = {}) {
+        const startTime = Date.now();
+        while (this.sandbox.status !== "DEPLOYED") {
+            await new Promise((resolve) => setTimeout(resolve, interval));
+            try {
+                const { data } = await (0, index_js_1.getSandbox)({
+                    path: {
+                        sandboxName: this.sandbox.metadata?.name ?? "",
+                    },
+                    throwOnError: true,
+                });
+                logger_js_1.logger.info(`Waiting for sandbox to be deployed, status: ${data.status}`);
+                this.sandbox = data;
+            }
+            catch (e) {
+                logger_js_1.logger.error("Could not retrieve sandbox", e);
+            }
+            if (this.sandbox.status === "FAILED") {
+                throw new Error("Sandbox failed to deploy");
+            }
+            if (Date.now() - startTime > maxWait) {
+                throw new Error("Sandbox did not deploy in time");
+            }
+        }
+    }
+    static async create(sandbox) {
+        if (sandbox.spec?.runtime?.generation == undefined) {
+            sandbox.spec = sandbox.spec ?? { runtime: {} };
+            sandbox.spec.runtime = sandbox.spec.runtime ?? {};
+            sandbox.spec.runtime.generation = "mk3";
+        }
+        const { data } = await (0, index_js_1.createSandbox)({
+            body: sandbox,
+            throwOnError: true,
+        });
+        return new SandboxInstance(data);
+    }
+    static async get(sandboxName) {
+        const { data } = await (0, index_js_1.getSandbox)({
+            path: {
+                sandboxName,
+            },
+            throwOnError: true,
+        });
+        return new SandboxInstance(data);
+    }
+    static async list() {
+        const { data } = await (0, index_js_1.listSandboxes)({ throwOnError: true });
+        return data.map((sandbox) => new SandboxInstance(sandbox));
+    }
+    static async delete(sandboxName) {
+        const { data } = await (0, index_js_1.deleteSandbox)({
+            path: {
+                sandboxName,
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
+}
+exports.SandboxInstance = SandboxInstance;

package/dist/telemetry/telemetry.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Options for creating a span
+ */
+export interface SpanOptions {
+    /** 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 Span {
+    /** 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 TelemetryProvider {
+    /** Create a new span */
+    startSpan(name: string, options?: SpanOptions): Span;
+}
+/**
+ * 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: TelemetryProvider): void;
+    /**
+     * Get the current telemetry provider
+     */
+    getProvider(): TelemetryProvider;
+}
+export declare const telemetryRegistry: TelemetryRegistry;
+/**
+ * Create a span with the registered provider
+ */
+export declare function startSpan(name: string, options?: SpanOptions): Span;
+export {};

package/dist/telemetry/telemetry.js

@@ -0,0 +1,59 @@
+"use strict";
+// @blaxel/core/src/telemetry/interface.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetryRegistry = void 0;
+exports.startSpan = startSpan;
+/**
+ * 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();
+    }
+}
+/**
+ * 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);
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,10 @@
+import { Function } from "../client/client.js";
+import { Tool } from "./types.js";
+export declare const getTool: (name: string) => 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 env_js_1 = require("../common/env.js");
+const mcpTool_js_1 = require("./mcpTool.js");
+const getTool = async (name) => {
+    return await (0, mcpTool_js_1.getMcpTool)(name);
+};
+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 envVar = tool.replace(/-/g, "_").toUpperCase();
+    if (env_js_1.env[`BL_FUNCTION_${envVar}_URL`]) {
+        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,21 @@
+import { Tool } from "./types.js";
+export declare class McpTool {
+    private name;
+    private client;
+    private transport?;
+    private timer?;
+    private ms;
+    private startPromise?;
+    constructor(name: string, ms?: 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(): Promise<void>;
+    stopCloseTimer(): void;
+    listTools(): Promise<Tool[]>;
+    call(toolName: string, args: Record<string, unknown> | undefined): Promise<unknown>;
+}
+export declare const getMcpTool: (name: string) => Promise<Tool[]>;

package/dist/tools/mcpTool.js

@@ -0,0 +1,193 @@
+"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;
+    client;
+    transport;
+    timer;
+    ms;
+    startPromise;
+    constructor(name, ms = 5000) {
+        this.name = name;
+        if (env_js_1.env.BL_CLOUD) {
+            this.ms = 0;
+        }
+        else {
+            this.ms = ms;
+        }
+        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}/functions/${this.name}`);
+    }
+    get internalUrl() {
+        const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, "function", this.name);
+        return new URL(`${settings_js_1.settings.runInternalProtocol}://bl-${settings_js_1.settings.env}-${hash}.${settings_js_1.settings.runInternalHostname}`);
+    }
+    get forcedUrl() {
+        const envVar = this.name.replace(/-/g, "_").toUpperCase();
+        if (env_js_1.env[`BL_FUNCTION_${envVar}_URL`]) {
+            return new URL(env_js_1.env[`BL_FUNCTION_${envVar}_URL`]);
+        }
+        return null;
+    }
+    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.transport = new client_js_1.BlaxelMcpClientTransport(this.url.toString(), settings_js_1.settings.headers);
+                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(err.stack);
+                }
+                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() {
+        logger_js_1.logger.debug(`MCP:${this.name}:Close in ${this.ms}ms`);
+        if (!this.ms) {
+            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(err.stack);
+                }
+            });
+        }, 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());
+            logger_js_1.logger.debug(`MCP:${this.name}:Listed tools result`, tools);
+            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,
+            });
+            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(err.stack);
+            }
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    }
+}
+exports.McpTool = McpTool;
+const getMcpTool = async (name) => {
+    let tool = McpToolCache.get(name);
+    if (!tool) {
+        logger_js_1.logger.debug(`MCP:${name}:Creating new tool`);
+        tool = new McpTool(name);
+        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,46 @@
+"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":
+                    zodType = zod_1.default.number();
+                    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/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@blaxel/core",
+  "version": "0.2.0-dev1",
+  "description": "Blaxel Core SDK for TypeScript",
+  "license": "MIT",
+  "author": "Blaxel, INC (https://blaxel.ai)",
+  "homepage": "https://blaxel.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/blaxel/toolkit/sdk-ts"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "blaxel",
+    "agent",
+    "mcp"
+  ],
+  "main": "dist/index.js",
+  "module": "./dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./*": {
+      "import": {
+        "types": "./dist/*.d.ts",
+        "default": "./dist/*.js"
+      },
+      "require": {
+        "types": "./dist/*.d.ts",
+        "default": "./dist/*.js"
+      }
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@hey-api/client-fetch": "^0.10.0",
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "crypto": "^1.0.1",
+    "jwt-decode": "^4.0.0",
+    "toml": "^3.0.0",
+    "uuid": "^11.1.0",
+    "ws": "^8.18.2",
+    "yaml": "^2.7.1",
+    "zod": "^3.24.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.26.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.31.1"
+  },
+  "scripts": {
+    "lint": "eslint src/",
+    "build": "tsc"
+  }
+}