Skip to content

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.

fix(platform): plot admin accuracy trends oldest-first and only count scored days (#15641)

Nicholas Tindle8f45927ed4d1
diff --git a/autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes.py b/autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes.py
index e4e37ac15c..f2ac28c642 100644
--- a/autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes.py
+++ b/autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes.py
@@ -4,7 +4,7 @@ from datetime import datetime
from typing import Optional
from autogpt_libs.auth import get_user_id, requires_admin_user
-from fastapi import APIRouter, HTTPException, Security
+from fastapi import APIRouter, HTTPException, Query, Security
from pydantic import BaseModel, Field
from backend.blocks.llm import DEFAULT_LLM_MODEL, LLMModel
@@ -453,7 +453,7 @@ async def _process_batch(
async def get_execution_accuracy_trends(
graph_id: str,
user_id: Optional[str] = None,
- days_back: int = 30,
+ days_back: int = Query(30, description="Number of days to look back", ge=7, le=90),
drop_threshold: float = 10.0,
include_historical: bool = False,
admin_user_id: str = Security(get_user_id),
diff --git a/autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes_test.py b/autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes_test.py
index c4e4b976f7..10a2de5bd8 100644
--- a/autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes_test.py
+++ b/autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes_test.py
@@ -1,14 +1,20 @@
+from datetime import datetime, timezone
from types import SimpleNamespace
from unittest.mock import AsyncMock, patch
+import fastapi
+import fastapi.testclient
import pytest
+from autogpt_libs.auth.jwt_utils import get_jwt_payload
from backend.api.features.admin.execution_analytics_routes import (
ExecutionAnalyticsRequest,
ExecutionAnalyticsResult,
_process_batch,
generate_execution_analytics,
+ router,
)
+from backend.data.analytics import AccuracyLatestData, AccuracyTrendsResponse
from backend.data.execution import ExecutionStatus, GraphExecutionMeta
from backend.executor.activity_status_generator import INSUFFICIENT_BALANCE_SUMMARY
from backend.util.exceptions import ExecutionFailureReason
@@ -29,7 +35,7 @@ async def test_process_batch_allows_credit_failure_without_openai_key():
started_at=None,
ended_at=None,
)
- request = ExecutionAnalyticsRequest(graph_id="graph-1")
+ request = ExecutionAnalyticsRequest.model_validate({"graph_id": "graph-1"})
with (
patch(
"backend.api.features.admin.execution_analytics_routes.update_graph_execution_stats",
@@ -44,6 +50,7 @@ async def test_process_batch_allows_credit_failure_without_openai_key():
assert results[0].status == "success"
assert results[0].score == 0.0
mock_update.assert_awaited_once()
+ assert mock_update.await_args is not None
update_call = mock_update.await_args.kwargs
assert update_call["graph_exec_id"] == "exec-1"
updated_stats = update_call["stats"]
@@ -66,7 +73,7 @@ async def test_process_batch_skips_non_credit_failure_without_llm_client():
ended_at=None,
)
db_client = AsyncMock()
- request = ExecutionAnalyticsRequest(graph_id="graph-1")
+ request = ExecutionAnalyticsRequest.model_validate({"graph_id": "graph-1"})
with (
patch(
@@ -120,7 +127,7 @@ async def test_generate_analytics_only_skips_complete_existing_analysis():
started_at=None,
ended_at=None,
)
- request = ExecutionAnalyticsRequest(graph_id="graph-1")
+ request = ExecutionAnalyticsRequest.model_validate({"graph_id": "graph-1"})
processed_result = ExecutionAnalyticsResult(
agent_id="graph-1",
version_id=1,
@@ -202,7 +209,7 @@ async def test_generate_analytics_counts_processed_rows_skipped():
),
):
response = await generate_execution_analytics(
- ExecutionAnalyticsRequest(graph_id="graph-1"),
+ ExecutionAnalyticsRequest.model_validate({"graph_id": "graph-1"}),
admin_user_id="admin-1",
)
@@ -211,3 +218,58 @@ async def test_generate_analytics_counts_processed_rows_skipped():
assert response.failed_analytics == 0
assert response.skipped_executions == 1
assert response.results == [skipped_result]
+
+
+# --- GET /admin/execution_accuracy_trends: days_back bounds -----------------
+
+
+def accuracy_client(mock_jwt_admin):
+ app = fastapi.FastAPI()
+ app.include_router(router)
+ app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
+ yield fastapi.testclient.TestClient(app)
+ app.dependency_overrides.clear()
+
+
[email protected]("days_back", [-1, 0, 6, 91, 100000000])
+def test_accuracy_trends_rejects_out_of_range_days_back(accuracy_client, days_back):
+ with patch(
+ "backend.api.features.admin.execution_analytics_routes.get_accuracy_trends_and_alerts",
+ new=AsyncMock(),
+ ) as mock_trends:
+ response = accuracy_client.get(
+ "/admin/execution_accuracy_trends",
+ params={"graph_id": "graph-1", "days_back": days_back},
+ )
+
+ assert response.status_code == 422
+ mock_trends.assert_not_awaited()
+
+
[email protected]("days_back", [None, 7, 90])
+def test_accuracy_trends_accepts_in_range_days_back(accuracy_client, days_back):
+ params: dict[str, object] = {"graph_id": "graph-1"}
+ if days_back is not None:
+ params["days_back"] = days_back
+ empty = AccuracyTrendsResponse(
+ latest_data=AccuracyLatestData(
+ date=datetime(2026, 10, 17, tzinfo=timezone.utc),
+ daily_score=None,
+ three_day_avg=None,
+ seven_day_avg=None,
+ fourteen_day_avg=None,
+ ),
+ alert=None,
+ )
+ with patch(
+ "backend.api.features.admin.execution_analytics_routes.get_accuracy_trends_and_alerts",
+ new=AsyncMock(return_value=empty),
+ ) as mock_trends:
+ response = accuracy_client.get(
+ "/admin/execution_accuracy_trends", params=params
+ )
+
+ assert response.status_code == 200
+ assert mock_trends.await_args is not None
+ assert mock_trends.await_args.kwargs["days_back"] == (days_back or 30)
diff --git a/autogpt_platform/backend/backend/data/analytics.py b/autogpt_platform/backend/backend/data/analytics.py
index 05a0a8b6e4..f837a0808f 100644
--- a/autogpt_platform/backend/backend/data/analytics.py
+++ b/autogpt_platform/backend/backend/data/analytics.py
@@ -2,7 +2,7 @@ import logging
from datetime import datetime, timedelta, timezone
from typing import Optional
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
from backend.data.db import query_raw_with_schema
@@ -35,7 +35,10 @@ class AccuracyTrendsResponse(BaseModel):
latest_data: AccuracyLatestData
alert: Optional[AccuracyAlertData]
- historical_data: Optional[list[AccuracyLatestData]] = None
+ historical_data: Optional[list[AccuracyLatestData]] = Field(
+ default=None,
+ description="Daily data points ordered oldest to newest",
+ )
async def get_accuracy_trends_and_alerts(
@@ -45,26 +48,40 @@ async def get_accuracy_trends_and_alerts(
drop_threshold: float = 10.0,
include_historical: bool = False,
) -> AccuracyTrendsResponse:
- """Get accuracy trends and detect alerts for a specific graph."""
+ """Get accuracy trends and detect alerts for a specific graph.
+
+ Only days with at least one scored execution are included. The 3/7/14-day
+ averages are row windows over those scored days.
+
+ `latest_data` and `alert` are taken from the most recent scored day.
+ `historical_data` (when requested) is ordered oldest to newest.
+ """
query_template = """
- WITH daily_scores AS (
+ WITH scored_executions AS (
SELECT
DATE(e."createdAt") as execution_date,
- AVG(CASE
+ CASE
WHEN e.stats IS NOT NULL
AND e.stats::json->>'correctness_score' IS NOT NULL
AND e.stats::json->>'correctness_score' != 'null'
THEN (e.stats::json->>'correctness_score')::float * 100
ELSE NULL
- END) as daily_score
+ END as score
FROM {schema_prefix}"AgentGraphExecution" e
WHERE e."agentGraphId" = $1::text
AND e."isDeleted" = false
AND e."createdAt" >= $2::timestamp
AND e."executionStatus" IN ('COMPLETED', 'FAILED', 'TERMINATED')
{user_filter}
- GROUP BY DATE(e."createdAt")
- HAVING COUNT(*) >= 1 -- Include all days with at least 1 execution
+ ),
+ daily_scores AS (
+ SELECT
+ execution_date,
+ AVG(score) as daily_score
+ FROM scored_executions
+ GROUP BY execution_date
+ -- Only days with at least 1 scored execution; COUNT(score) skips NULLs
+ HAVING COUNT(score) >= 1
),
trends AS (
SELECT
@@ -91,6 +108,7 @@ async def get_accuracy_trends_and_alerts(
ELSE NULL
END as drop_percent
FROM trends
+ -- DESC is load-bearing: result[0] is the latest day and LIMIT 1 relies on it
ORDER BY execution_date DESC
{limit_clause}
"""
@@ -147,7 +165,8 @@ async def get_accuracy_trends_and_alerts(
historical_data = None
if include_historical:
historical_data = []
- for row in result:
+ # The query returns newest first; the chart wants oldest to newest.
+ for row in reversed(result):
historical_data.append(
AccuracyLatestData(
date=row["execution_date"],
diff --git a/autogpt_platform/backend/backend/data/analytics_test.py b/autogpt_platform/backend/backend/data/analytics_test.py
new file mode 100644
index 0000000000..b590fea809
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/analytics_test.py
@@ -0,0 +1,215 @@
+"""DB-backed tests for the execution accuracy trends query (#15640)."""
+
+import logging
+from datetime import datetime, timedelta, timezone
+from statistics import mean
+from uuid import uuid4
+
+import pytest
+from prisma.enums import AgentExecutionStatus
+from prisma.models import AgentGraph, AgentGraphExecution, User
+
+from backend.data.analytics import get_accuracy_trends_and_alerts
+from backend.util.json import SafeJson
+from backend.util.test import SpinTestServer
+
+logger = logging.getLogger(__name__)
+
+
+def day_anchor() -> datetime:
+ now = datetime.now(timezone.utc)
+ today = now.replace(hour=12, minute=0, second=0, microsecond=0)
+ if today > now:
+ today -= timedelta(days=1)
+ return today
+
+
+def _day(days_ago: int, anchor: datetime) -> datetime:
+ return anchor - timedelta(days=days_ago)
+
+
+async def _setup() -> tuple[str, str]:
+ user_id = f"acc-{uuid4()}"
+ graph_id = f"acc-graph-{uuid4()}"
+ await User.prisma().create(
+ data={
+ "id": user_id,
+ "email": f"{user_id}@example.com",
+ "name": "Accuracy Trends Test",
+ }
+ )
+ await AgentGraph.prisma().create(
+ data={
+ "id": graph_id,
+ "version": 1,
+ "name": "Accuracy Trends Test",
+ "description": "test",
+ "userId": user_id,
+ "isActive": True,
+ }
+ )
+ return user_id, graph_id
+
+
+async def _run(
+ user_id: str, graph_id: str, created_at: datetime, score: float | None
+) -> None:
+ stats: dict[str, object] = {"cost": 0}
+ if score is not None:
+ stats["correctness_score"] = score
+ await AgentGraphExecution.prisma().create(
+ data={
+ "id": str(uuid4()),
+ "agentGraphId": graph_id,
+ "agentGraphVersion": 1,
+ "executionStatus": AgentExecutionStatus.COMPLETED,
+ "userId": user_id,
+ "createdAt": created_at,
+ "startedAt": created_at,
+ "endedAt": created_at + timedelta(seconds=1),
+ "stats": SafeJson(stats),
+ }
+ )
+
+
+async def _cleanup(user_id: str, graph_id: str) -> None:
+ try:
+ await AgentGraphExecution.prisma().delete_many(where={"userId": user_id})
+ await AgentGraph.prisma().delete_many(where={"id": graph_id})
+ await User.prisma().delete_many(where={"id": user_id})
+ except Exception as exc:
+ logger.warning("cleanup for %s failed: %s", user_id, exc)
+
+
+# Scored days, oldest first: a steadily falling score.
+_SCORED_DAYS = {5: 0.9, 4: 0.8, 3: 0.7, 2: 0.6, 1: 0.5}
+
+
+async def _seed_falling_series(
+ user_id: str, graph_id: str, anchor: datetime, *, unscored_today: bool
+) -> None:
+ for days_ago, score in _SCORED_DAYS.items():
+ await _run(user_id, graph_id, _day(days_ago, anchor), score)
+ # An unscored run on a scored day must not dilute that day's score.
+ await _run(user_id, graph_id, _day(days_ago, anchor) + timedelta(hours=1), None)
+ if unscored_today:
+ # A day with only unscored runs must not become a row.
+ await _run(user_id, graph_id, _day(0, anchor), None)
+ await _run(user_id, graph_id, _day(0, anchor) + timedelta(minutes=5), None)
+
+
[email protected](loop_scope="session")
+async def test_historical_data_is_oldest_first_and_scored_days_only(
+ server: SpinTestServer,
+ day_anchor: datetime,
+):
+ user_id, graph_id = await _setup()
+ try:
+ await _seed_falling_series(user_id, graph_id, day_anchor, unscored_today=True)
+
+ result = await get_accuracy_trends_and_alerts(
+ graph_id=graph_id,
+ days_back=30,
+ drop_threshold=10.0,
+ include_historical=True,
+ )
+
+ history = result.historical_data
+ assert history is not None
+ dates = [h.date for h in history]
+ assert dates == sorted(dates)
+ assert len(set(dates)) == len(dates)
+ assert len(history) == len(_SCORED_DAYS)
+ assert all(h.daily_score is not None for h in history)
+
+ expected_scores = [s * 100 for s in _SCORED_DAYS.values()]
+ assert [h.daily_score for h in history] == pytest.approx(expected_scores)
+
+ # The 3-day average is the mean of the last 3 *scored* days.
+ assert history[-1].three_day_avg == pytest.approx(mean(expected_scores[-3:]))
+
+ # latest_data is the most recent scored day, not the unscored today.
+ assert result.latest_data.date == history[-1].date
+ assert result.latest_data.daily_score == pytest.approx(50.0)
+ assert result.latest_data.three_day_avg == pytest.approx(60.0)
+ finally:
+ await _cleanup(user_id, graph_id)
+
+
[email protected](loop_scope="session")
+async def test_latest_and_alert_match_with_and_without_history(
+ server: SpinTestServer,
+ day_anchor: datetime,
+):
+ """The monitor calls without history (LIMIT 1); it must see the same
+ latest row and alert as the chart's call."""
+ user_id, graph_id = await _setup()
+ try:
+ await _seed_falling_series(user_id, graph_id, day_anchor, unscored_today=False)
+
+ with_history = await get_accuracy_trends_and_alerts(
+ graph_id=graph_id, days_back=30, include_historical=True
+ )
+ without_history = await get_accuracy_trends_and_alerts(
+ graph_id=graph_id, days_back=30, include_historical=False
+ )
+
+ assert without_history.historical_data is None
+ assert without_history.latest_data == with_history.latest_data
+ assert with_history.historical_data is not None
+ assert without_history.latest_data == with_history.historical_data[-1]
+
+ # Falling series: 3-day avg 60 vs 7-day avg 70 -> ~14.3% drop >= 10%.
+ assert with_history.alert is not None
+ assert without_history.alert is not None
+ assert without_history.alert.drop_percent == pytest.approx(
+ (70.0 - 60.0) / 70.0 * 100
+ )
+ assert without_history.alert.three_day_avg == pytest.approx(60.0)
+ assert without_history.alert.seven_day_avg == pytest.approx(70.0)
+ finally:
+ await _cleanup(user_id, graph_id)
+
+
[email protected](loop_scope="session")
+async def test_flat_series_with_unscored_today_has_no_alert(
+ server: SpinTestServer,
+ day_anchor: datetime,
+):
+ user_id, graph_id = await _setup()
+ try:
+ for days_ago in range(1, 8):
+ await _run(user_id, graph_id, _day(days_ago, day_anchor), 0.8)
+ await _run(user_id, graph_id, _day(0, day_anchor), None)
+
+ result = await get_accuracy_trends_and_alerts(
+ graph_id=graph_id, days_back=30, drop_threshold=10.0
+ )
+
+ assert result.alert is None
+ assert result.latest_data.daily_score == pytest.approx(80.0)
+ assert result.latest_data.date.date() == _day(1, day_anchor).date()
+ finally:
+ await _cleanup(user_id, graph_id)
+
+
[email protected](loop_scope="session")
+async def test_only_unscored_runs_returns_empty_latest(
+ server: SpinTestServer, day_anchor: datetime
+):
+ user_id, graph_id = await _setup()
+ try:
+ await _run(user_id, graph_id, _day(1, day_anchor), None)
+ await _run(user_id, graph_id, _day(0, day_anchor), None)
+
+ result = await get_accuracy_trends_and_alerts(
+ graph_id=graph_id, days_back=30, include_historical=True
+ )
+
+ assert result.alert is None
+ assert result.latest_data.daily_score is None
+ assert result.latest_data.three_day_avg is None
+ assert result.historical_data is None
+ finally:
+ await _cleanup(user_id, graph_id)
diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/ExecutionAnalyticsForm.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/ExecutionAnalyticsForm.tsx
index fcdd60dde7..0b94190508 100644
--- a/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/ExecutionAnalyticsForm.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/ExecutionAnalyticsForm.tsx
@@ -34,6 +34,7 @@ import type { ExecutionAnalyticsRequest } from "@/app/api/__generated__/models/e
import type { ExecutionAnalyticsResponse } from "@/app/api/__generated__/models/executionAnalyticsResponse";
import type { AccuracyTrendsResponse } from "@/app/api/__generated__/models/accuracyTrendsResponse";
import type { AccuracyLatestData } from "@/app/api/__generated__/models/accuracyLatestData";
+import { toAccuracyChartData } from "./accuracyChartData";
// Use the generated type with minimal adjustment for form handling
interface FormData extends Omit<ExecutionAnalyticsRequest, "created_after"> {
@@ -107,13 +108,7 @@ export function ExecutionAnalyticsForm() {
// Chart component for accuracy trends
function AccuracyChart({ data }: { data: AccuracyLatestData[] }) {
- const chartData = data.map((item) => ({
- date: new Date(item.date).toLocaleDateString(),
- "Daily Score": item.daily_score,
- "3-Day Avg": item.three_day_avg,
- "7-Day Avg": item.seven_day_avg,
- "14-Day Avg": item.fourteen_day_avg,
- }));
+ const chartData = toAccuracyChartData(data);
return (
<ResponsiveContainer width="100%" height={400}>
diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/__tests__/accuracyChartData.test.ts b/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/__tests__/accuracyChartData.test.ts
new file mode 100644
index 0000000000..9cffc9b95e
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/__tests__/accuracyChartData.test.ts
@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import type { AccuracyLatestData } from "@/app/api/__generated__/models/accuracyLatestData";
+import { toAccuracyChartData } from "../accuracyChartData";
+
+function point(date: string, score: number): AccuracyLatestData {
+ return {
+ date: date as unknown as Date,
+ daily_score: score,
+ three_day_avg: score + 1,
+ seven_day_avg: score + 2,
+ fourteen_day_avg: score + 3,
+ };
+}
+
+const label = (date: string) => new Date(date).toLocaleDateString();
+
+describe("toAccuracyChartData", () => {
+ it("puts the oldest date first when the API returns newest first", () => {
+ const newestFirst = [
+ point("2026-10-16T00:00:00Z", 50),
+ point("2026-10-15T00:00:00Z", 60),
+ point("2026-10-14T00:00:00Z", 70),
+ ];
+
+ const chart = toAccuracyChartData(newestFirst);
+
+ expect(chart.map((p) => p.date)).toEqual([
+ label("2026-10-14T00:00:00Z"),
+ label("2026-10-15T00:00:00Z"),
+ label("2026-10-16T00:00:00Z"),
+ ]);
+ expect(chart.map((p) => p["Daily Score"])).toEqual([70, 60, 50]);
+ expect(chart.map((p) => p["3-Day Avg"])).toEqual([71, 61, 51]);
+ expect(chart.map((p) => p["7-Day Avg"])).toEqual([72, 62, 52]);
+ expect(chart.map((p) => p["14-Day Avg"])).toEqual([73, 63, 53]);
+ });
+
+ it("sorts unordered input and keeps already-ascending input as is", () => {
+ const shuffled = [
+ point("2026-10-15T00:00:00Z", 60),
+ point("2026-10-16T00:00:00Z", 50),
+ point("2026-10-14T00:00:00Z", 70),
+ ];
+ const ascending = [
+ point("2026-10-14T00:00:00Z", 70),
+ point("2026-10-15T00:00:00Z", 60),
+ point("2026-10-16T00:00:00Z", 50),
+ ];
+
+ expect(toAccuracyChartData(shuffled)).toEqual(
+ toAccuracyChartData(ascending),
+ );
+ expect(toAccuracyChartData(ascending)[0].date).toBe(
+ label("2026-10-14T00:00:00Z"),
+ );
+ });
+
+ it("does not mutate the input array", () => {
+ const input = [
+ point("2026-10-16T00:00:00Z", 50),
+ point("2026-10-14T00:00:00Z", 70),
+ ];
+ const before = [...input];
+
+ toAccuracyChartData(input);
+
+ expect(input).toEqual(before);
+ });
+
+ it("preserves the calendar date of the API's timezone-free daily buckets", () => {
+ const chart = toAccuracyChartData([point("2026-10-16T00:00:00", 50)]);
+
+ expect(chart[0].date).toBe(new Date(2026, 9, 16).toLocaleDateString());
+ });
+});
diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/accuracyChartData.ts b/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/accuracyChartData.ts
new file mode 100644
index 0000000000..1aac0a8800
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/execution-analytics/components/accuracyChartData.ts
@@ -0,0 +1,29 @@
+import type { AccuracyLatestData } from "@/app/api/__generated__/models/accuracyLatestData";
+
+export interface AccuracyChartPoint {
+ date: string;
+ "Daily Score": AccuracyLatestData["daily_score"];
+ "3-Day Avg": AccuracyLatestData["three_day_avg"];
+ "7-Day Avg": AccuracyLatestData["seven_day_avg"];
+ "14-Day Avg": AccuracyLatestData["fourteen_day_avg"];
+}
+
+/**
+ * Map accuracy history to chart points, oldest date first.
+ *
+ * Recharts plots a category X axis in array order, so sort a copy by date
+ * rather than trusting the order the API returns.
+ */
+export function toAccuracyChartData(
+ data: AccuracyLatestData[],
+): AccuracyChartPoint[] {
+ return [...data]
+ .sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
+ .map((item) => ({
+ date: new Date(item.date).toLocaleDateString(),
+ "Daily Score": item.daily_score,
+ "3-Day Avg": item.three_day_avg,
+ "7-Day Avg": item.seven_day_avg,
+ "14-Day Avg": item.fourteen_day_avg,
+ }));
+}
diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index 4df3209701..c3e601fe19 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -6823,7 +6823,15 @@
"name": "days_back",
"in": "query",
"required": false,
- "schema": { "type": "integer", "default": 30, "title": "Days Back" }
+ "schema": {
+ "type": "integer",
+ "maximum": 90,
+ "minimum": 7,
+ "description": "Number of days to look back",
+ "default": 30,
+ "title": "Days Back"
+ },
+ "description": "Number of days to look back"
},
{
"name": "drop_threshold",
@@ -18811,7 +18819,8 @@
},
{ "type": "null" }
],
- "title": "Historical Data"
+ "title": "Historical Data",
+ "description": "Daily data points ordered oldest to newest"
}
},
"type": "object",