Files
openworker/tests/test_codex_provider.py
T
Devika Verma be8f71a859 fix(models): the catalog says what the vendors' own lists said on 2026-11-09 (OPE-252)
Rows re-read against each provider's model list (survey 2b.6) and the vendor docs read on 2026-11-10:

- ChatGPT plan: exactly the three ids the subscription backend lists (gpt-6-luna, gpt-5.6-terra, gpt-5.6-luna), 272K each; the five it does not serve leave untested. The provider's default becomes gpt-5.6-terra and the sign-in probe uses gpt-5.6-luna.
- DeepSeek: the Flash id is deepseek-flash (deepseek-v4-flash is not served); both rows 1,048,576 with a 393,216 output cap; Flash reads images.
- MiniMax: M2.5 is closed to new users and retires on 2026-11-18; the rows are M3.1 Flash and M3 at 1M, and the recommendation moves to M3.1 Flash.
- Fireworks: none of the four curated ids is served any more; the rows are glm-5p3, kimi-k3 and deepseek-v4p1-flash at 1,048,576.
- Kimi K2.6 262,144 and images; Mistral Large 262,144 and images, plus Mistral Large 4 at 1,048,576; Cohere Command A+ 436,000 and images; Grok 4.3 1,000,000 and images.
- OpenAI gains GPT-6 Astra (1,050,000, 128K output); Anthropic gains the Claude 5.5 family, and Opus 4.6, Opus 4.8 and Sonnet 4.6 take the 1M figure the vendor's list reports.

Serial 2026.11.10.1 retires the migration snapshot gate. The registry, the compat suggestion lists and the tests that pinned the old ids follow.
2026-11-17 18:38:30 +05:30

637 lines
23 KiB
Python

