@getpaseo/server 0.9.2 → 0.10.0-beta.1

package/dist/scripts/supervisor.js

@@ -1,7 +1,6 @@
 import { fork, spawn } from "child_process";
-import { mkdirSync } from "node:fs";
 import path from "node:path";
-import { createStream as createRotatingFileStream } from "rotating-file-stream";
+import { createStream as createRotatingFileStream, } from "rotating-file-stream";
 import { signalProcessTree } from "../src/utils/tree-kill.js";
 const WORKER_HEARTBEAT_INTERVAL_MS = 1000;
 const WORKER_TERMINATION_GRACE_MS = 10000;
@@ -49,16 +48,51 @@ function toRotatingFileStreamSize(size) {
     const unit = (match[2] ?? "M").toUpperCase();
     return `${value}${unit}`;
 }
-function createSupervisorLogStream(options) {
-    if (!options) {
-        return null;
-    }
-    mkdirSync(path.dirname(options.path), { recursive: true });
-    return createRotatingFileStream(path.basename(options.path), {
-        path: path.dirname(options.path),
-        size: toRotatingFileStreamSize(options.rotate.maxSize),
-        maxFiles: options.rotate.maxFiles,
-    });
+// daemon.log is best effort: a full disk or a replaced log path must not take the
+// supervisor, and with it the worker, down. A failed stream is dropped and a new one
+// is opened on the next write, so logging resumes once the file is writable again.
+function createDurableLog(options, reportFailure) {
+    let stream = null;
+    let failing = false;
+    const open = (logFile) => {
+        const next = createRotatingFileStream(path.basename(logFile.path), {
+            path: path.dirname(logFile.path),
+            size: toRotatingFileStreamSize(logFile.rotate.maxSize),
+            maxFiles: logFile.rotate.maxFiles,
+        });
+        next.on("error", (error) => {
+            if (stream === next) {
+                stream = null;
+            }
+            if (!failing) {
+                failing = true;
+                reportFailure(`Cannot write ${logFile.path}, will retry on the next log line: ${error.message}`);
+            }
+        });
+        return next;
+    };
+    return {
+        write(chunk) {
+            if (!options) {
+                return;
+            }
+            stream ?? (stream = open(options));
+            stream.write(chunk, (error) => {
+                if (!error) {
+                    failing = false;
+                }
+            });
+        },
+        close() {
+            return new Promise((resolve) => {
+                if (!stream) {
+                    resolve();
+                    return;
+                }
+                stream.end(() => resolve());
+            });
+        },
+    };
 }
 export function runSupervisor(options) {
     const restartOnCrash = options.restartOnCrash ?? false;
@@ -73,9 +107,11 @@ export function runSupervisor(options) {
     let lifecycleFailed = false;
     let publication = Promise.resolve();
     let forceKillTimer = null;
-    const logStream = createSupervisorLogStream(options.logFile);
+    const durableLog = createDurableLog(options.logFile, (message) => {
+        process.stderr.write(`[${options.name}] ${message}\n`);
+    });
     const writeDurableChunk = (chunk) => {
-        logStream?.write(chunk);
+        durableLog.write(chunk);
     };
     const writeLifecycleLog = (message, fields = {}) => {
         writeDurableChunk(`${JSON.stringify({
@@ -91,13 +127,7 @@ export function runSupervisor(options) {
         process.stderr.write(`[${options.name}] ${message}\n`);
         writeLifecycleLog(message);
     };
-    const closeLogStream = () => new Promise((resolve) => {
-        if (!logStream) {
-            resolve();
-            return;
-        }
-        logStream.end(resolve);
-    });
+    const closeLogStream = () => durableLog.close();
     const exitSupervisor = (code) => {
         if (exiting) {
             return;

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

@@ -2413,11 +2413,31 @@ export class AgentManager {
                 durableTimelineHasRows,
                 options,
             });
+            // Read history before publishing the agent: a provider failure must leave the
+            // session unregistered so the registration catch closes it.
+            const startupHistory = [];
+            if (session.initialTimeline?.length && !managed.historyPrimed) {
+                for await (const event of session.streamHistory()) {
+                    startupHistory.push(limitAgentStreamEventContent(event));
+                }
+            }
             this.assertAcceptingAgentRegistrations();
             this.agents.set(resolvedAgentId, managed);
             registered = true;
             // Initialize previousStatus to track transitions
             this.previousStatuses.set(resolvedAgentId, managed.lifecycle);
+            if (session.initialTimeline?.length) {
+                if (!managed.historyPrimed) {
+                    // Legacy/imported chats need their existing history before startup rows.
+                    await this.primeTimelineFromLegacyProviderHistory(managed, false, startupHistory);
+                }
+                else {
+                    for (const entry of session.initialTimeline) {
+                        this.recordTimeline(managed.id, entry.item, { timestamp: entry.timestamp });
+                    }
+                }
+                this.refreshSessionPersistence(managed);
+            }
             await this.refreshRuntimeInfo(managed, { emit: false });
             this.assertAgentRegistrationActive(managed);
             await this.persistSnapshot(managed, {
@@ -2817,7 +2837,7 @@ export class AgentManager {
         this.touchUpdatedAt(agent);
         this.emitState(agent);
     }
-    async primeTimelineFromLegacyProviderHistory(agent, broadcast) {
+    async primeTimelineFromLegacyProviderHistory(agent, broadcast, history = agent.session.streamHistory()) {
         const deferredBroadcast = typeof broadcast === "function";
         const historyEvents = [];
         const historySubagentEvents = [];
@@ -2826,7 +2846,7 @@ export class AgentManager {
             // Collect the whole replay before touching either store. A stream that fails
             // halfway then leaves the committed timeline as it was, instead of a partial
             // copy the next attempt would append to.
-            for await (const rawEvent of agent.session.streamHistory()) {
+            for await (const rawEvent of history) {
                 const event = limitAgentStreamEventContent(rawEvent);
                 if (event.type === "provider_subagent") {
                     historySubagentEvents.push(event);

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

@@ -234,6 +234,10 @@ function formatFinishNotificationBody(params) {
     }
     return sections.join("\n\n");
 }
+// A caller waits on a child through one armed notification. Arming again, such as a
+// follow-up prompt while the child still runs, replaces the earlier one so the child's
+// next finish reaches the caller once.
+const armedFinishNotifications = new WeakMap();
 export function setupFinishNotification(params) {
     const { agentManager, agentStorage, childAgentId, callerAgentId, requireParentOwnership = false, logger, } = params;
     let hasSeenRunning = false;
@@ -241,11 +245,19 @@ export function setupFinishNotification(params) {
     const notifiedPermissionRequestIds = new Set();
     let unsubscribe = null;
     let notificationQueue = Promise.resolve();
+    const armedByManager = armedFinishNotifications.get(agentManager) ?? new Map();
+    armedFinishNotifications.set(agentManager, armedByManager);
+    const armedKey = JSON.stringify([childAgentId, callerAgentId]);
+    armedByManager.get(armedKey)?.();
+    armedByManager.set(armedKey, stop);
     function stop() {
         if (stopped)
             return;
         stopped = true;
         unsubscribe?.();
+        if (armedByManager.get(armedKey) === stop) {
+            armedByManager.delete(armedKey);
+        }
     }
     async function notify(reason, permissionRequest) {
         const callerRecord = await agentStorage.get(callerAgentId);

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

@@ -585,6 +585,9 @@ export interface AgentSession {
     readonly id: string | null;
     readonly capabilities: AgentCapabilityFlags;
     readonly features?: AgentFeature[];
+    /** New provider-owned rows to commit on registration. streamHistory must also
+     * replay them at their original timestamps; restored sessions omit old rows. */
+    readonly initialTimeline?: ImportedTimelineEntry[];
     run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
     startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{
         turnId: string;

package/dist/server/server/agent/mcp-shared.d.ts

@@ -62,6 +62,10 @@ export interface ResolvedProviderModel {
     model: string | undefined;
 }
 export declare function resolveRequiredProviderModel(providerValue: string): Required<ResolvedProviderModel>;
+export interface AgentWaitWithTimeoutResult extends WaitForAgentResult {
+    /** The wait gave up while the agent was still working. */
+    timedOut: boolean;
+}
 /**
  * Wraps agentManager.waitForAgentEvent with a self-imposed timeout.
  * Returns a friendly message when timeout occurs, rather than letting
@@ -70,7 +74,7 @@ export declare function resolveRequiredProviderModel(providerValue: string): Req
 export declare function waitForAgentWithTimeout(agentManager: AgentManager, agentId: string, options?: {
     signal?: AbortSignal;
     waitForActive?: boolean;
-}): Promise<WaitForAgentResult>;
+}): Promise<AgentWaitWithTimeoutResult>;
 export declare function sanitizePermissionRequest(permission: AgentPermissionRequest): AgentPermissionRequest;
 export declare function sanitizePermissionRequest(permission: null | undefined): null;
 export declare function sanitizePermissionRequest(permission: AgentPermissionRequest | null | undefined): AgentPermissionRequest | null;

package/dist/server/server/agent/mcp-shared.js

@@ -93,7 +93,7 @@ export async function waitForAgentWithTimeout(agentManager, agentId, options) {
             signal: combinedController.signal,
             waitForActive: options?.waitForActive,
         });
-        return result;
+        return { ...result, timedOut: false };
     }
     catch (error) {
         if (error instanceof Error && error.message === "wait timeout") {
@@ -111,6 +111,7 @@ export async function waitForAgentWithTimeout(agentManager, agentId, options) {
                 status: snapshot?.lifecycle ?? "idle",
                 permission: null,
                 lastMessage: message,
+                timedOut: true,
             };
         }
         throw error;

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

@@ -9,7 +9,7 @@ import { CursorACPAgentClient } from "./providers/cursor-acp-agent.js";
 import { GenericACPAgentClient } from "./providers/generic-acp-agent.js";
 import { KimiACPAgentClient } from "./providers/kimi-acp-agent.js";
 import { KiroACPAgentClient } from "./providers/kiro-acp-agent.js";
-import { OpenCodeAgentClient } from "./providers/opencode-agent.js";
+import { OpenCodeRuntimeClient } from "./providers/opencode/runtime-client.js";
 import { OmpAgentClient } from "./providers/omp/agent.js";
 import { PiRpcAgentClient } from "./providers/pi/agent.js";
 import { TraeACPAgentClient } from "./providers/trae-acp-agent.js";
@@ -73,7 +73,7 @@ const PROVIDER_CLIENT_FACTORIES = {
         command: getCursorACPCommand(runtimeSettings),
         env: runtimeSettings?.env,
     }),
-    opencode: (logger, runtimeSettings, options) => new OpenCodeAgentClient(logger, runtimeSettings, {
+    opencode: (logger, runtimeSettings, options) => new OpenCodeRuntimeClient(logger, runtimeSettings, {
         managedProcesses: options?.managedProcesses,
         bridge: options?.openCodeBridge,
     }),

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

@@ -22,6 +22,16 @@ function assertChildWithPipes(child) {
         throw new Error("Child process did not expose stdio pipes");
     }
 }
+// Node reports a failed spawn (missing binary or missing cwd) as a child
+// `error` event; without a listener it becomes an uncaught exception.
+function rejectOnSpawnError(child, stderrChunks) {
+    return new Promise((_, reject) => {
+        child.once("error", (error) => {
+            const stderr = stderrChunks.join("").trim();
+            reject(new Error(stderr ? `${String(error)}\n${stderr}` : String(error)));
+        });
+    });
+}
 function isRecord(value) {
     return value != null && typeof value === "object" && !Array.isArray(value);
 }
@@ -753,12 +763,7 @@ export class ACPAgentClient {
         child.stderr.on("data", (chunk) => {
             stderrChunks.push(chunk.toString());
         });
-        const spawnErrorPromise = new Promise((_, reject) => {
-            child.once("error", (error) => {
-                const stderr = stderrChunks.join("").trim();
-                reject(new Error(stderr ? `${String(error)}\n${stderr}` : String(error)));
-            });
-        });
+        const spawnErrorPromise = rejectOnSpawnError(child, stderrChunks);
         const spawnReadyPromise = new Promise((resolve) => {
             child.once("spawn", () => {
                 resolve();
@@ -1850,6 +1855,7 @@ export class ACPAgentSession {
         child.stderr.on("data", (chunk) => {
             stderrChunks.push(chunk.toString());
         });
+        const spawnError = rejectOnSpawnError(child, stderrChunks);
         child.once("exit", (code, signal) => {
             if (this.closed) {
                 return;
@@ -1871,11 +1877,14 @@ export class ACPAgentSession {
         // close the process even when the ACP handshake itself rejects.
         this.child = child;
         this.connection = connection;
-        const initialize = await this.runACPRequest(() => connection.initialize({
-            protocolVersion: PROTOCOL_VERSION,
-            clientCapabilities: buildACPClientCapabilities(this.clientCapabilityMeta, this.clientCapabilities),
-            clientInfo: { name: "Paseo", version: "dev" },
-        }));
+        const initialize = await this.runACPRequest(() => Promise.race([
+            connection.initialize({
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: buildACPClientCapabilities(this.clientCapabilityMeta, this.clientCapabilities),
+                clientInfo: { name: "Paseo", version: "dev" },
+            }),
+            spawnError,
+        ]));
         return { child, connection, initialize };
     }
     async runACPRequest(request) {

package/dist/server/server/agent/providers/claude/agent.d.ts

@@ -24,7 +24,6 @@ interface ClaudeAgentClientOptions {
     queryFactory?: ClaudeQueryFactory;
     resolveBinary?: () => Promise<string>;
     resolveVersion?: (signal?: AbortSignal) => Promise<string>;
-    configDir?: string;
     rewindSdk?: ClaudeRewindSdk;
 }
 export declare function extractUserMessageText(content: unknown): string | null;
@@ -39,7 +38,6 @@ export declare class ClaudeAgentClient implements AgentClient {
     private readonly queryFactory?;
     private readonly resolveBinary;
     private readonly resolveVersion;
-    private readonly configDir?;
     private readonly rewindSdk;
     constructor(options: ClaudeAgentClientOptions);
     resolveConfiguredModel(model: AgentModelDefinition): AgentModelDefinition;
@@ -48,6 +46,7 @@ export declare class ClaudeAgentClient implements AgentClient {
     getCatalogCacheKey(_options: FetchCatalogOptions): Promise<string>;
     fetchCatalog(_options: FetchCatalogOptions, context?: ProviderRefreshContext): Promise<ProviderCatalog>;
     resolveDefaultModeId({ env: launchEnv }: ResolveAgentDefaultModeInput): Promise<string>;
+    private buildProviderEnv;
     listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../../agent-sdk-types.js").ImportedProviderSession>;

package/dist/server/server/agent/providers/claude/agent.js

@@ -1,7 +1,6 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import { promises } from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import { mapClaudeCanceledToolCall, mapClaudeCompletedToolCall, mapClaudeFailedToolCall, mapClaudeRunningToolCall, } from "./tool-call-mapper.js";
 import { mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, readTaskNotificationToolUseIdFromHistoryRecord, } from "./task-notification-tool-call.js";
@@ -23,7 +22,7 @@ import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
 import { claudeQuery } from "./query.js";
 import { realClaudeRewindSdk, revertClaudeConversation, revertClaudeFiles, } from "./rewind.js";
 import { normalizeProviderReplayTimestamp } from "../../provider-history-timestamps.js";
-import { claudeProjectDirSync } from "./project-dir.js";
+import { claudeConfigDir, claudeProjectDirSync } from "./project-dir.js";
 import { THINKING_APPLIES_NEXT_TURN_NOTICE } from "../../provider-notices.js";
 import { isProviderImageMarkdown, materializeProviderImage, renderProviderImageOutputAsAssistantMarkdown, } from "../provider-image-output.js";
 import { getAgentStreamEventTurnId, } from "../../agent-sdk-types.js";
@@ -1060,7 +1059,6 @@ export class ClaudeAgentClient {
         this.resolveVersion =
             options.resolveVersion ??
                 ((signal) => resolveClaudeCodeVersion(this.runtimeSettings, signal));
-        this.configDir = options.configDir;
         this.rewindSdk = options.rewindSdk ?? realClaudeRewindSdk;
     }
     resolveConfiguredModel(model) {
@@ -1117,20 +1115,23 @@ export class ClaudeAgentClient {
         catch (error) {
             this.logger.warn({ err: error }, "Failed to resolve Claude Code version for model catalog");
         }
-        const models = await runProviderRefreshActivity(context, "settings", () => getClaudeModelsWithSettings(this.logger, this.configDir, claudeCodeVersion));
-        const modeCatalog = claudeModeCatalog(createProviderEnv({ baseEnv: process.env, runtimeSettings: this.runtimeSettings }));
+        const env = this.buildProviderEnv();
+        const models = await runProviderRefreshActivity(context, "settings", () => getClaudeModelsWithSettings(this.logger, claudeConfigDir(env), claudeCodeVersion));
+        const modeCatalog = claudeModeCatalog(env);
         return {
             models,
             ...modeCatalog,
         };
     }
     async resolveDefaultModeId({ env: launchEnv }) {
-        const env = createProviderEnv({
+        return claudeModeCatalog(this.buildProviderEnv(launchEnv)).defaultModeId;
+    }
+    buildProviderEnv(launchEnv) {
+        return createProviderEnv({
             baseEnv: process.env,
             runtimeSettings: this.runtimeSettings,
             overlays: [launchEnv],
         });
-        return claudeModeCatalog(env).defaultModeId;
     }
     async listFeatures(config) {
         const claudeConfig = this.assertConfig(config);
@@ -1140,7 +1141,7 @@ export class ClaudeAgentClient {
         });
     }
     async listImportableSessions(options) {
-        const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
+        const configDir = claudeConfigDir(this.buildProviderEnv());
         const sessionsRoot = options?.cwd
             ? claudeProjectDirSync(options.cwd, { configDir })
             : path.join(configDir, "projects");
@@ -4018,7 +4019,7 @@ class ClaudeAgentSession {
         const cwd = this.config.cwd;
         if (!cwd)
             return null;
-        const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
+        const configDir = claudeConfigDir(this.buildSdkEnv());
         const candidates = [cwd];
         try {
             const realCwd = fs.realpathSync(cwd);

package/dist/server/server/agent/providers/claude/models.d.ts

@@ -3,7 +3,7 @@ import type { AgentModelDefinition } from "../../agent-sdk-types.js";
 export declare function getClaudeModels(claudeCodeVersion?: string): AgentModelDefinition[];
 export declare function resolveConfiguredClaudeModel(model: AgentModelDefinition): AgentModelDefinition;
 export declare function findClaudeModel(modelId: string | null | undefined): AgentModelDefinition | undefined;
-export declare function getClaudeModelsWithSettings(logger: Logger, configDir?: string, claudeCodeVersion?: string): Promise<AgentModelDefinition[]>;
+export declare function getClaudeModelsWithSettings(logger: Logger, configDir: string, claudeCodeVersion?: string): Promise<AgentModelDefinition[]>;
 /**
  * Normalize a runtime model string (from SDK init message) to a known model ID.
  * Handles the `[1m]` suffix that the SDK appends for 1M context sessions.

package/dist/server/server/agent/providers/claude/models.js

@@ -1,5 +1,4 @@
 import * as fs from "node:fs/promises";
-import * as os from "node:os";
 import * as path from "node:path";
 import { getClaudeCustomModelThinkingOptions, getClaudeManifestModels, normalizeClaudeManifestModelId, normalizeClaudeRuntimeModelId as normalizeClaudeManifestRuntimeModelId, } from "./model-manifest.js";
 const CLAUDE_SETTINGS_MODEL_ENV_KEYS = [
@@ -55,7 +54,7 @@ export async function getClaudeModelsWithSettings(logger, configDir, claudeCodeV
     return models;
 }
 async function readClaudeSettingsModels(logger, configDir) {
-    const settingsPath = path.join(resolveClaudeConfigDir(configDir), "settings.json");
+    const settingsPath = path.join(configDir, "settings.json");
     let parsed;
     try {
         const rawSettings = await fs.readFile(settingsPath, "utf8");
@@ -84,9 +83,6 @@ async function readClaudeSettingsModels(logger, configDir) {
     }
     return models;
 }
-function resolveClaudeConfigDir(configDir) {
-    return configDir ?? process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
-}
 function addSettingsModel(models, value, settingsKey) {
     if (typeof value !== "string") {
         return;

package/dist/server/server/agent/providers/claude/project-dir.d.ts

@@ -3,4 +3,5 @@ export interface ClaudeProjectDirOptions {
 }
 export declare function claudeProjectDir(cwd: string, options?: ClaudeProjectDirOptions): Promise<string>;
 export declare function claudeProjectDirSync(cwd: string, options?: ClaudeProjectDirOptions): string;
+export declare function claudeConfigDir(env: NodeJS.ProcessEnv): string;
 //# sourceMappingURL=project-dir.d.ts.map

package/dist/server/server/agent/providers/claude/project-dir.js

@@ -51,7 +51,11 @@ function hashSuffix(input) {
     }
     return Math.abs(hash).toString(36);
 }
+// Claude Code keeps its settings and transcripts here for a process launched with `env`.
+export function claudeConfigDir(env) {
+    return env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+}
 function resolveConfigDir(options) {
-    return options?.configDir ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+    return options?.configDir ?? claudeConfigDir(process.env);
 }
 //# sourceMappingURL=project-dir.js.map

package/dist/server/server/agent/providers/codex-app-server-agent.d.ts

@@ -20,7 +20,7 @@ interface CodexAppServerAgentDeps {
         label: string;
         extends: string;
     };
-    customCodexConfig?: Record<string, unknown> | null;
+    customCodexConfig?: CodexCustomProviderConfig | null;
     _createCodexClient?: (child: ChildProcessWithoutNullStreams, logger: Logger, getTraceContext: () => CodexAppServerTraceContext) => CodexAppServerClientLike;
     resolveSlashCommandInvocation?: (prompt: AgentPromptInput) => Promise<{
         commandName: string;
@@ -108,6 +108,10 @@ type CodexAppServerUserInput = {
 } | CodexSkillPromptBlock;
 export declare function codexAppServerTurnInputFromPrompt(prompt: CodexPromptInput, logger: Logger): Promise<CodexAppServerUserInput[]>;
 export declare function buildCodexAppServerEnv(runtimeSettings?: ProviderRuntimeSettings, launchEnv?: Record<string, string>): NodeJS.ProcessEnv;
+interface CodexCustomProviderConfig {
+    model_provider: string;
+    model_providers: Record<string, Record<string, unknown>>;
+}
 export declare class CodexAppServerAgentSession implements AgentSession {
     private readonly resumeHandle;
     private readonly spawnAppServer;
@@ -359,6 +363,7 @@ export declare class CodexAppServerAgentClient implements AgentClient {
     private autoReviewEnabledPromise;
     constructor(logger: Logger, runtimeSettings?: ProviderRuntimeSettings | undefined, deps?: CodexAppServerAgentDeps);
     private sessionDeps;
+    private customProviderConfig;
     private resolveGoalsEnabled;
     private resolveAutoReviewEnabled;
     private probeAutoReviewEnabled;

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -635,6 +635,7 @@ async function readCodexThreadWindow(client, logger, window) {
             // Older Codex builds ignore the unknown key and keep that order.
             sortKey: "updated_at",
             ...(window.cwd ? { cwd: window.cwd } : {}),
+            ...(window.modelProviders ? { modelProviders: window.modelProviders } : {}),
             ...(cursor ? { cursor } : {}),
         }));
         const page = Array.isArray(response?.data) ? response.data.filter(isRecord) : [];
@@ -5604,9 +5605,12 @@ export class CodexAppServerAgentClient {
     sessionDeps() {
         return {
             ...this.deps,
-            customCodexConfig: buildCodexCustomProviderConfig(this.runtimeSettings, this.deps.customProvider),
+            customCodexConfig: this.customProviderConfig(),
         };
     }
+    customProviderConfig() {
+        return buildCodexCustomProviderConfig(this.runtimeSettings, this.deps.customProvider);
+    }
     resolveGoalsEnabled() {
         if (!this.goalsEnabledPromise) {
             this.goalsEnabledPromise = (async () => {
@@ -5717,9 +5721,14 @@ export class CodexAppServerAgentClient {
             // filtering since most threads will be from other cwds, then keep the
             // local realpath-aware filter for symlink-equivalent workspace paths.
             const listLimit = options?.cwd ? Math.max(scanLimit, 50) : scanLimit;
+            // Codex records each thread under the model provider that ran it and,
+            // unless told otherwise, lists only the provider its own config selects.
+            // A custom provider runs under its own id, so ask for exactly that one.
+            const customProviderConfig = this.customProviderConfig();
             const allThreads = await readCodexThreadWindow(client, this.logger, {
                 limit: listLimit,
                 cwd: options?.cwd,
+                ...(customProviderConfig ? { modelProviders: [customProviderConfig.model_provider] } : {}),
             });
             const threads = filterCodexThreadsByCwd(allThreads, options?.cwd);
             return threads.slice(0, limit).map((thread) => {

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

@@ -29,7 +29,9 @@ export class GenericACPAgentClient extends ACPAgentClient {
             },
             defaultCommand: options.command,
             capabilities: buildGenericACPCapabilities(providerParams),
-            waitForInitialCommands: options.waitForInitialCommands,
+            // ACP agents advertise slash commands with available_commands_update after
+            // session/new, so the first listCommands() waits for that batch.
+            waitForInitialCommands: options.waitForInitialCommands ?? true,
             initialCommandsWaitTimeoutMs: options.initialCommandsWaitTimeoutMs,
             clientCapabilities: providerParams.clientCapabilities,
             clientCapabilityMeta: options.clientCapabilityMeta,

package/dist/server/server/agent/providers/omp/agent.js

@@ -336,6 +336,17 @@ function getInputQuestionTitle(title, placeholder) {
     }
     return "Optional response";
 }
+function readSelectOptions(options, optionDetails) {
+    const labels = readStringArray(options);
+    const details = Array.isArray(optionDetails) ? optionDetails : [];
+    return labels.map((label, index) => {
+        const detail = details[index];
+        const description = isRecord(detail) && typeof detail.description === "string" && detail.description.trim() !== ""
+            ? detail.description
+            : undefined;
+        return description === undefined ? { label } : { label, description };
+    });
+}
 function readStringArray(value) {
     return Array.isArray(value)
         ? value.filter((item) => typeof item === "string")
@@ -349,7 +360,7 @@ function mapExtensionUiRequestToPermission(event, options = {}) {
     const label = options.label ?? "OMP";
     switch (event.method) {
         case "select": {
-            const selectOptions = readStringArray(event.options);
+            const selectOptions = readSelectOptions(event.options, event.optionDetails);
             if (options.combineOptionalComment) {
                 return buildCombinedAskUserQuestionPermission(event, {
                     provider,
@@ -396,7 +407,7 @@ function mapExtensionUiRequestToPermission(event, options = {}) {
                 question: [optionalString(event.title), optionalString(event.message)]
                     .filter(Boolean)
                     .join("\n\n"),
-                options: ["Yes", "No"],
+                options: [{ label: "Yes" }, { label: "No" }],
                 multiSelect: false,
             });
         default:
@@ -439,7 +450,10 @@ function buildExtensionUiQuestionPermission(event, input) {
                 {
                     question: input.question,
                     header: QUESTION_RESPONSE_HEADER,
-                    options: input.options.map((label) => ({ label })),
+                    options: input.options.map((option) => ({
+                        label: option.label,
+                        ...(option.description === undefined ? {} : { description: option.description }),
+                    })),
                     multiSelect: input.multiSelect,
                     ...(input.placeholder ? { placeholder: input.placeholder } : {}),
                     ...(input.allowEmpty ? { allowEmpty: true } : {}),
@@ -454,7 +468,7 @@ function buildExtensionUiQuestionPermission(event, input) {
     };
 }
 function buildCombinedAskUserQuestionPermission(event, input) {
-    const visibleOptions = input.options.filter((option) => !isOmpAskUserFreeformOption(option));
+    const visibleOptions = input.options.filter((option) => !isOmpAskUserFreeformOption(option.label));
     const allowOther = input.allowFreeform || visibleOptions.length !== input.options.length;
     return {
         id: event.id,
@@ -467,7 +481,10 @@ function buildCombinedAskUserQuestionPermission(event, input) {
                 {
                     question: input.question,
                     header: QUESTION_RESPONSE_HEADER,
-                    options: visibleOptions.map((label) => ({ label })),
+                    options: visibleOptions.map((option) => ({
+                        label: option.label,
+                        ...(option.description === undefined ? {} : { description: option.description }),
+                    })),
                     multiSelect: false,
                     ...(allowOther ? { allowOther: true } : {}),
                 },
@@ -486,7 +503,7 @@ function buildCombinedAskUserQuestionPermission(event, input) {
             answerHeader: QUESTION_RESPONSE_HEADER,
             commentHeader: QUESTION_COMMENT_HEADER,
             combinedAskUser: COMBINED_ASK_USER_METADATA,
-            selectOptions: visibleOptions,
+            selectOptions: visibleOptions.map((option) => option.label),
             ...(allowOther ? { freeformSentinel: OMP_ASK_USER_FREEFORM_SENTINEL } : {}),
         },
     };

package/dist/server/server/agent/providers/omp/rpc-types.d.ts

@@ -1325,6 +1325,7 @@ export declare const OmpRuntimeEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     title: z.ZodOptional<z.ZodString>;
     message: z.ZodOptional<z.ZodString>;
     options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optionDetails: z.ZodOptional<z.ZodUnknown>;
     placeholder: z.ZodOptional<z.ZodString>;
     url: z.ZodOptional<z.ZodString>;
     launchUrl: z.ZodOptional<z.ZodString>;

package/dist/server/server/agent/providers/omp/rpc-types.js

@@ -425,6 +425,7 @@ const OmpExtensionUiRequestSchema = z
     title: z.string().optional(),
     message: z.string().optional(),
     options: z.array(z.string()).optional(),
+    optionDetails: z.unknown().optional(),
     placeholder: z.string().optional(),
     url: z.string().optional(),
     launchUrl: z.string().optional(),