@getpaseo/server 0.1.98 → 0.1.100

package/dist/server/server/agent/agent-manager.js

@@ -2580,8 +2580,8 @@ export class AgentManager {
             const client = this.clients.get(normalized.provider);
             if (client) {
                 try {
-                    const models = await client.listModels({ cwd: normalized.cwd, force: false });
-                    const defaultModel = models.find((model) => model.isDefault) ?? models[0];
+                    const catalog = await client.fetchCatalog({ cwd: normalized.cwd, force: false });
+                    const defaultModel = catalog.models.find((model) => model.isDefault) ?? catalog.models[0];
                     if (defaultModel) {
                         normalized.model = defaultModel.id;
                     }

package/dist/server/server/agent/agent-sdk-types.d.ts

@@ -578,21 +578,26 @@ export interface AgentSession {
         }): Promise<void>;
     } | null;
 }
-export interface ListModelsOptions {
+export interface FetchCatalogOptions {
     cwd: string;
     force: boolean;
 }
-export interface ListModesOptions {
-    cwd: string;
-    force: boolean;
+export interface ProviderCatalog {
+    models: AgentModelDefinition[];
+    modes: AgentMode[];
 }
 export interface AgentClient {
     readonly provider: AgentProvider;
     readonly capabilities: AgentCapabilityFlags;
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext, options?: AgentCreateSessionOptions): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
-    listModels(options: ListModelsOptions): Promise<AgentModelDefinition[]>;
-    listModes?(options: ListModesOptions): Promise<AgentMode[]>;
+    /**
+     * Discover models and modes together. Implementations may use one upstream
+     * process, separate upstream calls, static modes, or private helpers; callers
+     * outside the provider do not get separate runtime model/mode probes.
+     * The registry is responsible for merging configured model overrides.
+     */
+    fetchCatalog(options: FetchCatalogOptions): Promise<ProviderCatalog>;
     resolveCreateConfig?(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
     isCreateConfigUnattended?(input: AgentCreateConfigUnattendedInput): boolean;
     listCommands?(config: AgentSessionConfig): Promise<AgentSlashCommand[]>;

package/dist/server/server/agent/provider-registry.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "pino";
-import type { AgentClient, AgentCreateConfigUnattendedInput, AgentMode, AgentModelDefinition, AgentProvider, AgentSession, ListModelsOptions, ListModesOptions, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
+import type { AgentClient, AgentCreateConfigUnattendedInput, AgentProvider, AgentSession, FetchCatalogOptions, ProviderCatalog, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
 import type { WorkspaceGitService } from "../workspace-git-service.js";
 import type { ManagedProcessRegistry } from "../managed-processes/managed-processes.js";
 import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./provider-launch-config.js";
@@ -17,8 +17,11 @@ export interface ProviderDefinition extends AgentProviderDefinition {
     createClient: (logger: Logger) => AgentClient;
     resolveCreateConfig: (input: ResolveAgentCreateConfigInput) => ResolveAgentCreateConfigResult;
     isCreateConfigUnattended: (input: AgentCreateConfigUnattendedInput) => boolean;
-    fetchModels: (options: ListModelsOptions) => Promise<AgentModelDefinition[]>;
-    fetchModes: (options: ListModesOptions) => Promise<AgentMode[]>;
+    /**
+     * Single catalog discovery call used by ProviderSnapshotManager. Should spawn
+     * at most one provider runtime process and return both models and modes.
+     */
+    fetchCatalog: (options: FetchCatalogOptions, client?: AgentClient) => Promise<ProviderCatalog>;
 }
 export interface BuildProviderRegistryOptions {
     runtimeSettings?: AgentProviderRuntimeSettingsMap;

package/dist/server/server/agent/provider-registry.js

@@ -51,6 +51,7 @@ const PROVIDER_CLIENT_FACTORIES = {
         providerParams: options?.providerParams ?? {
             sessionDir: "~/.omp/agent/sessions",
         },
+        commandsRpcType: "get_available_commands",
     }),
     mock: (logger) => new MockLoadTestAgentClient(logger),
     "mock-slow": () => new MockSlowProviderClient(),
@@ -232,10 +233,15 @@ function wrapClientProvider(provider, inner, profileModels, additionalModels, pr
                 provider: inner.provider,
             }
             : undefined, launchContext)),
-        listModels: async (options) => mergeModels(provider, profileModels, additionalModels, await inner.listModels(options), {
-            profileModelsAreAdditive,
-        }),
-        listModes: inner.listModes?.bind(inner),
+        fetchCatalog: async (options) => {
+            const catalog = await inner.fetchCatalog(options);
+            return {
+                models: mergeModels(provider, profileModels, additionalModels, catalog.models, {
+                    profileModelsAreAdditive,
+                }),
+                modes: catalog.modes,
+            };
+        },
         resolveCreateConfig: inner.resolveCreateConfig?.bind(inner),
         isCreateConfigUnattended: inner.isCreateConfigUnattended?.bind(inner),
         listImportableSessions: listImportableSessions
@@ -275,6 +281,22 @@ function wrapClientProvider(provider, inner, profileModels, additionalModels, pr
 }
 function createRegistryEntry(logger, provider, resolved) {
     const modelClient = resolved.createBaseClient(logger);
+    const hasReplacementModels = resolved.profileModels.length > 0 && !resolved.profileModelsAreAdditive;
+    const replacementModels = hasReplacementModels
+        ? resolved.profileModels.map((model) => mapModel(provider, model))
+        : [];
+    const decorateModes = (modes) => modes.map((mode) => {
+        if (mode.icon && mode.colorTier)
+            return mode;
+        const definitionMode = resolved.definition.modes.find((d) => d.id === mode.id);
+        if (!definitionMode)
+            return mode;
+        return Object.assign({}, mode, {
+            icon: mode.icon ?? definitionMode.icon,
+            colorTier: mode.colorTier ?? definitionMode.colorTier,
+        });
+    });
+    const hasStaticModes = resolved.definition.modes.length > 0;
     return {
         ...resolved.definition,
         enabled: resolved.enabled,
@@ -282,24 +304,29 @@ function createRegistryEntry(logger, provider, resolved) {
         createClient: (providerLogger) => createResolvedProviderClient(providerLogger, provider, resolved),
         resolveCreateConfig: modelClient.resolveCreateConfig ?? resolveDefaultAgentCreateConfig,
         isCreateConfigUnattended: modelClient.isCreateConfigUnattended ?? isDefaultAgentCreateConfigUnattended,
-        fetchModels: async (options) => mergeModels(provider, resolved.profileModels, resolved.additionalModels, await modelClient.listModels(options), {
-            profileModelsAreAdditive: resolved.profileModelsAreAdditive,
-        }),
-        fetchModes: async (options) => {
-            const modes = modelClient.listModes
-                ? await modelClient.listModes(options)
-                : resolved.definition.modes;
-            return modes.map((mode) => {
-                if (mode.icon && mode.colorTier)
-                    return mode;
-                const definitionMode = resolved.definition.modes.find((d) => d.id === mode.id);
-                if (!definitionMode)
-                    return mode;
-                return Object.assign({}, mode, {
-                    icon: mode.icon ?? definitionMode.icon,
-                    colorTier: mode.colorTier ?? definitionMode.colorTier,
-                });
-            });
+        fetchCatalog: async (options, client) => {
+            const catalogClient = client ?? modelClient;
+            if (hasReplacementModels) {
+                // Replacement models skip runtime model discovery, but additionalModels
+                // must still be merged on top. If modes are dynamic, probe for modes via
+                // the single catalog API; otherwise use static/empty modes with no runtime.
+                const models = mergeModelAdditions(provider, replacementModels, resolved.additionalModels);
+                if (hasStaticModes) {
+                    return {
+                        models,
+                        modes: decorateModes(resolved.definition.modes),
+                    };
+                }
+                const catalog = await catalogClient.fetchCatalog(options);
+                return { models, modes: decorateModes(catalog.modes) };
+            }
+            const catalog = await catalogClient.fetchCatalog(options);
+            return {
+                models: mergeModels(provider, resolved.profileModels, resolved.additionalModels, catalog.models, {
+                    profileModelsAreAdditive: resolved.profileModelsAreAdditive,
+                }),
+                modes: decorateModes(catalog.modes),
+            };
         },
     };
 }

package/dist/server/server/agent/provider-snapshot-manager.js

@@ -5,6 +5,7 @@ import { expandTilde } from "../../utils/path.js";
 import { withTimeout } from "../../utils/promise-timeout.js";
 import { buildProviderRegistry, shutdownAgentClients, } from "./provider-registry.js";
 import { applyMutableProviderConfigToOverrides } from "../daemon-config-store.js";
+import { formatProviderDiagnostic } from "./providers/diagnostic-utils.js";
 const DEFAULT_REFRESH_TIMEOUT_MS = 30000;
 const REFRESH_TIMEOUT_ENV_VAR = "PASEO_PROVIDER_REFRESH_TIMEOUT_MS";
 // Provider refresh probes can be slow on cold starts (e.g. Copilot's first
@@ -179,13 +180,19 @@ export class ProviderSnapshotManager {
         });
     }
     async getProviderDiagnostic(provider) {
-        const client = this.providerClients[provider];
-        if (!client) {
-            throw new Error(`Provider ${provider} is not configured`);
-        }
-        const diagnostic = client.getDiagnostic
+        const definition = this.requireProvider(provider);
+        const client = this.ensureClient(provider, definition);
+        // Force-refresh the snapshot so Models/Status come from the single catalog authority.
+        await this.refreshSnapshotForCwd({ cwd: homedir(), providers: [provider] });
+        const entry = await this.getProvider({ cwd: homedir(), provider, wait: true });
+        const modelCount = entry.status === "ready" ? String(entry.models?.length ?? 0) : "—";
+        const status = formatProviderStatus(entry);
+        const baseDiagnostic = client.getDiagnostic
             ? (await client.getDiagnostic()).diagnostic
-            : "No diagnostic available for this provider.";
+            : formatProviderDiagnostic(definition.label ?? provider, [
+                { label: "Diagnostic", value: "No diagnostic available" },
+            ]);
+        const diagnostic = `${baseDiagnostic}\n  Models: ${modelCount}\n  Status: ${status}`;
         return { provider, diagnostic };
     }
     applyMutableProviderConfig(mutableProviders) {
@@ -238,8 +245,7 @@ export class ProviderSnapshotManager {
                 createClient: () => client,
                 resolveCreateConfig: client.resolveCreateConfig?.bind(client) ?? definition.resolveCreateConfig,
                 isCreateConfigUnattended: client.isCreateConfigUnattended?.bind(client) ?? definition.isCreateConfigUnattended,
-                fetchModels: client.listModels.bind(client),
-                fetchModes: client.listModes?.bind(client) ?? definition.fetchModes,
+                fetchCatalog: client.fetchCatalog.bind(client),
             };
         }
         return registry;
@@ -448,16 +454,13 @@ export class ProviderSnapshotManager {
                 setEntry({ ...base, status: "unavailable", enabled: true });
                 return;
             }
-            const [models, modes] = await withTimeout(Promise.all([
-                definition.fetchModels({ cwd, force }),
-                definition.fetchModes({ cwd, force }),
-            ]), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
+            const catalog = await withTimeout(definition.fetchCatalog({ cwd, force }, client), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
             setEntry({
                 ...base,
                 status: "ready",
                 enabled: true,
-                models,
-                modes,
+                models: catalog.models,
+                modes: catalog.modes,
                 fetchedAt: new Date().toISOString(),
             });
         }
@@ -580,4 +583,13 @@ function toErrorMessage(error) {
     }
     return "Unknown error";
 }
+function formatProviderStatus(entry) {
+    if (entry.status === "ready")
+        return "Ready";
+    if (entry.status === "error")
+        return `Error: ${entry.error ?? "Unknown error"}`;
+    if (entry.status === "unavailable")
+        return "Unavailable";
+    return "Loading";
+}
 //# sourceMappingURL=provider-snapshot-manager.js.map

package/dist/server/server/agent/providers/acp-agent.d.ts

@@ -3,7 +3,7 @@ import type { ProcessTerminator } from "../../../utils/tree-kill.js";
 import type { ReadableStream as NodeReadableStream, WritableStream as NodeWritableStream } from "node:stream/web";
 import { ClientSideConnection, type Client as ACPClient, type CreateTerminalRequest, type InitializeResponse, type KillTerminalRequest, type LoadSessionResponse, type NewSessionResponse, type ReadTextFileRequest, type RequestPermissionRequest, type RequestPermissionResponse, type ResumeSessionResponse, type SessionConfigOption, type SessionMode, type SessionModelState, type SessionNotification, type TerminalOutputRequest, type TerminalOutputResponse, type ToolCallContent, type ToolCallLocation, type ToolCallStatus, type ToolKind, type Usage, type WaitForTerminalExitRequest, type WriteTextFileRequest, type Stream as ACPStream } from "@agentclientprotocol/sdk";
 import type { Logger } from "pino";
-import { type AgentCapabilityFlags, type AgentClient, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentUsage, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModesOptions, type ListModelsOptions } from "../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentUsage, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 export declare function summarizeACPRequestError(error: unknown): {
     message: string;
@@ -24,6 +24,7 @@ interface ACPAgentClientOptions {
     modelTransformer?: (models: AgentModelDefinition[]) => AgentModelDefinition[];
     sessionResponseTransformer?: (response: SessionStateResponse) => SessionStateResponse;
     configOptionsTransformer?: (configOptions: SessionConfigOption[]) => SessionConfigOption[];
+    configFeatureOptions?: ACPConfigFeatureOption[];
     modeIdTransformer?: (modeId: string) => string | null;
     toolSnapshotTransformer?: (snapshot: ACPToolSnapshot) => ACPToolSnapshot;
     providerModeWriter?: (context: ACPProviderModeWriterContext) => Promise<ACPProviderModeWriteResult>;
@@ -43,6 +44,7 @@ interface ACPAgentSessionOptions {
     modelTransformer?: (models: AgentModelDefinition[]) => AgentModelDefinition[];
     sessionResponseTransformer?: (response: SessionStateResponse) => SessionStateResponse;
     configOptionsTransformer?: (configOptions: SessionConfigOption[]) => SessionConfigOption[];
+    configFeatureOptions?: ACPConfigFeatureOption[];
     modeIdTransformer?: (modeId: string) => string | null;
     toolSnapshotTransformer?: (snapshot: ACPToolSnapshot) => ACPToolSnapshot;
     providerModeWriter?: (context: ACPProviderModeWriterContext) => Promise<ACPProviderModeWriteResult>;
@@ -76,6 +78,16 @@ interface TerminalExit {
     exitCode?: number | null;
     signal?: string | null;
 }
+export interface ACPConfigFeatureOption {
+    id: string;
+    configId: string;
+    category: string;
+    label: string;
+    description?: string;
+    tooltip?: string;
+    icon?: string;
+    emptyOptionLabel?: string;
+}
 type SelectConfigOption = Extract<SessionConfigOption, {
     type: "select";
 }>;
@@ -134,6 +146,7 @@ export declare function deriveModesFromACP(fallbackModes: AgentMode[], modeState
     currentModeId: string | null;
 };
 export declare function deriveModelDefinitionsFromACP(provider: string, models: SessionModelState | null | undefined, configOptions?: SessionConfigOption[] | null): AgentModelDefinition[];
+export declare function deriveFeaturesFromACP(configOptions: SessionConfigOption[] | null | undefined, featureOptions: ACPConfigFeatureOption[]): AgentFeature[];
 export declare class ACPAgentClient implements AgentClient {
     readonly provider: string;
     readonly capabilities: AgentCapabilityFlags;
@@ -144,6 +157,7 @@ export declare class ACPAgentClient implements AgentClient {
     private readonly modelTransformer?;
     private readonly sessionResponseTransformer?;
     private readonly configOptionsTransformer?;
+    private readonly configFeatureOptions;
     private readonly modeIdTransformer?;
     private readonly toolSnapshotTransformer?;
     private readonly providerModeWriter?;
@@ -155,8 +169,8 @@ export declare class ACPAgentClient implements AgentClient {
     constructor(options: ACPAgentClientOptions);
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
-    listModels(options: ListModelsOptions): Promise<AgentModelDefinition[]>;
-    listModes(options: ListModesOptions): Promise<AgentMode[]>;
+    fetchCatalog(options: FetchCatalogOptions): Promise<ProviderCatalog>;
+    listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;
@@ -183,6 +197,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     protected readonly modelTransformer?: (models: AgentModelDefinition[]) => AgentModelDefinition[];
     private readonly sessionResponseTransformer?;
     private readonly configOptionsTransformer?;
+    private readonly configFeatureOptions;
     private readonly modeIdTransformer?;
     private readonly toolSnapshotTransformer?;
     private readonly providerModeWriter?;
@@ -194,6 +209,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private readonly pendingPermissions;
     private readonly messageAssemblies;
     private readonly submittedUserMessageIds;
+    private activeSubmittedUserMessage;
     private readonly toolCalls;
     private readonly terminalEntries;
     private readonly persistedHistory;
@@ -236,6 +252,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     getRuntimeInfo(): Promise<AgentRuntimeInfo>;
     getAvailableModes(): Promise<AgentMode[]>;
     getCurrentMode(): Promise<string | null>;
+    get features(): AgentFeature[];
     private ensureCommandsReadyDeferred;
     private settleCommandsReady;
     private waitForCommandsReady;
@@ -246,6 +263,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     setModel(modelId: string | null): Promise<void>;
     private setModelWithSelection;
     setThinkingOption(thinkingOptionId: string | null): Promise<void>;
+    setFeature(featureId: string, value: unknown): Promise<void>;
     private applyConfigOptionResponse;
     getPendingPermissions(): AgentPermissionRequest[];
     respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<void>;
@@ -282,6 +300,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private translateSessionUpdate;
     private handleToolCallUpdate;
     private createMessageTimelineItem;
+    private messageAssemblyKey;
     private handleCurrentModeUpdate;
     private handleConfigOptionUpdate;
     private handleSessionInfoUpdate;
@@ -292,6 +311,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private emitSubmittedUserMessage;
     private runtimeInfo;
     private finishTurn;
+    private isSubmittedUserMessageEcho;
     private emitBootstrapThreadEvent;
     private synthesizeCanceledToolCalls;
     private collectDiagnostic;

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

@@ -257,6 +257,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 +292,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 +312,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 +351,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,
@@ -344,7 +367,7 @@ export class ACPAgentClient {
         await session.initializeResumedSession();
         return session;
     }
-    async listModels(options) {
+    async fetchCatalog(options) {
         const { cwd } = options;
         const probe = await this.spawnProcess(PROBE_ENV);
         try {
@@ -354,23 +377,29 @@ export class ACPAgentClient {
             }));
             const transformed = this.transformSessionResponse(response);
             const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
-            return this.modelTransformer ? this.modelTransformer(models) : models;
+            const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
+            return {
+                models: this.modelTransformer ? this.modelTransformer(models) : models,
+                modes: modeInfo.modes,
+            };
         }
         finally {
             await this.closeProbe(probe);
         }
     }
-    async listModes(options) {
-        const { cwd } = options;
+    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 modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
-            return modeInfo.modes;
+            return deriveFeaturesFromACP(transformed.configOptions, this.configFeatureOptions);
         }
         finally {
             await this.closeProbe(probe);
@@ -561,6 +590,7 @@ export class ACPAgentSession {
         this.pendingPermissions = new Map();
         this.messageAssemblies = new Map();
         this.submittedUserMessageIds = new Set();
+        this.activeSubmittedUserMessage = null;
         this.toolCalls = new Map();
         this.terminalEntries = new Map();
         this.persistedHistory = [];
@@ -593,6 +623,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;
@@ -690,6 +721,7 @@ export class ACPAgentSession {
         const turnId = randomUUID();
         const messageId = options?.messageId ?? randomUUID();
         this.activeForegroundTurnId = turnId;
+        this.activeSubmittedUserMessage = null;
         this.emitBootstrapThreadEvent();
         this.pushEvent({ type: "turn_started", provider: this.provider, turnId });
         this.emitSubmittedUserMessage(prompt, messageId, turnId);
@@ -749,6 +781,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;
@@ -1025,6 +1060,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({
@@ -1396,6 +1462,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);
@@ -1413,7 +1486,10 @@ export class ACPAgentSession {
                 if (!item) {
                     return [];
                 }
-                if (update.messageId && this.submittedUserMessageIds.has(update.messageId)) {
+                if (item.type !== "user_message") {
+                    return [this.wrapTimeline(item)];
+                }
+                if (this.isSubmittedUserMessageEcho(item)) {
                     return [];
                 }
                 return [this.wrapTimeline(item)];
@@ -1476,7 +1552,7 @@ export class ACPAgentSession {
         if (!chunkText) {
             return null;
         }
-        const key = `${type}:${update.messageId ?? "default"}`;
+        const key = this.messageAssemblyKey(type, update.messageId);
         const state = this.messageAssemblies.get(key) ?? { text: "" };
         state.text += chunkText;
         this.messageAssemblies.set(key, state);
@@ -1488,6 +1564,10 @@ export class ACPAgentSession {
         }
         return { type: "reasoning", text: chunkText };
     }
+    messageAssemblyKey(type, messageId) {
+        const fallbackId = type === "user_message" ? (this.activeForegroundTurnId ?? "default") : "default";
+        return `${type}:${messageId ?? fallbackId}`;
+    }
     handleCurrentModeUpdate(update) {
         this.currentMode = this.transformModeId(update.currentModeId);
     }
@@ -1589,6 +1669,7 @@ export class ACPAgentSession {
             return;
         }
         this.submittedUserMessageIds.add(messageId);
+        this.activeSubmittedUserMessage = { messageId, text, turnId };
         this.pushEvent({
             type: "timeline",
             provider: this.provider,
@@ -1611,8 +1692,23 @@ export class ACPAgentSession {
     }
     finishTurn(event) {
         this.activeForegroundTurnId = null;
+        if (this.activeSubmittedUserMessage?.turnId === event.turnId) {
+            this.activeSubmittedUserMessage = null;
+        }
         this.pushEvent(event);
     }
+    isSubmittedUserMessageEcho(item) {
+        const active = this.activeSubmittedUserMessage;
+        if (!active || active.turnId !== this.activeForegroundTurnId) {
+            return false;
+        }
+        if (item.messageId) {
+            if (this.submittedUserMessageIds.has(item.messageId)) {
+                return true;
+            }
+        }
+        return active.text.startsWith(item.text);
+    }
     emitBootstrapThreadEvent() {
         if (!this.bootstrapThreadEventPending || !this.sessionId) {
             return;
@@ -1658,6 +1754,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;
@@ -1677,6 +1779,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) {