"""ChatGPT-subscription provider (`openai-codex`): PKCE flow, token storage +
refresh, backend request shape, failure modes, and the REST surface. No live
network — the token endpoint, the SDK client, and the verify probe are all faked;
the loopback callback server is exercised for real on its fixed port."""
from __future__ import annotations
import asyncio
import base64
import json
import socket
import time
from types import SimpleNamespace
from urllib.parse import parse_qs, urlsplit
import pytest
from fastapi.testclient import TestClient
from coworker.providers import codex_auth
from coworker.providers.codex_auth import (
CODEX_BASE_URL,
CodexAuthError,
CodexSignInRequired,
CodexTokenStore,
account_id_from,
build_authorize_url,
create_pkce,
)
from coworker.providers.codex_provider import CodexProvider
from coworker.secrets import SecretStore
from coworker.server.app import create_app
from coworker.server.manager import SessionManager
ACCOUNT_CLAIM = "https://api.openai.com/auth"
def _jwt(claims: dict) -> str:
def b64(obj) -> str:
raw = json.dumps(obj).encode()
return base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
return f"{b64({'alg': 'none'})}.{b64(claims)}.sig"
def _access(exp_offset: float = 3600, account: str = "acct_1") -> str:
return _jwt(
{"exp": time.time() + exp_offset, ACCOUNT_CLAIM: {"chatgpt_account_id": account}}
)
def _id_token(email: str = "user@example.com", account: str = "acct_1") -> str:
return _jwt({"email": email, ACCOUNT_CLAIM: {"chatgpt_account_id": account}})
def _token_response(status: int = 200, body: dict | None = None):
return SimpleNamespace(status_code=status, json=lambda: body or {})
def _seed(secrets, exp_offset: float = 3600) -> None:
CodexTokenStore(secrets).save(
{
"access_token": _access(exp_offset),
"refresh_token": "rt-1",
"id_token": _id_token(),
}
)
# -- PKCE / authorize URL -----------------------------------------------------------
def test_pkce_challenge_is_s256_of_verifier():
import hashlib
verifier, challenge = create_pkce()
expected = (
base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest())
.rstrip(b"=")
.decode()
)
assert challenge == expected
assert create_pkce()[0] != verifier # fresh randomness per flow
def test_authorize_url_shape():
url = build_authorize_url("st4te", "ch4llenge")
parts = urlsplit(url)
assert f"{parts.scheme}://{parts.netloc}{parts.path}" == codex_auth.AUTHORIZE_URL
q = {k: v[0] for k, v in parse_qs(parts.query).items()}
assert q["response_type"] == "code"
assert q["client_id"] == codex_auth.CLIENT_ID
assert q["redirect_uri"] == "http://localhost:1455/auth/callback"
assert q["state"] == "st4te"
assert q["code_challenge"] == "ch4llenge"
assert q["code_challenge_method"] == "S256"
assert q["codex_cli_simplified_flow"] == "true"
assert q["originator"] == codex_auth.ORIGINATOR
def test_account_id_from_token_claim():
tokens = {"id_token": _id_token(account="acct_9")}
assert account_id_from(tokens) == "acct_9"
# Falls back to the access token, and to the plain account_id key.
tokens = {"access_token": _jwt({ACCOUNT_CLAIM: {"account_id": "acct_x"}})}
assert account_id_from(tokens) == "acct_x"
assert account_id_from({"access_token": "not-a-jwt"}) == ""
# -- sign-in flow (loopback callback → exchange → storage) --------------------------
async def _hit_callback(query: str) -> str:
reader, writer = await asyncio.open_connection("127.0.0.1", codex_auth.CALLBACK_PORT)
writer.write(
f"GET /auth/callback?{query} HTTP/1.1\r\nHost: localhost\r\n\r\n".encode()
)
await writer.drain()
data = await reader.read(-1)
writer.close()
return data.decode()
def test_callback_host_defaults_to_loopback(monkeypatch):
monkeypatch.delenv(codex_auth.CALLBACK_HOST_ENV, raising=False)
assert codex_auth.callback_host() == "127.0.0.1"
# Empty is not a bind address — a blank env var must not become "listen
# everywhere", which is the one mistake here that widens exposure silently.
monkeypatch.setenv(codex_auth.CALLBACK_HOST_ENV, "")
assert codex_auth.callback_host() == "127.0.0.1"
class _FakeServer:
sockets: tuple = ()
def close(self):
pass
async def wait_closed(self):
pass
async def _bind_host_used(monkeypatch) -> str:
"""The address `_start_callback_server` actually asks asyncio to listen on.
Asserted through the call rather than by binding for real: the port is fixed at
1455, so a machine running the Codex CLI (its usual holder) or a container
publishing that port would otherwise fail this test for unrelated reasons.
"""
seen: dict = {}
async def fake_start_server(handler, host, port):
seen.update(host=host, port=port)
return _FakeServer()
monkeypatch.setattr(codex_auth.asyncio, "start_server", fake_start_server)
server, future = await codex_auth._start_callback_server("state-1")
future.cancel()
assert seen["port"] == codex_auth.CALLBACK_PORT
return seen["host"]
async def test_callback_server_binds_loopback_by_default(monkeypatch):
monkeypatch.delenv(codex_auth.CALLBACK_HOST_ENV, raising=False)
assert await _bind_host_used(monkeypatch) == "127.0.0.1"
async def test_callback_server_honours_the_bind_override(monkeypatch):
"""A container publishes a port to its external interface; a server bound to the
container's own loopback never sees that traffic, so the redirect lands on a closed
port. The registered redirect URI is unaffected — it says where the BROWSER goes."""
monkeypatch.setenv(codex_auth.CALLBACK_HOST_ENV, "0.0.0.0")
assert await _bind_host_used(monkeypatch) == "0.0.0.0"
assert codex_auth.REDIRECT_URI == "http://localhost:1455/auth/callback"
async def test_sign_in_full_flow(tmp_path, monkeypatch):
secrets = SecretStore(tmp_path / "s.json")
opened: dict = {}
exchanged: dict = {}
monkeypatch.setattr("webbrowser.open", lambda url: opened.update(url=url))
def fake_token_post(data, timeout=30.0):
exchanged.update(data)
return _token_response(
body={
"access_token": _access(),
"refresh_token": "rt-1",
"id_token": _id_token("user@example.com"),
}
)
monkeypatch.setattr(codex_auth, "_token_post", fake_token_post)
task = asyncio.create_task(codex_auth.sign_in(secrets))
while not opened: # wait for the flow to bind the port and "open" the browser
await asyncio.sleep(0.01)
state = parse_qs(urlsplit(opened["url"]).query)["state"][0]
# A forged local hit with the wrong state is rejected and does NOT consume the flow.
resp = await _hit_callback("code=evil&state=wrong")
assert resp.startswith("HTTP/1.1 400")
assert not task.done()
resp = await _hit_callback(f"code=c0de&state={state}")
assert resp.startswith("HTTP/1.1 200") and "close this tab" in resp.lower()
result = await task
assert result == {"ok": True, "account": "user@example.com"}
assert exchanged["grant_type"] == "authorization_code"
assert exchanged["code"] == "c0de"
assert exchanged["redirect_uri"] == "http://localhost:1455/auth/callback"
assert exchanged["code_verifier"]
profile = secrets.get("provider:openai-codex")
assert profile["tokens"]["refresh_token"] == "rt-1"
assert profile["account_id"] == "acct_1"
assert profile["account_email"] == "user@example.com"
assert isinstance(profile["tokens_issued_at"], int)
async def test_sign_in_provider_error_from_callback(tmp_path, monkeypatch):
secrets = SecretStore(tmp_path / "s.json")
opened: dict = {}
monkeypatch.setattr("webbrowser.open", lambda url: opened.update(url=url))
task = asyncio.create_task(codex_auth.sign_in(secrets))
while not opened:
await asyncio.sleep(0.01)
resp = await _hit_callback("error=access_denied")
assert resp.startswith("HTTP/1.1 400")
with pytest.raises(CodexAuthError, match="access_denied"):
await task
assert not CodexTokenStore(secrets).signed_in()
async def test_sign_in_port_busy_names_the_usual_holder(tmp_path):
secrets = SecretStore(tmp_path / "s.json")
blocker = socket.socket()
blocker.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
blocker.bind(("127.0.0.1", codex_auth.CALLBACK_PORT))
blocker.listen(1)
with pytest.raises(CodexAuthError, match="1455"):
await codex_auth.sign_in(secrets, open_browser=False)
finally:
blocker.close()
# -- token store: refresh ------------------------------------------------------------
def test_access_token_fresh_needs_no_refresh(tmp_path, monkeypatch):
secrets = SecretStore(tmp_path / "s.json")
_seed(secrets)
monkeypatch.setattr(
codex_auth, "_token_post", lambda *a, **k: pytest.fail("refresh not needed")
)
token, account = CodexTokenStore(secrets).access_token()
assert token == secrets.get("provider:openai-codex")["tokens"]["access_token"]
assert account == "acct_1"
def test_access_token_refreshes_near_expiry(tmp_path, monkeypatch):
secrets = SecretStore(tmp_path / "s.json")
_seed(secrets, exp_offset=30) # inside the refresh margin
sent: dict = {}
fresh = _access(7200)
def fake_token_post(data, timeout=30.0):
sent.update(data)
return _token_response(body={"access_token": fresh})
monkeypatch.setattr(codex_auth, "_token_post", fake_token_post)
token, account = CodexTokenStore(secrets).access_token()
assert token == fresh and account == "acct_1"
assert sent == {
"grant_type": "refresh_token",
"refresh_token": "rt-1",
"client_id": codex_auth.CLIENT_ID,
}
profile = secrets.get("provider:openai-codex")
# The refresh response omitted refresh/id tokens — prior values survive.
assert profile["tokens"]["access_token"] == fresh
assert profile["tokens"]["refresh_token"] == "rt-1"
def test_rejected_refresh_blanks_tokens_to_signed_out(tmp_path, monkeypatch):
secrets = SecretStore(tmp_path / "s.json")
_seed(secrets, exp_offset=-10)
monkeypatch.setattr(
codex_auth, "_token_post", lambda *a, **k: _token_response(status=400)
)
store = CodexTokenStore(secrets)
with pytest.raises(CodexSignInRequired):
store.access_token()
assert not store.signed_in() # clean signed-out state, not a crash loop
def test_access_token_signed_out_raises_typed_error(tmp_path):
store = CodexTokenStore(SecretStore(tmp_path / "s.json"))
with pytest.raises(CodexSignInRequired, match="Not signed in"):
store.access_token()
# -- provider: request shape to the backend -----------------------------------------
class _FakeSDKClient:
def __init__(self, events=None, errors=None):
self.kwargs: dict = {}
errors = list(errors or [])
def create(**kwargs):
self.kwargs = kwargs
if errors:
raise errors.pop(0)
return iter(events or [])
self.responses = SimpleNamespace(create=create)
def _completed_event(text="hello"):
return SimpleNamespace(
type="response.completed",
response=SimpleNamespace(
output=[
{
"type": "message",
"role": "assistant",
"content": [{"type": "output_text", "text": text}],
}
],
status="completed",
incomplete_details=None,
),
)
def _status_error(status: int, message: str = ""):
exc = Exception(message or f"HTTP {status}")
exc.status_code = status
return exc
def _provider(tmp_path, monkeypatch, clients):
"""A CodexProvider over seeded tokens whose SDK clients come from `clients`
(each OpenAI() construction pops the next one and records its init kwargs)."""
secrets = SecretStore(tmp_path / "s.json")
_seed(secrets)
built: list[dict] = []
def fake_openai(**kwargs):
built.append(kwargs)
return clients.pop(0)
monkeypatch.setattr("openai.OpenAI", fake_openai)
return CodexProvider(secrets=secrets), secrets, built
def test_stream_request_headers_and_body(tmp_path, monkeypatch):
fake = _FakeSDKClient(events=[_completed_event()])
provider, secrets, built = _provider(tmp_path, monkeypatch, [fake])
out = list(
provider.stream(
model="gpt-5.2-codex",
messages=[
{"role": "system", "content": "sys"},
{"role": "user", "content": "hi"},
],
tools=[{"type": "function", "function": {"name": "f"}}],
)
)
assert built[0]["api_key"] == secrets.get("provider:openai-codex")["tokens"][
"access_token"
]
assert built[0]["base_url"] == CODEX_BASE_URL
headers = built[0]["default_headers"]
assert headers["chatgpt-account-id"] == "acct_1"
assert headers["originator"] == codex_auth.ORIGINATOR
assert headers["OpenAI-Beta"] == "responses=experimental"
assert headers["session-id"] # per-conversation uuid
assert fake.kwargs["model"] == "gpt-5.2-codex"
assert fake.kwargs["stream"] is True
assert fake.kwargs["store"] is False
assert fake.kwargs["include"] == ["reasoning.encrypted_content"]
assert fake.kwargs["instructions"] == "sys"
assert fake.kwargs["tools"] == [{"type": "function", "name": "f"}]
assert out[-1].turn.text == "hello"
def test_complete_goes_through_stream_and_reasoning_effort_rides(tmp_path, monkeypatch):
fake = _FakeSDKClient(events=[_completed_event("done")])
provider, _, _ = _provider(tmp_path, monkeypatch, [fake])
turn = provider.complete(
model="gpt-5.2-codex",
messages=[{"role": "user", "content": "hi"}],
reasoning_effort="high",
)
assert turn.text == "done"
assert fake.kwargs["stream"] is True # the backend only serves streams
assert fake.kwargs["reasoning"] == {"summary": "auto", "effort": "high"}
assert fake.kwargs["instructions"] # bare-call fallback instructions present
def test_401_refreshes_once_and_retries_with_new_bearer(tmp_path, monkeypatch):
first = _FakeSDKClient(errors=[_status_error(401, "Unauthorized")])
second = _FakeSDKClient(events=[_completed_event("after refresh")])
provider, secrets, built = _provider(tmp_path, monkeypatch, [first, second])
fresh = _access(7200)
monkeypatch.setattr(
codex_auth,
"_token_post",
lambda *a, **k: _token_response(body={"access_token": fresh}),
)
turn = provider.complete(
model="gpt-5.2-codex", messages=[{"role": "user", "content": "hi"}]
)
assert turn.text == "after refresh"
assert len(built) == 2 and built[1]["api_key"] == fresh
def test_429_surfaces_plan_limit_message(tmp_path, monkeypatch):
fake = _FakeSDKClient(errors=[_status_error(429, "Too Many Requests")])
provider, _, _ = _provider(tmp_path, monkeypatch, [fake])
with pytest.raises(RuntimeError, match="plan limit"):
provider.complete(
model="gpt-5.2-codex", messages=[{"role": "user", "content": "hi"}]
)
def test_signed_out_provider_raises_typed_error(tmp_path):
provider = CodexProvider(secrets=SecretStore(tmp_path / "s.json"))
with pytest.raises(CodexSignInRequired, match="Not signed in"):
provider.complete(
model="gpt-5.2-codex", messages=[{"role": "user", "content": "hi"}]
)
# -- registry / matrix ---------------------------------------------------------------
def test_registry_builds_codex_provider():
from coworker.providers.registry import build_provider_client, get_descriptor
assert isinstance(build_provider_client("openai-codex", {}, None), CodexProvider)
d = get_descriptor("openai-codex")
assert d.auth == "oauth" and d.fields == []
assert d.to_dict()["auth"] == "oauth"
def test_descriptor_configured_means_tokens_present():
from coworker.providers.registry import descriptor_configured, get_descriptor
d = get_descriptor("openai-codex")
assert not descriptor_configured(d, {})
assert descriptor_configured(d, {"tokens": {"access_token": "a"}})
def test_matrix_curates_subscription_models():
from coworker.providers.capabilities import capabilities_for
from coworker.providers.matrix import models_for_provider
# Exactly what the subscription backend listed on 2026-11-09, 272K each; the ids it does
# not serve (Sol, the 5.2 and 5.1 Codex rows) left the catalog untested (OPE-252).
assert models_for_provider("openai-codex") == [
"gpt-6-luna",
"gpt-5.6-terra",
"gpt-5.6-luna",
]
caps = capabilities_for("openai-codex:gpt-5.6-terra")
assert caps.tools and caps.vision and caps.streaming
# -- verify probe --------------------------------------------------------------------
def _verify_with_backend(tmp_path, monkeypatch, status: int):
secrets = SecretStore(tmp_path / "s.json")
_seed(secrets)
probes: dict = {}
def fake_post(url, headers=None, json=None, timeout=None):
probes.update(url=url, headers=headers, body=json)
return SimpleNamespace(status_code=status)
monkeypatch.setattr("httpx.post", fake_post)
return codex_auth.verify(secrets), probes
def test_verify_signed_out(tmp_path):
result = codex_auth.verify(SecretStore(tmp_path / "s.json"))
assert result["ok"] is False and result["state"] == "signed_out"
def test_verify_ok_probes_backend(tmp_path, monkeypatch):
result, probes = _verify_with_backend(tmp_path, monkeypatch, 200)
assert result == {"ok": True, "account": "user@example.com"}
assert probes["url"] == CODEX_BASE_URL + "/responses"
assert probes["headers"]["Authorization"].startswith("Bearer ")
assert probes["headers"]["chatgpt-account-id"] == "acct_1"
assert probes["body"]["store"] is False and probes["body"]["stream"] is True
def test_verify_expired_and_plan_limited(tmp_path, monkeypatch):
result, _ = _verify_with_backend(tmp_path, monkeypatch, 401)
assert result["ok"] is False and result["state"] == "expired"
result, _ = _verify_with_backend(tmp_path, monkeypatch, 429)
assert result["ok"] is True and "note" in result # auth fine, window used up
# -- REST surface --------------------------------------------------------------------
def _rest(tmp_path):
manager = SessionManager(data_dir=tmp_path / "data")
return manager, TestClient(create_app(manager))
def test_providers_list_shows_oauth_state(tmp_path):
manager, client = _rest(tmp_path)
rows = {p["name"]: p for p in client.get("/v1/providers").json()}
row = rows["openai-codex"]
assert row["auth"] == "oauth"
assert row["signed_in"] is False and row["configured"] is False
assert "gpt-5.6-terra" in row["suggested_models"]
manager.secrets.put(
"provider:openai-codex",
{"tokens": {"access_token": "a", "refresh_token": "r"}, "account_email": "u@x.com"},
)
row = {p["name"]: p for p in client.get("/v1/providers").json()}["openai-codex"]
assert row["signed_in"] is True and row["configured"] is True
assert row["account"] == "u@x.com"
assert "tokens" not in row.get("values", {}) # secrets never leave the store
def test_signin_route_starts_background_flow(tmp_path, monkeypatch):
manager, _ = _rest(tmp_path)
seen = {}
async def fake_signin():
seen["called"] = True
return {"ok": True}
monkeypatch.setattr(manager, "codex_signin", fake_signin)
client = TestClient(create_app(manager))
assert client.post("/v1/providers/openai-codex/signin").json() == {
"ok": True,
"started": True,
}
assert seen["called"]
# begin_codex_signin flagged before the task ran, so the very first status
# poll after the button press already shows authorizing.
assert manager._codex_authorizing is True
def test_status_and_signout_routes(tmp_path):
manager, client = _rest(tmp_path)
status = client.get("/v1/providers/openai-codex/status").json()
assert status["signed_in"] is False and status["authorizing"] is False
manager.secrets.put(
"provider:openai-codex",
{"tokens": {"access_token": "a"}, "account_email": "u@x.com"},
)
status = client.get("/v1/providers/openai-codex/status").json()
assert status["signed_in"] is True and status["account"] == "u@x.com"
assert client.post("/v1/providers/openai-codex/signout").json() == {
"ok": True,
"had_tokens": True,
}
assert client.get("/v1/providers/openai-codex/status").json()["signed_in"] is False
def test_verify_route_reports_signed_out(tmp_path):
_, client = _rest(tmp_path)
result = client.post("/v1/providers/verify", json={"name": "openai-codex"}).json()
assert result["ok"] is False and result["state"] == "signed_out"
async def test_manager_signin_stores_and_promotes_model(tmp_path, monkeypatch):
manager, _ = _rest(tmp_path)
async def fake_sign_in(secrets, **kwargs):
CodexTokenStore(secrets).save(
{
"access_token": _access(),
"refresh_token": "rt-1",
"id_token": _id_token(),
}
)
return {"ok": True, "account": "user@example.com"}
monkeypatch.setattr(codex_auth, "sign_in", fake_sign_in)
result = await manager.codex_signin()
assert result["ok"] is True
assert manager._codex_authorizing is False
settings = manager.get_settings()
assert "openai-codex:gpt-5.6-sol" in settings["models"]
async def test_manager_signin_failure_lands_in_status(tmp_path, monkeypatch):
manager, client = _rest(tmp_path)
async def fake_sign_in(secrets, **kwargs):
raise CodexAuthError("Port 1455 is already in use — quit the other holder.")
monkeypatch.setattr(codex_auth, "sign_in", fake_sign_in)
result = await manager.codex_signin()
assert result["ok"] is False
status = client.get("/v1/providers/openai-codex/status").json()
assert "1455" in status["last_error"]
assert status["authorizing"] is False
def test_request_strips_backend_unsupported_params(tmp_path):
# The plan backend 400s on standard sampling/cap knobs ("Unsupported parameter:
# max_output_tokens" / "temperature") — which silently killed every autotitle attempt
# on plan sessions (owner catch 2026-08-24). The provider strips them; the reasoning
# effort knob still rides.
from coworker.secrets import SecretStore
provider = CodexProvider(secrets=SecretStore(tmp_path / "s.json"))
kwargs = provider._request_kwargs(
model="gpt-5.6-sol",
messages=[{"role": "user", "content": "hi"}],
tools=None,
settings={"max_tokens": 64, "temperature": 0.2, "top_p": 0.9, "reasoning_effort": "none"},
)
assert "max_output_tokens" not in kwargs
assert "temperature" not in kwargs
assert "top_p" not in kwargs
assert kwargs["reasoning"]["effort"] == "none"