@getpaseo/server 0.1.62 → 0.1.65

package/dist/server/server/agent/providers/acp-agent.js

@@ -3,8 +3,9 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { Readable, Writable } from "node:stream";
 import { ClientSideConnection, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
-import { applyProviderEnv, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
+import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
+import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "./provider-runner.js";
 import { findExecutable } from "../../../utils/executable.js";
 import { spawnProcess } from "../../../utils/spawn.js";
 const DEFAULT_ACP_CAPABILITIES = {
@@ -22,11 +23,16 @@ const ACP_CLIENT_CAPABILITIES = {
     },
     terminal: true,
 };
-const COPILOT_AUTOPILOT_MODE = "https://agentclientprotocol.com/protocol/session-modes#autopilot";
 // Suppress interactive auth side-effects (e.g. Gemini CLI opening a Google
 // sign-in URL in the browser) when probing an ACP agent for models/modes.
 // NO_BROWSER is honored by Gemini CLI; other ACP agents ignore it.
 const PROBE_ENV = { NO_BROWSER: "true" };
+function summarizeMalformedACPStdoutError(error) {
+    return {
+        type: error instanceof Error ? error.name : typeof error,
+        message: "ACP stdout line was not valid JSON",
+    };
+}
 export function createLoggedNdJsonStream(output, input, options) {
     const textEncoder = new TextEncoder();
     const textDecoder = new TextDecoder();
@@ -57,9 +63,8 @@ export function createLoggedNdJsonStream(output, input, options) {
                         }
                         catch (error) {
                             options.logger.warn({
-                                err: error,
+                                err: summarizeMalformedACPStdoutError(error),
                                 provider: options.provider,
-                                linePreview: trimmedLine.length > 500 ? `${trimmedLine.slice(0, 500)}...` : trimmedLine,
                             }, "ACP agent emitted non-JSON stdout; ignoring line");
                         }
                     }
@@ -94,6 +99,24 @@ export function mapACPUsage(usage) {
         cachedInputTokens: usage.cachedReadTokens ?? undefined,
     };
 }
+export function resolveACPModeSelection({ modeId, availableModes, configOptions, }) {
+    const configOption = findSelectConfigOption({ configOptions, category: "mode" });
+    return {
+        availableMode: availableModes.find((mode) => mode.id === modeId) ?? null,
+        configOption,
+        configChoice: findSelectConfigChoice({ option: configOption, value: modeId }),
+        hasAvailableModes: availableModes.length > 0,
+    };
+}
+export function resolveACPModelSelection({ modelId, availableModels, configOptions, }) {
+    const configOption = findSelectConfigOption({ configOptions, category: "model" });
+    return {
+        availableModel: availableModels?.find((model) => model.modelId === modelId) ?? null,
+        configOption,
+        configChoice: findSelectConfigChoice({ option: configOption, value: modelId }),
+        hasAvailableModels: Boolean(availableModels?.length),
+    };
+}
 export function deriveModesFromACP(fallbackModes, modeState, configOptions) {
     if (modeState?.availableModes?.length) {
         return {
@@ -105,8 +128,8 @@ export function deriveModesFromACP(fallbackModes, modeState, configOptions) {
             currentModeId: modeState.currentModeId ?? null,
         };
     }
-    const modeOption = configOptions?.find((option) => option.type === "select" && option.category === "mode");
-    if (modeOption?.type === "select") {
+    const modeOption = findSelectConfigOption({ configOptions, category: "mode" });
+    if (modeOption) {
         const flatOptions = flattenSelectOptions(modeOption.options);
         return {
             modes: flatOptions.map((option) => ({
@@ -257,10 +280,8 @@ export class ACPAgentClient {
             }
             const sessions = [];
             let cursor;
-            do {
-                const page = await probe.connection.listSessions({
-                    ...(cursor ? { cursor } : {}),
-                });
+            for (;;) {
+                const page = await probe.connection.listSessions(cursor ? { cursor } : {});
                 for (const session of page.sessions) {
                     sessions.push({
                         provider: this.provider,
@@ -282,7 +303,11 @@ export class ACPAgentClient {
                     });
                 }
                 cursor = page.nextCursor ?? null;
-            } while (cursor && (!options?.limit || sessions.length < options.limit));
+                if (!cursor)
+                    break;
+                if (options?.limit && sessions.length >= options.limit)
+                    break;
+            }
             return typeof options?.limit === "number" ? sessions.slice(0, options.limit) : sessions;
         }
         finally {
@@ -302,10 +327,10 @@ export class ACPAgentClient {
         const { command, args } = await this.resolveLaunchCommand();
         const child = spawnProcess(command, args, {
             cwd: process.cwd(),
-            env: {
-                ...applyProviderEnv(process.env, this.runtimeSettings),
-                ...(launchEnv ?? {}),
-            },
+            ...createProviderEnvSpec({
+                runtimeSettings: this.runtimeSettings,
+                overlays: [launchEnv],
+            }),
             stdio: ["pipe", "pipe", "pipe"],
         });
         const stderrChunks = [];
@@ -399,8 +424,8 @@ export class ACPAgentSession {
         this.agentCapabilities = null;
         this.sessionId = null;
         this.currentMode = null;
-        this.availableModels = [];
         this.currentModel = null;
+        this.availableModels = null;
         this.thinkingOptionId = null;
         this.currentTitle = null;
         this.lastActivityAt = null;
@@ -490,79 +515,18 @@ export class ACPAgentSession {
         await this.applyConfiguredOverrides();
     }
     async run(prompt, options) {
-        const timeline = [];
-        let finalText = "";
-        let usage;
-        let turnId = null;
-        let settled = false;
-        let resolveCompletion;
-        let rejectCompletion;
-        const buffered = [];
-        const completion = new Promise((resolve, reject) => {
-            resolveCompletion = resolve;
-            rejectCompletion = reject;
-        });
-        const processEvent = (event) => {
-            if (settled) {
-                return;
-            }
-            if (turnId && "turnId" in event && event.turnId && event.turnId !== turnId) {
-                return;
-            }
-            if (event.type === "timeline") {
-                timeline.push(event.item);
-                if (event.item.type === "assistant_message") {
-                    finalText = event.item.text.startsWith(finalText)
-                        ? event.item.text
-                        : `${finalText}${event.item.text}`;
-                }
-                return;
-            }
-            if (event.type === "turn_completed") {
-                usage = event.usage;
-                settled = true;
-                resolveCompletion();
-                return;
-            }
-            if (event.type === "turn_failed") {
-                settled = true;
-                rejectCompletion(new Error(event.error));
-                return;
-            }
-            if (event.type === "turn_canceled") {
-                settled = true;
-                resolveCompletion();
-            }
-        };
-        const unsubscribe = this.subscribe((event) => {
-            if (!turnId) {
-                buffered.push(event);
-                return;
-            }
-            processEvent(event);
+        const result = await runProviderTurn({
+            prompt,
+            runOptions: options,
+            startTurn: (p, o) => this.startTurn(p, o),
+            subscribe: (callback) => this.subscribe(callback),
+            getSessionId: () => this.sessionId ?? "",
+            reduceFinalText: appendOrReplaceGrowingAssistantMessage,
         });
-        try {
-            const started = await this.startTurn(prompt, options);
-            turnId = started.turnId;
-            for (const event of buffered) {
-                processEvent(event);
-            }
-            if (!settled) {
-                await completion;
-            }
-        }
-        finally {
-            unsubscribe();
-        }
         if (!this.sessionId) {
             throw new Error("ACP session did not expose a session id");
         }
-        return {
-            sessionId: this.sessionId,
-            finalText,
-            usage,
-            timeline,
-        };
+        return result;
     }
     async startTurn(prompt, _options) {
         if (this.closed) {
@@ -589,6 +553,7 @@ export class ACPAgentSession {
         })
             .then((response) => {
             this.handlePromptResponse(response, turnId);
+            return;
         })
             .catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
@@ -627,17 +592,7 @@ export class ACPAgentSession {
         }
     }
     async getRuntimeInfo() {
-        return {
-            provider: this.provider,
-            sessionId: this.sessionId,
-            model: this.currentModel,
-            thinkingOptionId: this.thinkingOptionId,
-            modeId: this.currentMode,
-            extra: {
-                title: this.currentTitle,
-                updatedAt: this.lastActivityAt,
-            },
-        };
+        return this.runtimeInfo();
     }
     async getAvailableModes() {
         return [...this.availableModes];
@@ -699,25 +654,64 @@ export class ACPAgentSession {
         if (!this.connection || !this.sessionId) {
             throw new Error("ACP session not initialized");
         }
-        const modeExists = this.availableModes.some((mode) => mode.id === modeId);
-        if (!modeExists && this.availableModes.length > 0) {
-            throw new Error(`Unknown ${this.provider} mode '${modeId}'`);
+        const selection = resolveACPModeSelection({
+            modeId,
+            availableModes: this.availableModes,
+            configOptions: this.configOptions,
+        });
+        await this.setModeWithSelection({ modeId, selection });
+    }
+    // Mode/model selection updates stay after ACP RPC success; this intentionally diverges from Zed's optimistic rollback path (acp.rs:3080-3104).
+    async setModeWithSelection({ modeId, selection, }) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
         }
-        if (this.availableModes.length > 0) {
+        if (selection.hasAvailableModes) {
+            if (!selection.availableMode) {
+                this.warnInvalidSelection(modeId, `is not valid ${this.provider} mode. Available options: ${this.availableModes
+                    .map((mode) => mode.id)
+                    .join(", ")}`);
+                return;
+            }
             await this.connection.setSessionMode({ sessionId: this.sessionId, modeId });
             this.currentMode = modeId;
+            this.pushEvent({
+                type: "mode_changed",
+                provider: this.provider,
+                currentModeId: this.currentMode,
+                availableModes: [...this.availableModes],
+            });
             return;
         }
-        const modeOption = this.getSelectConfigOption("mode");
+        const modeOption = selection.configOption;
         if (!modeOption) {
             throw new Error(`${this.provider} does not expose ACP mode switching`);
         }
-        await this.connection.setSessionConfigOption({
+        if (!selection.configChoice) {
+            this.warnInvalidSelection(modeId, `is not valid ${this.provider} mode config option. Available options: ${flattenSelectOptions(modeOption.options)
+                .map((option) => option.value)
+                .join(", ")}`);
+            return;
+        }
+        const response = await this.connection.setSessionConfigOption({
             sessionId: this.sessionId,
             configId: modeOption.id,
             value: modeId,
         });
-        this.currentMode = modeId;
+        this.currentMode = this.applyConfigOptionResponse({
+            response,
+            configId: modeOption.id,
+            category: "mode",
+            requestedValue: modeId,
+            label: "mode",
+        });
+        this.availableModes = deriveModesFromACP(this.defaultModes, null, this.configOptions).modes;
+        this.pushEvent({
+            type: "mode_changed",
+            provider: this.provider,
+            currentModeId: this.currentMode,
+            availableModes: [...this.availableModes],
+        });
     }
     async setModel(modelId) {
         if (!this.connection || !this.sessionId) {
@@ -727,33 +721,71 @@ export class ACPAgentSession {
             this.currentModel = null;
             return;
         }
-        const modelExists = this.availableModels.some((model) => model.id === modelId);
-        if (!modelExists && this.availableModels.length > 0) {
-            throw new Error(`Unknown ${this.provider} model '${modelId}'`);
+        const selection = resolveACPModelSelection({
+            modelId,
+            availableModels: this.availableModels,
+            configOptions: this.configOptions,
+        });
+        await this.setModelWithSelection({ modelId, selection });
+    }
+    async setModelWithSelection({ modelId, selection, }) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
         }
-        if ("unstable_setSessionModel" in this.connection) {
+        if (selection.hasAvailableModels) {
+            if (!selection.availableModel) {
+                this.warnInvalidSelection(modelId, `is not a valid ${this.provider} model. Available options: ${this.availableModels
+                    ?.map((model) => model.modelId)
+                    .join(", ")}`);
+                return;
+            }
+            if (typeof this.connection.unstable_setSessionModel !== "function") {
+                throw new Error(`${this.provider} does not expose ACP model selection`);
+            }
             try {
                 await this.connection.unstable_setSessionModel({
                     sessionId: this.sessionId,
                     modelId,
                 });
                 this.currentModel = modelId;
+                this.pushEvent({
+                    type: "model_changed",
+                    provider: this.provider,
+                    runtimeInfo: this.runtimeInfo(),
+                });
                 return;
             }
             catch {
                 // Fall through to config option path.
             }
         }
-        const modelOption = this.getSelectConfigOption("model");
+        const modelOption = selection.configOption;
         if (!modelOption) {
             throw new Error(`${this.provider} does not expose ACP model selection`);
         }
-        await this.connection.setSessionConfigOption({
+        if (!selection.configChoice) {
+            this.warnInvalidSelection(modelId, `is not a valid ${this.provider} model config option. Available options: ${flattenSelectOptions(modelOption.options)
+                .map((option) => option.value)
+                .join(", ")}`);
+            return;
+        }
+        const response = await this.connection.setSessionConfigOption({
             sessionId: this.sessionId,
             configId: modelOption.id,
             value: modelId,
         });
-        this.currentModel = modelId;
+        this.currentModel = this.applyConfigOptionResponse({
+            response,
+            configId: modelOption.id,
+            category: "model",
+            requestedValue: modelId,
+            label: "model",
+        });
+        this.pushEvent({
+            type: "model_changed",
+            provider: this.provider,
+            runtimeInfo: this.runtimeInfo(),
+        });
     }
     async setThinkingOption(thinkingOptionId) {
         if (!this.connection || !this.sessionId) {
@@ -766,18 +798,50 @@ export class ACPAgentSession {
         if (this.thinkingOptionWriter) {
             await this.thinkingOptionWriter(this.connection, this.sessionId, thinkingOptionId);
             this.thinkingOptionId = thinkingOptionId;
+            this.pushEvent({
+                type: "thinking_option_changed",
+                provider: this.provider,
+                thinkingOptionId: this.thinkingOptionId,
+            });
             return;
         }
-        const option = this.getSelectConfigOption("thought_level");
+        const option = findSelectConfigOption({
+            configOptions: this.configOptions,
+            category: "thought_level",
+        });
         if (!option) {
             throw new Error(`${this.provider} does not expose ACP thought-level selection`);
         }
-        await this.connection.setSessionConfigOption({
+        const response = await this.connection.setSessionConfigOption({
             sessionId: this.sessionId,
             configId: option.id,
             value: thinkingOptionId,
         });
-        this.thinkingOptionId = thinkingOptionId;
+        this.thinkingOptionId = this.applyConfigOptionResponse({
+            response,
+            configId: option.id,
+            category: "thought_level",
+            requestedValue: thinkingOptionId,
+            label: "thought-level",
+        });
+        this.pushEvent({
+            type: "thinking_option_changed",
+            provider: this.provider,
+            thinkingOptionId: this.thinkingOptionId,
+        });
+    }
+    applyConfigOptionResponse({ response, configId, category, requestedValue, label, }) {
+        this.configOptions = response.configOptions;
+        const responseOption = findSelectConfigOption({
+            configOptions: response.configOptions,
+            category,
+            id: configId,
+        });
+        if (responseOption?.currentValue != null) {
+            return responseOption.currentValue;
+        }
+        this.logger.warn({ configId, value: requestedValue }, `ACP setSessionConfigOption response did not include the requested ${label} option currentValue; using requested value`);
+        return requestedValue;
     }
     getPendingPermissions() {
         return Array.from(this.pendingPermissions.values(), (entry) => entry.request);
@@ -874,17 +938,7 @@ export class ACPAgentSession {
         this.activeForegroundTurnId = null;
     }
     async requestPermission(params) {
-        if (shouldAutoApprovePermissionRequest(this.provider, this.currentMode)) {
-            const selectedOption = selectPermissionOption(params.options, { behavior: "allow" });
-            return selectedOption
-                ? {
-                    outcome: {
-                        outcome: "selected",
-                        optionId: selectedOption.optionId,
-                    },
-                }
-                : { outcome: { outcome: "cancelled" } };
-        }
+        // Match Zed acp.rs:3189-3220 — pure pass-through. Accepted UX regression: Copilot Autopilot will now prompt the user for every tool request.
         const requestId = randomUUID();
         let toolSnapshot = this.toolCalls.get(params.toolCall.toolCallId) ??
             mergeToolSnapshot(params.toolCall.toolCallId, params.toolCall);
@@ -946,10 +1000,10 @@ export class ACPAgentSession {
         const env = Object.fromEntries((params.env ?? []).map((entry) => [entry.name, entry.value]));
         const child = spawnProcess(params.command, params.args ?? [], {
             cwd: params.cwd ?? this.config.cwd,
-            env: {
-                ...applyProviderEnv(process.env, this.runtimeSettings),
-                ...env,
-            },
+            ...createProviderEnvSpec({
+                runtimeSettings: this.runtimeSettings,
+                overlays: [env],
+            }),
             stdio: ["ignore", "pipe", "pipe"],
         });
         let resolveExit;
@@ -1018,10 +1072,10 @@ export class ACPAgentSession {
         const args = [...prefix.args, ...this.defaultCommand.slice(1)];
         const child = spawnProcess(command, args, {
             cwd: this.config.cwd,
-            env: {
-                ...applyProviderEnv(process.env, this.runtimeSettings),
-                ...(this.launchEnv ?? {}),
-            },
+            ...createProviderEnvSpec({
+                runtimeSettings: this.runtimeSettings,
+                overlays: [this.launchEnv],
+            }),
             stdio: ["pipe", "pipe", "pipe"],
         });
         const stderrChunks = [];
@@ -1062,24 +1116,39 @@ export class ACPAgentSession {
         this.configOptions = transformed.configOptions ?? [];
         const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, this.configOptions);
         this.availableModes = modeInfo.modes;
-        this.availableModels = this.deriveAvailableModels(transformed.models);
         this.currentMode = modeInfo.currentModeId ?? this.currentMode;
+        this.availableModels = transformed.models?.availableModels ?? null;
         this.currentModel =
             transformed.models?.currentModelId ?? deriveCurrentConfigValue(this.configOptions, "model");
         this.thinkingOptionId =
             deriveCurrentConfigValue(this.configOptions, "thought_level") ?? this.thinkingOptionId;
     }
     async applyConfiguredOverrides() {
-        if (this.config.modeId && this.config.modeId !== this.currentMode) {
-            await this.setMode(this.config.modeId);
-        }
-        if (this.config.model && this.config.model !== this.currentModel) {
-            await this.setModel(this.config.model);
+        const configuredModeId = this.config.modeId;
+        if (configuredModeId && configuredModeId !== this.currentMode) {
+            const selection = resolveACPModeSelection({
+                modeId: configuredModeId,
+                availableModes: this.availableModes,
+                configOptions: this.configOptions,
+            });
+            await this.setModeWithSelection({ modeId: configuredModeId, selection });
+        }
+        const configuredModelId = this.config.model;
+        if (configuredModelId && configuredModelId !== this.currentModel) {
+            const selection = resolveACPModelSelection({
+                modelId: configuredModelId,
+                availableModels: this.availableModels,
+                configOptions: this.configOptions,
+            });
+            await this.setModelWithSelection({ modelId: configuredModelId, selection });
         }
         if (this.config.thinkingOptionId && this.config.thinkingOptionId !== this.thinkingOptionId) {
             await this.setThinkingOption(this.config.thinkingOptionId);
         }
     }
+    warnInvalidSelection(value, message) {
+        this.logger.warn(value, message);
+    }
     translateSessionUpdate(update) {
         switch (update.sessionUpdate) {
             case "user_message_chunk": {
@@ -1104,31 +1173,24 @@ export class ACPAgentSession {
                 const item = this.createMessageTimelineItem("reasoning", update);
                 return item ? [this.wrapTimeline(item)] : [];
             }
-            case "tool_call": {
-                let snapshot = mergeToolSnapshot(update.toolCallId, update);
-                if (this.toolSnapshotTransformer) {
-                    snapshot = this.toolSnapshotTransformer(snapshot);
-                }
-                this.toolCalls.set(update.toolCallId, snapshot);
-                return [this.wrapTimeline(mapToolSnapshotToTimeline(snapshot, this.terminalEntries))];
-            }
-            case "tool_call_update": {
-                const previous = this.toolCalls.get(update.toolCallId);
-                let snapshot = mergeToolSnapshot(update.toolCallId, update, previous);
-                if (this.toolSnapshotTransformer) {
-                    snapshot = this.toolSnapshotTransformer(snapshot);
-                }
-                this.toolCalls.set(update.toolCallId, snapshot);
-                return [this.wrapTimeline(mapToolSnapshotToTimeline(snapshot, this.terminalEntries))];
-            }
+            case "tool_call":
+                return this.handleToolCallUpdate(update.toolCallId, update, undefined);
+            case "tool_call_update":
+                return this.handleToolCallUpdate(update.toolCallId, update, this.toolCalls.get(update.toolCallId));
             case "plan":
                 return [this.wrapTimeline(mapPlanToTimeline(update))];
             case "current_mode_update":
                 this.handleCurrentModeUpdate(update);
-                return [];
+                return [
+                    {
+                        type: "mode_changed",
+                        provider: this.provider,
+                        currentModeId: this.currentMode,
+                        availableModes: [...this.availableModes],
+                    },
+                ];
             case "config_option_update":
-                this.handleConfigOptionUpdate(update);
-                return [];
+                return this.handleConfigOptionUpdate(update);
             case "session_info_update":
                 this.handleSessionInfoUpdate(update);
                 return [];
@@ -1147,6 +1209,14 @@ export class ACPAgentSession {
                 return [];
         }
     }
+    handleToolCallUpdate(toolCallId, update, previous) {
+        let snapshot = mergeToolSnapshot(toolCallId, update, previous);
+        if (this.toolSnapshotTransformer) {
+            snapshot = this.toolSnapshotTransformer(snapshot);
+        }
+        this.toolCalls.set(toolCallId, snapshot);
+        return [this.wrapTimeline(mapToolSnapshotToTimeline(snapshot, this.terminalEntries))];
+    }
     createMessageTimelineItem(type, update) {
         const chunkText = contentBlockToText(update.content);
         if (!chunkText) {
@@ -1170,16 +1240,37 @@ export class ACPAgentSession {
     handleConfigOptionUpdate(update) {
         this.configOptions = update.configOptions;
         const modeInfo = deriveModesFromACP(this.defaultModes, null, this.configOptions);
+        const nextMode = modeInfo.currentModeId;
+        const nextModel = deriveCurrentConfigValue(this.configOptions, "model");
+        const nextThinkingOptionId = deriveCurrentConfigValue(this.configOptions, "thought_level");
         this.availableModes = modeInfo.modes;
-        this.availableModels = this.deriveAvailableModels(null);
-        this.currentMode = modeInfo.currentModeId ?? this.currentMode;
-        this.currentModel = deriveCurrentConfigValue(this.configOptions, "model") ?? this.currentModel;
-        this.thinkingOptionId =
-            deriveCurrentConfigValue(this.configOptions, "thought_level") ?? this.thinkingOptionId;
-    }
-    deriveAvailableModels(models) {
-        const availableModels = deriveModelDefinitionsFromACP(this.provider, models, this.configOptions);
-        return this.modelTransformer ? this.modelTransformer(availableModels) : availableModels;
+        this.currentMode = nextMode ?? this.currentMode;
+        this.currentModel = nextModel ?? this.currentModel;
+        this.thinkingOptionId = nextThinkingOptionId ?? this.thinkingOptionId;
+        const events = [];
+        if (nextMode !== null) {
+            events.push({
+                type: "mode_changed",
+                provider: this.provider,
+                currentModeId: this.currentMode,
+                availableModes: [...this.availableModes],
+            });
+        }
+        if (nextModel !== null) {
+            events.push({
+                type: "model_changed",
+                provider: this.provider,
+                runtimeInfo: this.runtimeInfo(),
+            });
+        }
+        if (nextThinkingOptionId !== null) {
+            events.push({
+                type: "thinking_option_changed",
+                provider: this.provider,
+                thinkingOptionId: this.thinkingOptionId,
+            });
+        }
+        return events;
     }
     handleSessionInfoUpdate(update) {
         if ("title" in update) {
@@ -1231,6 +1322,19 @@ export class ACPAgentSession {
             subscriber(event);
         }
     }
+    runtimeInfo() {
+        return {
+            provider: this.provider,
+            sessionId: this.sessionId,
+            model: this.currentModel,
+            thinkingOptionId: this.thinkingOptionId,
+            modeId: this.currentMode,
+            extra: {
+                title: this.currentTitle,
+                updatedAt: this.lastActivityAt,
+            },
+        };
+    }
     finishTurn(event) {
         this.activeForegroundTurnId = null;
         this.suppressUserEchoMessageId = null;
@@ -1270,10 +1374,6 @@ export class ACPAgentSession {
         }
         return parts.length > 0 ? parts.join(" | ") : undefined;
     }
-    getSelectConfigOption(category) {
-        const option = this.configOptions.find((entry) => entry.type === "select" && entry.category === category);
-        return option ?? null;
-    }
     getTerminalEntry(terminalId) {
         const entry = this.terminalEntries.get(terminalId);
         if (!entry) {
@@ -1282,6 +1382,16 @@ export class ACPAgentSession {
         return entry;
     }
 }
+function findSelectConfigOption({ configOptions, category, id, }) {
+    const option = configOptions?.find((entry) => entry.type === "select" && entry.category === category && (!id || entry.id === id));
+    return option ?? null;
+}
+function findSelectConfigChoice({ option, value, }) {
+    if (!option) {
+        return null;
+    }
+    return flattenSelectOptions(option.options).find((choice) => choice.value === value) ?? null;
+}
 function flattenSelectOptions(options) {
     const flattened = [];
     for (const option of options) {
@@ -1296,7 +1406,7 @@ function flattenSelectOptions(options) {
     return flattened;
 }
 function deriveSelectorOptions(configOptions, category) {
-    const option = configOptions?.find((entry) => entry.type === "select" && entry.category === category);
+    const option = findSelectConfigOption({ configOptions, category });
     if (!option) {
         return [];
     }
@@ -1354,19 +1464,21 @@ function toACPContentBlocks(prompt) {
     if (typeof prompt === "string") {
         return [{ type: "text", text: prompt }];
     }
-    return prompt.map((block) => {
-        if (block.type === "text") {
-            return { type: "text", text: block.text };
-        }
-        if (block.type === "github_pr" || block.type === "github_issue") {
-            return { type: "text", text: renderPromptAttachmentAsText(block) };
+    const contentBlocks = [];
+    for (const block of prompt) {
+        switch (block.type) {
+            case "text":
+                contentBlocks.push({ type: "text", text: block.text });
+                break;
+            case "image":
+                contentBlocks.push({ type: "image", data: block.data, mimeType: block.mimeType });
+                break;
+            default:
+                contentBlocks.push({ type: "text", text: renderPromptAttachmentAsText(block) });
+                break;
         }
-        return {
-            type: "image",
-            data: block.data,
-            mimeType: block.mimeType,
-        };
-    });
+    }
+    return contentBlocks;
 }
 function extractPromptText(prompt) {
     if (typeof prompt === "string") {
@@ -1395,18 +1507,25 @@ function contentBlockToText(content) {
             return "";
     }
 }
+function coalesceDefined(next, previous, fallback) {
+    if (next !== undefined) {
+        return next;
+    }
+    if (previous !== undefined) {
+        return previous;
+    }
+    return fallback;
+}
 function mergeToolSnapshot(toolCallId, update, previous) {
-    const isFull = "title" in update && typeof update.title === "string";
     return {
         toolCallId,
         title: (update.title ?? previous?.title ?? toolCallId),
         kind: update.kind ?? previous?.kind ?? null,
         status: update.status ?? previous?.status ?? null,
-        content: update.content !== undefined ? update.content : (previous?.content ?? null),
-        locations: update.locations !== undefined ? update.locations : (previous?.locations ?? null),
+        content: coalesceDefined(update.content, previous?.content, null),
+        locations: coalesceDefined(update.locations, previous?.locations, null),
         rawInput: update.rawInput !== undefined ? update.rawInput : previous?.rawInput,
         rawOutput: update.rawOutput !== undefined ? update.rawOutput : previous?.rawOutput,
-        ...(isFull ? {} : {}),
     };
 }
 function mapPlanToTimeline(plan) {
@@ -1464,98 +1583,125 @@ function mapToolStatus(status) {
     }
 }
 function mapToolDetail(snapshot, terminals) {
-    const firstLocation = snapshot.locations?.[0]?.path;
-    const textContent = extractToolText(snapshot.content);
-    const diffContent = extractDiffContent(snapshot.content);
-    const terminalContent = extractTerminalContent(snapshot.content, terminals);
-    const rawInput = readRecord(snapshot.rawInput);
-    const rawOutput = readRecord(snapshot.rawOutput);
+    const context = {
+        snapshot,
+        firstLocation: snapshot.locations?.[0]?.path,
+        textContent: extractToolText(snapshot.content),
+        diffContent: extractDiffContent(snapshot.content),
+        terminalContent: extractTerminalContent(snapshot.content, terminals),
+        rawInput: readRecord(snapshot.rawInput),
+        rawOutput: readRecord(snapshot.rawOutput),
+    };
     switch (snapshot.kind) {
         case "read":
-            return {
-                type: "read",
-                filePath: firstLocation ?? readString(rawInput, ["path", "filePath", "file"]) ?? snapshot.title,
-                content: textContent ?? readString(rawOutput, ["content", "text"]),
-                offset: readNumber(rawInput, ["offset", "line"]),
-                limit: readNumber(rawInput, ["limit"]),
-            };
+            return buildReadToolDetail(context);
         case "edit":
         case "delete":
-            return {
-                type: "edit",
-                filePath: firstLocation ?? readString(rawInput, ["path", "filePath", "file"]) ?? snapshot.title,
-                oldString: diffContent?.oldText ?? readString(rawInput, ["oldText", "oldString"]),
-                newString: snapshot.kind === "delete"
-                    ? ""
-                    : (diffContent?.newText ?? readString(rawInput, ["newText", "newString"])),
-                unifiedDiff: textContent ?? undefined,
-            };
+            return buildEditToolDetail(context);
         case "search":
-            return {
-                type: "search",
-                query: readString(rawInput, ["query", "pattern"]) ?? snapshot.title,
-                toolName: "search",
-                content: textContent ?? readString(rawOutput, ["content", "text"]),
-                filePaths: snapshot.locations?.map((location) => location.path),
-            };
+            return buildSearchAcpToolDetail(context);
         case "execute":
-            return {
-                type: "shell",
-                command: terminalContent?.command ??
-                    buildShellCommand(rawInput) ??
-                    readString(rawInput, ["command"]) ??
-                    snapshot.title,
-                cwd: terminalContent?.cwd ?? readString(rawInput, ["cwd"]),
-                output: terminalContent?.output ?? textContent ?? readString(rawOutput, ["output", "text"]),
-                exitCode: terminalContent?.exitCode ?? readNumber(rawOutput, ["exitCode"]),
-            };
+            return buildShellToolDetail(context);
         case "fetch":
-            return {
-                type: "fetch",
-                url: readString(rawInput, ["url"]) ?? snapshot.title,
-                prompt: readString(rawInput, ["prompt"]),
-                result: textContent ?? readString(rawOutput, ["result", "text", "content"]),
-                code: readNumber(rawOutput, ["status", "code"]),
-            };
+            return buildFetchToolDetail(context);
         case "think":
             return {
                 type: "plain_text",
                 label: snapshot.title,
                 icon: "brain",
-                text: textContent ?? stringifyUnknown(snapshot.rawOutput),
+                text: context.textContent ?? stringifyUnknown(snapshot.rawOutput),
             };
         case "switch_mode":
             return {
                 type: "plain_text",
                 label: snapshot.title,
                 icon: "sparkles",
-                text: textContent ?? stringifyUnknown(snapshot.rawInput),
+                text: context.textContent ?? stringifyUnknown(snapshot.rawInput),
             };
         default:
-            if (terminalContent) {
-                return {
-                    type: "shell",
-                    command: terminalContent.command ?? snapshot.title,
-                    cwd: terminalContent.cwd,
-                    output: terminalContent.output,
-                    exitCode: terminalContent.exitCode,
-                };
-            }
-            if (textContent) {
-                return {
-                    type: "plain_text",
-                    label: snapshot.title,
-                    text: textContent,
-                    icon: "wrench",
-                };
-            }
-            return {
-                type: "unknown",
-                input: snapshot.rawInput ?? null,
-                output: snapshot.rawOutput ?? null,
-            };
+            return buildDefaultToolDetail(context);
     }
 }
+function buildReadToolDetail(context) {
+    const { snapshot, firstLocation, textContent, rawInput, rawOutput } = context;
+    return {
+        type: "read",
+        filePath: firstLocation ?? readString(rawInput, ["path", "filePath", "file"]) ?? snapshot.title,
+        content: textContent ?? readString(rawOutput, ["content", "text"]),
+        offset: readNumber(rawInput, ["offset", "line"]),
+        limit: readNumber(rawInput, ["limit"]),
+    };
+}
+function buildEditToolDetail(context) {
+    const { snapshot, firstLocation, textContent, diffContent, rawInput } = context;
+    return {
+        type: "edit",
+        filePath: firstLocation ?? readString(rawInput, ["path", "filePath", "file"]) ?? snapshot.title,
+        oldString: diffContent?.oldText ?? readString(rawInput, ["oldText", "oldString"]),
+        newString: snapshot.kind === "delete"
+            ? ""
+            : (diffContent?.newText ?? readString(rawInput, ["newText", "newString"])),
+        unifiedDiff: textContent ?? undefined,
+    };
+}
+function buildSearchAcpToolDetail(context) {
+    const { snapshot, textContent, rawInput, rawOutput } = context;
+    return {
+        type: "search",
+        query: readString(rawInput, ["query", "pattern"]) ?? snapshot.title,
+        toolName: "search",
+        content: textContent ?? readString(rawOutput, ["content", "text"]),
+        filePaths: snapshot.locations?.map((location) => location.path),
+    };
+}
+function buildShellToolDetail(context) {
+    const { snapshot, textContent, terminalContent, rawInput, rawOutput } = context;
+    return {
+        type: "shell",
+        command: terminalContent?.command ??
+            buildShellCommand(rawInput) ??
+            readString(rawInput, ["command"]) ??
+            snapshot.title,
+        cwd: terminalContent?.cwd ?? readString(rawInput, ["cwd"]),
+        output: terminalContent?.output ?? textContent ?? readString(rawOutput, ["output", "text"]),
+        exitCode: terminalContent?.exitCode ?? readNumber(rawOutput, ["exitCode"]),
+    };
+}
+function buildFetchToolDetail(context) {
+    const { snapshot, textContent, rawInput, rawOutput } = context;
+    return {
+        type: "fetch",
+        url: readString(rawInput, ["url"]) ?? snapshot.title,
+        prompt: readString(rawInput, ["prompt"]),
+        result: textContent ?? readString(rawOutput, ["result", "text", "content"]),
+        code: readNumber(rawOutput, ["status", "code"]),
+    };
+}
+function buildDefaultToolDetail(context) {
+    const { snapshot, textContent, terminalContent } = context;
+    if (terminalContent) {
+        return {
+            type: "shell",
+            command: terminalContent.command ?? snapshot.title,
+            cwd: terminalContent.cwd,
+            output: terminalContent.output,
+            exitCode: terminalContent.exitCode,
+        };
+    }
+    if (textContent) {
+        return {
+            type: "plain_text",
+            label: snapshot.title,
+            text: textContent,
+            icon: "wrench",
+        };
+    }
+    return {
+        type: "unknown",
+        input: snapshot.rawInput ?? null,
+        output: snapshot.rawOutput ?? null,
+    };
+}
 function extractToolText(content) {
     if (!content) {
         return undefined;
@@ -1605,9 +1751,6 @@ function mapPermissionRequest(provider, requestId, params, snapshot) {
         },
     };
 }
-function shouldAutoApprovePermissionRequest(provider, currentMode) {
-    return provider === "copilot" && currentMode === COPILOT_AUTOPILOT_MODE;
-}
 function selectPermissionOption(options, response) {
     const order = response.behavior === "allow"
         ? ["allow_once", "allow_always"]