codex-relay 1.4.9 → 1.4.10

package/dist/api-schema2.js

@@ -250,6 +250,7 @@ const PendingInputRequestQuestionSchema = z.object({
 });
 const PendingInputRequestSchema = z.object({
 	id: z.string().min(1),
+	isBlocking: z.boolean().default(true),
 	questions: z.array(PendingInputRequestQuestionSchema),
 	threadId: z.string().min(1),
 	turnId: z.string().optional()

package/dist/src.js

@@ -3,7 +3,7 @@ import { a as getConnectUrlCandidates, c as permanentClientSessionExpiresAt, i a
 import { createRequire } from "node:module";
 import qrcode from "qrcode-terminal";
 import { execFile, spawn } from "node:child_process";
-import fs, { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import fs, { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { access, appendFile, copyFile, mkdir, open, readFile, readdir, realpath, stat, writeFile } from "node:fs/promises";
 import path, { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
@@ -36,6 +36,7 @@ const stdioAppServerArgs = [
 ];
 const sharedWindowsServerUrl = "ws://127.0.0.1:8788";
 const windowsShellExtensions = new Set([".bat", ".cmd"]);
+const require = createRequire(import.meta.url);
 function resolveCodexAppServerMode(input = {}) {
 	const env = input.env ?? process.env;
 	const platform$2 = input.platform ?? platform();
@@ -59,35 +60,46 @@ function resolveCodexAppServerMode(input = {}) {
 }
 function resolveCodexAppServerSpawn(input = {}) {
 	const platform$3 = input.platform ?? platform();
-	const command = resolveCodexBinary(input.env ?? process.env);
+	const executable = resolveCodexExecutable(input.env ?? process.env);
 	const isWindows = platform$3 === "win32";
 	return {
-		command,
-		args: [...stdioAppServerArgs],
-		shell: isWindows && shouldUseWindowsShell(command),
+		command: executable.command,
+		args: [...executable.args, ...stdioAppServerArgs],
+		shell: isWindows && executable.explicit && shouldUseWindowsShell(executable.command),
 		windowsHide: isWindows
 	};
 }
 function resolveCodexSharedAppServerSpawn(input = {}) {
 	const platform$4 = input.platform ?? platform();
-	const command = resolveCodexBinary(input.env ?? process.env);
+	const executable = resolveCodexExecutable(input.env ?? process.env);
 	const isWindows = platform$4 === "win32";
 	return {
-		command,
+		command: executable.command,
 		args: [
+			...executable.args,
 			"app-server",
 			"--listen",
 			resolveCodexSharedAppServerRemoteAddress(platform$4)
 		],
-		shell: isWindows && shouldUseWindowsShell(command),
+		shell: isWindows && executable.explicit && shouldUseWindowsShell(executable.command),
 		windowsHide: isWindows
 	};
 }
 function resolveCodexSharedAppServerRemoteAddress(platform$1 = platform()) {
 	return platform$1 === "win32" ? sharedWindowsServerUrl : "unix://";
 }
-function resolveCodexBinary(env) {
-	return env.CODEX_BIN?.trim() || "codex";
+function resolveCodexExecutable(env) {
+	const configuredBinary = env.CODEX_BIN?.trim();
+	if (configuredBinary) return {
+		args: [],
+		command: configuredBinary,
+		explicit: true
+	};
+	return {
+		args: [join(dirname(require.resolve("@openai/codex/package.json")), "bin", "codex.js")],
+		command: process.execPath,
+		explicit: false
+	};
 }
 function shouldUseWindowsShell(command) {
 	const extension = extname(command).toLowerCase();
@@ -155,6 +167,9 @@ var CodexAppServerClient = class {
 	sharedReconnectEnabled = false;
 	sharedServer;
 	socket;
+	activeTurnIdsByThreadId = /* @__PURE__ */ new Map();
+	terminalTurnIdsByThreadId = /* @__PURE__ */ new Map();
+	subscribedThreadIds = /* @__PURE__ */ new Set();
 	onStartupFallback;
 	startSharedServer;
 	constructor(options = {}) {
@@ -171,13 +186,30 @@ var CodexAppServerClient = class {
 		return this.ensureInitialized();
 	}
 	async listThreads(limit = 80) {
-		return (await this.request("thread/list", {
-			limit,
-			sortKey: "updated_at",
-			sortDirection: "desc",
-			sourceKinds: [],
-			archived: false
-		})).data;
+		const threads = [];
+		const seenCursors = /* @__PURE__ */ new Set();
+		let cursor;
+		do {
+			const response = await this.request("thread/list", {
+				archived: false,
+				cursor,
+				limit,
+				sortDirection: "desc",
+				sortKey: "recency_at",
+				sourceKinds: [
+					"cli",
+					"vscode",
+					"exec",
+					"appServer"
+				]
+			});
+			threads.push(...response.data);
+			const nextCursor = response.nextCursor ?? void 0;
+			if (!nextCursor || seenCursors.has(nextCursor)) break;
+			seenCursors.add(nextCursor);
+			cursor = nextCursor;
+		} while (cursor);
+		return threads;
 	}
 	async readThread(threadId, options = {}) {
 		return (await this.request("thread/read", {
@@ -195,19 +227,39 @@ var CodexAppServerClient = class {
 		return this.request("account/rateLimits/read", null);
 	}
 	async startThread(params) {
-		return (await this.request("thread/start", params)).thread;
+		const response = await this.request("thread/start", params);
+		this.subscribedThreadIds.add(response.thread.id);
+		return response.thread;
 	}
 	async resumeThread(params) {
-		return (await this.request("thread/resume", params)).thread;
+		const response = await this.request("thread/resume", params.excludeTurns ? {
+			...params,
+			initialTurnsPage: {
+				itemsView: "summary",
+				limit: 1,
+				sortDirection: "desc"
+			}
+		} : params);
+		this.subscribedThreadIds.add(response.thread.id);
+		this.rememberActiveTurn({
+			...response.thread,
+			turns: response.initialTurnsPage?.data ?? response.thread.turns
+		});
+		return response.thread;
 	}
 	async startTurn(params) {
-		return (await this.request("turn/start", params)).turn;
+		const response = await this.request("turn/start", params);
+		this.rememberTurn(params.threadId, response.turn);
+		return response.turn;
 	}
 	async interruptTurn(params) {
 		await this.request("turn/interrupt", params);
 	}
 	async archiveThread(params) {
 		await this.request("thread/archive", params);
+		this.subscribedThreadIds.delete(params.threadId);
+		this.activeTurnIdsByThreadId.delete(params.threadId);
+		this.terminalTurnIdsByThreadId.delete(params.threadId);
 	}
 	async setThreadName(params) {
 		await this.request("thread/name/set", params);
@@ -215,6 +267,9 @@ var CodexAppServerClient = class {
 	async rollbackThread(params) {
 		return (await this.request("thread/rollback", params)).thread;
 	}
+	async revertThread(params) {
+		return (await this.request("thread/revert", params)).thread;
+	}
 	async getThreadGoal(params) {
 		return (await this.request("thread/goal/get", params)).goal;
 	}
@@ -255,6 +310,9 @@ var CodexAppServerClient = class {
 		this.stopStdioCodexAppServer();
 		this.stopSharedCodexAppServer();
 		this.initialized = void 0;
+		this.activeTurnIdsByThreadId.clear();
+		this.terminalTurnIdsByThreadId.clear();
+		this.subscribedThreadIds.clear();
 	}
 	async request(method, params) {
 		await this.ensureInitialized();
@@ -322,8 +380,90 @@ var CodexAppServerClient = class {
 				title: "Codex Relay Mobile Server",
 				version: "1.2.0"
 			},
-			capabilities: { experimentalApi: true }
+			capabilities: {
+				experimentalApi: true,
+				requestAttestation: false
+			}
 		});
+		await this.writeJson({ method: "initialized" });
+		for (const threadId of this.subscribedThreadIds) try {
+			const disconnectedTurnId = this.activeTurnIdsByThreadId.get(threadId);
+			const response = await this.requestRaw("thread/resume", {
+				excludeTurns: true,
+				initialTurnsPage: {
+					itemsView: "summary",
+					limit: 1,
+					sortDirection: "desc"
+				},
+				threadId
+			});
+			this.reconcileResumedThread({
+				...response.thread,
+				turns: response.initialTurnsPage?.data ?? response.thread.turns
+			}, disconnectedTurnId);
+		} catch (error) {
+			relayDebugLog("app_server.thread.resubscribe_failed", {
+				message: error instanceof Error ? error.message : String(error),
+				threadId
+			});
+		}
+	}
+	reconcileResumedThread(thread, disconnectedTurnId) {
+		if (disconnectedTurnId) {
+			const disconnectedTurn = thread.turns?.find((turn) => turn.id === disconnectedTurnId);
+			if (disconnectedTurn && !isAppServerTurnInProgress(disconnectedTurn)) this.dispatchNotification({
+				method: "turn/completed",
+				params: {
+					threadId: thread.id,
+					turn: disconnectedTurn
+				}
+			});
+			else this.dispatchNotification({
+				method: "thread/status/changed",
+				params: {
+					status: thread.status,
+					threadId: thread.id
+				}
+			});
+		}
+		this.rememberActiveTurn(thread);
+	}
+	rememberActiveTurn(thread) {
+		const activeTurn = [...thread.turns ?? []].reverse().find((turn) => isAppServerTurnInProgress(turn));
+		if (activeTurn && this.terminalTurnIdsByThreadId.get(thread.id) !== activeTurn.id) {
+			this.activeTurnIdsByThreadId.set(thread.id, activeTurn.id);
+			this.terminalTurnIdsByThreadId.delete(thread.id);
+		} else this.activeTurnIdsByThreadId.delete(thread.id);
+	}
+	rememberTurn(threadId, turn) {
+		if (isAppServerTurnInProgress(turn)) {
+			if (this.terminalTurnIdsByThreadId.get(threadId) !== turn.id) {
+				this.activeTurnIdsByThreadId.set(threadId, turn.id);
+				this.terminalTurnIdsByThreadId.delete(threadId);
+			}
+		} else if (this.activeTurnIdsByThreadId.get(threadId) === turn.id) this.activeTurnIdsByThreadId.delete(threadId);
+	}
+	dispatchNotification(notification) {
+		const params = notification.params;
+		const record = params && typeof params === "object" ? params : {};
+		const threadId = typeof record.threadId === "string" ? record.threadId : void 0;
+		const turn = record.turn && typeof record.turn === "object" ? record.turn : void 0;
+		const turnId = typeof record.turnId === "string" ? record.turnId : typeof turn?.id === "string" ? turn.id : void 0;
+		if (notification.method === "turn/started" && threadId && turnId) {
+			if (this.terminalTurnIdsByThreadId.get(threadId) !== turnId) {
+				this.activeTurnIdsByThreadId.set(threadId, turnId);
+				this.terminalTurnIdsByThreadId.delete(threadId);
+			}
+		} else if ([
+			"turn/completed",
+			"turn/failed",
+			"turn/aborted",
+			"turn/cancelled"
+		].includes(notification.method) && threadId) {
+			if (turnId) this.terminalTurnIdsByThreadId.set(threadId, turnId);
+			if (!turnId || this.activeTurnIdsByThreadId.get(threadId) === turnId) this.activeTurnIdsByThreadId.delete(threadId);
+		}
+		for (const handler of this.notificationHandlers) handler(notification);
 	}
 	startStdioCodexAppServer() {
 		const spawnConfig = resolveCodexAppServerSpawn();
@@ -528,7 +668,7 @@ var CodexAppServerClient = class {
 		} catch {
 			return;
 		}
-		if (typeof message.method === "string" && typeof message.id === "number") {
+		if (typeof message.method === "string" && (typeof message.id === "number" || typeof message.id === "string")) {
 			debugAppServer("server-request", message.method, message.id);
 			const request = {
 				id: message.id,
@@ -545,7 +685,7 @@ var CodexAppServerClient = class {
 				method: message.method,
 				params: message.params
 			};
-			for (const handler of this.notificationHandlers) handler(notification);
+			this.dispatchNotification(notification);
 			return;
 		}
 		if (typeof message.id !== "number") return;
@@ -644,6 +784,15 @@ function connectRemoteAddress(remoteAddress) {
 function sharedCodexAppServerSocketPath() {
 	return join(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "app-server-control", "app-server-control.sock");
 }
+function isAppServerTurnInProgress(turn) {
+	if (turn.completedAt !== null && turn.completedAt !== void 0) return false;
+	const status = typeof turn.status === "string" ? turn.status : turn.status && typeof turn.status === "object" && "type" in turn.status ? String(turn.status.type) : "";
+	return [
+		"active",
+		"inprogress",
+		"running"
+	].includes(status.toLowerCase().replace(/[^a-z0-9]/g, ""));
+}
 function asError(error) {
 	return error instanceof Error ? error : new Error(String(error));
 }
@@ -672,7 +821,8 @@ function extractStreamText(event) {
 	if (!event || typeof event !== "object") return;
 	const record = event;
 	const item = record.item && typeof record.item === "object" ? record.item : void 0;
-	const candidate = record.delta ?? record.text ?? record.message ?? item?.text ?? item?.aggregated_output ?? item?.command;
+	const error = record.error && typeof record.error === "object" ? record.error : void 0;
+	const candidate = record.delta ?? record.text ?? record.message ?? error?.message ?? item?.text ?? item?.message ?? item?.aggregated_output ?? item?.command;
 	return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
 }
 function classifyStreamEvent(event) {
@@ -1472,11 +1622,47 @@ function createApp(options = {}) {
 	const appServerMutationTails = /* @__PURE__ */ new Map();
 	const workspaceTerminalSessions = /* @__PURE__ */ new Map();
 	const activeAppServerTurnIdsByThreadId = /* @__PURE__ */ new Map();
+	const appServerHistoryGenerationsByThreadId = /* @__PURE__ */ new Map();
 	const appServerHistoryLoadsByThreadId = /* @__PURE__ */ new Map();
+	const appServerRolloutPathsByThreadId = /* @__PURE__ */ new Map();
 	const steeringThreads = /* @__PURE__ */ new Set();
 	const secureSessionsByTokenHash = /* @__PURE__ */ new Map();
 	const activeStreamControllers = /* @__PURE__ */ new Map();
-	const threadOptions = { workingDirectory: workspacePath };
+	const threadOptions = {
+		threadSource: "codex-relay",
+		workingDirectory: workspacePath
+	};
+	const advanceAppServerHistoryGeneration = (threadId) => {
+		appServerHistoryGenerationsByThreadId.set(threadId, (appServerHistoryGenerationsByThreadId.get(threadId) ?? 0) + 1);
+	};
+	const invalidateAppServerHistory = (threadId) => {
+		advanceAppServerHistoryGeneration(threadId);
+		appServerHistoryLoadsByThreadId.delete(threadId);
+		appServerRolloutPathsByThreadId.delete(threadId);
+		messagesByThreadId.delete(threadId);
+	};
+	if (appServer && typeof appServer.onNotification === "function") appServer.onNotification((notification) => {
+		const params = recordParams(notification);
+		const threadId = firstString(params, ["threadId"]);
+		if (!threadId) return;
+		if (notification.method === "thread/reverted") {
+			invalidateAppServerHistory(threadId);
+			return;
+		}
+		if (notification.method === "item/completed") {
+			advanceAppServerHistoryGeneration(threadId);
+			const item = params?.item;
+			if (item && typeof item === "object" && item.type !== "userMessage") upsertAppServerItemMessage(messagesByThreadId, threadId, firstString(params, ["turnId"]), item);
+			return;
+		}
+		if (notification.method === "turn/completed") {
+			advanceAppServerHistoryGeneration(threadId);
+			const turn = appServerTurnFromParams(params);
+			if (turn) {
+				for (const item of turn.items) if (item.type !== "userMessage") upsertAppServerItemMessage(messagesByThreadId, threadId, turn.id, item);
+			}
+		}
+	});
 	function runThreadOperation(threadId, operation) {
 		const result = (threadOperationTails.get(threadId) ?? Promise.resolve()).then(operation, operation);
 		const tail = result.then(() => void 0, () => void 0);
@@ -1503,13 +1689,18 @@ function createApp(options = {}) {
 	const scheduleAppServerHistoryLoad = (threadId, cachedMessages) => {
 		if (!appServer || appServerHistoryLoadsByThreadId.has(threadId)) return;
 		const startedAt = Date.now();
+		const historyGeneration = appServerHistoryGenerationsByThreadId.get(threadId) ?? 0;
 		relayDebugLog("thread.detail.history.background_started", {
 			cachedMessageCount: cachedMessages.length,
 			threadId
 		});
 		const load = appServer.readThread(threadId, { includeTurns: true }).then((threadWithTurns) => {
-			const mappedThread = rememberAppServerThread(threads, threadWithTurns, { authoritativeMessageCount: true });
-			const messages = mergeAppServerMessagesWithLocalStatus(mapAppServerMessages(threadWithTurns), messagesByThreadId.get(threadId) ?? cachedMessages);
+			if ((appServerHistoryGenerationsByThreadId.get(threadId) ?? 0) !== historyGeneration) return;
+			const hasCompleteHistory = appServerThreadHasCompleteHistory(threadWithTurns);
+			const mappedThread = rememberAppServerThread(threads, threadWithTurns, { authoritativeMessageCount: hasCompleteHistory });
+			const appMessages = mapAppServerMessages(threadWithTurns);
+			const localMessages = messagesByThreadId.get(threadId) ?? cachedMessages;
+			const messages = hasCompleteHistory ? mergeAppServerMessagesWithLocalStatus(appMessages, localMessages) : mergeThreadMessagePages(appMessages, localMessages);
 			messagesByThreadId.set(threadId, messages);
 			relayDebugLog("thread.detail.history.background_completed", {
 				durationMs: Date.now() - startedAt,
@@ -1524,7 +1715,7 @@ function createApp(options = {}) {
 				threadId
 			});
 		}).finally(() => {
-			appServerHistoryLoadsByThreadId.delete(threadId);
+			if (appServerHistoryLoadsByThreadId.get(threadId) === load) appServerHistoryLoadsByThreadId.delete(threadId);
 		});
 		appServerHistoryLoadsByThreadId.set(threadId, load);
 	};
@@ -2203,13 +2394,27 @@ function createApp(options = {}) {
 				const turns = threadBeforeRewind.turns ?? [];
 				const turnIndex = turns.findIndex((turn) => turn.id === parsed.data.turnId);
 				if (turnIndex < 0) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("not_found", "The selected message is no longer available to rewind."), 404);
-				const rolledBackThread = await appServer.rollbackThread({
+				let rolledBackThread;
+				if (threadBeforeRewind.historyMode === "paginated" && typeof appServer.revertThread === "function") try {
+					rolledBackThread = await appServer.revertThread({
+						beforeTurnId: parsed.data.turnId,
+						threadId
+					});
+				} catch (error) {
+					if (!/method not found|unsupported|-32601/i.test(errorMessage(error))) throw error;
+					rolledBackThread = await appServer.rollbackThread({
+						threadId,
+						numTurns: turns.length - turnIndex
+					});
+				}
+				else rolledBackThread = await appServer.rollbackThread({
 					threadId,
 					numTurns: turns.length - turnIndex
 				});
 				const threadWithTurns = rolledBackThread.turns === void 0 ? await appServer.readThread(threadId, { includeTurns: true }) : rolledBackThread;
 				const thread = rememberAppServerThread(threads, threadWithTurns, { authoritativeMessageCount: true });
 				const messages = mapAppServerMessages(threadWithTurns);
+				invalidateAppServerHistory(threadId);
 				messagesByThreadId.set(threadId, messages);
 				liveThreads.delete(threadId);
 				activeAppServerTurnIdsByThreadId.delete(threadId);
@@ -2239,18 +2444,29 @@ function createApp(options = {}) {
 			const thread = await appServer.readThread(threadId, { includeTurns: false });
 			if (isSubagentThread(thread)) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("not_found", `Thread ${threadId} is not known to this server.`), 404);
 			const mappedThread = rememberAppServerThread(threads, thread);
-			const cachedMessages = messagesByThreadId.get(threadId) ?? [];
+			let cachedMessages = messagesByThreadId.get(threadId) ?? [];
+			if (thread.path) {
+				const previousRolloutPath = appServerRolloutPathsByThreadId.get(threadId);
+				if (previousRolloutPath && previousRolloutPath !== thread.path) {
+					invalidateAppServerHistory(threadId);
+					cachedMessages = [];
+				}
+				appServerRolloutPathsByThreadId.set(threadId, thread.path);
+			}
 			let loadedMessages = false;
 			let messages = cachedMessages;
 			let responseThread = preserveKnownRunningThreadState(mappedThread, wasKnownRunning);
 			if (forceRefresh && responseThread.state !== "running") {
 				const threadWithTurns = await appServer.readThread(threadId, { includeTurns: true });
-				responseThread = rememberAppServerThread(threads, threadWithTurns, { authoritativeMessageCount: true });
-				messages = mapAppServerMessages(threadWithTurns);
+				const hasCompleteHistory = appServerThreadHasCompleteHistory(threadWithTurns);
+				responseThread = rememberAppServerThread(threads, threadWithTurns, { authoritativeMessageCount: hasCompleteHistory });
+				const appMessages = mapAppServerMessages(threadWithTurns);
+				messages = hasCompleteHistory ? mergeAppServerMessagesWithLocalStatus(appMessages, cachedMessages) : mergeThreadMessagePages(appMessages, cachedMessages);
 				messagesByThreadId.set(threadId, messages);
 				loadedMessages = true;
 			} else {
-				const rolloutHistory = readRolloutThreadMessages(threadId, workspacePath);
+				const rolloutHistory = readRolloutThreadMessages(threadId, workspacePath, thread.path ?? void 0);
+				if (rolloutHistory.rolloutPath) appServerRolloutPathsByThreadId.set(threadId, rolloutHistory.rolloutPath);
 				if (rolloutHistory.messages.length > 0) {
 					messages = mergeThreadMessagePages(rolloutHistory.messages, cachedMessages);
 					responseThread = rememberRolloutThreadMessages(threads, responseThread, messages, rolloutHistory.messageCountLowerBound);
@@ -2265,8 +2481,10 @@ function createApp(options = {}) {
 			}
 			if (!loadedMessages && responseThread.state !== "running") {
 				const threadWithTurns = await appServer.readThread(threadId, { includeTurns: true });
-				responseThread = rememberAppServerThread(threads, threadWithTurns, { authoritativeMessageCount: true });
-				messages = mergeAppServerMessagesWithLocalStatus(mapAppServerMessages(threadWithTurns), cachedMessages);
+				const hasCompleteHistory = appServerThreadHasCompleteHistory(threadWithTurns);
+				responseThread = rememberAppServerThread(threads, threadWithTurns, { authoritativeMessageCount: hasCompleteHistory });
+				const appMessages = mapAppServerMessages(threadWithTurns);
+				messages = hasCompleteHistory ? mergeAppServerMessagesWithLocalStatus(appMessages, cachedMessages) : mergeThreadMessagePages(appMessages, cachedMessages);
 				messagesByThreadId.set(threadId, messages);
 				loadedMessages = true;
 			} else if (!loadedMessages) scheduleAppServerHistoryLoad(threadId, cachedMessages);
@@ -2927,11 +3145,10 @@ async function createAppServerThreadRecord(input) {
 	const thread = await input.appServer.startThread({
 		approvalPolicy: runtime.approvalPolicy,
 		cwd: input.workspacePath,
-		experimentalRawEvents: false,
 		model: input.options.model ?? null,
-		persistExtendedHistory: true,
 		sandbox: runtime.sandbox,
-		serviceTier: input.options.serviceTier ?? null
+		serviceTier: input.options.serviceTier ?? null,
+		threadSource: "codex-relay"
 	});
 	const metadata = ThreadSummarySchema.parse({
 		...mapAppServerThread({
@@ -3101,11 +3318,25 @@ async function runPromptStreamed(input) {
 			message: assistantMessage
 		});
 		for await (const event of streamed.events) {
+			activeThreadId = replaceLocalThreadId(input.threads, input.messagesByThreadId, input.liveThreads, activeThreadId, getThreadId(thread));
 			const kind = classifyStreamEvent(event);
 			const text = extractStreamText(event);
 			if (kind === "error") throw new Error(text ?? "Codex run failed.");
-			if (!text) continue;
 			if (kind === "assistant") {
+				if (!text) continue;
+				if (isCompletedAgentMessageEvent(event)) {
+					assistantMessage = updateMessage(input.messagesByThreadId, activeThreadId, assistantMessage.id, { content: text });
+					threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
+						state: "running",
+						lastResult: assistantMessage.content
+					});
+					sendSse(input.controller, input.encoder, input.secureSession, {
+						type: "thread.message.created",
+						thread: threadSummary,
+						message: assistantMessage
+					});
+					continue;
+				}
 				const assistantPatch = appendMessageDelta(input.messagesByThreadId, activeThreadId, assistantMessage.id, text);
 				assistantMessage = assistantPatch.message;
 				updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
@@ -3119,14 +3350,18 @@ async function runPromptStreamed(input) {
 					delta: assistantPatch.delta
 				});
 			} else {
-				const structured = structuredStreamMessage(kind, event, text);
-				const statusMessage = appendMessage(input.messagesByThreadId, activeThreadId, {
+				if (!text && !isRenderableStructuredStreamEvent(event)) continue;
+				const structured = structuredStreamMessage(kind, event, text ?? "Codex activity");
+				const itemId = firstString(eventItem(event), ["id"]);
+				const existingMessage = itemId ? input.messagesByThreadId.get(activeThreadId)?.find((message) => message.id === itemId) : void 0;
+				const message = {
 					role: kind,
 					kind: structured.kind,
 					content: structured.content,
 					details: structured.details,
-					state: "completed"
-				});
+					state: streamItemState(event)
+				};
+				const statusMessage = existingMessage ? updateMessage(input.messagesByThreadId, activeThreadId, existingMessage.id, message) : itemId ? appendMessageWithId(input.messagesByThreadId, activeThreadId, itemId, message) : appendMessage(input.messagesByThreadId, activeThreadId, message);
 				threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, { state: "running" });
 				sendSse(input.controller, input.encoder, input.secureSession, {
 					type: "thread.message.created",
@@ -3179,6 +3414,7 @@ async function startAppServerTurn(appServer, threadId, input) {
 	const runtime = resolveAppServerRuntime(input.runOptions, input.workspacePath);
 	const params = {
 		approvalPolicy: runtime.approvalPolicy,
+		clientUserMessageId: input.id,
 		collaborationMode: appServerCollaborationMode(input.runOptions),
 		cwd: input.workspacePath,
 		effort: input.runOptions.reasoningEffort ?? null,
@@ -3213,9 +3449,8 @@ async function resumeAppServerThread(appServer, threadId, input, runtime) {
 	await appServer.resumeThread({
 		approvalPolicy: runtime.approvalPolicy,
 		cwd: input.workspacePath,
-		excludeTurns: false,
+		excludeTurns: true,
 		model: input.runOptions.model ?? null,
-		persistExtendedHistory: true,
 		sandbox: runtime.sandbox,
 		serviceTier: input.runOptions.serviceTier ?? null,
 		threadId
@@ -3262,10 +3497,12 @@ async function streamRunningAppServerThread(input) {
 	let observedInputRequest = false;
 	let observedTurnActivity = false;
 	let producedTurnOutput = false;
+	const asyncAgentMessageIds = /* @__PURE__ */ new Set();
 	let threadSummary = input.threads.get(input.threadId);
 	let cleanupNotificationHandler = () => void 0;
 	let cleanupRequestHandler = () => void 0;
 	let handlersCleaned = false;
+	let streamFinished = false;
 	const cleanupHandlers = () => {
 		if (handlersCleaned) return;
 		handlersCleaned = true;
@@ -3286,6 +3523,7 @@ async function streamRunningAppServerThread(input) {
 		if (approval.kind === "structuredUserInput") {
 			const pending = {
 				appServer: input.appServer,
+				isBlocking: approval.isBlocking,
 				kind: approval.kind,
 				method: request.method,
 				questions: approval.questions,
@@ -3330,6 +3568,7 @@ async function streamRunningAppServerThread(input) {
 		const finish = (error) => {
 			if (settled) return;
 			settled = true;
+			streamFinished = true;
 			cleanupHandlers();
 			if (error === void 0) resolve();
 			else reject(error);
@@ -3340,6 +3579,20 @@ async function streamRunningAppServerThread(input) {
 			if (notificationThreadId && notificationThreadId !== input.threadId) return;
 			try {
 				switch (notification.method) {
+					case "serverRequest/resolved": {
+						const requestId = appServerRequestIdFromParams(params);
+						if (requestId === void 0) return;
+						const approvalId = appServerApprovalId(input.threadId, requestId);
+						const pending = input.pendingApprovals.get(approvalId);
+						if (!pending || pending.threadId !== input.threadId) return;
+						input.pendingApprovals.delete(approvalId);
+						if (pending.kind === "structuredUserInput") sendSse(input.controller, input.encoder, input.secureSession, {
+							type: "thread.input_request.resolved",
+							requestId: approvalId,
+							threadId: input.threadId
+						});
+						return;
+					}
 					case "thread/status/changed": {
 						const state = mapAppServerThreadState(params?.status);
 						if (state !== "running" && observedTurnActivity) return;
@@ -3375,11 +3628,13 @@ async function streamRunningAppServerThread(input) {
 						if (!item || typeof item !== "object") return;
 						const message = upsertAppServerItemMessage(input.messagesByThreadId, input.threadId, firstString(params, ["turnId"]) ?? activeTurnId, item);
 						if (!message) return;
-						if (message.role !== "user") producedTurnOutput = true;
-						if (message.role === "assistant") assistantMessageId = message.id;
+						const isAsyncAgentMessage = isAsyncAppServerAgentMessage(item);
+						if (isAsyncAgentMessage) asyncAgentMessageIds.add(message.id);
+						if (message.role !== "user" && !isAsyncAgentMessage) producedTurnOutput = true;
+						if (message.role === "assistant" && !isAsyncAgentMessage) assistantMessageId = message.id;
 						threadSummary = updateThread(input.threads, input.messagesByThreadId, input.threadId, {
 							state: "running",
-							lastResult: message.role === "assistant" ? message.content : void 0
+							...message.role === "assistant" && !isAsyncAgentMessage ? { lastResult: message.content } : {}
 						});
 						sendSse(input.controller, input.encoder, input.secureSession, {
 							type: notification.method === "item/completed" && message.role === "assistant" ? "thread.message.completed" : "thread.message.created",
@@ -3399,13 +3654,16 @@ async function streamRunningAppServerThread(input) {
 							state: "streaming",
 							turnId: firstString(params, ["turnId"]) ?? activeTurnId
 						});
-						assistantMessageId = itemId;
-						producedTurnOutput = true;
+						const isAsyncAgentMessage = asyncAgentMessageIds.has(itemId);
+						if (!isAsyncAgentMessage) {
+							assistantMessageId = itemId;
+							producedTurnOutput = true;
+						}
 						const patch = appendMessageDelta(input.messagesByThreadId, input.threadId, itemId, delta);
 						const message = patch.message;
 						updateThread(input.threads, input.messagesByThreadId, input.threadId, {
 							state: "running",
-							lastResult: message.content
+							...isAsyncAgentMessage ? {} : { lastResult: message.content }
 						});
 						if (patch.delta) sendSse(input.controller, input.encoder, input.secureSession, {
 							type: "thread.message.delta",
@@ -3441,6 +3699,27 @@ async function streamRunningAppServerThread(input) {
 					case "turn/failed": {
 						observedTurnActivity = true;
 						const state = terminalTurnState(notification.method, params);
+						const terminalTurn = appServerTurnFromParams(params);
+						if (terminalTurn) {
+							activeTurnId = terminalTurn.id;
+							for (const item of terminalTurn.items) {
+								const message = upsertAppServerItemMessage(input.messagesByThreadId, input.threadId, terminalTurn.id, item);
+								if (!message) continue;
+								const isAsyncAgentMessage = isAsyncAppServerAgentMessage(item);
+								if (isAsyncAgentMessage) asyncAgentMessageIds.add(message.id);
+								if (message.role !== "user" && !isAsyncAgentMessage) producedTurnOutput = true;
+								if (message.role === "assistant" && !isAsyncAgentMessage) assistantMessageId = message.id;
+								threadSummary = updateThread(input.threads, input.messagesByThreadId, input.threadId, {
+									state: "running",
+									...message.role === "assistant" && !isAsyncAgentMessage ? { lastResult: message.content } : {}
+								});
+								sendSse(input.controller, input.encoder, input.secureSession, {
+									type: message.role === "assistant" ? "thread.message.completed" : "thread.message.created",
+									thread: threadSummary,
+									message
+								});
+							}
+						}
 						relayDebugLog("app_server.turn.terminal", {
 							method: notification.method,
 							state,
@@ -3460,7 +3739,8 @@ async function streamRunningAppServerThread(input) {
 							finish();
 							return;
 						}
-						if (assistantMessageId) {
+						const assistantMessage = assistantMessageId ? input.messagesByThreadId.get(input.threadId)?.find((message) => message.id === assistantMessageId) : void 0;
+						if (assistantMessageId && assistantMessage?.state !== "completed") {
 							const completedMessage = updateMessage(input.messagesByThreadId, input.threadId, assistantMessageId, { state: "completed" });
 							sendSse(input.controller, input.encoder, input.secureSession, {
 								type: "thread.message.completed",
@@ -3518,8 +3798,15 @@ async function streamRunningAppServerThread(input) {
 		removeAbortListener = () => input.signal.removeEventListener("abort", onAbort);
 	});
 	try {
-		const appServerThread = await Promise.race([input.appServer.readThread(input.threadId, { includeTurns: false }), aborted.then(() => void 0)]);
+		const appServerThread = await Promise.race([typeof input.appServer.resumeThread === "function" ? input.appServer.resumeThread({
+			excludeTurns: true,
+			threadId: input.threadId
+		}) : input.appServer.readThread(input.threadId, { includeTurns: false }), aborted.then(() => void 0)]);
 		if (!appServerThread || input.signal.aborted) return;
+		if (streamFinished) {
+			await completed;
+			return;
+		}
 		threadSummary = rememberAppServerThread(input.threads, appServerThread);
 		sendSse(input.controller, input.encoder, input.secureSession, {
 			type: "thread.state.changed",
@@ -3553,6 +3840,7 @@ async function runAppServerPromptStreamed(input) {
 	let handedOffToQueuedTurn = false;
 	let observedInputRequest = false;
 	let producedTurnOutput = false;
+	const asyncAgentMessageIds = /* @__PURE__ */ new Set();
 	let userMessage = appendMessage(input.messagesByThreadId, activeThreadId, {
 		role: "user",
 		content: displayPrompt,
@@ -3589,6 +3877,7 @@ async function runAppServerPromptStreamed(input) {
 		if (approval.kind === "structuredUserInput") {
 			const pending = {
 				appServer: input.appServer,
+				isBlocking: approval.isBlocking,
 				kind: approval.kind,
 				method: request.method,
 				questions: approval.questions,
@@ -3668,7 +3957,8 @@ async function runAppServerPromptStreamed(input) {
 			resolveCompleted();
 			return;
 		}
-		if (assistantMessageId) {
+		const assistantMessage = assistantMessageId ? input.messagesByThreadId.get(activeThreadId)?.find((message) => message.id === assistantMessageId) : void 0;
+		if (assistantMessageId && assistantMessage?.state !== "completed") {
 			const completedMessage = updateMessage(input.messagesByThreadId, activeThreadId, assistantMessageId, { state: "completed" });
 			sendSse(input.controller, input.encoder, input.secureSession, {
 				type: "thread.message.completed",
@@ -3723,8 +4013,7 @@ async function runAppServerPromptStreamed(input) {
 		cleanupNotificationHandler();
 		resolveCompleted();
 	}
-	async function processReturnedTurn(turn) {
-		if (finalizedTurnIds.has(turn.id)) return;
+	function processTurnItems(turn) {
 		activeTurnId = turn.id;
 		input.activeAppServerTurnIdsByThreadId.set(activeThreadId, turn.id);
 		const turnIsRunning = isAppServerTurnRunning(turn);
@@ -3750,11 +4039,13 @@ async function runAppServerPromptStreamed(input) {
 			}
 			const message = upsertAppServerItemMessage(input.messagesByThreadId, activeThreadId, turn.id, item);
 			if (!message) continue;
-			if (message.role !== "user") producedTurnOutput = true;
-			if (message.role === "assistant" && turnIsRunning) assistantMessageId = message.id;
+			const isAsyncAgentMessage = isAsyncAppServerAgentMessage(item);
+			if (isAsyncAgentMessage) asyncAgentMessageIds.add(message.id);
+			if (message.role !== "user" && !isAsyncAgentMessage) producedTurnOutput = true;
+			if (message.role === "assistant" && !isAsyncAgentMessage) assistantMessageId = message.id;
 			threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
 				state: "running",
-				lastResult: message.role === "assistant" ? message.content : void 0
+				...message.role === "assistant" && !isAsyncAgentMessage ? { lastResult: message.content } : {}
 			});
 			sendSse(input.controller, input.encoder, input.secureSession, {
 				type: message.role === "assistant" ? "thread.message.completed" : "thread.message.created",
@@ -3762,7 +4053,11 @@ async function runAppServerPromptStreamed(input) {
 				message
 			});
 		}
-		if (turnIsRunning) return;
+		return turnIsRunning;
+	}
+	async function processReturnedTurn(turn) {
+		if (finalizedTurnIds.has(turn.id)) return;
+		if (processTurnItems(turn)) return;
 		const params = { turn };
 		const state = terminalTurnState("turn/completed", params);
 		await finishTerminalTurn({
@@ -3788,6 +4083,20 @@ async function runAppServerPromptStreamed(input) {
 			if (threadId && threadId !== activeThreadId) return;
 			try {
 				switch (notification.method) {
+					case "serverRequest/resolved": {
+						const requestId = appServerRequestIdFromParams(params);
+						if (requestId === void 0) return;
+						const approvalId = appServerApprovalId(activeThreadId, requestId);
+						const pending = input.pendingApprovals.get(approvalId);
+						if (!pending || pending.threadId !== activeThreadId) return;
+						input.pendingApprovals.delete(approvalId);
+						if (pending.kind === "structuredUserInput") sendSse(input.controller, input.encoder, input.secureSession, {
+							type: "thread.input_request.resolved",
+							requestId: approvalId,
+							threadId: activeThreadId
+						});
+						return;
+					}
 					case "thread/status/changed": {
 						const status = params?.status;
 						const state = mapAppServerThreadState(status);
@@ -3840,11 +4149,13 @@ async function runAppServerPromptStreamed(input) {
 						const turnId = firstString(params, ["turnId"]) ?? activeTurnId;
 						const message = upsertAppServerItemMessage(input.messagesByThreadId, activeThreadId, turnId, item);
 						if (!message) return;
-						if (message.role !== "user") producedTurnOutput = true;
-						if (message.role === "assistant") assistantMessageId = message.id;
+						const isAsyncAgentMessage = isAsyncAppServerAgentMessage(item);
+						if (isAsyncAgentMessage) asyncAgentMessageIds.add(message.id);
+						if (message.role !== "user" && !isAsyncAgentMessage) producedTurnOutput = true;
+						if (message.role === "assistant" && !isAsyncAgentMessage) assistantMessageId = message.id;
 						threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
 							state: "running",
-							lastResult: message.role === "assistant" ? message.content : void 0
+							...message.role === "assistant" && !isAsyncAgentMessage ? { lastResult: message.content } : {}
 						});
 						sendSse(input.controller, input.encoder, input.secureSession, {
 							type: notification.method === "item/completed" && message.role === "assistant" ? "thread.message.completed" : "thread.message.created",
@@ -3863,13 +4174,14 @@ async function runAppServerPromptStreamed(input) {
 							state: "streaming",
 							turnId: firstString(params, ["turnId"]) ?? activeTurnId
 						});
-						assistantMessageId = itemId;
+						const isAsyncAgentMessage = asyncAgentMessageIds.has(itemId);
+						if (!isAsyncAgentMessage) assistantMessageId = itemId;
 						const patch = appendMessageDelta(input.messagesByThreadId, activeThreadId, itemId, delta);
 						const message = patch.message;
-						producedTurnOutput = true;
+						if (!isAsyncAgentMessage) producedTurnOutput = true;
 						updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
 							state: "running",
-							lastResult: message.content
+							...isAsyncAgentMessage ? {} : { lastResult: message.content }
 						});
 						if (patch.delta) sendSse(input.controller, input.encoder, input.secureSession, {
 							type: "thread.message.delta",
@@ -3903,14 +4215,19 @@ async function runAppServerPromptStreamed(input) {
 					case "turn/completed":
 					case "turn/failed": {
 						const state = terminalTurnState(notification.method, params);
+						const terminalTurn = appServerTurnFromParams(params);
 						const terminalTurnId = firstString(params, ["turnId"]) ?? turnIdFromParams(params) ?? activeTurnId;
 						input.runThreadOperation(activeThreadId, async () => {
-							await input.runAppServerMutation(activeThreadId, () => finishTerminalTurn({
-								lastError: state === "failed" ? turnErrorMessage(params) : void 0,
-								method: notification.method,
-								state,
-								turnId: terminalTurnId
-							}));
+							await input.runAppServerMutation(activeThreadId, async () => {
+								if (terminalTurnId && finalizedTurnIds.has(terminalTurnId) || terminalTurnId && activeTurnId && terminalTurnId !== activeTurnId) return;
+								if (terminalTurn && terminalTurn.id === terminalTurnId) processTurnItems(terminalTurn);
+								await finishTerminalTurn({
+									lastError: state === "failed" ? turnErrorMessage(params) : void 0,
+									method: notification.method,
+									state,
+									turnId: terminalTurnId
+								});
+							});
 						}).catch((error) => {
 							cleanupNotificationHandler();
 							rejectCompleted(error);
@@ -3926,36 +4243,34 @@ async function runAppServerPromptStreamed(input) {
 	});
 	try {
 		debugStream(`wait idle gate first=${(input.messagesByThreadId.get(activeThreadId) ?? []).every((message) => message.id === userMessage.id) ? "1" : "0"} active=${activeTurnId ?? "none"}`, activeThreadId);
-		if (activeTurnId) {
-			debugStream("wait idle begin", activeThreadId);
-			await waitForAppServerThreadIdle({
-				appServer: input.appServer,
-				onWaiting() {
-					if (waitingForActiveTurnMessageId) return;
-					const message = appendMessage(input.messagesByThreadId, activeThreadId, {
-						role: "status",
-						content: "Waiting for the current Codex turn to finish.",
-						state: "streaming"
-					});
-					waitingForActiveTurnMessageId = message.id;
-					threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, { state: "running" });
-					sendSse(input.controller, input.encoder, input.secureSession, {
-						type: "thread.message.created",
-						thread: threadSummary,
-						message
-					});
-				},
-				onWaitingHeartbeat() {
-					threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, { state: "running" });
-					sendSse(input.controller, input.encoder, input.secureSession, {
-						type: "thread.state.changed",
-						thread: threadSummary
-					});
-				},
-				threadId: activeThreadId
-			});
-			debugStream("wait idle complete", activeThreadId);
-		}
+		debugStream("wait idle begin", activeThreadId);
+		await waitForAppServerThreadIdle({
+			appServer: input.appServer,
+			onWaiting() {
+				if (waitingForActiveTurnMessageId) return;
+				const message = appendMessage(input.messagesByThreadId, activeThreadId, {
+					role: "status",
+					content: "Waiting for the current Codex turn to finish.",
+					state: "streaming"
+				});
+				waitingForActiveTurnMessageId = message.id;
+				threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, { state: "running" });
+				sendSse(input.controller, input.encoder, input.secureSession, {
+					type: "thread.message.created",
+					thread: threadSummary,
+					message
+				});
+			},
+			onWaitingHeartbeat() {
+				threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, { state: "running" });
+				sendSse(input.controller, input.encoder, input.secureSession, {
+					type: "thread.state.changed",
+					thread: threadSummary
+				});
+			},
+			threadId: activeThreadId
+		});
+		debugStream("wait idle complete", activeThreadId);
 		if (waitingForActiveTurnMessageId) {
 			const message = updateMessage(input.messagesByThreadId, activeThreadId, waitingForActiveTurnMessageId, {
 				content: "Current Codex turn finished. Starting your reply.",
@@ -3973,7 +4288,7 @@ async function runAppServerPromptStreamed(input) {
 		try {
 			turn = await startAndProcessAppServerTurn(activeThreadId, {
 				attachments: input.attachments,
-				id: randomUUID(),
+				id: userMessage.id,
 				prompt,
 				runOptions: input.runOptions,
 				skills: input.skills,
@@ -4007,7 +4322,7 @@ async function runAppServerPromptStreamed(input) {
 			});
 			turn = await startAndProcessAppServerTurn(activeThreadId, {
 				attachments: input.attachments,
-				id: randomUUID(),
+				id: userMessage.id,
 				prompt,
 				runOptions: input.runOptions,
 				skills: input.skills,
@@ -4120,11 +4435,10 @@ async function recoverMissingAppServerThread(input) {
 	const thread = await input.appServer.startThread({
 		approvalPolicy: runtime.approvalPolicy,
 		cwd: input.workspacePath,
-		experimentalRawEvents: false,
 		model: input.runOptions.model ?? null,
-		persistExtendedHistory: true,
 		sandbox: runtime.sandbox,
-		serviceTier: input.runOptions.serviceTier ?? null
+		serviceTier: input.runOptions.serviceTier ?? null,
+		threadSource: "codex-relay"
 	});
 	const recoveredThread = mapAppServerThread({
 		...thread,
@@ -4277,7 +4591,11 @@ function appendMessageWithId(messagesByThreadId, threadId, id, input) {
 function upsertAppServerItemMessage(messagesByThreadId, threadId, turnId, item) {
 	const message = mapAppServerItem(threadId, appServerTurnShell(turnId), item);
 	if (!message) return;
-	if (messagesByThreadId.get(threadId)?.some((candidate) => candidate.id === item.id)) return updateMessage(messagesByThreadId, threadId, item.id, message);
+	const existing = messagesByThreadId.get(threadId)?.find((candidate) => candidate.id === item.id);
+	if (existing) return updateMessage(messagesByThreadId, threadId, item.id, {
+		...message,
+		createdAt: existing.createdAt
+	});
 	return appendMessageWithId(messagesByThreadId, threadId, item.id, {
 		role: message.role,
 		kind: message.kind,
@@ -4295,6 +4613,7 @@ function replaceDuplicateInitialUserMessage(messagesByThreadId, threadId, turnId
 }
 function isDuplicateInitialUserMessage(messagesByThreadId, threadId, item, localMessageId, prompt) {
 	if (item.type !== "userMessage" || !("content" in item) || !Array.isArray(item.content)) return false;
+	if (item.clientId) return item.clientId === localMessageId;
 	const localMessage = messagesByThreadId.get(threadId)?.find((message) => message.id === localMessageId);
 	const skills = appServerUserMessageSkills(item);
 	const normalizeContent = (content) => stripPromptSkillMentions(normalizeImageMessageContent(content), skills);
@@ -4966,6 +5285,7 @@ function hasExplicitRunOptions(options) {
 function mapAppServerThread(thread, fallbackMessageCount) {
 	const createdAt = fromUnixSeconds(thread.createdAt);
 	const updatedAt = fromUnixSeconds(thread.updatedAt);
+	const lastActivityAt = fromUnixSeconds(thread.recencyAt ?? thread.updatedAt);
 	const messageCount = Math.max(thread.turns ? countThreadMessages(thread) : 0, fallbackMessageCount ?? 0);
 	const mappedState = mapAppServerThreadState(thread.status, thread.turns);
 	return ThreadSummarySchema.parse({
@@ -4979,7 +5299,7 @@ function mapAppServerThread(thread, fallbackMessageCount) {
 		source: thread.source,
 		messageCount,
 		lastMessagePreview: thread.preview ? preview(thread.preview) : void 0,
-		lastActivityAt: updatedAt
+		lastActivityAt
 	});
 }
 function rememberAppServerThread(threads, thread, options = {}) {
@@ -5032,6 +5352,12 @@ function mapAppServerMessages(thread) {
 	}
 	return messages;
 }
+function appServerThreadHasCompleteHistory(thread) {
+	return (thread.turns ?? []).every((turn) => turn.itemsView === void 0 || turn.itemsView === "full");
+}
+function isAsyncAppServerAgentMessage(item) {
+	return item.type === "agentMessage" && "delivery" in item && item.delivery === "async";
+}
 function mergeAppServerMessagesWithLocalStatus(appMessages, localMessages) {
 	const appMessageIds = new Set(appMessages.map((message) => message.id));
 	const localStatusMessages = localMessages.filter((message) => message.role === "status" && !appMessageIds.has(message.id));
@@ -5162,13 +5488,18 @@ function readSessionIndexThreadTitle(threadId) {
 		} catch {}
 	}
 }
-function readRolloutThreadMessages(threadId, workspacePath = defaultWorkspacePath) {
-	const rolloutPath = findRolloutFileForThread(threadId);
+function readRolloutThreadMessages(threadId, workspacePath = defaultWorkspacePath, selectedRolloutPath) {
+	const rolloutPath = selectedRolloutPath && selectedRolloutPath.endsWith(".jsonl") && existsSync(selectedRolloutPath) ? selectedRolloutPath : findRolloutFileForThread(threadId);
 	if (!rolloutPath) return {
 		messageCountLowerBound: 0,
 		messages: [],
 		rolloutPath
 	};
+	if (isPaginatedRolloutFile(rolloutPath)) return {
+		messageCountLowerBound: 0,
+		messages: [],
+		rolloutPath
+	};
 	const collected = [];
 	const applyPatchInputs = /* @__PURE__ */ new Map();
 	const handledApplyPatchCallIds = /* @__PURE__ */ new Set();
@@ -5208,6 +5539,25 @@ function readRolloutThreadMessages(threadId, workspacePath = defaultWorkspacePat
 		rolloutPath
 	};
 }
+function isPaginatedRolloutFile(rolloutPath) {
+	let descriptor;
+	try {
+		descriptor = openSync(rolloutPath, "r");
+		const buffer = Buffer.allocUnsafe(64 * 1024);
+		const bytesRead = readSync(descriptor, buffer, 0, buffer.length, 0);
+		const prefix = buffer.toString("utf8", 0, bytesRead);
+		for (const line of prefix.split("\n")) {
+			if (!line.trim()) continue;
+			const record = JSON.parse(line);
+			if (record.type === "session_meta") return record.payload?.history_mode === "paginated";
+		}
+	} catch {
+		return false;
+	} finally {
+		if (descriptor !== void 0) closeSync(descriptor);
+	}
+	return false;
+}
 function findRolloutFileForThread(threadId) {
 	const sessionsRoot = join(process.env.CODEX_HOME || join(homedir(), ".codex"), "sessions");
 	if (!existsSync(sessionsRoot)) return;
@@ -5572,12 +5922,16 @@ function mapAppServerItem(threadId, turn, item) {
 			const agentItem = item;
 			const planContent = proposedPlanContent(agentItem.text);
 			const messageParts = appServerAgentMessageParts(agentItem);
+			const details = planContent ? { raw: agentItem.text } : agentItem.delivery || messageParts.details ? {
+				...messageParts.details,
+				delivery: agentItem.delivery ?? void 0
+			} : void 0;
 			return ChatMessageSchema.parse({
 				...base,
 				role: "assistant",
 				kind: planContent ? "plan" : void 0,
 				content: planContent ?? messageParts.content,
-				details: planContent ? { raw: agentItem.text } : messageParts.details
+				details
 			});
 		}
 		case "reasoning": {
@@ -5977,6 +6331,21 @@ function structuredStreamMessage(role, event, fallbackContent) {
 				type
 			}
 		};
+		case "todo_list": {
+			const items = Array.isArray(item?.items) ? item.items : [];
+			return {
+				kind: "plan",
+				content: items.flatMap((entry) => {
+					if (!entry || typeof entry !== "object") return [];
+					const todo = entry;
+					return typeof todo.text === "string" ? [`[${todo.completed === true ? "x" : " "}] ${todo.text}`] : [];
+				}).join("\n") || fallbackContent,
+				details: {
+					items,
+					type
+				}
+			};
+		}
 		default: return {
 			kind: kindFromProtocolType(type) ?? (role === "tool" ? "toolActivity" : "unknown"),
 			content: fallbackContent,
@@ -5984,6 +6353,17 @@ function structuredStreamMessage(role, event, fallbackContent) {
 		};
 	}
 }
+function isCompletedAgentMessageEvent(event) {
+	if (!event || typeof event !== "object") return false;
+	return event.type === "item.completed" && eventItem(event)?.type === "agent_message";
+}
+function isRenderableStructuredStreamEvent(event) {
+	const type = eventItem(event)?.type;
+	return type === "file_change" || type === "mcp_tool_call" || type === "todo_list" || type === "web_search";
+}
+function streamItemState(event) {
+	return event?.type === "item.completed" ? "completed" : "streaming";
+}
 function isApprovalServerRequest(method) {
 	return method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval" || method === "item/permissions/requestApproval" || method === "item/tool/requestUserInput" || method === "mcpServer/elicitation/request" || method === "execCommandApproval" || method === "applyPatchApproval";
 }
@@ -6046,7 +6426,7 @@ function approvalMessageFromRequest(request) {
 	const threadId = firstString(params, ["threadId", "conversationId"]);
 	const turnId = firstString(params, ["turnId"]) ?? void 0;
 	if (!threadId) return;
-	const approvalId = `approval-${request.id}`;
+	const approvalId = appServerApprovalId(threadId, request.id);
 	switch (request.method) {
 		case "item/commandExecution/requestApproval": {
 			const command = firstString(params, ["command"]) ?? "Command execution";
@@ -6134,6 +6514,7 @@ function approvalMessageFromRequest(request) {
 					questions
 				},
 				kind: "structuredUserInput",
+				isBlocking: typeof params?.isBlocking === "boolean" ? params.isBlocking : true,
 				questions,
 				threadId,
 				turnId
@@ -6188,6 +6569,7 @@ function pendingInputOptions(value) {
 function pendingInputRequestFromApproval(approval, threadId) {
 	return {
 		id: approval.approvalId,
+		isBlocking: approval.isBlocking ?? true,
 		questions: approval.questions ?? [],
 		threadId,
 		turnId: approval.turnId
@@ -6198,6 +6580,7 @@ function pendingInputRequestsForThread(pendingApprovals, threadId) {
 		if (pending.kind !== "structuredUserInput" || pending.threadId !== threadId) return [];
 		return [{
 			id: approvalId,
+			isBlocking: pending.isBlocking ?? true,
 			questions: pending.questions ?? [],
 			threadId,
 			turnId: pending.turnId
@@ -6293,6 +6676,20 @@ function turnIdFromParams(params) {
 	const turn = params?.turn;
 	return turn && typeof turn === "object" ? firstString(turn, ["id"]) : void 0;
 }
+function appServerRequestIdFromParams(params) {
+	const requestId = params?.requestId;
+	return typeof requestId === "number" || typeof requestId === "string" ? requestId : void 0;
+}
+function appServerApprovalId(threadId, requestId) {
+	return `approval-${createHash("sha256").update(threadId).update("\0").update(String(requestId)).digest("hex").slice(0, 24)}`;
+}
+function appServerTurnFromParams(params) {
+	const turn = params?.turn;
+	if (!turn || typeof turn !== "object") return;
+	const record = turn;
+	if (typeof record.id !== "string" || !Array.isArray(record.items)) return;
+	return turn;
+}
 function turnStatus(params) {
 	if (typeof params?.status === "string") return params.status;
 	const turn = params?.turn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-relay",
-  "version": "1.4.9",
+  "version": "1.4.10",
   "description": "Local Codex Relay CLI bridge for the Codex Relay mobile app.",
   "license": "Apache-2.0",
   "repository": {
@@ -41,6 +41,7 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
+    "@openai/codex": "0.149.1",
     "@openai/codex-sdk": "0.149.1",
     "base64-js": "1.5.1",
     "commander": "^14.0.3",

package/src/api-schema.ts

@@ -284,6 +284,7 @@ export const PendingInputRequestQuestionSchema = z.object({
 
 export const PendingInputRequestSchema = z.object({
   id: z.string().min(1),
+  isBlocking: z.boolean().default(true),
   questions: z.array(PendingInputRequestQuestionSchema),
   threadId: z.string().min(1),
   turnId: z.string().optional(),