@ccpocket/bridge 1.25.0 → 1.27.0

package/dist/codex-process.js

@@ -8,6 +8,8 @@ export class CodexProcess extends EventEmitter {
     child = null;
     _status = "starting";
     _threadId = null;
+    _agentNickname = null;
+    _agentRole = null;
     stopped = false;
     startModel;
     inputResolve = null;
@@ -40,9 +42,18 @@ export class CodexProcess extends EventEmitter {
     get isWaitingForInput() {
         return this.inputResolve !== null;
     }
+    getMessageModel() {
+        return sanitizeCodexModel(this.startModel) ?? "";
+    }
     get sessionId() {
         return this._threadId;
     }
+    get agentNickname() {
+        return this._agentNickname;
+    }
+    get agentRole() {
+        return this._agentRole;
+    }
     get isRunning() {
         return this.child !== null;
     }
@@ -89,23 +100,75 @@ export class CodexProcess extends EventEmitter {
     async archiveThread(threadId) {
         await this.request("thread/archive", { threadId });
     }
+    async listThreads(params = {}) {
+        const result = (await this.request("thread/list", {
+            sortKey: "updated_at",
+            archived: false,
+            ...(params.limit != null ? { limit: params.limit } : {}),
+            ...(params.cursor !== undefined ? { cursor: params.cursor } : {}),
+            ...(params.cwd ? { cwd: params.cwd } : {}),
+            ...(params.searchTerm ? { searchTerm: params.searchTerm } : {}),
+        }));
+        const data = Array.isArray(result.data)
+            ? result.data.map((entry) => toCodexThreadSummary(entry))
+            : [];
+        return {
+            data,
+            nextCursor: typeof result.nextCursor === "string" ? result.nextCursor : null,
+        };
+    }
     start(projectPath, options) {
         if (this.child) {
             this.stop();
         }
+        this.prepareLaunch(projectPath, options);
+        this.launchAppServer(projectPath, options);
+        void this.bootstrap(projectPath, options);
+    }
+    async initializeOnly(projectPath) {
+        if (this.child) {
+            this.stop();
+        }
+        this.prepareLaunch(projectPath);
+        this.launchAppServer(projectPath);
+        await this.initializeRpcConnection();
+        this.setStatus("idle");
+    }
+    stop() {
+        this.stopped = true;
+        if (this.inputResolve) {
+            this.inputResolve({ text: "" });
+            this.inputResolve = null;
+        }
+        this.pendingApprovals.clear();
+        this.pendingUserInputs.clear();
+        this.rejectAllPending(new Error("stopped"));
+        if (this.child) {
+            this.child.kill("SIGTERM");
+            this.child = null;
+        }
+        this.setStatus("idle");
+        console.log("[codex-process] Stopped");
+    }
+    prepareLaunch(projectPath, options) {
         this.stopped = false;
         this._threadId = null;
+        this._agentNickname = null;
+        this._agentRole = null;
         this.pendingTurnId = null;
         this.pendingTurnCompletion = null;
         this.pendingApprovals.clear();
         this.pendingUserInputs.clear();
         this.lastTokenUsage = null;
-        this.startModel = options?.model;
+        this.startModel = sanitizeCodexModel(options?.model);
         this._approvalPolicy = options?.approvalPolicy ?? "never";
         this._collaborationMode = options?.collaborationMode ?? "default";
         this.lastPlanItemText = null;
         this.pendingPlanCompletion = null;
         this._pendingPlanInput = null;
+        this._projectPath = projectPath;
+    }
+    launchAppServer(projectPath, options) {
         console.log(`[codex-process] Starting app-server (cwd: ${projectPath}, sandbox: ${options?.sandboxMode ?? "workspace-write"}, approval: ${options?.approvalPolicy ?? "never"}, model: ${options?.model ?? "default"}, collaboration: ${this._collaborationMode})`);
         const child = spawn("codex", ["app-server", "--listen", "stdio://"], {
             cwd: projectPath,
@@ -128,7 +191,10 @@ export class CodexProcess extends EventEmitter {
             if (this.stopped)
                 return;
             console.error("[codex-process] app-server process error:", err);
-            this.emitMessage({ type: "error", message: `Failed to start codex app-server: ${err.message}` });
+            this.emitMessage({
+                type: "error",
+                message: `Failed to start codex app-server: ${err.message}`,
+            });
             this.setStatus("idle");
             this.emit("exit", 1);
         });
@@ -137,28 +203,14 @@ export class CodexProcess extends EventEmitter {
             this.child = null;
             this.rejectAllPending(new Error("codex app-server exited"));
             if (!this.stopped && exitCode !== 0) {
-                this.emitMessage({ type: "error", message: `codex app-server exited with code ${exitCode}` });
+                this.emitMessage({
+                    type: "error",
+                    message: `codex app-server exited with code ${exitCode}`,
+                });
             }
             this.setStatus("idle");
             this.emit("exit", code);
         });
-        void this.bootstrap(projectPath, options);
-    }
-    stop() {
-        this.stopped = true;
-        if (this.inputResolve) {
-            this.inputResolve({ text: "" });
-            this.inputResolve = null;
-        }
-        this.pendingApprovals.clear();
-        this.pendingUserInputs.clear();
-        this.rejectAllPending(new Error("stopped"));
-        if (this.child) {
-            this.child.kill("SIGTERM");
-            this.child = null;
-        }
-        this.setStatus("idle");
-        console.log("[codex-process] Stopped");
     }
     interrupt() {
         if (!this._threadId || !this.pendingTurnId)
@@ -201,7 +253,8 @@ export class CodexProcess extends EventEmitter {
     }
     approve(toolUseId, _updatedInput) {
         // Check if this is a plan completion approval
-        if (this.pendingPlanCompletion && toolUseId === this.pendingPlanCompletion.toolUseId) {
+        if (this.pendingPlanCompletion &&
+            toolUseId === this.pendingPlanCompletion.toolUseId) {
             this.handlePlanApproved(_updatedInput);
             return;
         }
@@ -211,9 +264,7 @@ export class CodexProcess extends EventEmitter {
             return;
         }
         this.pendingApprovals.delete(pending.toolUseId);
-        this.respondToServerRequest(pending.requestId, {
-            decision: "accept",
-        });
+        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "accept"));
         this.emitToolResult(pending.toolUseId, "Approved");
         if (this.pendingApprovals.size === 0) {
             this.setStatus("running");
@@ -226,12 +277,7 @@ export class CodexProcess extends EventEmitter {
             return;
         }
         this.pendingApprovals.delete(pending.toolUseId);
-        this.respondToServerRequest(pending.requestId, {
-            decision: "accept",
-            acceptSettings: {
-                forSession: true,
-            },
-        });
+        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "acceptForSession"));
         this.emitToolResult(pending.toolUseId, "Approved (always)");
         if (this.pendingApprovals.size === 0) {
             this.setStatus("running");
@@ -239,7 +285,8 @@ export class CodexProcess extends EventEmitter {
     }
     reject(toolUseId, _message) {
         // Check if this is a plan completion rejection
-        if (this.pendingPlanCompletion && toolUseId === this.pendingPlanCompletion.toolUseId) {
+        if (this.pendingPlanCompletion &&
+            toolUseId === this.pendingPlanCompletion.toolUseId) {
             this.handlePlanRejected(_message);
             return;
         }
@@ -249,9 +296,7 @@ export class CodexProcess extends EventEmitter {
             return;
         }
         this.pendingApprovals.delete(pending.toolUseId);
-        this.respondToServerRequest(pending.requestId, {
-            decision: "decline",
-        });
+        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "decline"));
         this.emitToolResult(pending.toolUseId, "Rejected");
         if (this.pendingApprovals.size === 0) {
             this.setStatus("running");
@@ -264,9 +309,7 @@ export class CodexProcess extends EventEmitter {
             return;
         }
         this.pendingUserInputs.delete(pending.toolUseId);
-        this.respondToServerRequest(pending.requestId, {
-            answers: buildUserInputAnswers(pending.questions, result),
-        });
+        this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, result));
         this.emitToolResult(pending.toolUseId, "Answered");
         if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
             this.setStatus("running");
@@ -327,7 +370,9 @@ export class CodexProcess extends EventEmitter {
      * Plan approved → switch to Default mode and auto-start execution.
      */
     handlePlanApproved(updatedInput) {
-        const planText = updatedInput?.plan ?? this.pendingPlanCompletion?.planText ?? "";
+        const planText = updatedInput?.plan ??
+            this.pendingPlanCompletion?.planText ??
+            "";
         const resolvedToolUseId = this.pendingPlanCompletion?.toolUseId;
         this.pendingPlanCompletion = null;
         this._collaborationMode = "default";
@@ -378,24 +423,17 @@ export class CodexProcess extends EventEmitter {
     }
     async bootstrap(projectPath, options) {
         try {
-            await this.request("initialize", {
-                clientInfo: {
-                    name: "ccpocket_bridge",
-                    version: "1.0.0",
-                    title: "ccpocket bridge",
-                },
-                capabilities: {
-                    experimentalApi: true,
-                },
-            });
-            this.notify("initialized", {});
+            await this.initializeRpcConnection();
             const threadParams = {
                 cwd: projectPath,
                 approvalPolicy: normalizeApprovalPolicy(options?.approvalPolicy ?? "never"),
                 sandbox: normalizeSandboxMode(options?.sandboxMode ?? "workspace-write"),
+                experimentalRawEvents: false,
+                persistExtendedHistory: true,
             };
-            if (options?.model)
-                threadParams.model = options.model;
+            const requestedModel = sanitizeCodexModel(options?.model);
+            if (requestedModel)
+                threadParams.model = requestedModel;
             if (options?.modelReasoningEffort) {
                 threadParams.effort = normalizeReasoningEffort(options.modelReasoningEffort);
             }
@@ -412,11 +450,15 @@ export class CodexProcess extends EventEmitter {
             if (options?.threadId) {
                 threadParams.threadId = options.threadId;
             }
-            const response = await this.request(method, threadParams);
+            else {
+                threadParams.experimentalRawEvents = false;
+            }
+            if (options?.threadId) {
+                threadParams.persistExtendedHistory = true;
+            }
+            const response = (await this.request(method, threadParams));
             const thread = response.thread;
-            const threadId = typeof thread?.id === "string"
-                ? thread.id
-                : options?.threadId;
+            const threadId = typeof thread?.id === "string" ? thread.id : options?.threadId;
             if (!threadId) {
                 throw new Error(`${method} returned no thread id`);
             }
@@ -424,12 +466,34 @@ export class CodexProcess extends EventEmitter {
             if (typeof thread?.model === "string" && thread.model) {
                 this.startModel = thread.model;
             }
+            const resolvedSettings = extractResolvedSettingsFromThreadResponse(response);
+            if (resolvedSettings.model) {
+                this.startModel = resolvedSettings.model;
+            }
             this._threadId = threadId;
             this.emitMessage({
                 type: "system",
                 subtype: "init",
                 sessionId: threadId,
-                model: this.startModel ?? "codex",
+                provider: "codex",
+                ...(sanitizeCodexModel(this.startModel)
+                    ? { model: sanitizeCodexModel(this.startModel) }
+                    : {}),
+                ...(resolvedSettings.approvalPolicy
+                    ? { approvalPolicy: resolvedSettings.approvalPolicy }
+                    : {}),
+                ...(resolvedSettings.sandboxMode
+                    ? { sandboxMode: resolvedSettings.sandboxMode }
+                    : {}),
+                ...(resolvedSettings.modelReasoningEffort
+                    ? { modelReasoningEffort: resolvedSettings.modelReasoningEffort }
+                    : {}),
+                ...(resolvedSettings.networkAccessEnabled !== undefined
+                    ? { networkAccessEnabled: resolvedSettings.networkAccessEnabled }
+                    : {}),
+                ...(resolvedSettings.webSearchMode
+                    ? { webSearchMode: resolvedSettings.webSearchMode }
+                    : {}),
             });
             this.setStatus("idle");
             // Fetch skills in background (non-blocking)
@@ -442,12 +506,30 @@ export class CodexProcess extends EventEmitter {
                 const message = err instanceof Error ? err.message : String(err);
                 console.error("[codex-process] bootstrap error:", err);
                 this.emitMessage({ type: "error", message: `Codex error: ${message}` });
-                this.emitMessage({ type: "result", subtype: "error", error: message, sessionId: this._threadId ?? undefined });
+                this.emitMessage({
+                    type: "result",
+                    subtype: "error",
+                    error: message,
+                    sessionId: this._threadId ?? undefined,
+                });
             }
             this.setStatus("idle");
             this.emit("exit", 1);
         }
     }
+    async initializeRpcConnection() {
+        await this.request("initialize", {
+            clientInfo: {
+                name: "ccpocket_bridge",
+                version: "1.0.0",
+                title: "ccpocket bridge",
+            },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+        this.notify("initialized", {});
+    }
     /**
      * Fetch skills from Codex app-server via `skills/list` RPC and emit them
      * as a `supported_commands` system message so the Flutter client can display
@@ -456,10 +538,10 @@ export class CodexProcess extends EventEmitter {
     async fetchSkills(projectPath) {
         const TIMEOUT_MS = 10_000;
         try {
-            const result = await Promise.race([
+            const result = (await Promise.race([
                 this.request("skills/list", { cwds: [projectPath] }),
                 new Promise((resolve) => setTimeout(() => resolve(null), TIMEOUT_MS)),
-            ]);
+            ]));
             if (this.stopped || !result?.data)
                 return;
             const skills = [];
@@ -474,7 +556,9 @@ export class CodexProcess extends EventEmitter {
                             name: skill.name,
                             path: skill.path,
                             description: skill.description,
-                            shortDescription: skill.shortDescription ?? skill.interface?.shortDescription ?? undefined,
+                            shortDescription: skill.shortDescription ??
+                                skill.interface?.shortDescription ??
+                                undefined,
                             enabled: skill.enabled,
                             scope: skill.scope,
                             displayName: skill.interface?.displayName ?? undefined,
@@ -515,7 +599,10 @@ export class CodexProcess extends EventEmitter {
             if (this.stopped || !pendingInput.text)
                 break;
             if (!this._threadId) {
-                this.emitMessage({ type: "error", message: "Codex thread is not initialized" });
+                this.emitMessage({
+                    type: "error",
+                    message: "Codex thread is not initialized",
+                });
                 continue;
             }
             const { input, tempPaths } = await this.toRpcInput(pendingInput);
@@ -531,15 +618,18 @@ export class CodexProcess extends EventEmitter {
                     input,
                     approvalPolicy: normalizeApprovalPolicy(this._approvalPolicy),
                 };
-                if (options?.model)
-                    params.model = options.model;
+                const requestedModel = sanitizeCodexModel(options?.model);
+                if (requestedModel)
+                    params.model = requestedModel;
                 if (options?.modelReasoningEffort) {
                     params.effort = normalizeReasoningEffort(options.modelReasoningEffort);
                 }
                 // Always send collaborationMode so the server switches modes correctly.
                 // Omitting it causes the server to persist the previous turn's mode.
                 const modeSettings = {
-                    model: options?.model || this.startModel || "gpt-5.4",
+                    model: requestedModel
+                        || sanitizeCodexModel(this.startModel)
+                        || "gpt-5.4",
                 };
                 if (this._collaborationMode === "plan") {
                     modeSettings.reasoning_effort = "medium";
@@ -603,11 +693,15 @@ export class CodexProcess extends EventEmitter {
         }
     }
     handleRpcEnvelope(envelope) {
-        if (envelope.id != null && envelope.method && envelope.result === undefined && envelope.error === undefined) {
+        if (envelope.id != null &&
+            envelope.method &&
+            envelope.result === undefined &&
+            envelope.error === undefined) {
             this.handleServerRequest(envelope.id, envelope.method, envelope.params ?? {});
             return;
         }
-        if (envelope.id != null && (envelope.result !== undefined || envelope.error)) {
+        if (envelope.id != null &&
+            (envelope.result !== undefined || envelope.error)) {
             this.handleRpcResponse(envelope);
             return;
         }
@@ -635,17 +729,45 @@ export class CodexProcess extends EventEmitter {
             case "item/commandExecution/requestApproval": {
                 const toolUseId = this.extractToolUseId(params, id);
                 const input = {
-                    ...(typeof params.command === "string" ? { command: params.command } : {}),
+                    ...(typeof params.command === "string"
+                        ? { command: params.command }
+                        : {}),
                     ...(typeof params.cwd === "string" ? { cwd: params.cwd } : {}),
-                    ...(params.commandActions ? { commandActions: params.commandActions } : {}),
-                    ...(params.networkApprovalContext ? { networkApprovalContext: params.networkApprovalContext } : {}),
-                    ...(typeof params.reason === "string" ? { reason: params.reason } : {}),
+                    ...(params.commandActions
+                        ? { commandActions: params.commandActions }
+                        : {}),
+                    ...(params.networkApprovalContext
+                        ? { networkApprovalContext: params.networkApprovalContext }
+                        : {}),
+                    ...(params.additionalPermissions
+                        ? { additionalPermissions: params.additionalPermissions }
+                        : {}),
+                    ...(params.skillMetadata
+                        ? { skillMetadata: params.skillMetadata }
+                        : {}),
+                    ...(params.proposedExecpolicyAmendment
+                        ? {
+                            proposedExecpolicyAmendment: params.proposedExecpolicyAmendment,
+                        }
+                        : {}),
+                    ...(params.proposedNetworkPolicyAmendments
+                        ? {
+                            proposedNetworkPolicyAmendments: params.proposedNetworkPolicyAmendments,
+                        }
+                        : {}),
+                    ...(params.availableDecisions
+                        ? { availableDecisions: params.availableDecisions }
+                        : {}),
+                    ...(typeof params.reason === "string"
+                        ? { reason: params.reason }
+                        : {}),
                 };
                 this.pendingApprovals.set(toolUseId, {
                     requestId: id,
                     toolUseId,
                     toolName: "Bash",
                     input,
+                    kind: "command",
                 });
                 this.emitMessage({
                     type: "permission_request",
@@ -660,13 +782,19 @@ export class CodexProcess extends EventEmitter {
                 const toolUseId = this.extractToolUseId(params, id);
                 const input = {
                     ...(Array.isArray(params.changes) ? { changes: params.changes } : {}),
-                    ...(typeof params.reason === "string" ? { reason: params.reason } : {}),
+                    ...(typeof params.grantRoot === "string"
+                        ? { grantRoot: params.grantRoot }
+                        : {}),
+                    ...(typeof params.reason === "string"
+                        ? { reason: params.reason }
+                        : {}),
                 };
                 this.pendingApprovals.set(toolUseId, {
                     requestId: id,
                     toolUseId,
                     toolName: "FileChange",
                     input,
+                    kind: "file",
                 });
                 this.emitMessage({
                     type: "permission_request",
@@ -694,11 +822,13 @@ export class CodexProcess extends EventEmitter {
                 this.pendingUserInputs.set(toolUseId, {
                     requestId: id,
                     toolUseId,
+                    toolName: "AskUserQuestion",
                     questions: questions.map((q) => ({
                         id: q.id,
                         question: q.question,
                     })),
                     input,
+                    kind: "questions",
                 });
                 this.emitMessage({
                     type: "permission_request",
@@ -709,6 +839,52 @@ export class CodexProcess extends EventEmitter {
                 this.setStatus("waiting_approval");
                 break;
             }
+            case "item/permissions/requestApproval": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const requestedPermissions = asRecord(params.permissions) ?? {};
+                const input = {
+                    permissions: requestedPermissions,
+                    ...(typeof params.reason === "string"
+                        ? { reason: params.reason }
+                        : {}),
+                };
+                this.pendingApprovals.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "Permissions",
+                    input,
+                    kind: "permissions",
+                    requestedPermissions,
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "Permissions",
+                    input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
+            case "mcpServer/elicitation/request": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const elicitation = createElicitationInput(params);
+                this.pendingUserInputs.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "McpElicitation",
+                    questions: elicitation.questions,
+                    input: elicitation.input,
+                    kind: elicitation.kind,
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "McpElicitation",
+                    input: elicitation.input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
             default:
                 this.respondToServerRequest(id, {});
                 break;
@@ -721,6 +897,8 @@ export class CodexProcess extends EventEmitter {
                 if (typeof thread?.id === "string") {
                     this._threadId = thread.id;
                 }
+                this._agentNickname = stringOrNull(thread?.agentNickname);
+                this._agentRole = stringOrNull(thread?.agentRole);
                 break;
             }
             case "turn/started": {
@@ -806,11 +984,15 @@ export class CodexProcess extends EventEmitter {
                         id: randomUUID(),
                         role: "assistant",
                         content: [{ type: "text", text }],
-                        model: "codex",
+                        model: this.getMessageModel(),
                     },
                 });
                 break;
             }
+            case "serverRequest/resolved": {
+                this.handleServerRequestResolved(params);
+                break;
+            }
             default:
                 break;
         }
@@ -844,7 +1026,9 @@ export class CodexProcess extends EventEmitter {
                 subtype: "success",
                 sessionId: this._threadId ?? undefined,
                 ...(usage?.input != null ? { inputTokens: usage.input } : {}),
-                ...(usage?.cachedInput != null ? { cachedInputTokens: usage.cachedInput } : {}),
+                ...(usage?.cachedInput != null
+                    ? { cachedInputTokens: usage.cachedInput }
+                    : {}),
                 ...(usage?.output != null ? { outputTokens: usage.output } : {}),
             });
         }
@@ -868,7 +1052,8 @@ export class CodexProcess extends EventEmitter {
         }
         else {
             this.lastPlanItemText = null;
-            if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
+            if (this.pendingApprovals.size === 0 &&
+                this.pendingUserInputs.size === 0) {
                 this.setStatus("idle");
             }
         }
@@ -902,7 +1087,7 @@ export class CodexProcess extends EventEmitter {
                                 input: { command: commandText },
                             },
                         ],
-                        model: "codex",
+                        model: this.getMessageModel(),
                     },
                 });
                 break;
@@ -923,7 +1108,63 @@ export class CodexProcess extends EventEmitter {
                                 },
                             },
                         ],
-                        model: "codex",
+                        model: this.getMessageModel(),
+                    },
+                });
+                break;
+            }
+            case "dynamictoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "DynamicTool";
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: tool,
+                                input: toToolUseInput(item.arguments),
+                            },
+                        ],
+                        model: this.getMessageModel(),
+                    },
+                });
+                break;
+            }
+            case "collabagenttoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "subagent";
+                const toolName = "SubAgent";
+                const input = {
+                    tool,
+                    ...(typeof item.prompt === "string" ? { prompt: item.prompt } : {}),
+                    ...(typeof item.senderThreadId === "string"
+                        ? { senderThreadId: item.senderThreadId }
+                        : {}),
+                    ...(Array.isArray(item.receiverThreadIds)
+                        ? { receiverThreadIds: item.receiverThreadIds }
+                        : {}),
+                    ...(typeof item.model === "string" ? { model: item.model } : {}),
+                    ...(typeof item.reasoningEffort === "string"
+                        ? { reasoningEffort: item.reasoningEffort }
+                        : {}),
+                    ...(item.agentsStates ? { agentsStates: item.agentsStates } : {}),
+                };
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: toolName,
+                                input,
+                            },
+                        ],
+                        model: this.getMessageModel(),
                     },
                 });
                 break;
@@ -948,7 +1189,7 @@ export class CodexProcess extends EventEmitter {
                         id: itemId,
                         role: "assistant",
                         content: [{ type: "text", text }],
-                        model: "codex",
+                        model: this.getMessageModel(),
                     },
                 });
                 break;
@@ -990,6 +1231,7 @@ export class CodexProcess extends EventEmitter {
                 const tool = typeof item.tool === "string" ? item.tool : "unknown";
                 const toolName = `mcp:${server}/${tool}`;
                 const result = item.result ?? item.error ?? "MCP call completed";
+                const normalized = normalizeMcpToolResult(result);
                 this.emitMessage({
                     type: "assistant",
                     message: {
@@ -1003,14 +1245,28 @@ export class CodexProcess extends EventEmitter {
                                 input: item.arguments ?? {},
                             },
                         ],
-                        model: "codex",
+                        model: this.getMessageModel(),
                     },
                 });
                 this.emitMessage({
                     type: "tool_result",
                     toolUseId: itemId,
-                    content: typeof result === "string" ? result : JSON.stringify(result),
+                    content: normalized.content,
                     toolName,
+                    ...(normalized.rawContentBlocks.length > 0
+                        ? { rawContentBlocks: normalized.rawContentBlocks }
+                        : {}),
+                });
+                break;
+            }
+            case "dynamictoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "DynamicTool";
+                const content = formatDynamicToolResult(item);
+                this.emitMessage({
+                    type: "tool_result",
+                    toolUseId: itemId,
+                    content,
+                    toolName: tool,
                 });
                 break;
             }
@@ -1029,7 +1285,7 @@ export class CodexProcess extends EventEmitter {
                                 input: { query },
                             },
                         ],
-                        model: "codex",
+                        model: this.getMessageModel(),
                     },
                 });
                 this.emitMessage({
@@ -1040,6 +1296,27 @@ export class CodexProcess extends EventEmitter {
                 });
                 break;
             }
+            case "collabagenttoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "subagent";
+                const status = typeof item.status === "string" ? item.status : "completed";
+                const receiverThreadIds = Array.isArray(item.receiverThreadIds)
+                    ? item.receiverThreadIds.map((entry) => String(entry))
+                    : [];
+                const content = [
+                    `tool: ${tool}`,
+                    `status: ${status}`,
+                    ...(receiverThreadIds.length > 0
+                        ? [`agents: ${receiverThreadIds.join(", ")}`]
+                        : []),
+                ].join("\n");
+                this.emitMessage({
+                    type: "tool_result",
+                    toolUseId: itemId,
+                    content,
+                    toolName: "SubAgent",
+                });
+                break;
+            }
             case "plan": {
                 // Plan item completed — save text for plan approval emission in handleTurnCompleted()
                 const planText = typeof item.text === "string" ? item.text : "";
@@ -1060,7 +1337,11 @@ export class CodexProcess extends EventEmitter {
         const tempPaths = [];
         // Prepend SkillUserInput if a skill reference is attached
         if (pendingInput.skill) {
-            input.push({ type: "skill", name: pendingInput.skill.name, path: pendingInput.skill.path });
+            input.push({
+                type: "skill",
+                name: pendingInput.skill.name,
+                path: pendingInput.skill.path,
+            });
         }
         input.push({ type: "text", text: pendingInput.text });
         if (!pendingInput.images || pendingInput.images.length === 0) {
@@ -1150,12 +1431,59 @@ export class CodexProcess extends EventEmitter {
     extractToolUseId(params, requestId) {
         if (typeof params.approvalId === "string")
             return params.approvalId;
+        if (typeof params.elicitationId === "string")
+            return params.elicitationId;
         if (typeof params.itemId === "string")
             return params.itemId;
         if (typeof requestId === "string")
             return requestId;
         return `approval-${requestId}`;
     }
+    handleServerRequestResolved(params) {
+        const requestId = params.requestId;
+        if (requestId === undefined || requestId === null)
+            return;
+        const approval = [...this.pendingApprovals.values()].find((entry) => entry.requestId === requestId);
+        if (approval) {
+            this.pendingApprovals.delete(approval.toolUseId);
+            this.emitMessage({
+                type: "permission_resolved",
+                toolUseId: approval.toolUseId,
+            });
+        }
+        const inputRequest = [...this.pendingUserInputs.values()].find((entry) => entry.requestId === requestId);
+        if (inputRequest) {
+            this.pendingUserInputs.delete(inputRequest.toolUseId);
+            this.emitMessage({
+                type: "permission_resolved",
+                toolUseId: inputRequest.toolUseId,
+            });
+        }
+        if (!this.pendingPlanCompletion &&
+            this.pendingApprovals.size === 0 &&
+            this.pendingUserInputs.size === 0) {
+            this.setStatus(this.pendingTurnId ? "running" : "idle");
+        }
+    }
+}
+function buildApprovalResponse(pending, decision) {
+    if (pending.kind === "permissions") {
+        return {
+            scope: decision === "acceptForSession" ? "session" : "turn",
+            permissions: decision === "decline" ? {} : (pending.requestedPermissions ?? {}),
+        };
+    }
+    return {
+        decision,
+    };
+}
+function buildUserInputResponse(pending, rawResult) {
+    if (pending.kind === "questions") {
+        return {
+            answers: buildUserInputAnswers(pending.questions, rawResult),
+        };
+    }
+    return buildElicitationResponse(pending, rawResult);
 }
 function normalizeApprovalPolicy(value) {
     switch (value) {
@@ -1189,13 +1517,59 @@ function normalizeReasoningEffort(value) {
             return value;
     }
 }
+function sanitizeCodexModel(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim();
+    if (!normalized || normalized === "codex")
+        return undefined;
+    return normalized;
+}
+function extractResolvedSettingsFromThreadResponse(response) {
+    const thread = response.thread;
+    const sandbox = response.sandbox;
+    return {
+        model: sanitizeCodexModel(response.model)
+            ?? sanitizeCodexModel(thread?.model),
+        approvalPolicy: typeof response.approvalPolicy === "string"
+            ? response.approvalPolicy
+            : undefined,
+        sandboxMode: normalizeSandboxModeFromRpc(sandbox?.type),
+        modelReasoningEffort: typeof response.reasoningEffort === "string"
+            ? response.reasoningEffort
+            : undefined,
+        networkAccessEnabled: typeof sandbox?.networkAccess === "boolean"
+            ? sandbox.networkAccess
+            : undefined,
+        webSearchMode: typeof response.webSearchMode === "string"
+            ? response.webSearchMode
+            : undefined,
+    };
+}
+function normalizeSandboxModeFromRpc(value) {
+    switch (value) {
+        case "dangerFullAccess":
+            return "danger-full-access";
+        case "workspaceWrite":
+            return "workspace-write";
+        case "readOnly":
+            return "read-only";
+        default:
+            return typeof value === "string" && value.length > 0 ? value : undefined;
+    }
+}
 function normalizeItemType(raw) {
     if (typeof raw !== "string")
         return "";
     return raw.replace(/[_\s-]/g, "").toLowerCase();
 }
 function numberOrUndefined(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function stringOrNull(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
 function summarizeFileChanges(changes) {
     if (!Array.isArray(changes) || changes.length === 0) {
@@ -1212,6 +1586,131 @@ function summarizeFileChanges(changes) {
     })
         .join("\n");
 }
+function toToolUseInput(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return { items: value };
+    }
+    if (value === undefined || value === null) {
+        return {};
+    }
+    return { value };
+}
+function formatDynamicToolResult(item) {
+    const status = typeof item.status === "string" ? item.status : "completed";
+    const success = typeof item.success === "boolean" ? item.success : null;
+    const contentItems = Array.isArray(item.contentItems)
+        ? item.contentItems
+        : null;
+    const parts = [
+        `status: ${status}`,
+        ...(success != null ? [`success: ${success}`] : []),
+    ];
+    if (contentItems && contentItems.length > 0) {
+        for (const entry of contentItems) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const record = entry;
+            const type = typeof record.type === "string" ? record.type : "item";
+            if (type === "inputText" && typeof record.text === "string") {
+                parts.push(record.text);
+                continue;
+            }
+            if (type === "inputImage" && typeof record.imageUrl === "string") {
+                parts.push(`image: ${record.imageUrl}`);
+                continue;
+            }
+            parts.push(JSON.stringify(record));
+        }
+    }
+    return parts.join("\n");
+}
+function normalizeMcpToolResult(result) {
+    if (typeof result === "string") {
+        return { content: result, rawContentBlocks: [] };
+    }
+    const record = result && typeof result === "object" && !Array.isArray(result)
+        ? result
+        : null;
+    const contentItems = Array.isArray(record?.content) ? record.content : null;
+    if (!contentItems) {
+        return {
+            content: result == null ? "MCP call completed" : JSON.stringify(result),
+            rawContentBlocks: [],
+        };
+    }
+    const textParts = [];
+    const rawContentBlocks = [];
+    for (const entry of contentItems) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const item = entry;
+        const type = typeof item.type === "string" ? item.type : "";
+        if (type === "text" && typeof item.text === "string") {
+            textParts.push(item.text);
+            rawContentBlocks.push({ type: "text", text: item.text });
+            continue;
+        }
+        if (type === "image" && typeof item.data === "string") {
+            const mimeType = typeof item.mimeType === "string"
+                ? item.mimeType
+                : typeof item.mediaType === "string"
+                    ? item.mediaType
+                    : typeof item.media_type === "string"
+                        ? item.media_type
+                        : "image/png";
+            rawContentBlocks.push({
+                type: "image",
+                source: {
+                    type: "base64",
+                    data: item.data,
+                    media_type: mimeType,
+                },
+            });
+            continue;
+        }
+        rawContentBlocks.push(item);
+        textParts.push(JSON.stringify(item));
+    }
+    const content = textParts.join("\n").trim();
+    if (content.length > 0) {
+        return { content, rawContentBlocks };
+    }
+    const imageCount = rawContentBlocks.filter((entry) => entry.type === "image").length;
+    if (imageCount > 0) {
+        return {
+            content: imageCount === 1
+                ? "Generated 1 image"
+                : `Generated ${imageCount} images`,
+            rawContentBlocks,
+        };
+    }
+    return {
+        content: result == null ? "MCP call completed" : JSON.stringify(result),
+        rawContentBlocks,
+    };
+}
+function toCodexThreadSummary(entry) {
+    const record = entry && typeof entry === "object"
+        ? entry
+        : {};
+    const gitInfo = record.gitInfo && typeof record.gitInfo === "object"
+        ? record.gitInfo
+        : {};
+    return {
+        id: typeof record.id === "string" ? record.id : "",
+        preview: typeof record.preview === "string" ? record.preview : "",
+        createdAt: numberOrUndefined(record.createdAt) ?? 0,
+        updatedAt: numberOrUndefined(record.updatedAt) ?? 0,
+        cwd: typeof record.cwd === "string" ? record.cwd : "",
+        agentNickname: stringOrNull(record.agentNickname),
+        agentRole: stringOrNull(record.agentRole),
+        gitBranch: stringOrNull(gitInfo.branch),
+        name: stringOrNull(record.name),
+    };
+}
 /**
  * Format file changes including unified diff content for display in chat.
  * Falls back to `kind: path` summary when no diff is available.
@@ -1287,7 +1786,9 @@ function normalizeUserInputQuestions(raw) {
         .map((entry, index) => {
         const id = typeof entry.id === "string" ? entry.id : `question_${index + 1}`;
         const question = typeof entry.question === "string" ? entry.question : "";
-        const header = typeof entry.header === "string" ? entry.header : `Question ${index + 1}`;
+        const header = typeof entry.header === "string"
+            ? entry.header
+            : `Question ${index + 1}`;
         const optionsRaw = Array.isArray(entry.options) ? entry.options : [];
         const options = optionsRaw
             .filter((option) => !!option && typeof option === "object")
@@ -1367,6 +1868,172 @@ function normalizeAnswerValues(value) {
     const normalized = String(value).trim();
     return normalized ? [normalized] : [];
 }
+function buildElicitationResponse(pending, rawResult) {
+    if (pending.kind === "elicitation_url") {
+        const action = parseElicitationAction(rawResult);
+        return {
+            action,
+            content: null,
+            _meta: null,
+        };
+    }
+    const parsed = parseResultObject(rawResult);
+    const content = {};
+    for (const question of pending.questions) {
+        const candidate = parsed.byId[question.id] ?? parsed.byQuestion[question.question];
+        const answers = normalizeAnswerValues(candidate);
+        if (answers.length === 1) {
+            content[question.id] = answers[0];
+        }
+        else if (answers.length > 1) {
+            content[question.id] = answers;
+        }
+    }
+    if (Object.keys(content).length === 0 && pending.questions.length === 1) {
+        const answers = normalizeAnswerValues(rawResult);
+        if (answers.length === 1) {
+            content[pending.questions[0].id] = answers[0];
+        }
+        else if (answers.length > 1) {
+            content[pending.questions[0].id] = answers;
+        }
+    }
+    return {
+        action: "accept",
+        content: Object.keys(content).length > 0 ? content : null,
+        _meta: null,
+    };
+}
+function parseElicitationAction(rawResult) {
+    const normalized = rawResult.trim().toLowerCase();
+    if (normalized.includes("cancel"))
+        return "cancel";
+    if (normalized.includes("decline") || normalized.includes("deny"))
+        return "decline";
+    try {
+        const parsed = JSON.parse(rawResult);
+        const answers = parsed.answers;
+        if (answers && typeof answers === "object" && !Array.isArray(answers)) {
+            const first = Object.values(answers)[0];
+            const answer = normalizeAnswerValues(first).join(" ").toLowerCase();
+            if (answer.includes("cancel"))
+                return "cancel";
+            if (answer.includes("decline") || answer.includes("deny"))
+                return "decline";
+        }
+    }
+    catch {
+        // Fall through to accept.
+    }
+    return "accept";
+}
+function createElicitationInput(params) {
+    const serverName = typeof params.serverName === "string" ? params.serverName : "MCP";
+    const message = typeof params.message === "string" ? params.message : "Provide input";
+    if (params.mode === "url") {
+        const url = typeof params.url === "string" ? params.url : "";
+        const question = url ? `${message}\n${url}` : message;
+        return {
+            kind: "elicitation_url",
+            questions: [{ id: "elicitation_action", question }],
+            input: {
+                mode: "url",
+                serverName,
+                url,
+                message,
+                questions: [
+                    {
+                        id: "elicitation_action",
+                        header: serverName,
+                        question,
+                        options: [
+                            { label: "Accept", description: "Continue with this request" },
+                            { label: "Decline", description: "Reject this request" },
+                            { label: "Cancel", description: "Cancel without accepting" },
+                        ],
+                        multiSelect: false,
+                        isOther: false,
+                        isSecret: false,
+                    },
+                ],
+            },
+        };
+    }
+    const schema = asRecord(params.requestedSchema);
+    const properties = asRecord(schema?.properties) ?? {};
+    const requiredFields = new Set(Array.isArray(schema?.required)
+        ? schema.required.map((entry) => String(entry))
+        : []);
+    const questions = Object.entries(properties)
+        .filter(([, value]) => value && typeof value === "object")
+        .map(([key, value]) => {
+        const field = value;
+        const title = typeof field.title === "string" ? field.title : key;
+        const description = typeof field.description === "string" ? field.description : message;
+        const enumValues = Array.isArray(field.enum)
+            ? field.enum.map((entry) => String(entry))
+            : [];
+        const type = typeof field.type === "string" ? field.type : "";
+        const options = enumValues.length > 0
+            ? enumValues.map((entry, index) => ({
+                label: entry,
+                description: index === 0 ? description : "",
+            }))
+            : type === "boolean"
+                ? [
+                    { label: "true", description: description },
+                    { label: "false", description: "" },
+                ]
+                : [];
+        return {
+            id: key,
+            question: requiredFields.has(key) ? `${title} (required)` : title,
+            header: serverName,
+            options,
+            isOther: options.length === 0,
+            isSecret: false,
+        };
+    });
+    const normalizedQuestions = questions.length > 0
+        ? questions
+        : [
+            {
+                id: "value",
+                question: message,
+                header: serverName,
+                options: [],
+                isOther: true,
+                isSecret: false,
+            },
+        ];
+    return {
+        kind: "elicitation_form",
+        questions: normalizedQuestions.map((question) => ({
+            id: question.id,
+            question: question.question,
+        })),
+        input: {
+            mode: "form",
+            serverName,
+            message,
+            requestedSchema: schema,
+            questions: normalizedQuestions.map((question) => ({
+                id: question.id,
+                header: question.header,
+                question: question.question,
+                options: question.options,
+                multiSelect: false,
+                isOther: question.isOther,
+                isSecret: question.isSecret,
+            })),
+        },
+    };
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
 function formatPlanUpdateText(params) {
     const stepsRaw = params.plan;
     if (!Array.isArray(stepsRaw) || stepsRaw.length === 0)