gpt-codex-client 0.1.0__py3-none-any.whl

gpt_codex_client/__init__.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from ._async_auth import afinish_login, aget_token, alogin, arefresh
+from ._async_client import AsyncCodexClient
+from ._auth import PendingLogin, finish_login, get_token, login, refresh, start_login
+from ._client import CodexClient
+from ._config import Token, build_headers, get_account_id
+from ._errors import (
+    APIConnectionError,
+    APIError,
+    APITimeoutError,
+    AuthError,
+    CodexError,
+    InvalidRequestError,
+    RateLimitError,
+    ServerError,
+    StreamError,
+)
+from ._types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    FunctionTool,
+    Model,
+    ParsedResponse,
+    Reasoning,
+    Response,
+    ResponseStreamEvent,
+    TextConfig,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "APIConnectionError",
+    "APIError",
+    "APITimeoutError",
+    "AsyncCodexClient",
+    "AuthError",
+    "ChatCompletion",
+    "ChatCompletionChunk",
+    "CodexClient",
+    "CodexError",
+    "FunctionTool",
+    "InvalidRequestError",
+    "Model",
+    "ParsedResponse",
+    "PendingLogin",
+    "RateLimitError",
+    "Reasoning",
+    "Response",
+    "ResponseStreamEvent",
+    "ServerError",
+    "StreamError",
+    "TextConfig",
+    "Token",
+    "__version__",
+    "afinish_login",
+    "aget_token",
+    "alogin",
+    "arefresh",
+    "build_headers",
+    "finish_login",
+    "get_account_id",
+    "get_token",
+    "login",
+    "refresh",
+    "start_login",
+]

gpt_codex_client/_async_auth.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from ._auth import (
+    LoginHandler,
+    PendingLogin,
+    _code_from_callback,
+    _token_from_response,
+    start_login,
+)
+from ._config import DEFAULT_TOKEN_PATH, TOKEN_URL, Token, get_client_id, load_token, save_token
+from ._errors import AuthError
+
+
+async def afinish_login(
+    callback_url: str,
+    pending: PendingLogin,
+    *,
+    token_path: str | Path = DEFAULT_TOKEN_PATH,
+    http_client: httpx.AsyncClient | None = None,
+    timeout: float | httpx.Timeout | None = 120.0,
+) -> Token:
+    code = _code_from_callback(callback_url, pending.state)
+    owns_client = http_client is None
+    client = http_client or httpx.AsyncClient(timeout=timeout)
+    try:
+        response = await client.post(
+            TOKEN_URL,
+            data={
+                "grant_type": "authorization_code",
+                "client_id": pending.client_id or get_client_id(),
+                "code": code,
+                "redirect_uri": pending.redirect_uri,
+                "code_verifier": pending.verifier,
+            },
+            timeout=timeout,
+        )
+        token = _token_from_response(response)
+        save_token(token, token_path)
+        return token
+    finally:
+        if owns_client:
+            await client.aclose()
+
+
+async def alogin(
+    *,
+    headless: bool = False,
+    no_browser: bool = False,
+    token_path: str | Path = DEFAULT_TOKEN_PATH,
+    login_handler: LoginHandler | None = None,
+    client_id: str | None = None,
+    http_client: httpx.AsyncClient | None = None,
+    timeout: float | httpx.Timeout | None = 120.0,
+) -> Token:
+    if login_handler is not None:
+        pending = start_login(client_id=client_id)
+        callback_url = login_handler(pending.url)
+        return await afinish_login(
+            callback_url,
+            pending,
+            token_path=token_path,
+            http_client=http_client,
+            timeout=timeout,
+        )
+
+    from ._auth import login
+
+    def run_sync_login() -> Token:
+        return login(
+            headless=headless,
+            no_browser=no_browser,
+            token_path=token_path,
+            login_handler=None,
+            client_id=client_id,
+            timeout=timeout,
+        )
+
+    return await asyncio.to_thread(run_sync_login)
+
+
+async def arefresh(
+    *,
+    token_path: str | Path = DEFAULT_TOKEN_PATH,
+    refresh_token: str | None = None,
+    client_id: str | None = None,
+    http_client: httpx.AsyncClient | None = None,
+    timeout: float | httpx.Timeout | None = 120.0,
+) -> Token:
+    cached = load_token(token_path)
+    resolved_refresh_token = refresh_token or (cached.refresh_token if cached is not None else None)
+    if not resolved_refresh_token:
+        raise AuthError("No refresh token is available")
+
+    owns_client = http_client is None
+    client = http_client or httpx.AsyncClient(timeout=timeout)
+    try:
+        response = await client.post(
+            TOKEN_URL,
+            data={
+                "grant_type": "refresh_token",
+                "client_id": get_client_id(client_id),
+                "refresh_token": resolved_refresh_token,
+            },
+            timeout=timeout,
+        )
+        token = _token_from_response(response)
+        if token.refresh_token is None:
+            token.refresh_token = resolved_refresh_token
+        save_token(token, token_path)
+        return token
+    finally:
+        if owns_client:
+            await client.aclose()
+
+
+async def aget_token(
+    *,
+    token_path: str | Path = DEFAULT_TOKEN_PATH,
+    headless: bool = False,
+    no_browser: bool = False,
+    login_handler: LoginHandler | None = None,
+    client_id: str | None = None,
+    http_client: httpx.AsyncClient | None = None,
+    timeout: float | httpx.Timeout | None = 120.0,
+) -> Token:
+    cached = load_token(token_path)
+    if cached is not None and not cached.is_expired():
+        return cached
+
+    if cached is not None and cached.refresh_token:
+        try:
+            return await arefresh(
+                token_path=token_path,
+                refresh_token=cached.refresh_token,
+                client_id=client_id,
+                http_client=http_client,
+                timeout=timeout,
+            )
+        except AuthError:
+            pass
+
+    return await alogin(
+        headless=headless,
+        no_browser=no_browser,
+        token_path=token_path,
+        login_handler=login_handler,
+        client_id=client_id,
+        http_client=http_client,
+        timeout=timeout,
+    )
+
+
+def _unused(value: Any) -> None:
+    return None

