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

app/modules/request_logs/repository.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 from datetime import datetime
 
 import anyio
-from sqlalchemy import and_, select
+from sqlalchemy import String, and_, cast, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.utils.request_id import ensure_request_id
 from app.core.utils.time import utcnow
-from app.db.models import RequestLog
+from app.db.models import Account, RequestLog
 
 
 class RequestLogsRepository:
@@ -63,35 +63,147 @@ class RequestLogsRepository:
     async def list_recent(
         self,
         limit: int = 50,
+        offset: int = 0,
+        search: str | None = None,
         since: datetime | None = None,
         until: datetime | None = None,
-        account_id: str | None = None,
-        model: str | None = None,
-        status: str | None = None,
-        error_codes: list[str] | None = None,
+        account_ids: list[str] | None = None,
+        model_options: list[tuple[str, str | None]] | None = None,
+        models: list[str] | None = None,
+        reasoning_efforts: list[str] | None = None,
+        include_success: bool = True,
+        include_error_other: bool = True,
+        error_codes_in: list[str] | None = None,
+        error_codes_excluding: list[str] | None = None,
     ) -> list[RequestLog]:
         conditions = []
         if since is not None:
             conditions.append(RequestLog.requested_at >= since)
         if until is not None:
             conditions.append(RequestLog.requested_at <= until)
-        if account_id is not None:
-            conditions.append(RequestLog.account_id == account_id)
-        if model is not None:
-            conditions.append(RequestLog.model == model)
-        if status is not None:
-            conditions.append(RequestLog.status == status)
-        if error_codes:
-            conditions.append(RequestLog.error_code.in_(error_codes))
-
-        stmt = select(RequestLog).order_by(RequestLog.requested_at.desc())
+        if account_ids:
+            conditions.append(RequestLog.account_id.in_(account_ids))
+
+        if model_options:
+            pair_conditions = []
+            for model, effort in model_options:
+                base = (model or "").strip()
+                if not base:
+                    continue
+                if effort is None:
+                    pair_conditions.append(and_(RequestLog.model == base, RequestLog.reasoning_effort.is_(None)))
+                else:
+                    pair_conditions.append(and_(RequestLog.model == base, RequestLog.reasoning_effort == effort))
+            if pair_conditions:
+                conditions.append(or_(*pair_conditions))
+        else:
+            if models:
+                conditions.append(RequestLog.model.in_(models))
+            if reasoning_efforts:
+                conditions.append(RequestLog.reasoning_effort.in_(reasoning_efforts))
+
+        status_conditions = []
+        if include_success:
+            status_conditions.append(RequestLog.status == "success")
+        if error_codes_in:
+            status_conditions.append(and_(RequestLog.status == "error", RequestLog.error_code.in_(error_codes_in)))
+        if include_error_other:
+            error_clause = [RequestLog.status == "error"]
+            if error_codes_excluding:
+                error_clause.append(
+                    or_(
+                        RequestLog.error_code.is_(None),
+                        ~RequestLog.error_code.in_(error_codes_excluding),
+                    )
+                )
+            status_conditions.append(and_(*error_clause))
+        if status_conditions:
+            conditions.append(or_(*status_conditions))
+        if search:
+            search_pattern = f"%{search}%"
+            conditions.append(
+                or_(
+                    RequestLog.account_id.ilike(search_pattern),
+                    Account.email.ilike(search_pattern),
+                    RequestLog.request_id.ilike(search_pattern),
+                    RequestLog.model.ilike(search_pattern),
+                    RequestLog.reasoning_effort.ilike(search_pattern),
+                    RequestLog.status.ilike(search_pattern),
+                    RequestLog.error_code.ilike(search_pattern),
+                    RequestLog.error_message.ilike(search_pattern),
+                    cast(RequestLog.requested_at, String).ilike(search_pattern),
+                    cast(RequestLog.input_tokens, String).ilike(search_pattern),
+                    cast(RequestLog.output_tokens, String).ilike(search_pattern),
+                    cast(RequestLog.cached_input_tokens, String).ilike(search_pattern),
+                    cast(RequestLog.reasoning_tokens, String).ilike(search_pattern),
+                    cast(RequestLog.latency_ms, String).ilike(search_pattern),
+                )
+            )
+
+        stmt = (
+            select(RequestLog)
+            .outerjoin(Account, Account.id == RequestLog.account_id)
+            .order_by(RequestLog.requested_at.desc())
+        )
         if conditions:
             stmt = stmt.where(and_(*conditions))
+        if offset:
+            stmt = stmt.offset(offset)
         if limit:
             stmt = stmt.limit(limit)
         result = await self._session.execute(stmt)
         return list(result.scalars().all())
 
