codex-lb 0.3.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

app/core/openai/requests.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from app.core.types import JsonObject, JsonValue
 
@@ -35,17 +35,25 @@ class ResponsesRequest(BaseModel):
     instructions: str
     input: list[JsonValue]
     tools: list[JsonValue] = Field(default_factory=list)
-    tool_choice: str | None = None
+    tool_choice: str | dict[str, JsonValue] | None = None
     parallel_tool_calls: bool | None = None
     reasoning: ResponsesReasoning | None = None
-    store: bool | None = None
+    store: bool = False
     stream: bool | None = None
     include: list[str] = Field(default_factory=list)
     prompt_cache_key: str | None = None
     text: ResponsesTextControls | None = None
 
+    @field_validator("store")
+    @classmethod
+    def _ensure_store_false(cls, value: bool | None) -> bool:
+        if value is True:
+            raise ValueError("store must be false")
+        return False if value is None else value
+
     def to_payload(self) -> JsonObject:
-        return self.model_dump(mode="json", exclude_none=True)
+        payload = self.model_dump(mode="json", exclude_none=True)
+        return _strip_unsupported_fields(payload)
 
 
 class ResponsesCompactRequest(BaseModel):
@@ -56,4 +64,14 @@ class ResponsesCompactRequest(BaseModel):
     input: list[JsonValue]
 
     def to_payload(self) -> JsonObject:
-        return self.model_dump(mode="json", exclude_none=True)
+        payload = self.model_dump(mode="json", exclude_none=True)
+        return _strip_unsupported_fields(payload)
+
+
+_UNSUPPORTED_UPSTREAM_FIELDS = {"max_output_tokens"}
+
+
+def _strip_unsupported_fields(payload: dict[str, JsonValue]) -> dict[str, JsonValue]:
+    for key in _UNSUPPORTED_UPSTREAM_FIELDS:
+        payload.pop(key, None)
+    return payload

