@xalia/agent 1.0.19

package/dist/mcpServerManager.js

@@ -0,0 +1,269 @@
+"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 = {};
+        for (const [serverName, server] of Object.entries(this.mcpServers)) {
+            config[serverName] = structuredClone(server.getEnabledTools());
+        }
+        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,31 @@
+"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) {
+        return this.openai.chat.completions.create({
+            model: this.model,
+            messages,
+            tools,
+        });
+    }
+}
+exports.OpenAILLM = OpenAILLM;

package/dist/options.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openaiApiUrl = exports.openaiApiKey = exports.approveToolsUpTo = exports.approveTools = exports.oneShot = exports.llmModel = exports.systemPromptFile = exports.imageFile = exports.promptFile = void 0;
+exports.secretOption = secretOption;
+const cmd_ts_1 = require("cmd-ts");
+/// Prevents env content from being displayed in the help text.
+function secretOption({ long, short, env, description, }) {
+    if (env) {
+        return (0, cmd_ts_1.option)({
+            type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+            long,
+            short,
+            description: `${description} [env: ${env}]`,
+            defaultValue: () => process.env[env],
+            defaultValueIsSerializable: false, // hides the value from --help
+        });
+    }
+    return (0, cmd_ts_1.option)({
+        type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+        long,
+        short,
+        description: `${description} (can also be set via ${env} env var)`,
+    });
+}
+exports.promptFile = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+    long: "prompt",
+    short: "p",
+    description: "File containing user's first prompt to LLM",
+});
+exports.imageFile = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+    long: "image",
+    short: "i",
+    description: "File containing image input",
+});
+exports.systemPromptFile = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+    long: "sysprompt",
+    short: "s",
+    description: "File containing system prompt",
+});
+exports.llmModel = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+    long: "model",
+    short: "m",
+    description: "LLM model",
+    env: "LLM_MODEL",
+});
+exports.oneShot = (0, cmd_ts_1.flag)({
+    type: cmd_ts_1.boolean,
+    long: "one-shot",
+    short: "1",
+    description: "Exit after first reply (implies --approve-tools)",
+});
+exports.approveTools = (0, cmd_ts_1.flag)({
+    type: cmd_ts_1.boolean,
+    long: "approve-tools",
+    short: "y",
+    description: "Automatically approve all tool calls",
+});
+exports.approveToolsUpTo = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.number),
+    long: "approve-tools-up-to",
+    description: "Automatically approve all tool calls up to some number",
+});
+exports.openaiApiKey = secretOption({
+    long: "openai-api-key",
+    short: "o",
+    description: "OpenAI (or compatible protocol) API Key",
+    env: "OPENAI_API_KEY",
+});
+exports.openaiApiUrl = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+    long: "openai-api-url",
+    short: "u",
+    description: "OpenAI (or compatible protocol) RPC endpoint url",
+    env: "OPENAI_API_URL",
+});

package/dist/prompt.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Prompt = void 0;
+exports.parsePrompt = parsePrompt;
+const readline_1 = __importDefault(require("readline"));
+const DEFAULT_PROMPT = "USER: ";
+class Prompt {
+    constructor() {
+        this.prompt = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: DEFAULT_PROMPT,
+        });
+        this.prompt.on("line", (line) => {
+            this.line = line;
+            this.resolve();
+        });
+        this.prompt.on("close", () => {
+            this.line = undefined;
+            this.resolve();
+        });
+    }
+    async run(prompt) {
+        // Clear any line
+        this.line = "";
+        return new Promise((r) => {
+            this.online = r;
+            if (prompt) {
+                this.prompt.setPrompt(prompt);
+            }
+            this.prompt.prompt();
+            if (prompt) {
+                this.prompt.setPrompt(DEFAULT_PROMPT);
+            }
+        });
+    }
+    shutdown() {
+        this.prompt.close();
+    }
+    resolve() {
+        if (this.online) {
+            this.online(this.line);
+        }
+        this.online = undefined;
+    }
+}
+exports.Prompt = Prompt;
+/**
+ * Support prompts:
+ *  - some text                (msg: some text, cmds: undefined)
+ *  - :i image.png some text   (msg: some text, cmds: ["i", "image.png"])
+ *  - :i image.png             (msg: undefined, cmds: ["i", "image.png"])
+ *  - :l                       (msg: undefined, cmds: ["l"])
+ *  - :e toolName ..           (msg: undefined, cmds: ["e", "toolName", ...])
+ *  - :ea toolName ..          (msg: undefined, cmds: ["ea", "toolName", ...])
+ */
+function parsePrompt(prompt) {
+    prompt = prompt.trim();
+    let msg = undefined;
+    let cmds = undefined;
+    if (prompt.startsWith(":") || prompt.startsWith("/")) {
+        cmds = prompt.split(" ");
+        cmds[0] = cmds[0].slice(1);
+        if (cmds[0] == "i") {
+            // :i is special as it may have a trailing message
+            const fileDelim = prompt.indexOf(" ", 3);
+            if (fileDelim < 0) {
+                cmds = [cmds[0], prompt.slice(3)];
+            }
+            else {
+                msg = prompt.slice(fileDelim + 1);
+                cmds = [cmds[0], prompt.slice(3, fileDelim)];
+            }
+        }
+    }
+    else {
+        msg = prompt;
+    }
+    return { msg, cmds };
+}

