fix: cleanup on on serverRequest/resolved

Author: NikolaiSviridov

src/CodexEventHandler.ts

@@ -106,11 +106,13 @@ export class CodexEventHandler {
             case "turn/diff/updated":
             case "item/commandExecution/terminalInteraction":
             case "item/fileChange/outputDelta":
-            case "serverRequest/resolved":
             case "account/updated":
             case "fs/changed":
             case "mcpServer/startupStatus/updated":
                 return null;
+            case "serverRequest/resolved":
+                this.pendingMcpApprovals?.clearThread(notification.params.threadId);
+                return null;
             case "item/mcpToolCall/progress":
                 return this.createMcpToolProgressEvent(notification.params);
             case "account/rateLimits/updated":

src/PendingMcpApprovals.ts

@@ -15,13 +15,29 @@ export class PendingMcpApprovals {
     private readonly pending = new Map<string, string>();
 
     record(threadId: string, serverName: string, callId: string): void {
-        this.pending.set(`${threadId}:${serverName}`, callId);
+        this.pending.set(this.key(threadId, serverName), callId);
     }
 
     pop(threadId: string, serverName: string): string | undefined {
-        const key = `${threadId}:${serverName}`;
+        const key = this.key(threadId, serverName);
         const callId = this.pending.get(key);
         this.pending.delete(key);
         return callId;
     }
+
+    clearThread(threadId: string): void {
+        for (const key of this.pending.keys()) {
+            if (this.belongsToThread(key, threadId)) {
+                this.pending.delete(key);
+            }
+        }
+    }
+
+    private key(threadId: string, serverName: string): string {
+        return `${threadId}:${serverName}`;
+    }
+
+    private belongsToThread(key: string, threadId: string): boolean {
+        return key.startsWith(`${threadId}:`);
+    }
 }

src/__tests__/CodexACPAgent/elicitation-events.test.ts

@@ -306,6 +306,58 @@ describe('Elicitation Events', () => {
             completeTurn();
             await promptPromise;
         });
+
+        it('should not reuse a stale call id after serverRequest/resolved clears interrupted approval state', async () => {
+            const { promptPromise, completeTurn } = setupSessionWithPendingPrompt();
+            fixture.setPermissionResponse({ outcome: { outcome: 'selected', optionId: 'allow_once' } });
+
+            const startedNotification: ServerNotification = {
+                method: 'item/started',
+                params: {
+                    threadId: sessionId,
+                    turnId: 'turn-1',
+                    item: {
+                        type: "mcpToolCall",
+                        id: "interrupted-call-id",
+                        server: "tool-server",
+                        tool: "tool-name",
+                        status: "inProgress",
+                        arguments: { argument: "example" },
+                        result: null,
+                        error: null,
+                        durationMs: null,
+                    },
+                },
+            };
+            const resolvedNotification: ServerNotification = {
+                method: 'serverRequest/resolved',
+                params: {
+                    threadId: sessionId,
+                    requestId: 'request-1',
+                },
+            };
+
+            fixture.sendServerNotification(startedNotification);
+            fixture.sendServerNotification(resolvedNotification);
+            fixture.clearAcpConnectionDump();
+
+            const params: McpServerElicitationRequestParams = {
+                threadId: sessionId, turnId: 'turn-2', serverName: 'tool-server',
+                mode: 'form',
+                _meta: { codex_approval_kind: 'mcp_tool_call', persist: ['session', 'always'] },
+                message: 'Allow tool call?',
+                requestedSchema: { type: 'object', properties: {} },
+            };
+
+            await fixture.sendServerRequest('mcpServer/elicitation/request', params);
+
+            const [requestPermissionEvent] = fixture.getAcpConnectionEvents(['_meta']);
+            expect(requestPermissionEvent?.method).toBe('requestPermission');
+            expect(requestPermissionEvent?.args[0].toolCall.toolCallId).toBe('elicitation-tool-server');
+
+            completeTurn();
+            await promptPromise;
+        });
     });
 
     describe('URL mode elicitation', () => {