@xalia/agent 0.5.0 → 0.5.1

package/README.md

@@ -1,6 +1,6 @@
 # Sudobase Agent
 
-## Setup
+## Agent Setup
 
 ```sh
 # In the root folder
@@ -11,46 +11,85 @@ yarn workspaces run build
 Run a local backend server (follow instructions in `mcppro`) because authentication against deployed backend is WIP.
 
 ## Usage:
+
 To enter a chat with no initial prompt and default system prompt:
+
 ```sh
 node dist/main.js
 ```
 
 Optional arguments are `prompt` (first User message) and `systemprompt`
+
 ```sh
 node dist/main.js --prompt 'Who is the new pope?' --sysprompt 'You are extremely polite.'
 ```
 
 ## Features:
+
 ### Conversation:
+
 CLI-mode is a conversation between user and LLM.
 
 ### Tool selection:
+
 We now support MCP tool calls. Currently servers are enabled by editing the `mcpServerUrls.json` file, but this will be improved soon.
 
 ### Model selection:
+
 The CLI uses the default model (`gpt-4o-mini`) but uncomment the `agent.chooseModel` line to switch to `gpt-4.1-2025-04-14`. Right now we can use any OpenAI model that supports tool calling.
 
 Supporting inference providers like Together.ai is TODO.
 
 ### Callbacks
+
 The CLI uses an `onMessage` callback to display the Agent's messages and an `onToolCall` callback to request authorization for tool calls.
 
 ## Development Notes
 
 ### Architecture
+
 Frontend talks to
-  - Agent (for conversation, ChatCompletion)
-  - McpServerManager (to enable, disable tools that have been added)
-  - SudoMcpServerManager (to access catalog of SudoMCP servers, add to McpServerManager)
+
+- Agent (for conversation, ChatCompletion)
+- McpServerManager (to enable, disable tools that have been added)
+- SudoMcpServerManager (to access catalog of SudoMCP servers, add to McpServerManager)
 
 SudoMcpServerManager:
-  - track list of available mcp servers (via sdk/ApiClient)
-  - get the list of tools as required by UI (via sdk/ApiClient)
-  - add tools to McpServerManager
+
+- track list of available mcp servers (via sdk/ApiClient)
+- get the list of tools as required by UI (via sdk/ApiClient)
+- add tools to McpServerManager
 
 McpServerManager:
   - manager (mcpServer, tool)
   - enabling / disabling
   - list of enabled / available tools per mcp server
   - exposes tools to Agent
+
+## Multi-agent Chat Setup
+
+With the mcppro backend and DB running locally:
+
+```
+$ ./scripts/test_chat
+```
+
+to set up some users.
+
+```
+$ echo "LLM_URL=http://localhost:5001/v1" >> .env
+$ echo "LLM_API_KEY=dummy_key" >> .env
+$ ./dist/agent/src/tool/main.js chat server
+```
+
+(in 2 other terminals)
+
+Join as chatuser0:
+```
+$ ./dist/agent/src/tool/main.js chat client --api-key `cat _test_chat/chatuser0.apikey` --session test_session
+```
+
+Join as chatuser1:
+```
+$ ./dist/agent/src/tool/main.js chat client --api-key `cat _test_chat/chatuser1.apikey` --session chatuser0/test_session
+```

package/dist/{agent.js → agent/src/agent/agent.js}

@@ -79,15 +79,15 @@ class Agent {
     }
     setConversation(messages) {
         (0, assert_1.strict)(this.messages[0].role == "system");
-        (0, assert_1.strict)(messages[0].role != "system", "conversation contains system msg");
+        (0, assert_1.strict)(messages.length === 0 || messages[0].role != "system", "conversation contains system msg");
         const newMessages = [this.messages[0]];
         this.messages = newMessages.concat(structuredClone(messages));
     }
     getMcpServerManager() {
         return this.mcpServerManager;
     }
-    async userMessage(msg, imageB64) {
-        const userMessage = createUserMessage(msg, imageB64);
+    async userMessage(msg, imageB64, name) {
+        const userMessage = createUserMessage(msg, imageB64, name);
         if (!userMessage) {
             return undefined;
         }
@@ -203,7 +203,7 @@ exports.Agent = Agent;
  * (optional) image.  If neither is given (null message), then undefined is
  * returned.
  **/
-function createUserMessage(msg, imageB64) {
+function createUserMessage(msg, imageB64, name) {
     const content = (() => {
         if (!imageB64) {
             if (!msg) {
@@ -234,5 +234,6 @@ function createUserMessage(msg, imageB64) {
     return {
         role: "user",
         content,
+        name,
     };
 }

package/dist/{agentUtils.js → agent/src/agent/agentUtils.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_LLM_URL = void 0;
-exports.createAgentAndSudoMcpServerManager = createAgentAndSudoMcpServerManager;
+exports.DEFAULT_LLM_MODEL = exports.DEFAULT_LLM_URL = void 0;
+exports.createAgentWithSkills = createAgentWithSkills;
 exports.createNonInteractiveAgent = createNonInteractiveAgent;
 exports.runOneShot = runOneShot;
 const sdk_1 = require("@xalia/xmcp/sdk");
@@ -13,6 +13,7 @@ const dummyLLM_1 = require("./dummyLLM");
 const assert_1 = require("assert");
 const logger = (0, sdk_1.getLogger)();
 exports.DEFAULT_LLM_URL = "http://localhost:5001/v1";
+exports.DEFAULT_LLM_MODEL = "gpt-4o";
 /**
  * Util function to create an Agent from some config information.
  */
@@ -49,20 +50,20 @@ async function createAgent(llmUrl, model, systemPrompt, onMessage, onToolCall, p
 /**
  * Util function to create and initialize an Agent given an AgentProfile.
  */
-async function createAgentAndSudoMcpServerManager(url, agentProfile, onMessage, onToolCall, platform, openaiApiKey, sudomcpConfig, authorizedUrl, conversation, stream = false) {
+async function createAgentWithSkills(llmUrl, agentProfile, onMessage, onToolCall, platform, llmApiKey, sudomcpConfig, authorizedUrl, conversation, stream = false) {
     // Create agent
     logger.debug("[createAgentAndSudoMcpServerManager] creating agent ...");
-    const agent = await createAgent(url, agentProfile.model, agentProfile.system_prompt, onMessage, onToolCall, platform, openaiApiKey, stream);
+    const agent = await createAgent(llmUrl, agentProfile.model, agentProfile.system_prompt, onMessage, onToolCall, platform, llmApiKey, stream);
     if (conversation) {
         agent.setConversation(conversation);
     }
     // Init SudoMcpServerManager
-    logger.debug("[createAgentAndSudoMcpServerManager] creating SudoMcpServerManager.");
-    const sudoMcpServerManager = await sudoMcpServerManager_1.SudoMcpServerManager.initialize(agent.getMcpServerManager(), platform.openUrl, sudomcpConfig.backend_url, sudomcpConfig.api_key, authorizedUrl);
-    logger.debug("[createAgentAndSudoMcpServerManager] restore mcp settings:" +
+    logger.debug("[createAgentWithSkills] creating SudoMcpServerManager.");
+    const sudoMcpServerManager = await sudoMcpServerManager_1.SkillManager.initialize(agent.getMcpServerManager(), platform.openUrl, sudomcpConfig.backend_url, sudomcpConfig.api_key, authorizedUrl);
+    logger.debug("[createAgentWithSkills] restore mcp settings:" +
         JSON.stringify(agentProfile.mcp_settings));
     await sudoMcpServerManager.restoreMcpSettings(agentProfile.mcp_settings);
-    logger.debug("[createAgentAndSudoMcpServerManager] done");
+    logger.debug("[createAgentWithSkills] done");
     return [agent, sudoMcpServerManager];
 }
 /**
@@ -81,7 +82,7 @@ async function createNonInteractiveAgent(url, agentProfile, conversation, platfo
         }
         return false;
     };
-    const [agent, _] = await createAgentAndSudoMcpServerManager(url, agentProfile, onMessage, onToolCall, platform, openaiApiKey, sudomcpConfig, undefined, conversation);
+    const [agent, _] = await createAgentWithSkills(url, agentProfile, onMessage, onToolCall, platform, openaiApiKey, sudomcpConfig, undefined, conversation);
     return agent;
 }
 /**

package/dist/{mcpServerManager.js → agent/src/agent/mcpServerManager.js}

@@ -127,7 +127,8 @@ class McpServerManager {
             await client.connect(transport);
         }
         catch (e) {
-            // TODO: is this catch necessary?
+            // Ensure the socket is closed so the process can exit if there is an
+            // error at connection time.
             await client.close();
             throw e;
         }

package/dist/{sudoMcpServerManager.js → agent/src/agent/sudoMcpServerManager.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SudoMcpServerManager = exports.LOCAL_SERVER_URL = void 0;
+exports.SkillManager = exports.LOCAL_SERVER_URL = void 0;
 const sdk_1 = require("@xalia/xmcp/sdk");
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const logger = (0, sdk_1.getLogger)();
@@ -25,7 +25,7 @@ class SanitizedServerBrief extends sdk_1.McpServerBrief {
  * Manages access to the catalogue of servers hosted by sudomcp.  Supports
  * adding these servers to McpServerManager.
  */
-class SudoMcpServerManager {
+class SkillManager {
     constructor(mcpServerManager, apiClient, serverBriefs, serverBriefsMap, toolCache, openUrl, 
     // Redirect to this page after successful authorization
     authorized_url) {
@@ -47,7 +47,7 @@ class SudoMcpServerManager {
         // Fetch server list
         const servers = await apiClient.listServers();
         const [mcpServers, mcpServersMap] = buildServersList(servers);
-        return new SudoMcpServerManager(mcpServerManager, apiClient, mcpServers, mcpServersMap, {}, openUrl, authorized_url);
+        return new SkillManager(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.
@@ -138,7 +138,7 @@ class SudoMcpServerManager {
         return this.apiClient;
     }
 }
-exports.SudoMcpServerManager = SudoMcpServerManager;
+exports.SkillManager = SkillManager;
 /**
  * Connect a client to a hosted MCP server session,
  * prompting for authentication if needed.

package/dist/agent/src/chat/apiKeyManager.js

@@ -0,0 +1,23 @@
+"use strict";
+// TODO:
+// - lru-cache
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyManager = void 0;
+class ApiKeyManager {
+    constructor(db) {
+        this.db = db;
+    }
+    async verifyApiKey(apiKey) {
+        // TODO: Cache this
+        const userInfo = await this.db.getUserDataFromApiKey(apiKey);
+        return userInfo;
+        // if (apiKey.startsWith("dummy_key")) {
+        //   return {
+        //     user_uuid: apiKey,
+        //     nickname: apiKey,
+        //   };
+        // }
+        // return undefined;
+    }
+}
+exports.ApiKeyManager = ApiKeyManager;

package/dist/agent/src/chat/asyncQueue.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
+class AsyncQueue {
+    constructor(process, maxBacklog = 100) {
+        this.running = false;
+        this.queue = [];
+        this.process = process;
+        this.maxBacklog = maxBacklog;
+    }
+    getLength() {
+        return this.queue.length;
+    }
+    getMaxBacklog() {
+        return this.maxBacklog;
+    }
+    async enqueueAsync(queueEntry) {
+        while (this.maxBacklog > 0 && this.queue.length >= this.maxBacklog) {
+            await new Promise((r) => setTimeout(r, 1));
+        }
+        this.queue.push(queueEntry);
+        this.tryNext();
+    }
+    shift() {
+        return this.queue.shift();
+    }
+    async tryNext() {
+        if (this.running) {
+            return;
+        }
+        const queueEntry = this.shift();
+        if (queueEntry) {
+            this.running = true;
+            await this.process(queueEntry);
+            this.running = false;
+            // Check for more tasks on the queue.
+            setTimeout(() => this.tryNext());
+        }
+    }
+}
+exports.AsyncQueue = AsyncQueue;

package/dist/agent/src/chat/client.js

@@ -0,0 +1,126 @@
+"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.ChatClient = void 0;
+const dotenv = __importStar(require("dotenv"));
+const sdk_1 = require("@xalia/xmcp/sdk");
+const assert_1 = require("assert");
+const websocket = __importStar(require("ws"));
+dotenv.config();
+const logger = (0, sdk_1.getLogger)();
+class ChatClient {
+    constructor(ws, onMessageCB, onConnectionClosedCB) {
+        this.ws = ws;
+        this.onMessageCB = onMessageCB;
+        this.onConnectionClosedCB = onConnectionClosedCB;
+        this.closed = false;
+    }
+    static async initWithParams(host, port, token, params, onMessageCB, onConnectionClosedCB) {
+        return new Promise((r, e) => {
+            const urlParams = new URLSearchParams(params);
+            const url = `ws://${host}:${port}?${urlParams}`;
+            const ws = new websocket.WebSocket(url, [token]);
+            logger.info("created ws");
+            const client = new ChatClient(ws, onMessageCB, onConnectionClosedCB);
+            ws.onopen = async () => {
+                logger.info("opened");
+                ws.onmessage = (ev) => {
+                    try {
+                        const msgData = ev.data;
+                        if (typeof msgData !== "string") {
+                            throw `expected "string" data, got ${typeof msgData}`;
+                        }
+                        logger.debug(`[client.onmessage]: ${msgData}`);
+                        const msg = JSON.parse(msgData);
+                        client.onMessageCB(msg);
+                    }
+                    catch (e) {
+                        client.close();
+                        throw e;
+                    }
+                };
+                r(client);
+            };
+            ws.onclose = (err) => {
+                logger.info("closed");
+                logger.info(`[client] WebSocket connection closed: ${JSON.stringify(err)}`);
+                client.closed = true;
+                onConnectionClosedCB();
+            };
+            ws.onerror = (error) => {
+                logger.error("[client] WebSocket error:", JSON.stringify(error));
+                e(error);
+                client.closed = true;
+                onConnectionClosedCB();
+            };
+        });
+    }
+    // public static async initWithSession(
+    //   host: string,
+    //   port: number,
+    //   token: string,
+    //   sessionId: string,
+    //   onMessageCB: OnMessageCallback,
+    //   onConnectionClosedCB: OnConnectionClosedCallback
+    // ): Promise<ChatClient> {
+    //   return ChatClient.initWithParams(
+    //     host,
+    //     port,
+    //     token,
+    //     { session_id: sessionId },
+    //     onMessageCB,
+    //     onConnectionClosedCB
+    //   );
+    // }
+    static async init(host, port, token, onMessageCB, onConnectionClosedCB, sessionId = "untitled", agentProfileId = undefined) {
+        const params = { session_id: sessionId };
+        if (agentProfileId) {
+            params["agent_profile_id"] = agentProfileId;
+        }
+        return ChatClient.initWithParams(host, port, token, params, onMessageCB, onConnectionClosedCB);
+    }
+    sendMessage(message) {
+        (0, assert_1.strict)(!this.closed);
+        const data = JSON.stringify(message);
+        this.ws.send(data);
+    }
+    close() {
+        this.closed = true;
+        this.onConnectionClosedCB();
+        this.ws.close();
+    }
+}
+exports.ChatClient = ChatClient;
+// TODO: remove this

