@xalia/agent 0.5.7 → 0.6.0

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

@@ -1,392 +0,0 @@
-"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(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, 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();
-            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, 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,
-            from: userToken,
-        });
-        this.curAgentMsgId = `${msgId}-resp`;
-        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)}`);
-        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;

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

@@ -1,209 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Database = exports.SUPABASE_LOCAL_KEY = exports.SUPABASE_LOCAL_URL = void 0;
-exports.resolveCompoundName = resolveCompoundName;
-const supabase_js_1 = require("@supabase/supabase-js");
-const sdk_1 = require("@xalia/xmcp/sdk");
-const logger = (0, sdk_1.getLogger)();
-exports.SUPABASE_LOCAL_URL = "http://127.0.0.1:54321";
-exports.SUPABASE_LOCAL_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiw" +
-    "icm9sZSI6InNlcnZpY2Vfcm9sZSIsImV4cCI6MTk4MzgxMjk5Nn0.EGIM96RAZx35lJz" +
-    "dJsyH-qQwv8Hdp7fsn3W0YpN81IU";
-/**
- * 'name' -> 'name'
- * 'space/name' -> ['space', 'name']
- */
-function resolveCompoundName(name) {
-    const components = name.split("/");
-    if (components.length === 1) {
-        return name;
-    }
-    if (components.length !== 2) {
-        throw "invalid compound name";
-    }
-    return components;
-}
-class Database {
-    constructor(supabaseUrl, supabaseKey) {
-        this.client = (0, supabase_js_1.createClient)(supabaseUrl, supabaseKey);
-    }
-    async getUserDataFromApiKey(apiKey) {
-        const { data, error } = await this.client
-            .from("api_keys")
-            .select("user_uuid, users ( nickname )")
-            .eq("api_key", apiKey)
-            .maybeSingle();
-        logger.debug(`[getUserDataFromApiKey]: got ${JSON.stringify({ data, error })}`);
-        if (error) {
-            throw error;
-        }
-        if (data === null) {
-            return undefined;
-        }
-        return {
-            uuid: data.user_uuid,
-            nickname: data.users.nickname || `user ${data.user_uuid}`,
-        };
-    }
-    async getUserFromUuid(user_uuid) {
-        const { data, error } = await this.client
-            .from("users")
-            .select("*")
-            .eq("uuid", user_uuid)
-            .maybeSingle();
-        if (error) {
-            throw error;
-        }
-        return data;
-    }
-    async createUser(user_uuid, email, nickname, timezone) {
-        const payload = {
-            uuid: user_uuid,
-            email,
-            nickname,
-            timezone: timezone || "UTC",
-        };
-        const { error } = await this.client.from("users").insert(payload);
-        if (error) {
-            throw error;
-        }
-    }
-    async addApiKey(user_uuid, api_key, name, scopes, is_default = false) {
-        const payload = {
-            user_uuid,
-            api_key,
-            name,
-            scopes,
-            is_default,
-        };
-        const { data, error } = await this.client
-            .from("api_keys")
-            .insert(payload)
-            .select("*")
-            .maybeSingle();
-        if (error) {
-            throw error;
-        }
-        return data;
-    }
-    async getSavedAgentProfileById(agentProfileId) {
-        const { data, error } = await this.client
-            .from("agent_profiles")
-            .select("*")
-            .eq("uuid", agentProfileId)
-            .maybeSingle();
-        if (error) {
-            throw error;
-        }
-        return data
-            ? sdk_1.SavedAgentProfile.fromJSONObj(data)
-            : undefined;
-    }
-    async getSavedAgentProfileByName(user_uuid, agentProfileName) {
-        const { data, error } = await this.client
-            .from("agent_profiles")
-            .select("*")
-            .eq("user_uuid", user_uuid)
-            .eq("profile_name", agentProfileName)
-            .maybeSingle();
-        if (error) {
-            throw error;
-        }
-        return data
-            ? sdk_1.SavedAgentProfile.fromJSONObj(data)
-            : undefined;
-    }
-    async getAgentProfileById(agentProfileId) {
-        const { data, error } = await this.client
-            .from("agent_profiles")
-            .select("profile")
-            .eq("uuid", agentProfileId)
-            .maybeSingle();
-        if (error) {
-            throw error;
-        }
-        return data
-            ? sdk_1.AgentProfile.fromJSONObj(data.profile)
-            : undefined;
-    }
-    async createAgentProfile(user_uuid, profileName, profile) {
-        const payload = {
-            profile: profile,
-            user_uuid,
-            profile_name: profileName,
-        };
-        const { data, error } = await this.client
-            .from("agent_profiles")
-            .upsert(payload)
-            .select("uuid");
-        if (error) {
-            throw error;
-        }
-        if (!data || !data[0] || !data[0].uuid) {
-            return undefined;
-        }
-        return data[0].uuid;
-    }
-    async updateAgentProfile(uuid, profile) {
-        const payload = {
-            profile: profile,
-        };
-        const { error } = await this.client
-            .from("agent_profiles")
-            .update(payload)
-            .eq("uuid", uuid);
-        if (error) {
-            throw error;
-        }
-    }
-    async clearAgentProfiles() {
-        await this.client.from("agent_profiles").delete().neq("uuid", "");
-    }
-    // TODO: is there a session model?
-    async getSessionById(session_uuid) {
-        const { data, error } = await this.client
-            .from("sessions")
-            .select("*")
-            .eq("uuid", session_uuid)
-            .maybeSingle();
-        if (error) {
-            throw error;
-        }
-        return data;
-    }
-    async getSessionByName(user_uuid, session_name) {
-        const { data, error } = await this.client
-            .from("sessions")
-            .select("*")
-            .eq("user_uuid", user_uuid)
-            .eq("title", session_name)
-            .maybeSingle();
-        if (error) {
-            throw error;
-        }
-        return data;
-    }
-    async createSession(user_uuid, title, agentProfileId) {
-        const payload = {
-            agent_profile_uuid: agentProfileId,
-            user_uuid,
-            title: title,
-            conversation: [],
-        };
-        const { data, error } = await this.client
-            .from("sessions")
-            .upsert(payload)
-            .select("uuid");
-        if (error) {
-            throw error;
-        }
-        if (!data || !data[0] || !data[0].uuid) {
-            return undefined;
-        }
-        return data[0].uuid;
-    }
-    async clearSessions() {
-        await this.client.from("sessions").delete().neq("uuid", "");
-    }
-}
-exports.Database = Database;

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

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FrontendChatClient = void 0;
-class FrontendChatClient {
-    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((resolve, reject) => {
-            const urlParams = new URLSearchParams(params);
-            const url = `ws://${host}:${port}?${urlParams}`;
-            const ws = new WebSocket(url, [token]);
-            console.log("created ws");
-            const client = new FrontendChatClient(ws, onMessageCB, onConnectionClosedCB);
-            ws.onopen = async () => {
-                console.log("opened");
-                ws.onmessage = (ev) => {
-                    try {
-                        const msgData = ev.data;
-                        if (typeof msgData !== "string") {
-                            throw `expected "string" data, got ${typeof msgData}`;
-                        }
-                        console.debug(`[client.onmessage]: ${msgData}`);
-                        const msg = JSON.parse(msgData);
-                        client.onMessageCB(msg);
-                    }
-                    catch (e) {
-                        client.close();
-                        throw e;
-                    }
-                };
-                resolve(client);
-            };
-            ws.onclose = (event) => {
-                console.log("closed");
-                console.log(`[client] WebSocket connection closed: ${JSON.stringify(event)}`);
-                client.closed = true;
-                onConnectionClosedCB();
-            };
-            ws.onerror = (error) => {
-                console.error("[client] WebSocket error:", error);
-                reject(error);
-                client.closed = true;
-                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 FrontendChatClient.initWithParams(host, port, token, params, onMessageCB, onConnectionClosedCB);
-    }
-    sendMessage(message) {
-        if (this.closed) {
-            throw new Error("Cannot send message on closed connection");
-        }
-        const data = JSON.stringify(message);
-        this.ws.send(data);
-    }
-    close() {
-        this.closed = true;
-        this.onConnectionClosedCB();
-        this.ws.close();
-    }
-    isClosed() {
-        return this.closed;
-    }
-}
-exports.FrontendChatClient = FrontendChatClient;