+    async def list_filter_options(
+        self,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        include_success: bool = True,
+        include_error_other: bool = True,
+        error_codes_in: list[str] | None = None,
+        error_codes_excluding: list[str] | None = None,
+    ) -> tuple[list[str], list[tuple[str, str | None]]]:
+        conditions = []
+        if since is not None:
+            conditions.append(RequestLog.requested_at >= since)
+        if until is not None:
+            conditions.append(RequestLog.requested_at <= until)
+        status_conditions = []
+        if include_success:
+            status_conditions.append(RequestLog.status == "success")
+        if error_codes_in:
+            status_conditions.append(and_(RequestLog.status == "error", RequestLog.error_code.in_(error_codes_in)))
+        if include_error_other:
+            error_clause = [RequestLog.status == "error"]
+            if error_codes_excluding:
+                error_clause.append(
+                    or_(
+                        RequestLog.error_code.is_(None),
+                        ~RequestLog.error_code.in_(error_codes_excluding),
+                    )
+                )
+            status_conditions.append(and_(*error_clause))
+        if status_conditions:
+            conditions.append(or_(*status_conditions))
+
+        account_stmt = select(RequestLog.account_id).distinct().order_by(RequestLog.account_id.asc())
+        model_stmt = (
+            select(RequestLog.model, RequestLog.reasoning_effort)
+            .distinct()
+            .order_by(RequestLog.model.asc(), RequestLog.reasoning_effort.asc())
+        )
+        if conditions:
+            clause = and_(*conditions)
+            account_stmt = account_stmt.where(clause)
+            model_stmt = model_stmt.where(clause)
+
+        account_rows = await self._session.execute(account_stmt)
+        model_rows = await self._session.execute(model_stmt)
+
+        account_ids = [row[0] for row in account_rows.all() if row[0]]
+        model_options = [(row[0], row[1]) for row in model_rows.all() if row[0]]
+        return account_ids, model_options
+
 
 async def _safe_rollback(session: AsyncSession) -> None:
     if not session.in_transaction():

app/modules/request_logs/schemas.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import List
 
 from pydantic import Field
 
@@ -24,4 +23,14 @@ class RequestLogEntry(DashboardModel):
 
 
 class RequestLogsResponse(DashboardModel):
-    requests: List[RequestLogEntry] = Field(default_factory=list)
+    requests: list[RequestLogEntry] = Field(default_factory=list)
+
+
+class RequestLogModelOption(DashboardModel):
+    model: str
+    reasoning_effort: str | None = None
+
+
+class RequestLogFilterOptionsResponse(DashboardModel):
+    account_ids: list[str] = Field(default_factory=list)
+    model_options: list[RequestLogModelOption] = Field(default_factory=list)

app/modules/request_logs/service.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from datetime import datetime
 from typing import cast
 
@@ -17,6 +18,26 @@ RATE_LIMIT_CODES = {"rate_limit_exceeded", "usage_limit_reached"}
 QUOTA_CODES = {"insufficient_quota", "usage_not_included", "quota_exceeded"}
 
 
+@dataclass(frozen=True, slots=True)
+class RequestLogModelOption:
+    model: str
+    reasoning_effort: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class RequestLogStatusFilter:
+    include_success: bool
+    include_error_other: bool
+    error_codes_in: list[str] | None
+    error_codes_excluding: list[str] | None
+
+
+@dataclass(frozen=True, slots=True)
+class RequestLogFilterOptions:
+    account_ids: list[str]
+    model_options: list[RequestLogModelOption]
+
+
 class RequestLogsService:
     def __init__(self, repo: RequestLogsRepository) -> None:
         self._repo = repo
@@ -24,38 +45,94 @@ class RequestLogsService:
     async def list_recent(
         self,
         limit: int = 50,
+        offset: int = 0,
+        search: str | None = None,
         since: datetime | None = None,
         until: datetime | None = None,
-        account_id: str | None = None,
-        model: str | None = None,
-        status: str | None = None,
+        account_ids: list[str] | None = None,
+        model_options: list[RequestLogModelOption] | None = None,
+        models: list[str] | None = None,
+        reasoning_efforts: list[str] | None = None,
+        status: list[str] | None = None,
     ) -> list[RequestLogEntry]:
-        status_filter, error_codes = _map_status_filter(status)
+        status_filter = _map_status_filter(status)
         logs = await self._repo.list_recent(
             limit=limit,
+            offset=offset,
+            search=search,
             since=since,
             until=until,
-            account_id=account_id,
-            model=model,
-            status=status_filter,
-            error_codes=error_codes,
+            account_ids=account_ids,
+            model_options=(
+                [(option.model, option.reasoning_effort) for option in model_options] if model_options else None
+            ),
+            models=models,
+            reasoning_efforts=reasoning_efforts,
+            include_success=status_filter.include_success,
+            include_error_other=status_filter.include_error_other,
+            error_codes_in=status_filter.error_codes_in,
+            error_codes_excluding=status_filter.error_codes_excluding,
         )
         return [_to_entry(log) for log in logs]
 
