@xalia/agent 0.5.4 → 0.5.6

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

@@ -34,26 +34,184 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 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 sdk_1 = require("@xalia/xmcp/sdk");
+const mcpServerManager_1 = require("../agent/mcpServerManager");
 const logger = (0, sdk_1.getLogger)();
+class RemoteMcpServerManager {
+    constructor(sender) {
+        this.sender = sender;
+        this.mcpServers = {};
+        this.mcpServers = {};
+    }
+    hasMcpServer(mcpServerName) {
+        return !!this.mcpServers[mcpServerName];
+    }
+    getMcpServerNames() {
+        return Object.keys(this.mcpServers);
+    }
+    getMcpServer(mcpServerName) {
+        const server = this.mcpServers[mcpServerName];
+        if (server) {
+            return server;
+        }
+        throw Error(`unknown server ${mcpServerName}`);
+    }
+    async removeMcpServer(mcpServerName) {
+        if (!this.mcpServers[mcpServerName]) {
+            throw Error(`no server ${mcpServerName} (removeMcpServer)`);
+        }
+        this.sender.sendMessage({
+            type: "remove_mcp_server",
+            server_name: mcpServerName,
+        });
+    }
+    enableAllTools(mcpServerName) {
+        if (!this.mcpServers[mcpServerName]) {
+            throw Error(`no server ${mcpServerName} (enableAllTools)`);
+        }
+        this.sender.sendMessage({
+            type: "enable_all_mcp_server_tools",
+            server_name: mcpServerName,
+        });
+    }
+    disableAllTools(mcpServerName) {
+        if (!this.mcpServers[mcpServerName]) {
+            throw Error(`no server ${mcpServerName} (disableAllTools)`);
+        }
+        this.sender.sendMessage({
+            type: "disable_all_mcp_server_tools",
+            server_name: mcpServerName,
+        });
+    }
+    enableTool(mcpServerName, toolName) {
+        const server = this.mcpServers[mcpServerName];
+        if (!server) {
+            throw Error(`no server ${mcpServerName} (enableTool)`);
+        }
+        const tools = server.getTool(toolName);
+        if (!tools) {
+            throw Error(`no tool ${toolName} on server ${mcpServerName}`);
+        }
+        this.sender.sendMessage({
+            type: "enable_mcp_server_tool",
+            server_name: mcpServerName,
+            tool: toolName,
+        });
+    }
+    disableTool(mcpServerName, toolName) {
+        const server = this.mcpServers[mcpServerName];
+        if (!server) {
+            throw Error(`no server ${mcpServerName} (disableTool)`);
+        }
+        const tools = server.getTool(toolName);
+        if (!tools) {
+            throw Error(`no tool ${toolName} on server ${mcpServerName}`);
+        }
+        this.sender.sendMessage({
+            type: "disable_mcp_server_tool",
+            server_name: mcpServerName,
+            tool: toolName,
+        });
+    }
+    onMcpServerAdded(mcpServerName, tools, enabled_tools) {
+        logger.debug(`[onMcpServerAdded]: ${mcpServerName}, tools: ${JSON.stringify(tools)}` +
+            `, enabled: ${JSON.stringify(enabled_tools)}`);
+        const mcpServerInfo = new mcpServerManager_1.McpServerInfoRW(tools);
+        for (const tool of enabled_tools) {
+            mcpServerInfo.enableTool(tool);
+        }
+        this.mcpServers[mcpServerName] = mcpServerInfo;
+    }
+    onMcpServerRemoved(mcpServerName) {
+        delete this.mcpServers[mcpServerName];
+    }
+    onMcpServerToolEnabled(mcpServerName, toolName) {
+        const server = this.mcpServers[mcpServerName];
+        if (!server) {
+            throw Error(`no server ${mcpServerName} (onMcpServerToolEnabled)`);
+        }
+        const tools = server.getTool(toolName);
+        if (!tools) {
+            throw Error(`no tool ${toolName} on server ${mcpServerName}`);
+        }
+        server.enableTool(toolName);
+    }
+    onMcpServerToolDisabled(mcpServerName, toolName) {
+        const server = this.mcpServers[mcpServerName];
+        if (!server) {
+            throw Error(`no server ${mcpServerName} (onMcpServerToolDisabled)`);
+        }
+        const tools = server.getTool(toolName);
+        if (!tools) {
+            throw Error(`no tool ${toolName} on server ${mcpServerName}`);
+        }
+        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;
+    }
+    async addMcpServer(server_name, enable_all) {
+        if (!this.briefsMap[server_name]) {
+            throw Error(`no such server ${server_name} (addMcpServer)`);
+        }
+        this.sender.sendMessage({
+            type: "add_mcp_server",
+            server_name,
+            enable_all,
+        });
+    }
+}
 class ChatClient {
-    constructor(ws, onMessageCB, onConnectionClosedCB) {
+    constructor(platform, ws, onMessageCB, onConnectionClosedCB, serverBriefs) {
+        this.platform = platform;
         this.ws = ws;
         this.onMessageCB = onMessageCB;
         this.onConnectionClosedCB = onConnectionClosedCB;
         this.closed = false;
+        this.msm = new RemoteMcpServerManager(this);
+        this.smsm = new RemoteSudoMcpServerManager(this, serverBriefs, this.msm);
+        this.systemPrompt = "";
+        this.model = "";
     }
-    static async initWithParams(host, port, token, params, onMessageCB, onConnectionClosedCB) {
-        return new Promise((r, e) => {
+    static async initWithParams(host, port, token, params, onMessageCB, onConnectionClosedCB, platform) {
+        return new Promise((resolveClient, 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);
+            let client = undefined;
+            const onMsg = (msg) => {
+                if (msg.type === "mcp_server_briefs") {
+                    // This should be received once, as the first message at startup.
+                    (0, assert_1.strict)(!client);
+                    client = new ChatClient(platform, ws, onMessageCB, onConnectionClosedCB, msg.server_briefs);
+                    resolveClient(client);
+                }
+                else {
+                    (0, assert_1.strict)(client);
+                    // Pass all messages to our internal handler (to update mcp state,
+                    // etc) before sending to the client code.
+                    // logger.debug(`[ChatClient.init(onMsg)]: ${JSON.stringify(msg)}`);
+                    client.handleMessageInternal(msg);
+                    client.onMessageCB(msg);
+                }
+            };
             ws.onopen = async () => {
                 logger.info("opened");
                 ws.onmessage = (ev) => {
@@ -63,57 +221,80 @@ class ChatClient {
                             throw `expected "string" data, got ${typeof msgData}`;
                         }
                         logger.debug(`[client.onmessage]: ${msgData}`);
-                        const msg = JSON.parse(msgData);
-                        client.onMessageCB(msg);
+                        onMsg(JSON.parse(msgData));
                     }
                     catch (e) {
-                        client.close();
+                        if (client) {
+                            client.close();
+                        }
                         throw e;
                     }
                 };
-                r(client);
             };
-            ws.onclose = (err) => {
+            ws.onclose = async (err) => {
                 logger.info("closed");
                 logger.info(`[client] WebSocket connection closed: ${JSON.stringify(err)}`);
-                client.closed = true;
-                onConnectionClosedCB();
+                if (client) {
+                    client.closed = true;
+                }
+                await onConnectionClosedCB();
             };
-            ws.onerror = (error) => {
+            ws.onerror = async (error) => {
                 logger.error("[client] WebSocket error:", JSON.stringify(error));
                 e(error);
-                client.closed = true;
-                onConnectionClosedCB();
+                if (client) {
+                    client.closed = true;
+                }
+                await 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) {
+    static async init(host, port, token, onMessageCB, onConnectionClosedCB, platform, 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);
+        return ChatClient.initWithParams(host, port, token, params, onMessageCB, onConnectionClosedCB, platform);
+    }
+    getSudoMcpServerManager() {
+        return this.smsm;
+    }
+    getConversation() {
+        throw "unimpl";
+    }
+    getAgentProfile() {
+        throw "unimpl";
+    }
+    getSystemPrompt() {
+        return this.systemPrompt;
+    }
+    setSystemPrompt(system_prompt) {
+        // Don't set system prompt here.  Wait until we get confirmation from the
+        // server.
+        this.sendMessage({ type: "set_system_prompt", system_prompt });
+    }
+    getModel() {
+        return this.model;
+    }
+    setModel(model) {
+        // Don't set model here.  Wait until we get confirmation from the server.
+        this.sendMessage({ type: "set_model", model });
+    }
+    userMessage(msg, imageB64) {
+        (0, assert_1.strict)(msg);
+        (0, assert_1.strict)(!imageB64, "images not supported in Chat yet");
+        this.sendMessage({
+            type: "msg",
+            message: msg,
+        });
+    }
+    resetConversation() {
+        throw "resetConversation not implemented for ChatClient";
     }
     sendMessage(message) {
         (0, assert_1.strict)(!this.closed);
         const data = JSON.stringify(message);
+        logger.debug(`[ChatClient.sendMessage] ${data}`);
         this.ws.send(data);
     }
     close() {
@@ -121,6 +302,48 @@ class ChatClient {
         this.onConnectionClosedCB();
         this.ws.close();
     }
+    handleMessageInternal(message) {
+        switch (message.type) {
+            //
+            // State updates
+            //
+            case "mcp_server_added":
+                this.msm.onMcpServerAdded(message.server_name, message.tools, message.enabled_tools);
+                break;
+            case "mcp_server_removed":
+                this.msm.onMcpServerRemoved(message.server_name);
+                break;
+            case "mcp_server_tool_enabled":
+                this.msm.onMcpServerToolEnabled(message.server_name, message.tool);
+                break;
+            case "mcp_server_tool_disabled":
+                this.msm.onMcpServerToolDisabled(message.server_name, message.tool);
+                break;
+            case "system_prompt_updated":
+                this.systemPrompt = message.system_prompt;
+                break;
+            case "model_updated":
+                this.model = message.model;
+                break;
+            //
+            // Actions
+            //
+            case "open_url":
+                this.platform.openUrl(message.url, new Promise(() => { }), // TODO: Why do we need this?  Remove it.
+                message.display_name);
+                break;
+            case "approve_tool_call":
+                throw "unimpl approve_tool_call";
+            // break;
+            //
+            // Ignore other messages - the owner (the UI layer) can handle them at
+            // its discretion.
+            //
+            default:
+                logger.debug(`[handleMessageInternal]: ignoring message: ${message.type}`);
+                break;
+        }
+    }
 }
 exports.ChatClient = ChatClient;
 // TODO: remove this

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

@@ -18,9 +18,11 @@ exports.UserAlreadyConnected = UserAlreadyConnected;
  * Describes a Session (conversation) with connected participants.
  */
 class OpenSession {
-    constructor(agent, sudoMcpServerManager, onEmpty) {
-        // public agent: Agent,
+    constructor(db, agent, sessionUUID, agentProfileUUID, sudoMcpServerManager, onEmpty) {
+        this.db = db;
         this.agent = agent;
+        this.sessionUUID = sessionUUID;
+        this.agentProfileUUID = agentProfileUUID;
         this.skillManager = sudoMcpServerManager;
         this.onEmpty = onEmpty;
         this.connections = {};
@@ -34,6 +36,22 @@ class OpenSession {
         // Inform any other participants, and add the WebSocket to the map.
         this.broadcast({ type: "user_joined", user: userName });
         this.connections[userName] = ws;
+        // TODO:
+        //
+        //   - send conversation state (ServerHistory)
+        const briefs = this.skillManager.getServerBriefs();
+        this.sendTo(userName, { type: "mcp_server_briefs", server_briefs: briefs });
+        const msm = this.agent.getMcpServerManager();
+        const mcpServerNames = msm.getMcpServerNames();
+        for (const serverName of mcpServerNames) {
+            const info = msm.getMcpServer(serverName);
+            this.sendTo(userName, {
+                type: "mcp_server_added",
+                server_name: serverName,
+                tools: info.getTools(),
+                enabled_tools: Object.keys(info.getEnabledTools()),
+            });
+        }
         ws.on("message", async (message) => {
             logger.debug(`[convMgr]: got message: (from ${userName}): ${message}`);
             const msgStr = message.toString();
@@ -57,12 +75,59 @@ class OpenSession {
     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)}`;
+        // In general, handlers return a message to be broadcast.  Errors are
+        // handled by returning an error to just the sender.  Handlers can
+        // also broadcast and send directly.
+        try {
+            const msg = queuedMessage.msg;
+            let broadcastMsg = undefined;
+            switch (msg.type) {
+                case "msg":
+                    broadcastMsg = await this.onChatMessage(msg.message, queuedMessage.from);
+                    break;
+                case "add_mcp_server":
+                    broadcastMsg = await this.onAddMcpServer(msg.server_name, msg.enable_all);
+                    break;
+                case "remove_mcp_server":
+                    broadcastMsg = await this.onRemoveMcpServer(msg.server_name);
+                    break;
+                case "enable_mcp_server_tool":
+                    broadcastMsg = await this.onEnableMcpServerTool(msg.server_name, msg.tool);
+                    break;
+                case "disable_mcp_server_tool":
+                    broadcastMsg = await this.onDisableMcpServerTool(msg.server_name, msg.tool);
+                    break;
+                case "enable_all_mcp_server_tools":
+                    broadcastMsg = await this.onEnableAllMcpServerTools(msg.server_name);
+                    break;
+                case "disable_all_mcp_server_tools":
+                    broadcastMsg = await this.onDisableAllMcpServerTools(msg.server_name);
+                    break;
+                case "set_system_prompt":
+                    broadcastMsg = await this.onSetSystemPrompt(msg.system_prompt);
+                    break;
+                case "set_model":
+                    broadcastMsg = await this.onSetModel(msg.model);
+                    break;
+                default:
+                    throw `unknown message: ${JSON.stringify(queuedMessage)}`;
+            }
+            if (broadcastMsg) {
+                if (broadcastMsg instanceof Array) {
+                    broadcastMsg.map((msg) => this.broadcast(msg));
+                }
+                else {
+                    this.broadcast(broadcastMsg);
+                }
+            }
+        }
+        catch (err) {
+            if (typeof err === "string") {
+                this.sendTo(queuedMessage.from, { type: "error", message: err });
+            }
+            else {
+                throw err;
+            }
         }
     }
     async onAgentMessage(msg, end) {
@@ -75,20 +140,114 @@ class OpenSession {
             end,
         });
     }
-    async onChatMessage(queuedMessage) {
-        const msg = queuedMessage.msg;
-        const userToken = queuedMessage.from;
+    async onChatMessage(message, 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.
         const msgId = (0, uuid_1.v4)();
         this.broadcast({
             type: "user_msg",
             message_id: msgId,
-            message: msg.message,
+            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);
+        await this.agent.userMessageEx(message, undefined, userToken);
+    }
+    async onAddMcpServer(serverName, enableAll) {
+        logger.info(`[onAddMcpServer]: Adding server ${serverName} (enable_all: ${enableAll})`);
+        const mcpServerManager = this.agent.getMcpServerManager();
+        if (mcpServerManager.hasMcpServer(serverName)) {
+            throw `${serverName} already added`;
+        }
+        if (!this.skillManager.hasServer(serverName)) {
+            throw `no such server: ${serverName}`;
+        }
+        await this.skillManager.addMcpServer(serverName, enableAll);
+        mcpServerManager.enableAllTools(serverName);
+        // Save changes to the AgentProfile
+        await this.updateAgentProfile();
+        // Broadcast the message to all participants.
+        const server = mcpServerManager.getMcpServer(serverName);
+        const tools = server.getTools();
+        const enabled_tools = Object.keys(server.getEnabledTools());
+        return {
+            type: "mcp_server_added",
+            server_name: serverName,
+            tools,
+            enabled_tools,
+        };
+    }
+    async onRemoveMcpServer(server_name) {
+        logger.info(`[onRemoveMcpServer]: Removing server ${server_name}`);
+        const mcpServerManager = this.agent.getMcpServerManager();
+        if (!mcpServerManager.hasMcpServer(server_name)) {
+            throw `${server_name} not enabled`;
+        }
+        await mcpServerManager.removeMcpServer(server_name);
+        await this.updateAgentProfile();
+        return {
+            type: "mcp_server_removed",
+            server_name,
+        };
+    }
+    async onEnableMcpServerTool(server_name, tool) {
+        const msm = this.agent.getMcpServerManager();
+        this.ensureMcpServerAndTool(msm, server_name, tool);
+        msm.enableTool(server_name, tool);
+        await this.updateAgentProfile();
+        return { type: "mcp_server_tool_enabled", server_name, tool };
+    }
+    async onDisableMcpServerTool(server_name, tool) {
+        const msm = this.agent.getMcpServerManager();
+        this.ensureMcpServerAndTool(msm, server_name, tool);
+        msm.disableTool(server_name, tool);
+        await this.updateAgentProfile();
+        return { type: "mcp_server_tool_disabled", server_name, tool };
+    }
+    async onEnableAllMcpServerTools(server_name) {
+        // We reimplement the logic to enable any disabled tools so we can
+        // construct messages along the way.
+        const msm = this.agent.getMcpServerManager();
+        const server = this.ensureMcpServer(msm, server_name);
+        const enabledTools = server.getEnabledTools();
+        const msgs = [];
+        for (const tool of server.getTools()) {
+            if (!enabledTools[tool.name]) {
+                msm.enableTool(server_name, tool.name);
+                msgs.push({
+                    type: "mcp_server_tool_enabled",
+                    server_name,
+                    tool: tool.name,
+                });
+            }
+        }
+        await this.updateAgentProfile();
+        return msgs;
+    }
+    async onDisableAllMcpServerTools(server_name) {
+        // We reimplement the logic to disable all enabled tools so we can
+        // construct messages along the way.
+        const msm = this.agent.getMcpServerManager();
+        const server = this.ensureMcpServer(msm, server_name);
+        const enabledTools = server.getEnabledTools();
+        const msgs = [];
+        for (const tool in enabledTools) {
+            msm.disableTool(server_name, tool);
+            msgs.push({ type: "mcp_server_tool_disabled", server_name, tool });
+        }
+        await this.updateAgentProfile();
+        return msgs;
+    }
+    async onSetSystemPrompt(system_prompt) {
+        this.agent.setSystemPrompt(system_prompt);
+        await this.updateAgentProfile();
+        return { type: "system_prompt_updated", system_prompt };
+    }
+    async onSetModel(model) {
+        this.agent.setModel(model);
+        await this.updateAgentProfile();
+        return { type: "model_updated", model };
     }
     broadcast(msg) {
         logger.info(`[broadcast]: broadcast msg: ${JSON.stringify(msg)}`);
@@ -97,6 +256,34 @@ class OpenSession {
             ws.send(msgString);
         }
     }
+    sendTo(userName, msg) {
+        const ws = this.connections[userName];
+        const msgString = JSON.stringify(msg);
+        logger.info(`[sendTo]: (${userName}) msg: ${msgString}`);
+        (0, assert_1.strict)(ws);
+        ws.send(msgString);
+    }
+    ensureMcpServer(msm, serverName) {
+        const server = msm.getMcpServer(serverName);
+        if (!server) {
+            throw `${serverName} not added`;
+        }
+        return server;
+    }
+    ensureMcpServerAndTool(msm, serverName, toolName) {
+        const server = this.ensureMcpServer(msm, serverName);
+        const tool = server.getTool(toolName);
+        if (!tool) {
+            throw `Tool ${toolName} on ${serverName} not found`;
+        }
+        return tool;
+    }
+    async updateAgentProfile() {
+        const profile = this.agent.getAgentProfile();
+        logger.debug(`[updateAgentProfile]: uuid: ${this.agentProfileUUID} profile: ` +
+            JSON.stringify(profile));
+        return this.db.updateAgentProfile(this.agentProfileUUID, profile);
+    }
 }
 exports.OpenSession = OpenSession;
 /**
@@ -113,7 +300,7 @@ class ConversationManager {
     }
     async join(sessionId, llmApiKey, xmcpApiKey, userData, ws) {
         await this.openSessionsLock.lockAndProcess(() => {
-            return this.getOrCreateAndSubscribe(sessionId, llmApiKey, xmcpApiKey, userData.nickname || userData.user_uuid, ws);
+            return this.getOrCreateAndSubscribe(sessionId, llmApiKey, xmcpApiKey, userData.nickname || userData.uuid, ws);
         });
     }
     /**
@@ -138,20 +325,46 @@ class ConversationManager {
             throw `no such session ${sessionId}`;
         }
         const conversation = sessionData.conversation;
-        const agentProfile = await this.db.getAgentProfileById(sessionData.agent_profile_uuid);
+        const agentProfileUUID = sessionData.agent_profile_uuid;
+        const agentProfile = await this.db.getAgentProfileById(agentProfileUUID);
         if (!agentProfile) {
-            throw `no such agent profile ${sessionData.agent_profile_uuid}`;
+            throw `no such agent profile ${agentProfileUUID}`;
         }
+        // TODO: store some owner data on the OpenSession object itself?
+        const owner = await this.db.getUserFromUuid(sessionData.user_uuid);
+        (0, assert_1.strict)(owner, `no owner for session ${JSON.stringify(sessionData)}`);
+        const ownerUserName = owner.nickname;
+        if (!ownerUserName) {
+            throw (`user ${sessionData.user_uuid} has no user name - ` +
+                "cannot create chat session");
+        }
+        // Access to the OpenSession (once it is iniailized
+        const context = {};
         const platform = {
-            openUrl: (_url, _authResultP, _displayName) => {
-                throw "unimpl";
+            openUrl: (url, _authResultP, display_name) => {
+                // These requests are always passed to the original owner, since it is
+                // his settings that will be used for all mcp servers.
+                if (context.openSession) {
+                    const conn = openSession.connections[ownerUserName];
+                    if (conn) {
+                        openSession.sendTo(ownerUserName, {
+                            type: "open_url",
+                            url,
+                            display_name,
+                        });
+                    }
+                    else {
+                        throw `user ${ownerUserName} must authenticate`;
+                    }
+                }
+                else {
+                    throw `no open session ${sessionData.uuid}`;
+                }
             },
             load: (_filename) => {
-                throw "unimpl";
+                throw "unimpl platform.load";
             },
         };
-        // 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);
@@ -159,11 +372,17 @@ class ConversationManager {
         };
         const onToolCall = async (toolCall) => {
             logger.debug(`[onToolCall] : ${JSON.stringify(toolCall)}`);
+            (0, assert_1.strict)(context.openSession);
+            context.openSession.broadcast({
+                type: "agent_tool_call",
+                message_id: toolCall.id,
+                message: 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);
+        openSession = new OpenSession(this.db, agent, sessionId, agentProfileUUID, smsm, onEmpty);
         context.openSession = openSession;
         this.openSessions[sessionId] = openSession;
         openSession.join(userName, ws);