@xalia/agent 0.5.0

package/dist/mcpServerManager.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpServerManager = exports.McpServerInfo = void 0;
+exports.computeQualifiedName = computeQualifiedName;
+exports.splitQualifiedName = splitQualifiedName;
+exports.computeOpenAIToolList = computeOpenAIToolList;
+exports.mcpToolToOpenAITool = mcpToolToOpenAITool;
+const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const tokenAuth_1 = require("./tokenAuth");
+const assert_1 = require("assert");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const logger = (0, sdk_1.getLogger)();
+/**
+ * The (read-only) McpServerInfo to expose to external classes.  Callers
+ * should not modify this data directly.  Only through the McpServerManager
+ * class.
+ */
+class McpServerInfo {
+    constructor(tools) {
+        const toolsMap = {};
+        for (const mcpTool of tools) {
+            const toolName = mcpTool.name;
+            toolsMap[toolName] = mcpTool;
+        }
+        this.tools = tools;
+        this.toolsMap = toolsMap;
+        this.enabledToolsMap = {};
+    }
+    getEnabledTools() {
+        return this.enabledToolsMap;
+    }
+    getTools() {
+        return this.tools;
+    }
+    getTool(toolName) {
+        return this.toolsMap[toolName];
+    }
+}
+exports.McpServerInfo = McpServerInfo;
+/**
+ * The internal class holds server info and allows it to be updated. Managed
+ * by McpServerManager.  Do not access these methods except via the
+ * McpServerManager.
+ */
+class McpServerInfoInternal extends McpServerInfo {
+    constructor(client, tools) {
+        super(tools);
+        const callbacks = {};
+        for (const mcpTool of tools) {
+            const toolName = mcpTool.name;
+            // Create callback
+            const callback = async (argStr) => {
+                logger.debug(`cb for ${toolName} invoked with args (${typeof argStr}): ` +
+                    `${JSON.stringify(argStr)}`);
+                const argsObj = JSON.parse(argStr);
+                const toolResult = await client.callTool({
+                    name: toolName,
+                    arguments: argsObj,
+                });
+                logger.debug(`cb for ${toolName} returned: ${JSON.stringify(toolResult)}`);
+                (0, assert_1.strict)(typeof toolResult === "object");
+                const content = toolResult.content;
+                (0, assert_1.strict)(typeof content === "object");
+                (0, assert_1.strict)(content);
+                const content0 = content[0];
+                (0, assert_1.strict)(typeof content0 === "object");
+                const content0Text = content0.text;
+                (0, assert_1.strict)(typeof content0Text === "string");
+                return content0Text;
+            };
+            callbacks[toolName] = callback;
+        }
+        this.client = client;
+        this.callbacks = callbacks;
+    }
+    async shutdown() {
+        await this.client.close();
+    }
+    enableTool(toolName) {
+        this.enabledToolsMap[toolName] = true;
+    }
+    disableTool(toolName) {
+        delete this.enabledToolsMap[toolName];
+    }
+    getCallback(toolName) {
+        return this.callbacks[toolName];
+    }
+}
+/**
+ * Manage a set of MCP servers, where the tools for each server have an
+ * 'enabled' flag.  Tools are disabled by default.  The set of enabled tools
+ * over all servers is exposed as a single list of OpenAI functions.
+ */
+class McpServerManager {
+    constructor() {
+        this.mcpServers = {};
+        this.enabledToolsDirty = true;
+        this.enabledOpenAITools = [];
+    }
+    async shutdown() {
+        await Promise.all(Object.keys(this.mcpServers).map((name) => {
+            logger.debug(`shutting down: ${name}...`);
+            this.mcpServers[name].shutdown();
+        }));
+        this.mcpServers = {};
+    }
+    getMcpServerNames() {
+        return Object.keys(this.mcpServers);
+    }
+    getMcpServer(mcpServerName) {
+        return this.getMcpServerInternal(mcpServerName);
+    }
+    async addMcpServer(mcpServerName, url, apiKey, tools) {
+        logger.debug(`Adding mcp server ${mcpServerName}: ${url}`);
+        const sseTransportOptions = {};
+        if (apiKey) {
+            sseTransportOptions.authProvider = new tokenAuth_1.TokenAuth(apiKey);
+        }
+        const urlO = new URL(url);
+        const transport = new sse_js_1.SSEClientTransport(urlO, sseTransportOptions);
+        const client = new index_js_1.Client({
+            name: "@xalia/agent",
+            version: "1.0.0",
+        });
+        try {
+            await client.connect(transport);
+        }
+        catch (e) {
+            // TODO: is this catch necessary?
+            await client.close();
+            throw e;
+        }
+        await this.addMcpServerWithClient(client, mcpServerName, tools);
+    }
+    /**
+     * Add MCP server from an already connected McpClient.
+     */
+    async addMcpServerWithClient(client, mcpServerName, tools) {
+        try {
+            // TODO; require the tools to be passed in.
+            if (!tools) {
+                const mcpTools = await client.listTools();
+                tools = mcpTools.tools;
+            }
+            this.mcpServers[mcpServerName] = new McpServerInfoInternal(client, tools);
+        }
+        catch (e) {
+            await client.close();
+            throw e;
+        }
+    }
+    async removeMcpServer(mcpServerName) {
+        const server = this.getMcpServerInternal(mcpServerName);
+        delete this.mcpServers[mcpServerName];
+        await server.shutdown();
+        this.enabledToolsDirty = true;
+    }
+    enableAllTools(mcpServerName) {
+        logger.debug(`enableAllTools: ${mcpServerName}`);
+        const server = this.getMcpServerInternal(mcpServerName);
+        for (const tool of server.getTools()) {
+            logger.debug(`enable: ${tool.name}`);
+            server.enableTool(tool.name);
+        }
+        this.enabledToolsDirty = true;
+    }
+    disableAllTools(mcpServerName) {
+        logger.debug(`disableAllTools: ${mcpServerName}`);
+        const server = this.getMcpServerInternal(mcpServerName);
+        for (const tool of server.getTools()) {
+            logger.debug(`disable: ${tool.name}`);
+            server.disableTool(tool.name);
+        }
+        this.enabledToolsDirty = true;
+    }
+    enableTool(mcpServerName, toolName) {
+        logger.debug(`enableTool: ${mcpServerName} ${toolName}`);
+        const server = this.getMcpServerInternal(mcpServerName);
+        server.enableTool(toolName);
+        this.enabledToolsDirty = true;
+    }
+    disableTool(mcpServerName, toolName) {
+        const server = this.getMcpServerInternal(mcpServerName);
+        server.disableTool(toolName);
+        this.enabledToolsDirty = true;
+    }
+    getOpenAITools() {
+        if (this.enabledToolsDirty) {
+            this.enabledOpenAITools = computeOpenAIToolList(this.mcpServers);
+            this.enabledToolsDirty = false;
+        }
+        return this.enabledOpenAITools;
+    }
+    /**
+     * Note the `qualifiedToolName` is the full `{mcpServerName}/{toolName}` as
+     * in the openai spec.
+     */
+    async invoke(qualifiedToolName, args) {
+        const [mcpServerName, toolName] = splitQualifiedName(qualifiedToolName);
+        logger.debug(`invoke: qualified: ${qualifiedToolName}`);
+        logger.debug(`invoke: mcpServerName: ${mcpServerName}, toolName: ${toolName}`);
+        logger.debug(`invoke: args: ${JSON.stringify(args)}`);
+        const server = this.getMcpServerInternal(mcpServerName);
+        const cb = server.getCallback(toolName);
+        if (!cb) {
+            throw `Unknown tool ${qualifiedToolName}`;
+        }
+        return cb(JSON.stringify(args));
+    }
+    /**
+     * "Settings" refers to the set of added servers and enabled tools.
+     */
+    getMcpServerSettings() {
+        const config = {};
+        // NOTE: on load, entires of the form:
+        //
+        //   <server>: []
+        //
+        // may be interpreted as "all tools for <server>".  If the client has left
+        // a server with no tools enabled, we mark it as disabled.
+        for (const [serverName, server] of Object.entries(this.mcpServers)) {
+            const tools = Object.keys(server.getEnabledTools());
+            if (tools.length > 0) {
+                config[serverName] = tools;
+            }
+        }
+        return config;
+    }
+    getMcpServerInternal(mcpServerName) {
+        const server = this.mcpServers[mcpServerName];
+        if (server) {
+            return server;
+        }
+        throw Error(`unknown server ${mcpServerName}`);
+    }
+}
+exports.McpServerManager = McpServerManager;
+function computeQualifiedName(mcpServerName, toolName) {
+    return `${mcpServerName}__${toolName}`;
+}
+function splitQualifiedName(qualifiedToolName) {
+    const delimIdx = qualifiedToolName.indexOf("__");
+    if (delimIdx < 0) {
+        throw Error(`invalid qualified name: ${qualifiedToolName}`);
+    }
+    return [
+        qualifiedToolName.slice(0, delimIdx),
+        qualifiedToolName.slice(delimIdx + 2),
+    ];
+}
+function computeOpenAIToolList(mcpServers) {
+    const openaiTools = [];
+    for (const mcpServerName in mcpServers) {
+        const mcpServer = mcpServers[mcpServerName];
+        const tools = mcpServer.getTools();
+        const enabled = mcpServer.getEnabledTools();
+        for (const mcpTool of tools) {
+            const toolName = mcpTool.name;
+            if (enabled[toolName]) {
+                const qualifiedName = computeQualifiedName(mcpServerName, toolName);
+                const openaiTool = mcpToolToOpenAITool(mcpTool, qualifiedName);
+                openaiTools.push(openaiTool);
+            }
+        }
+    }
+    return openaiTools;
+}
+function mcpToolToOpenAITool(tool, qualifiedName) {
+    return {
+        type: "function",
+        function: {
+            name: qualifiedName || tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema,
+        },
+    };
+}

