@xalia/agent 0.5.6 → 0.5.8

package/dist/agent/src/agent/agent.js

@@ -92,6 +92,9 @@ class Agent {
         if (!userMessage) {
             return undefined;
         }
+        return this.userMessageRaw(userMessage);
+    }
+    async userMessageRaw(userMessage) {
         this.messages.push(userMessage);
         let completion = await this.chatCompletion();
         let message = completion.choices[0].message;

package/dist/agent/src/agent/agentUtils.js

@@ -60,30 +60,24 @@ async function createAgent(llmUrl, model, systemPrompt, onMessage, onToolCall, p
  * Util function to create and initialize an Agent given an AgentProfile.
  */
 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(llmUrl, agentProfile.model, agentProfile.system_prompt, onMessage, onToolCall, platform, llmApiKey, stream);
-    if (conversation) {
-        agent.setConversation(conversation);
-    }
     // Init SudoMcpServerManager
     logger.debug("[createAgentWithSkills] creating SudoMcpServerManager.");
-    const sudoMcpServerManager = await sudoMcpServerManager_1.SkillManager.initialize(agent.getMcpServerManager(), platform.openUrl, sudomcpConfig.backend_url, sudomcpConfig.api_key, authorizedUrl);
+    const sudoMcpServerManager = await sudoMcpServerManager_1.SkillManager.initialize(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("[createAgentWithSkills] done");
+    // Create agent using the McpServerManager just created
+    const agent = await createAgentFromSkillManager(llmUrl, agentProfile, onMessage, onToolCall, platform, llmApiKey, sudoMcpServerManager, conversation, stream);
     return [agent, sudoMcpServerManager];
 }
 async function createAgentFromSkillManager(llmUrl, agentProfile, onMessage, onToolCall, platform, llmApiKey, skillManager, conversation, stream = false) {
     // Create agent
-    logger.debug("[createAgentAndSudoMcpServerManager] creating agent ...");
-    const mcpServerManager = skillManager.getMcpServerManager();
-    const agent = await createAgent(llmUrl, agentProfile.model, agentProfile.system_prompt, onMessage, onToolCall, platform, llmApiKey, stream, mcpServerManager);
+    logger.debug("[createAgentFromSkillManager] creating agent ...");
+    const agent = await createAgent(llmUrl, agentProfile.model, agentProfile.system_prompt, onMessage, onToolCall, platform, llmApiKey, stream, skillManager);
     if (conversation) {
         agent.setConversation(conversation);
     }
-    logger.debug("[createAgentWithSkills] done");
+    logger.debug("[createAgentFromSkillManager] done");
     return agent;
 }
 /**

package/dist/agent/src/agent/mcpServerManager.js

@@ -121,7 +121,7 @@ class McpServerManager {
     getMcpServer(mcpServerName) {
         return this.getMcpServerInternal(mcpServerName);
     }
-    async addMcpServer(mcpServerName, url, apiKey, tools) {
+    async addMcpServerWithSSEUrl(mcpServerName, url, apiKey, tools) {
         logger.debug(`Adding mcp server ${mcpServerName}: ${url}`);
         const sseTransportOptions = {};
         if (apiKey) {

package/dist/agent/src/agent/openAILLMStreaming.js

@@ -263,9 +263,10 @@ function updateCompletionChoice(completionChoice, chunkChoice) {
 }
 function initializeCompletionChoices(chunkChoices) {
     // Technically, one choice could be done and the other still have some
-    // content to stream.  We keep it simple for now and assume only single
-    // choices, which allows us to mark everything as done if any choice we hit is
-    // done.
+    // content to stream.  We keep it simple for now and allow zero or one
+    // choice per chunk, which allows us to mark everything as done if any
+    // choice we hit is done. Zero choices can occur in usage-only chunks at
+    // the end of the stream.
     (0, assert_1.strict)(chunkChoices.length < 2);
     let msgDone = false;
     const choices = [];
@@ -280,10 +281,11 @@ function initializeCompletionChoices(chunkChoices) {
 }
 function updateCompletionChoices(completionChoices, chunkChoices) {
     // Technically, one choice could be done and the other still have some
-    // content to stream.  We keep it simple for now and assume only single
-    // choices, which allows us to mark everything as done if any choice we hit is
-    // done.
-    (0, assert_1.strict)(chunkChoices.length === 1);
+    // content to stream.  We keep it simple for now and allow zero or one
+    // choice per chunk, which allows us to mark everything as done if any
+    // choice we hit is done. Zero choices can occur in usage-only chunks at
+    // the end of the stream.
+    (0, assert_1.strict)(chunkChoices.length < 2);
     (0, assert_1.strict)(completionChoices.length === 1);
     let msgDone = false;
     for (const chunkChoice of chunkChoices) {
@@ -391,6 +393,9 @@ class OpenAILLMStreaming {
             messages,
             tools,
             stream: true,
+            stream_options: {
+                include_usage: true,
+            },
         });
         // Check the type casting above
         if (!chunks.iterator) {
@@ -413,6 +418,8 @@ class OpenAILLMStreaming {
             }
             if (onMessage) {
                 // Inform the call of a message fragment if it contains any text.
+                // Note: chunks may have zero choices (e.g., usage-only chunks), so
+                // we safely access the first choice.
                 const delta = chunk.choices[0]?.delta;
                 if (delta?.content) {
                     await onMessage(delta.content, false);

package/dist/agent/src/agent/sudoMcpServerManager.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SkillManager = exports.LOCAL_SERVER_URL = void 0;
+const mcpServerManager_1 = require("./mcpServerManager");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const logger = (0, sdk_1.getLogger)();
@@ -25,11 +26,11 @@ class SanitizedServerBrief extends sdk_1.McpServerBrief {
  * Manages access to the catalogue of servers hosted by sudomcp.  Supports
  * adding these servers to McpServerManager.
  */
-class SkillManager {
-    constructor(mcpServerManager, apiClient, serverBriefs, serverBriefsMap, toolCache, openUrl, 
+class SkillManager extends mcpServerManager_1.McpServerManager {
+    constructor(apiClient, serverBriefs, serverBriefsMap, toolCache, openUrl, 
     // Redirect to this page after successful authorization
     authorized_url) {
-        this.mcpServerManager = mcpServerManager;
+        super();
         this.apiClient = apiClient;
         this.serverBriefs = serverBriefs;
         this.serverBriefsMap = serverBriefsMap;
@@ -41,13 +42,16 @@ class SkillManager {
      * Initialize an ApiClient to interface with SudoMCP backend and
      * fetch the current list of ServerBriefs.
      */
-    static async initialize(mcpServerManager, openUrl, sudoMcpUrl, sudoMcpApiKey, authorized_url) {
+    static async initialize(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.listServers();
         const [mcpServers, mcpServersMap] = buildServersList(servers);
-        return new SkillManager(mcpServerManager, apiClient, mcpServers, mcpServersMap, {}, openUrl, authorized_url);
+        return new SkillManager(apiClient, mcpServers, mcpServersMap, {}, openUrl, authorized_url);
+    }
+    async shutdown() {
+        return super.shutdown();
     }
     /// 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.
@@ -73,12 +77,12 @@ class SkillManager {
             }
             if (enabled.length === 0) {
                 logger.debug(` restoring "${serverName}": (all tools)`);
-                this.mcpServerManager.enableAllTools(serverName);
+                this.enableAllTools(serverName);
                 return;
             }
             logger.debug(` restoring "${serverName}": ${JSON.stringify(enabled)}`);
             for (const toolName of enabled) {
-                this.mcpServerManager.enableTool(serverName, toolName);
+                this.enableTool(serverName, toolName);
             }
         };
         Object.entries(mcpConfig).map((e) => enableTools(e));
@@ -99,9 +103,6 @@ class SkillManager {
     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.
@@ -131,10 +132,9 @@ class SkillManager {
             version: "1.0.0",
         });
         await connectServer(client, this.apiClient, mcpserver, this.openUrl, this.authorized_url);
-        const msm = this.mcpServerManager;
-        await msm.addMcpServerWithClient(client, serverName, tools);
+        await this.addMcpServerWithClient(client, serverName, tools);
         if (enableAll) {
-            msm.enableAllTools(serverName);
+            this.enableAllTools(serverName);
         }
     }
     getOriginalName(serverName) {

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

@@ -1,48 +1,20 @@
 "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 assert_1 = require("assert");
-const websocket = __importStar(require("ws"));
 const sdk_1 = require("@xalia/xmcp/sdk");
 const mcpServerManager_1 = require("../agent/mcpServerManager");
+const websocket_1 = require("./websocket");
 const logger = (0, sdk_1.getLogger)();
-class RemoteMcpServerManager {
-    constructor(sender) {
-        this.sender = sender;
+class RemoteSudoMcpServerManager {
+    constructor(sender, briefs) {
         this.mcpServers = {};
+        this.sender = sender;
+        this.briefs = briefs;
+        this.briefsMap = {};
+        briefs.forEach((b) => {
+            this.briefsMap[b.name] = b;
+        });
         this.mcpServers = {};
     }
     hasMcpServer(mcpServerName) {
@@ -149,20 +121,6 @@ class RemoteMcpServerManager {
         }
         server.disableTool(toolName);
     }
-}
-class RemoteSudoMcpServerManager {
-    constructor(sender, briefs, msm) {
-        this.sender = sender;
-        this.briefs = briefs;
-        this.msm = msm;
-        this.briefsMap = {};
-        briefs.forEach((b) => {
-            this.briefsMap[b.name] = b;
-        });
-    }
-    getMcpServerManager() {
-        return this.msm;
-    }
     getServerBriefs() {
         return this.briefs;
     }
@@ -176,6 +134,7 @@ class RemoteSudoMcpServerManager {
             enable_all,
         });
     }
+    async shutdown() { }
 }
 class ChatClient {
     constructor(platform, ws, onMessageCB, onConnectionClosedCB, serverBriefs) {
@@ -184,8 +143,7 @@ class ChatClient {
         this.onMessageCB = onMessageCB;
         this.onConnectionClosedCB = onConnectionClosedCB;
         this.closed = false;
-        this.msm = new RemoteMcpServerManager(this);
-        this.smsm = new RemoteSudoMcpServerManager(this, serverBriefs, this.msm);
+        this.smsm = new RemoteSudoMcpServerManager(this, serverBriefs);
         this.systemPrompt = "";
         this.model = "";
     }
@@ -193,7 +151,7 @@ class ChatClient {
         return new Promise((resolveClient, e) => {
             const urlParams = new URLSearchParams(params);
             const url = `ws://${host}:${port}?${urlParams}`;
-            const ws = new websocket.WebSocket(url, [token]);
+            const ws = new websocket_1.WebSocket(url, [token]);
             logger.info("created ws");
             let client = undefined;
             const onMsg = (msg) => {
@@ -231,17 +189,17 @@ class ChatClient {
                     }
                 };
             };
-            ws.onclose = async (err) => {
+            ws.onclose = async (ev) => {
                 logger.info("closed");
-                logger.info(`[client] WebSocket connection closed: ${JSON.stringify(err)}`);
+                logger.info(`[client] WebSocket connection closed: ${JSON.stringify(ev)}`);
                 if (client) {
                     client.closed = true;
                 }
                 await onConnectionClosedCB();
             };
-            ws.onerror = async (error) => {
-                logger.error("[client] WebSocket error:", JSON.stringify(error));
-                e(error);
+            ws.onerror = async (ev) => {
+                logger.error("[client] WebSocket error:", JSON.stringify(ev));
+                e(ev);
                 if (client) {
                     client.closed = true;
                 }
@@ -291,6 +249,9 @@ class ChatClient {
     resetConversation() {
         throw "resetConversation not implemented for ChatClient";
     }
+    shutdown() {
+        throw "shutdown not implemented for ChatClient";
+    }
     sendMessage(message) {
         (0, assert_1.strict)(!this.closed);
         const data = JSON.stringify(message);
@@ -308,16 +269,16 @@ class ChatClient {
             // State updates
             //
             case "mcp_server_added":
-                this.msm.onMcpServerAdded(message.server_name, message.tools, message.enabled_tools);
+                this.smsm.onMcpServerAdded(message.server_name, message.tools, message.enabled_tools);
                 break;
             case "mcp_server_removed":
-                this.msm.onMcpServerRemoved(message.server_name);
+                this.smsm.onMcpServerRemoved(message.server_name);
                 break;
             case "mcp_server_tool_enabled":
-                this.msm.onMcpServerToolEnabled(message.server_name, message.tool);
+                this.smsm.onMcpServerToolEnabled(message.server_name, message.tool);
                 break;
             case "mcp_server_tool_disabled":
-                this.msm.onMcpServerToolDisabled(message.server_name, message.tool);
+                this.smsm.onMcpServerToolDisabled(message.server_name, message.tool);
                 break;
             case "system_prompt_updated":
                 this.systemPrompt = message.system_prompt;

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

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConversationManager = exports.OpenSession = exports.UserAlreadyConnected = void 0;
+exports.userMessageToChatMessage = userMessageToChatMessage;
+exports.conversationToChatMessages = conversationToChatMessages;
 const uuid_1 = require("uuid");
 const assert_1 = require("assert");
 const sdk_1 = require("@xalia/xmcp/sdk");
+const agent_1 = require("../agent/agent");
 const agentUtils_1 = require("../agent/agentUtils");
 const asyncQueue_1 = require("./asyncQueue");
 const asyncLock_1 = require("../utils/asyncLock");
@@ -33,23 +36,40 @@ class OpenSession {
         if (this.connections[userName]) {
             throw new UserAlreadyConnected();
         }
-        // Inform any other participants, and add the WebSocket to the map.
+        // Inform any other participants, then add the new WebSocket to the map.
         this.broadcast({ type: "user_joined", user: userName });
         this.connections[userName] = ws;
-        // TODO:
-        //
-        //   - send conversation state (ServerHistory)
+        // Send MCP server briefs first (client expects this)
         const briefs = this.skillManager.getServerBriefs();
         this.sendTo(userName, { type: "mcp_server_briefs", server_briefs: briefs });
+        // Send conversation
+        const conversation = this.agent.getConversation();
+        const convMessages = conversationToChatMessages(conversation, userName);
+        for (const chatMsg of convMessages) {
+            this.sendTo(userName, chatMsg);
+        }
+        // Update the MSM state
+        const agentProfile = this.agent.getAgentProfile();
         const msm = this.agent.getMcpServerManager();
-        const mcpServerNames = msm.getMcpServerNames();
-        for (const serverName of mcpServerNames) {
-            const info = msm.getMcpServer(serverName);
+        for (const server_name in agentProfile.mcp_settings) {
+            const tools = msm.getMcpServer(server_name).getTools();
+            const enabled_tools = agentProfile.mcp_settings[server_name];
             this.sendTo(userName, {
                 type: "mcp_server_added",
-                server_name: serverName,
-                tools: info.getTools(),
-                enabled_tools: Object.keys(info.getEnabledTools()),
+                server_name,
+                tools,
+                enabled_tools,
+            });
+        }
+        // Send system prompt and model
+        this.sendTo(userName, {
+            type: "system_prompt_updated",
+            system_prompt: agentProfile.system_prompt,
+        });
+        if (agentProfile.model) {
+            this.sendTo(userName, {
+                type: "model_updated",
+                model: agentProfile.model,
             });
         }
         ws.on("message", async (message) => {
@@ -140,7 +160,9 @@ class OpenSession {
             end,
         });
     }
-    async onChatMessage(message, userToken) {
+    async onChatMessage(message, 
+    // imageB64: string | undefined,
+    userToken) {
         // We manually broadcast the user's message here and start the agent
         // conversation, and then wait to get back all data from the agent before
         // processing further messages from clients.
@@ -149,10 +171,27 @@ class OpenSession {
             type: "user_msg",
             message_id: msgId,
             message,
+            // imageB64,
             from: userToken,
         });
         this.curAgentMsgId = `${msgId}-resp`;
-        await this.agent.userMessageEx(message, undefined, userToken);
+        const userMessageParam = (0, agent_1.createUserMessage)(message, 
+        /*imageB64*/ undefined, userToken);
+        if (!userMessageParam) {
+            logger.debug(`ignoring empty message: ${message}`);
+            return;
+        }
+        const assistantReply = await this.agent.userMessageRaw(userMessageParam);
+        if (assistantReply) {
+            // TODO: consider including all messages (including tool calls)
+            // const newEntries = agent.getTrailingEntries(prevConvLength);
+            // await this.db.sessionConversationAppend(this.sessionUUID, newEntries);
+            const newEntries = [
+                userMessageParam,
+                assistantReply,
+            ];
+            await this.db.sessionConversationAppend(this.sessionUUID, newEntries);
+        }
     }
     async onAddMcpServer(serverName, enableAll) {
         logger.info(`[onAddMcpServer]: Adding server ${serverName} (enable_all: ${enableAll})`);
@@ -390,3 +429,74 @@ class ConversationManager {
     }
 }
 exports.ConversationManager = ConversationManager;
+function userMessageToChatMessage(userMessage, message_id, defaultName) {
+    const from = userMessage.name || defaultName;
+    if (typeof userMessage.content === "string") {
+        return {
+            type: "user_msg",
+            message_id,
+            message: userMessage.content,
+            from,
+        };
+    }
+    let message = "";
+    let image = undefined;
+    for (const content of userMessage.content) {
+        switch (content.type) {
+            case "text":
+                message += content.text;
+                break;
+            case "image_url":
+                (0, assert_1.strict)(!image, "only one image per message supported");
+                image = content.image_url;
+                break;
+            case "input_audio":
+                throw "userMessageToChatMessage: audio content not supported";
+            case "file":
+                throw "userMessageToChatMessage: file content not supported";
+            default:
+                throw "userMessageToChatMessage: unexpected content.type";
+        }
+    }
+    if (image) {
+        throw "unimpl: image content";
+    }
+    return {
+        type: "user_msg",
+        message_id,
+        message,
+        from,
+    };
+}
+function conversationToChatMessages(conversation, defaultName) {
+    const msgs = [];
+    for (const ccmp of conversation) {
+        const message_id = `message_${msgs.length}`;
+        switch (ccmp.role) {
+            case "developer":
+                throw "developer messages not handled yet";
+            case "assistant":
+                (0, assert_1.strict)(!ccmp.audio);
+                if (ccmp.content) {
+                    msgs.push({
+                        type: "agent_msg",
+                        message: ccmp,
+                        message_id,
+                    });
+                }
+                // TODO: do we want to convert tool calls etc?
+                break;
+            case "user":
+                {
+                    const msg = userMessageToChatMessage(ccmp, message_id, defaultName);
+                    if (msg) {
+                        msgs.push(msg);
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return msgs;
+}

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

@@ -202,6 +202,15 @@ class Database {
         }
         return data[0].uuid;
     }
+    async sessionConversationAppend(session_id, newEntries) {
+        const { error } = await this.client.rpc("session_append_to_conversation", {
+            session_id,
+            messages: newEntries,
+        });
+        if (error) {
+            throw error;
+        }
+    }
     async clearSessions() {
         await this.client.from("sessions").delete().neq("uuid", "");
     }

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

@@ -1,2 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeAssistantMessageParam = decodeAssistantMessageParam;
+function decodeAssistantMessageParam(msg) {
+    let text = "";
+    if (msg.audio) {
+        throw "decodeAssistantMessageParam; audio unimplemented";
+    }
+    if (msg.content) {
+        if (typeof msg.content === "string") {
+            text = msg.content;
+        }
+        else if (msg.content instanceof Array) {
+            for (const c of msg.content) {
+                switch (c.type) {
+                    case "text":
+                        text += c.text;
+                        break;
+                    case "refusal":
+                        text += c.refusal;
+                        break;
+                    default:
+                        throw Error("unexpected AssistantMessageParam.content entry");
+                }
+            }
+        }
+    }
+    return text;
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+// Browser and Node.js Universal WebSocket wrapper
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocket = void 0;
+let WSClass;
+if (typeof window !== "undefined" && typeof window.WebSocket !== "undefined") {
+    // Running in browser
+    exports.WebSocket = WSClass = window.WebSocket;
+}
+else {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const ws = require("ws");
+    exports.WebSocket = WSClass = ws.WebSocket;
+}

package/dist/agent/src/test/db.test.js

@@ -79,6 +79,14 @@ describe("DB", () => {
         (0, chai_1.expect)(agentProfileFromDB).eql(AGENT_PROFILE_2);
     });
     it("should create and retrieve sessions", async function () {
+        const CONV_0 = [
+            { role: "user", content: "message 0" },
+            { role: "assistant", content: "message 1" },
+        ];
+        const CONV_1 = [
+            { role: "user", content: "message 2" },
+            { role: "assistant", content: "message 3" },
+        ];
         const db = getLocalDB();
         await db.clearAgentProfiles();
         await db.clearSessions();
@@ -92,5 +100,13 @@ describe("DB", () => {
         (0, chai_1.expect)(session.title).eql("test_session");
         (0, chai_1.expect)(session.user_uuid).eql("dummy_user");
         (0, chai_1.expect)(session.uuid).eql(sessionId);
+        // Append messages to empty conversation
+        await db.sessionConversationAppend(sessionId, CONV_0);
+        const session0 = (await db.getSessionById(sessionId));
+        (0, chai_1.expect)(session0.conversation).eql(CONV_0);
+        // Append further messages
+        await db.sessionConversationAppend(sessionId, CONV_1);
+        const session1 = (await db.getSessionById(sessionId));
+        (0, chai_1.expect)(session1.conversation).eql(CONV_0.concat(CONV_1));
     });
 });

package/dist/agent/src/test/mcpServerManager.test.js

@@ -21,7 +21,7 @@ async function shutdownAll() {
 describe("McpServerManager", async () => {
     it("should initialize with correct descriptions", async () => {
         const tm = getMcpServerManager();
-        await tm.addMcpServer("simplecalc", "http://localhost:5001/mcpservers/sudomcp/simplecalc/session", "dummy_key");
+        await tm.addMcpServerWithSSEUrl("simplecalc", "http://localhost:5001/mcpservers/sudomcp/simplecalc/session", "dummy_key");
         const server = tm.getMcpServer("simplecalc");
         const availableTools = server.getTools();
         (0, chai_1.expect)(availableTools.length).greaterThan(0);
@@ -58,7 +58,7 @@ describe("McpServerManager", async () => {
     });
     it("add / remove servers", async () => {
         const tm = getMcpServerManager();
-        await tm.addMcpServer("simplecalc", "http://localhost:5001/mcpservers/sudomcp/simplecalc/session", "dummy_key");
+        await tm.addMcpServerWithSSEUrl("simplecalc", "http://localhost:5001/mcpservers/sudomcp/simplecalc/session", "dummy_key");
         tm.enableAllTools("simplecalc");
         (0, chai_1.expect)(tm.getOpenAITools().length).greaterThan(0);
         // Remove server and check there is no server, and no openai entries.