factory-factory 0.3.2 → 0.3.4

package/dist/src/backend/domains/session/lifecycle/session.service.js

@@ -1,27 +1,35 @@
-import { SessionStatus } from '@factory-factory/core';
 import { AcpEventTranslator, AcpPermissionBridge, acpRuntimeManager, } from '../../../../backend/domains/session/acp/index.js';
+import { acpTraceLogger } from '../../../../backend/domains/session/logging/acp-trace-logger.service.js';
 import { sessionFileLogger } from '../../../../backend/domains/session/logging/session-file-logger.service.js';
 import { sessionDomainService } from '../../../../backend/domains/session/session-domain.service.js';
 import { createLogger } from '../../../../backend/services/logger.service.js';
 import { extractPlanText } from '../../../../shared/acp-protocol/plan-content.js';
 import { EMPTY_CHAT_BAR_CAPABILITIES } from '../../../../shared/chat-capabilities.js';
+import { SessionStatus } from '../../../../shared/core/index.js';
+import { isUserQuestionRequest } from '../../../../shared/pending-request-types.js';
 import { createInitialSessionRuntimeState, } from '../../../../shared/session-runtime.js';
 import { sessionPromptBuilder } from './session.prompt-builder.js';
 import { sessionRepository } from './session.repository.js';
 const logger = createLogger('session');
 const STALE_LOADING_RUNTIME_MAX_AGE_MS = 30_000;
