@blaxel/core 0.2.36-dev.185 → 0.2.36-dev.190

package/dist/esm/telemetry/telemetry.js

@@ -0,0 +1,74 @@
+// @blaxel/core/src/telemetry/interface.ts
+/**
+ * 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
+export const telemetryRegistry = TelemetryRegistry.getInstance();
+// Convenience functions that delegate to the provider
+/**
+ * Create a span with the registered provider
+ */
+export function startSpan(name, options) {
+    return telemetryRegistry.getProvider().startSpan(name, options);
+}
+export 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;
+    }
+}
+export async function flush() {
+    await telemetryRegistry.getProvider().flush();
+}

package/dist/esm/tools/index.js

@@ -0,0 +1,44 @@
+import { findFromCache } from "../cache/index.js";
+import { getFunction } from "../client/client.js";
+import { getForcedUrl } from "../common/internal.js";
+import { getMcpTool } from "./mcpTool.js";
+export const getTool = async (name, options) => {
+    return await getMcpTool(name, options);
+};
+export class BLTools {
+    toolNames;
+    constructor(toolNames) {
+        this.toolNames = toolNames;
+    }
+}
+export const blTools = (names) => {
+    return new BLTools(names);
+};
+export const blTool = (name) => {
+    return new BLTools([name]);
+};
+export const getToolMetadata = async (tool) => {
+    const forcedUrl = getForcedUrl('function', tool);
+    if (forcedUrl) {
+        return {
+            metadata: {
+                name: tool,
+            },
+            spec: {
+                runtime: {
+                    type: "mcp",
+                },
+            },
+        };
+    }
+    const cacheData = await findFromCache("Function", tool);
+    if (cacheData) {
+        return cacheData;
+    }
+    const { data } = await getFunction({
+        path: {
+            functionName: tool,
+        },
+    });
+    return data || null;
+};

package/dist/esm/tools/mcpTool.js

@@ -0,0 +1,213 @@
+import { Client as ModelContextProtocolClient } from "@modelcontextprotocol/sdk/client/index.js";
+import { env } from "../common/env.js";
+import { getForcedUrl, getGlobalUniqueHash } from "../common/internal.js";
+import { logger } from "../common/logger.js";
+import { settings } from "../common/settings.js";
+import { authenticate } from "../index.js";
+import { BlaxelMcpClientTransport } from "../mcp/client.js";
+import { startSpan } from "../telemetry/telemetry.js";
+import { schemaToZodSchema } from "./zodSchema.js";
+const McpToolCache = new Map();
+export 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.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 ModelContextProtocolClient({
+            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.runUrl}/${settings.workspace}/${this.pluralType}/${this.name}`);
+    }
+    get internalUrl() {
+        const hash = getGlobalUniqueHash(settings.workspace, this.type, this.name);
+        return new URL(`${settings.runInternalProtocol}://bl-${settings.env}-${hash}.${settings.runInternalHostname}`);
+    }
+    get forcedUrl() {
+        return getForcedUrl(this.type, this.name);
+    }
+    get url() {
+        if (this.forcedUrl)
+            return this.forcedUrl;
+        if (settings.runInternalHostname)
+            return this.internalUrl;
+        return this.externalUrl;
+    }
+    async start() {
+        logger.debug(`MCP:${this.name}:start`);
+        this.stopCloseTimer();
+        this.startPromise = this.startPromise || (async () => {
+            await authenticate();
+            try {
+                logger.debug(`MCP:${this.name}:Connecting::${this.url.toString()}`);
+                this.transport = new BlaxelMcpClientTransport(this.url.toString(), settings.headers, { retry: { max: 0 } });
+                await this.client.connect(this.transport);
+                logger.debug(`MCP:${this.name}:Connected`);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    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.debug(`MCP:${this.name}:Connecting to fallback`);
+                this.transport = new BlaxelMcpClientTransport(this.fallbackUrl.toString(), settings.headers);
+                await this.client.connect(this.transport);
+                logger.debug(`MCP:${this.name}:Connected to fallback`);
+            }
+        })();
+        return await this.startPromise;
+    }
+    async close(now = false) {
+        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.debug(`MCP:${this.name}:CloseTimer`);
+            delete this.startPromise;
+            this.client.close().catch((err) => {
+                if (err instanceof Error) {
+                    logger.error(`MCP ${this.name} close failed: ${err.message}`, {
+                        error: err.message,
+                        stack: err.stack,
+                        mcpName: this.name
+                    });
+                }
+            });
+        }, now ? 0 : this.ms);
+    }
+    stopCloseTimer() {
+        logger.debug(`MCP:${this.name}:StopCloseTimer`);
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+    }
+    async listTools() {
+        const span = startSpan(this.name, {
+            attributes: {
+                "span.type": "tool.list",
+            },
+        });
+        try {
+            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: 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 = startSpan(this.name + "." + toolName, {
+            attributes: {
+                "span.type": "tool.call",
+                "tool.name": toolName,
+                "tool.args": JSON.stringify(args),
+            },
+        });
+        try {
+            logger.debug(`MCP:${this.name}:Tool calling`, toolName, JSON.stringify(args));
+            logger.debug(`MCP:${this.name}:Tool calling:start`);
+            await this.start();
+            logger.debug(`MCP:${this.name}:Tool calling:start2`);
+            const result = await this.client.callTool({
+                name: toolName,
+                arguments: args,
+                _meta: this.meta
+            });
+            logger.debug(`MCP:${this.name}:Tool calling:result`);
+            await this.close();
+            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.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();
+        }
+    }
+}
+export const getMcpTool = async (name, options) => {
+    let tool = McpToolCache.get(name);
+    if (!tool) {
+        logger.debug(`MCP:${name}:Creating new tool`);
+        tool = new McpTool(name, options);
+        McpToolCache.set(name, tool);
+    }
+    return await tool.listTools();
+};

