factory-factory 0.2.6 → 0.2.8

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

@@ -0,0 +1,672 @@
+import { EventEmitter } from 'node:events';
+import { existsSync, readFileSync } from 'node:fs';
+import { WS_READY_STATE } from '../../../../backend/constants/index.js';
+import { sessionFileLogger } from '../../../../backend/domains/session/logging/session-file-logger.service.js';
+import { sessionDomainService } from '../../../../backend/domains/session/session-domain.service.js';
+import { interceptorRegistry } from '../../../../backend/interceptors/index.js';
+import { AskUserQuestionInputSchema, ExitPlanModeInputSchema, extractInputValue, isString, safeParseToolInput, } from '../../../../backend/schemas/tool-inputs.schema.js';
+import { configService } from '../../../../backend/services/config.service.js';
+import { createLogger } from '../../../../backend/services/logger.service.js';
+import { slashCommandCacheService } from '../../../../backend/services/slash-command-cache.service.js';
+import { hasToolResultContent } from '../../../../shared/claude/index.js';
+import { isInteractiveResponseTool, } from '../../../../shared/pending-request-types.js';
+import { chatConnectionService } from './chat-connection.service.js';
+const logger = createLogger('chat-event-forwarder');
+const DEBUG_CHAT_WS = configService.getDebugConfig().chatWebSocket;
+class ChatEventForwarderService {
+    clientEventSetup = new Map();
+    registeredListeners = new Map();
+    workspaceNotificationsSetup = false;
+    lastCompactBoundaryAt = new Map();
+    workspaceBridge = null;
+    configure(bridges) {
+        this.workspaceBridge = bridges.workspace;
+    }
+    get workspace() {
+        if (!this.workspaceBridge) {
+            throw new Error('ChatEventForwarderService not configured: workspace bridge missing. Call configure() first.');
+        }
+        return this.workspaceBridge;
+    }
+    forwardClaudeMessage(dbSessionId, message) {
+        const order = sessionDomainService.appendClaudeEvent(dbSessionId, message);
+        const wsMsg = order === undefined
+            ? { type: 'claude_message', data: message }
+            : { type: 'claude_message', data: message, order };
+        sessionDomainService.emitDelta(dbSessionId, wsMsg);
+    }
+    removeForwardingListeners(dbSessionId, client) {
+        const listeners = this.registeredListeners.get(dbSessionId);
+        if (listeners) {
+            for (const { event, handler } of listeners) {
+                client.off(event, handler);
+            }
+            this.registeredListeners.delete(dbSessionId);
+        }
+    }
+    isSetup(dbSessionId) {
+        return this.clientEventSetup.has(dbSessionId);
+    }
+    getPendingRequest(dbSessionId) {
+        return sessionDomainService.getPendingInteractiveRequest(dbSessionId) ?? undefined;
+    }
+    clearPendingRequest(dbSessionId) {
+        sessionDomainService.clearPendingInteractiveRequest(dbSessionId);
+    }
+    clearPendingRequestIfMatches(dbSessionId, requestId) {
+        sessionDomainService.clearPendingInteractiveRequestIfMatches(dbSessionId, requestId);
+    }
+    setupWorkspaceNotifications() {
+        if (this.workspaceNotificationsSetup) {
+            return;
+        }
+        this.workspaceNotificationsSetup = true;
+        this.workspace.on('request_notification', (data) => {
+            const { workspaceId, workspaceName, sessionCount, finishedAt } = data;
+            logger.debug('Broadcasting workspace notification request', { workspaceId });
+            const message = JSON.stringify({
+                type: 'workspace_notification_request',
+                workspaceId,
+                workspaceName,
+                sessionCount,
+                finishedAt: finishedAt.toISOString(),
+            });
+            for (const info of chatConnectionService.values()) {
+                if (info.ws.readyState === WS_READY_STATE.OPEN) {
+                    try {
+                        info.ws.send(message);
+                    }
+                    catch (error) {
+                        logger.error('Failed to send workspace notification', error);
+                    }
+                }
+            }
+        });
+    }
+    setupClientEvents(dbSessionId, client, context, onDispatchNextMessage) {
+        const existingClient = this.clientEventSetup.get(dbSessionId);
+        if (existingClient === client) {
+            if (DEBUG_CHAT_WS) {
+                logger.info('[Chat WS] Event forwarding already set up for same client, skipping', {
+                    dbSessionId,
+                });
+            }
+            return;
+        }
+        if (existingClient) {
+            logger.info('[Chat WS] Replacing event forwarding with new client', { dbSessionId });
+            this.removeForwardingListeners(dbSessionId, existingClient);
+            sessionDomainService.clearPendingInteractiveRequest(dbSessionId);
+        }
+        this.clientEventSetup.set(dbSessionId, client);
+        if (DEBUG_CHAT_WS) {
+            logger.info('[Chat WS] Setting up event forwarding for session', { dbSessionId });
+        }
+        const emitterOn = EventEmitter.prototype.on.bind(client);
+        const listeners = [];
+        const on = (event, handler) => {
+            emitterOn(event, handler);
+            listeners.push({ event, handler });
+        };
+        this.registeredListeners.set(dbSessionId, listeners);
+        const initResponse = client.getInitializeResponse();
+        if (initResponse?.commands && initResponse.commands.length > 0) {
+            if (DEBUG_CHAT_WS) {
+                logger.info('[Chat WS] Forwarding slash commands to frontend', {
+                    dbSessionId,
+                    commandCount: initResponse.commands.length,
+                });
+            }
+            const slashCommandsMsg = {
+                type: 'slash_commands',
+                slashCommands: initResponse.commands,
+            };
+            sessionDomainService.emitDelta(dbSessionId, slashCommandsMsg);
+            void slashCommandCacheService.setCachedCommands(initResponse.commands);
+        }
+        const pendingToolNames = new Map();
+        const pendingToolInputs = new Map();
+        on('tool_use', (toolUse) => {
+            pendingToolNames.set(toolUse.id, toolUse.name);
+            pendingToolInputs.set(toolUse.id, toolUse.input);
+            interceptorRegistry.notifyToolStart({ toolUseId: toolUse.id, toolName: toolUse.name, input: toolUse.input }, {
+                sessionId: dbSessionId,
+                workspaceId: context.workspaceId,
+                workingDir: context.workingDir,
+                timestamp: new Date(),
+            });
+        });
+        on('session_id', (claudeSessionId) => {
+            if (DEBUG_CHAT_WS) {
+                logger.info('[Chat WS] Received session_id from Claude CLI', {
+                    dbSessionId,
+                    claudeSessionId,
+                });
+            }
+            this.workspace.markSessionRunning(context.workspaceId, dbSessionId);
+            this.syncRuntimeFromClient(dbSessionId, client);
+        });
+        on('idle', () => {
+            if (DEBUG_CHAT_WS) {
+                logger.info('[Chat WS] Claude became idle, checking queue', { dbSessionId });
+            }
+            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()) {
+                    this.workspace.markSessionIdle(context.workspaceId, dbSessionId);
+                }
+                this.syncRuntimeFromClient(dbSessionId, client);
+            });
+        });
+        on('stream', (event) => {
+            const streamEvent = event;
+            if (DEBUG_CHAT_WS) {
+                logger.info('[Chat WS] Received stream event from client', {
+                    dbSessionId,
+                    eventType: streamEvent.type,
+                });
+            }
+            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'stream', data: event });
+            this.forwardClaudeMessage(dbSessionId, event);
+        });
+        const registerLoggedDeltaEvent = (eventName, options = {}) => {
+            on(eventName, (event) => {
+                if (DEBUG_CHAT_WS) {
+                    logger.info(options.debugMessage ?? `[Chat WS] Received ${eventName} event`, {
+                        dbSessionId,
+                        ...(options.debugData?.(event) ?? {}),
+                    });
+                }
+                sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
+                    eventType: eventName,
+                    data: event,
+                });
+                sessionDomainService.emitDelta(dbSessionId, options.mapDelta?.(event) ?? event);
+            });
+        };
+        const mappedDeltaEvents = [
+            {
+                eventName: 'tool_progress',
+                debugMessage: '[Chat WS] Received tool_progress event',
+            },
+            {
+                eventName: 'tool_use_summary',
+                debugMessage: '[Chat WS] Received tool_use_summary event',
+            },
+            {
+                eventName: 'system_init',
+                debugMessage: '[Chat WS] Received system_init event',
+                debugData: (rawEvent) => {
+                    const event = rawEvent;
+                    return {
+                        tools: event.tools?.length ?? 0,
+                        model: event.model,
+                    };
+                },
+                mapDelta: (rawEvent) => {
+                    const event = rawEvent;
+                    return {
+                        type: 'system_init',
+                        data: {
+                            tools: event.tools,
+                            model: event.model,
+                            cwd: event.cwd,
+                            apiKeySource: event.apiKeySource,
+                            slashCommands: event.slash_commands,
+                            plugins: event.plugins,
+                        },
+                    };
+                },
+            },
+            {
+                eventName: 'system_status',
+                debugMessage: '[Chat WS] Received system_status event',
+                debugData: (rawEvent) => {
+                    const event = rawEvent;
+                    return {
+                        status: event.status,
+                        permission_mode: event.permission_mode,
+                    };
+                },
+                mapDelta: (rawEvent) => {
+                    const event = rawEvent;
+                    return {
+                        type: 'status_update',
+                        permissionMode: event.permission_mode,
+                    };
+                },
+            },
+            {
+                eventName: 'hook_started',
+                debugMessage: '[Chat WS] Received hook_started event',
+                debugData: (rawEvent) => {
+                    const event = rawEvent;
+                    return {
+                        hookId: event.hook_id,
+                        hookName: event.hook_name,
+                        hookEvent: event.hook_event,
+                    };
+                },
+                mapDelta: (rawEvent) => {
+                    const event = rawEvent;
+                    return {
+                        type: 'hook_started',
+                        data: {
+                            hookId: event.hook_id,
+                            hookName: event.hook_name,
+                            hookEvent: event.hook_event,
+                        },
+                    };
+                },
+            },
+            {
+                eventName: 'hook_response',
+                debugMessage: '[Chat WS] Received hook_response event',
+                debugData: (rawEvent) => {
+                    const event = rawEvent;
+                    return {
+                        hookId: event.hook_id,
+                        exitCode: event.exit_code,
+                        outcome: event.outcome,
+                    };
+                },
+                mapDelta: (rawEvent) => {
+                    const event = rawEvent;
+                    return {
+                        type: 'hook_response',
+                        data: {
+                            hookId: event.hook_id,
+                            output: event.output,
+                            stdout: event.stdout,
+                            stderr: event.stderr,
+                            exitCode: event.exit_code,
+                            outcome: event.outcome,
+                        },
+                    };
+                },
+            },
+        ];
+        for (const eventConfig of mappedDeltaEvents) {
+            registerLoggedDeltaEvent(eventConfig.eventName, {
+                debugMessage: eventConfig.debugMessage,
+                debugData: eventConfig.debugData,
+                mapDelta: eventConfig.mapDelta,
+            });
+        }
+        on('compact_boundary', (event) => {
+            if (DEBUG_CHAT_WS) {
+                logger.info('[Chat WS] Received compact_boundary event', { dbSessionId });
+            }
+            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
+                eventType: 'compact_boundary',
+                data: event,
+            });
+            const now = Date.now();
+            const lastBoundary = this.lastCompactBoundaryAt.get(dbSessionId) ?? 0;
+            if (now - lastBoundary < 1000) {
+                return;
+            }
+            this.lastCompactBoundaryAt.set(dbSessionId, now);
+            const boundaryMsg = { type: 'compact_boundary' };
+            sessionDomainService.emitDelta(dbSessionId, boundaryMsg);
+        });
+        for (const compactEventName of ['compacting_start', 'compacting_end']) {
+            on(compactEventName, () => {
+                if (DEBUG_CHAT_WS) {
+                    logger.info(compactEventName === 'compacting_start'
+                        ? '[Chat WS] Context compaction started'
+                        : '[Chat WS] Context compaction ended', { dbSessionId });
+                }
+                sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: compactEventName });
+                sessionDomainService.emitDelta(dbSessionId, { type: compactEventName });
+            });
+        }
+        on('message', (msg) => {
+            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'message', data: msg });
+            this.handleMessageEvent(dbSessionId, msg, pendingToolNames, pendingToolInputs, context);
+        });
+        on('result', (result) => {
+            if (DEBUG_CHAT_WS) {
+                const res = result;
+                logger.info('[Chat WS] Received result event from client', { dbSessionId, uuid: res.uuid });
+            }
+            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'result', data: result });
+            this.forwardClaudeMessage(dbSessionId, result);
+            this.workspace.markSessionIdle(context.workspaceId, dbSessionId);
+            this.syncRuntimeFromClient(dbSessionId, client);
+        });
+        on('interactive_request', (request) => {
+            if (DEBUG_CHAT_WS) {
+                logger.info('[Chat WS] Received interactive_request from client', {
+                    dbSessionId,
+                    toolName: request.toolName,
+                    requestId: request.requestId,
+                });
+            }
+            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
+                eventType: 'interactive_request',
+                data: request,
+            });
+            this.routeInteractiveRequest(dbSessionId, request, client);
+        });
+        on('exit', () => {
+            this.removeForwardingListeners(dbSessionId, client);
+            this.clientEventSetup.delete(dbSessionId);
+            this.lastCompactBoundaryAt.delete(dbSessionId);
+        });
+        on('permission_cancelled', (requestId) => {
+            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
+                eventType: 'permission_cancelled',
+                requestId,
+            });
+            this.clearPendingRequestIfMatches(dbSessionId, requestId);
+            sessionDomainService.emitDelta(dbSessionId, {
+                type: 'permission_cancelled',
+                requestId,
+            });
+        });
+        on('error', (error) => {
+            sessionDomainService.emitDelta(dbSessionId, {
+                type: 'error',
+                message: error.message,
+            });
+        });
+    }
+    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),
+                });
+            }
+            sessionDomainService.emitDelta(dbSessionId, {
+                type: 'error',
+                message: reason,
+            });
+            return;
+        }
+        const planContent = request.toolName === 'ExitPlanMode' ? this.extractPlanContent(request.input) : null;
+        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),
+                        });
+                    }
+                    sessionDomainService.emitDelta(dbSessionId, {
+                        type: 'error',
+                        message: 'Received invalid question format from CLI',
+                    });
+                    return;
+                }
+                this.storePendingInteractiveRequest(dbSessionId, request, planContent);
+                sessionDomainService.emitDelta(dbSessionId, {
+                    type: 'user_question',
+                    requestId: request.requestId,
+                    questions: parsed.data.questions,
+                });
+                return;
+            }
+            case 'ExitPlanMode':
+                this.storePendingInteractiveRequest(dbSessionId, request, planContent);
+                sessionDomainService.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) {
+        sessionDomainService.setPendingInteractiveRequest(dbSessionId, {
+            requestId: request.requestId,
+            toolName: request.toolName,
+            toolUseId: request.toolUseId,
+            input: request.input,
+            planContent,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    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 };
+            sessionDomainService.emitDelta(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 = hasToolResultContent(content);
+        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',
+        });
+        this.forwardClaudeMessage(dbSessionId, msg);
+    }
+    extractPlanContent(input) {
+        const parsed = ExitPlanModeInputSchema.safeParse(input);
+        if (!parsed.success) {
+            logger.warn('[Chat WS] ExitPlanMode input validation failed', {
+                errors: parsed.error.issues.map((i) => ({ path: i.path, message: i.message })),
+                inputKeys: Object.keys(input),
+            });
+        }
+        const inlinePlan = extractInputValue(input, 'plan', isString, 'ExitPlanMode', logger);
+        if (inlinePlan) {
+            return inlinePlan;
+        }
+        const planFile = extractInputValue(input, 'planFile', isString, 'ExitPlanMode', logger);
+        if (planFile) {
+            return this.readPlanFileContent(planFile);
+        }
+        return null;
+    }
+    readPlanFileContent(planFile) {
+        if (!existsSync(planFile)) {
+            logger.debug('[Chat WS] Plan file does not exist', { planFile });
+            return null;
+        }
+        try {
+            return readFileSync(planFile, 'utf-8');
+        }
+        catch (error) {
+            logger.error('[Chat WS] Failed to read plan file - user will see empty plan content', {
+                planFile,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    getAllPendingRequests() {
+        return sessionDomainService.getAllPendingRequests();
+    }
+    notifyToolResultInterceptors(content, pendingToolNames, pendingToolInputs, interceptorContext) {
+        for (const item of content) {
+            const typedItem = item;
+            if (typedItem.type !== 'tool_result' || !typedItem.tool_use_id) {
+                continue;
+            }
+            const toolName = pendingToolNames.get(typedItem.tool_use_id) ?? 'unknown';
+            const toolInput = pendingToolInputs.get(typedItem.tool_use_id) ?? {};
+            interceptorRegistry.notifyToolComplete({
+                toolUseId: typedItem.tool_use_id,
+                toolName,
+                input: toolInput,
+                output: {
+                    content: typeof typedItem.content === 'string'
+                        ? typedItem.content
+                        : JSON.stringify(typedItem.content),
+                    isError: typedItem.is_error ?? false,
+                },
+            }, { ...interceptorContext, timestamp: new Date() });
+            pendingToolNames.delete(typedItem.tool_use_id);
+            pendingToolInputs.delete(typedItem.tool_use_id);
+        }
+    }
+    syncRuntimeFromClient(dbSessionId, client) {
+        if (client.isWorking()) {
+            sessionDomainService.markRunning(dbSessionId);
+            return;
+        }
+        sessionDomainService.markIdle(dbSessionId, client.isRunning() ? 'alive' : 'stopped');
+    }
+}
+export const chatEventForwarderService = new ChatEventForwarderService();
+//# sourceMappingURL=chat-event-forwarder.service.js.map