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

package/dist/esm-browser/tools/mcpTool.js

@@ -0,0 +1,249 @@
+import { Client as ModelContextProtocolClient } from "@modelcontextprotocol/sdk/client/index.js";
+import { env } from "../common/env.js";
+import { generateInternalUrl, getForcedUrl } 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";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+const McpToolCache = new Map();
+export class McpTool {
+    name;
+    type;
+    pluralType;
+    client;
+    transport;
+    timer;
+    ms;
+    transportName;
+    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 url = generateInternalUrl(settings.workspace, this.type, this.name, settings.env, settings.runInternalProtocol, settings.runInternalHostname, settings.blCloud, settings.workspaceId);
+        return new URL(url);
+    }
+    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 = await this.getTransport();
+                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 = await this.getTransport(this.fallbackUrl);
+                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();
+        }
+    }
+    async getTransport(forcedUrl) {
+        if (!this.transportName) {
+            // Detect transport type dynamically by querying the function's endpoint
+            try {
+                const testUrl = (forcedUrl || this.url).toString();
+                const response = await fetch(testUrl + "/", {
+                    method: "GET",
+                    headers: settings.headers,
+                });
+                const responseText = await response.text();
+                if (responseText.toLowerCase().includes("websocket")) {
+                    this.transportName = "websocket";
+                }
+                else {
+                    this.transportName = "http-stream";
+                }
+                logger.debug(`Detected transport type for ${this.name}: ${this.transportName}`);
+            }
+            catch (error) {
+                // Default to websocket if we can't determine the transport type
+                const message = error instanceof Error ? error.message : String(error);
+                logger.warn(`Failed to detect transport type for ${this.name}: ${message}. Defaulting to websocket.`);
+                this.transportName = "websocket";
+            }
+        }
+        const url = forcedUrl || this.url;
+        if (this.transportName === "http-stream") {
+            url.pathname = url.pathname + "/mcp";
+            return new StreamableHTTPClientTransport(url, { requestInit: { headers: settings.headers } });
+        }
+        else {
+            return new BlaxelMcpClientTransport(url.toString(), settings.headers, { retry: { max: 0 } });
+        }
+    }
+}
+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-browser/tools/types.js

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

package/dist/esm-browser/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-browser/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.43-dev.196",
+  "version": "0.2.43-dev.199",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -19,10 +19,21 @@
   ],
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
+  "browser": "./dist/esm-browser/index.js",
   "types": "./dist/cjs/types/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/cjs/types/index.d.ts",
+      "browser": {
+        "import": "./dist/esm-browser/index.js",
+        "require": "./dist/cjs-browser/index.js",
+        "default": "./dist/esm-browser/index.js"
+      },
+      "node": {
+        "import": "./dist/esm/index.js",
+        "require": "./dist/cjs/index.js",
+        "default": "./dist/cjs/index.js"
+      },
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js",
       "default": "./dist/cjs/index.js"
@@ -63,17 +74,18 @@
     "vite": "^5.2.0",
     "vitest": "^1.5.0"
   },
-  "commit": "06f9febf3efcdd8e281706bd186624c5f0c0a51b",
+  "commit": "f0e8fd40aacd9997e2a873e83577658212c0134f",
   "scripts": {
     "lint": "eslint src/",
     "dev": "tsc --watch",
-    "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": "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 && npm run build:browser",
     "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:browser": "node fix-browser-imports.js",
     "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 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);}});\"",
+    "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','dist/cjs-browser/common/settings.js','dist/esm-browser/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"
   }