@xalia/agent 0.5.7 → 0.6.0

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

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+"use strict";
+// -*- typescript -*-
+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.OpenSession = exports.ConnectionManager = void 0;
+exports.runServer = runServer;
+exports.resolveSessionIdFromIdentifier = resolveSessionIdFromIdentifier;
+exports.resolveAgentProfileId = resolveAgentProfileId;
+const dotenv = __importStar(require("dotenv"));
+const sdk_1 = require("@xalia/xmcp/sdk");
+const ws_1 = require("ws");
+const connectionManager_1 = require("./connectionManager");
+const database_1 = require("../data/database");
+const apiKeyManager_1 = require("../data/apiKeyManager");
+const errors_1 = require("../protocol/errors");
+const sessionRegistry_1 = require("./sessionRegistry");
+dotenv.config();
+const logger = (0, sdk_1.getLogger)();
+/**
+ * Extract error message from unknown error type
+ */
+function extractErrorMessage(e) {
+    if (typeof e === "string")
+        return e;
+    if (e instanceof Error)
+        return e.message;
+    return "Unknown connection error";
+}
+/**
+ * Send error response and close WebSocket connection
+ */
+function sendErrorAndClose(ws, message) {
+    try {
+        sendErrorResponse(ws, message);
+    }
+    catch (closeError) {
+        logger.error(`[server] Error closing connection:`, closeError);
+    }
+    finally {
+        ws.close(4000, message);
+    }
+}
+/**
+ * Send error response but keep connection open
+ */
+function sendErrorResponse(ws, message) {
+    try {
+        ws.send(JSON.stringify({
+            t: "error",
+            e: message,
+        }));
+    }
+    catch (sendError) {
+        logger.error(`[server] Error sending error response:`, sendError);
+    }
+}
+async function runServer(port, supabaseUrl, supabaseKey, llmUrl, xmcpUrl) {
+    return new Promise((r, _e) => {
+        const wss = new ws_1.WebSocketServer({ port });
+        const db = new database_1.Database(supabaseUrl, supabaseKey);
+        const apiKeyManager = new apiKeyManager_1.ApiKeyManager(db);
+        const createSessionRegistry = (connManager) => {
+            return new sessionRegistry_1.SessionRegistry(db, connManager, llmUrl, xmcpUrl);
+        };
+        const connectionManager = connectionManager_1.ConnectionManager.init(apiKeyManager, createSessionRegistry);
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        wss.on("connection", async (ws, req) => {
+            try {
+                logger.info(`[server] connection: ${req.url || "unknown"}`);
+                logger.info(`[server] headers: ${JSON.stringify(req.headers)}`);
+                // Extract API key and clientMessageId from WebSocket subprotocol header
+                // Format: "apiKey, clientMessageId" (comma-separated)
+                const subprotocols = req.headers["sec-websocket-protocol"];
+                if (!subprotocols) {
+                    throw new errors_1.ChatFatalError("empty api key");
+                }
+                // Parse the subprotocols - they come as comma-separated string
+                if (typeof subprotocols !== "string") {
+                    throw new errors_1.ChatFatalError("subprotocols was not a string");
+                }
+                const protocols = subprotocols.split(",").map((p) => p.trim());
+                const apiKey = protocols[0];
+                if (!apiKey) {
+                    throw new errors_1.ChatFatalError("empty api key");
+                }
+                // Handle via ConnectionManager (multi-session protocol only)
+                await connectionManager.handleConnection(ws, apiKey, req);
+            }
+            catch (e) {
+                logger.error(`[server] Connection error:`, e);
+                // Extract error message consistently
+                const errorMessage = extractErrorMessage(e);
+                if (e instanceof errors_1.ChatFatalError) {
+                    // Fatal errors: send error response and close connection
+                    sendErrorAndClose(ws, errorMessage);
+                }
+                else {
+                    // Non-fatal errors: send error response but keep connection open
+                    sendErrorResponse(ws, errorMessage);
+                    logger.error(`[server] Client error:`, errorMessage);
+                }
+            }
+        });
+        logger.info(`[server] started: ws://localhost:${String(port)}/`);
+        r(wss);
+    });
+}
+async function resolveSessionIdFromIdentifier(db, sessionIdentifier) {
+    logger.info(`[resolveSessionIdFromIdentifier] ${sessionIdentifier}`);
+    let session = undefined;
+    const compound = (0, database_1.resolveCompoundName)(sessionIdentifier);
+    logger.info(`[resolveSessionIdFromIdentifier] compound: ${JSON.stringify(compound)}`);
+    if (typeof compound === "string") {
+        // Interpret as an id
+        session = await db.sessionGetById(compound);
+    }
+    else {
+        session = await db.sessionGetByName(compound[0], compound[1]);
+    }
+    logger.info(`[resolveSessionIdFromIdentifier] ${JSON.stringify(session)}`);
+    return session?.session_uuid;
+}
+/**
+ * Try as id, then by user/name and return the AgentProfile uuid.
+ */
+async function resolveAgentProfileId(db, userData, agentProfileIdentifier) {
+    let ap = await db.getSavedAgentProfileById(agentProfileIdentifier);
+    logger.debug(`[resolveAgentProfileId]: by id: {JSON.stringify(ap)}`);
+    if (ap) {
+        return agentProfileIdentifier;
+    }
+    ap = await db.getSavedAgentProfileByName(userData.uuid, agentProfileIdentifier);
+    logger.debug(`[resolveAgentProfileId]: by name: {JSON.stringify(ap)}`);
+    if (ap) {
+        return ap.uuid;
+    }
+    logger.debug("[resolveAgentProfileId]: agent profile not found");
+    return undefined;
+}
+// Export main classes for external use
+var connectionManager_2 = require("./connectionManager");
+Object.defineProperty(exports, "ConnectionManager", { enumerable: true, get: function () { return connectionManager_2.ConnectionManager; } });
+var openSession_1 = require("./openSession");
+Object.defineProperty(exports, "OpenSession", { enumerable: true, get: function () { return openSession_1.OpenSession; } });

