Activity

1. jarvanstack

   added

   appIssues related to the Codex desktop appIssues related to the Codex desktop app

   on May 23, 2026
2. github-actions

   added

   bugSomething isn't workingSomething isn't working

   mcpIssues related to the use of model context protocol (MCP) serversIssues related to the use of model context protocol (MCP) servers

   configIssues involving config.toml, config keys, config merging, or config updatesIssues involving config.toml, config keys, config merging, or config updates

   on May 23, 2026
3. github-actions commented on May 23, 2026

   

   github-actionsbot

   on May 23, 2026 – with GitHub Actions

   Contributor

   More actions

   Potential duplicates detected. Please review them and close your issue if it is a duplicate.

   • Burp HTTP/SSE MCP server appears in /mcp and works manually, but tools are not injected into assistant native tool list #23738

   Powered by Codex Action
4. jshaofa-ui commented on May 23, 2026

   

   jshaofa-ui

   on May 23, 2026

   More actions

   openai/codex #24168: Desktop MCP Tools Not Injected Into Thread

   🔍 Root Cause Analysis

   Severity: P1 — MCP tools intermittently absent from thread, model cannot call configured tools

   Codex Desktop sometimes starts a thread without exposing configured MCP tools to the model, even though the same MCP server is correctly detected by the Codex CLI. The tools are absent from session_meta.dynamic_tools.

   Root Cause Chain

   1. Desktop vs CLI tool injection divergence: The Desktop app's tool injection pipeline has a race condition or state synchronization gap that the CLI does not have
   2. MCP manager state not propagated: The MCP server connection is established (CLI sees it), but the tool definitions are not injected into the thread's dynamic_tools
   3. Thread creation timing: The thread may be created before the MCP manager finishes loading/validating the server
   4. streamable_http transport specific: The issue occurs with streamable_http MCP servers — possibly a connection timing issue with HTTP-based MCP

   🛠️ Proposed Fix

   Fix 1: MCP Tool Injection Verification Gate (Critical)

   // In ThreadManager — verify MCP tools are injected before thread starts
   class ThreadManager {
     async createThread(config: ThreadConfig): Promise<Thread> {
       // Wait for MCP manager to be ready
       await this.mcpManager.waitForReady();
   
       // Get MCP tool definitions
       const mcpTools = await this.mcpManager.getAllToolDefinitions();
   
       // NEW: Verify tools are injected into session_meta
       const thread = await this.doCreateThread(config);
       const injectedTools = thread.session_meta.dynamic_tools || [];
   
       const expectedToolNames = mcpTools.map(t => `mcp__${t.name}`);
       const missingTools = expectedToolNames.filter(
         name => !injectedTools.some(t => t.name === name)
       );
   
       if (missingTools.length > 0) {
         this.logger.error('MCP tools not injected into thread', {
           threadId: thread.id,
           missingTools,
           injectedTools: injectedTools.map(t => t.name),
           mcpServers: await this.mcpManager.getServerList(),
         });
   
         // Retry injection
         await this.retryMcpToolInjection(thread, mcpTools);
       }
   
       return thread;
     }
   
     private async retryMcpToolInjection(thread: Thread, tools: McpToolDef[]): Promise<void> {
       for (const tool of tools) {
         const toolName = `mcp__${tool.name}`;
         if (!thread.session_meta.dynamic_tools.some(t => t.name === toolName)) {
           thread.session_meta.dynamic_tools.push({
             name: toolName,
             description: tool.description,
             parameters: tool.parameters,
             source: 'mcp',
           });
         }
       }
     }
   }

   Fix 2: MCP Manager Ready Signal (Important)

   // In McpManager — emit ready signal when all servers are loaded
   class McpManager {
     private readyPromise: Promise<void> | null = null;
     private servers: Map<string, McpServerConnection> = new Map();
   
     async waitForReady(): Promise<void> {
       if (!this.readyPromise) {
         this.readyPromise = this.initializeAllServers();
       }
       return this.readyPromise;
     }