@getpaseo/server 0.1.63 → 0.1.65

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

@@ -5,6 +5,7 @@ import { Readable, Writable } from "node:stream";
 import { ClientSideConnection, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
 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,7 +23,6 @@ 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.
@@ -99,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 {
@@ -110,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) => ({
@@ -407,6 +425,7 @@ export class ACPAgentSession {
         this.sessionId = null;
         this.currentMode = null;
         this.currentModel = null;
+        this.availableModels = null;
         this.thinkingOptionId = null;
         this.currentTitle = null;
         this.lastActivityAt = null;
@@ -496,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 result = await runProviderTurn({
+            prompt,
+            runOptions: options,
+            startTurn: (p, o) => this.startTurn(p, o),
+            subscribe: (callback) => this.subscribe(callback),
+            getSessionId: () => this.sessionId ?? "",
+            reduceFinalText: appendOrReplaceGrowingAssistantMessage,
         });
-        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);
-        });
-        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) {
@@ -634,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];
@@ -706,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) {
@@ -734,29 +721,71 @@ export class ACPAgentSession {
             this.currentModel = null;
             return;
         }
-        if ("unstable_setSessionModel" in this.connection) {
+        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 (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) {
@@ -769,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);
@@ -877,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);
@@ -1066,22 +1117,38 @@ export class ACPAgentSession {
         const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, this.configOptions);
         this.availableModes = modeInfo.modes;
         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": {
@@ -1114,10 +1181,16 @@ export class ACPAgentSession {
                 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 [];
@@ -1167,11 +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.currentMode = modeInfo.currentModeId ?? this.currentMode;
-        this.currentModel = deriveCurrentConfigValue(this.configOptions, "model") ?? this.currentModel;
-        this.thinkingOptionId =
-            deriveCurrentConfigValue(this.configOptions, "thought_level") ?? this.thinkingOptionId;
+        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) {
@@ -1223,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;
@@ -1262,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) {
@@ -1274,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) {
@@ -1288,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 [];
     }
@@ -1346,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") {
@@ -1631,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"]