factory-factory 0.3.3 → 0.3.5

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

@@ -2,16 +2,17 @@ import { AcpEventTranslator, AcpPermissionBridge, acpRuntimeManager, } from '../
 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 { interceptorRegistry } from '../../../../backend/interceptors/registry.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;
@@ -22,9 +23,14 @@ class SessionService {
     suppressAcpReplayForSession = new Set();
     workspaceBridge = null;
     sessionToWorkspace = new Map();
+    sessionToWorkingDir = 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;
@@ -95,6 +101,7 @@ class SessionService {
                 this.pendingAcpToolCalls.delete(sid);
                 this.suppressAcpReplayForSession.delete(sid);
                 this.sessionToWorkspace.delete(sid);
+                this.sessionToWorkingDir.delete(sid);
                 const b = this.acpPermissionBridges.get(sid);
                 if (b) {
                     b.cancelAll();
@@ -209,7 +216,16 @@ class SessionService {
             return;
         }
         const toolName = typeof contentBlock?.name === 'string' ? contentBlock.name : 'ACP Tool';
-        this.upsertPendingToolCall(sid, toolUseId, { toolName });
+        const toolInput = this.normalizeToolInput(contentBlock?.input);
+        const existing = this.getPendingToolCall(sid, toolUseId);
+        this.upsertPendingToolCall(sid, toolUseId, { toolName, toolInput });
+        if (!existing) {
+            this.notifyInterceptorToolStart(sid, {
+                toolUseId,
+                toolName,
+                toolInput: toolInput ?? {},
+            });
+        }
     }
     clearPendingFromToolResultMessage(sid, data) {
         if (data.type !== 'user') {
@@ -221,6 +237,8 @@ class SessionService {
         }
         for (const item of content) {
             if (item.type === 'tool_result') {
+                const pending = this.getPendingToolCall(sid, item.tool_use_id);
+                this.notifyInterceptorToolComplete(sid, item.tool_use_id, item.content, item.is_error === true, pending);
                 this.removePendingToolCall(sid, item.tool_use_id);
             }
         }
@@ -229,15 +247,19 @@ class SessionService {
         if (!progress.tool_use_id) {
             return;
         }
-        if (progress.acpStatus && TERMINAL_TOOL_STATUSES.has(progress.acpStatus)) {
-            this.removePendingToolCall(sid, progress.tool_use_id);
-            return;
-        }
+        const existing = this.getPendingToolCall(sid, progress.tool_use_id);
         this.upsertPendingToolCall(sid, progress.tool_use_id, {
             toolName: progress.tool_name ?? 'ACP Tool',
             acpKind: progress.acpKind,
             acpLocations: progress.acpLocations,
         });
+        if (!existing) {
+            this.notifyInterceptorToolStart(sid, {
+                toolUseId: progress.tool_use_id,
+                toolName: progress.tool_name ?? 'ACP Tool',
+                toolInput: {},
+            });
+        }
     }
     upsertPendingToolCall(sid, toolUseId, update) {
         const pendingById = this.pendingAcpToolCalls.get(sid) ?? new Map();
@@ -245,11 +267,15 @@ class SessionService {
         pendingById.set(toolUseId, {
             toolUseId,
             toolName: update.toolName || existing?.toolName || 'ACP Tool',
+            toolInput: update.toolInput ?? existing?.toolInput,
             acpKind: update.acpKind ?? existing?.acpKind,
             acpLocations: update.acpLocations ?? existing?.acpLocations,
         });
         this.pendingAcpToolCalls.set(sid, pendingById);
     }
+    getPendingToolCall(sid, toolUseId) {
+        return this.pendingAcpToolCalls.get(sid)?.get(toolUseId);
+    }
     removePendingToolCall(sid, toolUseId) {
         const pendingById = this.pendingAcpToolCalls.get(sid);
         if (!pendingById) {
@@ -260,6 +286,80 @@ class SessionService {
             this.pendingAcpToolCalls.delete(sid);
         }
     }
+    normalizeToolInput(input) {
+        if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+            return undefined;
+        }
+        return input;
+    }
+    extractToolResultText(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            return content
+                .flatMap((item) => {
+                if (typeof item === 'object' &&
+                    item !== null &&
+                    item.type === 'text' &&
+                    typeof item.text === 'string') {
+                    return [item.text];
+                }
+                return [];
+            })
+                .join('\n');
+        }
+        if (content === undefined || content === null) {
+            return '';
+        }
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return String(content);
+        }
+    }
+    getInterceptorContext(sessionId) {
+        const workspaceId = this.sessionToWorkspace.get(sessionId);
+        const workingDir = this.sessionToWorkingDir.get(sessionId);
+        if (!(workspaceId && workingDir)) {
+            return null;
+        }
+        return {
+            sessionId,
+            workspaceId,
+            workingDir,
+            timestamp: new Date(),
+        };
+    }
+    notifyInterceptorToolStart(sessionId, tool) {
+        const context = this.getInterceptorContext(sessionId);
+        if (!context) {
+            return;
+        }
+        const event = {
+            toolUseId: tool.toolUseId,
+            toolName: tool.toolName,
+            input: tool.toolInput,
+        };
+        interceptorRegistry.notifyToolStart(event, context);
+    }
+    notifyInterceptorToolComplete(sessionId, toolUseId, content, isError, pending) {
+        const context = this.getInterceptorContext(sessionId);
+        if (!context) {
+            return;
+        }
+        const event = {
+            toolUseId,
+            toolName: pending?.toolName ?? 'ACP Tool',
+            input: pending?.toolInput ?? {},
+            output: {
+                content: this.extractToolResultText(content),
+                isError,
+            },
+        };
+        interceptorRegistry.notifyToolComplete(event, context);
+    }
     finalizeOrphanedToolCalls(sid, reason) {
         const pendingById = this.pendingAcpToolCalls.get(sid);
         if (!pendingById || pendingById.size === 0) {
@@ -359,11 +459,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,
             });
@@ -409,6 +510,7 @@ class SessionService {
         }
         await this.repository.markWorkspaceHasHadSessions(sessionContext.workspaceId);
         this.sessionToWorkspace.set(sessionId, sessionContext.workspaceId);
+        this.sessionToWorkingDir.set(sessionId, sessionContext.workingDir);
         const handlers = this.setupAcpEventHandler(sessionId);
         const shouldSuppressReplay = this.shouldSuppressReplayDuringAcpResume(sessionId, session);
         if (shouldSuppressReplay) {
@@ -435,6 +537,8 @@ class SessionService {
         }
         catch (error) {
             this.suppressAcpReplayForSession.delete(sessionId);
+            this.sessionToWorkspace.delete(sessionId);
+            this.sessionToWorkingDir.delete(sessionId);
             throw error;
         }
         await this.persistAcpConfigSnapshot(sessionId, {
@@ -489,15 +593,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;
@@ -510,7 +709,6 @@ class SessionService {
             updatedAt: new Date().toISOString(),
         });
         this.acpStreamState.delete(sessionId);
-        this.pendingAcpToolCalls.delete(sessionId);
         this.suppressAcpReplayForSession.delete(sessionId);
         const acpBridge = this.acpPermissionBridges.get(sessionId);
         if (acpBridge) {
@@ -531,14 +729,18 @@ 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);
+            this.sessionToWorkingDir.delete(sessionId);
             if (!stopClientFailed) {
                 const shouldCleanupTransientRatchetSession = options?.cleanupTransientRatchetSession ?? true;
                 await this.cleanupTransientRatchetOnStop(session, sessionId, shouldCleanupTransientRatchetSession);
@@ -550,6 +752,33 @@ class SessionService {
             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) {
         try {
             return await this.repository.getSessionById(sessionId);
@@ -691,7 +920,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
@@ -712,6 +949,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) {
@@ -795,6 +1072,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) {
@@ -846,12 +1146,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();
@@ -961,12 +1261,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: {
@@ -975,13 +1299,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'] },
@@ -994,28 +1319,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();
@@ -1036,7 +1367,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,
@@ -1044,44 +1374,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) {