Codex Desktop model picker filters out models returned from model_catalog_json

[vacinator]

What version of the Codex App are you using (From “About Codex” dialog)?

26.422.30944

What subscription do you have?

Plus

What platform is your computer?

Microsoft Windows NT 10.0.26200.0 x64

What issue are you seeing?

Title

Codex Desktop model picker filters out models returned from official model_catalog_json config

Bug report

What variant of Codex are you using?

Codex Desktop App

What issue are you seeing?

The Codex Desktop App model picker does not show models that are loaded from a locally configured model_catalog_json file, even though model_catalog_json is an officially supported config.toml key.

The app-server appears to load the configured model catalog correctly and returns the custom models through model/list. However, the Desktop UI does not render these models in the model picker.

This makes models from a valid local catalog unavailable from the Desktop model picker, even though they are available to Codex through configuration and can be used when set directly in config.toml.

Why I am filing this as a bug

I am filing this as a bug because model_catalog_json is an officially supported configuration key.

If the app-server resolves the effective model catalog and returns the configured models via model/list, the Desktop model picker should respect that effective model list. The Desktop UI should not remove locally configured catalog models after they have already been loaded by the app-server.

Remote allowlists, rollout gates, or entitlement checks may make sense for OpenAI-hosted first-party models. However, they should not filter out locally configured custom/provider models that were explicitly loaded from model_catalog_json.

This is not a request to bypass entitlement checks for OpenAI-hosted models. The issue is specifically about locally configured catalog models for a custom/OpenAI-compatible provider.

Relevant config.toml

Example:

model_catalog_json = "C:\\Users\\abc\\.codex\\local-models.json"
model = "some-name"
model_provider = "local-provider"

[model_providers.local-provider]
name = "local-provider"
base_url = "http://127.0.0.1:5092/v1"
wire_api = "responses"
env_key = "CODEX_LOCAL_PROVIDER"
requires_openai_auth = false
supports_websockets = false
request_max_retries = 4
stream_max_retries = 5
stream_idle_timeout_ms = 300000

Current behavior

1. model_catalog_json is configured in config.toml.
2. The model catalog JSON contains visible custom models with hidden: false.
3. The app-server loads the model catalog.
4. The app-server returns the custom models through model/list.
5. The Codex Desktop model picker does not show these models.
6. If model = "some-model-name" is set directly in config.toml, the Desktop App may show Custom, but the configured model string is still sent correctly.

Expected behavior

When model_catalog_json is configured, Codex Desktop should show the visible models from the effective model catalog in the model picker.

At minimum, the Desktop renderer should not apply an additional remote allowlist/filter that removes locally configured catalog models returned by the app-server.

A reasonable behavior would be:

• First-party OpenAI models can still be filtered by entitlement or rollout rules.
• Locally configured models from model_catalog_json should be shown if they are returned by model/list and are not marked as hidden.
• The model picker should use the model key/slug returned by the app-server instead of only allowing model IDs from a remote allowlist.

Why this matters

model_catalog_json is important for custom providers, local gateways, enterprise proxies, and OpenAI-compatible bridges.

Without Desktop model picker support, users have to manually edit config.toml whenever they want to switch between locally configured models. The configured model may still work, but the UI gives the impression that the model is unsupported or unavailable.

This is confusing because the model is available according to the app-server, but invisible in the Desktop App.

Additional notes

This appears to be a Desktop UI filtering issue rather than a model catalog or provider issue.

The backend/app-server side seems to have the correct effective model list. The filtering appears to happen after model/list, inside the Desktop renderer/model picker UI.

What steps can reproduce the bug?

1. Configure a custom/OpenAI-compatible model provider in config.toml.

Example:

model_catalog_json = "C:\\Users\\abc\\.codex\\custom-model-catalog.json"
model = "some-model-name"
model_provider = "custom_openai_compat_provider"

[model_providers.custom_openai_compat_provider]
name = "custom_openai_compat_provider"
base_url = "http://127.0.0.1:5092/v1"
wire_api = "responses"
env_key = "CUSTOM_PROVIDER_TOKEN"
requires_openai_auth = false
supports_websockets = false

2. Create the referenced model catalog JSON file and include at least one visible custom model.

Example:

{
  "models": [
    {
      "slug": "some-model-name",
      "displayName": "Some Model Name",
      "provider": "custom_openai_compat_provider",
      "hidden": false
    }
  ]
}

3. Start or restart the Codex Desktop App so that the model_catalog_json setting is loaded.

4. Verify that the app-server has loaded the model catalog and that the custom model is returned by the model list endpoint.

5. Open the Codex Desktop App model picker.

6. Observe that the model from the configured model_catalog_json file is not shown in the model picker.

