codex-lb 0.1.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

app/modules/request_logs/repository.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-import asyncio
 from datetime import datetime
 
+import anyio
 from sqlalchemy import and_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -33,6 +33,7 @@ class RequestLogsRepository:
         requested_at: datetime | None = None,
         cached_input_tokens: int | None = None,
         reasoning_tokens: int | None = None,
+        reasoning_effort: str | None = None,
     ) -> RequestLog:
         resolved_request_id = ensure_request_id(request_id)
         log = RequestLog(
@@ -43,6 +44,7 @@ class RequestLogsRepository:
             output_tokens=output_tokens,
             cached_input_tokens=cached_input_tokens,
             reasoning_tokens=reasoning_tokens,
+            reasoning_effort=reasoning_effort,
             latency_ms=latency_ms,
             status=status,
             error_code=error_code,
@@ -95,6 +97,7 @@ async def _safe_rollback(session: AsyncSession) -> None:
     if not session.in_transaction():
         return
     try:
-        await asyncio.shield(session.rollback())
-    except Exception:
+        with anyio.CancelScope(shield=True):
+            await session.rollback()
+    except BaseException:
         return

app/modules/request_logs/schemas.py

@@ -17,6 +17,8 @@ class RequestLogEntry(DashboardModel):
     error_code: str | None = None
     error_message: str | None = None
     tokens: int | None = None
+    cached_input_tokens: int | None = None
+    reasoning_effort: str | None = None
     cost_usd: float | None = None
     latency_ms: int | None = None
 

app/modules/request_logs/service.py

@@ -1,8 +1,14 @@
 from __future__ import annotations
 
 from datetime import datetime
+from typing import cast
 
-from app.core.usage.logs import cost_from_log, total_tokens_from_log
+from app.core.usage.logs import (
+    RequestLogLike,
+    cached_input_tokens_from_log,
+    cost_from_log,
+    total_tokens_from_log,
+)
 from app.db.models import RequestLog
 from app.modules.request_logs.repository import RequestLogsRepository
 from app.modules.request_logs.schemas import RequestLogEntry
@@ -63,15 +69,18 @@ def _log_status(log: RequestLog) -> str:
 
 
 def _to_entry(log: RequestLog) -> RequestLogEntry:
+    log_like = cast(RequestLogLike, log)
     return RequestLogEntry(
         requested_at=log.requested_at,
         account_id=log.account_id,
         request_id=log.request_id,
         model=log.model,
+        reasoning_effort=log.reasoning_effort,
         status=_log_status(log),
         error_code=log.error_code,
         error_message=log.error_message,
-        tokens=total_tokens_from_log(log),
-        cost_usd=cost_from_log(log, precision=6),
+        tokens=total_tokens_from_log(log_like),
+        cached_input_tokens=cached_input_tokens_from_log(log_like),
+        cost_usd=cost_from_log(log_like, precision=6),
         latency_ms=log.latency_ms,
     )

app/modules/settings/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

app/modules/settings/api.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Body, Depends
+
+from app.dependencies import SettingsContext, get_settings_context
+from app.modules.settings.schemas import DashboardSettingsResponse, DashboardSettingsUpdateRequest
+from app.modules.settings.service import DashboardSettingsData
+
+router = APIRouter(prefix="/api/settings", tags=["dashboard"])
+
+
+@router.get("", response_model=DashboardSettingsResponse)
+async def get_settings(
+    context: SettingsContext = Depends(get_settings_context),
+) -> DashboardSettingsResponse:
+    settings = await context.service.get_settings()
+    return DashboardSettingsResponse(
+        sticky_threads_enabled=settings.sticky_threads_enabled,
+        prefer_earlier_reset_accounts=settings.prefer_earlier_reset_accounts,
+    )
+
+
+@router.put("", response_model=DashboardSettingsResponse)
+async def update_settings(
+    payload: DashboardSettingsUpdateRequest = Body(...),
+    context: SettingsContext = Depends(get_settings_context),
+) -> DashboardSettingsResponse:
+    updated = await context.service.update_settings(
+        DashboardSettingsData(
+            sticky_threads_enabled=payload.sticky_threads_enabled,
+            prefer_earlier_reset_accounts=payload.prefer_earlier_reset_accounts,
+        )
+    )
+    return DashboardSettingsResponse(
+        sticky_threads_enabled=updated.sticky_threads_enabled,
+        prefer_earlier_reset_accounts=updated.prefer_earlier_reset_accounts,
+    )

app/modules/settings/repository.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import DashboardSettings
+
+_SETTINGS_ID = 1
+
+
+class SettingsRepository:
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def get_or_create(self) -> DashboardSettings:
+        existing = await self._session.get(DashboardSettings, _SETTINGS_ID)
+        if existing is not None:
+            return existing
+
+        row = DashboardSettings(
+            id=_SETTINGS_ID,
+            sticky_threads_enabled=False,
+            prefer_earlier_reset_accounts=False,
+        )
+        self._session.add(row)
+        await self._session.commit()
+        await self._session.refresh(row)
+        return row
+
+    async def update(
+        self,
+        *,
+        sticky_threads_enabled: bool,
+        prefer_earlier_reset_accounts: bool,
+    ) -> DashboardSettings:
+        settings = await self.get_or_create()
+        settings.sticky_threads_enabled = sticky_threads_enabled
+        settings.prefer_earlier_reset_accounts = prefer_earlier_reset_accounts
+        await self._session.commit()
+        await self._session.refresh(settings)
+        return settings

app/modules/settings/schemas.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from app.modules.shared.schemas import DashboardModel
+
+
+class DashboardSettingsResponse(DashboardModel):
+    sticky_threads_enabled: bool
+    prefer_earlier_reset_accounts: bool
+
+
+class DashboardSettingsUpdateRequest(DashboardModel):
+    sticky_threads_enabled: bool
+    prefer_earlier_reset_accounts: bool

app/modules/settings/service.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from app.modules.settings.repository import SettingsRepository
+
+
+@dataclass(frozen=True, slots=True)
+class DashboardSettingsData:
+    sticky_threads_enabled: bool
+    prefer_earlier_reset_accounts: bool
+
+
+class SettingsService:
+    def __init__(self, repository: SettingsRepository) -> None:
+        self._repository = repository
+
+    async def get_settings(self) -> DashboardSettingsData:
+        row = await self._repository.get_or_create()
+        return DashboardSettingsData(
+            sticky_threads_enabled=row.sticky_threads_enabled,
+            prefer_earlier_reset_accounts=row.prefer_earlier_reset_accounts,
+        )
+
+    async def update_settings(self, payload: DashboardSettingsData) -> DashboardSettingsData:
+        row = await self._repository.update(
+            sticky_threads_enabled=payload.sticky_threads_enabled,
+            prefer_earlier_reset_accounts=payload.prefer_earlier_reset_accounts,
+        )
+        return DashboardSettingsData(
+            sticky_threads_enabled=row.sticky_threads_enabled,
+            prefer_earlier_reset_accounts=row.prefer_earlier_reset_accounts,
+        )

app/modules/shared/schemas.py

@@ -1,8 +1,22 @@
 from __future__ import annotations
 
-from pydantic import BaseModel, ConfigDict
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, field_serializer
 from pydantic.alias_generators import to_camel
 
 
 class DashboardModel(BaseModel):
-    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        ser_json_timedelta="iso8601",
+    )
+
+    @field_serializer("*", when_used="json")
+    def serialize_datetime_as_utc(value, _info):
+        if isinstance(value, datetime):
+            if value.tzinfo is None:
+                return value.isoformat() + "Z"
+            return value.isoformat().replace("+00:00", "Z")
+        return value