+    async def list_filter_options(
+        self,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        status: list[str] | None = None,
+    ) -> RequestLogFilterOptions:
+        status_filter = _map_status_filter(status)
+        account_ids, model_options = await self._repo.list_filter_options(
+            since=since,
+            until=until,
+            include_success=status_filter.include_success,
+            include_error_other=status_filter.include_error_other,
+            error_codes_in=status_filter.error_codes_in,
+            error_codes_excluding=status_filter.error_codes_excluding,
+        )
+        return RequestLogFilterOptions(
+            account_ids=account_ids,
+            model_options=[
+                RequestLogModelOption(model=model, reasoning_effort=reasoning_effort)
+                for model, reasoning_effort in model_options
+            ],
+        )
+
 
-def _map_status_filter(status: str | None) -> tuple[str | None, list[str] | None]:
+def _map_status_filter(status: list[str] | None) -> RequestLogStatusFilter:
     if not status:
-        return None, None
-    normalized = status.lower()
-    if normalized == "ok":
-        return "success", None
-    if normalized == "rate_limit":
-        return "error", sorted(RATE_LIMIT_CODES)
-    if normalized == "quota":
-        return "error", sorted(QUOTA_CODES)
-    if normalized == "error":
-        return "error", None
-    return status, None
+        return RequestLogStatusFilter(
+            include_success=True,
+            include_error_other=True,
+            error_codes_in=None,
+            error_codes_excluding=None,
+        )
+    normalized = {value.lower() for value in status if value}
+    if not normalized or "all" in normalized:
+        return RequestLogStatusFilter(
+            include_success=True,
+            include_error_other=True,
+            error_codes_in=None,
+            error_codes_excluding=None,
+        )
+
+    include_success = "ok" in normalized
+    include_rate_limit = "rate_limit" in normalized
+    include_quota = "quota" in normalized
+    include_error_other = "error" in normalized
+
+    error_codes_in: set[str] = set()
+    if include_rate_limit:
+        error_codes_in |= RATE_LIMIT_CODES
+    if include_quota:
+        error_codes_in |= QUOTA_CODES
+
+    return RequestLogStatusFilter(
+        include_success=include_success,
+        include_error_other=include_error_other,
+        error_codes_in=sorted(error_codes_in) if error_codes_in else None,
+        error_codes_excluding=sorted(RATE_LIMIT_CODES | QUOTA_CODES) if include_error_other else None,
+    )
 
 
 def _log_status(log: RequestLog) -> str:

app/modules/usage/updater.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 import logging
 import math
-from collections import Counter
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Mapping, Protocol
 
 from app.core.auth.refresh import RefreshError
@@ -14,8 +13,7 @@ from app.core.usage.models import UsagePayload
 from app.core.utils.request_id import get_request_id
 from app.core.utils.time import utcnow
 from app.db.models import Account, AccountStatus, UsageHistory
-from app.modules.accounts.auth_manager import AuthManager
-from app.modules.accounts.repository import AccountsRepository
+from app.modules.accounts.auth_manager import AccountsRepositoryPort, AuthManager
 
 logger = logging.getLogger(__name__)
 
@@ -41,7 +39,7 @@ class UsageUpdater:
     def __init__(
         self,
         usage_repo: UsageRepositoryPort,
-        accounts_repo: AccountsRepository | None = None,
+        accounts_repo: AccountsRepositoryPort | None = None,
     ) -> None:
         self._usage_repo = usage_repo
         self._encryptor = TokenEncryptor()
@@ -56,7 +54,6 @@ class UsageUpdater:
         if not settings.usage_refresh_enabled:
             return
 
-        shared_chatgpt_account_ids = _shared_chatgpt_account_ids(accounts)
         now = utcnow()
         interval = settings.usage_refresh_interval_seconds
         for account in accounts:
@@ -65,16 +62,11 @@ class UsageUpdater:
             latest = latest_usage.get(account.id)
             if latest and (now - latest.recorded_at).total_seconds() < interval:
                 continue
-            usage_account_id = (
-                None
-                if account.chatgpt_account_id and account.chatgpt_account_id in shared_chatgpt_account_ids
-                else account.chatgpt_account_id
-            )
             # NOTE: AsyncSession is not safe for concurrent use. Run sequentially
             # within the request-scoped session to avoid PK collisions and
             # flush-time warnings (SAWarning: Session.add during flush).
             try:
