@getpaseo/server 0.1.99 → 0.1.101

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

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
+import { homedir } from "node:os";
 import path from "node:path";
 import { Readable, Writable } from "node:stream";
 import { terminateWithTreeKill } from "../../../utils/tree-kill.js";
@@ -10,6 +11,8 @@ import { checkProviderLaunchAvailable, createProviderEnvSpec, resolveProviderLau
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "./provider-runner.js";
 import { platformShell, spawnProcess } from "../../../utils/spawn.js";
+import { toDiagnosticErrorMessage, truncateForDiagnostic, } from "./diagnostic-utils.js";
+import { withTimeout } from "../../../utils/promise-timeout.js";
 function assertChildWithPipes(child) {
     if (!child.stdin || !child.stdout || !child.stderr) {
         throw new Error("Child process did not expose stdio pipes");
@@ -70,6 +73,19 @@ function resolveTerminalCommand(command, args) {
     const shell = platformShell();
     return { command: shell.command, args: [...shell.flag, command] };
 }
+function formatDurationMs(startedAt) {
+    return `${Math.max(0, Date.now() - startedAt)}ms`;
+}
+function pushACPStderrRow(rows, stderrChunks) {
+    const stderr = stderrChunks.join("").trim();
+    if (!stderr) {
+        return;
+    }
+    rows.push({
+        label: "ACP stderr",
+        value: truncateForDiagnostic(stderr),
+    });
+}
 export const DEFAULT_ACP_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -96,6 +112,8 @@ const ACP_CLIENT_CAPABILITIES = {
 // 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" };
+const ACP_CATALOG_TIMEOUT_MS = 60000;
+const ACP_DIAGNOSTIC_PHASE_TIMEOUT_MS = 20000;
 function summarizeMalformedACPStdoutError(error) {
     return {
         type: error instanceof Error ? error.name : typeof error,
@@ -257,6 +275,26 @@ export function deriveModelDefinitionsFromACP(provider, models, configOptions) {
         metadata: option.metadata,
     }));
 }
+export function deriveFeaturesFromACP(configOptions, featureOptions) {
+    return featureOptions.flatMap((featureOption) => {
+        const option = findSelectConfigFeatureOption(configOptions, featureOption);
+        if (!option) {
+            return [];
+        }
+        return [
+            {
+                type: "select",
+                id: featureOption.id,
+                label: featureOption.label,
+                description: featureOption.description,
+                tooltip: featureOption.tooltip,
+                icon: featureOption.icon,
+                value: option.currentValue ?? null,
+                options: deriveConfigFeatureSelectOptions(option, featureOption),
+            },
+        ];
+    });
+}
 export class ACPAgentClient {
     constructor(options) {
         this.provider = options.provider;
@@ -272,6 +310,7 @@ export class ACPAgentClient {
         this.modelTransformer = options.modelTransformer;
         this.sessionResponseTransformer = options.sessionResponseTransformer;
         this.configOptionsTransformer = options.configOptionsTransformer;
+        this.configFeatureOptions = options.configFeatureOptions ?? [];
         this.modeIdTransformer = options.modeIdTransformer;
         this.toolSnapshotTransformer = options.toolSnapshotTransformer;
         this.providerModeWriter = options.providerModeWriter;
@@ -291,6 +330,7 @@ export class ACPAgentClient {
             modelTransformer: this.modelTransformer,
             sessionResponseTransformer: this.sessionResponseTransformer,
             configOptionsTransformer: this.configOptionsTransformer,
+            configFeatureOptions: this.configFeatureOptions,
             modeIdTransformer: this.modeIdTransformer,
             toolSnapshotTransformer: this.toolSnapshotTransformer,
             providerModeWriter: this.providerModeWriter,
@@ -329,6 +369,7 @@ export class ACPAgentClient {
             modelTransformer: this.modelTransformer,
             sessionResponseTransformer: this.sessionResponseTransformer,
             configOptionsTransformer: this.configOptionsTransformer,
+            configFeatureOptions: this.configFeatureOptions,
             modeIdTransformer: this.modeIdTransformer,
             toolSnapshotTransformer: this.toolSnapshotTransformer,
             providerModeWriter: this.providerModeWriter,
@@ -346,19 +387,50 @@ export class ACPAgentClient {
     }
     async fetchCatalog(options) {
         const { cwd } = options;
+        const timeoutMs = options.timeoutMs ?? ACP_CATALOG_TIMEOUT_MS;
+        let probe = null;
+        try {
+            const catalogProbe = (async () => {
+                const initializedProbe = await this.spawnProcess(PROBE_ENV, {
+                    initializeTimeoutMs: timeoutMs,
+                    onSpawned: (spawned) => {
+                        probe = spawned;
+                    },
+                });
+                probe = initializedProbe;
+                const response = await this.runACPRequest(() => initializedProbe.connection.newSession({
+                    cwd,
+                    mcpServers: [],
+                }));
+                const transformed = this.transformSessionResponse(response);
+                const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
+                const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
+                return {
+                    models: this.modelTransformer ? this.modelTransformer(models) : models,
+                    modes: modeInfo.modes,
+                };
+            })();
+            return await withTimeout(catalogProbe, timeoutMs, `ACP catalog probe timed out after ${timeoutMs}ms`);
+        }
+        finally {
+            if (probe) {
+                await this.closeProbe(probe);
+            }
+        }
+    }
+    async listFeatures(config) {
+        if (this.configFeatureOptions.length === 0) {
+            return [];
+        }
+        this.assertProvider(config);
         const probe = await this.spawnProcess(PROBE_ENV);
         try {
             const response = await this.runACPRequest(() => probe.connection.newSession({
-                cwd,
+                cwd: config.cwd,
                 mcpServers: [],
             }));
             const transformed = this.transformSessionResponse(response);
-            const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
-            const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
-            return {
-                models: this.modelTransformer ? this.modelTransformer(models) : models,
-                modes: modeInfo.modes,
-            };
+            return deriveFeaturesFromACP(transformed.configOptions, this.configFeatureOptions);
         }
         finally {
             await this.closeProbe(probe);
@@ -420,6 +492,28 @@ export class ACPAgentClient {
         }
     }
     async spawnProcess(launchEnv, options) {
+        const transport = await this.spawnTransport(launchEnv);
+        const probe = {
+            child: transport.child,
+            connection: transport.connection,
+            stderrChunks: transport.stderrChunks,
+        };
+        options?.onSpawned?.(probe);
+        try {
+            const initialize = await this.initializeTransport(transport, options?.initializeTimeoutMs);
+            const initializedProbe = {
+                ...probe,
+                initialize,
+            };
+            probe.initialize = initialize;
+            return initializedProbe;
+        }
+        catch (error) {
+            await terminateChildProcess(transport.child, 2000, this.terminateProcess);
+            throw error;
+        }
+    }
+    async spawnTransport(launchEnv) {
         const { command, args } = await this.resolveLaunchCommand();
         const child = spawnProcess(command, args, {
             cwd: process.cwd(),
@@ -440,38 +534,46 @@ export class ACPAgentClient {
                 reject(new Error(stderr ? `${String(error)}\n${stderr}` : String(error)));
             });
         });
+        const spawnReadyPromise = new Promise((resolve) => {
+            child.once("spawn", () => {
+                resolve();
+            });
+        });
         const stream = createLoggedNdJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout), { logger: this.logger, provider: this.provider });
         const connection = new ClientSideConnection(() => this.buildProbeClient(), stream);
+        return {
+            child,
+            connection,
+            stderrChunks,
+            spawnReady: spawnReadyPromise,
+            spawnError: spawnErrorPromise,
+        };
+    }
+    async initializeTransport(transport, initializeTimeoutMs) {
         let timeout = null;
-        const initializeTimeoutPromise = options?.initializeTimeoutMs
+        const initializeTimeoutPromise = initializeTimeoutMs
             ? new Promise((_, reject) => {
                 timeout = setTimeout(() => {
-                    reject(new Error(`ACP initialize timed out after ${options.initializeTimeoutMs}ms`));
-                }, options.initializeTimeoutMs);
+                    reject(new Error(`ACP initialize timed out after ${initializeTimeoutMs}ms`));
+                }, initializeTimeoutMs);
             })
             : null;
-        let initialize;
         try {
-            initialize = await this.runACPRequest(() => Promise.race([
-                connection.initialize({
+            return await this.runACPRequest(() => Promise.race([
+                transport.connection.initialize({
                     protocolVersion: PROTOCOL_VERSION,
                     clientCapabilities: ACP_CLIENT_CAPABILITIES,
                     clientInfo: { name: "Paseo", version: "dev" },
                 }),
-                spawnErrorPromise,
+                transport.spawnError,
                 ...(initializeTimeoutPromise ? [initializeTimeoutPromise] : []),
             ]));
         }
-        catch (error) {
-            await terminateChildProcess(child, 2000, this.terminateProcess);
-            throw error;
-        }
         finally {
             if (timeout) {
                 clearTimeout(timeout);
             }
         }
-        return { child, connection, initialize };
     }
     buildProbeClient() {
         return {
@@ -495,7 +597,7 @@ export class ACPAgentClient {
     }
     async closeProbe(probe) {
         try {
-            if (probe.initialize.agentCapabilities?.sessionCapabilities?.close) {
+            if (probe.initialize?.agentCapabilities?.sessionCapabilities?.close) {
                 // No active session to close here; ignore capability.
             }
         }
@@ -511,6 +613,89 @@ export class ACPAgentClient {
             throw toACPRequestError(error);
         }
     }
+    async buildACPProbeDiagnosticRows(options = {}) {
+        const rows = [];
+        const phaseTimeoutMs = options.phaseTimeoutMs ?? ACP_DIAGNOSTIC_PHASE_TIMEOUT_MS;
+        const cwd = options.cwd ?? homedir();
+        let transport = null;
+        try {
+            const spawnStartedAt = Date.now();
+            try {
+                transport = await this.spawnTransport(PROBE_ENV);
+                await withTimeout(Promise.race([transport.spawnReady, transport.spawnError]), phaseTimeoutMs, `ACP spawn timed out after ${phaseTimeoutMs}ms`);
+                rows.push({
+                    label: "ACP spawn",
+                    value: `ok (${formatDurationMs(spawnStartedAt)})`,
+                });
+            }
+            catch (error) {
+                rows.push({
+                    label: "ACP spawn",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                });
+                return rows;
+            }
+            const activeTransport = transport;
+            const initializeStartedAt = Date.now();
+            try {
+                await this.initializeTransport(activeTransport, phaseTimeoutMs);
+                rows.push({
+                    label: "ACP initialize",
+                    value: `ok (${formatDurationMs(initializeStartedAt)})`,
+                });
+            }
+            catch (error) {
+                rows.push({
+                    label: "ACP initialize",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                });
+                pushACPStderrRow(rows, activeTransport.stderrChunks);
+                return rows;
+            }
+            const sessionStartedAt = Date.now();
+            try {
+                const response = await withTimeout(this.runACPRequest(() => activeTransport.connection.newSession({
+                    cwd,
+                    mcpServers: [],
+                })), phaseTimeoutMs, `ACP session/new timed out after ${phaseTimeoutMs}ms`);
+                const transformed = this.transformSessionResponse(response);
+                const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
+                const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
+                rows.push({
+                    label: "ACP session/new",
+                    value: `ok (${formatDurationMs(sessionStartedAt)}; models=${models.length}; modes=${modeInfo.modes.length})`,
+                });
+            }
+            catch (error) {
+                rows.push({
+                    label: "ACP session/new",
+                    value: `error: ${toDiagnosticErrorMessage(error)}`,
+                });
+                pushACPStderrRow(rows, activeTransport.stderrChunks);
+                return rows;
+            }
+            pushACPStderrRow(rows, activeTransport.stderrChunks);
+            return rows;
+        }
+        finally {
+            if (transport) {
+                const cleanupStartedAt = Date.now();
+                try {
+                    await terminateChildProcess(transport.child, 2000, this.terminateProcess);
+                    rows.push({
+                        label: "ACP cleanup",
+                        value: `ok (${formatDurationMs(cleanupStartedAt)})`,
+                    });
+                }
+                catch (error) {
+                    rows.push({
+                        label: "ACP cleanup",
+                        value: `error: ${toDiagnosticErrorMessage(error)}`,
+                    });
+                }
+            }
+        }
+    }
     async resolveLaunchCommand() {
         const prefix = await resolveProviderLaunch({
             commandConfig: this.runtimeSettings?.command,
@@ -582,6 +767,7 @@ export class ACPAgentSession {
         this.modelTransformer = options.modelTransformer;
         this.sessionResponseTransformer = options.sessionResponseTransformer;
         this.configOptionsTransformer = options.configOptionsTransformer;
+        this.configFeatureOptions = options.configFeatureOptions ?? [];
         this.modeIdTransformer = options.modeIdTransformer;
         this.toolSnapshotTransformer = options.toolSnapshotTransformer;
         this.providerModeWriter = options.providerModeWriter;
@@ -739,6 +925,9 @@ export class ACPAgentSession {
     async getCurrentMode() {
         return this.currentMode;
     }
+    get features() {
+        return deriveFeaturesFromACP(this.configOptions, this.configFeatureOptions);
+    }
     ensureCommandsReadyDeferred() {
         if (this.commandsReadyDeferred || this.commandsReadySettled || this.cachedCommands.length > 0) {
             return;
@@ -1015,6 +1204,37 @@ export class ACPAgentSession {
             thinkingOptionId: this.thinkingOptionId,
         });
     }
+    async setFeature(featureId, value) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        const featureOption = this.configFeatureOptions.find((option) => option.id === featureId);
+        if (!featureOption) {
+            throw new Error(`Unknown ${this.provider} feature: ${featureId}`);
+        }
+        const option = findSelectConfigFeatureOption(this.configOptions, featureOption);
+        if (!option) {
+            throw new Error(`${this.provider} does not expose ACP feature '${featureId}'`);
+        }
+        const requestedValue = normalizeConfigFeatureValue(value);
+        const choice = findSelectConfigChoice({ option, value: requestedValue });
+        if (!choice) {
+            throw new Error(`${this.provider} feature '${featureId}' does not include option '${requestedValue}'`);
+        }
+        const response = await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId: option.id,
+            value: requestedValue,
+        });
+        const currentValue = this.applyConfigOptionResponse({
+            response,
+            configId: option.id,
+            category: featureOption.category,
+            requestedValue,
+            label: featureOption.label,
+        });
+        this.config.featureValues = { ...this.config.featureValues, [featureId]: currentValue };
+    }
     applyConfigOptionResponse({ response, configId, category, requestedValue, label, }) {
         this.configOptions = this.transformConfigOptions(response.configOptions);
         const responseOption = findSelectConfigOption({
@@ -1386,6 +1606,13 @@ export class ACPAgentSession {
         if (this.config.thinkingOptionId && this.config.thinkingOptionId !== this.thinkingOptionId) {
             await this.setThinkingOption(this.config.thinkingOptionId);
         }
+        const configuredFeatureValues = this.config.featureValues ?? {};
+        for (const featureOption of this.configFeatureOptions) {
+            if (!Object.prototype.hasOwnProperty.call(configuredFeatureValues, featureOption.id)) {
+                continue;
+            }
+            await this.setFeature(featureOption.id, configuredFeatureValues[featureOption.id]);
+        }
     }
     warnInvalidSelection(value, message) {
         this.logger.warn({ value }, message);
@@ -1671,6 +1898,12 @@ function findSelectConfigOption({ configOptions, category, id, }) {
     const option = configOptions?.find((entry) => entry.type === "select" && entry.category === category && (!id || entry.id === id));
     return option ?? null;
 }
+function findSelectConfigFeatureOption(configOptions, featureOption) {
+    const option = configOptions?.find((entry) => entry.type === "select" &&
+        entry.id === featureOption.configId &&
+        entry.category === featureOption.category);
+    return option ?? null;
+}
 function findSelectConfigChoice({ option, value, }) {
     if (!option) {
         return null;
@@ -1690,6 +1923,34 @@ function flattenSelectOptions(options) {
     }
     return flattened;
 }
+function deriveConfigFeatureSelectOptions(option, featureOption) {
+    return flattenSelectOptions(option.options).map((choice) => ({
+        id: choice.value,
+        label: normalizeConfigFeatureOptionLabel(choice, featureOption),
+        description: choice.description ?? undefined,
+        isDefault: choice.value === option.currentValue,
+        metadata: choice.group ? { group: choice.group } : undefined,
+    }));
+}
+function normalizeConfigFeatureOptionLabel(choice, featureOption) {
+    const name = choice.name.trim();
+    if (name) {
+        return name;
+    }
+    if (choice.value === "" && featureOption.emptyOptionLabel) {
+        return featureOption.emptyOptionLabel;
+    }
+    return choice.value;
+}
+function normalizeConfigFeatureValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === null) {
+        return "";
+    }
+    throw new Error(`ACP feature value must be a string`);
+}
 function deriveSelectorOptions(configOptions, category) {
     const option = findSelectConfigOption({ configOptions, category });
     if (!option) {