mirror of
https://github.com/BerriAI/litellm.git
synced 2026-11-16 09:22:22 +00:00
Merge d39df0d4ac into dbcacc7ab7
This commit is contained in:
commit
3e9e702c87
49 changed files with 3485 additions and 22 deletions
1
.github/workflows/test-unit.yml
vendored
1
.github/workflows/test-unit.yml
vendored
|
|
@ -227,6 +227,7 @@ jobs:
|
|||
tests/unit/llms/test_oss_decision.py
|
||||
tests/unit/llms/test_polling_url_origin_match.py
|
||||
tests/unit/llms/test_predibase_transformation.py
|
||||
tests/unit/llms/test_subscription_accounts.py
|
||||
tests/unit/llms/a2a
|
||||
tests/unit/llms/aiml
|
||||
tests/unit/llms/aiohttp_openai
|
||||
|
|
|
|||
|
|
@ -55,6 +55,7 @@ BACKEND_PATH_PREFIXES: tuple[str, ...] = (
|
|||
"/cache_settings",
|
||||
"/coordination_redis/",
|
||||
"/cost_tracking",
|
||||
"/subscription_accounts/",
|
||||
"/cost_optimization/",
|
||||
"/cost/",
|
||||
"/credentials",
|
||||
|
|
|
|||
|
|
@ -0,0 +1,21 @@
|
|||
SET LOCAL lock_timeout = '10s';
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE IF NOT EXISTS "LiteLLM_SubscriptionAccountTable" (
|
||||
"subscription_account_id" TEXT NOT NULL,
|
||||
"custom_llm_provider" TEXT NOT NULL,
|
||||
"account_id" TEXT NOT NULL,
|
||||
"label" TEXT,
|
||||
"monthly_fee" DOUBLE PRECISION NOT NULL,
|
||||
"currency" TEXT NOT NULL,
|
||||
"billing_period_start" TEXT NOT NULL,
|
||||
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"created_by" TEXT NOT NULL,
|
||||
"updated_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"updated_by" TEXT NOT NULL,
|
||||
|
||||
CONSTRAINT "LiteLLM_SubscriptionAccountTable_pkey" PRIMARY KEY ("subscription_account_id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX IF NOT EXISTS "LiteLLM_SubscriptionAccountTable_provider_account_key" ON "LiteLLM_SubscriptionAccountTable"("custom_llm_provider", "account_id");
|
||||
|
|
@ -2131,3 +2131,19 @@ model LiteLLM_AccountingDelivery {
|
|||
@@id([event_id, target, version])
|
||||
@@index([target, state, next_attempt_at])
|
||||
}
|
||||
|
||||
model LiteLLM_SubscriptionAccountTable {
|
||||
subscription_account_id String @id @default(uuid())
|
||||
custom_llm_provider String
|
||||
account_id String
|
||||
label String?
|
||||
monthly_fee Float
|
||||
currency String
|
||||
billing_period_start String
|
||||
created_at DateTime @default(now()) @map("created_at")
|
||||
created_by String
|
||||
updated_at DateTime @default(now()) @updatedAt @map("updated_at")
|
||||
updated_by String
|
||||
|
||||
@@unique([custom_llm_provider, account_id], map: "LiteLLM_SubscriptionAccountTable_provider_account_key")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -897,6 +897,7 @@ PROVIDERS_THAT_AUTHENTICATE_ON_PROVIDER_INFO: Final = frozenset(
|
|||
}
|
||||
)
|
||||
|
||||
SUBSCRIPTION_BACKED_PROVIDERS: Final = frozenset({"chatgpt"})
|
||||
A2A_CHAT_COMPLETION_BRIDGE_PROVIDERS: Final = frozenset({"databricks_agent"})
|
||||
|
||||
LITELLM_EMBEDDING_PROVIDERS_SUPPORTING_INPUT_ARRAY_OF_TOKENS: Final = [
|
||||
|
|
|
|||
|
|
@ -361,6 +361,7 @@ _PRISMA_MODELS: Final[frozenset[str]] = frozenset(
|
|||
"LiteLLM_LensReview",
|
||||
"LiteLLM_LensIngestionKey",
|
||||
"LiteLLM_LensWorker",
|
||||
"LiteLLM_SubscriptionAccountTable",
|
||||
"LiteLLM_LensSignalConfig",
|
||||
"LiteLLM_LensTraceSignal",
|
||||
)
|
||||
|
|
|
|||
|
|
@ -122,6 +122,12 @@ class Authenticator:
|
|||
return tokens["access_token"]
|
||||
|
||||
def get_account_id(self, access_token: str | None = None) -> str | None:
|
||||
return self._account_id(access_token, persist_derived=True)
|
||||
|
||||
def read_account_id(self, access_token: str | None = None) -> str | None:
|
||||
return self._account_id(access_token, persist_derived=False)
|
||||
|
||||
def _account_id(self, access_token: str | None, persist_derived: bool) -> str | None:
|
||||
auth_data: Final = self._read_auth_file()
|
||||
if access_token and (not auth_data or auth_data.get("access_token") != access_token):
|
||||
return extract_chatgpt_account_id(access_token)
|
||||
|
|
@ -133,7 +139,7 @@ class Authenticator:
|
|||
id_token: Final = auth_data.get("id_token")
|
||||
saved_access_token: Final = auth_data.get("access_token")
|
||||
derived: Final = extract_chatgpt_account_id(_optional_str(id_token or saved_access_token))
|
||||
if derived:
|
||||
if derived and persist_derived:
|
||||
self._write_auth_file({**auth_data, "account_id": derived})
|
||||
return derived
|
||||
|
||||
|
|
|
|||
37
litellm/llms/subscription_accounts.py
Normal file
37
litellm/llms/subscription_accounts.py
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
"""
|
||||
Providers whose requests are covered by a flat subscription, each with the way to read
|
||||
the account id of the login a deployment is signed into.
|
||||
"""
|
||||
|
||||
from collections.abc import Callable, Mapping
|
||||
from types import MappingProxyType
|
||||
from typing import Final
|
||||
|
||||
from litellm.llms.chatgpt.authenticator import Authenticator, get_cached_authenticator, get_chatgpt_auth_file
|
||||
from litellm.secret_managers.main import UnresolvableSecretReference, resolve_local_oidc_reference
|
||||
from litellm.utils import with_named_credential
|
||||
|
||||
|
||||
def _chatgpt_account_id(litellm_params: Mapping[str, object]) -> str | None:
|
||||
params: Final = with_named_credential(litellm_params)
|
||||
auth_file: Final = get_chatgpt_auth_file(params)
|
||||
if auth_file:
|
||||
return get_cached_authenticator(auth_file).read_account_id()
|
||||
api_key: Final = params.get("api_key")
|
||||
if not isinstance(api_key, str) or not api_key:
|
||||
return Authenticator().read_account_id()
|
||||
match resolve_local_oidc_reference(api_key):
|
||||
case UnresolvableSecretReference():
|
||||
return None
|
||||
case str() as access_token:
|
||||
return Authenticator().read_account_id(access_token)
|
||||
|
||||
|
||||
SUBSCRIPTION_ACCOUNT_ID_RESOLVERS: Final[Mapping[str, Callable[[Mapping[str, object]], str | None]]] = MappingProxyType(
|
||||
{"chatgpt": _chatgpt_account_id}
|
||||
)
|
||||
|
||||
|
||||
def resolve_subscription_account_id(custom_llm_provider: str, litellm_params: Mapping[str, object]) -> str | None:
|
||||
resolver: Final = SUBSCRIPTION_ACCOUNT_ID_RESOLVERS.get(custom_llm_provider)
|
||||
return None if resolver is None else resolver(litellm_params)
|
||||
|
|
@ -30,6 +30,7 @@ from litellm.models.organization_membership import LiteLLM_OrganizationMembershi
|
|||
from litellm.models.project import LiteLLM_ProjectTable
|
||||
from litellm.models.skills import LiteLLM_SkillsTable
|
||||
from litellm.models.spend_logs import LiteLLM_ErrorLogs, LiteLLM_SpendLogs
|
||||
from litellm.models.subscription_account import LiteLLM_SubscriptionAccountTable
|
||||
from litellm.models.tag import LiteLLM_TagTable
|
||||
from litellm.models.team import LiteLLM_TeamTable
|
||||
from litellm.models.team_membership import LiteLLM_TeamMembership
|
||||
|
|
@ -59,6 +60,7 @@ __all__ = [
|
|||
"LiteLLM_ProxyModelTable",
|
||||
"LiteLLM_SkillsTable",
|
||||
"LiteLLM_SpendLogs",
|
||||
"LiteLLM_SubscriptionAccountTable",
|
||||
"LiteLLM_TagTable",
|
||||
"LiteLLM_TeamMemberTable",
|
||||
"LiteLLM_TeamMembership",
|
||||
|
|
|
|||
28
litellm/models/subscription_account.py
Normal file
28
litellm/models/subscription_account.py
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
"""
|
||||
Subscription account table model.
|
||||
|
||||
Canonical definition for ``litellm_subscriptionaccounttable``: the operator-entered
|
||||
recurring fee of a provider account whose requests are covered by a flat subscription.
|
||||
"""
|
||||
|
||||
from datetime import datetime
|
||||
|
||||
from pydantic import ConfigDict
|
||||
|
||||
from litellm.types.llms.base import LiteLLMPydanticObjectBase
|
||||
|
||||
|
||||
class LiteLLM_SubscriptionAccountTable(LiteLLMPydanticObjectBase):
|
||||
model_config = ConfigDict(protected_namespaces=(), frozen=True)
|
||||
|
||||
subscription_account_id: str
|
||||
custom_llm_provider: str
|
||||
account_id: str
|
||||
label: str | None = None
|
||||
monthly_fee: float
|
||||
currency: str
|
||||
billing_period_start: str
|
||||
created_at: datetime
|
||||
created_by: str
|
||||
updated_at: datetime
|
||||
updated_by: str
|
||||
|
|
@ -667,6 +667,10 @@ class LiteLLMRoutes(enum.Enum):
|
|||
"/team/spend/by_user",
|
||||
# gateway request counts (SGR); deployment-wide, admin-only
|
||||
"/gateway/daily/activity",
|
||||
"/subscription_accounts/usage",
|
||||
"/subscription_accounts/new",
|
||||
"/subscription_accounts/update",
|
||||
"/subscription_accounts/delete",
|
||||
# model
|
||||
"/model/new",
|
||||
"/model/update",
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ from typing_extensions import ReadOnly, TypedDict, assert_never
|
|||
|
||||
from litellm import constants
|
||||
from litellm._logging import verbose_proxy_logger
|
||||
from litellm.constants import PTU_SENTINEL_API_KEY
|
||||
from litellm.constants import PTU_SENTINEL_API_KEY, SUBSCRIPTION_BACKED_PROVIDERS
|
||||
from litellm.proxy._types import CommonProxyErrors
|
||||
from litellm.proxy.spend_tracking.key_metadata_recovery import (
|
||||
attach_user_details,
|
||||
|
|
@ -295,6 +295,12 @@ def _entity_metadata(
|
|||
return stored if stored is not None else {}
|
||||
|
||||
|
||||
def provider_bucket_metadata(provider: str, base: Mapping[str, object]) -> Mapping[str, object]:
|
||||
if provider in SUBSCRIPTION_BACKED_PROVIDERS:
|
||||
return {**base, "subscription_covered": True}
|
||||
return dict(base)
|
||||
|
||||
|
||||
def update_breakdown_metrics(
|
||||
breakdown: BreakdownMetrics,
|
||||
record: DailySpendRecord,
|
||||
|
|
@ -395,7 +401,7 @@ def update_breakdown_metrics(
|
|||
if provider not in breakdown.providers:
|
||||
breakdown.providers[provider] = MetricWithMetadata(
|
||||
metrics=SpendMetrics(),
|
||||
metadata=provider_metadata.get(provider, {}), # Add any provider-specific metadata here
|
||||
metadata=provider_bucket_metadata(provider, provider_metadata.get(provider, {})),
|
||||
)
|
||||
breakdown.providers[provider].metrics = update_metrics(breakdown.providers[provider].metrics, record)
|
||||
|
||||
|
|
@ -795,12 +801,23 @@ def _aggregate_grouping_sets_records_sync(
|
|||
grouped_data[date_str] = bucket
|
||||
return bucket
|
||||
|
||||
def assign_metric_with_metadata(target: dict[str, MetricWithMetadata], key: str, metrics: SpendMetrics) -> None:
|
||||
def assign_metric_with_metadata(
|
||||
target: dict[str, MetricWithMetadata],
|
||||
key: str,
|
||||
metrics: SpendMetrics,
|
||||
metadata: Mapping[str, object] | None = None,
|
||||
) -> None:
|
||||
existing: Final = target.get(key)
|
||||
if existing is None:
|
||||
target[key] = MetricWithMetadata(metrics=metrics, metadata={})
|
||||
else:
|
||||
existing.metrics = sum_spend_metrics((existing.metrics, metrics))
|
||||
target[key] = (
|
||||
MetricWithMetadata(metrics=metrics, metadata=dict(metadata or {}))
|
||||
if existing is None
|
||||
else existing.model_copy(
|
||||
update={
|
||||
"metrics": sum_spend_metrics((existing.metrics, metrics)),
|
||||
"metadata": {**existing.metadata, **(metadata or {})},
|
||||
}
|
||||
)
|
||||
)
|
||||
|
||||
def assign_api_key_breakdown(
|
||||
target: dict[str, MetricWithMetadata],
|
||||
|
|
@ -864,7 +881,9 @@ def _aggregate_grouping_sets_records_sync(
|
|||
# provider the base build reported.
|
||||
provider_metrics = metrics.model_copy(update={"flat_cost": 0.0})
|
||||
provider = record.custom_llm_provider or "unknown"
|
||||
assign_metric_with_metadata(breakdown.providers, provider, provider_metrics)
|
||||
assign_metric_with_metadata(
|
||||
breakdown.providers, provider, provider_metrics, provider_bucket_metadata(provider, {})
|
||||
)
|
||||
elif level == _GROUP_DATE_PROVIDER_API_KEY:
|
||||
if not is_ptu_sentinel:
|
||||
provider = record.custom_llm_provider or "unknown"
|
||||
|
|
|
|||
335
litellm/proxy/management_endpoints/subscription_accounts.py
Normal file
335
litellm/proxy/management_endpoints/subscription_accounts.py
Normal file
|
|
@ -0,0 +1,335 @@
|
|||
"""
|
||||
Subscription accounts: the operator-entered recurring fee of a provider account whose
|
||||
requests are covered by a flat subscription, shown beside metered spend on the Usage page.
|
||||
"""
|
||||
|
||||
import re
|
||||
from collections.abc import Callable, Iterable, Mapping
|
||||
from dataclasses import dataclass
|
||||
from datetime import date
|
||||
from itertools import chain
|
||||
from typing import TYPE_CHECKING, Annotated, Final, TypeAlias
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
||||
from pydantic import TypeAdapter
|
||||
|
||||
from litellm.constants import LITELLM_PROXY_ADMIN_NAME, SUBSCRIPTION_BACKED_PROVIDERS
|
||||
from litellm.litellm_core_utils.get_llm_provider_logic import declared_authenticating_provider
|
||||
from litellm.llms.subscription_accounts import resolve_subscription_account_id
|
||||
from litellm.models.subscription_account import LiteLLM_SubscriptionAccountTable
|
||||
from litellm.proxy._types import CommonProxyErrors, LitellmUserRoles, UserAPIKeyAuth, user_api_key_has_admin_view
|
||||
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
|
||||
from litellm.proxy.spend_tracking.subscription_billing_periods import billing_periods_starting_within
|
||||
from litellm.proxy.utils import get_prisma_client_or_throw
|
||||
from litellm.repositories.subscription_account_repository import (
|
||||
DuplicateSubscriptionAccount,
|
||||
KeepLabel,
|
||||
SetLabel,
|
||||
SubscriptionAccountFeeChanges,
|
||||
SubscriptionAccountFeeFields,
|
||||
SubscriptionAccountRepository,
|
||||
SubscriptionAccountStore,
|
||||
)
|
||||
from litellm.types.proxy.management_endpoints.subscription_accounts import (
|
||||
BillingPeriod,
|
||||
DeleteSubscriptionAccountRequest,
|
||||
SubscriptionAccountFeeRequest,
|
||||
SubscriptionAccountUsage,
|
||||
SubscriptionUsageResponse,
|
||||
UpdateSubscriptionAccountFeeRequest,
|
||||
)
|
||||
from litellm.types.router import DeploymentTypedDict
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from litellm.router import Router
|
||||
|
||||
router: Final = APIRouter(prefix="/subscription_accounts", tags=["subscription accounts"])
|
||||
Auth: TypeAlias = Annotated[UserAPIKeyAuth, Depends(user_api_key_auth)]
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SubscriptionDeployment:
|
||||
model_name: str
|
||||
custom_llm_provider: str
|
||||
account_id: str | None
|
||||
|
||||
|
||||
AccountIdResolver: TypeAlias = Callable[[str, Mapping[str, object]], str | None]
|
||||
_MODEL_INFO_ADAPTER: Final = TypeAdapter(Mapping[str, object])
|
||||
|
||||
|
||||
def _declared_provider(litellm_params: Mapping[str, object]) -> str | None:
|
||||
model: Final = litellm_params.get("model")
|
||||
configured_provider: Final = litellm_params.get("custom_llm_provider")
|
||||
return declared_authenticating_provider(
|
||||
model if isinstance(model, str) else None,
|
||||
configured_provider if isinstance(configured_provider, str) else None,
|
||||
)
|
||||
|
||||
|
||||
def _model_info(deployment: Mapping[str, object]) -> Mapping[str, object]:
|
||||
return _MODEL_INFO_ADAPTER.validate_python(deployment.get("model_info") or {})
|
||||
|
||||
|
||||
def _public_model_name(entry: DeploymentTypedDict) -> str:
|
||||
team_public_model_name: Final = _model_info(entry).get("team_public_model_name")
|
||||
return team_public_model_name if isinstance(team_public_model_name, str) else entry["model_name"]
|
||||
|
||||
|
||||
def _subscription_deployment(
|
||||
entry: DeploymentTypedDict, account_id_resolver: AccountIdResolver
|
||||
) -> SubscriptionDeployment | None:
|
||||
litellm_params: Final = entry["litellm_params"]
|
||||
provider: Final = _declared_provider(litellm_params)
|
||||
if provider is None or provider not in SUBSCRIPTION_BACKED_PROVIDERS:
|
||||
return None
|
||||
return SubscriptionDeployment(
|
||||
model_name=_public_model_name(entry),
|
||||
custom_llm_provider=provider,
|
||||
account_id=account_id_resolver(provider, litellm_params),
|
||||
)
|
||||
|
||||
|
||||
def subscription_deployments_from_model_list(
|
||||
model_list: Iterable[DeploymentTypedDict], account_id_resolver: AccountIdResolver
|
||||
) -> tuple[SubscriptionDeployment, ...]:
|
||||
candidates: Final = (_subscription_deployment(entry, account_id_resolver) for entry in model_list)
|
||||
return tuple(candidate for candidate in candidates if candidate is not None)
|
||||
|
||||
|
||||
def subscription_deployments_of_router(
|
||||
llm_router: "Router | None", account_id_resolver: AccountIdResolver
|
||||
) -> tuple[SubscriptionDeployment, ...]:
|
||||
if llm_router is None:
|
||||
return ()
|
||||
registry: Final = llm_router.registry()
|
||||
indexed_names: Final = tuple(registry.index("model_name"))
|
||||
deployments: Final = chain.from_iterable(registry.deployments(name, source="named") or () for name in indexed_names)
|
||||
return subscription_deployments_from_model_list(deployments, account_id_resolver)
|
||||
|
||||
|
||||
def get_subscription_deployments() -> tuple[SubscriptionDeployment, ...]:
|
||||
from litellm.proxy.proxy_server import llm_router
|
||||
|
||||
return subscription_deployments_of_router(llm_router, resolve_subscription_account_id)
|
||||
|
||||
|
||||
def get_subscription_account_repository() -> SubscriptionAccountStore:
|
||||
return SubscriptionAccountRepository(get_prisma_client_or_throw(CommonProxyErrors.db_not_connected_error.value))
|
||||
|
||||
|
||||
Store: TypeAlias = Annotated[SubscriptionAccountStore, Depends(get_subscription_account_repository)]
|
||||
Deployments: TypeAlias = Annotated[tuple[SubscriptionDeployment, ...], Depends(get_subscription_deployments)]
|
||||
|
||||
|
||||
def _forbidden(user_api_key_dict: UserAPIKeyAuth) -> HTTPException:
|
||||
return HTTPException(
|
||||
status_code=status.HTTP_403_FORBIDDEN,
|
||||
detail={"error": f"{CommonProxyErrors.not_allowed_access.value}, your role={user_api_key_dict.user_role}"},
|
||||
)
|
||||
|
||||
|
||||
def _account_usage(
|
||||
custom_llm_provider: str,
|
||||
account_id: str | None,
|
||||
deployments: Iterable[SubscriptionDeployment],
|
||||
fee_row: LiteLLM_SubscriptionAccountTable | None,
|
||||
start_date: date,
|
||||
end_date: date,
|
||||
) -> SubscriptionAccountUsage:
|
||||
model_names: Final = tuple(sorted({deployment.model_name for deployment in deployments}))
|
||||
if fee_row is None:
|
||||
return SubscriptionAccountUsage(
|
||||
custom_llm_provider=custom_llm_provider,
|
||||
account_id=account_id,
|
||||
deployments=model_names,
|
||||
fee=None,
|
||||
billing_periods=(),
|
||||
fixed_cost=None,
|
||||
)
|
||||
periods: Final = billing_periods_starting_within(
|
||||
date.fromisoformat(fee_row.billing_period_start), start_date, end_date
|
||||
)
|
||||
return SubscriptionAccountUsage(
|
||||
custom_llm_provider=custom_llm_provider,
|
||||
account_id=account_id,
|
||||
deployments=model_names,
|
||||
fee=fee_row,
|
||||
billing_periods=tuple(BillingPeriod(start=period.start, end=period.end) for period in periods),
|
||||
fixed_cost=len(periods) * fee_row.monthly_fee,
|
||||
)
|
||||
|
||||
|
||||
def build_subscription_usage(
|
||||
deployments: Iterable[SubscriptionDeployment],
|
||||
fee_rows: Iterable[LiteLLM_SubscriptionAccountTable],
|
||||
start_date: date,
|
||||
end_date: date,
|
||||
) -> SubscriptionUsageResponse:
|
||||
deployment_tuple: Final = tuple(deployments)
|
||||
fees_by_account: Final = {(row.custom_llm_provider, row.account_id): row for row in fee_rows}
|
||||
deployment_keys: Final = {(d.custom_llm_provider, d.account_id) for d in deployment_tuple}
|
||||
account_keys: Final = sorted(deployment_keys | set(fees_by_account), key=lambda key: (key[0], key[1] or "~"))
|
||||
accounts: Final = tuple(
|
||||
_account_usage(
|
||||
provider,
|
||||
account_id,
|
||||
(d for d in deployment_tuple if (d.custom_llm_provider, d.account_id) == (provider, account_id)),
|
||||
fees_by_account.get((provider, account_id)) if account_id is not None else None,
|
||||
start_date,
|
||||
end_date,
|
||||
)
|
||||
for provider, account_id in account_keys
|
||||
)
|
||||
return SubscriptionUsageResponse(
|
||||
start_date=start_date,
|
||||
end_date=end_date,
|
||||
subscription_providers=tuple(sorted(SUBSCRIPTION_BACKED_PROVIDERS)),
|
||||
accounts=accounts,
|
||||
)
|
||||
|
||||
|
||||
_DAY_PATTERN: Final = re.compile(r"\d{4}-\d{2}-\d{2}")
|
||||
|
||||
|
||||
def _parse_day(value: str) -> date | None:
|
||||
if _DAY_PATTERN.fullmatch(value) is None:
|
||||
return None
|
||||
try:
|
||||
return date.fromisoformat(value)
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def _parse_date(value: str, name: str) -> date:
|
||||
parsed: Final = _parse_day(value)
|
||||
if parsed is None:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST, detail={"error": f"{name} must be YYYY-MM-DD, got {value!r}"}
|
||||
)
|
||||
return parsed
|
||||
|
||||
|
||||
@router.get("/usage", response_model=SubscriptionUsageResponse, dependencies=[Depends(user_api_key_auth)])
|
||||
async def get_subscription_usage(
|
||||
start_date: Annotated[str, Query(description="First day of the Usage page filter, YYYY-MM-DD")],
|
||||
end_date: Annotated[str, Query(description="Last day of the Usage page filter, YYYY-MM-DD")],
|
||||
user_api_key_dict: Auth,
|
||||
repository: Store,
|
||||
deployments: Deployments,
|
||||
) -> SubscriptionUsageResponse:
|
||||
"""
|
||||
Subscription-backed accounts behind the proxy's deployments or carrying a stored fee, each with
|
||||
its configured monthly fee and the fixed cost attributed to the date range: the fee once per billing
|
||||
period whose start date falls inside the range, however many deployments share the account.
|
||||
"""
|
||||
if not user_api_key_has_admin_view(user_api_key_dict):
|
||||
raise _forbidden(user_api_key_dict)
|
||||
start: Final = _parse_date(start_date, "start_date")
|
||||
end: Final = _parse_date(end_date, "end_date")
|
||||
if end < start:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST, detail={"error": "end_date must not be before start_date"}
|
||||
)
|
||||
return build_subscription_usage(deployments, await repository.list_all(), start, end)
|
||||
|
||||
|
||||
def _require_proxy_admin(user_api_key_dict: UserAPIKeyAuth) -> None:
|
||||
if user_api_key_dict.user_role != LitellmUserRoles.PROXY_ADMIN:
|
||||
raise _forbidden(user_api_key_dict)
|
||||
|
||||
|
||||
def _actor(user_api_key_dict: UserAPIKeyAuth) -> str:
|
||||
return user_api_key_dict.user_id or LITELLM_PROXY_ADMIN_NAME
|
||||
|
||||
|
||||
@router.post("/new", response_model=LiteLLM_SubscriptionAccountTable, dependencies=[Depends(user_api_key_auth)])
|
||||
async def new_subscription_account(
|
||||
request: SubscriptionAccountFeeRequest,
|
||||
user_api_key_dict: Auth,
|
||||
repository: Store,
|
||||
) -> LiteLLM_SubscriptionAccountTable:
|
||||
"""Record the monthly fee of one subscription-backed provider account."""
|
||||
_require_proxy_admin(user_api_key_dict)
|
||||
if request.custom_llm_provider not in SUBSCRIPTION_BACKED_PROVIDERS:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail={
|
||||
"error": f"{request.custom_llm_provider!r} is not a subscription-backed provider; "
|
||||
f"expected one of {sorted(SUBSCRIPTION_BACKED_PROVIDERS)}"
|
||||
},
|
||||
)
|
||||
created: Final = await repository.create_account(
|
||||
request.custom_llm_provider,
|
||||
request.account_id,
|
||||
SubscriptionAccountFeeFields(
|
||||
monthly_fee=request.monthly_fee,
|
||||
currency=request.currency,
|
||||
billing_period_start=request.billing_period_start.isoformat(),
|
||||
label=request.label,
|
||||
),
|
||||
_actor(user_api_key_dict),
|
||||
)
|
||||
if isinstance(created, DuplicateSubscriptionAccount):
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail={
|
||||
"error": f"A fee is already configured for {created.custom_llm_provider} account "
|
||||
f"{created.account_id}; use /subscription_accounts/update to change it"
|
||||
},
|
||||
)
|
||||
return created
|
||||
|
||||
|
||||
def _fee_changes(request: UpdateSubscriptionAccountFeeRequest) -> SubscriptionAccountFeeChanges:
|
||||
return SubscriptionAccountFeeChanges(
|
||||
monthly_fee=request.monthly_fee,
|
||||
currency=request.currency,
|
||||
billing_period_start=(
|
||||
request.billing_period_start.isoformat() if request.billing_period_start is not None else None
|
||||
),
|
||||
label=SetLabel(request.label) if "label" in request.model_fields_set else KeepLabel(),
|
||||
)
|
||||
|
||||
|
||||
@router.post("/update", response_model=LiteLLM_SubscriptionAccountTable, dependencies=[Depends(user_api_key_auth)])
|
||||
async def update_subscription_account(
|
||||
request: UpdateSubscriptionAccountFeeRequest,
|
||||
user_api_key_dict: Auth,
|
||||
repository: Store,
|
||||
) -> LiteLLM_SubscriptionAccountTable:
|
||||
"""
|
||||
Change the fee, currency, billing period start, or label of a subscription account.
|
||||
Only the fields named in the request are written, so two admins changing different
|
||||
fields at the same time both land.
|
||||
"""
|
||||
_require_proxy_admin(user_api_key_dict)
|
||||
updated: Final = await repository.update_fee(
|
||||
request.subscription_account_id, _fee_changes(request), _actor(user_api_key_dict)
|
||||
)
|
||||
if updated is None:
|
||||
raise _not_found(request.subscription_account_id)
|
||||
return updated
|
||||
|
||||
|
||||
@router.post("/delete", response_model=LiteLLM_SubscriptionAccountTable, dependencies=[Depends(user_api_key_auth)])
|
||||
async def delete_subscription_account(
|
||||
request: DeleteSubscriptionAccountRequest,
|
||||
user_api_key_dict: Auth,
|
||||
repository: Store,
|
||||
) -> LiteLLM_SubscriptionAccountTable:
|
||||
"""Stop tracking a subscription account's fee; its requests stay marked as subscription-covered."""
|
||||
_require_proxy_admin(user_api_key_dict)
|
||||
if await repository.find_by_id(request.subscription_account_id) is None:
|
||||
raise _not_found(request.subscription_account_id)
|
||||
deleted: Final = await repository.delete_account(request.subscription_account_id)
|
||||
if deleted is None:
|
||||
raise _not_found(request.subscription_account_id)
|
||||
return deleted
|
||||
|
||||
|
||||
def _not_found(subscription_account_id: str) -> HTTPException:
|
||||
return HTTPException(
|
||||
status_code=status.HTTP_404_NOT_FOUND,
|
||||
detail={"error": f"No subscription account with id {subscription_account_id}"},
|
||||
)
|
||||
|
|
@ -776,6 +776,9 @@ from litellm.proxy.management_endpoints.session_endpoints import (
|
|||
router as session_management_router,
|
||||
)
|
||||
from litellm.proxy.management_endpoints.sso.saml_sso import SAML_AUTHN_REQUEST_TTL_SECONDS
|
||||
from litellm.proxy.management_endpoints.subscription_accounts import (
|
||||
router as subscription_accounts_router,
|
||||
)
|
||||
from litellm.proxy.management_endpoints.tag_management_endpoints import (
|
||||
router as tag_management_router,
|
||||
)
|
||||
|
|
@ -21767,6 +21770,7 @@ app.include_router(memory_router)
|
|||
app.include_router(lens_router)
|
||||
app.include_router(plugin_router)
|
||||
app.include_router(cost_tracking_settings_router)
|
||||
app.include_router(subscription_accounts_router)
|
||||
app.include_router(prompt_caching_requests_router)
|
||||
app.include_router(router_settings_router)
|
||||
app.include_router(fallback_management_router)
|
||||
|
|
|
|||
|
|
@ -2131,3 +2131,19 @@ model LiteLLM_AccountingDelivery {
|
|||
@@id([event_id, target, version])
|
||||
@@index([target, state, next_attempt_at])
|
||||
}
|
||||
|
||||
model LiteLLM_SubscriptionAccountTable {
|
||||
subscription_account_id String @id @default(uuid())
|
||||
custom_llm_provider String
|
||||
account_id String
|
||||
label String?
|
||||
monthly_fee Float
|
||||
currency String
|
||||
billing_period_start String
|
||||
created_at DateTime @default(now()) @map("created_at")
|
||||
created_by String
|
||||
updated_at DateTime @default(now()) @updatedAt @map("updated_at")
|
||||
updated_by String
|
||||
|
||||
@@unique([custom_llm_provider, account_id], map: "LiteLLM_SubscriptionAccountTable_provider_account_key")
|
||||
}
|
||||
|
|
|
|||
54
litellm/proxy/spend_tracking/subscription_billing_periods.py
Normal file
54
litellm/proxy/spend_tracking/subscription_billing_periods.py
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
from calendar import monthrange
|
||||
from dataclasses import dataclass
|
||||
from datetime import date, timedelta
|
||||
from typing import Final
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class BillingPeriodRange:
|
||||
start: date
|
||||
end: date
|
||||
|
||||
|
||||
def _month_index(anchor: date, months_after_anchor: int) -> int:
|
||||
return anchor.year * 12 + (anchor.month - 1) + months_after_anchor
|
||||
|
||||
|
||||
_LAST_MONTH_INDEX: Final = _month_index(date.max, 0)
|
||||
|
||||
|
||||
def _month_start(anchor: date, months_after_anchor: int) -> date:
|
||||
month_index: Final = _month_index(anchor, months_after_anchor)
|
||||
year: Final = month_index // 12
|
||||
month: Final = month_index % 12 + 1
|
||||
return date(year, month, min(anchor.day, monthrange(year, month)[1]))
|
||||
|
||||
|
||||
def _period_end(anchor: date, months_after_anchor: int) -> date:
|
||||
if _month_index(anchor, months_after_anchor + 1) > _LAST_MONTH_INDEX:
|
||||
return date.max
|
||||
return _month_start(anchor, months_after_anchor + 1) - timedelta(days=1)
|
||||
|
||||
|
||||
def _first_candidate_index(anchor: date, start_date: date) -> int:
|
||||
months_apart: Final = (start_date.year - anchor.year) * 12 + (start_date.month - anchor.month)
|
||||
return max(0, months_apart - 1)
|
||||
|
||||
|
||||
def billing_periods_starting_within(anchor: date, start_date: date, end_date: date) -> tuple[BillingPeriodRange, ...]:
|
||||
"""Monthly periods anchored on `anchor`'s day of month whose start lies inside [start_date, end_date]."""
|
||||
if end_date < start_date or end_date < anchor:
|
||||
return ()
|
||||
first_index: Final = _first_candidate_index(anchor, start_date)
|
||||
last_index: Final = min(
|
||||
first_index + _month_span(start_date, end_date) + 1, _LAST_MONTH_INDEX - _month_index(anchor, 0)
|
||||
)
|
||||
candidates: Final = (
|
||||
BillingPeriodRange(start=_month_start(anchor, index), end=_period_end(anchor, index))
|
||||
for index in range(first_index, last_index + 1)
|
||||
)
|
||||
return tuple(period for period in candidates if start_date <= period.start <= end_date)
|
||||
|
||||
|
||||
def _month_span(start_date: date, end_date: date) -> int:
|
||||
return (end_date.year - start_date.year) * 12 + (end_date.month - start_date.month)
|
||||
134
litellm/repositories/subscription_account_repository.py
Normal file
134
litellm/repositories/subscription_account_repository.py
Normal file
|
|
@ -0,0 +1,134 @@
|
|||
"""
|
||||
Subscription account repository for database operations on LiteLLM_SubscriptionAccountTable.
|
||||
"""
|
||||
|
||||
from collections.abc import Mapping
|
||||
from dataclasses import dataclass
|
||||
from types import MappingProxyType
|
||||
from typing import TYPE_CHECKING, Final, Protocol, TypeAlias
|
||||
|
||||
from litellm.models.subscription_account import LiteLLM_SubscriptionAccountTable
|
||||
from litellm.repositories.base_repository import BaseRepository, is_unique_violation
|
||||
from litellm.repositories.prisma_protocols import TableActions
|
||||
from litellm.repositories.table_repositories import PrismaTableRepository
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from prisma import models as prisma_models
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DuplicateSubscriptionAccount:
|
||||
custom_llm_provider: str
|
||||
account_id: str
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SubscriptionAccountFeeFields:
|
||||
monthly_fee: float
|
||||
currency: str
|
||||
billing_period_start: str
|
||||
label: str | None
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class KeepLabel:
|
||||
pass
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SetLabel:
|
||||
value: str | None
|
||||
|
||||
|
||||
LabelChange: TypeAlias = KeepLabel | SetLabel
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SubscriptionAccountFeeChanges:
|
||||
monthly_fee: float | None = None
|
||||
currency: str | None = None
|
||||
billing_period_start: str | None = None
|
||||
label: LabelChange = KeepLabel()
|
||||
|
||||
def columns(self) -> Mapping[str, float | str | None]:
|
||||
named: Final = {
|
||||
"monthly_fee": self.monthly_fee,
|
||||
"currency": self.currency,
|
||||
"billing_period_start": self.billing_period_start,
|
||||
}
|
||||
present: Final = {column: value for column, value in named.items() if value is not None}
|
||||
label_column: Final = {"label": self.label.value} if isinstance(self.label, SetLabel) else {}
|
||||
return MappingProxyType({**present, **label_column})
|
||||
|
||||
|
||||
class SubscriptionAccountStore(Protocol):
|
||||
async def list_all(self) -> tuple[LiteLLM_SubscriptionAccountTable, ...]: ...
|
||||
|
||||
async def find_by_id(self, id_value: str) -> LiteLLM_SubscriptionAccountTable | None: ...
|
||||
|
||||
async def create_account(
|
||||
self, custom_llm_provider: str, account_id: str, fee: SubscriptionAccountFeeFields, created_by: str
|
||||
) -> LiteLLM_SubscriptionAccountTable | DuplicateSubscriptionAccount: ...
|
||||
|
||||
async def update_fee(
|
||||
self, subscription_account_id: str, changes: SubscriptionAccountFeeChanges, updated_by: str
|
||||
) -> LiteLLM_SubscriptionAccountTable | None: ...
|
||||
|
||||
async def delete_account(self, subscription_account_id: str) -> LiteLLM_SubscriptionAccountTable | None: ...
|
||||
|
||||
|
||||
class _SubscriptionAccountTable(PrismaTableRepository["prisma_models.LiteLLM_SubscriptionAccountTable"]):
|
||||
table_name = "litellm_subscriptionaccounttable"
|
||||
|
||||
|
||||
class SubscriptionAccountRepository(BaseRepository[LiteLLM_SubscriptionAccountTable]):
|
||||
def __init__(self, prisma_client: object) -> None:
|
||||
super().__init__(prisma_client)
|
||||
self._table: Final = _SubscriptionAccountTable(prisma_client)
|
||||
|
||||
@property
|
||||
def table(self) -> TableActions["prisma_models.LiteLLM_SubscriptionAccountTable"]:
|
||||
return self._table.table
|
||||
|
||||
@property
|
||||
def model_class(self) -> type[LiteLLM_SubscriptionAccountTable]:
|
||||
return LiteLLM_SubscriptionAccountTable
|
||||
|
||||
async def list_all(self) -> tuple[LiteLLM_SubscriptionAccountTable, ...]:
|
||||
return tuple(await self.find_many(order={"created_at": "asc"}))
|
||||
|
||||
async def find_by_id(
|
||||
self, id_value: str, id_field: str = "subscription_account_id"
|
||||
) -> LiteLLM_SubscriptionAccountTable | None:
|
||||
return await super().find_by_id(id_value, id_field)
|
||||
|
||||
async def create_account(
|
||||
self, custom_llm_provider: str, account_id: str, fee: SubscriptionAccountFeeFields, created_by: str
|
||||
) -> LiteLLM_SubscriptionAccountTable | DuplicateSubscriptionAccount:
|
||||
try:
|
||||
return await self.create(
|
||||
{
|
||||
"custom_llm_provider": custom_llm_provider,
|
||||
"account_id": account_id,
|
||||
"monthly_fee": fee.monthly_fee,
|
||||
"currency": fee.currency,
|
||||
"billing_period_start": fee.billing_period_start,
|
||||
"label": fee.label,
|
||||
"created_by": created_by,
|
||||
"updated_by": created_by,
|
||||
}
|
||||
)
|
||||
except Exception as exc:
|
||||
if is_unique_violation(exc):
|
||||
return DuplicateSubscriptionAccount(custom_llm_provider=custom_llm_provider, account_id=account_id)
|
||||
raise
|
||||
|
||||
async def update_fee(
|
||||
self, subscription_account_id: str, changes: SubscriptionAccountFeeChanges, updated_by: str
|
||||
) -> LiteLLM_SubscriptionAccountTable | None:
|
||||
return await self.update(
|
||||
subscription_account_id, {**changes.columns(), "updated_by": updated_by}, id_field="subscription_account_id"
|
||||
)
|
||||
|
||||
async def delete_account(self, subscription_account_id: str) -> LiteLLM_SubscriptionAccountTable | None:
|
||||
return await self.delete(subscription_account_id, id_field="subscription_account_id")
|
||||
|
|
@ -31,7 +31,10 @@ from litellm.integrations.anthropic_cache_control_hook import (
|
|||
from litellm.litellm_core_utils.asyncify import run_async_function
|
||||
from litellm.litellm_core_utils.completion_timeout import CompletionTimeout, StreamKind
|
||||
from litellm.litellm_core_utils.core_helpers import drops_unsupported_params, normalize_drop_params
|
||||
from litellm.litellm_core_utils.get_llm_provider_logic import get_provider_affinity_header
|
||||
from litellm.litellm_core_utils.get_llm_provider_logic import (
|
||||
declared_authenticating_provider,
|
||||
get_provider_affinity_header,
|
||||
)
|
||||
from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
|
||||
from litellm.litellm_core_utils.litellm_logging import StandardLoggingPayloadSetup
|
||||
from litellm.litellm_core_utils.prompt_templates.common_utils import (
|
||||
|
|
@ -805,6 +808,7 @@ def provider_stores_the_conversation(model: str, custom_llm_provider: str | None
|
|||
return not _will_bridge_to_chat_completions(
|
||||
model,
|
||||
custom_llm_provider
|
||||
or declared_authenticating_provider(model)
|
||||
or litellm.get_llm_provider(model=model, api_base=api_base, litellm_params=litellm_params)[1],
|
||||
bool(kwargs.get("use_chat_completions_api")),
|
||||
kwargs.get("model_info"),
|
||||
|
|
|
|||
|
|
@ -0,0 +1,62 @@
|
|||
from datetime import date
|
||||
from typing import Final
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
|
||||
from litellm.models.subscription_account import LiteLLM_SubscriptionAccountTable
|
||||
|
||||
CURRENCY_CODE_PATTERN: Final = r"^[A-Z]{3}$"
|
||||
|
||||
|
||||
class SubscriptionAccountFeeRequest(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
custom_llm_provider: str = Field(min_length=1)
|
||||
account_id: str = Field(min_length=1)
|
||||
monthly_fee: float = Field(gt=0, allow_inf_nan=False)
|
||||
currency: str = Field(pattern=CURRENCY_CODE_PATTERN)
|
||||
billing_period_start: date
|
||||
label: str | None = None
|
||||
|
||||
|
||||
class UpdateSubscriptionAccountFeeRequest(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
subscription_account_id: str
|
||||
monthly_fee: float | None = Field(default=None, gt=0, allow_inf_nan=False)
|
||||
currency: str | None = Field(default=None, pattern=CURRENCY_CODE_PATTERN)
|
||||
billing_period_start: date | None = None
|
||||
label: str | None = None
|
||||
|
||||
|
||||
class DeleteSubscriptionAccountRequest(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
subscription_account_id: str
|
||||
|
||||
|
||||
class BillingPeriod(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
start: date
|
||||
end: date
|
||||
|
||||
|
||||
class SubscriptionAccountUsage(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
custom_llm_provider: str
|
||||
account_id: str | None
|
||||
deployments: tuple[str, ...]
|
||||
fee: LiteLLM_SubscriptionAccountTable | None
|
||||
billing_periods: tuple[BillingPeriod, ...]
|
||||
fixed_cost: float | None
|
||||
|
||||
|
||||
class SubscriptionUsageResponse(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
start_date: date
|
||||
end_date: date
|
||||
subscription_providers: tuple[str, ...]
|
||||
accounts: tuple[SubscriptionAccountUsage, ...]
|
||||
|
|
@ -2131,3 +2131,19 @@ model LiteLLM_AccountingDelivery {
|
|||
@@id([event_id, target, version])
|
||||
@@index([target, state, next_attempt_at])
|
||||
}
|
||||
|
||||
model LiteLLM_SubscriptionAccountTable {
|
||||
subscription_account_id String @id @default(uuid())
|
||||
custom_llm_provider String
|
||||
account_id String
|
||||
label String?
|
||||
monthly_fee Float
|
||||
currency String
|
||||
billing_period_start String
|
||||
created_at DateTime @default(now()) @map("created_at")
|
||||
created_by String
|
||||
updated_at DateTime @default(now()) @updatedAt @map("updated_at")
|
||||
updated_by String
|
||||
|
||||
@@unique([custom_llm_provider, account_id], map: "LiteLLM_SubscriptionAccountTable_provider_account_key")
|
||||
}
|
||||
|
|
|
|||
322
tests/integration/spend/test_chatgpt_subscription_usage.py
Normal file
322
tests/integration/spend/test_chatgpt_subscription_usage.py
Normal file
|
|
@ -0,0 +1,322 @@
|
|||
import uuid
|
||||
from collections.abc import Iterator, Mapping
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime
|
||||
from typing import Final
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from integration._support import codex_vendor as cv
|
||||
from integration._support import responses_vendor as rv
|
||||
from integration._support.client import Gateway, Scenario, eventually, gateway_from_environment, string_value
|
||||
from integration._support.process import OwnedProxy, owned_proxy_process
|
||||
from integration._support.wire import Wire, wire_server
|
||||
from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter
|
||||
|
||||
_MODEL: Final = "chatgpt/gpt-5.5"
|
||||
_PROVIDER: Final = "chatgpt"
|
||||
_FEE_TABLE_QUERY: Final = (
|
||||
'SELECT subscription_account_id FROM "LiteLLM_SubscriptionAccountTable" WHERE custom_llm_provider = %s'
|
||||
" AND account_id = %s"
|
||||
)
|
||||
_FEE_ROW_QUERY: Final = (
|
||||
'SELECT subscription_account_id FROM "LiteLLM_SubscriptionAccountTable" WHERE subscription_account_id = %s'
|
||||
)
|
||||
_MONTHLY_FEE: Final = 200.0
|
||||
_BILLING_PERIOD_START: Final = "2026-01-15"
|
||||
_RANGE: Final = {"start_date": "2026-03-01", "end_date": "2026-03-31"}
|
||||
_PERIOD_IN_RANGE: Final = ("2026-03-15", "2026-04-14")
|
||||
_TOKENS: Final = TypeAdapter(int)
|
||||
|
||||
|
||||
class _Metrics(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
spend: float
|
||||
prompt_tokens: int
|
||||
completion_tokens: int
|
||||
api_requests: int
|
||||
successful_requests: int
|
||||
failed_requests: int
|
||||
|
||||
|
||||
class _ProviderUsage(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
metrics: _Metrics
|
||||
metadata: Mapping[str, JsonValue]
|
||||
|
||||
|
||||
class _Breakdown(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
providers: Mapping[str, _ProviderUsage]
|
||||
|
||||
|
||||
class _Day(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
breakdown: _Breakdown
|
||||
|
||||
|
||||
class _DailyActivity(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
results: tuple[_Day, ...]
|
||||
|
||||
|
||||
class _Fee(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
subscription_account_id: str
|
||||
custom_llm_provider: str
|
||||
account_id: str
|
||||
monthly_fee: float
|
||||
currency: str
|
||||
billing_period_start: str
|
||||
|
||||
|
||||
class _Period(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
start: str
|
||||
end: str
|
||||
|
||||
|
||||
class _Account(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
custom_llm_provider: str
|
||||
account_id: str | None
|
||||
deployments: tuple[str, ...]
|
||||
fee: _Fee | None
|
||||
billing_periods: tuple[_Period, ...]
|
||||
fixed_cost: float | None
|
||||
|
||||
|
||||
class _SubscriptionUsage(BaseModel):
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
accounts: tuple[_Account, ...]
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class _Rig:
|
||||
wire: Wire
|
||||
proxy: OwnedProxy
|
||||
model: str
|
||||
|
||||
@property
|
||||
def gateway(self) -> Gateway:
|
||||
return self.proxy.gateway
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def rig(tmp_path_factory: pytest.TempPathFactory) -> Iterator[_Rig]:
|
||||
directory: Final = tmp_path_factory.mktemp("chatgpt-subscription-usage")
|
||||
no_default_login: Final = directory / "no-default-login"
|
||||
no_default_login.mkdir()
|
||||
deployment_login: Final = cv.login(directory) / "auth.json"
|
||||
with gateway_from_environment() as gateway, wire_server(cv.CodexVendor().respond) as wire:
|
||||
overrides: Final = {"CHATGPT_TOKEN_DIR": str(no_default_login), "CHATGPT_API_BASE": wire.url}
|
||||
config: Final = cv.proxy_config(directory, probe=False)
|
||||
with (
|
||||
owned_proxy_process(gateway, directory, overrides, config=config, workers=2) as owned,
|
||||
owned.gateway.scenario() as scenario,
|
||||
):
|
||||
model: Final = scenario.model(
|
||||
model=_MODEL, api_base=wire.url, api_key=None, chatgpt_auth_file=str(deployment_login)
|
||||
)
|
||||
yield _Rig(wire, owned, model)
|
||||
|
||||
|
||||
def _responses_body(model: str, marker: str, *, stream: bool) -> Mapping[str, JsonValue]:
|
||||
return {
|
||||
"model": model,
|
||||
"input": [{"role": "user", "content": f"Say marker-{marker}"}],
|
||||
"stream": stream,
|
||||
"cache": {"no-cache": True},
|
||||
}
|
||||
|
||||
|
||||
def _assert_answered(response: httpx.Response, marker: str, content_type: str) -> None:
|
||||
assert response.status_code == 200, response.text
|
||||
assert response.headers["content-type"].startswith(content_type), response.headers
|
||||
assert rv.answer(marker) in response.text, response.text
|
||||
|
||||
|
||||
def _today() -> str:
|
||||
return datetime.now(UTC).date().isoformat()
|
||||
|
||||
|
||||
def _chatgpt_usage_between(gateway: Gateway, first_day: str, last_day: str) -> tuple[_ProviderUsage, ...]:
|
||||
response: Final = gateway.request(
|
||||
"GET", "/user/daily/activity", params={"start_date": first_day, "end_date": last_day}
|
||||
)
|
||||
assert response.status_code == 200, response.text
|
||||
activity: Final = _DailyActivity.model_validate_json(response.content)
|
||||
return tuple(
|
||||
result.breakdown.providers[_PROVIDER] for result in activity.results if _PROVIDER in result.breakdown.providers
|
||||
)
|
||||
|
||||
|
||||
def _summed(buckets: tuple[_ProviderUsage, ...]) -> _Metrics:
|
||||
return _Metrics(
|
||||
spend=sum(bucket.metrics.spend for bucket in buckets),
|
||||
prompt_tokens=sum(bucket.metrics.prompt_tokens for bucket in buckets),
|
||||
completion_tokens=sum(bucket.metrics.completion_tokens for bucket in buckets),
|
||||
api_requests=sum(bucket.metrics.api_requests for bucket in buckets),
|
||||
successful_requests=sum(bucket.metrics.successful_requests for bucket in buckets),
|
||||
failed_requests=sum(bucket.metrics.failed_requests for bucket in buckets),
|
||||
)
|
||||
|
||||
|
||||
def _usage(gateway: Gateway, *, key: str | None = None) -> httpx.Response:
|
||||
return gateway.request("GET", "/subscription_accounts/usage", params=_RANGE, key=key)
|
||||
|
||||
|
||||
def _accounts(gateway: Gateway) -> tuple[_Account, ...]:
|
||||
response: Final = _usage(gateway)
|
||||
assert response.status_code == 200, response.text
|
||||
return _SubscriptionUsage.model_validate_json(response.content).accounts
|
||||
|
||||
|
||||
def _deployment_account(rig: _Rig) -> _Account:
|
||||
(account,) = _accounts(rig.gateway)
|
||||
assert (account.custom_llm_provider, account.account_id, account.deployments) == (
|
||||
_PROVIDER,
|
||||
cv.ACCOUNT,
|
||||
(rig.model,),
|
||||
), account
|
||||
return account
|
||||
|
||||
|
||||
def _assert_no_fee(account: _Account) -> None:
|
||||
assert (account.fee, account.billing_periods, account.fixed_cost) == (None, (), None), account
|
||||
|
||||
|
||||
def _fee_body(account_id: str, monthly_fee: float = _MONTHLY_FEE) -> Mapping[str, JsonValue]:
|
||||
return {
|
||||
"custom_llm_provider": _PROVIDER,
|
||||
"account_id": account_id,
|
||||
"monthly_fee": monthly_fee,
|
||||
"currency": "USD",
|
||||
"billing_period_start": _BILLING_PERIOD_START,
|
||||
"label": "integration",
|
||||
}
|
||||
|
||||
|
||||
def _delete_fee_if_present(gateway: Gateway, identity: str) -> None:
|
||||
if gateway.rows(_FEE_ROW_QUERY, (identity,)):
|
||||
gateway.post("/subscription_accounts/delete", {"subscription_account_id": identity})
|
||||
assert gateway.rows(_FEE_ROW_QUERY, (identity,)) == []
|
||||
|
||||
|
||||
def _set_fee(scenario: Scenario, account_id: str) -> str:
|
||||
created: Final = scenario.gateway.post("/subscription_accounts/new", _fee_body(account_id))
|
||||
identity: Final = string_value(created["subscription_account_id"])
|
||||
scenario.cleanups.callback(_delete_fee_if_present, scenario.gateway, identity)
|
||||
return identity
|
||||
|
||||
|
||||
def _assert_fee_reported(account: _Account, identity: str) -> None:
|
||||
assert account.fee is not None, account
|
||||
assert (
|
||||
account.fee.subscription_account_id,
|
||||
account.fee.account_id,
|
||||
account.fee.monthly_fee,
|
||||
account.fee.currency,
|
||||
account.fee.billing_period_start,
|
||||
) == (identity, cv.ACCOUNT, _MONTHLY_FEE, "USD", _BILLING_PERIOD_START), account
|
||||
assert tuple((period.start, period.end) for period in account.billing_periods) == (_PERIOD_IN_RANGE,), account
|
||||
assert account.fixed_cost == _MONTHLY_FEE, account
|
||||
|
||||
|
||||
def test_responses_calls_on_a_deployment_login_count_as_subscription_covered_chatgpt_usage(rig: _Rig) -> None:
|
||||
first_day: Final = _today()
|
||||
rig.wire.drain()
|
||||
plain_marker: Final = uuid.uuid4().hex
|
||||
stream_marker: Final = uuid.uuid4().hex
|
||||
plain: Final = rig.gateway.request("POST", "/v1/responses", _responses_body(rig.model, plain_marker, stream=False))
|
||||
_assert_answered(plain, plain_marker, "application/json")
|
||||
streamed: Final = rig.gateway.request(
|
||||
"POST", "/v1/responses", _responses_body(rig.model, stream_marker, stream=True)
|
||||
)
|
||||
_assert_answered(streamed, stream_marker, "text/event-stream")
|
||||
forwarded: Final = rig.wire.drain()
|
||||
assert len(forwarded) == 2, [request.target for request in forwarded]
|
||||
for request, marker in zip(forwarded, (plain_marker, stream_marker), strict=True):
|
||||
cv.forwarded(request, marker)
|
||||
last_day: Final = _today()
|
||||
buckets: Final = eventually(
|
||||
lambda: _chatgpt_usage_between(rig.gateway, first_day, last_day),
|
||||
lambda found: _summed(found).api_requests >= 2,
|
||||
seconds=70,
|
||||
)
|
||||
totals: Final = _summed(buckets)
|
||||
assert (totals.api_requests, totals.successful_requests, totals.failed_requests, totals.spend) == (
|
||||
2,
|
||||
2,
|
||||
0,
|
||||
0,
|
||||
), buckets
|
||||
assert (totals.prompt_tokens, totals.completion_tokens) == (
|
||||
2 * _TOKENS.validate_python(cv.USAGE["input_tokens"]),
|
||||
2 * _TOKENS.validate_python(cv.USAGE["output_tokens"]),
|
||||
), buckets
|
||||
assert all(bucket.metadata.get("subscription_covered") is True for bucket in buckets), buckets
|
||||
|
||||
|
||||
def test_fee_on_the_deployment_account_reports_its_fixed_cost_until_deleted(rig: _Rig) -> None:
|
||||
_assert_no_fee(_deployment_account(rig))
|
||||
with rig.gateway.scenario() as scenario:
|
||||
identity: Final = _set_fee(scenario, cv.ACCOUNT)
|
||||
_assert_fee_reported(_deployment_account(rig), identity)
|
||||
deleted: Final = rig.gateway.post("/subscription_accounts/delete", {"subscription_account_id": identity})
|
||||
assert deleted["subscription_account_id"] == identity, deleted
|
||||
assert rig.gateway.rows(_FEE_ROW_QUERY, (identity,)) == []
|
||||
_assert_no_fee(_deployment_account(rig))
|
||||
|
||||
|
||||
def test_second_fee_for_the_same_account_answers_400_and_keeps_the_first(rig: _Rig) -> None:
|
||||
with rig.gateway.scenario() as scenario:
|
||||
identity: Final = _set_fee(scenario, cv.ACCOUNT)
|
||||
duplicate: Final = rig.gateway.request(
|
||||
"POST", "/subscription_accounts/new", _fee_body(cv.ACCOUNT, monthly_fee=3 * _MONTHLY_FEE)
|
||||
)
|
||||
assert duplicate.status_code == 400, duplicate.text
|
||||
assert rig.gateway.rows(_FEE_TABLE_QUERY, (_PROVIDER, cv.ACCOUNT)) == [{"subscription_account_id": identity}]
|
||||
_assert_fee_reported(_deployment_account(rig), identity)
|
||||
|
||||
|
||||
def test_update_and_delete_of_an_unknown_fee_answer_404(rig: _Rig) -> None:
|
||||
unknown: Final = str(uuid.uuid4())
|
||||
updated: Final = rig.gateway.request(
|
||||
"POST", "/subscription_accounts/update", {"subscription_account_id": unknown, "monthly_fee": _MONTHLY_FEE}
|
||||
)
|
||||
assert updated.status_code == 404, updated.text
|
||||
deleted: Final = rig.gateway.request("POST", "/subscription_accounts/delete", {"subscription_account_id": unknown})
|
||||
assert deleted.status_code == 404, deleted.text
|
||||
assert rig.gateway.rows(_FEE_ROW_QUERY, (unknown,)) == []
|
||||
|
||||
|
||||
def test_internal_user_is_refused_setting_a_fee_and_reading_usage(rig: _Rig) -> None:
|
||||
with rig.gateway.scenario() as scenario:
|
||||
key: Final = scenario.key(user_id=scenario.user(user_role="internal_user"))
|
||||
created: Final = rig.gateway.request("POST", "/subscription_accounts/new", _fee_body(cv.ACCOUNT), key=key)
|
||||
assert created.status_code == 401, created.text
|
||||
assert rig.gateway.rows(_FEE_TABLE_QUERY, (_PROVIDER, cv.ACCOUNT)) == []
|
||||
usage: Final = _usage(rig.gateway, key=key)
|
||||
assert usage.status_code == 401, usage.text
|
||||
|
||||
|
||||
def test_fee_on_an_account_no_deployment_uses_stays_listed_and_counted(rig: _Rig) -> None:
|
||||
unused: Final = f"acct-unused-{uuid.uuid4().hex}"
|
||||
with rig.gateway.scenario() as scenario:
|
||||
identity: Final = _set_fee(scenario, unused)
|
||||
accounts: Final = _accounts(rig.gateway)
|
||||
assert frozenset(account.account_id for account in accounts) == {cv.ACCOUNT, unused}, accounts
|
||||
(unused_account,) = (account for account in accounts if account.account_id == unused)
|
||||
assert unused_account.fee is not None, unused_account
|
||||
assert (unused_account.deployments, unused_account.fee.subscription_account_id) == ((), identity)
|
||||
assert unused_account.fixed_cost == _MONTHLY_FEE, unused_account
|
||||
110
tests/unit/llms/test_subscription_accounts.py
Normal file
110
tests/unit/llms/test_subscription_accounts.py
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
import base64
|
||||
import json
|
||||
from pathlib import Path
|
||||
from typing import Final
|
||||
|
||||
import pytest
|
||||
|
||||
import litellm
|
||||
from litellm.constants import SUBSCRIPTION_BACKED_PROVIDERS
|
||||
from litellm.llms.chatgpt.common_utils import OPENAI_AUTH_CLAIM_KEY
|
||||
from litellm.llms.subscription_accounts import SUBSCRIPTION_ACCOUNT_ID_RESOLVERS, resolve_subscription_account_id
|
||||
from litellm.types.utils import CredentialItem
|
||||
|
||||
|
||||
def _write_login(path: Path, account_id: str) -> Path:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(json.dumps({"account_id": account_id}))
|
||||
return path
|
||||
|
||||
|
||||
def _access_token_for(account_id: str) -> str:
|
||||
claims: Final = json.dumps({OPENAI_AUTH_CLAIM_KEY: {"chatgpt_account_id": account_id}}).encode()
|
||||
payload: Final = base64.urlsafe_b64encode(claims).decode().rstrip("=")
|
||||
return f"header.{payload}.signature"
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def signed_in_chatgpt_token_dir(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
|
||||
monkeypatch.setenv("CHATGPT_TOKEN_DIR", str(tmp_path))
|
||||
monkeypatch.delenv("CHATGPT_AUTH_FILE", raising=False)
|
||||
_write_login(tmp_path / "auth.json", "acct-from-token-file")
|
||||
return tmp_path
|
||||
|
||||
|
||||
def test_every_subscription_backed_provider_has_an_account_id_resolver() -> None:
|
||||
assert frozenset(SUBSCRIPTION_ACCOUNT_ID_RESOLVERS) == SUBSCRIPTION_BACKED_PROVIDERS
|
||||
|
||||
|
||||
def test_chatgpt_resolves_to_the_account_in_the_signed_in_token_file(signed_in_chatgpt_token_dir: Path) -> None:
|
||||
assert resolve_subscription_account_id("chatgpt", {"model": "chatgpt/gpt-5.6-terra"}) == "acct-from-token-file"
|
||||
|
||||
|
||||
def test_each_deployment_takes_the_account_of_its_own_auth_file(signed_in_chatgpt_token_dir: Path) -> None:
|
||||
first: Final = _write_login(signed_in_chatgpt_token_dir / "team-a" / "auth.json", "acct-team-a")
|
||||
second: Final = _write_login(signed_in_chatgpt_token_dir / "team-b" / "auth.json", "acct-team-b")
|
||||
|
||||
assert resolve_subscription_account_id("chatgpt", {"chatgpt_auth_file": str(first)}) == "acct-team-a"
|
||||
assert resolve_subscription_account_id("chatgpt", {"chatgpt_auth_file": str(second)}) == "acct-team-b"
|
||||
|
||||
|
||||
def test_a_configured_access_token_resolves_to_its_own_account(signed_in_chatgpt_token_dir: Path) -> None:
|
||||
litellm_params: Final = {"model": "chatgpt/gpt-5.6-terra", "api_key": _access_token_for("acct-from-api-key")}
|
||||
|
||||
assert resolve_subscription_account_id("chatgpt", litellm_params) == "acct-from-api-key"
|
||||
|
||||
|
||||
def test_a_metered_provider_resolves_to_no_account_even_with_a_chatgpt_login(
|
||||
signed_in_chatgpt_token_dir: Path,
|
||||
) -> None:
|
||||
assert resolve_subscription_account_id("openai", {"model": "openai/gpt-5.6-terra"}) is None
|
||||
|
||||
|
||||
def test_chatgpt_without_a_login_resolves_to_no_account(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
empty_dir: Final = tmp_path / "no-login"
|
||||
monkeypatch.setenv("CHATGPT_TOKEN_DIR", str(empty_dir))
|
||||
monkeypatch.delenv("CHATGPT_AUTH_FILE", raising=False)
|
||||
assert resolve_subscription_account_id("chatgpt", {"model": "chatgpt/gpt-5.6-terra"}) is None
|
||||
|
||||
|
||||
def test_resolving_an_account_leaves_the_login_file_untouched(signed_in_chatgpt_token_dir: Path) -> None:
|
||||
login: Final = signed_in_chatgpt_token_dir / "no-saved-account" / "auth.json"
|
||||
login.parent.mkdir(parents=True)
|
||||
saved: Final = json.dumps({"access_token": _access_token_for("acct-derived"), "refresh_token": "rt-current"})
|
||||
login.write_text(saved)
|
||||
|
||||
assert resolve_subscription_account_id("chatgpt", {"chatgpt_auth_file": str(login)}) == "acct-derived"
|
||||
assert login.read_text() == saved
|
||||
|
||||
|
||||
@pytest.mark.parametrize("credential_field", ["chatgpt_auth_file", "api_key"])
|
||||
def test_a_named_credential_resolves_to_the_account_it_signs_in_as(
|
||||
credential_field: str, signed_in_chatgpt_token_dir: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
login: Final = _write_login(signed_in_chatgpt_token_dir / "named" / "auth.json", "acct-named-credential")
|
||||
values: Final = {
|
||||
"chatgpt_auth_file": {"chatgpt_auth_file": str(login)},
|
||||
"api_key": {"api_key": _access_token_for("acct-named-credential")},
|
||||
}[credential_field]
|
||||
monkeypatch.setattr(
|
||||
litellm,
|
||||
"credential_list",
|
||||
[CredentialItem(credential_name="chatgpt-team", credential_values=values, credential_info={})],
|
||||
)
|
||||
litellm_params: Final = {"model": "chatgpt/gpt-5.6-terra", "litellm_credential_name": "chatgpt-team"}
|
||||
|
||||
assert resolve_subscription_account_id("chatgpt", litellm_params) == "acct-named-credential"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("api_key", "expected_account"),
|
||||
[("oidc/env/CHATGPT_TEAM_TOKEN", "acct-from-oidc-env"), ("oidc/env/CHATGPT_UNSET_TOKEN", None)],
|
||||
)
|
||||
def test_an_oidc_env_api_key_resolves_to_the_account_of_the_token_it_points_to(
|
||||
api_key: str, expected_account: str | None, signed_in_chatgpt_token_dir: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
monkeypatch.setenv("CHATGPT_TEAM_TOKEN", _access_token_for("acct-from-oidc-env"))
|
||||
monkeypatch.delenv("CHATGPT_UNSET_TOKEN", raising=False)
|
||||
litellm_params: Final = {"model": "chatgpt/gpt-5.6-terra", "api_key": api_key}
|
||||
|
||||
assert resolve_subscription_account_id("chatgpt", litellm_params) == expected_account
|
||||
|
|
@ -6,6 +6,7 @@ import re
|
|||
from collections.abc import AsyncIterator, Callable
|
||||
from contextlib import AbstractAsyncContextManager, asynccontextmanager
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from typing import Final, cast
|
||||
from unittest.mock import AsyncMock, MagicMock, call, patch
|
||||
|
|
@ -4325,6 +4326,36 @@ async def test_insert_spend_log_asks_for_an_immediate_flush_only_on_rows_the_bri
|
|||
assert prisma.spend_log_flush_requested.is_set() is expects_flush
|
||||
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@pytest.mark.timeout(30)
|
||||
async def test_a_chatgpt_responses_row_queues_without_a_default_chatgpt_login(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
||||
):
|
||||
monkeypatch.setenv("CHATGPT_TOKEN_DIR", str(tmp_path / "no-default-login"))
|
||||
monkeypatch.delenv("CHATGPT_AUTH_FILE", raising=False)
|
||||
own_login: Final = tmp_path / "team" / "auth.json"
|
||||
own_login.parent.mkdir()
|
||||
own_login.write_text(json.dumps({"access_token": "at-team", "account_id": "acct-team"}))
|
||||
router: Final = litellm.Router(
|
||||
model_list=[
|
||||
{
|
||||
"model_name": "chatgpt-team",
|
||||
"litellm_params": {"model": "chatgpt/gpt-5.6-terra", "chatgpt_auth_file": str(own_login)},
|
||||
"model_info": {"id": "dep-chatgpt"},
|
||||
}
|
||||
]
|
||||
)
|
||||
prisma: Final = _tool_usage_prisma()
|
||||
prisma.spend_log_flush_requested = asyncio.Event()
|
||||
payload: Final = {"request_id": "req-1", "call_type": "aresponses", "model_id": "dep-chatgpt"}
|
||||
|
||||
await DBSpendUpdateWriter()._insert_spend_log_to_db(payload=payload, prisma_client=prisma, llm_router=router)
|
||||
|
||||
assert prisma.spend_log_transactions == [payload]
|
||||
assert prisma.spend_log_flush_requested.is_set() is False
|
||||
|
||||
|
||||
def _batch_cost_payload() -> dict:
|
||||
return {
|
||||
**_minimal_spend_payload(),
|
||||
|
|
|
|||
|
|
@ -2553,6 +2553,71 @@ async def test_get_daily_activity_rejects_non_canonical_dates_before_querying(st
|
|||
mock_table.find_many.assert_not_awaited()
|
||||
|
||||
|
||||
def _provider_record(provider: str, *, model: str, spend: float):
|
||||
base = vars(_spend_record("real-key", model=model, spend=spend))
|
||||
return SimpleNamespace(**{**base, "custom_llm_provider": provider, "api_requests": 1, "successful_requests": 1})
|
||||
|
||||
|
||||
def test_per_row_provider_bucket_marks_subscription_backed_providers_only():
|
||||
from litellm.proxy.management_endpoints.common_daily_activity import update_breakdown_metrics
|
||||
from litellm.types.proxy.management_endpoints.common_daily_activity import BreakdownMetrics
|
||||
|
||||
breakdown = BreakdownMetrics()
|
||||
update_breakdown_metrics(breakdown, _provider_record("chatgpt", model="gpt-5.6-terra", spend=0.0), {}, {}, {})
|
||||
update_breakdown_metrics(breakdown, _provider_record("openai", model="gpt-5.6", spend=0.0), {}, {}, {})
|
||||
update_breakdown_metrics(breakdown, _provider_record("chatgpt", model="gpt-5.6-sol", spend=0.0), {}, {}, {})
|
||||
|
||||
assert breakdown.providers["chatgpt"].metadata == {"subscription_covered": True}
|
||||
assert "subscription_covered" not in breakdown.providers["openai"].metadata
|
||||
assert breakdown.providers["chatgpt"].metrics.api_requests == 2
|
||||
assert "subscription_covered" not in breakdown.models["gpt-5.6-terra"].metadata
|
||||
|
||||
|
||||
def test_per_row_provider_marker_keeps_existing_provider_metadata():
|
||||
from litellm.proxy.management_endpoints.common_daily_activity import update_breakdown_metrics
|
||||
from litellm.types.proxy.management_endpoints.common_daily_activity import BreakdownMetrics
|
||||
|
||||
breakdown = BreakdownMetrics()
|
||||
update_breakdown_metrics(
|
||||
breakdown,
|
||||
_provider_record("chatgpt", model="gpt-5.6-terra", spend=0.0),
|
||||
{},
|
||||
{"chatgpt": {"region": "us"}},
|
||||
{},
|
||||
)
|
||||
|
||||
assert breakdown.providers["chatgpt"].metadata == {"region": "us", "subscription_covered": True}
|
||||
|
||||
|
||||
@pytest.mark.parametrize("provider_row_first", [True, False])
|
||||
def test_grouping_sets_provider_bucket_marks_subscription_backed_providers_in_any_row_order(provider_row_first):
|
||||
from litellm.proxy.management_endpoints.common_daily_activity import (
|
||||
_GROUP_DATE_PROVIDER,
|
||||
_GROUP_DATE_PROVIDER_API_KEY,
|
||||
_GROUP_GRAND_TOTAL,
|
||||
_aggregate_grouping_sets_records_sync,
|
||||
)
|
||||
|
||||
provider_rows = [
|
||||
_grouping_row(_GROUP_DATE_PROVIDER, custom_llm_provider="chatgpt", spend=0.0),
|
||||
_grouping_row(_GROUP_DATE_PROVIDER_API_KEY, custom_llm_provider="chatgpt", api_key="real-key", spend=0.0),
|
||||
]
|
||||
ordered_rows = provider_rows if provider_row_first else list(reversed(provider_rows))
|
||||
records = [
|
||||
*ordered_rows,
|
||||
_grouping_row(_GROUP_DATE_PROVIDER, custom_llm_provider="openai", spend=0.0),
|
||||
_grouping_row(_GROUP_DATE_PROVIDER_API_KEY, custom_llm_provider="openai", api_key="real-key", spend=0.0),
|
||||
_grouping_row(_GROUP_GRAND_TOTAL, spend=0.0),
|
||||
]
|
||||
|
||||
aggregated = _aggregate_grouping_sets_records_sync(records=records, api_key_metadata={})
|
||||
|
||||
providers = aggregated["results"][0].breakdown.providers
|
||||
assert providers["chatgpt"].metadata == {"subscription_covered": True}
|
||||
assert "real-key" in providers["chatgpt"].api_key_breakdown
|
||||
assert "subscription_covered" not in providers["openai"].metadata
|
||||
|
||||
|
||||
@pytest.mark.parametrize("missing", [None, ""])
|
||||
def test_missing_dimensions_preserve_all_paginated_metrics(missing: str | None) -> None:
|
||||
records: Final = (
|
||||
|
|
|
|||
|
|
@ -0,0 +1,438 @@
|
|||
from collections.abc import Iterator
|
||||
from datetime import datetime, timezone
|
||||
from typing import Final
|
||||
from uuid import uuid4
|
||||
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
import pytest
|
||||
from fastapi import FastAPI, HTTPException, Request
|
||||
from fastapi.testclient import TestClient
|
||||
from pydantic import ValidationError
|
||||
|
||||
from litellm.models.subscription_account import LiteLLM_SubscriptionAccountTable
|
||||
from litellm.proxy._types import LiteLLM_JWTAuth, LitellmUserRoles, UserAPIKeyAuth
|
||||
from litellm.proxy.auth.auth_checks import allowed_routes_check
|
||||
from litellm.proxy.auth.route_checks import RouteChecks
|
||||
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
|
||||
from litellm.proxy.management_endpoints.subscription_accounts import (
|
||||
SubscriptionDeployment,
|
||||
get_subscription_account_repository,
|
||||
get_subscription_deployments,
|
||||
router,
|
||||
subscription_deployments_from_model_list,
|
||||
subscription_deployments_of_router,
|
||||
)
|
||||
from litellm.router import Router
|
||||
from litellm.types.proxy.management_endpoints.subscription_accounts import (
|
||||
SubscriptionAccountFeeRequest,
|
||||
UpdateSubscriptionAccountFeeRequest,
|
||||
)
|
||||
from litellm.repositories.subscription_account_repository import (
|
||||
DuplicateSubscriptionAccount,
|
||||
SubscriptionAccountFeeChanges,
|
||||
SubscriptionAccountFeeFields,
|
||||
)
|
||||
|
||||
_ACCOUNT: Final = "org-team-workspace"
|
||||
_TEST_FEE: Final = {
|
||||
"custom_llm_provider": "chatgpt",
|
||||
"account_id": _ACCOUNT,
|
||||
"monthly_fee": 25.0,
|
||||
"currency": "USD",
|
||||
"billing_period_start": "2026-10-01",
|
||||
"label": "Team plan (test value)",
|
||||
}
|
||||
_TWO_DEPLOYMENTS_ONE_ACCOUNT: Final = (
|
||||
SubscriptionDeployment(model_name="gpt-5.6-terra", custom_llm_provider="chatgpt", account_id=_ACCOUNT),
|
||||
SubscriptionDeployment(model_name="gpt-5.6-sol", custom_llm_provider="chatgpt", account_id=_ACCOUNT),
|
||||
)
|
||||
|
||||
|
||||
class _FakeStore:
|
||||
def __init__(self) -> None:
|
||||
self.rows: dict[str, LiteLLM_SubscriptionAccountTable] = {}
|
||||
self.written_columns: list[dict[str, float | str | None]] = []
|
||||
|
||||
async def list_all(self) -> list[LiteLLM_SubscriptionAccountTable]:
|
||||
return sorted(self.rows.values(), key=lambda row: row.created_at)
|
||||
|
||||
async def find_by_id(self, id_value: str) -> LiteLLM_SubscriptionAccountTable | None:
|
||||
return self.rows.get(id_value)
|
||||
|
||||
async def create_account(
|
||||
self, custom_llm_provider: str, account_id: str, fee: SubscriptionAccountFeeFields, created_by: str
|
||||
) -> LiteLLM_SubscriptionAccountTable | DuplicateSubscriptionAccount:
|
||||
for row in self.rows.values():
|
||||
if (row.custom_llm_provider, row.account_id) == (custom_llm_provider, account_id):
|
||||
return DuplicateSubscriptionAccount(custom_llm_provider=custom_llm_provider, account_id=account_id)
|
||||
now = datetime.now(timezone.utc)
|
||||
row = LiteLLM_SubscriptionAccountTable(
|
||||
subscription_account_id=str(uuid4()),
|
||||
custom_llm_provider=custom_llm_provider,
|
||||
account_id=account_id,
|
||||
label=fee.label,
|
||||
monthly_fee=fee.monthly_fee,
|
||||
currency=fee.currency,
|
||||
billing_period_start=fee.billing_period_start,
|
||||
created_at=now,
|
||||
created_by=created_by,
|
||||
updated_at=now,
|
||||
updated_by=created_by,
|
||||
)
|
||||
self.rows[row.subscription_account_id] = row
|
||||
return row
|
||||
|
||||
async def update_fee(
|
||||
self, subscription_account_id: str, changes: SubscriptionAccountFeeChanges, updated_by: str
|
||||
) -> LiteLLM_SubscriptionAccountTable | None:
|
||||
columns = dict(changes.columns())
|
||||
self.written_columns.append(columns)
|
||||
existing = self.rows.get(subscription_account_id)
|
||||
if existing is None:
|
||||
return None
|
||||
updated = existing.model_copy(
|
||||
update={**columns, "updated_by": updated_by, "updated_at": datetime.now(timezone.utc)}
|
||||
)
|
||||
self.rows[subscription_account_id] = updated
|
||||
return updated
|
||||
|
||||
async def delete_account(self, subscription_account_id: str) -> LiteLLM_SubscriptionAccountTable | None:
|
||||
return self.rows.pop(subscription_account_id, None)
|
||||
|
||||
|
||||
def _resolve_auth(request: Request) -> UserAPIKeyAuth:
|
||||
role: Final = LitellmUserRoles(request.headers.get("x-user-role", LitellmUserRoles.PROXY_ADMIN.value))
|
||||
return UserAPIKeyAuth(user_id="admin", user_role=role, api_key="sk-test")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def deployments() -> tuple[SubscriptionDeployment, ...]:
|
||||
return _TWO_DEPLOYMENTS_ONE_ACCOUNT
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client(deployments: tuple[SubscriptionDeployment, ...]) -> Iterator[tuple[TestClient, _FakeStore]]:
|
||||
store: Final = _FakeStore()
|
||||
app: Final = FastAPI()
|
||||
app.include_router(router)
|
||||
app.dependency_overrides[get_subscription_account_repository] = lambda: store
|
||||
app.dependency_overrides[get_subscription_deployments] = lambda: deployments
|
||||
app.dependency_overrides[user_api_key_auth] = _resolve_auth
|
||||
with TestClient(app) as test_client:
|
||||
yield test_client, store
|
||||
|
||||
|
||||
def _usage(test_client: TestClient, start_date: str, end_date: str, **headers: str) -> dict:
|
||||
response = test_client.get(
|
||||
"/subscription_accounts/usage", params={"start_date": start_date, "end_date": end_date}, headers=headers
|
||||
)
|
||||
assert response.status_code == 200, response.text
|
||||
return response.json()
|
||||
|
||||
|
||||
def test_untracked_account_lists_its_deployments_with_no_fee(client):
|
||||
test_client, _ = client
|
||||
|
||||
body = _usage(test_client, "2026-10-01", "2026-10-07")
|
||||
|
||||
assert body["subscription_providers"] == ["chatgpt"]
|
||||
assert body["accounts"] == [
|
||||
{
|
||||
"custom_llm_provider": "chatgpt",
|
||||
"account_id": _ACCOUNT,
|
||||
"deployments": ["gpt-5.6-sol", "gpt-5.6-terra"],
|
||||
"fee": None,
|
||||
"billing_periods": [],
|
||||
"fixed_cost": None,
|
||||
}
|
||||
]
|
||||
|
||||
|
||||
def test_fee_counts_once_per_billing_period_however_many_deployments_share_the_account(client):
|
||||
test_client, _ = client
|
||||
created = test_client.post("/subscription_accounts/new", json=_TEST_FEE)
|
||||
assert created.status_code == 200, created.text
|
||||
|
||||
one_period = _usage(test_client, "2026-10-01", "2026-10-07")
|
||||
two_periods = _usage(test_client, "2026-09-15", "2026-11-15")
|
||||
between_starts = _usage(test_client, "2026-10-02", "2026-10-31")
|
||||
|
||||
(account,) = one_period["accounts"]
|
||||
assert account["deployments"] == ["gpt-5.6-sol", "gpt-5.6-terra"]
|
||||
assert account["fee"]["monthly_fee"] == 25.0
|
||||
assert account["fee"]["currency"] == "USD"
|
||||
assert account["fee"]["label"] == "Team plan (test value)"
|
||||
assert account["billing_periods"] == [{"start": "2026-10-01", "end": "2026-10-31"}]
|
||||
assert account["fixed_cost"] == 25.0
|
||||
assert two_periods["accounts"][0]["fixed_cost"] == 50.0
|
||||
assert [period["start"] for period in two_periods["accounts"][0]["billing_periods"]] == [
|
||||
"2026-10-01",
|
||||
"2026-11-01",
|
||||
]
|
||||
assert between_starts["accounts"][0]["fixed_cost"] == 0.0
|
||||
assert between_starts["accounts"][0]["billing_periods"] == []
|
||||
|
||||
|
||||
def test_fee_of_an_account_no_deployment_uses_stays_listed_and_counted(client):
|
||||
test_client, _ = client
|
||||
other = {**_TEST_FEE, "account_id": "org-other", "monthly_fee": 200.0, "currency": "EUR"}
|
||||
assert test_client.post("/subscription_accounts/new", json=other).status_code == 200
|
||||
assert test_client.post("/subscription_accounts/new", json=_TEST_FEE).status_code == 200
|
||||
|
||||
body = _usage(test_client, "2026-10-01", "2026-10-07")
|
||||
|
||||
unused, used = body["accounts"]
|
||||
assert (unused["account_id"], unused["deployments"], unused["fee"]["currency"]) == ("org-other", [], "EUR")
|
||||
assert unused["fixed_cost"] == 200.0
|
||||
assert (used["account_id"], used["fixed_cost"]) == (_ACCOUNT, 25.0)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"deployments",
|
||||
[(SubscriptionDeployment(model_name="gpt-5.6-terra", custom_llm_provider="chatgpt", account_id=None),)],
|
||||
)
|
||||
def test_account_not_signed_in_shows_no_account_and_takes_no_fee(client):
|
||||
test_client, _ = client
|
||||
assert test_client.post("/subscription_accounts/new", json=_TEST_FEE).status_code == 200
|
||||
|
||||
body = _usage(test_client, "2026-10-01", "2026-10-07")
|
||||
|
||||
unsigned = next(account for account in body["accounts"] if account["account_id"] is None)
|
||||
assert unsigned["deployments"] == ["gpt-5.6-terra"]
|
||||
assert unsigned["fee"] is None
|
||||
assert unsigned["fixed_cost"] is None
|
||||
|
||||
|
||||
def test_update_changes_the_fee_and_delete_returns_the_account_to_untracked(client):
|
||||
test_client, store = client
|
||||
created = test_client.post("/subscription_accounts/new", json=_TEST_FEE).json()
|
||||
account_id = created["subscription_account_id"]
|
||||
|
||||
updated = test_client.post(
|
||||
"/subscription_accounts/update",
|
||||
json={"subscription_account_id": account_id, "monthly_fee": 30.0, "billing_period_start": "2026-10-05"},
|
||||
)
|
||||
assert updated.status_code == 200, updated.text
|
||||
assert updated.json()["monthly_fee"] == 30.0
|
||||
assert updated.json()["currency"] == "USD"
|
||||
assert updated.json()["billing_period_start"] == "2026-10-05"
|
||||
assert updated.json()["label"] == _TEST_FEE["label"]
|
||||
assert _usage(test_client, "2026-10-01", "2026-10-07")["accounts"][0]["fixed_cost"] == 30.0
|
||||
|
||||
cleared = test_client.post(
|
||||
"/subscription_accounts/update", json={"subscription_account_id": account_id, "label": None}
|
||||
)
|
||||
assert cleared.status_code == 200, cleared.text
|
||||
assert cleared.json()["label"] is None
|
||||
assert cleared.json()["monthly_fee"] == 30.0
|
||||
assert store.written_columns == [{"monthly_fee": 30.0, "billing_period_start": "2026-10-05"}, {"label": None}]
|
||||
|
||||
unknown = test_client.post(
|
||||
"/subscription_accounts/update", json={"subscription_account_id": "no-such-account", "monthly_fee": 1.0}
|
||||
)
|
||||
assert unknown.status_code == 404
|
||||
|
||||
deleted = test_client.post("/subscription_accounts/delete", json={"subscription_account_id": account_id})
|
||||
assert deleted.status_code == 200, deleted.text
|
||||
assert store.rows == {}
|
||||
assert _usage(test_client, "2026-10-01", "2026-10-07")["accounts"][0]["fixed_cost"] is None
|
||||
|
||||
missing = test_client.post("/subscription_accounts/delete", json={"subscription_account_id": account_id})
|
||||
assert missing.status_code == 404
|
||||
|
||||
|
||||
def test_rejects_a_second_fee_for_the_same_account(client):
|
||||
test_client, _ = client
|
||||
assert test_client.post("/subscription_accounts/new", json=_TEST_FEE).status_code == 200
|
||||
|
||||
duplicate = test_client.post("/subscription_accounts/new", json={**_TEST_FEE, "monthly_fee": 99.0})
|
||||
|
||||
assert duplicate.status_code == 400
|
||||
assert "/subscription_accounts/update" in duplicate.json()["detail"]["error"]
|
||||
|
||||
|
||||
def test_rejects_a_fee_on_a_metered_provider(client):
|
||||
test_client, store = client
|
||||
|
||||
response = test_client.post("/subscription_accounts/new", json={**_TEST_FEE, "custom_llm_provider": "openai"})
|
||||
|
||||
assert response.status_code == 400
|
||||
assert store.rows == {}
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"payload",
|
||||
[
|
||||
{**_TEST_FEE, "monthly_fee": 0},
|
||||
{**_TEST_FEE, "account_id": ""},
|
||||
{**_TEST_FEE, "currency": "usd"},
|
||||
{**_TEST_FEE, "currency": "$"},
|
||||
{**_TEST_FEE, "billing_period_start": "10/01/2026"},
|
||||
],
|
||||
)
|
||||
def test_rejects_malformed_fee_fields(client, payload):
|
||||
test_client, store = client
|
||||
|
||||
assert test_client.post("/subscription_accounts/new", json=payload).status_code == 422
|
||||
assert store.rows == {}
|
||||
|
||||
|
||||
def test_rejects_an_infinite_monthly_fee():
|
||||
with pytest.raises(ValidationError):
|
||||
SubscriptionAccountFeeRequest.model_validate({**_TEST_FEE, "monthly_fee": float("inf")})
|
||||
with pytest.raises(ValidationError):
|
||||
UpdateSubscriptionAccountFeeRequest.model_validate(
|
||||
{"subscription_account_id": "fee-1", "monthly_fee": float("inf")}
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("deployments", [()])
|
||||
def test_fee_stays_listed_after_the_last_subscription_deployment_is_removed(client):
|
||||
test_client, _ = client
|
||||
assert test_client.post("/subscription_accounts/new", json=_TEST_FEE).status_code == 200
|
||||
|
||||
body = _usage(test_client, "2026-10-01", "2026-10-07")
|
||||
|
||||
(account,) = body["accounts"]
|
||||
assert (account["account_id"], account["deployments"], account["fixed_cost"]) == (_ACCOUNT, [], 25.0)
|
||||
|
||||
|
||||
def test_usage_rejects_a_malformed_or_inverted_range(client):
|
||||
test_client, _ = client
|
||||
|
||||
malformed = [
|
||||
test_client.get("/subscription_accounts/usage", params={"start_date": start, "end_date": "2026-10-07"})
|
||||
for start in ("2026-10-1", "20261001", "2026-W40-1", "2026-13-01")
|
||||
]
|
||||
inverted = test_client.get(
|
||||
"/subscription_accounts/usage", params={"start_date": "2026-10-07", "end_date": "2026-10-01"}
|
||||
)
|
||||
|
||||
assert [response.status_code for response in malformed] == [400, 400, 400, 400]
|
||||
assert inverted.status_code == 400
|
||||
|
||||
|
||||
def test_viewer_reads_usage_but_cannot_write(client):
|
||||
test_client, store = client
|
||||
viewer = {"x-user-role": LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY.value}
|
||||
|
||||
assert _usage(test_client, "2026-10-01", "2026-10-07", **viewer)["accounts"][0]["account_id"] == _ACCOUNT
|
||||
assert test_client.post("/subscription_accounts/new", json=_TEST_FEE, headers=viewer).status_code == 403
|
||||
assert store.rows == {}
|
||||
|
||||
|
||||
_SUBSCRIPTION_ROUTES: Final = (
|
||||
"/subscription_accounts/usage",
|
||||
"/subscription_accounts/new",
|
||||
"/subscription_accounts/update",
|
||||
"/subscription_accounts/delete",
|
||||
)
|
||||
|
||||
|
||||
def test_routes_follow_the_admin_route_policy():
|
||||
jwt_admin_defaults = LiteLLM_JWTAuth()
|
||||
|
||||
for route in _SUBSCRIPTION_ROUTES:
|
||||
assert allowed_routes_check(
|
||||
user_role=LitellmUserRoles.PROXY_ADMIN, user_route=route, litellm_proxy_roles=jwt_admin_defaults
|
||||
)
|
||||
assert RouteChecks.is_management_route(route)
|
||||
|
||||
|
||||
def test_viewer_route_gate_reads_usage_and_blocks_writes():
|
||||
viewer_role: Final = LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY.value
|
||||
get_usage = MagicMock(spec=Request, method="GET", query_params={})
|
||||
post_new = MagicMock(spec=Request, method="POST", query_params={})
|
||||
|
||||
RouteChecks._check_proxy_admin_viewer_access(
|
||||
route="/subscription_accounts/usage", _user_role=viewer_role, request_data={}, request=get_usage
|
||||
)
|
||||
with pytest.raises(HTTPException) as denied:
|
||||
RouteChecks._check_proxy_admin_viewer_access(
|
||||
route="/subscription_accounts/new", _user_role=viewer_role, request_data=_TEST_FEE, request=post_new
|
||||
)
|
||||
assert denied.value.status_code == 403
|
||||
|
||||
|
||||
def test_internal_user_cannot_read_subscription_accounts(client):
|
||||
test_client, _ = client
|
||||
|
||||
response = test_client.get(
|
||||
"/subscription_accounts/usage",
|
||||
params={"start_date": "2026-10-01", "end_date": "2026-10-07"},
|
||||
headers={"x-user-role": LitellmUserRoles.INTERNAL_USER.value},
|
||||
)
|
||||
|
||||
assert response.status_code == 403
|
||||
|
||||
|
||||
def test_deployments_take_the_account_of_their_own_login():
|
||||
model_list = [
|
||||
{"model_name": "gpt-5.6-terra", "litellm_params": {"model": "chatgpt/gpt-5.6-terra"}},
|
||||
{"model_name": "gpt-5.6-sol", "litellm_params": {"model": "chatgpt/gpt-5.6-sol"}},
|
||||
{
|
||||
"model_name": "gpt-5.6-luna",
|
||||
"litellm_params": {"model": "chatgpt/gpt-5.6-luna", "chatgpt_auth_file": "/logins/other.json"},
|
||||
},
|
||||
{"model_name": "sonnet", "litellm_params": {"model": "anthropic/claude-sonnet-4-5", "api_key": "sk-x"}},
|
||||
{"model_name": "broken", "litellm_params": {"model": "no-such-provider-model"}},
|
||||
]
|
||||
lookups: list[tuple[str, object]] = []
|
||||
|
||||
def resolver(provider: str, litellm_params) -> str | None:
|
||||
lookups.append((provider, litellm_params.get("model")))
|
||||
return "org-other" if litellm_params.get("chatgpt_auth_file") == "/logins/other.json" else _ACCOUNT
|
||||
|
||||
deployments = subscription_deployments_from_model_list(model_list, resolver)
|
||||
|
||||
assert deployments == (
|
||||
*_TWO_DEPLOYMENTS_ONE_ACCOUNT,
|
||||
SubscriptionDeployment(model_name="gpt-5.6-luna", custom_llm_provider="chatgpt", account_id="org-other"),
|
||||
)
|
||||
assert lookups == [
|
||||
("chatgpt", "chatgpt/gpt-5.6-terra"),
|
||||
("chatgpt", "chatgpt/gpt-5.6-sol"),
|
||||
("chatgpt", "chatgpt/gpt-5.6-luna"),
|
||||
]
|
||||
|
||||
|
||||
def test_deployments_list_each_router_deployment_once_by_the_name_callers_use():
|
||||
llm_router: Final = Router(
|
||||
model_list=[
|
||||
{"model_name": "gpt-5.6-sol", "litellm_params": {"model": "chatgpt/gpt-5.6-sol"}},
|
||||
{
|
||||
"model_name": "model_name_team-1_7f3a",
|
||||
"litellm_params": {"model": "chatgpt/gpt-5.6-terra"},
|
||||
"model_info": {"team_id": "team-1", "team_public_model_name": "team-terra"},
|
||||
},
|
||||
],
|
||||
model_group_alias={"sol-alias": "gpt-5.6-sol"},
|
||||
)
|
||||
|
||||
deployments = subscription_deployments_of_router(llm_router, lambda provider, litellm_params: _ACCOUNT)
|
||||
|
||||
assert sorted(deployment.model_name for deployment in deployments) == ["gpt-5.6-sol", "team-terra"]
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"deployments",
|
||||
[
|
||||
(
|
||||
*_TWO_DEPLOYMENTS_ONE_ACCOUNT,
|
||||
SubscriptionDeployment(model_name="gpt-5.6-luna", custom_llm_provider="chatgpt", account_id="org-other"),
|
||||
)
|
||||
],
|
||||
)
|
||||
def test_two_logins_each_count_their_own_fee_once(client):
|
||||
test_client, _ = client
|
||||
other = {**_TEST_FEE, "account_id": "org-other", "monthly_fee": 40.0}
|
||||
assert test_client.post("/subscription_accounts/new", json=_TEST_FEE).status_code == 200
|
||||
assert test_client.post("/subscription_accounts/new", json=other).status_code == 200
|
||||
|
||||
body = _usage(test_client, "2026-10-01", "2026-10-07")
|
||||
|
||||
assert [(a["account_id"], a["deployments"], a["fixed_cost"]) for a in body["accounts"]] == [
|
||||
("org-other", ["gpt-5.6-luna"], 40.0),
|
||||
(_ACCOUNT, ["gpt-5.6-sol", "gpt-5.6-terra"], 25.0),
|
||||
]
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
from datetime import date
|
||||
|
||||
from litellm.proxy.spend_tracking.subscription_billing_periods import (
|
||||
BillingPeriodRange,
|
||||
billing_periods_starting_within,
|
||||
)
|
||||
|
||||
|
||||
def test_one_period_per_month_start_inside_the_filter():
|
||||
periods = billing_periods_starting_within(date(2026, 8, 5), date(2026, 9, 1), date(2026, 10, 31))
|
||||
|
||||
assert periods == (
|
||||
BillingPeriodRange(start=date(2026, 9, 5), end=date(2026, 10, 4)),
|
||||
BillingPeriodRange(start=date(2026, 10, 5), end=date(2026, 11, 4)),
|
||||
)
|
||||
|
||||
|
||||
def test_filter_boundaries_are_inclusive():
|
||||
anchor = date(2026, 10, 1)
|
||||
|
||||
assert billing_periods_starting_within(anchor, date(2026, 10, 1), date(2026, 10, 7)) == (
|
||||
BillingPeriodRange(start=date(2026, 10, 1), end=date(2026, 10, 31)),
|
||||
)
|
||||
assert billing_periods_starting_within(anchor, date(2026, 9, 25), date(2026, 10, 1)) == (
|
||||
BillingPeriodRange(start=date(2026, 10, 1), end=date(2026, 10, 31)),
|
||||
)
|
||||
|
||||
|
||||
def test_filter_between_two_period_starts_attributes_nothing():
|
||||
assert billing_periods_starting_within(date(2026, 10, 15), date(2026, 10, 1), date(2026, 10, 7)) == ()
|
||||
|
||||
|
||||
def test_no_period_before_the_anchor():
|
||||
assert billing_periods_starting_within(date(2026, 10, 1), date(2026, 8, 1), date(2026, 9, 30)) == ()
|
||||
assert billing_periods_starting_within(date(2026, 10, 1), date(2026, 8, 1), date(2026, 10, 1)) == (
|
||||
BillingPeriodRange(start=date(2026, 10, 1), end=date(2026, 10, 31)),
|
||||
)
|
||||
|
||||
|
||||
def test_anchor_day_clamps_to_short_months_without_drifting():
|
||||
periods = billing_periods_starting_within(date(2026, 1, 31), date(2026, 2, 1), date(2026, 5, 31))
|
||||
|
||||
assert [period.start for period in periods] == [
|
||||
date(2026, 2, 28),
|
||||
date(2026, 3, 31),
|
||||
date(2026, 4, 30),
|
||||
date(2026, 5, 31),
|
||||
]
|
||||
assert periods[0].end == date(2026, 3, 30)
|
||||
assert periods[-1].end == date(2026, 6, 29)
|
||||
|
||||
|
||||
def test_period_ends_the_day_before_the_next_start_across_a_year_boundary():
|
||||
periods = billing_periods_starting_within(date(2025, 12, 20), date(2025, 12, 1), date(2026, 1, 31))
|
||||
|
||||
assert periods == (
|
||||
BillingPeriodRange(start=date(2025, 12, 20), end=date(2026, 1, 19)),
|
||||
BillingPeriodRange(start=date(2026, 1, 20), end=date(2026, 2, 19)),
|
||||
)
|
||||
|
||||
|
||||
def test_inverted_filter_is_empty():
|
||||
assert billing_periods_starting_within(date(2026, 1, 1), date(2026, 3, 1), date(2026, 2, 1)) == ()
|
||||
|
||||
|
||||
def test_the_calendar_s_last_month_ends_on_its_last_day_instead_of_failing():
|
||||
assert billing_periods_starting_within(date(9999, 11, 15), date(9999, 11, 1), date(9999, 12, 31)) == (
|
||||
BillingPeriodRange(start=date(9999, 11, 15), end=date(9999, 12, 14)),
|
||||
BillingPeriodRange(start=date(9999, 12, 15), end=date(9999, 12, 31)),
|
||||
)
|
||||
assert billing_periods_starting_within(date(9999, 12, 1), date(9999, 12, 1), date(9999, 12, 31)) == (
|
||||
BillingPeriodRange(start=date(9999, 12, 1), end=date(9999, 12, 31)),
|
||||
)
|
||||
|
|
@ -30,6 +30,11 @@ from litellm.repositories.object_permission_repository import (
|
|||
)
|
||||
from litellm.repositories.organization_repository import OrganizationRepository
|
||||
from litellm.repositories.project_repository import ProjectRepository
|
||||
from litellm.repositories.subscription_account_repository import (
|
||||
SetLabel,
|
||||
SubscriptionAccountFeeChanges,
|
||||
SubscriptionAccountRepository,
|
||||
)
|
||||
from litellm.repositories.team_repository import TeamRepository
|
||||
from litellm.repositories.user_repository import UserRepository
|
||||
from litellm.repositories.verification_token_repository import (
|
||||
|
|
@ -140,6 +145,7 @@ class MockPrismaClient:
|
|||
self.db.litellm_projecttable = MockTable(pk_field="project_id")
|
||||
self.db.litellm_objectpermissiontable = MockTable(pk_field="object_permission_id")
|
||||
self.db.litellm_credentialstable = MockTable()
|
||||
self.db.litellm_subscriptionaccounttable = MockTable(pk_field="subscription_account_id")
|
||||
|
||||
|
||||
class TestBaseRepository:
|
||||
|
|
@ -2461,3 +2467,40 @@ class TestAutoRouterSessionRepository:
|
|||
assert AutoRouterSessionRepository(client).table is client.db.litellm_autoroutersession
|
||||
with pytest.raises(RuntimeError, match="No DB Connected"):
|
||||
_ = AutoRouterSessionRepository(None).table
|
||||
|
||||
|
||||
class TestSubscriptionAccountRepository:
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_fee_writes_only_the_named_columns(self):
|
||||
client = MockPrismaClient()
|
||||
stored_at = datetime(2026, 10, 1)
|
||||
await client.db.litellm_subscriptionaccounttable.create(
|
||||
data={
|
||||
"subscription_account_id": "sub-1",
|
||||
"custom_llm_provider": "chatgpt",
|
||||
"account_id": "acct_123",
|
||||
"label": "Team plan (test value)",
|
||||
"monthly_fee": 25.0,
|
||||
"currency": "USD",
|
||||
"billing_period_start": "2026-10-01",
|
||||
"created_at": stored_at,
|
||||
"created_by": "admin-a",
|
||||
"updated_at": stored_at,
|
||||
"updated_by": "admin-a",
|
||||
}
|
||||
)
|
||||
repo = SubscriptionAccountRepository(client)
|
||||
|
||||
fee_only = await repo.update_fee("sub-1", SubscriptionAccountFeeChanges(monthly_fee=30.0), "admin-b")
|
||||
label_cleared = await repo.update_fee("sub-1", SubscriptionAccountFeeChanges(label=SetLabel(None)), "admin-c")
|
||||
missing = await repo.update_fee("sub-2", SubscriptionAccountFeeChanges(monthly_fee=1.0), "admin-b")
|
||||
|
||||
assert fee_only is not None and label_cleared is not None
|
||||
assert (fee_only.monthly_fee, fee_only.currency, fee_only.label, fee_only.updated_by) == (
|
||||
30.0,
|
||||
"USD",
|
||||
"Team plan (test value)",
|
||||
"admin-b",
|
||||
)
|
||||
assert (label_cleared.monthly_fee, label_cleared.label, label_cleared.updated_by) == (30.0, None, "admin-c")
|
||||
assert missing is None
|
||||
|
|
|
|||
|
|
@ -1160,6 +1160,34 @@ describe("EntityUsage", () => {
|
|||
expect(screen.getByTestId("provider-spend-total")).toHaveTextContent("$100.50");
|
||||
});
|
||||
|
||||
it("lists a subscription-covered provider on the team view as included in the subscription at zero spend", async () => {
|
||||
const day = mockSpendData.results[0];
|
||||
mockTeamDailyActivityCall.mockResolvedValue({
|
||||
...mockSpendData,
|
||||
results: [
|
||||
{
|
||||
...day,
|
||||
breakdown: {
|
||||
...day.breakdown,
|
||||
providers: {
|
||||
...day.breakdown.providers,
|
||||
chatgpt: {
|
||||
metrics: { ...day.breakdown.providers.openai.metrics, spend: 0, api_requests: 4 },
|
||||
metadata: { subscription_covered: true },
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
render(<StatefulEntityUsage {...defaultProps} entityType="team" />);
|
||||
|
||||
expect(await screen.findByText("Included in subscription")).toBeInTheDocument();
|
||||
expect(screen.getByText("chatgpt")).toBeInTheDocument();
|
||||
expect(screen.getAllByTestId("provider-share-segment")).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("should label the chart with user_email metadata instead of the raw UUID (LIT-3889)", async () => {
|
||||
const userUuid = "c0e68be8-057e-4e2f-9d3a-000000000000";
|
||||
const spendDataForUser = {
|
||||
|
|
|
|||
|
|
@ -258,6 +258,34 @@ describe("SpendByProvider", () => {
|
|||
expect(screen.getByTestId("provider-spend-total")).toHaveTextContent("$200.50");
|
||||
});
|
||||
|
||||
it("always shows a subscription-covered provider and marks it included in the subscription", () => {
|
||||
const providerSpendWithSubscription = [
|
||||
{
|
||||
provider: "chatgpt",
|
||||
spend: 0,
|
||||
requests: 7,
|
||||
successful_requests: 7,
|
||||
failed_requests: 0,
|
||||
tokens: 11608,
|
||||
subscription_covered: true,
|
||||
},
|
||||
{
|
||||
provider: "google",
|
||||
spend: 0,
|
||||
requests: 0,
|
||||
successful_requests: 0,
|
||||
failed_requests: 0,
|
||||
tokens: 0,
|
||||
},
|
||||
];
|
||||
render(<SpendByProvider loading={false} isDateChanging={false} providerSpend={providerSpendWithSubscription} />);
|
||||
expect(screen.getAllByText("chatgpt").length).toBeGreaterThan(0);
|
||||
expect(screen.getByText("Included in subscription")).toBeInTheDocument();
|
||||
expect(screen.getByText("11,608")).toBeInTheDocument();
|
||||
expect(screen.queryByText("google")).not.toBeInTheDocument();
|
||||
expect(screen.getByText("Included in subscription").closest("td")).not.toHaveTextContent("$");
|
||||
});
|
||||
|
||||
it("should include all providers with spend greater than zero by default", () => {
|
||||
const providerSpendWithMixed = [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ import { MoneyCell } from "@/components/shared/table_cells";
|
|||
import { formatNumberWithCommas } from "@/utils/dataUtils";
|
||||
import { Info, Server } from "lucide-react";
|
||||
import type { ColumnDef } from "@tanstack/react-table";
|
||||
import { Badge } from "@/components/ui/badge";
|
||||
import { Switch } from "@/components/ui/switch";
|
||||
import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
|
||||
import React, { useId, useState } from "react";
|
||||
|
|
@ -11,13 +12,14 @@ import { ProviderLogo } from "@/components/molecules/models/ProviderLogo";
|
|||
import { ChartLoader } from "@/components/shared/chart_loader";
|
||||
import { Panel } from "../overview/Primitives";
|
||||
|
||||
type ProviderSpendData = {
|
||||
export type ProviderSpendData = {
|
||||
provider: string;
|
||||
spend: number;
|
||||
requests: number;
|
||||
successful_requests: number;
|
||||
failed_requests: number;
|
||||
tokens: number;
|
||||
subscription_covered?: boolean;
|
||||
};
|
||||
|
||||
interface SpendByProviderProps {
|
||||
|
|
@ -48,7 +50,15 @@ const columns: ColumnDef<ProviderSpendData>[] = [
|
|||
header: "Spend",
|
||||
accessorKey: "spend",
|
||||
meta: { numeric: true, ...QUIET_HEADER },
|
||||
cell: ({ row }) => <MoneyCell value={row.original.spend} decimals={2} />,
|
||||
cell: ({ row }) =>
|
||||
row.original.subscription_covered ? (
|
||||
<div className="flex items-center justify-end gap-2">
|
||||
{row.original.spend > 0 && <MoneyCell value={row.original.spend} decimals={2} />}
|
||||
<Badge variant="secondary">Included in subscription</Badge>
|
||||
</div>
|
||||
) : (
|
||||
<MoneyCell value={row.original.spend} decimals={2} />
|
||||
),
|
||||
},
|
||||
{
|
||||
header: "Successful",
|
||||
|
|
@ -164,6 +174,10 @@ const SpendByProvider: React.FC<SpendByProviderProps> = ({ loading, isDateChangi
|
|||
return includeUnknown;
|
||||
}
|
||||
|
||||
if (provider.subscription_covered) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// If includeZeroSpend is true, include all providers (including those with 0 spend)
|
||||
// Otherwise, only include providers with spend > 0
|
||||
if (includeZeroSpend) {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
import { keyActivityLabel } from "@/components/UsagePage/keyActivityLabel";
|
||||
import type { TopKeyItem } from "@/components/UsagePage/components/EntityUsage/TopKeyView";
|
||||
import { BreakdownMetrics, DailyData, KeyMetricWithMetadata, TagUsage } from "@/components/UsagePage/types";
|
||||
import { subscriptionCoveredProviders } from "../SubscriptionCost/types";
|
||||
|
||||
export type ExtendedDailyData = DailyData & {
|
||||
breakdown: BreakdownMetrics;
|
||||
|
|
@ -15,6 +16,7 @@ export interface ProviderSpendRow extends Record<string, unknown> {
|
|||
successful_requests: number;
|
||||
failed_requests: number;
|
||||
tokens: number;
|
||||
subscription_covered: boolean;
|
||||
}
|
||||
|
||||
export const getTopModels = (
|
||||
|
|
@ -205,6 +207,7 @@ export const getTopAPIKeys = (results: ExtendedDailyData[], topKeysLimit: number
|
|||
};
|
||||
|
||||
export const getProviderSpend = (results: ExtendedDailyData[]): ProviderSpendRow[] => {
|
||||
const covered = subscriptionCoveredProviders(results);
|
||||
const providerSpend: Record<string, ProviderSpendRow> = {};
|
||||
results.forEach((day) => {
|
||||
Object.entries(day.breakdown.providers || {}).forEach(([provider, metrics]) => {
|
||||
|
|
@ -216,6 +219,7 @@ export const getProviderSpend = (results: ExtendedDailyData[]): ProviderSpendRow
|
|||
successful_requests: 0,
|
||||
failed_requests: 0,
|
||||
tokens: 0,
|
||||
subscription_covered: covered.has(provider),
|
||||
};
|
||||
}
|
||||
try {
|
||||
|
|
@ -231,6 +235,6 @@ export const getProviderSpend = (results: ExtendedDailyData[]): ProviderSpendRow
|
|||
});
|
||||
|
||||
return Object.values(providerSpend)
|
||||
.filter((provider) => provider.spend > 0)
|
||||
.filter((provider) => provider.spend > 0 || provider.subscription_covered)
|
||||
.sort((a, b) => b.spend - a.spend);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -0,0 +1,185 @@
|
|||
import { fireEvent, render, screen } from "@testing-library/react";
|
||||
import { describe, expect, it, vi } from "vitest";
|
||||
import SubscriptionCostCard from "./SubscriptionCostCard";
|
||||
import type { SubscriptionAccountUsage, SubscriptionFee } from "./types";
|
||||
|
||||
vi.mock("@/components/shared/chart_loader", () => ({
|
||||
ChartLoader: () => <div data-testid="chart-loader">Loading chart data...</div>,
|
||||
}));
|
||||
|
||||
vi.mock("@/components/molecules/models/ProviderLogo", () => ({
|
||||
ProviderLogo: ({ provider }: { provider: string }) => <div data-testid={`provider-logo-${provider}`} />,
|
||||
}));
|
||||
|
||||
const fee = (overrides: Partial<SubscriptionFee> = {}): SubscriptionFee => ({
|
||||
subscription_account_id: "fee-1",
|
||||
custom_llm_provider: "chatgpt",
|
||||
account_id: "acct_123",
|
||||
label: null,
|
||||
monthly_fee: 25,
|
||||
currency: "USD",
|
||||
billing_period_start: "2026-10-01",
|
||||
created_at: "2026-10-06T00:00:00Z",
|
||||
updated_at: "2026-10-06T00:00:00Z",
|
||||
created_by: "admin",
|
||||
updated_by: "admin",
|
||||
...overrides,
|
||||
});
|
||||
|
||||
const account = (overrides: Partial<SubscriptionAccountUsage> = {}): SubscriptionAccountUsage => ({
|
||||
custom_llm_provider: "chatgpt",
|
||||
account_id: "acct_123",
|
||||
deployments: ["gpt-5.6-terra", "gpt-5.6-sol"],
|
||||
fee: null,
|
||||
billing_periods: [],
|
||||
fixed_cost: null,
|
||||
...overrides,
|
||||
});
|
||||
|
||||
const handlers = () => ({ onSetFee: vi.fn(), onEditFee: vi.fn(), onRemoveFee: vi.fn() });
|
||||
|
||||
const renderCard = (accounts: SubscriptionAccountUsage[], props: { canEdit?: boolean; meteredSpend?: number } = {}) => {
|
||||
const actions = handlers();
|
||||
const view = render(
|
||||
<SubscriptionCostCard
|
||||
loading={false}
|
||||
failed={false}
|
||||
isDateChanging={false}
|
||||
usage={{ subscription_providers: ["chatgpt"], accounts }}
|
||||
meteredSpend={props.meteredSpend ?? 0}
|
||||
canEdit={props.canEdit ?? true}
|
||||
{...actions}
|
||||
/>,
|
||||
);
|
||||
return { ...view, ...actions };
|
||||
};
|
||||
|
||||
describe("SubscriptionCostCard", () => {
|
||||
it("renders nothing when there are no subscription accounts", () => {
|
||||
const { container } = render(
|
||||
<SubscriptionCostCard
|
||||
loading={false}
|
||||
failed={false}
|
||||
isDateChanging={false}
|
||||
usage={{ subscription_providers: [], accounts: [] }}
|
||||
meteredSpend={0}
|
||||
canEdit
|
||||
{...handlers()}
|
||||
/>,
|
||||
);
|
||||
expect(container).toBeEmptyDOMElement();
|
||||
expect(screen.queryByText("Subscription fixed costs")).not.toBeInTheDocument();
|
||||
});
|
||||
|
||||
it("calls out an untracked fixed cost and offers to set the fee only to an editor", () => {
|
||||
const { onSetFee, unmount } = renderCard([account()]);
|
||||
expect(screen.getByText("Fixed cost not tracked")).toBeInTheDocument();
|
||||
expect(screen.getByText("gpt-5.6-terra, gpt-5.6-sol")).toBeInTheDocument();
|
||||
expect(screen.getByText("None in range")).toBeInTheDocument();
|
||||
expect(screen.getByTestId("fixed-cost-total")).toHaveTextContent("Fixed cost in range: none");
|
||||
fireEvent.click(screen.getByRole("button", { name: "Set monthly fee" }));
|
||||
expect(onSetFee).toHaveBeenCalledWith(account());
|
||||
unmount();
|
||||
|
||||
renderCard([account()], { canEdit: false });
|
||||
expect(screen.getByText("Fixed cost not tracked")).toBeInTheDocument();
|
||||
expect(screen.queryByRole("button", { name: "Set monthly fee" })).not.toBeInTheDocument();
|
||||
});
|
||||
|
||||
it("shows a configured fee once for two deployments sharing the account and the fixed cost in range", () => {
|
||||
const covered = account({
|
||||
fee: fee({ label: "Team workspace" }),
|
||||
billing_periods: [{ start: "2026-10-01", end: "2026-10-31" }],
|
||||
fixed_cost: 25,
|
||||
});
|
||||
const { onEditFee, onRemoveFee } = renderCard([covered], { meteredSpend: 0.0838 });
|
||||
|
||||
expect(screen.getAllByText("25.00 USD")).toHaveLength(2);
|
||||
expect(screen.getByText("Team workspace")).toBeInTheDocument();
|
||||
expect(screen.getByText("Oct 1 - Oct 31, 2026")).toBeInTheDocument();
|
||||
expect(screen.getByTestId("fixed-cost-total")).toHaveTextContent("Fixed cost in range: 25.00 USD");
|
||||
expect(screen.getByTestId("metered-spend")).toHaveTextContent("Usage-billed spend in range, all providers: $0.08");
|
||||
expect(screen.queryByText(/25\.08/)).not.toBeInTheDocument();
|
||||
|
||||
fireEvent.click(screen.getByRole("button", { name: "Edit" }));
|
||||
expect(onEditFee).toHaveBeenCalledWith(covered);
|
||||
});
|
||||
|
||||
it("removes a fee only after the admin confirms it", async () => {
|
||||
const covered = account({ fee: fee(), billing_periods: [], fixed_cost: 0 });
|
||||
const { onRemoveFee } = renderCard([covered]);
|
||||
|
||||
fireEvent.click(screen.getByRole("button", { name: "Remove" }));
|
||||
expect(onRemoveFee).not.toHaveBeenCalled();
|
||||
fireEvent.click(await screen.findByRole("button", { name: "Cancel" }));
|
||||
expect(onRemoveFee).not.toHaveBeenCalled();
|
||||
|
||||
fireEvent.click(screen.getByRole("button", { name: "Remove" }));
|
||||
fireEvent.click(await screen.findByRole("button", { name: "Remove fee" }));
|
||||
expect(onRemoveFee).toHaveBeenCalledWith(covered);
|
||||
});
|
||||
|
||||
it("sums fixed costs per currency and keeps a second currency separate", () => {
|
||||
const october = { start: "2026-10-01", end: "2026-10-31" };
|
||||
const twoPeriods = {
|
||||
fee: fee(),
|
||||
billing_periods: [{ start: "2026-09-01", end: "2026-09-30" }, october],
|
||||
fixed_cost: 50,
|
||||
};
|
||||
const secondUsd = { subscription_account_id: "fee-2", account_id: "acct_456", monthly_fee: 10 };
|
||||
const noDeployments = {
|
||||
account_id: "acct_456",
|
||||
deployments: [],
|
||||
fee: fee(secondUsd),
|
||||
billing_periods: [october],
|
||||
fixed_cost: 10,
|
||||
};
|
||||
const euro = { subscription_account_id: "fee-3", account_id: "acct_789", monthly_fee: 20, currency: "EUR" };
|
||||
const inEuros = { account_id: "acct_789", fee: fee(euro), billing_periods: [october], fixed_cost: 20 };
|
||||
renderCard([account(twoPeriods), account(noDeployments), account(inEuros)]);
|
||||
|
||||
const totals = screen.getAllByTestId("fixed-cost-total").map((node) => node.textContent);
|
||||
expect(totals).toEqual(["Fixed cost in range: 60.00 USD", "Fixed cost in range: 20.00 EUR"]);
|
||||
expect(screen.getByText("None")).toBeInTheDocument();
|
||||
expect(screen.getByText("Sep 1 - Sep 30, 2026")).toBeInTheDocument();
|
||||
});
|
||||
|
||||
it("explains an unresolved account and offers no action for it", () => {
|
||||
renderCard([account({ account_id: null })]);
|
||||
expect(screen.getByText("Account not signed in on the proxy")).toBeInTheDocument();
|
||||
expect(screen.getByText("Fixed cost not tracked")).toBeInTheDocument();
|
||||
expect(screen.queryByRole("button")).not.toBeInTheDocument();
|
||||
});
|
||||
|
||||
it("shows the loader instead of the table while a range is loading", () => {
|
||||
render(
|
||||
<SubscriptionCostCard
|
||||
loading
|
||||
failed={false}
|
||||
isDateChanging
|
||||
usage={{ subscription_providers: ["chatgpt"], accounts: [account({ fee: fee(), fixed_cost: 25 })] }}
|
||||
meteredSpend={0}
|
||||
canEdit
|
||||
{...handlers()}
|
||||
/>,
|
||||
);
|
||||
expect(screen.getByTestId("chart-loader")).toBeInTheDocument();
|
||||
expect(screen.queryByText("25.00 USD")).not.toBeInTheDocument();
|
||||
});
|
||||
|
||||
it("says so instead of disappearing when the usage request fails", () => {
|
||||
render(
|
||||
<SubscriptionCostCard
|
||||
loading={false}
|
||||
failed
|
||||
isDateChanging={false}
|
||||
usage={null}
|
||||
meteredSpend={0}
|
||||
canEdit
|
||||
{...handlers()}
|
||||
/>,
|
||||
);
|
||||
expect(screen.getByText("Could not load subscription accounts for this range.")).toBeInTheDocument();
|
||||
expect(screen.queryByTestId("chart-loader")).not.toBeInTheDocument();
|
||||
});
|
||||
});
|
||||
|
|
@ -0,0 +1,221 @@
|
|||
import type { ColumnDef } from "@tanstack/react-table";
|
||||
import { Info } from "lucide-react";
|
||||
import React from "react";
|
||||
import { ProviderLogo } from "@/components/molecules/models/ProviderLogo";
|
||||
import { ChartLoader } from "@/components/shared/chart_loader";
|
||||
import { DataTable } from "@/components/shared/DataTable";
|
||||
import {
|
||||
AlertDialog,
|
||||
AlertDialogAction,
|
||||
AlertDialogCancel,
|
||||
AlertDialogContent,
|
||||
AlertDialogDescription,
|
||||
AlertDialogFooter,
|
||||
AlertDialogHeader,
|
||||
AlertDialogTitle,
|
||||
AlertDialogTrigger,
|
||||
} from "@/components/ui/alert-dialog";
|
||||
import { Badge } from "@/components/ui/badge";
|
||||
import { Button } from "@/components/ui/button";
|
||||
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
|
||||
import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
|
||||
import { formatNumberWithCommas } from "@/utils/dataUtils";
|
||||
import { ATTRIBUTION_RULE, fixedCostByCurrency, formatBillingPeriod, formatFee } from "./formatting";
|
||||
import type { SubscriptionAccountUsage, SubscriptionUsageResponse } from "./types";
|
||||
|
||||
interface SubscriptionCostCardProps {
|
||||
loading: boolean;
|
||||
failed: boolean;
|
||||
isDateChanging: boolean;
|
||||
usage: SubscriptionUsageResponse | null;
|
||||
meteredSpend: number;
|
||||
canEdit: boolean;
|
||||
onSetFee: (account: SubscriptionAccountUsage) => void;
|
||||
onEditFee: (account: SubscriptionAccountUsage) => void;
|
||||
onRemoveFee: (account: SubscriptionAccountUsage) => void;
|
||||
}
|
||||
|
||||
type FeeActions = Pick<SubscriptionCostCardProps, "onSetFee" | "onEditFee" | "onRemoveFee">;
|
||||
|
||||
const accountRowId = (account: SubscriptionAccountUsage): string =>
|
||||
`${account.custom_llm_provider}:${account.account_id ?? "unresolved"}`;
|
||||
|
||||
const AccountCell = ({ account }: { account: SubscriptionAccountUsage }) => {
|
||||
if (account.account_id === null) {
|
||||
return <span className="text-muted-foreground">Account not signed in on the proxy</span>;
|
||||
}
|
||||
return (
|
||||
<div className="flex flex-col">
|
||||
<span className="font-mono text-xs break-all whitespace-normal">{account.account_id}</span>
|
||||
{account.fee?.label && <span className="text-xs text-muted-foreground">{account.fee.label}</span>}
|
||||
</div>
|
||||
);
|
||||
};
|
||||
|
||||
const ActionsCell = ({
|
||||
account,
|
||||
onSetFee,
|
||||
onEditFee,
|
||||
onRemoveFee,
|
||||
}: { account: SubscriptionAccountUsage } & FeeActions) => {
|
||||
if (account.account_id === null) return null;
|
||||
if (account.fee === null) {
|
||||
return (
|
||||
<Button variant="outline" size="xs" onClick={() => onSetFee(account)}>
|
||||
Set monthly fee
|
||||
</Button>
|
||||
);
|
||||
}
|
||||
return (
|
||||
<div className="flex justify-end gap-2">
|
||||
<Button variant="outline" size="xs" onClick={() => onEditFee(account)}>
|
||||
Edit
|
||||
</Button>
|
||||
<AlertDialog>
|
||||
<AlertDialogTrigger render={<Button variant="outline" size="xs" />}>Remove</AlertDialogTrigger>
|
||||
<AlertDialogContent>
|
||||
<AlertDialogHeader>
|
||||
<AlertDialogTitle>Remove this monthly fee?</AlertDialogTitle>
|
||||
<AlertDialogDescription>
|
||||
{account.account_id} goes back to "Fixed cost not tracked". Its requests stay included in the
|
||||
subscription
|
||||
</AlertDialogDescription>
|
||||
</AlertDialogHeader>
|
||||
<AlertDialogFooter>
|
||||
<AlertDialogCancel>Cancel</AlertDialogCancel>
|
||||
<AlertDialogAction variant="destructive" onClick={() => onRemoveFee(account)}>
|
||||
Remove fee
|
||||
</AlertDialogAction>
|
||||
</AlertDialogFooter>
|
||||
</AlertDialogContent>
|
||||
</AlertDialog>
|
||||
</div>
|
||||
);
|
||||
};
|
||||
|
||||
const baseColumns: ColumnDef<SubscriptionAccountUsage>[] = [
|
||||
{
|
||||
header: "Provider",
|
||||
accessorKey: "custom_llm_provider",
|
||||
cell: ({ row }) => (
|
||||
<div className="flex items-center gap-2 whitespace-nowrap">
|
||||
<ProviderLogo provider={row.original.custom_llm_provider} className="size-4 shrink-0" />
|
||||
<span>{row.original.custom_llm_provider}</span>
|
||||
</div>
|
||||
),
|
||||
},
|
||||
{
|
||||
header: "Account",
|
||||
accessorKey: "account_id",
|
||||
cell: ({ row }) => <AccountCell account={row.original} />,
|
||||
},
|
||||
{
|
||||
header: "Deployments",
|
||||
id: "deployments",
|
||||
cell: ({ row }) => (row.original.deployments.length === 0 ? "None" : row.original.deployments.join(", ")),
|
||||
},
|
||||
{
|
||||
header: "Monthly fee",
|
||||
id: "monthly_fee",
|
||||
meta: { numeric: true },
|
||||
cell: ({ row }) =>
|
||||
row.original.fee === null ? (
|
||||
<Badge variant="outline">Fixed cost not tracked</Badge>
|
||||
) : (
|
||||
formatFee(row.original.fee.monthly_fee, row.original.fee.currency)
|
||||
),
|
||||
},
|
||||
{
|
||||
header: "Billing periods in range",
|
||||
id: "billing_periods",
|
||||
cell: ({ row }) =>
|
||||
row.original.billing_periods.length === 0 ? (
|
||||
<span className="text-muted-foreground">None in range</span>
|
||||
) : (
|
||||
<div className="flex flex-col">
|
||||
{row.original.billing_periods.map((period) => (
|
||||
<span key={period.start}>{formatBillingPeriod(period)}</span>
|
||||
))}
|
||||
</div>
|
||||
),
|
||||
},
|
||||
{
|
||||
header: "Fixed cost in range",
|
||||
id: "fixed_cost",
|
||||
meta: { numeric: true },
|
||||
cell: ({ row }) =>
|
||||
row.original.fee === null || row.original.fixed_cost === null
|
||||
? "-"
|
||||
: formatFee(row.original.fixed_cost, row.original.fee.currency),
|
||||
},
|
||||
];
|
||||
|
||||
const actionsColumn = (actions: FeeActions): ColumnDef<SubscriptionAccountUsage> => ({
|
||||
header: "",
|
||||
id: "actions",
|
||||
meta: { numeric: true },
|
||||
cell: ({ row }) => <ActionsCell account={row.original} {...actions} />,
|
||||
});
|
||||
|
||||
const SubscriptionCostCard: React.FC<SubscriptionCostCardProps> = ({
|
||||
loading,
|
||||
failed,
|
||||
isDateChanging,
|
||||
usage,
|
||||
meteredSpend,
|
||||
canEdit,
|
||||
onSetFee,
|
||||
onEditFee,
|
||||
onRemoveFee,
|
||||
}) => {
|
||||
if (!failed && (usage === null || usage.accounts.length === 0)) return null;
|
||||
const columns = canEdit ? [...baseColumns, actionsColumn({ onSetFee, onEditFee, onRemoveFee })] : baseColumns;
|
||||
const accounts = usage?.accounts ?? [];
|
||||
const totals = fixedCostByCurrency(accounts);
|
||||
|
||||
return (
|
||||
<Card className="col-span-2">
|
||||
<CardHeader>
|
||||
<CardTitle className="flex items-center gap-1">
|
||||
Subscription fixed costs
|
||||
<Tooltip>
|
||||
<TooltipTrigger render={<Info className="size-4 text-muted-foreground hover:text-foreground" />} />
|
||||
<TooltipContent>{ATTRIBUTION_RULE}</TooltipContent>
|
||||
</Tooltip>
|
||||
</CardTitle>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
{failed && <p className="text-sm text-destructive">Could not load subscription accounts for this range.</p>}
|
||||
{!failed && loading && <ChartLoader isDateChanging={isDateChanging} />}
|
||||
{!failed && !loading && (
|
||||
<div className="flex flex-col gap-4">
|
||||
<DataTable
|
||||
columns={columns}
|
||||
data={accounts}
|
||||
getRowId={accountRowId}
|
||||
noDataMessage="No subscription accounts"
|
||||
size="compact"
|
||||
/>
|
||||
<div className="flex flex-wrap items-center gap-x-6 gap-y-1 text-sm">
|
||||
{totals.length === 0 ? (
|
||||
<span data-testid="fixed-cost-total">Fixed cost in range: none</span>
|
||||
) : (
|
||||
totals.map(({ currency, total }) => (
|
||||
<span key={currency} data-testid="fixed-cost-total">
|
||||
Fixed cost in range: {formatFee(total, currency)}
|
||||
</span>
|
||||
))
|
||||
)}
|
||||
<span data-testid="metered-spend">
|
||||
Usage-billed spend in range, all providers: ${formatNumberWithCommas(meteredSpend, 2)}
|
||||
</span>
|
||||
</div>
|
||||
<p className="text-xs text-muted-foreground">{ATTRIBUTION_RULE}</p>
|
||||
</div>
|
||||
)}
|
||||
</CardContent>
|
||||
</Card>
|
||||
);
|
||||
};
|
||||
|
||||
export default SubscriptionCostCard;
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
import { fireEvent, screen, waitFor } from "@testing-library/react";
|
||||
import userEvent from "@testing-library/user-event";
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { renderWithProviders, testQueryClient } from "@/../tests/test-utils";
|
||||
import { subscriptionAccountCreateCall, subscriptionUsageCall } from "@/components/networking";
|
||||
import SubscriptionCosts from "./SubscriptionCosts";
|
||||
import type { SubscriptionUsageResponse } from "./types";
|
||||
|
||||
vi.mock("@/components/networking", () => ({
|
||||
formatDate: (date: Date) => date.toISOString().slice(0, 10),
|
||||
subscriptionUsageCall: vi.fn(),
|
||||
subscriptionAccountCreateCall: vi.fn().mockResolvedValue({}),
|
||||
subscriptionAccountUpdateCall: vi.fn().mockResolvedValue({}),
|
||||
subscriptionAccountDeleteCall: vi.fn().mockResolvedValue({}),
|
||||
}));
|
||||
vi.mock("@/lib/toast", () => ({ toast: { success: vi.fn(), fromError: vi.fn() } }));
|
||||
|
||||
const untracked: SubscriptionUsageResponse = {
|
||||
start_date: "2026-10-01",
|
||||
end_date: "2026-10-07",
|
||||
subscription_providers: ["chatgpt"],
|
||||
accounts: [
|
||||
{
|
||||
custom_llm_provider: "chatgpt",
|
||||
account_id: "acct_123",
|
||||
deployments: ["gpt-5.6-sol", "gpt-5.6-terra"],
|
||||
fee: null,
|
||||
billing_periods: [],
|
||||
fixed_cost: null,
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
const fill = (label: string, value: string) => fireEvent.change(screen.getByLabelText(label), { target: { value } });
|
||||
|
||||
describe("SubscriptionCosts", () => {
|
||||
beforeEach(() => {
|
||||
testQueryClient.clear();
|
||||
vi.clearAllMocks();
|
||||
vi.mocked(subscriptionUsageCall).mockResolvedValue(untracked);
|
||||
});
|
||||
|
||||
it("saves a fee set from the card on that card's account and reloads the card", async () => {
|
||||
const user = userEvent.setup();
|
||||
renderWithProviders(
|
||||
<SubscriptionCosts
|
||||
accessToken="sk-admin"
|
||||
startTime={new Date("2026-10-01T00:00:00Z")}
|
||||
endTime={new Date("2026-10-07T00:00:00Z")}
|
||||
enabled
|
||||
meteredSpend={0}
|
||||
canEdit
|
||||
/>,
|
||||
);
|
||||
|
||||
await user.click(await screen.findByRole("button", { name: "Set monthly fee" }));
|
||||
expect(screen.getByText("chatgpt account acct_123")).toBeInTheDocument();
|
||||
fill("Monthly fee", "25");
|
||||
fill("Currency", "USD");
|
||||
fill("Billing period start", "2026-10-01");
|
||||
await user.click(screen.getByRole("button", { name: "Save" }));
|
||||
|
||||
await waitFor(() => expect(subscriptionUsageCall).toHaveBeenCalledTimes(2));
|
||||
expect(subscriptionAccountCreateCall).toHaveBeenCalledWith(
|
||||
"sk-admin",
|
||||
expect.objectContaining({ custom_llm_provider: "chatgpt", account_id: "acct_123", monthly_fee: 25 }),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
import React from "react";
|
||||
import { useSubscriptionUsage, type SubscriptionUsageOptions } from "../../hooks/useSubscriptionUsage";
|
||||
import SubscriptionCostCard from "./SubscriptionCostCard";
|
||||
import SubscriptionFeeModal from "./SubscriptionFeeModal";
|
||||
import { useSubscriptionFeeActions } from "./useSubscriptionFeeActions";
|
||||
|
||||
interface SubscriptionCostsProps extends SubscriptionUsageOptions {
|
||||
meteredSpend: number;
|
||||
canEdit: boolean;
|
||||
}
|
||||
|
||||
const SubscriptionCosts: React.FC<SubscriptionCostsProps> = ({ meteredSpend, canEdit, ...usageOptions }) => {
|
||||
const usage = useSubscriptionUsage(usageOptions);
|
||||
const feeActions = useSubscriptionFeeActions({ accessToken: usageOptions.accessToken, refetch: usage.refetch });
|
||||
return (
|
||||
<>
|
||||
<SubscriptionCostCard
|
||||
loading={usage.loading}
|
||||
failed={usage.failed}
|
||||
isDateChanging={false}
|
||||
usage={usage.data}
|
||||
meteredSpend={meteredSpend}
|
||||
canEdit={canEdit}
|
||||
onSetFee={feeActions.openFeeModal}
|
||||
onEditFee={feeActions.openFeeModal}
|
||||
onRemoveFee={feeActions.removeFee}
|
||||
/>
|
||||
<SubscriptionFeeModal
|
||||
visible={feeActions.feeModalAccount !== null}
|
||||
account={feeActions.feeModalAccount}
|
||||
onCancel={feeActions.closeFeeModal}
|
||||
onSubmit={feeActions.submitFee}
|
||||
/>
|
||||
</>
|
||||
);
|
||||
};
|
||||
|
||||
export default SubscriptionCosts;
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
import { fireEvent, render, screen, waitFor } from "@testing-library/react";
|
||||
import userEvent from "@testing-library/user-event";
|
||||
import { describe, expect, it, vi } from "vitest";
|
||||
import SubscriptionFeeModal from "./SubscriptionFeeModal";
|
||||
import type { SubscriptionAccountUsage } from "./types";
|
||||
|
||||
const account: SubscriptionAccountUsage = {
|
||||
custom_llm_provider: "chatgpt",
|
||||
account_id: "acct_123",
|
||||
deployments: ["gpt-5.6-terra"],
|
||||
fee: null,
|
||||
billing_periods: [],
|
||||
fixed_cost: null,
|
||||
};
|
||||
|
||||
const fill = (label: string, value: string) => fireEvent.change(screen.getByLabelText(label), { target: { value } });
|
||||
|
||||
describe("SubscriptionFeeModal", () => {
|
||||
it("submits normalized values for a new fee", async () => {
|
||||
const onSubmit = vi.fn().mockResolvedValue(undefined);
|
||||
render(<SubscriptionFeeModal visible account={account} onCancel={vi.fn()} onSubmit={onSubmit} />);
|
||||
|
||||
expect(screen.getByText("Set monthly fee")).toBeInTheDocument();
|
||||
expect(screen.getByText("chatgpt account acct_123")).toBeInTheDocument();
|
||||
fill("Monthly fee", "25");
|
||||
fill("Currency", "usd");
|
||||
fill("Billing period start", "2026-10-01");
|
||||
fill("Label (optional)", "Team workspace");
|
||||
await userEvent.setup().click(screen.getByRole("button", { name: "Save" }));
|
||||
|
||||
await waitFor(() => expect(onSubmit).toHaveBeenCalledTimes(1));
|
||||
const normalized = {
|
||||
monthly_fee: 25,
|
||||
currency: "USD",
|
||||
billing_period_start: "2026-10-01",
|
||||
label: "Team workspace",
|
||||
};
|
||||
expect(onSubmit).toHaveBeenCalledWith(normalized);
|
||||
});
|
||||
|
||||
it("rejects a zero fee and a two-letter currency", async () => {
|
||||
const onSubmit = vi.fn().mockResolvedValue(undefined);
|
||||
const user = userEvent.setup();
|
||||
render(<SubscriptionFeeModal visible account={account} onCancel={vi.fn()} onSubmit={onSubmit} />);
|
||||
|
||||
fill("Monthly fee", "0");
|
||||
fill("Billing period start", "2026-10-01");
|
||||
await user.click(screen.getByRole("button", { name: "Save" }));
|
||||
expect(await screen.findByText("Monthly fee must be greater than 0")).toBeInTheDocument();
|
||||
|
||||
fill("Monthly fee", "25");
|
||||
fill("Currency", "US");
|
||||
await user.click(screen.getByRole("button", { name: "Save" }));
|
||||
expect(await screen.findByText("Currency must be a three-letter code")).toBeInTheDocument();
|
||||
expect(onSubmit).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("prefills the existing fee when editing", () => {
|
||||
const existing: SubscriptionAccountUsage = {
|
||||
...account,
|
||||
fee: {
|
||||
subscription_account_id: "fee-1",
|
||||
custom_llm_provider: "chatgpt",
|
||||
account_id: "acct_123",
|
||||
label: "Team workspace",
|
||||
monthly_fee: 25,
|
||||
currency: "EUR",
|
||||
billing_period_start: "2026-09-15",
|
||||
created_at: "2026-10-06T00:00:00Z",
|
||||
updated_at: "2026-10-06T00:00:00Z",
|
||||
created_by: "admin",
|
||||
updated_by: "admin",
|
||||
},
|
||||
};
|
||||
render(<SubscriptionFeeModal visible account={existing} onCancel={vi.fn()} onSubmit={vi.fn()} />);
|
||||
|
||||
expect(screen.getByText("Edit monthly fee")).toBeInTheDocument();
|
||||
expect(screen.getByLabelText("Monthly fee")).toHaveValue(25);
|
||||
expect(screen.getByLabelText("Currency")).toHaveValue("EUR");
|
||||
expect(screen.getByLabelText("Billing period start")).toHaveValue("2026-09-15");
|
||||
expect(screen.getByLabelText("Label (optional)")).toHaveValue("Team workspace");
|
||||
});
|
||||
});
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
"use client";
|
||||
|
||||
import React, { useEffect } from "react";
|
||||
import { z } from "zod";
|
||||
import { formatDate } from "@/components/networking";
|
||||
import { FormField } from "@/components/shared/form/FormField";
|
||||
import { Button } from "@/components/ui/button";
|
||||
import {
|
||||
Dialog,
|
||||
DialogContent,
|
||||
DialogDescription,
|
||||
DialogFooter,
|
||||
DialogHeader,
|
||||
DialogTitle,
|
||||
} from "@/components/ui/dialog";
|
||||
import { FieldGroup } from "@/components/ui/field";
|
||||
import { Input } from "@/components/ui/input";
|
||||
import { useZodForm } from "@/lib/forms/useZodForm";
|
||||
import type { SubscriptionAccountUsage, SubscriptionFeeFormValues } from "./types";
|
||||
|
||||
const feeShape = {
|
||||
monthly_fee: z
|
||||
.string()
|
||||
.min(1, "Enter a monthly fee")
|
||||
.refine((value) => Number(value) > 0, "Monthly fee must be greater than 0"),
|
||||
currency: z
|
||||
.string()
|
||||
.trim()
|
||||
.toUpperCase()
|
||||
.regex(/^[A-Z]{3}$/, "Currency must be a three-letter code"),
|
||||
billing_period_start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Pick a billing period start date"),
|
||||
label: z.string().trim(),
|
||||
};
|
||||
|
||||
const feeSchema = z.object(feeShape);
|
||||
|
||||
type FeeFormInput = z.input<typeof feeSchema>;
|
||||
|
||||
const formInputFor = (account: SubscriptionAccountUsage | null): FeeFormInput => ({
|
||||
monthly_fee: account?.fee ? String(account.fee.monthly_fee) : "",
|
||||
currency: account?.fee?.currency ?? "USD",
|
||||
billing_period_start: account?.fee?.billing_period_start ?? formatDate(new Date()),
|
||||
label: account?.fee?.label ?? "",
|
||||
});
|
||||
|
||||
interface SubscriptionFeeModalProps {
|
||||
visible: boolean;
|
||||
account: SubscriptionAccountUsage | null;
|
||||
onCancel: () => void;
|
||||
onSubmit: (values: SubscriptionFeeFormValues) => Promise<void>;
|
||||
}
|
||||
|
||||
const SubscriptionFeeModal: React.FC<SubscriptionFeeModalProps> = ({ visible, account, onCancel, onSubmit }) => {
|
||||
const form = useZodForm(feeSchema, { defaultValues: formInputFor(account) });
|
||||
const { reset } = form;
|
||||
|
||||
useEffect(() => {
|
||||
if (visible) reset(formInputFor(account));
|
||||
}, [visible, account, reset]);
|
||||
|
||||
const handleFinish = async (values: z.output<typeof feeSchema>) => {
|
||||
const submitted: SubscriptionFeeFormValues = {
|
||||
monthly_fee: Number(values.monthly_fee),
|
||||
currency: values.currency,
|
||||
billing_period_start: values.billing_period_start,
|
||||
label: values.label === "" ? null : values.label,
|
||||
};
|
||||
await onSubmit(submitted);
|
||||
};
|
||||
|
||||
const handleCancel = () => {
|
||||
reset(formInputFor(null));
|
||||
onCancel();
|
||||
};
|
||||
|
||||
return (
|
||||
<Dialog open={visible} onOpenChange={(open) => !open && handleCancel()}>
|
||||
<DialogContent className="sm:max-w-[480px]">
|
||||
<DialogHeader>
|
||||
<DialogTitle>{account?.fee ? "Edit monthly fee" : "Set monthly fee"}</DialogTitle>
|
||||
<DialogDescription>
|
||||
{account ? `${account.custom_llm_provider} account ${account.account_id ?? ""}` : ""}
|
||||
</DialogDescription>
|
||||
</DialogHeader>
|
||||
<form onSubmit={form.handleSubmit(handleFinish)} noValidate>
|
||||
<FieldGroup>
|
||||
<FormField control={form.control} name="monthly_fee" label="Monthly fee">
|
||||
{({ ref, ...field }) => <Input {...field} ref={ref} type="number" step={0.01} min={0.01} />}
|
||||
</FormField>
|
||||
<FormField control={form.control} name="currency" label="Currency">
|
||||
{({ ref, ...field }) => <Input {...field} ref={ref} maxLength={3} />}
|
||||
</FormField>
|
||||
<FormField control={form.control} name="billing_period_start" label="Billing period start">
|
||||
{({ ref, ...field }) => <Input {...field} ref={ref} type="date" />}
|
||||
</FormField>
|
||||
<FormField control={form.control} name="label" label="Label (optional)">
|
||||
{({ ref, ...field }) => <Input {...field} ref={ref} />}
|
||||
</FormField>
|
||||
</FieldGroup>
|
||||
<DialogFooter className="mt-4">
|
||||
<Button type="button" variant="outline" onClick={handleCancel}>
|
||||
Cancel
|
||||
</Button>
|
||||
<Button type="submit" disabled={form.formState.isSubmitting}>
|
||||
Save
|
||||
</Button>
|
||||
</DialogFooter>
|
||||
</form>
|
||||
</DialogContent>
|
||||
</Dialog>
|
||||
);
|
||||
};
|
||||
|
||||
export default SubscriptionFeeModal;
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
import type { BillingPeriod } from "./types";
|
||||
|
||||
export const ATTRIBUTION_RULE =
|
||||
"A subscription fee is counted once for each monthly billing period whose start date falls inside the selected dates. Fixed costs sit beside metered spend and are never added to it, to key or team spend, or to budgets.";
|
||||
|
||||
export const formatFee = (amount: number, currency: string): string => `${amount.toFixed(2)} ${currency}`;
|
||||
|
||||
const parseLocalDay = (day: string): Date => {
|
||||
const [year, month, date] = day.split("-").map(Number);
|
||||
return new Date(year, month - 1, date);
|
||||
};
|
||||
|
||||
export const formatBillingPeriod = ({ start, end }: BillingPeriod): string => {
|
||||
const startDate = parseLocalDay(start);
|
||||
const endDate = parseLocalDay(end);
|
||||
const startLabel = startDate.toLocaleDateString("en-US", {
|
||||
month: "short",
|
||||
day: "numeric",
|
||||
year: startDate.getFullYear() !== endDate.getFullYear() ? "numeric" : undefined,
|
||||
});
|
||||
const endLabel = endDate.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
|
||||
return `${startLabel} - ${endLabel}`;
|
||||
};
|
||||
|
||||
export const fixedCostByCurrency = (
|
||||
accounts: readonly { fee: { currency: string } | null; fixed_cost: number | null }[],
|
||||
): readonly { currency: string; total: number }[] => {
|
||||
const totals = new Map<string, number>();
|
||||
accounts.forEach((account) => {
|
||||
if (account.fee === null || account.fixed_cost === null) return;
|
||||
totals.set(account.fee.currency, (totals.get(account.fee.currency) ?? 0) + account.fixed_cost);
|
||||
});
|
||||
return Array.from(totals, ([currency, total]) => ({ currency, total }));
|
||||
};
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
import type { DailyData } from "@/components/UsagePage/types";
|
||||
|
||||
export interface SubscriptionFee {
|
||||
subscription_account_id: string;
|
||||
custom_llm_provider: string;
|
||||
account_id: string;
|
||||
label: string | null;
|
||||
monthly_fee: number;
|
||||
currency: string;
|
||||
billing_period_start: string;
|
||||
created_at: string;
|
||||
updated_at: string;
|
||||
created_by: string;
|
||||
updated_by: string;
|
||||
}
|
||||
|
||||
export interface BillingPeriod {
|
||||
start: string;
|
||||
end: string;
|
||||
}
|
||||
|
||||
export interface SubscriptionAccountUsage {
|
||||
custom_llm_provider: string;
|
||||
account_id: string | null;
|
||||
deployments: string[];
|
||||
fee: SubscriptionFee | null;
|
||||
billing_periods: BillingPeriod[];
|
||||
fixed_cost: number | null;
|
||||
}
|
||||
|
||||
export interface SubscriptionUsageResponse {
|
||||
subscription_providers: string[];
|
||||
accounts: SubscriptionAccountUsage[];
|
||||
}
|
||||
|
||||
export interface SubscriptionAccountCreateRequest {
|
||||
custom_llm_provider: string;
|
||||
account_id: string;
|
||||
monthly_fee: number;
|
||||
currency: string;
|
||||
billing_period_start: string;
|
||||
label: string | null;
|
||||
}
|
||||
|
||||
export interface SubscriptionAccountUpdateRequest {
|
||||
subscription_account_id: string;
|
||||
monthly_fee?: number;
|
||||
currency?: string;
|
||||
billing_period_start?: string;
|
||||
label?: string | null;
|
||||
}
|
||||
|
||||
export interface SubscriptionAccountDeleteRequest {
|
||||
subscription_account_id: string;
|
||||
}
|
||||
|
||||
export interface SubscriptionFeeFormValues {
|
||||
monthly_fee: number;
|
||||
currency: string;
|
||||
billing_period_start: string;
|
||||
label: string | null;
|
||||
}
|
||||
|
||||
export const isSubscriptionCovered = (metadata: object | undefined): boolean =>
|
||||
metadata !== undefined && "subscription_covered" in metadata && metadata.subscription_covered === true;
|
||||
|
||||
export const subscriptionCoveredProviders = (results: readonly DailyData[]): ReadonlySet<string> =>
|
||||
new Set(
|
||||
results.flatMap((day) =>
|
||||
Object.entries(day.breakdown.providers ?? {})
|
||||
.filter(([, entry]) => isSubscriptionCovered(entry.metadata))
|
||||
.map(([provider]) => provider),
|
||||
),
|
||||
);
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
import { act, renderHook } from "@testing-library/react";
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { subscriptionAccountCreateCall, subscriptionAccountUpdateCall } from "@/components/networking";
|
||||
import type { SubscriptionAccountUsage, SubscriptionFeeFormValues } from "./types";
|
||||
import { useSubscriptionFeeActions } from "./useSubscriptionFeeActions";
|
||||
|
||||
vi.mock("@/components/networking", () => ({
|
||||
subscriptionAccountCreateCall: vi.fn().mockResolvedValue({}),
|
||||
subscriptionAccountUpdateCall: vi.fn().mockResolvedValue({}),
|
||||
subscriptionAccountDeleteCall: vi.fn(),
|
||||
}));
|
||||
vi.mock("@/lib/toast", () => ({ toast: { success: vi.fn(), fromError: vi.fn() } }));
|
||||
|
||||
const stored: SubscriptionFeeFormValues = {
|
||||
monthly_fee: 25,
|
||||
currency: "USD",
|
||||
billing_period_start: "2026-10-01",
|
||||
label: "Team plan (test value)",
|
||||
};
|
||||
|
||||
const tracked: SubscriptionAccountUsage = {
|
||||
custom_llm_provider: "chatgpt",
|
||||
account_id: "acct_123",
|
||||
deployments: ["gpt-5.6-terra"],
|
||||
fee: {
|
||||
subscription_account_id: "sub-1",
|
||||
custom_llm_provider: "chatgpt",
|
||||
account_id: "acct_123",
|
||||
...stored,
|
||||
created_at: "2026-10-01T00:00:00Z",
|
||||
updated_at: "2026-10-01T00:00:00Z",
|
||||
created_by: "admin",
|
||||
updated_by: "admin",
|
||||
},
|
||||
billing_periods: [{ start: "2026-10-01", end: "2026-10-31" }],
|
||||
fixed_cost: 25,
|
||||
};
|
||||
|
||||
const submit = async (account: SubscriptionAccountUsage, values: SubscriptionFeeFormValues) => {
|
||||
const refetch = vi.fn().mockResolvedValue(undefined);
|
||||
const { result } = renderHook(() => useSubscriptionFeeActions({ accessToken: "sk-admin", refetch }));
|
||||
act(() => result.current.openFeeModal(account));
|
||||
await act(() => result.current.submitFee(values));
|
||||
return { refetch, result };
|
||||
};
|
||||
|
||||
describe("useSubscriptionFeeActions", () => {
|
||||
beforeEach(() => vi.clearAllMocks());
|
||||
|
||||
it("sends only the fields the admin changed when editing a fee", async () => {
|
||||
const { refetch, result } = await submit(tracked, { ...stored, monthly_fee: 30 });
|
||||
|
||||
expect(subscriptionAccountUpdateCall).toHaveBeenCalledWith("sk-admin", {
|
||||
subscription_account_id: "sub-1",
|
||||
monthly_fee: 30,
|
||||
});
|
||||
expect(refetch).toHaveBeenCalledTimes(1);
|
||||
expect(result.current.feeModalAccount).toBeNull();
|
||||
});
|
||||
|
||||
it("clears a label with an explicit null and nothing else", async () => {
|
||||
await submit(tracked, { ...stored, label: null });
|
||||
|
||||
expect(subscriptionAccountUpdateCall).toHaveBeenCalledWith("sk-admin", {
|
||||
subscription_account_id: "sub-1",
|
||||
label: null,
|
||||
});
|
||||
});
|
||||
|
||||
it("creates a fee with every field for an untracked account", async () => {
|
||||
const untracked: SubscriptionAccountUsage = { ...tracked, fee: null, billing_periods: [], fixed_cost: null };
|
||||
const createRequest = { custom_llm_provider: "chatgpt", account_id: "acct_123", ...stored };
|
||||
|
||||
await submit(untracked, stored);
|
||||
|
||||
expect(subscriptionAccountCreateCall).toHaveBeenCalledWith("sk-admin", createRequest);
|
||||
expect(subscriptionAccountUpdateCall).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
import { useCallback, useState } from "react";
|
||||
import {
|
||||
subscriptionAccountCreateCall,
|
||||
subscriptionAccountDeleteCall,
|
||||
subscriptionAccountUpdateCall,
|
||||
} from "@/components/networking";
|
||||
import { toast } from "@/lib/toast";
|
||||
import type {
|
||||
SubscriptionAccountUpdateRequest,
|
||||
SubscriptionAccountUsage,
|
||||
SubscriptionFee,
|
||||
SubscriptionFeeFormValues,
|
||||
} from "./types";
|
||||
|
||||
interface Options {
|
||||
accessToken: string | null;
|
||||
refetch: () => Promise<unknown>;
|
||||
}
|
||||
|
||||
interface Result {
|
||||
feeModalAccount: SubscriptionAccountUsage | null;
|
||||
openFeeModal: (account: SubscriptionAccountUsage) => void;
|
||||
closeFeeModal: () => void;
|
||||
submitFee: (values: SubscriptionFeeFormValues) => Promise<void>;
|
||||
removeFee: (account: SubscriptionAccountUsage) => Promise<void>;
|
||||
}
|
||||
|
||||
const changedFields = (fee: SubscriptionFee, values: SubscriptionFeeFormValues): SubscriptionAccountUpdateRequest => ({
|
||||
subscription_account_id: fee.subscription_account_id,
|
||||
...(values.monthly_fee !== fee.monthly_fee && { monthly_fee: values.monthly_fee }),
|
||||
...(values.currency !== fee.currency && { currency: values.currency }),
|
||||
...(values.billing_period_start !== fee.billing_period_start && {
|
||||
billing_period_start: values.billing_period_start,
|
||||
}),
|
||||
...(values.label !== fee.label && { label: values.label }),
|
||||
});
|
||||
|
||||
const saveFee = (
|
||||
accessToken: string,
|
||||
account: SubscriptionAccountUsage,
|
||||
values: SubscriptionFeeFormValues,
|
||||
): Promise<unknown> | null => {
|
||||
if (account.fee) {
|
||||
return subscriptionAccountUpdateCall(accessToken, changedFields(account.fee, values));
|
||||
}
|
||||
if (account.account_id === null) return null;
|
||||
return subscriptionAccountCreateCall(accessToken, {
|
||||
custom_llm_provider: account.custom_llm_provider,
|
||||
account_id: account.account_id,
|
||||
...values,
|
||||
});
|
||||
};
|
||||
|
||||
export function useSubscriptionFeeActions({ accessToken, refetch }: Options): Result {
|
||||
const [feeModalAccount, setFeeModalAccount] = useState<SubscriptionAccountUsage | null>(null);
|
||||
const closeFeeModal = useCallback(() => setFeeModalAccount(null), []);
|
||||
|
||||
const submitFee = useCallback(
|
||||
async (values: SubscriptionFeeFormValues) => {
|
||||
if (!accessToken || feeModalAccount === null) return;
|
||||
const request = saveFee(accessToken, feeModalAccount, values);
|
||||
if (request === null) return;
|
||||
try {
|
||||
await request;
|
||||
toast.success("Monthly fee saved");
|
||||
setFeeModalAccount(null);
|
||||
await refetch();
|
||||
} catch (error) {
|
||||
toast.fromError(error);
|
||||
}
|
||||
},
|
||||
[accessToken, feeModalAccount, refetch],
|
||||
);
|
||||
|
||||
const removeFee = useCallback(
|
||||
async (account: SubscriptionAccountUsage) => {
|
||||
if (!accessToken || account.fee === null) return;
|
||||
try {
|
||||
await subscriptionAccountDeleteCall(accessToken, account.fee.subscription_account_id);
|
||||
toast.success("Monthly fee removed");
|
||||
await refetch();
|
||||
} catch (error) {
|
||||
toast.fromError(error);
|
||||
}
|
||||
},
|
||||
[accessToken, refetch],
|
||||
);
|
||||
|
||||
return { feeModalAccount, openFeeModal: setFeeModalAccount, closeFeeModal, submitFee, removeFee };
|
||||
}
|
||||
|
|
@ -8,7 +8,7 @@ import type { ComponentProps } from "react";
|
|||
import userEvent from "@testing-library/user-event";
|
||||
import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import type { UrlUpdateEvent } from "nuqs/adapters/testing";
|
||||
import { chooseSelectOption, renderWithProviders } from "@/../tests/test-utils";
|
||||
import { chooseSelectOption, renderWithProviders, testQueryClient } from "@/../tests/test-utils";
|
||||
import { toast } from "@/lib/toast";
|
||||
import { processActivityData } from "@/components/activity_metrics";
|
||||
import type { Organization } from "@/components/networking";
|
||||
|
|
@ -74,6 +74,11 @@ beforeAll(() => {
|
|||
|
||||
// Mock the networking module
|
||||
vi.mock("@/components/networking", () => ({
|
||||
formatDate: (date: Date) => date.toISOString().slice(0, 10),
|
||||
subscriptionUsageCall: vi.fn(),
|
||||
subscriptionAccountCreateCall: vi.fn(),
|
||||
subscriptionAccountUpdateCall: vi.fn(),
|
||||
subscriptionAccountDeleteCall: vi.fn(),
|
||||
dailyActivityAggregatedCall: vi.fn(),
|
||||
dailyActivityKeyPageCall: vi.fn(),
|
||||
userDailyActivityUserPageCall: vi.fn(),
|
||||
|
|
@ -142,6 +147,14 @@ vi.mock("./EntityUsage/SpendByProvider", () => ({
|
|||
default: () => <div>Spend By Provider</div>,
|
||||
}));
|
||||
|
||||
vi.mock("./SubscriptionCost/SubscriptionCostCard", () => ({
|
||||
default: ({ usage, canEdit }: { usage: unknown; canEdit: boolean }) => (
|
||||
<div data-testid="subscription-cost-card" data-usage={JSON.stringify(usage)} data-can-edit={String(canEdit)}>
|
||||
Subscription Cost
|
||||
</div>
|
||||
),
|
||||
}));
|
||||
|
||||
vi.mock("./EndpointUsage/EndpointUsage", () => ({
|
||||
default: () => <div>Endpoint Usage</div>,
|
||||
}));
|
||||
|
|
@ -278,6 +291,7 @@ describe("UsagePage", () => {
|
|||
const mockTagListCall = vi.mocked(networking.tagListCall);
|
||||
const mockGatewayDailyActivityCall = vi.mocked(networking.gatewayDailyActivityCall);
|
||||
const mockRequestErrorActivityCall = vi.mocked(networking.requestErrorActivityCall);
|
||||
const mockSubscriptionUsageCall = vi.mocked(networking.subscriptionUsageCall);
|
||||
const mockUseAgents = vi.mocked(useAgents);
|
||||
const mockUseAuthorized = vi.mocked(useAuthorized);
|
||||
const mockUseCurrentUser = vi.mocked(useCurrentUser);
|
||||
|
|
@ -496,7 +510,24 @@ describe("UsagePage", () => {
|
|||
organizations: [],
|
||||
};
|
||||
|
||||
const mockSubscriptionUsage = {
|
||||
subscription_providers: ["chatgpt"],
|
||||
accounts: [
|
||||
{
|
||||
custom_llm_provider: "chatgpt",
|
||||
account_id: "acct_123",
|
||||
deployments: ["gpt-5.6-terra", "gpt-5.6-sol"],
|
||||
fee: null,
|
||||
billing_periods: [],
|
||||
fixed_cost: null,
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
beforeEach(() => {
|
||||
testQueryClient.clear();
|
||||
mockSubscriptionUsageCall.mockReset();
|
||||
mockSubscriptionUsageCall.mockResolvedValue(mockSubscriptionUsage);
|
||||
mockClientUsagePanel.mockClear();
|
||||
vi.mocked(processActivityData).mockReset();
|
||||
vi.mocked(processActivityData).mockImplementation((_data, key) => ({
|
||||
|
|
@ -578,6 +609,72 @@ describe("UsagePage", () => {
|
|||
} as any);
|
||||
});
|
||||
|
||||
it("hands the subscription usage to the fixed cost card for an admin and never fetches it otherwise", async () => {
|
||||
const { unmount } = renderWithProviders(<UsagePage {...defaultProps} />);
|
||||
await waitFor(() => {
|
||||
expect(mockSubscriptionUsageCall).toHaveBeenCalledWith("test-token", expect.any(Date), expect.any(Date));
|
||||
});
|
||||
await waitFor(() => {
|
||||
expect(screen.getByTestId("subscription-cost-card")).toHaveAttribute(
|
||||
"data-usage",
|
||||
JSON.stringify(mockSubscriptionUsage),
|
||||
);
|
||||
});
|
||||
unmount();
|
||||
|
||||
for (const session of [nonAdminSession, { ...nonAdminSession, userRole: "org_admin" }]) {
|
||||
mockSubscriptionUsageCall.mockClear();
|
||||
mockUserDailyActivityAggregatedCall.mockClear();
|
||||
mockUseAuthorized.mockReturnValue(session);
|
||||
const rendered = renderWithProviders(<UsagePage {...defaultProps} />);
|
||||
await waitFor(() => {
|
||||
expect(mockUserDailyActivityAggregatedCall).toHaveBeenCalled();
|
||||
});
|
||||
expect(mockSubscriptionUsageCall).not.toHaveBeenCalled();
|
||||
expect(screen.getByTestId("subscription-cost-card")).toHaveAttribute("data-usage", "null");
|
||||
rendered.unmount();
|
||||
}
|
||||
});
|
||||
|
||||
it("lets a proxy admin edit subscription fees but shows an admin viewer the same card read-only", async () => {
|
||||
const adminRender = renderWithProviders(<UsagePage {...defaultProps} />);
|
||||
await waitFor(() => {
|
||||
expect(screen.getByTestId("subscription-cost-card")).toHaveAttribute(
|
||||
"data-usage",
|
||||
JSON.stringify(mockSubscriptionUsage),
|
||||
);
|
||||
});
|
||||
expect(screen.getByTestId("subscription-cost-card")).toHaveAttribute("data-can-edit", "true");
|
||||
adminRender.unmount();
|
||||
|
||||
const adminViewerSession = {
|
||||
...nonAdminSession,
|
||||
userRole: "Admin",
|
||||
userRoleLabel: "Admin Viewer",
|
||||
isViewOnly: true,
|
||||
};
|
||||
mockUseAuthorized.mockReturnValue(adminViewerSession);
|
||||
renderWithProviders(<UsagePage {...defaultProps} />);
|
||||
await waitFor(() => {
|
||||
expect(screen.getByTestId("subscription-cost-card")).toHaveAttribute(
|
||||
"data-usage",
|
||||
JSON.stringify(mockSubscriptionUsage),
|
||||
);
|
||||
});
|
||||
expect(screen.getByTestId("subscription-cost-card")).toHaveAttribute("data-can-edit", "false");
|
||||
});
|
||||
|
||||
it("never sets an account-wide subscription fee beside one user's spend when an admin filters by user", async () => {
|
||||
renderWithProviders(<UsagePage {...defaultProps} />, { searchParams: "?user=user-001" });
|
||||
await waitFor(() => {
|
||||
expect(mockUserDailyActivityAggregatedCall).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ entityIds: ["user-001"] }),
|
||||
);
|
||||
});
|
||||
expect(mockSubscriptionUsageCall).not.toHaveBeenCalled();
|
||||
expect(screen.getByTestId("subscription-cost-card")).toHaveAttribute("data-usage", "null");
|
||||
});
|
||||
|
||||
it("should render and fetch usage data on mount", async () => {
|
||||
renderWithProviders(<UsagePage {...defaultProps} />);
|
||||
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ import { useOrganizations } from "@/app/(dashboard)/hooks/organizations/useOrgan
|
|||
import { toast } from "@/lib/toast";
|
||||
import { hasCapability } from "@/utils/capabilities";
|
||||
import { copyToClipboard } from "@/utils/dataUtils";
|
||||
import { hasProxyWideSpendView, internalUserRoles } from "@/utils/roles";
|
||||
import { hasProxyWideSpendView, internalUserRoles, isProxyAdminRole } from "@/utils/roles";
|
||||
import { ActivityMetrics, processActivityData } from "@/components/activity_metrics";
|
||||
import CloudZeroExportModal from "@/components/cloudzero_export_modal";
|
||||
import UserDropdown from "@/components/common_components/UserDropdown";
|
||||
|
|
@ -92,7 +92,7 @@ import {
|
|||
usageViewFromParams,
|
||||
usageViewPatch,
|
||||
} from "../usageUrlState";
|
||||
import { overviewTotals, rollUpBreakdown } from "./overview/overviewData";
|
||||
import { overviewTotals, providerSpendRows } from "./overview/overviewData";
|
||||
import TopAgents from "./overview/TopAgents";
|
||||
import { parseUsageClient, topAgents, type AgentRow } from "./overview/agentCatalog";
|
||||
import ClientUsagePanel from "./ClientUsagePanel";
|
||||
|
|
@ -100,6 +100,7 @@ import { resolveClientUsageScope } from "../hooks/clientUsageScope";
|
|||
import { useUsagePanelContext } from "../hooks/useUsagePanelContext";
|
||||
import ClientUsageSelect from "./ClientUsageSelect";
|
||||
import SpendByProvider from "./EntityUsage/SpendByProvider";
|
||||
import SubscriptionCosts from "./SubscriptionCost/SubscriptionCosts";
|
||||
import { useTagSummary } from "@/app/(dashboard)/hooks/tags/useTagSummary";
|
||||
import { Panel } from "./overview/Primitives";
|
||||
import UsageOverview from "./overview/UsageOverview";
|
||||
|
|
@ -112,7 +113,7 @@ interface UsagePageProps {
|
|||
}
|
||||
|
||||
const UsagePage: React.FC<UsagePageProps> = ({ teams, organizations, teamsLoading = false, defaultTimeRange }) => {
|
||||
const { accessToken, userRole, userId: userID, premiumUser, isLoading: authorizationLoading } = useAuthorized();
|
||||
const { accessToken, userRole, userId: userID, premiumUser, isViewOnly, isLoading: authLoading } = useAuthorized();
|
||||
const [gatewayActivityData, setGatewayActivityData] = useState<FetchedGatewayActivity | null>(null);
|
||||
|
||||
const defaultRange = useMemo(() => defaultUsageDateRange(defaultTimeRange), [defaultTimeRange]);
|
||||
|
|
@ -187,7 +188,7 @@ const UsagePage: React.FC<UsagePageProps> = ({ teams, organizations, teamsLoadin
|
|||
};
|
||||
|
||||
const { isLoading: organizationsLoading } = useOrganizations();
|
||||
const authorizationSettled = !authorizationLoading && userRole !== null;
|
||||
const authorizationSettled = !authLoading && userRole !== null;
|
||||
const accessSettled = authorizationSettled && !organizationsLoading && !teamsLoading;
|
||||
useEffect(() => {
|
||||
if (!accessSettled) return;
|
||||
|
|
@ -374,10 +375,7 @@ const UsagePage: React.FC<UsagePageProps> = ({ teams, organizations, teamsLoadin
|
|||
() => overviewTotals(userSpendData.metadata, gatewayActivity),
|
||||
[userSpendData.metadata, gatewayActivity],
|
||||
);
|
||||
const providerSpend = useMemo(
|
||||
() => rollUpBreakdown(userSpendData.results, "providers").map(({ key, ...row }) => ({ provider: key, ...row })),
|
||||
[userSpendData.results],
|
||||
);
|
||||
const providerSpend = useMemo(() => providerSpendRows(userSpendData.results), [userSpendData.results]);
|
||||
const {
|
||||
data: tagSummary,
|
||||
isLoading: tagSummaryLoading,
|
||||
|
|
@ -546,6 +544,16 @@ const UsagePage: React.FC<UsagePageProps> = ({ teams, organizations, teamsLoadin
|
|||
loading={loading}
|
||||
requestCountsPending={requestCountsPending}
|
||||
budget={currentUser?.max_budget ?? null}
|
||||
subscriptionCosts={
|
||||
<SubscriptionCosts
|
||||
accessToken={accessToken}
|
||||
startTime={startTime}
|
||||
endTime={endTime}
|
||||
enabled={isAdmin && effectiveUserId === null}
|
||||
meteredSpend={totals.spend}
|
||||
canEdit={!isViewOnly && isProxyAdminRole(userRole || "")}
|
||||
/>
|
||||
}
|
||||
topKeys={
|
||||
<TopKeyView
|
||||
topKeys={topKeys}
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ interface UsageOverviewProps {
|
|||
loading: boolean;
|
||||
requestCountsPending: boolean;
|
||||
budget: number | null;
|
||||
subscriptionCosts: ReactNode;
|
||||
topKeys: ReactNode;
|
||||
topUsers: ReactNode;
|
||||
gatewayByEndpoint: ReactNode;
|
||||
|
|
@ -32,6 +33,7 @@ export default function UsageOverview({
|
|||
totals,
|
||||
loading,
|
||||
requestCountsPending,
|
||||
subscriptionCosts,
|
||||
topKeys,
|
||||
topUsers,
|
||||
gatewayByEndpoint,
|
||||
|
|
@ -49,6 +51,8 @@ export default function UsageOverview({
|
|||
budget={budget}
|
||||
/>
|
||||
|
||||
{subscriptionCosts}
|
||||
|
||||
<UsageBreakdownChart results={results} loading={loading} />
|
||||
|
||||
{topAgents}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ import {
|
|||
labelForDate,
|
||||
modelColorMap,
|
||||
OTHER_COLOR,
|
||||
providerSpendRows,
|
||||
rollUpBreakdown,
|
||||
seriesBy,
|
||||
} from "./overviewData";
|
||||
|
|
@ -88,6 +89,34 @@ describe("bucketSeries", () => {
|
|||
});
|
||||
});
|
||||
|
||||
const providerDay = (date: string, providers: Record<string, Record<string, unknown>>): DailyData =>
|
||||
({
|
||||
...day(date, 0, {}),
|
||||
breakdown: {
|
||||
...day(date, 0, {}).breakdown,
|
||||
providers: Object.fromEntries(
|
||||
Object.entries(providers).map(([name, metadata]) => [
|
||||
name,
|
||||
{ metrics: metrics(0), metadata, api_key_breakdown: {} },
|
||||
]),
|
||||
),
|
||||
},
|
||||
}) as unknown as DailyData;
|
||||
|
||||
describe("providerSpendRows", () => {
|
||||
it("marks a provider covered by a subscription on any day of the range and leaves metered ones unmarked", () => {
|
||||
const rows = providerSpendRows([
|
||||
providerDay("2026-10-01", { chatgpt: {}, openai: {} }),
|
||||
providerDay("2026-10-02", { chatgpt: { subscription_covered: true }, openai: { subscription_covered: false } }),
|
||||
]);
|
||||
expect(Object.fromEntries(rows.map((row) => [row.provider, row.subscription_covered]))).toEqual({
|
||||
chatgpt: true,
|
||||
openai: false,
|
||||
});
|
||||
expect(rows.find((row) => row.provider === "chatgpt")).toEqual(expect.objectContaining({ requests: 2 }));
|
||||
});
|
||||
});
|
||||
|
||||
describe("rollUpBreakdown", () => {
|
||||
it("sums a dimension across days without changing the input", () => {
|
||||
const days = [day("2026-10-01", 3, { a: 3 }), day("2026-10-02", 2, { a: 2 })];
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ import type { DailyData, SpendMetrics } from "@/components/UsagePage/types";
|
|||
import { stackedUsageColor } from "@/components/shared/charts";
|
||||
import { EMPTY_DAILY_ACTIVITY_METADATA, type DailyActivityMetadata } from "@/components/UsagePage/dailyActivityApi";
|
||||
import type { GatewayActivity } from "../gatewayActivity";
|
||||
import { subscriptionCoveredProviders } from "../SubscriptionCost/types";
|
||||
|
||||
export type BreakdownDimension = "models" | "model_groups" | "providers";
|
||||
|
||||
|
|
@ -40,6 +41,15 @@ export const rollUpBreakdown = (results: readonly DailyData[], dimension: Breakd
|
|||
return [...totals.values()].sort((a, b) => b.spend - a.spend);
|
||||
};
|
||||
|
||||
export const providerSpendRows = (results: readonly DailyData[]) => {
|
||||
const covered = subscriptionCoveredProviders(results);
|
||||
return rollUpBreakdown(results, "providers").map(({ key, ...row }) => ({
|
||||
provider: key,
|
||||
...row,
|
||||
subscription_covered: covered.has(key),
|
||||
}));
|
||||
};
|
||||
|
||||
export const modelColorMap = (results: readonly DailyData[]): ReadonlyMap<string, string> => {
|
||||
const groups = rollUpBreakdown(results, "model_groups");
|
||||
const models = rollUpBreakdown(results, "models");
|
||||
|
|
|
|||
|
|
@ -0,0 +1,47 @@
|
|||
import { keepPreviousData, queryOptions, skipToken, useQuery } from "@tanstack/react-query";
|
||||
import { formatDate, subscriptionUsageCall } from "@/components/networking";
|
||||
import type { SubscriptionUsageResponse } from "../components/SubscriptionCost/types";
|
||||
|
||||
export interface SubscriptionUsageOptions {
|
||||
accessToken: string | null;
|
||||
startTime: Date | null;
|
||||
endTime: Date | null;
|
||||
enabled: boolean;
|
||||
}
|
||||
|
||||
interface Result {
|
||||
data: SubscriptionUsageResponse | null;
|
||||
loading: boolean;
|
||||
failed: boolean;
|
||||
refetch: () => Promise<unknown>;
|
||||
}
|
||||
|
||||
interface UsageRequest {
|
||||
accessToken: string;
|
||||
startTime: Date;
|
||||
endTime: Date;
|
||||
}
|
||||
|
||||
const subscriptionUsageQuery = (request: UsageRequest | null) => {
|
||||
const queryKey = [
|
||||
"subscriptionUsage",
|
||||
request ? formatDate(request.startTime) : null,
|
||||
request ? formatDate(request.endTime) : null,
|
||||
];
|
||||
const queryFn = request
|
||||
? () => subscriptionUsageCall(request.accessToken, request.startTime, request.endTime)
|
||||
: skipToken;
|
||||
return queryOptions({ queryKey, queryFn, placeholderData: keepPreviousData });
|
||||
};
|
||||
|
||||
export function useSubscriptionUsage({ accessToken, startTime, endTime, enabled }: SubscriptionUsageOptions): Result {
|
||||
const range = startTime && endTime ? { startTime, endTime } : null;
|
||||
const request = enabled && accessToken && range ? { accessToken, ...range } : null;
|
||||
const query = useQuery(subscriptionUsageQuery(request));
|
||||
return {
|
||||
data: request && query.data ? query.data : null,
|
||||
loading: request !== null && (query.isPending || query.isPlaceholderData),
|
||||
failed: query.isError,
|
||||
refetch: query.refetch,
|
||||
};
|
||||
}
|
||||
|
|
@ -119,6 +119,13 @@ import { MCP_TOOLS_PREVIEW_FORBIDDEN_MESSAGE } from "./mcp_tools/constants";
|
|||
import type { ComplexityRouterConfigPayload } from "./add_model/build_complexity_router_config";
|
||||
import type { AutoRouterPresetsResponse } from "@/lib/autorouter_presets";
|
||||
import type { VectorStoreIndex } from "@/app/(dashboard)/vector-stores/_components/IndexesTab";
|
||||
import type {
|
||||
SubscriptionAccountCreateRequest,
|
||||
SubscriptionAccountDeleteRequest,
|
||||
SubscriptionAccountUpdateRequest,
|
||||
SubscriptionFee,
|
||||
SubscriptionUsageResponse,
|
||||
} from "@/app/(dashboard)/usage/_components/components/SubscriptionCost/types";
|
||||
import type { RoutingDecision } from "./logs/detail/RoutingDecisionCard";
|
||||
import type {
|
||||
SpanDetail,
|
||||
|
|
@ -1395,6 +1402,34 @@ export const dailyActivityAggregatedCall = (
|
|||
query: dailyActivityQuery(entity, req, req.apiKeyLimit === undefined ? {} : { api_key_limit: req.apiKeyLimit }),
|
||||
});
|
||||
|
||||
export const subscriptionUsageCall = (
|
||||
accessToken: string,
|
||||
startTime: Date,
|
||||
endTime: Date,
|
||||
): Promise<SubscriptionUsageResponse> =>
|
||||
apiClient.get<SubscriptionUsageResponse>("/subscription_accounts/usage", {
|
||||
accessToken,
|
||||
query: { start_date: formatDate(startTime), end_date: formatDate(endTime) },
|
||||
});
|
||||
|
||||
export const subscriptionAccountCreateCall = (
|
||||
accessToken: string,
|
||||
body: SubscriptionAccountCreateRequest,
|
||||
): Promise<SubscriptionFee> => apiClient.post<SubscriptionFee>("/subscription_accounts/new", { accessToken, body });
|
||||
|
||||
export const subscriptionAccountUpdateCall = (
|
||||
accessToken: string,
|
||||
body: SubscriptionAccountUpdateRequest,
|
||||
): Promise<SubscriptionFee> => apiClient.post<SubscriptionFee>("/subscription_accounts/update", { accessToken, body });
|
||||
|
||||
export const subscriptionAccountDeleteCall = (
|
||||
accessToken: string,
|
||||
subscriptionAccountId: string,
|
||||
): Promise<SubscriptionFee> => {
|
||||
const body: SubscriptionAccountDeleteRequest = { subscription_account_id: subscriptionAccountId };
|
||||
return apiClient.post<SubscriptionFee>("/subscription_accounts/delete", { accessToken, body });
|
||||
};
|
||||
|
||||
export const dailyActivityKeyPageCall = (
|
||||
entity: DailyActivityEntity,
|
||||
req: DailyActivityRequest,
|
||||
|
|
|
|||
328
ui/litellm-dashboard/src/lib/http/schema.d.ts
generated
vendored
328
ui/litellm-dashboard/src/lib/http/schema.d.ts
generated
vendored
|
|
@ -16079,6 +16079,90 @@ export interface paths {
|
|||
patch?: never;
|
||||
trace?: never;
|
||||
};
|
||||
"/subscription_accounts/delete": {
|
||||
parameters: {
|
||||
query?: never;
|
||||
header?: never;
|
||||
path?: never;
|
||||
cookie?: never;
|
||||
};
|
||||
get?: never;
|
||||
put?: never;
|
||||
/**
|
||||
* Delete Subscription Account
|
||||
* @description Stop tracking a subscription account's fee; its requests stay marked as subscription-covered.
|
||||
*/
|
||||
post: operations["delete_subscription_account_subscription_accounts_delete_post"];
|
||||
delete?: never;
|
||||
options?: never;
|
||||
head?: never;
|
||||
patch?: never;
|
||||
trace?: never;
|
||||
};
|
||||
"/subscription_accounts/new": {
|
||||
parameters: {
|
||||
query?: never;
|
||||
header?: never;
|
||||
path?: never;
|
||||
cookie?: never;
|
||||
};
|
||||
get?: never;
|
||||
put?: never;
|
||||
/**
|
||||
* New Subscription Account
|
||||
* @description Record the monthly fee of one subscription-backed provider account.
|
||||
*/
|
||||
post: operations["new_subscription_account_subscription_accounts_new_post"];
|
||||
delete?: never;
|
||||
options?: never;
|
||||
head?: never;
|
||||
patch?: never;
|
||||
trace?: never;
|
||||
};
|
||||
"/subscription_accounts/update": {
|
||||
parameters: {
|
||||
query?: never;
|
||||
header?: never;
|
||||
path?: never;
|
||||
cookie?: never;
|
||||
};
|
||||
get?: never;
|
||||
put?: never;
|
||||
/**
|
||||
* Update Subscription Account
|
||||
* @description Change the fee, currency, billing period start, or label of a subscription account.
|
||||
* Only the fields named in the request are written, so two admins changing different
|
||||
* fields at the same time both land.
|
||||
*/
|
||||
post: operations["update_subscription_account_subscription_accounts_update_post"];
|
||||
delete?: never;
|
||||
options?: never;
|
||||
head?: never;
|
||||
patch?: never;
|
||||
trace?: never;
|
||||
};
|
||||
"/subscription_accounts/usage": {
|
||||
parameters: {
|
||||
query?: never;
|
||||
header?: never;
|
||||
path?: never;
|
||||
cookie?: never;
|
||||
};
|
||||
/**
|
||||
* Get Subscription Usage
|
||||
* @description Subscription-backed accounts behind the proxy's deployments or carrying a stored fee, each with
|
||||
* its configured monthly fee and the fixed cost attributed to the date range: the fee once per billing
|
||||
* period whose start date falls inside the range, however many deployments share the account.
|
||||
*/
|
||||
get: operations["get_subscription_usage_subscription_accounts_usage_get"];
|
||||
put?: never;
|
||||
post?: never;
|
||||
delete?: never;
|
||||
options?: never;
|
||||
head?: never;
|
||||
patch?: never;
|
||||
trace?: never;
|
||||
};
|
||||
"/systemone": {
|
||||
parameters: {
|
||||
query?: never;
|
||||
|
|
@ -27401,6 +27485,19 @@ export interface components {
|
|||
/** Entities */
|
||||
entities: components["schemas"]["BedrockChecksSensitiveInformationEntityItem"][];
|
||||
};
|
||||
/** BillingPeriod */
|
||||
BillingPeriod: {
|
||||
/**
|
||||
* End
|
||||
* Format: date
|
||||
*/
|
||||
end: string;
|
||||
/**
|
||||
* Start
|
||||
* Format: date
|
||||
*/
|
||||
start: string;
|
||||
};
|
||||
/** BlockKeyRequest */
|
||||
BlockKeyRequest: {
|
||||
/** Key */
|
||||
|
|
@ -31881,6 +31978,11 @@ export interface components {
|
|||
*/
|
||||
type: string;
|
||||
};
|
||||
/** DeleteSubscriptionAccountRequest */
|
||||
DeleteSubscriptionAccountRequest: {
|
||||
/** Subscription Account Id */
|
||||
subscription_account_id: string;
|
||||
};
|
||||
/** DeleteTeamRequest */
|
||||
DeleteTeamRequest: {
|
||||
/** Team Ids */
|
||||
|
|
@ -36016,6 +36118,37 @@ export interface components {
|
|||
*/
|
||||
user: string | null;
|
||||
};
|
||||
/** LiteLLM_SubscriptionAccountTable */
|
||||
LiteLLM_SubscriptionAccountTable: {
|
||||
/** Account Id */
|
||||
account_id: string;
|
||||
/** Billing Period Start */
|
||||
billing_period_start: string;
|
||||
/**
|
||||
* Created At
|
||||
* Format: date-time
|
||||
*/
|
||||
created_at: string;
|
||||
/** Created By */
|
||||
created_by: string;
|
||||
/** Currency */
|
||||
currency: string;
|
||||
/** Custom Llm Provider */
|
||||
custom_llm_provider: string;
|
||||
/** Label */
|
||||
label?: string | null;
|
||||
/** Monthly Fee */
|
||||
monthly_fee: number;
|
||||
/** Subscription Account Id */
|
||||
subscription_account_id: string;
|
||||
/**
|
||||
* Updated At
|
||||
* Format: date-time
|
||||
*/
|
||||
updated_at: string;
|
||||
/** Updated By */
|
||||
updated_by: string;
|
||||
};
|
||||
/** LiteLLM_TeamMembership */
|
||||
LiteLLM_TeamMembership: {
|
||||
/** Budget Id */
|
||||
|
|
@ -46224,6 +46357,55 @@ export interface components {
|
|||
/** Window Start */
|
||||
window_start: number;
|
||||
};
|
||||
/** SubscriptionAccountFeeRequest */
|
||||
SubscriptionAccountFeeRequest: {
|
||||
/** Account Id */
|
||||
account_id: string;
|
||||
/**
|
||||
* Billing Period Start
|
||||
* Format: date
|
||||
*/
|
||||
billing_period_start: string;
|
||||
/** Currency */
|
||||
currency: string;
|
||||
/** Custom Llm Provider */
|
||||
custom_llm_provider: string;
|
||||
/** Label */
|
||||
label?: string | null;
|
||||
/** Monthly Fee */
|
||||
monthly_fee: number;
|
||||
};
|
||||
/** SubscriptionAccountUsage */
|
||||
SubscriptionAccountUsage: {
|
||||
/** Account Id */
|
||||
account_id: string | null;
|
||||
/** Billing Periods */
|
||||
billing_periods: components["schemas"]["BillingPeriod"][];
|
||||
/** Custom Llm Provider */
|
||||
custom_llm_provider: string;
|
||||
/** Deployments */
|
||||
deployments: string[];
|
||||
fee: components["schemas"]["LiteLLM_SubscriptionAccountTable"] | null;
|
||||
/** Fixed Cost */
|
||||
fixed_cost: number | null;
|
||||
};
|
||||
/** SubscriptionUsageResponse */
|
||||
SubscriptionUsageResponse: {
|
||||
/** Accounts */
|
||||
accounts: components["schemas"]["SubscriptionAccountUsage"][];
|
||||
/**
|
||||
* End Date
|
||||
* Format: date
|
||||
*/
|
||||
end_date: string;
|
||||
/**
|
||||
* Start Date
|
||||
* Format: date
|
||||
*/
|
||||
start_date: string;
|
||||
/** Subscription Providers */
|
||||
subscription_providers: string[];
|
||||
};
|
||||
/**
|
||||
* SuccessfulKeyUpdate
|
||||
* @description Successfully updated key with its updated information
|
||||
|
|
@ -48897,6 +49079,19 @@ export interface components {
|
|||
UpdateSearchToolRequest: {
|
||||
search_tool: components["schemas"]["SearchTool"];
|
||||
};
|
||||
/** UpdateSubscriptionAccountFeeRequest */
|
||||
UpdateSubscriptionAccountFeeRequest: {
|
||||
/** Billing Period Start */
|
||||
billing_period_start?: string | null;
|
||||
/** Currency */
|
||||
currency?: string | null;
|
||||
/** Label */
|
||||
label?: string | null;
|
||||
/** Monthly Fee */
|
||||
monthly_fee?: number | null;
|
||||
/** Subscription Account Id */
|
||||
subscription_account_id: string;
|
||||
};
|
||||
/**
|
||||
* UpdateTeamMemberPermissionsRequest
|
||||
* @description Request to update the team member permissions for a team
|
||||
|
|
@ -72987,6 +73182,139 @@ export interface operations {
|
|||
};
|
||||
};
|
||||
};
|
||||
delete_subscription_account_subscription_accounts_delete_post: {
|
||||
parameters: {
|
||||
query?: never;
|
||||
header?: never;
|
||||
path?: never;
|
||||
cookie?: never;
|
||||
};
|
||||
requestBody: {
|
||||
content: {
|
||||
"application/json": components["schemas"]["DeleteSubscriptionAccountRequest"];
|
||||
};
|
||||
};
|
||||
responses: {
|
||||
/** @description Successful Response */
|
||||
200: {
|
||||
headers: {
|
||||
[name: string]: unknown;
|
||||
};
|
||||
content: {
|
||||
"application/json": components["schemas"]["LiteLLM_SubscriptionAccountTable"];
|
||||
};
|
||||
};
|
||||
/** @description Validation Error */
|
||||
422: {
|
||||
headers: {
|
||||
[name: string]: unknown;
|
||||
};
|
||||
content: {
|
||||
"application/json": components["schemas"]["HTTPValidationError"];
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
new_subscription_account_subscription_accounts_new_post: {
|
||||
parameters: {
|
||||
query?: never;
|
||||
header?: never;
|
||||
path?: never;
|
||||
cookie?: never;
|
||||
};
|
||||
requestBody: {
|
||||
content: {
|
||||
"application/json": components["schemas"]["SubscriptionAccountFeeRequest"];
|
||||
};
|
||||
};
|
||||
responses: {
|
||||
/** @description Successful Response */
|
||||
200: {
|
||||
headers: {
|
||||
[name: string]: unknown;
|
||||
};
|
||||
content: {
|
||||
"application/json": components["schemas"]["LiteLLM_SubscriptionAccountTable"];
|
||||
};
|
||||
};
|
||||
/** @description Validation Error */
|
||||
422: {
|
||||
headers: {
|
||||
[name: string]: unknown;
|
||||
};
|
||||
content: {
|
||||
"application/json": components["schemas"]["HTTPValidationError"];
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
update_subscription_account_subscription_accounts_update_post: {
|
||||
parameters: {
|
||||
query?: never;
|
||||
header?: never;
|
||||
path?: never;
|
||||
cookie?: never;
|
||||
};
|
||||
requestBody: {
|
||||
content: {
|
||||
"application/json": components["schemas"]["UpdateSubscriptionAccountFeeRequest"];
|
||||
};
|
||||
};
|
||||
responses: {
|
||||
/** @description Successful Response */
|
||||
200: {
|
||||
headers: {
|
||||
[name: string]: unknown;
|
||||
};
|
||||
content: {
|
||||
"application/json": components["schemas"]["LiteLLM_SubscriptionAccountTable"];
|
||||
};
|
||||
};
|
||||
/** @description Validation Error */
|
||||
422: {
|
||||
headers: {
|
||||
[name: string]: unknown;
|
||||
};
|
||||
content: {
|
||||
"application/json": components["schemas"]["HTTPValidationError"];
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
get_subscription_usage_subscription_accounts_usage_get: {
|
||||
parameters: {
|
||||
query: {
|
||||
/** @description First day of the Usage page filter, YYYY-MM-DD */
|
||||
start_date: string;
|
||||
/** @description Last day of the Usage page filter, YYYY-MM-DD */
|
||||
end_date: string;
|
||||
};
|
||||
header?: never;
|
||||
path?: never;
|
||||
cookie?: never;
|
||||
};
|
||||
requestBody?: never;
|
||||
responses: {
|
||||
/** @description Successful Response */
|
||||
200: {
|
||||
headers: {
|
||||
[name: string]: unknown;
|
||||
};
|
||||
content: {
|
||||
"application/json": components["schemas"]["SubscriptionUsageResponse"];
|
||||
};
|
||||
};
|
||||
/** @description Validation Error */
|
||||
422: {
|
||||
headers: {
|
||||
[name: string]: unknown;
|
||||
};
|
||||
content: {
|
||||
"application/json": components["schemas"]["HTTPValidationError"];
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
systemone_systemone_post: {
|
||||
parameters: {
|
||||
query?: never;
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue