@keyou007/agent-bot 0.1.20-alpha.1 → 0.1.21

package/dist/codex/CodexRuntime.js

@@ -1,3 +1,4 @@
+import { statSync } from "node:fs";
 import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import { AppServerRequestError } from "./AppServerConnection.js";
@@ -5,6 +6,8 @@ import { mapCodexNotification } from "./CodexEventMapper.js";
 import { CodexLocalActivityDetector } from "./CodexLocalActivityDetector.js";
 import { detectProjectlessWorkspace } from "./ProjectlessWorkspace.js";
 import { threadWriterLockPath } from "./ThreadWriterProcess.js";
+import { assertProviderSettingsApplied, PROVIDER_SWITCH_BUSY, providerSwitchFailure } from "./ProviderSwitch.js";
+import { fetchProviderModels } from "./ProviderModels.js";
 const WINDOWS_SCREENSHOT_DEVELOPER_INSTRUCTIONS = [
     "When capturing any screenshot on Windows, use one fresh process and make it Per-Monitor DPI Aware V2 before loading System.Windows.Forms, System.Drawing, or UI Automation, and before calling any screen, window, or bounds API.",
     "Call user32!SetProcessDpiAwarenessContext((IntPtr)-4) in that same process and verify that it succeeded or that the process is already PMv2 before continuing.",
@@ -16,10 +19,10 @@ const WINDOWS_SCREENSHOT_DEVELOPER_INSTRUCTIONS = [
 const SESSION_REQUEST_TIMEOUT_MS = 60_000;
 const CONTROL_REQUEST_TIMEOUT_MS = 10_000;
 const SYNC_REQUEST_TIMEOUT_MS = 5_000;
-const THREAD_TURN_PAGE_SIZE = 100;
 const FORK_SOURCE_TURN_PAGE_SIZE = 20;
 const FORK_SOURCE_REQUEST_TIMEOUT_MS = 15_000;
 const USER_RESUMABLE_THREAD_SOURCE_KINDS = ["cli", "vscode", "exec", "appServer"];
+const BUILT_IN_CODEX_PROVIDER_ID = "openai";
 // A timed-out fork keeps running in App Server and can create an orphan thread.
 // Wait for its response; connection closure still rejects the request.
 const FORK_REQUEST_TIMEOUT_MS = 0;
@@ -34,9 +37,9 @@ export class CodexRuntime {
     unsubscribe;
     unsubscribeDisconnect;
     sessionSyncs = new Map();
+    sessionOperations = new Map();
     localActivityDetector;
     codexHome;
-    threadListSortKey = "recency_at";
     releaseInFlight;
     constructor(provider, logger) {
         this.provider = provider;
@@ -56,6 +59,9 @@ export class CodexRuntime {
         return this.codexHome ? threadWriterLockPath(this.codexHome, remoteSessionId) : undefined;
     }
     async createSession(input) {
+        return this.runSessionOperation(input.localSessionId, () => this.createSessionNow(input));
+    }
+    async createSessionNow(input) {
         const client = await this.client();
         const response = await client.request("thread/start", {
             cwd: input.cwd,
@@ -80,6 +86,9 @@ export class CodexRuntime {
         return session;
     }
     async resumeSession(input) {
+        return this.runSessionOperation(input.localSessionId, () => this.resumeSessionNow(input));
+    }
+    async resumeSessionNow(input) {
         const client = await this.client();
         const response = await client.request("thread/resume", {
             threadId: input.remoteSessionId,
@@ -96,6 +105,9 @@ export class CodexRuntime {
         return session;
     }
     async forkSession(input) {
+        return this.runSessionOperation(input.localSessionId, () => this.forkSessionNow(input));
+    }
+    async forkSessionNow(input) {
         const client = await this.client();
         const forkParams = {
             threadId: input.remoteSessionId,
@@ -107,19 +119,10 @@ export class CodexRuntime {
             ...threadLifecycleParams(input.cwd),
             ...permissionParams(input.permissionMode),
         };
-        let response;
-        try {
-            response = await client.request("thread/fork", {
-                ...forkParams,
-                excludeTurns: true,
-            }, FORK_REQUEST_TIMEOUT_MS);
-        }
-        catch (error) {
-            if (!isUnsupportedExcludeTurnsError(error))
-                throw error;
-            this.logger.warn({ error }, "App Server does not support thread/fork excludeTurns; retrying without it.");
-            response = await client.request("thread/fork", forkParams, FORK_REQUEST_TIMEOUT_MS);
-        }
+        const response = await client.request("thread/fork", {
+            ...forkParams,
+            excludeTurns: true,
+        }, FORK_REQUEST_TIMEOUT_MS);
         const requestedTitle = normalizeTaskTitle(input.title);
         if (requestedTitle) {
             await client.request("thread/name/set", {
@@ -135,9 +138,13 @@ export class CodexRuntime {
         return session;
     }
     async startTurn(sessionId, prompt) {
+        return this.runSessionOperation(sessionId, () => this.startTurnNow(sessionId, prompt));
+    }
+    async startTurnNow(sessionId, prompt) {
         const session = this.requireSession(sessionId);
         const client = await this.client();
         await this.ensureSessionResumed(session, client);
+        session.canReplaceEmptyThread = false;
         const start = () => client.request("turn/start", {
             threadId: session.remoteSessionId,
             input: codexUserInput(prompt),
@@ -172,24 +179,14 @@ export class CodexRuntime {
     }
     async listRemoteSessions(input = {}) {
         const client = await this.client();
-        let response;
-        try {
-            response = await this.requestThreadList(client, input, this.threadListSortKey);
-        }
-        catch (error) {
-            if (this.threadListSortKey !== "recency_at" || !isUnsupportedRecencySortError(error))
-                throw error;
-            this.threadListSortKey = "updated_at";
-            this.logger.warn({ error }, "App Server does not support thread/list recency_at sorting; retrying with updated_at.");
-            response = await this.requestThreadList(client, input, this.threadListSortKey);
-        }
+        const response = await this.requestThreadList(client, input);
         const sessions = await Promise.all(response.data.map(async (thread) => {
             const listed = remoteSessionSummary(thread);
             if (listed.status === "active" || listed.lastTurnStatus === "inProgress")
                 return listed;
             try {
-                const detail = await client.request("thread/read", { threadId: thread.id, includeTurns: true }, SYNC_REQUEST_TIMEOUT_MS);
-                return mergeRemoteSessionSummary(listed, remoteSessionSummary(detail.thread));
+                const turns = await this.readLatestThreadTurns(client, thread.id, "summary");
+                return mergeRemoteSessionSummary(listed, remoteSessionSummary({ ...thread, turns }));
             }
             catch {
                 return listed;
@@ -203,35 +200,84 @@ export class CodexRuntime {
             nextCursor: response.nextCursor ?? undefined,
         };
     }
-    requestThreadList(client, input, sortKey) {
+    requestThreadList(client, input) {
         return client.request("thread/list", {
             cursor: input.cursor,
             limit: input.limit ?? 20,
-            sortKey,
+            sortKey: this.provider.getAgentFamily?.() === "traex" ? "updated_at" : "recency_at",
             sortDirection: "desc",
+            // Omitting this filter only lists the App Server's current Provider.
+            modelProviders: [],
             sourceKinds: USER_RESUMABLE_THREAD_SOURCE_KINDS,
             archived: false,
             searchTerm: input.searchTerm,
         }, CONTROL_REQUEST_TIMEOUT_MS);
     }
-    async readRemoteSession(remoteSessionId) {
+    async readRemoteSession(remoteSessionId, view = "latest") {
+        const client = await this.client();
+        const response = await client.request("thread/read", { threadId: remoteSessionId, includeTurns: false }, SYNC_REQUEST_TIMEOUT_MS);
+        const turns = view === "metadata" ? []
+            : await this.readLatestThreadTurns(client, remoteSessionId, view === "latest-full" ? "full" : "summary");
+        return this.decorateRemoteSession(remoteSessionId, remoteSessionSummary({ ...response.thread, turns }));
+    }
+    async readRemoteSessionMetrics(remoteSessionId) {
         const client = await this.client();
-        const response = await this.readThreadWithTurns(client, remoteSessionId);
-        return this.decorateRemoteSession(remoteSessionId, remoteSessionSummary(response.thread));
+        const metadata = await client.request("thread/read", { threadId: remoteSessionId, includeTurns: false }, SYNC_REQUEST_TIMEOUT_MS);
+        const { turnCount, turnIds } = await this.countRemoteTurns(client, remoteSessionId);
+        const rolloutPath = stringValue(metadata.thread.path)?.trim() || undefined;
+        const loaded = [...this.sessions.values()].filter((session) => session.remoteSessionId === remoteSessionId);
+        for (const session of loaded) {
+            session.rolloutPath = rolloutPath ?? session.rolloutPath;
+            const knownTurnIds = new Set(turnIds);
+            if (session.activeTurnId && !knownTurnIds.has(session.activeTurnId))
+                knownTurnIds.add(session.activeTurnId);
+            session.knownTurnIds = knownTurnIds;
+            session.turnCount = knownTurnIds.size;
+        }
+        const effectivePath = rolloutPath ?? loaded[0]?.rolloutPath;
+        return {
+            turnCount: loaded[0]?.turnCount ?? turnCount,
+            storageBytes: rolloutStorageBytes(effectivePath),
+        };
+    }
+    async countRemoteTurns(client, remoteSessionId) {
+        const turnIds = new Set();
+        const seenCursors = new Set();
+        let cursor;
+        do {
+            const page = await this.readTurnPage(client, remoteSessionId, {
+                cursor,
+                limit: 100,
+                itemsView: "summary",
+            }, CONTROL_REQUEST_TIMEOUT_MS);
+            for (const turn of page.data)
+                turnIds.add(turn.id);
+            const nextCursor = page.nextCursor ?? undefined;
+            if (!nextCursor)
+                break;
+            if (nextCursor === cursor || seenCursors.has(nextCursor)) {
+                throw new Error("App Server repeated a Turn history cursor while counting task Turns.");
+            }
+            seenCursors.add(nextCursor);
+            cursor = nextCursor;
+        } while (cursor);
+        return { turnCount: turnIds.size, turnIds };
+    }
+    async listRemoteTurnSummaries(remoteSessionId, input) {
+        const response = await this.readTurnPage(await this.client(), remoteSessionId, {
+            cursor: input.cursor,
+            limit: Math.max(1, Math.min(100, Math.trunc(input.limit))),
+            itemsView: "summary",
+        });
+        return {
+            turns: remoteSessionSummary({ id: remoteSessionId, turns: response.data }).completedTurns ?? [],
+            nextCursor: response.nextCursor ?? undefined,
+        };
     }
     async readRemoteForkSource(remoteSessionId) {
         const client = await this.client();
         const metadata = await client.request("thread/read", { threadId: remoteSessionId, includeTurns: false }, FORK_SOURCE_REQUEST_TIMEOUT_MS);
-        let turns;
-        try {
-            turns = await this.listRecentThreadTurnsThroughCompleted(client, remoteSessionId);
-        }
-        catch (error) {
-            if (!isUnsupportedThreadTurnsListError(error))
-                throw error;
-            this.logger.warn({ error, remoteSessionId }, "App Server does not support lightweight Fork source reads; falling back to complete thread history.");
-            return this.readRemoteSession(remoteSessionId);
-        }
+        const turns = await this.listRecentThreadTurnsThroughCompleted(client, remoteSessionId);
         return this.decorateRemoteSession(remoteSessionId, remoteSessionSummary({
             ...metadata.thread,
             turns,
@@ -251,12 +297,8 @@ export class CodexRuntime {
         const seenCursors = new Set();
         let cursor;
         do {
-            const response = await client.request("thread/turns/list", {
-                threadId: remoteSessionId,
-                ...(cursor ? { cursor } : {}),
-                limit: FORK_SOURCE_TURN_PAGE_SIZE,
-                sortDirection: "desc",
-                itemsView: "summary",
+            const response = await this.readTurnPage(client, remoteSessionId, {
+                cursor, limit: FORK_SOURCE_TURN_PAGE_SIZE, itemsView: "summary",
             }, FORK_SOURCE_REQUEST_TIMEOUT_MS);
             turns.push(...response.data);
             const completedIndex = turns.findIndex((turn) => turn.status === "completed");
@@ -276,49 +318,25 @@ export class CodexRuntime {
         } while (cursor);
         return turns.reverse();
     }
-    async readThreadWithTurns(client, remoteSessionId) {
+    async readLatestThreadTurns(client, remoteSessionId, itemsView) {
+        const response = await this.readTurnPage(client, remoteSessionId, { limit: 1, itemsView });
+        return response.data;
+    }
+    async readTurnPage(client, remoteSessionId, input, timeoutMs = SYNC_REQUEST_TIMEOUT_MS) {
         try {
-            return await client.request("thread/read", { threadId: remoteSessionId, includeTurns: true }, SYNC_REQUEST_TIMEOUT_MS);
+            return await client.request("thread/turns/list", {
+                threadId: remoteSessionId,
+                ...(input.cursor ? { cursor: input.cursor } : {}),
+                limit: input.limit, sortDirection: "desc", itemsView: input.itemsView,
+            }, timeoutMs);
         }
         catch (error) {
-            const paginated = isPaginatedThreadReadError(error);
-            if (!paginated && !isUnmaterializedThreadReadError(error))
-                throw error;
-            const metadata = await client.request("thread/read", { threadId: remoteSessionId, includeTurns: false }, SYNC_REQUEST_TIMEOUT_MS);
-            if (!paginated)
-                return { thread: { ...metadata.thread, turns: [] } };
-            return {
-                thread: {
-                    ...metadata.thread,
-                    turns: await this.listThreadTurns(client, remoteSessionId),
-                },
-            };
-        }
-    }
-    async listThreadTurns(client, remoteSessionId) {
-        const turns = [];
-        const seenCursors = new Set();
-        let cursor;
-        do {
-            const response = await client.request("thread/turns/list", {
-                threadId: remoteSessionId,
-                ...(cursor ? { cursor } : {}),
-                limit: THREAD_TURN_PAGE_SIZE,
-                sortDirection: "asc",
-                itemsView: "full",
-            }, SYNC_REQUEST_TIMEOUT_MS);
-            turns.push(...response.data);
-            const nextCursor = response.nextCursor ?? undefined;
-            if (!nextCursor)
-                break;
-            if (seenCursors.has(nextCursor)) {
-                this.logger.warn({ remoteSessionId, cursor: nextCursor }, "App Server repeated a thread Turn pagination cursor; stopping pagination.");
-                break;
+            if (error instanceof AppServerRequestError && error.method === "thread/turns/list"
+                && /not materialized yet; thread\/turns\/list is unavailable before first user message/i.test(error.serverMessage)) {
+                return { data: [], nextCursor: null };
             }
-            seenCursors.add(nextCursor);
-            cursor = nextCursor;
-        } while (cursor);
-        return turns;
+            throw error;
+        }
     }
     async inspectRemoteSessionActivity(remoteSessionId) {
         const [response, activeThreads] = await Promise.all([
@@ -341,7 +359,7 @@ export class CodexRuntime {
         const existing = this.sessionSyncs.get(sessionId);
         if (existing)
             return existing;
-        const synchronization = this.synchronizeSessionNow(sessionId);
+        const synchronization = this.runSessionOperation(sessionId, () => this.synchronizeSessionNow(sessionId));
         this.sessionSyncs.set(sessionId, synchronization);
         try {
             return await synchronization;
@@ -368,8 +386,10 @@ export class CodexRuntime {
         this.logger.info({ ...(sessionId ? { sessionId } : {}), threadId: remoteSessionId, turnId }, "App Server accepted the turn interrupt request.");
     }
     async closeSession(sessionId) {
-        const session = this.requireSession(sessionId);
-        await this.archiveRemoteSession(session.remoteSessionId);
+        await this.runSessionOperation(sessionId, async () => {
+            const session = this.requireSession(sessionId);
+            await this.archiveRemoteSession(session.remoteSessionId);
+        });
     }
     async archiveRemoteSession(remoteSessionId) {
         await (await this.client()).request("thread/archive", { threadId: remoteSessionId }, CONTROL_REQUEST_TIMEOUT_MS);
@@ -379,6 +399,9 @@ export class CodexRuntime {
         }
     }
     async setTitle(sessionId, title) {
+        return this.runSessionOperation(sessionId, () => this.setTitleNow(sessionId, title));
+    }
+    async setTitleNow(sessionId, title) {
         const session = this.requireSession(sessionId);
         const normalizedTitle = normalizeTaskTitle(title);
         if (!normalizedTitle)
@@ -387,6 +410,9 @@ export class CodexRuntime {
         session.title = normalizedTitle;
     }
     async getGoal(sessionId) {
+        return this.runSessionOperation(sessionId, () => this.getGoalNow(sessionId));
+    }
+    async getGoalNow(sessionId) {
         const session = this.requireSession(sessionId);
         const client = await this.client();
         await this.ensureSessionResumed(session, client);
@@ -394,13 +420,20 @@ export class CodexRuntime {
         return response.goal ?? undefined;
     }
     async setGoal(sessionId, update) {
+        return this.runSessionOperation(sessionId, () => this.setGoalNow(sessionId, update));
+    }
+    async setGoalNow(sessionId, update) {
         const session = this.requireSession(sessionId);
         const client = await this.client();
         await this.ensureSessionResumed(session, client);
+        session.canReplaceEmptyThread = false;
         const response = await client.request("thread/goal/set", { threadId: session.remoteSessionId, ...update }, CONTROL_REQUEST_TIMEOUT_MS);
         return response.goal;
     }
     async clearGoal(sessionId) {
+        return this.runSessionOperation(sessionId, () => this.clearGoalNow(sessionId));
+    }
+    async clearGoalNow(sessionId) {
         const session = this.requireSession(sessionId);
         const client = await this.client();
         await this.ensureSessionResumed(session, client);
@@ -408,32 +441,132 @@ export class CodexRuntime {
         return response.cleared;
     }
     async setModel(sessionId, model) {
-        this.requireSession(sessionId).model = model;
+        await this.runSessionOperation(sessionId, async () => { this.requireSession(sessionId).model = model; });
     }
     async setReasoningEffort(sessionId, effort) {
-        this.requireSession(sessionId).reasoningEffort = effort;
+        await this.runSessionOperation(sessionId, async () => { this.requireSession(sessionId).reasoningEffort = effort; });
     }
     async setPermissionMode(sessionId, mode) {
-        this.requireSession(sessionId).permissionMode = mode;
+        await this.runSessionOperation(sessionId, async () => { this.requireSession(sessionId).permissionMode = mode; });
+    }
+    async setExecutionSettings(sessionId, settings, persist) {
+        return this.runSessionOperation(sessionId, () => this.setExecutionSettingsNow(sessionId, settings, persist));
     }
-    async setExecutionSettings(sessionId, settings) {
+    async setExecutionSettingsNow(sessionId, settings, persist) {
         const session = this.requireSession(sessionId);
-        const response = await (await this.client()).request("thread/resume", {
-            threadId: session.remoteSessionId,
-            excludeTurns: true,
-            cwd: session.cwd,
-            modelProvider: settings.modelProvider,
-            model: settings.model,
-            ...threadLifecycleParams(session.cwd),
-            ...permissionParams(settings.permissionMode),
-        }, SESSION_REQUEST_TIMEOUT_MS);
-        session.modelProvider = response.modelProvider ?? settings.modelProvider;
-        session.model = response.model ?? settings.model;
-        session.reasoningEffort = settings.reasoningEffort;
-        session.permissionMode = settings.permissionMode;
-        session.needsResume = false;
+        if (session.activeTurnId)
+            throw new Error(PROVIDER_SWITCH_BUSY);
+        const client = await this.client();
+        const metadata = await client.request("thread/read", {
+            threadId: session.remoteSessionId, includeTurns: false,
+        }, SYNC_REQUEST_TIMEOUT_MS);
+        const localActive = await this.localActivityDetector?.activeThreads([session.remoteSessionId]);
+        if (metadata.thread.status?.type === "active" || localActive?.has(session.remoteSessionId) || session.activeTurnId) {
+            throw new Error(PROVIDER_SWITCH_BUSY);
+        }
+        let empty = false;
+        if (session.canReplaceEmptyThread && !metadata.thread.forkedFromId && !metadata.thread.preview?.trim()) {
+            try {
+                const turns = await this.readLatestThreadTurns(client, session.remoteSessionId, "summary");
+                empty = turns.length === 0;
+                if (!empty)
+                    session.canReplaceEmptyThread = false;
+            }
+            catch (error) {
+                if (!(error instanceof AppServerRequestError) || error.method !== "thread/turns/list"
+                    || !/missing source rollout|no rollout found/iu.test(error.serverMessage))
+                    throw error;
+                empty = true;
+            }
+        }
+        const previous = { ...session };
+        let replacementId;
+        let detached = false;
+        try {
+            const params = {
+                cwd: session.cwd, modelProvider: settings.modelProvider, model: settings.model,
+                ...threadLifecycleParams(session.cwd), ...permissionParams(settings.permissionMode),
+            };
+            if (!empty) {
+                await this.detachThreadForSettings(client, session);
+                detached = true;
+            }
+            const response = empty
+                ? await client.request("thread/start", {
+                    ...params, threadSource: "user", allowProviderModelFallback: false,
+                }, SESSION_REQUEST_TIMEOUT_MS)
+                : await client.request("thread/resume", {
+                    ...params, threadId: session.remoteSessionId, excludeTurns: true,
+                }, SESSION_REQUEST_TIMEOUT_MS);
+            if (empty)
+                replacementId = response.thread.id;
+            assertProviderSettingsApplied(response, settings);
+            if (!empty && response.thread.id !== session.remoteSessionId)
+                throw new Error("App Server 返回了不同的任务 ID，未保存设置。");
+            if (empty && session.title)
+                await client.request("thread/name/set", {
+                    threadId: response.thread.id, name: session.title,
+                }, SESSION_REQUEST_TIMEOUT_MS);
+            const candidate = { ...session, ...settings, remoteSessionId: response.thread.id,
+                needsResume: false, settingsRecoveryError: undefined };
+            await persist?.(candidate);
+            Object.assign(session, candidate);
+        }
+        catch (error) {
+            if (replacementId)
+                await this.discardUnusedThread(client, replacementId);
+            let recovery = "原任务设置未更改。";
+            if (detached) {
+                try {
+                    await this.detachThreadForSettings(client, previous);
+                    const restored = await client.request("thread/resume", {
+                        threadId: previous.remoteSessionId, excludeTurns: true, cwd: previous.cwd,
+                        modelProvider: previous.modelProvider, model: previous.model,
+                        ...threadLifecycleParams(previous.cwd), ...permissionParams(previous.permissionMode),
+                    }, SESSION_REQUEST_TIMEOUT_MS);
+                    if (previous.modelProvider && previous.model)
+                        assertProviderSettingsApplied(restored, {
+                            modelProvider: previous.modelProvider, model: previous.model,
+                        });
+                    if (restored.thread.id !== previous.remoteSessionId)
+                        throw new Error("恢复时返回了不同的任务 ID。");
+                    session.needsResume = false;
+                    session.settingsRecoveryError = undefined;
+                }
+                catch (restoreError) {
+                    this.logger.warn({ error: restoreError, sessionId }, "Failed to restore Provider after a rejected settings change.");
+                    recovery = "原设置仍保留，但远端恢复失败；请重新切换 Provider，确认成功后再发送消息。";
+                    session.settingsRecoveryError = recovery;
+                    session.needsResume = true;
+                }
+            }
+            throw new Error(`Provider 切换失败：${providerSwitchFailure(error)} ${recovery}`, { cause: error });
+        }
+        if (replacementId)
+            await this.discardUnusedThread(client, previous.remoteSessionId);
         return session;
     }
+    async detachThreadForSettings(client, session) {
+        const current = await client.request("thread/read", {
+            threadId: session.remoteSessionId, includeTurns: false,
+        }, SYNC_REQUEST_TIMEOUT_MS);
+        if (session.activeTurnId || current.thread.status?.type === "active")
+            throw new Error(PROVIDER_SWITCH_BUSY);
+        const result = await client.request("thread/unsubscribe", {
+            threadId: session.remoteSessionId,
+        }, CONTROL_REQUEST_TIMEOUT_MS);
+        if (result.status !== "unsubscribed" && result.status !== "notLoaded") {
+            throw new Error("当前任务仍由其他客户端加载，无法安全切换 Provider。请先在原客户端释放任务。");
+        }
+    }
+    async discardUnusedThread(client, threadId) {
+        try {
+            await client.request("thread/unsubscribe", { threadId }, CONTROL_REQUEST_TIMEOUT_MS);
+        }
+        catch (error) {
+            this.logger.warn({ error, threadId }, "Failed to release an unused empty Thread after changing Provider.");
+        }
+    }
     async respondToApproval(sessionId, requestId, decision) {
         const pending = this.approvals.get(requestId);
         if (!pending || pending.sessionId !== sessionId)
@@ -442,7 +575,43 @@ export class CodexRuntime {
         pending.resolve({ decision });
         this.emit({ type: "approval_resolved", sessionId, turnId: pending.turnId, requestId, decision });
     }
-    async listModels() {
+    async listModels(modelProvider, fallbackModel) {
+        const requestedProvider = modelProvider?.trim();
+        if (!requestedProvider
+            || (requestedProvider === BUILT_IN_CODEX_PROVIDER_ID && this.provider.getAgentFamily?.() !== "traex")) {
+            return this.listCatalogModels();
+        }
+        const config = await this.readConfig();
+        const configuredProviders = isRecord(config.model_providers) ? config.model_providers : {};
+        const providerConfig = configuredProviders[requestedProvider];
+        let catalog = [];
+        try {
+            catalog = await this.listCatalogModels();
+        }
+        catch (error) {
+            this.logger.warn({ error, modelProvider: requestedProvider }, "Failed to read the App Server model catalog while discovering Provider models.");
+        }
+        const configuredDefaultModel = stringValue(config.model_provider)?.trim() === requestedProvider
+            ? stringValue(config.model)?.trim()
+            : undefined;
+        try {
+            return await fetchProviderModels({
+                providerId: requestedProvider,
+                config: (isRecord(providerConfig) ? providerConfig : {}),
+                catalog,
+                configuredDefaultModel,
+                environmentValue: (name) => this.provider.getEnvironmentVariable?.(name) ?? process.env[name],
+            });
+        }
+        catch (error) {
+            const fallback = fallbackProviderModel(catalog, fallbackModel, configuredDefaultModel);
+            if (!fallback)
+                throw error;
+            this.logger.warn({ error, modelProvider: requestedProvider, fallbackModel: fallback.id }, "Provider model discovery failed; using the current or configured model as a fallback.");
+            return [fallback];
+        }
+    }
+    async listCatalogModels() {
         const response = await (await this.client()).request("model/list", {});
         return response.data.filter((model) => model.id).map((model) => ({
             id: model.id,
@@ -456,8 +625,7 @@ export class CodexRuntime {
         }));
     }
     async listModelProviders() {
-        const response = await (await this.client()).request("config/read", {}, CONTROL_REQUEST_TIMEOUT_MS);
-        const config = response.config ?? {};
+        const config = await this.readConfig();
         const defaultProvider = stringValue(config.model_provider)?.trim();
         const configuredProviders = isRecord(config.model_providers) ? config.model_providers : {};
         const providers = new Map();
@@ -471,11 +639,22 @@ export class CodexRuntime {
                 ...(id === defaultProvider ? { isDefault: true } : {}),
             });
         }
+        if (this.provider.getAgentFamily?.() === "codex" && !providers.has(BUILT_IN_CODEX_PROVIDER_ID)) {
+            providers.set(BUILT_IN_CODEX_PROVIDER_ID, {
+                id: BUILT_IN_CODEX_PROVIDER_ID,
+                displayName: "OpenAI",
+                ...(!defaultProvider ? { isDefault: true } : {}),
+            });
+        }
         if (defaultProvider && !providers.has(defaultProvider)) {
             providers.set(defaultProvider, { id: defaultProvider, isDefault: true });
         }
         return [...providers.values()].sort((left, right) => Number(Boolean(right.isDefault)) - Number(Boolean(left.isDefault)) || left.id.localeCompare(right.id));
     }
+    async readConfig() {
+        const response = await (await this.client()).request("config/read", {}, CONTROL_REQUEST_TIMEOUT_MS);
+        return response.config ?? {};
+    }
     onEvent(listener) {
         this.listeners.add(listener);
         return () => this.listeners.delete(listener);
@@ -484,7 +663,7 @@ export class CodexRuntime {
         if (this.releaseInFlight)
             return this.releaseInFlight;
         const activeSessionIds = [...this.sessions.values()]
-            .filter((session) => Boolean(session.activeTurnId))
+            .filter((session) => Boolean(session.activeTurnId) || this.sessionOperations.has(session.localSessionId))
             .map((session) => session.localSessionId);
         if (activeSessionIds.length > 0 && options.force !== true) {
             return { status: "busy", activeSessionIds };
@@ -606,6 +785,19 @@ export class CodexRuntime {
                 turnId: mapped.turnId,
                 lastTokens: mapped.lastTokens,
                 cumulativeTokens: mapped.cumulativeTokens,
+                contextTokens: mapped.contextTokens,
+            });
+        }
+        else if (mapped.kind === "context_compaction") {
+            this.emit({
+                type: "context_compaction",
+                sessionId,
+                turnId: mapped.turnId,
+                phase: mapped.phase,
+                compactionId: mapped.compactionId,
+                timestampMs: mapped.timestampMs,
+                turnCount: session.turnCount,
+                storageBytes: rolloutStorageBytes(session.rolloutPath),
             });
         }
         else if (mapped.kind === "agent_message_phase") {
@@ -726,11 +918,13 @@ export class CodexRuntime {
         if (response.reasoningEffort)
             return response.reasoningEffort;
         const model = input.model ?? response.model;
-        const models = await this.listModels();
+        const models = await this.listModels(input.modelProvider ?? response.modelProvider, model);
         return models.find((item) => item.id === model)?.defaultReasoningEffort
             ?? models.find((item) => item.isDefault)?.defaultReasoningEffort;
     }
     async ensureSessionResumed(session, client) {
+        if (session.settingsRecoveryError)
+            throw new Error(session.settingsRecoveryError);
         if (!session.needsResume)
             return;
         await this.resumeAppServerSession(session, client);
@@ -749,9 +943,12 @@ export class CodexRuntime {
     }
     async synchronizeSessionNow(sessionId) {
         const session = this.requireSession(sessionId);
-        const response = await (await this.client()).request("thread/read", { threadId: session.remoteSessionId, includeTurns: true }, SYNC_REQUEST_TIMEOUT_MS);
-        this.reconcileThreadSnapshot(session, response.thread);
-        return session;
+        const client = await this.client();
+        const response = await client.request("thread/read", { threadId: session.remoteSessionId, includeTurns: false }, SYNC_REQUEST_TIMEOUT_MS);
+        const turns = await this.readLatestThreadTurns(client, session.remoteSessionId, "full");
+        const thread = { ...response.thread, turns };
+        this.reconcileThreadSnapshot(session, thread);
+        return { ...session, remoteSummary: await this.decorateRemoteSession(session.remoteSessionId, remoteSessionSummary(thread)) };
     }
     reconcileThreadSnapshot(session, thread) {
         const turns = Array.isArray(thread.turns) ? thread.turns : [];
@@ -796,6 +993,12 @@ export class CodexRuntime {
         this.finishSnapshotTurn(session, latest);
     }
     adoptTurn(session, turnId, startedAt) {
+        session.canReplaceEmptyThread = false;
+        if (!session.knownTurnIds.has(turnId)) {
+            session.knownTurnIds.add(turnId);
+            if (session.turnCount !== undefined)
+                session.turnCount += 1;
+        }
         session.activeTurnId = turnId;
         session.activeTurnStartedAt = startedAt;
         session.finalText = "";
@@ -873,6 +1076,10 @@ export class CodexRuntime {
             generatedImagePaths: [],
             messagePhases: new Map(),
             needsResume: false,
+            canReplaceEmptyThread: !("remoteSessionId" in input),
+            rolloutPath: stringValue(response.thread.path)?.trim() || undefined,
+            turnCount: "remoteSessionId" in input ? undefined : 0,
+            knownTurnIds: new Set(),
         };
     }
     requireSession(sessionId) {
@@ -881,6 +1088,18 @@ export class CodexRuntime {
             throw new Error(`Unknown App Server session: ${sessionId}`);
         return session;
     }
+    async runSessionOperation(sessionId, operation) {
+        const previous = this.sessionOperations.get(sessionId);
+        const current = (previous ?? Promise.resolve()).catch(() => undefined).then(operation);
+        this.sessionOperations.set(sessionId, current);
+        try {
+            return await current;
+        }
+        finally {
+            if (this.sessionOperations.get(sessionId) === current)
+                this.sessionOperations.delete(sessionId);
+        }
+    }
     requireActiveTurn(sessionId, turnId) {
         const session = this.requireSession(sessionId);
         if (session.activeTurnId !== turnId)
@@ -957,6 +1176,31 @@ function isRecord(value) {
 function stringValue(value) {
     return typeof value === "string" ? value : undefined;
 }
+function rolloutStorageBytes(filePath) {
+    if (!filePath)
+        return undefined;
+    try {
+        const stats = statSync(filePath);
+        return stats.isFile() ? stats.size : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function fallbackProviderModel(catalog, requestedModel, configuredDefaultModel) {
+    const id = requestedModel?.trim()
+        || configuredDefaultModel?.trim()
+        || catalog.find((model) => model.isDefault)?.id
+        || catalog[0]?.id;
+    if (!id)
+        return undefined;
+    const catalogModel = catalog.find((model) => model.id === id);
+    return {
+        ...(catalogModel ?? { id, supportedReasoningEfforts: [] }),
+        id,
+        isDefault: true,
+    };
+}
 function turnStartedAt(turn) {
     return typeof turn.startedAt === "number" ? turn.startedAt * 1_000 : Date.now();
 }
@@ -976,62 +1220,11 @@ function extractGeneratedImagePaths(turn) {
 function uniqueStrings(values) {
     return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
 }
-function isUnsupportedExcludeTurnsError(error) {
-    if (!(error instanceof AppServerRequestError) || error.method !== "thread/fork")
-        return false;
-    const data = typeof error.data === "string"
-        ? error.data
-        : error.data === undefined
-            ? ""
-            : JSON.stringify(error.data);
-    const details = `${error.serverMessage} ${data}`;
-    if (!details.toLowerCase().replaceAll(/[^a-z]/g, "").includes("excludeturns"))
-        return false;
-    return error.code === -32602
-        || /unknown|unrecognized|unexpected|unsupported|not supported|experimental/i.test(details);
-}
 function isInvalidWorkingDirectoryError(error) {
     return error instanceof AppServerRequestError
         && error.method === "turn/start"
         && /invalid cwd/i.test(`${error.serverMessage} ${error.data === undefined ? "" : JSON.stringify(error.data)}`);
 }
-function isUnsupportedRecencySortError(error) {
-    if (!(error instanceof AppServerRequestError) || error.method !== "thread/list")
-        return false;
-    const data = typeof error.data === "string"
-        ? error.data
-        : error.data === undefined
-            ? ""
-            : JSON.stringify(error.data);
-    const details = `${error.serverMessage} ${data}`;
-    return /recency_at/i.test(details)
-        && /unknown|unrecognized|unexpected|unsupported|not supported|invalid/i.test(details);
-}
-function isPaginatedThreadReadError(error) {
-    const details = appServerErrorDetails(error);
-    return /paginated threads?[^\n]*do(?:es)? not support[^\n]*thread\/read[^\n]*includeTurns\s*=\s*true/i.test(details);
-}
-function isUnsupportedThreadTurnsListError(error) {
-    if (!(error instanceof AppServerRequestError) || error.method !== "thread/turns/list")
-        return false;
-    return error.code === -32601
-        || /method not found|unknown method|unsupported|not supported/i.test(appServerErrorDetails(error));
-}
-function isUnmaterializedThreadReadError(error) {
-    const details = appServerErrorDetails(error);
-    return /thread[^\n]*(?:not materialized|not loaded)[^\n]*includeTurns[^\n]*(?:unavailable|before first user message)/i
-        .test(details);
-}
-function appServerErrorDetails(error) {
-    if (!(error instanceof AppServerRequestError))
-        return error instanceof Error ? error.message : String(error);
-    const data = typeof error.data === "string"
-        ? error.data
-        : error.data === undefined
-            ? ""
-            : JSON.stringify(error.data);
-    return `${error.message} ${error.serverMessage} ${data}`;
-}
 function remoteSessionSummary(thread) {
     const lastTurn = thread.turns?.at(-1);
     const lastCompletedTurn = [...(thread.turns ?? [])]