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

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

@@ -0,0 +1,254 @@
+"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 streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const McpToolCache = new Map();
+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_js_1.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 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}/${this.pluralType}/${this.name}`);
+    }
+    get internalUrl() {
+        const url = (0, internal_js_1.generateInternalUrl)(settings_js_1.settings.workspace, this.type, this.name, settings_js_1.settings.env, settings_js_1.settings.runInternalProtocol, settings_js_1.settings.runInternalHostname, settings_js_1.settings.blCloud, settings_js_1.settings.workspaceId);
+        return new URL(url);
+    }
+    get forcedUrl() {
+        return (0, internal_js_1.getForcedUrl)(this.type, this.name);
+    }
+    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.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.transport = await this.getTransport(this.fallbackUrl);
+                await this.client.connect(this.transport);
+                logger_js_1.logger.debug(`MCP:${this.name}:Connected to fallback`);
+            }
+        })();
+        return await this.startPromise;
+    }
+    async close(now = false) {
+        logger_js_1.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_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(`MCP ${this.name} close failed: ${err.message}`, {
+                        error: err.message,
+                        stack: err.stack,
+                        mcpName: this.name
+                    });
+                }
+            });
+        }, now ? 0 : 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());
+            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,
+                _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;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                logger_js_1.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_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) => {
+    let tool = McpToolCache.get(name);
+    if (!tool) {
+        logger_js_1.logger.debug(`MCP:${name}:Creating new tool`);
+        tool = new McpTool(name, options);
+        McpToolCache.set(name, tool);
+    }
+    return await tool.listTools();
+};
+exports.getMcpTool = getMcpTool;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,50 @@
+"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":
+                case "integer":
+                    zodType = zod_1.default.number();
+                    break;
+                case "null":
+                    zodType = zod_1.default.null();
+                    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/dist/cjs-browser/types/agents/index.d.ts

@@ -0,0 +1,15 @@
+import { Agent } from "../client/index.js";
+declare class BlAgent {
+    agentName: string;
+    constructor(agentName: string);
+    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;
+    call(url: URL, input: Record<string, unknown> | string | undefined): Promise<Response>;
+    run(input: Record<string, unknown> | string | undefined): Promise<string>;
+}
+export declare const blAgent: (agentName: string) => BlAgent;
+export declare const getAgentMetadata: (agent: string) => Promise<Agent | null>;
+export {};

package/dist/cjs-browser/types/authentication/apikey.d.ts

@@ -0,0 +1,10 @@
+import { Credentials } from "./credentials.js";
+import { CredentialsType } from "./types.js";
+export declare class ApiKey extends Credentials {
+    private apiKey;
+    private credentials;
+    constructor(credentials: CredentialsType);
+    get workspace(): string;
+    get authorization(): string;
+    get token(): string;
+}

package/dist/cjs-browser/types/authentication/clientcredentials.d.ts

@@ -0,0 +1,17 @@
+import { Credentials } from "./credentials.js";
+import { CredentialsType } from "./types.js";
+export declare class ClientCredentials extends Credentials {
+    private clientCredentials;
+    private accessToken;
+    private credentials;
+    private currentPromise;
+    constructor(credentials: CredentialsType);
+    get workspace(): string;
+    needRefresh(): boolean;
+    authenticate(): Promise<void>;
+    private sleep;
+    processWithRetry(retry?: number): Promise<void>;
+    process(): Promise<void>;
+    get authorization(): string;
+    get token(): string;
+}

package/dist/cjs-browser/types/authentication/credentials.d.ts

@@ -0,0 +1,6 @@
+export declare class Credentials {
+    authenticate(): Promise<void>;
+    get workspace(): string;
+    get authorization(): string;
+    get token(): string;
+}

package/dist/cjs-browser/types/authentication/deviceMode.d.ts

@@ -0,0 +1,15 @@
+import { CredentialsType } from "./types.js";
+export declare class DeviceMode {
+    private refreshToken;
+    private deviceCode;
+    private accessToken;
+    private credentials;
+    private currentPromise;
+    constructor(credentials: CredentialsType);
+    get workspace(): string;
+    needRefresh(): boolean;
+    authenticate(): Promise<void>;
+    process(): Promise<void>;
+    get authorization(): string;
+    get token(): string;
+}

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

@@ -0,0 +1,3 @@
+import { Credentials } from "./credentials.js";
+import { DeviceMode } from "./deviceMode.js";
+export declare function authentication(): Credentials | DeviceMode;

package/dist/cjs-browser/types/authentication/types.d.ts

@@ -0,0 +1,9 @@
+export type CredentialsType = {
+    apiKey?: string;
+    clientCredentials?: string;
+    refresh_token?: string;
+    access_token?: string;
+    device_code?: string;
+    expires_in?: number;
+    workspace?: string;
+};

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

@@ -0,0 +1 @@
+export declare function findFromCache(resource: string, name: string): Promise<unknown | null>;

package/dist/cjs-browser/types/client/authentication.d.ts

@@ -0,0 +1,25 @@
+import { OptionsLegacyParser } from "@hey-api/client-fetch";
+type OauthTokenData = {
+    body: {
+        grant_type: 'client_credentials' | 'refresh_token' | 'device_code';
+        client_id?: string;
+        client_secret?: string;
+        device_code?: string;
+        refresh_token?: string;
+    };
+    authenticated?: boolean;
+};
+type OauthTokenResponse = {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    token_type: string;
+};
+type OauthTokenError = {
+    error: string;
+};
+/**
+ * Get a new oauth token
+ */
+export declare const oauthToken: <ThrowOnError extends boolean = false>(options: OptionsLegacyParser<OauthTokenData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<OauthTokenResponse, OauthTokenError, ThrowOnError>;
+export {};

package/dist/cjs-browser/types/client/client.d.ts

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { _Function as Function } from './types.gen.js';

package/dist/cjs-browser/types/client/client.gen.d.ts

@@ -0,0 +1,12 @@
+import type { ClientOptions } from './types.gen';
+import { type Config, type ClientOptions as DefaultClientOptions } from '@hey-api/client-fetch';
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> = (override?: Config<DefaultClientOptions & T>) => Config<Required<DefaultClientOptions> & T>;
+export declare const client: import("@hey-api/client-fetch").Client;

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

@@ -0,0 +1,2 @@
+export * from './types.gen.js';
+export * from './sdk.gen.js';

package/dist/cjs-browser/types/client/interceptors.d.ts

@@ -0,0 +1,3 @@
+type Interceptor = (request: Request, options: Record<string, unknown>) => Promise<Request | Response>;
+export declare const interceptors: Interceptor[];
+export {};