package/dist/agent/src/chat/conversationManager.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationManager = exports.OpenSession = exports.UserAlreadyConnected = void 0;
+const uuid_1 = require("uuid");
+const assert_1 = require("assert");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const agentUtils_1 = require("../agent/agentUtils");
+const asyncQueue_1 = require("./asyncQueue");
+const asyncLock_1 = require("../utils/asyncLock");
+const logger = (0, sdk_1.getLogger)();
+class UserAlreadyConnected extends Error {
+    constructor() {
+        super("User already connected to the conversation");
+    }
+}
+exports.UserAlreadyConnected = UserAlreadyConnected;
+/**
+ * Describes a Session (conversation) with connected participants.
+ */
+class OpenSession {
+    constructor(agent, sudoMcpServerManager, onEmpty) {
+        // public agent: Agent,
+        this.agent = agent;
+        this.skillManager = sudoMcpServerManager;
+        this.onEmpty = onEmpty;
+        this.connections = {};
+        this.messageQueue = new asyncQueue_1.AsyncQueue((m) => this.onMessage(m));
+        this.curAgentMsgId = undefined;
+    }
+    join(userName, ws) {
+        if (this.connections[userName]) {
+            throw new UserAlreadyConnected();
+        }
+        // Inform any other participants, and add the WebSocket to the map.
+        this.broadcast({ type: "user_joined", user: userName });
+        this.connections[userName] = ws;
+        ws.on("message", async (message) => {
+            logger.debug(`[convMgr]: got message: (from ${userName}): ${message}`);
+            const msgStr = message.toString();
+            const msg = JSON.parse(msgStr);
+            await this.messageQueue.enqueueAsync({ msg, from: userName });
+        });
+        ws.on("close", () => {
+            logger.debug(`[convMgr]: ${userName} closed`);
+            // Remove our connection then inform any other participants
+            delete this.connections[userName];
+            this.broadcast({ type: "user_left", user: userName });
+            if (Object.keys(this.connections).length == 0) {
+                this.onEmpty();
+            }
+        });
+    }
+    /**
+     * Called once for each message.  Messages are queued to avoid overlapping
+     * calls to the LLM.
+     */
+    async onMessage(queuedMessage) {
+        logger.debug(`[onMessage]: processing (${queuedMessage.from}) ` +
+            `${JSON.stringify(queuedMessage.msg)}`);
+        const msg = queuedMessage.msg;
+        switch (msg.type) {
+            case "msg":
+                return this.onChatMessage(queuedMessage);
+            default:
+                throw `unknown message: ${JSON.stringify(queuedMessage)}`;
+        }
+    }
+    async onAgentMessage(msg, end) {
+        logger.debug(`[onAgentMessage] msg: ${msg}, end: ${end}`);
+        (0, assert_1.strict)(this.curAgentMsgId);
+        this.broadcast({
+            type: "agent_msg_chunk",
+            message_id: this.curAgentMsgId,
+            message: msg,
+            end,
+        });
+    }
+    async onChatMessage(queuedMessage) {
+        const msg = queuedMessage.msg;
+        const userToken = queuedMessage.from;
+        const msgId = (0, uuid_1.v4)();
+        this.broadcast({
+            type: "user_msg",
+            message_id: msgId,
+            message: msg.message,
+            from: userToken,
+        });
+        // Messages will be handled by the Agent.onMessage callback.  We await the
+        // response here before processing further messages.
+        this.curAgentMsgId = `${msgId}-resp`;
+        await this.agent.userMessage(msg.message, undefined, userToken);
+    }
+    broadcast(msg) {
+        logger.info(`[broadcast]: broadcast msg: ${JSON.stringify(msg)}`);
+        const msgString = JSON.stringify(msg);
+        for (const ws of Object.values(this.connections)) {
+            ws.send(msgString);
+        }
+    }
+}
+exports.OpenSession = OpenSession;
+/**
+ * Handles forwarding of messages between all participants of a session, as
+ * well as messages to/from and Agent.
+ */
+class ConversationManager {
+    constructor(db, llmUrl, xmcpUrl) {
+        this.db = db;
+        this.llmUrl = llmUrl;
+        this.xmcpUrl = xmcpUrl;
+        this.openSessionsLock = new asyncLock_1.AsyncLock();
+        this.openSessions = {};
+    }
+    async join(sessionId, llmApiKey, xmcpApiKey, userData, ws) {
+        await this.openSessionsLock.lockAndProcess(() => {
+            return this.getOrCreateAndSubscribe(sessionId, llmApiKey, xmcpApiKey, userData.nickname || userData.user_uuid, ws);
+        });
+    }
+    /**
+     * Must be called while holding the openSessionsLock
+     */
+    async getOrCreateAndSubscribe(sessionId, llmApiKey, xmcpApiKey, userName, ws) {
+        let openSession = this.openSessions[sessionId];
+        if (openSession) {
+            openSession.join(userName, ws);
+            return openSession;
+        }
+        // Create a new session
+        // TODO: The owner of llmApiKey and xmcpApiKey may not be the owner of the
+        // session.  Should we create the Agent and SudoMcpServerManager with the
+        // session-owners api key?
+        const onEmpty = () => {
+            logger.debug(`session ${sessionId} empty.  removing`);
+            delete this.openSessions[sessionId];
+        };
+        const sessionData = await this.db.getSessionById(sessionId);
+        if (!sessionData) {
+            throw `no such session ${sessionId}`;
+        }
+        const conversation = sessionData.conversation;
+        const agentProfile = await this.db.getAgentProfileById(sessionData.agent_profile_uuid);
+        if (!agentProfile) {
+            throw `no such agent profile ${sessionData.agent_profile_uuid}`;
+        }
+        const platform = {
+            openUrl: (_url, _authResultP, _displayName) => {
+                throw "unimpl";
+            },
+            load: (_filename) => {
+                throw "unimpl";
+            },
+        };
+        // Forward agent messages to the OpenSession (once it is iniailized
+        const context = {};
+        const onMessage = async (msg, end) => {
+            logger.debug(`[onMessage] msg: ${msg}, end: ${end}`);
+            (0, assert_1.strict)(context.openSession);
+            context.openSession.onAgentMessage(msg, end);
+        };
+        const onToolCall = async (toolCall) => {
+            logger.debug(`[onToolCall] : ${JSON.stringify(toolCall)}`);
+            return true;
+        };
+        const xmcpConfig = sdk_1.Configuration.new(xmcpApiKey, this.xmcpUrl, false);
+        const [agent, smsm] = await (0, agentUtils_1.createAgentWithSkills)(this.llmUrl, agentProfile, onMessage, onToolCall, platform, llmApiKey, xmcpConfig, undefined, conversation, true);
+        openSession = new OpenSession(agent, smsm, onEmpty);
+        context.openSession = openSession;
+        this.openSessions[sessionId] = openSession;
+        openSession.join(userName, ws);
+        return openSession;
+    }
+}
+exports.ConversationManager = ConversationManager;