factory-factory 0.2.5 → 0.2.6

package/dist/src/backend/services/chat-event-forwarder.service.js

@@ -1,14 +1,15 @@
 import { EventEmitter } from 'node:events';
 import { existsSync, readFileSync } from 'node:fs';
+import { hasToolResultContent } from '../../shared/claude/index.js';
+import { isInteractiveResponseTool, } from '../../shared/pending-request-types.js';
 import { WS_READY_STATE } from '../constants/index.js';
 import { interceptorRegistry } from '../interceptors/index.js';
 import { AskUserQuestionInputSchema, ExitPlanModeInputSchema, extractInputValue, isString, safeParseToolInput, } from '../schemas/tool-inputs.schema.js';
 import { chatConnectionService } from './chat-connection.service.js';
 import { configService } from './config.service.js';
 import { createLogger } from './logger.service.js';
-import { messageStateService } from './message-state.service.js';
 import { sessionFileLogger } from './session-file-logger.service.js';
-import { sessionRuntimeStoreService } from './session-runtime-store.service.js';
+import { sessionStoreService } from './session-store.service.js';
 import { slashCommandCacheService } from './slash-command-cache.service.js';
 import { workspaceActivityService } from './workspace-activity.service.js';
 const logger = createLogger('chat-event-forwarder');
