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

app/core/clients/proxy.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-from typing import AsyncIterator, Mapping
+from typing import AsyncIterator, Mapping, Protocol, TypeAlias
 
 import aiohttp
 
@@ -28,6 +28,18 @@ class StreamIdleTimeoutError(Exception):
     pass
 
 
+class ErrorResponseProtocol(Protocol):
+    status: int
+    reason: str | None
+
+    async def json(self, *, content_type: str | None = None) -> object: ...
+
+    async def text(self, *, encoding: str | None = None, errors: str = "strict") -> str: ...
+
+
+ErrorResponse: TypeAlias = aiohttp.ClientResponse | ErrorResponseProtocol
+
+
 class ProxyResponseError(Exception):
     def __init__(self, status_code: int, payload: OpenAIErrorEnvelope) -> None:
         super().__init__(f"Proxy response error ({status_code})")
@@ -88,8 +100,10 @@ async def _iter_sse_lines(
         yield line
 
 
-async def _error_event_from_response(resp: aiohttp.ClientResponse) -> ResponseFailedEvent:
+async def _error_event_from_response(resp: ErrorResponse) -> ResponseFailedEvent:
     fallback_message = f"Upstream error: HTTP {resp.status}"
+    if resp.reason:
+        fallback_message += f" {resp.reason}"
     try:
         data = await resp.json(content_type=None)
     except Exception:
@@ -112,11 +126,16 @@ async def _error_event_from_response(resp: aiohttp.ClientResponse) -> ResponseFa
                 if key in payload:
                     event["response"]["error"][key] = payload[key]
             return event
+        message = _extract_upstream_message(data)
+        if message:
+            return response_failed_event("upstream_error", message, response_id=get_request_id())
     return response_failed_event("upstream_error", fallback_message, response_id=get_request_id())
 
 
-async def _error_payload_from_response(resp: aiohttp.ClientResponse) -> OpenAIErrorEnvelope:
+async def _error_payload_from_response(resp: ErrorResponse) -> OpenAIErrorEnvelope:
     fallback_message = f"Upstream error: HTTP {resp.status}"
+    if resp.reason:
+        fallback_message += f" {resp.reason}"
     try:
         data = await resp.json(content_type=None)
     except Exception:
@@ -128,9 +147,20 @@ async def _error_payload_from_response(resp: aiohttp.ClientResponse) -> OpenAIEr
         error = parse_error_payload(data)
         if error:
             return {"error": error.model_dump(exclude_none=True)}
+        message = _extract_upstream_message(data)
+        if message:
+            return openai_error("upstream_error", message)
     return openai_error("upstream_error", fallback_message)
 
 
+def _extract_upstream_message(data: dict) -> str | None:
+    for key in ("message", "detail", "error"):
+        value = data.get(key)
+        if isinstance(value, str) and value.strip():
+            return value
+    return None
+
+
 async def stream_responses(
     payload: ResponsesRequest,
     headers: Mapping[str, str],

app/core/config/settings.py

@@ -42,6 +42,7 @@ class Settings(BaseSettings):
     database_migrations_fail_fast: bool = True
     log_proxy_request_shape: bool = False
     log_proxy_request_shape_raw_cache_key: bool = False
+    log_proxy_request_payload: bool = False
 
     @field_validator("database_url")
     @classmethod

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
 
@@ -44,8 +44,16 @@ class ResponsesRequest(BaseModel):
     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
+
     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,148 @@
+from __future__ import annotations
+
+from typing import cast
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+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 | 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)
+
+
+def _coerce_messages(existing_instructions: str, messages: list[JsonValue]) -> tuple[str, list[JsonValue]]:
+    instruction_parts: list[str] = []
+    input_messages: list[JsonValue] = []
+    for message in messages:
+        if not isinstance(message, dict):
+            raise ValueError("Each message must be an object.")
+        message_dict = cast(dict[str, JsonValue], message)
+        role_value = message_dict.get("role")
+        role = role_value if isinstance(role_value, str) else None
+        if role in ("system", "developer"):
+            content_text = _content_to_text(message_dict.get("content"))
+            if content_text:
+                instruction_parts.append(content_text)
+            continue
+        input_messages.append(cast(JsonValue, message_dict))
+    merged = _merge_instructions(existing_instructions, instruction_parts)
+    return merged, input_messages
+
+
+def _merge_instructions(existing: str, extra_parts: list[str]) -> str:
+    if not extra_parts:
+        return existing
+    extra = "\n".join([part for part in extra_parts if part])
+    if not extra:
+        return existing
+    if existing:
+        return f"{existing}\n{extra}"
+    return extra
+
+
+def _content_to_text(content: object) -> str | None:
+    if content is None:
+        return None
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for part in content:
+            if isinstance(part, str):
+                parts.append(part)
+            elif isinstance(part, dict):
+                part_dict = cast(dict[str, JsonValue], part)
+                text = part_dict.get("text")
+                if isinstance(text, str):
+                    parts.append(text)
+        return "\n".join([part for part in parts if part])
+    if isinstance(content, dict):
+        content_dict = cast(dict[str, JsonValue], content)
+        text = content_dict.get("text")
+        if isinstance(text, str):
+            return text
+        return None
+    return None

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/main.py

@@ -102,6 +102,7 @@ def create_app() -> FastAPI:
         return await http_exception_handler(request, exc)
 
     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:
@@ -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

app/modules/proxy/api.py

@@ -8,10 +8,12 @@ from fastapi.responses import JSONResponse, StreamingResponse
 from app.core.clients.proxy import ProxyResponseError
 from app.core.errors import openai_error
 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 +22,23 @@ 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)
