@getpaseo/server 0.1.61 → 0.1.63

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

@@ -8,7 +8,7 @@ import { z } from "zod";
 import { loadCodexPersistedTimeline } from "./codex-rollout-timeline.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { mapCodexRolloutToolCall, mapCodexToolCallFromThreadItem, } from "./codex/tool-call-mapper.js";
-import { applyProviderEnv, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
+import { createProviderEnv, createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
 import { spawnProcess } from "../../../utils/spawn.js";
 import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mapper-utils.js";
@@ -96,16 +96,16 @@ function isObjectSchemaNode(schema) {
         type === "object" ||
         (Array.isArray(type) && type.includes("object")));
 }
-function normalizeCodexOutputSchemaNode(schema, path) {
+function normalizeCodexOutputSchemaNode(schema, schemaPath) {
     if (Array.isArray(schema)) {
-        return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${path}[${index}]`));
+        return schema.map((entry, index) => normalizeCodexOutputSchemaNode(entry, `${schemaPath}[${index}]`));
     }
     if (!isSchemaRecord(schema)) {
         return schema;
     }
     const normalized = {};
     for (const [key, value] of Object.entries(schema)) {
-        normalized[key] = normalizeCodexOutputSchemaNode(value, `${path}.${key}`);
+        normalized[key] = normalizeCodexOutputSchemaNode(value, `${schemaPath}.${key}`);
     }
     if (!isObjectSchemaNode(normalized)) {
         return normalized;
@@ -114,7 +114,7 @@ function normalizeCodexOutputSchemaNode(schema, path) {
         normalized.additionalProperties = false;
     }
     else if (normalized.additionalProperties !== false) {
-        throw new Error(`Codex structured outputs require ${path} to set additionalProperties to false for object schemas.`);
+        throw new Error(`Codex structured outputs require ${schemaPath} to set additionalProperties to false for object schemas.`);
     }
     const properties = isSchemaRecord(normalized.properties) ? normalized.properties : null;
     if (!properties) {
@@ -156,6 +156,29 @@ async function resolveCodexLaunchPrefix(runtimeSettings) {
 function resolveCodexHomeDir() {
     return process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
 }
+function decodeEscapedChar(next) {
+    if (next === "n")
+        return "\n";
+    if (next === "t")
+        return "\t";
+    return next;
+}
+function resolvePermissionDecision(response) {
+    if (response.behavior === "allow")
+        return "accept";
+    if (response.interrupt)
+        return "cancel";
+    return "decline";
+}
+function firstPositiveFiniteNumber(primary, secondary) {
+    if (typeof primary === "number" && Number.isFinite(primary) && primary > 0) {
+        return primary;
+    }
+    if (typeof secondary === "number" && Number.isFinite(secondary) && secondary > 0) {
+        return secondary;
+    }
+    return undefined;
+}
 function tokenizeCommandArgs(args) {
     const tokens = [];
     let current = "";
@@ -171,7 +194,7 @@ function tokenizeCommandArgs(args) {
                 const next = args[i + 1];
                 if (next === quote || next === "\\" || next === "n" || next === "t") {
                     i += 1;
-                    current += next === "n" ? "\n" : next === "t" ? "\t" : next;
+                    current += decodeEscapedChar(next);
                     continue;
                 }
             }
@@ -242,35 +265,27 @@ async function listCodexCustomPrompts() {
     catch {
         return [];
     }
-    const commands = [];
-    for (const entry of entries) {
-        if (!entry.isFile()) {
-            continue;
-        }
-        if (!entry.name.endsWith(".md")) {
-            continue;
-        }
+    const mdEntries = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md") && entry.name.slice(0, -".md".length));
+    const parsedCommands = await Promise.all(mdEntries.map(async (entry) => {
         const name = entry.name.slice(0, -".md".length);
-        if (!name) {
-            continue;
-        }
         const fullPath = path.join(promptsDir, entry.name);
         let content;
         try {
             content = await fs.readFile(fullPath, "utf8");
         }
         catch {
-            continue;
+            return null;
         }
         const parsed = parseFrontMatter(content);
         const description = parsed.frontMatter["description"] ?? "Custom prompt";
         const argumentHint = parsed.frontMatter["argument-hint"] ?? parsed.frontMatter["argument_hint"] ?? "";
-        commands.push({
+        return {
             name: `prompts:${name}`,
             description,
             argumentHint,
-        });
-    }
+        };
+    }));
+    const commands = parsedCommands.filter((cmd) => cmd !== null);
     return commands.sort((a, b) => a.name.localeCompare(b.name));
 }
 async function listCodexSkills(cwd, workspaceGitService) {
@@ -284,28 +299,30 @@ async function listCodexSkills(cwd, workspaceGitService) {
         candidates.push(path.join(repoRoot, ".codex", "skills"));
     }
     candidates.push(path.join(resolveCodexHomeDir(), "skills"));
-    const commandsByName = new Map();
-    for (const dir of candidates) {
+    const candidateReads = await Promise.all(candidates.map(async (dir) => {
         let entries;
         try {
             entries = await fs.readdir(dir, { withFileTypes: true });
         }
         catch {
-            continue;
+            return [];
         }
-        for (const entry of entries) {
-            if (!entry.isDirectory() && !entry.isSymbolicLink()) {
-                continue;
-            }
+        const dirEntries = entries.filter((entry) => entry.isDirectory() || entry.isSymbolicLink());
+        const skillContents = await Promise.all(dirEntries.map(async (entry) => {
             const skillDir = path.join(dir, entry.name);
             const skillPath = path.join(skillDir, "SKILL.md");
-            let content;
             try {
-                content = await fs.readFile(skillPath, "utf8");
+                return await fs.readFile(skillPath, "utf8");
             }
             catch {
-                continue;
+                return null;
             }
+        }));
+        return skillContents.filter((content) => content !== null);
+    }));
+    const commandsByName = new Map();
+    for (const skillContents of candidateReads) {
+        for (const content of skillContents) {
             const { frontMatter } = parseFrontMatter(content);
             const name = frontMatter["name"];
             const description = frontMatter["description"];
@@ -579,24 +596,8 @@ function toAgentUsage(tokenUsage) {
     if (!tokenUsage || typeof tokenUsage !== "object")
         return undefined;
     const usage = tokenUsage;
-    const contextWindowMaxTokens = typeof usage.model_context_window === "number" &&
-        Number.isFinite(usage.model_context_window) &&
-        usage.model_context_window > 0
-        ? usage.model_context_window
-        : typeof usage.modelContextWindow === "number" &&
-            Number.isFinite(usage.modelContextWindow) &&
-            usage.modelContextWindow > 0
-            ? usage.modelContextWindow
-            : undefined;
-    const contextWindowUsedTokens = typeof usage.last?.total_tokens === "number" &&
-        Number.isFinite(usage.last.total_tokens) &&
-        usage.last.total_tokens > 0
-        ? usage.last.total_tokens
-        : typeof usage.last?.totalTokens === "number" &&
-            Number.isFinite(usage.last.totalTokens) &&
-            usage.last.totalTokens > 0
-            ? usage.last.totalTokens
-            : undefined;
+    const contextWindowMaxTokens = firstPositiveFiniteNumber(usage.model_context_window, usage.modelContextWindow);
+    const contextWindowUsedTokens = firstPositiveFiniteNumber(usage.last?.total_tokens, usage.last?.totalTokens);
     return {
         inputTokens: usage.last?.inputTokens,
         cachedInputTokens: usage.last?.cachedInputTokens,
@@ -970,8 +971,8 @@ function parseCodexPatchChanges(changes) {
         ];
     }
     return Object.entries(recordChanges)
-        .map(([path, value]) => {
-        const normalizedPath = path.trim();
+        .map(([entryPath, value]) => {
+        const normalizedPath = entryPath.trim();
         if (!normalizedPath) {
             return null;
         }
@@ -1096,11 +1097,7 @@ function mapCodexPatchNotificationToToolCall(params) {
             : {
                 ...(files.length > 0
                     ? {
-                        files: files.map((file) => ({
-                            path: file.path,
-                            ...(file.kind ? { kind: file.kind } : {}),
-                            ...codexPatchTextFields(file.content ?? patchText),
-                        })),
+                        files: files.map((file) => Object.assign({ path: file.path }, file.kind ? { kind: file.kind } : {}, codexPatchTextFields(file.content ?? patchText))),
                     }
                     : {}),
                 ...(params.stdout ? { stdout: params.stdout } : {}),
@@ -1139,43 +1136,49 @@ function mapCodexTerminalInteractionToToolCall(params) {
         ...(processId ? { metadata: { processId } } : {}),
     };
 }
+function mapCodexThreadPlanItem(normalizedItem) {
+    const callId = nonEmptyString(normalizedItem.id ?? normalizedItem.itemId ?? undefined) ??
+        `plan:${normalizePlanMarkdown(typeof normalizedItem.text === "string" ? normalizedItem.text : "")}`;
+    return mapCodexPlanToToolCall({
+        callId,
+        text: typeof normalizedItem.text === "string" ? normalizedItem.text : "",
+    });
+}
+function mapCodexThreadReasoningItem(normalizedItem) {
+    const summary = Array.isArray(normalizedItem.summary) ? normalizedItem.summary.join("\n") : "";
+    const content = Array.isArray(normalizedItem.content) ? normalizedItem.content.join("\n") : "";
+    const text = summary || content;
+    return text ? { type: "reasoning", text } : null;
+}
+function mapCodexThreadUserMessageItem(normalizedItem, includeUserMessage) {
+    if (!includeUserMessage) {
+        return null;
+    }
+    const text = extractUserText(normalizedItem.content) ?? "";
+    return { type: "user_message", text };
+}
 function threadItemToTimeline(item, options) {
     if (!item || typeof item !== "object")
         return null;
+    const itemRecord = item;
     const includeUserMessage = options?.includeUserMessage ?? true;
     const cwd = options?.cwd ?? null;
-    const normalizedType = normalizeCodexThreadItemType(typeof item.type === "string" ? item.type : undefined);
-    const normalizedItem = normalizedType && normalizedType !== item.type
-        ? { ...item, type: normalizedType }
-        : item;
+    const normalizedType = normalizeCodexThreadItemType(typeof itemRecord.type === "string" ? itemRecord.type : undefined);
+    const normalizedItem = normalizedType && normalizedType !== itemRecord.type
+        ? { ...itemRecord, type: normalizedType }
+        : itemRecord;
     switch (normalizedType) {
-        case "userMessage": {
-            if (!includeUserMessage) {
-                return null;
-            }
-            const text = extractUserText(normalizedItem.content) ?? "";
-            return { type: "user_message", text };
-        }
-        case "agentMessage": {
-            return { type: "assistant_message", text: normalizedItem.text ?? "" };
-        }
-        case "plan": {
-            return mapCodexPlanToToolCall({
-                callId: nonEmptyString(normalizedItem.id ?? normalizedItem.itemId ?? undefined) ??
-                    `plan:${normalizePlanMarkdown(normalizedItem.text ?? "")}`,
-                text: normalizedItem.text ?? "",
-            });
-        }
-        case "reasoning": {
-            const summary = Array.isArray(normalizedItem.summary)
-                ? normalizedItem.summary.join("\n")
-                : "";
-            const content = Array.isArray(normalizedItem.content)
-                ? normalizedItem.content.join("\n")
-                : "";
-            const text = summary || content;
-            return text ? { type: "reasoning", text } : null;
-        }
+        case "userMessage":
+            return mapCodexThreadUserMessageItem(normalizedItem, includeUserMessage);
+        case "agentMessage":
+            return {
+                type: "assistant_message",
+                text: typeof normalizedItem.text === "string" ? normalizedItem.text : "",
+            };
+        case "plan":
+            return mapCodexThreadPlanItem(normalizedItem);
+        case "reasoning":
+            return mapCodexThreadReasoningItem(normalizedItem);
         case "commandExecution":
         case "fileChange":
         case "mcpToolCall":
@@ -1824,11 +1827,9 @@ export async function codexAppServerTurnInputFromPrompt(prompt, logger) {
         return [{ type: "text", text: prompt }];
     }
     const blocks = prompt;
-    const output = [];
-    for (const block of blocks) {
+    const output = await Promise.all(blocks.map(async (block) => {
         if (!block || typeof block !== "object") {
-            output.push(block);
-            continue;
+            return block;
         }
         const record = block;
         if (record.type === "image" &&
@@ -1836,38 +1837,32 @@ export async function codexAppServerTurnInputFromPrompt(prompt, logger) {
             typeof record.data === "string") {
             try {
                 const filePath = await writeImageAttachment(record.mimeType, record.data);
-                output.push({ type: "localImage", path: filePath });
+                return { type: "localImage", path: filePath };
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 logger.warn({ message }, "Failed to write Codex image attachment");
-                output.push({
+                return {
                     type: "text",
                     text: `User attached image (failed to write temp file): ${message}`,
-                });
+                };
             }
-            continue;
         }
         if (record.type === "github_pr" || record.type === "github_issue") {
-            output.push({
+            return {
                 type: "text",
                 text: renderPromptAttachmentAsText(record),
-            });
-            continue;
+            };
         }
-        output.push(block);
-    }
+        return block;
+    }));
     return output;
 }
 function buildCodexAppServerEnv(runtimeSettings, launchEnv) {
-    const env = applyProviderEnv(process.env, runtimeSettings);
-    if (!launchEnv) {
-        return env;
-    }
-    return {
-        ...env,
-        ...launchEnv,
-    };
+    return createProviderEnv({
+        runtimeSettings,
+        overlays: [launchEnv],
+    });
 }
 function buildCodexAppServerInitializeParams() {
     return {
@@ -1975,11 +1970,11 @@ class CodexAppServerAgentSession {
             const response = (await this.client.request("collaborationMode/list", {}));
             const data = Array.isArray(response?.data) ? response.data : [];
             this.collaborationModes = data.map((entry) => ({
-                name: String(entry.name ?? ""),
-                mode: entry.mode ?? null,
-                model: entry.model ?? null,
-                reasoning_effort: entry.reasoning_effort ?? null,
-                developer_instructions: entry.developer_instructions ?? null,
+                name: typeof entry.name === "string" ? entry.name : "",
+                mode: typeof entry.mode === "string" ? entry.mode : null,
+                model: typeof entry.model === "string" ? entry.model : null,
+                reasoning_effort: typeof entry.reasoning_effort === "string" ? entry.reasoning_effort : null,
+                developer_instructions: typeof entry.developer_instructions === "string" ? entry.developer_instructions : null,
             }));
         }
         catch (error) {
@@ -1998,13 +1993,15 @@ class CodexAppServerAgentSession {
             const entries = Array.isArray(response?.data) ? response.data : [];
             const skills = [];
             for (const entry of entries) {
-                const list = Array.isArray(entry.skills) ? entry.skills : [];
+                const list = Array.isArray(entry.skills)
+                    ? entry.skills
+                    : [];
                 for (const skill of list) {
-                    if (!skill?.name || !skill?.path)
+                    if (typeof skill?.name !== "string" || typeof skill?.path !== "string")
                         continue;
                     skills.push({
                         name: skill.name,
-                        description: skill.description ?? skill.shortDescription ?? "Skill",
+                        description: resolveSkillDescription(skill),
                         path: skill.path,
                     });
                 }
@@ -2063,7 +2060,7 @@ class CodexAppServerAgentSession {
     }
     applyFeatureValue(featureId, value) {
         this.config.featureValues = {
-            ...(this.config.featureValues ?? {}),
+            ...this.config.featureValues,
             [featureId]: value,
         };
         if (featureId === "fast_mode") {
@@ -2148,17 +2145,7 @@ class CodexAppServerAgentSession {
             if (thread && Array.isArray(thread.turns)) {
                 for (const turn of thread.turns) {
                     const items = Array.isArray(turn.items) ? turn.items : [];
-                    for (const item of items) {
-                        const timelineItem = threadItemToTimeline(item, {
-                            cwd: this.config.cwd ?? null,
-                        });
-                        if (timelineItem) {
-                            if (timelineItem.type === "tool_call") {
-                                this.warnOnIncompleteEditToolCall(timelineItem, "thread_read", item);
-                            }
-                            threadTimeline.push(timelineItem);
-                        }
-                    }
+                    this.collectThreadTurnTimelineItems(items, threadTimeline);
                 }
             }
             const timeline = rolloutTimeline.length > 0 ? rolloutTimeline : threadTimeline;
@@ -2486,55 +2473,13 @@ class CodexAppServerAgentSession {
         }
         const pendingRequest = this.pendingPermissions.get(requestId) ?? null;
         if (pending.kind === "plan") {
-            let followUpPrompt;
-            if (response.behavior === "allow") {
-                followUpPrompt = this.preparePlanImplementation({
-                    planText: pending.planText ?? pendingRequest?.metadata?.planText,
-                });
-            }
-            this.pendingPermissionHandlers.delete(requestId);
-            this.pendingPermissions.delete(requestId);
-            this.resolvedPermissionRequests.add(requestId);
-            this.emitEvent({
-                type: "permission_resolved",
-                provider: CODEX_PROVIDER,
-                requestId,
-                resolution: response,
-            });
-            if (followUpPrompt) {
-                return { followUpPrompt };
-            }
-            return;
+            return this.handlePlanPermissionResponse({ requestId, response, pending, pendingRequest });
         }
         this.pendingPermissionHandlers.delete(requestId);
         this.pendingPermissions.delete(requestId);
         this.resolvedPermissionRequests.add(requestId);
         if (response.behavior === "deny" && pendingRequest?.kind === "tool") {
-            const fallbackName = pendingRequest.name === "CodexBash"
-                ? "shell"
-                : pendingRequest.name === "CodexFileChange"
-                    ? "apply_patch"
-                    : pendingRequest.name;
-            this.emitEvent({
-                type: "timeline",
-                provider: CODEX_PROVIDER,
-                item: {
-                    type: "tool_call",
-                    callId: requestId,
-                    name: fallbackName,
-                    status: "failed",
-                    error: { message: response.message ?? "Permission denied" },
-                    detail: pendingRequest.detail ?? {
-                        type: "unknown",
-                        input: pendingRequest.input ?? null,
-                        output: null,
-                    },
-                    metadata: {
-                        permissionRequestId: requestId,
-                        denied: true,
-                    },
-                },
-            });
+            this.emitDeniedToolCallTimelineEvent({ requestId, response, pendingRequest });
         }
         this.emitEvent({
             type: "permission_resolved",
@@ -2543,13 +2488,11 @@ class CodexAppServerAgentSession {
             resolution: response,
         });
         if (pending.kind === "command") {
-            const decision = response.behavior === "allow" ? "accept" : response.interrupt ? "cancel" : "decline";
-            pending.resolve({ decision });
+            pending.resolve({ decision: resolvePermissionDecision(response) });
             return;
         }
         if (pending.kind === "file") {
-            const decision = response.behavior === "allow" ? "accept" : response.interrupt ? "cancel" : "decline";
-            pending.resolve({ decision });
+            pending.resolve({ decision: resolvePermissionDecision(response) });
             return;
         }
         const questions = pending.questions ?? [];
@@ -2593,6 +2536,60 @@ class CodexAppServerAgentSession {
         });
         pending.resolve({ answers: {} });
     }
+    handlePlanPermissionResponse(params) {
+        const { requestId, response, pending, pendingRequest } = params;
+        let followUpPrompt;
+        if (response.behavior === "allow") {
+            followUpPrompt = this.preparePlanImplementation({
+                planText: pending.planText ?? pendingRequest?.metadata?.planText,
+            });
+        }
+        this.pendingPermissionHandlers.delete(requestId);
+        this.pendingPermissions.delete(requestId);
+        this.resolvedPermissionRequests.add(requestId);
+        this.emitEvent({
+            type: "permission_resolved",
+            provider: CODEX_PROVIDER,
+            requestId,
+            resolution: response,
+        });
+        if (followUpPrompt) {
+            return { followUpPrompt };
+        }
+    }
+    emitDeniedToolCallTimelineEvent(params) {
+        const { requestId, response, pendingRequest } = params;
+        let fallbackName;
+        if (pendingRequest.name === "CodexBash") {
+            fallbackName = "shell";
+        }
+        else if (pendingRequest.name === "CodexFileChange") {
+            fallbackName = "apply_patch";
+        }
+        else {
+            fallbackName = pendingRequest.name;
+        }
+        this.emitEvent({
+            type: "timeline",
+            provider: CODEX_PROVIDER,
+            item: {
+                type: "tool_call",
+                callId: requestId,
+                name: fallbackName,
+                status: "failed",
+                error: { message: response.message ?? "Permission denied" },
+                detail: pendingRequest.detail ?? {
+                    type: "unknown",
+                    input: pendingRequest.input ?? null,
+                    output: null,
+                },
+                metadata: {
+                    permissionRequestId: requestId,
+                    denied: true,
+                },
+            },
+        });
+    }
     describePersistence() {
         if (!this.currentThreadId)
             return null;
@@ -2663,12 +2660,10 @@ class CodexAppServerAgentSession {
             : [];
         return [...appServerSkills, ...fallbackSkills, ...prompts].sort((a, b) => a.name.localeCompare(b.name));
     }
-    async ensureThread() {
-        if (!this.client)
-            return;
-        if (this.currentThreadId)
-            return;
-        // Resolve model + thinking defaults when omitted.
+    async resolveModelAndThinking() {
+        if (!this.client) {
+            throw new Error("Codex client is not initialized");
+        }
         let configuredDefaults = {};
         let model = this.config.model;
         let thinkingOptionId = normalizeCodexThinkingOptionId(this.config.thinkingOptionId);
@@ -2696,6 +2691,17 @@ class CodexAppServerAgentSession {
                 thinkingOptionId = normalizeCodexThinkingOptionId(selectedModel.defaultReasoningEffort);
             }
         }
+        if (!model) {
+            throw new Error("Unable to resolve Codex model");
+        }
+        return { model, thinkingOptionId };
+    }
+    async ensureThread() {
+        if (!this.client)
+            return;
+        if (this.currentThreadId)
+            return;
+        const { model, thinkingOptionId } = await this.resolveModelAndThinking();
         this.config.model = model;
         this.config.thinkingOptionId = thinkingOptionId;
         const preset = MODE_PRESETS[this.currentMode] ?? MODE_PRESETS[DEFAULT_CODEX_MODE_ID];
@@ -2764,96 +2770,62 @@ class CodexAppServerAgentSession {
     }
     handleNotification(method, params) {
         const parsed = CodexNotificationSchema.parse({ method, params });
-        if (parsed.kind === "thread_started") {
-            this.currentThreadId = parsed.threadId;
-            this.emitEvent({
-                type: "thread_started",
-                provider: CODEX_PROVIDER,
-                sessionId: parsed.threadId,
-            });
-            return;
-        }
-        if (parsed.kind === "turn_started") {
-            this.currentTurnId = parsed.turnId;
-            this.latestPlanResult = null;
-            this.emittedItemStartedIds.clear();
-            this.emittedItemCompletedIds.clear();
-            this.emittedExecCommandStartedCallIds.clear();
-            this.emittedExecCommandCompletedCallIds.clear();
-            this.pendingCommandOutputDeltas.clear();
-            this.pendingFileChangeOutputDeltas.clear();
-            this.warnedIncompleteEditToolCallIds.clear();
-            this.emitEvent({ type: "turn_started", provider: CODEX_PROVIDER });
-            return;
-        }
-        if (parsed.kind === "turn_completed") {
-            if (parsed.status === "failed") {
-                this.emitEvent({
-                    type: "turn_failed",
-                    provider: CODEX_PROVIDER,
-                    error: parsed.errorMessage ?? "Codex turn failed",
-                });
-            }
-            else if (parsed.status === "interrupted") {
-                this.emitEvent({ type: "turn_canceled", provider: CODEX_PROVIDER, reason: "interrupted" });
-            }
-            else {
-                if (this.planModeEnabled && this.latestPlanResult?.text) {
-                    this.emitSyntheticPlanApprovalRequest(this.latestPlanResult.text);
-                }
-                this.emitEvent({
-                    type: "turn_completed",
-                    provider: CODEX_PROVIDER,
-                    usage: this.latestUsage,
-                });
-            }
-            this.activeForegroundTurnId = null;
-            this.latestPlanResult = null;
-            this.emittedItemStartedIds.clear();
-            this.emittedItemCompletedIds.clear();
-            this.emittedExecCommandStartedCallIds.clear();
-            this.emittedExecCommandCompletedCallIds.clear();
-            this.pendingCommandOutputDeltas.clear();
-            this.pendingFileChangeOutputDeltas.clear();
-            this.warnedIncompleteEditToolCallIds.clear();
-            return;
-        }
-        if (parsed.kind === "plan_updated") {
-            const timelineItem = mapCodexPlanToToolCall({
-                callId: `plan:${this.currentTurnId ?? this.currentThreadId ?? "current"}`,
-                text: planStepsToMarkdown(parsed.plan.map((entry) => ({
-                    step: entry.step ?? "",
-                    status: entry.status ?? "pending",
-                }))),
-            });
-            if (timelineItem) {
-                this.rememberPlanResult(timelineItem);
-                this.emitEvent({
-                    type: "timeline",
-                    provider: CODEX_PROVIDER,
-                    item: timelineItem,
-                });
-            }
-            return;
-        }
-        if (parsed.kind === "diff_updated") {
-            // NOTE: Codex app-server emits frequent `turn/diff/updated` notifications
-            // containing a full accumulated unified diff for the *entire turn*.
-            // This is not a concrete file-change tool call; it is progress telemetry.
-            // We intentionally do NOT store every diff update in the timeline.
-            return;
-        }
-        if (parsed.kind === "token_usage_updated") {
-            this.latestUsage = toAgentUsage(parsed.tokenUsage);
-            if (this.latestUsage) {
-                this.notifySubscribers({
-                    type: "usage_updated",
-                    provider: CODEX_PROVIDER,
-                    usage: this.latestUsage,
-                });
-            }
-            return;
+        switch (parsed.kind) {
+            case "thread_started":
+                this.handleThreadStartedNotification(parsed);
+                return;
+            case "turn_started":
+                this.handleTurnStartedNotification(parsed);
+                return;
+            case "turn_completed":
+                this.handleTurnCompletedNotification(parsed);
+                return;
+            case "plan_updated":
+                this.handlePlanUpdatedNotification(parsed);
+                return;
+            case "diff_updated":
+                // NOTE: Codex app-server emits frequent `turn/diff/updated` notifications
+                // containing a full accumulated unified diff for the *entire turn*.
+                // This is not a concrete file-change tool call; it is progress telemetry.
+                return;
+            case "token_usage_updated":
+                this.handleTokenUsageUpdatedNotification(parsed);
+                return;
+            case "agent_message_delta":
+            case "reasoning_delta":
+            case "exec_command_output_delta":
+            case "file_change_output_delta":
+                this.handleCodexDeltaNotification(parsed);
+                return;
+            case "exec_command_started":
+                this.handleExecCommandStartedNotification(parsed);
+                return;
+            case "exec_command_completed":
+                this.handleExecCommandCompletedNotification(parsed);
+                return;
+            case "terminal_interaction":
+                this.handleTerminalInteractionNotification(parsed);
+                return;
+            case "patch_apply_started":
+                this.handlePatchApplyStartedNotification(parsed);
+                return;
+            case "patch_apply_completed":
+                this.handlePatchApplyCompletedNotification(parsed);
+                return;
+            case "item_completed":
+                this.handleItemCompletedNotification(parsed);
+                return;
+            case "item_started":
+                this.handleItemStartedNotification(parsed);
+                return;
+            case "invalid_payload":
+                this.warnInvalidNotificationPayload(parsed.method, parsed.params);
+                return;
+            default:
+                this.warnUnknownNotificationMethod(parsed.method, parsed.params);
         }
+    }
+    handleCodexDeltaNotification(parsed) {
         if (parsed.kind === "agent_message_delta") {
             const prev = this.pendingAgentMessages.get(parsed.itemId) ?? "";
             this.pendingAgentMessages.set(parsed.itemId, prev + parsed.delta);
@@ -2871,192 +2843,255 @@ class CodexAppServerAgentSession {
             });
             return;
         }
-        if (parsed.kind === "file_change_output_delta") {
-            this.appendOutputDeltaChunk(this.pendingFileChangeOutputDeltas, parsed.itemId, parsed.delta);
-            return;
+        this.appendOutputDeltaChunk(this.pendingFileChangeOutputDeltas, parsed.itemId, parsed.delta);
+    }
+    handleThreadStartedNotification(parsed) {
+        this.currentThreadId = parsed.threadId;
+        this.emitEvent({
+            type: "thread_started",
+            provider: CODEX_PROVIDER,
+            sessionId: parsed.threadId,
+        });
+    }
+    handleTurnStartedNotification(parsed) {
+        this.currentTurnId = parsed.turnId;
+        this.resetTurnTrackingState();
+        this.emitEvent({ type: "turn_started", provider: CODEX_PROVIDER });
+    }
+    handleTurnCompletedNotification(parsed) {
+        if (parsed.status === "failed") {
+            this.emitEvent({
+                type: "turn_failed",
+                provider: CODEX_PROVIDER,
+                error: parsed.errorMessage ?? "Codex turn failed",
+            });
+        }
+        else if (parsed.status === "interrupted") {
+            this.emitEvent({ type: "turn_canceled", provider: CODEX_PROVIDER, reason: "interrupted" });
         }
-        if (parsed.kind === "exec_command_started") {
-            if (parsed.callId) {
-                this.emittedExecCommandStartedCallIds.add(parsed.callId);
-                this.pendingCommandOutputDeltas.delete(parsed.callId);
+        else {
+            if (this.planModeEnabled && this.latestPlanResult?.text) {
+                this.emitSyntheticPlanApprovalRequest(this.latestPlanResult.text);
             }
-            const timelineItem = mapCodexExecNotificationToToolCall({
-                callId: parsed.callId,
-                command: parsed.command,
-                cwd: parsed.cwd ?? this.config.cwd ?? null,
-                running: true,
+            this.emitEvent({
+                type: "turn_completed",
+                provider: CODEX_PROVIDER,
+                usage: this.latestUsage,
             });
-            if (timelineItem) {
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-            }
-            return;
         }
-        if (parsed.kind === "exec_command_completed") {
-            const bufferedOutput = this.consumeOutputDelta(this.pendingCommandOutputDeltas, parsed.callId);
-            const resolvedOutput = parsed.output ?? bufferedOutput;
-            this.rememberTerminalProcessForCommand(parsed.command, resolvedOutput);
-            const timelineItem = mapCodexExecNotificationToToolCall({
-                callId: parsed.callId,
-                command: parsed.command,
-                cwd: parsed.cwd ?? this.config.cwd ?? null,
-                output: resolvedOutput,
-                exitCode: parsed.exitCode,
-                success: parsed.success,
-                stderr: parsed.stderr,
-                running: false,
-            });
-            if (timelineItem) {
-                this.emittedExecCommandCompletedCallIds.add(timelineItem.callId);
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-            }
-            return;
+        this.activeForegroundTurnId = null;
+        this.resetTurnTrackingState();
+    }
+    resetTurnTrackingState() {
+        this.latestPlanResult = null;
+        this.emittedItemStartedIds.clear();
+        this.emittedItemCompletedIds.clear();
+        this.emittedExecCommandStartedCallIds.clear();
+        this.emittedExecCommandCompletedCallIds.clear();
+        this.pendingCommandOutputDeltas.clear();
+        this.pendingFileChangeOutputDeltas.clear();
+        this.warnedIncompleteEditToolCallIds.clear();
+    }
+    handlePlanUpdatedNotification(parsed) {
+        const timelineItem = mapCodexPlanToToolCall({
+            callId: `plan:${this.currentTurnId ?? this.currentThreadId ?? "current"}`,
+            text: planStepsToMarkdown(parsed.plan.map((entry) => ({
+                step: entry.step ?? "",
+                status: entry.status ?? "pending",
+            }))),
+        });
+        if (timelineItem) {
+            this.rememberPlanResult(timelineItem);
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
         }
-        if (parsed.kind === "terminal_interaction") {
-            const interactionKey = [parsed.processId ?? "", parsed.stdin ?? ""].join("\u0000");
-            if (!this.shouldEmitTerminalInteractionKey(interactionKey)) {
-                return;
-            }
-            const command = (parsed.processId ? this.terminalCommandByProcessId.get(parsed.processId) : undefined) ??
-                null;
-            if (!command && parsed.processId) {
-                this.pendingUnlabeledTerminalInteractions.add(parsed.processId);
-            }
-            const timelineItem = mapCodexTerminalInteractionToToolCall({
-                processId: parsed.processId,
-                fallbackCallId: parsed.callId,
-                command,
+    }
+    handleTokenUsageUpdatedNotification(parsed) {
+        this.latestUsage = toAgentUsage(parsed.tokenUsage);
+        if (this.latestUsage) {
+            this.notifySubscribers({
+                type: "usage_updated",
+                provider: CODEX_PROVIDER,
+                usage: this.latestUsage,
             });
+        }
+    }
+    handleExecCommandStartedNotification(parsed) {
+        if (parsed.callId) {
+            this.emittedExecCommandStartedCallIds.add(parsed.callId);
+            this.pendingCommandOutputDeltas.delete(parsed.callId);
+        }
+        const timelineItem = mapCodexExecNotificationToToolCall({
+            callId: parsed.callId,
+            command: parsed.command,
+            cwd: parsed.cwd ?? this.config.cwd ?? null,
+            running: true,
+        });
+        if (timelineItem) {
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        }
+    }
+    handleExecCommandCompletedNotification(parsed) {
+        const bufferedOutput = this.consumeOutputDelta(this.pendingCommandOutputDeltas, parsed.callId);
+        const resolvedOutput = parsed.output ?? bufferedOutput;
+        this.rememberTerminalProcessForCommand(parsed.command, resolvedOutput);
+        const timelineItem = mapCodexExecNotificationToToolCall({
+            callId: parsed.callId,
+            command: parsed.command,
+            cwd: parsed.cwd ?? this.config.cwd ?? null,
+            output: resolvedOutput,
+            exitCode: parsed.exitCode,
+            success: parsed.success,
+            stderr: parsed.stderr,
+            running: false,
+        });
+        if (timelineItem) {
+            this.emittedExecCommandCompletedCallIds.add(timelineItem.callId);
             this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        }
+    }
+    handleTerminalInteractionNotification(parsed) {
+        const interactionKey = [parsed.processId ?? "", parsed.stdin ?? ""].join("\u0000");
+        if (!this.shouldEmitTerminalInteractionKey(interactionKey)) {
             return;
         }
-        if (parsed.kind === "patch_apply_started") {
-            if (parsed.callId) {
-                this.pendingFileChangeOutputDeltas.delete(parsed.callId);
-            }
-            const timelineItem = mapCodexPatchNotificationToToolCall({
+        const command = (parsed.processId ? this.terminalCommandByProcessId.get(parsed.processId) : undefined) ??
+            null;
+        if (!command && parsed.processId) {
+            this.pendingUnlabeledTerminalInteractions.add(parsed.processId);
+        }
+        const timelineItem = mapCodexTerminalInteractionToToolCall({
+            processId: parsed.processId,
+            fallbackCallId: parsed.callId,
+            command,
+        });
+        this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+    }
+    handlePatchApplyStartedNotification(parsed) {
+        if (parsed.callId) {
+            this.pendingFileChangeOutputDeltas.delete(parsed.callId);
+        }
+        const timelineItem = mapCodexPatchNotificationToToolCall({
+            callId: parsed.callId,
+            changes: parsed.changes,
+            cwd: this.config.cwd ?? null,
+            running: true,
+        });
+        if (timelineItem) {
+            this.warnOnIncompleteEditToolCall(timelineItem, "patch_apply_started", {
                 callId: parsed.callId,
                 changes: parsed.changes,
-                cwd: this.config.cwd ?? null,
-                running: true,
             });
-            if (timelineItem) {
-                this.warnOnIncompleteEditToolCall(timelineItem, "patch_apply_started", {
-                    callId: parsed.callId,
-                    changes: parsed.changes,
-                });
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-            }
-            return;
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
         }
-        if (parsed.kind === "patch_apply_completed") {
-            const bufferedOutput = this.consumeOutputDelta(this.pendingFileChangeOutputDeltas, parsed.callId);
-            const timelineItem = mapCodexPatchNotificationToToolCall({
+    }
+    handlePatchApplyCompletedNotification(parsed) {
+        const bufferedOutput = this.consumeOutputDelta(this.pendingFileChangeOutputDeltas, parsed.callId);
+        const timelineItem = mapCodexPatchNotificationToToolCall({
+            callId: parsed.callId,
+            changes: parsed.changes,
+            cwd: this.config.cwd ?? null,
+            stdout: parsed.stdout ?? bufferedOutput,
+            stderr: parsed.stderr,
+            success: parsed.success,
+            running: false,
+        });
+        if (timelineItem) {
+            this.warnOnIncompleteEditToolCall(timelineItem, "patch_apply_completed", {
                 callId: parsed.callId,
                 changes: parsed.changes,
-                cwd: this.config.cwd ?? null,
-                stdout: parsed.stdout ?? bufferedOutput,
-                stderr: parsed.stderr,
-                success: parsed.success,
-                running: false,
+                stdout: parsed.stdout,
             });
-            if (timelineItem) {
-                this.warnOnIncompleteEditToolCall(timelineItem, "patch_apply_completed", {
-                    callId: parsed.callId,
-                    changes: parsed.changes,
-                    stdout: parsed.stdout,
-                });
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-            }
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        }
+    }
+    handleItemCompletedNotification(parsed) {
+        // Codex emits mirrored lifecycle notifications via both `codex/event/item_*`
+        // and canonical `item/*`. We render only the canonical channel to avoid
+        // duplicated assistant/reasoning rows.
+        if (parsed.source === "codex_event") {
             return;
         }
-        if (parsed.kind === "item_completed") {
-            // Codex emits mirrored lifecycle notifications via both `codex/event/item_*`
-            // and canonical `item/*`. We render only the canonical channel to avoid
-            // duplicated assistant/reasoning rows.
-            if (parsed.source === "codex_event") {
+        const timelineItem = threadItemToTimeline(parsed.item, {
+            includeUserMessage: false,
+            cwd: this.config.cwd ?? null,
+        });
+        if (!timelineItem) {
+            return;
+        }
+        const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
+        const itemId = parsed.item.id;
+        // For commandExecution items, codex/event/exec_command_* is authoritative.
+        if (timelineItem.type === "tool_call" && normalizedItemType === "commandExecution") {
+            const callId = timelineItem.callId || itemId;
+            if (callId && this.emittedExecCommandCompletedCallIds.has(callId)) {
                 return;
             }
-            const timelineItem = threadItemToTimeline(parsed.item, {
-                includeUserMessage: false,
-                cwd: this.config.cwd ?? null,
-            });
-            if (timelineItem) {
-                const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
-                const itemId = parsed.item.id;
-                // For commandExecution items, codex/event/exec_command_* is authoritative.
-                // Keep item/completed as fallback only when no exec_command completion was seen.
-                if (timelineItem.type === "tool_call" && normalizedItemType === "commandExecution") {
-                    const callId = timelineItem.callId || itemId;
-                    if (callId && this.emittedExecCommandCompletedCallIds.has(callId)) {
-                        return;
-                    }
-                }
-                if (itemId && this.emittedItemCompletedIds.has(itemId)) {
-                    return;
-                }
-                if (timelineItem.type === "assistant_message" && itemId) {
-                    const buffered = this.pendingAgentMessages.get(itemId);
-                    if (buffered && buffered.length > 0) {
-                        timelineItem.text = buffered;
-                    }
-                }
-                if (timelineItem.type === "reasoning" && itemId) {
-                    const buffered = this.pendingReasoning.get(itemId);
-                    if (buffered && buffered.length > 0) {
-                        timelineItem.text = buffered.join("");
-                    }
-                }
-                if (timelineItem.type === "tool_call") {
-                    if (timelineItem.detail.type === "plan") {
-                        this.rememberPlanResult(timelineItem);
-                    }
-                    this.warnOnIncompleteEditToolCall(timelineItem, "item_completed", parsed.item);
-                }
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-                if (itemId) {
-                    this.emittedItemCompletedIds.add(itemId);
-                    this.emittedItemStartedIds.delete(itemId);
-                    this.pendingCommandOutputDeltas.delete(itemId);
-                    this.pendingFileChangeOutputDeltas.delete(itemId);
-                }
+        }
+        if (itemId && this.emittedItemCompletedIds.has(itemId)) {
+            return;
+        }
+        this.applyBufferedDeltaTextToTimelineItem(timelineItem, itemId);
+        if (timelineItem.type === "tool_call") {
+            if (timelineItem.detail.type === "plan") {
+                this.rememberPlanResult(timelineItem);
             }
+            this.warnOnIncompleteEditToolCall(timelineItem, "item_completed", parsed.item);
+        }
+        this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        if (itemId) {
+            this.emittedItemCompletedIds.add(itemId);
+            this.emittedItemStartedIds.delete(itemId);
+            this.pendingCommandOutputDeltas.delete(itemId);
+            this.pendingFileChangeOutputDeltas.delete(itemId);
+        }
+    }
+    applyBufferedDeltaTextToTimelineItem(timelineItem, itemId) {
+        if (!itemId) {
             return;
         }
-        if (parsed.kind === "item_started") {
-            if (parsed.source === "codex_event") {
-                return;
+        if (timelineItem.type === "assistant_message") {
+            const buffered = this.pendingAgentMessages.get(itemId);
+            if (buffered && buffered.length > 0) {
+                timelineItem.text = buffered;
             }
-            const timelineItem = threadItemToTimeline(parsed.item, {
-                includeUserMessage: false,
-                cwd: this.config.cwd ?? null,
-            });
-            if (timelineItem && timelineItem.type === "tool_call") {
-                const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
-                const itemId = parsed.item.id;
-                if (normalizedItemType === "commandExecution") {
-                    const callId = timelineItem.callId || itemId;
-                    if (callId && this.emittedExecCommandStartedCallIds.has(callId)) {
-                        return;
-                    }
-                }
-                if (itemId && this.emittedItemStartedIds.has(itemId)) {
-                    return;
-                }
-                this.warnOnIncompleteEditToolCall(timelineItem, "item_started", parsed.item);
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-                if (itemId) {
-                    this.emittedItemStartedIds.add(itemId);
-                    this.pendingCommandOutputDeltas.delete(itemId);
-                    this.pendingFileChangeOutputDeltas.delete(itemId);
-                }
+            return;
+        }
+        if (timelineItem.type === "reasoning") {
+            const buffered = this.pendingReasoning.get(itemId);
+            if (buffered && buffered.length > 0) {
+                timelineItem.text = buffered.join("");
             }
+        }
+    }
+    handleItemStartedNotification(parsed) {
+        if (parsed.source === "codex_event") {
             return;
         }
-        if (parsed.kind === "invalid_payload") {
-            this.warnInvalidNotificationPayload(parsed.method, parsed.params);
+        const timelineItem = threadItemToTimeline(parsed.item, {
+            includeUserMessage: false,
+            cwd: this.config.cwd ?? null,
+        });
+        if (!timelineItem || timelineItem.type !== "tool_call") {
             return;
         }
-        this.warnUnknownNotificationMethod(parsed.method, parsed.params);
+        const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
+        const itemId = parsed.item.id;
+        if (normalizedItemType === "commandExecution") {
+            const callId = timelineItem.callId || itemId;
+            if (callId && this.emittedExecCommandStartedCallIds.has(callId)) {
+                return;
+            }
+        }
+        if (itemId && this.emittedItemStartedIds.has(itemId)) {
+            return;
+        }
+        this.warnOnIncompleteEditToolCall(timelineItem, "item_started", parsed.item);
+        this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        if (itemId) {
+            this.emittedItemStartedIds.add(itemId);
+            this.pendingCommandOutputDeltas.delete(itemId);
+            this.pendingFileChangeOutputDeltas.delete(itemId);
+        }
     }
     warnUnknownNotificationMethod(method, params) {
         if (this.warnedUnknownNotificationMethods.has(method)) {
@@ -3132,6 +3167,20 @@ class CodexAppServerAgentSession {
         this.emittedTerminalInteractionKeys.add(key);
         return true;
     }
+    collectThreadTurnTimelineItems(items, target) {
+        for (const item of items) {
+            const timelineItem = threadItemToTimeline(item, {
+                cwd: this.config.cwd ?? null,
+            });
+            if (!timelineItem) {
+                continue;
+            }
+            if (timelineItem.type === "tool_call") {
+                this.warnOnIncompleteEditToolCall(timelineItem, "thread_read", item);
+            }
+            target.push(timelineItem);
+        }
+    }
     warnOnIncompleteEditToolCall(item, source, payload) {
         if (!isEditToolCallWithoutContent(item)) {
             return;
@@ -3280,7 +3329,10 @@ export class CodexAppServerAgentClient {
         return spawnProcess(launchPrefix.command, [...launchPrefix.args, "app-server"], {
             detached: process.platform !== "win32",
             stdio: ["pipe", "pipe", "pipe"],
-            env: buildCodexAppServerEnv(this.runtimeSettings, launchEnv),
+            ...createProviderEnvSpec({
+                runtimeSettings: this.runtimeSettings,
+                overlays: [launchEnv],
+            }),
         });
     }
     async createSession(config, launchContext) {
@@ -3310,18 +3362,19 @@ export class CodexAppServerAgentClient {
             const limit = options?.limit ?? 20;
             const response = (await client.request("thread/list", { limit }));
             const threads = Array.isArray(response?.data) ? response.data : [];
-            const descriptors = [];
-            for (const thread of threads.slice(0, limit)) {
-                const threadId = thread.id;
-                const cwd = thread.cwd ?? process.cwd();
-                const title = thread.preview ?? null;
+            const descriptors = await Promise.all(threads.slice(0, limit).map(async (thread) => {
+                const threadId = typeof thread.id === "string" ? thread.id : "";
+                const cwd = typeof thread.cwd === "string" ? thread.cwd : process.cwd();
+                const title = typeof thread.preview === "string" ? thread.preview : null;
                 let timeline = [];
                 try {
-                    const rolloutTimeline = await loadCodexPersistedTimeline(threadId, undefined, this.logger);
-                    const read = (await client.request("thread/read", {
-                        threadId,
-                        includeTurns: true,
-                    }));
+                    const [rolloutTimeline, read] = await Promise.all([
+                        loadCodexPersistedTimeline(threadId, undefined, this.logger),
+                        client.request("thread/read", {
+                            threadId,
+                            includeTurns: true,
+                        }),
+                    ]);
                     const turns = read.thread?.turns ?? [];
                     const itemsFromThreadRead = [];
                     for (const turn of turns) {
@@ -3336,12 +3389,14 @@ export class CodexAppServerAgentClient {
                 catch {
                     timeline = [];
                 }
-                descriptors.push({
+                return {
                     provider: CODEX_PROVIDER,
                     sessionId: threadId,
                     cwd,
                     title,
-                    lastActivityAt: new Date((thread.updatedAt ?? thread.createdAt ?? 0) * 1000),
+                    lastActivityAt: new Date(((typeof thread.updatedAt === "number" ? thread.updatedAt : undefined) ??
+                        (typeof thread.createdAt === "number" ? thread.createdAt : undefined) ??
+                        0) * 1000),
                     persistence: {
                         provider: CODEX_PROVIDER,
                         sessionId: threadId,
@@ -3354,8 +3409,8 @@ export class CodexAppServerAgentClient {
                         },
                     },
                     timeline,
-                });
-            }
+                };
+            }));
             return descriptors;
         }
         finally {
@@ -3377,55 +3432,11 @@ export class CodexAppServerAgentClient {
             const hasConfiguredDefaultModel = typeof configuredDefaultModelId === "string"
                 ? models.some((model) => model?.id === configuredDefaultModelId)
                 : false;
-            return models.map((model) => {
-                const defaultReasoningEffort = normalizeCodexThinkingOptionId(typeof model.defaultReasoningEffort === "string" ? model.defaultReasoningEffort : null);
-                const resolvedDefaultReasoningEffort = configuredDefaultThinkingOptionId ?? defaultReasoningEffort;
-                const thinkingById = new Map();
-                if (Array.isArray(model.supportedReasoningEfforts)) {
-                    for (const entry of model.supportedReasoningEfforts) {
-                        const id = normalizeCodexThinkingOptionId(typeof entry?.reasoningEffort === "string" ? entry.reasoningEffort : null);
-                        if (!id)
-                            continue;
-                        const description = typeof entry?.description === "string" && entry.description.trim().length > 0
-                            ? entry.description
-                            : undefined;
-                        thinkingById.set(id, { id, label: id, description });
-                    }
-                }
-                if (resolvedDefaultReasoningEffort && !thinkingById.has(resolvedDefaultReasoningEffort)) {
-                    thinkingById.set(resolvedDefaultReasoningEffort, {
-                        id: resolvedDefaultReasoningEffort,
-                        label: resolvedDefaultReasoningEffort,
-                        description: configuredDefaultThinkingOptionId === resolvedDefaultReasoningEffort
-                            ? "Configured default reasoning effort"
-                            : "Model default reasoning effort",
-                    });
-                }
-                const thinkingOptions = Array.from(thinkingById.values()).map((option) => ({
-                    ...option,
-                    isDefault: option.id === resolvedDefaultReasoningEffort,
-                }));
-                const defaultThinkingOptionId = resolvedDefaultReasoningEffort ??
-                    thinkingOptions.find((option) => option.isDefault)?.id ??
-                    thinkingOptions[0]?.id;
-                const isDefaultModel = hasConfiguredDefaultModel
-                    ? model.id === configuredDefaultModelId
-                    : model.isDefault;
-                return {
-                    provider: CODEX_PROVIDER,
-                    id: model.id,
-                    label: normalizeCodexModelLabel(model.displayName),
-                    description: model.description,
-                    isDefault: isDefaultModel,
-                    thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
-                    defaultThinkingOptionId,
-                    metadata: {
-                        model: model.model,
-                        defaultReasoningEffort: model.defaultReasoningEffort,
-                        supportedReasoningEfforts: model.supportedReasoningEfforts,
-                    },
-                };
-            });
+            return models.map((model) => buildCodexModelDefinition(model, {
+                configuredDefaultModelId,
+                configuredDefaultThinkingOptionId,
+                hasConfiguredDefaultModel,
+            }));
         }
         finally {
             await client.dispose();
@@ -3484,6 +3495,67 @@ export class CodexAppServerAgentClient {
         }
     }
 }
+function buildCodexModelDefinition(model, ctx) {
+    const defaultReasoningEffort = normalizeCodexThinkingOptionId(typeof model.defaultReasoningEffort === "string" ? model.defaultReasoningEffort : null);
+    const resolvedDefaultReasoningEffort = ctx.configuredDefaultThinkingOptionId ?? defaultReasoningEffort;
+    const thinkingById = buildCodexThinkingOptionMap(model.supportedReasoningEfforts, resolvedDefaultReasoningEffort, ctx.configuredDefaultThinkingOptionId);
+    const thinkingOptions = Array.from(thinkingById.values()).map((option) => Object.assign({}, option, {
+        isDefault: option.id === resolvedDefaultReasoningEffort,
+    }));
+    const defaultThinkingOptionId = resolvedDefaultReasoningEffort ??
+        thinkingOptions.find((option) => option.isDefault)?.id ??
+        thinkingOptions[0]?.id;
+    const isDefaultModel = ctx.hasConfiguredDefaultModel
+        ? model.id === ctx.configuredDefaultModelId
+        : model.isDefault;
+    return {
+        provider: CODEX_PROVIDER,
+        id: model.id,
+        label: normalizeCodexModelLabel(model.displayName ?? ""),
+        description: model.description,
+        isDefault: isDefaultModel,
+        thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
+        defaultThinkingOptionId,
+        metadata: {
+            model: model.model,
+            defaultReasoningEffort: model.defaultReasoningEffort,
+            supportedReasoningEfforts: model.supportedReasoningEfforts,
+        },
+    };
+}
+function buildCodexThinkingOptionMap(supportedReasoningEfforts, resolvedDefaultReasoningEffort, configuredDefaultThinkingOptionId) {
+    const thinkingById = new Map();
+    if (Array.isArray(supportedReasoningEfforts)) {
+        for (const entry of supportedReasoningEfforts) {
+            const id = normalizeCodexThinkingOptionId(typeof entry?.reasoningEffort === "string" ? entry.reasoningEffort : null);
+            if (!id)
+                continue;
+            const description = typeof entry?.description === "string" && entry.description.trim().length > 0
+                ? entry.description
+                : undefined;
+            thinkingById.set(id, { id, label: id, description });
+        }
+    }
+    if (resolvedDefaultReasoningEffort && !thinkingById.has(resolvedDefaultReasoningEffort)) {
+        thinkingById.set(resolvedDefaultReasoningEffort, {
+            id: resolvedDefaultReasoningEffort,
+            label: resolvedDefaultReasoningEffort,
+            description: configuredDefaultThinkingOptionId === resolvedDefaultReasoningEffort
+                ? "Configured default reasoning effort"
+                : "Model default reasoning effort",
+        });
+    }
+    return thinkingById;
+}
+function resolveSkillDescription(skill) {
+    if (typeof skill.description === "string") {
+        return skill.description;
+    }
+    if (typeof skill.shortDescription === "string") {
+        return skill.shortDescription;
+    }
+    return "Skill";
+}
 export const __codexAppServerInternals = {
     buildCodexAppServerEnv,
     CodexAppServerClient,