-                await self._refresh_account(account, usage_account_id=usage_account_id)
+                await self._refresh_account(account, usage_account_id=account.chatgpt_account_id)
             except Exception as exc:
                 logger.warning(
                     "Usage refresh failed account_id=%s request_id=%s error=%s",
@@ -88,12 +80,16 @@ class UsageUpdater:
 
     async def _refresh_account(self, account: Account, *, usage_account_id: str | None) -> None:
         access_token = self._encryptor.decrypt(account.access_token_encrypted)
+        payload: UsagePayload | None = None
         try:
             payload = await fetch_usage(
                 access_token=access_token,
                 account_id=usage_account_id,
             )
         except UsageFetchError as exc:
+            if _should_deactivate_for_usage_error(exc.status_code):
+                await self._deactivate_for_client_error(account, exc)
+                return
             if exc.status_code != 401 or not self._auth_manager:
                 return
             try:
@@ -106,25 +102,32 @@ class UsageUpdater:
                     access_token=access_token,
                     account_id=usage_account_id,
                 )
-            except UsageFetchError:
+            except UsageFetchError as retry_exc:
+                if _should_deactivate_for_usage_error(retry_exc.status_code):
+                    await self._deactivate_for_client_error(account, retry_exc)
                 return
 
+        if payload is None:
+            return
+
         rate_limit = payload.rate_limit
-        primary = rate_limit.primary_window if rate_limit else None
+        if rate_limit is None:
+            return
+
+        primary = rate_limit.primary_window
+        secondary = rate_limit.secondary_window
         credits_has, credits_unlimited, credits_balance = _credits_snapshot(payload)
-        primary_window_minutes = _window_minutes(primary.limit_window_seconds) if primary else None
-        secondary = rate_limit.secondary_window if rate_limit else None
-        secondary_window_minutes = _window_minutes(secondary.limit_window_seconds) if secondary else None
+        now_epoch = _now_epoch()
 
         if primary and primary.used_percent is not None:
             await self._usage_repo.add_entry(
                 account_id=account.id,
-                used_percent=primary.used_percent,
+                used_percent=float(primary.used_percent),
                 input_tokens=None,
                 output_tokens=None,
                 window="primary",
-                reset_at=primary.reset_at,
-                window_minutes=primary_window_minutes,
+                reset_at=_reset_at(primary.reset_at, primary.reset_after_seconds, now_epoch),
+                window_minutes=_window_minutes(primary.limit_window_seconds),
                 credits_has=credits_has,
                 credits_unlimited=credits_unlimited,
                 credits_balance=credits_balance,
@@ -133,14 +136,29 @@ class UsageUpdater:
         if secondary and secondary.used_percent is not None:
             await self._usage_repo.add_entry(
                 account_id=account.id,
-                used_percent=secondary.used_percent,
+                used_percent=float(secondary.used_percent),
                 input_tokens=None,
                 output_tokens=None,
                 window="secondary",
-                reset_at=secondary.reset_at,
-                window_minutes=secondary_window_minutes,
+                reset_at=_reset_at(secondary.reset_at, secondary.reset_after_seconds, now_epoch),
+                window_minutes=_window_minutes(secondary.limit_window_seconds),
             )
 
+    async def _deactivate_for_client_error(self, account: Account, exc: UsageFetchError) -> None:
+        if not self._auth_manager:
+            return
+        reason = f"Usage API error: HTTP {exc.status_code} - {exc.message}"
+        logger.warning(
+            "Deactivating account due to client error account_id=%s status=%s message=%s request_id=%s",
+            account.id,
+            exc.status_code,
+            exc.message,
+            get_request_id(),
+        )
+        await self._auth_manager._repo.update_status(account.id, AccountStatus.DEACTIVATED, reason)
+        account.status = AccountStatus.DEACTIVATED
+        account.deactivation_reason = reason
+
 
 def _credits_snapshot(payload: UsagePayload) -> tuple[bool | None, bool | None, float | None]:
     credits = payload.credits
@@ -171,6 +189,20 @@ def _window_minutes(limit_seconds: int | None) -> int | None:
     return max(1, math.ceil(limit_seconds / 60))
 
 
-def _shared_chatgpt_account_ids(accounts: list[Account]) -> set[str]:
-    counts = Counter(account.chatgpt_account_id for account in accounts if account.chatgpt_account_id)
-    return {account_id for account_id, count in counts.items() if count > 1}
+def _now_epoch() -> int:
+    return int(utcnow().replace(tzinfo=timezone.utc).timestamp())
+
+
+def _reset_at(reset_at: int | None, reset_after_seconds: int | None, now_epoch: int) -> int | None:
+    if reset_at is not None:
+        return int(reset_at)
+    if reset_after_seconds is None:
+        return None
+    return now_epoch + max(0, int(reset_after_seconds))
+
+
+_DEACTIVATING_USAGE_STATUS_CODES = {402, 403, 404}
+
+
+def _should_deactivate_for_usage_error(status_code: int) -> bool:
+    return status_code in _DEACTIVATING_USAGE_STATUS_CODES