@xalia/agent 0.5.7 → 0.6.0

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

@@ -0,0 +1,700 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionRegistry = void 0;
+exports.userSessionDataCreate = userSessionDataCreate;
+exports.teamSessionDataCreate = teamSessionDataCreate;
+const uuid_1 = require("uuid");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const messages_1 = require("../protocol/messages");
+const openSession_1 = require("./openSession");
+const database_1 = require("../data/database");
+const userResolver_1 = require("../utils/userResolver");
+const errors_1 = require("../protocol/errors");
+const agentUtils_1 = require("../../agent/agentUtils");
+const errorUtils_1 = require("./errorUtils");
+const logger = (0, sdk_1.getLogger)();
+class SessionRegistry {
+    constructor(db, connectionManager, llmUrl, xmcpUrl) {
+        this.db = db;
+        this.connectionManager = connectionManager;
+        this.llmUrl = llmUrl;
+        this.xmcpUrl = xmcpUrl;
+        // In memory session-user/user-session mappings
+        // Note: this mappings ONLY trackes online users and will
+        // be cleaned up when the user disconnects.
+        // sessionId -> userIds
+        this.sessionUsers = new Map();
+        // userId -> sessionIds
+        this.userSessions = new Map();
+        // Session instances
+        // sessionId -> OpenSession
+        this.openSessions = new Map();
+    }
+    /**
+     * Add user to session membership.
+     * Creates session tracking if it doesn't exist.
+     */
+    addUserToSessionMemory(userId, sessionId) {
+        logger.debug(`[SessionRegistry] Adding user ${userId} to session ${sessionId}`);
+        // Add to sessionUsers
+        if (!this.sessionUsers.has(sessionId)) {
+            this.sessionUsers.set(sessionId, new Set());
+        }
+        const sessionUserSet = this.sessionUsers.get(sessionId);
+        if (sessionUserSet) {
+            sessionUserSet.add(userId);
+        }
+        // Add to userSessions
+        if (!this.userSessions.has(userId)) {
+            this.userSessions.set(userId, new Set());
+        }
+        const userSessionSet = this.userSessions.get(userId);
+        if (userSessionSet) {
+            userSessionSet.add(sessionId);
+        }
+    }
+    /**
+     * Remove user from session membership.
+     * Cleans up empty sessions and triggers session cleanup if needed.
+     */
+    removeUserFromSessionMemory(userId, sessionId) {
+        logger.debug(`[SessionRegistry] Removing user ${userId} from session ${sessionId}`);
+        // Remove from sessionUsers
+        const sessionUserSet = this.sessionUsers.get(sessionId);
+        if (sessionUserSet) {
+            sessionUserSet.delete(userId);
+            if (sessionUserSet.size === 0) {
+                this.sessionUsers.delete(sessionId);
+                // Clean up session instance when empty
+                const session = this.openSessions.get(sessionId);
+                if (session) {
+                    logger.debug(`[SessionRegistry] Triggering cleanup for empty session ` +
+                        sessionId);
+                    // The onEmpty callback will remove from openSessions map
+                    logger.debug(`[SessionRegistry] Session ${sessionId} empty. Removing`);
+                    session.onEmpty();
+                    this.openSessions.delete(sessionId);
+                }
+            }
+        }
+        // Remove from userSessions
+        const userSessionSet = this.userSessions.get(userId);
+        if (userSessionSet) {
+            userSessionSet.delete(sessionId);
+            if (userSessionSet.size === 0) {
+                this.userSessions.delete(userId);
+            }
+        }
+        logger.info(`[SessionRegistry] User ${userId} removed from session ${sessionId}`);
+    }
+    /**
+     * Get all users in a session.
+     */
+    async getSessionUsers(sessionId) {
+        const users = await this.db.sessionGetParticipants(sessionId);
+        return new Set(users.map((u) => u.user_uuid));
+    }
+    /**
+     * Get all users in a session.
+     */
+    getInMemorySessionUsers(sessionId) {
+        return this.sessionUsers.get(sessionId) || new Set();
+    }
+    /**
+     * Get all sessions a user belongs to.
+     */
+    getUserSessions(userId) {
+        return this.userSessions.get(userId) || new Set();
+    }
+    /**
+     * Get all sessions a user belongs to in memory.
+     */
+    getInMemoryUserSessions(userId) {
+        return this.userSessions.get(userId) || new Set();
+    }
+    async processMessage(connectionId, userId, message) {
+        if ((0, messages_1.isClientControlMessage)(message)) {
+            // handle connection level message
+            await this.processClientControlMessage(connectionId, userId, message);
+        }
+        else {
+            // handle session level message
+            this.processSessionMessage(userId, message);
+        }
+    }
+    sendControlError(connectionId, clientMsgId, errorMessage) {
+        // TODO: Why is this managed at the transport level?
+        const errorMsg = {
+            type: "control_error",
+            message: errorMessage,
+            client_message_id: clientMsgId,
+        };
+        this.connectionManager.sendToConnection(connectionId, errorMsg);
+    }
+    async processClientControlMessage(connectionId, userId, message) {
+        switch (message.type) {
+            case "control_agent_profile_create":
+                await this.handleAgentProfileCreate(message, userId);
+                break;
+            case "control_agent_profile_delete":
+                // TODO:
+                throw new Error("not implemented yet");
+            case "control_get_session_list":
+                await this.handleGetSessionList(connectionId, userId, message);
+                break;
+            case "control_session_create":
+                await this.handleSessionCreate(connectionId, userId, message);
+                break;
+            case "control_session_join":
+                await this.handleSessionJoin(connectionId, userId, message);
+                break;
+            case "control_session_delete":
+                await this.handleSessionDelete(connectionId, userId, message);
+                break;
+            case "control_team_create":
+                await this.handleTeamCreate(connectionId, userId, message);
+                break;
+            case "control_add_team_user":
+                await this.handleAddTeamUser(connectionId, userId, message);
+                break;
+            case "control_remove_team_user":
+                await this.handleRemoveTeamUser(connectionId, userId, message);
+                break;
+            default: {
+                const exhaustive = message;
+                // unknown connection type should be a fatal error
+                throw new errors_1.ChatFatalError(`Unknown connection message type: ${String(exhaustive)}`);
+            }
+        }
+    }
+    /**
+     * Handle session_list request
+     */
+    async handleGetSessionList(connectionId, userId, message) {
+        try {
+            const [userSessions, teamSessions, userAgents] = await this.getAllAgentsAndSessionsByUser(userId);
+            const response = {
+                type: "control_session_list",
+                user_sessions: userSessions,
+                team_sessions: teamSessions,
+                user_agents: userAgents,
+                client_message_id: message.client_message_id,
+            };
+            this.connectionManager.sendToConnection(connectionId, response);
+            logger.info(`[ConnectionManager] Sent ` +
+                `${String(userSessions.length)} user sessions and ` +
+                `${String(teamSessions.length)} team sessions to user ${userId}`);
+        }
+        catch (error) {
+            logger.error(`[ConnectionManager] Failed to get session list:`, error);
+            this.sendControlError(connectionId, message.client_message_id, JSON.stringify(error));
+        }
+    }
+    async handleSessionDelete(connectionId, userId, message) {
+        const sessionId = message.target_session_id;
+        try {
+            // validate the session access
+            await this.validateSessionAccess(sessionId, userId, "owner");
+            // get users/team-uuid before deletion
+            const [users, teamUuid, sessionData] = await Promise.all([
+                this.getSessionUsers(sessionId),
+                this.db.sessionGetTeamUuid(sessionId),
+                this.db.sessionGetById(sessionId),
+            ]);
+            if (!sessionData) {
+                throw new errors_1.ChatFatalError(`No such session: ${sessionId}`);
+            }
+            // delete the session from database
+            await this.db.sessionDeleteById(sessionId);
+            // remove the session from memory (should be no thrown from here)
+            const session = this.openSessions.get(sessionId);
+            if (session) {
+                const users = this.getInMemorySessionUsers(sessionId);
+                for (const user of users) {
+                    this.removeUserFromSessionMemory(user, sessionId);
+                }
+            }
+            this.openSessions.delete(sessionId);
+            // send confirmation to the client
+            const response = {
+                type: "control_session_deleted",
+                session_id: sessionId,
+                team_uuid: teamUuid,
+                agent_profile_uuid: sessionData.agent_profile_uuid,
+                client_message_id: message.client_message_id,
+            };
+            this.connectionManager.sendToUsers(users, response);
+        }
+        catch (error) {
+            logger.error(`[SessionRegistry] Error delete session ${sessionId}:`, error);
+            this.sendControlError(connectionId, message.client_message_id, String(error));
+        }
+    }
+    /**
+     * Handle team_create_request message - creates a new team.
+     * @param connectionId  connection id
+     * @param userId  user id
+     * @param message  team create request message
+     */
+    async handleTeamCreate(connectionId, userId, message) {
+        try {
+            // Resolve all initial members in parallel
+            // this contains undefined to mark failed lookups
+            const resolvedMemberIds = await Promise.all(message.initial_members.map((member) => (0, userResolver_1.resolveUserIdentifier)(this.db, member)));
+            const failedLookups = [];
+            const validMemberIds = [];
+            const participants = [];
+            // filter out the owner and extract failed lookups
+            resolvedMemberIds.forEach((user, index) => {
+                if (user && user.uuid !== userId) {
+                    validMemberIds.push(user.uuid);
+                    participants.push({
+                        user_uuid: user.uuid,
+                        nickname: user.nickname || "",
+                        email: user.email,
+                        role: "participant",
+                    });
+                }
+                else if (user === undefined) {
+                    failedLookups.push(message.initial_members[index]);
+                }
+            });
+            // Create the team with initial participants
+            const teamUuid = await this.db.createTeamWithParticipants(message.team_name, userId, validMemberIds);
+            const response = {
+                type: "control_team_created",
+                team_uuid: teamUuid,
+                team_owner_uuid: userId,
+                team_name: message.team_name,
+                members: participants,
+                failed_lookups: failedLookups,
+            };
+            const members = new Set(validMemberIds);
+            members.add(userId);
+            this.connectionManager.sendToUsers(members, response);
+        }
+        catch (error) {
+            logger.error(`[SessionRegistry] Error creating team: ${String(error)}`);
+            this.sendControlError(connectionId, message.client_message_id, String(error));
+        }
+    }
+    /**
+     * Process session-scoped client message.
+     * Handles membership messages here, others to OpenSession.
+     */
+    processSessionMessage(userId, message) {
+        const sessionId = message.session_id;
+        logger.info(`[SessionRegistry] Processing message from user ${userId} in session ` +
+            sessionId);
+        const session = this.openSessions.get(sessionId);
+        if (!session) {
+            throw new errors_1.ChatFatalError(`Internal error: No such session ${sessionId}`);
+        }
+        // Forward all other messages to OpenSession
+        session.onClientSessionMessage(userId, message);
+    }
+    /**
+     * Handle add_user message - adds user to team.
+     */
+    async handleAddTeamUser(connectionId, fromUserId, message) {
+        // Validate permissions - only owner can add users
+        const access = await this.validateTeamAccess(message.target_team_id, fromUserId, "owner");
+        if (!access) {
+            this.sendControlError(connectionId, message.client_message_id, "Only team owner can add users");
+            return;
+        }
+        // Resolve user identifier
+        const user = await (0, userResolver_1.resolveUserIdentifier)(this.db, message.user_uuid_or_email);
+        if (!user) {
+            this.sendControlError(connectionId, message.client_message_id, "User not found");
+            return;
+        }
+        // Check if user is already a participant
+        const participants = await this.db.teamGetMembers(message.target_team_id);
+        if (participants.some((p) => p.user_uuid === user.uuid)) {
+            this.sendControlError(connectionId, message.client_message_id, "User is already a participant");
+            return;
+        }
+        // Update database
+        try {
+            await this.db.teamAddMember(message.target_team_id, user.uuid);
+        }
+        catch (error) {
+            this.sendControlError(connectionId, message.client_message_id, "Server Internal Error: cannot add user.");
+            logger.error(`[SessionRegistry] Error adding user ${user.uuid}` +
+                ` to team ${message.target_team_id}:`, error);
+            return;
+        }
+        // add user to related active sessions
+        const sessions = await this.db.teamGetSessions(message.target_team_id);
+        for (const sessionData of sessions) {
+            const session = this.openSessions.get(sessionData.session_uuid);
+            if (session) {
+                session.addParticipant(user.uuid, {
+                    user_uuid: user.uuid,
+                    nickname: user.nickname || "",
+                    email: user.email,
+                    role: "participant",
+                });
+            }
+        }
+        logger.info(`[SessionRegistry] User ${user.uuid}` +
+            `added to team ${message.target_team_id}`);
+    }
+    /**
+     * Handle remove_user message - removes user from session membership.
+     * Only session owner can remove users.
+     */
+    async handleRemoveTeamUser(connectionId, fromUserId, message) {
+        // Validate permissions - only owner can remove users
+        const access = await this.validateTeamAccess(message.target_team_id, fromUserId, "owner");
+        if (!access) {
+            this.sendControlError(connectionId, message.client_message_id, "Only team owner can remove users");
+            return;
+        }
+        // Resolve user identifier
+        const user = await (0, userResolver_1.resolveUserIdentifier)(this.db, message.user_uuid_or_email);
+        if (!user) {
+            this.sendControlError(connectionId, message.client_message_id, "User not found");
+            return;
+        }
+        // owner cannot remove her/himself
+        if (user.uuid === fromUserId) {
+            this.sendControlError(connectionId, message.client_message_id, "Owner cannot remove herself/himself");
+            return;
+        }
+        // Check if user is actually a participant
+        const participants = await this.db.teamGetMembers(message.target_team_id);
+        if (!participants.some((p) => p.user_uuid === user.uuid)) {
+            this.sendControlError(connectionId, message.client_message_id, "User is not a participant");
+            return;
+        }
+        // Remove from database
+        try {
+            await this.db.teamRemoveMember(message.target_team_id, user.uuid);
+        }
+        catch (error) {
+            this.sendControlError(connectionId, message.client_message_id, "Server Internal Error: cannot remove user.");
+            logger.error(`[SessionRegistry] Error removing user ${user.uuid}` +
+                ` from team ${message.target_team_id}:`, error);
+            return;
+        }
+        // Update OpenSession's participant map and in memory tracking
+        const sessions = await this.db.teamGetSessions(message.target_team_id);
+        for (const sessionData of sessions) {
+            const session = this.openSessions.get(sessionData.session_uuid);
+            if (session) {
+                session.removeParticipant(user.uuid);
+                this.removeUserFromSessionMemory(user.uuid, sessionData.session_uuid);
+            }
+        }
+        logger.info(`[SessionRegistry] User ${user.uuid} ` +
+            `removed from team ${message.target_team_id}`);
+    }
+    /**
+     * Get session instance, if the session has not been initialized,
+     * it will be.
+     */
+    async getAndActivateSession(sessionId) {
+        if (this.openSessions.has(sessionId)) {
+            logger.info(`[SessionRegistry] Session ${sessionId} already exists`);
+            const openSession = this.openSessions.get(sessionId);
+            if (!openSession) {
+                throw new errors_1.ChatFatalError(`Internal error: No such session: ${sessionId}`);
+            }
+            return openSession;
+        }
+        else {
+            logger.info(`[SessionRegistry] loading session ${sessionId}`);
+            return openSession_1.OpenSession.initWithExistingSession(this.db, sessionId, this.llmUrl, this.xmcpUrl, this.connectionManager);
+        }
+    }
+    /**
+     * Handle user joining a session.
+     * Activates the session if not already active.
+     * return the session info to the client joining the session.
+     */
+    async handleSessionJoin(connectionId, userId, message) {
+        const sessionId = message.target_session_id;
+        logger.info(`[SessionRegistry] Joining session ${sessionId} for user ${userId}`);
+        try {
+            // Validate session access permissions
+            const access = await this.validateSessionAccess(sessionId, userId);
+            if (!access) {
+                throw new errors_1.ChatFatalError(`User ${userId} is not authorized to ` + `join session ${sessionId}`);
+            }
+            // get or create the session
+            const session = await this.getAndActivateSession(sessionId);
+            if (!session) {
+                // this in theory should not happen
+                // since we have validated the access
+                throw new errors_1.ChatFatalError(`Server internal error: ` + `failed to load session ${sessionId}`);
+            }
+            // To this point, there should be no error thrown.
+            // Update in-memory session-user/user-session mappings
+            this.addUserToSessionMemory(userId, sessionId);
+            // Register session immediately
+            if (!this.openSessions.has(sessionId)) {
+                this.openSessions.set(sessionId, session);
+            }
+            // pass the message to the session to handle the rest
+            session.sendSessionData(connectionId, message.client_message_id);
+        }
+        catch (error) {
+            logger.error(`[SessionRegistry] Error handling user join: ${String(error)}`);
+            this.sendControlError(connectionId, message.client_message_id, String(error));
+        }
+    }
+    async handleAgentProfileCreate(message, from) {
+        // get agent profile from template
+        let agentProfileFromTemplate = undefined;
+        if (message.template_name) {
+            const template = await this.db.agentTemplateGetByName(message.template_name);
+            if (!template) {
+                throw new Error(`template ${message.template_name} not found`);
+            }
+            agentProfileFromTemplate = template.agent_profile;
+        }
+        const newAgentProfile = agentProfileFromTemplate || {
+            model: agentUtils_1.DEFAULT_LLM_MODEL,
+            system_prompt: sdk_1.DEFAULT_AGENT_PROFILE_SYSTEM_PROMPT,
+            mcp_settings: {},
+        };
+        const team_uuid = message.team_uuid || undefined;
+        if (team_uuid) {
+            // TODO: should be able to reconstruct the full SavedAgentProfile in one
+            // call.
+            const savedAgentProfile = await this.db.createAgentProfile(undefined, team_uuid, message.title, newAgentProfile);
+            if (!savedAgentProfile) {
+                throw new Error("failed creating team agent profile (createAgentProfile)");
+            }
+            // Broadcast the new AgentProfile to all participants
+            const participants = await this.db.teamGetMembers(team_uuid);
+            this.connectionManager.sendToUsers(new Set(participants.map((p) => p.user_uuid)), { type: "control_agent_profile_created", profile: savedAgentProfile });
+            return savedAgentProfile.uuid;
+        }
+        // User AgentProfile
+        const savedAgentProfile = await this.db.createAgentProfile(from, undefined, message.title, newAgentProfile);
+        if (!savedAgentProfile) {
+            throw new Error("failed creating agent profile (createAgentProfile)");
+        }
+        // Send the new AgentProfile to the user
+        this.connectionManager.sendToUsers(new Set([from]), {
+            type: "control_agent_profile_created",
+            profile: savedAgentProfile,
+        });
+        return savedAgentProfile.uuid;
+    }
+    /**
+     * Create a new session for a user.
+     * - create session in database (via `newSession`)
+     * - create an OpenSession instance
+     * - return the session info
+     */
+    async handleSessionCreate(connectionId, fromUserId, message) {
+        try {
+            // If agent not given, create one and inform the client
+            if (!message.agent_profile_id) {
+                logger.info("[handleSessionCreate] creating new AgentProfile");
+                // Create AgentProfile and inform the client
+                message.agent_profile_id = await this.handleAgentProfileCreate({
+                    type: "control_agent_profile_create",
+                    title: "New Agent " + (0, uuid_1.v4)(),
+                    user_uuid: fromUserId,
+                    team_uuid: message.team_id,
+                }, fromUserId);
+            }
+            // Create new session and get its instance
+            const { openSession, sessionId } = message.team_id
+                ? await this.newTeamSession(fromUserId, message.team_id, message.title, message.agent_profile_id)
+                : await this.newUserSession(fromUserId, message.title, message.agent_profile_id);
+            // there should be no further error thrown from now.
+            // Register session immediately
+            this.openSessions.set(sessionId, openSession);
+            // add owner to session memory
+            this.addUserToSessionMemory(fromUserId, sessionId);
+            // send session info to the connection
+            openSession.sendSessionData(connectionId, message.client_message_id);
+            logger.info(`[SessionRegistry] new session ${sessionId}:` +
+                ` ${message.title} for ${fromUserId}`);
+        }
+        catch (error) {
+            const errStr = (0, errorUtils_1.getErrorString)(error);
+            logger.error(`[SessionRegistry] Error in session create: ${errStr}`);
+            this.sendControlError(connectionId, message.client_message_id, errStr);
+        }
+    }
+    /**
+     * Create a new user session.
+     */
+    async newUserSession(ownerId, title, agentProfileId) {
+        // validate the agent profile
+        await this.validateSavedAgentProfile(agentProfileId);
+        const newSessionData = {
+            ...userSessionDataCreate(ownerId, title, agentProfileId),
+            updated_at: new Date().toISOString(),
+        };
+        const openSession = await openSession_1.OpenSession.initWithEmptySession(this.db, newSessionData, this.llmUrl, this.xmcpUrl, this.connectionManager);
+        return { sessionId: newSessionData.session_uuid, openSession };
+    }
+    /**
+     * Create a new team session.
+     */
+    async newTeamSession(fromUserId, teamId, title, agentProfileId) {
+        // validate agent profile and team access
+        const [_savedAgentProfile, access] = await Promise.all([
+            this.validateSavedAgentProfile(agentProfileId),
+            this.validateTeamAccess(teamId, fromUserId),
+        ]);
+        if (!access) {
+            throw new errors_1.ChatFatalError(`User ${fromUserId} is not a participant of team ${teamId}`);
+        }
+        const newSessionData = {
+            ...teamSessionDataCreate(teamId, fromUserId, title, agentProfileId),
+            updated_at: new Date().toISOString(),
+        };
+        // initialize the open session
+        const openSession = await openSession_1.OpenSession.initWithEmptySession(this.db, newSessionData, this.llmUrl, this.xmcpUrl, this.connectionManager);
+        return { sessionId: newSessionData.session_uuid, openSession };
+    }
+    /**
+     * Gracefully shutdown all sessions and clean up resources.
+     */
+    shutdown() {
+        logger.info(`[SessionRegistry] Shutting down ` +
+            String(this.openSessions.size) +
+            ` sessions`);
+        // Create list of sessions to avoid concurrent modification
+        const sessionsToClose = Array.from(this.openSessions.keys());
+        for (const sessionId of sessionsToClose) {
+            const session = this.openSessions.get(sessionId);
+            if (session) {
+                logger.debug(`[SessionRegistry] Closing session ${sessionId}`);
+                try {
+                    // Trigger the session's cleanup
+                    session.onEmpty();
+                }
+                catch (error) {
+                    logger.error(`[SessionRegistry] Error closing session ${sessionId}:`, error);
+                }
+            }
+        }
+        // Clear all maps
+        this.sessionUsers.clear();
+        this.userSessions.clear();
+        this.openSessions.clear();
+        logger.info(`[SessionRegistry] Shutdown complete`);
+    }
+    /**
+     * Handle user disconnect - clean up from all sessions.
+     * Called when a connection is closed to ensure proper cleanup.
+     */
+    handleUserDisconnect(userId) {
+        logger.info(`[SessionRegistry] Handling disconnect for user ${userId}`);
+        // Get all sessions the user is in (copy to avoid concurrent modification)
+        const userSessionIds = this.getInMemoryUserSessions(userId);
+        const sessionsToLeave = Array.from(userSessionIds);
+        // Remove user from each session
+        for (const sessionId of sessionsToLeave) {
+            this.removeUserFromSessionMemory(userId, sessionId);
+        }
+        logger.info(`[SessionRegistry] User ${userId} removed` +
+            ` from ${String(sessionsToLeave.length)} sessions`);
+    }
+    /**
+     * Get all sessions for a user,
+     * including user solo sessions and team sessions.
+     * This will also create a default agent profile if none exists.
+     */
+    async getAllAgentsAndSessionsByUser(userId) {
+        return Promise.all([
+            this.db.getUserSessions(userId),
+            this.db.getTeamInfosByUser(userId),
+            this.agentProfilesGetByUserOrDefault(userId),
+        ]);
+    }
+    async agentProfilesGetByUserOrDefault(userId) {
+        const agentProfiles = await this.db.agentProfilesGetByUser(userId);
+        if (agentProfiles.length === 0) {
+            const profileName = sdk_1.DEFAULT_AGENT_PROFILE_NAME;
+            const profile = await this.db.createAgentProfile(userId, undefined, profileName, sdk_1.DEFAULT_AGENT_PROFILE);
+            if (!profile) {
+                throw new Error(`No such agent profile: ${profileName}`);
+            }
+            return [profile];
+        }
+        return agentProfiles;
+    }
+    /**
+     * Validates that an agent profile exists in the database.
+     */
+    async validateSavedAgentProfile(agentProfileId) {
+        const savedAgentProfile = await this.db.getSavedAgentProfileById(agentProfileId);
+        if (!savedAgentProfile) {
+            throw new errors_1.ChatFatalError(`No such agent profile: ${agentProfileId}`);
+        }
+        return savedAgentProfile;
+    }
+    /**
+     * Validates that a user has permission to access a session.
+     */
+    async validateSessionAccess(sessionId, userId, accessType) {
+        const session = this.openSessions.get(sessionId);
+        if (session) {
+            // in memory session
+            const participants = session.getParticipants();
+            const role = participants.get(userId);
+            if (!role) {
+                return false;
+            }
+            else {
+                return !accessType || role.role === accessType;
+            }
+        }
+        else {
+            // fetch the session from database
+            const participants = await this.db.sessionGetParticipants(sessionId);
+            const role = participants.find((p) => p.user_uuid === userId)?.role;
+            if (!role) {
+                return false;
+            }
+            else {
+                return !accessType || role === accessType;
+            }
+        }
+    }
+    /**
+     * Validates that a user has permission to access a team.
+     */
+    async validateTeamAccess(teamId, userId, accessType) {
+        const participants = await this.db.teamGetMembers(teamId);
+        const role = participants.find((p) => p.user_uuid === userId)?.role;
+        if (!role) {
+            return false;
+        }
+        else {
+            return !accessType || role === accessType;
+        }
+    }
+}
+exports.SessionRegistry = SessionRegistry;
+function userSessionDataCreate(ownerId, title, agentProfileId) {
+    return {
+        session_uuid: database_1.Database.sessionNewUUID(),
+        title,
+        team_uuid: undefined,
+        agent_profile_uuid: agentProfileId,
+        workspace: undefined,
+        user_uuid: ownerId,
+    };
+}
+function teamSessionDataCreate(teamId, ownerId, title, agentProfileId) {
+    return {
+        session_uuid: database_1.Database.sessionNewUUID(),
+        title,
+        team_uuid: teamId,
+        agent_profile_uuid: agentProfileId,
+        workspace: undefined,
+        user_uuid: ownerId,
+    };
+}