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(backend): give new free trials one $20 CoPilot budget (#15184)
Toran Bruce Richards4ec2449ce903
diff --git a/autogpt_platform/backend/backend/copilot/rate_limit.py b/autogpt_platform/backend/backend/copilot/rate_limit.pyindex e115e78596..91597f2d0d 100644--- a/autogpt_platform/backend/backend/copilot/rate_limit.py+++ b/autogpt_platform/backend/backend/copilot/rate_limit.py@@ -10,7 +10,8 @@ Failure-mode policy:* Enforcement path (:func:`check_rate_limit`) **fails closed** — if Redisis unreachable we raise :class:`RateLimitUnavailable` so the API layerreturns HTTP 503. A brown-out must not let a user bypass their- daily / weekly USD cap.+ daily / weekly USD cap. Trials whose lifetime cap makes both windows+ redundant use their durable trial counter instead of Redis.* Observability paths (:func:`get_usage_status`, the reset-countread/write helpers, the recording path :func:`record_cost_usage`) keepfail-open / best-effort semantics — losing a usage gauge or a single@@ -77,6 +78,8 @@ from backend.util.feature_flag import Flag, get_feature_flag_value, is_feature_eif TYPE_CHECKING:import stripe+ from backend.data.subscription_trial import TrialState+logger = logging.getLogger(__name__)# "copilot:cost" (not the legacy "copilot:usage") so stale token-based@@ -435,6 +438,8 @@ class CoPilotUsagePublic(BaseModel):pct = 100.0else:pct = round(100.0 * w.used / w.limit, 1)+ if status.tier == SubscriptionTier.TRIAL:+ pct = min(pct, 99.9)return UsageWindowPublic(percent_used=pct,resets_at=w.resets_at,@@ -516,6 +521,19 @@ async def get_usage_status(# SET) — same fail-open semantics, returns zeros.logger.warning("Redis unavailable for usage status, returning zeros")+ weekly_reset = _weekly_reset_time(now=now)+ if tier == SubscriptionTier.TRIAL:+ trial = await credit_db().get_subscription_trial(user_id)+ if trial and _trial_uses_total_budget(+ trial, daily_cost_limit, weekly_cost_limit+ ):+ # The client's weekly gauge also gates sending: it must retain+ # lifetime exhaustion after calendar resets and exclude beta spend.+ daily_used = min(daily_used, trial.cost_microdollars)+ weekly_used = trial.cost_microdollars+ weekly_cost_limit = trial.offer.total_cost_limit+ weekly_reset = trial.ends_at or now+return CoPilotUsageStatus(daily=UsageWindow(used=daily_used,@@ -525,7 +543,7 @@ async def get_usage_status(weekly=UsageWindow(used=weekly_used,limit=weekly_cost_limit,- resets_at=_weekly_reset_time(now=now),+ resets_at=weekly_reset,),tier=tier,reset_cost=0 if tier == SubscriptionTier.TRIAL else rate_limit_reset_cost,@@ -546,14 +564,17 @@ async def get_remaining_usd_budget(user is close to their actual cap, and to feed the baseline path'sper-turn budget hint via :func:`build_budget_ctx`.+ Trials whose daily and weekly caps are at least their total cap use+ the durable lifetime remainder directly, independent of Redis windows.+A limit of ``0`` is treated as "no spend allowed" — remaining = 0on that window; callers should not pass 0 expecting it to mean "nocap". A negative limit means that window has no cap (the self-hosteddefault); when both windows are uncapped the result is ``inf``.Failure modes:- * Redis brown-out → ``floor_usd``, on every tier (so callers using- the value as a soft hint don't pretend the user has full budget;+ * Redis brown-out → ``floor_usd`` for Redis-backed windows (so callers+ using the value as a soft hint don't pretend the user has full budget;the pre-turn gate has already failed closed at 503 in this case,so we only land here from observability paths). A caller thatmust tell "unknown" from "$0.00 left" passes a negative floor.@@ -574,6 +595,11 @@ async def get_remaining_usd_budget(trial = await _subscription_trial(user_id)if trial is None or not trial.active:return 0.0+ if _trial_uses_total_budget(trial, daily_cost_limit, weekly_cost_limit):+ return (+ max(0, trial.offer.total_cost_limit - trial.cost_microdollars)+ / 1_000_000+ )now = datetime.now(UTC)try:redis = await get_redis_async()@@ -673,6 +699,10 @@ async def check_rate_limit(caller must fail closed (HTTP 503) — the daily/weekly USD caps arereal money and cannot be bypassed by a Redis brown-out.+ Trials whose period caps are at least their lifetime cap use the durable+ trial counter alone. Their remaining allowance survives Redis outages,+ and resetting Redis cannot replenish their lifetime budget.+A limit of ``0`` means "no spend allowed", not "unlimited". A negativelimit disables that window's check entirely — the explicit "no cap"sentinel that self-hosted distributions export (see ChatConfig) — so@@ -700,6 +730,8 @@ async def check_rate_limit(raise RateLimitExceeded("trial", now)if trial.cost_microdollars >= trial.offer.total_cost_limit:raise RateLimitExceeded("trial", trial.ends_at or now)+ if _trial_uses_total_budget(trial, daily_cost_limit, weekly_cost_limit):+ returnif (skip_daily or daily_cost_limit < 0) and weekly_cost_limit < 0:returntry:@@ -740,6 +772,16 @@ async def check_rate_limit(raise RateLimitExceeded("weekly", _weekly_reset_time(now=now))+def _trial_uses_total_budget(+ trial: "TrialState", daily_cost_limit: int, weekly_cost_limit: int+) -> bool:+ """Redundant window caps must not count spending from before the trial."""+ return (+ daily_cost_limit >= trial.offer.total_cost_limit+ and weekly_cost_limit >= trial.offer.total_cost_limit+ )++async def reset_daily_usage(user_id: str, daily_cost_limit: int = 0) -> bool:"""Reset a user's daily cost usage counter in Redis.diff --git a/autogpt_platform/backend/backend/copilot/rate_limit_test.py b/autogpt_platform/backend/backend/copilot/rate_limit_test.pyindex f7e64af24f..b77d68ae55 100644--- a/autogpt_platform/backend/backend/copilot/rate_limit_test.py+++ b/autogpt_platform/backend/backend/copilot/rate_limit_test.py@@ -2883,12 +2883,15 @@ class TestGetRemainingUsdBudget:assert result == 0.5@pytest.mark.asyncio- async def test_an_active_trial_gets_the_same_failure_sentinel(self, mocker):- """Every tier answers a brown-out with ``floor_usd``. A trial that- returned a hardcoded 0.0 instead was indistinguishable from a trial- that had genuinely spent its last cent."""+ async def test_trial_with_tighter_windows_gets_the_same_failure_sentinel(+ self, mocker+ ):+ """A trial requiring Redis windows answers a brown-out with ``floor_usd``.+ A hardcoded 0.0 would be indistinguishable from exhausted allowance.+ """trial = MagicMock(spec=TrialState)trial.active = True+ trial.offer = MagicMock(total_cost_limit=100_000_000)store = MagicMock()store.get_subscription_trial = AsyncMock(return_value=trial)mocker.patch("backend.copilot.rate_limit.credit_db", return_value=store)diff --git a/autogpt_platform/backend/backend/copilot/trial_usage_limits_test.py b/autogpt_platform/backend/backend/copilot/trial_usage_limits_test.pynew file mode 100644index 0000000000..6a226c9cb5--- /dev/null+++ b/autogpt_platform/backend/backend/copilot/trial_usage_limits_test.py@@ -0,0 +1,289 @@+"""A free trial has one lifetime budget, independent of calendar resets."""++from datetime import UTC, datetime, timedelta+from unittest.mock import AsyncMock, MagicMock++import pytest+from pytest_mock import MockerFixture++from backend.copilot import rate_limit+from backend.data import subscription_trial_config+from backend.data.subscription_trial import TrialState+from backend.data.subscription_trial_config import AcceptedTrialOffer++_USER = "free-trial-user"+_SUNDAY = datetime(2026, 10, 4, 23, 59, tzinfo=UTC)+++def clock(mocker: MockerFixture) -> MagicMock:+ clock = MagicMock(wraps=datetime)+ clock.now.return_value = _SUNDAY+ mocker.patch.object(rate_limit, "datetime", clock)+ mocker.patch.object(subscription_trial_config, "datetime", clock)+ return clock+++def trial(clock: MagicMock, mocker: MockerFixture) -> TrialState:+ trial = TrialState(+ id="trial-1",+ user_id=_USER,+ customer_id="cus_trial",+ offer=AcceptedTrialOffer(+ version="trial-budget-v2",+ new_users_from=_SUNDAY - timedelta(days=1),+ duration_days=7,+ tier="PRO",+ billing_cycle="monthly",+ daily_cost_limit=100_000_000,+ weekly_cost_limit=20_000_000,+ total_cost_limit=20_000_000,+ onboarding_credit_amount=300,+ price_id="price_pro",+ unit_amount=5000,+ currency="usd",+ ),+ checkout_session_id="cs_trial",+ subscription_id="sub_trial",+ checkout_attempt=1,+ success_url="https://example.com/success",+ cancel_url="https://example.com/cancel",+ checkout_metadata={},+ status="trialing",+ card_verified_at=_SUNDAY,+ started_at=_SUNDAY,+ ends_at=_SUNDAY + timedelta(days=7),+ consumed_at=_SUNDAY,+ converted_at=None,+ cancel_at_period_end=False,+ cost_microdollars=0,+ )+ store = MagicMock(get_subscription_trial=AsyncMock(return_value=trial))+ mocker.patch.object(rate_limit, "credit_db", return_value=store)+ for name in ("_fetch_user_tier", "get_user_tier"):+ mocker.patch.object(+ rate_limit, name, AsyncMock(return_value=rate_limit.SubscriptionTier.TRIAL)+ )+ return trial+++def usage(mocker: MockerFixture) -> dict[str, int]:+ counters: dict[str, int] = {}+ redis = AsyncMock()+ redis.get.side_effect = lambda key: str(counters.get(key, 0))+ mocker.patch.object(rate_limit, "get_redis_async", AsyncMock(return_value=redis))+ mocker.patch.object(+ rate_limit, "_fetch_cost_limits_flag", AsyncMock(return_value=None)+ )+ return counters++[email protected]("spent", [0, 5_000_000, 19_999_999])+async def test_entire_trial_budget_can_be_spent_in_one_day(+ trial: TrialState, usage: dict[str, int], spent: int+):+ trial.cost_microdollars = spent+ usage[rate_limit._daily_key(_USER)] = spent+ usage[rate_limit._weekly_key(_USER)] = spent+ daily, weekly, tier = await rate_limit.get_global_rate_limits(+ _USER, config_daily=5_000_000, config_weekly=25_000_000+ )++ assert (daily, weekly, tier) == (+ 100_000_000,+ 20_000_000,+ rate_limit.SubscriptionTier.TRIAL,+ )+ await rate_limit.check_rate_limit(_USER, daily, weekly)+ remaining = await rate_limit.get_remaining_usd_budget(_USER, daily, weekly)++ assert remaining == pytest.approx((20_000_000 - spent) / 1_000_000)+++async def test_weekly_reset_does_not_replenish_trial_budget(+ trial: TrialState, usage: dict[str, int], clock: MagicMock+):+ trial.cost_microdollars = 15_000_000+ old_week_key = rate_limit._weekly_key(_USER)+ usage[rate_limit._daily_key(_USER)] = 15_000_000+ usage[old_week_key] = 15_000_000+ daily, weekly, _ = await rate_limit.get_global_rate_limits(_USER, 1, 1)+ before = await rate_limit.get_remaining_usd_budget(_USER, daily, weekly)++ clock.now.return_value = _SUNDAY + timedelta(minutes=2)+ assert rate_limit._weekly_key(_USER) != old_week_key+ assert usage.get(rate_limit._weekly_key(_USER), 0) == 0+ await rate_limit.check_rate_limit(_USER, daily, weekly)+ after = await rate_limit.get_remaining_usd_budget(_USER, daily, weekly)++ assert before == after == 5.0+ trial.cost_microdollars += 5_000_000+ usage[rate_limit._daily_key(_USER)] = 5_000_000+ usage[rate_limit._weekly_key(_USER)] = 5_000_000+ with pytest.raises(rate_limit.RateLimitExceeded) as exc:+ await rate_limit.check_rate_limit(_USER, daily, weekly)+ assert exc.value.window == "trial"+ assert await rate_limit.get_remaining_usd_budget(_USER, daily, weekly) == 0.0++[email protected]("spent", [20_000_000, 25_000_000])[email protected]("windows_reset", [False, True])+async def test_exhausted_trial_stays_blocked_before_and_after_window_resets(+ trial: TrialState, usage: dict[str, int], spent: int, windows_reset: bool+):+ trial.cost_microdollars = spent+ if not windows_reset:+ usage[rate_limit._daily_key(_USER)] = spent+ usage[rate_limit._weekly_key(_USER)] = spent+ daily, weekly, _ = await rate_limit.get_global_rate_limits(_USER, 1, 1)++ with pytest.raises(rate_limit.RateLimitExceeded) as exc:+ await rate_limit.check_rate_limit(_USER, daily, weekly)++ assert exc.value.window == "trial"+ assert exc.value.resets_at == trial.ends_at+ assert await rate_limit.get_remaining_usd_budget(_USER, daily, weekly) == 0.0+ assert trial.cost_microdollars == spent+ assert trial.started_at == _SUNDAY+ assert trial.ends_at == _SUNDAY + timedelta(days=7)+++ "tier,expected_daily,expected_weekly",+ [+ (rate_limit.SubscriptionTier.BASIC, 4_000_000, 20_000_000),+ (rate_limit.SubscriptionTier.PRO, 5_000_000, 25_000_000),+ ],+)+async def test_paid_tiers_keep_their_daily_and_weekly_limits(+ clock: MagicMock,+ usage: dict[str, int],+ mocker: MockerFixture,+ tier: rate_limit.SubscriptionTier,+ expected_daily: int,+ expected_weekly: int,+):+ for name in ("_fetch_user_tier", "get_user_tier"):+ mocker.patch.object(rate_limit, name, AsyncMock(return_value=tier))+ mocker.patch.object(+ rate_limit, "_fetch_tier_multipliers_flag", AsyncMock(return_value=None)+ )+ store = mocker.patch.object(rate_limit, "credit_db")+ daily, weekly, resolved_tier = await rate_limit.get_global_rate_limits(+ _USER, 4_000_000, 20_000_000+ )+ assert (daily, weekly, resolved_tier) == (expected_daily, expected_weekly, tier)+ usage[rate_limit._daily_key(_USER)] = daily++ with pytest.raises(rate_limit.RateLimitExceeded) as exc:+ await rate_limit.check_rate_limit(_USER, daily, weekly)++ assert exc.value.window == "daily"+ usage[rate_limit._daily_key(_USER)] = 0+ usage[rate_limit._weekly_key(_USER)] = weekly+ with pytest.raises(rate_limit.RateLimitExceeded) as exc:+ await rate_limit.check_rate_limit(_USER, daily, weekly)+ assert exc.value.window == "weekly"+ store.assert_not_called()+++ "daily_used,weekly_used", [(5_000_000, 25_000_000), (100_000_000, 100_000_000)]+)+async def test_spending_before_trial_cannot_block_remaining_trial_allowance(+ trial: TrialState, usage: dict[str, int], daily_used: int, weekly_used: int+):+ trial.cost_microdollars = 5_000_000+ usage[rate_limit._daily_key(_USER)] = daily_used+ usage[rate_limit._weekly_key(_USER)] = weekly_used+ before = dict(usage)+ daily, weekly, _ = await rate_limit.get_global_rate_limits(_USER, 1, 1)++ await rate_limit.check_rate_limit(_USER, daily, weekly)++ assert await rate_limit.get_remaining_usd_budget(_USER, daily, weekly) == 15.0+ assert usage == before++[email protected]("spent", [5_000_000, 19_999_999, 20_000_000, 25_000_000])+async def test_public_trial_exhaustion_matches_lifetime_budget_across_weekly_reset(+ trial: TrialState, usage: dict[str, int], clock: MagicMock, spent: int+):+ trial.cost_microdollars = spent+ usage[rate_limit._daily_key(_USER)] = 100_000_000+ usage[rate_limit._weekly_key(_USER)] = 100_000_000+ before = dict(usage)+ daily, weekly, tier = await rate_limit.get_global_rate_limits(_USER, 1, 1)++ for now in (_SUNDAY, _SUNDAY + timedelta(minutes=2)):+ clock.now.return_value = now+ status = await rate_limit.get_usage_status(_USER, daily, weekly, tier=tier)+ public = rate_limit.CoPilotUsagePublic.from_status(status)++ assert status.weekly.used == spent+ assert status.weekly.limit == 20_000_000+ assert status.weekly.resets_at == trial.ends_at+ assert public.daily is not None and public.daily.percent_used < 100+ assert public.weekly is not None+ assert (public.weekly.percent_used >= 100) == (spent >= 20_000_000)+ assert usage == before+++async def test_legacy_trial_with_tighter_windows_retains_periodic_limits(+ trial: TrialState, usage: dict[str, int]+):+ trial.offer = trial.offer.model_copy(+ update={"daily_cost_limit": 2_000_000, "weekly_cost_limit": 10_000_000}+ )+ trial.cost_microdollars = 8_000_000+ usage[rate_limit._daily_key(_USER)] = 2_000_000+ usage[rate_limit._weekly_key(_USER)] = 5_000_000+ daily, weekly, tier = await rate_limit.get_global_rate_limits(_USER, 1, 1)++ with pytest.raises(rate_limit.RateLimitExceeded) as exc:+ await rate_limit.check_rate_limit(_USER, daily, weekly)++ assert exc.value.window == "daily"+ assert await rate_limit.get_remaining_usd_budget(_USER, daily, weekly) == 0.0+ status = await rate_limit.get_usage_status(_USER, daily, weekly, tier=tier)+ assert status.weekly.used == 5_000_000+ assert status.weekly.limit == 10_000_000+ assert status.weekly.resets_at == _SUNDAY + timedelta(minutes=1)++[email protected]("spent", [5_000_000, 20_000_000])+async def test_lifetime_trial_budget_remains_authoritative_without_redis(+ trial: TrialState, usage: dict[str, int], mocker: MockerFixture, spent: int+):+ trial.cost_microdollars = spent+ mocker.patch.object(+ rate_limit,+ "get_redis_async",+ AsyncMock(side_effect=ConnectionError("unavailable")),+ )+ daily, weekly, tier = await rate_limit.get_global_rate_limits(_USER, 1, 1)++ if spent < 20_000_000:+ await rate_limit.check_rate_limit(_USER, daily, weekly)+ else:+ with pytest.raises(rate_limit.RateLimitExceeded) as exc:+ await rate_limit.check_rate_limit(_USER, daily, weekly)+ assert exc.value.window == "trial"++ assert (+ await rate_limit.get_remaining_usd_budget(_USER, daily, weekly)+ == (20_000_000 - spent) / 1_000_000+ )+ status = await rate_limit.get_usage_status(_USER, daily, weekly, tier=tier)+ assert status.weekly.used == spent+ assert status.weekly.resets_at == trial.ends_atdiff --git a/autogpt_platform/backend/backend/data/subscription_trial_config.py b/autogpt_platform/backend/backend/data/subscription_trial_config.pyindex a8885d5ba2..57851acf4e 100644--- a/autogpt_platform/backend/backend/data/subscription_trial_config.py+++ b/autogpt_platform/backend/backend/data/subscription_trial_config.py@@ -5,20 +5,21 @@ from datetime import UTC, datetimefrom hashlib import sha256from typing import Literal-from pydantic import (- AwareDatetime,- BaseModel,- ConfigDict,- Field,- ValidationError,- model_validator,-)+from pydantic import AwareDatetime, BaseModel, ConfigDict, Field, ValidationErrorfrom backend.util.country import country_codefrom backend.util.feature_flag import Flag, get_feature_flag_value, is_feature_enabledlogger = logging.getLogger(__name__)+# The flag controls trial eligibility and commercial terms; usage is one+# lifetime budget, spendable at any pace. Periodic limits must not subdivide it.+FREE_TRIAL_COST_LIMITS = {+ "daily_cost_limit": 100_000_000,+ "weekly_cost_limit": 20_000_000,+ "total_cost_limit": 20_000_000,+}+class TrialOffer(BaseModel):model_config = ConfigDict(extra="forbid", frozen=True)@@ -39,12 +40,6 @@ class TrialOffer(BaseModel):# a new seat is taken, never to revoke a seat already held.max_active_trials: int | None = Field(default=None, ge=0, strict=True)- @model_validator(mode="after")- def ordered_limits(self) -> "TrialOffer":- if not self.daily_cost_limit <= self.weekly_cost_limit <= self.total_cost_limit:- raise ValueError("Trial limits must satisfy daily <= weekly <= total")- return self-def is_eligible(self,*,@@ -111,7 +106,7 @@ async def get_trial_offer(if not isinstance(raw, dict) or "version" not in raw:logger.debug("No card-required trial offer configured")return None- return TrialOffer.model_validate(raw)+ return TrialOffer.model_validate(raw).model_copy(update=FREE_TRIAL_COST_LIMITS)except (ValidationError, ValueError, TypeError):logger.error("Invalid card-required-trial-offer; refusing trial enrollment")return Nonediff --git a/autogpt_platform/backend/backend/data/subscription_trial_config_test.py b/autogpt_platform/backend/backend/data/subscription_trial_config_test.pyindex dfd5704dde..7dff7702c9 100644--- a/autogpt_platform/backend/backend/data/subscription_trial_config_test.py+++ b/autogpt_platform/backend/backend/data/subscription_trial_config_test.py@@ -52,6 +52,36 @@ def test_offer_has_no_implicit_existing_user_eligibility():assert offer.allow_existing_beta_users is False+def test_daily_limit_can_exceed_the_entire_trial_budget():+ data = {+ **offer_data(),+ "daily_cost_limit": 100_000_000,+ "weekly_cost_limit": 20_000_000,+ "total_cost_limit": 20_000_000,+ }+ assert trials.TrialOffer.model_validate(data).model_dump() == {+ **trials.TrialOffer.model_validate(offer_data()).model_dump(),+ **{key: data[key] for key in data if key.endswith("cost_limit")},+ }+++async def test_new_trial_offer_uses_fixed_usage_limits_and_preserves_other_terms():+ raw = {**offer_data(), "max_active_trials": 500}+ with patch.object(+ trials, "is_feature_enabled", AsyncMock(return_value=True)+ ), patch.object(trials, "get_feature_flag_value", AsyncMock(return_value=raw)):+ offer = await trials.get_trial_offer("user-1")+ assert offer is not None+ assert offer.model_dump() == {+ **trials.TrialOffer.model_validate(raw).model_dump(),+ "daily_cost_limit": 100_000_000,+ "weekly_cost_limit": 20_000_000,+ "total_cost_limit": 20_000_000,+ }+ assert raw["daily_cost_limit"] == 250_000++@pytest.mark.parametrize("overrides",[@@ -62,8 +92,6 @@ def test_offer_has_no_implicit_existing_user_eligibility():{"weekly_cost_limit": 0},{"total_cost_limit": "1000000"},{"total_cost_limit": True},- {"daily_cost_limit": 2_000_000},- {"weekly_cost_limit": 2_000_000},{"new_users_from": "2026-09-10T00:00:00"},{"tier": "TRIAL"},{"tier": "ENTERPRISE"},@@ -184,7 +212,9 @@ async def test_payment_enabled_and_valid_offer_is_available():):assert await trials.get_trial_offer("user-1"- ) == trials.TrialOffer.model_validate(offer_data())+ ) == trials.TrialOffer.model_validate(+ {**offer_data(), **trials.FREE_TRIAL_COST_LIMITS}+ )enabled.assert_awaited_once_with(trials.Flag.ENABLE_PLATFORM_PAYMENT, "user-1", default=False)