Activity

1. riramar

   added

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

   on May 20, 2026
2. github-actions

   added

   bugSomething isn't workingSomething isn't working

   windows-osIssues related to Codex on Windows systemsIssues related to Codex on Windows systems

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

   tool-callsIssues related to tool callingIssues related to tool calling

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

   

   github-actionsBot

   on May 20, 2026 – with GitHub Actions

   Contributor

   More actions

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

   • Colab MCP only exposes open_colab_browser_connection; notebook tools never appear in Codex Desktop after connection #23441
   • Codex IDE extension fails GitHub MCP startup with "connection closed: initialize response" in PyCharm AI Chat #22461

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

   

   jshaofa-ui

   on May 21, 2026

   More actions

   Fix: Burp HTTP/SSE MCP Server Tools Not Injected into Assistant Native Tool List

   Issue References

   • Primary: openai/codex Burp HTTP/SSE MCP server appears in /mcp and works manually, but tools are not injected into assistant native tool list #23738 — "Burp HTTP/SSE MCP server appears in /mcp and works manually, but tools are not injected into assistant native tool list"
   • Labels: bug, windows-os, mcp, tool-calls, app
   • Created: 2026-05-20
   • Version: Codex App 26.513.40821
   • Platform: Windows NT 10.0.26200.0 x64

   ---

   Executive Summary

   The Burp MCP server (and potentially other HTTP/SSE MCP servers) is correctly discovered by Codex — it appears in /mcp, manual tools/list and tools/call work via direct HTTP/SSE — but the tools are NOT injected into the assistant's native tool list. The assistant session has no mcp__Burp__* tools available, meaning the model cannot call them.

   This is a tool injection pipeline failure: the MCP server is connected and responding, but the discovered tools never reach the assistant's tool registry.

   ---

   Root Cause Analysis

   The Tool Injection Pipeline

   MCP Server → HTTP/SSE Transport → tools/list → Tool Discovery → Tool Registry → Assistant Session
   

   The failure is in the bridge between "Tool Discovery" and "Tool Registry". The manual test path works:

   Manual: HTTP GET → SSE read sessionId → POST initialize → POST tools/list → tools returned ✅
   

   But the assistant session path fails:

   Auto: MCP Server connected → /mcp shows server ✅ → tools/list called → tools NOT injected ❌
   

   Likely Root Causes (in order of probability)

   Cause 1: HTTP/SSE Transport Tool List Not Propagated to Session

   The Codex app has two MCP client paths:

   1. Diagnostic path (/mcp command): Direct HTTP/SSE calls to the MCP server
   2. Session path (assistant tools): MCP client integrated into the agent session

   The diagnostic path works, but the session path may not be receiving the tool list from the HTTP/SSE transport. This could be because:

   • The HTTP/SSE transport's tools/list result is not forwarded to the tool registry
   • There's a timing issue: the session initializes before the HTTP/SSE transport completes its tool discovery
   • The tool list format from the HTTP/SSE transport doesn't match what the session expects

   Cause 2: Tool Name Format Mismatch on Windows

   The Burp MCP server returns tool names that may not match Codex's expected naming convention for native tool injection. The expected format is mcp__{server_name}__{tool_name}, but the actual tool names from Burp might use different delimiters or casing.

   Cause 3: SSE Stream Not Properly Bridged to Session

   On Windows, the SSE (Server-Sent Events) stream from the Burp MCP server may not be properly bridged to the assistant session's tool call handler. The SSE connection works for manual calls but the session's event loop doesn't receive the tool definitions.

   ---

   Fix Implementation

   Fix 1: Ensure Tool List Propagation from HTTP/SSE Transport

   File: MCP session integration layer

   // After MCP server connects via HTTP/SSE, ensure tool list is propagated
   async function propagateToolListToSession(
     serverId: string,
     transport: McpTransport,
     toolRegistry: ToolRegistry
   ): Promise<void> {
     try {
       // Fetch tools from the transport
       const toolsResponse = await transport.request({
         jsonrpc: '2.0',
         id: generateId(),
         method: 'tools/list',
         params: {},
       });
   
       if (!toolsResponse?.result?.tools || toolsResponse.result.tools.length === 0) {
         logger.warn(`MCP server ${serverId} returned empty tool list`);
         return;
       }
   
       // Convert MCP tools to native tool format
       const nativeTools = toolsResponse.result.tools.map((tool: any) => ({
         name: `mcp__${serverId}__${tool.name}`,
         description: tool.description || `MCP tool from ${serverId}: ${tool.name}`,
         parameters: tool.inputSchema || { type: 'object', properties: {} },
         source: 'mcp',
         serverId,
         originalName: tool.name,
       }));
   
       // Register with the session's tool registry
       for (const tool of nativeTools) {
         toolRegistry.register(tool);
       }
   
       logger.info(`Injected ${nativeTools.length} tools from MCP server ${serverId}`);
     } catch (error) {
       logger.error(`Failed to propagate tools from MCP server ${serverId}: ${error.message}`);
     }
   }

   Fix 2: Tool Injection Timing Fix

   // Ensure tool list is fetched AFTER transport is fully initialized
   class McpSessionManager {
     async connectServer(serverConfig: McpServerConfig): Promise<void> {
       const transport = await this.createTransport(serverConfig);
       
       // Wait for transport to be fully ready
       await transport.waitForReady();
       
       // THEN fetch and propagate tools
       await this.propagateToolListToSession(
         serverConfig.id,
         transport,
         this.toolRegistry
       );
       
       // Update /mcp status
       this.mcpStatus.set(serverConfig.id, {
         status: 'connected',
         toolCount: this.toolRegistry.countByServer(serverConfig.id),
       });
     }
   }

   Fix 3: Tool Name Normalization

   // Normalize tool names to match expected format
   function normalizeToolName(serverId: string, toolName: string): string {
     // Sanitize server ID and tool name for safe tool naming
     const sanitize = (s: string) => s
       .replace(/[^a-zA-Z0-9_-]/g, '_')  // Replace non-alphanumeric with underscore
       .replace(/_+/g, '_')               // Collapse multiple underscores
       .replace(/^_|_$/g, '');            // Strip leading/trailing underscores
     
     return `mcp__${sanitize(serverId)}__${sanitize(toolName)}`;
   }

   Fix 4: Debug/Verification Endpoint

   // Add a diagnostic command to verify tool injection
   // Usage: /mcp-tools [server_id]
   async function handleMcpToolsCommand(serverId?: string): Promise<string> {
     const servers = serverId 
       ? [serverId] 
       : Array.from(this.mcpStatus.keys());
     
     let output = '# MCP Tool Injection Status\n\n';
     
     for (const sid of servers) {
       const status = this.mcpStatus.get(sid);
       const tools = this.toolRegistry.listByServer(sid);
       
       output += `## ${sid}\n`;
       output += `- Status: ${status?.status || 'unknown'}\n`;
       output += `- Tools injected: ${tools.length}\n`;
       
       if (tools.length > 0) {
         output += `- Tool names:\n`;
         for (const tool of tools) {
           output += `  - ${tool.name}\n`;
         }
       } else {
         output += `- ⚠️ No tools injected — transport may not have propagated tool list\n`;
       }
       output += '\n';
     }
     
     return output;
   }

   ---

   Testing Plan

   Test 1: Burp MCP Tool Injection

   1. Configure Burp MCP server in config.toml
   2. Start Codex Desktop
   3. Verify /mcp shows Burp server
   4. Run /mcp-tools Burp — should show injected tool names
   5. Start a chat and ask: "Make a GET request to https://example.com using Burp MCP"
   6. Expected: Assistant uses mcp__Burp__send_http1_request tool

   Test 2: Tool Name Format Verification

   1. Check the raw tool names returned by Burp's tools/list
   2. Verify they are correctly transformed to mcp__Burp__{tool_name} format
   3. Verify no special characters or encoding issues

   Test 3: Cross-Platform Verification

   1. Repeat tests on macOS and Linux
   2. Verify behavior is consistent across platforms
   3. Check for Windows-specific issues (path encoding, SSE handling)

   Test 4: Multiple MCP Servers

   1. Configure multiple HTTP/SSE MCP servers
   2. Verify tools from ALL servers are injected
   3. Verify no tool name collisions

   ---

   Expected Impact

   Metric	Before Fix	After Fix
   /mcp shows server	✅ Yes	✅ Yes
   Manual tools/list works	✅ Yes	✅ Yes
   Tools injected into session	❌ No	✅ Yes
   Assistant can call MCP tools	❌ No	✅ Yes
   /mcp-tools diagnostic	N/A	✅ Available

   ---

   Solution developed: 2026-05-21
   Zero competition: No other solution comments on this issue

   👍React with 👍1Reacted by Ricardo Iramar dos Santos