factory-factory 0.2.6 → 0.2.8

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

@@ -1,657 +0,0 @@
-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 { sessionFileLogger } from './session-file-logger.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');
-const DEBUG_CHAT_WS = configService.getDebugConfig().chatWebSocket;
-class ChatEventForwarderService {
-    clientEventSetup = new Map();
-    registeredListeners = 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) {
-            for (const { event, handler } of listeners) {
-                client.off(event, handler);
-            }
-            this.registeredListeners.delete(dbSessionId);
-        }
-    }
-    isSetup(dbSessionId) {
-        return this.clientEventSetup.has(dbSessionId);
-    }
-    getPendingRequest(dbSessionId) {
-        return sessionStoreService.getPendingInteractiveRequest(dbSessionId) ?? undefined;
-    }
-    clearPendingRequest(dbSessionId) {
-        sessionStoreService.clearPendingInteractiveRequest(dbSessionId);
-    }
-    clearPendingRequestIfMatches(dbSessionId, requestId) {
-        sessionStoreService.clearPendingInteractiveRequestIfMatches(dbSessionId, requestId);
-    }
-    setupWorkspaceNotifications() {
-        if (this.workspaceNotificationsSetup) {
-            return;
-        }
-        this.workspaceNotificationsSetup = true;
-        workspaceActivityService.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);
-            sessionStoreService.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,
-            };
-            sessionStoreService.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,
-                });
-            }
-            workspaceActivityService.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()) {
-                    workspaceActivityService.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);
-        });
-        on('tool_progress', (event) => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Received tool_progress event', { dbSessionId });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
-                eventType: 'tool_progress',
-                data: event,
-            });
-            sessionStoreService.emitDelta(dbSessionId, event);
-        });
-        on('tool_use_summary', (event) => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Received tool_use_summary event', { dbSessionId });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
-                eventType: 'tool_use_summary',
-                data: event,
-            });
-            sessionStoreService.emitDelta(dbSessionId, event);
-        });
-        on('system_init', (event) => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Received system_init event', {
-                    dbSessionId,
-                    tools: event.tools?.length ?? 0,
-                    model: event.model,
-                });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
-                eventType: 'system_init',
-                data: event,
-            });
-            const msg = {
-                type: 'system_init',
-                data: {
-                    tools: event.tools,
-                    model: event.model,
-                    cwd: event.cwd,
-                    apiKeySource: event.apiKeySource,
-                    slashCommands: event.slash_commands,
-                    plugins: event.plugins,
-                },
-            };
-            sessionStoreService.emitDelta(dbSessionId, msg);
-        });
-        on('system_status', (event) => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Received system_status event', {
-                    dbSessionId,
-                    status: event.status,
-                    permission_mode: event.permission_mode,
-                });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
-                eventType: 'system_status',
-                data: event,
-            });
-            const msg = {
-                type: 'status_update',
-                permissionMode: event.permission_mode,
-            };
-            sessionStoreService.emitDelta(dbSessionId, msg);
-        });
-        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' };
-            sessionStoreService.emitDelta(dbSessionId, boundaryMsg);
-        });
-        on('hook_started', (event) => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Received hook_started event', {
-                    dbSessionId,
-                    hookId: event.hook_id,
-                    hookName: event.hook_name,
-                    hookEvent: event.hook_event,
-                });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
-                eventType: 'hook_started',
-                data: event,
-            });
-            const msg = {
-                type: 'hook_started',
-                data: {
-                    hookId: event.hook_id,
-                    hookName: event.hook_name,
-                    hookEvent: event.hook_event,
-                },
-            };
-            sessionStoreService.emitDelta(dbSessionId, msg);
-        });
-        on('hook_response', (event) => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Received hook_response event', {
-                    dbSessionId,
-                    hookId: event.hook_id,
-                    exitCode: event.exit_code,
-                    outcome: event.outcome,
-                });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
-                eventType: 'hook_response',
-                data: event,
-            });
-            const msg = {
-                type: 'hook_response',
-                data: {
-                    hookId: event.hook_id,
-                    output: event.output,
-                    stdout: event.stdout,
-                    stderr: event.stderr,
-                    exitCode: event.exit_code,
-                    outcome: event.outcome,
-                },
-            };
-            sessionStoreService.emitDelta(dbSessionId, msg);
-        });
-        on('compacting_start', () => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Context compaction started', { dbSessionId });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'compacting_start' });
-            const event = { type: 'compacting_start' };
-            sessionStoreService.emitDelta(dbSessionId, event);
-        });
-        on('compacting_end', () => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Context compaction ended', { dbSessionId });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'compacting_end' });
-            const event = { type: 'compacting_end' };
-            sessionStoreService.emitDelta(dbSessionId, event);
-        });
-        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);
-            workspaceActivityService.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', (result) => {
-            sessionStoreService.markProcessExit(dbSessionId, result.code);
-            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);
-            sessionStoreService.emitDelta(dbSessionId, {
-                type: 'permission_cancelled',
-                requestId,
-            });
-        });
-        on('error', (error) => {
-            sessionStoreService.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),
-                });
-            }
-            sessionStoreService.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),
-                        });
-                    }
-                    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,
-            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 };
-            sessionStoreService.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 sessionStoreService.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()) {
-            sessionStoreService.markRunning(dbSessionId);
-            return;
-        }
-        sessionStoreService.markIdle(dbSessionId, client.isRunning() ? 'alive' : 'stopped');
-    }
-}
-export const chatEventForwarderService = new ChatEventForwarderService();
-//# sourceMappingURL=chat-event-forwarder.service.js.map