gpt_codex_client/_async_client.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from types import TracebackType
+from typing import Any
+from urllib.parse import urljoin
+
+import httpx
+
+from ._async_auth import aget_token
+from ._async_models import AsyncModelsResource
+from ._async_responses import AsyncResponsesResource
+from ._async_stream import AsyncResponseStream
+from ._auth import LoginHandler
+from ._chat import AsyncChatResource
+from ._config import (
+    DEFAULT_BASE_URL,
+    DEFAULT_TOKEN_PATH,
+    Token,
+    build_headers,
+    get_client_version,
+)
+from ._errors import (
+    APIConnectionError,
+    APIError,
+    APITimeoutError,
+    CodexError,
+    error_from_response,
+    is_retryable_error,
+)
+from ._types import JsonObject
+
+
+class AsyncCodexClient:
+    def __init__(
+        self,
+        *,
+        headless: bool = False,
+        no_browser: bool = False,
+        token_path: str | Path = DEFAULT_TOKEN_PATH,
+        login_handler: LoginHandler | None = None,
+        auth_client_id: str | None = None,
+        client_version: str | None = None,
+        models_manifest_url: str | None = None,
+        timeout: float = 120.0,
+        max_retries: int = 2,
+        default_headers: dict[str, str] | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        base_url: str = DEFAULT_BASE_URL,
+    ) -> None:
+        self.headless = headless
+        self.no_browser = no_browser
+        self.token_path = token_path
+        self.login_handler = login_handler
+        self.auth_client_id = auth_client_id
+        self.client_version = get_client_version(client_version)
+        self.models_manifest_url = models_manifest_url
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.default_headers = default_headers or {}
+        self.base_url = base_url.rstrip("/") + "/"
+        self._http_client = http_client or httpx.AsyncClient(timeout=timeout)
+        self._owns_http_client = http_client is None
+        self._token: Token | None = None
+
+        self.responses = AsyncResponsesResource(self)
+        self.chat = AsyncChatResource(self)
+        self.models = AsyncModelsResource(self, manifest_url=models_manifest_url)
+
+    async def __aenter__(self) -> AsyncCodexClient:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        if self._owns_http_client:
+            await self._http_client.aclose()
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: JsonObject | None = None,
+        timeout: float | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> JsonObject:
+        url = urljoin(self.base_url, path.lstrip("/"))
+        attempts = self.max_retries + 1
+        for attempt in range(attempts):
+            try:
+                response = await self._http_client.request(
+                    method,
+                    url,
+                    json=json,
+                    params=self._params(),
+                    headers=await self._headers(extra_headers),
+                    timeout=timeout or self.timeout,
+                )
+            except httpx.TimeoutException as exc:
+                if attempt + 1 < attempts:
+                    await self._sleep_before_retry(attempt, None)
+                    continue
+                raise APITimeoutError(str(exc)) from exc
+            except httpx.RequestError as exc:
+                if attempt + 1 < attempts:
+                    await self._sleep_before_retry(attempt, None)
+                    continue
+                raise APIConnectionError(str(exc)) from exc
+
+            if response.status_code < 400:
+                return _json_object(response)
+            error = error_from_response(response)
+            if attempt + 1 < attempts and is_retryable_error(error):
+                retry_after = error.retry_after if isinstance(error, APIError) else None
+                await self._sleep_before_retry(attempt, retry_after)
+                continue
+            raise error
+        raise APIConnectionError("Request retry loop exited unexpectedly")
+
+    async def _stream(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: JsonObject | None = None,
+        timeout: float | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> AsyncResponseStream:
+        url = urljoin(self.base_url, path.lstrip("/"))
+        manager = self._http_client.stream(
+            method,
+            url,
+            json=json,
+            params=self._params(),
+            headers=await self._headers(extra_headers),
+            timeout=timeout or self.timeout,
+        )
+        return AsyncResponseStream(manager)
+
+    def _params(self) -> dict[str, str]:
+        return {"client_version": self.client_version}
+
+    async def _headers(self, extra_headers: dict[str, str] | None = None) -> dict[str, str]:
+        token = self._token
+        if token is None or token.is_expired():
+            token = await aget_token(
+                token_path=self.token_path,
+                headless=self.headless,
+                no_browser=self.no_browser,
+                login_handler=self.login_handler,
+                client_id=self.auth_client_id,
+                http_client=self._http_client,
+                timeout=self.timeout,
+            )
+            self._token = token
+        headers = build_headers(token, default_headers=self.default_headers)
+        if extra_headers:
+            headers.update(extra_headers)
+        return headers
+
+    async def _sleep_before_retry(self, attempt: int, retry_after: float | None) -> None:
+        delay = retry_after if retry_after is not None else min(2.0, 0.25 * (2**attempt))
+        await asyncio.sleep(delay)
+
+
+def _json_object(response: httpx.Response) -> JsonObject:
+    if not response.content:
+        return {}
+    try:
+        payload: Any = response.json()
+    except ValueError as exc:
+        raise CodexError("Response was not valid JSON") from exc
+    if not isinstance(payload, dict):
+        raise CodexError("Response JSON was not an object")
+    return payload

gpt_codex_client/_async_models.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import httpx
+
+from ._config import get_models_manifest_url
+from ._errors import (
+    APIConnectionError,
+    APIError,
+    APITimeoutError,
+    CodexError,
+    error_from_response,
+    is_retryable_error,
+)
+from ._models import _models_from_payload
+from ._types import JsonObject, Model
+
+
+class AsyncModelsResource:
+    def __init__(
+        self,
+        client: Any,
+        *,
+        ttl_seconds: float = 300.0,
+        manifest_url: str | None = None,
+    ) -> None:
+        self._client = client
+        self._ttl_seconds = ttl_seconds
+        self._manifest_url = get_models_manifest_url(manifest_url)
+        self._cache: list[Model] | None = None
+        self._cache_at = 0.0
+
+    async def list(
+        self, *, force_refresh: bool = False, timeout: float | None = None
+    ) -> list[Model]:
+        if (
+            not force_refresh
+            and self._cache is not None
+            and time.time() - self._cache_at < self._ttl_seconds
+        ):
+            return list(self._cache)
+        payload = await self._fetch_manifest(timeout=timeout)
+        models = _models_from_payload(payload)
+        self._cache = models
+        self._cache_at = time.time()
+        return list(models)
+
+    async def _fetch_manifest(self, *, timeout: float | None = None) -> JsonObject:
+        attempts = self._client.max_retries + 1
+        for attempt in range(attempts):
+            try:
+                response = await self._client._http_client.get(
+                    self._manifest_url,
+                    headers={"accept": "application/json"},
+                    timeout=timeout or self._client.timeout,
+                )
+            except httpx.TimeoutException as exc:
+                if attempt + 1 < attempts:
+                    await self._client._sleep_before_retry(attempt, None)
+                    continue
+                raise APITimeoutError(str(exc)) from exc
+            except httpx.RequestError as exc:
+                if attempt + 1 < attempts:
+                    await self._client._sleep_before_retry(attempt, None)
+                    continue
+                raise APIConnectionError(str(exc)) from exc
+            if response.status_code < 400:
+                try:
+                    payload = response.json()
+                except ValueError as exc:
+                    raise CodexError("Models manifest response was not valid JSON") from exc
+                if not isinstance(payload, dict):
+                    raise CodexError("Models manifest JSON was not an object")
+                return payload
+            error = error_from_response(response)
+            if attempt + 1 < attempts and is_retryable_error(error):
+                retry_after = error.retry_after if isinstance(error, APIError) else None
+                await self._client._sleep_before_retry(attempt, retry_after)
+                continue
+            raise error
+        raise APIConnectionError("Models manifest retry loop exited unexpectedly")

gpt_codex_client/_async_responses.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from typing import Any, Literal, TypeVar, cast, overload
+
+from ._async_stream import AsyncResponseStream
+from ._converters import response_request_body
+from ._responses import _parse_output, _text_config_for_format
+from ._types import FunctionTool, JsonObject, ParsedResponse, Reasoning, Response, TextConfig
+
+T = TypeVar("T")
+
+
+class AsyncResponsesResource:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    @overload
+    async def create(
+        self,
+        *,
+        model: str,
+        input: str | list[Any],
+        instructions: str | None = None,
+        stream: Literal[False] = False,
+        tools: list[FunctionTool | JsonObject] | None = None,
+        tool_choice: str | JsonObject | None = None,
+        parallel_tool_calls: bool | None = None,
+        reasoning: Reasoning | JsonObject | None = None,
+        text: TextConfig | JsonObject | None = None,
+        include: list[str] | None = None,
+        previous_response_id: str | None = None,
+        timeout: float | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> Response: ...
+
+    @overload
+    async def create(
+        self,
+        *,
+        model: str,
+        input: str | list[Any],
+        instructions: str | None = None,
+        stream: Literal[True],
+        tools: list[FunctionTool | JsonObject] | None = None,
+        tool_choice: str | JsonObject | None = None,
+        parallel_tool_calls: bool | None = None,
+        reasoning: Reasoning | JsonObject | None = None,
+        text: TextConfig | JsonObject | None = None,
+        include: list[str] | None = None,
+        previous_response_id: str | None = None,
+        timeout: float | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> AsyncResponseStream: ...
+
+    async def create(
+        self,
+        *,
+        model: str,
+        input: str | list[Any],
+        instructions: str | None = None,
+        stream: bool = False,
+        tools: list[FunctionTool | JsonObject] | None = None,
+        tool_choice: str | JsonObject | None = None,
+        parallel_tool_calls: bool | None = None,
+        reasoning: Reasoning | JsonObject | None = None,
+        text: TextConfig | JsonObject | None = None,
+        include: list[str] | None = None,
+        previous_response_id: str | None = None,
+        timeout: float | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> Response | AsyncResponseStream:
+        body = response_request_body(
+            model=model,
+            input=input,
+            instructions=instructions,
+            stream=True,
+            tools=tools,
+            tool_choice=tool_choice,
+            parallel_tool_calls=parallel_tool_calls,
+            reasoning=reasoning,
+            text=text,
+            include=include,
+            previous_response_id=previous_response_id,
+        )
+        if stream:
+            return cast(
+                AsyncResponseStream,
+                await self._client._stream(
+                    "POST",
+                    "/responses",
+                    json=body,
+                    timeout=timeout,
+                    extra_headers=extra_headers,
+                ),
+            )
+        response_stream = cast(
+            AsyncResponseStream,
+            await self._client._stream(
+                "POST",
+                "/responses",
+                json=body,
+                timeout=timeout,
+                extra_headers=extra_headers,
+            ),
+        )
+        async with response_stream as opened_stream:
+            async for _event in opened_stream:
+                pass
+            return await opened_stream.get_final_response()
+
+    async def parse(
+        self,
+        *,
+        model: str,
+        input: str | list[Any],
+        text_format: type[T] | JsonObject,
+        instructions: str | None = None,
+        tools: list[FunctionTool | JsonObject] | None = None,
+        tool_choice: str | JsonObject | None = None,
+        parallel_tool_calls: bool | None = None,
+        reasoning: Reasoning | JsonObject | None = None,
+        include: list[str] | None = None,
+        previous_response_id: str | None = None,
+        timeout: float | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ParsedResponse[T]:
+        text_config = _text_config_for_format(text_format)
+        response = await self.create(
+            model=model,
+            input=input,
+            instructions=instructions,
+            tools=tools,
+            tool_choice=tool_choice,
+            parallel_tool_calls=parallel_tool_calls,
+            reasoning=reasoning,
+            text=text_config,
+            include=include,
+            previous_response_id=previous_response_id,
+            timeout=timeout,
+            extra_headers=extra_headers,
+        )
+        if isinstance(response, AsyncResponseStream):
+            raise TypeError("parse() does not support stream=True")
+        return ParsedResponse(
+            response=response, parsed=_parse_output(response.output_text, text_format)
+        )