Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
"""ChatGPT Codex provider backed by shared SDK Responses execution."""
import asyncio
import sys
import uuid
from collections.abc import AsyncIterator, Mapping
from importlib.metadata import PackageNotFoundError, version
from typing import Any
import httpx2
from openai import AsyncOpenAI
from packaging.version import Version
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.core.stream_recovery import ContinuationSeed
from free_claude_code.providers.admission import (
ProviderAdmissionController,
ProviderOperationKind,
)
from free_claude_code.providers.base import BaseProvider, ProviderConfig
from free_claude_code.providers.endpoint import RequestEndpoint
from free_claude_code.providers.failure_policy import provider_authentication_status
from free_claude_code.providers.http import ProviderAttemptScope
from free_claude_code.providers.model_listing import (
optional_input_modalities,
optional_positive_int,
reasoning_capability_from_options,
)
from free_claude_code.providers.openai_client import OpenAIRequestClient
from free_claude_code.providers.openai_responses import OpenAIResponsesTransport
from free_claude_code.providers.request_recovery import RequestRecovery
from .auth import OpenAIAuthManager
from .endpoint import CodexEndpointContext
from .login import OPENAI_CODEX_ORIGINATOR
try:
FCC_VERSION = version("free-claude-code")
except PackageNotFoundError:
FCC_VERSION = "dev"
class OpenAICodexProvider(BaseProvider):
"""Own SDK resources and supply the Codex backend's request requirements."""
def __init__(
self,
config: ProviderConfig,
*,
auth: OpenAIAuthManager,
admission: ProviderAdmissionController,
transport: httpx2.AsyncBaseTransport | None = None,
) -> None:
super().__init__(config)
self._auth = auth
self._admission = admission
self._client_headers = {
"User-Agent": f"{OPENAI_CODEX_ORIGINATOR}/{FCC_VERSION}",
"originator": OPENAI_CODEX_ORIGINATOR,
"version": FCC_VERSION,
}
self._pool = (
transport
if transport is not None
else httpx2.AsyncHTTPTransport(proxy=config.proxy)
)
timeout = httpx2.Timeout(
config.http_read_timeout,
connect=config.http_connect_timeout,
write=config.http_write_timeout,
)
self._client = AsyncOpenAI(
api_key=_endpoint_required,
base_url=config.base_url,
max_retries=0,
timeout=timeout,
http_client=httpx2.AsyncClient(transport=self._pool, timeout=timeout),
)
self._responses = OpenAIResponsesTransport(
client=self._client,
admission=admission,
provider_name="OpenAI",
read_timeout_s=config.http_read_timeout,
log_raw_sse_events=config.log_raw_sse_events,
endpoint_transport=self._pool,
omitted_request_fields=frozenset({"max_output_tokens", "metadata"}),
)
def _endpoint(self, *, session_id: str | None = None) -> CodexEndpointContext:
return CodexEndpointContext(
self._auth,
base_url=self._config.base_url,
headers=self._client_headers,
session_id=session_id,
)
async def cleanup(self) -> None:
await self._client.close()
async def list_model_infos(self) -> frozenset[ProviderModelInfo]:
"""Discover models visible to the currently connected ChatGPT account."""
return _model_infos(await self._list_models_payload())
async def _list_models_payload(self) -> Any:
"""Admit each catalog GET while borrowing request-scoped SDK credentials."""
execution = self._admission.start_execution()
endpoint = RequestEndpoint(self._endpoint())
request_client = OpenAIRequestClient(self._pool)
recovery = RequestRecovery(execution, endpoint=endpoint)
try:
while execution.can_attempt:
scope: ProviderAttemptScope | None = None
try:
client = request_client.for_endpoint(
self._client, await endpoint.resolve()
)
attempt = await execution.open_attempt(
ProviderOperationKind.MODEL_DISCOVERY
)
scope = ProviderAttemptScope(
attempt,
provider_name="OpenAI",
request_id=execution.request_id,
)
payload = await client.get(
"models",
cast_to=object,
options={
"params": {"client_version": _model_list_client_version()}
},
)
await attempt.accept()
execution.succeed()
return payload
except asyncio.CancelledError:
raise
except Exception as error:
if scope is not None:
if await recovery.retry_authentication(
error, provider_authentication_status(error), scope.attempt
):
continue
if not scope.attempt.accepted:
decision = await scope.attempt.fail(error)
if decision.retry_allowed:
continue
execution.fail(error)
raise
finally:
if scope is not None:
await scope.aclose(active_error=sys.exception())
if execution.last_failure is not None:
raise execution.last_failure
raise RuntimeError("OpenAI model discovery ended without an outcome.")
finally:
try:
await request_client.aclose()
finally:
execution.abandon()
def stream_messages(
self,
request: MessagesRequest,
input_tokens: int = 0,
*,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
request_headers: Mapping[str, str] | None = None,
model_info: ProviderModelInfo | None = None,
continuation: ContinuationSeed | None = None,
) -> AsyncIterator[str]:
return self._responses.stream_messages(
request,
input_tokens=input_tokens,
request_id=request_id,
response_model=response_model or request.model,
reasoning=reasoning,
endpoint_context=self._endpoint(session_id=str(uuid.uuid4())),
model_info=model_info,
continuation=continuation,
)
def stream_responses(
self,
request: OpenAIResponsesRequest,
input_tokens: int = 0,
*,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
request_headers: Mapping[str, str] | None = None,
model_info: ProviderModelInfo | None = None,
continuation: ContinuationSeed | None = None,
) -> AsyncIterator[str]:
return self._responses.stream_responses(
request,
input_tokens=input_tokens,
request_id=request_id,
response_model=response_model or request.model,
reasoning=reasoning,
endpoint_context=self._endpoint(session_id=str(uuid.uuid4())),
continuation=continuation,
)
def _model_list_client_version() -> str:
"""Format FCC's release and VCS development versions for the catalog API."""
if FCC_VERSION == "dev":
return "0.0.0-dev"
parsed = Version(FCC_VERSION)
formatted = f"{parsed.major}.{parsed.minor}.{parsed.micro}"
if parsed.dev is not None:
formatted += f"-dev.{parsed.dev}"
if parsed.local is not None:
formatted += f"+{parsed.local}"
return formatted
async def _endpoint_required() -> str:
raise RuntimeError(
"Codex requests require request-scoped subscription credentials."
)
def _model_infos(payload: Any) -> frozenset[ProviderModelInfo]:
if not isinstance(payload, dict) or not isinstance(payload.get("models"), list):
raise ValueError("OpenAI model-list response is missing the models array.")
infos: set[ProviderModelInfo] = set()
for model in payload["models"]:
if not isinstance(model, dict):
continue
model_id = model.get("slug")
visibility = model.get("visibility")
if (
not isinstance(model_id, str)
or not model_id.strip()
or visibility != "list"
):
continue
efforts = model.get(
"supported_reasoning_levels",
model.get("supported_reasoning_efforts"),
)
infos.add(
ProviderModelInfo(
model_id=model_id,
supports_thinking=_supports_reasoning(efforts),
reasoning_capability=reasoning_capability_from_options(
{
"supported_efforts": [level["effort"] for level in efforts]
if _supports_reasoning(efforts) is not None
else None,
}
),
input_modalities=optional_input_modalities(
model.get("input_modalities")
),
context_window_tokens=optional_positive_int(
model.get("context_window")
),
)
)
if not infos:
raise ValueError("OpenAI did not advertise any visible models.")
return frozenset(infos)
def _supports_reasoning(levels: object) -> bool | None:
if not isinstance(levels, list):
return None
for level in levels:
if not isinstance(level, dict):
return None
effort = level.get("effort")
if not isinstance(effort, str) or not effort.strip():
return None
return bool(levels)