package/dist/esm/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/tools/zodSchema.js

@@ -0,0 +1,43 @@
+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 const schemaToZodSchema = (schema) => {
+    const shape = {};
+    if (schema.properties) {
+        Object.entries(schema.properties).forEach(([key, param]) => {
+            let zodType;
+            switch (param.type) {
+                case "boolean":
+                    zodType = z.boolean();
+                    break;
+                case "number":
+                case "integer":
+                    zodType = z.number();
+                    break;
+                case "null":
+                    zodType = z.null();
+                    break;
+                case "array":
+                    zodType = z.array(schemaToZodSchema(param.items || {}));
+                    break;
+                case "object":
+                    zodType = schemaToZodSchema(param);
+                    break;
+                default:
+                    zodType = z.string();
+            }
+            if (param.description) {
+                zodType = zodType.describe(param.description);
+            }
+            shape[key] =
+                param.required || schema.required?.includes(key)
+                    ? zodType
+                    : zodType.optional();
+        });
+    }
+    return z.object(shape);
+};

package/dist/esm/volume/index.js

@@ -0,0 +1,109 @@
+import { v4 as uuidv4 } from "uuid";
+import { createVolume, deleteVolume, getVolume, listVolumes } from "../client/index.js";
+export 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-${uuidv4().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 createVolume({
+            body: volume,
+            throwOnError: true,
+        });
+        return new VolumeInstance(data);
+    }
+    static async get(volumeName) {
+        const { data } = await getVolume({
+            path: {
+                volumeName,
+            },
+            throwOnError: true,
+        });
+        return new VolumeInstance(data);
+    }
+    static async list() {
+        const { data } = await listVolumes({ throwOnError: true });
+        return data.map((volume) => new VolumeInstance(volume));
+    }
+    static async delete(volumeName) {
+        const { data } = await 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;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.36-dev.185",
+  "version": "0.2.36-dev.190",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -17,38 +17,22 @@
     "agent",
     "mcp"
   ],
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/cjs/types/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/cjs/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
     },
-    "./*": {
-      "import": {
-        "types": "./dist/*.d.ts",
-        "default": "./dist/*.js"
-      },
-      "require": {
-        "types": "./dist/*.d.ts",
-        "default": "./dist/*.js"
-      }
-    }
+    "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
       ".": [
-        "./dist/index.d.ts"
-      ],
-      "*": [
-        "./dist/*"
+        "./dist/cjs/types/index.d.ts"
       ]
     }
   },
@@ -79,14 +63,17 @@
     "vite": "^5.2.0",
     "vitest": "^1.5.0"
   },
-  "commit": "5fe52a30fa512d6defc5e18fa2d991ed887f7c18",
+  "commit": "fcb44cfa2e6fc7b7cc20cf8bf70e3bf380d74146",
   "scripts": {
     "lint": "eslint src/",
     "dev": "tsc --watch",
-    "build": "npm run build:inject-commit && tsc && npm run build:replace-imports",
-    "build:clean": "tsc",
+    "build": "npm run build:inject-commit && npm run build:cjs && npm run build:esm && npm run build:fix-esm && npm run build:esm-package && npm run build:replace-imports",
+    "build:cjs": "NODE_OPTIONS='--max-old-space-size=8192' tsc -p tsconfig.cjs.json",
+    "build:esm": "NODE_OPTIONS='--max-old-space-size=8192' tsc -p tsconfig.esm.json",
+    "build:fix-esm": "node fix-esm-imports.js",
+    "build:esm-package": "echo '{\"type\":\"module\"}' > dist/esm/package.json",
     "build:inject-commit": "node -e \"const fs=require('fs'),pkg=require('./package.json'),{execSync}=require('child_process');try{const commit=execSync('git rev-parse HEAD',{encoding:'utf8'}).trim();pkg.commit=commit;fs.writeFileSync('./package.json',JSON.stringify(pkg,null,'\\t')+'\\n');console.log('✅ Injected commit:',commit.substring(0,7))}catch(e){console.log('⚠️  Could not inject commit:',e.message)}\"",
-    "build:replace-imports": "node -e \"const fs=require('fs'),path=require('path'),pkg=require('./package.json');const settingsPath=path.join('dist','common','settings.js');if(fs.existsSync(settingsPath)){let content=fs.readFileSync(settingsPath,'utf8');content=content.replace(/require\\(\\\".*?\\/package\\.json\\\"\\)/g,JSON.stringify({version:pkg.version,commit:pkg.commit||'unknown'}));fs.writeFileSync(settingsPath,content);console.log('✅ Replaced package.json imports in compiled JS with version:',pkg.version,'commit:',(pkg.commit||'unknown').substring(0,7));}else{console.log('⚠️  Could not find',settingsPath,'to replace imports');}\"",
+    "build:replace-imports": "node -e \"const fs=require('fs'),path=require('path'),pkg=require('./package.json');const paths=['dist/cjs/common/settings.js','dist/esm/common/settings.js'];paths.forEach(settingsPath=>{if(fs.existsSync(settingsPath)){let content=fs.readFileSync(settingsPath,'utf8');content=content.replace(/require\\(\\\".*?\\/package\\.json\\\"\\)/g,JSON.stringify({version:pkg.version,commit:pkg.commit||'unknown'}));fs.writeFileSync(settingsPath,content);console.log('✅ Replaced imports in',settingsPath);}});\"",
     "test": "vitest --run",
     "test:watch": "vitest --watch"
   }