+
+
+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 +68,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:

app/modules/proxy/service.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import logging
 import time
 from collections.abc import Sequence
@@ -80,6 +81,7 @@ class ProxyService:
         *,
         propagate_http_errors: bool = False,
     ) -> AsyncIterator[str]:
+        _maybe_log_proxy_request_payload("stream", payload, headers)
         _maybe_log_proxy_request_shape("stream", payload, headers)
         filtered = filter_inbound_headers(headers)
         return self._stream_with_retry(
@@ -93,6 +95,7 @@ class ProxyService:
         payload: ResponsesCompactRequest,
         headers: Mapping[str, str],
     ) -> OpenAIResponsePayload:
+        _maybe_log_proxy_request_payload("compact", payload, headers)
         _maybe_log_proxy_request_shape("compact", payload, headers)
         filtered = filter_inbound_headers(headers)
         settings = await self._settings_repo.get_or_create()
@@ -526,6 +529,32 @@ def _maybe_log_proxy_request_shape(
     )
 
 
+def _maybe_log_proxy_request_payload(
+    kind: str,
+    payload: ResponsesRequest | ResponsesCompactRequest,
+    headers: Mapping[str, str],
+) -> None:
+    settings = get_settings()
+    if not settings.log_proxy_request_payload:
+        return
+
+    request_id = get_request_id()
+    payload_dict = payload.model_dump(mode="json", exclude_none=True)
+    extra = payload.model_extra or {}
+    if extra:
+        payload_dict = {**payload_dict, "_extra": extra}
+    header_keys = _interesting_header_keys(headers)
+    payload_json = json.dumps(payload_dict, ensure_ascii=True, separators=(",", ":"))
+
+    logger.warning(
+        "proxy_request_payload request_id=%s kind=%s payload=%s headers=%s",
+        request_id,
+        kind,
+        payload_json,
+        header_keys,
+    )
+
+
 def _hash_identifier(value: str) -> str:
     digest = sha256(value.encode("utf-8")).hexdigest()
     return f"sha256:{digest[:12]}"

app/modules/request_logs/api.py

@@ -5,27 +5,81 @@ from datetime import datetime
 from fastapi import APIRouter, Depends, Query
 
 from app.dependencies import RequestLogsContext, get_request_logs_context
-from app.modules.request_logs.schemas import RequestLogsResponse
+from app.modules.request_logs.schemas import (
+    RequestLogFilterOptionsResponse,
+    RequestLogModelOption,
+    RequestLogsResponse,
+)
+from app.modules.request_logs.service import RequestLogModelOption as ServiceRequestLogModelOption
 
 router = APIRouter(prefix="/api/request-logs", tags=["dashboard"])
 
+_MODEL_OPTION_DELIMITER = ":::"
+
+
+def _parse_model_option(value: str) -> ServiceRequestLogModelOption | None:
+    raw = (value or "").strip()
+    if not raw:
+        return None
+    if _MODEL_OPTION_DELIMITER not in raw:
+        return ServiceRequestLogModelOption(model=raw, reasoning_effort=None)
+    model, effort = raw.split(_MODEL_OPTION_DELIMITER, 1)
+    model = model.strip()
+    effort = effort.strip()
+    if not model:
+        return None
+    return ServiceRequestLogModelOption(model=model, reasoning_effort=effort or None)
+
 
 @router.get("", response_model=RequestLogsResponse)
 async def list_request_logs(
-    limit: int = Query(50, ge=1, le=200),
-    account_id: str | None = Query(default=None, alias="accountId"),
-    status: str | None = Query(default=None),
-    model: str | None = Query(default=None),
+    limit: int = Query(50, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+    search: str | None = Query(default=None),
+    account_id: list[str] | None = Query(default=None, alias="accountId"),
+    status: list[str] | None = Query(default=None),
+    model: list[str] | None = Query(default=None),
+    reasoning_effort: list[str] | None = Query(default=None, alias="reasoningEffort"),
+    model_option: list[str] | None = Query(default=None, alias="modelOption"),
     since: datetime | None = Query(default=None),
     until: datetime | None = Query(default=None),
     context: RequestLogsContext = Depends(get_request_logs_context),
 ) -> RequestLogsResponse:
+    parsed_options: list[ServiceRequestLogModelOption] | None = None
+    if model_option:
+        parsed = [_parse_model_option(value) for value in model_option]
+        parsed_options = [value for value in parsed if value is not None] or None
     logs = await context.service.list_recent(
         limit=limit,
+        offset=offset,
+        search=search,
         since=since,
         until=until,
-        account_id=account_id,
-        model=model,
+        account_ids=account_id,
+        model_options=parsed_options,
+        models=model,
+        reasoning_efforts=reasoning_effort,
         status=status,
     )
     return RequestLogsResponse(requests=logs)
+
+
+@router.get("/options", response_model=RequestLogFilterOptionsResponse)
+async def list_request_log_filter_options(
+    status: list[str] | None = Query(default=None),
+    since: datetime | None = Query(default=None),
+    until: datetime | None = Query(default=None),
+    context: RequestLogsContext = Depends(get_request_logs_context),
+) -> RequestLogFilterOptionsResponse:
+    options = await context.service.list_filter_options(
+        status=status,
+        since=since,
+        until=until,
+    )
+    return RequestLogFilterOptionsResponse(
+        account_ids=options.account_ids,
+        model_options=[
+            RequestLogModelOption(model=option.model, reasoning_effort=option.reasoning_effort)
+            for option in options.model_options
+        ],
+    )