@blaxel/core 0.2.73-preview.111 → 0.2.73

package/dist/cjs-browser/common/settings.js

@@ -9,8 +9,8 @@ const index_js_1 = require("../authentication/index.js");
 const env_js_1 = require("../common/env.js");
 const node_js_1 = require("../common/node.js");
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.2.73-preview.111";
-const BUILD_COMMIT = "be898ba36d0cf6922cdfac1bd3795180c34f14f4";
+const BUILD_VERSION = "0.2.73";
+const BUILD_COMMIT = "ca69d9d46e02efafefc83f2fe96e377b857b493a";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 // Cache for config.yaml tracking value
 let configTrackingValue = null;

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

@@ -1,9 +1,6 @@
 "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");
+exports.blTool = exports.blTools = exports.BLTools = exports.getTool = void 0;
 const mcpTool_js_1 = require("./mcpTool.js");
 const getTool = async (name, options) => {
     return await (0, mcpTool_js_1.getMcpTool)(name, options);
@@ -24,27 +21,3 @@ 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: {},
-            },
-        };
-    }
-    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/cjs-browser/tools/mcpTool.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMcpTool = exports.McpTool = void 0;
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const index_js_2 = require("../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 index_js_3 = require("../index.js");
 const telemetry_js_1 = require("../telemetry/telemetry.js");
 const zodSchema_js_1 = require("./zodSchema.js");
 const McpToolCache = new Map();
@@ -17,12 +17,11 @@ class McpTool {
     type;
     pluralType;
     client;
-    transport;
     timer;
     ms;
-    transportName;
     meta;
     startPromise;
+    metadataUrl;
     constructor(name, options = { ms: 5000 }) {
         this.name = name;
         this.type = "function";
@@ -44,69 +43,60 @@ class McpTool {
             version: "1.0.0",
         });
     }
-    get fallbackUrl() {
-        if (this.externalUrl != this.url) {
-            return this.externalUrl;
-        }
-        return null;
+    get forcedUrl() {
+        return (0, internal_js_1.getForcedUrl)(this.type, this.name);
     }
     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);
+    async fetchMetadataUrl() {
+        try {
+            if (this.type === "sandbox") {
+                const { data } = await (0, index_js_2.getSandbox)({ path: { sandboxName: this.name } });
+                if (data?.metadata?.url)
+                    return data.metadata.url;
+            }
+            else {
+                const { data } = await (0, index_js_2.getFunction)({ path: { functionName: this.name } });
+                if (data?.metadata?.url)
+                    return data.metadata.url;
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger_js_1.logger.debug(`Failed to fetch metadata URL for ${this.name}: ${message}`);
+        }
+        return null;
     }
-    get url() {
-        if (this.forcedUrl)
+    async resolveUrl() {
+        if (this.forcedUrl) {
+            logger_js_1.logger.debug(`MCP:${this.name}:ForcedURL:${this.forcedUrl.toString()}`);
             return this.forcedUrl;
-        if (settings_js_1.settings.runInternalHostname)
-            return this.internalUrl;
+        }
+        if (this.metadataUrl === undefined) {
+            this.metadataUrl = await this.fetchMetadataUrl();
+        }
+        if (this.metadataUrl) {
+            logger_js_1.logger.debug(`MCP:${this.name}:MetadataURL:${this.metadataUrl}`);
+            return new URL(this.metadataUrl);
+        }
+        logger_js_1.logger.debug(`MCP:${this.name}:FallingBackToExternalURL:${this.externalUrl.toString()}`);
         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)();
-            // Sandbox using run v2 API
-            if (this.pluralType == "sandboxes") {
-                const sandbox = await index_js_2.SandboxInstance.get(this.name);
-                const url = sandbox.metadata.url + "/mcp";
-                this.transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(url), {
-                    requestInit: { headers: settings_js_1.settings.headers },
-                });
-                await this.client.connect(this.transport);
-                logger_js_1.logger.debug(`MCP:${this.name}:Connected to sandbox`);
-                return;
-            }
-            try {
-                logger_js_1.logger.debug(`MCP:${this.name}:Connecting::${this.url.toString()}`);
-                this.transport = await this.getTransport();
-                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.transportName = undefined;
-                this.transport = await this.getTransport(this.fallbackUrl);
-                await this.client.connect(this.transport);
-                logger_js_1.logger.debug(`MCP:${this.name}:Connected to fallback`);
-            }
+            await (0, index_js_3.authenticate)();
+            const url = await this.resolveUrl();
+            const mcpUrl = new URL(url.toString());
+            mcpUrl.pathname = mcpUrl.pathname.replace(/\/$/, "") + "/mcp";
+            logger_js_1.logger.debug(`MCP:${this.name}:Connecting::${mcpUrl.toString()}`);
+            const transport = new streamableHttp_js_1.StreamableHTTPClientTransport(mcpUrl, {
+                requestInit: { headers: settings_js_1.settings.headers },
+            });
+            await this.client.connect(transport);
+            logger_js_1.logger.debug(`MCP:${this.name}:Connected`);
         })();
         return await this.startPromise;
     }
@@ -127,7 +117,7 @@ class McpTool {
                     logger_js_1.logger.error(`MCP ${this.name} close failed: ${err.message}`, {
                         error: err.message,
                         stack: err.stack,
-                        mcpName: this.name
+                        mcpName: this.name,
                     });
                 }
             });
@@ -184,17 +174,13 @@ class McpTool {
         });
         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
+                _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;
         }
@@ -205,7 +191,7 @@ class McpTool {
                     stack: err.stack,
                     mcpName: this.name,
                     toolName,
-                    args: JSON.stringify(args)
+                    args: JSON.stringify(args),
                 });
             }
             throw err;
@@ -214,40 +200,6 @@ class McpTool {
             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_js_1.settings.headers,
-                });
-                const responseText = await response.text();
-                if (responseText.toLowerCase().includes("websocket")) {
-                    this.transportName = "websocket";
-                }
-                else {
-                    this.transportName = "http-stream";
-                }
-                logger_js_1.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_js_1.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 streamableHttp_js_1.StreamableHTTPClientTransport(url, { requestInit: { headers: settings_js_1.settings.headers } });
-        }
-        else {
-            return new client_js_1.BlaxelMcpClientTransport(url.toString(), settings_js_1.settings.headers, { retry: { max: 0 } });
-        }
-    }
 }
 exports.McpTool = McpTool;
 const getMcpTool = async (name, options) => {

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

@@ -1,4 +1,3 @@
-import { Function } from "../client/client.js";
 import { ToolOptions } from "./mcpTool.js";
 import { Tool } from "./types.js";
 export type { ToolOptions };
@@ -9,4 +8,3 @@ export declare class BLTools {
 }
 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

@@ -1,33 +1,27 @@
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { BlaxelMcpClientTransport } from "../mcp/client.js";
 import { Tool } from "./types.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?;
+    private metadataUrl?;
     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;
+    get forcedUrl(): URL | null;
+    get externalUrl(): URL;
+    private fetchMetadataUrl;
+    private resolveUrl;
     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[]>;