@@ -16,9 +17,15 @@ const DEBUG_CHAT_WS = configService.getDebugConfig().chatWebSocket;
 class ChatEventForwarderService {
     clientEventSetup = new Map();
     registeredListeners = new Map();
-    pendingInteractiveRequests = new Map();
     workspaceNotificationsSetup = false;
     lastCompactBoundaryAt = new Map();
+    forwardClaudeMessage(dbSessionId, message) {
+        const order = sessionStoreService.appendClaudeEvent(dbSessionId, message);
+        const wsMsg = order === undefined
+            ? { type: 'claude_message', data: message }
+            : { type: 'claude_message', data: message, order };
+        sessionStoreService.emitDelta(dbSessionId, wsMsg);
+    }
     removeForwardingListeners(dbSessionId, client) {
         const listeners = this.registeredListeners.get(dbSessionId);
         if (listeners) {
@@ -32,16 +39,13 @@ class ChatEventForwarderService {
         return this.clientEventSetup.has(dbSessionId);
     }
     getPendingRequest(dbSessionId) {
-        return this.pendingInteractiveRequests.get(dbSessionId);
+        return sessionStoreService.getPendingInteractiveRequest(dbSessionId) ?? undefined;
     }
     clearPendingRequest(dbSessionId) {
-        this.pendingInteractiveRequests.delete(dbSessionId);
+        sessionStoreService.clearPendingInteractiveRequest(dbSessionId);
     }
     clearPendingRequestIfMatches(dbSessionId, requestId) {
-        const pending = this.pendingInteractiveRequests.get(dbSessionId);
-        if (pending?.requestId === requestId) {
-            this.pendingInteractiveRequests.delete(dbSessionId);
-        }
+        sessionStoreService.clearPendingInteractiveRequestIfMatches(dbSessionId, requestId);
     }
     setupWorkspaceNotifications() {
         if (this.workspaceNotificationsSetup) {
@@ -83,7 +87,7 @@ class ChatEventForwarderService {
         if (existingClient) {
             logger.info('[Chat WS] Replacing event forwarding with new client', { dbSessionId });
             this.removeForwardingListeners(dbSessionId, existingClient);
-            this.pendingInteractiveRequests.delete(dbSessionId);
+            sessionStoreService.clearPendingInteractiveRequest(dbSessionId);
         }
         this.clientEventSetup.set(dbSessionId, client);
         if (DEBUG_CHAT_WS) {
@@ -108,8 +112,7 @@ class ChatEventForwarderService {
                 type: 'slash_commands',
                 slashCommands: initResponse.commands,
             };
-            messageStateService.storeEvent(dbSessionId, slashCommandsMsg);
-            chatConnectionService.forwardToSession(dbSessionId, slashCommandsMsg);
+            sessionStoreService.emitDelta(dbSessionId, slashCommandsMsg);
             void slashCommandCacheService.setCachedCommands(initResponse.commands);
         }
         const pendingToolNames = new Map();
@@ -132,20 +135,24 @@ class ChatEventForwarderService {
                 });
             }
             workspaceActivityService.markSessionRunning(context.workspaceId, dbSessionId);
-            sessionRuntimeStoreService.syncFromClient(dbSessionId, {
-                isRunning: client.isRunning(),
-                isWorking: client.isWorking(),
-            });
+            this.syncRuntimeFromClient(dbSessionId, client);
         });
         on('idle', () => {
             if (DEBUG_CHAT_WS) {
                 logger.info('[Chat WS] Claude became idle, checking queue', { dbSessionId });
             }
-            onDispatchNextMessage().catch((error) => {
+            void onDispatchNextMessage()
+                .catch((error) => {
                 logger.error('[Chat WS] Error dispatching queued message on idle', {
                     dbSessionId,
                     error: error instanceof Error ? error.message : String(error),
                 });
+            })
+                .finally(() => {
+                if (!client.isWorking()) {
+                    workspaceActivityService.markSessionIdle(context.workspaceId, dbSessionId);
+                }
+                this.syncRuntimeFromClient(dbSessionId, client);
             });
         });
         on('stream', (event) => {
@@ -157,10 +164,7 @@ class ChatEventForwarderService {
                 });
             }
             sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'stream', data: event });
-            const order = messageStateService.allocateOrder(dbSessionId);
-            const msg = { type: 'claude_message', data: event, order };
-            messageStateService.storeEvent(dbSessionId, msg);
-            chatConnectionService.forwardToSession(dbSessionId, msg);
+            this.forwardClaudeMessage(dbSessionId, event);
         });
         on('tool_progress', (event) => {
             if (DEBUG_CHAT_WS) {
@@ -170,9 +174,7 @@ class ChatEventForwarderService {
                 eventType: 'tool_progress',
                 data: event,
             });
-            const sdkEvent = event;
-            messageStateService.storeEvent(dbSessionId, sdkEvent);
-            chatConnectionService.forwardToSession(dbSessionId, sdkEvent);
+            sessionStoreService.emitDelta(dbSessionId, event);
         });
         on('tool_use_summary', (event) => {
             if (DEBUG_CHAT_WS) {
@@ -182,9 +184,7 @@ class ChatEventForwarderService {
                 eventType: 'tool_use_summary',
                 data: event,
             });
-            const sdkEvent = event;
-            messageStateService.storeEvent(dbSessionId, sdkEvent);
-            chatConnectionService.forwardToSession(dbSessionId, sdkEvent);
+            sessionStoreService.emitDelta(dbSessionId, event);
         });
         on('system_init', (event) => {
             if (DEBUG_CHAT_WS) {
@@ -209,8 +209,7 @@ class ChatEventForwarderService {
                     plugins: event.plugins,
                 },
             };
-            messageStateService.storeEvent(dbSessionId, msg);
-            chatConnectionService.forwardToSession(dbSessionId, msg);
+            sessionStoreService.emitDelta(dbSessionId, msg);
         });
         on('system_status', (event) => {
             if (DEBUG_CHAT_WS) {
@@ -228,8 +227,7 @@ class ChatEventForwarderService {
                 type: 'status_update',
                 permissionMode: event.permission_mode,
             };
-            messageStateService.storeEvent(dbSessionId, msg);
-            chatConnectionService.forwardToSession(dbSessionId, msg);
+            sessionStoreService.emitDelta(dbSessionId, msg);
         });
         on('compact_boundary', (event) => {
             if (DEBUG_CHAT_WS) {
@@ -246,8 +244,7 @@ class ChatEventForwarderService {
             }
             this.lastCompactBoundaryAt.set(dbSessionId, now);
             const boundaryMsg = { type: 'compact_boundary' };
-            messageStateService.storeEvent(dbSessionId, boundaryMsg);
-            chatConnectionService.forwardToSession(dbSessionId, boundaryMsg);
+            sessionStoreService.emitDelta(dbSessionId, boundaryMsg);
         });
         on('hook_started', (event) => {
             if (DEBUG_CHAT_WS) {
@@ -270,8 +267,7 @@ class ChatEventForwarderService {
                     hookEvent: event.hook_event,
                 },
             };
-            messageStateService.storeEvent(dbSessionId, msg);
-            chatConnectionService.forwardToSession(dbSessionId, msg);
+            sessionStoreService.emitDelta(dbSessionId, msg);
         });
         on('hook_response', (event) => {
             if (DEBUG_CHAT_WS) {
@@ -297,8 +293,7 @@ class ChatEventForwarderService {
                     outcome: event.outcome,
                 },
             };
-            messageStateService.storeEvent(dbSessionId, msg);
-            chatConnectionService.forwardToSession(dbSessionId, msg);
+            sessionStoreService.emitDelta(dbSessionId, msg);
         });
         on('compacting_start', () => {
             if (DEBUG_CHAT_WS) {
@@ -306,8 +301,7 @@ class ChatEventForwarderService {
             }
             sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'compacting_start' });
             const event = { type: 'compacting_start' };
-            messageStateService.storeEvent(dbSessionId, event);
-            chatConnectionService.forwardToSession(dbSessionId, event);
+            sessionStoreService.emitDelta(dbSessionId, event);
         });
         on('compacting_end', () => {
             if (DEBUG_CHAT_WS) {
@@ -315,63 +309,11 @@ class ChatEventForwarderService {
             }
             sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'compacting_end' });
             const event = { type: 'compacting_end' };
-            messageStateService.storeEvent(dbSessionId, event);
-            chatConnectionService.forwardToSession(dbSessionId, event);
+            sessionStoreService.emitDelta(dbSessionId, event);
         });
         on('message', (msg) => {
             sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'message', data: msg });
