codex-lb 0.1.2__py3-none-any.whl

app/core/usage/__init__.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from typing import Iterable, Mapping
+
+from app.core.usage.types import (
+    UsageCostSummary,
+    UsageHistoryPayload,
+    UsageMetricsSummary,
+    UsageSummaryPayload,
+    UsageWindowRow,
+    UsageWindowSnapshot,
+    UsageWindowSummary,
+)
+from app.db.models import Account
+
+PLAN_CAPACITY_CREDITS_PRIMARY = {
+    "plus": 225.0,
+    "business": 225.0,
+    "pro": 1500.0,
+}
+
+PLAN_CAPACITY_CREDITS_SECONDARY = {
+    "plus": 7560.0,
+    "business": 7560.0,
+    "pro": 50400.0,
+}
+
+DEFAULT_WINDOW_MINUTES_PRIMARY = 300
+DEFAULT_WINDOW_MINUTES_SECONDARY = 10080
+
+
+def _normalize_window_key(window: str | None) -> str:
+    normalized = (window or "").lower()
+    if normalized in {"primary", "5h"}:
+        return "primary"
+    if normalized in {"secondary", "7d"}:
+        return "secondary"
+    return normalized
+
+
+def _empty_cost() -> UsageCostSummary:
+    return UsageCostSummary(currency="USD", total_usd_7d=0.0, by_model=[])
+
+
+def _empty_window(
+    reset_at: int | None = None,
+    window_minutes: int | None = None,
+) -> UsageWindowSnapshot:
+    return UsageWindowSnapshot(
+        used_percent=0.0,
+        capacity_credits=0.0,
+        used_credits=0.0,
+        reset_at=reset_at,
+        window_minutes=window_minutes,
+    )
+
+
+def used_credits_from_percent(used_percent: float | None, capacity_credits: float | None) -> float | None:
+    if used_percent is None or capacity_credits is None:
+        return None
+    return (capacity_credits * used_percent) / 100.0
+
+
+def remaining_percent_from_used(used_percent: float | None) -> float | None:
+    if used_percent is None:
+        return None
+    return max(0.0, 100.0 - float(used_percent))
+
+
+def remaining_credits_from_used(
+    used_credits: float | None,
+    capacity_credits: float | None,
+) -> float | None:
+    if used_credits is None or capacity_credits is None:
+        return None
+    return max(0.0, float(capacity_credits) - float(used_credits))
+
+
+def remaining_credits_from_percent(
+    used_percent: float | None,
+    capacity_credits: float | None,
+) -> float | None:
+    used_credits = used_credits_from_percent(used_percent, capacity_credits)
+    return remaining_credits_from_used(used_credits, capacity_credits)
+
+
+def normalize_usage_window(summary: UsageWindowSummary) -> UsageWindowSnapshot:
+    return UsageWindowSnapshot(
+        used_percent=float(summary.used_percent or 0.0),
+        capacity_credits=float(summary.capacity_credits),
+        used_credits=float(summary.used_credits),
+        reset_at=summary.reset_at,
+        window_minutes=summary.window_minutes,
+    )
+
+
+def summarize_usage_window(
+    usage_rows: Iterable[UsageWindowRow],
+    account_map: Mapping[str, Account],
+    window: str,
+) -> UsageWindowSummary:
+    total_capacity = 0.0
+    total_used = 0.0
+    reset_candidates: list[int] = []
+    window_minutes: int | None = None
+
+    for row in usage_rows:
+        if row.reset_at is not None:
+            reset_candidates.append(row.reset_at)
+        if row.window_minutes is not None and row.window_minutes > 0:
+            if window_minutes is None or row.window_minutes > window_minutes:
+                window_minutes = row.window_minutes
+        account = account_map.get(row.account_id)
+        capacity = capacity_for_plan(account.plan_type if account else None, window)
+        if row.used_percent is None or capacity is None:
+            continue
+        total_capacity += capacity
+        total_used += (capacity * float(row.used_percent)) / 100.0
+
+    if window_minutes is None:
+        window_minutes = default_window_minutes(window)
+
+    overall = None
+    if total_capacity > 0:
+        overall = (total_used / total_capacity) * 100.0
+    reset_at_value = min(reset_candidates) if reset_candidates else None
+    return UsageWindowSummary(
+        used_percent=float(overall) if overall is not None else None,
+        capacity_credits=float(total_capacity),
+        used_credits=float(total_used),
+        reset_at=reset_at_value,
+        window_minutes=window_minutes,
+    )
+
+
+def capacity_for_plan(plan_type: str | None, window: str) -> float | None:
+    if not plan_type:
+        return None
+    normalized = plan_type.lower()
+    window_key = _normalize_window_key(window)
+    if window_key == "primary":
+        return PLAN_CAPACITY_CREDITS_PRIMARY.get(normalized)
+    if window_key == "secondary":
+        return PLAN_CAPACITY_CREDITS_SECONDARY.get(normalized)
+    return None
+
+
+def default_window_minutes(window: str) -> int | None:
+    window_key = _normalize_window_key(window)
+    if window_key == "primary":
+        return DEFAULT_WINDOW_MINUTES_PRIMARY
+    if window_key == "secondary":
+        return DEFAULT_WINDOW_MINUTES_SECONDARY
+    return None
+
+
+def parse_usage_summary(
+    primary_window: UsageWindowSummary,
+    secondary_window: UsageWindowSummary | None,
+    cost: UsageCostSummary,
+    metrics: UsageMetricsSummary | None = None,
+) -> UsageSummaryPayload:
+    primary = normalize_usage_window(primary_window)
+    secondary = None
+    if secondary_window is not None:
+        secondary = normalize_usage_window(secondary_window)
+    return UsageSummaryPayload(
+        primary_window=primary,
+        secondary_window=secondary,
+        cost=cost,
+        metrics=metrics,
+    )
+
+
+async def usage_summary() -> UsageSummaryPayload:
+    return UsageSummaryPayload(
+        primary_window=_empty_window(window_minutes=None),
+        secondary_window=None,
+        cost=_empty_cost(),
+        metrics=None,
+    )
+
+
+async def usage_history(hours: int) -> UsageHistoryPayload:
+    return UsageHistoryPayload(window_hours=hours, accounts=[])

app/core/usage/logs.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from app.core.usage.pricing import UsageTokens, calculate_cost_from_usage, get_pricing_for_model
+
+
+class RequestLogLike(Protocol):
+    model: str | None
+    input_tokens: int | None
+    output_tokens: int | None
+    cached_input_tokens: int | None
+    reasoning_tokens: int | None
+
+
+def usage_tokens_from_log(log: RequestLogLike) -> UsageTokens | None:
+    input_tokens = log.input_tokens
+    if input_tokens is None:
+        return None
+    output_tokens = log.output_tokens if log.output_tokens is not None else log.reasoning_tokens
+    if output_tokens is None:
+        return None
+    cached_tokens = log.cached_input_tokens or 0
+    cached_tokens = max(0, min(cached_tokens, input_tokens))
+    return UsageTokens(
+        input_tokens=float(input_tokens),
+        output_tokens=float(output_tokens),
+        cached_input_tokens=float(cached_tokens),
+    )
+
+
+def cost_from_log(log: RequestLogLike, *, precision: int | None = None) -> float | None:
+    if not log.model:
+        return None
+    usage = usage_tokens_from_log(log)
+    if not usage:
+        return None
+    resolved = get_pricing_for_model(log.model, None, None)
+    if not resolved:
+        return None
+    _, price = resolved
+    cost = calculate_cost_from_usage(usage, price)
+    if cost is None:
+        return None
+    if precision is None:
+        return cost
+    return round(cost, precision)
+
+
+def total_tokens_from_log(log: RequestLogLike) -> int | None:
+    input_tokens = log.input_tokens
+    output_tokens = log.output_tokens
+    if output_tokens is None and log.reasoning_tokens is not None:
+        output_tokens = log.reasoning_tokens
+    if input_tokens is None and output_tokens is None:
+        return None
+    return (input_tokens or 0) + (output_tokens or 0)

