@xalia/agent 0.5.8 → 0.6.0

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

@@ -1,502 +0,0 @@
-"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");
-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(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 = {};
-        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, then add the new WebSocket to the map.
-        this.broadcast({ type: "user_joined", user: userName });
-        this.connections[userName] = ws;
-        // 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();
-        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,
-                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) => {
-            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)}`);
-        // 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) {
-        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(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.
-        const msgId = (0, uuid_1.v4)();
-        this.broadcast({
-            type: "user_msg",
-            message_id: msgId,
-            message,
-            // imageB64,
-            from: userToken,
-        });
-        this.curAgentMsgId = `${msgId}-resp`;
-        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})`);
-        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)}`);
-        const msgString = JSON.stringify(msg);
-        for (const ws of Object.values(this.connections)) {
-            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;
-/**
- * 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.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 agentProfileUUID = sessionData.agent_profile_uuid;
-        const agentProfile = await this.db.getAgentProfileById(agentProfileUUID);
-        if (!agentProfile) {
-            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, 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 platform.load";
-            },
-        };
-        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)}`);
-            (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(this.db, agent, sessionId, agentProfileUUID, smsm, onEmpty);
-        context.openSession = openSession;
-        this.openSessions[sessionId] = openSession;
-        openSession.join(userName, ws);
-        return openSession;
-    }
-}
-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;
-}