7. Set model = "some-model-name" directly in config.toml.

8. Start the Desktop App again.

9. Observe that the Desktop App may show the selected model as Custom, but the configured model string is still passed through correctly.

What is the expected behavior?

When model_catalog_json is configured in config.toml, the Codex Desktop App should show the visible models from the effective model catalog in the model picker.

If the app-server loads the configured catalog and returns a model through the model list endpoint, the Desktop UI should not remove that model from the picker only because it is not part of a remote allowlist or rollout configuration.

Expected behavior:

• Models loaded from model_catalog_json should appear in the Desktop model picker if they are returned by the app-server and are not marked as hidden.
• Locally configured custom/provider models should not be filtered out by remote rollout or allowlist logic intended for first-party OpenAI models.
• First-party OpenAI models can still be subject to entitlement checks, rollout gates, or account-specific availability.
• Custom/provider models from an explicitly configured local catalog should remain visible and selectable.
• The picker should use the model identifier returned by the app-server, for example some-model-name, instead of requiring it to exist in a remote list of known OpenAI model IDs.

Additional information

This appears to be a Desktop UI filtering issue rather than a model catalog or provider issue.

The configured model_catalog_json file is loaded correctly by the app-server, and the custom models are returned through the model list endpoint. However, the Electron/Desktop renderer appears to apply an additional client-side filter before rendering the model picker.

This is confusing because the effective backend configuration knows about the model, but the Desktop UI hides it.

This is not a request to bypass entitlement checks for OpenAI-hosted first-party models. The issue is specifically about locally configured models from an official model_catalog_json config key and a custom/OpenAI-compatible provider.

The current workaround is to set the desired model directly in config.toml, for example:

model = "some-model-name"
model_provider = "custom_openai_compat_provider"

With this workaround, the Desktop App may show Custom in the model picker, but it still passes the configured model string through correctly. However, this requires manual config editing and makes the model picker unusable for switching between locally configured catalog models.

[github-actions]

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

• Desktop app model picker does not show gpt-5.5 even when backend reports it available #19404

Powered by Codex Action

[trite8q1]

Same problem

[makainan123-prog]

+1

[hheei]

Reproduced on Codex Desktop App on macOS.

In my case, a custom model loaded via model_catalog_json is present in the backend catalog, but does not appear in the Desktop model picker UI.

Observed behavior:

• ~/.codex/config.toml points model_catalog_json to a custom catalog
• codex debug models includes deepseek-v4-pro in the final catalog
• the model is usable by slug from CLI / config (model = "deepseek-v4-pro")
• app-server logs show requests actually running with model=deepseek-v4-pro
• but the Desktop model picker still does not show it

So this looks like a Desktop picker / frontend filtering issue rather than a catalog parsing or provider issue.

I also confirmed this is not just stale config: after restarting the app, the picker still omits the model while backend debug output still includes it.

[ryoreonhz-dev]

I can reproduce a similar issue in Codex Desktop App on macOS.

Environment:

• Codex Desktop App version: 26.5.21.10419
• macOS: Apple Silicon
• Custom provider: Moon Bridge
• Provider base_url: http://127.0.0.1:38440/v1
• wire_api: responses
• model_catalog_json: ~/.codex/models_catalog.json

Behavior:

• Codex CLI can use the custom provider successfully.
• Codex Desktop App recognizes the custom provider and shows "Moon Bridge".
• ~/.codex/models_catalog.json contains deepseek-v4-pro, deepseek-v4-flash, and moonbridge.
• Moon Bridge /v1/models also returns deepseek-v4-pro, deepseek-v4-flash, and moonbridge.
• However, the Desktop App model picker does not show deepseek-v4-pro or deepseek-v4-flash.
• The right-side "Model" field in the Custom menu is not editable, so I cannot manually enter the custom model name from the UI.
• Setting model = "deepseek-v4-pro" or model = "deepseek-v4-flash" in ~/.codex/config.toml works as a workaround. The Desktop App sends the configured model string correctly to Moon Bridge, and Moon Bridge logs show actual_model=deepseek-v4-pro / actual_model=deepseek-v4-flash.

Expected:

• Desktop App should list custom models from model_catalog_json in the model picker, or allow manual entry of the model name in the Custom provider UI.

Workaround:

• I currently switch models by editing ~/.codex/config.toml via a local script.

Relevant config:
model = "deepseek-v4-pro"
model_provider = "moonbridge"
model_catalog_json = "/Users/liangliang/.codex/models_catalog.json"

[model_providers.moonbridge]
name = "Moon Bridge"
base_url = "http://127.0.0.1:38440/v1"
wire_api = "responses"