Refine MCP config conflict deduplication toggle

Author: i1bro

src/CodexAcpClient.ts

@@ -48,19 +48,17 @@ export class CodexAcpClient {
     private readonly codexClient: CodexAppServerClient;
     private readonly config: JsonObject;
     private readonly modelProvider: string | null;
-    private readonly disableMcpConfigFiltering: boolean;
     private gatewayConfig: GatewayConfig | null;
     private pendingLoginCompleted: Promise<AccountLoginCompletedNotification> | null = null;
     private pendingAccountUpdated: Promise<AccountUpdatedNotification> | null = null;
     private readonly sessionNotificationQueues = new Map<string, Promise<void>>();
     private skillExtraRoots: string[] = [];
 
 
-    constructor(codexClient: CodexAppServerClient, codexConfig?: JsonObject, modelProvider?: string, disableMcpConfigFiltering = false) {
+    constructor(codexClient: CodexAppServerClient, codexConfig?: JsonObject, modelProvider?: string) {
         this.codexClient = codexClient;
         this.config = codexConfig ?? {};
         this.modelProvider = modelProvider ?? null;
-        this.disableMcpConfigFiltering = disableMcpConfigFiltering;
         this.gatewayConfig = null;
     }
 
@@ -328,23 +326,23 @@ export class CodexAcpClient {
             return configWithWorkspaceRoots;
         }
 
-        // Deduplicates new servers against existing config to prevent Codex from deep-merging
-        // incompatible field types (e.g., mixing url and stdio schemas).
-        const existingNames = this.disableMcpConfigFiltering
-            ? new Set<string>()
-            : await this.getConfigMcpServerNames(projectPath);
         const requestedServers = mcpServers.map(mcp => ({
             name: sanitizeMcpServerName(mcp.name),
             server: mcp,
         }));
-        const uniqueServers = requestedServers.filter(mcp => !existingNames.has(mcp.name));
-        if (uniqueServers.length === 0) {
+        let serversToConfigure = requestedServers;
+        if (shouldDeduplicateMcpConflicts()) {
+            // Prevents Codex from deep-merging incompatible field types, such as url and stdio schemas.
+            const existingNames = await this.getConfigMcpServerNames(projectPath);
+            serversToConfigure = requestedServers.filter(mcp => !existingNames.has(mcp.name));
+        }
+        if (serversToConfigure.length === 0) {
             return configWithWorkspaceRoots;
         }
 
         return {
             ...configWithWorkspaceRoots,
-            "mcp_servers": Object.fromEntries(uniqueServers.map(mcp => [mcp.name, this.createMcpSeverConfig(mcp.server)])),
+            "mcp_servers": Object.fromEntries(serversToConfigure.map(mcp => [mcp.name, this.createMcpSeverConfig(mcp.server)])),
         };
     }
 
@@ -739,6 +737,11 @@ function formatUriAsLink(name: string | null | undefined, uri: string): string {
     return uri;
 }
 
+function shouldDeduplicateMcpConflicts(): boolean {
+    const disabledByEnv = process.env["DISABLE_MCP_CONFIG_FILTERING"] === "true";
+    return !disabledByEnv;
+}
+
 interface GatewayConfig {
     modelProvider: string;
     config: {

src/index.ts

@@ -42,7 +42,6 @@ function startAcpServer() {
     const configString = process.env["CODEX_CONFIG"];
     const authRequestString = process.env["DEFAULT_AUTH_REQUEST"];
     const modelProvider = process.env["MODEL_PROVIDER"];
-    const disableMcpConfigFiltering = process.env["DISABLE_MCP_CONFIG_FILTERING"] === "true";
     const config = configString ? JSON.parse(configString) : undefined;
     const parsedAuthRequest = authRequestString ? JSON.parse(authRequestString) : undefined;
     const defaultAuthRequest = parsedAuthRequest && isCodexAuthRequest(parsedAuthRequest) ? parsedAuthRequest : undefined;
@@ -73,7 +72,7 @@ function startAcpServer() {
 
     function createAgent(connection: acp.AgentSideConnection): CodexAcpServer {
         const appServerClient = new CodexAppServerClient(codexConnection.connection);
-        const codexClient = new CodexAcpClient(appServerClient, config, modelProvider, disableMcpConfigFiltering);
+        const codexClient = new CodexAcpClient(appServerClient, config, modelProvider);
         return new CodexAcpServer(connection, codexClient, defaultAuthRequest, () => codexConnection.process.exitCode);
     }