Handle MCP server elicitation approvals via ACP

Author: i1bro

src/CodexAppServerClient.ts

@@ -34,11 +34,14 @@ import type {
     SkillsListResponse,
     ListMcpServerStatusParams,
     ListMcpServerStatusResponse, ConfigReadParams, ConfigReadResponse,
+    McpServerElicitationRequestParams,
+    McpServerElicitationRequestResponse,
 } from "./app-server/v2";
 
 export interface ApprovalHandler {
     handleCommandExecution(params: CommandExecutionRequestApprovalParams): Promise<CommandExecutionRequestApprovalResponse>;
     handleFileChange(params: FileChangeRequestApprovalParams): Promise<FileChangeRequestApprovalResponse>;
+    handleMcpServerElicitation(params: McpServerElicitationRequestParams): Promise<McpServerElicitationRequestResponse>;
 }
 
 const CommandExecutionApprovalRequest = new RequestType<
@@ -53,6 +56,12 @@ const FileChangeApprovalRequest = new RequestType<
     void
 >('item/fileChange/requestApproval');
 
+const McpServerElicitationRequest = new RequestType<
+    McpServerElicitationRequestParams,
+    McpServerElicitationRequestResponse,
+    void
+>('mcpServer/elicitation/request');
+
 /**
  * A type-safe client over the Codex App Server's JSON-RPC API.
  * Maps each request to its expected response and exposes clear, typed methods for supported JSON-RPC operations.
@@ -98,6 +107,14 @@ export class CodexAppServerClient {
             }
             return await handler.handleFileChange(params);
         });
+
+        this.connection.onRequest(McpServerElicitationRequest, async (params) => {
+            const handler = this.approvalHandlers.get(params.threadId);
+            if (!handler) {
+                return { action: "cancel", content: null, _meta: null };
+            }
+            return await handler.handleMcpServerElicitation(params);
+        });
     }
 
     onApprovalRequest(threadId: string, handler: ApprovalHandler): void {

src/CodexApprovalHandler.ts

@@ -5,8 +5,11 @@ import type {
     CommandExecutionRequestApprovalParams,
     CommandExecutionRequestApprovalResponse,
     FileChangeRequestApprovalParams,
-    FileChangeRequestApprovalResponse
+    FileChangeRequestApprovalResponse,
+    McpServerElicitationRequestParams,
+    McpServerElicitationRequestResponse
 } from "./app-server/v2";
+import type {JsonValue} from "./app-server/serde_json/JsonValue";
 import type {ToolCallContent} from "@agentclientprotocol/sdk/dist/schema/types.gen";
 import {logger} from "./Logger";
 import {stripShellPrefix} from "./CodexEventHandler";
@@ -17,6 +20,14 @@ const APPROVAL_OPTIONS: acp.PermissionOption[] = [
     { optionId: "reject_once", name: "Reject", kind: "reject_once" },
 ];
 
+const ELICITATION_ALLOW_ONCE_OPTION_ID = "allow_once";
+const ELICITATION_ALLOW_SESSION_OPTION_ID = "allow_for_session";
+const ELICITATION_ALLOW_ALWAYS_OPTION_ID = "allow_always";
+const ELICITATION_DENY_ONCE_OPTION_ID = "deny_once";
+
+type ElicitationPersistOption = "session" | "always";
+type JsonObject = { [key: string]: JsonValue };
+
 export class CodexApprovalHandler implements ApprovalHandler {
     private readonly connection: acp.AgentSideConnection;
     private readonly sessionState: SessionState;
@@ -57,11 +68,25 @@ export class CodexApprovalHandler implements ApprovalHandler {
         }
     }
 
+    async handleMcpServerElicitation(
+        params: McpServerElicitationRequestParams
+    ): Promise<McpServerElicitationRequestResponse> {
+        try {
+            const sessionId = this.sessionState.sessionId;
+            const acpRequest = this.buildMcpServerElicitationPermissionRequest(sessionId, params);
+            const response = await this.connection.requestPermission(acpRequest);
+            return this.convertMcpServerElicitationResponse(params, response);
+        } catch (error) {
+            logger.error("Error requesting MCP server elicitation approval", error);
+            return this.createCancelledMcpServerElicitationResponse();
+        }
+    }
+
     private buildCommandPermissionRequest(
         sessionId: string,
         params: CommandExecutionRequestApprovalParams
     ): acp.RequestPermissionRequest {
-        const reasonContent = this.createContentFromReason(params.reason ?? null);
+        const reasonContent = this.createTextContent(params.reason ?? null);
         return {
             sessionId,
             toolCall: {
@@ -75,24 +100,31 @@ export class CodexApprovalHandler implements ApprovalHandler {
         };
     }
 
-    private createContentFromReason(reason: string | null): ToolCallContent | null {
-        if (reason === null || reason === "") {
+    private createTextContent(text: string | null): ToolCallContent | null {
+        if (text === null || text === "") {
             return null;
         }
         return {
             type: "content",
             content: {
                 type: "text",
-                text: reason
+                text
             }
         }
     }
 
+    private createTextContents(...texts: Array<string | null | undefined>): Array<ToolCallContent> | null {
+        const contents = texts
+            .map(text => this.createTextContent(text ?? null))
+            .filter((content): content is ToolCallContent => content !== null)
+        return contents.length > 0 ? contents : null
+    }
+
     private buildFileChangePermissionRequest(
         sessionId: string,
         params: FileChangeRequestApprovalParams
     ): acp.RequestPermissionRequest {
-        const reasonContent = this.createContentFromReason(params.reason ?? null);
+        const reasonContent = this.createTextContent(params.reason ?? null);
         return {
             sessionId,
             toolCall: {
@@ -105,6 +137,117 @@ export class CodexApprovalHandler implements ApprovalHandler {
         };
     }
 
+    private buildMcpServerElicitationPermissionRequest(
+        sessionId: string,
+        params: McpServerElicitationRequestParams
+    ): acp.RequestPermissionRequest {
+        const meta = this.asRecord(params._meta);
+        const persist = meta?.["persist"];
+        const persistOptions = (Array.isArray(persist) ? persist : [persist]).filter(
+            (value): value is ElicitationPersistOption => value === "session" || value === "always"
+        );
+        const toolDescription = typeof meta?.["tool_description"] === "string"
+            ? meta["tool_description"]
+            : null;
+        const rawInput = this.tryToJsonValue(meta?.["tool_params"]) ?? null;
+
+        return {
+            sessionId,
+            toolCall: {
+                toolCallId: this.buildMcpServerElicitationToolCallId(params),
+                title: params.message !== "" ? params.message : "MCP permission request",
+                kind: "other",
+                status: "pending",
+                content: this.createTextContents(toolDescription),
+                rawInput,
+            },
+            options: this.buildMcpServerElicitationOptions(persistOptions),
+        };
+    }
+
+    private buildMcpServerElicitationToolCallId(
+        params: McpServerElicitationRequestParams
+    ): string {
+        return `mcp-elicitation:${params.serverName}:${params.turnId ?? params.threadId}:${params.mode}`;
+    }
+
+    private buildMcpServerElicitationOptions(
+        persistOptions: Array<ElicitationPersistOption>
+    ): Array<acp.PermissionOption> {
+        const options: Array<acp.PermissionOption> = [
+            { optionId: ELICITATION_ALLOW_ONCE_OPTION_ID, name: "Allow Once", kind: "allow_once" },
+        ]
+
+        if (persistOptions.includes("session")) {
+            options.push({
+                optionId: ELICITATION_ALLOW_SESSION_OPTION_ID,
+                name: "Allow for Session",
+                kind: "allow_always",
+            })
+        }
+
+        if (persistOptions.includes("always")) {
+            options.push({
+                optionId: ELICITATION_ALLOW_ALWAYS_OPTION_ID,
+                name: "Always Allow",
+                kind: "allow_always",
+            })
+        }
+
+        options.push({
+            optionId: ELICITATION_DENY_ONCE_OPTION_ID,
+            name: "Deny Once",
+            kind: "reject_once",
+        })
+
+        return options
+    }
+
+    private asRecord(value: unknown): Record<string, unknown> | null {
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            return null
+        }
+        return value as Record<string, unknown>
+    }
+
+    private tryToJsonValue(value: unknown): JsonValue | undefined {
+        if (
+            value === null ||
+            typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean"
+        ) {
+            return value
+        }
+
+        if (Array.isArray(value)) {
+            const convertedValues: Array<JsonValue> = []
+            for (const item of value) {
+                const convertedItem = this.tryToJsonValue(item)
+                if (convertedItem === undefined) {
+                    return undefined
+                }
+                convertedValues.push(convertedItem)
+            }
+            return convertedValues
+        }
+
+        if (typeof value === "object") {
+            const record = value as Record<string, unknown>
+            const jsonObject: JsonObject = {}
+            for (const [key, nestedValue] of Object.entries(record)) {
+                const convertedValue = this.tryToJsonValue(nestedValue)
+                if (convertedValue === undefined) {
+                    return undefined
+                }
+                jsonObject[key] = convertedValue
+            }
+            return jsonObject
+        }
+
+        return undefined
+    }
+
     private convertCommandResponse(
         response: acp.RequestPermissionResponse
     ): CommandExecutionRequestApprovalResponse {
@@ -138,4 +281,42 @@ export class CodexApprovalHandler implements ApprovalHandler {
             return { decision: "cancel" };
         }
     }
+
+    private convertMcpServerElicitationResponse(
+        params: McpServerElicitationRequestParams,
+        response: acp.RequestPermissionResponse
+    ): McpServerElicitationRequestResponse {
+        if (response.outcome.outcome === "cancelled") {
+            return this.createCancelledMcpServerElicitationResponse();
+        }
+
+        switch (response.outcome.optionId) {
+            case ELICITATION_ALLOW_ONCE_OPTION_ID:
+                return this.createAcceptedMcpServerElicitationResponse(params, null);
+            case ELICITATION_ALLOW_SESSION_OPTION_ID:
+                return this.createAcceptedMcpServerElicitationResponse(params, { persist: "session" });
+            case ELICITATION_ALLOW_ALWAYS_OPTION_ID:
+                return this.createAcceptedMcpServerElicitationResponse(params, { persist: "always" });
+            case ELICITATION_DENY_ONCE_OPTION_ID:
+            case "reject_once":
+                return { action: "decline", content: null, _meta: null };
+            default:
+                return this.createCancelledMcpServerElicitationResponse();
+        }
+    }
+
+    private createAcceptedMcpServerElicitationResponse(
+        params: McpServerElicitationRequestParams,
+        meta: JsonObject | null
+    ): McpServerElicitationRequestResponse {
+        return {
+            action: "accept",
+            content: params.mode === "form" ? {} : null,
+            _meta: meta,
+        }
+    }
+
+    private createCancelledMcpServerElicitationResponse(): McpServerElicitationRequestResponse {
+        return { action: "cancel", content: null, _meta: null }
+    }
 }