-            const msgWithType = msg;
-            if (msgWithType.type !== 'user') {
-                sessionFileLogger.log(dbSessionId, 'INFO', {
-                    action: 'skipped_message',
-                    reason: 'not_user_type',
-                    type: msgWithType.type,
-                });
-                return;
-            }
-            if (msgWithType.uuid) {
-                const uuidMsg = { type: 'user_message_uuid', uuid: msgWithType.uuid };
-                messageStateService.storeEvent(dbSessionId, uuidMsg);
-                chatConnectionService.forwardToSession(dbSessionId, uuidMsg);
-                if (DEBUG_CHAT_WS) {
-                    logger.info('[Chat WS] Forwarding user message UUID', {
-                        dbSessionId,
-                        uuid: msgWithType.uuid,
-                    });
-                }
-            }
-            const content = msgWithType.message?.content;
-            if (!Array.isArray(content)) {
-                sessionFileLogger.log(dbSessionId, 'INFO', {
-                    action: 'skipped_message',
-                    reason: 'no_array_content',
-                });
-                return;
-            }
-            const hasToolResult = content.some((item) => item.type === 'tool_result');
-            if (!hasToolResult) {
-                sessionFileLogger.log(dbSessionId, 'INFO', {
-                    action: 'skipped_message',
-                    reason: 'no_tool_result_content',
-                    content_types: content.map((c) => c.type),
-                });
-                return;
-            }
-            this.notifyToolResultInterceptors(content, pendingToolNames, pendingToolInputs, {
-                sessionId: dbSessionId,
-                workspaceId: context.workspaceId,
-                workingDir: context.workingDir,
-            });
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Forwarding user message with tool_result', { dbSessionId });
-            }
-            sessionFileLogger.log(dbSessionId, 'INFO', {
-                action: 'forwarding_user_message_with_tool_result',
-            });
-            const order = messageStateService.allocateOrder(dbSessionId);
-            const wsMsg = { type: 'claude_message', data: msg, order };
-            messageStateService.storeEvent(dbSessionId, wsMsg);
-            chatConnectionService.forwardToSession(dbSessionId, wsMsg);
+            this.handleMessageEvent(dbSessionId, msg, pendingToolNames, pendingToolInputs, context);
         });
         on('result', (result) => {
             if (DEBUG_CHAT_WS) {
@@ -379,12 +321,9 @@ class ChatEventForwarderService {
                 logger.info('[Chat WS] Received result event from client', { dbSessionId, uuid: res.uuid });
             }
             sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'result', data: result });
-            const order = messageStateService.allocateOrder(dbSessionId);
-            const resultMsg = { type: 'claude_message', data: result, order };
-            messageStateService.storeEvent(dbSessionId, resultMsg);
-            chatConnectionService.forwardToSession(dbSessionId, resultMsg);
+            this.forwardClaudeMessage(dbSessionId, result);
             workspaceActivityService.markSessionIdle(context.workspaceId, dbSessionId);
-            sessionRuntimeStoreService.markIdle(dbSessionId, client.isRunning() ? 'alive' : 'stopped');
+            this.syncRuntimeFromClient(dbSessionId, client);
         });
         on('interactive_request', (request) => {
             if (DEBUG_CHAT_WS) {
@@ -398,15 +337,13 @@ class ChatEventForwarderService {
                 eventType: 'interactive_request',
                 data: request,
             });
-            this.routeInteractiveRequest(dbSessionId, request);
+            this.routeInteractiveRequest(dbSessionId, request, client);
         });
         on('exit', (result) => {
-            sessionRuntimeStoreService.markProcessExit(dbSessionId, result.code);
+            sessionStoreService.markProcessExit(dbSessionId, result.code);
             this.removeForwardingListeners(dbSessionId, client);
             this.clientEventSetup.delete(dbSessionId);
             this.lastCompactBoundaryAt.delete(dbSessionId);
-            this.pendingInteractiveRequests.delete(dbSessionId);
-            messageStateService.clearSession(dbSessionId);
         });
         on('permission_cancelled', (requestId) => {
             sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
@@ -414,21 +351,102 @@ class ChatEventForwarderService {
                 requestId,
             });
             this.clearPendingRequestIfMatches(dbSessionId, requestId);
-            chatConnectionService.forwardToSession(dbSessionId, {
+            sessionStoreService.emitDelta(dbSessionId, {
                 type: 'permission_cancelled',
                 requestId,
             });
         });
         on('error', (error) => {
-            chatConnectionService.forwardToSession(dbSessionId, {
+            sessionStoreService.emitDelta(dbSessionId, {
                 type: 'error',
                 message: error.message,
             });
         });
     }
-    routeInteractiveRequest(dbSessionId, request) {
+    routeInteractiveRequest(dbSessionId, request, client) {
+        if (!isInteractiveResponseTool(request.toolName)) {
+            const reason = `Unsupported interactive tool: ${request.toolName}`;
+            logger.warn('[Chat WS] Denying unsupported interactive request', {
+                dbSessionId,
+                requestId: request.requestId,
+                toolName: request.toolName,
+            });
+            try {
+                client.denyInteractiveRequest(request.requestId, reason);
+            }
+            catch (error) {
+                logger.error('[Chat WS] Failed to deny unsupported interactive request', {
+                    dbSessionId,
+                    requestId: request.requestId,
+                    toolName: request.toolName,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            sessionStoreService.emitDelta(dbSessionId, {
+                type: 'error',
+                message: reason,
+            });
+            return;
+        }
         const planContent = request.toolName === 'ExitPlanMode' ? this.extractPlanContent(request.input) : null;
-        this.pendingInteractiveRequests.set(dbSessionId, {
+        this.routeSupportedInteractiveRequest(dbSessionId, { ...request, toolName: request.toolName }, planContent, client);
+    }
+    routeSupportedInteractiveRequest(dbSessionId, request, planContent, client) {
+        switch (request.toolName) {
+            case 'AskUserQuestion': {
+                const parsed = safeParseToolInput(AskUserQuestionInputSchema, request.input, 'AskUserQuestion', logger);
+                if (!parsed.success || parsed.data.questions.length === 0) {
+                    logger.warn('[Chat WS] Invalid or empty AskUserQuestion input', {
+                        dbSessionId,
+                        requestId: request.requestId,
+                        validationSuccess: parsed.success,
+                    });
+                    try {
+                        client.denyInteractiveRequest(request.requestId, 'Invalid question format - unable to display question');
+                    }
+                    catch (error) {
+                        logger.error('[Chat WS] Failed to deny invalid AskUserQuestion request', {
+                            dbSessionId,
+                            requestId: request.requestId,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                    sessionStoreService.emitDelta(dbSessionId, {
+                        type: 'error',
+                        message: 'Received invalid question format from CLI',
+                    });
+                    return;
+                }
+                this.storePendingInteractiveRequest(dbSessionId, request, planContent);
+                sessionStoreService.emitDelta(dbSessionId, {
+                    type: 'user_question',
+                    requestId: request.requestId,
+                    questions: parsed.data.questions,
+                });
+                return;
+            }
+            case 'ExitPlanMode':
+                this.storePendingInteractiveRequest(dbSessionId, request, planContent);
+                sessionStoreService.emitDelta(dbSessionId, {
+                    type: 'permission_request',
+                    requestId: request.requestId,
+                    toolName: request.toolName,
+                    toolInput: request.input,
+                    planContent,
+                });
+                return;
+            default: {
+                const unreachable = request.toolName;
+                logger.error('[Chat WS] Unhandled interactive response tool', {
+                    dbSessionId,
+                    requestId: request.requestId,
+                    toolName: unreachable,
+                });
+            }
+        }
+    }
+    storePendingInteractiveRequest(dbSessionId, request, planContent) {
+        sessionStoreService.setPendingInteractiveRequest(dbSessionId, {
             requestId: request.requestId,
             toolName: request.toolName,
             toolUseId: request.toolUseId,
@@ -436,44 +454,136 @@ class ChatEventForwarderService {
             planContent,
             timestamp: new Date().toISOString(),
         });
-        if (request.toolName === 'AskUserQuestion') {
-            const parsed = safeParseToolInput(AskUserQuestionInputSchema, request.input, 'AskUserQuestion', logger);
-            if (!parsed.success || parsed.data.questions.length === 0) {
-                logger.warn('[Chat WS] Invalid or empty AskUserQuestion input', {
+    }
+    handleMessageEvent(dbSessionId, msg, pendingToolNames, pendingToolInputs, context) {
+        const msgWithType = msg;
+        if (msgWithType.type === 'assistant') {
+            this.forwardAssistantTextMessage(dbSessionId, msg, msgWithType);
+            return;
+        }
+        if (msgWithType.type !== 'user') {
+            sessionFileLogger.log(dbSessionId, 'INFO', {
+                action: 'skipped_message',
+                reason: 'not_user_type',
+                type: msgWithType.type,
+            });
+            return;
+        }
+        this.forwardUserMessageWithToolResult(dbSessionId, msg, msgWithType, pendingToolNames, pendingToolInputs, context);
+    }
+    forwardAssistantTextMessage(dbSessionId, msg, msgWithType) {
+        const assistantMsg = msg;
+        const fallbackToolUseEvents = this.buildToolUseFallbackStreamEvents(assistantMsg);
+        for (const toolUseEvent of fallbackToolUseEvents) {
+            this.forwardClaudeMessage(dbSessionId, toolUseEvent);
+        }
+        const content = msgWithType.message?.content;
+        if (!Array.isArray(content)) {
+            sessionFileLogger.log(dbSessionId, 'INFO', {
+                action: 'skipped_message',
+                reason: 'assistant_no_array_content',
+            });
+            return;
+        }
+        const hasNarrativeText = content.some((item) => item.type === 'text' && typeof item.text === 'string');
+        if (!hasNarrativeText) {
+            sessionFileLogger.log(dbSessionId, 'INFO', {
+                action: 'skipped_message',
+                reason: 'assistant_no_text_content',
+            });
+            return;
+        }
+        const normalized = this.normalizeAssistantMessageToTextOnly(assistantMsg);
+        if (!normalized) {
+            return;
+        }
+        this.forwardClaudeMessage(dbSessionId, normalized);
+    }
+    buildToolUseFallbackStreamEvents(message) {
+        if (message.type !== 'assistant') {
+            return [];
+        }
+        const content = message.message?.content;
+        if (!Array.isArray(content)) {
+            return [];
+        }
+        const fallbackEvents = [];
+        for (const [index, item] of content.entries()) {
+            if (item.type !== 'tool_use') {
+                continue;
+            }
+            fallbackEvents.push({
+                type: 'stream_event',
+                event: {
+                    type: 'content_block_start',
+                    index,
+                    content_block: item,
+                },
+                timestamp: message.timestamp ?? new Date().toISOString(),
+            });
+        }
+        return fallbackEvents;
+    }
+    normalizeAssistantMessageToTextOnly(message) {
+        if (message.type !== 'assistant') {
+            return null;
+        }
+        const content = message.message?.content;
+        if (!Array.isArray(content)) {
+            return null;
+        }
+        const textBlocks = content.filter((item) => item.type === 'text' && typeof item.text === 'string');
+        if (textBlocks.length === 0) {
+            return null;
+        }
+        return {
+            ...message,
+            message: {
+                role: 'assistant',
+                content: textBlocks,
+            },
+        };
+    }
+    forwardUserMessageWithToolResult(dbSessionId, msg, msgWithType, pendingToolNames, pendingToolInputs, context) {
+        if (msgWithType.uuid) {
+            const uuidMsg = { type: 'user_message_uuid', uuid: msgWithType.uuid };
+            sessionStoreService.emitDelta(dbSessionId, uuidMsg);
+            if (DEBUG_CHAT_WS) {
+                logger.info('[Chat WS] Forwarding user message UUID', {
                     dbSessionId,
-                    requestId: request.requestId,
-                    validationSuccess: parsed.success,
-                });
-                chatConnectionService.forwardToSession(dbSessionId, {
-                    type: 'error',
-                    message: 'Received invalid question format from CLI',
+                    uuid: msgWithType.uuid,
                 });
-                return;
             }
-            chatConnectionService.forwardToSession(dbSessionId, {
-                type: 'user_question',
-                requestId: request.requestId,
-                questions: parsed.data.questions,
+        }
+        const content = msgWithType.message?.content;
+        if (!Array.isArray(content)) {
+            sessionFileLogger.log(dbSessionId, 'INFO', {
+                action: 'skipped_message',
+                reason: 'no_array_content',
             });
             return;
         }
-        if (request.toolName === 'ExitPlanMode') {
-            chatConnectionService.forwardToSession(dbSessionId, {
-                type: 'permission_request',
-                requestId: request.requestId,
-                toolName: request.toolName,
-                toolInput: request.input,
-                planContent,
+        const hasToolResult = hasToolResultContent(content);
+        if (!hasToolResult) {
+            sessionFileLogger.log(dbSessionId, 'INFO', {
+                action: 'skipped_message',
+                reason: 'no_tool_result_content',
+                content_types: content.map((c) => c.type),
             });
             return;
         }
-        chatConnectionService.forwardToSession(dbSessionId, {
-            type: 'interactive_request',
-            requestId: request.requestId,
-            toolName: request.toolName,
-            toolUseId: request.toolUseId,
-            toolInput: request.input,
+        this.notifyToolResultInterceptors(content, pendingToolNames, pendingToolInputs, {
+            sessionId: dbSessionId,
+            workspaceId: context.workspaceId,
+            workingDir: context.workingDir,
         });
+        if (DEBUG_CHAT_WS) {
+            logger.info('[Chat WS] Forwarding user message with tool_result', { dbSessionId });
+        }
+        sessionFileLogger.log(dbSessionId, 'INFO', {
+            action: 'forwarding_user_message_with_tool_result',
+        });
+        this.forwardClaudeMessage(dbSessionId, msg);
     }
     extractPlanContent(input) {
         const parsed = ExitPlanModeInputSchema.safeParse(input);
@@ -509,6 +619,9 @@ class ChatEventForwarderService {
             return null;
         }
     }
+    getAllPendingRequests() {
+        return sessionStoreService.getAllPendingRequests();
+    }
     notifyToolResultInterceptors(content, pendingToolNames, pendingToolInputs, interceptorContext) {
         for (const item of content) {
             const typedItem = item;
@@ -532,6 +645,13 @@ class ChatEventForwarderService {
             pendingToolInputs.delete(typedItem.tool_use_id);
         }
     }
+    syncRuntimeFromClient(dbSessionId, client) {
+        if (client.isWorking()) {
+            sessionStoreService.markRunning(dbSessionId);
+            return;
+        }
+        sessionStoreService.markIdle(dbSessionId, client.isRunning() ? 'alive' : 'stopped');
+    }
 }
 export const chatEventForwarderService = new ChatEventForwarderService();
 //# sourceMappingURL=chat-event-forwarder.service.js.map