From 54a51c80df0aebd45a40b208498071252aca6d4b Mon Sep 17 00:00:00 2001 From: "devin-ai-integration[bot]" <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 1 Oct 2026 16:57:23 -0700 Subject: [PATCH] feat(proxy): bounded daily activity routes for all usage entities (#43408) Co-authored-by: yassin Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- backend/routes/allowlist.py | 1 + litellm/proxy/_lazy_openapi_snapshot.json | 1046 +++++++++ litellm/proxy/_types.py | 52 + litellm/proxy/agent_endpoints/endpoints.py | 175 +- .../common_daily_activity.py | 33 +- .../customer_endpoints.py | 52 +- .../daily_activity_routes.py | 579 +++++ .../daily_activity_scopes.py | 472 ++++ .../internal_user_endpoints.py | 147 +- .../organization_endpoints.py | 89 +- .../tag_management_endpoints.py | 4 +- .../management_endpoints/team_endpoints.py | 102 +- litellm/proxy/proxy_server.py | 2 + .../common_daily_activity.py | 45 + .../endpointaudit/coverage_allowlist.txt | 29 + .../unbounded_in_baseline.txt | 5 +- .../daily_activity_team_aggregated.json | 1169 ++++++++++ .../golden/daily_activity_team_paginated.json | 1197 ++++++++++ .../daily_activity_user_aggregated.json | 1002 ++++++++ .../golden/daily_activity_user_paginated.json | 1198 ++++++++++ .../spend/test_daily_activity_routes.py | 514 +++++ tests/unit/proxy/auth/test_route_checks.py | 89 +- .../test_activity_tenant_scoping.py | 56 + .../test_common_daily_activity.py | 17 +- .../test_daily_activity_routes.py | 1261 ++++++++++ .../test_internal_user_endpoints.py | 182 -- .../test_organization_endpoints.py | 2 +- .../test_team_endpoints.py | 125 +- ui/litellm-dashboard/src/lib/http/schema.d.ts | 2041 +++++++++++++++++ 29 files changed, 11031 insertions(+), 655 deletions(-) create mode 100644 litellm/proxy/management_endpoints/daily_activity_routes.py create mode 100644 litellm/proxy/management_endpoints/daily_activity_scopes.py create mode 100644 tests/integration/spend/golden/daily_activity_team_aggregated.json create mode 100644 tests/integration/spend/golden/daily_activity_team_paginated.json create mode 100644 tests/integration/spend/golden/daily_activity_user_aggregated.json create mode 100644 tests/integration/spend/golden/daily_activity_user_paginated.json create mode 100644 tests/integration/spend/test_daily_activity_routes.py create mode 100644 tests/unit/proxy/management_endpoints/test_daily_activity_routes.py diff --git a/backend/routes/allowlist.py b/backend/routes/allowlist.py index 80ca0ef22bb..d7f3e615c67 100644 --- a/backend/routes/allowlist.py +++ b/backend/routes/allowlist.py @@ -60,6 +60,7 @@ BACKEND_PATH_PREFIXES: tuple[str, ...] = ( # Tools / agents (registry & policy admin) "/v1/tool/", "/v1/agents", + "/agent/daily/activity/", # Guardrails admin "/v2/guardrails/", # MCP server admin + BYOK OAuth flow (UI-initiated) + dynamic per-server endpoints diff --git a/litellm/proxy/_lazy_openapi_snapshot.json b/litellm/proxy/_lazy_openapi_snapshot.json index a9d88c50380..5de6e91a0f2 100644 --- a/litellm/proxy/_lazy_openapi_snapshot.json +++ b/litellm/proxy/_lazy_openapi_snapshot.json @@ -3432,6 +3432,53 @@ "title": "BreakdownMetrics", "type": "object" }, + "DailyActivityKeyPageResponse": { + "properties": { + "api_keys": { + "items": { + "$ref": "#/components/schemas/KeySpendActivityRow" + }, + "title": "Api Keys", + "type": "array" + }, + "limit": { + "title": "Limit", + "type": "integer" + }, + "offset": { + "title": "Offset", + "type": "integer" + }, + "total_api_keys": { + "title": "Total Api Keys", + "type": "integer" + } + }, + "required": [ + "api_keys", + "total_api_keys", + "offset", + "limit" + ], + "title": "DailyActivityKeyPageResponse", + "type": "object" + }, + "DailyActivityKeySearchResponse": { + "properties": { + "api_keys": { + "items": { + "$ref": "#/components/schemas/KeyActivityRow" + }, + "title": "Api Keys", + "type": "array" + } + }, + "required": [ + "api_keys" + ], + "title": "DailyActivityKeySearchResponse", + "type": "object" + }, "DailySpendData": { "properties": { "breakdown": { @@ -3653,6 +3700,16 @@ "title": "EntraIdentityConfig", "type": "object" }, + "ExportType": { + "enum": [ + "daily", + "daily_with_keys", + "daily_with_models", + "daily_with_users" + ], + "title": "ExportType", + "type": "string" + }, "HTTPAuthSecurityScheme": { "description": "Defines a security scheme using HTTP authentication.", "properties": { @@ -3708,6 +3765,27 @@ "title": "HTTPValidationError", "type": "object" }, + "KeyActivityRow": { + "properties": { + "api_key": { + "title": "Api Key", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/KeyMetadata" + }, + "metrics": { + "$ref": "#/components/schemas/SpendMetrics" + } + }, + "required": [ + "api_key", + "metrics", + "metadata" + ], + "title": "KeyActivityRow", + "type": "object" + }, "KeyMetadata": { "description": "Metadata for a key", "properties": { @@ -3786,6 +3864,78 @@ "title": "KeyMetricWithMetadata", "type": "object" }, + "KeySpendActivityRow": { + "properties": { + "api_key": { + "title": "Api Key", + "type": "string" + }, + "metadata": { + "$ref": "#/components/schemas/KeyMetadata" + }, + "metrics": { + "$ref": "#/components/schemas/KeySpendMetrics" + } + }, + "required": [ + "api_key", + "metrics", + "metadata" + ], + "title": "KeySpendActivityRow", + "type": "object" + }, + "KeySpendMetrics": { + "properties": { + "api_requests": { + "default": 0, + "title": "Api Requests", + "type": "integer" + }, + "cache_creation_input_tokens": { + "default": 0, + "title": "Cache Creation Input Tokens", + "type": "integer" + }, + "cache_read_input_tokens": { + "default": 0, + "title": "Cache Read Input Tokens", + "type": "integer" + }, + "completion_tokens": { + "default": 0, + "title": "Completion Tokens", + "type": "integer" + }, + "failed_requests": { + "default": 0, + "title": "Failed Requests", + "type": "integer" + }, + "prompt_tokens": { + "default": 0, + "title": "Prompt Tokens", + "type": "integer" + }, + "spend": { + "default": 0.0, + "title": "Spend", + "type": "number" + }, + "successful_requests": { + "default": 0, + "title": "Successful Requests", + "type": "integer" + }, + "total_tokens": { + "default": 0, + "title": "Total Tokens", + "type": "integer" + } + }, + "title": "KeySpendMetrics", + "type": "object" + }, "MakeAgentsPublicRequest": { "properties": { "agent_ids": { @@ -3874,6 +4024,32 @@ "title": "MetricWithMetadata", "type": "object" }, + "ModelTopKeysResponse": { + "properties": { + "api_keys": { + "items": { + "$ref": "#/components/schemas/KeySpendActivityRow" + }, + "title": "Api Keys", + "type": "array" + }, + "by_model_group": { + "title": "By Model Group", + "type": "boolean" + }, + "model": { + "title": "Model", + "type": "string" + } + }, + "required": [ + "model", + "by_model_group", + "api_keys" + ], + "title": "ModelTopKeysResponse", + "type": "object" + }, "MutualTLSSecurityScheme": { "description": "Defines a security scheme using mTLS authentication.", "properties": { @@ -4475,6 +4651,876 @@ ] } }, + "/agent/daily/activity/aggregated": { + "get": { + "operationId": "get_agent_daily_activity_aggregated_agent_daily_activity_aggregated_get", + "parameters": [ + { + "in": "query", + "name": "api_key_limit", + "required": false, + "schema": { + "default": 100, + "maximum": 1000, + "minimum": 1, + "title": "Api Key Limit", + "type": "integer" + } + }, + { + "in": "query", + "name": "agent_ids", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Agent Ids" + } + }, + { + "in": "query", + "name": "start_date", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Start Date" + } + }, + { + "in": "query", + "name": "end_date", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "End Date" + } + }, + { + "in": "query", + "name": "model", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Model" + } + }, + { + "in": "query", + "name": "api_key", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Api Key" + } + }, + { + "in": "query", + "name": "exclude_agent_ids", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Exclude Agent Ids" + } + }, + { + "in": "query", + "name": "timezone", + "required": false, + "schema": { + "anyOf": [ + { + "type": "integer" + }, + { + "type": "null" + } + ], + "title": "Timezone" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SpendAnalyticsPaginatedResponse" + } + } + }, + "description": "Successful Response" + }, + "422": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + }, + "description": "Validation Error" + } + }, + "security": [ + { + "APIKeyHeader": [] + } + ], + "summary": "Get Agent Daily Activity Aggregated", + "tags": [ + "agents" + ] + } + }, + "/agent/daily/activity/aggregated/keys": { + "get": { + "operationId": "get_agent_daily_activity_aggregated_keys_agent_daily_activity_aggregated_keys_get", + "parameters": [ + { + "in": "query", + "name": "offset", + "required": false, + "schema": { + "default": 0, + "minimum": 0, + "title": "Offset", + "type": "integer" + } + }, + { + "in": "query", + "name": "limit", + "required": false, + "schema": { + "default": 50, + "maximum": 100, + "minimum": 1, + "title": "Limit", + "type": "integer" + } + }, + { + "in": "query", + "name": "agent_ids", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Agent Ids" + } + }, + { + "in": "query", + "name": "start_date", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Start Date" + } + }, + { + "in": "query", + "name": "end_date", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "End Date" + } + }, + { + "in": "query", + "name": "model", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Model" + } + }, + { + "in": "query", + "name": "api_key", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Api Key" + } + }, + { + "in": "query", + "name": "exclude_agent_ids", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Exclude Agent Ids" + } + }, + { + "in": "query", + "name": "timezone", + "required": false, + "schema": { + "anyOf": [ + { + "type": "integer" + }, + { + "type": "null" + } + ], + "title": "Timezone" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DailyActivityKeyPageResponse" + } + } + }, + "description": "Successful Response" + }, + "422": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + }, + "description": "Validation Error" + } + }, + "security": [ + { + "APIKeyHeader": [] + } + ], + "summary": "Get Agent Daily Activity Aggregated Keys", + "tags": [ + "agents" + ] + } + }, + "/agent/daily/activity/aggregated/model_top_keys": { + "get": { + "operationId": "get_agent_daily_activity_model_top_keys_agent_daily_activity_aggregated_model_top_keys_get", + "parameters": [ + { + "in": "query", + "name": "model_group", + "required": true, + "schema": { + "minLength": 1, + "title": "Model Group", + "type": "string" + } + }, + { + "in": "query", + "name": "by_model_group", + "required": false, + "schema": { + "default": true, + "title": "By Model Group", + "type": "boolean" + } + }, + { + "in": "query", + "name": "limit", + "required": false, + "schema": { + "default": 5, + "maximum": 100, + "minimum": 1, + "title": "Limit", + "type": "integer" + } + }, + { + "in": "query", + "name": "agent_ids", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Agent Ids" + } + }, + { + "in": "query", + "name": "start_date", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Start Date" + } + }, + { + "in": "query", + "name": "end_date", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "End Date" + } + }, + { + "in": "query", + "name": "model", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Model" + } + }, + { + "in": "query", + "name": "api_key", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Api Key" + } + }, + { + "in": "query", + "name": "exclude_agent_ids", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Exclude Agent Ids" + } + }, + { + "in": "query", + "name": "timezone", + "required": false, + "schema": { + "anyOf": [ + { + "type": "integer" + }, + { + "type": "null" + } + ], + "title": "Timezone" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ModelTopKeysResponse" + } + } + }, + "description": "Successful Response" + }, + "422": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + }, + "description": "Validation Error" + } + }, + "security": [ + { + "APIKeyHeader": [] + } + ], + "summary": "Get Agent Daily Activity Model Top Keys", + "tags": [ + "agents" + ] + } + }, + "/agent/daily/activity/aggregated/search": { + "get": { + "operationId": "get_agent_daily_activity_aggregated_search_agent_daily_activity_aggregated_search_get", + "parameters": [ + { + "in": "query", + "name": "search", + "required": true, + "schema": { + "minLength": 1, + "title": "Search", + "type": "string" + } + }, + { + "in": "query", + "name": "limit", + "required": false, + "schema": { + "default": 100, + "maximum": 100, + "minimum": 1, + "title": "Limit", + "type": "integer" + } + }, + { + "in": "query", + "name": "agent_ids", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Agent Ids" + } + }, + { + "in": "query", + "name": "start_date", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Start Date" + } + }, + { + "in": "query", + "name": "end_date", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "End Date" + } + }, + { + "in": "query", + "name": "model", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Model" + } + }, + { + "in": "query", + "name": "api_key", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Api Key" + } + }, + { + "in": "query", + "name": "exclude_agent_ids", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Exclude Agent Ids" + } + }, + { + "in": "query", + "name": "timezone", + "required": false, + "schema": { + "anyOf": [ + { + "type": "integer" + }, + { + "type": "null" + } + ], + "title": "Timezone" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/DailyActivityKeySearchResponse" + } + } + }, + "description": "Successful Response" + }, + "422": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + }, + "description": "Validation Error" + } + }, + "security": [ + { + "APIKeyHeader": [] + } + ], + "summary": "Get Agent Daily Activity Aggregated Search", + "tags": [ + "agents" + ] + } + }, + "/agent/daily/activity/export": { + "get": { + "operationId": "get_agent_daily_activity_export_agent_daily_activity_export_get", + "parameters": [ + { + "in": "query", + "name": "export_type", + "required": false, + "schema": { + "$ref": "#/components/schemas/ExportType", + "default": "daily" + } + }, + { + "in": "query", + "name": "format", + "required": false, + "schema": { + "default": "csv", + "enum": [ + "csv", + "json" + ], + "title": "Format", + "type": "string" + } + }, + { + "in": "query", + "name": "agent_ids", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Agent Ids" + } + }, + { + "in": "query", + "name": "start_date", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Start Date" + } + }, + { + "in": "query", + "name": "end_date", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "End Date" + } + }, + { + "in": "query", + "name": "model", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Model" + } + }, + { + "in": "query", + "name": "api_key", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Api Key" + } + }, + { + "in": "query", + "name": "exclude_agent_ids", + "required": false, + "schema": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Exclude Agent Ids" + } + }, + { + "in": "query", + "name": "timezone", + "required": false, + "schema": { + "anyOf": [ + { + "type": "integer" + }, + { + "type": "null" + } + ], + "title": "Timezone" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "items": { + "type": "object" + }, + "type": "array" + } + }, + "text/csv": { + "schema": { + "type": "string" + } + } + }, + "description": "Streamed daily activity export" + }, + "422": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + }, + "description": "Validation Error" + } + }, + "security": [ + { + "APIKeyHeader": [] + } + ], + "summary": "Get Agent Daily Activity Export", + "tags": [ + "agents" + ] + } + }, "/v1/agents": { "get": { "description": "Example usage:\n```\ncurl -X GET \"http://localhost:4000/v1/agents\" -H \"Content-Type: application/json\" -H \"Authorization: Bearer your-key\" ```\n\nPass `?health_check=true` to filter out agents whose URL is unreachable:\n```\ncurl -X GET \"http://localhost:4000/v1/agents?health_check=true\" -H \"Content-Type: application/json\" -H \"Authorization: Bearer your-key\" ```\n\nPass `?query=` to get the best matching agents ranked by semantic similarity:\n```\ncurl -X GET \"http://localhost:4000/v1/agents?query=translate+a+PDF+document&top_k=5\" -H \"Content-Type: application/json\" -H \"Authorization: Bearer your-key\" ```\n\nReturns: List[AgentResponse]", diff --git a/litellm/proxy/_types.py b/litellm/proxy/_types.py index a471fb6f6f8..a745213f9e6 100644 --- a/litellm/proxy/_types.py +++ b/litellm/proxy/_types.py @@ -699,6 +699,10 @@ class LiteLLMRoutes(enum.Enum): KeyManagementRoutes.TEAM_KEY_BULK_UPDATE.value, KeyManagementRoutes.TEAM_DAILY_ACTIVITY.value, KeyManagementRoutes.TEAM_DAILY_ACTIVITY_AGGREGATED.value, + "/team/daily/activity/aggregated/keys", + "/team/daily/activity/aggregated/search", + "/team/daily/activity/aggregated/model_top_keys", + "/team/daily/activity/export", KeyManagementRoutes.SPEND_LOGS.value, KeyManagementRoutes.SPEND_LOGS_V2.value, KeyManagementRoutes.KEY_RESET_SPEND.value, @@ -725,6 +729,11 @@ class LiteLLMRoutes(enum.Enum): "/user/list", "/user/daily/activity", "/user/daily/activity/aggregated", + "/user/daily/activity/aggregated/keys", + "/user/daily/activity/aggregated/search", + "/user/daily/activity/aggregated/model_top_keys", + "/user/daily/activity/export", + "/user/daily/activity/aggregated/cache_leakage_keys", # team "/team/new", "/team/update", @@ -742,6 +751,10 @@ class LiteLLMRoutes(enum.Enum): "/team/permissions_bulk_update", "/team/daily/activity", "/team/daily/activity/aggregated", + "/team/daily/activity/aggregated/keys", + "/team/daily/activity/aggregated/search", + "/team/daily/activity/aggregated/model_top_keys", + "/team/daily/activity/export", "/team/spend/by_user", # gateway request counts (SGR); deployment-wide, admin-only "/gateway/daily/activity", @@ -870,6 +883,11 @@ class LiteLLMRoutes(enum.Enum): # Tag usage endpoints scope internal users to tags produced by # their own keys in tag_management_endpoints.py. "/tag/daily/activity", + "/tag/daily/activity/aggregated", + "/tag/daily/activity/aggregated/keys", + "/tag/daily/activity/aggregated/search", + "/tag/daily/activity/aggregated/model_top_keys", + "/tag/daily/activity/export", "/tag/list", "/v1/models/{model_id}", "/models/{model_id}", @@ -894,6 +912,11 @@ class LiteLLMRoutes(enum.Enum): # Tag usage endpoints scope internal viewers to tags produced by # their own keys in tag_management_endpoints.py. "/tag/daily/activity", + "/tag/daily/activity/aggregated", + "/tag/daily/activity/aggregated/keys", + "/tag/daily/activity/aggregated/search", + "/tag/daily/activity/aggregated/model_top_keys", + "/tag/daily/activity/export", "/tag/list", ] ) @@ -913,6 +936,10 @@ class LiteLLMRoutes(enum.Enum): "/team/permissions_update", "/team/daily/activity", "/team/daily/activity/aggregated", + "/team/daily/activity/aggregated/keys", + "/team/daily/activity/aggregated/search", + "/team/daily/activity/aggregated/model_top_keys", + "/team/daily/activity/export", "/team/spend/by_user", "/team/{team_id}/members/me", # POST/GET the team's logging callbacks, and DELETE one of them. Every @@ -928,9 +955,19 @@ class LiteLLMRoutes(enum.Enum): "/model/delete", "/user/daily/activity", "/user/daily/activity/aggregated", + "/user/daily/activity/aggregated/keys", + "/user/daily/activity/aggregated/search", + "/user/daily/activity/aggregated/model_top_keys", + "/user/daily/activity/export", + "/user/daily/activity/aggregated/cache_leakage_keys", # Endpoint restricts results to organizations the caller is ORG_ADMIN # of; a caller who administers none gets an empty result set. "/organization/daily/activity", + "/organization/daily/activity/aggregated", + "/organization/daily/activity/aggregated/keys", + "/organization/daily/activity/aggregated/search", + "/organization/daily/activity/aggregated/model_top_keys", + "/organization/daily/activity/export", "/user/available_roles", # read-only role metadata; any authenticated user may read # Claude Code gateway: the signed-in CLI fetches its managed settings and posts its own telemetry "/claude_code_gateway/managed/settings", @@ -1009,9 +1046,24 @@ class LiteLLMRoutes(enum.Enum): "/user/available_users", "/user/available_roles", "/user/daily/activity", + "/user/daily/activity/aggregated", + "/user/daily/activity/aggregated/keys", + "/user/daily/activity/aggregated/search", + "/user/daily/activity/aggregated/model_top_keys", + "/user/daily/activity/export", + "/user/daily/activity/aggregated/cache_leakage_keys", "/team/daily/activity", "/team/daily/activity/aggregated", + "/team/daily/activity/aggregated/keys", + "/team/daily/activity/aggregated/search", + "/team/daily/activity/aggregated/model_top_keys", + "/team/daily/activity/export", "/tag/daily/activity", + "/tag/daily/activity/aggregated", + "/tag/daily/activity/aggregated/keys", + "/tag/daily/activity/aggregated/search", + "/tag/daily/activity/aggregated/model_top_keys", + "/tag/daily/activity/export", "/tag/list", "/audit", "/audit/{id}", diff --git a/litellm/proxy/agent_endpoints/endpoints.py b/litellm/proxy/agent_endpoints/endpoints.py index 875b62103b9..c0f34a24a0a 100644 --- a/litellm/proxy/agent_endpoints/endpoints.py +++ b/litellm/proxy/agent_endpoints/endpoints.py @@ -13,7 +13,7 @@ import os import uuid from collections.abc import Mapping, Sequence from types import MappingProxyType -from typing import Annotated, Final, TypedDict +from typing import Annotated, Final, NamedTuple, TypedDict from fastapi import APIRouter, Depends, HTTPException, Query, Request from pydantic import ValidationError @@ -47,7 +47,11 @@ from litellm.proxy.agent_endpoints.agent_search import ( global_agent_search_index, search_agents, ) -from litellm.proxy.agent_endpoints.auth.agent_permission_handler import accessible_agents +from litellm.proxy.agent_endpoints.auth.agent_permission_handler import ( + AgentRequestHandler, + UnrestrictedAgentAccess, + accessible_agents, +) from litellm.proxy.agent_endpoints.identity import reject_legacy_identity from litellm.proxy.agent_endpoints.identity_store import AgentIdentityStore from litellm.proxy.agent_endpoints.kill_switch import ( @@ -63,7 +67,8 @@ from litellm.proxy.agent_endpoints.managed_identity import raise_identity_failur from litellm.proxy.auth.user_api_key_auth import user_api_key_auth from litellm.proxy.common_utils.rbac_utils import check_feature_access_for_user from litellm.proxy.management_endpoints.common_daily_activity import get_daily_activity -from litellm.proxy.utils import get_custom_url +from litellm.proxy.utils import PrismaClient, get_custom_url +from litellm.repositories.chunked_in import find_many_in from litellm.types.agents import ( AgentCard, AgentConfig, @@ -303,6 +308,73 @@ async def _rank_agents_by_query( assert_never(outcome) +class _AgentDailyActivityScope(NamedTuple): + agent_ids: tuple[str, ...] | None + agent_metadata: Mapping[str, dict[str, object]] + + +async def _owned_agent_ids(*, user_id: str | None, prisma_client: PrismaClient) -> frozenset[str]: + if user_id is None: + return frozenset() + owned_records: Final = await agents_table(prisma_client).find_many(where={"created_by": user_id}) + return frozenset(agent.agent_id for agent in owned_records) + + +async def _permitted_daily_activity_agent_ids( + *, user_api_key_dict: UserAPIKeyAuth, prisma_client: PrismaClient +) -> frozenset[str]: + access: Final = await AgentRequestHandler.resolve_agent_access(user_api_key_auth=user_api_key_dict) + if isinstance(access, UnrestrictedAgentAccess): + return await _owned_agent_ids(user_id=user_api_key_dict.user_id, prisma_client=prisma_client) + return access.agent_ids + + +async def _resolve_daily_activity_agent_ids( + *, + agent_ids: tuple[str, ...] | None, + user_api_key_dict: UserAPIKeyAuth, + prisma_client: PrismaClient, +) -> tuple[str, ...] | None: + from litellm.proxy.management_endpoints.common_utils import _user_has_admin_view + + if _user_has_admin_view(user_api_key_dict): + return agent_ids + permitted_agent_ids: Final = await _permitted_daily_activity_agent_ids( + user_api_key_dict=user_api_key_dict, + prisma_client=prisma_client, + ) + return ( + tuple(agent_id for agent_id in agent_ids if agent_id in permitted_agent_ids) + if agent_ids + else tuple(permitted_agent_ids) + ) + + +async def resolve_agent_daily_activity_scope( + *, + agent_ids: tuple[str, ...] | None, + user_api_key_dict: UserAPIKeyAuth, + prisma_client: PrismaClient, +) -> _AgentDailyActivityScope: + await check_feature_access_for_user(user_api_key_dict, "agents") + + resolved_agent_ids: Final = await _resolve_daily_activity_agent_ids( + agent_ids=agent_ids, + user_api_key_dict=user_api_key_dict, + prisma_client=prisma_client, + ) + + agent_records: Final = ( + await agents_table(prisma_client).find_many(where={}) + if resolved_agent_ids is None + else await find_many_in(agents_table(prisma_client), "agent_id", resolved_agent_ids) + ) + agent_metadata: Final[Mapping[str, dict[str, object]]] = MappingProxyType( + {agent.agent_id: {"agent_name": agent.agent_name} for agent in agent_records} + ) + return _AgentDailyActivityScope(resolved_agent_ids, agent_metadata) + + @router.get( "/v1/agents", tags=["[beta] A2A Agents"], @@ -1288,82 +1360,39 @@ async def get_agent_daily_activity( detail={"error": CommonProxyErrors.db_not_connected_error.value}, ) - agent_ids_list = agent_ids.split(",") if agent_ids else None - exclude_agent_ids_list: list[str] | None = None - if exclude_agent_ids: - exclude_agent_ids_list = exclude_agent_ids.split(",") if exclude_agent_ids else None - - # Without scoping, an empty `agent_ids` query returned every agent's - # spend/token rows on the proxy. Restrict non-admin callers to the - # agents they're permitted to invoke (or that they created), and - # intersect their explicit `agent_ids` filter with the same allowlist. - from litellm.proxy.agent_endpoints.auth.agent_permission_handler import ( - AgentRequestHandler, - RestrictedAgentAccess, - UnrestrictedAgentAccess, + requested_agent_ids: Final = tuple(agent_ids.split(",")) if agent_ids else None + exclude_agent_ids_list: Final[list[str] | None] = exclude_agent_ids.split(",") if exclude_agent_ids else None + agent_scope: Final = await resolve_agent_daily_activity_scope( + agent_ids=requested_agent_ids, + user_api_key_dict=user_api_key_dict, + prisma_client=prisma_client, ) - from litellm.proxy.management_endpoints.common_utils import _user_has_admin_view - - where_condition: Final[dict[str, object]] = {} - if not _user_has_admin_view(user_api_key_dict): - permitted_agent_ids: list[str] = [] - # An unrestricted caller is not "see everything" for activity scoping. Fall - # back to the agents the caller created so they cannot enumerate other - # tenants' agents. - # Guard against `user_id is None`: a literal None in Prisma - # `where={"created_by": None}` resolves to ``created_by IS NULL`` - # and would expose every ownerless agent's rows. - match await AgentRequestHandler.resolve_agent_access(user_api_key_auth=user_api_key_dict): - case RestrictedAgentAccess(allowed_agent_ids): - permitted_agent_ids = list(allowed_agent_ids) - case UnrestrictedAgentAccess(): - if user_api_key_dict.user_id is not None: - owned_records: Final = await agents_table(prisma_client).find_many( - where={"created_by": user_api_key_dict.user_id} - ) - permitted_agent_ids = [a.agent_id for a in owned_records] - - if agent_ids_list: - permitted_agent_id_set: Final = set(permitted_agent_ids) - agent_ids_list = [aid for aid in agent_ids_list if aid in permitted_agent_id_set] - else: - agent_ids_list = list(permitted_agent_ids) - - # No accessible agents → return an empty page without querying. - if not agent_ids_list: - return SpendAnalyticsPaginatedResponse( - results=[], - metadata=DailySpendMetadata( - total_spend=0.0, - total_prompt_tokens=0, - total_completion_tokens=0, - total_tokens=0, - total_api_requests=0, - total_successful_requests=0, - total_failed_requests=0, - total_cache_read_input_tokens=0, - total_cache_creation_input_tokens=0, - total_compression_saved_tokens=0, - page=page, - total_pages=0, - has_more=False, - ), - ) - - if agent_ids_list: - where_condition["agent_id"] = {"in": list(agent_ids_list)} - - agent_records: Final = await agents_table(prisma_client).find_many(where=where_condition) - agent_metadata: Final[Mapping[str, dict[str, object]]] = { - agent.agent_id: {"agent_name": agent.agent_name} for agent in agent_records - } + if agent_scope.agent_ids == (): + return SpendAnalyticsPaginatedResponse( + results=[], + metadata=DailySpendMetadata( + total_spend=0.0, + total_prompt_tokens=0, + total_completion_tokens=0, + total_tokens=0, + total_api_requests=0, + total_successful_requests=0, + total_failed_requests=0, + total_cache_read_input_tokens=0, + total_cache_creation_input_tokens=0, + total_compression_saved_tokens=0, + page=page, + total_pages=0, + has_more=False, + ), + ) return await get_daily_activity( prisma_client=prisma_client, table_name="litellm_dailyagentspend", entity_id_field="agent_id", - entity_id=agent_ids_list, - entity_metadata_field=agent_metadata, + entity_id=None if agent_scope.agent_ids is None else list(agent_scope.agent_ids), + entity_metadata_field=agent_scope.agent_metadata, exclude_entity_ids=exclude_agent_ids_list, start_date=start_date, end_date=end_date, diff --git a/litellm/proxy/management_endpoints/common_daily_activity.py b/litellm/proxy/management_endpoints/common_daily_activity.py index 59d1d2bf01d..e13d623c73b 100644 --- a/litellm/proxy/management_endpoints/common_daily_activity.py +++ b/litellm/proxy/management_endpoints/common_daily_activity.py @@ -4,10 +4,10 @@ from collections.abc import Set as AbstractSet from dataclasses import dataclass, replace from datetime import datetime, timedelta from types import MappingProxyType -from typing import Final, Protocol +from typing import Final, Literal, NoReturn, Protocol from fastapi import HTTPException, status -from typing_extensions import ReadOnly, TypedDict +from typing_extensions import ReadOnly, TypedDict, assert_never from litellm import constants from litellm._logging import verbose_proxy_logger @@ -45,6 +45,27 @@ from litellm.types.repositories.daily_activity import ( ) +@dataclass(frozen=True, slots=True) +class ScopeDenied: + status_code: Literal[403, 404] + reason: str + + +@dataclass(frozen=True, slots=True) +class InvalidDateRange: + reason: str + + +def raise_public(error: ScopeDenied | InvalidDateRange) -> NoReturn: + match error: + case ScopeDenied(): + raise HTTPException(status_code=error.status_code, detail={"error": error.reason}) + case InvalidDateRange(): + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail={"error": error.reason}) + case _: + assert_never(error) + + class DailySpendRecord(Protocol): @property def date(self) -> str: ... @@ -402,7 +423,7 @@ def update_breakdown_metrics( return breakdown -def _spend_logs_window(dates: AbstractSet[str | None]) -> tuple[datetime, datetime] | None: +def spend_logs_window(dates: AbstractSet[str | None]) -> tuple[datetime, datetime] | None: parsed: Final = sorted(day for day in (_parse_spend_date(raw) for raw in dates) if day is not None) if not parsed: return None @@ -622,7 +643,7 @@ async def _aggregate_spend_records( api_key_metadata: Final[Mapping[str, KeyMetadataRow]] = ( await repository.key_metadata( - frozenset(api_keys), _spend_logs_window(frozenset(record.date for record in records)) + frozenset(api_keys), spend_logs_window(frozenset(record.date for record in records)) ) if api_keys else MappingProxyType({}) @@ -823,7 +844,7 @@ async def _aggregate_grouping_sets_records( api_keys: Final[set[str]] = {r.api_key for r in records if r.api_key and r.api_key != PTU_SENTINEL_API_KEY} api_key_metadata: Final[Mapping[str, KeyMetadataRow]] = ( - await repository.key_metadata(frozenset(api_keys), _spend_logs_window(frozenset(r.date for r in records))) + await repository.key_metadata(frozenset(api_keys), spend_logs_window(frozenset(r.date for r in records))) if api_keys else MappingProxyType({}) ) @@ -990,7 +1011,7 @@ async def get_daily_activity_aggregated( ) entity_key_metadata: Final[Mapping[str, KeyMetadataRow]] = ( await repository.key_metadata( - entity_api_keys, _spend_logs_window(frozenset(row.date for row in entity_records)) + entity_api_keys, spend_logs_window(frozenset(row.date for row in entity_records)) ) if entity_api_keys else MappingProxyType({}) diff --git a/litellm/proxy/management_endpoints/customer_endpoints.py b/litellm/proxy/management_endpoints/customer_endpoints.py index b35bc01b4d0..7236fd12e9d 100644 --- a/litellm/proxy/management_endpoints/customer_endpoints.py +++ b/litellm/proxy/management_endpoints/customer_endpoints.py @@ -12,7 +12,8 @@ All /customer management endpoints #### END-USER/CUSTOMER MANAGEMENT #### from collections.abc import Mapping, Sequence from datetime import datetime, timedelta -from typing import TYPE_CHECKING, Final, Protocol, TypeVar, overload +from types import MappingProxyType +from typing import TYPE_CHECKING, Final, NamedTuple, Protocol, TypeVar, overload import fastapi from fastapi import APIRouter, Depends, HTTPException, Request @@ -41,6 +42,7 @@ from litellm.proxy.management_helpers.object_permission_utils import ( ) from litellm.proxy.utils import handle_exception_on_proxy from litellm.repositories.budget_repository import BudgetRepository +from litellm.repositories.chunked_in import find_many_in from litellm.repositories.table_repositories import EndUserRepository from litellm.types.proxy.management_endpoints.common_daily_activity import ( SpendAnalyticsPaginatedResponse, @@ -490,6 +492,33 @@ async def new_end_user( raise handle_exception_on_proxy(e) +class _CustomerDailyActivityScope(NamedTuple): + end_user_ids: tuple[str, ...] | None + end_user_metadata: Mapping[str, dict[str, object]] + + +async def resolve_customer_daily_activity_scope( + *, + end_user_ids: tuple[str, ...] | None, + prisma_client: "PrismaClient", +) -> _CustomerDailyActivityScope: + end_user_table: Final = _typed_table(EndUserRepository(prisma_client)) + end_user_aliases: Final = ( + await find_many_in(end_user_table, "user_id", end_user_ids) + if end_user_ids is not None + else await end_user_table.find_many(where={}) + ) + metadata: Final = MappingProxyType({end_user.user_id: {"alias": end_user.alias} for end_user in end_user_aliases}) + return _CustomerDailyActivityScope(end_user_ids, metadata) + + +def customer_daily_activity_is_admin(user_api_key_dict: UserAPIKeyAuth) -> bool: + return user_api_key_dict.user_role in ( + LitellmUserRoles.PROXY_ADMIN, + LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY, + ) + + @router.get( "/customer/info", tags=["Customer Management"], @@ -888,10 +917,7 @@ async def get_customer_daily_activity( """ Get daily activity for specific organizations or all accessible organizations. """ - if ( - user_api_key_dict.user_role != LitellmUserRoles.PROXY_ADMIN - and user_api_key_dict.user_role != LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY - ): + if not customer_daily_activity_is_admin(user_api_key_dict): raise HTTPException( status_code=401, detail={"error": f"Admin-only endpoint. Your user role={user_api_key_dict.user_role}"}, @@ -906,24 +932,22 @@ async def get_customer_daily_activity( ) # Parse comma-separated ids - end_user_ids_list: Final = end_user_ids.split(",") if end_user_ids else None + end_user_ids_list: Final = tuple(end_user_ids.split(",")) if end_user_ids else None exclude_end_user_ids_list: list[str] | None = None if exclude_end_user_ids: exclude_end_user_ids_list = exclude_end_user_ids.split(",") if exclude_end_user_ids else None - # Fetch organization aliases for metadata - where_condition: Final = dict[str, object]() - if end_user_ids_list: - where_condition["user_id"] = {"in": list(end_user_ids_list)} - end_user_aliases: Final = await _typed_table(EndUserRepository(prisma_client)).find_many(where=where_condition) + customer_scope: Final = await resolve_customer_daily_activity_scope( + end_user_ids=end_user_ids_list, + prisma_client=prisma_client, + ) - # Query daily activity for organizations return await get_daily_activity( prisma_client=prisma_client, table_name="litellm_dailyenduserspend", entity_id_field="end_user_id", - entity_id=end_user_ids_list, - entity_metadata_field={e.user_id: {"alias": e.alias} for e in end_user_aliases}, + entity_id=None if customer_scope.end_user_ids is None else list(customer_scope.end_user_ids), + entity_metadata_field=customer_scope.end_user_metadata, exclude_entity_ids=exclude_end_user_ids_list, start_date=start_date, end_date=end_date, diff --git a/litellm/proxy/management_endpoints/daily_activity_routes.py b/litellm/proxy/management_endpoints/daily_activity_routes.py new file mode 100644 index 00000000000..065f23c3829 --- /dev/null +++ b/litellm/proxy/management_endpoints/daily_activity_routes.py @@ -0,0 +1,579 @@ +import csv +import io +import json +from collections.abc import AsyncIterator, Mapping, Sequence +from dataclasses import asdict, fields, replace +from datetime import datetime +from typing import Annotated, Final, Literal + +from fastapi import APIRouter, Depends, HTTPException, Query +from fastapi.encoders import jsonable_encoder +from fastapi.responses import StreamingResponse + +from litellm import constants +from litellm._logging import verbose_proxy_logger +from litellm.proxy._types import CommonProxyErrors, UserAPIKeyAuth +from litellm.proxy.auth.user_api_key_auth import user_api_key_auth +from litellm.proxy.management_endpoints.common_daily_activity import ( + InvalidDateRange, + ScopeDenied, + daily_activity_repository, + get_daily_activity_aggregated, + raise_public, + spend_logs_window, +) +from litellm.proxy.management_endpoints.daily_activity_scopes import ( + AGENT_RESOLVER, + CUSTOMER_RESOLVER, + ORGANIZATION_RESOLVER, + TAG_RESOLVER, + TEAM_RESOLVER, + USER_RESOLVER, + EntityQuery, + EntityScopeResolver, + ResolvedScope, +) +from litellm.proxy.management_endpoints.team_endpoints import aggregated_date_range_error +from litellm.proxy.management_helpers.utils import management_endpoint_wrapper +from litellm.proxy.utils import PrismaClient, get_prisma_client_or_throw +from litellm.repositories.daily_activity_repository import DailyActivityRepository +from litellm.types.proxy.management_endpoints.common_daily_activity import ( + CacheLeakageKeysResponse, + DailyActivityKeyPageResponse, + DailyActivityKeySearchResponse, + KeyActivityRow, + KeyMetadata, + KeySpendActivityRow, + KeySpendMetrics, + ModelTopKeysResponse, + SpendAnalyticsPaginatedResponse, + SpendMetrics, +) +from litellm.types.repositories.daily_activity import ( + ExportRow, + ExportType, + KeyMetadataRow, + KeySpendRow, +) + +router = APIRouter() + + +def get_daily_activity_prisma_client() -> PrismaClient: + return get_prisma_client_or_throw(CommonProxyErrors.db_not_connected_error.value) + + +def get_daily_activity_repository() -> DailyActivityRepository: + return daily_activity_repository(get_daily_activity_prisma_client()) + + +def _date_range_error(query: EntityQuery, *, user_aggregated: bool) -> InvalidDateRange | None: + if user_aggregated: + if query.start_date is None or query.end_date is None: + return InvalidDateRange(reason="Please provide start_date and end_date") + return None + + range_error: Final[str | None] = aggregated_date_range_error(query.start_date, query.end_date) + return None if range_error is None else InvalidDateRange(reason=range_error) + + +async def _resolved_scope( + resolver: EntityScopeResolver, + query: EntityQuery, + user_api_key_dict: UserAPIKeyAuth, + prisma_client: PrismaClient, + *, + user_aggregated: bool, +) -> ResolvedScope: + date_error: Final[InvalidDateRange | None] = _date_range_error(query, user_aggregated=user_aggregated) + if date_error is not None: + raise_public(date_error) + result: ResolvedScope | ScopeDenied = await resolver.resolve(user_api_key_dict, query, prisma_client) + if isinstance(result, ScopeDenied): + raise_public(result) + return result + + +def _sum_metrics(metrics: Sequence[SpendMetrics]) -> SpendMetrics: + return SpendMetrics( + spend=sum(metric.spend for metric in metrics), + flat_cost=sum(metric.flat_cost for metric in metrics), + prompt_tokens=sum(metric.prompt_tokens for metric in metrics), + completion_tokens=sum(metric.completion_tokens for metric in metrics), + cache_read_input_tokens=sum(metric.cache_read_input_tokens for metric in metrics), + cache_creation_input_tokens=sum(metric.cache_creation_input_tokens for metric in metrics), + compression_saved_tokens=sum(metric.compression_saved_tokens for metric in metrics), + compression_savings_spend=sum(metric.compression_savings_spend for metric in metrics), + prompt_caching_savings_spend=sum(metric.prompt_caching_savings_spend for metric in metrics), + gateway_injected_caching_savings_spend=sum(metric.gateway_injected_caching_savings_spend for metric in metrics), + autorouter_savings_spend=sum(metric.autorouter_savings_spend for metric in metrics), + total_tokens=sum(metric.total_tokens for metric in metrics), + successful_requests=sum(metric.successful_requests for metric in metrics), + failed_requests=sum(metric.failed_requests for metric in metrics), + api_requests=sum(metric.api_requests for metric in metrics), + total_response_time_ms=sum(metric.total_response_time_ms for metric in metrics), + timed_requests=sum(metric.timed_requests for metric in metrics), + ) + + +def _key_metadata(api_key: str, metadata: Mapping[str, KeyMetadataRow]) -> KeyMetadata: + row: Final[KeyMetadataRow | None] = metadata.get(api_key) + if row is None: + return KeyMetadata() + return KeyMetadata( + key_alias=row.key_alias, + team_id=row.team_id, + user_id=row.user_id, + user_email=row.user_email, + key_exists=row.key_exists, + ) + + +def _key_activity_row(row: KeySpendRow, metadata: Mapping[str, KeyMetadataRow]) -> KeySpendActivityRow: + return KeySpendActivityRow( + api_key=row.api_key, + metrics=KeySpendMetrics( + spend=row.spend, + prompt_tokens=row.prompt_tokens, + completion_tokens=row.completion_tokens, + total_tokens=row.total_tokens, + api_requests=row.api_requests, + successful_requests=row.successful_requests, + failed_requests=row.failed_requests, + cache_read_input_tokens=row.cache_read_input_tokens, + cache_creation_input_tokens=row.cache_creation_input_tokens, + ), + metadata=_key_metadata(row.api_key, metadata), + ) + + +async def _key_activity_rows( + repository: DailyActivityRepository, + rows: Sequence[KeySpendRow], + resolved_scope: ResolvedScope, +) -> list[KeySpendActivityRow]: + spend_window: Final[tuple[datetime, datetime] | None] = spend_logs_window( + frozenset((resolved_scope.scope.start_date, resolved_scope.scope.end_date)) + ) + metadata: Final[Mapping[str, KeyMetadataRow]] = await repository.key_metadata( + frozenset(row.api_key for row in rows), + spend_window, + ) + return [_key_activity_row(row, metadata) for row in rows] + + +def _export_filename( + entity: str, + start_date: str, + end_date: str, + export_type: ExportType, + file_format: Literal["csv", "json"], +) -> str: + extension: Final[str] = "csv" if file_format == "csv" else "json" + return f"{entity}-usage-{start_date}-{end_date}-{export_type.value}.{extension}" + + +def _content_disposition( + entity: str, + start_date: str, + end_date: str, + export_type: ExportType, + file_format: Literal["csv", "json"], +) -> str: + filename: Final = _export_filename(entity, start_date, end_date, export_type, file_format) + return f'attachment; filename="{filename}"' + + +def _fold_key_metrics(api_key: str, response: SpendAnalyticsPaginatedResponse) -> KeyActivityRow | None: + metrics: Final[tuple[SpendMetrics, ...]] = tuple( + day.breakdown.api_keys[api_key].metrics for day in response.results if api_key in day.breakdown.api_keys + ) + if not metrics: + return None + metadata: Final[KeyMetadata] = next( + day.breakdown.api_keys[api_key].metadata for day in response.results if api_key in day.breakdown.api_keys + ) + return KeyActivityRow(api_key=api_key, metrics=_sum_metrics(metrics), metadata=metadata) + + +def _search_rows(keys: Sequence[str], response: SpendAnalyticsPaginatedResponse) -> list[KeyActivityRow]: + return [row for key in keys if (row := _fold_key_metrics(key, response)) is not None] + + +def _csv_cell(value: object) -> object: + if isinstance(value, str) and value.startswith(("=", "+", "-", "@", "\t", "\r")): + return f"'{value}" + return value + + +def _csv_row(values: Sequence[object]) -> bytes: + output: Final[io.StringIO] = io.StringIO(newline="") + csv.writer(output, lineterminator="\r\n").writerow(tuple(_csv_cell(value) for value in values)) + return output.getvalue().encode() + + +def _stream_export_rows( + first_row: ExportRow | None, + rows: AsyncIterator[ExportRow], + file_format: Literal["csv", "json"], +) -> AsyncIterator[bytes]: + async def stream() -> AsyncIterator[bytes]: + if file_format == "csv": + yield _csv_row(tuple(field.name for field in fields(ExportRow))) + if first_row is not None: + yield _csv_row(tuple(asdict(first_row).values())) + async for row in rows: + yield _csv_row(tuple(asdict(row).values())) + return + + if first_row is None: + yield b"[]" + return + yield b"[" + json.dumps(jsonable_encoder(first_row), separators=(",", ":")).encode() + async for row in rows: + yield b"," + json.dumps(jsonable_encoder(row), separators=(",", ":")).encode() + yield b"]" + + return stream() + + +def _register_aggregated_route(router: APIRouter, resolver: EntityScopeResolver, prefix: str) -> None: + @management_endpoint_wrapper + async def aggregated( + entity_query: Annotated[EntityQuery, Depends(resolver.query)], + user_api_key_dict: Annotated[UserAPIKeyAuth, Depends(user_api_key_auth)], + repository: Annotated[DailyActivityRepository, Depends(get_daily_activity_repository)], + prisma_client: Annotated[PrismaClient, Depends(get_daily_activity_prisma_client)], + api_key_limit: Annotated[ + int, Query(ge=1, le=constants.USAGE_TOP_API_KEYS_MAX) + ] = constants.USAGE_TOP_API_KEYS_DEFAULT, + ) -> SpendAnalyticsPaginatedResponse: + try: + resolved: ResolvedScope = await _resolved_scope( + resolver, + entity_query, + user_api_key_dict, + prisma_client, + user_aggregated=resolver.entity == "user", + ) + return await get_daily_activity_aggregated( + repository, + resolved.scope, + entity_metadata_field=resolved.entity_metadata, + include_entity_breakdown=resolver.include_entity_breakdown, + api_key_limit=api_key_limit, + ) + except HTTPException: + raise + except Exception as exc: + verbose_proxy_logger.exception("Daily activity aggregation failed: %s", exc) + raise HTTPException(status_code=500, detail={"error": f"Failed to fetch analytics: {exc}"}) + + router.add_api_route( + f"{prefix}/daily/activity/aggregated", + aggregated, + methods=["GET"], + name=resolver.operation_names["aggregated"], + tags=list(resolver.tags), + dependencies=(Depends(user_api_key_auth),), + response_model=SpendAnalyticsPaginatedResponse, + include_in_schema=prefix != "/end_user", + ) + + if resolver.entity == "user": + aggregated.__doc__ = ( + "Aggregated analytics for a user's daily activity without pagination.\n" + "Returns the same response shape as the paginated endpoint with page metadata set to single-page.\n\n" + "Reads daily spend records that only ever accumulate and are never affected by budget\n" + "resets. Their total can legitimately exceed the `spend` field returned by\n" + "`/v2/user/info`, which is a running budget counter that every budget reset sets back\n" + "to zero (or to the overage above `max_budget` when `budget_rollover` is enabled)." + ) + elif resolver.entity == "team": + aggregated.__doc__ = ( + "Aggregated daily activity for teams without pagination, including per-team breakdown.\n\n" + "One SQL GROUPING SETS pass returns every day in the range regardless of row\n" + "volume, so callers never reassemble pages. Same response shape as the\n" + "paginated endpoint with page metadata pinned to a single page.\n\n" + "Args:\n" + " team_ids (Optional[str]): Comma-separated list of team IDs to filter by. If not provided, " + "returns data for all teams.\n" + " start_date (Optional[str]): Start date for the activity period (YYYY-MM-DD).\n" + " end_date (Optional[str]): End date for the activity period (YYYY-MM-DD).\n" + " model (Optional[str]): Filter by model name.\n" + " api_key (Optional[str]): Filter by API key.\n" + " exclude_team_ids (Optional[str]): Comma-separated list of team IDs to exclude.\n" + " timezone (Optional[int]): Timezone offset in minutes from UTC, matching JavaScript's " + "Date.getTimezoneOffset() convention.\n" + "Returns:\n" + " SpendAnalyticsPaginatedResponse: Response containing all daily activity data for the range." + ) + + +def _register_key_page_route(router: APIRouter, resolver: EntityScopeResolver, prefix: str) -> None: + @management_endpoint_wrapper + async def key_page( + entity_query: Annotated[EntityQuery, Depends(resolver.query)], + user_api_key_dict: Annotated[UserAPIKeyAuth, Depends(user_api_key_auth)], + repository: Annotated[DailyActivityRepository, Depends(get_daily_activity_repository)], + prisma_client: Annotated[PrismaClient, Depends(get_daily_activity_prisma_client)], + offset: Annotated[int, Query(ge=0)] = 0, + limit: Annotated[int, Query(ge=1, le=constants.USAGE_KEY_PAGE_MAX)] = constants.USAGE_KEY_PAGE_DEFAULT, + ) -> DailyActivityKeyPageResponse: + try: + resolved: Final = await _resolved_scope( + resolver, + entity_query, + user_api_key_dict, + prisma_client, + user_aggregated=False, + ) + page: Final = await repository.key_page(resolved.scope, offset=offset, limit=limit) + return DailyActivityKeyPageResponse( + api_keys=await _key_activity_rows(repository, page.rows, resolved), + total_api_keys=page.total_api_keys, + offset=offset, + limit=limit, + ) + except HTTPException: + raise + except Exception as exc: + verbose_proxy_logger.exception("Daily activity key page failed: %s", exc) + raise HTTPException(status_code=500, detail={"error": f"Failed to fetch analytics: {exc}"}) + + router.add_api_route( + f"{prefix}/daily/activity/aggregated/keys", + key_page, + methods=["GET"], + name=resolver.operation_names["key_page"], + tags=list(resolver.tags), + dependencies=(Depends(user_api_key_auth),), + response_model=DailyActivityKeyPageResponse, + include_in_schema=prefix != "/end_user", + ) + + +def _register_search_route(router: APIRouter, resolver: EntityScopeResolver, prefix: str) -> None: + @management_endpoint_wrapper + async def search( + entity_query: Annotated[EntityQuery, Depends(resolver.query)], + search: Annotated[str, Query(min_length=1)], + user_api_key_dict: Annotated[UserAPIKeyAuth, Depends(user_api_key_auth)], + repository: Annotated[DailyActivityRepository, Depends(get_daily_activity_repository)], + prisma_client: Annotated[PrismaClient, Depends(get_daily_activity_prisma_client)], + limit: Annotated[int, Query(ge=1, le=constants.USAGE_KEY_SEARCH_MAX)] = constants.USAGE_KEY_SEARCH_DEFAULT, + ) -> DailyActivityKeySearchResponse: + try: + resolved: ResolvedScope = await _resolved_scope( + resolver, + entity_query, + user_api_key_dict, + prisma_client, + user_aggregated=False, + ) + keys: tuple[str, ...] = await repository.search_keys( + resolved.scope, + search=search, + limit=limit, + ) + if not keys: + return DailyActivityKeySearchResponse(api_keys=[]) + search_response: SpendAnalyticsPaginatedResponse = await get_daily_activity_aggregated( + repository, + replace(resolved.scope, api_keys=keys), + include_entity_breakdown=False, + ) + return DailyActivityKeySearchResponse(api_keys=_search_rows(keys, search_response)) + except HTTPException: + raise + except Exception as exc: + verbose_proxy_logger.exception("Daily activity key search failed: %s", exc) + raise HTTPException(status_code=500, detail={"error": f"Failed to fetch analytics: {exc}"}) + + router.add_api_route( + f"{prefix}/daily/activity/aggregated/search", + search, + methods=["GET"], + name=resolver.operation_names["search"], + tags=list(resolver.tags), + dependencies=(Depends(user_api_key_auth),), + response_model=DailyActivityKeySearchResponse, + include_in_schema=prefix != "/end_user", + ) + + +def _register_model_top_keys_route(router: APIRouter, resolver: EntityScopeResolver, prefix: str) -> None: + @management_endpoint_wrapper + async def model_top_keys( + entity_query: Annotated[EntityQuery, Depends(resolver.query)], + user_api_key_dict: Annotated[UserAPIKeyAuth, Depends(user_api_key_auth)], + repository: Annotated[DailyActivityRepository, Depends(get_daily_activity_repository)], + prisma_client: Annotated[PrismaClient, Depends(get_daily_activity_prisma_client)], + model_group: Annotated[str, Query(min_length=1)], + by_model_group: Annotated[bool, Query()] = True, + limit: Annotated[int, Query(ge=1, le=constants.USAGE_MODEL_TOP_KEYS_MAX)] = ( + constants.USAGE_MODEL_TOP_KEYS_DEFAULT + ), + ) -> ModelTopKeysResponse: + try: + resolved: ResolvedScope = await _resolved_scope( + resolver, + entity_query, + user_api_key_dict, + prisma_client, + user_aggregated=False, + ) + rows: tuple[KeySpendRow, ...] = await repository.model_top_keys( + resolved.scope, + model_group=model_group, + by_model_group=by_model_group, + limit=limit, + ) + return ModelTopKeysResponse( + model=model_group, + by_model_group=by_model_group, + api_keys=await _key_activity_rows(repository, rows, resolved), + ) + except HTTPException: + raise + except Exception as exc: + verbose_proxy_logger.exception("Daily activity model top keys failed: %s", exc) + raise HTTPException(status_code=500, detail={"error": f"Failed to fetch analytics: {exc}"}) + + router.add_api_route( + f"{prefix}/daily/activity/aggregated/model_top_keys", + model_top_keys, + methods=["GET"], + name=resolver.operation_names["model_top_keys"], + tags=list(resolver.tags), + dependencies=(Depends(user_api_key_auth),), + response_model=ModelTopKeysResponse, + include_in_schema=prefix != "/end_user", + ) + + +def _register_export_route(router: APIRouter, resolver: EntityScopeResolver, prefix: str) -> None: + @management_endpoint_wrapper + async def export( + entity_query: Annotated[EntityQuery, Depends(resolver.query)], + user_api_key_dict: Annotated[UserAPIKeyAuth, Depends(user_api_key_auth)], + repository: Annotated[DailyActivityRepository, Depends(get_daily_activity_repository)], + prisma_client: Annotated[PrismaClient, Depends(get_daily_activity_prisma_client)], + export_type: Annotated[ExportType, Query()] = ExportType.DAILY, + file_format: Annotated[Literal["csv", "json"], Query(alias="format")] = "csv", + ) -> StreamingResponse: + try: + resolved: ResolvedScope = await _resolved_scope( + resolver, + entity_query, + user_api_key_dict, + prisma_client, + user_aggregated=False, + ) + rows: Final = repository.export_rows(resolved.scope, export_type=export_type) + first_row: Final = await anext(rows, None) + return StreamingResponse( + _stream_export_rows(first_row, rows, file_format), + media_type="text/csv" if file_format == "csv" else "application/json", + headers={ + "Cache-Control": "no-store", + "Content-Disposition": _content_disposition( + resolver.entity, + resolved.scope.start_date, + resolved.scope.end_date, + export_type, + file_format, + ), + }, + ) + except HTTPException: + raise + except Exception as exc: + verbose_proxy_logger.exception("Daily activity export failed: %s", exc) + raise HTTPException(status_code=500, detail={"error": f"Failed to fetch analytics: {exc}"}) + + router.add_api_route( + f"{prefix}/daily/activity/export", + export, + methods=["GET"], + name=resolver.operation_names["export"], + tags=list(resolver.tags), + dependencies=(Depends(user_api_key_auth),), + response_class=StreamingResponse, + responses={ + 200: { + "description": "Streamed daily activity export", + "content": { + "text/csv": {"schema": {"type": "string"}}, + "application/json": {"schema": {"type": "array", "items": {"type": "object"}}}, + }, + } + }, + include_in_schema=prefix != "/end_user", + ) + + +def _register_cache_leakage_route(router: APIRouter, resolver: EntityScopeResolver, prefix: str) -> None: + @management_endpoint_wrapper + async def cache_leakage_keys( + entity_query: Annotated[EntityQuery, Depends(resolver.query)], + user_api_key_dict: Annotated[UserAPIKeyAuth, Depends(user_api_key_auth)], + repository: Annotated[DailyActivityRepository, Depends(get_daily_activity_repository)], + prisma_client: Annotated[PrismaClient, Depends(get_daily_activity_prisma_client)], + limit: Annotated[ + int, Query(ge=1, le=constants.USAGE_CACHE_LEAKAGE_KEYS_MAX) + ] = constants.USAGE_CACHE_LEAKAGE_KEYS_DEFAULT, + ) -> CacheLeakageKeysResponse: + try: + resolved: ResolvedScope = await _resolved_scope( + resolver, + entity_query, + user_api_key_dict, + prisma_client, + user_aggregated=False, + ) + rows: tuple[KeySpendRow, ...] = await repository.cache_leakage_keys( + resolved.scope, + limit=limit, + ) + return CacheLeakageKeysResponse( + api_keys=await _key_activity_rows(repository, rows, resolved), + ) + except HTTPException: + raise + except Exception as exc: + verbose_proxy_logger.exception("Daily activity cache leakage keys failed: %s", exc) + raise HTTPException(status_code=500, detail={"error": f"Failed to fetch analytics: {exc}"}) + + router.add_api_route( + f"{prefix}/daily/activity/aggregated/cache_leakage_keys", + cache_leakage_keys, + methods=["GET"], + name=resolver.operation_names["cache_leakage_keys"], + tags=list(resolver.tags), + dependencies=(Depends(user_api_key_auth),), + response_model=CacheLeakageKeysResponse, + include_in_schema=prefix != "/end_user", + ) + + +def register_daily_activity_routes(router: APIRouter, resolver: EntityScopeResolver) -> None: + for prefix in resolver.route_prefixes: + _register_aggregated_route(router, resolver, prefix) + _register_key_page_route(router, resolver, prefix) + _register_search_route(router, resolver, prefix) + _register_model_top_keys_route(router, resolver, prefix) + _register_export_route(router, resolver, prefix) + if resolver.entity == "user": + _register_cache_leakage_route(router, resolver, prefix) + + +for _resolver in ( + USER_RESOLVER, + TEAM_RESOLVER, + TAG_RESOLVER, + ORGANIZATION_RESOLVER, + CUSTOMER_RESOLVER, + AGENT_RESOLVER, +): + register_daily_activity_routes(router, _resolver) diff --git a/litellm/proxy/management_endpoints/daily_activity_scopes.py b/litellm/proxy/management_endpoints/daily_activity_scopes.py new file mode 100644 index 00000000000..4ed3c680f15 --- /dev/null +++ b/litellm/proxy/management_endpoints/daily_activity_scopes.py @@ -0,0 +1,472 @@ +from collections.abc import Awaitable, Callable, Mapping, Sequence +from dataclasses import dataclass +from types import MappingProxyType +from typing import Final, Literal + +from fastapi import Query + +from litellm.proxy._types import UserAPIKeyAuth +from litellm.proxy.agent_endpoints.endpoints import resolve_agent_daily_activity_scope +from litellm.proxy.management_endpoints.common_daily_activity import ScopeDenied +from litellm.proxy.management_endpoints.customer_endpoints import ( + customer_daily_activity_is_admin, + resolve_customer_daily_activity_scope, +) +from litellm.proxy.management_endpoints.internal_user_endpoints import resolve_user_daily_activity_entity_ids +from litellm.proxy.management_endpoints.organization_endpoints import resolve_organization_daily_activity_scope +from litellm.proxy.management_endpoints.tag_management_endpoints import get_tag_daily_activity_api_key_filter +from litellm.proxy.management_endpoints.team_endpoints import resolve_team_daily_activity_scope +from litellm.proxy.utils import PrismaClient +from litellm.types.repositories.daily_activity import DailyActivityScope, DailyActivityTable + + +@dataclass(frozen=True, slots=True) +class EntityQuery: + entity_ids: tuple[str, ...] | None + exclude_entity_ids: tuple[str, ...] + api_key: str | None + start_date: str | None + end_date: str | None + model: str | None + timezone_offset_minutes: int | None + include_current_utc_day: bool + + +@dataclass(frozen=True, slots=True) +class ResolvedScope: + scope: DailyActivityScope + entity_metadata: Mapping[str, dict[str, object]] | None + + +Entity = Literal["user", "team", "tag", "organization", "customer", "agent"] +EntityScopeResolution = ResolvedScope | ScopeDenied +EntityScopeQuery = Callable[..., EntityQuery] +EntityScopeResolve = Callable[[UserAPIKeyAuth, EntityQuery, PrismaClient], Awaitable[EntityScopeResolution]] +OperationNames = Mapping[str, str] + + +@dataclass(frozen=True, slots=True) +class EntityScopeResolver: + entity: Entity + table: DailyActivityTable + entity_id_field: str + route_prefixes: tuple[str, ...] + tags: tuple[str, ...] + query: EntityScopeQuery + resolve: EntityScopeResolve + include_entity_breakdown: bool + operation_names: OperationNames + + +def _query_ids(value: str | None) -> tuple[str, ...] | None: + return tuple(value.split(",")) if value else None + + +def _query_excluded_ids(value: str | None) -> tuple[str, ...]: + return tuple(value.split(",")) if value else () + + +def _build_scope( + resolver: EntityScopeResolver, + query: EntityQuery, + entity_ids: Sequence[str] | None, + exclude_entity_ids: Sequence[str], + api_key_filter: str | Sequence[str] | None, + entity_metadata: Mapping[str, dict[str, object]] | None, +) -> ResolvedScope: + start_date: Final[str] = query.start_date or "" + end_date: Final[str] = query.end_date or "" + api_keys: Final[tuple[str, ...] | None] = ( + None + if api_key_filter is None or api_key_filter == "" + else (api_key_filter,) + if isinstance(api_key_filter, str) + else tuple(api_key_filter) + ) + return ResolvedScope( + scope=DailyActivityScope( + table=resolver.table, + entity_id_field=resolver.entity_id_field, + entity_ids=None if entity_ids is None else tuple(entity_ids), + exclude_entity_ids=tuple(exclude_entity_ids), + api_keys=api_keys, + start_date=start_date, + end_date=end_date, + model=query.model, + timezone_offset_minutes=query.timezone_offset_minutes, + include_current_utc_day=query.include_current_utc_day, + ), + entity_metadata=entity_metadata, + ) + + +async def _resolve_user( + user_api_key_dict: UserAPIKeyAuth, query: EntityQuery, prisma_client: PrismaClient +) -> EntityScopeResolution: + entity_ids: Final = resolve_user_daily_activity_entity_ids( + user_id=query.entity_ids[0] if query.entity_ids is not None else None, + user_api_key_dict=user_api_key_dict, + ) + if isinstance(entity_ids, ScopeDenied): + return entity_ids + return _build_scope( + USER_RESOLVER, + query, + entity_ids, + query.exclude_entity_ids, + query.api_key, + None, + ) + + +async def _resolve_team( + user_api_key_dict: UserAPIKeyAuth, query: EntityQuery, prisma_client: PrismaClient +) -> EntityScopeResolution: + from litellm.proxy.proxy_server import proxy_logging_obj, user_api_key_cache + + team_scope: Final = await resolve_team_daily_activity_scope( + team_ids=",".join(query.entity_ids) if query.entity_ids is not None else None, + exclude_team_ids=",".join(query.exclude_entity_ids) if query.exclude_entity_ids else None, + api_key=query.api_key, + user_api_key_dict=user_api_key_dict, + prisma_client=prisma_client, + user_api_key_cache=user_api_key_cache, + proxy_logging_obj=proxy_logging_obj, + ) + return _build_scope( + TEAM_RESOLVER, + query, + team_scope.team_ids, + team_scope.exclude_team_ids or (), + team_scope.api_key_filter, + team_scope.team_alias_metadata, + ) + + +async def _resolve_tag( + user_api_key_dict: UserAPIKeyAuth, query: EntityQuery, prisma_client: PrismaClient +) -> EntityScopeResolution: + api_key_filter: Final = await get_tag_daily_activity_api_key_filter( + prisma_client=prisma_client, + user_api_key_dict=user_api_key_dict, + requested_api_key=query.api_key, + ) + return _build_scope( + TAG_RESOLVER, + query, + query.entity_ids, + query.exclude_entity_ids, + api_key_filter, + None, + ) + + +async def _resolve_organization( + user_api_key_dict: UserAPIKeyAuth, query: EntityQuery, prisma_client: PrismaClient +) -> EntityScopeResolution: + org_scope: Final = await resolve_organization_daily_activity_scope( + organization_ids=query.entity_ids, + prisma_client=prisma_client, + user_api_key_dict=user_api_key_dict, + ) + return _build_scope( + ORGANIZATION_RESOLVER, + query, + org_scope.organization_ids, + query.exclude_entity_ids, + query.api_key, + org_scope.organization_metadata, + ) + + +async def _resolve_customer( + user_api_key_dict: UserAPIKeyAuth, query: EntityQuery, prisma_client: PrismaClient +) -> EntityScopeResolution: + if not customer_daily_activity_is_admin(user_api_key_dict): + return ScopeDenied(403, f"Admin-only endpoint. Your user role={user_api_key_dict.user_role}") + customer_scope: Final = await resolve_customer_daily_activity_scope( + end_user_ids=query.entity_ids, + prisma_client=prisma_client, + ) + return _build_scope( + CUSTOMER_RESOLVER, + query, + customer_scope.end_user_ids, + query.exclude_entity_ids, + query.api_key, + customer_scope.end_user_metadata, + ) + + +async def _resolve_agent( + user_api_key_dict: UserAPIKeyAuth, query: EntityQuery, prisma_client: PrismaClient +) -> EntityScopeResolution: + agent_scope: Final = await resolve_agent_daily_activity_scope( + agent_ids=query.entity_ids, + user_api_key_dict=user_api_key_dict, + prisma_client=prisma_client, + ) + return _build_scope( + AGENT_RESOLVER, + query, + agent_scope.agent_ids, + query.exclude_entity_ids, + query.api_key, + agent_scope.agent_metadata, + ) + + +def _user_query( + start_date: str | None = Query(default=None, description="Start date in YYYY-MM-DD format"), + end_date: str | None = Query(default=None, description="End date in YYYY-MM-DD format"), + model: str | None = Query(default=None, description="Filter by specific model"), + api_key: str | None = Query(default=None, description="Filter by specific API key"), + user_id: str | None = Query( + default=None, + description="Filter by specific user ID. Admins can filter by any user or omit for global view. " + "Non-admins must provide their own user_id.", + ), + timezone: int | None = Query( + default=None, + description="Timezone offset in minutes from UTC (e.g., 480 for PST). " + "Matches JavaScript's Date.getTimezoneOffset() convention.", + ), + include_current_utc_day: bool = Query( + default=False, + description="When the range ends on the caller's current local day, extend it to " + "today's UTC bucket so spend written after the caller's local midnight (in UTC " + "terms) is included. Requires the timezone parameter. Historical ranges are " + "never extended.", + ), +) -> EntityQuery: + return EntityQuery( + entity_ids=(user_id,) if user_id is not None else None, + exclude_entity_ids=(), + api_key=api_key, + start_date=start_date, + end_date=end_date, + model=model, + timezone_offset_minutes=timezone, + include_current_utc_day=include_current_utc_day, + ) + + +def _team_query( + team_ids: str | None = None, + start_date: str | None = None, + end_date: str | None = None, + model: str | None = None, + api_key: str | None = None, + exclude_team_ids: str | None = None, + timezone: int | None = None, +) -> EntityQuery: + return EntityQuery( + entity_ids=_query_ids(team_ids), + exclude_entity_ids=_query_excluded_ids(exclude_team_ids), + api_key=api_key, + start_date=start_date, + end_date=end_date, + model=model, + timezone_offset_minutes=timezone, + include_current_utc_day=False, + ) + + +def _tag_query( + start_date: str | None = None, + end_date: str | None = None, + model: str | None = None, + api_key: str | None = None, + tags: str | None = None, + timezone: int | None = None, +) -> EntityQuery: + return EntityQuery( + entity_ids=_query_ids(tags), + exclude_entity_ids=(), + api_key=api_key, + start_date=start_date, + end_date=end_date, + model=model, + timezone_offset_minutes=timezone, + include_current_utc_day=False, + ) + + +def _organization_query( + organization_ids: str | None = None, + start_date: str | None = None, + end_date: str | None = None, + model: str | None = None, + api_key: str | None = None, + exclude_organization_ids: str | None = None, + timezone: int | None = None, +) -> EntityQuery: + return EntityQuery( + entity_ids=_query_ids(organization_ids), + exclude_entity_ids=_query_excluded_ids(exclude_organization_ids), + api_key=api_key, + start_date=start_date, + end_date=end_date, + model=model, + timezone_offset_minutes=timezone, + include_current_utc_day=False, + ) + + +def _customer_query( + end_user_ids: str | None = None, + start_date: str | None = None, + end_date: str | None = None, + model: str | None = None, + api_key: str | None = None, + exclude_end_user_ids: str | None = None, + timezone: int | None = None, +) -> EntityQuery: + return EntityQuery( + entity_ids=_query_ids(end_user_ids), + exclude_entity_ids=_query_excluded_ids(exclude_end_user_ids), + api_key=api_key, + start_date=start_date, + end_date=end_date, + model=model, + timezone_offset_minutes=timezone, + include_current_utc_day=False, + ) + + +def _agent_query( + agent_ids: str | None = None, + start_date: str | None = None, + end_date: str | None = None, + model: str | None = None, + api_key: str | None = None, + exclude_agent_ids: str | None = None, + timezone: int | None = None, +) -> EntityQuery: + return EntityQuery( + entity_ids=_query_ids(agent_ids), + exclude_entity_ids=_query_excluded_ids(exclude_agent_ids), + api_key=api_key, + start_date=start_date, + end_date=end_date, + model=model, + timezone_offset_minutes=timezone, + include_current_utc_day=False, + ) + + +USER_RESOLVER = EntityScopeResolver( + entity="user", + table=DailyActivityTable.USER, + entity_id_field="user_id", + route_prefixes=("/user",), + tags=("Budget & Spend Tracking", "Internal User management"), + query=_user_query, + resolve=_resolve_user, + include_entity_breakdown=False, + operation_names=MappingProxyType( + { + "aggregated": "get_user_daily_activity_aggregated", + "search": "get_user_daily_activity_aggregated_search", + "key_page": "get_user_daily_activity_aggregated_keys", + "model_top_keys": "get_user_daily_activity_model_top_keys", + "export": "get_user_daily_activity_export", + "cache_leakage_keys": "get_user_daily_activity_cache_leakage_keys", + } + ), +) +TEAM_RESOLVER = EntityScopeResolver( + entity="team", + table=DailyActivityTable.TEAM, + entity_id_field="team_id", + route_prefixes=("/team",), + tags=("team management",), + query=_team_query, + resolve=_resolve_team, + include_entity_breakdown=True, + operation_names=MappingProxyType( + { + "aggregated": "get_team_daily_activity_aggregated", + "search": "get_team_daily_activity_aggregated_search", + "key_page": "get_team_daily_activity_aggregated_keys", + "model_top_keys": "get_team_daily_activity_model_top_keys", + "export": "get_team_daily_activity_export", + } + ), +) +TAG_RESOLVER = EntityScopeResolver( + entity="tag", + table=DailyActivityTable.TAG, + entity_id_field="tag", + route_prefixes=("/tag",), + tags=("tag management",), + query=_tag_query, + resolve=_resolve_tag, + include_entity_breakdown=True, + operation_names=MappingProxyType( + { + "aggregated": "get_tag_daily_activity_aggregated", + "search": "get_tag_daily_activity_aggregated_search", + "key_page": "get_tag_daily_activity_aggregated_keys", + "model_top_keys": "get_tag_daily_activity_model_top_keys", + "export": "get_tag_daily_activity_export", + } + ), +) +ORGANIZATION_RESOLVER = EntityScopeResolver( + entity="organization", + table=DailyActivityTable.ORGANIZATION, + entity_id_field="organization_id", + route_prefixes=("/organization",), + tags=("organization management",), + query=_organization_query, + resolve=_resolve_organization, + include_entity_breakdown=True, + operation_names=MappingProxyType( + { + "aggregated": "get_organization_daily_activity_aggregated", + "search": "get_organization_daily_activity_aggregated_search", + "key_page": "get_organization_daily_activity_aggregated_keys", + "model_top_keys": "get_organization_daily_activity_model_top_keys", + "export": "get_organization_daily_activity_export", + } + ), +) +CUSTOMER_RESOLVER = EntityScopeResolver( + entity="customer", + table=DailyActivityTable.CUSTOMER, + entity_id_field="end_user_id", + route_prefixes=("/customer", "/end_user"), + tags=("Customer Management",), + query=_customer_query, + resolve=_resolve_customer, + include_entity_breakdown=True, + operation_names=MappingProxyType( + { + "aggregated": "get_customer_daily_activity_aggregated", + "search": "get_customer_daily_activity_aggregated_search", + "key_page": "get_customer_daily_activity_aggregated_keys", + "model_top_keys": "get_customer_daily_activity_model_top_keys", + "export": "get_customer_daily_activity_export", + } + ), +) +AGENT_RESOLVER = EntityScopeResolver( + entity="agent", + table=DailyActivityTable.AGENT, + entity_id_field="agent_id", + route_prefixes=("/agent",), + tags=("Agent Management",), + query=_agent_query, + resolve=_resolve_agent, + include_entity_breakdown=True, + operation_names=MappingProxyType( + { + "aggregated": "get_agent_daily_activity_aggregated", + "search": "get_agent_daily_activity_aggregated_search", + "key_page": "get_agent_daily_activity_aggregated_keys", + "model_top_keys": "get_agent_daily_activity_model_top_keys", + "export": "get_agent_daily_activity_export", + } + ), +) diff --git a/litellm/proxy/management_endpoints/internal_user_endpoints.py b/litellm/proxy/management_endpoints/internal_user_endpoints.py index 1fd63c6d456..04b8ec56ae2 100644 --- a/litellm/proxy/management_endpoints/internal_user_endpoints.py +++ b/litellm/proxy/management_endpoints/internal_user_endpoints.py @@ -54,10 +54,9 @@ from litellm.proxy.hooks.user_management_event_hooks import UserManagementEventH from litellm.proxy.management.teams.access import is_team_admin from litellm.proxy.management_endpoints.common_daily_activity import ( DailySpendRecord, - daily_activity_repository, - daily_activity_scope, + ScopeDenied, get_daily_activity, - get_daily_activity_aggregated, + raise_public, ) from litellm.proxy.management_endpoints.common_utils import ( _user_has_admin_view, @@ -2864,6 +2863,18 @@ async def ui_view_users( # Using shared metric helper implementations from common_daily_activity +def resolve_user_daily_activity_entity_ids( + *, user_id: str | None, user_api_key_dict: UserAPIKeyAuth +) -> tuple[str, ...] | None | ScopeDenied: + if _user_has_admin_view(user_api_key_dict): + return (user_id,) if user_id is not None else None + + caller_user_id: Final = require_caller_user_id_for_non_admin(user_api_key_dict) + if user_id is not None and user_id != caller_user_id: + return ScopeDenied(403, "Non-admin users can only view their own spend data.") + return (caller_user_id,) + + async def _resolve_user_email_metadata( prisma_client: "PrismaClient", records: Sequence[DailySpendRecord] ) -> dict[str, dict]: @@ -2958,20 +2969,13 @@ async def get_user_daily_activity( ) try: - is_admin: Final = _user_has_admin_view(user_api_key_dict) - - if is_admin: - entity_id = user_id # None means global view, otherwise filter by user - else: - caller_user_id: Final = require_caller_user_id_for_non_admin(user_api_key_dict) - if user_id is None: - user_id = caller_user_id - if user_id != caller_user_id: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail={"error": "Non-admin users can only view their own spend data."}, - ) - entity_id = user_id + resolved_entity_ids: Final = resolve_user_daily_activity_entity_ids( + user_id=user_id, + user_api_key_dict=user_api_key_dict, + ) + if isinstance(resolved_entity_ids, ScopeDenied): + raise_public(resolved_entity_ids) + entity_id: Final[str | None] = resolved_entity_ids[0] if resolved_entity_ids is not None else None return await get_daily_activity( prisma_client=prisma_client, @@ -2998,112 +3002,3 @@ async def get_user_daily_activity( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail={"error": f"Failed to fetch analytics: {e}"}, ) - - -@router.get( - "/user/daily/activity/aggregated", - tags=["Budget & Spend Tracking", "Internal User management"], - dependencies=[Depends(user_api_key_auth)], - response_model=SpendAnalyticsPaginatedResponse, -) -@management_endpoint_wrapper -async def get_user_daily_activity_aggregated( - start_date: str | None = fastapi.Query( - default=None, - description="Start date in YYYY-MM-DD format", - ), - end_date: str | None = fastapi.Query( - default=None, - description="End date in YYYY-MM-DD format", - ), - model: str | None = fastapi.Query( - default=None, - description="Filter by specific model", - ), - api_key: str | None = fastapi.Query( - default=None, - description="Filter by specific API key", - ), - user_id: str | None = fastapi.Query( - default=None, - description="Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id.", - ), - timezone: int | None = fastapi.Query( - default=None, - description="Timezone offset in minutes from UTC (e.g., 480 for PST). " - "Matches JavaScript's Date.getTimezoneOffset() convention.", - ), - include_current_utc_day: bool = fastapi.Query( - default=False, - description="When the range ends on the caller's current local day, extend it to " - "today's UTC bucket so spend written after the caller's local midnight (in UTC " - "terms) is included. Requires the timezone parameter. Historical ranges are " - "never extended.", - ), - user_api_key_dict: UserAPIKeyAuth = Depends(user_api_key_auth), -) -> SpendAnalyticsPaginatedResponse: - """ - Aggregated analytics for a user's daily activity without pagination. - Returns the same response shape as the paginated endpoint with page metadata set to single-page. - - Reads daily spend records that only ever accumulate and are never affected by budget - resets. Their total can legitimately exceed the `spend` field returned by - `/v2/user/info`, which is a running budget counter that every budget reset sets back - to zero (or to the overage above `max_budget` when `budget_rollover` is enabled). - """ - from litellm.proxy.proxy_server import prisma_client - - if prisma_client is None: - raise HTTPException( - status_code=500, - detail={"error": CommonProxyErrors.db_not_connected_error.value}, - ) - - if start_date is None or end_date is None: - raise HTTPException( - status_code=status.HTTP_400_BAD_REQUEST, - detail={"error": "Please provide start_date and end_date"}, - ) - - try: - is_admin: Final = _user_has_admin_view(user_api_key_dict) - - if is_admin: - entity_id = user_id # None means global view, otherwise filter by user - else: - caller_user_id: Final = require_caller_user_id_for_non_admin(user_api_key_dict) - if user_id is None: - user_id = caller_user_id - if user_id != caller_user_id: - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail={"error": "Non-admin users can only view their own spend data."}, - ) - entity_id = user_id - - repository: Final = daily_activity_repository(prisma_client) - scope: Final = daily_activity_scope( - "litellm_dailyuserspend", - "user_id", - entity_id, - None, - api_key, - start_date, - end_date, - model, - timezone, - include_current_utc_day, - ) - return await get_daily_activity_aggregated( - repository, - scope, - ) - - except HTTPException: - raise - except Exception as e: - verbose_proxy_logger.exception("/user/daily/activity/aggregated: Exception occured - %s", e) - raise HTTPException( - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - detail={"error": f"Failed to fetch analytics: {e}"}, - ) diff --git a/litellm/proxy/management_endpoints/organization_endpoints.py b/litellm/proxy/management_endpoints/organization_endpoints.py index 24bbd2b4b1f..c8ae7af41db 100644 --- a/litellm/proxy/management_endpoints/organization_endpoints.py +++ b/litellm/proxy/management_endpoints/organization_endpoints.py @@ -14,10 +14,12 @@ Endpoints for /organization operations #### ORGANIZATION MANAGEMENT #### from collections.abc import Mapping, Sequence +from types import MappingProxyType from typing import ( TYPE_CHECKING, Annotated, Final, + NamedTuple, Protocol, cast, # noqa: TID251 # prisma types Json columns as fields.Json but reads back plain python values overload, @@ -62,6 +64,7 @@ from litellm.proxy.management_helpers.utils import ( ) from litellm.proxy.utils import PrismaClient, ProxyLogging from litellm.repositories.budget_repository import BudgetRepository +from litellm.repositories.chunked_in import find_many_in from litellm.repositories.object_permission_repository import ObjectPermissionRepository from litellm.repositories.organization_repository import OrganizationRepository from litellm.repositories.table_repositories import OrganizationMembershipRepository @@ -583,43 +586,23 @@ async def get_organization_daily_activity( detail={"error": CommonProxyErrors.db_not_connected_error.value}, ) - # Parse comma-separated ids - org_ids_list = organization_ids.split(",") if organization_ids else None + org_ids: Final = tuple(organization_ids.split(",")) if organization_ids else None exclude_org_ids_list: list[str] | None = None if exclude_organization_ids: exclude_org_ids_list = exclude_organization_ids.split(",") if exclude_organization_ids else None - # Restrict non-proxy-admins to only organizations where they are org_admin - if not _user_has_admin_view(user_api_key_dict): - memberships: Final = await _table(OrganizationMembershipRepository(prisma_client)).find_many( - where={"user_id": user_api_key_dict.user_id} - ) - admin_org_ids = [m.organization_id for m in memberships if m.user_role == LitellmUserRoles.ORG_ADMIN.value] - if org_ids_list is None: - # Default to orgs where user is org_admin - org_ids_list = admin_org_ids - else: - # Ensure user is org_admin for all requested orgs - for org_id in org_ids_list: - if org_id not in admin_org_ids: - raise HTTPException( - status_code=403, - detail={"error": f"User is not org_admin for Organization= {org_id}."}, - ) + org_scope: Final = await resolve_organization_daily_activity_scope( + organization_ids=org_ids, + prisma_client=prisma_client, + user_api_key_dict=user_api_key_dict, + ) - # Fetch organization aliases for metadata - where_condition: Final = _STR_OBJECT_DICT_ADAPTER.validate_python({}) - if org_ids_list is not None: - where_condition["organization_id"] = {"in": list(org_ids_list)} - org_aliases: Final = await _table(OrganizationRepository(prisma_client)).find_many(where=where_condition) - - # Query daily activity for organizations return await get_daily_activity( prisma_client=prisma_client, table_name="litellm_dailyorganizationspend", entity_id_field="organization_id", - entity_id=org_ids_list, - entity_metadata_field={o.organization_id: {"organization_alias": o.organization_alias} for o in org_aliases}, + entity_id=None if org_scope.organization_ids is None else list(org_scope.organization_ids), + entity_metadata_field=org_scope.organization_metadata, exclude_entity_ids=exclude_org_ids_list, start_date=start_date, end_date=end_date, @@ -630,6 +613,56 @@ async def get_organization_daily_activity( ) +class _OrganizationDailyActivityScope(NamedTuple): + organization_ids: tuple[str, ...] | None + organization_metadata: Mapping[str, dict[str, object]] + + +async def resolve_organization_daily_activity_scope( + *, + organization_ids: tuple[str, ...] | None, + prisma_client: PrismaClient, + user_api_key_dict: UserAPIKeyAuth, +) -> _OrganizationDailyActivityScope: + is_admin: Final = _user_has_admin_view(user_api_key_dict) + memberships: Final = ( + await _table(OrganizationMembershipRepository(prisma_client)).find_many( + where={"user_id": user_api_key_dict.user_id} + ) + if not is_admin + else () + ) + admin_organization_ids: Final = tuple( + membership.organization_id + for membership in memberships + if membership.user_role == LitellmUserRoles.ORG_ADMIN.value + ) + if not is_admin and organization_ids is not None: + for organization_id in organization_ids: + if organization_id not in admin_organization_ids: + raise HTTPException( + status_code=403, + detail={"error": f"User is not org_admin for Organization= {organization_id}."}, + ) + resolved_organization_ids: Final[tuple[str, ...] | None] = ( + organization_ids if is_admin or organization_ids is not None else admin_organization_ids + ) + + organization_table: Final = _table(OrganizationRepository(prisma_client)) + organization_rows: Final = ( + await find_many_in(organization_table, "organization_id", resolved_organization_ids) + if resolved_organization_ids is not None + else await organization_table.find_many(where={}) + ) + metadata: Final = MappingProxyType( + { + organization.organization_id: {"organization_alias": organization.organization_alias} + for organization in organization_rows + } + ) + return _OrganizationDailyActivityScope(resolved_organization_ids, metadata) + + async def _set_object_permission( data: NewOrganizationRequest, prisma_client: PrismaClient | None, diff --git a/litellm/proxy/management_endpoints/tag_management_endpoints.py b/litellm/proxy/management_endpoints/tag_management_endpoints.py index ab33d4bd766..5bf16379d05 100644 --- a/litellm/proxy/management_endpoints/tag_management_endpoints.py +++ b/litellm/proxy/management_endpoints/tag_management_endpoints.py @@ -190,7 +190,7 @@ async def _get_tag_list_scope( return {"api_key": {"in": scoped_api_keys}} -async def _get_tag_daily_activity_api_key_filter( +async def get_tag_daily_activity_api_key_filter( prisma_client: "PrismaClient", user_api_key_dict: UserAPIKeyAuth, requested_api_key: str | None, @@ -757,7 +757,7 @@ async def get_tag_daily_activity( # Convert comma-separated tags string to list if provided tag_list: Final = tags.split(",") if tags else None - scoped_api_key_filter: Final = await _get_tag_daily_activity_api_key_filter( + scoped_api_key_filter: Final = await get_tag_daily_activity_api_key_filter( prisma_client=prisma_client, user_api_key_dict=user_api_key_dict, requested_api_key=api_key, diff --git a/litellm/proxy/management_endpoints/team_endpoints.py b/litellm/proxy/management_endpoints/team_endpoints.py index 040b27b5802..88d51729c13 100644 --- a/litellm/proxy/management_endpoints/team_endpoints.py +++ b/litellm/proxy/management_endpoints/team_endpoints.py @@ -124,11 +124,6 @@ from litellm.proxy.hooks.model_max_budget_limiter import ( ) from litellm.proxy.management.teams.access import TEAM_OR_ORG_ADMIN, TeamRole, is_team_admin, team_access_denied from litellm.proxy.management.teams.dependencies import get_team_access -from litellm.proxy.management_endpoints.common_daily_activity import ( - daily_activity_repository, - daily_activity_scope, - get_daily_activity_aggregated, -) from litellm.proxy.management_endpoints.common_utils import ( _check_disable_global_guardrails_caller_permission, _check_passthrough_routes_caller_permission, @@ -6523,7 +6518,7 @@ class _TeamDailyActivityScope(NamedTuple): api_key_filter: str | list[str] | None # mutable-ok: downstream daily-activity signatures take str | list unions -async def _resolve_team_daily_activity_scope( +async def resolve_team_daily_activity_scope( *, team_ids: str | None, exclude_team_ids: str | None, @@ -6606,11 +6601,14 @@ async def _resolve_team_daily_activity_scope( user_api_keys = [key.token for key in user_keys if key.token] # If user has no API keys, return empty result if not user_api_keys: - user_api_keys = [""] # Use empty string to ensure no matches + user_api_keys = [] - # If api_key parameter is provided, use it; otherwise use user_api_keys if set - final_api_key_filter: str | list[str] | None = api_key - if final_api_key_filter is None and user_api_keys is not None: + final_api_key_filter: str | list[str] | None + if user_api_keys is None: + final_api_key_filter = api_key + elif api_key: + final_api_key_filter = api_key if api_key in user_api_keys else [] + else: final_api_key_filter = user_api_keys return _TeamDailyActivityScope( @@ -6661,7 +6659,7 @@ async def get_team_daily_activity( if prisma_client is None: raise _daily_activity_error(status_code=500, message=CommonProxyErrors.db_not_connected_error.value) - scope: Final = await _resolve_team_daily_activity_scope( + scope: Final = await resolve_team_daily_activity_scope( team_ids=team_ids, exclude_team_ids=exclude_team_ids, api_key=api_key, @@ -6690,7 +6688,7 @@ async def get_team_daily_activity( _MAX_AGGREGATED_RANGE_DAYS: Final = 400 -def _aggregated_date_range_error(start_date: str | None, end_date: str | None) -> str | None: +def aggregated_date_range_error(start_date: str | None, end_date: str | None) -> str | None: """The aggregated endpoint has no pagination to bound its work, so malformed dates and ranges wider than the UI ever requests are rejected before querying.""" if start_date is None or end_date is None: @@ -6707,82 +6705,6 @@ def _aggregated_date_range_error(start_date: str | None, end_date: str | None) - return None -@router.get( - "/team/daily/activity/aggregated", - response_model=SpendAnalyticsPaginatedResponse, - tags=["team management"], -) -async def get_team_daily_activity_aggregated( - user_api_key_dict: Annotated[UserAPIKeyAuth, Depends(user_api_key_auth)], - team_ids: str | None = None, - start_date: str | None = None, - end_date: str | None = None, - model: str | None = None, - api_key: str | None = None, - exclude_team_ids: str | None = None, - timezone: int | None = None, -): - """ - Aggregated daily activity for teams without pagination, including per-team breakdown. - - One SQL GROUPING SETS pass returns every day in the range regardless of row - volume, so callers never reassemble pages. Same response shape as the - paginated endpoint with page metadata pinned to a single page. - - Args: - team_ids (Optional[str]): Comma-separated list of team IDs to filter by. If not provided, returns data for all teams. - start_date (Optional[str]): Start date for the activity period (YYYY-MM-DD). - end_date (Optional[str]): End date for the activity period (YYYY-MM-DD). - model (Optional[str]): Filter by model name. - api_key (Optional[str]): Filter by API key. - exclude_team_ids (Optional[str]): Comma-separated list of team IDs to exclude. - timezone (Optional[int]): Timezone offset in minutes from UTC, matching JavaScript's Date.getTimezoneOffset() convention. - Returns: - SpendAnalyticsPaginatedResponse: Response containing all daily activity data for the range. - """ - from litellm.proxy.proxy_server import ( - prisma_client, - proxy_logging_obj, - user_api_key_cache, - ) - - if prisma_client is None: - raise _daily_activity_error(status_code=500, message=CommonProxyErrors.db_not_connected_error.value) - - range_error: Final = _aggregated_date_range_error(start_date, end_date) - if range_error is not None: - raise _daily_activity_error(status_code=400, message=range_error) - - scope: Final = await _resolve_team_daily_activity_scope( - team_ids=team_ids, - exclude_team_ids=exclude_team_ids, - api_key=api_key, - user_api_key_dict=user_api_key_dict, - prisma_client=prisma_client, - user_api_key_cache=user_api_key_cache, - proxy_logging_obj=proxy_logging_obj, - ) - - repository: Final = daily_activity_repository(prisma_client) - activity_scope: Final = daily_activity_scope( - "litellm_dailyteamspend", - "team_id", - scope.team_ids, - scope.exclude_team_ids, - scope.api_key_filter, - start_date, - end_date, - model, - timezone, - ) - return await get_daily_activity_aggregated( - repository, - activity_scope, - entity_metadata_field=scope.team_alias_metadata, - include_entity_breakdown=True, - ) - - def _team_user_spend_sql(*, team_count: int, restrict_to_user: bool) -> str: team_placeholders: Final = ", ".join(f"${i}" for i in range(3, 3 + team_count)) user_clause: Final = f' AND sl."user" = ${3 + team_count}' if restrict_to_user else "" @@ -6850,14 +6772,14 @@ async def get_team_spend_by_user( if prisma_client is None: raise _daily_activity_error(status_code=500, message=CommonProxyErrors.db_not_connected_error.value) - range_error: Final = _aggregated_date_range_error(start_date, end_date) + range_error: Final = aggregated_date_range_error(start_date, end_date) if range_error is not None or start_date is None or end_date is None: raise _daily_activity_error(status_code=400, message=range_error or "Please provide start_date and end_date") if not team_ids: raise _daily_activity_error(status_code=400, message="Please provide team_ids") - scope: Final = await _resolve_team_daily_activity_scope( + scope: Final = await resolve_team_daily_activity_scope( team_ids=team_ids, exclude_team_ids=None, api_key=None, diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 9abf949ec1e..9282f216a52 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -604,6 +604,7 @@ from litellm.proxy.management_endpoints.cost_tracking_settings import ( from litellm.proxy.management_endpoints.customer_endpoints import ( router as customer_router, ) +from litellm.proxy.management_endpoints.daily_activity_routes import router as daily_activity_router from litellm.proxy.management_endpoints.fallback_management_endpoints import ( router as fallback_management_router, ) @@ -19951,6 +19952,7 @@ app.include_router(pass_through_router) app.include_router(health_router) app.include_router(key_management_router) app.include_router(internal_user_router) +app.include_router(daily_activity_router) app.include_router(password_management_router) app.include_router(session_management_router) app.include_router(team_router) diff --git a/litellm/types/proxy/management_endpoints/common_daily_activity.py b/litellm/types/proxy/management_endpoints/common_daily_activity.py index 5f997945ec2..37804032569 100644 --- a/litellm/types/proxy/management_endpoints/common_daily_activity.py +++ b/litellm/types/proxy/management_endpoints/common_daily_activity.py @@ -124,6 +124,51 @@ class SpendAnalyticsPaginatedResponse(BaseModel): metadata: DailySpendMetadata = Field(default_factory=DailySpendMetadata) +class KeyActivityRow(BaseModel): + api_key: str + metrics: SpendMetrics + metadata: KeyMetadata + + +class KeySpendMetrics(BaseModel): + spend: float = 0.0 + prompt_tokens: int = 0 + completion_tokens: int = 0 + total_tokens: int = 0 + api_requests: int = 0 + successful_requests: int = 0 + failed_requests: int = 0 + cache_read_input_tokens: int = 0 + cache_creation_input_tokens: int = 0 + + +class KeySpendActivityRow(BaseModel): + api_key: str + metrics: KeySpendMetrics + metadata: KeyMetadata + + +class DailyActivityKeySearchResponse(BaseModel): + api_keys: list[KeyActivityRow] + + +class DailyActivityKeyPageResponse(BaseModel): + api_keys: list[KeySpendActivityRow] + total_api_keys: int + offset: int + limit: int + + +class ModelTopKeysResponse(BaseModel): + model: str + by_model_group: bool + api_keys: list[KeySpendActivityRow] + + +class CacheLeakageKeysResponse(BaseModel): + api_keys: list[KeySpendActivityRow] + + class LiteLLM_DailyUserSpend(BaseModel): id: str user_id: str diff --git a/terraform/provider/tools/endpointaudit/coverage_allowlist.txt b/terraform/provider/tools/endpointaudit/coverage_allowlist.txt index 99ed82dcad8..fe89257e83b 100644 --- a/terraform/provider/tools/endpointaudit/coverage_allowlist.txt +++ b/terraform/provider/tools/endpointaudit/coverage_allowlist.txt @@ -12,14 +12,34 @@ # Read-only analytics and spend reporting; observability, not Terraform-managed state GET /agent/daily/activity +GET /agent/daily/activity/aggregated +GET /agent/daily/activity/aggregated/keys +GET /agent/daily/activity/aggregated/model_top_keys +GET /agent/daily/activity/aggregated/search +GET /agent/daily/activity/export GET /customer/daily/activity +GET /customer/daily/activity/aggregated +GET /customer/daily/activity/aggregated/keys +GET /customer/daily/activity/aggregated/model_top_keys +GET /customer/daily/activity/aggregated/search +GET /customer/daily/activity/export GET /guardrails/usage/detail/{guardrail_id} GET /guardrails/usage/logs GET /guardrails/usage/overview GET /key/spend/report GET /organization/daily/activity +GET /organization/daily/activity/aggregated +GET /organization/daily/activity/aggregated/keys +GET /organization/daily/activity/aggregated/model_top_keys +GET /organization/daily/activity/aggregated/search +GET /organization/daily/activity/export GET /organization/spend/report GET /tag/daily/activity +GET /tag/daily/activity/aggregated +GET /tag/daily/activity/aggregated/keys +GET /tag/daily/activity/aggregated/model_top_keys +GET /tag/daily/activity/aggregated/search +GET /tag/daily/activity/export GET /tag/dau GET /tag/distinct GET /tag/mau @@ -28,10 +48,19 @@ GET /tag/user-agent/per-user-analytics GET /tag/wau GET /team/daily/activity GET /team/daily/activity/aggregated +GET /team/daily/activity/aggregated/keys +GET /team/daily/activity/aggregated/model_top_keys +GET /team/daily/activity/aggregated/search +GET /team/daily/activity/export GET /team/spend/by_user GET /team/spend/report GET /user/daily/activity GET /user/daily/activity/aggregated +GET /user/daily/activity/aggregated/keys +GET /user/daily/activity/aggregated/cache_leakage_keys +GET /user/daily/activity/aggregated/model_top_keys +GET /user/daily/activity/aggregated/search +GET /user/daily/activity/export GET /user/spend/report # Admin UI helper endpoints; serve UI forms and caller-scoped views, not desired state diff --git a/tests/code_coverage_tests/unbounded_in_baseline.txt b/tests/code_coverage_tests/unbounded_in_baseline.txt index 9acc92e2afd..0a95ebfc01f 100644 --- a/tests/code_coverage_tests/unbounded_in_baseline.txt +++ b/tests/code_coverage_tests/unbounded_in_baseline.txt @@ -11,7 +11,6 @@ litellm/proxy/_experimental/mcp_server/oauth2_flow_backfill.py backfill_null_oau litellm/proxy/_experimental/mcp_server/oauth2_flow_backfill.py backfill_null_oauth2_flows prisma server_id.in `server_ids` 0 litellm/proxy/_experimental/mcp_server/toolset_db.py list_mcp_toolsets prisma toolset_id.in `toolset_ids` 0 litellm/proxy/agent_endpoints/endpoints.py _attach_keys_to_agents prisma agent_id.in `agent_ids` 0 -litellm/proxy/agent_endpoints/endpoints.py get_agent_daily_activity prisma agent_id.in `list(agent_ids_list)` 0 litellm/proxy/agent_endpoints/endpoints.py get_agents prisma agent_id.in `agent_ids` 0 litellm/proxy/anthropic_endpoints/claude_code_endpoints/claude_code_skill_access.py SkillVisibility.where prisma name.in `sorted(self.granted)` 0 litellm/proxy/auth/auth_checks.py _fetch_uncached_model_access_group_budgets prisma access_group_name.in `list(uncached_groups)` 0 @@ -43,7 +42,6 @@ litellm/proxy/management_endpoints/common_utils.py _team_admin_can_invite_user p litellm/proxy/management_endpoints/common_utils.py _user_has_admin_privileges prisma team_id.in `user_obj.teams` 0 litellm/proxy/management_endpoints/customer_endpoints.py delete_end_user prisma user_id.in `data.user_ids` 0 litellm/proxy/management_endpoints/customer_endpoints.py delete_end_user prisma user_id.in `data.user_ids` 1 -litellm/proxy/management_endpoints/customer_endpoints.py get_customer_daily_activity prisma user_id.in `list(end_user_ids_list)` 0 litellm/proxy/management_endpoints/internal_user_endpoints.py _check_user_info_v2_access prisma team_id.in `caller_user.teams` 0 litellm/proxy/management_endpoints/internal_user_endpoints.py _resolve_user_email_metadata prisma user_id.in `list(user_ids)` 0 litellm/proxy/management_endpoints/internal_user_endpoints.py delete_user prisma created_by.in `data.user_ids` 0 @@ -73,7 +71,6 @@ litellm/proxy/management_endpoints/mcp_management_endpoints.py fetch_all_mcp_ser litellm/proxy/management_endpoints/model_access_group_management_endpoints.py update_deployments_with_access_group prisma model_name.in `model_names` 0 litellm/proxy/management_endpoints/model_management_endpoints.py delete_team_models prisma model_id.in `model_ids` 0 litellm/proxy/management_endpoints/organization_endpoints.py deprecated_info_organization prisma organization_id.in `data.organizations` 0 -litellm/proxy/management_endpoints/organization_endpoints.py get_organization_daily_activity prisma organization_id.in `list(org_ids_list)` 0 litellm/proxy/management_endpoints/organization_endpoints.py list_organization prisma organization_id.in `membership_org_ids` 0 litellm/proxy/management_endpoints/router_weights.py validate_router_settings_weights prisma model_id.in `list(deployment_ids)` 0 litellm/proxy/management_endpoints/session_endpoints.py revoke_ui_session_keys prisma token.in `revoked_tokens` 0 @@ -91,7 +88,7 @@ litellm/proxy/management_endpoints/team_endpoints.py _build_team_list_where_cond litellm/proxy/management_endpoints/team_endpoints.py _get_keys_count_by_team prisma team_id.in `page_team_ids` 0 litellm/proxy/management_endpoints/team_endpoints.py _hydrate_member_user_details prisma user_id.in `sorted(user_ids)` 0 litellm/proxy/management_endpoints/team_endpoints.py _resolve_existing_member_user_ids prisma user_id.in `sorted(requested_user_ids)` 0 -litellm/proxy/management_endpoints/team_endpoints.py _resolve_team_daily_activity_scope prisma team_id.in `list(team_ids_list)` 0 +litellm/proxy/management_endpoints/team_endpoints.py resolve_team_daily_activity_scope prisma team_id.in `list(team_ids_list)` 0 litellm/proxy/management_endpoints/team_endpoints.py _sweep_deleted_team_references prisma team_id.in `tuple(team_ids)` 0 litellm/proxy/management_endpoints/team_endpoints.py _sweep_deleted_team_references_tx prisma team_id.in `tuple(team_ids)` 0 litellm/proxy/management_endpoints/team_endpoints.py _team_member_delete prisma user_id.in `sorted(addressed_user_ids)` 0 diff --git a/tests/integration/spend/golden/daily_activity_team_aggregated.json b/tests/integration/spend/golden/daily_activity_team_aggregated.json new file mode 100644 index 00000000000..f434e767700 --- /dev/null +++ b/tests/integration/spend/golden/daily_activity_team_aggregated.json @@ -0,0 +1,1169 @@ +{ + "metadata": {"entity_total_api_keys":{"team-1":5}, + "api_key_limit": 100, + "has_more": false, + "page": 1, + "total_api_keys": 5, + "total_api_requests": 5, + "total_autorouter_savings_spend": 0.0, + "total_cache_creation_input_tokens": 0, + "total_cache_read_input_tokens": 6, + "total_completion_tokens": 10, + "total_compression_saved_tokens": 0, + "total_compression_savings_spend": 0.0, + "total_failed_requests": 0, + "total_flat_cost": 0.0, + "total_gateway_injected_caching_savings_spend": 0.0, + "total_pages": 1, + "total_prompt_caching_savings_spend": 0.0, + "total_prompt_tokens": 1014, + "total_response_time_ms": 0, + "total_spend": 1273.0, + "total_successful_requests": 5, + "total_timed_requests": 0, + "total_tokens": 1024 + }, + "results": [ + { + "breakdown": { + "api_keys": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "endpoints": { + "/v1/chat/completions": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + }, + "entities": { + "team-1": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": { + "team_alias": "Usage Team" + }, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + }, + "mcp_servers": {}, + "model_groups": { + "model-cache": { + "api_key_breakdown": { + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "model-popular": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 3, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 3, + "completion_tokens": 6, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 9, + "spend": 270.0, + "successful_requests": 3, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 15 + } + }, + "model-ptu": { + "api_key_breakdown": {}, + "metadata": {}, + "metrics": { + "api_requests": 0, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + "completion_tokens": 0, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 0, + "spend": 1000.0, + "successful_requests": 0, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 0 + } + }, + "model-target": { + "api_key_breakdown": { + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "models": { + "model-cache": { + "api_key_breakdown": { + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "model-popular": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 3, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 3, + "completion_tokens": 6, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 9, + "spend": 270.0, + "successful_requests": 3, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 15 + } + }, + "model-ptu": { + "api_key_breakdown": {}, + "metadata": {}, + "metrics": { + "api_requests": 0, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + "completion_tokens": 0, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 0, + "spend": 1000.0, + "successful_requests": 0, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 0 + } + }, + "model-target": { + "api_key_breakdown": { + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "providers": { + "provider-a": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + } + }, + "date": "2026-06-01", + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + ] +} diff --git a/tests/integration/spend/golden/daily_activity_team_paginated.json b/tests/integration/spend/golden/daily_activity_team_paginated.json new file mode 100644 index 00000000000..e56ebbffe55 --- /dev/null +++ b/tests/integration/spend/golden/daily_activity_team_paginated.json @@ -0,0 +1,1197 @@ +{ + "metadata": {"entity_total_api_keys":null, + "api_key_limit": null, + "has_more": false, + "page": 1, + "total_api_keys": null, + "total_api_requests": 5, + "total_autorouter_savings_spend": 0.0, + "total_cache_creation_input_tokens": 0, + "total_cache_read_input_tokens": 6, + "total_completion_tokens": 10, + "total_compression_saved_tokens": 0, + "total_compression_savings_spend": 0.0, + "total_failed_requests": 0, + "total_flat_cost": 0.0, + "total_gateway_injected_caching_savings_spend": 0.0, + "total_pages": 1, + "total_prompt_caching_savings_spend": 0.0, + "total_prompt_tokens": 1014, + "total_response_time_ms": 0, + "total_spend": 1273.0, + "total_successful_requests": 5, + "total_timed_requests": 0, + "total_tokens": 1024 + }, + "results": [ + { + "breakdown": { + "api_keys": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "endpoints": { + "/v1/chat/completions": { + "api_key_breakdown": { + "__ptu_flat_cost__": { + "metadata": { + "key_alias": null, + "key_exists": false, + "team_id": null, + "user_email": null, + "user_id": null + }, + "metrics": { + "api_requests": 0, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + "completion_tokens": 0, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 0, + "spend": 1000.0, + "successful_requests": 0, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 0 + } + }, + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + }, + "entities": { + "team-1": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": { + "team_alias": "Usage Team" + }, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + }, + "mcp_servers": {}, + "model_groups": { + "model-cache": { + "api_key_breakdown": { + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "model-popular": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 3, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 3, + "completion_tokens": 6, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 9, + "spend": 270.0, + "successful_requests": 3, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 15 + } + }, + "model-ptu": { + "api_key_breakdown": {}, + "metadata": {}, + "metrics": { + "api_requests": 0, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + "completion_tokens": 0, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 0, + "spend": 1000.0, + "successful_requests": 0, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 0 + } + }, + "model-target": { + "api_key_breakdown": { + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "models": { + "model-cache": { + "api_key_breakdown": { + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "model-popular": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 3, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 3, + "completion_tokens": 6, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 9, + "spend": 270.0, + "successful_requests": 3, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 15 + } + }, + "model-ptu": { + "api_key_breakdown": {}, + "metadata": {}, + "metrics": { + "api_requests": 0, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + "completion_tokens": 0, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 0, + "spend": 1000.0, + "successful_requests": 0, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 0 + } + }, + "model-target": { + "api_key_breakdown": { + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "providers": { + "provider-a": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + } + }, + "date": "2026-06-01", + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + ] +} diff --git a/tests/integration/spend/golden/daily_activity_user_aggregated.json b/tests/integration/spend/golden/daily_activity_user_aggregated.json new file mode 100644 index 00000000000..de1bbd63977 --- /dev/null +++ b/tests/integration/spend/golden/daily_activity_user_aggregated.json @@ -0,0 +1,1002 @@ +{ + "metadata": {"entity_total_api_keys":null, + "api_key_limit": 100, + "has_more": false, + "page": 1, + "total_api_keys": 5, + "total_api_requests": 5, + "total_autorouter_savings_spend": 0.0, + "total_cache_creation_input_tokens": 0, + "total_cache_read_input_tokens": 6, + "total_completion_tokens": 10, + "total_compression_saved_tokens": 0, + "total_compression_savings_spend": 0.0, + "total_failed_requests": 0, + "total_flat_cost": 0.0, + "total_gateway_injected_caching_savings_spend": 0.0, + "total_pages": 1, + "total_prompt_caching_savings_spend": 0.0, + "total_prompt_tokens": 1014, + "total_response_time_ms": 0, + "total_spend": 1273.0, + "total_successful_requests": 5, + "total_timed_requests": 0, + "total_tokens": 1024 + }, + "results": [ + { + "breakdown": { + "api_keys": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "endpoints": { + "/v1/chat/completions": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + }, + "entities": {}, + "mcp_servers": {}, + "model_groups": { + "model-cache": { + "api_key_breakdown": { + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "model-popular": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 3, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 3, + "completion_tokens": 6, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 9, + "spend": 270.0, + "successful_requests": 3, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 15 + } + }, + "model-ptu": { + "api_key_breakdown": {}, + "metadata": {}, + "metrics": { + "api_requests": 0, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + "completion_tokens": 0, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 0, + "spend": 1000.0, + "successful_requests": 0, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 0 + } + }, + "model-target": { + "api_key_breakdown": { + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "models": { + "model-cache": { + "api_key_breakdown": { + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "model-popular": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 3, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 3, + "completion_tokens": 6, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 9, + "spend": 270.0, + "successful_requests": 3, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 15 + } + }, + "model-ptu": { + "api_key_breakdown": {}, + "metadata": {}, + "metrics": { + "api_requests": 0, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + "completion_tokens": 0, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 0, + "spend": 1000.0, + "successful_requests": 0, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 0 + } + }, + "model-target": { + "api_key_breakdown": { + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "providers": { + "provider-a": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + } + }, + "date": "2026-06-01", + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + ] +} diff --git a/tests/integration/spend/golden/daily_activity_user_paginated.json b/tests/integration/spend/golden/daily_activity_user_paginated.json new file mode 100644 index 00000000000..b27bc405ebd --- /dev/null +++ b/tests/integration/spend/golden/daily_activity_user_paginated.json @@ -0,0 +1,1198 @@ +{ + "metadata": {"entity_total_api_keys":null, + "api_key_limit": null, + "has_more": false, + "page": 1, + "total_api_keys": null, + "total_api_requests": 5, + "total_autorouter_savings_spend": 0.0, + "total_cache_creation_input_tokens": 0, + "total_cache_read_input_tokens": 6, + "total_completion_tokens": 10, + "total_compression_saved_tokens": 0, + "total_compression_savings_spend": 0.0, + "total_failed_requests": 0, + "total_flat_cost": 0.0, + "total_gateway_injected_caching_savings_spend": 0.0, + "total_pages": 1, + "total_prompt_caching_savings_spend": 0.0, + "total_prompt_tokens": 1014, + "total_response_time_ms": 0, + "total_spend": 1273.0, + "total_successful_requests": 5, + "total_timed_requests": 0, + "total_tokens": 1024 + }, + "results": [ + { + "breakdown": { + "api_keys": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "endpoints": { + "/v1/chat/completions": { + "api_key_breakdown": { + "__ptu_flat_cost__": { + "metadata": { + "key_alias": null, + "key_exists": false, + "team_id": null, + "user_email": null, + "user_id": null + }, + "metrics": { + "api_requests": 0, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + "completion_tokens": 0, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 0, + "spend": 1000.0, + "successful_requests": 0, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 0 + } + }, + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + }, + "entities": { + "user-1": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": { + "user_alias": null, + "user_email": "user@example.com" + }, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + }, + "mcp_servers": {}, + "model_groups": { + "model-cache": { + "api_key_breakdown": { + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "model-popular": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 3, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 3, + "completion_tokens": 6, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 9, + "spend": 270.0, + "successful_requests": 3, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 15 + } + }, + "model-ptu": { + "api_key_breakdown": {}, + "metadata": {}, + "metrics": { + "api_requests": 0, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + "completion_tokens": 0, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 0, + "spend": 1000.0, + "successful_requests": 0, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 0 + } + }, + "model-target": { + "api_key_breakdown": { + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "models": { + "model-cache": { + "api_key_breakdown": { + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "model-popular": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 3, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 3, + "completion_tokens": 6, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 9, + "spend": 270.0, + "successful_requests": 3, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 15 + } + }, + "model-ptu": { + "api_key_breakdown": {}, + "metadata": {}, + "metrics": { + "api_requests": 0, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + "completion_tokens": 0, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 0, + "spend": 1000.0, + "successful_requests": 0, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 0 + } + }, + "model-target": { + "api_key_breakdown": { + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "providers": { + "provider-a": { + "api_key_breakdown": { + "key-a": { + "metadata": { + "key_alias": "alias-a", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 2, + "spend": 100.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 4 + } + }, + "key-b": { + "metadata": { + "key_alias": "alias-b", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 3, + "spend": 90.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 5 + } + }, + "key-c": { + "metadata": { + "key_alias": "alias-c", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 4, + "spend": 80.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 6 + } + }, + "key-cache": { + "metadata": { + "key_alias": "alias-cache", + "key_exists": true, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 1, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1000, + "spend": 2.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1002 + } + }, + "key-target": { + "metadata": { + "key_alias": "deleted-target", + "key_exists": false, + "team_id": "team-1", + "user_email": "user@example.com", + "user_id": "user-1" + }, + "metrics": { + "api_requests": 1, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 2, + "completion_tokens": 2, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 5, + "spend": 1.0, + "successful_requests": 1, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 7 + } + } + }, + "metadata": {}, + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + } + }, + "date": "2026-06-01", + "metrics": { + "api_requests": 5, + "autorouter_savings_spend": 0.0, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 6, + "completion_tokens": 10, + "compression_saved_tokens": 0, + "compression_savings_spend": 0.0, + "failed_requests": 0, + "flat_cost": 0.0, + "gateway_injected_caching_savings_spend": 0.0, + "prompt_caching_savings_spend": 0.0, + "prompt_tokens": 1014, + "spend": 1273.0, + "successful_requests": 5, + "timed_requests": 0, + "total_response_time_ms": 0, + "total_tokens": 1024 + } + } + ] +} diff --git a/tests/integration/spend/test_daily_activity_routes.py b/tests/integration/spend/test_daily_activity_routes.py new file mode 100644 index 00000000000..7c8db96966e --- /dev/null +++ b/tests/integration/spend/test_daily_activity_routes.py @@ -0,0 +1,514 @@ +import csv +import hashlib +import io +import uuid +from datetime import datetime, timedelta, timezone +from itertools import chain +from pathlib import Path +from typing import Final + +import httpx +import pytest +from fastapi import FastAPI +from integration._support.client import JSON_OBJECT, Gateway, eventually, object_value, string_value +from integration._support.database import read_rows +from integration._support.process import owned_proxy +from integration._support.upstream import JsonResponse, delete_scenario, register_scenario +from integration.spend.test_daily_activity_repository import _daily_activity_database, _PrismaDatabase, _repository + +from litellm import constants +from litellm.proxy import proxy_server +from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth +from litellm.proxy.auth.user_api_key_auth import user_api_key_auth +from litellm.proxy.management_endpoints.daily_activity_routes import ( + get_daily_activity_prisma_client, + get_daily_activity_repository, +) +from litellm.proxy.management_endpoints.daily_activity_routes import ( + router as daily_activity_router, +) +from litellm.proxy.management_endpoints.internal_user_endpoints import router as internal_user_router +from litellm.proxy.management_endpoints.team_endpoints import router as team_router +from litellm.types.proxy.management_endpoints.common_daily_activity import DailyActivityKeyPageResponse + + +def _delete_organization(gateway: Gateway, organization_id: str) -> None: + response: Final = gateway.request("DELETE", "/organization/delete", {"organization_ids": [organization_id]}) + assert response.status_code == 200, response.text + + +def _delete_tag(gateway: Gateway, tag: str) -> None: + response: Final = gateway.request("POST", "/tag/delete", {"name": tag}) + assert response.status_code == 200, response.text + + +def _delete_end_user(gateway: Gateway, end_user_id: str) -> None: + response: Final = gateway.request("POST", "/end_user/delete", {"user_ids": [end_user_id]}) + assert response.status_code == 200, response.text + + +def _delete_agent(gateway: Gateway, agent_id: str) -> None: + response: Final = gateway.request("DELETE", f"/v1/agents/{agent_id}") + assert response.status_code == 200, response.text + + +def _daily_activity_request( + gateway: Gateway, + *, + model: str, + key: str, + end_user_id: str, + tag: str, + request_number: int, +) -> None: + response: Final = gateway.request( + "POST", + "/v1/chat/completions", + JSON_OBJECT.validate_python( + { + "model": model, + "messages": [{"role": "user", "content": f"daily activity {request_number}"}], + "metadata": {"tags": [tag]}, + "user": end_user_id, + } + ), + key=key, + ) + assert response.status_code == 200, response.text + + +def _aggregate_result_api_keys(result: object) -> tuple[str, ...]: + result_body: Final = object_value(result) + breakdown: Final = object_value(result_body["breakdown"]) + api_keys: Final = object_value(breakdown["api_keys"]) + return tuple(api_keys) + + +def _aggregate_top_keys(results: object) -> frozenset[str]: + assert isinstance(results, list) + api_keys_by_result: Final = tuple(_aggregate_result_api_keys(result) for result in results) + return frozenset(chain.from_iterable(api_keys_by_result)) + + +def _assert_entity_activity_routes( + gateway: Gateway, + *, + prefix: str, + entity_param: str, + entity_id: str, + table: str, + entity_column: str, + date_params: dict[str, str], + target_digest: str, + model: str, +) -> None: + params: Final = {**date_params, entity_param: entity_id} + persisted_rows: Final = eventually( + lambda: read_rows( + f'SELECT api_key FROM "{table}" WHERE "{entity_column}"=%s AND date BETWEEN %s AND %s', + (entity_id, date_params["start_date"], date_params["end_date"]), + ), + lambda rows: len(rows) == 6, + seconds=70, + ) + aggregated: Final = gateway.request( + "GET", + f"{prefix}/daily/activity/aggregated", + params={**params, "api_key_limit": "3"}, + ) + assert aggregated.status_code == 200, aggregated.text + aggregate_body: Final = object_value(aggregated.json()) + metadata: Final = object_value(aggregate_body["metadata"]) + total_api_keys: Final = metadata["total_api_keys"] + api_key_limit: Final = metadata["api_key_limit"] + assert isinstance(total_api_keys, int) and total_api_keys == 6, aggregated.text + assert isinstance(api_key_limit, int) and api_key_limit == 3, aggregated.text + assert total_api_keys > api_key_limit, aggregated.text + assert metadata["total_api_requests"] == 8, aggregated.text + top_api_keys: Final = _aggregate_top_keys(aggregate_body["results"]) + assert target_digest not in top_api_keys, aggregated.text + ranked_rows: Final = read_rows( + f'SELECT api_key FROM "{table}" WHERE "{entity_column}"=%s AND date BETWEEN %s AND %s ' + "AND api_key <> %s GROUP BY api_key ORDER BY SUM(spend::numeric) DESC, api_key", + ( + entity_id, + date_params["start_date"], + date_params["end_date"], + constants.PTU_SENTINEL_API_KEY, + ), + ) + ranked_keys: Final = tuple(string_value(row["api_key"]) for row in ranked_rows) + page_responses: Final = tuple( + gateway.request( + "GET", + f"{prefix}/daily/activity/aggregated/keys", + params={**params, "offset": str(offset), "limit": "2"}, + ) + for offset in range(0, len(ranked_keys), 2) + ) + assert all(response.status_code == 200 for response in page_responses), tuple( + response.text for response in page_responses + ) + page_bodies: Final = tuple( + DailyActivityKeyPageResponse.model_validate_json(response.content) for response in page_responses + ) + page_api_keys: Final = tuple(tuple(row.api_key for row in body.api_keys) for body in page_bodies) + paged_keys: Final = tuple(chain.from_iterable(page_api_keys)) + assert tuple(body.total_api_keys for body in page_bodies) == (6,) * len(page_bodies) + assert paged_keys == ranked_keys + assert len(paged_keys) == len(frozenset(paged_keys)) + assert frozenset(paged_keys[:3]) == top_api_keys, aggregated.text + + key_details: Final = gateway.request( + "GET", + f"{prefix}/daily/activity/aggregated", + params={**params, "api_key": target_digest}, + ) + assert key_details.status_code == 200, key_details.text + key_details_body: Final = JSON_OBJECT.validate_json(key_details.content) + assert object_value(key_details_body["metadata"])["total_api_keys"] == 1, key_details.text + assert _aggregate_top_keys(key_details_body["results"]) == frozenset((target_digest,)), key_details.text + + searched: Final = gateway.request( + "GET", + f"{prefix}/daily/activity/aggregated/search", + params={**params, "search": target_digest}, + ) + assert searched.status_code == 200, searched.text + search_body: Final = object_value(searched.json()) + search_rows: Final = search_body["api_keys"] + assert isinstance(search_rows, list) and len(search_rows) == 1, searched.text + assert object_value(search_rows[0])["api_key"] == target_digest, searched.text + + top_keys: Final = gateway.request( + "GET", + f"{prefix}/daily/activity/aggregated/model_top_keys", + params={**params, "model_group": model}, + ) + assert top_keys.status_code == 200, top_keys.text + top_body: Final = object_value(top_keys.json()) + top_rows: Final = top_body["api_keys"] + assert isinstance(top_rows, list) and len(top_rows) == 5, top_keys.text + top_spends: Final = tuple(object_value(object_value(row)["metrics"])["spend"] for row in top_rows[:2]) + assert top_spends == ( + pytest.approx(0.12), + pytest.approx(0.12), + ), top_keys.text + + exported: Final = gateway.request( + "GET", + f"{prefix}/daily/activity/export", + params={**params, "export_type": "daily_with_keys"}, + ) + assert exported.status_code == 200, exported.text + export_rows: Final = tuple(csv.reader(io.StringIO(exported.text))) + assert len(export_rows) == len(persisted_rows) + 1, exported.text + + +@pytest.mark.timeout(90) +def test_daily_activity_routes_cover_all_entities_and_bounded_key_search(gateway: Gateway, tmp_path: Path) -> None: + with owned_proxy(gateway, tmp_path, {}) as proxy: + _assert_daily_activity_routes(proxy) + + +def _assert_daily_activity_routes(gateway: Gateway) -> None: + with gateway.scenario() as scenario: + model: Final = scenario.model(input_cost_per_token=0.001, output_cost_per_token=0.002) + target_scenario_id: Final = f"usage-cache-{uuid.uuid4().hex}" + target_response: Final = JsonResponse( + content_type="application/json", + body=JSON_OBJECT.validate_python( + { + "id": "$UNIQUE_ID", + "object": "chat.completion", + "created": 1_700_000_000, + "model": "gpt-4o-mini", + "choices": [ + { + "index": 0, + "message": {"role": "assistant", "content": "cached response"}, + "finish_reason": "stop", + } + ], + "usage": { + "prompt_tokens": 40, + "completion_tokens": 20, + "total_tokens": 60, + "prompt_tokens_details": {"cached_tokens": 20}, + }, + } + ), + ) + target_upstream: Final = register_scenario(target_scenario_id, target_response) + scenario.cleanups.callback(delete_scenario, target_upstream) + cache_model: Final = scenario.model( + api_base=target_upstream.api_base(), + api_key=target_scenario_id, + input_cost_per_token=0.0, + output_cost_per_token=0.0, + ) + organization: Final = gateway.post( + "/organization/new", + {"organization_alias": f"integration-{uuid.uuid4().hex}"}, + ) + organization_id: Final = string_value(organization["organization_id"]) + scenario.cleanups.callback(_delete_organization, gateway, organization_id) + team_id: Final = scenario.team(organization_id=organization_id) + user_id: Final = scenario.user() + tag: Final = f"integration-{uuid.uuid4().hex}" + gateway.post("/tag/new", {"name": tag}) + scenario.cleanups.callback(_delete_tag, gateway, tag) + end_user_id: Final = f"integration-{uuid.uuid4().hex}" + gateway.post("/end_user/new", {"user_id": end_user_id}) + scenario.cleanups.callback(_delete_end_user, gateway, end_user_id) + agent_response: Final = gateway.request( + "POST", + "/v1/agents", + { + "agent_name": f"integration-{uuid.uuid4().hex}", + "agent_card_params": { + "protocolVersion": "0.3", + "name": "integration", + "description": "integration agent", + "url": "http://127.0.0.1:1/agent", + "version": "1", + "capabilities": {}, + "defaultInputModes": ["text"], + "defaultOutputModes": ["text"], + "skills": [], + }, + }, + ) + assert agent_response.status_code == 200, agent_response.text + agent_id: Final = string_value(object_value(agent_response.json())["agent_id"]) + scenario.cleanups.callback(_delete_agent, gateway, agent_id) + keys: Final = tuple( + scenario.key( + models=[model, cache_model], + team_id=team_id, + user_id=user_id, + organization_id=organization_id, + agent_id=agent_id, + ) + for _ in range(5) + ) + target_key: Final = scenario.key( + models=[model, cache_model], + team_id=team_id, + user_id=user_id, + organization_id=organization_id, + agent_id=agent_id, + ) + for request_number, key in enumerate(keys): + _daily_activity_request( + gateway, + model=model, + key=key, + end_user_id=end_user_id, + tag=tag, + request_number=request_number, + ) + for request_number, key in enumerate(keys[:2]): + _daily_activity_request( + gateway, + model=model, + key=key, + end_user_id=end_user_id, + tag=tag, + request_number=100 + request_number, + ) + target_request: Final = gateway.request( + "POST", + "/v1/chat/completions", + JSON_OBJECT.validate_python( + { + "model": cache_model, + "messages": [{"role": "user", "content": "cached activity response"}], + "metadata": {"tags": [tag]}, + "user": end_user_id, + } + ), + key=target_key, + ) + assert target_request.status_code == 200, target_request.text + + today: Final = datetime.now(timezone.utc).date() + start_date: Final = (today - timedelta(days=1)).isoformat() + end_date: Final = (today + timedelta(days=1)).isoformat() + date_params: Final = {"start_date": start_date, "end_date": end_date, "timezone": "0"} + route_cases: Final = ( + ("/user", "user_id", user_id, "LiteLLM_DailyUserSpend", "user_id"), + ("/team", "team_ids", team_id, "LiteLLM_DailyTeamSpend", "team_id"), + ("/tag", "tags", tag, "LiteLLM_DailyTagSpend", "tag"), + ( + "/organization", + "organization_ids", + organization_id, + "LiteLLM_DailyOrganizationSpend", + "organization_id", + ), + ("/customer", "end_user_ids", end_user_id, "LiteLLM_DailyEndUserSpend", "end_user_id"), + ("/agent", "agent_ids", agent_id, "LiteLLM_DailyAgentSpend", "agent_id"), + ) + target_digest: Final = hashlib.sha256(target_key.encode()).hexdigest() + for prefix, entity_param, entity_id, table, entity_column in route_cases: + _assert_entity_activity_routes( + gateway, + prefix=prefix, + entity_param=entity_param, + entity_id=entity_id, + table=table, + entity_column=entity_column, + date_params=date_params, + target_digest=target_digest, + model=model, + ) + + user_cache_keys: Final = gateway.request( + "GET", + "/user/daily/activity/aggregated/cache_leakage_keys", + params={**date_params, "user_id": user_id}, + ) + assert user_cache_keys.status_code == 200, user_cache_keys.text + cache_rows: Final = object_value(user_cache_keys.json())["api_keys"] + assert isinstance(cache_rows, list) and cache_rows, user_cache_keys.text + cache_api_keys: Final = tuple(string_value(object_value(row)["api_key"]) for row in cache_rows) + assert target_digest in cache_api_keys, user_cache_keys.text + + +async def _assert_route_matches_golden(client: httpx.AsyncClient, route: str, golden_name: str) -> None: + response: Final = await client.get( + route, + params={"start_date": "2026-06-01", "end_date": "2026-06-01"}, + ) + assert response.status_code == 200, response.text + golden: Final = (Path(__file__).parent / "golden" / golden_name).read_text() + expected: Final = JSON_OBJECT.validate_json(golden) + actual: Final = object_value(response.json()) + assert actual == expected, route + + +@pytest.mark.asyncio +async def test_existing_activity_routes_match_base_branch_goldens(monkeypatch: pytest.MonkeyPatch) -> None: + async with _daily_activity_database() as database: + repository: Final = _repository(database) + app: Final = FastAPI() + app.include_router(internal_user_router) + app.include_router(team_router) + app.include_router(daily_activity_router) + monkeypatch.setattr(proxy_server, "prisma_client", _PrismaDatabase(database)) + app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth( + user_id="integration-admin", user_role=LitellmUserRoles.PROXY_ADMIN + ) + app.dependency_overrides[get_daily_activity_prisma_client] = lambda: _PrismaDatabase(database) + app.dependency_overrides[get_daily_activity_repository] = lambda: repository + + async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver") as client: + route_goldens: Final = ( + ("/user/daily/activity", "daily_activity_user_paginated.json"), + ("/user/daily/activity/aggregated", "daily_activity_user_aggregated.json"), + ("/team/daily/activity", "daily_activity_team_paginated.json"), + ("/team/daily/activity/aggregated", "daily_activity_team_aggregated.json"), + ) + for route, golden_name in route_goldens: + await _assert_route_matches_golden(client, route, golden_name) + + +@pytest.mark.asyncio +async def test_user_key_pages_and_details_respect_caller_scope() -> None: + async with _daily_activity_database() as database: + await database.query_raw( + 'INSERT INTO "LiteLLM_UserTable" (user_id, user_email, models) VALUES ($1, $2, $3)', + "user-2", + "other@example.test", + [], + ) + await database.query_raw( + """ + INSERT INTO "LiteLLM_VerificationToken" + (token, key_alias, team_id, user_id, metadata, models) + VALUES ($1, $2, $3, $4, $5::jsonb, $6) + """, + "key-other-user", + "Other user key", + None, + "user-2", + "{}", + [], + ) + await database.query_raw( + """ + INSERT INTO "LiteLLM_DailyUserSpend" + (id, user_id, date, api_key, model, model_group, custom_llm_provider, + mcp_namespaced_tool_name, endpoint, prompt_tokens, completion_tokens, + cache_read_input_tokens, cache_creation_input_tokens, spend, api_requests, + successful_requests, failed_requests, updated_at) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18::timestamp) + """, + "other-user-row", + "user-2", + "2026-06-01", + "key-other-user", + "model", + "", + "provider-a", + None, + "/v1/chat/completions", + 1, + 1, + 0, + 0, + 50.0, + 1, + 1, + 0, + "2026-06-01 12:00:00", + ) + repository: Final = _repository(database) + app: Final = FastAPI() + app.include_router(daily_activity_router) + app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth( + user_id="user-1", + user_role=LitellmUserRoles.INTERNAL_USER, + ) + app.dependency_overrides[get_daily_activity_prisma_client] = lambda: _PrismaDatabase(database) + app.dependency_overrides[get_daily_activity_repository] = lambda: repository + + async with httpx.AsyncClient( + transport=httpx.ASGITransport(app=app), + base_url="http://testserver", + ) as client: + params: Final = {"start_date": "2026-06-01", "end_date": "2026-06-01"} + page: Final = await client.get( + "/user/daily/activity/aggregated/keys", + params={**params, "user_id": "user-1", "limit": 100}, + ) + assert page.status_code == 200, page.text + page_body: Final = DailyActivityKeyPageResponse.model_validate_json(page.content) + page_keys: Final = frozenset(row.api_key for row in page_body.api_keys) + assert page_body.total_api_keys == len(page_keys) == 5 + assert "key-other-user" not in page_keys + + denied: Final = await client.get( + "/user/daily/activity/aggregated/keys", + params={**params, "user_id": "user-2"}, + ) + assert denied.status_code == 403, denied.text + + own_details: Final = await client.get( + "/user/daily/activity/aggregated", + params={**params, "user_id": "user-1", "api_key": "key-a"}, + ) + assert own_details.status_code == 200, own_details.text + own_body: Final = JSON_OBJECT.validate_json(own_details.content) + assert object_value(own_body["metadata"])["total_api_keys"] == 1 + assert _aggregate_top_keys(own_body["results"]) == frozenset(("key-a",)) + + other_details: Final = await client.get( + "/user/daily/activity/aggregated", + params={**params, "user_id": "user-1", "api_key": "key-other-user"}, + ) + assert other_details.status_code == 200, other_details.text + other_body: Final = JSON_OBJECT.validate_json(other_details.content) + assert object_value(other_body["metadata"])["total_api_keys"] == 0 + assert _aggregate_top_keys(other_body["results"]) == frozenset() diff --git a/tests/unit/proxy/auth/test_route_checks.py b/tests/unit/proxy/auth/test_route_checks.py index d8ee58a52ea..6503e5bf50e 100644 --- a/tests/unit/proxy/auth/test_route_checks.py +++ b/tests/unit/proxy/auth/test_route_checks.py @@ -16,6 +16,93 @@ from litellm.proxy._types import ( from litellm.proxy.auth.auth_checks_organization import _user_is_org_admin from litellm.proxy.auth.route_checks import RouteChecks +DAILY_ACTIVITY_ROUTE_PAIRS: Final[tuple[tuple[str, str], ...]] = ( + ("/user/daily/activity", "/user/daily/activity/aggregated"), + ("/user/daily/activity", "/user/daily/activity/aggregated/keys"), + ("/user/daily/activity", "/user/daily/activity/aggregated/search"), + ("/user/daily/activity", "/user/daily/activity/aggregated/model_top_keys"), + ("/user/daily/activity", "/user/daily/activity/export"), + ("/user/daily/activity", "/user/daily/activity/aggregated/cache_leakage_keys"), + ("/team/daily/activity", "/team/daily/activity/aggregated"), + ("/team/daily/activity", "/team/daily/activity/aggregated/keys"), + ("/team/daily/activity", "/team/daily/activity/aggregated/search"), + ("/team/daily/activity", "/team/daily/activity/aggregated/model_top_keys"), + ("/team/daily/activity", "/team/daily/activity/export"), + ("/tag/daily/activity", "/tag/daily/activity/aggregated"), + ("/tag/daily/activity", "/tag/daily/activity/aggregated/keys"), + ("/tag/daily/activity", "/tag/daily/activity/aggregated/search"), + ("/tag/daily/activity", "/tag/daily/activity/aggregated/model_top_keys"), + ("/tag/daily/activity", "/tag/daily/activity/export"), + ("/organization/daily/activity", "/organization/daily/activity/aggregated"), + ("/organization/daily/activity", "/organization/daily/activity/aggregated/keys"), + ("/organization/daily/activity", "/organization/daily/activity/aggregated/search"), + ("/organization/daily/activity", "/organization/daily/activity/aggregated/model_top_keys"), + ("/organization/daily/activity", "/organization/daily/activity/export"), + ("/customer/daily/activity", "/customer/daily/activity/aggregated"), + ("/customer/daily/activity", "/customer/daily/activity/aggregated/keys"), + ("/customer/daily/activity", "/customer/daily/activity/aggregated/search"), + ("/customer/daily/activity", "/customer/daily/activity/aggregated/model_top_keys"), + ("/customer/daily/activity", "/customer/daily/activity/export"), + ("/customer/daily/activity", "/end_user/daily/activity/aggregated"), + ("/customer/daily/activity", "/end_user/daily/activity/aggregated/keys"), + ("/customer/daily/activity", "/end_user/daily/activity/aggregated/search"), + ("/customer/daily/activity", "/end_user/daily/activity/aggregated/model_top_keys"), + ("/customer/daily/activity", "/end_user/daily/activity/export"), + ("/agent/daily/activity", "/agent/daily/activity/aggregated"), + ("/agent/daily/activity", "/agent/daily/activity/aggregated/keys"), + ("/agent/daily/activity", "/agent/daily/activity/aggregated/search"), + ("/agent/daily/activity", "/agent/daily/activity/aggregated/model_top_keys"), + ("/agent/daily/activity", "/agent/daily/activity/export"), +) + +DAILY_ACTIVITY_ROLES: Final[tuple[LitellmUserRoles, ...]] = ( + LitellmUserRoles.PROXY_ADMIN, + LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY, + LitellmUserRoles.INTERNAL_USER, + LitellmUserRoles.INTERNAL_USER_VIEW_ONLY, + LitellmUserRoles.ORG_ADMIN, + LitellmUserRoles.TEAM, + LitellmUserRoles.CUSTOMER, +) + + +def _daily_activity_route_outcome(route: str, user_role: LitellmUserRoles) -> str: + if user_role == LitellmUserRoles.PROXY_ADMIN: + return "allowed" + user_obj = LiteLLM_UserTable( + user_id="test_user", + user_email="test@example.com", + user_role=user_role.value, + ) + valid_token = UserAPIKeyAuth(user_id="test_user", user_role=user_role) + request = MagicMock(spec=Request) + request.method = "GET" + request.query_params = {} + try: + RouteChecks.non_proxy_admin_allowed_routes_check( + user_obj=user_obj, + _user_role=user_role.value, + route=route, + request=request, + valid_token=valid_token, + request_data={}, + ) + except HTTPException as exc: + return f"denied:{exc.status_code}" + except Exception as exc: + return f"denied:{type(exc).__name__}" + return "allowed" + + +@pytest.mark.parametrize(("existing_path", "new_path"), DAILY_ACTIVITY_ROUTE_PAIRS) +@pytest.mark.parametrize("user_role", DAILY_ACTIVITY_ROLES) +def test_daily_activity_routes_preserve_route_access_outcomes( + existing_path: str, new_path: str, user_role: LitellmUserRoles +) -> None: + assert _daily_activity_route_outcome(new_path, user_role) == _daily_activity_route_outcome( + existing_path, user_role + ) + def test_non_admin_config_update_route_rejected(): """Test that non-admin users are rejected when trying to call /config/update""" @@ -2219,7 +2306,7 @@ def test_internal_user_can_access_logs_drawer_detail_route(user_role): request_data={}, ) except Exception as e: - pytest.fail(f"{user_role.value} should be able to access {route}. Got error: {str(e)}") + pytest.fail(f"{user_role.value} should be able to access {route}. Got error: {e!s}") @pytest.mark.parametrize( diff --git a/tests/unit/proxy/management_endpoints/test_activity_tenant_scoping.py b/tests/unit/proxy/management_endpoints/test_activity_tenant_scoping.py index 8c80429aa92..bd1436dcd10 100644 --- a/tests/unit/proxy/management_endpoints/test_activity_tenant_scoping.py +++ b/tests/unit/proxy/management_endpoints/test_activity_tenant_scoping.py @@ -387,3 +387,59 @@ async def test_agent_activity_non_admin_no_access_returns_empty_page(): assert result.results == [] fake_get_daily.assert_not_awaited() + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + ("owned_tokens", "requested_api_key"), + [ + ([], None), + (["alice-key-1"], "bob-key-1"), + ], +) +async def test_team_activity_member_without_matching_keys_queries_nothing( + owned_tokens: list[str], requested_api_key: str | None +) -> None: + """A member without full team view whose key list is empty, or who asks for + a key they do not own, must reach the repository with an empty key filter, + never with no filter at all.""" + from litellm.proxy.management_endpoints import common_daily_activity, team_endpoints + from litellm.repositories.daily_activity_sql import build_where_clause + from litellm.types.repositories.daily_activity import DailyRowsPage + + user = UserAPIKeyAuth(user_id="alice", user_role=LitellmUserRoles.INTERNAL_USER.value) + prisma = MagicMock() + prisma.db.litellm_teamtable.find_many = AsyncMock(return_value=[_make_team("team-B", admin_user_ids=["bob"])]) + prisma.db.litellm_verificationtoken.find_many = AsyncMock( + return_value=[MagicMock(token=token) for token in owned_tokens] + ) + user_info = MagicMock() + user_info.teams = ["team-B"] + repository = MagicMock() + repository.daily_rows = AsyncMock(return_value=DailyRowsPage(total_count=0, rows=())) + + with ( + patch.object(team_endpoints, "prisma_client", prisma, create=True), + patch( + "litellm.proxy.management_endpoints.team_endpoints.get_user_object", + new=AsyncMock(return_value=user_info), + ), + patch.object(common_daily_activity, "daily_activity_repository", return_value=repository), + patch("litellm.proxy.proxy_server.prisma_client", prisma), + patch("litellm.proxy.proxy_server.user_api_key_cache", MagicMock()), + patch("litellm.proxy.proxy_server.proxy_logging_obj", MagicMock()), + ): + response = await team_endpoints.get_team_daily_activity( + team_ids="team-B", + start_date="2026-01-01", + end_date="2026-01-02", + api_key=requested_api_key, + user_api_key_dict=user, + ) + + scope = repository.daily_rows.await_args.args[0] + assert scope.api_keys == () + sql, _params = build_where_clause(scope) + assert sql.endswith(" AND FALSE") + assert response.results == [] + assert response.metadata.total_spend == 0 diff --git a/tests/unit/proxy/management_endpoints/test_common_daily_activity.py b/tests/unit/proxy/management_endpoints/test_common_daily_activity.py index 75e4a865137..45820adb4ce 100644 --- a/tests/unit/proxy/management_endpoints/test_common_daily_activity.py +++ b/tests/unit/proxy/management_endpoints/test_common_daily_activity.py @@ -10,6 +10,7 @@ from fastapi import HTTPException import litellm.proxy.management_endpoints.common_daily_activity as common_daily_activity_module from litellm.constants import USAGE_TOP_API_KEYS_DEFAULT from litellm.proxy.management_endpoints.common_daily_activity import ( + InvalidDateRange, _is_user_agent_tag, _ProxyDailyActivityReads, _record_to_spend_metrics, @@ -18,6 +19,7 @@ from litellm.proxy.management_endpoints.common_daily_activity import ( daily_activity_scope, get_api_key_metadata, get_daily_activity, + raise_public, update_metrics, ) from litellm.proxy.management_endpoints.common_daily_activity import ( @@ -2332,17 +2334,17 @@ async def test_get_api_key_metadata_resolves_session_key_via_spend_log_window(): def test_spend_logs_window_pads_min_minus_one_day_and_max_plus_two_days(): - from litellm.proxy.management_endpoints.common_daily_activity import _spend_logs_window + from litellm.proxy.management_endpoints.common_daily_activity import spend_logs_window - window = _spend_logs_window({"2026-09-08", "2026-09-05", "not-a-date"}) + window = spend_logs_window({"2026-09-08", "2026-09-05", "not-a-date"}) assert window == (datetime(2026, 9, 4), datetime(2026, 9, 10)) def test_spend_logs_window_is_none_when_no_date_parses(): - from litellm.proxy.management_endpoints.common_daily_activity import _spend_logs_window + from litellm.proxy.management_endpoints.common_daily_activity import spend_logs_window - assert _spend_logs_window({"garbage", ""}) is None + assert spend_logs_window({"garbage", ""}) is None @pytest.mark.asyncio @@ -2447,3 +2449,10 @@ async def test_get_api_key_metadata_does_not_recover_daily_spend_owner_for_activ assert active_metadata.get("user_email") == "active-owner@example.com" assert active_metadata.get("key_exists") is True recovery_query_raw.assert_not_awaited() + + +def test_raise_public_maps_invalid_date_range_to_400() -> None: + with pytest.raises(HTTPException) as excinfo: + raise_public(InvalidDateRange(reason="Date range must be at most 400 days")) + assert excinfo.value.status_code == 400 + assert excinfo.value.detail == {"error": "Date range must be at most 400 days"} diff --git a/tests/unit/proxy/management_endpoints/test_daily_activity_routes.py b/tests/unit/proxy/management_endpoints/test_daily_activity_routes.py new file mode 100644 index 00000000000..076538e5cd0 --- /dev/null +++ b/tests/unit/proxy/management_endpoints/test_daily_activity_routes.py @@ -0,0 +1,1261 @@ +import csv +import io +from collections.abc import AsyncIterator, Iterator, Mapping, Sequence +from dataclasses import dataclass, fields +from itertools import chain +from types import SimpleNamespace +from typing import Final +from unittest.mock import AsyncMock + +import pytest +from fastapi import FastAPI, Request +from fastapi.testclient import TestClient + +from litellm import constants +from litellm.proxy._types import LiteLLM_TeamTable, LiteLLM_UserTable, LitellmUserRoles, Member, UserAPIKeyAuth +from litellm.proxy.auth.user_api_key_auth import user_api_key_auth +from litellm.proxy.management_endpoints.daily_activity_routes import ( + _csv_cell, + get_daily_activity_prisma_client, + get_daily_activity_repository, + router, +) +from litellm.types.proxy.management_endpoints.common_daily_activity import KeySpendMetrics, SpendMetrics +from litellm.types.repositories.daily_activity import ( + AggregatedRows, + DailyActivityScope, + DailyActivityTable, + EntityRollupRow, + ExportRow, + ExportType, + GroupingSetsRow, + KeyMetadataRow, + KeyPage, + KeySpendRow, +) + + +@dataclass(frozen=True, slots=True) +class _Activity: + table: DailyActivityTable + entity_id: str + date: str + api_key: str + model: str + model_group: str + spend: float + flat_cost: float + prompt_tokens: int + completion_tokens: int + cache_read_input_tokens: int + cache_creation_input_tokens: int + compression_saved_tokens: int + compression_savings_spend: float + prompt_caching_savings_spend: float + gateway_injected_caching_savings_spend: float + autorouter_savings_spend: float + api_requests: int + successful_requests: int + failed_requests: int + total_response_time_ms: int + timed_requests: int + + +_ENTITY_CASES: Final[tuple[tuple[str, str, str], ...]] = ( + ("/user", "user_id", "user-a"), + ("/team", "team_ids", "team-a"), + ("/tag", "tags", "blue"), + ("/organization", "organization_ids", "org-a"), + ("/customer", "end_user_ids", "customer-a"), + ("/agent", "agent_ids", "agent-a"), +) +_DATE_PARAMS: Final = {"start_date": "2025-01-01", "end_date": "2025-01-02"} + + +def _activity_for_entity( + table: DailyActivityTable, + entity_id: str, + key_rows: tuple[tuple[str, str, str, float, int], ...], +) -> tuple[_Activity, ...]: + return tuple( + _Activity( + table=table, + entity_id=entity_id, + date=date, + api_key=api_key, + model=model, + model_group="rare-group" if model == "rare-model" else "popular-group", + spend=spend, + flat_cost=0.05, + prompt_tokens=10, + completion_tokens=5, + cache_read_input_tokens=cache_read, + cache_creation_input_tokens=1, + compression_saved_tokens=2, + compression_savings_spend=0.1, + prompt_caching_savings_spend=0.2, + gateway_injected_caching_savings_spend=0.3, + autorouter_savings_spend=0.4, + api_requests=1, + successful_requests=1, + failed_requests=0, + total_response_time_ms=100, + timed_requests=1, + ) + for api_key, date, model, spend, cache_read in key_rows + ) + + +def _seeded_activity() -> tuple[_Activity, ...]: + entity_ids: Final = { + DailyActivityTable.USER: "user-a", + DailyActivityTable.TEAM: "team-a", + DailyActivityTable.TAG: "blue", + DailyActivityTable.ORGANIZATION: "org-a", + DailyActivityTable.CUSTOMER: "customer-a", + DailyActivityTable.AGENT: "agent-a", + } + other_entity_ids: Final = { + DailyActivityTable.USER: "user-b", + DailyActivityTable.TEAM: "team-b", + DailyActivityTable.TAG: "other-blue", + DailyActivityTable.ORGANIZATION: "other-org", + DailyActivityTable.CUSTOMER: "customer-b", + DailyActivityTable.AGENT: "agent-b", + } + key_rows: Final = ( + ("key-alpha", "2025-01-01", "popular", 1.0, 0), + ("key-alpha", "2025-01-02", "popular", 2.0, 0), + ("key-beta", "2025-01-01", "popular", 4.0, 0), + ("key-gamma", "2025-01-01", "popular", 5.0, 0), + ("key-cache", "2025-01-01", "popular", 2.0, 20), + ("key-target", "2025-01-01", "rare-model", 0.5, 0), + ) + return tuple( + chain.from_iterable(_activity_for_entity(table, entity_id, key_rows) for table, entity_id in entity_ids.items()) + ) + tuple( + _Activity( + table=table, + entity_id=other_entity_ids[table], + date="2025-01-01", + api_key=f"key-other-{table.value}", + model="popular", + model_group="popular-group", + spend=100.0, + flat_cost=0.0, + prompt_tokens=10, + completion_tokens=5, + cache_read_input_tokens=5 if table is DailyActivityTable.USER else 0, + cache_creation_input_tokens=0, + compression_saved_tokens=0, + compression_savings_spend=0.0, + prompt_caching_savings_spend=0.0, + gateway_injected_caching_savings_spend=0.0, + autorouter_savings_spend=0.0, + api_requests=1, + successful_requests=1, + failed_requests=0, + total_response_time_ms=100, + timed_requests=1, + ) + for table in entity_ids + ) + + +def _metrics(rows: Sequence[_Activity]) -> Mapping[str, int | float]: + return { + "spend": sum(row.spend for row in rows), + "ptu_flat_cost": sum(row.flat_cost for row in rows), + "prompt_tokens": sum(row.prompt_tokens for row in rows), + "completion_tokens": sum(row.completion_tokens for row in rows), + "cache_read_input_tokens": sum(row.cache_read_input_tokens for row in rows), + "cache_creation_input_tokens": sum(row.cache_creation_input_tokens for row in rows), + "compression_saved_tokens": sum(row.compression_saved_tokens for row in rows), + "compression_savings_spend": sum(row.compression_savings_spend for row in rows), + "prompt_caching_savings_spend": sum(row.prompt_caching_savings_spend for row in rows), + "gateway_injected_caching_savings_spend": sum(row.gateway_injected_caching_savings_spend for row in rows), + "autorouter_savings_spend": sum(row.autorouter_savings_spend for row in rows), + "api_requests": sum(row.api_requests for row in rows), + "successful_requests": sum(row.successful_requests for row in rows), + "failed_requests": sum(row.failed_requests for row in rows), + "total_response_time_ms": sum(row.total_response_time_ms for row in rows), + "timed_requests": sum(row.timed_requests for row in rows), + } + + +def _grouping_row( + rows: Sequence[_Activity], + *, + date: str | None, + api_key: str | None, + group_level: int, + distinct_api_keys: int | None, +) -> GroupingSetsRow: + metric_values: Final = _metrics(rows) + return GroupingSetsRow( + date=date, + api_key=api_key, + **metric_values, + model=None, + model_group=None, + custom_llm_provider=None, + mcp_namespaced_tool_name=None, + endpoint=None, + group_level=group_level, + distinct_api_keys=distinct_api_keys, + ) + + +def _grouping_rows_for_day( + date: str, rows: Sequence[_Activity], top_keys: tuple[str, ...], distinct_api_keys: int +) -> tuple[GroupingSetsRow, ...]: + date_rows: Final = tuple(row for row in rows if row.date == date) + return ( + _grouping_row(date_rows, date=date, api_key=None, group_level=63, distinct_api_keys=distinct_api_keys), + ) + tuple( + _grouping_row( + tuple(row for row in date_rows if row.api_key == api_key), + date=date, + api_key=api_key, + group_level=31, + distinct_api_keys=None, + ) + for api_key in top_keys + if any(row.api_key == api_key for row in date_rows) + ) + + +class _FakeRepository: + def __init__(self, rows: tuple[_Activity, ...]) -> None: + self._rows: Final = rows + self.aggregated = AsyncMock(side_effect=self._aggregated) + self.key_page = AsyncMock(side_effect=self._key_page) + self.key_page_call: tuple[DailyActivityScope, int, int] | None = None + self.search_keys = AsyncMock(side_effect=self._search_keys) + self.model_top_keys = AsyncMock(side_effect=self._model_top_keys) + self.cache_leakage_keys = AsyncMock(side_effect=self._cache_leakage_keys) + self.key_metadata = AsyncMock(side_effect=self._key_metadata) + self.export_rows_error: Exception | None = None + + def _matching_rows(self, scope: DailyActivityScope) -> tuple[_Activity, ...]: + return tuple( + row + for row in self._rows + if row.table == scope.table + and scope.start_date <= row.date <= scope.end_date + and (scope.entity_ids is None or row.entity_id in scope.entity_ids) + and row.entity_id not in scope.exclude_entity_ids + and (scope.api_keys is None or row.api_key in scope.api_keys) + and (scope.model is None or row.model == scope.model) + ) + + async def _aggregated( + self, + scope: DailyActivityScope, + *, + include_entity_breakdown: bool = False, + api_key_limit: int = constants.USAGE_TOP_API_KEYS_DEFAULT, + ) -> AggregatedRows: + rows: Final = self._matching_rows(scope) + key_spend: Final = tuple( + sorted( + ((key, sum(row.spend for row in rows if row.api_key == key)) for key in {row.api_key for row in rows}), + key=lambda item: (-item[1], item[0]), + ) + ) + distinct_keys: Final = len(key_spend) + top_keys: Final = tuple(key for key, _ in key_spend[:api_key_limit]) + dates: Final = tuple(sorted({row.date for row in rows})) + grouping_rows: Final = ( + _grouping_row(rows, date=None, api_key=None, group_level=127, distinct_api_keys=distinct_keys), + ) + tuple( + grouping_row + for date in dates + for grouping_row in _grouping_rows_for_day(date, rows, top_keys, distinct_keys) + ) + entity_rows: Final = ( + tuple(entity_row for date in dates for entity_row in _entity_rows_for_day(date, rows)) + if include_entity_breakdown + else () + ) + return AggregatedRows( + grouping_rows=grouping_rows, + entity_rows=entity_rows if include_entity_breakdown else None, + distinct_api_keys=distinct_keys, + ) + + async def _search_keys(self, scope: DailyActivityScope, *, search: str, limit: int) -> tuple[str, ...]: + rows: Final = self._matching_rows(scope) + return tuple(key for key in dict.fromkeys(row.api_key for row in rows) if search.casefold() in key.casefold())[ + :limit + ] + + async def _key_page(self, scope: DailyActivityScope, *, offset: int, limit: int) -> KeyPage: + self.key_page_call = (scope, offset, limit) + rows: Final = self._matching_rows(scope) + api_keys: Final = _ranked_keys(rows) + return KeyPage( + rows=tuple(_key_spend_row(api_key, rows) for api_key in api_keys[offset : offset + limit]), + total_api_keys=len(api_keys), + ) + + async def _model_top_keys( + self, scope: DailyActivityScope, *, model_group: str, by_model_group: bool, limit: int + ) -> tuple[KeySpendRow, ...]: + rows: Final = tuple( + row + for row in self._matching_rows(scope) + if (row.model_group if by_model_group else row.model) == model_group + ) + return tuple(_key_spend_row(key, rows) for key in _ranked_keys(rows)[:limit]) + + async def _cache_leakage_keys(self, scope: DailyActivityScope, *, limit: int) -> tuple[KeySpendRow, ...]: + rows: Final = tuple(row for row in self._matching_rows(scope) if row.cache_read_input_tokens > 0) + return tuple(_key_spend_row(key, rows) for key in _ranked_keys(rows)[:limit]) + + async def _key_metadata( + self, api_keys: frozenset[str], window: tuple[object, object] | None + ) -> Mapping[str, KeyMetadataRow]: + return { + key: KeyMetadataRow( + api_key=key, + key_alias=f"alias-{key}", + team_id="team-a", + user_id="user-a", + user_email="user@example.test", + key_exists=True, + tags=(), + ) + for key in api_keys + } + + async def export_rows(self, scope: DailyActivityScope, *, export_type: ExportType) -> AsyncIterator[ExportRow]: + if self.export_rows_error is not None: + raise self.export_rows_error + for row in self._matching_rows(scope): + yield ExportRow( + date=row.date, + entity_id=row.entity_id, + entity_alias="=entity", + api_key=row.api_key, + key_alias="+key", + user_id="user-a", + user_email="user@example.test", + model=row.model, + spend=row.spend, + flat_cost=row.flat_cost, + prompt_tokens=row.prompt_tokens, + completion_tokens=row.completion_tokens, + api_requests=row.api_requests, + successful_requests=row.successful_requests, + failed_requests=row.failed_requests, + cache_read_input_tokens=row.cache_read_input_tokens, + cache_creation_input_tokens=row.cache_creation_input_tokens, + ) + + +def _ranked_keys(rows: Sequence[_Activity]) -> tuple[str, ...]: + return tuple( + key + for key, _ in sorted( + ((key, sum(row.spend for row in rows if row.api_key == key)) for key in {row.api_key for row in rows}), + key=lambda item: (-item[1], item[0]), + ) + ) + + +def _key_spend_row(api_key: str, rows: Sequence[_Activity]) -> KeySpendRow: + matching: Final = tuple(row for row in rows if row.api_key == api_key) + return KeySpendRow( + api_key=api_key, + spend=sum(row.spend for row in matching), + prompt_tokens=sum(row.prompt_tokens for row in matching), + completion_tokens=sum(row.completion_tokens for row in matching), + total_tokens=sum(row.prompt_tokens + row.completion_tokens for row in matching), + api_requests=sum(row.api_requests for row in matching), + successful_requests=sum(row.successful_requests for row in matching), + failed_requests=sum(row.failed_requests for row in matching), + cache_read_input_tokens=sum(row.cache_read_input_tokens for row in matching), + cache_creation_input_tokens=sum(row.cache_creation_input_tokens for row in matching), + ) + + +def _entity_rows_for_day( + date: str, rows: Sequence[_Activity], distinct_api_keys: int | None = None +) -> tuple[EntityRollupRow, ...]: + date_rows: Final = tuple(row for row in rows if row.date == date) + entities: Final = tuple(dict.fromkeys(row.entity_id for row in date_rows)) + return tuple( + entity_row + for entity_id in entities + for entity_row in _entity_rows_for_entity(date, entity_id, date_rows, distinct_api_keys) + ) + + +def _entity_rows_for_entity( + date: str, entity_id: str, rows: Sequence[_Activity], distinct_api_keys: int | None +) -> tuple[EntityRollupRow, ...]: + entity_rows: Final = tuple(row for row in rows if row.entity_id == entity_id) + return ( + _entity_rollup( + entity_rows, + date=date, + entity_id=entity_id, + api_key=None, + api_key_rolled=1, + distinct_api_keys=distinct_api_keys, + ), + ) + tuple( + _entity_rollup( + tuple(row for row in entity_rows if row.api_key == api_key), + date=date, + entity_id=entity_id, + api_key=api_key, + api_key_rolled=0, + distinct_api_keys=None, + ) + for api_key in dict.fromkeys(row.api_key for row in entity_rows) + ) + + +def _entity_rollup( + rows: Sequence[_Activity], + *, + date: str, + entity_id: str, + api_key: str | None, + api_key_rolled: int, + distinct_api_keys: int | None, +) -> EntityRollupRow: + return EntityRollupRow( + date=date, + api_key=api_key, + **_metrics(rows), + entity_id=entity_id, + api_key_rolled=api_key_rolled, + distinct_api_keys=distinct_api_keys, + ) + + +class _PrismaTable: + def __init__(self, rows: tuple[object, ...] = ()) -> None: + self._rows: Final = rows + + async def find_many(self, *, where: Mapping[str, object] | None = None, **kwargs: object) -> tuple[object, ...]: + if where is None: + return self._rows + return tuple(row for row in self._rows if _matches(row, where)) + + async def find_unique(self, *, where: Mapping[str, object], **kwargs: object) -> object | None: + return next((row for row in self._rows if _matches(row, where)), None) + + +def _matches(row: object, where: Mapping[str, object]) -> bool: + return all( + getattr(row, field_name, None) in value["in"] + if isinstance(value, Mapping) and "in" in value + else getattr(row, field_name, None) == value + for field_name, value in where.items() + ) + + +def _prisma_client() -> object: + user: Final = LiteLLM_UserTable( + user_id="user-a", + user_email="user@example.test", + user_role=LitellmUserRoles.INTERNAL_USER.value, + teams=["team-a"], + ) + team: Final = LiteLLM_TeamTable( + team_id="team-a", + team_alias="Team A", + members_with_roles=[Member(user_id="user-a", role="user")], + ) + other_user: Final = LiteLLM_UserTable( + user_id="user-b", + user_email="other-user@example.test", + user_role=LitellmUserRoles.INTERNAL_USER.value, + teams=["team-b"], + ) + other_team: Final = LiteLLM_TeamTable( + team_id="team-b", + team_alias="Team B", + members_with_roles=[Member(user_id="user-b", role="user")], + ) + db: Final = SimpleNamespace( + litellm_usertable=_PrismaTable((user, other_user)), + litellm_teamtable=_PrismaTable((team, other_team)), + litellm_verificationtoken=_PrismaTable((SimpleNamespace(token="key-alpha", user_id="user-a"),)), + litellm_organizationmembership=_PrismaTable( + ( + SimpleNamespace(user_id="user-a", organization_id="org-a", user_role="org_admin"), + SimpleNamespace(user_id="user-b", organization_id="other-org", user_role="org_admin"), + ) + ), + litellm_organizationtable=_PrismaTable( + ( + SimpleNamespace(organization_id="org-a", organization_alias="Org A"), + SimpleNamespace(organization_id="other-org", organization_alias="Other Org"), + ) + ), + litellm_endusertable=_PrismaTable( + ( + SimpleNamespace(user_id="customer-a", alias="Customer A"), + SimpleNamespace(user_id="customer-b", alias="Customer B"), + ) + ), + litellm_agentstable=_PrismaTable( + ( + SimpleNamespace(agent_id="agent-a", agent_name="Agent A", created_by="user-a"), + SimpleNamespace(agent_id="agent-b", agent_name="Agent B", created_by="user-b"), + ) + ), + ) + return SimpleNamespace(db=db, writer_db=db) + + +@pytest.fixture +def daily_activity_client() -> Iterator[tuple[TestClient, _FakeRepository]]: + repository: Final = _FakeRepository(_seeded_activity()) + prisma_client: Final = _prisma_client() + app: Final = FastAPI() + app.include_router(router) + + def resolve_auth(request: Request) -> UserAPIKeyAuth: + role: Final = LitellmUserRoles(request.headers.get("x-user-role", LitellmUserRoles.PROXY_ADMIN.value)) + user_id: Final[str | None] = request.headers.get("x-user-id") or ( + "admin" if role != LitellmUserRoles.INTERNAL_USER else None + ) + return UserAPIKeyAuth( + user_id=user_id, + user_role=role, + api_key=request.headers.get("x-api-key"), + ) + + app.dependency_overrides[get_daily_activity_repository] = lambda: repository + app.dependency_overrides[get_daily_activity_prisma_client] = lambda: prisma_client + app.dependency_overrides[user_api_key_auth] = resolve_auth + with TestClient(app) as client: + yield client, repository + + +def _entity_params(query_name: str, entity_id: str) -> dict[str, str]: + return {**_DATE_PARAMS, query_name: entity_id} + + +@pytest.mark.parametrize(("prefix", "query_name", "entity_id"), _ENTITY_CASES) +def test_aggregated_routes_return_scoped_results( + daily_activity_client: tuple[TestClient, _FakeRepository], + prefix: str, + query_name: str, + entity_id: str, +) -> None: + client, _ = daily_activity_client + response: Final = client.get( + f"{prefix}/daily/activity/aggregated", + params=_entity_params(query_name, entity_id), + ) + assert response.status_code == 200, response.text + body: Final = response.json() + assert body["metadata"]["total_spend"] == pytest.approx(14.5), response.text + assert body["metadata"]["total_api_keys"] == 5, response.text + assert len(body["results"]) == 2, response.text + + +@pytest.mark.parametrize(("prefix", "query_name", "entity_id"), _ENTITY_CASES) +def test_admin_aggregates_all_entities_when_filter_is_omitted( + daily_activity_client: tuple[TestClient, _FakeRepository], prefix: str, query_name: str, entity_id: str +) -> None: + client, _ = daily_activity_client + response: Final = client.get( + f"{prefix}/daily/activity/aggregated", + params=_DATE_PARAMS, + ) + assert response.status_code == 200, response.text + assert response.json()["metadata"]["total_spend"] == pytest.approx(114.5), response.text + assert response.json()["metadata"]["total_api_keys"] == 6, response.text + + +@pytest.mark.parametrize(("prefix", "query_name", "entity_id"), _ENTITY_CASES) +def test_search_folds_each_entity_key_across_days( + daily_activity_client: tuple[TestClient, _FakeRepository], prefix: str, query_name: str, entity_id: str +) -> None: + client, _ = daily_activity_client + response: Final = client.get( + f"{prefix}/daily/activity/aggregated/search", + params={**_entity_params(query_name, entity_id), "search": "alpha"}, + ) + assert response.status_code == 200, response.text + assert response.json() == { + "api_keys": [ + { + "api_key": "key-alpha", + "metrics": { + "spend": 3.0, + "flat_cost": 0.0, + "prompt_tokens": 20, + "completion_tokens": 10, + "cache_read_input_tokens": 0, + "cache_creation_input_tokens": 2, + "compression_saved_tokens": 4, + "compression_savings_spend": 0.2, + "prompt_caching_savings_spend": 0.4, + "gateway_injected_caching_savings_spend": 0.6, + "autorouter_savings_spend": 0.8, + "total_tokens": 30, + "successful_requests": 2, + "failed_requests": 0, + "api_requests": 2, + "total_response_time_ms": 200, + "timed_requests": 2, + }, + "metadata": { + "key_alias": "alias-key-alpha", + "team_id": "team-a", + "user_id": "user-a", + "user_email": "user@example.test", + "key_exists": True, + }, + } + ] + } + + +def test_search_finds_keys_outside_the_top_keys_limit_and_skips_empty_aggregate( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, repository = daily_activity_client + aggregate_response: Final = client.get( + "/user/daily/activity/aggregated", + params={**_entity_params("user_id", "user-a"), "api_key_limit": 3}, + ) + assert aggregate_response.status_code == 200, aggregate_response.text + assert repository.aggregated.call_args.kwargs["api_key_limit"] == 3 + top_keys: Final = frozenset( + chain.from_iterable(result["breakdown"]["api_keys"] for result in aggregate_response.json()["results"]) + ) + assert "key-target" not in top_keys + + search_response: Final = client.get( + "/user/daily/activity/aggregated/search", + params={**_entity_params("user_id", "user-a"), "search": "target", "limit": 7}, + ) + assert search_response.status_code == 200, search_response.text + assert repository.search_keys.call_args.kwargs["limit"] == 7 + assert search_response.json()["api_keys"][0]["api_key"] == "key-target" + assert search_response.json()["api_keys"][0]["metrics"]["spend"] == pytest.approx(0.5) + search_metrics: Final = search_response.json()["api_keys"][0]["metrics"] + assert set(search_metrics) == set(SpendMetrics.model_fields) + assert search_metrics["compression_savings_spend"] == pytest.approx(0.1) + assert search_metrics["total_response_time_ms"] == 100 + + repository.aggregated.reset_mock() + empty_response: Final = client.get( + "/user/daily/activity/aggregated/search", + params={**_entity_params("user_id", "user-a"), "search": "absent"}, + ) + assert empty_response.status_code == 200, empty_response.text + assert empty_response.json() == {"api_keys": []} + repository.aggregated.assert_not_awaited() + + +@pytest.mark.parametrize(("prefix", "query_name", "entity_id"), _ENTITY_CASES) +def test_key_page_routes_map_ranked_rows_and_totals( + daily_activity_client: tuple[TestClient, _FakeRepository], + prefix: str, + query_name: str, + entity_id: str, +) -> None: + client, repository = daily_activity_client + response: Final = client.get( + f"{prefix}/daily/activity/aggregated/keys", + params={**_entity_params(query_name, entity_id), "offset": 1, "limit": 2}, + ) + + assert response.status_code == 200, response.text + assert response.json() == { + "api_keys": [ + { + "api_key": "key-beta", + "metrics": { + "spend": 4.0, + "prompt_tokens": 10, + "completion_tokens": 5, + "total_tokens": 15, + "api_requests": 1, + "successful_requests": 1, + "failed_requests": 0, + "cache_read_input_tokens": 0, + "cache_creation_input_tokens": 1, + }, + "metadata": { + "key_alias": "alias-key-beta", + "team_id": "team-a", + "user_id": "user-a", + "user_email": "user@example.test", + "key_exists": True, + }, + }, + { + "api_key": "key-alpha", + "metrics": { + "spend": 3.0, + "prompt_tokens": 20, + "completion_tokens": 10, + "total_tokens": 30, + "api_requests": 2, + "successful_requests": 2, + "failed_requests": 0, + "cache_read_input_tokens": 0, + "cache_creation_input_tokens": 2, + }, + "metadata": { + "key_alias": "alias-key-alpha", + "team_id": "team-a", + "user_id": "user-a", + "user_email": "user@example.test", + "key_exists": True, + }, + }, + ], + "total_api_keys": 5, + "offset": 1, + "limit": 2, + } + key_page_call: Final = repository.key_page_call + assert key_page_call is not None + scope: Final = key_page_call[0] + assert scope.entity_ids == (entity_id,) + assert key_page_call[1:] == (1, 2) + + +@pytest.mark.parametrize("params", ({"limit": 101}, {"offset": -1})) +def test_key_page_route_rejects_invalid_bounds( + daily_activity_client: tuple[TestClient, _FakeRepository], + params: Mapping[str, int], +) -> None: + client, repository = daily_activity_client + response: Final = client.get( + "/user/daily/activity/aggregated/keys", + params={**_entity_params("user_id", "user-a"), **params}, + ) + + assert response.status_code == 422, response.text + repository.key_page.assert_not_awaited() + + +@pytest.mark.parametrize( + ("path", "route_params", "limit_name", "invalid_limit"), + ( + ("/user/daily/activity/aggregated", {}, "api_key_limit", 0), + ( + "/user/daily/activity/aggregated", + {}, + "api_key_limit", + constants.USAGE_TOP_API_KEYS_MAX + 1, + ), + ("/user/daily/activity/aggregated/search", {"search": "key"}, "limit", 0), + ( + "/user/daily/activity/aggregated/search", + {"search": "key"}, + "limit", + constants.USAGE_KEY_SEARCH_MAX + 1, + ), + ( + "/user/daily/activity/aggregated/model_top_keys", + {"model_group": "popular-group"}, + "limit", + 0, + ), + ( + "/user/daily/activity/aggregated/model_top_keys", + {"model_group": "popular-group"}, + "limit", + constants.USAGE_MODEL_TOP_KEYS_MAX + 1, + ), + ( + "/user/daily/activity/aggregated/cache_leakage_keys", + {}, + "limit", + 0, + ), + ( + "/user/daily/activity/aggregated/cache_leakage_keys", + {}, + "limit", + constants.USAGE_CACHE_LEAKAGE_KEYS_MAX + 1, + ), + ), +) +def test_usage_limit_routes_reject_values_outside_bounds( + daily_activity_client: tuple[TestClient, _FakeRepository], + path: str, + route_params: Mapping[str, str], + limit_name: str, + invalid_limit: int, +) -> None: + client, repository = daily_activity_client + response: Final = client.get( + path, + params={ + **_entity_params("user_id", "user-a"), + **route_params, + limit_name: invalid_limit, + }, + ) + + assert response.status_code == 422, response.text + repository.aggregated.assert_not_awaited() + repository.search_keys.assert_not_awaited() + repository.model_top_keys.assert_not_awaited() + repository.cache_leakage_keys.assert_not_awaited() + + +@pytest.mark.parametrize(("prefix", "query_name", "entity_id"), _ENTITY_CASES) +def test_model_top_routes_rank_keys_and_include_metadata( + daily_activity_client: tuple[TestClient, _FakeRepository], prefix: str, query_name: str, entity_id: str +) -> None: + client, repository = daily_activity_client + response: Final = client.get( + f"{prefix}/daily/activity/aggregated/model_top_keys", + params={ + **_entity_params(query_name, entity_id), + "model_group": "rare-group", + "limit": 3, + }, + ) + assert response.status_code == 200, response.text + assert repository.model_top_keys.call_args.kwargs["limit"] == 3 + assert response.json()["model"] == "rare-group" + assert response.json()["by_model_group"] is True + assert tuple(row["api_key"] for row in response.json()["api_keys"]) == ("key-target",) + metrics: Final = response.json()["api_keys"][0]["metrics"] + expected_row: Final = KeySpendRow( + api_key="key-target", + spend=0.5, + prompt_tokens=10, + completion_tokens=5, + total_tokens=15, + api_requests=1, + successful_requests=1, + failed_requests=0, + cache_read_input_tokens=0, + cache_creation_input_tokens=1, + ) + assert set(metrics) == set(KeySpendMetrics.model_fields) + assert metrics == {field: getattr(expected_row, field) for field in KeySpendMetrics.model_fields} + + +@pytest.mark.parametrize(("prefix", "query_name", "entity_id"), _ENTITY_CASES) +def test_export_routes_stream_csv_and_preserve_row_counts( + daily_activity_client: tuple[TestClient, _FakeRepository], + prefix: str, + query_name: str, + entity_id: str, +) -> None: + client, _ = daily_activity_client + response: Final = client.get( + f"{prefix}/daily/activity/export", + params={**_entity_params(query_name, entity_id), "export_type": ExportType.DAILY.value}, + ) + assert response.status_code == 200, response.text + assert response.headers["cache-control"] == "no-store" + assert "attachment;" in response.headers["content-disposition"] + records: Final = tuple(csv.reader(io.StringIO(response.text))) + assert tuple(records[0]) == tuple(field.name for field in fields(ExportRow)) + assert len(records) == 7 + assert records[1][2] == "'=entity" + assert records[1][4] == "'+key" + + +@pytest.mark.parametrize(("prefix", "query_name", "entity_id"), _ENTITY_CASES) +def test_export_routes_stream_json_arrays( + daily_activity_client: tuple[TestClient, _FakeRepository], + prefix: str, + query_name: str, + entity_id: str, +) -> None: + client, _ = daily_activity_client + response: Final = client.get( + f"{prefix}/daily/activity/export", + params={**_entity_params(query_name, entity_id), "format": "json"}, + ) + assert response.status_code == 200, response.text + assert response.headers["content-type"].startswith("application/json") + assert response.headers["cache-control"] == "no-store" + records: Final = response.json() + assert isinstance(records, list) and len(records) == 6, response.text + assert records[0]["entity_alias"] == "=entity" + + +def test_export_first_row_error_returns_json_error_before_streaming( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, repository = daily_activity_client + repository.export_rows_error = RuntimeError("database query failed") + response: Final = client.get( + "/team/daily/activity/export", + params={**_entity_params("team_ids", "team-a"), "format": "csv"}, + ) + assert response.status_code >= 400 + assert response.headers["content-type"].startswith("application/json") + assert response.text != ",".join(field.name for field in fields(ExportRow)) + "\r\n" + assert "database query failed" in response.text + + +def test_csv_export_with_no_rows_contains_only_header( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, _ = daily_activity_client + response: Final = client.get( + "/team/daily/activity/export", + params={**_entity_params("team_ids", "team-a"), "api_key": "missing-key"}, + ) + assert response.status_code == 200, response.text + assert response.text == ",".join(field.name for field in fields(ExportRow)) + "\r\n" + + +def test_json_export_with_no_rows_is_an_empty_array( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, _ = daily_activity_client + response: Final = client.get( + "/team/daily/activity/export", + params={**_entity_params("team_ids", "team-a"), "api_key": "missing-key", "format": "json"}, + ) + assert response.status_code == 200, response.text + assert response.json() == [] + + +def test_user_routes_preserve_scope_denials_and_service_account_guard( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, repository = daily_activity_client + denied: Final = client.get( + "/user/daily/activity/aggregated", + params=_entity_params("user_id", "user-b"), + headers={"x-user-role": LitellmUserRoles.INTERNAL_USER.value, "x-user-id": "user-a"}, + ) + assert denied.status_code == 403, denied.text + repository.aggregated.assert_not_awaited() + + service_account: Final = client.get( + "/user/daily/activity/aggregated", + params=_DATE_PARAMS, + headers={"x-user-role": LitellmUserRoles.INTERNAL_USER.value}, + ) + assert service_account.status_code == 403, service_account.text + repository.aggregated.assert_not_awaited() + + own_scope: Final = client.get( + "/user/daily/activity/aggregated", + params=_DATE_PARAMS, + headers={"x-user-role": LitellmUserRoles.INTERNAL_USER.value, "x-user-id": "user-a"}, + ) + assert own_scope.status_code == 200, own_scope.text + assert own_scope.json()["metadata"]["total_spend"] == pytest.approx(14.5) + assert own_scope.json()["metadata"]["total_api_keys"] == 5 + + +def test_team_scope_applies_membership_and_user_key_filter( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, repository = daily_activity_client + response: Final = client.get( + "/team/daily/activity/aggregated", + params={**_entity_params("team_ids", "team-a"), "timezone": "480"}, + headers={"x-user-role": LitellmUserRoles.INTERNAL_USER.value, "x-user-id": "user-a"}, + ) + assert response.status_code == 200, response.text + assert response.json()["metadata"]["total_spend"] == pytest.approx(3.0) + assert response.json()["metadata"]["total_api_keys"] == 1 + scope: Final = repository.aggregated.call_args.args[0] + assert scope.api_keys == ("key-alpha",) + assert scope.entity_ids == ("team-a",) + assert scope.timezone_offset_minutes == 480 + assert repository.aggregated.call_args.kwargs["include_entity_breakdown"] is True + + +def test_team_scope_does_not_allow_an_unowned_api_key( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, _ = daily_activity_client + response: Final = client.get( + "/team/daily/activity/aggregated", + params={**_entity_params("team_ids", "team-a"), "api_key": "key-beta"}, + headers={"x-user-role": LitellmUserRoles.INTERNAL_USER.value, "x-user-id": "user-a"}, + ) + assert response.status_code == 200, response.text + assert response.json()["metadata"]["total_spend"] == 0 + assert response.json()["metadata"]["total_api_keys"] == 0 + assert "key-beta" not in response.text + + +def _assert_customer_route_denied(client: TestClient, prefix: str, suffix: str, extra_params: dict[str, str]) -> None: + response: Final = client.get( + f"{prefix}/daily/activity/{suffix}", + params={**_entity_params("end_user_ids", "customer-a"), **extra_params}, + headers={"x-user-role": LitellmUserRoles.INTERNAL_USER.value, "x-user-id": "user-a"}, + ) + assert response.status_code == 403, response.text + + +def test_customer_service_routes_deny_non_admins(daily_activity_client: tuple[TestClient, _FakeRepository]) -> None: + client, repository = daily_activity_client + route_params: Final = ( + ("aggregated", {}), + ("aggregated/search", {"search": "alpha"}), + ("aggregated/model_top_keys", {"model_group": "rare-group"}), + ("export", {"export_type": ExportType.DAILY.value}), + ) + for prefix in ("/customer", "/end_user"): + for suffix, extra_params in route_params: + _assert_customer_route_denied(client, prefix, suffix, extra_params) + repository.aggregated.assert_not_awaited() + + +def test_customer_end_user_aliases_are_hidden_from_openapi( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, _ = daily_activity_client + paths: Final = client.get("/openapi.json").json()["paths"] + assert "/customer/daily/activity/aggregated" in paths + assert "/end_user/daily/activity/aggregated" not in paths + response: Final = client.get( + "/end_user/daily/activity/aggregated", + params=_entity_params("end_user_ids", "customer-a"), + ) + assert response.status_code == 200, response.text + + +@pytest.mark.parametrize( + ("prefix", "query_name", "entity_id"), + _ENTITY_CASES[:4] + (_ENTITY_CASES[-1],), +) +@pytest.mark.parametrize( + ("family", "extra_params"), + ( + ("aggregated", {}), + ("aggregated/search", {"search": "key"}), + ("aggregated/model_top_keys", {"model_group": "popular-group"}), + ("export", {"export_type": ExportType.DAILY.value}), + ), +) +def test_non_admin_routes_return_only_permitted_entities_and_keys( + daily_activity_client: tuple[TestClient, _FakeRepository], + prefix: str, + query_name: str, + entity_id: str, + family: str, + extra_params: Mapping[str, str], +) -> None: + client, _ = daily_activity_client + headers: Final = {"x-user-role": LitellmUserRoles.INTERNAL_USER.value, "x-user-id": "user-a"} + response: Final = client.get( + f"{prefix}/daily/activity/{family}", + params={**_entity_params(query_name, entity_id), **extra_params}, + headers=headers, + ) + assert response.status_code == 200, response.text + assert "key-other-" not in response.text, response.text + if prefix in ("/team", "/tag"): + assert "key-beta" not in response.text, response.text + assert "key-alpha" in response.text, response.text + + +def test_empty_scope_filters_fail_closed(daily_activity_client: tuple[TestClient, _FakeRepository]) -> None: + client, _ = daily_activity_client + response: Final = client.get( + "/tag/daily/activity/aggregated", + params=_entity_params("tags", "blue"), + headers={"x-user-role": LitellmUserRoles.INTERNAL_USER.value, "x-user-id": "user-empty"}, + ) + assert response.status_code == 200, response.text + assert response.json()["metadata"]["total_spend"] == 0 + assert response.json()["results"] == [] + + +@pytest.mark.parametrize( + ("prefix", "query_name", "entity_id", "other_entity_id", "exclude_query_name"), + ( + ("/team", "team_ids", "team-a", "team-b", "exclude_team_ids"), + ("/organization", "organization_ids", "org-a", "other-org", "exclude_organization_ids"), + ("/customer", "end_user_ids", "customer-a", "customer-b", "exclude_end_user_ids"), + ("/agent", "agent_ids", "agent-a", "agent-b", "exclude_agent_ids"), + ), +) +def test_exclusion_filters_apply_after_entity_scope( + daily_activity_client: tuple[TestClient, _FakeRepository], + prefix: str, + query_name: str, + entity_id: str, + other_entity_id: str, + exclude_query_name: str, +) -> None: + client, _ = daily_activity_client + response: Final = client.get( + f"{prefix}/daily/activity/aggregated", + params={ + **_DATE_PARAMS, + query_name: f"{entity_id},{other_entity_id}", + exclude_query_name: entity_id, + }, + ) + assert response.status_code == 200, response.text + assert response.json()["metadata"]["total_spend"] == pytest.approx(100) + assert response.json()["metadata"]["total_api_keys"] == 1 + + +def test_csv_formula_escaping_covers_all_supported_leading_characters() -> None: + dangerous_values: Final = ("=sum", "+sum", "-sum", "@sum", "\tsum", "\rsum") + assert tuple(_csv_cell(value) for value in dangerous_values) == tuple(f"'{value}" for value in dangerous_values) + + +def test_user_cache_leakage_route_returns_cache_keys_and_metadata( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, repository = daily_activity_client + response: Final = client.get( + "/user/daily/activity/aggregated/cache_leakage_keys", + params={**_entity_params("user_id", "user-a"), "limit": 4}, + ) + assert response.status_code == 200, response.text + assert repository.cache_leakage_keys.call_args.kwargs["limit"] == 4 + assert tuple(row["api_key"] for row in response.json()["api_keys"]) == ("key-cache",) + metrics: Final = response.json()["api_keys"][0]["metrics"] + expected_row: Final = KeySpendRow( + api_key="key-cache", + spend=2.0, + prompt_tokens=10, + completion_tokens=5, + total_tokens=15, + api_requests=1, + successful_requests=1, + failed_requests=0, + cache_read_input_tokens=20, + cache_creation_input_tokens=1, + ) + assert set(metrics) == set(KeySpendMetrics.model_fields) + assert metrics == {field: getattr(expected_row, field) for field in KeySpendMetrics.model_fields} + assert response.json()["api_keys"][0]["metadata"]["key_alias"] == "alias-key-cache" + repository.cache_leakage_keys.assert_awaited_once() + repository.key_metadata.assert_awaited_once() + assert repository.key_metadata.call_args.args[0] == frozenset(("key-cache",)) + assert repository.key_metadata.call_args.args[1] is not None + + +def test_user_cache_leakage_route_respects_requested_user_scope( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, repository = daily_activity_client + response: Final = client.get( + "/user/daily/activity/aggregated/cache_leakage_keys", + params=_entity_params("user_id", "user-missing"), + ) + assert response.status_code == 200, response.text + assert response.json() == {"api_keys": []} + scope: Final = repository.cache_leakage_keys.call_args.args[0] + assert scope.entity_ids == ("user-missing",) + + +def test_export_json_stream_has_all_seeded_rows(daily_activity_client: tuple[TestClient, _FakeRepository]) -> None: + client, _ = daily_activity_client + response: Final = client.get( + "/user/daily/activity/export", + params={ + **_entity_params("user_id", "user-a"), + "export_type": ExportType.DAILY.value, + "format": "json", + }, + ) + assert response.status_code == 200, response.text + assert response.headers["content-type"].startswith("application/json") + assert len(response.json()) == 6 + + +def test_user_internal_role_is_scoped_to_api_key(daily_activity_client: tuple[TestClient, _FakeRepository]) -> None: + client, _ = daily_activity_client + response: Final = client.get( + "/tag/daily/activity/aggregated", + params=_entity_params("tags", "blue"), + headers={ + "x-user-role": LitellmUserRoles.INTERNAL_USER.value, + "x-user-id": "user-a", + }, + ) + assert response.status_code == 200, response.text + assert response.json()["metadata"]["total_spend"] == pytest.approx(3.0) + + +def test_user_aggregate_keeps_current_day_query_semantics( + daily_activity_client: tuple[TestClient, _FakeRepository], +) -> None: + client, repository = daily_activity_client + response: Final = client.get( + "/user/daily/activity/aggregated", + params={**_DATE_PARAMS, "user_id": "user-a", "timezone": 480, "include_current_utc_day": "true"}, + ) + assert response.status_code == 200, response.text + assert response.json()["metadata"]["total_spend"] == pytest.approx(14.5) + scope: Final = repository.aggregated.call_args.args[0] + assert scope.entity_ids == ("user-a",) + assert scope.timezone_offset_minutes == 480 + assert scope.include_current_utc_day is True + + +@pytest.mark.parametrize( + ("start_date", "end_date", "message"), + ( + ("2020-01-01", "2026-12-31", "at most 400 days"), + ("0000-01-01", "9999-12-31", "valid YYYY-MM-DD"), + ("2024-06-01", "2024-01-01", "on or after"), + ("not-a-date", "2024-01-31", "valid YYYY-MM-DD"), + (None, "2024-01-31", "start_date and end_date"), + ), +) +def test_team_aggregated_route_rejects_bad_date_ranges( + daily_activity_client: tuple[TestClient, _FakeRepository], + start_date: str | None, + end_date: str | None, + message: str, +) -> None: + client, repository = daily_activity_client + response: Final = client.get( + "/team/daily/activity/aggregated", + params={"start_date": start_date, "end_date": end_date, "team_ids": "team-a"}, + ) + assert response.status_code == 400, response.text + assert message in str(response.json()["detail"]), response.text + repository.aggregated.assert_not_awaited() + + +def test_user_aggregate_rejects_missing_dates(daily_activity_client: tuple[TestClient, _FakeRepository]) -> None: + client, repository = daily_activity_client + missing_dates: Final = client.get("/user/daily/activity/aggregated", params={"user_id": "user-a"}) + assert missing_dates.status_code == 400, missing_dates.text + assert missing_dates.json()["detail"] == {"error": "Please provide start_date and end_date"} + repository.aggregated.assert_not_awaited() + + +@pytest.mark.parametrize( + ("start_date", "end_date", "message"), + ( + ("2020-01-01", "2026-12-31", "at most 400 days"), + ("not-a-date", "2024-01-31", "valid YYYY-MM-DD"), + ("2024-06-01", "2024-01-01", "on or after"), + ), +) +def test_user_key_page_rejects_bad_date_ranges( + daily_activity_client: tuple[TestClient, _FakeRepository], + start_date: str, + end_date: str, + message: str, +) -> None: + client, repository = daily_activity_client + response: Final = client.get( + "/user/daily/activity/aggregated/keys", + params={"start_date": start_date, "end_date": end_date, "user_id": "user-a"}, + ) + assert response.status_code == 400, response.text + assert message in str(response.json()["detail"]), response.text + repository.key_page.assert_not_awaited() diff --git a/tests/unit/proxy/management_endpoints/test_internal_user_endpoints.py b/tests/unit/proxy/management_endpoints/test_internal_user_endpoints.py index be8628d7f46..799fe59147c 100644 --- a/tests/unit/proxy/management_endpoints/test_internal_user_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_internal_user_endpoints.py @@ -15,7 +15,6 @@ from fastapi.testclient import TestClient from pytest_mock import MockerFixture from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler - from litellm.proxy._types import ( LiteLLM_UserTableFiltered, LitellmUserRoles, @@ -26,12 +25,10 @@ from litellm.proxy._types import ( UserAPIKeyAuth, ) from litellm.proxy.management_endpoints.internal_user_endpoints import ( - LiteLLM_UserTableWithKeyCount, _authorize_user_list_request, _resolve_org_filter_for_user_search, _resolve_user_email_metadata, _update_internal_user_params, - get_user_key_counts, get_users, new_user, ui_view_users, @@ -2480,185 +2477,6 @@ async def test_get_user_daily_activity_rejects_service_account_caller(monkeypatc mock_get_daily.assert_not_called() -@pytest.mark.asyncio -async def test_get_user_daily_activity_aggregated_rejects_service_account_caller( - monkeypatch, -): - """ - Same security regression as - test_get_user_daily_activity_rejects_service_account_caller, on the - aggregated route. Same shape, raw-SQL builder, same fix. - """ - from unittest.mock import AsyncMock, MagicMock - - from fastapi import HTTPException - - from litellm.proxy.management_endpoints.internal_user_endpoints import ( - get_user_daily_activity_aggregated, - ) - - mock_prisma_client = MagicMock() - monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) - - mock_get_daily_agg = AsyncMock() - monkeypatch.setattr( - "litellm.proxy.management_endpoints.internal_user_endpoints.get_daily_activity_aggregated", - mock_get_daily_agg, - ) - - service_account_key = UserAPIKeyAuth( - user_id=None, - user_role=LitellmUserRoles.INTERNAL_USER, - ) - - with pytest.raises(HTTPException) as exc_info: - await get_user_daily_activity_aggregated( - start_date="2025-01-01", - end_date="2025-01-31", - model=None, - api_key=None, - user_id=None, - timezone=None, - user_api_key_dict=service_account_key, - ) - - assert exc_info.value.status_code == 403 - assert "Service-account keys" in str(exc_info.value.detail) - mock_get_daily_agg.assert_not_called() - - -@pytest.mark.asyncio -@pytest.mark.parametrize("include_current_utc_day", [False, True]) -async def test_get_user_daily_activity_aggregated_admin_global_view(monkeypatch, include_current_utc_day): - """ - Test that admin users can call the aggregated endpoint without a user_id - to get a global view. Also verifies that the correct arguments are forwarded - to the underlying get_daily_activity_aggregated helper. - """ - from unittest.mock import AsyncMock, MagicMock - - from litellm.proxy.management_endpoints.internal_user_endpoints import ( - get_user_daily_activity_aggregated, - ) - - # Mock the prisma client - mock_prisma_client = MagicMock() - monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) - - # Mock the downstream helper so we don't need a real DB - mock_response = MagicMock() - mock_get_daily_agg = AsyncMock(return_value=mock_response) - monkeypatch.setattr( - "litellm.proxy.management_endpoints.internal_user_endpoints.get_daily_activity_aggregated", - mock_get_daily_agg, - ) - - # Admin caller - admin_key_dict = UserAPIKeyAuth( - user_id="admin-user-001", - user_role=LitellmUserRoles.PROXY_ADMIN, - ) - - # Admin calls without user_id → global view (entity_id=None) - result = await get_user_daily_activity_aggregated( - start_date="2025-02-01", - end_date="2025-02-28", - model="gpt-4", - api_key=None, - user_id=None, - timezone=480, - include_current_utc_day=include_current_utc_day, - user_api_key_dict=admin_key_dict, - ) - - assert result is mock_response - - # Verify the helper was called with the right parameters - mock_get_daily_agg.assert_called_once() - repository, scope = mock_get_daily_agg.call_args.args - assert repository is not None - assert scope.table.value == "litellm_dailyuserspend" - assert scope.entity_id_field == "user_id" - assert scope.entity_ids is None - assert scope.start_date == "2025-02-01" - assert scope.end_date == "2025-02-28" - assert scope.model == "gpt-4" - assert scope.api_keys is None - assert scope.timezone_offset_minutes == 480 - assert scope.include_current_utc_day is include_current_utc_day - - -@pytest.mark.asyncio -async def test_get_user_daily_activity_aggregated_non_admin_cannot_view_other_users( - monkeypatch, -): - """ - Same scoping contract as - test_get_user_daily_activity_non_admin_cannot_view_other_users, on the - aggregated route. Non-admins reach this handler now that the route is in - self_managed_routes, so the 403-on-mismatch and default-to-self behaviour - has to hold here too: opening the route must not widen access. - """ - from unittest.mock import AsyncMock, MagicMock, patch - - from fastapi import HTTPException - - from litellm.proxy.management_endpoints.internal_user_endpoints import ( - get_user_daily_activity_aggregated, - ) - - mock_prisma_client = MagicMock() - monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) - - non_admin_key_dict = UserAPIKeyAuth( - user_id="regular-user-123", - user_role=LitellmUserRoles.INTERNAL_USER, - ) - - # Case 1: Non-admin targets another user's data — 403, helper never reached - with patch( - "litellm.proxy.management_endpoints.internal_user_endpoints.get_daily_activity_aggregated", - new_callable=AsyncMock, - ) as mock_get_daily_agg: - with pytest.raises(HTTPException) as exc_info: - await get_user_daily_activity_aggregated( - start_date="2025-01-01", - end_date="2025-01-31", - model=None, - api_key=None, - user_id="other-user-456", - timezone=None, - user_api_key_dict=non_admin_key_dict, - ) - - assert exc_info.value.status_code == 403 - assert "Non-admin users can only view their own spend data" in str(exc_info.value.detail) - mock_get_daily_agg.assert_not_called() - - # Case 2: Non-admin omits user_id — scoped to their own user_id, not global - mock_response = MagicMock() - with patch( - "litellm.proxy.management_endpoints.internal_user_endpoints.get_daily_activity_aggregated", - new_callable=AsyncMock, - return_value=mock_response, - ) as mock_get_daily_agg: - result = await get_user_daily_activity_aggregated( - start_date="2025-01-01", - end_date="2025-01-31", - model=None, - api_key=None, - user_id=None, - timezone=None, - user_api_key_dict=non_admin_key_dict, - ) - - assert result is mock_response - mock_get_daily_agg.assert_called_once() - repository, scope = mock_get_daily_agg.call_args.args - assert repository is not None - assert scope.entity_ids == ("regular-user-123",) - - @pytest.mark.asyncio async def test_delete_user_cleans_up_created_by_invitation_links(mocker): """ diff --git a/tests/unit/proxy/management_endpoints/test_organization_endpoints.py b/tests/unit/proxy/management_endpoints/test_organization_endpoints.py index 48586874788..440f93d1387 100644 --- a/tests/unit/proxy/management_endpoints/test_organization_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_organization_endpoints.py @@ -1292,7 +1292,7 @@ async def test_get_organization_daily_activity_non_admin_without_org_admin_role_ ) assert get_daily_activity_mock.call_args.kwargs["entity_id"] == [] - assert org_table_find_many.call_args.kwargs["where"] == {"organization_id": {"in": []}} + org_table_find_many.assert_not_awaited() @pytest.mark.asyncio diff --git a/tests/unit/proxy/management_endpoints/test_team_endpoints.py b/tests/unit/proxy/management_endpoints/test_team_endpoints.py index 764193c9650..7e8e588fec6 100644 --- a/tests/unit/proxy/management_endpoints/test_team_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_team_endpoints.py @@ -1,10 +1,10 @@ import asyncio import json +from collections.abc import Sequence from contextlib import AbstractContextManager, asynccontextmanager, contextmanager from dataclasses import dataclass from datetime import datetime, timezone from types import SimpleNamespace -from collections.abc import Sequence from typing import Final, Optional, cast from unittest.mock import AsyncMock, MagicMock, PropertyMock, call, patch @@ -14602,129 +14602,6 @@ async def test_new_team_batch_enqueued_token_limit_rejected_for_non_admin(): assert "on a team" in str(exc.value.message) -@pytest.mark.asyncio -async def test_get_team_daily_activity_aggregated_scopes_and_flags(mock_db_client): - """The aggregated endpoint must apply the same non-admin key scoping as the - paginated one and request the per-team entity breakdown with the caller's - timezone, so the Team Usage UI gets every day in one response.""" - from litellm.proxy.management_endpoints.team_endpoints import ( - get_team_daily_activity_aggregated, - ) - - user_id = "test_user_123" - team_id = "test_team_456" - user_api_key_dict = UserAPIKeyAuth( - user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER - ) - - mock_user_info = LiteLLM_UserTable( - user_id=user_id, - teams=[team_id], - max_budget=1000.0, - spend=0.0, - user_email="test@example.com", - user_role="internal_user", - ) - - mock_team_member = Member(user_id=user_id, role="user") - mock_team = MagicMock(spec=LiteLLM_TeamTable) - mock_team.team_id = team_id - mock_team.team_alias = "Test Team" - mock_team.members_with_roles = [mock_team_member] - mock_team.model_dump.return_value = { - "team_id": team_id, - "team_alias": "Test Team", - "members_with_roles": [{"user_id": user_id, "role": "user"}], - } - - user_api_key_1 = MagicMock() - user_api_key_1.token = "user_key_1" - - mock_db_client.db.litellm_teamtable.find_many = AsyncMock(return_value=[mock_team]) - mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock( - return_value=[user_api_key_1] - ) - - with patch( - "litellm.proxy.management_endpoints.team_endpoints.get_user_object", - new_callable=AsyncMock, - ) as mock_get_user_object: - mock_get_user_object.return_value = mock_user_info - - with patch( - "litellm.proxy.management_endpoints.team_endpoints.get_daily_activity_aggregated", - new_callable=AsyncMock, - ) as mock_aggregated: - mock_aggregated.return_value = MagicMock() - - await get_team_daily_activity_aggregated( - team_ids=team_id, - start_date="2024-01-01", - end_date="2024-01-31", - model=None, - api_key=None, - exclude_team_ids=None, - timezone=480, - user_api_key_dict=user_api_key_dict, - ) - - mock_aggregated.assert_called_once() - repository, scope = mock_aggregated.call_args.args - call_kwargs = mock_aggregated.call_args.kwargs - assert repository is not None - assert scope.api_keys == ("user_key_1",) - assert scope.entity_ids == (team_id,) - assert call_kwargs["entity_metadata_field"] == { - team_id: {"team_alias": "Test Team"} - } - assert call_kwargs["include_entity_breakdown"] is True - assert scope.timezone_offset_minutes == 480 - assert scope.table.value == "litellm_dailyteamspend" - - -@pytest.mark.asyncio -@pytest.mark.parametrize( - "start_date,end_date,expected_error", - [ - ("2020-01-01", "2026-12-31", "at most 400 days"), - ("0000-01-01", "9999-12-31", "valid YYYY-MM-DD"), - ("2024-06-01", "2024-01-01", "on or after"), - ("not-a-date", "2024-01-31", "valid YYYY-MM-DD"), - (None, "2024-01-31", "start_date and end_date"), - ], -) -async def test_get_team_daily_activity_aggregated_rejects_bad_ranges( - mock_db_client, start_date, end_date, expected_error -): - """The aggregated endpoint has no pagination bounding its work, so an - unbounded or malformed range must 400 before any query runs.""" - from litellm.proxy.management_endpoints.team_endpoints import ( - get_team_daily_activity_aggregated, - ) - - with patch( - "litellm.proxy.management_endpoints.team_endpoints.get_daily_activity_aggregated", - new_callable=AsyncMock, - ) as mock_aggregated: - with pytest.raises(HTTPException) as exc_info: - await get_team_daily_activity_aggregated( - team_ids=None, - start_date=start_date, - end_date=end_date, - model=None, - api_key=None, - exclude_team_ids=None, - timezone=None, - user_api_key_dict=UserAPIKeyAuth( - user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN - ), - ) - - assert exc_info.value.status_code == 400 - assert expected_error in str(exc_info.value.detail) - mock_aggregated.assert_not_called() - - def _wire_new_team_prisma(mock_db_client): mock_db_client.jsonify_team_object = lambda db_data: db_data mock_db_client.get_data = AsyncMock(return_value=None) diff --git a/ui/litellm-dashboard/src/lib/http/schema.d.ts b/ui/litellm-dashboard/src/lib/http/schema.d.ts index 7bce039cd3e..a240b4ed84a 100644 --- a/ui/litellm-dashboard/src/lib/http/schema.d.ts +++ b/ui/litellm-dashboard/src/lib/http/schema.d.ts @@ -834,6 +834,91 @@ export interface paths { patch?: never; trace?: never; }; + "/agent/daily/activity/aggregated": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Agent Daily Activity Aggregated */ + get: operations["get_agent_daily_activity_aggregated_agent_daily_activity_aggregated_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/agent/daily/activity/aggregated/keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Agent Daily Activity Aggregated Keys */ + get: operations["get_agent_daily_activity_aggregated_keys_agent_daily_activity_aggregated_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/agent/daily/activity/aggregated/model_top_keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Agent Daily Activity Model Top Keys */ + get: operations["get_agent_daily_activity_model_top_keys_agent_daily_activity_aggregated_model_top_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/agent/daily/activity/aggregated/search": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Agent Daily Activity Aggregated Search */ + get: operations["get_agent_daily_activity_aggregated_search_agent_daily_activity_aggregated_search_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/agent/daily/activity/export": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Agent Daily Activity Export */ + get: operations["get_agent_daily_activity_export_agent_daily_activity_export_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; "/alerting/settings": { parameters: { query?: never; @@ -3982,6 +4067,91 @@ export interface paths { patch?: never; trace?: never; }; + "/customer/daily/activity/aggregated": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Customer Daily Activity Aggregated */ + get: operations["get_customer_daily_activity_aggregated_customer_daily_activity_aggregated_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/customer/daily/activity/aggregated/keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Customer Daily Activity Aggregated Keys */ + get: operations["get_customer_daily_activity_aggregated_keys_customer_daily_activity_aggregated_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/customer/daily/activity/aggregated/model_top_keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Customer Daily Activity Model Top Keys */ + get: operations["get_customer_daily_activity_model_top_keys_customer_daily_activity_aggregated_model_top_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/customer/daily/activity/aggregated/search": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Customer Daily Activity Aggregated Search */ + get: operations["get_customer_daily_activity_aggregated_search_customer_daily_activity_aggregated_search_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/customer/daily/activity/export": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Customer Daily Activity Export */ + get: operations["get_customer_daily_activity_export_customer_daily_activity_export_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; "/customer/delete": { parameters: { query?: never; @@ -4542,6 +4712,91 @@ export interface paths { patch?: never; trace?: never; }; + "/end_user/daily/activity/aggregated": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Customer Daily Activity Aggregated */ + get: operations["get_customer_daily_activity_aggregated_end_user_daily_activity_aggregated_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/end_user/daily/activity/aggregated/keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Customer Daily Activity Aggregated Keys */ + get: operations["get_customer_daily_activity_aggregated_keys_end_user_daily_activity_aggregated_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/end_user/daily/activity/aggregated/model_top_keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Customer Daily Activity Model Top Keys */ + get: operations["get_customer_daily_activity_model_top_keys_end_user_daily_activity_aggregated_model_top_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/end_user/daily/activity/aggregated/search": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Customer Daily Activity Aggregated Search */ + get: operations["get_customer_daily_activity_aggregated_search_end_user_daily_activity_aggregated_search_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/end_user/daily/activity/export": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Customer Daily Activity Export */ + get: operations["get_customer_daily_activity_export_end_user_daily_activity_export_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; "/end_user/delete": { parameters: { query?: never; @@ -11093,6 +11348,91 @@ export interface paths { patch?: never; trace?: never; }; + "/organization/daily/activity/aggregated": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Organization Daily Activity Aggregated */ + get: operations["get_organization_daily_activity_aggregated_organization_daily_activity_aggregated_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/organization/daily/activity/aggregated/keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Organization Daily Activity Aggregated Keys */ + get: operations["get_organization_daily_activity_aggregated_keys_organization_daily_activity_aggregated_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/organization/daily/activity/aggregated/model_top_keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Organization Daily Activity Model Top Keys */ + get: operations["get_organization_daily_activity_model_top_keys_organization_daily_activity_aggregated_model_top_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/organization/daily/activity/aggregated/search": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Organization Daily Activity Aggregated Search */ + get: operations["get_organization_daily_activity_aggregated_search_organization_daily_activity_aggregated_search_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/organization/daily/activity/export": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Organization Daily Activity Export */ + get: operations["get_organization_daily_activity_export_organization_daily_activity_export_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; "/organization/delete": { parameters: { query?: never; @@ -15647,6 +15987,91 @@ export interface paths { patch?: never; trace?: never; }; + "/tag/daily/activity/aggregated": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Tag Daily Activity Aggregated */ + get: operations["get_tag_daily_activity_aggregated_tag_daily_activity_aggregated_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/tag/daily/activity/aggregated/keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Tag Daily Activity Aggregated Keys */ + get: operations["get_tag_daily_activity_aggregated_keys_tag_daily_activity_aggregated_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/tag/daily/activity/aggregated/model_top_keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Tag Daily Activity Model Top Keys */ + get: operations["get_tag_daily_activity_model_top_keys_tag_daily_activity_aggregated_model_top_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/tag/daily/activity/aggregated/search": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Tag Daily Activity Aggregated Search */ + get: operations["get_tag_daily_activity_aggregated_search_tag_daily_activity_aggregated_search_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/tag/daily/activity/export": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Tag Daily Activity Export */ + get: operations["get_tag_daily_activity_export_tag_daily_activity_export_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; "/tag/dau": { parameters: { query?: never; @@ -16138,6 +16563,74 @@ export interface paths { patch?: never; trace?: never; }; + "/team/daily/activity/aggregated/keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Team Daily Activity Aggregated Keys */ + get: operations["get_team_daily_activity_aggregated_keys_team_daily_activity_aggregated_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/team/daily/activity/aggregated/model_top_keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Team Daily Activity Model Top Keys */ + get: operations["get_team_daily_activity_model_top_keys_team_daily_activity_aggregated_model_top_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/team/daily/activity/aggregated/search": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Team Daily Activity Aggregated Search */ + get: operations["get_team_daily_activity_aggregated_search_team_daily_activity_aggregated_search_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/team/daily/activity/export": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get Team Daily Activity Export */ + get: operations["get_team_daily_activity_export_team_daily_activity_export_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; "/team/delete": { parameters: { query?: never; @@ -17819,6 +18312,91 @@ export interface paths { patch?: never; trace?: never; }; + "/user/daily/activity/aggregated/cache_leakage_keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get User Daily Activity Cache Leakage Keys */ + get: operations["get_user_daily_activity_cache_leakage_keys_user_daily_activity_aggregated_cache_leakage_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/user/daily/activity/aggregated/keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get User Daily Activity Aggregated Keys */ + get: operations["get_user_daily_activity_aggregated_keys_user_daily_activity_aggregated_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/user/daily/activity/aggregated/model_top_keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get User Daily Activity Model Top Keys */ + get: operations["get_user_daily_activity_model_top_keys_user_daily_activity_aggregated_model_top_keys_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/user/daily/activity/aggregated/search": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get User Daily Activity Aggregated Search */ + get: operations["get_user_daily_activity_aggregated_search_user_daily_activity_aggregated_search_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/user/daily/activity/export": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get User Daily Activity Export */ + get: operations["get_user_daily_activity_export_user_daily_activity_export_get"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; "/user/delete": { parameters: { query?: never; @@ -27151,6 +27729,11 @@ export interface components { */ source: "provider_usage"; }; + /** CacheLeakageKeysResponse */ + CacheLeakageKeysResponse: { + /** Api Keys */ + api_keys: components["schemas"]["KeySpendActivityRow"][]; + }; /** CachePingResponse */ CachePingResponse: { /** Cache Type */ @@ -30170,6 +30753,22 @@ export interface components { */ ssl_verify?: string | null; }; + /** DailyActivityKeyPageResponse */ + DailyActivityKeyPageResponse: { + /** Api Keys */ + api_keys: components["schemas"]["KeySpendActivityRow"][]; + /** Limit */ + limit: number; + /** Offset */ + offset: number; + /** Total Api Keys */ + total_api_keys: number; + }; + /** DailyActivityKeySearchResponse */ + DailyActivityKeySearchResponse: { + /** Api Keys */ + api_keys: components["schemas"]["KeyActivityRow"][]; + }; /** DailySpendData */ DailySpendData: { breakdown?: components["schemas"]["BreakdownMetrics"]; @@ -30977,6 +31576,11 @@ export interface components { /** Parts */ parts: components["schemas"]["TracePart"][]; }; + /** + * ExportType + * @enum {string} + */ + ExportType: "daily" | "daily_with_keys" | "daily_with_models" | "daily_with_users"; /** * FacetListResponse * @description The distinct values one column takes over a filtered query. `data` holds bare values, not entity rows. @@ -32564,6 +33168,13 @@ export interface components { worker_id?: string | null; }; JsonValue: unknown; + /** KeyActivityRow */ + KeyActivityRow: { + /** Api Key */ + api_key: string; + metadata: components["schemas"]["KeyMetadata"]; + metrics: components["schemas"]["SpendMetrics"]; + }; /** KeyHealthResponse */ KeyHealthResponse: { /** @@ -32626,6 +33237,61 @@ export interface components { /** Keys */ keys?: string[] | null; }; + /** KeySpendActivityRow */ + KeySpendActivityRow: { + /** Api Key */ + api_key: string; + metadata: components["schemas"]["KeyMetadata"]; + metrics: components["schemas"]["KeySpendMetrics"]; + }; + /** KeySpendMetrics */ + KeySpendMetrics: { + /** + * Api Requests + * @default 0 + */ + api_requests: number; + /** + * Cache Creation Input Tokens + * @default 0 + */ + cache_creation_input_tokens: number; + /** + * Cache Read Input Tokens + * @default 0 + */ + cache_read_input_tokens: number; + /** + * Completion Tokens + * @default 0 + */ + completion_tokens: number; + /** + * Failed Requests + * @default 0 + */ + failed_requests: number; + /** + * Prompt Tokens + * @default 0 + */ + prompt_tokens: number; + /** + * Spend + * @default 0 + */ + spend: number; + /** + * Successful Requests + * @default 0 + */ + successful_requests: number; + /** + * Total Tokens + * @default 0 + */ + total_tokens: number; + }; /** * KeyUpdateFields * @description Allowlist of bulk-broadcastable fields for /team/key/bulk_update; `extra="forbid"` blocks RBAC/ownership/scope mutations even by team admins. @@ -37312,6 +37978,15 @@ export interface components { /** Cost */ cost: number; }; + /** ModelTopKeysResponse */ + ModelTopKeysResponse: { + /** Api Keys */ + api_keys: components["schemas"]["KeySpendActivityRow"][]; + /** By Model Group */ + by_model_group: boolean; + /** Model */ + model: string; + }; /** * Move * @description A mouse move action. @@ -49724,6 +50399,202 @@ export interface operations { }; }; }; + get_agent_daily_activity_aggregated_agent_daily_activity_aggregated_get: { + parameters: { + query?: { + api_key_limit?: number; + agent_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_agent_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["SpendAnalyticsPaginatedResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_agent_daily_activity_aggregated_keys_agent_daily_activity_aggregated_keys_get: { + parameters: { + query?: { + offset?: number; + limit?: number; + agent_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_agent_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeyPageResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_agent_daily_activity_model_top_keys_agent_daily_activity_aggregated_model_top_keys_get: { + parameters: { + query: { + model_group: string; + by_model_group?: boolean; + limit?: number; + agent_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_agent_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ModelTopKeysResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_agent_daily_activity_aggregated_search_agent_daily_activity_aggregated_search_get: { + parameters: { + query: { + search: string; + limit?: number; + agent_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_agent_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeySearchResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_agent_daily_activity_export_agent_daily_activity_export_get: { + parameters: { + query?: { + export_type?: components["schemas"]["ExportType"]; + format?: "csv" | "json"; + agent_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_agent_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Streamed daily activity export */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": Record[]; + "text/csv": string; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; alerting_settings_alerting_settings_get: { parameters: { query?: never; @@ -54767,6 +55638,202 @@ export interface operations { }; }; }; + get_customer_daily_activity_aggregated_customer_daily_activity_aggregated_get: { + parameters: { + query?: { + api_key_limit?: number; + end_user_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_end_user_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["SpendAnalyticsPaginatedResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_customer_daily_activity_aggregated_keys_customer_daily_activity_aggregated_keys_get: { + parameters: { + query?: { + offset?: number; + limit?: number; + end_user_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_end_user_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeyPageResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_customer_daily_activity_model_top_keys_customer_daily_activity_aggregated_model_top_keys_get: { + parameters: { + query: { + model_group: string; + by_model_group?: boolean; + limit?: number; + end_user_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_end_user_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ModelTopKeysResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_customer_daily_activity_aggregated_search_customer_daily_activity_aggregated_search_get: { + parameters: { + query: { + search: string; + limit?: number; + end_user_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_end_user_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeySearchResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_customer_daily_activity_export_customer_daily_activity_export_get: { + parameters: { + query?: { + export_type?: components["schemas"]["ExportType"]; + format?: "csv" | "json"; + end_user_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_end_user_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Streamed daily activity export */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": Record[]; + "text/csv": string; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; delete_end_user_customer_delete_post: { parameters: { query?: never; @@ -55364,6 +56431,202 @@ export interface operations { }; }; }; + get_customer_daily_activity_aggregated_end_user_daily_activity_aggregated_get: { + parameters: { + query?: { + api_key_limit?: number; + end_user_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_end_user_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["SpendAnalyticsPaginatedResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_customer_daily_activity_aggregated_keys_end_user_daily_activity_aggregated_keys_get: { + parameters: { + query?: { + offset?: number; + limit?: number; + end_user_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_end_user_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeyPageResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_customer_daily_activity_model_top_keys_end_user_daily_activity_aggregated_model_top_keys_get: { + parameters: { + query: { + model_group: string; + by_model_group?: boolean; + limit?: number; + end_user_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_end_user_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ModelTopKeysResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_customer_daily_activity_aggregated_search_end_user_daily_activity_aggregated_search_get: { + parameters: { + query: { + search: string; + limit?: number; + end_user_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_end_user_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeySearchResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_customer_daily_activity_export_end_user_daily_activity_export_get: { + parameters: { + query?: { + export_type?: components["schemas"]["ExportType"]; + format?: "csv" | "json"; + end_user_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_end_user_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Streamed daily activity export */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": Record[]; + "text/csv": string; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; delete_end_user_end_user_delete_post: { parameters: { query?: never; @@ -64202,6 +65465,202 @@ export interface operations { }; }; }; + get_organization_daily_activity_aggregated_organization_daily_activity_aggregated_get: { + parameters: { + query?: { + api_key_limit?: number; + organization_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_organization_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["SpendAnalyticsPaginatedResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_organization_daily_activity_aggregated_keys_organization_daily_activity_aggregated_keys_get: { + parameters: { + query?: { + offset?: number; + limit?: number; + organization_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_organization_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeyPageResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_organization_daily_activity_model_top_keys_organization_daily_activity_aggregated_model_top_keys_get: { + parameters: { + query: { + model_group: string; + by_model_group?: boolean; + limit?: number; + organization_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_organization_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ModelTopKeysResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_organization_daily_activity_aggregated_search_organization_daily_activity_aggregated_search_get: { + parameters: { + query: { + search: string; + limit?: number; + organization_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_organization_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeySearchResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_organization_daily_activity_export_organization_daily_activity_export_get: { + parameters: { + query?: { + export_type?: components["schemas"]["ExportType"]; + format?: "csv" | "json"; + organization_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_organization_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Streamed daily activity export */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": Record[]; + "text/csv": string; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; delete_organization_organization_delete_delete: { parameters: { query?: never; @@ -69246,6 +70705,197 @@ export interface operations { }; }; }; + get_tag_daily_activity_aggregated_tag_daily_activity_aggregated_get: { + parameters: { + query?: { + api_key_limit?: number; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + tags?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["SpendAnalyticsPaginatedResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_tag_daily_activity_aggregated_keys_tag_daily_activity_aggregated_keys_get: { + parameters: { + query?: { + offset?: number; + limit?: number; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + tags?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeyPageResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_tag_daily_activity_model_top_keys_tag_daily_activity_aggregated_model_top_keys_get: { + parameters: { + query: { + model_group: string; + by_model_group?: boolean; + limit?: number; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + tags?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ModelTopKeysResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_tag_daily_activity_aggregated_search_tag_daily_activity_aggregated_search_get: { + parameters: { + query: { + search: string; + limit?: number; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + tags?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeySearchResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_tag_daily_activity_export_tag_daily_activity_export_get: { + parameters: { + query?: { + export_type?: components["schemas"]["ExportType"]; + format?: "csv" | "json"; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + tags?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Streamed daily activity export */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": Record[]; + "text/csv": string; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; get_daily_active_users_tag_dau_get: { parameters: { query?: { @@ -69748,6 +71398,7 @@ export interface operations { get_team_daily_activity_aggregated_team_daily_activity_aggregated_get: { parameters: { query?: { + api_key_limit?: number; team_ids?: string | null; start_date?: string | null; end_date?: string | null; @@ -69782,6 +71433,164 @@ export interface operations { }; }; }; + get_team_daily_activity_aggregated_keys_team_daily_activity_aggregated_keys_get: { + parameters: { + query?: { + offset?: number; + limit?: number; + team_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_team_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeyPageResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_team_daily_activity_model_top_keys_team_daily_activity_aggregated_model_top_keys_get: { + parameters: { + query: { + model_group: string; + by_model_group?: boolean; + limit?: number; + team_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_team_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ModelTopKeysResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_team_daily_activity_aggregated_search_team_daily_activity_aggregated_search_get: { + parameters: { + query: { + search: string; + limit?: number; + team_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_team_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeySearchResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_team_daily_activity_export_team_daily_activity_export_get: { + parameters: { + query?: { + export_type?: components["schemas"]["ExportType"]; + format?: "csv" | "json"; + team_ids?: string | null; + start_date?: string | null; + end_date?: string | null; + model?: string | null; + api_key?: string | null; + exclude_team_ids?: string | null; + timezone?: number | null; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Streamed daily activity export */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": Record[]; + "text/csv": string; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; delete_team_team_delete_post: { parameters: { query?: never; @@ -71871,6 +73680,7 @@ export interface operations { get_user_daily_activity_aggregated_user_daily_activity_aggregated_get: { parameters: { query?: { + api_key_limit?: number; /** @description Start date in YYYY-MM-DD format */ start_date?: string | null; /** @description End date in YYYY-MM-DD format */ @@ -71912,6 +73722,237 @@ export interface operations { }; }; }; + get_user_daily_activity_cache_leakage_keys_user_daily_activity_aggregated_cache_leakage_keys_get: { + parameters: { + query?: { + limit?: number; + /** @description Start date in YYYY-MM-DD format */ + start_date?: string | null; + /** @description End date in YYYY-MM-DD format */ + end_date?: string | null; + /** @description Filter by specific model */ + model?: string | null; + /** @description Filter by specific API key */ + api_key?: string | null; + /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */ + user_id?: string | null; + /** @description Timezone offset in minutes from UTC (e.g., 480 for PST). Matches JavaScript's Date.getTimezoneOffset() convention. */ + timezone?: number | null; + /** @description When the range ends on the caller's current local day, extend it to today's UTC bucket so spend written after the caller's local midnight (in UTC terms) is included. Requires the timezone parameter. Historical ranges are never extended. */ + include_current_utc_day?: boolean; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["CacheLeakageKeysResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_user_daily_activity_aggregated_keys_user_daily_activity_aggregated_keys_get: { + parameters: { + query?: { + offset?: number; + limit?: number; + /** @description Start date in YYYY-MM-DD format */ + start_date?: string | null; + /** @description End date in YYYY-MM-DD format */ + end_date?: string | null; + /** @description Filter by specific model */ + model?: string | null; + /** @description Filter by specific API key */ + api_key?: string | null; + /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */ + user_id?: string | null; + /** @description Timezone offset in minutes from UTC (e.g., 480 for PST). Matches JavaScript's Date.getTimezoneOffset() convention. */ + timezone?: number | null; + /** @description When the range ends on the caller's current local day, extend it to today's UTC bucket so spend written after the caller's local midnight (in UTC terms) is included. Requires the timezone parameter. Historical ranges are never extended. */ + include_current_utc_day?: boolean; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeyPageResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_user_daily_activity_model_top_keys_user_daily_activity_aggregated_model_top_keys_get: { + parameters: { + query: { + model_group: string; + by_model_group?: boolean; + limit?: number; + /** @description Start date in YYYY-MM-DD format */ + start_date?: string | null; + /** @description End date in YYYY-MM-DD format */ + end_date?: string | null; + /** @description Filter by specific model */ + model?: string | null; + /** @description Filter by specific API key */ + api_key?: string | null; + /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */ + user_id?: string | null; + /** @description Timezone offset in minutes from UTC (e.g., 480 for PST). Matches JavaScript's Date.getTimezoneOffset() convention. */ + timezone?: number | null; + /** @description When the range ends on the caller's current local day, extend it to today's UTC bucket so spend written after the caller's local midnight (in UTC terms) is included. Requires the timezone parameter. Historical ranges are never extended. */ + include_current_utc_day?: boolean; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ModelTopKeysResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_user_daily_activity_aggregated_search_user_daily_activity_aggregated_search_get: { + parameters: { + query: { + search: string; + limit?: number; + /** @description Start date in YYYY-MM-DD format */ + start_date?: string | null; + /** @description End date in YYYY-MM-DD format */ + end_date?: string | null; + /** @description Filter by specific model */ + model?: string | null; + /** @description Filter by specific API key */ + api_key?: string | null; + /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */ + user_id?: string | null; + /** @description Timezone offset in minutes from UTC (e.g., 480 for PST). Matches JavaScript's Date.getTimezoneOffset() convention. */ + timezone?: number | null; + /** @description When the range ends on the caller's current local day, extend it to today's UTC bucket so spend written after the caller's local midnight (in UTC terms) is included. Requires the timezone parameter. Historical ranges are never extended. */ + include_current_utc_day?: boolean; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Successful Response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["DailyActivityKeySearchResponse"]; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; + get_user_daily_activity_export_user_daily_activity_export_get: { + parameters: { + query?: { + export_type?: components["schemas"]["ExportType"]; + format?: "csv" | "json"; + /** @description Start date in YYYY-MM-DD format */ + start_date?: string | null; + /** @description End date in YYYY-MM-DD format */ + end_date?: string | null; + /** @description Filter by specific model */ + model?: string | null; + /** @description Filter by specific API key */ + api_key?: string | null; + /** @description Filter by specific user ID. Admins can filter by any user or omit for global view. Non-admins must provide their own user_id. */ + user_id?: string | null; + /** @description Timezone offset in minutes from UTC (e.g., 480 for PST). Matches JavaScript's Date.getTimezoneOffset() convention. */ + timezone?: number | null; + /** @description When the range ends on the caller's current local day, extend it to today's UTC bucket so spend written after the caller's local midnight (in UTC terms) is included. Requires the timezone parameter. Historical ranges are never extended. */ + include_current_utc_day?: boolean; + }; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description Streamed daily activity export */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": Record[]; + "text/csv": string; + }; + }; + /** @description Validation Error */ + 422: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["HTTPValidationError"]; + }; + }; + }; + }; delete_user_user_delete_post: { parameters: { query?: never;