opencode-openai-codex-auth

This plugin is strictly for personal development use only. It leverages OpenAI's official OAuth authentication to allow individual coding assistance via a ChatGPT Plus/Pro subscription.

Prohibited Uses:

• Commercial services
• API resale
• Multi-user applications

For production-grade requirements, use the OpenAI Platform API. Users are responsible for complying with OpenAI's Terms of Use.

OpenCode merges configuration from multiple sources. When multiple sources define the same setting, the last source in the list wins. The loading order is:

1. Global Config: Located at ~/.config/opencode/opencode.jsonc or ~/.config/opencode/opencode.json.
2. Project Configs: Traversed upward from the current working directory (cwd) to the worktree root. Looks for .opencode/opencode.jsonc or .opencode/opencode.json in the current or parent directories.
3. Custom Config (via flags): Provided via environment variables during execution:
   • OPENCODE_CONFIG=/path/to/config.json opencode
   • OPENCODE_CONFIG_CONTENT='{"model":"openai/gpt-5"}' opencode
4. Auth Configs: Fetched from .well-known/opencode endpoints for OAuth providers (e.g., https://auth.example.com/.well-known/opencode).

You can apply settings at different levels of granularity:

Pattern 1: Global Options

Apply settings to all models by placing them in the provider.openai.options block. Use this for consistent behavior across your environment.

Pattern 2: Per-Model Options

Define specific settings within the provider.openai.models.<model-id>.options block.

Precedence: Model-specific options always override global options.

{
  "plugin": ["opencode-openai-codex-auth"],
  "provider": {
    "openai": {
      "options": {
        "reasoningEffort": "medium",
        "store": false
      },
      "models": {
        "gpt-5-codex-fast": {
          "name": "Fast Codex",
          "options": {
            "reasoningEffort": "low",
            "store": false
          }
        }
      }
    }
  }
}

The plugin stores the following data locally on your machine:

If you do not define a specific model in your configuration, or if the selected model does not have a custom entry in the models object, the plugin falls back to the global options defined under the provider.

For example, if you select openai/gpt-5-codex and it is not explicitly defined in your models config, it will use the settings provided in provider.openai.options.

{
  "plugin": ["opencode-openai-codex-auth"],
  "provider": {
    "openai": {
      "options": {
        "reasoningEffort": "medium"
      }
    }
  }
}

The codex-opencode-bridge (located in lib/prompts/codex-opencode-bridge.ts) is a specialized prompt transformation layer. It replaces standard OpenCode system prompts with Codex-specific instructions.

Benefits include:

• Tool Mapping: Explains differences in tool names (e.g., mapping apply_patch to edit).
• Efficiency: Achieves approximately a 90% reduction in prompt tokens compared to full OpenCode prompts, leading to faster inference and lower costs.
• Behavioral Alignment: Maintains the OpenCode working style while preserving Codex best practices.

The OpenCode OpenAI Codex Auth Plugin is designed to bridge AI SDK constructs with the Codex API. It employs several key architectural strategies to ensure compatibility and performance:

• AI SDK Compatibility: The plugin filters item_reference (an AI SDK construct) to ensure compatibility with the Codex API.
• Stateless Operation: For ChatGPT backends, the plugin operates in a stateless mode by setting store: false.
• Full Context Preservation: To maintain LLM context, the plugin sends the complete message history, though it strips IDs before transmission.
• Rate Limit Protection: It implements a 15-minute caching mechanism to prevent exhausting GitHub API rate limits.
• Per-Model Configuration: The system supports per-model configuration, allowing users to switch between different quality presets easily.

Before options reach a plugin, they are merged through several stages. The User Config has the highest priority and overrides all previous stages.

1. Stage 1: Database Defaults: Baseline capabilities provided by Models.dev.
2. Stage 2: Environment Variables: e.g., export OPENAI_API_KEY="sk-...".
3. Stage 3: Custom Loaders: Options injected via a plugin's loader() function.
4. Stage 4: User Config (HIGHEST PRIORITY): Settings defined in your OpenCode configuration file under the provider key.

Since the plugin uses store:false, it cannot rely on the server to remember the model's internal reasoning process. To solve this, the plugin uses reasoning.encrypted_content to pass reasoning context back and forth between the client and server.

The Flow:

1. Turn 1: The client sends a request. The server returns a response containing encrypted_content (the model's reasoning).
2. Client Side: The client stores this encrypted content locally.
3. Turn 2: The client sends the next request, including the previously received encrypted_content in the include array.
4. Server Side: The server decrypts the content to restore the model's reasoning context before generating the next response.

body.include = modelConfig.include || ["reasoning.encrypted_content"];