package/dist/agent/src/chat/server/sessionFileManager.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatSessionFileManager = exports.MemoryFileManager = exports.SESSION_FILE_TYPES = void 0;
+exports.listFilesForLLM = listFilesForLLM;
+exports.fileManagerTool = fileManagerTool;
+const uuid_1 = require("uuid");
+const tools_1 = require("./tools");
+exports.SESSION_FILE_TYPES = ["text", "image", "pdf"];
+/**
+ * In-memory implementation of ISessionFileManager
+ */
+class MemoryFileManager {
+    constructor() {
+        this.files = new Map();
+        this.eventHandler = undefined;
+    }
+    // ISessionFileManager.listFiles
+    listFiles() {
+        return Array.from(this.files.values());
+    }
+    // ISessionFileManager.getFileContent
+    getFileContent(name) {
+        return new Promise((r, e) => {
+            const entry = this.files.get(name);
+            if (entry) {
+                r(entry.content);
+            }
+            else {
+                e(new Error(`no such file ${name}`));
+            }
+        });
+    }
+    // ISessionFileManager.addFile
+    putFileContent(name, file_type, summary, content) {
+        return new Promise((r, e) => {
+            if (!name) {
+                name = (0, uuid_1.v4)();
+            }
+            if (!summary) {
+                summary = "";
+            }
+            if (!isSingleLine(summary)) {
+                e(new Error("summary must no contain new-lines"));
+            }
+            else {
+                const entry = { name, file_type, summary, content };
+                this.eventHandler?.onFileChange(entry);
+                this.files.set(name, entry);
+                r(name);
+            }
+        });
+    }
+    // ISessionFileManager.setEventHandler
+    setEventHandler(eventHandler) {
+        this.eventHandler = eventHandler;
+    }
+}
+exports.MemoryFileManager = MemoryFileManager;
+/**
+ * Implementation of ISessionFileManager which can store files in the DB.
+ */
+class ChatSessionFileManager extends MemoryFileManager {
+    // private readonly db: Database;
+    // private readonly sessionUUID: string;
+    constructor(_sessionUUID, _db) {
+        super();
+        // this.db = db;
+        // this.sessionUUID = sessionUUID;
+    }
+}
+exports.ChatSessionFileManager = ChatSessionFileManager;
+/**
+ * Return the file list in a form easily parsable by the LLM.
+ */
+function listFilesForLLM(fm) {
+    const files = fm.listFiles();
+    if (files.length === 0) {
+        return "";
+    }
+    let summary = "Available files:\nname,type,summary\n";
+    for (const f of files) {
+        summary += `${f.name},${f.file_type},${f.summary || ""}\n`;
+    }
+    return summary;
+}
+const GET_FILE_CONTENT_TOOL = {
+    type: "function",
+    function: {
+        name: "get_file_content",
+        description: "Obtain the contents of a file listed in the system prompt",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "File name",
+                },
+            },
+            required: ["name"],
+        },
+    },
+};
+const PUT_FILE_CONTENT_TOOL = {
+    type: "function",
+    function: {
+        name: "put_file_content",
+        description: "Create or update file content",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "File name",
+                },
+                file_type: {
+                    type: "string",
+                    enum: exports.SESSION_FILE_TYPES,
+                },
+                summary: {
+                    type: "string",
+                    description: "Content summary",
+                },
+                content: {
+                    type: "string",
+                    description: "Content (text/dataurl)",
+                },
+            },
+            required: ["name", "type", "summary", "content"],
+        },
+    },
+};
+function fileManagerTool(fileManager) {
+    // get_file_content
+    const getName = (0, tools_1.makeParseArgsFn)(["name"]);
+    const getFileContentFn = async (_agent, args) => {
+        const { name } = getName(args);
+        const response = await fileManager.getFileContent(name);
+        return { response };
+    };
+    // set_file_content
+    const putArgs = ["name", "file_type", "summary", "content"];
+    const getNameSummaryContent = (0, tools_1.makeParseArgsFn)(putArgs);
+    const putFileContentFn = async (_, args) => {
+        const { name, file_type, summary, content } = getNameSummaryContent(args);
+        const response = await fileManager.putFileContent(name, file_type, summary, content);
+        return { response };
+    };
+    const provider = {
+        setup: (agent) => {
+            agent.addAgentTool(GET_FILE_CONTENT_TOOL, getFileContentFn);
+            agent.addAgentTool(PUT_FILE_CONTENT_TOOL, putFileContentFn);
+            return new Promise((r) => {
+                r();
+            });
+        },
+    };
+    return provider;
+}
+function isSingleLine(str) {
+    return !/[\r\n]/.test(str);
+}