package/dist/nodePlatform.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE_PLATFORM = void 0;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+/**
+ * Implementation of the IPlatform interface for node.js
+ */
+exports.NODE_PLATFORM = {
+    openUrl: (url) => {
+        const platform = process.platform;
+        if (platform === "darwin") {
+            (0, child_process_1.execSync)(`open '${url}'`);
+        }
+        else if (platform === "linux") {
+            (0, child_process_1.execSync)(`xdg-open '${url}'`);
+        }
+        else if (platform === "win32") {
+            (0, child_process_1.execSync)(`start '${url}'`);
+        }
+        else {
+            throw `Unknown platform ${platform}`;
+        }
+    },
+    load: async (filename) => {
+        return fs.readFileSync(filename, { encoding: "utf8" });
+    },
+};

package/dist/openAILLM.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAILLM = void 0;
+const openai_1 = require("openai");
+class OpenAILLM {
+    constructor(apiKey, apiUrl, model) {
+        this.openai = new openai_1.OpenAI({
+            apiKey,
+            baseURL: apiUrl,
+            dangerouslyAllowBrowser: true,
+        });
+        this.model = model || "gpt-4o-mini";
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    getModel() {
+        return this.model;
+    }
+    getUrl() {
+        return this.openai.baseURL;
+    }
+    async getConversationResponse(messages, tools, onMessage) {
+        const completion = await this.openai.chat.completions.create({
+            model: this.model,
+            messages,
+            tools,
+        });
+        if (onMessage) {
+            const message = completion.choices[0].message;
+            if (message.content) {
+                await onMessage(message.content, true);
+            }
+        }
+        return completion;
+    }
+}
+exports.OpenAILLM = OpenAILLM;