AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.
feat(platform/admin): enhance cost dashboard with token breakdown and averages (#12757)
Zamil Majdy7240dd4fb108
diff --git a/autogpt_platform/backend/backend/data/platform_cost.py b/autogpt_platform/backend/backend/data/platform_cost.pyindex ec27572058..aa539bc66b 100644--- a/autogpt_platform/backend/backend/data/platform_cost.py+++ b/autogpt_platform/backend/backend/data/platform_cost.py@@ -8,6 +8,7 @@ from prisma.models import User as PrismaUserfrom prisma.types import PlatformCostLogCreateInput, PlatformCostLogWhereInputfrom pydantic import BaseModel+from backend.data.db import query_raw_with_schemafrom backend.util.cache import cachedfrom backend.util.json import SafeJson@@ -142,6 +143,7 @@ class UserCostSummary(BaseModel):total_cache_read_tokens: int = 0total_cache_creation_tokens: int = 0request_count: int+ cost_bearing_request_count: int = 0class CostLogRow(BaseModel):@@ -163,12 +165,27 @@ class CostLogRow(BaseModel):cache_creation_tokens: int | None = None+class CostBucket(BaseModel):+ bucket: str+ count: int++class PlatformCostDashboard(BaseModel):by_provider: list[ProviderCostSummary]by_user: list[UserCostSummary]total_cost_microdollars: inttotal_requests: inttotal_users: int+ total_input_tokens: int = 0+ total_output_tokens: int = 0+ avg_input_tokens_per_request: float = 0.0+ avg_output_tokens_per_request: float = 0.0+ avg_cost_microdollars_per_request: float = 0.0+ cost_p50_microdollars: float = 0.0+ cost_p75_microdollars: float = 0.0+ cost_p95_microdollars: float = 0.0+ cost_p99_microdollars: float = 0.0+ cost_buckets: list[CostBucket] = []def _si(row: dict, field: str) -> int:@@ -228,6 +245,66 @@ def _build_prisma_where(return where+def _build_raw_where(+ start: datetime | None,+ end: datetime | None,+ provider: str | None,+ user_id: str | None,+ model: str | None = None,+ block_name: str | None = None,+ tracking_type: str | None = None,+) -> tuple[str, list]:+ """Build a parameterised WHERE clause for raw SQL queries.++ Mirrors the filter logic of ``_build_prisma_where`` so there is a single+ source of truth for which columns are filtered and how. The first clause+ always restricts to ``cost_usd`` tracking type unless *tracking_type* is+ explicitly provided by the caller.+ """+ params: list = []+ clauses: list[str] = []+ idx = 1++ # Always filter by tracking type — defaults to cost_usd for percentile /+ # bucket queries that only make sense on cost-denominated rows.+ tt = tracking_type if tracking_type is not None else "cost_usd"+ clauses.append(f'"trackingType" = ${idx}')+ params.append(tt)+ idx += 1++ if start is not None:+ clauses.append(f'"createdAt" >= ${idx}::timestamptz')+ params.append(start)+ idx += 1++ if end is not None:+ clauses.append(f'"createdAt" <= ${idx}::timestamptz')+ params.append(end)+ idx += 1++ if provider is not None:+ clauses.append(f'"provider" = ${idx}')+ params.append(provider.lower())+ idx += 1++ if user_id is not None:+ clauses.append(f'"userId" = ${idx}')+ params.append(user_id)+ idx += 1++ if model is not None:+ clauses.append(f'"model" = ${idx}')+ params.append(model)+ idx += 1++ if block_name is not None:+ clauses.append(f'LOWER("blockName") = LOWER(${idx})')+ params.append(block_name)+ idx += 1++ return (" AND ".join(clauses), params)++@cached(ttl_seconds=30)async def get_platform_cost_dashboard(start: datetime | None = None,@@ -256,6 +333,14 @@ async def get_platform_cost_dashboard(start, end, provider, user_id, model, block_name, tracking_type)+ # For per-user tracking-type breakdown we intentionally omit the+ # tracking_type filter so cost_usd and tokens rows are always present.+ # This ensures cost_bearing_request_count is correct even when the caller+ # is filtering the main view by a different tracking_type.+ where_no_tracking_type = _build_prisma_where(+ start, end, provider, user_id, model, block_name, tracking_type=None+ )+sum_fields = {"costMicrodollars": True,"inputTokens": True,@@ -266,13 +351,18 @@ async def get_platform_cost_dashboard("trackingAmount": True,}- # Run all four aggregation queries in parallel.- (- by_provider_groups,- by_user_groups,- total_user_groups,- total_agg_groups,- ) = await asyncio.gather(+ # Build parameterised WHERE clause for the raw SQL percentile/bucket+ # queries. Uses _build_raw_where so filter logic is shared with+ # _build_prisma_where and only maintained in one place.+ # Always force tracking_type=None here so _build_raw_where defaults to+ # "cost_usd" — percentile and histogram queries only make sense on+ # cost-denominated rows, regardless of what the caller is filtering.+ raw_where, raw_params = _build_raw_where(+ start, end, provider, user_id, model, block_name, tracking_type=None+ )++ # Queries that always run regardless of tracking_type filter.+ common_queries = [# (provider, trackingType, model) aggregation — no ORDER BY in ORM;# sort by total cost descending in Python after fetch.PrismaLog.prisma().group_by(@@ -288,20 +378,125 @@ async def get_platform_cost_dashboard(sum=sum_fields,count=True,),+ # Per-user cost-bearing request count: group by (userId, trackingType)+ # so we can compute the correct denominator for per-user avg cost.+ # Uses where_no_tracking_type so cost_usd rows are always included+ # even when the caller filters the main view by a different tracking_type.+ PrismaLog.prisma().group_by(+ by=["userId", "trackingType"],+ where=where_no_tracking_type,+ count=True,+ ),# Distinct user count: group by userId, count groups.PrismaLog.prisma().group_by(by=["userId"],where=where,count=True,),- # Total aggregate: group by provider (no limit) to sum across all- # matching rows. Summed in Python to get grand totals.+ # Total aggregate (filtered): group by (provider, trackingType) so we can+ # compute cost-bearing and token-bearing denominators for avg stats.PrismaLog.prisma().group_by(- by=["provider"],+ by=["provider", "trackingType"],where=where,- sum={"costMicrodollars": True},+ sum={+ "costMicrodollars": True,+ "inputTokens": True,+ "outputTokens": True,+ },count=True,),+ # Percentile distribution of cost per request (respects all filters).+ query_raw_with_schema(+ "SELECT"+ " percentile_cont(0.5) WITHIN GROUP"+ ' (ORDER BY "costMicrodollars") as p50,'+ " percentile_cont(0.75) WITHIN GROUP"+ ' (ORDER BY "costMicrodollars") as p75,'+ " percentile_cont(0.95) WITHIN GROUP"+ ' (ORDER BY "costMicrodollars") as p95,'+ " percentile_cont(0.99) WITHIN GROUP"+ ' (ORDER BY "costMicrodollars") as p99'+ ' FROM {schema_prefix}"PlatformCostLog"'+ f" WHERE {raw_where}",+ *raw_params,+ ),+ # Histogram buckets for cost distribution (respects all filters).+ # NULL costMicrodollars is excluded explicitly to prevent such rows+ # from falling through all WHEN clauses into the ELSE '$10+' bucket.+ query_raw_with_schema(+ "SELECT"+ " CASE"+ ' WHEN "costMicrodollars" < 500000'+ " THEN '$0-0.50'"+ ' WHEN "costMicrodollars" < 1000000'+ " THEN '$0.50-1'"+ ' WHEN "costMicrodollars" < 2000000'+ " THEN '$1-2'"+ ' WHEN "costMicrodollars" < 5000000'+ " THEN '$2-5'"+ ' WHEN "costMicrodollars" < 10000000'+ " THEN '$5-10'"+ " ELSE '$10+'"+ " END as bucket,"+ " COUNT(*) as count"+ ' FROM {schema_prefix}"PlatformCostLog"'+ f' WHERE {raw_where} AND "costMicrodollars" IS NOT NULL'+ " GROUP BY bucket"+ ' ORDER BY MIN("costMicrodollars")',+ *raw_params,+ ),+ ]++ # Only run the unfiltered aggregate query when tracking_type is set;+ # when tracking_type is None, the filtered query already contains all+ # tracking types and reusing it avoids a redundant full aggregation.+ if tracking_type is not None:+ common_queries.append(+ # Total aggregate (no tracking_type filter): used to compute+ # cost_bearing_requests and token_bearing_requests denominators so+ # global avg stats remain meaningful when the caller filters the+ # main view by a specific tracking_type (e.g. 'tokens').+ PrismaLog.prisma().group_by(+ by=["provider", "trackingType"],+ where=where_no_tracking_type,+ sum={+ "costMicrodollars": True,+ "inputTokens": True,+ "outputTokens": True,+ },+ count=True,+ )+ )++ results = await asyncio.gather(*common_queries)++ # Unpack results by name for clarity.+ by_provider_groups = results[0]+ by_user_groups = results[1]+ by_user_tracking_groups = results[2]+ total_user_groups = results[3]+ total_agg_groups = results[4]+ percentile_rows = results[5]+ bucket_rows = results[6]+ # When tracking_type is None, the filtered and unfiltered queries are+ # identical — reuse total_agg_groups to avoid the extra DB round-trip.+ total_agg_no_tracking_type_groups = (+ results[7] if tracking_type is not None else total_agg_groups+ )++ # Compute token grand-totals from the unfiltered aggregate so they remain+ # consistent with the avg-token stats (which also use unfiltered data).+ # Using by_provider_groups here would give 0 tokens when tracking_type='cost_usd'+ # because cost_usd rows carry no token data, contradicting non-zero averages.+ total_input_tokens = sum(+ _si(r, "inputTokens")+ for r in total_agg_no_tracking_type_groups+ if r.get("trackingType") == "tokens"+ )+ total_output_tokens = sum(+ _si(r, "outputTokens")+ for r in total_agg_no_tracking_type_groups+ if r.get("trackingType") == "tokens")# Sort by_provider by total cost descending and cap at MAX_PROVIDER_ROWS.@@ -328,6 +523,61 @@ async def get_platform_cost_dashboard(total_cost = sum(_si(r, "costMicrodollars") for r in total_agg_groups)total_requests = sum(_ca(r) for r in total_agg_groups)+ # Extract percentile values from the raw query result.+ pctl = percentile_rows[0] if percentile_rows else {}+ cost_p50 = float(pctl.get("p50") or 0)+ cost_p75 = float(pctl.get("p75") or 0)+ cost_p95 = float(pctl.get("p95") or 0)+ cost_p99 = float(pctl.get("p99") or 0)++ # Build cost bucket list.+ cost_buckets: list[CostBucket] = [+ CostBucket(bucket=r["bucket"], count=int(r["count"])) for r in bucket_rows+ ]++ # Avg-stat numerators and denominators are derived from the unfiltered+ # aggregate so they remain meaningful when the caller filters by a specific+ # tracking_type. Example: filtering by 'tokens' excludes cost_usd rows from+ # total_agg_groups, so avg_cost would always be 0 if we used that; using+ # total_agg_no_tracking_type_groups gives the correct cost_usd total/count.+ avg_cost_total = sum(+ _si(r, "costMicrodollars")+ for r in total_agg_no_tracking_type_groups+ if r.get("trackingType") == "cost_usd"+ )+ cost_bearing_requests = sum(+ _ca(r)+ for r in total_agg_no_tracking_type_groups+ if r.get("trackingType") == "cost_usd"+ )+ avg_input_total = sum(+ _si(r, "inputTokens")+ for r in total_agg_no_tracking_type_groups+ if r.get("trackingType") == "tokens"+ )+ avg_output_total = sum(+ _si(r, "outputTokens")+ for r in total_agg_no_tracking_type_groups+ if r.get("trackingType") == "tokens"+ )+ # Token-bearing request count: only rows where trackingType == "tokens".+ # Token averages must use this denominator; cost_usd rows do not carry tokens.+ token_bearing_requests = sum(+ _ca(r)+ for r in total_agg_no_tracking_type_groups+ if r.get("trackingType") == "tokens"+ )++ # Per-user cost-bearing request count: used for per-user avg cost so the+ # denominator matches the numerator (cost_usd rows only, per user).+ user_cost_bearing_counts: dict[str, int] = {}+ for r in by_user_tracking_groups:+ if r.get("trackingType") == "cost_usd" and r.get("userId"):+ uid = r["userId"]+ user_cost_bearing_counts[uid] = user_cost_bearing_counts.get(uid, 0) + _ca(+ r+ )+return PlatformCostDashboard(by_provider=[ProviderCostSummary(@@ -355,12 +605,35 @@ async def get_platform_cost_dashboard(total_cache_read_tokens=_si(r, "cacheReadTokens"),total_cache_creation_tokens=_si(r, "cacheCreationTokens"),request_count=_ca(r),+ cost_bearing_request_count=user_cost_bearing_counts.get(+ r.get("userId") or "", 0+ ),)for r in by_user_groups],total_cost_microdollars=total_cost,total_requests=total_requests,total_users=total_users,+ total_input_tokens=total_input_tokens,+ total_output_tokens=total_output_tokens,+ avg_input_tokens_per_request=(+ avg_input_total / token_bearing_requests+ if token_bearing_requests > 0+ else 0.0+ ),+ avg_output_tokens_per_request=(+ avg_output_total / token_bearing_requests+ if token_bearing_requests > 0+ else 0.0+ ),+ avg_cost_microdollars_per_request=(+ avg_cost_total / cost_bearing_requests if cost_bearing_requests > 0 else 0.0+ ),+ cost_p50_microdollars=cost_p50,+ cost_p75_microdollars=cost_p75,+ cost_p95_microdollars=cost_p95,+ cost_p99_microdollars=cost_p99,+ cost_buckets=cost_buckets,)diff --git a/autogpt_platform/backend/backend/data/platform_cost_test.py b/autogpt_platform/backend/backend/data/platform_cost_test.pyindex 4a2372628b..ad15fb425b 100644--- a/autogpt_platform/backend/backend/data/platform_cost_test.py+++ b/autogpt_platform/backend/backend/data/platform_cost_test.py@@ -10,6 +10,8 @@ from backend.util.json import SafeJsonfrom .platform_cost import (PlatformCostEntry,+ _build_prisma_where,+ _build_raw_where,_build_where,_mask_email,get_platform_cost_dashboard,@@ -156,6 +158,84 @@ class TestBuildWhere:assert 'p."trackingType" = $3' in sql+class TestBuildPrismaWhere:+ def test_both_start_and_end(self):+ start = datetime(2026, 1, 1, tzinfo=timezone.utc)+ end = datetime(2026, 6, 1, tzinfo=timezone.utc)+ where = _build_prisma_where(start, end, None, None)+ assert where["createdAt"] == {"gte": start, "lte": end}++ def test_end_only(self):+ end = datetime(2026, 6, 1, tzinfo=timezone.utc)+ where = _build_prisma_where(None, end, None, None)+ assert where["createdAt"] == {"lte": end}++ def test_start_only(self):+ start = datetime(2026, 1, 1, tzinfo=timezone.utc)+ where = _build_prisma_where(start, None, None, None)+ assert where["createdAt"] == {"gte": start}++ def test_no_filters(self):+ where = _build_prisma_where(None, None, None, None)+ assert "createdAt" not in where++ def test_provider_lowercased(self):+ where = _build_prisma_where(None, None, "OpenAI", None)+ assert where["provider"] == "openai"++ def test_model_filter(self):+ where = _build_prisma_where(None, None, None, None, model="gpt-4")+ assert where["model"] == "gpt-4"++ def test_block_name_case_insensitive(self):+ where = _build_prisma_where(None, None, None, None, block_name="LLMBlock")+ assert where["blockName"] == {"equals": "LLMBlock", "mode": "insensitive"}++ def test_tracking_type(self):+ where = _build_prisma_where(None, None, None, None, tracking_type="tokens")+ assert where["trackingType"] == "tokens"+++class TestBuildRawWhere:+ def test_end_filter(self):+ end = datetime(2026, 6, 1, tzinfo=timezone.utc)+ sql, params = _build_raw_where(None, end, None, None)+ assert '"createdAt" <= $2::timestamptz' in sql+ assert end in params++ def test_model_filter(self):+ sql, params = _build_raw_where(None, None, None, None, model="gpt-4")+ assert '"model" = $' in sql+ assert "gpt-4" in params++ def test_block_name_filter(self):+ sql, params = _build_raw_where(None, None, None, None, block_name="LLMBlock")+ assert 'LOWER("blockName") = LOWER($' in sql+ assert "LLMBlock" in params++ def test_all_filters_combined(self):+ start = datetime(2026, 1, 1, tzinfo=timezone.utc)+ end = datetime(2026, 6, 1, tzinfo=timezone.utc)+ sql, params = _build_raw_where(+ start, end, "anthropic", "u1", model="claude-3", block_name="LLM"+ )+ # trackingType (default), start, end, provider, user_id, model, block_name+ assert len(params) == 7+ assert "anthropic" in params+ assert "u1" in params+ assert "claude-3" in params+ assert "LLM" in params++ def test_default_tracking_type_is_cost_usd(self):+ sql, params = _build_raw_where(None, None, None, None)+ assert '"trackingType" = $1' in sql+ assert params[0] == "cost_usd"++ def test_explicit_tracking_type_overrides_default(self):+ sql, params = _build_raw_where(None, None, None, None, tracking_type="tokens")+ assert params[0] == "tokens"++def _make_entry(**overrides: object) -> PlatformCostEntry:return PlatformCostEntry.model_validate({@@ -286,8 +366,9 @@ class TestGetPlatformCostDashboard:side_effect=[[provider_row], # by_provider[user_row], # by_user+ [], # by_user_tracking_groups (no cost_usd rows for this user)[{"userId": "u1"}], # distinct users- [provider_row], # total agg+ [provider_row], # total agg (tracking_type=None → same as unfiltered)])mock_actions.find_many = AsyncMock(return_value=[mock_user])@@ -301,6 +382,14 @@ class TestGetPlatformCostDashboard:"backend.data.platform_cost.PrismaUser.prisma",return_value=mock_actions,),+ patch(+ "backend.data.platform_cost.query_raw_with_schema",+ new_callable=AsyncMock,+ side_effect=[+ [{"p50": 1000, "p75": 2000, "p95": 4000, "p99": 5000}],+ [{"bucket": "$0-0.50", "count": 3}],+ ],+ ),):dashboard = await get_platform_cost_dashboard()@@ -313,6 +402,131 @@ class TestGetPlatformCostDashboard:assert dashboard.by_provider[0].total_duration_seconds == 10.5assert len(dashboard.by_user) == 1assert dashboard.by_user[0].email == "a***@b.com"+ assert dashboard.cost_p50_microdollars == 1000+ assert dashboard.cost_p75_microdollars == 2000+ assert dashboard.cost_p95_microdollars == 4000+ assert dashboard.cost_p99_microdollars == 5000+ assert len(dashboard.cost_buckets) == 1+ # total_input/output_tokens come from total_agg_no_tracking_type_groups+ # (provider_row has 1000/500)+ assert dashboard.total_input_tokens == 1000+ assert dashboard.total_output_tokens == 500+ # Token averages must use token_bearing_requests (3) not cost_bearing (0)+ assert dashboard.avg_input_tokens_per_request == pytest.approx(1000 / 3)+ assert dashboard.avg_output_tokens_per_request == pytest.approx(500 / 3)+ # No cost_usd rows in total_agg → avg_cost should be 0+ assert dashboard.avg_cost_microdollars_per_request == 0.0++ @pytest.mark.asyncio+ async def test_cost_bearing_request_count_nonzero_when_filtering_by_tokens(self):+ """When filtering by tracking_type='tokens', cost_bearing_request_count+ must still reflect cost_usd rows because by_user_tracking_groups is+ queried without the tracking_type constraint."""+ # total_agg only has a tokens row (because of the tracking_type filter)+ total_row = _make_group_by_row(+ provider="openai", tracking_type="tokens", cost=0, count=5+ )+ # by_user_tracking_groups returns BOTH rows (no tracking_type filter)+ user_tracking_cost_usd_row = {+ "_count": {"_all": 7},+ "userId": "u1",+ "trackingType": "cost_usd",+ }+ user_tracking_tokens_row = {+ "_count": {"_all": 5},+ "userId": "u1",+ "trackingType": "tokens",+ }++ mock_actions = MagicMock()+ mock_actions.group_by = AsyncMock(+ side_effect=[+ [total_row], # by_provider+ [{"_sum": {}, "_count": {"_all": 5}, "userId": "u1"}], # by_user+ [+ user_tracking_cost_usd_row,+ user_tracking_tokens_row,+ ], # by_user_tracking+ [{"userId": "u1"}], # distinct users+ [total_row], # total agg (filtered)+ [total_row], # total agg (no tracking_type filter)+ ]+ )+ mock_actions.find_many = AsyncMock(return_value=[])++ with (+ patch(+ "backend.data.platform_cost.PrismaLog.prisma",+ return_value=mock_actions,+ ),+ patch(+ "backend.data.platform_cost.PrismaUser.prisma",+ return_value=mock_actions,+ ),+ patch(+ "backend.data.platform_cost.query_raw_with_schema",+ new_callable=AsyncMock,+ side_effect=[[], []],+ ),+ ):+ dashboard = await get_platform_cost_dashboard(tracking_type="tokens")++ # by_user has 1 user with 5 total requests (tokens rows only due to filter)+ # but per-user cost_bearing count should be 7 (from cost_usd rows in+ # by_user_tracking_groups which uses where_no_tracking_type)+ assert len(dashboard.by_user) == 1+ assert dashboard.by_user[0].cost_bearing_request_count == 7++ @pytest.mark.asyncio+ async def test_global_avg_cost_nonzero_when_filtering_by_tokens(self):+ """When filtering by tracking_type='tokens', avg_cost_microdollars_per_request+ must still reflect cost_usd rows from total_agg_no_tracking_type_groups,+ not the filtered total_agg_groups which only has tokens rows."""+ # filtered total_agg only has tokens rows (zero cost)+ tokens_row = _make_group_by_row(+ provider="openai", tracking_type="tokens", cost=0, count=5+ )+ # unfiltered total_agg has both rows (cost_usd carries the actual cost)+ cost_usd_row = _make_group_by_row(+ provider="openai", tracking_type="cost_usd", cost=10_000, count=4+ )++ mock_actions = MagicMock()+ mock_actions.group_by = AsyncMock(+ side_effect=[+ [tokens_row], # by_provider+ [{"_sum": {}, "_count": {"_all": 5}, "userId": "u1"}], # by_user+ [], # by_user_tracking_groups+ [{"userId": "u1"}], # distinct users+ [tokens_row], # total agg (filtered — tokens only)+ [tokens_row, cost_usd_row], # total agg (no tracking_type filter)+ ]+ )+ mock_actions.find_many = AsyncMock(return_value=[])++ with (+ patch(+ "backend.data.platform_cost.PrismaLog.prisma",+ return_value=mock_actions,+ ),+ patch(+ "backend.data.platform_cost.PrismaUser.prisma",+ return_value=mock_actions,+ ),+ patch(+ "backend.data.platform_cost.query_raw_with_schema",+ new_callable=AsyncMock,+ side_effect=[[], []],+ ),+ ):+ dashboard = await get_platform_cost_dashboard(tracking_type="tokens")++ # avg_cost_microdollars_per_request must be non-zero: cost_usd row+ # (10_000 microdollars, 4 requests) is present in the unfiltered agg.+ assert dashboard.avg_cost_microdollars_per_request == pytest.approx(10_000 / 4)+ # avg token stats use token_bearing_requests from unfiltered agg (5)+ assert dashboard.avg_input_tokens_per_request == pytest.approx(1000 / 5)+ assert dashboard.avg_output_tokens_per_request == pytest.approx(500 / 5)@pytest.mark.asyncioasync def test_cache_tokens_aggregated_not_hardcoded(self):@@ -335,8 +549,9 @@ class TestGetPlatformCostDashboard:side_effect=[[provider_row], # by_provider[user_row], # by_user+ [], # by_user_tracking_groups[{"userId": "u2"}], # distinct users- [provider_row], # total agg+ [provider_row], # total agg (tracking_type=None → same as unfiltered)])mock_actions.find_many = AsyncMock(return_value=[])@@ -350,6 +565,14 @@ class TestGetPlatformCostDashboard:"backend.data.platform_cost.PrismaUser.prisma",return_value=mock_actions,),+ patch(+ "backend.data.platform_cost.query_raw_with_schema",+ new_callable=AsyncMock,+ side_effect=[+ [{"p50": 0, "p75": 0, "p95": 0, "p99": 0}],+ [],+ ],+ ),):dashboard = await get_platform_cost_dashboard()@@ -361,7 +584,7 @@ class TestGetPlatformCostDashboard:@pytest.mark.asyncioasync def test_returns_empty_dashboard(self):mock_actions = MagicMock()- mock_actions.group_by = AsyncMock(side_effect=[[], [], [], []])+ mock_actions.group_by = AsyncMock(side_effect=[[], [], [], [], []])mock_actions.find_many = AsyncMock(return_value=[])with (@@ -373,6 +596,11 @@ class TestGetPlatformCostDashboard:"backend.data.platform_cost.PrismaUser.prisma",return_value=mock_actions,),+ patch(+ "backend.data.platform_cost.query_raw_with_schema",+ new_callable=AsyncMock,+ side_effect=[[], []],+ ),):dashboard = await get_platform_cost_dashboard()@@ -381,15 +609,18 @@ class TestGetPlatformCostDashboard:assert dashboard.total_users == 0assert dashboard.by_provider == []assert dashboard.by_user == []+ assert dashboard.cost_p50_microdollars == 0+ assert dashboard.cost_buckets == []@pytest.mark.asyncioasync def test_passes_filters_to_queries(self):start = datetime(2026, 1, 1, tzinfo=timezone.utc)mock_actions = MagicMock()- mock_actions.group_by = AsyncMock(side_effect=[[], [], [], []])+ mock_actions.group_by = AsyncMock(side_effect=[[], [], [], [], []])mock_actions.find_many = AsyncMock(return_value=[])+ raw_mock = AsyncMock(side_effect=[[], []])with (patch("backend.data.platform_cost.PrismaLog.prisma",@@ -399,16 +630,63 @@ class TestGetPlatformCostDashboard:"backend.data.platform_cost.PrismaUser.prisma",return_value=mock_actions,),+ patch(+ "backend.data.platform_cost.query_raw_with_schema",+ raw_mock,+ ),):await get_platform_cost_dashboard(start=start, provider="openai", user_id="u1")- # group_by called 4 times (by_provider, by_user, distinct users, totals)- assert mock_actions.group_by.await_count == 4+ # group_by called 5 times (by_provider, by_user, by_user_tracking, distinct users,+ # total agg filtered); the 6th call (total agg no-tracking-type) only runs+ # when tracking_type is set.+ assert mock_actions.group_by.await_count == 5# The where dict passed to the first call should include createdAtfirst_call_kwargs = mock_actions.group_by.call_args_list[0][1]assert "createdAt" in first_call_kwargs.get("where", {})+ # Raw SQL queries should receive provider and user_id as parameters+ assert raw_mock.await_count == 2+ raw_call_args = raw_mock.call_args_list[0][0] # positional args of 1st call+ raw_params = raw_call_args[1:] # first arg is the query template+ assert "openai" in raw_params+ assert "u1" in raw_params++ @pytest.mark.asyncio+ async def test_user_tracking_groups_excludes_tracking_type_filter(self):+ """by_user_tracking_groups must NOT apply the tracking_type filter so that+ cost_usd rows are always included even when the caller filters by 'tokens'."""+ mock_actions = MagicMock()+ mock_actions.group_by = AsyncMock(side_effect=[[], [], [], [], [], []])+ mock_actions.find_many = AsyncMock(return_value=[])++ with (+ patch(+ "backend.data.platform_cost.PrismaLog.prisma",+ return_value=mock_actions,+ ),+ patch(+ "backend.data.platform_cost.PrismaUser.prisma",+ return_value=mock_actions,+ ),+ patch(+ "backend.data.platform_cost.query_raw_with_schema",+ new_callable=AsyncMock,+ side_effect=[[], []],+ ),+ ):+ await get_platform_cost_dashboard(tracking_type="tokens")++ # Call index 2 is by_user_tracking_groups (0=by_provider, 1=by_user,+ # 2=by_user_tracking, 3=distinct_users, 4=total_agg, 5=total_agg_no_tt).+ tracking_call_where = mock_actions.group_by.call_args_list[2][1]["where"]+ # The main filter applies trackingType; by_user_tracking must NOT.+ assert "trackingType" not in tracking_call_where+ # Other filters (e.g., date range, provider) are still passed through.+ # The first call (by_provider) should have trackingType in its where dict.+ provider_call_where = mock_actions.group_by.call_args_list[0][1]["where"]+ assert "trackingType" in provider_call_wheredef _make_prisma_log_row(diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/__tests__/PlatformCostContent.test.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/__tests__/PlatformCostContent.test.tsxindex 5944e94ea7..bde8507b37 100644--- a/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/__tests__/PlatformCostContent.test.tsx+++ b/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/__tests__/PlatformCostContent.test.tsx@@ -29,6 +29,16 @@ const emptyDashboard: PlatformCostDashboard = {total_cost_microdollars: 0,total_requests: 0,total_users: 0,+ total_input_tokens: 0,+ total_output_tokens: 0,+ avg_input_tokens_per_request: 0,+ avg_output_tokens_per_request: 0,+ avg_cost_microdollars_per_request: 0,+ cost_p50_microdollars: 0,+ cost_p75_microdollars: 0,+ cost_p95_microdollars: 0,+ cost_p99_microdollars: 0,+ cost_buckets: [],by_provider: [],by_user: [],};@@ -47,6 +57,20 @@ const dashboardWithData: PlatformCostDashboard = {total_cost_microdollars: 5_000_000,total_requests: 100,total_users: 5,+ total_input_tokens: 150000,+ total_output_tokens: 60000,+ avg_input_tokens_per_request: 2500,+ avg_output_tokens_per_request: 1000,+ avg_cost_microdollars_per_request: 83333,+ cost_p50_microdollars: 50000,+ cost_p75_microdollars: 100000,+ cost_p95_microdollars: 250000,+ cost_p99_microdollars: 500000,+ cost_buckets: [+ { bucket: "$0-0.50", count: 80 },+ { bucket: "$0.50-1", count: 15 },+ { bucket: "$1-2", count: 5 },+ ],by_provider: [{provider: "openai",@@ -75,6 +99,7 @@ const dashboardWithData: PlatformCostDashboard = {total_input_tokens: 50000,total_output_tokens: 20000,request_count: 60,+ cost_bearing_request_count: 40,},],};@@ -134,9 +159,14 @@ describe("PlatformCostContent", () => {await waitFor(() =>expect(document.querySelector(".animate-pulse")).toBeNull(),);- // Verify the two summary cards that show $0.0000 — Known Cost and Estimated Total+ // Known Cost and Estimated Total cards render $0.0000+ // "Known Cost" appears in both the SummaryCard and the ProviderTable header+ expect(screen.getAllByText("Known Cost").length).toBeGreaterThanOrEqual(1);+ expect(screen.getByText("Estimated Total")).toBeDefined();+ // All cost summary cards (Known Cost, Estimated Total, Avg Cost,+ // Typical/Upper/High/Peak Cost) show $0.0000const zeroCostItems = screen.getAllByText("$0.0000");- expect(zeroCostItems.length).toBe(2);+ expect(zeroCostItems.length).toBe(7);expect(screen.getByText("No cost data yet")).toBeDefined();});@@ -155,7 +185,9 @@ describe("PlatformCostContent", () => {);expect(screen.getByText("$5.0000")).toBeDefined();expect(screen.getByText("100")).toBeDefined();- expect(screen.getByText("5")).toBeDefined();+ // "5" appears in multiple places (Active Users card + bucket count),+ // so verify at least one element renders it.+ expect(screen.getAllByText("5").length).toBeGreaterThanOrEqual(1);expect(screen.getByText("openai")).toBeDefined();expect(screen.getByText("google_maps")).toBeDefined();});@@ -223,10 +255,83 @@ describe("PlatformCostContent", () => {await waitFor(() =>expect(document.querySelector(".animate-pulse")).toBeNull(),);+ // Original 4 cardsexpect(screen.getAllByText("Known Cost").length).toBeGreaterThanOrEqual(1);expect(screen.getByText("Estimated Total")).toBeDefined();expect(screen.getByText("Total Requests")).toBeDefined();expect(screen.getByText("Active Users")).toBeDefined();+ // New average/token cards+ expect(screen.getByText("Avg Cost / Request")).toBeDefined();+ expect(screen.getByText("Avg Input Tokens")).toBeDefined();+ expect(screen.getByText("Avg Output Tokens")).toBeDefined();+ expect(screen.getByText("Total Tokens")).toBeDefined();+ // Percentile cards (friendlier labels)+ expect(screen.getByText("Typical Cost (P50)")).toBeDefined();+ expect(screen.getByText("Upper Cost (P75)")).toBeDefined();+ expect(screen.getByText("High Cost (P95)")).toBeDefined();+ expect(screen.getByText("Peak Cost (P99)")).toBeDefined();+ });++ it("renders cost distribution buckets", async () => {+ mockUseGetDashboard.mockReturnValue({+ data: dashboardWithData,+ isLoading: false,+ });+ mockUseGetLogs.mockReturnValue({+ data: logsWithData,+ isLoading: false,+ });+ renderComponent();+ await waitFor(() =>+ expect(document.querySelector(".animate-pulse")).toBeNull(),+ );+ expect(screen.getByText("Cost Distribution by Bucket")).toBeDefined();+ expect(screen.getByText("$0-0.50")).toBeDefined();+ expect(screen.getByText("$0.50-1")).toBeDefined();+ expect(screen.getByText("$1-2")).toBeDefined();+ expect(screen.getByText("80")).toBeDefined();+ expect(screen.getByText("15")).toBeDefined();+ });++ it("renders new summary card values from fixture data", async () => {+ mockUseGetDashboard.mockReturnValue({+ data: dashboardWithData,+ isLoading: false,+ });+ mockUseGetLogs.mockReturnValue({+ data: logsWithData,+ isLoading: false,+ });+ renderComponent();+ await waitFor(() =>+ expect(document.querySelector(".animate-pulse")).toBeNull(),+ );+ // Avg Input Tokens: 2500 formatted+ expect(screen.getByText("2,500")).toBeDefined();+ // Avg Output Tokens: 1000 formatted+ expect(screen.getByText("1,000")).toBeDefined();+ // P50 cost: 50000 microdollars = $0.0500+ expect(screen.getByText("$0.0500")).toBeDefined();+ });++ it("renders user table avg cost column with fixture data", async () => {+ mockUseGetDashboard.mockReturnValue({+ data: dashboardWithData,+ isLoading: false,+ });+ mockUseGetLogs.mockReturnValue({+ data: logsWithData,+ isLoading: false,+ });+ renderComponent({ tab: "by-user" });+ await waitFor(() =>+ expect(document.querySelector(".animate-pulse")).toBeNull(),+ );+ // User table should show Avg Cost / Req header+ expect(screen.getByText("Avg Cost / Req")).toBeDefined();+ // Input/Output token columns+ expect(screen.getByText("Input Tokens")).toBeDefined();+ expect(screen.getByText("Output Tokens")).toBeDefined();});it("renders filter inputs", async () => {diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/PlatformCostContent.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/PlatformCostContent.tsxindex 749a2136a3..ce0329af19 100644--- a/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/PlatformCostContent.tsx+++ b/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/PlatformCostContent.tsx@@ -2,12 +2,13 @@import { Alert, AlertDescription } from "@/components/molecules/Alert/Alert";import { Skeleton } from "@/components/atoms/Skeleton/Skeleton";-import { formatMicrodollars } from "../helpers";+import { formatMicrodollars, formatTokens } from "../helpers";import { SummaryCard } from "./SummaryCard";import { ProviderTable } from "./ProviderTable";import { UserTable } from "./UserTable";import { LogsTable } from "./LogsTable";import { usePlatformCostContent } from "./usePlatformCostContent";+import type { CostBucket } from "@/app/api/__generated__/models/costBucket";interface Props {searchParams: {@@ -54,6 +55,76 @@ export function PlatformCostContent({ searchParams }: Props) {handleExport,} = usePlatformCostContent(searchParams);+ const summaryCards: { label: string; value: string; subtitle?: string }[] =+ dashboard+ ? [+ {+ label: "Known Cost",+ value: formatMicrodollars(dashboard.total_cost_microdollars),+ subtitle: "From providers that report USD cost",+ },+ {+ label: "Estimated Total",+ value: formatMicrodollars(totalEstimatedCost),+ subtitle: "Including per-run cost estimates",+ },+ {+ label: "Total Requests",+ value: dashboard.total_requests.toLocaleString(),+ },+ {+ label: "Active Users",+ value: dashboard.total_users.toLocaleString(),+ },+ {+ label: "Avg Cost / Request",+ value: formatMicrodollars(+ dashboard.avg_cost_microdollars_per_request ?? 0,+ ),+ subtitle: "Known cost divided by cost-bearing requests",+ },+ {+ label: "Avg Input Tokens",+ value: Math.round(+ dashboard.avg_input_tokens_per_request ?? 0,+ ).toLocaleString(),+ subtitle: "Prompt tokens per request (context size)",+ },+ {+ label: "Avg Output Tokens",+ value: Math.round(+ dashboard.avg_output_tokens_per_request ?? 0,+ ).toLocaleString(),+ subtitle: "Completion tokens per request (response length)",+ },+ {+ label: "Total Tokens",+ value: `${formatTokens(dashboard.total_input_tokens ?? 0)} in / ${formatTokens(dashboard.total_output_tokens ?? 0)} out`,+ subtitle: "Prompt vs completion token split",+ },+ {+ label: "Typical Cost (P50)",+ value: formatMicrodollars(dashboard.cost_p50_microdollars ?? 0),+ subtitle: "Median cost per request",+ },+ {+ label: "Upper Cost (P75)",+ value: formatMicrodollars(dashboard.cost_p75_microdollars ?? 0),+ subtitle: "75th percentile cost",+ },+ {+ label: "High Cost (P95)",+ value: formatMicrodollars(dashboard.cost_p95_microdollars ?? 0),+ subtitle: "95th percentile cost",+ },+ {+ label: "Peak Cost (P99)",+ value: formatMicrodollars(dashboard.cost_p99_microdollars ?? 0),+ subtitle: "99th percentile cost",+ },+ ]+ : [];+return (<div className="flex flex-col gap-6"><div className="flex flex-wrap items-end gap-3 rounded-lg border p-4">@@ -204,37 +275,54 @@ export function PlatformCostContent({ searchParams }: Props) {{loading ? (<div className="flex flex-col gap-4">- <div className="grid grid-cols-2 gap-4 md:grid-cols-4">- {[...Array(4)].map((_, i) => (+ <div className="grid grid-cols-2 gap-4 sm:grid-cols-3 md:grid-cols-4">+ {/* 12 skeleton placeholders — one per summary card */}+ {Array.from({ length: 12 }, (_, i) => (<Skeleton key={i} className="h-20 rounded-lg" />))}</div>+ <Skeleton className="h-32 rounded-lg" /><Skeleton className="h-8 w-48 rounded" /><Skeleton className="h-64 rounded-lg" /></div>) : (<>{dashboard && (- <div className="grid grid-cols-2 gap-4 md:grid-cols-4">- <SummaryCard- label="Known Cost"- value={formatMicrodollars(dashboard.total_cost_microdollars)}- subtitle="From providers that report USD cost"- />- <SummaryCard- label="Estimated Total"- value={formatMicrodollars(totalEstimatedCost)}- subtitle="Including per-run cost estimates"- />- <SummaryCard- label="Total Requests"- value={dashboard.total_requests.toLocaleString()}- />- <SummaryCard- label="Active Users"- value={dashboard.total_users.toLocaleString()}- />- </div>+ <>+ <div className="grid grid-cols-2 gap-4 sm:grid-cols-3 md:grid-cols-4">+ {summaryCards.map((card) => (+ <SummaryCard+ key={card.label}+ label={card.label}+ value={card.value}+ subtitle={card.subtitle}+ />+ ))}+ </div>++ {dashboard.cost_buckets && dashboard.cost_buckets.length > 0 && (+ <div className="rounded-lg border p-4">+ <h3 className="mb-3 text-sm font-medium">+ Cost Distribution by Bucket+ </h3>+ <div className="grid grid-cols-2 gap-2 sm:grid-cols-3 md:grid-cols-6">+ {dashboard.cost_buckets.map((b: CostBucket) => (+ <div+ key={b.bucket}+ className="flex flex-col items-center rounded border p-2 text-center"+ >+ <span className="text-xs text-muted-foreground">+ {b.bucket}+ </span>+ <span className="text-lg font-semibold">+ {b.count.toLocaleString()}+ </span>+ </div>+ ))}+ </div>+ </div>+ )}+ </>)}<divdiff --git a/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/ProviderTable.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/ProviderTable.tsxindex db100e0220..22c8ccc3a8 100644--- a/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/ProviderTable.tsx+++ b/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/ProviderTable.tsx@@ -3,6 +3,7 @@ import {defaultRateFor,estimateCostForRow,formatMicrodollars,+ formatTokens,rateKey,rateUnitLabel,trackingValue,@@ -33,6 +34,20 @@ function ProviderTable({ data, rateOverrides, onRateOverride }: Props) {<th scope="col" className="px-4 py-3 text-right">Usage</th>+ <th+ scope="col"+ className="px-4 py-3 text-right"+ title="Only populated for token-tracking providers (e.g. LLM calls). Non-token rows (per_run, characters, etc.) show —."+ >+ Input Tokens+ </th>+ <th+ scope="col"+ className="px-4 py-3 text-right"+ title="Only populated for token-tracking providers (e.g. LLM calls). Non-token rows (per_run, characters, etc.) show —."+ >+ Output Tokens+ </th><th scope="col" className="px-4 py-3 text-right">Requests</th>@@ -74,6 +89,16 @@ function ProviderTable({ data, rateOverrides, onRateOverride }: Props) {<TrackingBadge trackingType={row.tracking_type} /></td><td className="px-4 py-3 text-right">{trackingValue(row)}</td>+ <td className="px-4 py-3 text-right">+ {row.total_input_tokens > 0+ ? formatTokens(row.total_input_tokens)+ : "-"}+ </td>+ <td className="px-4 py-3 text-right">+ {row.total_output_tokens > 0+ ? formatTokens(row.total_output_tokens)+ : "-"}+ </td><td className="px-4 py-3 text-right">{row.request_count.toLocaleString()}</td>@@ -124,7 +149,7 @@ function ProviderTable({ data, rateOverrides, onRateOverride }: Props) {{data.length === 0 && (<tr><td- colSpan={8}+ colSpan={10}className="px-4 py-8 text-center text-muted-foreground">No cost data yetdiff --git a/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/UserTable.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/UserTable.tsxindex c2ee70ce72..aa14ca175c 100644--- a/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/UserTable.tsx+++ b/autogpt_platform/frontend/src/app/(platform)/admin/platform-costs/components/UserTable.tsx@@ -27,10 +27,7 @@ function UserTable({ data }: Props) {Output Tokens</th><th scope="col" className="px-4 py-3 text-right">- Cache Read- </th>- <th scope="col" className="px-4 py-3 text-right">- Cache Write+ Avg Cost / Req</th></tr></thead>@@ -61,13 +58,12 @@ function UserTable({ data }: Props) {{formatTokens(row.total_output_tokens)}</td><td className="px-4 py-3 text-right">- {(row.total_cache_read_tokens ?? 0) > 0- ? formatTokens(row.total_cache_read_tokens ?? 0)- : "-"}- </td>- <td className="px-4 py-3 text-right">- {(row.total_cache_creation_tokens ?? 0) > 0- ? formatTokens(row.total_cache_creation_tokens ?? 0)+ {(row.cost_bearing_request_count ?? 0) > 0 &&+ row.total_cost_microdollars > 0+ ? formatMicrodollars(+ row.total_cost_microdollars /+ (row.cost_bearing_request_count ?? 1),+ ): "-"}</td></tr>@@ -75,7 +71,7 @@ function UserTable({ data }: Props) {{data.length === 0 && (<tr><td- colSpan={7}+ colSpan={6}className="px-4 py-8 text-center text-muted-foreground">No cost data yetdiff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.jsonindex 43f14a13fd..732ef569d9 100644--- a/autogpt_platform/frontend/src/app/api/openapi.json+++ b/autogpt_platform/frontend/src/app/api/openapi.json@@ -9123,6 +9123,15 @@],"title": "ContentType"},+ "CostBucket": {+ "properties": {+ "bucket": { "type": "string", "title": "Bucket" },+ "count": { "type": "integer", "title": "Count" }+ },+ "type": "object",+ "required": ["bucket", "count"],+ "title": "CostBucket"+ },"CostLogRow": {"properties": {"id": { "type": "string", "title": "Id" },@@ -12141,7 +12150,58 @@"title": "Total Cost Microdollars"},"total_requests": { "type": "integer", "title": "Total Requests" },- "total_users": { "type": "integer", "title": "Total Users" }+ "total_users": { "type": "integer", "title": "Total Users" },+ "total_input_tokens": {+ "type": "integer",+ "title": "Total Input Tokens",+ "default": 0+ },+ "total_output_tokens": {+ "type": "integer",+ "title": "Total Output Tokens",+ "default": 0+ },+ "avg_input_tokens_per_request": {+ "type": "number",+ "title": "Avg Input Tokens Per Request",+ "default": 0.0+ },+ "avg_output_tokens_per_request": {+ "type": "number",+ "title": "Avg Output Tokens Per Request",+ "default": 0.0+ },+ "avg_cost_microdollars_per_request": {+ "type": "number",+ "title": "Avg Cost Microdollars Per Request",+ "default": 0.0+ },+ "cost_p50_microdollars": {+ "type": "number",+ "title": "Cost P50 Microdollars",+ "default": 0.0+ },+ "cost_p75_microdollars": {+ "type": "number",+ "title": "Cost P75 Microdollars",+ "default": 0.0+ },+ "cost_p95_microdollars": {+ "type": "number",+ "title": "Cost P95 Microdollars",+ "default": 0.0+ },+ "cost_p99_microdollars": {+ "type": "number",+ "title": "Cost P99 Microdollars",+ "default": 0.0+ },+ "cost_buckets": {+ "items": { "$ref": "#/components/schemas/CostBucket" },+ "type": "array",+ "title": "Cost Buckets",+ "default": []+ }},"type": "object","required": [@@ -15585,7 +15645,12 @@"title": "Total Cache Creation Tokens","default": 0},- "request_count": { "type": "integer", "title": "Request Count" }+ "request_count": { "type": "integer", "title": "Request Count" },+ "cost_bearing_request_count": {+ "type": "integer",+ "title": "Cost Bearing Request Count",+ "default": 0+ }},"type": "object","required": [