Skip to content

"Vibe-Trading: Your Personal Trading Agent"

feat(settings): discover ChatGPT Codex OAuth models dynamically

zeus229dea94bad3006
diff --git a/README.md b/README.md
index 7622c8748..89008537c 100644
--- a/README.md
+++ b/README.md
@@ -1069,6 +1069,7 @@ vibe-trading-mcp # start MCP server (stdio)
- **Python 3.11+** for Path B
- **Docker** for Path A
- OpenAI Codex can also be used with ChatGPT OAuth: set `LANGCHAIN_PROVIDER=openai-codex`, then run `vibe-trading provider login openai-codex`. This does not use `OPENAI_API_KEY`.
+ In Web Settings, the Codex model picker discovers available models and reasoning levels from the authenticated ChatGPT session. If discovery is unavailable, the default model and manual model entry remain available.
- GitHub Copilot can be used with an active Copilot subscription instead of a separately billed LLM API key. See [GitHub Copilot SDK provider](#github-copilot-sdk-provider).
- A local Claude Code login can drive the agent without an API key. See [Claude Code CLI provider](#claude-code-cli-provider).
diff --git a/agent/src/api/settings_routes.py b/agent/src/api/settings_routes.py
index 6bf9aaf41..f8af1d2a4 100644
--- a/agent/src/api/settings_routes.py
+++ b/agent/src/api/settings_routes.py
@@ -10,6 +10,7 @@ import importlib.util
import logging
import json
import os
+import re
import sys as _sys
from pathlib import Path
from typing import Any, Awaitable, Callable, Dict, List, Literal, Optional
@@ -115,6 +116,9 @@ class LLMModelsResponse(BaseModel):
# Model id -> reasoning effort levels it accepts; an empty list means the
# model takes no effort setting. Only providers that report it fill this.
effort_levels: Optional[Dict[str, List[str]]] = None
+ # Optional display metadata. IDs remain canonical and editable.
+ model_labels: Optional[Dict[str, str]] = None
+ default_effort_levels: Optional[Dict[str, str]] = None
class SourceOrderEntry(BaseModel):
@@ -315,6 +319,92 @@ def _extract_model_ids(payload: Any) -> List[str]:
return sorted(model_ids, key=str.casefold)[:1000]
+# Codex CLI model discovery requires a client_version query parameter. Keep
+# this value explicit and review it when updating Codex OAuth compatibility.
+# Verified with the ChatGPT Codex catalog on 2026-10-27.
+_CODEX_MODELS_URL = "https://chatgpt.com/backend-api/codex/models"
+_CODEX_MODELS_CLIENT_VERSION = "0.159.0"
+_CODEX_EFFORT_LEVELS = frozenset({"low", "medium", "high", "xhigh", "max", "ultra"})
+
+
+async def _list_openai_codex_models(provider: LLMProviderOption) -> LLMModelsResponse:
+ """Discover ChatGPT OAuth models without sharing the token with form URLs."""
+ from src.providers.openai_codex import _build_headers, _get_codex_token
+
+ fallback = LLMModelsResponse(
+ provider=provider.name,
+ models=[provider.default_model],
+ source="default",
+ warning_code="model_list_unavailable",
+ )
+ try:
+ token = await asyncio.to_thread(_get_codex_token)
+ async with httpx.AsyncClient(timeout=12.0, follow_redirects=False, trust_env=False) as client:
+ for attempt in range(2):
+ headers = _build_headers(token.account_id, token.access)
+ headers["Accept"] = "application/json"
+ response = await client.get(
+ _CODEX_MODELS_URL,
+ params={"client_version": _CODEX_MODELS_CLIENT_VERSION},
+ headers=headers,
+ )
+ if response.status_code == 401 and attempt == 0:
+ token = await asyncio.to_thread(
+ _get_codex_token, force_refresh=True, rejected_access=token.access
+ )
+ continue
+ response.raise_for_status()
+ payload = response.json()
+ break
+ if not isinstance(payload, dict) or not isinstance(payload.get("models"), list):
+ return fallback
+
+ models: list[str] = []
+ efforts: dict[str, list[str]] = {}
+ labels: dict[str, str] = {}
+ defaults: dict[str, str] = {}
+ for item in payload["models"][:1000]:
+ if not isinstance(item, dict):
+ continue
+ if item.get("visibility") != "list" or item.get("supported_in_api") is not True:
+ continue
+ slug = item.get("slug")
+ if not isinstance(slug, str) or not slug or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}", slug):
+ continue
+ model_id = f"openai-codex/{slug}"
+ if model_id in models:
+ continue
+ models.append(model_id)
+ label = item.get("display_name")
+ if isinstance(label, str) and label.strip():
+ labels[model_id] = label.strip()[:128]
+ levels = item.get("supported_reasoning_levels")
+ if isinstance(levels, list):
+ supported = []
+ for level in levels:
+ effort = level.get("effort") if isinstance(level, dict) else None
+ if effort in _CODEX_EFFORT_LEVELS and effort not in supported:
+ supported.append(effort)
+ efforts[model_id] = supported
+ default = item.get("default_reasoning_level")
+ if isinstance(default, str) and default in _CODEX_EFFORT_LEVELS:
+ defaults[model_id] = default
+ if not models:
+ return fallback
+ return LLMModelsResponse(
+ provider=provider.name,
+ models=models,
+ source="provider",
+ effort_levels=efforts,
+ model_labels=labels,
+ default_effort_levels=defaults,
+ )
+ except (RuntimeError, AttributeError, httpx.HTTPError, ValueError, TypeError) as exc:
+ # Never log exception bodies here: the HTTP response could contain secrets.
+ logger.warning("OpenAI Codex model discovery unavailable (%s)", type(exc).__name__)
+ return fallback
+
+
async def _list_provider_models(
provider: LLMProviderOption,
*,
@@ -827,6 +917,10 @@ def register_settings_routes(
if provider.auth_type == "claude_cli":
# No HTTP endpoint: the base URL checks below would reject it outright.
return await _list_claude_cli_models(provider, refresh=payload.refresh)
+ if provider.name == "openai-codex":
+ # OAuth credentials only go to our fixed Codex catalog endpoint.
+ # Do not use base_url or api_key values supplied by the settings form.
+ return await _list_openai_codex_models(provider)
current_values = _read_settings_env_values()
requested_base_url = (payload.base_url or "").strip()
diff --git a/agent/src/providers/llm_providers.json b/agent/src/providers/llm_providers.json
index 94208ba59..a12d6e6c6 100644
--- a/agent/src/providers/llm_providers.json
+++ b/agent/src/providers/llm_providers.json
@@ -40,7 +40,8 @@
"default_base_url": "https://chatgpt.com/backend-api/codex/responses",
"api_key_required": false,
"auth_type": "oauth",
- "login_command": "vibe-trading provider login openai-codex"
+ "login_command": "vibe-trading provider login openai-codex",
+ "reasoning_efforts": ["low", "medium", "high", "xhigh", "max", "ultra"]
},
{
"name": "deepseek",
diff --git a/agent/tests/test_codex_model_discovery.py b/agent/tests/test_codex_model_discovery.py
new file mode 100644
index 000000000..e3b66dda1
--- /dev/null
+++ b/agent/tests/test_codex_model_discovery.py
@@ -0,0 +1,143 @@
+"""Regression tests for ChatGPT Codex OAuth model discovery (no live credentials)."""
+
+from __future__ import annotations
+
+import asyncio
+from types import SimpleNamespace
+
+import httpx
+import pytest
+
+from src.api import settings_routes
+from src.providers import openai_codex
+
+
+REAL_ASYNC_CLIENT = httpx.AsyncClient
+PROVIDER = settings_routes.LLM_PROVIDER_BY_NAME["openai-codex"]
+
+
+def _run(monkeypatch: pytest.MonkeyPatch, handler, *, token=None):
+ """Run discovery against a mock HTTP transport with a fake OAuth session."""
+ real_client = REAL_ASYNC_CLIENT
+ calls = []
+
+ def get_token(**kwargs):
+ calls.append(kwargs)
+ return token or SimpleNamespace(access="fake-test-access", account_id="fake-account")
+
+ monkeypatch.setattr(openai_codex, "_get_codex_token", get_token)
+ monkeypatch.setattr(
+ settings_routes.httpx, "AsyncClient",
+ lambda **kwargs: real_client(transport=httpx.MockTransport(handler), **kwargs),
+ )
+ result = asyncio.run(settings_routes._list_openai_codex_models(PROVIDER))
+ return result, calls
+
+
+def test_catalog_parses_visible_supported_models_and_efforts(monkeypatch):
+ payload = {
+ "models": [
+ {
+ "slug": "gpt-6-sol",
+ "display_name": "GPT-6 Sol",
+ "visibility": "list",
+ "supported_in_api": True,
+ "default_reasoning_level": "medium",
+ "supported_reasoning_levels": [
+ {"effort": "low", "description": "Low"},
+ {"effort": "medium", "description": "Medium"},
+ {"effort": "ultra", "description": "Ultra"},
+ ],
+ },
+ {"slug": "gpt-reserve", "visibility": "hide", "supported_in_api": True},
+ {"slug": "unsupported", "visibility": "list", "supported_in_api": False},
+ {"slug": "gpt-6-sol", "visibility": "list", "supported_in_api": True},
+ {"slug": "bad/name", "visibility": "list", "supported_in_api": True},
+ ],
+ }
+
+ def handler(request):
+ assert request.method == "GET"
+ assert str(request.url) == (
+ "https://chatgpt.com/backend-api/codex/models?client_version=0.159.0"
+ )
+ assert request.headers["authorization"] == "Bearer fake-test-access"
+ assert request.headers["chatgpt-account-id"] == "fake-account"
+ assert request.headers["originator"] == "vibe-trading"
+ return httpx.Response(200, json=payload)
+
+ result, calls = _run(monkeypatch, handler)
+ assert calls == [{}]
+ assert result.source == "provider"
+ assert result.warning_code is None
+ assert result.models == ["openai-codex/gpt-6-sol"]
+ assert result.model_labels == {"openai-codex/gpt-6-sol": "GPT-6 Sol"}
+ assert result.default_effort_levels == {"openai-codex/gpt-6-sol": "medium"}
+ assert result.effort_levels == {
+ "openai-codex/gpt-6-sol": ["low", "medium", "ultra"]
+ }
+
+
+ "payload",
+ [{}, {"models": "incorrect"}, {"models": []}, {"models": [{"slug": "hidden", "visibility": "hide", "supported_in_api": True}]}],
+)
+def test_unusable_catalog_falls_back_without_exposing_payload(monkeypatch, payload):
+ result, _ = _run(monkeypatch, lambda _: httpx.Response(200, json=payload))
+ assert result.source == "default"
+ assert result.warning_code == "model_list_unavailable"
+ assert result.models == [PROVIDER.default_model]
+ assert result.model_labels is None
+
+
+def test_refreshes_once_after_401_with_rejected_token(monkeypatch):
+ seen = []
+ def handler(request):
+ seen.append(request.headers["authorization"])
+ if len(seen) == 1:
+ return httpx.Response(401, text="do not expose response body")
+ return httpx.Response(200, json={
+ "models": [{"slug": "gpt-6-sol", "visibility": "list", "supported_in_api": True}]
+ })
+
+ real_client = REAL_ASYNC_CLIENT
+ calls = []
+ def get_token(**kwargs):
+ calls.append(kwargs)
+ if kwargs.get("force_refresh"):
+ return SimpleNamespace(access="new-access", account_id="fake-account")
+ return SimpleNamespace(access="old-access", account_id="fake-account")
+
+ monkeypatch.setattr(openai_codex, "_get_codex_token", get_token)
+ monkeypatch.setattr(settings_routes.httpx, "AsyncClient",
+ lambda **kwargs: real_client(transport=httpx.MockTransport(handler), **kwargs))
+ result = asyncio.run(settings_routes._list_openai_codex_models(PROVIDER))
+ assert result.source == "provider"
+ assert seen == ["Bearer old-access", "Bearer new-access"]
+ assert calls == [{}, {"force_refresh": True, "rejected_access": "old-access"}]
+
+
+def test_missing_oauth_session_returns_safe_fallback(monkeypatch):
+ def missing(**kwargs):
+ raise RuntimeError("private-token-must-never-be-logged")
+ monkeypatch.setattr(openai_codex, "_get_codex_token", missing)
+ result = asyncio.run(settings_routes._list_openai_codex_models(PROVIDER))
+ assert result.warning_code == "model_list_unavailable"
+ assert "private-token" not in str(result.model_dump())
+
+
+def test_transport_failure_and_redirect_never_leave_codex_host(monkeypatch):
+ for status_code in (302, 403, 500):
+ def handler(request, status_code=status_code):
+ return httpx.Response(
+ status_code,
+ headers={"location": "https://example.org/should-never-follow"}
+ )
+ result, _ = _run(monkeypatch, handler)
+ assert result.warning_code == "model_list_unavailable"
+
+
+def test_codex_provider_accepts_announced_extended_efforts():
+ assert settings_routes.LLM_PROVIDER_BY_NAME["openai-codex"].reasoning_efforts == [
+ "low", "medium", "high", "xhigh", "max", "ultra"
+ ]
diff --git a/agent/tests/test_settings_api.py b/agent/tests/test_settings_api.py
index 1c1e1aaa8..b463d7ac5 100644
--- a/agent/tests/test_settings_api.py
+++ b/agent/tests/test_settings_api.py
@@ -76,13 +76,6 @@ def test_extract_model_ids_normalizes_openai_compatible_payloads() -> None:
{"provider": "openrouter", "base_url": "https://openrouter.ai/api/v1"},
"api_key_required",
),
- (
- {
- "provider": "openai-codex",
- "base_url": "https://chatgpt.com/backend-api/codex/responses",
- },
- "oauth_discovery_unsupported",
- ),
# gh_cli used to build "gh_cli_discovery_unsupported", which the response
# model rejects; it shares the OAuth code instead.
({"provider": "copilot"}, "oauth_discovery_unsupported"),
@@ -913,3 +906,36 @@ def test_other_providers_still_reject_xhigh(client: TestClient) -> None:
response = client.put("/settings/llm", json=payload)
assert response.status_code == 400
+
+
+def test_codex_model_discovery_uses_fixed_oauth_catalog_not_form_url(
+ client: TestClient, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ called = []
+
+ async def fake_catalog(provider):
+ called.append(provider.name)
+ return settings_routes.LLMModelsResponse(
+ provider=provider.name,
+ models=["openai-codex/gpt-6-sol"],
+ source="provider",
+ model_labels={"openai-codex/gpt-6-sol": "GPT-6 Sol"},
+ effort_levels={"openai-codex/gpt-6-sol": ["low", "medium", "ultra"]},
+ default_effort_levels={"openai-codex/gpt-6-sol": "medium"},
+ )
+
+ monkeypatch.setattr(settings_routes, "_list_openai_codex_models", fake_catalog)
+ response = client.post(
+ "/settings/llm/models",
+ json={
+ "provider": "openai-codex",
+ "base_url": "https://untrusted.example/should-not-receive-token",
+ "api_key": "untrusted-form-value",
+ },
+ )
+ assert response.status_code == 200
+ assert called == ["openai-codex"]
+ assert response.json()["models"] == ["openai-codex/gpt-6-sol"]
+ assert response.json()["model_labels"]["openai-codex/gpt-6-sol"] == "GPT-6 Sol"
+ assert response.json()["effort_levels"]["openai-codex/gpt-6-sol"] == ["low", "medium", "ultra"]
+ assert response.json()["default_effort_levels"]["openai-codex/gpt-6-sol"] == "medium"
diff --git a/frontend/src/components/settings/ModelPicker.tsx b/frontend/src/components/settings/ModelPicker.tsx
index 4a8bb7eb8..e3ee41124 100644
--- a/frontend/src/components/settings/ModelPicker.tsx
+++ b/frontend/src/components/settings/ModelPicker.tsx
@@ -4,6 +4,7 @@ import { useEffect, useId, useRef, useState, type KeyboardEvent } from "react";
interface ModelPickerProps {
value: string;
options: string[];
+ labels?: Record<string, string>;
onChange: (value: string) => void;
ariaLabel: string;
optionsAriaLabel: string;
@@ -12,6 +13,7 @@ interface ModelPickerProps {
export function ModelPicker({
value,
options,
+ labels = {},
onChange,
ariaLabel,
optionsAriaLabel,
@@ -67,7 +69,7 @@ export function ModelPicker({
};
return (
- <div ref={rootRef} className="relative min-w-0 flex-1">
+ <div ref={rootRef} className="relative min-w-0 basis-full flex-1 sm:basis-auto">
<div className="relative">
<input
value={value}
@@ -123,7 +125,9 @@ export function ModelPicker({
active ? "bg-muted text-foreground" : "text-foreground hover:bg-muted/70"
}`}
>
- <span className="min-w-0 whitespace-normal break-words font-medium">{model}</span>
+ <span className="min-w-0 flex-1 whitespace-normal break-words font-medium">
+ {labels[model] ? <>{labels[model]} <span className="text-xs font-normal text-muted-foreground">({model})</span></> : model}
+ </span>
<Check className={`h-4 w-4 shrink-0 text-primary ${selected ? "opacity-100" : "opacity-0"}`} />
</button>
);
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index 5d2299cc1..b7df35a1c 100644
--- a/frontend/src/lib/api.ts
+++ b/frontend/src/lib/api.ts
@@ -1005,6 +1005,8 @@ export interface LLMModelsResponse {
| null;
/** Model id -> reasoning effort levels it accepts; empty means none. */
effort_levels?: Record<string, string[]> | null;
+ model_labels?: Record<string, string> | null;
+ default_effort_levels?: Record<string, string> | null;
}
export interface SourceOrderEntry {
diff --git a/frontend/src/pages/Settings.tsx b/frontend/src/pages/Settings.tsx
index 68e690fbb..abb0a87dc 100644
--- a/frontend/src/pages/Settings.tsx
+++ b/frontend/src/pages/Settings.tsx
@@ -49,6 +49,8 @@ export function Settings() {
const [modelsLoading, setModelsLoading] = useState(false);
const [modelListHint, setModelListHint] = useState<string | null>(null);
const [effortLevelsByModel, setEffortLevelsByModel] = useState<Record<string, string[]> | null>(null);
+ const [modelLabels, setModelLabels] = useState<Record<string, string>>({});
+ const [defaultEffortsByModel, setDefaultEffortsByModel] = useState<Record<string, string>>({});
const [localApiKey, setLocalApiKeyState] = useState(() => getApiAuthKey());
const [clearApiKey, setClearApiKey] = useState(false);
const [tushareToken, setTushareToken] = useState("");
@@ -127,6 +129,9 @@ export function Settings() {
});
setModelOptions([provider.default_model]);
setModelListHint(null);
+ setEffortLevelsByModel(null);
+ setModelLabels({});
+ setDefaultEffortsByModel({});
};
const onProviderChange = (name: string) => {
@@ -143,6 +148,8 @@ export function Settings() {
setModelOptions([provider.default_model]);
setModelListHint(null);
setEffortLevelsByModel(null);
+ setModelLabels({});
+ setDefaultEffortsByModel({});
};
// The provider the form shows now; a model list answering for an earlier one
@@ -169,6 +176,8 @@ export function Settings() {
...result.models,
].filter(Boolean))));
setEffortLevelsByModel(result.effort_levels ?? null);
+ setModelLabels(result.model_labels ?? {});
+ setDefaultEffortsByModel(result.default_effort_levels ?? {});
const warningMessages = {
oauth_discovery_unsupported: t("settings.modelDiscoveryOauthUnsupported"),
api_key_required: t("settings.modelDiscoveryApiKeyRequired"),
@@ -423,10 +432,11 @@ export function Settings() {
<label className="grid gap-2">
<span className={labelClass}>{t("settings.model")}</span>
- <div className="flex gap-2">
+ <div className="flex flex-wrap gap-2">
<ModelPicker
value={form.model_name}
options={modelOptions}
+ labels={modelLabels}
onChange={(modelName) => setForm({ ...form, model_name: modelName })}
ariaLabel={t("settings.model")}
optionsAriaLabel={t("settings.modelOptions")}
@@ -579,6 +589,14 @@ export function Settings() {
})}
</select>
<span className={hintClass}>{t("settings.reasoningEffortDesc")}</span>
+ {form.provider === "openai-codex" && defaultEffortsByModel[form.model_name] && (
+ <span className={hintClass}>
+ {t("settings.providerDefault")}:
+ {" "}{effortLabelKey(defaultEffortsByModel[form.model_name])
+ ? t(effortLabelKey(defaultEffortsByModel[form.model_name])!)
+ : defaultEffortsByModel[form.model_name]}
+ </span>
+ )}
{unsupportedEffort && (
<span className={hintClass}>
{t("settings.reasoningEffortReset", {