Codex++: A Practical Guide to Unlocking Full Plugins Functionality with Chinese LLMs

Why Plugins Get Disabled When Connecting Chinese LLMs to Codex

Developers who've used OpenAI Codex know that the Plugins feature is its core competitive advantage — advanced capabilities like code completion, debugging, and file operations all depend on it. Without Plugins, Codex loses about 70% of its power.

OpenAI Codex's Plugins system is essentially a Tool Use framework that allows the model to dynamically invoke external capabilities during inference. This design stems from the "tool-augmented language model" architecture — a pure language model can only generate text, but through Plugins, the model can perform real file I/O, terminal commands, code execution, and more, forming a complete "perceive-reason-execute" loop. Plugin availability is typically tightly coupled with the model's Function Calling capability. OpenAI's official models natively support the structured function calling protocol, but when some Chinese models fail to fully implement specific fields or response formats of this protocol, Codex's client-side capability detection logic simply disables the Plugins entry point.

However, when we connect Chinese models (such as Qwen) to Codex using the standard approach, we encounter a frustrating problem — the Plugins feature is completely grayed out and unusable.

Chinese LLMs like Qwen generally provide OpenAI-compatible API access (i.e., "OpenAI Compatible API"), allowing developers to seamlessly connect them to clients supporting the OpenAI protocol by simply swapping the base_url and api_key. However, "compatible" does not mean "fully equivalent." OpenAI's Function Calling protocol has gone through multiple iterations — from the early functions field to the tools field, and then to advanced features like Parallel Tool Calls. Different Chinese models vary in their support for these protocol details, and missing fields or subtle deviations in response structure are enough to trigger capability detection failures on the client side, causing the frontend logic to actively hide UI features (like the Plugins entry) that depend on these capabilities.

This issue was already mentioned in previous Codex hands-on series articles. While connecting Chinese models works fine and the models respond normally, the absence of Plugins significantly degrades the development experience. For developers who rely on these advanced features daily, this is nearly unacceptable.

Codex++: An Open-Source Enhancement Tool Built for Chinese LLMs

The good news is that the community has delivered a solution — Codex++, an open-source enhancement tool specifically designed to address this pain point. With Codex++, even when using Chinese models like Qwen, you can fully unlock Codex's Plugins functionality for a true "full-power" experience.

From the actual demo, the interface launched through Codex++ shows Plugins fully functional — identical to the experience with OpenAI's official models. This means you can enjoy the low cost and low latency advantages of Chinese models without sacrificing any advanced features.

Codex++ Technical Principles: A Safe, Non-Invasive CDP Injection Approach

The technical implementation of Codex++ is worth understanding in depth, as it employs a safe and non-invasive architectural design.

No Modification to Original Codex Installation Files

Codex++ makes zero changes to Codex's original installation files. This is crucial — your Codex installation always remains in its official, pristine state with no risk of tampering, and it won't interfere with future official updates.

External Launcher + CDP Protocol Script Injection

Codex++ operates in two steps:

1. Launch Codex through an external Launcher: Codex++ provides a standalone launcher that replaces directly opening the Codex application
2. Inject enhancement scripts via Chromium DevTools Protocol (CDP): After launch, Codex++ injects enhancement scripts into Codex's runtime environment through the CDP protocol, unlocking the restricted Plugins functionality

CDP (Chromium DevTools Protocol) is a low-level debugging and automation protocol designed by Google for Chromium-based browsers. Built on WebSocket communication, it allows external programs to interact bidirectionally with the browser's rendering process, JavaScript engine, and network layer. CDP was originally created to serve the Chrome DevTools debugging panel but was later widely adopted by automation testing frameworks like Puppeteer and Playwright, becoming the de facto standard in browser automation. Since the Codex client is essentially a desktop application built on the Electron framework — which uses Chromium under the hood — CDP is naturally suited for script injection and behavior intervention in its runtime environment. This approach requires no modification to the application's disk files; all enhancement logic exists only in runtime memory, making it minimally invasive from a security audit perspective. Codex++ cleverly leverages this protocol to achieve functionality enhancement without breaking the original program structure.

Practical Value of Using Codex++

Three Core Advantages

• Significantly lower costs: Chinese model API pricing is typically a fraction of OpenAI's official models, saving considerable expenses over long-term use
• More stable network: Chinese models offer better access speed and connection stability within China, eliminating frequent timeouts and disconnections
• Zero feature loss: With Plugins unlocked through Codex++, there's no longer a trade-off between feature completeness and usage cost

Important Notes Before Use

1. Codex++ is an open-source project — always obtain the installation package from the official GitHub repository and avoid redistributed versions from unknown sources
2. Since it uses script injection, official Codex version updates may require waiting for Codex++ to release a compatible adaptation
3. It's recommended to test in a non-production environment first, and only adopt it for daily development after confirming all features work stably

Conclusion: The Perfect Companion for Chinese LLMs + Codex

Codex++ provides an elegant solution to the missing Plugins functionality when connecting Chinese models to Codex. Its design philosophy of not modifying original files and injecting enhancement scripts through the standard CDP protocol ensures both security and complete feature unlocking.

For developers who want to use Chinese models like Qwen in Codex, Codex++ is undoubtedly the most worthwhile enhancement solution to try right now. If you're frustrated by the Plugins being unavailable, head over to GitHub and give this project a try.

Key Takeaways

• Plugins get disabled when connecting Chinese models to Codex because Function Calling protocol compatibility differences trigger the client's capability detection failure
• Codex++ is an open-source enhancement tool that fully unlocks Plugins functionality for Chinese models
• Codex++ doesn't modify original installation files — it launches via an external Launcher and injects enhancement scripts at runtime using Chromium DevTools Protocol (CDP)
• This solution combines the cost and network advantages of Chinese models while preserving Codex's complete feature experience