@rtsee/messenger-signaling 0.0.108 → 0.0.110

package/dist/messenger-signaling/src/models/RTSeeMessengerSignaling.js

@@ -1,22 +1,17 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RTSeeMessengerSignaling = void 0;
 const signaling_1 = require("@rtsee/signaling");
 const common_1 = require("@rtsee/common");
 const live_storage_1 = require("@rtsee/live-storage");
 const messenger_signaling_1 = require("@rtsee/messenger-signaling");
+const LLMConverseStream_js_1 = require("./ozzy/connectors/LLMConverseStream.js");
 const core_1 = require("@rtsee/core");
-const DEFAULT_LIMIT = 20;
+const CHAT_ROOM_PREFIX = 'messenger-chat';
 class RTSeeMessengerSignaling extends signaling_1.RTSeeSignalingBase {
+    storage;
+    handlers;
+    ozzy;
     constructor(options) {
         super(options);
         if (options.storageHandlers) {
@@ -28,174 +23,667 @@ class RTSeeMessengerSignaling extends signaling_1.RTSeeSignalingBase {
             this.storage = new live_storage_1.RTSeeMessengerStorage();
         }
         this.handlers = (0, messenger_signaling_1.getMessengerHandlers)(this.storage);
+        this.attachChatRoomsJoining();
+        if (options.ozzy) {
+            this.ozzy = options.ozzy;
+            this.ozzy.attachBridge({
+                emitToChat: (transport, chatId, event, data) => this.emitToChatRoom(transport, chatId, event, data),
+                getChatMember: (transport, chatId, memberId) => this.storage.getChatMember(transport, { chatId, memberId }),
+            });
+        }
     }
     onAfterConnected(socket) {
+        // --- Peer ---
         socket.on(common_1.RTSeeMessengerEvents.GET_PEER, (peerId, requestId) => this.handlers.getPeer.run(socket, requestId, peerId));
         socket.on(common_1.RTSeeMessengerEvents.UPDATE_PEER, (peer, requestId) => this.handlers.updatePeer.run(socket, requestId, peer));
-        socket.on(common_1.RTSeeMessengerEvents.CREATE_CHAT, (chat) => void this.handleCreateChat(socket, chat));
-        socket.on(common_1.RTSeeMessengerEvents.OUTGOING_MESSAGE, (message) => void this.handleOutgoingMessage(socket, message));
-        socket.on(common_1.RTSeeMessengerEvents.GET_CHATS, (options) => void this.handleGetChats(socket, options));
-        socket.on(common_1.RTSeeMessengerEvents.GET_CHAT, (options) => void this.handleGetChat(socket, options));
-        socket.on(common_1.RTSeeMessengerEvents.GET_MESSAGES, (options) => void this.handleGetMessages(socket, options));
-        socket.on(common_1.RTSeeMessengerEvents.MESSAGE_RECEIVED, (options) => void this.handleMessageReceived(socket, options));
-        socket.on(common_1.RTSeeMessengerEvents.INCOMING_MESSAGES_SEEN, (options) => void this.handleMessageSeen(socket, options));
-        socket.on(common_1.RTSeeMessengerEvents.SEARCH, (options) => void this.handleSearch(socket, options));
-    }
-    handleCreateChat(socket, chatOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!socket.rtseePeer) {
-                console.log("Peer is not yet initialized, can not create chats!");
+        // --- Chats ---
+        socket.on(common_1.RTSeeMessengerEvents.GET_CHATS, (options, requestId) => this.handlers.getChats.run(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.GET_CHAT, (options, requestId) => this.handlers.getChat.run(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.CREATE_CHAT, (options, requestId) => this.handleCreateChat(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.EDIT_CHAT, (options, requestId) => this.handleEditChat(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.DELETE_CHAT, (chatId, requestId) => this.handleDeleteChat(socket, requestId, chatId));
+        // --- Messages ---
+        socket.on(common_1.RTSeeMessengerEvents.GET_MESSAGES, (options, requestId) => this.handlers.getMessages.run(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.SEND_MESSAGE, (message, requestId) => this.handleSendMessage(socket, requestId, message));
+        // --- Message Status ---
+        socket.on(common_1.RTSeeMessengerEvents.MESSAGE_RECEIVED, (options, requestId) => this.handleMessageReceived(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.INCOMING_MESSAGES_SEEN, (options, requestId) => this.handleMessageSeen(socket, requestId, options));
+        // --- Search ---
+        socket.on(common_1.RTSeeMessengerEvents.SEARCH, (options, requestId) => this.handlers.search.run(socket, requestId, options));
+        // --- Chat Members ---
+        socket.on(common_1.RTSeeMessengerEvents.GET_CHAT_MEMBERS, (options, requestId) => this.handlers.getChatMembers.run(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.GET_CHAT_MEMBER, (options, requestId) => this.handlers.getChatMember.run(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.ADD_CHAT_MEMBER, (options, requestId) => this.handleAddChatMember(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.EDIT_CHAT_MEMBER, (options, requestId) => this.handleEditChatMember(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.REMOVE_CHAT_MEMBER, (options, requestId) => this.handleRemoveChatMember(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.GET_CHAT_INVITATION_LINK, (options, requestId) => this.handlers.getChatMember.run(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.GET_CHAT_INVITATION_LINK, (options, requestId) => this.handlers.getChatInvitationLink.run(socket, requestId, options));
+        socket.on(common_1.RTSeeMessengerEvents.JOIN_CHAT_BY_TOKEN, (token, requestId) => this.handlers.joinChatByToken.run(socket, requestId, token));
+        // --- Agent Streaming ---
+        socket.on(common_1.RTSeeMessengerEvents.ABORT_AGENT_STREAM, async (data) => {
+            if (!socket.rtseePeer || !this.ozzy) {
                 return;
             }
-            const createChatOptions = Object.assign(Object.assign({}, chatOptions), { creatorId: socket.rtseePeer.clientId });
-            const peers = this.storage.isLocalProcessor
-                ? {
-                    creator: this.getChatMemberByPeerId(socket.rtseePeer.clientId),
-                    members: this.getChatMembersByPeerIds(chatOptions.membersIds),
-                }
-                : null;
-            return yield this.storage.processChat((0, core_1.socketPeerToTransport)(socket, peers || undefined), createChatOptions);
-        });
-    }
-    handleOutgoingMessage(socket, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!socket.rtseePeer) {
-                console.log("Peer is not yet initialized, can not send messages!");
-                return;
+            try {
+                const transport = (0, core_1.socketPeerToTransport)(socket);
+                // Abort the LLM flow
+                this.ozzy.abortFlow(data.flowId);
+                // Save the partial response as a message from the agent
+                // (the streaming text was accumulated client-side)
+                // Send stop-widget message from the aborter
+                const stopMessage = await this.storage.processMessage(transport, {
+                    from: socket.rtseePeer.clientId,
+                    chatId: data.chatId,
+                    text: '',
+                    widget: 'rtsee-agent-stopped',
+                });
+                // Broadcast stop message + stream end
+                void this.emitEventToChatId(transport, data.chatId, common_1.RTSeeMessengerEvents.INCOMING_MESSAGE, stopMessage);
+                void this.emitEventToChatId(transport, data.chatId, common_1.RTSeeMessengerEvents.AGENT_STREAM_END, { chatId: data.chatId });
             }
-            yield this.sendMessage((0, core_1.socketPeerToTransport)(socket), message);
-        });
-    }
-    handleGetChats(socket, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!socket.rtseePeer) {
-                console.log("Peer is not yet initialized, can not send messages!");
-                return;
+            catch (e) {
+                console.error('Failed to abort agent stream:', e);
             }
-            const result = yield this.storage.getChats((0, core_1.socketPeerToTransport)(socket), {
-                clientId: socket.rtseePeer.clientId,
-                limit: options.limit | DEFAULT_LIMIT,
-                offset: options.offset | 0,
-            });
-            socket.emit(common_1.RTSeeMessengerEvents.CHATS_FETCHED, result);
         });
-    }
-    handleGetChat(socket, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!socket.rtseePeer) {
-                console.log("Peer is not yet initialized, can not send messages!");
+        // --- Tool Use Approval Response (client → server) ---
+        socket.on(common_1.RTSeeMessengerEvents.TOOL_USE_REQUEST_RESPONSE, (data) => {
+            if (!socket.rtseePeer || !this.ozzy) {
                 return;
             }
-            const result = yield this.storage.getChat((0, core_1.socketPeerToTransport)(socket), {
-                chatId: options.id,
+            this.ozzy.handleToolUseResponse(data.flowId, {
+                toolUseId: data.toolUseId,
+                granted: data.granted,
             });
-            socket.emit(common_1.RTSeeMessengerEvents.CHAT_FETCHED, result);
         });
+        // --- Ozzy Workflows & Tasks ---
+        if (this.ozzy) {
+            this.attachOzzyEvents(socket);
+        }
     }
-    handleGetMessages(socket, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let result;
-            if (!socket.rtseePeer) {
-                console.log("Peer is not yet initialized, can not send messages!");
+    /**
+     * Create chat: run handler, then auto-send a welcome message from the creator.
+     */
+    async handleCreateChat(socket, requestId, options) {
+        if (!socket.rtseePeer) {
+            return;
+        }
+        let createdChat = null;
+        if (!options.membersIds) {
+            options.membersIds = [socket.rtseePeer.clientId];
+        }
+        try {
+            const transport = (0, core_1.socketPeerToTransport)(socket);
+            createdChat = await this.storage.processChat(transport, {
+                ...options,
+                creatorId: socket.rtseePeer.clientId || options.creatorId,
+            });
+            if (!createdChat) {
+                this.handlers.createChat.onError({
+                    socketPeer: socket,
+                    requestId,
+                    payload: options,
+                    error: new Error('Chat creation returned null'),
+                    eventName: `${common_1.RTSeeMessengerEvents.CREATE_CHAT}-failure-${requestId}`,
+                });
                 return;
             }
-            if (this.storage.getMessages) {
-                result = yield this.storage.getMessages((0, core_1.socketPeerToTransport)(socket), {
-                    chatId: options.chatId,
-                    limit: options.limit | DEFAULT_LIMIT,
-                    offset: options.offset | 0,
-                    lastLoadedMessageId: options.lastLoadedMessageId || null,
-                    direction: options.direction,
+            this.handlers.createChat.onSuccess({
+                socketPeer: socket,
+                requestId,
+                data: createdChat,
+                eventName: `${common_1.RTSeeMessengerEvents.CREATE_CHAT}-success-${requestId}`,
+            });
+            void this.joinChatRoom((0, core_1.socketPeerToTransport)(socket), createdChat.id);
+        }
+        catch (e) {
+            this.handlers.createChat.onError({
+                socketPeer: socket,
+                requestId,
+                payload: options,
+                error: e,
+                eventName: `${common_1.RTSeeMessengerEvents.CREATE_CHAT}-failure-${requestId}`,
+            });
+            return;
+        }
+        // Auto-send a welcome message from the creator (separate try-catch
+        // so a failure here does not emit a duplicate error after success).
+        try {
+            const transport = (0, core_1.socketPeerToTransport)(socket);
+            const peerName = socket.rtseePeer.name || socket.rtseePeer.clientId;
+            const welcomeMessage = await this.storage.processMessage(transport, {
+                from: socket.rtseePeer.clientId,
+                chatId: createdChat.id,
+                text: `${peerName} created a chat.`,
+            });
+            if (welcomeMessage) {
+                const ids = await this.storage.getChatPeersIds(transport, createdChat.id);
+                ids.forEach((id) => {
+                    if (id !== transport.peer.clientId) {
+                        this.sendToIndividualRoom({ peer: { clientId: id, rtseeAppId: transport.peer.rtseeAppId } }, common_1.RTSeeMessengerEvents.INCOMING_MESSAGE, welcomeMessage);
+                    }
                 });
             }
-            else {
-                result = {
-                    chatId: options.chatId,
-                    messages: [],
-                    unreadCount: 0,
-                    direction: options.direction,
-                };
-            }
-            socket.emit(common_1.RTSeeMessengerEvents.MESSAGES_FETCHED, result);
-        });
+        }
+        catch (e) {
+            console.error('Failed to send welcome message for new chat:', e?.message);
+        }
     }
-    handleMessageReceived(socket, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!socket.rtseePeer) {
-                console.log("Peer is not yet initialized, can not send messages!");
-                return;
+    /**
+     * Send message: run handler, then broadcast INCOMING_MESSAGE to other chat members.
+     */
+    async handleSendMessage(socket, requestId, message) {
+        if (!socket.rtseePeer) {
+            console.log("Peer is not yet initialized, can not send messages!");
+            return;
+        }
+        try {
+            const transport = (0, core_1.socketPeerToTransport)(socket);
+            const savedMessage = await this.storage.processMessage(transport, message);
+            // Respond to sender with the saved message
+            this.handlers.sendMessage.onSuccess({
+                socketPeer: socket,
+                requestId,
+                data: savedMessage,
+                eventName: `${common_1.RTSeeMessengerEvents.SEND_MESSAGE}-success-${requestId}`,
+            });
+            // Broadcast INCOMING_MESSAGE to other chat members
+            const ids = await this.storage.getChatPeersIds(transport, savedMessage.chatId);
+            ids.forEach((id) => {
+                if (id !== transport.peer.clientId) {
+                    this.sendToIndividualRoom({ peer: { clientId: id, rtseeAppId: transport.peer.rtseeAppId } }, common_1.RTSeeMessengerEvents.INCOMING_MESSAGE, savedMessage);
+                }
+            });
+            // --- Agent Detection & Ozzy Dispatch ---
+            if (this.ozzy && savedMessage.to) {
+                try {
+                    await this.dispatchToAgent(socket, transport, savedMessage);
+                }
+                catch (agentError) {
+                    console.error('Failed to dispatch agent message:', agentError);
+                }
             }
-            yield this.storage.processMessagesReceivedEvent((0, core_1.socketPeerToTransport)(socket), options);
-            const groups = this.groupBySender(options.messages);
-            groups.forEach((g) => {
-                this.sendToIndividualRoom({
-                    peer: {
-                        clientId: g.senderId,
-                        rtseeAppId: socket.rtseePeer.rtseeAppId,
-                    },
-                }, common_1.RTSeeMessengerEvents.MESSAGE_RECEIVED, g);
+        }
+        catch (e) {
+            this.handlers.sendMessage.onError({
+                socketPeer: socket,
+                requestId,
+                payload: message,
+                error: e,
+                eventName: `${common_1.RTSeeMessengerEvents.SEND_MESSAGE}-failure-${requestId}`,
             });
-        });
+        }
     }
-    handleMessageSeen(socket, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!socket.rtseePeer) {
-                console.log("Peer is not yet initialized, can not send messages!");
-                return;
-            }
-            if (this.storage.processMessagesSeenEvent) {
-                yield this.storage.processMessagesSeenEvent((0, core_1.socketPeerToTransport)(socket), options);
-            }
-            const groups = this.groupBySender(options.messages);
-            groups.forEach((g) => {
-                this.sendToIndividualRoom({
-                    peer: {
-                        clientId: g.senderId,
-                        rtseeAppId: socket.rtseePeer.rtseeAppId,
-                    },
-                }, common_1.RTSeeMessengerEvents.INCOMING_MESSAGES_SEEN, g);
+    /**
+     * If the message targets an agent member, start an LLM stream via Ozzy.
+     * Relays text chunks to all chat members, then saves the assembled response.
+     */
+    async dispatchToAgent(socket, transport, message) {
+        // Look up the target member
+        let targetMember = null;
+        if (this.storage.getChatMember) {
+            targetMember = await this.storage.getChatMember(transport, {
+                chatId: message.chatId,
+                memberId: message.to,
+            });
+        }
+        if (!targetMember || !targetMember.isAgent) {
+            return;
+        }
+        const canCallAgents = (0, core_1.hasPermission)(transport.peer, core_1.RTSeePeerPermissions.ADMINISTER_STORIES);
+        if (!canCallAgents) {
+            socket.emit(common_1.RTSeeMessengerEvents.AGENT_ACCESS_DENIED, {
+                chatId: message.chatId,
+            });
+            return;
+        }
+        const agentMember = targetMember;
+        const flowId = core_1.RTSeeCore.uuidv4();
+        // Broadcast AGENT_STREAM_START to all chat members
+        void this.emitEventToChatId(transport, message.chatId, common_1.RTSeeMessengerEvents.AGENT_STREAM_START, { chatId: message.chatId, flowId, agentId: agentMember.id });
+        socket.emit(common_1.RTSeeMessengerEvents.AGENT_STREAM_START, {
+            chatId: message.chatId, flowId, agentId: agentMember.id,
+        });
+        // Relay text chunks from LLM to all chat members
+        let accumulatedText = '';
+        let streamCost = null;
+        const generatedImages = [];
+        // ozzy.send() returns the LLMConverseStream directly — subscribe to it
+        const stream = this.ozzy.send(flowId, message.text, agentMember.agentConfiguration.systemPrompt, transport, agentMember.agentConfiguration.model.model, undefined, agentMember.id);
+        stream.on(LLMConverseStream_js_1.StreamEvents.TEXT_CHUNK, (chunkData) => {
+            accumulatedText += chunkData.text;
+            void this.emitEventToChatId(transport, message.chatId, common_1.RTSeeMessengerEvents.AGENT_TEXT_CHUNK, { chatId: message.chatId, flowId, text: chunkData.text });
+            socket.emit(common_1.RTSeeMessengerEvents.AGENT_TEXT_CHUNK, {
+                chatId: message.chatId, flowId, text: chunkData.text,
             });
         });
-    }
-    handleSearch(socket, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.storage.processSearch) {
-                return false;
+        stream.on(LLMConverseStream_js_1.StreamEvents.COST, (cost) => {
+            streamCost = cost;
+        });
+        stream.on(LLMConverseStream_js_1.StreamEvents.IMAGE_GENERATED, (imageData) => {
+            generatedImages.push({
+                name: `generated-${generatedImages.length + 1}`,
+                url: imageData.url,
+            });
+        });
+        stream.on(LLMConverseStream_js_1.StreamEvents.TOOL_USE_REQUEST, (request) => {
+            const toolRequestPayload = {
+                chatId: message.chatId,
+                flowId,
+                toolUseId: request.toolUseId,
+                params: request.params,
+                agentId: request.agentId,
+                createdAt: request.createdAt,
+            };
+            void this.emitEventToChatId(transport, message.chatId, common_1.RTSeeMessengerEvents.TOOL_USE_REQUEST, toolRequestPayload);
+            socket.emit(common_1.RTSeeMessengerEvents.TOOL_USE_REQUEST, toolRequestPayload);
+        });
+        stream.on(LLMConverseStream_js_1.StreamEvents.STREAM_END, async () => {
+            this.ozzy.releaseStream(flowId);
+            // Determine if we have content to save
+            const hasText = accumulatedText.trim().length > 0;
+            const hasImages = generatedImages.length > 0;
+            // Determine the widget type: image generation models always respond via the media widget
+            const isImageModel = !!(0, common_1.getOzzyLlm)(agentMember.agentConfiguration.model?.model)?.imageGeneration;
+            const widget = hasImages && (isImageModel || !hasText)
+                ? 'rtsee-media'
+                : 'agentic-text-response';
+            // Final message shipped to clients with AGENT_STREAM_END (images are not streamed as chunks)
+            let finalMessage;
+            if (hasText || hasImages) {
+                try {
+                    const agentMessage = await this.storage.processMessage({
+                        ...transport,
+                        agentId: agentMember.id
+                    }, {
+                        from: agentMember.id,
+                        chatId: message.chatId,
+                        text: accumulatedText,
+                        widget,
+                        cost: streamCost || undefined,
+                        images: hasImages ? generatedImages : undefined,
+                    });
+                    finalMessage = {
+                        id: agentMessage?.id,
+                        createdAt: agentMessage?.createdAt,
+                        text: accumulatedText,
+                        widget,
+                        cost: streamCost || undefined,
+                        // Prefer persisted (uploaded) image urls over the raw base64 data urls
+                        images: agentMessage?.images?.length
+                            ? agentMessage.images
+                            : (hasImages ? generatedImages : undefined),
+                    };
+                    // Persist cost server-side (authoritative, independent of client)
+                    if (streamCost && agentMessage.id && this.storage.persistAgenticCost) {
+                        const costWithMessageId = {
+                            ...streamCost,
+                            messageId: agentMessage.id,
+                        };
+                        void this.storage.persistAgenticCost(transport, costWithMessageId).catch((e) => console.error('Failed to persist agentic cost:', e));
+                    }
+                }
+                catch (saveError) {
+                    console.error('Failed to save agent response message:', saveError);
+                    // Still deliver what was generated, even if persisting failed
+                    finalMessage = {
+                        text: accumulatedText,
+                        widget,
+                        cost: streamCost || undefined,
+                        images: hasImages ? generatedImages : undefined,
+                    };
+                }
             }
-            const result = yield this.storage.processSearch((0, core_1.socketPeerToTransport)(socket), options);
-            socket.emit(common_1.RTSeeMessengerEvents.SEARCH_SUCCESS, result);
+            // Broadcast AGENT_STREAM_END (with the final message so clients can render images/cost)
+            const streamEndPayload = { chatId: message.chatId, flowId, message: finalMessage };
+            void this.emitEventToChatId(transport, message.chatId, common_1.RTSeeMessengerEvents.AGENT_STREAM_END, streamEndPayload);
+            socket.emit(common_1.RTSeeMessengerEvents.AGENT_STREAM_END, streamEndPayload);
         });
     }
-    emitEventToChatId(transport, chatId, eventName, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ids = yield this.storage.getChatPeersIds(transport, chatId);
+    /**
+     * Edit chat: run handler, then broadcast CHAT_UPDATED to other chat members.
+     */
+    async handleEditChat(socket, requestId, options) {
+        if (!socket.rtseePeer) {
+            return;
+        }
+        try {
+            const transport = (0, core_1.socketPeerToTransport)(socket);
+            const updatedChat = await this.storage.editChat(transport, options);
+            this.handlers.editChat.onSuccess({
+                socketPeer: socket,
+                requestId,
+                data: updatedChat,
+                eventName: `${common_1.RTSeeMessengerEvents.EDIT_CHAT}-success-${requestId}`,
+            });
+            // Broadcast to other chat members
+            void this.emitEventToChatId(transport, updatedChat.id, common_1.RTSeeMessengerEvents.CHAT_UPDATED, updatedChat);
+        }
+        catch (e) {
+            this.handlers.editChat.onError({
+                socketPeer: socket,
+                requestId,
+                payload: options,
+                error: e,
+                eventName: `${common_1.RTSeeMessengerEvents.EDIT_CHAT}-failure-${requestId}`,
+            });
+        }
+    }
+    /**
+     * Delete chat: run handler, then broadcast CHAT_DELETED to all chat members.
+     */
+    async handleDeleteChat(socket, requestId, chatId) {
+        if (!socket.rtseePeer) {
+            return;
+        }
+        try {
+            const transport = (0, core_1.socketPeerToTransport)(socket);
+            // Get member IDs before deleting
+            const ids = await this.storage.getChatPeersIds(transport, chatId);
+            const deletedChat = await this.storage.deleteChat(transport, chatId);
+            this.handlers.deleteChat.onSuccess({
+                socketPeer: socket,
+                requestId,
+                data: deletedChat,
+                eventName: `${common_1.RTSeeMessengerEvents.DELETE_CHAT}-success-${requestId}`,
+            });
+            // Broadcast to other chat members
             ids.forEach((id) => {
                 if (id !== transport.peer.clientId) {
-                    this.sendToIndividualRoom({ peer: { clientId: id, rtseeAppId: transport.peer.rtseeAppId } }, eventName, data);
+                    this.sendToIndividualRoom({ peer: { clientId: id, rtseeAppId: transport.peer.rtseeAppId } }, common_1.RTSeeMessengerEvents.CHAT_DELETED, { chatId });
                 }
             });
+        }
+        catch (e) {
+            this.handlers.deleteChat.onError({
+                socketPeer: socket,
+                requestId,
+                payload: chatId,
+                error: e,
+                eventName: `${common_1.RTSeeMessengerEvents.DELETE_CHAT}-failure-${requestId}`,
+            });
+        }
+    }
+    /**
+     * Message received status: process and forward to original senders.
+     */
+    async handleMessageReceived(socket, requestId, options) {
+        if (!socket.rtseePeer) {
+            return;
+        }
+        if (this.storage.processMessagesReceivedEvent) {
+            await this.storage.processMessagesReceivedEvent((0, core_1.socketPeerToTransport)(socket), options);
+        }
+        const groups = this.groupBySender(options.messages);
+        groups.forEach((g) => {
+            this.sendToIndividualRoom({
+                peer: {
+                    clientId: g.senderId,
+                    rtseeAppId: socket.rtseePeer.rtseeAppId,
+                },
+            }, common_1.RTSeeMessengerEvents.MESSAGE_RECEIVED, g);
         });
     }
-    getChatMemberByPeerId(id) {
-        // move this logic to local storage processor
-        if (this.storage.isLocalProcessor) {
-            const peer = this.connectionsManager.getPeerByClientId(id);
-            return Object.assign(Object.assign({}, peer), { id: peer.clientId });
+    /**
+     * Messages seen: process and forward to original senders.
+     */
+    async handleMessageSeen(socket, requestId, options) {
+        if (!socket.rtseePeer) {
+            return;
         }
-        else {
-            return null;
+        if (this.storage.processMessagesSeenEvent) {
+            await this.storage.processMessagesSeenEvent((0, core_1.socketPeerToTransport)(socket), options);
         }
+        const groups = this.groupBySender(options.messages);
+        groups.forEach((g) => {
+            this.sendToIndividualRoom({
+                peer: {
+                    clientId: g.senderId,
+                    rtseeAppId: socket.rtseePeer.rtseeAppId,
+                },
+            }, common_1.RTSeeMessengerEvents.INCOMING_MESSAGES_SEEN, g);
+        });
     }
-    getChatMembersByPeerIds(ids) {
-        // move this logic to local storage processor
-        if (this.storage.isLocalProcessor) {
-            const peers = this.connectionsManager.getPeerByClientIdsList(ids);
-            return peers.map((e) => {
-                return Object.assign(Object.assign({}, e), { id: e.clientId });
+    /**
+     * Add chat member: run handler, then broadcast CHAT_MEMBER_ADDED.
+     */
+    async handleAddChatMember(socket, requestId, options) {
+        if (!socket.rtseePeer) {
+            return;
+        }
+        try {
+            const transport = (0, core_1.socketPeerToTransport)(socket);
+            const member = await this.storage.addChatMember(transport, options);
+            this.handlers.addChatMember.onSuccess({
+                socketPeer: socket,
+                requestId,
+                data: member,
+                eventName: `${common_1.RTSeeMessengerEvents.ADD_CHAT_MEMBER}-success-${requestId}`,
+            });
+            if (member?.id) {
+                this.joinPeersToChatRoom(transport, options.chatId, [member.id]);
+            }
+            void this.emitEventToChatId(transport, options.chatId, common_1.RTSeeMessengerEvents.CHAT_MEMBER_ADDED, member);
+        }
+        catch (e) {
+            this.handlers.addChatMember.onError({
+                socketPeer: socket,
+                requestId,
+                payload: options,
+                error: e,
+                eventName: `${common_1.RTSeeMessengerEvents.ADD_CHAT_MEMBER}-failure-${requestId}`,
             });
         }
-        else {
-            return null;
+    }
+    /**
+     * Edit chat member: run handler, then broadcast CHAT_MEMBER_UPDATED.
+     */
+    async handleEditChatMember(socket, requestId, options) {
+        if (!socket.rtseePeer) {
+            return;
+        }
+        try {
+            const transport = (0, core_1.socketPeerToTransport)(socket);
+            const member = await this.storage.editChatMember(transport, options);
+            this.handlers.editChatMember.onSuccess({
+                socketPeer: socket,
+                requestId,
+                data: member,
+                eventName: `${common_1.RTSeeMessengerEvents.EDIT_CHAT_MEMBER}-success-${requestId}`,
+            });
+            void this.emitEventToChatId(transport, options.chatId, common_1.RTSeeMessengerEvents.CHAT_MEMBER_UPDATED, member);
+        }
+        catch (e) {
+            this.handlers.editChatMember.onError({
+                socketPeer: socket,
+                requestId,
+                payload: options,
+                error: e,
+                eventName: `${common_1.RTSeeMessengerEvents.EDIT_CHAT_MEMBER}-failure-${requestId}`,
+            });
+        }
+    }
+    /**
+     * Remove chat member: run handler, then broadcast CHAT_MEMBER_REMOVED.
+     */
+    async handleRemoveChatMember(socket, requestId, options) {
+        if (!socket.rtseePeer) {
+            return;
+        }
+        try {
+            const transport = (0, core_1.socketPeerToTransport)(socket);
+            const member = await this.storage.removeChatMember(transport, options);
+            this.handlers.removeChatMember.onSuccess({
+                socketPeer: socket,
+                requestId,
+                data: member,
+                eventName: `${common_1.RTSeeMessengerEvents.REMOVE_CHAT_MEMBER}-success-${requestId}`,
+            });
+            void this.emitEventToChatId(transport, options.chatId, common_1.RTSeeMessengerEvents.CHAT_MEMBER_REMOVED, { chatId: options.chatId, memberId: options.memberId });
+            this.io
+                ?.in(signaling_1.RTSeeSignalingBase.getPersonalRoomName({
+                peer: { clientId: options.memberId, rtseeAppId: transport.peer.rtseeAppId },
+            }))
+                .socketsLeave(RTSeeMessengerSignaling.getChatRoomName(transport, options.chatId));
+        }
+        catch (e) {
+            this.handlers.removeChatMember.onError({
+                socketPeer: socket,
+                requestId,
+                payload: options,
+                error: e,
+                eventName: `${common_1.RTSeeMessengerEvents.REMOVE_CHAT_MEMBER}-failure-${requestId}`,
+            });
+        }
+    }
+    async emitEventToChatId(transport, chatId, eventName, data) {
+        const ids = await this.storage.getChatPeersIds(transport, chatId);
+        ids.forEach((id) => {
+            if (id !== transport.peer.clientId) {
+                this.sendToIndividualRoom({ peer: { clientId: id, rtseeAppId: transport.peer.rtseeAppId } }, eventName, data);
+            }
+        });
+    }
+    // ─── Chat rooms ──────────────────────────────────────────────────────
+    static getChatRoomName(transport, chatId) {
+        return `${CHAT_ROOM_PREFIX}-${transport.peer.rtseeAppId}-${chatId}`;
+    }
+    /** Emits to every socket of every chat member (including the sender) */
+    emitToChatRoom(transport, chatId, eventName, data) {
+        this.io?.to(RTSeeMessengerSignaling.getChatRoomName(transport, chatId)).emit(eventName, data);
+    }
+    /** Joins all sockets of the given peers (personal rooms) to the chat room */
+    joinPeersToChatRoom(transport, chatId, peerIds) {
+        if (!this.io) {
+            return;
+        }
+        const roomName = RTSeeMessengerSignaling.getChatRoomName(transport, chatId);
+        const personalRooms = peerIds.map((clientId) => signaling_1.RTSeeSignalingBase.getPersonalRoomName({
+            peer: { clientId, rtseeAppId: transport.peer.rtseeAppId },
+        }));
+        if (personalRooms.length) {
+            this.io.in(personalRooms).socketsJoin(roomName);
+        }
+    }
+    /** Joins all members of the chat to its room */
+    async joinChatRoom(transport, chatId) {
+        const ids = (await this.storage.getChatPeersIds(transport, chatId)) || [];
+        this.joinPeersToChatRoom(transport, chatId, ids);
+        return ids;
+    }
+    /**
+     * Requester's sockets join the rooms of the chats they fetch.
+     */
+    attachChatRoomsJoining() {
+        const getChats = this.handlers.getChats.processor;
+        this.handlers.getChats.processor = async (socketPeer, requestId, payload) => {
+            const result = await getChats(socketPeer, requestId, payload);
+            const transport = (0, core_1.socketPeerToTransport)(socketPeer);
+            (result?.chats || []).forEach((chat) => this.joinPeersToChatRoom(transport, chat.id, [transport.peer.clientId]));
+            return result;
+        };
+        const getChat = this.handlers.getChat.processor;
+        this.handlers.getChat.processor = async (socketPeer, requestId, payload) => {
+            const chat = await getChat(socketPeer, requestId, payload);
+            if (chat?.id) {
+                const transport = (0, core_1.socketPeerToTransport)(socketPeer);
+                this.joinPeersToChatRoom(transport, chat.id, [transport.peer.clientId]);
+            }
+            return chat;
+        };
+        const joinChatByToken = this.handlers.joinChatByToken.processor;
+        this.handlers.joinChatByToken.processor = async (socketPeer, requestId, payload) => {
+            const chat = await joinChatByToken(socketPeer, requestId, payload);
+            if (chat?.id) {
+                const transport = (0, core_1.socketPeerToTransport)(socketPeer);
+                this.joinPeersToChatRoom(transport, chat.id, [transport.peer.clientId]);
+            }
+            return chat;
+        };
+    }
+    // ─── Ozzy: workflows & tasks ─────────────────────────────────────────
+    attachOzzyEvents(socket) {
+        socket.on(common_1.OzzyWorkflowEvents.GET_WORKFLOW_DEFINITIONS, (_, requestId) => this.respond(socket, common_1.OzzyWorkflowEvents.GET_WORKFLOW_DEFINITIONS, requestId, async () => this.ozzy.workflows.getDefinitions(), 'Failed to load workflows.'));
+        socket.on(common_1.OzzyWorkflowEvents.CREATE_WORKFLOW, (request, requestId) => this.respond(socket, common_1.OzzyWorkflowEvents.CREATE_WORKFLOW, requestId, (transport) => this.handleCreateWorkflow(transport, request), 'Failed to create workflow.'));
+        socket.on(common_1.OzzyWorkflowEvents.GET_WORKFLOW, (request, requestId) => this.respond(socket, common_1.OzzyWorkflowEvents.GET_WORKFLOW, requestId, async (transport) => {
+            const workflow = await this.ozzy.workflows.get(transport, request.workflowId);
+            if (!workflow) {
+                throw new Error(`Workflow ${request.workflowId} not found.`);
+            }
+            await this.assertChatMember(transport, workflow.chatId);
+            this.joinPeersToChatRoom(transport, workflow.chatId, [transport.peer.clientId]);
+            return workflow;
+        }, 'Failed to load workflow.'));
+        socket.on(common_1.OzzyWorkflowEvents.COMPLETE_STEP, (request, requestId) => this.respond(socket, common_1.OzzyWorkflowEvents.COMPLETE_STEP, requestId, async (transport) => {
+            const workflow = await this.ozzy.workflows.get(transport, request.workflowId);
+            await this.assertChatMember(transport, workflow?.chatId);
+            return this.ozzy.workflows.completeStep(transport, request);
+        }, 'Failed to complete workflow step.'));
+        socket.on(common_1.OzzyTaskEvents.EXECUTE_TASK, (request, requestId) => this.respond(socket, common_1.OzzyTaskEvents.EXECUTE_TASK, requestId, async (transport) => {
+            const task = await this.ozzy.tasks.get(transport, request.taskId);
+            await this.assertChatMember(transport, task?.chatId);
+            await this.joinChatRoom(transport, task.chatId);
+            return this.ozzy.tasks.execute(transport, request.taskId);
+        }, 'Failed to execute task.'));
+        socket.on(common_1.OzzyTaskEvents.GET_TASK, (request, requestId) => this.respond(socket, common_1.OzzyTaskEvents.GET_TASK, requestId, async (transport) => {
+            const task = await this.ozzy.tasks.get(transport, request.taskId);
+            if (!task) {
+                throw new Error(`Task ${request.taskId} not found.`);
+            }
+            await this.assertChatMember(transport, task.chatId);
+            return task;
+        }, 'Failed to load task.'));
+    }
+    /**
+     * Persists the workflow (first step = submitted form), attaches an "rts-workflow" message to the chat,
+     * then activates the next step (which may start a task).
+     */
+    async handleCreateWorkflow(transport, request) {
+        await this.assertChatMember(transport, request.chatId);
+        const peersIds = await this.joinChatRoom(transport, request.chatId);
+        const workflow = await this.ozzy.workflows.create(transport, request);
+        const message = await this.storage.processMessage(transport, {
+            from: transport.peer.clientId,
+            chatId: request.chatId,
+            text: workflow.title || workflow.name,
+            widget: 'rts-workflow',
+            ozzyWorkflowId: workflow.id,
+        });
+        await this.ozzy.workflows.attachMessage(transport, workflow, message.id);
+        peersIds.forEach((id) => {
+            if (id !== transport.peer.clientId) {
+                this.sendToIndividualRoom({ peer: { clientId: id, rtseeAppId: transport.peer.rtseeAppId } }, common_1.RTSeeMessengerEvents.INCOMING_MESSAGE, message);
+            }
+        });
+        // continue in background - progress is broadcast to the chat room
+        void this.ozzy.workflows.start(transport, workflow).catch((e) => console.error(`[Ozzy] failed to start workflow ${workflow.id}`, e));
+        return { workflow, message };
+    }
+    async assertChatMember(transport, chatId) {
+        if (!chatId) {
+            throw new Error('Chat not found.');
+        }
+        const ids = (await this.storage.getChatPeersIds(transport, chatId)) || [];
+        if (!ids.includes(transport.peer.clientId)) {
+            throw new Error('You are not a member of this chat.');
+        }
+    }
+    async respond(socket, eventName, requestId, processor, friendlyMessage) {
+        if (!socket.rtseePeer) {
+            return;
+        }
+        try {
+            const result = await processor((0, core_1.socketPeerToTransport)(socket));
+            socket.emit(`${eventName}-${core_1.REQUEST_SUCCESS_SUFFIX}-${requestId}`, result);
+        }
+        catch (e) {
+            console.error(`[Ozzy] ${eventName} failed:`, e?.message || e);
+            const error = {
+                name: eventName,
+                code: eventName,
+                message: `${e?.message || e}`,
+                friendlyMessage,
+            };
+            socket.emit(`${eventName}-${core_1.REQUEST_FAILURE_SUFFIX}-${requestId}`, error);
         }
     }
     groupBySender(messages) {
@@ -215,30 +703,6 @@ class RTSeeMessengerSignaling extends signaling_1.RTSeeSignalingBase {
         });
         return groups;
     }
-    sendMessage(transport, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const peers = this.storage.isLocalProcessor
-                ? {
-                    creator: this.getChatMemberByPeerId(transport.peer.clientId),
-                    members: this.getChatMembersByPeerIds([
-                        transport.peer.clientId,
-                        message.to,
-                    ]),
-                }
-                : null;
-            if (peers) {
-                transport.peers = peers;
-            }
-            const savedMessage = yield this.storage.processMessage(transport, message);
-            const ids = yield this.storage.getChatPeersIds(transport, savedMessage.chatId);
-            this.sendToIndividualRoom(transport, common_1.RTSeeMessengerEvents.MESSAGE_SEND_SUCCEED, Object.assign(Object.assign({}, savedMessage), { temporaryId: message.temporaryId, temporaryChatId: message.temporaryChatId }));
-            ids.forEach((id) => {
-                if (id !== transport.peer.clientId) {
-                    this.sendToIndividualRoom({ peer: { clientId: id, rtseeAppId: transport.peer.rtseeAppId } }, common_1.RTSeeMessengerEvents.INCOMING_MESSAGE, savedMessage);
-                }
-            });
-        });
-    }
 }
 exports.RTSeeMessengerSignaling = RTSeeMessengerSignaling;
 //# sourceMappingURL=RTSeeMessengerSignaling.js.map