app/modules/usage/schemas.py

@@ -30,6 +30,7 @@ class UsageCost(DashboardModel):
 class UsageMetrics(DashboardModel):
     requests_7d: int | None = Field(default=None, alias="requests7d")
     tokens_secondary_window: int | None = None
+    cached_tokens_secondary_window: int | None = None
     error_rate_7d: float | None = Field(default=None, alias="errorRate7d")
     top_error: str | None = None
 

app/modules/usage/service.py

@@ -1,9 +1,16 @@
 from __future__ import annotations
 
 from datetime import timedelta
+from typing import cast
 
 from app.core import usage as usage_core
-from app.core.usage.logs import cost_from_log, total_tokens_from_log, usage_tokens_from_log
+from app.core.usage.logs import (
+    RequestLogLike,
+    cached_input_tokens_from_log,
+    cost_from_log,
+    total_tokens_from_log,
+    usage_tokens_from_log,
+)
 from app.core.usage.pricing import CostItem, calculate_costs
 from app.core.usage.types import (
     UsageCostSummary,
@@ -15,7 +22,6 @@ from app.core.usage.types import (
 from app.core.utils.time import from_epoch_seconds, utcnow
 from app.db.models import Account, RequestLog
 from app.modules.accounts.repository import AccountsRepository
-from app.modules.proxy.usage_updater import UsageUpdater
 from app.modules.request_logs.repository import RequestLogsRepository
 from app.modules.usage.repository import UsageRepository
 from app.modules.usage.schemas import (
@@ -28,6 +34,7 @@ from app.modules.usage.schemas import (
     UsageWindow,
     UsageWindowResponse,
 )
+from app.modules.usage.updater import UsageUpdater
 
 
 class UsageService:
@@ -137,7 +144,7 @@ def _build_account_history(
     for log in logs:
         account_id = log.account_id
         counts[account_id] = counts.get(account_id, 0) + 1
-        cost = cost_from_log(log)
+        cost = cost_from_log(cast(RequestLogLike, log))
         if cost is None:
             continue
         costs[account_id] = costs.get(account_id, 0.0) + cost
@@ -166,7 +173,7 @@ def _build_account_history(
 
 def _log_to_cost_item(log: RequestLog) -> CostItem | None:
     model = log.model
-    usage = usage_tokens_from_log(log)
+    usage = usage_tokens_from_log(cast(RequestLogLike, log))
     if not model or not usage:
         return None
     return CostItem(model=model, usage=usage)
@@ -180,9 +187,11 @@ def _usage_metrics(logs_secondary: list[RequestLog]) -> UsageMetricsSummary:
         error_rate = len(error_logs) / total_requests
     top_error = _top_error_code(error_logs)
     tokens_secondary = _sum_tokens(logs_secondary)
+    cached_tokens_secondary = _sum_cached_input_tokens(logs_secondary)
     return UsageMetricsSummary(
         requests_7d=total_requests,
         tokens_secondary_window=tokens_secondary,
+        cached_tokens_secondary_window=cached_tokens_secondary,
         error_rate_7d=error_rate,
         top_error=top_error,
     )
@@ -191,7 +200,14 @@ def _usage_metrics(logs_secondary: list[RequestLog]) -> UsageMetricsSummary:
 def _sum_tokens(logs: list[RequestLog]) -> int:
     total = 0
     for log in logs:
-        total += total_tokens_from_log(log) or 0
+        total += total_tokens_from_log(cast(RequestLogLike, log)) or 0
+    return total
+
+
+def _sum_cached_input_tokens(logs: list[RequestLog]) -> int:
+    total = 0
+    for log in logs:
+        total += cached_input_tokens_from_log(cast(RequestLogLike, log)) or 0
     return total
 
 
@@ -232,7 +248,7 @@ def _window_snapshot_to_model(snapshot: UsageWindowSnapshot) -> UsageWindow:
 def _cost_summary_to_model(cost: UsageCostSummary) -> UsageCost:
     return UsageCost(
         currency=cost.currency,
-        total_usd_7d=cost.total_usd_7d,
+        totalUsd7d=cost.total_usd_7d,
         by_model=[UsageCostByModel(model=item.model, usd=item.usd) for item in cost.by_model],
     )
 
@@ -241,6 +257,7 @@ def _metrics_summary_to_model(metrics: UsageMetricsSummary) -> UsageMetrics:
     return UsageMetrics(
         requests_7d=metrics.requests_7d,
         tokens_secondary_window=metrics.tokens_secondary_window,
+        cached_tokens_secondary_window=metrics.cached_tokens_secondary_window,
         error_rate_7d=metrics.error_rate_7d,
         top_error=metrics.top_error,
     )

app/modules/{proxy/usage_updater.py → usage/updater.py}

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import logging
 import math
-from typing import Mapping
+from collections import Counter
+from datetime import datetime
+from typing import Mapping, Protocol
 
 from app.core.auth.refresh import RefreshError
 from app.core.clients.usage import UsageFetchError, fetch_usage
@@ -12,17 +14,33 @@ 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.proxy.auth_manager import AuthManager
-from app.modules.usage.repository import UsageRepository
 
 logger = logging.getLogger(__name__)
 
 
+class UsageRepositoryPort(Protocol):
+    async def add_entry(
+        self,
+        account_id: str,
+        used_percent: float,
+        input_tokens: int | None = None,
+        output_tokens: int | None = None,
+        recorded_at: datetime | None = None,
+        window: str | None = None,
+        reset_at: int | None = None,
+        window_minutes: int | None = None,
+        credits_has: bool | None = None,
+        credits_unlimited: bool | None = None,
+        credits_balance: float | None = None,
+    ) -> UsageHistory | None: ...
+
+
 class UsageUpdater:
     def __init__(
         self,
-        usage_repo: UsageRepository,
+        usage_repo: UsageRepositoryPort,
         accounts_repo: AccountsRepository | None = None,
     ) -> None:
         self._usage_repo = usage_repo
@@ -38,6 +56,7 @@ 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:
@@ -46,11 +65,16 @@ 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)
+                await self._refresh_account(account, usage_account_id=usage_account_id)
             except Exception as exc:
                 logger.warning(
                     "Usage refresh failed account_id=%s request_id=%s error=%s",
@@ -62,12 +86,12 @@ class UsageUpdater:
                 # swallow per-account failures so the whole refresh loop keeps going
                 continue
 
-    async def _refresh_account(self, account: Account) -> None:
+    async def _refresh_account(self, account: Account, *, usage_account_id: str | None) -> None:
         access_token = self._encryptor.decrypt(account.access_token_encrypted)
         try:
             payload = await fetch_usage(
                 access_token=access_token,
-                account_id=account.id,
+                account_id=usage_account_id,
             )
         except UsageFetchError as exc:
             if exc.status_code != 401 or not self._auth_manager:
@@ -80,7 +104,7 @@ class UsageUpdater:
             try:
                 payload = await fetch_usage(
                     access_token=access_token,
-                    account_id=account.id,
+                    account_id=usage_account_id,
                 )
             except UsageFetchError:
                 return
@@ -145,3 +169,8 @@ def _window_minutes(limit_seconds: int | None) -> int | None:
     if not limit_seconds or limit_seconds <= 0:
         return 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}

app/static/7.css

@@ -48,6 +48,9 @@
     --w7-s-icon: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiI+PHBhdGggc3Ryb2tlPSIjMjA3MGI5IiBkPSJNMTAuNSAxQzguMDIgMSA2IDMuMDIgNiA1LjVhNC40NSA0LjQ1IDAgMCAwIDEgMi43OTNMMi4wMjMgMTMuMjdsLjcwNC43MUw3LjcwNyA5Yy43Ny42MTcgMS43MzQgMSAyLjc5MyAxIDIuNDggMCA0LjUtMi4wMiA0LjUtNC41UzEyLjk4IDEgMTAuNSAxWm0wIDFDMTIuNDM4IDIgMTQgMy41NjMgMTQgNS41IDE0IDcuNDM4IDEyLjQzNyA5IDEwLjUgOUEzLjQ5NCAzLjQ5NCAwIDAgMSA3IDUuNUM3IDMuNTYyIDguNTYzIDIgMTAuNSAyWiIvPjwvc3ZnPg==");
     --w7-s-bg: var(--w7-s-icon) no-repeat center;
 
+    /* checkbox */
+    --w7-cb-size: 14px;
+
     /* radio */
     --w7-rd-size: 14px;
     --w7-rdl-space: 6px;
@@ -416,6 +419,76 @@ table>tbody>tr>:not(:last-child) {
     }
 }
 
+input[type=checkbox] {
+    appearance: none;
+    -webkit-appearance: none;
+    -moz-appearance: none;
+    background: none;
+    border: none;
+    font: var(--w7-font);
+    margin: 0;
+    opacity: 0
+}
+
+input[type=checkbox]+label {
+    align-items: center;
+    display: inline-flex;
+    font: var(--w7-font);
+    position: relative
+}
+
+input[type=checkbox]+label:before {
+    background: #f6f6f6;
+    border: 1px solid var(--w7-el-bd);
+    box-shadow: inset 0 0 0 1px var(--w7-el-bg-d),inset 1px 1px 0 1px #aeaeae,inset -1px -1px 0 1px #ddd,inset 3px 3px 6px #ccc;
+    box-sizing: border-box;
+    content: "";
+    display: inline-block;
+    height: var(--w7-cb-size);
+    margin-right: 6px;
+    transition: .4s;
+    width: var(--w7-cb-size)
+}
+
+input[type=checkbox]+label:hover:before {
+    background: #e9f7fe;
+    border-color: var(--w7-el-bd-h);
+    box-shadow: inset 0 0 0 1px #def9fa,inset 1px 1px 0 1px #79c6f9,inset -1px -1px 0 1px #c6e9fc,inset 3px 3px 6px #b1dffd
+}
+
+input[type=checkbox]:focus-visible+label {
+    outline: 1px dotted #000
+}
+
+input[type=checkbox]:checked+label:after {
+    color: #4a5f97;
+    content: "\2714";
+    display: block;
+    font-weight: 700;
+    left: 2px;
+    position: absolute;
+    top: 0
+}
+
+input[type=checkbox]:disabled+label {
+    color: #6d6d6d
+}
+
+input[type=checkbox]:disabled+label:before {
+    background: linear-gradient(to bottom right,#f0f0f0,#fbfbfb);
+    border: 1px solid #b1b1b1;
+    box-shadow: none;
+    content: "";
+    display: inline-block;
+    height: var(--w7-cb-size);
+    margin-right: 6px;
+    width: var(--w7-cb-size)
+}
+
+input[type=checkbox]:disabled+label:after {
+    color: #bfbfbf
+}
+
 input[type=radio] {
     appearance: none;
     -webkit-appearance: none;

app/static/index.css

@@ -304,17 +304,46 @@ body {
 }
 
 .legend li {
-  display: flex;
-  justify-content: space-between;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 120px;
+  align-items: center;
   gap: 8px;
   font-size: 12px;
   width: 100%;
 }
 
-.legend span {
-  display: inline-flex;
+.legend-label {
+  display: flex;
   align-items: center;
   gap: 6px;
+  min-width: 0;
+}
+
+.legend-label-text {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.legend-detail {
+  white-space: nowrap;
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 6px;
+}
+
+.legend-detail-label {
+  min-width: 0;
+}
+
+.legend-detail-value {
+  min-width: 4ch;
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+  font-feature-settings: "tnum" 1;
 }
 
 

app/static/index.html

@@ -78,11 +78,14 @@
                     <ul class="legend">
                       <template x-for="item in donut.items" :key="item.label">
                         <li>
-                          <span>
+                          <span class="legend-label">
                             <i :style="{ '--legend-color': item.color }"></i>
-                            <span x-text="item.label"></span>
+                            <span class="legend-label-text" x-text="item.label" :title="item.label"></span>
+                          </span>
+                          <span class="legend-detail">
+                            <span class="legend-detail-label" x-text="item.detailLabel"></span>
+                            <span class="legend-detail-value" x-text="item.detailValue"></span>
                           </span>
-                          <span x-text="item.detail"></span>
                         </li>
                       </template>
                     </ul>
@@ -297,6 +300,50 @@
               </div>
             </div>
           </article>
+
+          <article role="tabpanel" id="tab-settings" :hidden="view !== 'settings'">
+            <div class="panel">
+              <h3>Routing settings</h3>
+              <p class="text-muted">Toggle routing features. When both options are off, accounts are selected by
+                balancing usage evenly.</p>
+
+              <fieldset style="margin-top: 12px">
+                <legend>Sticky threads</legend>
+                <input
+                  id="sticky-threads-toggle"
+                  type="checkbox"
+                  x-model="settings.stickyThreadsEnabled"
+                  aria-describedby="sticky-threads-help"
+                >
+                <label for="sticky-threads-toggle">Enable sticky threads (reuse the same upstream account per conversation)</label>
+                <div id="sticky-threads-help" class="text-muted" style="margin-top: 6px">
+                  When enabled, requests with a prompt cache key stay pinned to the same upstream account unless the
+                  pinned account becomes unavailable.
+                </div>
+              </fieldset>
+
+              <fieldset style="margin-top: 12px">
+                <legend>Reset priority</legend>
+                <input
+                  id="reset-priority-toggle"
+                  type="checkbox"
+                  x-model="settings.preferEarlierResetAccounts"
+                  aria-describedby="reset-priority-help"
+                >
+                <label for="reset-priority-toggle">Prefer accounts that reset earlier first</label>
+                <div id="reset-priority-help" class="text-muted" style="margin-top: 6px">
+                  When enabled, the load balancer prefers accounts whose secondary quota resets sooner, then balances
+                  usage.
+                </div>
+              </fieldset>
+
+              <div class="inline-actions" style="margin-top: 12px">
+                <button type="button" @click="saveSettings" :disabled="settings.isSaving">
+                  <span>Save</span>
+                </button>
+              </div>
+            </div>
+          </article>
         </section>
       </div>
       <div class="status-bar">
@@ -454,4 +501,4 @@
   <script defer src="https://unpkg.com/alpinejs@3.13.2/dist/cdn.min.js"></script>
 </body>
 
-</html>
+</html>