Add requestId to device code auth elicitation requests

Author: anvilpete

src/CodexAcpClient.ts

@@ -82,6 +82,7 @@ export class CodexAcpClient {
     async authenticate(
         connection: AcpClientConnection,
         authRequest: acp.AuthenticateRequest,
+        requestId: acp.JsonRpcId,
         env: NodeJS.ProcessEnv = process.env,
     ): Promise<Boolean> {
         if (!isCodexAuthRequest(authRequest)) {
@@ -100,7 +101,7 @@ export class CodexAcpClient {
                     return true;
                 }
                 if (env["NO_BROWSER"]) {
-                    return await this.authenticateWithChatGptDeviceCode(connection);
+                    return await this.authenticateWithChatGptDeviceCode(connection, requestId);
                 } else {
                     return await this.authenticateWithChatGptBrowser();
                 }
@@ -151,14 +152,15 @@ export class CodexAcpClient {
         return result.success;
     }
 
-    private async authenticateWithChatGptDeviceCode(connection: AcpClientConnection): Promise<Boolean> {
+    private async authenticateWithChatGptDeviceCode(connection: AcpClientConnection, requestId: acp.JsonRpcId): Promise<Boolean> {
         const loginCompletedPromise = this.awaitNextLoginCompleted();
         const loginResponse = await this.codexClient.accountLogin({type: "chatgptDeviceCode"});
         if (loginResponse.type == "chatgptDeviceCode") {
             const url = loginResponse.verificationUrl;
             const userCode = loginResponse.userCode;
 
             await this.requestDeviceCodeAuth(connection, {
+                requestId,
                 elicitationId: `chatgpt-login-${crypto.randomUUID()}`,
                 url,
                 message: `Follow these steps to sign in with ChatGPT using device code authorization:\n\
@@ -174,15 +176,13 @@ export class CodexAcpClient {
 
     private async requestDeviceCodeAuth(
         client: AcpClientConnection,
-        request: { elicitationId: string; url: string; message: string },
+        request: { requestId: acp.JsonRpcId, elicitationId: string; url: string; message: string },
     ): Promise<void> {
         const response = await client.request(
             acp.methods.client.elicitation.create,
             {
                 mode: "url",
-                // This should be the authenticate requestId, but this is not exposed by the ACP SDK.
-                // The elicitation still works, but won't be tied to the authenticate request.
-                requestId: null,
+                requestId: request.requestId,
                 elicitationId: request.elicitationId,
                 url: request.url,
                 message: request.message,

src/CodexAcpServer.ts

@@ -233,15 +233,15 @@ export class CodexAcpServer {
         }
     }
 
-    async checkAuthorization(){
+    async checkAuthorization(requestId: acp.JsonRpcId){
         const authNeeded = await this.runWithProcessCheck(() => this.codexAcpClient.authRequired());
         logger.log("Auth requirement checked", {authRequired: authNeeded});
         if (authNeeded) {
             if (this.defaultAuthRequest) {
                 logger.log("Authenticating with default auth request...", {
                     authRequest: this.defaultAuthRequest
                 });
-                await this.authenticate(this.defaultAuthRequest)
+                await this.authenticate(this.defaultAuthRequest, requestId);
                 logger.log("Authentication completed");
             } else {
                 logger.log("Authentication required but no default auth request provided, return to IDE");
@@ -250,9 +250,12 @@ export class CodexAcpServer {
         }
     }
 
-    async getOrCreateSession(request: acp.NewSessionRequest | acp.ResumeSessionRequest): Promise<[SessionId, LegacySessionModelState, SessionModeState]> {
+    async getOrCreateSession(
+        request: acp.NewSessionRequest | acp.ResumeSessionRequest,
+        requestId: acp.JsonRpcId,
+    ): Promise<[SessionId, LegacySessionModelState, SessionModeState]> {
         try {
-            return await this.tryCreateSession(request);
+            return await this.tryCreateSession(request, requestId);
         } catch (e) {
             const error = e instanceof Error ? e : new Error(String(e));
             await this.handleError(error);
@@ -331,11 +334,14 @@ export class CodexAcpServer {
         return generation;
     }
 
-    async tryCreateSession(request: acp.NewSessionRequest | acp.ResumeSessionRequest): Promise<[SessionId, LegacySessionModelState, SessionModeState]> {
+    async tryCreateSession(
+        request: acp.NewSessionRequest | acp.ResumeSessionRequest,
+        requestId: acp.JsonRpcId,
+    ): Promise<[SessionId, LegacySessionModelState, SessionModeState]> {
         const requestedSessionGeneration = "sessionId" in request
             ? this.beginSessionOpen(request.sessionId)
             : null;
-        await this.checkAuthorization();
+        await this.checkAuthorization(requestId);
         const requestedMcpServers = request.mcpServers ?? [];
         const mcpServerStartupVersion = requestedMcpServers.length > 0
             ? this.codexAcpClient.getMcpServerStartupVersion()
@@ -453,14 +459,17 @@ export class CodexAcpServer {
         return null;
     }
 
-    async loadSession(params: acp.LoadSessionRequest): Promise<LegacyLoadSessionResponse> {
+    async loadSession(
+        params: acp.LoadSessionRequest,
+        requestId: acp.JsonRpcId,
+    ): Promise<LegacyLoadSessionResponse> {
         logger.log("Loading session...", {sessionId: params.sessionId});
         const {
             sessionId,
             modelState,
             modeState,
             thread,
-        } = await this.getOrCreateSessionWithHistory(params);
+        } = await this.getOrCreateSessionWithHistory(params, requestId);
 
         await this.streamThreadHistory(sessionId, thread);
 
@@ -476,9 +485,12 @@ export class CodexAcpServer {
         };
     }
 
-    async resumeSession(params: acp.ResumeSessionRequest): Promise<LegacyResumeSessionResponse> {
+    async resumeSession(
+        params: acp.ResumeSessionRequest,
+        requestId: acp.JsonRpcId,
+    ): Promise<LegacyResumeSessionResponse> {
         logger.log("Resuming session...", {sessionId: params.sessionId});
-        const [sessionId, modelState, modeState] = await this.getOrCreateSession(params);
+        const [sessionId, modelState, modeState] = await this.getOrCreateSession(params, requestId);
 
         logger.log("Session resumed", {
             sessionId: sessionId,
@@ -492,9 +504,9 @@ export class CodexAcpServer {
         };
     }
 
-    async listSessions(params: acp.ListSessionsRequest): Promise<acp.ListSessionsResponse> {
+    async listSessions(params: acp.ListSessionsRequest, requestId: acp.JsonRpcId): Promise<acp.ListSessionsResponse> {
         logger.log("Listing sessions...", {cwd: params.cwd, cursor: params.cursor});
-        await this.checkAuthorization();
+        await this.checkAuthorization(requestId);
         const response = await this.runWithProcessCheck(() => this.codexAcpClient.listSessions(params));
         return {
             ...response,
@@ -582,9 +594,10 @@ export class CodexAcpServer {
 
     async newSession(
         params: acp.NewSessionRequest,
+        requestId: acp.JsonRpcId,
     ): Promise<LegacyNewSessionResponse> {
         logger.log("Starting new session...");
-        const [sessionId, modelState, modeState] = await this.getOrCreateSession(params);
+        const [sessionId, modelState, modeState] = await this.getOrCreateSession(params, requestId);
 
         logger.log("New session created", {
             sessionId: sessionId,
@@ -602,9 +615,10 @@ export class CodexAcpServer {
 
     async authenticate(
         _params: acp.AuthenticateRequest,
+        requestId: acp.JsonRpcId,
     ): Promise<acp.AuthenticateResponse> {
         logger.log("Authenticate request received");
-        const isAuthenticated = await this.runWithProcessCheck(() => this.codexAcpClient.authenticate(this.connection, _params));
+        const isAuthenticated = await this.runWithProcessCheck(() => this.codexAcpClient.authenticate(this.connection, _params, requestId));
         if (!isAuthenticated) {
             logger.log("Authenticate request failed");
             throw RequestError.invalidParams();
@@ -838,15 +852,16 @@ export class CodexAcpServer {
     }
 
     private async getOrCreateSessionWithHistory(
-        request: acp.LoadSessionRequest
+        request: acp.LoadSessionRequest,
+        requestId: acp.JsonRpcId,
     ): Promise<{
         sessionId: SessionId;
         modelState: LegacySessionModelState;
         modeState: SessionModeState;
         thread: Thread;
     }> {
         const requestedSessionGeneration = this.beginSessionOpen(request.sessionId);
-        await this.checkAuthorization();
+        await this.checkAuthorization(requestId);
         const requestedMcpServers = request.mcpServers ?? [];
         const mcpServerStartupVersion = requestedMcpServers.length > 0
             ? this.codexAcpClient.getMcpServerStartupVersion()