tellrun 1.3.2 → 1.3.3

package/dist/agents/codex.js

@@ -1,13 +1,13 @@
 import { execFile } from "node:child_process";
-import { readFileSync } from "node:fs";
 import { connect } from "node:net";
 import { homedir } from "node:os";
 import { delimiter, dirname, join } from "node:path";
 import { promisify } from "node:util";
-import { createJSONRPCErrorResponse, createJSONRPCSuccessResponse, JSONRPCClient, JSONRPCErrorException, } from "json-rpc-2.0";
+import { JSONRPCErrorException } from "json-rpc-2.0";
 import WebSocket from "ws";
 import { z } from "zod";
 import { fileChangesSchema, parseCodexInteraction } from "./codex-interaction.js";
+import { createCodexRpc } from "./codex-rpc.js";
 /** 由 Codex 0.165.0 的 generate-ts 核对；只校验实际消费的协议字段。 */
 const turnSchema = z.object({
     id: z.string().min(1),
@@ -57,47 +57,114 @@ export async function createCodexAgent(command = "codex") {
     /** 只绑定当前任务的连接，不能把迟到输入送入下一轮或其他客户端的轮次。 */
     let steer;
     let respond;
+    /** 任务与只读查询共用连接流程；各自使用独立 socket，不争用会话。 */
+    async function connectServer(cwd, signal) {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            signal.throwIfAborted();
+            const socket = await new Promise((resolve) => {
+                const connection = new WebSocket("ws://localhost", {
+                    createConnection: () => connect(join(env.CODEX_HOME ?? join(homedir(), ".codex"), "app-server-control", "app-server-control.sock")),
+                    handshakeTimeout: 5_000,
+                    maxPayload: 8_000_000,
+                });
+                /** 连接尚未建立时也能响应关停，不等待握手超时。 */
+                const abort = () => connection.terminate();
+                signal.addEventListener("abort", abort, { once: true });
+                connection.once("open", () => {
+                    signal.removeEventListener("abort", abort);
+                    resolve(connection);
+                });
+                connection.once("error", () => {
+                    signal.removeEventListener("abort", abort);
+                    connection.terminate();
+                    resolve(undefined);
+                });
+            });
+            if (socket) {
+                if (signal.aborted) {
+                    socket.terminate();
+                    signal.throwIfAborted();
+                }
+                return socket;
+            }
+            signal.throwIfAborted();
+            if (attempt === 0) {
+                /** bootstrap 由系统管理独立 daemon，避免随 Tellrun 的进程组退出。 */
+                await promisify(execFile)(command, ["app-server", "daemon", "bootstrap"], {
+                    cwd,
+                    env,
+                    timeout: 30_000,
+                    maxBuffer: 1_048_576,
+                    signal,
+                });
+            }
+        }
+        throw new Error("Codex daemon unavailable.");
+    }
     return {
         name: "Codex",
         version: stdout.trim().replace(/^codex-cli /, ""),
         permissionModes: permissionModes.map(({ id, label }) => ({ id, label })),
+        /** 分页读取模型目录；不恢复会话、不发起轮次，也不影响任务连接。 */
+        async listModels(cwd, signal) {
+            signal = AbortSignal.any([signal, AbortSignal.timeout(15_000)]);
+            const rpc = createCodexRpc(await connectServer(cwd, signal));
+            /** 取消仅关闭目录查询，不能向正在运行的轮次发送中断。 */
+            const abort = () => rpc.close("Codex model query cancelled.");
+            signal.addEventListener("abort", abort, { once: true });
+            try {
+                signal.throwIfAborted();
+                await rpc.initialize();
+                const models = [];
+                let cursor = null;
+                do {
+                    signal.throwIfAborted();
+                    const page = z
+                        .object({
+                        data: z.array(z.object({
+                            model: z.string().min(1),
+                            displayName: z.string(),
+                            hidden: z.boolean(),
+                            supportedReasoningEfforts: z.array(z.object({
+                                reasoningEffort: z.string().min(1),
+                                description: z.string(),
+                            })),
+                            defaultReasoningEffort: z.string().min(1),
+                        })),
+                        nextCursor: z.string().nullable(),
+                    })
+                        .parse(await rpc.request("model/list", { limit: 100, includeHidden: false, cursor }));
+                    for (const model of page.data)
+                        if (!model.hidden && !models.some((option) => option.id === model.model))
+                            models.push({
+                                id: model.model,
+                                label: model.displayName || model.model,
+                                reasoningEfforts: model.supportedReasoningEfforts.map((effort) => ({
+                                    id: effort.reasoningEffort,
+                                    label: effort.description,
+                                })),
+                                defaultReasoningEffort: model.defaultReasoningEffort,
+                            });
+                    cursor = page.nextCursor;
+                } while (cursor);
+                return models;
+            }
+            catch {
+                throw new Error("Codex model query failed. Check the local configuration and connection.");
+            }
+            finally {
+                signal.removeEventListener("abort", abort);
+                rpc.close();
+            }
+        },
         async run(input) {
             if (active)
                 throw new Error("Codex is already running a task.");
             const controller = new AbortController();
             active = controller;
-            /** 复用后台的 Unix socket，避免把编码进程放进 Tellrun 的服务控制组。 */
-            const socketPath = join(env.CODEX_HOME ?? join(homedir(), ".codex"), "app-server-control", "app-server-control.sock");
             let socket;
             try {
-                for (let attempt = 0; attempt < 2 && !controller.signal.aborted; attempt++) {
-                    socket = await new Promise((resolve) => {
-                        const connection = new WebSocket("ws://localhost", {
-                            createConnection: () => connect(socketPath),
-                            handshakeTimeout: 5_000,
-                            maxPayload: 8_000_000,
-                        });
-                        connection.once("open", () => resolve(connection));
-                        connection.once("error", () => {
-                            connection.terminate();
-                            resolve(undefined);
-                        });
-                    });
-                    if (socket)
-                        break;
-                    if (attempt === 0) {
-                        /** bootstrap 交给系统管理独立 daemon；普通 detached 子进程仍会被 systemd 清理。 */
-                        await promisify(execFile)(command, ["app-server", "daemon", "bootstrap"], {
-                            cwd: input.cwd,
-                            env,
-                            timeout: 30_000,
-                            maxBuffer: 1_048_576,
-                            signal: controller.signal,
-                        });
-                    }
-                }
-                if (!socket)
-                    throw new Error("Codex daemon unavailable.");
+                socket = await connectServer(input.cwd, controller.signal);
             }
             catch {
                 active = undefined;
@@ -116,16 +183,14 @@ export async function createCodexAgent(command = "codex") {
                 };
             }
             const completed = Promise.withResolvers();
-            /** 库管理请求关联和超时；Codex 线上消息省略 jsonrpc 字段。 */
-            const client = new JSONRPCClient(({ id, method, params }) => write({ id, method, params }));
             const messages = new Map();
             /** 应用随机 ID 隔离每次连接；已见 RPC 编号保留到任务结束，重复请求不生成新按钮。 */
             const interactions = new Map();
             const seenRequests = new Set();
             const fileChanges = new Map();
-            let buffer = "";
             /** 新任务等启动响应，恢复任务等完整快照，再处理当前轮次的早到事件。 */
-            let earlyMessages = "";
+            const earlyMessages = [];
+            let earlyMessageSize = 0;
             let sessionId = input.sessionId ?? undefined;
             let runId;
             let dispatched = Boolean(input.runId);
@@ -154,32 +219,15 @@ export async function createCodexAgent(command = "codex") {
                 if (settled)
                     return;
                 finish({ status: "interrupted", text });
-                client.rejectAllPendingRequests(text);
+                rpc.close(text);
                 controller.abort();
             }
-            /** 请求、通知和交互应答共用发送入口，一帧对应一条 RPC 消息。 */
-            function write(message) {
-                try {
-                    socket?.send(JSON.stringify(message), (error) => {
-                        if (error)
-                            fail("Codex connection write failed. Task status unknown.");
-                    });
-                }
-                catch {
-                    fail("Codex connection write failed. Task status unknown.");
-                }
-            }
             /** 超时结束本次跟踪；区分服务端拒绝与连接故障，保留输入的不确定状态。 */
             async function request(method, params) {
                 if (controller.signal.aborted && method !== "turn/interrupt")
                     throw new Error("Task stopped.");
                 try {
-                    return await client
-                        .timeout(30_000, (id) => {
-                        fail(`Codex ${method} timed out. Not retried.`);
-                        return createJSONRPCErrorResponse(id, 0, "Codex request timed out.");
-                    })
-                        .request(method, params);
+                    return await (method === "initialize" ? rpc.initialize() : rpc.request(method, params));
                 }
                 catch (error) {
                     /** 只识别已知占用错误，避免把可能含敏感信息的原始错误转发到 IM。 */
@@ -214,16 +262,15 @@ export async function createCodexAgent(command = "codex") {
                     return;
                 if (controller.signal.reason === "disconnect") {
                     finish();
-                    client.rejectAllPendingRequests("Tellrun disconnected. Task continues in Codex.");
-                    socket?.terminate();
+                    rpc.close("Tellrun disconnected. Task continues in Codex.");
                     return;
                 }
                 stopTimer = setTimeout(() => fail("Stop unconfirmed; Codex disconnected. Check the project before /resume."), 5_000);
                 if (sessionId && runId) {
-                    void request("turn/interrupt", { threadId: sessionId, turnId: runId }).catch(() => socket?.terminate());
+                    void request("turn/interrupt", { threadId: sessionId, turnId: runId }).catch(() => rpc.close());
                 }
                 else
-                    socket?.terminate();
+                    rpc.close();
             }, { once: true });
             /** 连接关闭不能当作后台任务已停止，更不能向后台补发取消。 */
             function onClose() {
@@ -232,194 +279,169 @@ export async function createCodexAgent(command = "codex") {
                 if (!settled)
                     fail("Codex disconnected. Task may still be running; check the local session.");
                 else
-                    client.rejectAllPendingRequests("Codex connection closed.");
+                    rpc.close();
             }
             /** 实时事件与恢复快照共用协议处理，始终只消费当前任务的事件。 */
-            function onData(chunk) {
+            function onMessage(message) {
                 if (settled)
                     return;
-                buffer += chunk;
-                if (buffer.length > 8_000_000)
-                    return fail("Codex buffer limit exceeded. Task interrupted.");
-                const lines = buffer.split("\n");
-                buffer = lines.pop() ?? "";
-                for (const line of lines) {
-                    if (!line.trim() || settled)
-                        continue;
-                    try {
-                        const message = z
-                            .object({
-                            id: z.union([z.number(), z.string()]).optional(),
-                            method: z.string().optional(),
-                            params: z.unknown().optional(),
-                            result: z.unknown().optional(),
-                            error: z.object({ code: z.number(), message: z.string().optional() }).optional(),
-                        })
-                            .parse(JSON.parse(line));
-                        if (message.method && !runId) {
-                            if (dispatched) {
-                                earlyMessages += `${line}\n`;
-                                if (earlyMessages.length > 8_000_000)
-                                    return fail("Codex event limit exceeded. Task interrupted.");
-                            }
-                            continue;
+                try {
+                    if (message.method && !runId) {
+                        if (dispatched) {
+                            earlyMessages.push(message);
+                            earlyMessageSize += JSON.stringify(message).length;
+                            if (earlyMessageSize > 8_000_000)
+                                return fail("Codex event limit exceeded. Task interrupted.");
                         }
-                        if (message.id !== undefined && message.method) {
-                            /** 共享连接上的交互可能属于其他会话或轮次，不能替其他客户端拒绝。 */
-                            const context = z
-                                .object({ threadId: z.string(), turnId: z.string().optional() })
-                                .safeParse(message.params);
-                            if (!context.success ||
-                                context.data.threadId !== sessionId ||
-                                (context.data.turnId !== undefined && context.data.turnId !== runId))
-                                continue;
-                            if (controller.signal.aborted || seenRequests.has(message.id))
-                                continue;
-                            seenRequests.add(message.id);
-                            const parsed = parseCodexInteraction(message.method, message.params, input.cwd, fileChanges);
-                            if ("error" in parsed) {
-                                if (parsed.unsupported)
-                                    write({
-                                        id: message.id,
-                                        error: { code: -32601, message: "Unsupported interactive request" },
-                                    });
-                                fail(parsed.error);
-                                continue;
-                            }
-                            const { request: interaction } = parsed;
-                            interactions.set(interaction.id, {
-                                requestId: message.id,
-                                ...parsed,
-                                timer: setTimeout(() => {
-                                    const pending = interactions.get(interaction.id);
-                                    if (!pending)
-                                        return;
-                                    if (interaction.blocking) {
-                                        fail("Request timed out. Check /last, then /resume.");
+                        return;
+                    }
+                    if (message.id !== undefined && message.method) {
+                        /** 共享连接上的交互可能属于其他会话或轮次，不能替其他客户端拒绝。 */
+                        const context = z
+                            .object({ threadId: z.string(), turnId: z.string().optional() })
+                            .safeParse(message.params);
+                        if (!context.success ||
+                            context.data.threadId !== sessionId ||
+                            (context.data.turnId !== undefined && context.data.turnId !== runId))
+                            return;
+                        if (controller.signal.aborted || seenRequests.has(message.id))
+                            return;
+                        seenRequests.add(message.id);
+                        const parsed = parseCodexInteraction(message.method, message.params, input.cwd, fileChanges);
+                        if ("error" in parsed) {
+                            if (parsed.unsupported)
+                                rpc.write({
+                                    id: message.id,
+                                    error: { code: -32601, message: "Unsupported interactive request" },
+                                });
+                            fail(parsed.error);
+                            return;
+                        }
+                        const { request: interaction } = parsed;
+                        interactions.set(interaction.id, {
+                            requestId: message.id,
+                            ...parsed,
+                            timer: setTimeout(() => {
+                                const pending = interactions.get(interaction.id);
+                                if (!pending)
+                                    return;
+                                if (interaction.blocking) {
+                                    fail("Request timed out. Check /last, then /resume.");
+                                }
+                                else {
+                                    interactions.delete(interaction.id);
+                                    /** 非阻塞问题过期只返回空答案，不替用户选择，也不中断正在执行的任务。 */
+                                    try {
+                                        input.onInteractionClosed(interaction.id, "Question expired. Task continues.");
+                                        rpc.write({ id: pending.requestId, result: { answers: {} } });
                                     }
-                                    else {
-                                        interactions.delete(interaction.id);
-                                        /** 非阻塞问题过期只返回空答案，不替用户选择，也不中断正在执行的任务。 */
-                                        try {
-                                            input.onInteractionClosed(interaction.id, "Question expired. Task continues.");
-                                            write({ id: pending.requestId, result: { answers: {} } });
-                                        }
-                                        catch {
-                                            fail("Cannot save expired question state. Task interrupted.");
-                                        }
+                                    catch {
+                                        fail("Cannot save expired question state. Task interrupted.");
                                     }
-                                }, Math.max(0, interaction.expiresAt - Date.now())),
-                            });
-                            input.onInteraction(interaction);
-                        }
-                        else if (typeof message.id === "number") {
-                            /** 补齐库需要的协议字段；错误来源标记仅用于本地处理，不信任服务端 data。 */
-                            client.receive(message.error
-                                ? createJSONRPCErrorResponse(message.id, message.error.code, message.error.message ?? "", "codex")
-                                : createJSONRPCSuccessResponse(message.id, message.result));
-                        }
-                        else if (message.method === "serverRequest/resolved") {
-                            const event = z
-                                .object({ threadId: z.string(), requestId: z.union([z.string(), z.number()]) })
-                                .parse(message.params);
-                            if (event.threadId !== sessionId)
-                                continue;
-                            seenRequests.add(event.requestId);
-                            for (const [id, interaction] of interactions) {
-                                if (interaction.requestId !== event.requestId)
-                                    continue;
-                                clearTimeout(interaction.timer);
-                                interactions.delete(id);
-                                input.onInteractionClosed(id, "Request closed.");
-                            }
-                        }
-                        else if (message.method === "item/fileChange/patchUpdated") {
-                            const event = z
-                                .object({
-                                threadId: z.string(),
-                                turnId: z.string(),
-                                itemId: z.string(),
-                                changes: fileChangesSchema,
-                            })
-                                .parse(message.params);
-                            if (event.threadId === sessionId && event.turnId === runId)
-                                fileChanges.set(event.itemId, event.changes);
-                        }
-                        else if (message.method === "item/agentMessage/delta") {
-                            const event = z
-                                .object({
-                                threadId: z.string(),
-                                turnId: z.string(),
-                                itemId: z.string(),
-                                delta: z.string(),
-                            })
-                                .parse(message.params);
-                            if (event.threadId !== sessionId || !recordRun(event.turnId))
+                                }
+                            }, Math.max(0, interaction.expiresAt - Date.now())),
+                        });
+                        input.onInteraction(interaction);
+                    }
+                    else if (message.method === "serverRequest/resolved") {
+                        const event = z
+                            .object({ threadId: z.string(), requestId: z.union([z.string(), z.number()]) })
+                            .parse(message.params);
+                        if (event.threadId !== sessionId)
+                            return;
+                        seenRequests.add(event.requestId);
+                        for (const [id, interaction] of interactions) {
+                            if (interaction.requestId !== event.requestId)
                                 continue;
-                            const item = messages.get(event.itemId) ?? { text: "" };
-                            item.text += event.delta;
-                            messages.set(event.itemId, item);
-                            publishText(item.text);
+                            clearTimeout(interaction.timer);
+                            interactions.delete(id);
+                            input.onInteractionClosed(id, "Request closed.");
                         }
-                        else if (message.method === "item/started" || message.method === "item/completed") {
-                            const event = z
-                                .object({
-                                threadId: z.string(),
-                                turnId: z.string(),
-                                item: z.object({
-                                    type: z.string(),
-                                    id: z.string(),
-                                    text: z.string().optional(),
-                                    phase: z.string().nullish(),
-                                    changes: fileChangesSchema.optional(),
-                                }),
-                            })
-                                .parse(message.params);
-                            if (event.threadId !== sessionId || !recordRun(event.turnId))
-                                continue;
-                            if (event.item.type === "fileChange" && event.item.changes)
-                                fileChanges.set(event.item.id, event.item.changes);
-                            if (event.item.type === "agentMessage" && event.item.text !== undefined) {
-                                messages.set(event.item.id, { text: event.item.text, phase: event.item.phase });
-                                publishText(event.item.text);
-                            }
+                    }
+                    else if (message.method === "item/fileChange/patchUpdated") {
+                        const event = z
+                            .object({
+                            threadId: z.string(),
+                            turnId: z.string(),
+                            itemId: z.string(),
+                            changes: fileChangesSchema,
+                        })
+                            .parse(message.params);
+                        if (event.threadId === sessionId && event.turnId === runId)
+                            fileChanges.set(event.itemId, event.changes);
+                    }
+                    else if (message.method === "item/agentMessage/delta") {
+                        const event = z
+                            .object({
+                            threadId: z.string(),
+                            turnId: z.string(),
+                            itemId: z.string(),
+                            delta: z.string(),
+                        })
+                            .parse(message.params);
+                        if (event.threadId !== sessionId || !recordRun(event.turnId))
+                            return;
+                        const item = messages.get(event.itemId) ?? { text: "" };
+                        item.text += event.delta;
+                        messages.set(event.itemId, item);
+                        publishText(item.text);
+                    }
+                    else if (message.method === "item/started" || message.method === "item/completed") {
+                        const event = z
+                            .object({
+                            threadId: z.string(),
+                            turnId: z.string(),
+                            item: z.object({
+                                type: z.string(),
+                                id: z.string(),
+                                text: z.string().optional(),
+                                phase: z.string().nullish(),
+                                changes: fileChangesSchema.optional(),
+                            }),
+                        })
+                            .parse(message.params);
+                        if (event.threadId !== sessionId || !recordRun(event.turnId))
+                            return;
+                        if (event.item.type === "fileChange" && event.item.changes)
+                            fileChanges.set(event.item.id, event.item.changes);
+                        if (event.item.type === "agentMessage" && event.item.text !== undefined) {
+                            messages.set(event.item.id, { text: event.item.text, phase: event.item.phase });
+                            publishText(event.item.text);
                         }
-                        else if (message.method === "turn/started" || message.method === "turn/completed") {
-                            const event = z
-                                .object({ threadId: z.string(), turn: turnSchema })
-                                .parse(message.params);
-                            if (event.threadId !== sessionId || !recordRun(event.turn.id))
-                                continue;
-                            if (message.method === "turn/completed") {
-                                const final = [...messages.values()].filter((item) => item.phase === "final_answer");
-                                finish({
-                                    status: event.turn.status === "completed"
-                                        ? "completed"
+                    }
+                    else if (message.method === "turn/started" || message.method === "turn/completed") {
+                        const event = z
+                            .object({ threadId: z.string(), turn: turnSchema })
+                            .parse(message.params);
+                        if (event.threadId !== sessionId || !recordRun(event.turn.id))
+                            return;
+                        if (message.method === "turn/completed") {
+                            const final = [...messages.values()].filter((item) => item.phase === "final_answer");
+                            finish({
+                                status: event.turn.status === "completed"
+                                    ? "completed"
+                                    : event.turn.status === "failed"
+                                        ? "failed"
+                                        : controller.signal.aborted
+                                            ? "cancelled"
+                                            : "interrupted",
+                                text: (final.length ? final : [...messages.values()])
+                                    .map((item) => item.text)
+                                    .join("\n\n") ||
+                                    (event.turn.status === "completed"
+                                        ? "Codex finished with no text output."
                                         : event.turn.status === "failed"
-                                            ? "failed"
-                                            : controller.signal.aborted
-                                                ? "cancelled"
-                                                : "interrupted",
-                                    text: (final.length ? final : [...messages.values()])
-                                        .map((item) => item.text)
-                                        .join("\n\n") ||
-                                        (event.turn.status === "completed"
-                                            ? "Codex finished with no text output."
-                                            : event.turn.status === "failed"
-                                                ? "Codex task failed. Check sign-in, model access, and network."
-                                                : "Task interrupted. File changes were not reverted."),
-                                });
-                            }
+                                            ? "Codex task failed. Check sign-in, model access, and network."
+                                            : "Task interrupted. File changes were not reverted."),
+                            });
                         }
                     }
-                    catch {
-                        fail("Codex response or state save failed. Task interrupted; check CLI version and storage.");
-                    }
+                }
+                catch {
+                    fail("Codex response or state save failed. Task interrupted; check CLI version and storage.");
                 }
             }
-            socket?.on("error", () => fail("Codex connection failed. Task status unknown."));
-            socket?.on("close", onClose);
-            socket?.on("message", (data) => onData(`${data.toString()}\n`));
+            const rpc = createCodexRpc(socket, { onMessage, onFailure: fail, onClose });
             steer = async (prompt) => {
                 if (!sessionId || !runId || settled || controller.signal.aborted)
                     throw new Error("Codex turn is not running. Input not sent; try again later.");
@@ -464,7 +486,7 @@ export async function createCodexAgent(command = "codex") {
                 /** 在写入前移除映射，失败也不重发批准；任务终态负责说明不确定结果。 */
                 interactions.delete(id);
                 clearTimeout(interaction.timer);
-                write({
+                rpc.write({
                     id: interaction.requestId,
                     result: interaction.permissions
                         ? {
@@ -490,16 +512,7 @@ export async function createCodexAgent(command = "codex") {
                 const permissionMode = permissionModes.find((mode) => mode.id === (input.permissionMode ?? "default"));
                 if (!permissionMode)
                     throw new Error("Codex permission mode unavailable. Choose another mode with /permissions.");
-                await request("initialize", {
-                    clientInfo: {
-                        name: "tellrun",
-                        title: "Tellrun",
-                        /** 源码和编译产物都读取包版本，与 CLI 的版本显示保持一致。 */
-                        version: JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version,
-                    },
-                    capabilities: { experimentalApi: true, requestAttestation: false },
-                });
-                write({ method: "initialized" });
+                await request("initialize");
                 if (input.runId) {
                     if (!sessionId)
                         throw new Error("Codex task session missing. Task not resubmitted.");
@@ -531,14 +544,17 @@ export async function createCodexAgent(command = "codex") {
                             recordRun(turn.id);
                             /** 完整快照补回离线输出；缓冲增量已包含在快照中，不再次拼接。 */
                             for (const item of turn.items)
-                                onData(`${JSON.stringify({ method: "item/completed", params: { threadId: sessionId, turnId: turn.id, item } })}\n`);
-                            onData(`${earlyMessages
-                                .split("\n")
-                                .filter((line) => line && JSON.parse(line).method !== "item/agentMessage/delta")
-                                .join("\n")}\n`);
-                            earlyMessages = "";
+                                onMessage({
+                                    method: "item/completed",
+                                    params: { threadId: sessionId, turnId: turn.id, item },
+                                });
+                            for (const message of earlyMessages)
+                                if (message.method !== "item/agentMessage/delta")
+                                    onMessage(message);
+                            earlyMessages.length = 0;
+                            earlyMessageSize = 0;
                             if (turn.status !== "inProgress")
-                                onData(`${JSON.stringify({ method: "turn/completed", params: { threadId: sessionId, turn } })}\n`);
+                                onMessage({ method: "turn/completed", params: { threadId: sessionId, turn } });
                             return await completed.promise;
                         }
                         cursor = page.nextCursor;
@@ -562,14 +578,19 @@ export async function createCodexAgent(command = "codex") {
                     approvalPolicy: z.unknown(),
                     approvalsReviewer: z.string(),
                     sandbox: z.object({ type: z.string() }),
+                    model: z.string().optional(),
                 })
                     .parse(await request(input.sessionId ? "thread/resume" : "thread/start", {
                     ...(input.sessionId ? { threadId: input.sessionId, excludeTurns: true } : {}),
                     cwd: input.cwd,
                     ...permissionMode.config,
+                    ...(input.model ? { model: input.model } : {}),
                 }));
                 if (response.thread.status?.type !== "idle")
                     throw new Error("Codex session busy. Message not sent; wait until it is idle.");
+                /** 模型被服务端替换时停止派发，避免悄悄使用其他模型。 */
+                if (input.model && response.model !== input.model)
+                    throw new Error("Codex did not apply the selected model. Open /model and choose again.");
                 /** 使用服务端实际返回值核实预设，不能在权限被改写时仍启动任务。 */
                 if (response.approvalPolicy !== permissionMode.config.approvalPolicy ||
                     response.approvalsReviewer !== permissionMode.config.approvalsReviewer ||
@@ -587,15 +608,17 @@ export async function createCodexAgent(command = "codex") {
                     request("turn/start", {
                         threadId: sessionId,
                         input: [{ type: "text", text: input.prompt, text_elements: [] }],
+                        ...(input.model ? { model: input.model } : {}),
+                        ...(input.reasoningEffort ? { effort: input.reasoningEffort } : {}),
                     }),
                     completed.promise.then(() => null),
                 ]);
                 if (started !== null && !settled) {
                     recordRun(z.object({ turn: turnSchema }).parse(started).turn.id);
-                    earlyMessages += buffer;
-                    buffer = "";
-                    onData(earlyMessages);
-                    earlyMessages = "";
+                    for (const message of earlyMessages)
+                        onMessage(message);
+                    earlyMessages.length = 0;
+                    earlyMessageSize = 0;
                 }
                 return await completed.promise;
             }
@@ -616,8 +639,7 @@ export async function createCodexAgent(command = "codex") {
                     clearTimeout(interaction.timer);
                 interactions.clear();
                 clearTimeout(stopTimer);
-                client.rejectAllPendingRequests("Codex connection closed.");
-                socket?.terminate();
+                rpc.close();
                 active = undefined;
             }
         },