app/core/usage/models.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class UsageWindow(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    used_percent: float | None = None
+    reset_at: int | None = None
+    limit_window_seconds: int | None = None
+    reset_after_seconds: int | None = None
+
+
+class RateLimitPayload(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    primary_window: UsageWindow | None = None
+    secondary_window: UsageWindow | None = None
+
+
+class CreditsPayload(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    has_credits: bool | None = None
+    unlimited: bool | None = None
+    balance: str | None = None
+
+
+class UsagePayload(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    plan_type: str | None = None
+    rate_limit: RateLimitPayload | None = None
+    credits: CreditsPayload | None = None

app/core/usage/pricing.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+from fnmatch import fnmatchcase
+from typing import Iterable, Mapping
+
+from app.core.openai.models import ResponseUsage
+from app.core.usage.types import UsageCostByModel, UsageCostSummary
+
+
+@dataclass(frozen=True)
+class ModelPrice:
+    input_per_1m: float
+    output_per_1m: float
+    cached_input_per_1m: float | None = None
+
+
+@dataclass(frozen=True)
+class UsageTokens:
+    input_tokens: float
+    output_tokens: float
+    cached_input_tokens: float = 0.0
+
+
+@dataclass(frozen=True)
+class CostItem:
+    model: str
+    usage: UsageTokens
+
+
+def _as_number(value: object) -> float | None:
+    if isinstance(value, (int, float)):
+        return float(value)
+    return None
+
+
+def _normalize_usage(usage: UsageTokens | ResponseUsage | None) -> UsageTokens | None:
+    if isinstance(usage, UsageTokens):
+        return usage
+    if not usage:
+        return None
+    input_tokens = _as_number(usage.input_tokens)
+    output_tokens = _as_number(usage.output_tokens)
+    if output_tokens is None and usage.output_tokens_details is not None:
+        output_tokens = _as_number(usage.output_tokens_details.reasoning_tokens)
+    if input_tokens is None or output_tokens is None:
+        return None
+    cached_tokens = 0.0
+    if usage.input_tokens_details is not None:
+        cached_tokens = _as_number(usage.input_tokens_details.cached_tokens) or 0.0
+    cached_tokens = max(0.0, min(cached_tokens, input_tokens))
+    return UsageTokens(
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        cached_input_tokens=cached_tokens,
+    )
+
+
+DEFAULT_PRICING_MODELS: dict[str, ModelPrice] = {
+    "gpt-5.2": ModelPrice(input_per_1m=1.75, cached_input_per_1m=0.175, output_per_1m=14.0),
+    "gpt-5.1": ModelPrice(input_per_1m=1.25, cached_input_per_1m=0.125, output_per_1m=10.0),
+    "gpt-5": ModelPrice(input_per_1m=1.25, cached_input_per_1m=0.125, output_per_1m=10.0),
+    "gpt-5.1-codex-max": ModelPrice(
+        input_per_1m=1.25,
+        cached_input_per_1m=0.125,
+        output_per_1m=10.0,
+    ),
+    "gpt-5.1-codex-mini": ModelPrice(
+        input_per_1m=0.25,
+        cached_input_per_1m=0.025,
+        output_per_1m=2.0,
+    ),
+    "gpt-5.1-codex": ModelPrice(input_per_1m=1.25, cached_input_per_1m=0.125, output_per_1m=10.0),
+    "gpt-5-codex": ModelPrice(input_per_1m=1.25, cached_input_per_1m=0.125, output_per_1m=10.0),
+}
+
+DEFAULT_MODEL_ALIASES: dict[str, str] = {
+    "gpt-5.2*": "gpt-5.2",
+    "gpt-5.1*": "gpt-5.1",
+    "gpt-5*": "gpt-5",
+    "gpt-5.1-codex-max*": "gpt-5.1-codex-max",
+    "gpt-5.1-codex-mini*": "gpt-5.1-codex-mini",
+    "gpt-5.1-codex*": "gpt-5.1-codex",
+    "gpt-5-codex*": "gpt-5-codex",
+}
+
+
+def resolve_model_alias(model: str, aliases: Mapping[str, str]) -> str | None:
+    if not model:
+        return None
+    normalized = model.lower()
+    matched: list[tuple[int, str]] = []
+    for pattern, target in aliases.items():
+        if fnmatchcase(normalized, pattern.lower()):
+            matched.append((len(pattern), target))
+    if not matched:
+        return None
+    return max(matched, key=lambda item: item[0])[1]
+
+
+def get_pricing_for_model(
+    model: str,
+    pricing: Mapping[str, ModelPrice] | None = None,
+    aliases: Mapping[str, str] | None = None,
+) -> tuple[str, ModelPrice] | None:
+    if not model:
+        return None
+    pricing = pricing or DEFAULT_PRICING_MODELS
+    aliases = aliases or DEFAULT_MODEL_ALIASES
+
+    normalized = model.lower()
+    for key, value in pricing.items():
+        if key.lower() == normalized:
+            return key, value
+
+    alias = resolve_model_alias(normalized, aliases)
+    if not alias:
+        return None
+    for key, value in pricing.items():
+        if key.lower() == alias.lower():
+            return key, value
+    return None
+
+
+def calculate_cost_from_usage(usage: UsageTokens | ResponseUsage | None, price: ModelPrice) -> float | None:
+    normalized = _normalize_usage(usage)
+    if not normalized:
+        return None
+    billable_input = normalized.input_tokens - normalized.cached_input_tokens
+
+    input_rate = price.input_per_1m
+    cached_rate = price.cached_input_per_1m if price.cached_input_per_1m is not None else input_rate
+    output_rate = price.output_per_1m
+
+    return (
+        (billable_input / 1_000_000) * input_rate
+        + (normalized.cached_input_tokens / 1_000_000) * cached_rate
+        + (normalized.output_tokens / 1_000_000) * output_rate
+    )
+
+
+def calculate_costs(
+    items: Iterable[CostItem],
+    pricing: Mapping[str, ModelPrice] | None = None,
+    aliases: Mapping[str, str] | None = None,
+) -> UsageCostSummary:
+    pricing = pricing or DEFAULT_PRICING_MODELS
+    aliases = aliases or DEFAULT_MODEL_ALIASES
+
+    totals: dict[str, float] = defaultdict(float)
+    total_usd = 0.0
+
+    for item in items:
+        model = item.model
+        usage = item.usage
+        resolved = get_pricing_for_model(model, pricing, aliases)
+        if not resolved:
+            continue
+        canonical, price = resolved
+        cost = calculate_cost_from_usage(usage, price)
+        if cost is None:
+            continue
+        totals[canonical] += cost
+        total_usd += cost
+
+    by_model = [UsageCostByModel(model=model, usd=round(value, 6)) for model, value in sorted(totals.items())]
+    return UsageCostSummary(
+        currency="USD",
+        total_usd_7d=round(total_usd, 6),
+        by_model=by_model,
+    )

app/core/usage/types.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass(frozen=True)
+class UsageWindowRow:
+    account_id: str
+    used_percent: float | None
+    reset_at: int | None = None
+    window_minutes: int | None = None
+
+
+@dataclass(frozen=True)
+class UsageAggregateRow:
+    account_id: str
+    used_percent_avg: float | None
+    input_tokens_sum: int | None
+    output_tokens_sum: int | None
+    samples: int
+    last_recorded_at: datetime | None
+    reset_at_max: int | None
+    window_minutes_max: int | None
+
+    def to_window_row(self) -> UsageWindowRow:
+        return UsageWindowRow(
+            account_id=self.account_id,
+            used_percent=self.used_percent_avg,
+            reset_at=self.reset_at_max,
+            window_minutes=self.window_minutes_max,
+        )
+
+
+@dataclass(frozen=True)
+class UsageWindowSummary:
+    used_percent: float | None
+    capacity_credits: float
+    used_credits: float
+    reset_at: int | None
+    window_minutes: int | None
+
+
+@dataclass(frozen=True)
+class UsageWindowSnapshot:
+    used_percent: float
+    capacity_credits: float
+    used_credits: float
+    reset_at: int | None
+    window_minutes: int | None
+
+
+@dataclass(frozen=True)
+class UsageCostByModel:
+    model: str
+    usd: float
+
+
+@dataclass(frozen=True)
+class UsageCostSummary:
+    currency: str
+    total_usd_7d: float
+    by_model: list[UsageCostByModel]
+
+
+@dataclass(frozen=True)
+class UsageMetricsSummary:
+    requests_7d: int | None
+    tokens_secondary_window: int | None
+    error_rate_7d: float | None
+    top_error: str | None
+
+
+@dataclass(frozen=True)
+class UsageSummaryPayload:
+    primary_window: UsageWindowSnapshot
+    secondary_window: UsageWindowSnapshot | None
+    cost: UsageCostSummary
+    metrics: UsageMetricsSummary | None = None
+
+
+@dataclass(frozen=True)
+class UsageHistoryEntry:
+    account_id: str
+    email: str
+    used_percent_avg: float
+    used_credits: float
+    request_count: int
+    cost_usd: float
+
+
+@dataclass(frozen=True)
+class UsageHistoryPayload:
+    window_hours: int
+    accounts: list[UsageHistoryEntry]

app/core/utils/request_id.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from contextvars import ContextVar, Token
+from uuid import uuid4
+
+_REQUEST_ID: ContextVar[str | None] = ContextVar("request_id", default=None)
+
+
+def get_request_id() -> str | None:
+    return _REQUEST_ID.get()
+
+
+def set_request_id(value: str | None) -> Token[str | None]:
+    return _REQUEST_ID.set(value)
+
+
+def reset_request_id(token: Token[str | None]) -> None:
+    _REQUEST_ID.reset(token)
+
+
+def ensure_request_id(value: str | None = None) -> str:
+    if value:
+        _REQUEST_ID.set(value)
+        return value
+    current = _REQUEST_ID.get()
+    if current:
+        return current
+    generated = str(uuid4())
+    _REQUEST_ID.set(generated)
+    return generated

app/core/utils/retry.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import re
+
+_RETRY_PATTERN = re.compile(r"(?i)try again in\s*(\d+(?:\.\d+)?)\s*(s|ms|seconds?)")
+
+
+def parse_retry_after(message: str) -> float | None:
+    match = _RETRY_PATTERN.search(message or "")
+    if not match:
+        return None
+    value = float(match.group(1))
+    unit = match.group(2).lower()
+    if unit == "ms":
+        return value / 1000
+    return value

app/core/utils/sse.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import json
+
+from app.core.types import JsonObject
+
+
+def format_sse_event(payload: JsonObject) -> str:
+    data = json.dumps(payload, ensure_ascii=True, separators=(",", ":"))
+    event_type = payload.get("type")
+    if isinstance(event_type, str) and event_type:
+        return f"event: {event_type}\ndata: {data}\n\n"
+    return f"data: {data}\n\n"

app/core/utils/time.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+
+def utcnow() -> datetime:
+    return datetime.now(timezone.utc).replace(tzinfo=None)
+
+
+def to_utc_naive(value: datetime) -> datetime:
+    if value.tzinfo is None:
+        return value
+    return value.astimezone(timezone.utc).replace(tzinfo=None)
+
+
+def from_epoch_seconds(value: int | float | None) -> datetime | None:
+    if value is None:
+        return None
+    return datetime.fromtimestamp(value, tz=timezone.utc)