+const TERMINAL_TOOL_STATUSES = new Set(['completed', 'failed', 'cancelled']);
 class SessionService {
     repository;
     promptBuilder;
     acpEventTranslator = new AcpEventTranslator(logger);
     acpPermissionBridges = new Map();
     acpStreamState = new Map();
+    pendingAcpToolCalls = new Map();
     suppressAcpReplayForSession = new Set();
     workspaceBridge = null;
     sessionToWorkspace = new Map();
+    promptTurnCompleteHandler = null;
     configure(bridges) {
         this.workspaceBridge = bridges.workspace;
     }
+    setPromptTurnCompleteHandler(handler) {
+        this.promptTurnCompleteHandler = handler;
+    }
     isStaleLoadingRuntime(runtime) {
         if (runtime.phase !== 'loading' || runtime.processState === 'alive') {
             return false;
@@ -46,7 +54,18 @@ class SessionService {
                         return;
                     }
                     const deltas = this.acpEventTranslator.translateSessionUpdate(update);
-                    for (const delta of deltas) {
+                    if (deltas.length === 0) {
+                        acpTraceLogger.log(sid, 'translated_delta', {
+                            sessionUpdate: update.sessionUpdate,
+                            deltaCount: 0,
+                        });
+                    }
+                    for (const [index, delta] of deltas.entries()) {
+                        acpTraceLogger.log(sid, 'translated_delta', {
+                            sessionUpdate: update.sessionUpdate,
+                            deltaIndex: index,
+                            delta,
+                        });
                         this.handleAcpDelta(sid, delta);
                     }
                     return;
@@ -59,6 +78,10 @@ class SessionService {
             onSessionId: async (sid, providerSessionId) => {
                 try {
                     await this.repository.updateSession(sid, { providerSessionId });
+                    acpTraceLogger.log(sid, 'runtime_metadata', {
+                        type: 'provider_session_id',
+                        providerSessionId,
+                    });
                     logger.debug('Updated session with ACP providerSessionId', {
                         sessionId: sid,
                         providerSessionId,
@@ -74,6 +97,7 @@ class SessionService {
             },
             onExit: async (sid, exitCode) => {
                 this.acpStreamState.delete(sid);
+                this.pendingAcpToolCalls.delete(sid);
                 this.suppressAcpReplayForSession.delete(sid);
                 this.sessionToWorkspace.delete(sid);
                 const b = this.acpPermissionBridges.get(sid);
@@ -81,6 +105,7 @@ class SessionService {
                     b.cancelAll();
                     this.acpPermissionBridges.delete(sid);
                 }
+                acpTraceLogger.log(sid, 'runtime_exit', { exitCode });
                 try {
                     sessionDomainService.markProcessExit(sid, exitCode);
                     const session = await this.repository.updateSession(sid, {
@@ -99,8 +124,15 @@ class SessionService {
                         error: error instanceof Error ? error.message : String(error),
                     });
                 }
+                finally {
+                    acpTraceLogger.closeSession(sid);
+                }
             },
             onError: (sid, error) => {
+                acpTraceLogger.log(sid, 'runtime_error', {
+                    message: error.message,
+                    stack: error.stack,
+                });
                 logger.error('ACP client error', {
                     sessionId: sid,
                     error: error.message,
@@ -108,6 +140,7 @@ class SessionService {
                 });
             },
             onAcpLog: (sid, payload) => {
+                acpTraceLogger.log(sid, 'raw_acp_event', payload);
                 sessionFileLogger.log(sid, 'FROM_CLAUDE_CLI', payload);
             },
         };
@@ -119,6 +152,7 @@ class SessionService {
             delta.type !== 'slash_commands') {
             return;
         }
+        this.trackPendingAcpToolCalls(sid, delta);
         if (delta.type === 'config_options_update') {
             const acpHandle = acpRuntimeManager.getClient(sid);
             if (acpHandle) {
@@ -150,6 +184,140 @@ class SessionService {
         const order = sessionDomainService.appendClaudeEvent(sid, data);
         sessionDomainService.emitDelta(sid, { ...delta, order });
     }
+    trackPendingAcpToolCalls(sid, delta) {
+        if (delta.type === 'agent_message') {
+            this.trackPendingFromAgentMessage(sid, delta.data);
+            return;
+        }
+        if (delta.type === 'tool_progress') {
+            this.trackPendingFromToolProgress(sid, delta);
+        }
+    }
+    trackPendingFromAgentMessage(sid, data) {
+        if (data.type === 'stream_event') {
+            this.trackPendingFromToolUseStreamEvent(sid, data);
+        }
+        if (data.type !== 'user') {
+            return;
+        }
+        this.clearPendingFromToolResultMessage(sid, data);
+    }
+    trackPendingFromToolUseStreamEvent(sid, data) {
+        const streamEvent = data.event;
+        const contentBlock = streamEvent?.content_block;
+        const isToolUse = streamEvent?.type === 'content_block_start' && contentBlock?.type === 'tool_use';
+        if (!isToolUse) {
+            return;
+        }
+        const toolUseId = typeof contentBlock?.id === 'string' ? contentBlock.id : null;
+        if (!toolUseId) {
+            return;
+        }
+        const toolName = typeof contentBlock?.name === 'string' ? contentBlock.name : 'ACP Tool';
+        this.upsertPendingToolCall(sid, toolUseId, { toolName });
+    }
+    clearPendingFromToolResultMessage(sid, data) {
+        if (data.type !== 'user') {
+            return;
+        }
+        const content = data.message?.content;
+        if (!Array.isArray(content)) {
+            return;
+        }
+        for (const item of content) {
+            if (item.type === 'tool_result') {
+                this.removePendingToolCall(sid, item.tool_use_id);
+            }
+        }
+    }
+    trackPendingFromToolProgress(sid, progress) {
+        if (!progress.tool_use_id) {
+            return;
+        }
+        if (progress.acpStatus && TERMINAL_TOOL_STATUSES.has(progress.acpStatus)) {
+            this.removePendingToolCall(sid, progress.tool_use_id);
+            return;
+        }
+        this.upsertPendingToolCall(sid, progress.tool_use_id, {
+            toolName: progress.tool_name ?? 'ACP Tool',
+            acpKind: progress.acpKind,
+            acpLocations: progress.acpLocations,
+        });
+    }
+    upsertPendingToolCall(sid, toolUseId, update) {
+        const pendingById = this.pendingAcpToolCalls.get(sid) ?? new Map();
+        const existing = pendingById.get(toolUseId);
+        pendingById.set(toolUseId, {
+            toolUseId,
+            toolName: update.toolName || existing?.toolName || 'ACP Tool',
+            acpKind: update.acpKind ?? existing?.acpKind,
+            acpLocations: update.acpLocations ?? existing?.acpLocations,
+        });
+        this.pendingAcpToolCalls.set(sid, pendingById);
+    }
+    removePendingToolCall(sid, toolUseId) {
+        const pendingById = this.pendingAcpToolCalls.get(sid);
+        if (!pendingById) {
+            return;
+        }
+        pendingById.delete(toolUseId);
+        if (pendingById.size === 0) {
+            this.pendingAcpToolCalls.delete(sid);
+        }
+    }
+    finalizeOrphanedToolCalls(sid, reason) {
+        const pendingById = this.pendingAcpToolCalls.get(sid);
+        if (!pendingById || pendingById.size === 0) {
+            this.pendingAcpToolCalls.delete(sid);
+            return;
+        }
+        const toolUseIds = [...pendingById.keys()];
+        logger.warn('Finalizing orphaned ACP tool calls without terminal status', {
+            sessionId: sid,
+            reason,
+            count: toolUseIds.length,
+            toolUseIds,
+        });
+        for (const pending of pendingById.values()) {
+            const syntheticProgress = {
+                type: 'tool_progress',
+                tool_use_id: pending.toolUseId,
+                tool_name: pending.toolName,
+                acpStatus: 'failed',
+                elapsed_time_seconds: 0,
+                ...(pending.acpKind ? { acpKind: pending.acpKind } : {}),
+                ...(pending.acpLocations ? { acpLocations: pending.acpLocations } : {}),
+            };
+            this.handleAcpDelta(sid, syntheticProgress);
+            const syntheticResult = {
+                type: 'agent_message',
+                data: {
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'tool_result',
+                                tool_use_id: pending.toolUseId,
+                                content: `Tool call did not receive a terminal ACP update (${reason}). Marked as failed locally.`,
+                                is_error: true,
+                            },
+                        ],
+                    },
+                },
+            };
+            this.handleAcpDelta(sid, syntheticResult);
+            acpTraceLogger.log(sid, 'translated_delta', {
+                sessionUpdate: 'synthetic_orphan_tool_call',
+                delta: syntheticProgress,
+            });
+            acpTraceLogger.log(sid, 'translated_delta', {
+                sessionUpdate: 'synthetic_orphan_tool_call',
+                delta: syntheticResult,
+            });
+        }
+        this.pendingAcpToolCalls.delete(sid);
+    }
     handleAcpUserMessageChunk(sid, text) {
         this.maybeLiftReplaySuppression(sid);
         if (this.suppressAcpReplayForSession.has(sid)) {
@@ -196,11 +364,12 @@ class SessionService {
             kind: o.kind,
         }));
         const planContent = this.extractPlanContent(toolName, toolInput);
-        if (toolName === 'AskUserQuestion') {
+        if (isUserQuestionRequest({ toolName, input: toolInput })) {
             const questions = this.extractAskUserQuestions(toolInput);
             sessionDomainService.emitDelta(sid, {
                 type: 'user_question',
                 requestId,
+                toolName,
                 questions,
                 acpOptions,
             });
@@ -326,15 +495,110 @@ class SessionService {
         if (existingClient) {
             throw new Error('Session is already running');
         }
-        await this.getOrCreateAcpSessionClient(sessionId, { permissionMode: 'bypassPermissions' }, session);
+        const startupModePreset = options?.startupModePreset;
+        const startupPermissionMode = startupModePreset === 'plan' ? 'plan' : 'bypassPermissions';
+        const handle = await this.getOrCreateAcpSessionClient(sessionId, { permissionMode: startupPermissionMode }, session);
+        await this.applyStartupModePreset(sessionId, handle, startupModePreset);
         const initialPrompt = options?.initialPrompt ?? 'Continue with the task.';
         if (initialPrompt) {
             await this.sendSessionMessage(sessionId, initialPrompt);
         }
         logger.info('Session started', { sessionId, provider: session.provider });
     }
+    async applyStartupModePreset(sessionId, handle, startupModePreset) {
+        if (!startupModePreset) {
+            return;
+        }
+        const modeOption = handle.configOptions.find((option) => option.category === 'mode');
+        if (!modeOption) {
+            return;
+        }
+        const availableModeValues = this.getConfigOptionValues(modeOption);
+        const targetMode = this.resolveStartupModeTarget(handle.provider, startupModePreset, availableModeValues);
+        if (!targetMode) {
+            logger.debug('Startup mode preset not available in ACP mode options', {
+                sessionId,
+                provider: handle.provider,
+                startupModePreset,
+                availableModeValues,
+            });
+            return;
+        }
+        const currentMode = modeOption.currentValue ? String(modeOption.currentValue) : null;
+        if (currentMode === targetMode) {
+            return;
+        }
+        try {
+            const configOptions = await acpRuntimeManager.setSessionMode(sessionId, targetMode);
+            handle.configOptions = configOptions;
+            await this.persistAcpConfigSnapshot(sessionId, {
+                provider: handle.provider,
+                providerSessionId: handle.providerSessionId,
+                configOptions,
+            });
+            sessionDomainService.emitDelta(sessionId, {
+                type: 'config_options_update',
+                configOptions,
+            });
+            sessionDomainService.emitDelta(sessionId, {
+                type: 'chat_capabilities',
+                capabilities: this.buildAcpChatBarCapabilities(handle),
+            });
+        }
+        catch (error) {
+            logger.warn('Failed applying startup mode preset', {
+                sessionId,
+                provider: handle.provider,
+                startupModePreset,
+                targetMode,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    resolveStartupModeTarget(provider, startupModePreset, availableModeValues) {
+        if (availableModeValues.length === 0) {
+            return null;
+        }
+        if (startupModePreset === 'plan') {
+            return this.findModeValue(availableModeValues, ['plan']);
+        }
+        if (provider === 'CLAUDE') {
+            return this.findModeValue(availableModeValues, [
+                'bypassPermissions',
+                'dangerouslySkipPermissions',
+                'dangerousSkipPermissions',
+                'acceptEdits',
+            ]);
+        }
+        return this.findModeValue(availableModeValues, [
+            'fullAccess',
+            'full_access',
+            'full-access',
+            'code',
+        ]);
+    }
+    findModeValue(availableModeValues, preferredModeValues) {
+        if (availableModeValues.length === 0 || preferredModeValues.length === 0) {
+            return null;
+        }
+        const availableByNormalized = new Map();
+        for (const value of availableModeValues) {
+            availableByNormalized.set(this.normalizeModeValue(value), value);
+        }
+        for (const preferredValue of preferredModeValues) {
+            const match = availableByNormalized.get(this.normalizeModeValue(preferredValue));
+            if (match) {
+                return match;
+            }
+        }
+        return null;
+    }
+    normalizeModeValue(value) {
+        return value.replace(/[^a-z0-9]/gi, '').toLowerCase();
+    }
     async stopSession(sessionId, options) {
         const session = await this.loadSessionForStop(sessionId);
+        const workspaceId = session?.workspaceId ?? this.sessionToWorkspace.get(sessionId);
         if (acpRuntimeManager.isStopInProgress(sessionId)) {
             logger.debug('Session stop already in progress', { sessionId });
             return;
@@ -367,14 +631,17 @@ class SessionService {
             });
         }
         finally {
+            this.finalizeOrphanedToolCallsOnStop(sessionId);
             await this.updateStoppedSessionState(sessionId);
-            sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: false });
+            sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: true });
             sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'idle',
                 processState: 'stopped',
                 activity: 'IDLE',
                 updatedAt: new Date().toISOString(),
             });
+            this.markWorkspaceSessionIdleOnStop(workspaceId, sessionId);
+            this.sessionToWorkspace.delete(sessionId);
             if (!stopClientFailed) {
                 const shouldCleanupTransientRatchetSession = options?.cleanupTransientRatchetSession ?? true;
                 await this.cleanupTransientRatchetOnStop(session, sessionId, shouldCleanupTransientRatchetSession);
@@ -383,6 +650,34 @@ class SessionService {
                 sessionId,
                 ...(stopClientFailed ? { runtimeStopFailed: true } : {}),
             });
+            acpTraceLogger.closeSession(sessionId);
+        }
+    }
+    finalizeOrphanedToolCallsOnStop(sessionId) {
+        try {
+            this.finalizeOrphanedToolCalls(sessionId, 'session_stop');
+        }
+        catch (error) {
+            logger.warn('Failed finalizing orphaned ACP tool calls during stop', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            this.pendingAcpToolCalls.delete(sessionId);
+        }
+    }
+    markWorkspaceSessionIdleOnStop(workspaceId, sessionId) {
+        if (!(workspaceId && this.workspaceBridge)) {
+            return;
+        }
+        try {
+            this.workspaceBridge.markSessionIdle(workspaceId, sessionId);
+        }
+        catch (error) {
+            logger.warn('Failed to mark workspace session idle during stop', {
+                sessionId,
+                workspaceId,
+                error: error instanceof Error ? error.message : String(error),
+            });
         }
     }
     async loadSessionForStop(sessionId) {
@@ -526,7 +821,15 @@ class SessionService {
     }
     async setSessionConfigOption(sessionId, configId, value) {
         const acpHandle = acpRuntimeManager.getClient(sessionId);
-        const selectedOption = acpHandle?.configOptions.find((option) => option.id === configId);
+        if (!acpHandle) {
+            const configOptions = await this.setCachedSessionConfigOption(sessionId, configId, value);
+            sessionDomainService.emitDelta(sessionId, {
+                type: 'config_options_update',
+                configOptions,
+            });
+            return;
+        }
+        const selectedOption = acpHandle.configOptions.find((option) => option.id === configId);
         const isModeOption = configId === 'mode' || selectedOption?.category === 'mode';
         const isModelOption = configId === 'model' || selectedOption?.category === 'model';
         const configOptions = isModeOption
@@ -547,6 +850,46 @@ class SessionService {
             });
         }
     }
+    async setCachedSessionConfigOption(sessionId, configId, value) {
+        const session = await this.repository.getSessionById(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const snapshot = this.extractAcpConfigSnapshot(session.providerMetadata);
+        if (!snapshot || snapshot.provider !== session.provider) {
+            throw new Error(`Cannot set config option for inactive session ${sessionId}: no cached ACP config available`);
+        }
+        const configOptions = this.updateCachedConfigOptions(snapshot.configOptions, configId, value);
+        await this.persistAcpConfigSnapshot(sessionId, {
+            provider: snapshot.provider,
+            providerSessionId: snapshot.providerSessionId,
+            configOptions,
+            existingMetadata: session.providerMetadata,
+        });
+        return configOptions;
+    }
+    updateCachedConfigOptions(configOptions, configId, value) {
+        let didUpdate = false;
+        const nextConfigOptions = configOptions.map((option) => {
+            if (option.id !== configId) {
+                return option;
+            }
+            const allowedValues = this.getConfigOptionValues(option);
+            if (allowedValues.length > 0 && !allowedValues.includes(value)) {
+                throw new Error(`Unsupported value "${value}" for config option "${configId}"` +
+                    ` (allowed: ${allowedValues.join(', ')})`);
+            }
+            didUpdate = true;
+            return {
+                ...option,
+                currentValue: value,
+            };
+        });
+        if (!didUpdate) {
+            throw new Error(`Unknown config option: ${configId}`);
+        }
+        return nextConfigOptions;
+    }
     sendSessionMessage(sessionId, content) {
         const acpClient = acpRuntimeManager.getClient(sessionId);
         if (acpClient) {
@@ -595,6 +938,7 @@ class SessionService {
     }
     async sendAcpMessage(sessionId, content) {
         const workspaceId = this.sessionToWorkspace.get(sessionId);
+        this.pendingAcpToolCalls.set(sessionId, new Map());
         sessionDomainService.setRuntimeSnapshot(sessionId, {
             phase: 'running',
             processState: 'alive',
@@ -606,6 +950,7 @@ class SessionService {
         }
         try {
             const result = await acpRuntimeManager.sendPrompt(sessionId, content);
+            this.finalizeOrphanedToolCalls(sessionId, `stop_reason:${result.stopReason}`);
             sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'idle',
                 processState: 'alive',
@@ -615,6 +960,7 @@ class SessionService {
             return result.stopReason;
         }
         catch (error) {
+            this.finalizeOrphanedToolCalls(sessionId, 'prompt_error');
             sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'error',
                 processState: 'alive',
@@ -627,6 +973,29 @@ class SessionService {
             if (workspaceId && this.workspaceBridge) {
                 this.workspaceBridge.markSessionIdle(workspaceId, sessionId);
             }
+            this.schedulePromptTurnComplete(sessionId);
+        }
+    }
+    schedulePromptTurnComplete(sessionId) {
+        if (!this.promptTurnCompleteHandler) {
+            return;
+        }
+        setTimeout(() => {
+            void this.notifyPromptTurnComplete(sessionId);
+        }, 0);
+    }
+    async notifyPromptTurnComplete(sessionId) {
+        if (!this.promptTurnCompleteHandler) {
+            return;
+        }
+        try {
+            await this.promptTurnCompleteHandler(sessionId);
+        }
+        catch (error) {
+            logger.warn('Prompt turn completion handler failed', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
         }
     }
     async cancelAcpPrompt(sessionId) {
@@ -678,12 +1047,12 @@ class SessionService {
             .join('\n')
             .trim();
     }
-    respondToAcpPermission(sessionId, requestId, optionId) {
+    respondToAcpPermission(sessionId, requestId, optionId, answers) {
         const bridge = this.acpPermissionBridges.get(sessionId);
         if (!bridge) {
             return false;
         }
-        return bridge.resolvePermission(requestId, optionId);
+        return bridge.resolvePermission(requestId, optionId, answers);
     }
     getRuntimeSnapshot(sessionId) {
         const fallback = createInitialSessionRuntimeState();
@@ -793,12 +1162,36 @@ class SessionService {
     }
     buildCapabilitiesFromConfigOptions(provider, configOptions, fallbackModel) {
         const modelOption = configOptions.find((o) => o.category === 'model');
-        const thoughtOption = configOptions.find((o) => o.category === 'thought_level');
+        const modeOption = configOptions.find((o) => o.category === 'mode');
+        const thoughtOption = configOptions.find((o) => o.category === 'thought_level' || o.id === 'reasoning_effort' || o.category === 'reasoning');
         const selectedModel = modelOption?.currentValue
             ? String(modelOption.currentValue)
             : (fallbackModel ?? undefined);
         const modelOptions = this.buildModelOptions(modelOption, selectedModel);
         const isCodexProvider = provider === 'CODEX';
+        const reasoningOptions = isCodexProvider && thoughtOption
+            ? this.getSelectOptions(thoughtOption).map((option) => ({
+                value: option.value,
+                label: option.name ?? option.value,
+                ...(option.description ? { description: option.description } : {}),
+            }))
+            : [];
+        const reasoningValues = new Set(reasoningOptions.map((option) => option.value));
+        const selectedReasoning = isCodexProvider &&
+            thoughtOption?.currentValue &&
+            typeof thoughtOption.currentValue === 'string' &&
+            reasoningValues.has(thoughtOption.currentValue)
+            ? thoughtOption.currentValue
+            : undefined;
+        const modeDescriptors = modeOption
+            ? [
+                ...this.getConfigOptionValues(modeOption),
+                ...this.getSelectOptions(modeOption)
+                    .map((entry) => entry.name ?? '')
+                    .filter((value) => value.trim().length > 0),
+            ]
+            : [];
+        const planModeEnabled = modeDescriptors.some((entry) => /plan/i.test(entry));
         return {
             provider,
             model: {
@@ -807,13 +1200,14 @@ class SessionService {
                 ...(selectedModel ? { selected: selectedModel } : {}),
             },
             reasoning: {
-                enabled: false,
-                options: [],
+                enabled: reasoningOptions.length > 0,
+                options: reasoningOptions,
+                ...(selectedReasoning ? { selected: selectedReasoning } : {}),
             },
             thinking: {
-                enabled: !!thoughtOption,
+                enabled: !isCodexProvider && !!thoughtOption,
             },
-            planMode: { enabled: true },
+            planMode: { enabled: planModeEnabled },
             attachments: isCodexProvider
                 ? { enabled: false, kinds: [] }
                 : { enabled: true, kinds: ['image', 'text'] },
@@ -826,28 +1220,34 @@ class SessionService {
         if (!modelOption) {
             return selectedModel ? [{ value: selectedModel, label: selectedModel }] : [];
         }
-        const uniqueValues = new Set(this.getConfigOptionValues(modelOption));
-        if (selectedModel) {
-            uniqueValues.add(selectedModel);
+        const byValue = new Map();
+        for (const option of this.getSelectOptions(modelOption)) {
+            if (!byValue.has(option.value)) {
+                byValue.set(option.value, option.name ?? option.value);
+            }
+        }
+        if (selectedModel && !byValue.has(selectedModel)) {
+            byValue.set(selectedModel, selectedModel);
         }
-        return Array.from(uniqueValues).map((value) => ({ value, label: value }));
+        return Array.from(byValue.entries()).map(([value, label]) => ({ value, label }));
     }
-    getConfigOptionValues(option) {
+    getSelectOptions(option) {
         return option.options.flatMap((entry) => {
             if (typeof entry !== 'object' || entry === null) {
                 return [];
             }
             if ('value' in entry && typeof entry.value === 'string') {
-                return [entry.value];
+                return [entry];
             }
             if ('options' in entry && Array.isArray(entry.options)) {
-                return entry.options
-                    .map((grouped) => grouped?.value)
-                    .filter((value) => typeof value === 'string');
+                return entry.options.filter((grouped) => typeof grouped === 'object' && grouped !== null && typeof grouped.value === 'string');
             }
             return [];
         });
     }
+    getConfigOptionValues(option) {
+        return this.getSelectOptions(option).map((entry) => entry.value);
+    }
     async stopAllClients(_timeoutMs = 5000) {
         try {
             await acpRuntimeManager.stopAllClients();
@@ -868,7 +1268,6 @@ class SessionService {
         const metadataSource = params.existingMetadata ??
             (await this.repository.getSessionById(sessionId))?.providerMetadata ??
             null;
-        const metadataRecord = this.toMetadataRecord(metadataSource);
         const snapshot = {
             provider: params.provider,
             providerSessionId: params.providerSessionId,
@@ -876,44 +1275,42 @@ class SessionService {
             configOptions: configOptionsForStorage,
             ...(observedModelId ? { observedModelId } : {}),
         };
+        const persistedUpdate = this.buildSnapshotPersistUpdate(metadataSource, snapshot, observedModelId);
+        try {
+            await this.repository.updateSession(sessionId, persistedUpdate);
+        }
+        catch (error) {
+            logger.warn('Failed persisting ACP config snapshot to session metadata; retrying once', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            await this.retryPersistAcpConfigSnapshot(sessionId, snapshot, observedModelId);
+        }
+    }
+    buildSnapshotPersistUpdate(metadataSource, snapshot, observedModelId) {
         const nextMetadata = {
-            ...metadataRecord,
+            ...this.toMetadataRecord(metadataSource),
             acpConfigSnapshot: snapshot,
         };
         if (observedModelId) {
             nextMetadata.observedModelId = observedModelId;
         }
+        return {
+            providerMetadata: nextMetadata,
+            ...(observedModelId ? { model: observedModelId } : {}),
+        };
+    }
+    async retryPersistAcpConfigSnapshot(sessionId, snapshot, observedModelId) {
         try {
-            await this.repository.updateSession(sessionId, {
-                providerMetadata: nextMetadata,
-            });
+            const latestMetadataSource = (await this.repository.getSessionById(sessionId))
+                ?.providerMetadata;
+            await this.repository.updateSession(sessionId, this.buildSnapshotPersistUpdate(latestMetadataSource, snapshot, observedModelId));
         }
-        catch (error) {
-            logger.warn('Failed persisting ACP config snapshot to session metadata; retrying once', {
+        catch (retryError) {
+            logger.warn('Retry failed persisting ACP config snapshot to session metadata', {
                 sessionId,
-                error: error instanceof Error ? error.message : String(error),
+                error: retryError instanceof Error ? retryError.message : String(retryError),
             });
-            try {
-                const latestMetadataSource = (await this.repository.getSessionById(sessionId))
-                    ?.providerMetadata;
-                const latestMetadata = this.toMetadataRecord(latestMetadataSource);
-                const retryMetadata = {
-                    ...latestMetadata,
-                    acpConfigSnapshot: snapshot,
-                };
-                if (observedModelId) {
-                    retryMetadata.observedModelId = observedModelId;
-                }
-                await this.repository.updateSession(sessionId, {
-                    providerMetadata: retryMetadata,
-                });
-            }
-            catch (retryError) {
-                logger.warn('Retry failed persisting ACP config snapshot to session metadata', {
-                    sessionId,
-                    error: retryError instanceof Error ? retryError.message : String(retryError),
-                });
-            }
         }
     }
     cloneConfigOptionsForStorage(configOptions) {