app/core/openai/v1_requests.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+from app.core.openai.message_coercion import coerce_messages
+from app.core.openai.requests import (
+    ResponsesCompactRequest,
+    ResponsesReasoning,
+    ResponsesRequest,
+    ResponsesTextControls,
+)
+from app.core.types import JsonValue
+
+
+class V1ResponsesRequest(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    model: str = Field(min_length=1)
+    messages: list[JsonValue] | None = None
+    input: list[JsonValue] | None = None
+    instructions: str | None = None
+    tools: list[JsonValue] = Field(default_factory=list)
+    tool_choice: str | dict[str, JsonValue] | None = None
+    parallel_tool_calls: bool | None = None
+    reasoning: ResponsesReasoning | None = None
+    store: bool | None = None
+    stream: bool | None = None
+    include: list[str] = Field(default_factory=list)
+    prompt_cache_key: str | None = None
+    text: ResponsesTextControls | None = None
+
+    @field_validator("store")
+    @classmethod
+    def _ensure_store_false(cls, value: bool | None) -> bool | None:
+        if value is True:
+            raise ValueError("store must be false")
+        return value
+
+    @model_validator(mode="after")
+    def _validate_input(self) -> "V1ResponsesRequest":
+        if self.messages is None and self.input is None:
+            raise ValueError("Provide either 'input' or 'messages'.")
+        if self.messages is not None and self.input not in (None, []):
+            raise ValueError("Provide either 'input' or 'messages', not both.")
+        return self
+
+    def to_responses_request(self) -> ResponsesRequest:
+        data = self.model_dump(mode="json", exclude_none=True)
+        messages = data.pop("messages", None)
+        instructions = data.get("instructions")
+        instruction_text = instructions if isinstance(instructions, str) else ""
+        input_value = data.get("input")
+        input_items: list[JsonValue] = input_value if isinstance(input_value, list) else []
+
+        if messages is not None:
+            instruction_text, input_items = coerce_messages(instruction_text, messages)
+
+        data["instructions"] = instruction_text
+        data["input"] = input_items
+        return ResponsesRequest.model_validate(data)
+
+
+class V1ResponsesCompactRequest(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    model: str = Field(min_length=1)
+    messages: list[JsonValue] | None = None
+    input: list[JsonValue] | None = None
+    instructions: str | None = None
+
+    @model_validator(mode="after")
+    def _validate_input(self) -> "V1ResponsesCompactRequest":
+        if self.messages is None and self.input is None:
+            raise ValueError("Provide either 'input' or 'messages'.")
+        if self.messages is not None and self.input not in (None, []):
+            raise ValueError("Provide either 'input' or 'messages', not both.")
+        return self
+
+    def to_compact_request(self) -> ResponsesCompactRequest:
+        data = self.model_dump(mode="json", exclude_none=True)
+        messages = data.pop("messages", None)
+        instructions = data.get("instructions")
+        instruction_text = instructions if isinstance(instructions, str) else ""
+        input_value = data.get("input")
+        input_items: list[JsonValue] = input_value if isinstance(input_value, list) else []
+
+        if messages is not None:
+            instruction_text, input_items = coerce_messages(instruction_text, messages)
+
+        data["instructions"] = instruction_text
+        data["input"] = input_items
+        return ResponsesCompactRequest.model_validate(data)

app/db/models.py

@@ -48,7 +48,7 @@ class UsageHistory(Base):
     __tablename__ = "usage_history"
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    account_id: Mapped[str] = mapped_column(String, ForeignKey("accounts.id"), nullable=False)
+    account_id: Mapped[str] = mapped_column(String, ForeignKey("accounts.id", ondelete="CASCADE"), nullable=False)
     recorded_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now(), nullable=False)
     window: Mapped[str | None] = mapped_column(String, nullable=True)
     used_percent: Mapped[float] = mapped_column(Float, nullable=False)
@@ -65,7 +65,7 @@ class RequestLog(Base):
     __tablename__ = "request_logs"
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    account_id: Mapped[str] = mapped_column(String, ForeignKey("accounts.id"), nullable=False)
+    account_id: Mapped[str] = mapped_column(String, ForeignKey("accounts.id", ondelete="CASCADE"), nullable=False)
     request_id: Mapped[str] = mapped_column(String, nullable=False)
     requested_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now(), nullable=False)
     model: Mapped[str] = mapped_column(String, nullable=False)
@@ -84,7 +84,7 @@ class StickySession(Base):
     __tablename__ = "sticky_sessions"
 
     key: Mapped[str] = mapped_column(String, primary_key=True)
-    account_id: Mapped[str] = mapped_column(String, ForeignKey("accounts.id"), nullable=False)
+    account_id: Mapped[str] = mapped_column(String, ForeignKey("accounts.id", ondelete="CASCADE"), nullable=False)
     created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.now(), nullable=False)
     updated_at: Mapped[datetime] = mapped_column(
         DateTime,

app/db/session.py

@@ -13,7 +13,7 @@ from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_asyn
 from app.core.config.settings import get_settings
 from app.db.migrations import run_migrations
 
-DATABASE_URL = get_settings().database_url
+_settings = get_settings()
 
 logger = logging.getLogger(__name__)
 
@@ -43,15 +43,32 @@ def _configure_sqlite_engine(engine: Engine, *, enable_wal: bool) -> None:
             cursor.close()
 
 
-if _is_sqlite_url(DATABASE_URL):
+if _is_sqlite_url(_settings.database_url):
+    is_sqlite_memory = _is_sqlite_memory_url(_settings.database_url)
+    if is_sqlite_memory:
+        engine = create_async_engine(
+            _settings.database_url,
+            echo=False,
+            connect_args={"timeout": _SQLITE_BUSY_TIMEOUT_SECONDS},
+        )
+    else:
+        engine = create_async_engine(
+            _settings.database_url,
+            echo=False,
+            pool_size=_settings.database_pool_size,
+            max_overflow=_settings.database_max_overflow,
+            pool_timeout=_settings.database_pool_timeout_seconds,
+            connect_args={"timeout": _SQLITE_BUSY_TIMEOUT_SECONDS},
+        )
+    _configure_sqlite_engine(engine.sync_engine, enable_wal=not is_sqlite_memory)
+else:
     engine = create_async_engine(
-        DATABASE_URL,
+        _settings.database_url,
         echo=False,
-        connect_args={"timeout": _SQLITE_BUSY_TIMEOUT_SECONDS},
+        pool_size=_settings.database_pool_size,
+        max_overflow=_settings.database_max_overflow,
+        pool_timeout=_settings.database_pool_timeout_seconds,
     )
-    _configure_sqlite_engine(engine.sync_engine, enable_wal=not _is_sqlite_memory_url(DATABASE_URL))
-else:
-    engine = create_async_engine(DATABASE_URL, echo=False)
 
 SessionLocal = async_sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)
 