package/dist/sudoMcpServerManager.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SudoMcpServerManager = exports.LOCAL_SERVER_URL = void 0;
+const sdk_1 = require("@xalia/xmcp/sdk");
+const assert_1 = require("assert");
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const logger = (0, sdk_1.getLogger)();
+exports.LOCAL_SERVER_URL = "http://localhost:5001";
+/**
+ * ServerBrief with sanitized name, and original name in another field.
+ */
+class SanitizedServerBrief extends sdk_1.McpServerBrief {
+    constructor() {
+        super("dummy", "dummy", "dummy", false, {}, "dummy", "dummy");
+        this.originalName = "dummy";
+    }
+    static fromServerBrief(brief) {
+        const b = brief;
+        const origName = brief.name;
+        b.originalName = origName; // eslint-disable-line
+        brief.name = sanitizeName(origName);
+        return b;
+    }
+}
+/**
+ * Manages access to the catalogue of servers hosted by sudomcp.  Supports
+ * adding these servers to McpServerManager.
+ */
+class SudoMcpServerManager {
+    constructor(mcpServerManager, apiClient, serverBriefs, serverBriefsMap, toolCache, openUrl, 
+    // Redirect to this page after successful authorization
+    authorized_url) {
+        this.mcpServerManager = mcpServerManager;
+        this.apiClient = apiClient;
+        this.serverBriefs = serverBriefs;
+        this.serverBriefsMap = serverBriefsMap;
+        this.toolCache = toolCache;
+        this.openUrl = openUrl;
+        this.authorized_url = authorized_url;
+    }
+    /**
+     * Initialize an ApiClient to interface with SudoMCP backend and
+     * fetch the current list of ServerBriefs.
+     */
+    static async initialize(mcpServerManager, openUrl, sudoMcpUrl, sudoMcpApiKey, authorized_url) {
+        // TODO: Keep it on here and pass to `McpServerManager.addMcpServer`
+        const apiClient = new sdk_1.ApiClient(sudoMcpUrl ?? sdk_1.DEFAULT_SERVER_URL, sudoMcpApiKey ?? "dummy_key");
+        // Fetch server list
+        const servers = await apiClient.search([]);
+        const [mcpServers, mcpServersMap] = buildServersList(servers);
+        return new SudoMcpServerManager(mcpServerManager, apiClient, mcpServers, mcpServersMap, {}, openUrl, authorized_url);
+    }
+    /// TODO: Bit awkward that we have to restore via this class, but it's the
+    /// only class which knows how to restore (restart) the mcp servers.
+    async restoreMcpSettings(mcpSettings, serverConfigs) {
+        await this.restoreConfiguration(mcpSettings, serverConfigs);
+    }
+    /**
+     * Load the configuration from sudomcp, and enable the specified tools.
+     */
+    async restoreConfiguration(mcpConfig, serverConfigs) {
+        logger.debug("Restoring Mcp config");
+        // TODO: remove existing servers?
+        for (const [serverName, enabled] of Object.entries(mcpConfig)) {
+            logger.debug(` restoring "${serverName}" ...`);
+            if (Object.keys(enabled).length === 0) {
+                logger.debug(` restoring "${serverName}": (empty)`);
+                continue;
+            }
+            const serverConfig = serverConfigs[serverName] ?? {};
+            logger.debug(` restoring ${serverName}: ${JSON.stringify(Object.keys(enabled))}`);
+            await this.addMcpServer(serverName, serverConfig);
+            for (const [toolName, v] of Object.entries(enabled)) {
+                (0, assert_1.strict)(v === true);
+                this.mcpServerManager.enableTool(serverName, toolName);
+            }
+        }
+    }
+    /**
+     * Query backend for server list, clear tool cache.
+     */
+    async refresh() {
+        const servers = await this.apiClient.search([]);
+        const [mcpServers, mcpServersMap] = buildServersList(servers);
+        this.serverBriefs = mcpServers;
+        this.serverBriefsMap = mcpServersMap;
+        this.toolCache = {};
+    }
+    getServerBriefs() {
+        return this.serverBriefs;
+    }
+    getMcpServerManager() {
+        return this.mcpServerManager;
+    }
+    /**
+     * Return tool list for a given MCP server. Queries the backend
+     * if necessary and caches the result.
+     */
+    async getServerTools(serverName) {
+        // Check cache
+        let tools = this.toolCache[serverName];
+        if (tools) {
+            return tools;
+        }
+        // Query backend (using the original name)
+        const originalName = this.serverBriefsMap[serverName].originalName;
+        tools = await this.apiClient.listTools(originalName);
+        this.toolCache[serverName] = tools;
+        return tools;
+    }
+    /**
+     * Add a server to the `McpServerManager`, using `ApiClient`
+     * to produce the transport. Validates the server's config
+     * schema, if applicable.
+     */
+    async addMcpServer(serverName, configuration) {
+        const tools = await this.getServerTools(serverName);
+        const originalName = this.serverBriefsMap[serverName].originalName;
+        const mcpserver = await this.apiClient.getDetails(originalName, "run");
+        (0, sdk_1.verifyConfigForServer)(mcpserver, configuration);
+        const client = new index_js_1.Client({
+            name: "@xalia/agent",
+            version: "1.0.0",
+        });
+        await connectServer(client, this.apiClient, mcpserver, configuration, this.openUrl, this.authorized_url);
+        await this.mcpServerManager.addMcpServerWithClient(client, serverName, tools);
+    }
+    getOriginalName(serverName) {
+        return this.serverBriefsMap[serverName].name;
+    }
+}
+exports.SudoMcpServerManager = SudoMcpServerManager;
+/**
+ * Connect a client to a hosted MCP server session,
+ * prompting for authentication if needed.
+ */
+async function connectServer(client, apiClient, mcpServer, config, openUrl, authorized_url, noRetry = false) {
+    const transport = apiClient.mcpSession(mcpServer, config ?? {});
+    await client.connect(transport).catch(async (e) => {
+        if (e instanceof sdk_1.AuthenticationRequired && !noRetry) {
+            logger.info("authentication required: " + e.msg);
+            const { url, authenticatedP } = await apiClient.authenticate(mcpServer.name, authorized_url);
+            logger.info(`authenticate at url: ${url}`);
+            openUrl(url);
+            const authResult = await authenticatedP;
+            logger.info(`authResult: ${authResult}`);
+            if (!authResult) {
+                throw "authentication failed";
+            }
+            return connectServer(client, apiClient, mcpServer, config, openUrl, authorized_url, true);
+        }
+        else {
+            throw e;
+        }
+    });
+}
+/**
+ * Given a list of`ServerBrief` objects, create the corresponding list and map
+ * of `SantiizedServerBrief` objects (namely, objects with sanitized names,
+ * holding the original name in a new field).
+ */
+function buildServersList(serverList) {
+    const servers = [];
+    const serversMap = {};
+    for (const s of serverList) {
+        const ss = SanitizedServerBrief.fromServerBrief(s);
+        servers.push(ss);
+        serversMap[ss.name] = ss;
+    }
+    return [servers, serversMap];
+}
+function sanitizeName(name) {
+    return name.replace("/", "_");
+}