@blaxel/core 0.2.73-preview.111 → 0.2.73

package/dist/esm/common/settings.js

@@ -3,8 +3,8 @@ import { authentication } from "../authentication/index.js";
 import { env } from "../common/env.js";
 import { fs, os, path } from "../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/esm/tools/index.js

@@ -1,6 +1,3 @@
-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);
@@ -17,26 +14,3 @@ export const 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: {},
-            },
-        };
-    }
-    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

@@ -1,11 +1,11 @@
 import { Client as ModelContextProtocolClient } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { getFunction, getSandbox } from "../client/index.js";
 import { env } from "../common/env.js";
-import { getForcedUrl, getGlobalUniqueHash } from "../common/internal.js";
+import { getForcedUrl } from "../common/internal.js";
 import { logger } from "../common/logger.js";
 import { settings } from "../common/settings.js";
-import { authenticate, SandboxInstance } from "../index.js";
-import { BlaxelMcpClientTransport } from "../mcp/client.js";
+import { authenticate } from "../index.js";
 import { startSpan } from "../telemetry/telemetry.js";
 import { schemaToZodSchema } from "./zodSchema.js";
 const McpToolCache = new Map();
@@ -14,12 +14,11 @@ export class McpTool {
     type;
     pluralType;
     client;
-    transport;
     timer;
     ms;
-    transportName;
     meta;
     startPromise;
+    metadataUrl;
     constructor(name, options = { ms: 5000 }) {
         this.name = name;
         this.type = "function";
@@ -41,27 +40,44 @@ export class McpTool {
             version: "1.0.0",
         });
     }
-    get fallbackUrl() {
-        if (this.externalUrl != this.url) {
-            return this.externalUrl;
-        }
-        return null;
+    get forcedUrl() {
+        return getForcedUrl(this.type, this.name);
     }
     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);
+    async fetchMetadataUrl() {
+        try {
+            if (this.type === "sandbox") {
+                const { data } = await getSandbox({ path: { sandboxName: this.name } });
+                if (data?.metadata?.url)
+                    return data.metadata.url;
+            }
+            else {
+                const { data } = await 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.debug(`Failed to fetch metadata URL for ${this.name}: ${message}`);
+        }
+        return null;
     }
-    get url() {
-        if (this.forcedUrl)
+    async resolveUrl() {
+        if (this.forcedUrl) {
+            logger.debug(`MCP:${this.name}:ForcedURL:${this.forcedUrl.toString()}`);
             return this.forcedUrl;
-        if (settings.runInternalHostname)
-            return this.internalUrl;
+        }
+        if (this.metadataUrl === undefined) {
+            this.metadataUrl = await this.fetchMetadataUrl();
+        }
+        if (this.metadataUrl) {
+            logger.debug(`MCP:${this.name}:MetadataURL:${this.metadataUrl}`);
+            return new URL(this.metadataUrl);
+        }
+        logger.debug(`MCP:${this.name}:FallingBackToExternalURL:${this.externalUrl.toString()}`);
         return this.externalUrl;
     }
     async start() {
@@ -69,41 +85,15 @@ export class McpTool {
         this.stopCloseTimer();
         this.startPromise = this.startPromise || (async () => {
             await authenticate();
-            // Sandbox using run v2 API
-            if (this.pluralType == "sandboxes") {
-                const sandbox = await SandboxInstance.get(this.name);
-                const url = sandbox.metadata.url + "/mcp";
-                this.transport = new StreamableHTTPClientTransport(new URL(url), {
-                    requestInit: { headers: settings.headers },
-                });
-                await this.client.connect(this.transport);
-                logger.debug(`MCP:${this.name}:Connected to sandbox`);
-                return;
-            }
-            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.transportName = undefined;
-                this.transport = await this.getTransport(this.fallbackUrl);
-                await this.client.connect(this.transport);
-                logger.debug(`MCP:${this.name}:Connected to fallback`);
-            }
+            const url = await this.resolveUrl();
+            const mcpUrl = new URL(url.toString());
+            mcpUrl.pathname = mcpUrl.pathname.replace(/\/$/, "") + "/mcp";
+            logger.debug(`MCP:${this.name}:Connecting::${mcpUrl.toString()}`);
+            const transport = new StreamableHTTPClientTransport(mcpUrl, {
+                requestInit: { headers: settings.headers },
+            });
+            await this.client.connect(transport);
+            logger.debug(`MCP:${this.name}:Connected`);
         })();
         return await this.startPromise;
     }
@@ -124,7 +114,7 @@ export class McpTool {
                     logger.error(`MCP ${this.name} close failed: ${err.message}`, {
                         error: err.message,
                         stack: err.stack,
-                        mcpName: this.name
+                        mcpName: this.name,
                     });
                 }
             });
@@ -181,17 +171,13 @@ export class McpTool {
         });
         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
+                _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;
         }
@@ -202,7 +188,7 @@ export class McpTool {
                     stack: err.stack,
                     mcpName: this.name,
                     toolName,
-                    args: JSON.stringify(args)
+                    args: JSON.stringify(args),
                 });
             }
             throw err;
@@ -211,40 +197,6 @@ export 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.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);