@@ -116,7 +133,7 @@ async def get_session() -> AsyncIterator[AsyncSession]:
 async def init_db() -> None:
     from app.db.models import Base
 
-    _ensure_sqlite_dir(DATABASE_URL)
+    _ensure_sqlite_dir(_settings.database_url)
 
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)

app/dependencies.py

@@ -11,6 +11,7 @@ from app.db.session import SessionLocal, _safe_close, _safe_rollback, get_sessio
 from app.modules.accounts.repository import AccountsRepository
 from app.modules.accounts.service import AccountsService
 from app.modules.oauth.service import OauthService
+from app.modules.proxy.repo_bundle import ProxyRepositories
 from app.modules.proxy.service import ProxyService
 from app.modules.proxy.sticky_repository import StickySessionsRepository
 from app.modules.request_logs.repository import RequestLogsRepository
@@ -79,7 +80,12 @@ def get_usage_context(
     usage_repository = UsageRepository(session)
     request_logs_repository = RequestLogsRepository(session)
     accounts_repository = AccountsRepository(session)
-    service = UsageService(usage_repository, request_logs_repository, accounts_repository)
+    service = UsageService(
+        usage_repository,
+        request_logs_repository,
+        accounts_repository,
+        refresh_repo_factory=_usage_refresh_context,
+    )
     return UsageContext(
         session=session,
         usage_repository=usage_repository,
@@ -101,6 +107,40 @@ async def _accounts_repo_context() -> AsyncIterator[AccountsRepository]:
         await _safe_close(session)
 
 
+@asynccontextmanager
+async def _usage_refresh_context() -> AsyncIterator[tuple[UsageRepository, AccountsRepository]]:
+    session = SessionLocal()
+    try:
+        yield UsageRepository(session), AccountsRepository(session)
+    except BaseException:
+        await _safe_rollback(session)
+        raise
+    finally:
+        if session.in_transaction():
+            await _safe_rollback(session)
+        await _safe_close(session)
+
+
+@asynccontextmanager
+async def _proxy_repo_context() -> AsyncIterator[ProxyRepositories]:
+    session = SessionLocal()
+    try:
+        yield ProxyRepositories(
+            accounts=AccountsRepository(session),
+            usage=UsageRepository(session),
+            request_logs=RequestLogsRepository(session),
+            sticky_sessions=StickySessionsRepository(session),
+            settings=SettingsRepository(session),
+        )
+    except BaseException:
+        await _safe_rollback(session)
+        raise
+    finally:
+        if session.in_transaction():
+            await _safe_rollback(session)
+        await _safe_close(session)
+
+
 def get_oauth_context(
     session: AsyncSession = Depends(get_session),
 ) -> OauthContext:
@@ -108,21 +148,8 @@ def get_oauth_context(
     return OauthContext(service=OauthService(accounts_repository, repo_factory=_accounts_repo_context))
 
 
-def get_proxy_context(
-    session: AsyncSession = Depends(get_session),
-) -> ProxyContext:
-    accounts_repository = AccountsRepository(session)
-    usage_repository = UsageRepository(session)
-    request_logs_repository = RequestLogsRepository(session)
-    sticky_repository = StickySessionsRepository(session)
-    settings_repository = SettingsRepository(session)
-    service = ProxyService(
-        accounts_repository,
-        usage_repository,
-        request_logs_repository,
-        sticky_repository,
-        settings_repository,
-    )
+def get_proxy_context() -> ProxyContext:
+    service = ProxyService(repo_factory=_proxy_repo_context)
     return ProxyContext(service=service)
 
 

app/main.py

@@ -1,23 +1,19 @@
 from __future__ import annotations
 
-import logging
 from contextlib import asynccontextmanager
 from pathlib import Path
-from uuid import uuid4
 
-from fastapi import FastAPI, Request
-from fastapi.exception_handlers import (
-    http_exception_handler,
-    request_validation_exception_handler,
-)
-from fastapi.exceptions import RequestValidationError
-from fastapi.responses import FileResponse, JSONResponse, RedirectResponse, Response
+from fastapi import FastAPI
+from fastapi.responses import FileResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
-from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from app.core.clients.http import close_http_client, init_http_client
-from app.core.errors import dashboard_error
-from app.core.utils.request_id import get_request_id, reset_request_id, set_request_id
+from app.core.handlers import add_exception_handlers
+from app.core.middleware import (
+    add_api_unhandled_error_middleware,
+    add_request_decompression_middleware,
+    add_request_id_middleware,
+)
 from app.db.session import close_db, init_db
 from app.modules.accounts import api as accounts_api
 from app.modules.health import api as health_api
@@ -27,8 +23,6 @@ from app.modules.request_logs import api as request_logs_api
 from app.modules.settings import api as settings_api
 from app.modules.usage import api as usage_api
 
-logger = logging.getLogger(__name__)
-
 
 @asynccontextmanager
 async def lifespan(_: FastAPI):
@@ -47,61 +41,13 @@ async def lifespan(_: FastAPI):
 def create_app() -> FastAPI:
     app = FastAPI(title="codex-lb", version="0.1.0", lifespan=lifespan)
 
-    @app.middleware("http")
-    async def request_id_middleware(request: Request, call_next) -> JSONResponse:
-        inbound_request_id = request.headers.get("x-request-id") or request.headers.get("request-id")
-        request_id = inbound_request_id or str(uuid4())
-        token = set_request_id(request_id)
-        try:
-            response = await call_next(request)
-        except Exception:
-            reset_request_id(token)
-            raise
-        response.headers.setdefault("x-request-id", request_id)
-        return response
-
-    @app.middleware("http")
-    async def api_unhandled_error_middleware(request: Request, call_next) -> Response:
-        try:
-            return await call_next(request)
-        except Exception:
-            if request.url.path.startswith("/api/"):
-                logger.exception(
-                    "Unhandled API error request_id=%s",
-                    get_request_id(),
-                )
-                return JSONResponse(
-                    status_code=500,
-                    content=dashboard_error("internal_error", "Unexpected error"),
-                )
-            raise
-
-    @app.exception_handler(RequestValidationError)
-    async def _validation_error_handler(
-        request: Request,
-        exc: RequestValidationError,
-    ) -> Response:
-        if request.url.path.startswith("/api/"):
-            return JSONResponse(
-                status_code=422,
-                content=dashboard_error("validation_error", "Invalid request payload"),
-            )
-        return await request_validation_exception_handler(request, exc)
-
-    @app.exception_handler(StarletteHTTPException)
-    async def _http_error_handler(
-        request: Request,
-        exc: StarletteHTTPException,
-    ) -> Response:
-        if request.url.path.startswith("/api/"):
-            detail = exc.detail if isinstance(exc.detail, str) else "Request failed"
-            return JSONResponse(
-                status_code=exc.status_code,
-                content=dashboard_error(f"http_{exc.status_code}", detail),
-            )
-        return await http_exception_handler(request, exc)
+    add_request_decompression_middleware(app)
+    add_request_id_middleware(app)
+    add_api_unhandled_error_middleware(app)
+    add_exception_handlers(app)
 
     app.include_router(proxy_api.router)
+    app.include_router(proxy_api.v1_router)
     app.include_router(proxy_api.usage_router)
     app.include_router(accounts_api.router)
     app.include_router(usage_api.router)

app/modules/accounts/repository.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from sqlalchemy import delete, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db.models import Account, AccountStatus
+from app.db.models import Account, AccountStatus, RequestLog, StickySession, UsageHistory
 
 
 class AccountsRepository:
@@ -19,19 +19,19 @@ class AccountsRepository:
     async def upsert(self, account: Account) -> Account:
         existing = await self._session.get(Account, account.id)
         if existing:
-            existing.chatgpt_account_id = account.chatgpt_account_id
-            existing.email = account.email
-            existing.plan_type = account.plan_type
-            existing.access_token_encrypted = account.access_token_encrypted
-            existing.refresh_token_encrypted = account.refresh_token_encrypted
-            existing.id_token_encrypted = account.id_token_encrypted
-            existing.last_refresh = account.last_refresh
-            existing.status = account.status
-            existing.deactivation_reason = account.deactivation_reason
+            _apply_account_updates(existing, account)
             await self._session.commit()
             await self._session.refresh(existing)
             return existing
 
+        result = await self._session.execute(select(Account).where(Account.email == account.email))
+        existing_by_email = result.scalar_one_or_none()
+        if existing_by_email:
+            _apply_account_updates(existing_by_email, account)
+            await self._session.commit()
+            await self._session.refresh(existing_by_email)
+            return existing_by_email
+
         self._session.add(account)
         await self._session.commit()
         await self._session.refresh(account)
@@ -54,6 +54,9 @@ class AccountsRepository:
         return result.scalar_one_or_none() is not None
 
     async def delete(self, account_id: str) -> bool:
+        await self._session.execute(delete(UsageHistory).where(UsageHistory.account_id == account_id))
+        await self._session.execute(delete(RequestLog).where(RequestLog.account_id == account_id))
+        await self._session.execute(delete(StickySession).where(StickySession.account_id == account_id))
         result = await self._session.execute(delete(Account).where(Account.id == account_id).returning(Account.id))
         await self._session.commit()
         return result.scalar_one_or_none() is not None
@@ -86,3 +89,15 @@ class AccountsRepository:
         )
         await self._session.commit()
         return result.scalar_one_or_none() is not None
+
+
+def _apply_account_updates(target: Account, source: Account) -> None:
+    target.chatgpt_account_id = source.chatgpt_account_id
+    target.email = source.email
+    target.plan_type = source.plan_type
+    target.access_token_encrypted = source.access_token_encrypted
+    target.refresh_token_encrypted = source.refresh_token_encrypted
+    target.id_token_encrypted = source.id_token_encrypted
+    target.last_refresh = source.last_refresh
+    target.status = source.status
+    target.deactivation_reason = source.deactivation_reason

app/modules/proxy/api.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import time
 from collections.abc import AsyncIterator
 
 from fastapi import APIRouter, Body, Depends, Request, Response
@@ -7,11 +8,16 @@ from fastapi.responses import JSONResponse, StreamingResponse
 
 from app.core.clients.proxy import ProxyResponseError
 from app.core.errors import openai_error
+from app.core.openai.chat_requests import ChatCompletionsRequest
+from app.core.openai.chat_responses import collect_chat_completion, stream_chat_chunks
+from app.core.openai.models_catalog import MODEL_CATALOG
 from app.core.openai.requests import ResponsesCompactRequest, ResponsesRequest
+from app.core.openai.v1_requests import V1ResponsesCompactRequest, V1ResponsesRequest
 from app.dependencies import ProxyContext, get_proxy_context
 from app.modules.proxy.schemas import RateLimitStatusPayload
 
 router = APIRouter(prefix="/backend-api/codex", tags=["proxy"])
+v1_router = APIRouter(prefix="/v1", tags=["proxy"])
 usage_router = APIRouter(tags=["proxy"])
 
 
@@ -20,6 +26,77 @@ async def responses(
     request: Request,
     payload: ResponsesRequest = Body(...),
     context: ProxyContext = Depends(get_proxy_context),
+) -> Response:
+    return await _stream_responses(request, payload, context)
+
+
+@v1_router.post("/responses")
+async def v1_responses(
+    request: Request,
+    payload: V1ResponsesRequest = Body(...),
+    context: ProxyContext = Depends(get_proxy_context),
+) -> Response:
+    return await _stream_responses(request, payload.to_responses_request(), context)
+
+
+@v1_router.get("/models")
+async def v1_models() -> JSONResponse:
+    created = int(time.time())
+    items = [
+        {
+            "id": model_id,
+            "object": "model",
+            "created": created,
+            "owned_by": "codex-lb",
+            "metadata": entry.model_dump(mode="json"),
+        }
+        for model_id, entry in MODEL_CATALOG.items()
+    ]
+    return JSONResponse({"object": "list", "data": items})
+
+
+@v1_router.post("/chat/completions")
+async def v1_chat_completions(
+    request: Request,
+    payload: ChatCompletionsRequest = Body(...),
+    context: ProxyContext = Depends(get_proxy_context),
+) -> Response:
+    rate_limit_headers = await context.service.rate_limit_headers()
+    responses_payload = payload.to_responses_request()
+    responses_payload.stream = True
+    stream = context.service.stream_responses(
+        responses_payload,
+        request.headers,
+        propagate_http_errors=True,
+    )
+    try:
+        first = await stream.__anext__()
+    except StopAsyncIteration:
+        first = None
+    except ProxyResponseError as exc:
+        return JSONResponse(status_code=exc.status_code, content=exc.payload, headers=rate_limit_headers)
+
+    stream_with_first = _prepend_first(first, stream)
+    if payload.stream:
+        return StreamingResponse(
+            stream_chat_chunks(stream_with_first, model=payload.model),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", **rate_limit_headers},
+        )
+
+    result = await collect_chat_completion(stream_with_first, model=payload.model)
+    status_code = 200
+    if isinstance(result, dict) and "error" in result:
+        error = result.get("error")
+        code = error.get("code") if isinstance(error, dict) else None
+        status_code = 503 if code == "no_accounts" else 502
+    return JSONResponse(content=result, status_code=status_code, headers=rate_limit_headers)
+
+
+async def _stream_responses(
+    request: Request,
+    payload: ResponsesRequest,
+    context: ProxyContext,
 ) -> Response:
     rate_limit_headers = await context.service.rate_limit_headers()
     stream = context.service.stream_responses(
@@ -49,6 +126,23 @@ async def responses_compact(
     request: Request,
     payload: ResponsesCompactRequest = Body(...),
     context: ProxyContext = Depends(get_proxy_context),
+) -> JSONResponse:
+    return await _compact_responses(request, payload, context)
+
+
+@v1_router.post("/responses/compact")
+async def v1_responses_compact(
+    request: Request,
+    payload: V1ResponsesCompactRequest = Body(...),
+    context: ProxyContext = Depends(get_proxy_context),
+) -> JSONResponse:
+    return await _compact_responses(request, payload.to_compact_request(), context)
+
+
+async def _compact_responses(
+    request: Request,
+    payload: ResponsesCompactRequest,
+    context: ProxyContext,
 ) -> JSONResponse:
     rate_limit_headers = await context.service.rate_limit_headers()
     try: