LLM-26016 [Codex] Show mcp initialization errors in chat

Author: NikolaiSviridov

package-lock.json

@@ -259,9 +259,8 @@ export class CodexAcpClient {
         };
     }
 
-    async awaitMcpServers(): Promise<Array<string>>{
-        const response = await this.codexClient.awaitMcpStartup();
-        return response.ready;
+    async awaitMcpServers() {
+        return await this.codexClient.awaitMcpStartup();
     }
 
     private createSessionConfig(projectPath: string, mcpServers: Array<McpServer>): JsonObject {

src/CodexAcpClient.ts

@@ -10,9 +10,10 @@ import {CodexApprovalHandler} from "./CodexApprovalHandler";
 import {CodexAuthMethods, type CodexAuthRequest} from "./CodexAuthMethod";
 import {CodexAcpClient, type SessionMetadata, type SessionMetadataWithThread} from "./CodexAcpClient";
 import {ACPSessionConnection, type UpdateSessionEvent} from "./ACPSessionConnection";
-import type {Account, CollabAgentToolCallStatus, Model, RateLimitSnapshot, Thread, ThreadItem, UserInput, ReasoningEffortOption} from "./app-server/v2";
+import type {Account, CollabAgentToolCallStatus, Model, Thread, ThreadItem, UserInput, ReasoningEffortOption} from "./app-server/v2";
 import type {RateLimitsMap} from "./RateLimitsMap";
 import type {InputModality, ReasoningEffort} from "./app-server";
+import type {McpStartupCompleteEvent} from "./app-server";
 import {ModelId} from "./ModelId";
 import {AgentMode} from "./AgentMode";
 import type {TokenCount} from "./TokenCount";
@@ -127,7 +128,7 @@ 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();
+        const pendingMcpStartup: Promise<McpStartupCompleteEvent> = this.codexAcpClient.awaitMcpServers();
 
         let sessionMetadata: SessionMetadata;
         if ("sessionId" in request) {
@@ -141,7 +142,9 @@ 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 mcpStartup = await pendingMcpStartup;
+        const sessionMcpServers = mcpStartup.ready;
+        await this.publishMcpStartupStatus(sessionId, mcpStartup);
         const currentModel = this.findCurrentModel(models, currentModelId);
         const sessionState: SessionState = {
             sessionId: sessionId,
@@ -332,7 +335,7 @@ export class CodexAcpServer implements acp.Agent {
         thread: Thread;
     }> {
         await this.checkAuthorization();
-        const pendingMcpServers: Promise<Array<string>> = this.codexAcpClient.awaitMcpServers();
+        const pendingMcpStartup: Promise<McpStartupCompleteEvent> = this.codexAcpClient.awaitMcpServers();
 
         logger.log(`Load existing session: ${request.sessionId}...`);
         const sessionMetadata: SessionMetadataWithThread = await this.runWithProcessCheck(() =>
@@ -342,7 +345,9 @@ 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 mcpStartup = await pendingMcpStartup;
+        const sessionMcpServers = mcpStartup.ready;
+        await this.publishMcpStartupStatus(sessionId, mcpStartup);
         const currentModel = this.findCurrentModel(models, currentModelId);
         const sessionState: SessionState = {
             sessionId: sessionId,
@@ -700,6 +705,52 @@ export class CodexAcpServer implements acp.Agent {
         };
     }
 
+    private async publishMcpStartupStatus(sessionId: string, mcpStartup: McpStartupCompleteEvent): Promise<void> {
+        if (mcpStartup.failed.length === 0 && mcpStartup.cancelled.length === 0) {
+            return;
+        }
+
+        for (const server of mcpStartup.failed) {
+            await this.connection.sessionUpdate({
+                sessionId,
+                update: this.createMcpStartupToolCallUpdate(
+                    server.server,
+                    `[codex-acp forwarded startup error] MCP server \`${server.server}\` failed to start: ${server.error}`
+                ),
+            });
+        }
+        for (const server of mcpStartup.cancelled) {
+            await this.connection.sessionUpdate({
+                sessionId,
+                update: this.createMcpStartupToolCallUpdate(
+                    server,
+                    `[codex-acp forwarded startup error] MCP server \`${server}\` startup was cancelled.`
+                ),
+            });
+        }
+    }
+
+    private createMcpStartupToolCallUpdate(serverName: string, message: string): UpdateSessionEvent {
+        return {
+            sessionUpdate: "tool_call",
+            toolCallId: this.getMcpStartupToolCallId(serverName),
+            kind: "other",
+            title: `mcp__${serverName}__startup`,
+            status: "failed",
+            content: [{
+                type: "content",
+                content: {
+                    type: "text",
+                    text: message,
+                },
+            }],
+        };
+    }
+
+    private getMcpStartupToolCallId(serverName: string): string {
+        return `mcp_startup.${encodeURIComponent(serverName)}`;
+    }
+
     private async runWithProcessCheck<T>(operation: () => Promise<T>): Promise<T> {
         try {
             return await operation();

src/CodexAcpServer.ts

@@ -135,6 +135,48 @@ describe('ACP server test', { timeout: 40_000 }, () => {
         expect(newSessionResponse.sessionId).toBeDefined()
     })
 
+    it('should forward MCP startup failures to ACP session updates', async () => {
+        const mockFixture = createCodexMockTestFixture();
+        const codexAcpAgent = mockFixture.getCodexAcpAgent();
+        const codexAcpClient = mockFixture.getCodexAcpClient();
+
+        vi.spyOn(codexAcpClient, "authRequired").mockResolvedValue(false);
+        vi.spyOn(codexAcpClient, "newSession").mockResolvedValue({
+            sessionId: "session-id",
+            currentModelId: "gpt-5[medium]",
+            models: [{
+                id: "gpt-5",
+                model: "gpt-5",
+                upgrade: null,
+                upgradeInfo: null,
+                availabilityNux: null,
+                displayName: "GPT-5",
+                description: "Test model",
+                hidden: false,
+                supportedReasoningEfforts: [{ reasoningEffort: "medium", description: "Balanced" }],
+                defaultReasoningEffort: "medium",
+                inputModalities: ["text"],
+                supportsPersonality: false,
+                isDefault: true,
+            }],
+        });
+        vi.spyOn(codexAcpClient, "getAccount").mockResolvedValue({ account: null, requiresOpenaiAuth: false });
+        vi.spyOn(codexAcpClient, "awaitMcpServers").mockResolvedValue({
+            ready: ["athena-jetbrains-mcp"],
+            failed: [{
+                server: "ide-athenadiff-mcp",
+                error: "MCP startup failed: connection closed: initialize response",
+            }],
+            cancelled: ["ide-jira-mcp"],
+        });
+
+        await codexAcpAgent.newSession({ cwd: "/workspace", mcpServers: [] });
+
+        const dump = mockFixture.getAcpConnectionDump([]);
+        expect(dump).toContain("MCP server `ide-athenadiff-mcp` failed to start: MCP startup failed: connection closed: initialize response");
+        expect(dump).toContain("MCP server `ide-jira-mcp` startup was cancelled.");
+    });
+
     it('prefetches session additional skill roots before thread start', async () => {
         const mockFixture = createCodexMockTestFixture();
         const codexAcpClient = mockFixture.getCodexAcpClient();

src/__tests__/CodexACPAgent/CodexAcpClient.test.ts

@@ -15,7 +15,11 @@ describe("CodexACPAgent - loadSession", () => {
             account: null,
             requiresOpenaiAuth: false,
         });
-        codexAcpClient.awaitMcpServers = vi.fn().mockResolvedValue([]);
+        codexAcpClient.awaitMcpServers = vi.fn().mockResolvedValue({
+            ready: [],
+            failed: [],
+            cancelled: [],
+        });
         codexAcpClient.listSkills = vi.fn().mockResolvedValue({ data: [] });
 
         const model: Model = {

src/__tests__/CodexACPAgent/load-session.test.ts

@@ -82,7 +82,11 @@ describe("Model filtering", () => {
             models,
         });
         vi.spyOn(codexAcpClient, "getAccount").mockResolvedValue({account: null, requiresOpenaiAuth: false});
-        vi.spyOn(codexAcpClient, "awaitMcpServers").mockResolvedValue([]);
+        vi.spyOn(codexAcpClient, "awaitMcpServers").mockResolvedValue({
+            ready: [],
+            failed: [],
+            cancelled: [],
+        });
 
         const newSessionResponse = await codexAcpAgent.newSession({ cwd: "", mcpServers: [] });
         const sessionModels = newSessionResponse.models;