Update codex to 0.115.0

.github/workflows/codex-update.yml

@@ -70,6 +70,8 @@ jobs:
           openai-api-key: ${{ secrets.OPENAI_API_KEY }}
           codex-version: ${{ env.VERSION }}
           output-file: pr-body.md
+          codex-args: >-
+            -c sandbox_workspace_write.writable_roots=["${{ github.workspace }}/.git"]
           prompt: >
             Finalize the update using codex-update-compat skill. 
             Commit the changes, the message should mention that types or/and tests after the update were fixed. 
@@ -100,4 +102,3 @@ jobs:
             --base main \
             --title "Update codex to ${{ env.VERSION }}" \
             --body-file pr-body.md \
-            --label "codex-update"

package.json

@@ -28,7 +28,7 @@
   "license": "ISC",
   "type": "module",
   "devDependencies": {
-    "@openai/codex": "^0.111.0",
+    "@openai/codex": "^0.115.0",
     "@types/node": "^24.10.1",
     "mcp-hello-world": "^1.1.2",
     "tsx": "^4.20.6",

src/CodexAcpClient.ts

@@ -68,20 +68,25 @@ export class CodexAcpClient {
             throw RequestError.invalidRequest();
         }
 
+        let loginId: string | null = null;
         switch (authRequest.methodId) {
             case "api-key":
                 if (!authRequest._meta || !authRequest._meta["api-key"]) throw RequestError.invalidRequest();
                 await this.codexClient.accountLogin({
                     type: "apiKey",
                     apiKey: authRequest._meta["api-key"].apiKey
                 });
-                break;
+                this.gatewayConfig = null;
+                return true;
             case "chat-gpt":
                 const loginResponse = await this.codexClient.accountLogin({type: "chatgpt"});
                 if (loginResponse.type == "chatgpt") {
+                    loginId = loginResponse.loginId;
                     await open(loginResponse.authUrl);
+                    break;
                 }
-                break;
+                this.gatewayConfig = null;
+                return loginResponse.type === "chatgptAuthTokens";
             case "gateway":
                 if (!authRequest._meta) throw RequestError.invalidRequest();
 
@@ -112,7 +117,7 @@ export class CodexAcpClient {
         // Reset the gateway config to null if another authentication method was used
         this.gatewayConfig = null;
 
-        const result = await this.codexClient.awaitLoginCompleted()
+        const result = await this.codexClient.awaitLoginCompleted(loginId)
         return result.success;
     }
 
@@ -259,11 +264,6 @@ export class CodexAcpClient {
         };
     }
 
-    async awaitMcpServers(): Promise<Array<string>>{
-        const response = await this.codexClient.awaitMcpStartup();
-        return response.ready;
-    }
-
     private createSessionConfig(projectPath: string, mcpServers: Array<McpServer>): JsonObject {
         const mergedConfig = {
             ...mergeGatewayConfig(this.config, this.gatewayConfig),
@@ -384,6 +384,11 @@ export class CodexAcpClient {
         return this.codexClient.listMcpServerStatus(params);
     }
 
+    async awaitMcpServers(): Promise<Array<string>> {
+        const response = await this.listMcpServers();
+        return response.data.map((server) => server.name);
+    }
+
     async listSessions(request: acp.ListSessionsRequest): Promise<acp.ListSessionsResponse> {
         const sourceKinds: ThreadSourceKind[] = [
             "cli",

src/CodexAcpServer.ts

@@ -127,7 +127,6 @@ export class CodexAcpServer implements acp.Agent {
 
     async getOrCreateSession(request: acp.NewSessionRequest | acp.ResumeSessionRequest): Promise<[SessionId, SessionModelState, SessionModeState]> {
         await this.checkAuthorization();
-        const pendingMcpServers: Promise<Array<string>> = this.codexAcpClient.awaitMcpServers();
 
         let sessionMetadata: SessionMetadata;
         if ("sessionId" in request) {
@@ -140,8 +139,7 @@ export class CodexAcpServer implements acp.Agent {
 
         const accountResponse = await this.runWithProcessCheck(() => this.codexAcpClient.getAccount());
         const {sessionId, currentModelId, models} = sessionMetadata;
-        logger.log(`Waiting MCP servers to start...`)
-        const sessionMcpServers = await pendingMcpServers;
+        const sessionMcpServers = request.mcpServers?.map((server) => server.name) ?? [];
         const currentModel = this.findCurrentModel(models, currentModelId);
         const sessionState: SessionState = {
             sessionId: sessionId,
@@ -332,7 +330,6 @@ export class CodexAcpServer implements acp.Agent {
         thread: Thread;
     }> {
         await this.checkAuthorization();
-        const pendingMcpServers: Promise<Array<string>> = this.codexAcpClient.awaitMcpServers();
 
         logger.log(`Load existing session: ${request.sessionId}...`);
         const sessionMetadata: SessionMetadataWithThread = await this.runWithProcessCheck(() =>
@@ -341,8 +338,7 @@ export class CodexAcpServer implements acp.Agent {
 
         const accountResponse = await this.runWithProcessCheck(() => this.codexAcpClient.getAccount());
         const {sessionId, currentModelId, models, thread} = sessionMetadata;
-        logger.log("Waiting MCP servers to start...");
-        const sessionMcpServers = await pendingMcpServers;
+        const sessionMcpServers = request.mcpServers?.map((server) => server.name) ?? [];
         const currentModel = this.findCurrentModel(models, currentModelId);
         const sessionState: SessionState = {
             sessionId: sessionId,

src/CodexAppServerClient.ts

@@ -146,9 +146,12 @@ export class CodexAppServerClient {
         return await this.sendRequest({ method: "config/read", params: params });
     }
 
-    async awaitLoginCompleted(): Promise<AccountLoginCompletedNotification> {
+    async awaitLoginCompleted(loginId: string | null = null): Promise<AccountLoginCompletedNotification> {
         return await new Promise((resolve) => {
             this.connection.onNotification("account/login/completed", (event: AccountLoginCompletedNotification) => {
+                if (loginId !== null && event.loginId !== loginId) {
+                    return;
+                }
                 resolve(event);
             });
         });

src/CodexEventHandler.ts

@@ -83,9 +83,16 @@ export class CodexEventHandler {
             case "turn/completed":
                 this.sessionState.currentTurnId = null;
                 return null;
+            case "hook/started":
+            case "hook/completed":
+            case "item/autoApprovalReview/started":
+            case "item/autoApprovalReview/completed":
+                return null;
             case "thread/tokenUsage/updated":
                 this.handleTokenUsageUpdated(notification.params);
                 return null;
+            case "command/exec/outputDelta":
+                return null;
             case "item/commandExecution/outputDelta":
                 return this.createCommandOutputDeltaEvent(notification.params);
             case "item/reasoning/summaryTextDelta": //TODO streaming reasoning?

src/__tests__/CodexACPAgent/CodexAcpClient.test.ts

@@ -108,31 +108,32 @@ describe('ACP server test', { timeout: 40_000 }, () => {
     });
 
     it('should authenticate with a gateway', async () => {
-        const codexAcpAgent = fixture.getCodexAcpAgent();
+        await overrideCodexHome('cli_auth_credentials_store = "file"', async () => {
+            const codexAcpAgent = fixture.getCodexAcpAgent();
 
-        await codexAcpAgent.initialize({protocolVersion: 1});
-        await fixture.getCodexAcpClient().logout();
+            await codexAcpAgent.initialize({protocolVersion: 1});
 
-        const authRequest: CodexAuthRequest = {
-            methodId: "gateway",
-            _meta: {
-                "gateway": {
-                    baseUrl: "https://www.example.com",
-                    headers: {
-                        "Custom-Auth-Header": "TOKEN"
+            const authRequest: CodexAuthRequest = {
+                methodId: "gateway",
+                _meta: {
+                    "gateway": {
+                        baseUrl: "https://www.example.com",
+                        headers: {
+                            "Custom-Auth-Header": "TOKEN"
+                        }
                     }
                 }
-            }
-        };
+            };
 
-        await codexAcpAgent.authenticate(authRequest);
-        expect(await fixture.getCodexAcpClient().authRequired()).toBe(false);
+            await codexAcpAgent.authenticate(authRequest);
+            expect(await fixture.getCodexAcpClient().authRequired()).toBe(false);
 
-        const authenticatedResponse = await fixture.getCodexAcpAgent().extMethod("authentication/status", {});
-        expect(authenticatedResponse).toEqual({type: "gateway", name: "custom-gateway"});
+            const authenticatedResponse = await fixture.getCodexAcpAgent().extMethod("authentication/status", {});
+            expect(authenticatedResponse).toEqual({type: "gateway", name: "custom-gateway"});
 
-        const newSessionResponse = await codexAcpAgent.newSession({cwd: "", mcpServers: []});
-        expect(newSessionResponse.sessionId).toBeDefined()
+            const newSessionResponse = await codexAcpAgent.newSession({cwd: "", mcpServers: []});
+            expect(newSessionResponse.sessionId).toBeDefined()
+        });
     })
 
     it('prefetches session additional skill roots before thread start', async () => {