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.

feat(backend): reset usage on trial conversion to Pro or Max (#15208)

Toran Bruce Richards0df72910b3cf
diff --git a/autogpt_platform/backend/backend/api/features/billing/subscriptions/routes.py b/autogpt_platform/backend/backend/api/features/billing/subscriptions/routes.py
index 1ba2bb1e1b..e8ac028dfb 100644
--- a/autogpt_platform/backend/backend/api/features/billing/subscriptions/routes.py
+++ b/autogpt_platform/backend/backend/api/features/billing/subscriptions/routes.py
@@ -47,9 +47,11 @@ from backend.data.credit import (
sync_tier_from_checkout_session,
)
from backend.data.notifications import PassWorkEvent, PassWorkKind
+from backend.data.pro_activation import get_usage_activation_state
from backend.data.redis_client import get_redis_async
from backend.data.stripe_authentication import requires_authentication
from backend.data.stripe_client import stripe_call
+from backend.data.subscription_activation_events import recover_claimed_billing_event
from backend.data.subscription_checkout import AnotherPlanLive
from backend.data.subscription_trial import TrialState
from backend.data.subscription_trial_billing import (
@@ -238,8 +240,12 @@ async def _get_stripe_price_amount(price_id: str) -> int | None:
async def get_subscription_status(
user_id: Annotated[str, Security(get_user_id)],
) -> SubscriptionStatusResponse:
- user = await get_user_by_id(user_id)
- tier = user.subscription_tier or SubscriptionTier.NO_TIER
+ activation = await get_usage_activation_state(user_id)
+ if not activation.ready:
+ raise HTTPException(
+ 503, "Subscription activation is processing", headers={"Retry-After": "3"}
+ )
+ tier = activation.tier
# Tiers that *can* have a Stripe price configured (and therefore appear
# in the tier picker if the LD flag exposes a price-id). NO_TIER is not
@@ -852,10 +858,20 @@ async def stripe_webhook(request: Request):
await sync_trials_for_billing_event(event_type, event.get("data"))
return Response(status_code=200)
+ event_data = event.get("data") or {}
+ data_object = event_data.get("object") if isinstance(event_data, dict) else None
+ if not isinstance(data_object, dict):
+ logger.warning(
+ "stripe_webhook: %s missing or non-dict data.object; ignoring",
+ event_type,
+ )
+ return Response(status_code=200)
+
# Event-level dedup: short-circuit identical re-deliveries before any
# handler runs. Stripe retries the same event.id on non-2xx responses, and
# not every downstream handler is independently idempotent.
if not await _claim_stripe_event(event_id):
+ await recover_claimed_billing_event(event_type, data_object)
logger.info(
"stripe_webhook: event %s (%s) already processed; skipping",
event_id,
@@ -863,15 +879,6 @@ async def stripe_webhook(request: Request):
)
return Response(status_code=200)
- event_data = event.get("data") or {}
- data_object = event_data.get("object") if isinstance(event_data, dict) else None
- if not isinstance(data_object, dict):
- logger.warning(
- "stripe_webhook: %s missing or non-dict data.object; ignoring",
- event_type,
- )
- return Response(status_code=200)
-
# Wrap handler dispatch so a downstream failure releases the dedup claim;
# otherwise Stripe's retry would hit the live key and silently drop the
# event. Concurrent retries that arrive *during* in-flight processing
@@ -927,7 +934,7 @@ async def stripe_webhook(request: Request):
):
await sync_subscription_schedule_from_stripe(data_object)
- if event_type == "invoice.payment_succeeded":
+ if event_type in ("invoice.payment_succeeded", "invoice.paid"):
await handle_subscription_payment_success(data_object)
await on_trial_invoice(data_object, paid=True)
diff --git a/autogpt_platform/backend/backend/api/features/chat/routes.py b/autogpt_platform/backend/backend/api/features/chat/routes.py
index 8563374685..4fec9bd00a 100644
--- a/autogpt_platform/backend/backend/api/features/chat/routes.py
+++ b/autogpt_platform/backend/backend/api/features/chat/routes.py
@@ -1932,7 +1932,7 @@ async def stream_chat_post(
# the shared scheduling path below.
if user_id and is_platform_route:
try:
- daily_limit, weekly_limit, _ = await get_global_rate_limits(
+ daily_limit, weekly_limit, usage_tier = await get_global_rate_limits(
user_id,
config.daily_cost_limit_microdollars,
config.weekly_cost_limit_microdollars,
@@ -1941,6 +1941,7 @@ async def stream_chat_post(
user_id=user_id,
daily_cost_limit=daily_limit,
weekly_cost_limit=weekly_limit,
+ expected_tier=usage_tier,
)
except RateLimitExceeded as e:
# Structured envelope (not a bare string) so the frontend can
diff --git a/autogpt_platform/backend/backend/api/features/chat/routes_test.py b/autogpt_platform/backend/backend/api/features/chat/routes_test.py
index 7f7cab322f..84653bbf14 100644
--- a/autogpt_platform/backend/backend/api/features/chat/routes_test.py
+++ b/autogpt_platform/backend/backend/api/features/chat/routes_test.py
@@ -333,6 +333,18 @@ def _mock_stream_internals(
new_callable=AsyncMock,
return_value=None,
)
+ # Validation tests do not need a live entitlement snapshot or Redis.
+ # Gate-specific tests replace these boundary mocks with their verdict.
+ mocker.patch(
+ "backend.api.features.chat.routes.get_global_rate_limits",
+ new_callable=AsyncMock,
+ return_value=(1_000_000, 5_000_000, SubscriptionTier.BASIC),
+ )
+ mocker.patch(
+ "backend.api.features.chat.routes.check_rate_limit",
+ new_callable=AsyncMock,
+ return_value=None,
+ )
# ``schedule_chat_turn`` owns acquire-slot + persist-message + dispatch
# in one call. Patching it at the route boundary lets tests exercise
# validation/enrichment (file_ids, message length, rate limits, etc.)
@@ -343,6 +355,12 @@ def _mock_stream_internals(
new_callable=AsyncMock,
return_value="turn-id-mock",
)
+ mocker.patch.object(
+ chat_routes.stream_registry,
+ "publish_chunk",
+ new_callable=AsyncMock,
+ return_value=None,
+ )
mocker.patch.object(
chat_routes.stream_registry,
"subscribe_to_session",
@@ -3186,21 +3204,6 @@ def test_stream_chat_accepts_exactly_max_length_message(
):
"""A message exactly at max_length=64_000 must be accepted."""
_mock_stream_internals(mocker)
- # Pass generous rate-limits so the rate-limit gate doesn't interfere
- # with the message-length validation under test. Pre-PR convention
- # used 0 for "unlimited"; we now treat 0 as "no spend allowed".
- mocker.patch(
- "backend.api.features.chat.routes.get_global_rate_limits",
- new_callable=AsyncMock,
- return_value=(1_000_000, 5_000_000, SubscriptionTier.BASIC),
- )
- # And mock the redis lookup so check_rate_limit sees zero usage.
- mock_redis = mocker.AsyncMock()
- mock_redis.get = mocker.AsyncMock(side_effect=["0", "0"])
- mocker.patch(
- "backend.copilot.rate_limit.get_redis_async",
- return_value=mock_redis,
- )
response = client.post(
"/sessions/sess-1/stream",
diff --git a/autogpt_platform/backend/backend/api/features/chat/speech.py b/autogpt_platform/backend/backend/api/features/chat/speech.py
index 1dfecf0f49..05d11ac9d0 100644
--- a/autogpt_platform/backend/backend/api/features/chat/speech.py
+++ b/autogpt_platform/backend/backend/api/features/chat/speech.py
@@ -93,7 +93,7 @@ async def _enforce_spend_allowance(user_id: str) -> None:
await enforce_payment_paywall(user_id)
try:
- daily_limit, weekly_limit, _ = await get_global_rate_limits(
+ daily_limit, weekly_limit, usage_tier = await get_global_rate_limits(
user_id,
config.daily_cost_limit_microdollars,
config.weekly_cost_limit_microdollars,
@@ -102,6 +102,7 @@ async def _enforce_spend_allowance(user_id: str) -> None:
user_id=user_id,
daily_cost_limit=daily_limit,
weekly_cost_limit=weekly_limit,
+ expected_tier=usage_tier,
)
except RateLimitExceeded as exc:
raise HTTPException(status_code=429, detail=str(exc)) from exc
diff --git a/autogpt_platform/backend/backend/api/features/chat/speech_test.py b/autogpt_platform/backend/backend/api/features/chat/speech_test.py
index 8095bb0168..b78b689bd3 100644
--- a/autogpt_platform/backend/backend/api/features/chat/speech_test.py
+++ b/autogpt_platform/backend/backend/api/features/chat/speech_test.py
@@ -12,8 +12,11 @@ from backend.api.features.chat import speech as speech_routes
from backend.api.rest_api import handle_internal_http_error
from backend.copilot import speech as speech_module
from backend.copilot.rate_limit import RateLimitExceeded, RateLimitUnavailable
+from backend.copilot.usage_activation_fixtures import usage_snapshot
from backend.util.exceptions import UserPaywalledError
+_usage_snapshot = usage_snapshot
+
app = fastapi.FastAPI()
app.include_router(speech_routes.router)
# The route lets ValueError through to the app's global handler; without this
diff --git a/autogpt_platform/backend/backend/api/features/subscription_activation_routes.py b/autogpt_platform/backend/backend/api/features/subscription_activation_routes.py
new file mode 100644
index 0000000000..48eb67a52f
--- /dev/null
+++ b/autogpt_platform/backend/backend/api/features/subscription_activation_routes.py
@@ -0,0 +1,109 @@
+"""Explicit Pro/Max trial conversion; pro-activation is the historical URL."""
+
+import logging
+from typing import Annotated
+
+import stripe
+from autogpt_libs.auth import get_user_id, requires_user
+from fastapi import APIRouter, Depends, HTTPException, Security
+
+from backend.api.features.billing.credits_rate_limit import (
+ enforce_subscription_status_rate_limit,
+)
+from backend.data.subscription_activation_checkout import (
+ confirm_activation,
+ current_activation,
+ get_activation,
+ preview_activation,
+)
+from backend.data.subscription_activation_models import (
+ ActivationConfirmRequest,
+ ActivationNotFound,
+ ActivationPreviewRequest,
+ ActivationResponse,
+ ActivationUnavailable,
+)
+from backend.data.subscription_checkout import SubscriptionCheckoutUnavailable
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(
+ prefix="/credits/pro-activation",
+ tags=["subscriptions"],
+ dependencies=[
+ Security(requires_user),
+ Depends(enforce_subscription_status_rate_limit),
+ ],
+ responses={
+ 404: {"description": "No owned activation"},
+ 409: {"description": "Review fresh terms or retry a concurrent confirmation"},
+ 502: {"description": "Preview temporarily unavailable; no payment started"},
+ },
+)
+CurrentUser = Annotated[str, Security(get_user_id)]
+
+
[email protected]("/preview")
+async def preview_pro_activation(
+ body: ActivationPreviewRequest,
+ user_id: CurrentUser,
+) -> ActivationResponse:
+ try:
+ return await preview_activation(user_id, body.return_to, body.plan)
+ except (ActivationUnavailable, SubscriptionCheckoutUnavailable) as exc:
+ raise HTTPException(409, str(exc)) from exc
+ except stripe.StripeError as exc:
+ raise HTTPException(502, "Unable to preview the charge. Please retry.") from exc
+
+
[email protected]("/{attempt_id}/confirm")
+async def confirm_pro_activation(
+ attempt_id: str,
+ body: ActivationConfirmRequest,
+ user_id: CurrentUser,
+) -> ActivationResponse:
+ try:
+ return await confirm_activation(user_id, attempt_id, body)
+ except ActivationNotFound as exc:
+ raise HTTPException(404, str(exc)) from exc
+ except (ActivationUnavailable, SubscriptionCheckoutUnavailable) as exc:
+ raise HTTPException(409, str(exc)) from exc
+ except stripe.StripeError as exc:
+ raise HTTPException(
+ 502, "Unable to validate terms. No payment was started."
+ ) from exc
+ except Exception:
+ logger.exception("Confirmation outcome needs recovery for %s", attempt_id)
+ return ActivationResponse(
+ id=attempt_id, status="processing", retry_after_seconds=3
+ )
+
+
[email protected]("/current")
+async def get_current_pro_activation(user_id: CurrentUser) -> ActivationResponse:
+ try:
+ return await current_activation(user_id)
+ except ActivationNotFound as exc:
+ raise HTTPException(404, str(exc)) from exc
+ except ActivationUnavailable as exc:
+ raise HTTPException(409, str(exc)) from exc
+ except Exception:
+ logger.exception("Current activation state is temporarily unavailable")
+ return ActivationResponse(status="processing", retry_after_seconds=3)
+
+
[email protected]("/{attempt_id}")
+async def get_pro_activation(
+ attempt_id: str, user_id: CurrentUser
+) -> ActivationResponse:
+ try:
+ return await get_activation(user_id, attempt_id)
+ except ActivationNotFound as exc:
+ raise HTTPException(404, str(exc)) from exc
+ except ActivationUnavailable as exc:
+ raise HTTPException(409, str(exc)) from exc
+ except Exception:
+ logger.exception("Activation state needs recovery for %s", attempt_id)
+ return ActivationResponse(
+ id=attempt_id, status="processing", retry_after_seconds=3
+ )
diff --git a/autogpt_platform/backend/backend/api/features/subscription_activation_routes_test.py b/autogpt_platform/backend/backend/api/features/subscription_activation_routes_test.py
new file mode 100644
index 0000000000..20a0be6a33
--- /dev/null
+++ b/autogpt_platform/backend/backend/api/features/subscription_activation_routes_test.py
@@ -0,0 +1,155 @@
+"""Authenticated activation API, explicit consent, and recoverable failures."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+from fastapi import FastAPI
+from httpx import ASGITransport, AsyncClient
+
+from backend.api.features import subscription_activation_routes as routes
+from backend.data.subscription_activation_models import (
+ ActivationNotFound,
+ ActivationResponse,
+)
+
+
+def app():
+ app = FastAPI()
+ app.include_router(routes.router, prefix="/api")
+ app.dependency_overrides[routes.enforce_subscription_status_rate_limit] = (
+ allow_request
+ )
+ return app
+
+
+def authorize(app):
+ app.dependency_overrides[routes.requires_user] = allow_request
+ app.dependency_overrides[routes.get_user_id] = authenticated_user
+
+
+async def allow_request():
+ return None
+
+
+async def authenticated_user():
+ return "authenticated-user"
+
+
+async def test_activation_endpoints_require_authentication(app):
+ async with AsyncClient(
+ transport=ASGITransport(app=app), base_url="https://app.test"
+ ) as client:
+ for method, path in [
+ ("GET", "/current"),
+ ("GET", "/attempt"),
+ ("POST", "/preview"),
+ ("POST", "/attempt/confirm"),
+ ]:
+ response = await client.request(
+ method, f"/api/credits/pro-activation{path}", json={}
+ )
+ assert response.status_code in (401, 403)
+
+
+async def test_confirm_rejects_missing_or_false_consent(app, monkeypatch):
+ authorize(app)
+ confirm = AsyncMock()
+ monkeypatch.setattr(routes, "confirm_activation", confirm)
+ async with AsyncClient(
+ transport=ASGITransport(app=app), base_url="https://app.test"
+ ) as client:
+ for body in [{}, {"confirmed": False, "terms_token": "a" * 64}]:
+ response = await client.post(
+ "/api/credits/pro-activation/attempt/confirm", json=body
+ )
+ assert response.status_code == 422
+ confirm.assert_not_awaited()
+
+
+async def test_owned_attempt_read_passes_authenticated_user_and_returns_404(
+ app, monkeypatch
+):
+ authorize(app)
+ get = AsyncMock(side_effect=ActivationNotFound("Activation was not found"))
+ monkeypatch.setattr(routes, "get_activation", get)
+ async with AsyncClient(
+ transport=ASGITransport(app=app), base_url="https://app.test"
+ ) as client:
+ response = await client.get("/api/credits/pro-activation/someone-elses-attempt")
+ assert response.status_code == 404
+ get.assert_awaited_once_with("authenticated-user", "someone-elses-attempt")
+
+
+async def test_current_failure_returns_processing_without_retrying_payment(
+ app, monkeypatch
+):
+ authorize(app)
+ monkeypatch.setattr(
+ routes, "current_activation", AsyncMock(side_effect=ConnectionError("DB down"))
+ )
+ confirm = AsyncMock()
+ monkeypatch.setattr(routes, "confirm_activation", confirm)
+ async with AsyncClient(
+ transport=ASGITransport(app=app), base_url="https://app.test"
+ ) as client:
+ response = await client.get("/api/credits/pro-activation/current")
+ assert response.status_code == 200
+ assert response.json()["status"] == "processing"
+ assert response.json()["retry_after_seconds"] == 3
+ confirm.assert_not_awaited()
+
+
+async def test_current_ready_preserves_return_destination(app, monkeypatch):
+ authorize(app)
+ monkeypatch.setattr(
+ routes,
+ "current_activation",
+ AsyncMock(
+ return_value=ActivationResponse(
+ status="ready", return_to="/chat/123?resume=1"
+ )
+ ),
+ )
+ async with AsyncClient(
+ transport=ASGITransport(app=app), base_url="https://app.test"
+ ) as client:
+ response = await client.get("/api/credits/pro-activation/current")
+ assert response.json()["return_to"] == "/chat/123?resume=1"
+
+
[email protected]("plan", ["PRO", "MAX", None])
+async def test_preview_forwards_plan_to_quote(app, monkeypatch, plan):
+ authorize(app)
+ preview = AsyncMock(return_value=ActivationResponse(status="confirmation_required"))
+ monkeypatch.setattr(routes, "preview_activation", preview)
+ async with AsyncClient(
+ transport=ASGITransport(app=app), base_url="https://app.test"
+ ) as client:
+ result = await client.post(
+ "/api/credits/pro-activation/preview",
+ json={"plan": plan, "return_to": "/chat"},
+ )
+ assert result.status_code == 200
+ preview.assert_awaited_once_with("authenticated-user", "/chat", plan)
+
+
+async def test_preview_rejects_unrelated_plan(app, monkeypatch):
+ authorize(app)
+ preview = AsyncMock(return_value=ActivationResponse(status="confirmation_required"))
+ monkeypatch.setattr(routes, "preview_activation", preview)
+ async with AsyncClient(
+ transport=ASGITransport(app=app), base_url="https://app.test"
+ ) as client:
+ result = await client.post(
+ "/api/credits/pro-activation/preview", json={"plan": "BUSINESS"}
+ )
+ assert result.status_code == 422
+ preview.assert_not_awaited()
diff --git a/autogpt_platform/backend/backend/api/features/subscription_routes_test.py b/autogpt_platform/backend/backend/api/features/subscription_routes_test.py
index ba53e555ec..8a588eba88 100644
--- a/autogpt_platform/backend/backend/api/features/subscription_routes_test.py
+++ b/autogpt_platform/backend/backend/api/features/subscription_routes_test.py
@@ -10,7 +10,10 @@ import stripe
from autogpt_libs.auth.jwt_utils import get_jwt_payload
from prisma.enums import SubscriptionTier
+from backend.data.pro_activation import UsageActivationState
+
from .billing.credits_rate_limit import enforce_subscription_status_rate_limit
+from .billing.subscriptions import routes as subscription_routes
from .billing.subscriptions.routes import _validate_checkout_redirect_url, router
TEST_USER_ID = "3e53486c-cf57-477e-ba2a-cb02dc828e1a"
@@ -135,6 +138,20 @@ def _stub_subscription_status_lookups(mocker: pytest_mock.MockFixture) -> None:
helpers. Individual tests can override via their own mocker.patch call.
"""
+ async def activation_state(user_id: str) -> UsageActivationState:
+ user = await subscription_routes.get_user_by_id(user_id)
+ return UsageActivationState(
+ user_id=user_id,
+ generation=None,
+ trial_id=None,
+ tier=user.subscription_tier or SubscriptionTier.NO_TIER,
+ ready=True,
+ )
+
+ mocker.patch.object(
+ subscription_routes, "get_usage_activation_state", side_effect=activation_state
+ )
+
async def default_price_id(
tier: SubscriptionTier, billing_cycle: str = "monthly"
) -> str | None:
@@ -146,6 +163,12 @@ def _stub_subscription_status_lookups(mocker: pytest_mock.MockFixture) -> None:
"backend.api.features.billing.subscriptions.routes.get_subscription_price_id",
side_effect=default_price_id,
)
+ mocker.patch.object(
+ subscription_routes,
+ "_get_stripe_price_amount",
+ new_callable=AsyncMock,
+ return_value=0,
+ )
mocker.patch(
"backend.api.features.billing.subscriptions.routes.get_proration_credit_cents",
new_callable=AsyncMock,
@@ -232,6 +255,61 @@ def test_validate_checkout_redirect_url(
assert _validate_checkout_redirect_url(url) is expected
+def test_subscription_status_reads_ready_tier_over_stale_user_cache(
+ client: fastapi.testclient.TestClient,
+ mocker: pytest_mock.MockFixture,
+) -> None:
+ mocker.patch.object(
+ subscription_routes,
+ "get_user_by_id",
+ new_callable=AsyncMock,
+ return_value=Mock(subscription_tier=SubscriptionTier.TRIAL),
+ )
+ mocker.patch.object(
+ subscription_routes,
+ "get_usage_activation_state",
+ new_callable=AsyncMock,
+ return_value=UsageActivationState(
+ user_id=TEST_USER_ID,
+ generation="activation",
+ trial_id=None,
+ tier=SubscriptionTier.PRO,
+ ready=True,
+ ),
+ )
+ mocker.patch.object(
+ subscription_routes,
+ "_get_stripe_price_amount",
+ new_callable=AsyncMock,
+ return_value=1999,
+ )
+ response = client.get("/credits/subscription")
+ assert response.status_code == 200
+ assert response.json()["tier"] == "PRO"
+
+
+def test_subscription_status_does_not_report_ready_during_activation(
+ client: fastapi.testclient.TestClient,
+ mocker: pytest_mock.MockFixture,
+) -> None:
+ mocker.patch.object(subscription_routes, "get_user_by_id", new_callable=AsyncMock)
+ mocker.patch.object(
+ subscription_routes,
+ "get_usage_activation_state",
+ new_callable=AsyncMock,
+ return_value=UsageActivationState(
+ user_id=TEST_USER_ID,
+ generation=None,
+ trial_id=None,
+ tier=SubscriptionTier.PRO,
+ ready=False,
+ ),
+ )
+ response = client.get("/credits/subscription")
+ assert response.status_code == 503
+ assert response.headers["Retry-After"] == "3"
+
+
def test_get_subscription_status_pro(
client: fastapi.testclient.TestClient,
mocker: pytest_mock.MockFixture,
diff --git a/autogpt_platform/backend/backend/api/features/v1_credits_authz_test.py b/autogpt_platform/backend/backend/api/features/v1_credits_authz_test.py
index 8c094a3937..4779b5bc6f 100644
--- a/autogpt_platform/backend/backend/api/features/v1_credits_authz_test.py
+++ b/autogpt_platform/backend/backend/api/features/v1_credits_authz_test.py
@@ -373,6 +373,12 @@ TRIAL_CREDITS_ROUTES = {
"resume_trial",
"start_trial_checkout",
}
+PERSONAL_ACTIVATION_ROUTES = {
+ "confirm_pro_activation",
+ "get_current_pro_activation",
+ "get_pro_activation",
+ "preview_pro_activation",
+}
# Routes that never resolve the org-pooled credit model at all. The reason is
# prose; the exemption is checked by the transitive walk at the bottom of this
# module.
@@ -427,6 +433,22 @@ def test_every_credits_route_is_gated_or_explicitly_exempt():
f"{route.name} now resolves an org context; it can reach pooled "
"credit and needs gating or its own documented reason"
)
+ elif route.name in PERSONAL_ACTIVATION_ROUTES:
+ # These act only on the authenticated user's subscription and
+ # cannot resolve an org's pooled credits, even through helpers.
+ dependencies = _dependency_names(route.dependant)
+ assert {
+ "requires_user",
+ "get_user_id",
+ } <= dependencies, (
+ f"{route.name} must authenticate and identify its own user"
+ )
+ assert (
+ "get_request_context" not in dependencies
+ ), f"{route.name} now resolves an org context; review its billing gate"
+ assert not _reaches_credit_model(
+ route.endpoint
+ ), f"{route.name} now reaches pooled org credit; require MANAGE_BILLING"
elif route.name in POOLED_MODEL_UNREACHABLE_ROUTES:
assert not _reaches_credit_model(route.endpoint), (
f"{route.name} now reaches get_credit_model, so it can resolve a "
diff --git a/autogpt_platform/backend/backend/api/features/v1_stripe_webhook_test.py b/autogpt_platform/backend/backend/api/features/v1_stripe_webhook_test.py
index d1b29b1579..7746e96cfd 100644
--- a/autogpt_platform/backend/backend/api/features/v1_stripe_webhook_test.py
+++ b/autogpt_platform/backend/backend/api/features/v1_stripe_webhook_test.py
@@ -112,15 +112,15 @@ def test_stripe_webhook_checkout_calls_sync_tier_helper(
mock_sync.assert_called_once()
-def test_stripe_webhook_skips_handlers_on_replayed_event(
+def test_stripe_webhook_reconciles_activation_without_repeating_checkout_on_replay(
mocker: pytest_mock.MockFixture,
) -> None:
- """A second delivery of the same Stripe event.id must short-circuit.
+ """A claimed event still reconciles activation after a crashed delivery.
Stripe retries the same event on non-2xx responses, and not every
downstream handler is independently idempotent (e.g. ``fulfill_checkout``
relies on a checkout-state flag that races on concurrent retries). The
- webhook dedupes by event.id so retries don't re-run any handler.
+ The webhook skips collection/fulfillment but retries authoritative sync.
"""
event = _make_checkout_event("subscription", "sub_dedup")
event["id"] = "evt_already_seen"
@@ -146,6 +146,9 @@ def test_stripe_webhook_skips_handlers_on_replayed_event(
"backend.api.features.billing.subscriptions.routes.sync_tier_from_checkout_session",
new_callable=AsyncMock,
)
+ recover_sync = mocker.patch(
+ "backend.data.credit.sync_tier_from_checkout_session", new_callable=AsyncMock
+ )
response = client.post(
"/credits/stripe_webhook",
@@ -156,6 +159,59 @@ def test_stripe_webhook_skips_handlers_on_replayed_event(
assert response.status_code == 200
mock_fulfill.assert_not_called()
mock_sync.assert_not_called()
+ recover_sync.assert_awaited_once_with(event["data"]["object"])
+
+
+ "event_type,payload",
+ [
+ ("customer.subscription.updated", {"id": "sub_retry", "customer": "cus"}),
+ ("invoice.paid", {"id": "in_retry", "subscription": "sub_retry"}),
+ ],
+)
+def test_claimed_webhook_recovers_subscription_without_collection(
+ mocker: pytest_mock.MockFixture, event_type: str, payload: dict
+) -> None:
+ mocker.patch(
+ "stripe.Webhook.construct_event",
+ return_value={
+ "id": "evt_retry",
+ "type": event_type,
+ "data": {"object": payload},
+ },
+ )
+ mocker.patch(
+ "backend.api.features.billing.subscriptions.routes.settings.secrets.stripe_webhook_secret",
+ new="whsec_test",
+ )
+ mocker.patch(
+ "backend.api.features.billing.subscriptions.routes._claim_stripe_event",
+ new_callable=AsyncMock,
+ return_value=False,
+ )
+ current = {"id": "sub_retry", "customer": "cus"}
+ mocker.patch(
+ "stripe.Subscription.retrieve_async",
+ new_callable=AsyncMock,
+ return_value=current,
+ )
+ recovered = mocker.patch(
+ "backend.data.credit.sync_subscription_from_stripe", new_callable=AsyncMock
+ )
+ collection = mocker.patch("stripe.Invoice.pay_async", new_callable=AsyncMock)
+ fulfill = mocker.patch(
+ "backend.api.features.billing.subscriptions.routes.UserCredit.fulfill_checkout",
+ new_callable=AsyncMock,
+ )
+ response = client.post(
+ "/credits/stripe_webhook",
+ content=b"{}",
+ headers={"stripe-signature": "t=1,v1=sig"},
+ )
+ assert response.status_code == 200
+ recovered.assert_awaited_once_with(current)
+ collection.assert_not_awaited()
+ fulfill.assert_not_awaited()
def test_stripe_webhook_checkout_propagates_sync_failure(
diff --git a/autogpt_platform/backend/backend/api/rest_api.py b/autogpt_platform/backend/backend/api/rest_api.py
index 4ae1dbfc14..b75822b823 100644
--- a/autogpt_platform/backend/backend/api/rest_api.py
+++ b/autogpt_platform/backend/backend/api/rest_api.py
@@ -70,6 +70,7 @@ import backend.api.features.skills.routes as skills_routes
import backend.api.features.store.model
import backend.api.features.store.routes
import backend.api.features.store.skill_routes
+import backend.api.features.subscription_activation_routes as subscription_activation_routes
import backend.api.features.subscription_trial_routes as subscription_trial_routes
import backend.api.features.transfers.routes as transfer_routes
import backend.api.features.user.routes as user_routes
@@ -387,6 +388,7 @@ app.include_router(
backend.api.features.desktop_preview.router, tags=["v1"], prefix="/api"
)
app.include_router(subscription_trial_routes.router, prefix="/api")
+app.include_router(subscription_activation_routes.router, prefix="/api")
app.include_router(
api_keys_routes.router,
tags=["v1", "api-keys"],
diff --git a/autogpt_platform/backend/backend/copilot/briefing/generate.py b/autogpt_platform/backend/backend/copilot/briefing/generate.py
index d31c69fe5d..62e68a344f 100644
--- a/autogpt_platform/backend/backend/copilot/briefing/generate.py
+++ b/autogpt_platform/backend/backend/copilot/briefing/generate.py
@@ -11,6 +11,7 @@ from pydantic import ValidationError
from backend.api.features.experts.models import Expert
from backend.api.features.graph_executions.review.model import PendingHumanReviewModel
+from backend.copilot.usage_activation import UsageActivationUnavailable
from backend.data.db_accessors import (
execution_db,
experts_db,
@@ -251,9 +252,14 @@ async def _compose_fresh_briefing(
# the thread — home's `without_summaries` only covers the card.
if not await is_feature_enabled(Flag.AI_ACTIVITY_STATUS, user_id):
return content
- return content.model_copy(
- update={"narrative": await compose_narrative(user_id, content)}
- )
+ try:
+ narrative = await compose_narrative(user_id, content)
+ except UsageActivationUnavailable:
+ logger.warning(
+ "Briefing narrative usage attribution unavailable for %s", user_id[:8]
+ )
+ narrative = None
+ return content.model_copy(update={"narrative": narrative})
async def generate_and_deliver_briefing(user_id: str) -> BriefingResult:
diff --git a/autogpt_platform/backend/backend/copilot/briefing/generate_test.py b/autogpt_platform/backend/backend/copilot/briefing/generate_test.py
index 9823baa3ae..f9ba3815bd 100644
--- a/autogpt_platform/backend/backend/copilot/briefing/generate_test.py
+++ b/autogpt_platform/backend/backend/copilot/briefing/generate_test.py
@@ -3,11 +3,14 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
+from backend.copilot import usage_activation
from backend.copilot.briefing import generate as generate_module
+from backend.copilot.briefing import narrative
from backend.copilot.briefing.generate import AgentInfo, compose_briefing
from backend.copilot.briefing.models import BriefingContent
from backend.copilot.briefing.render import render_briefing_markdown
from backend.data.execution import ExecutionStatus, GraphExecutionMeta
+from backend.data.pro_activation import UsageActivationState
from backend.util import posthog_client
from backend.util.feature_flag import Flag
@@ -1034,6 +1037,46 @@ async def test_narrative_failure_still_delivers_the_template_briefing(
)
[email protected]("lookup_fails", [False, True])
+async def test_unavailable_narrative_attribution_still_delivers_template(
+ monkeypatch, lookup_fails
+):
+ client = MagicMock(
+ get_briefing_for_date=AsyncMock(return_value=None),
+ create_briefing=AsyncMock(return_value=MagicMock(id="briefing-1")),
+ append_plain_session_message=AsyncMock(return_value="session-1"),
+ mark_briefing_delivered=AsyncMock(),
+ )
+ _patch_fresh_compose_env(monkeypatch, generate_module, client)
+ monkeypatch.setattr(
+ generate_module, "compose_narrative", narrative.compose_narrative
+ )
+ lookup = AsyncMock(
+ return_value=UsageActivationState(user_id="user-1", tier="PRO", ready=False),
+ side_effect=RuntimeError("database unavailable") if lookup_fails else None,
+ )
+ monkeypatch.setattr(
+ usage_activation,
+ "pro_activation_db",
+ lambda: MagicMock(get_usage_activation_state=lookup),
+ )
+ provider = AsyncMock()
+ monkeypatch.setattr(narrative, "structured_completion", provider)
+
+ result = await generate_module.generate_and_deliver_briefing("user-1")
+
+ assert result["status"] == "delivered"
+ stored = client.create_briefing.await_args.args[2]
+ assert stored["narrative"] is None
+ assert client.append_plain_session_message.await_args.kwargs[
+ "content"
+ ] == render_briefing_markdown(BriefingContent.model_validate(stored))
+ client.mark_briefing_delivered.assert_awaited_once_with("user-1", "briefing-1")
+ lookup.assert_awaited_once_with("user-1")
+ provider.assert_not_awaited()
+
+
@pytest.mark.asyncio
async def test_narrative_is_not_regenerated_when_redelivering(
monkeypatch, stub_narrative
diff --git a/autogpt_platform/backend/backend/copilot/briefing/narrative.py b/autogpt_platform/backend/backend/copilot/briefing/narrative.py
index 19cc219c29..98b515e219 100644
--- a/autogpt_platform/backend/backend/copilot/briefing/narrative.py
+++ b/autogpt_platform/backend/backend/copilot/briefing/narrative.py
@@ -39,6 +39,7 @@ from backend.copilot.dream.llm import (
from backend.copilot.expert_context import escape_prompt_xml_tags
from backend.copilot.token_tracking import persist_and_record_usage
from backend.copilot.transport_routing import routing_kwargs_for_chat_transport
+from backend.copilot.trial_cost_context import attributed_usage
from .models import BriefingContent, BriefingRunItem
@@ -87,6 +88,7 @@ class NarrativeResponse(BaseModel):
narrative: str
+@attributed_usage
async def compose_narrative(user_id: str, content: BriefingContent) -> str | None:
"""Write the briefing's opening paragraph, or ``None`` to fall back.
diff --git a/autogpt_platform/backend/backend/copilot/briefing/narrative_test.py b/autogpt_platform/backend/backend/copilot/briefing/narrative_test.py
index 14d6a70b1e..daae83bcfb 100644
--- a/autogpt_platform/backend/backend/copilot/briefing/narrative_test.py
+++ b/autogpt_platform/backend/backend/copilot/briefing/narrative_test.py
@@ -3,6 +3,7 @@ from unittest.mock import AsyncMock, patch
import pytest
+from backend.copilot import usage_activation_fixtures
from backend.copilot.briefing import narrative as narrative_module
from backend.copilot.briefing.models import BriefingContent, BriefingRunItem
from backend.copilot.briefing.narrative import (
@@ -302,3 +303,6 @@ async def test_cost_log_failure_does_not_lose_the_narrative(cost_log):
cost_log.side_effect = RuntimeError("redis down")
with patch_llm(return_value=completion("Morning.")):
assert await compose_narrative(USER, make_content()) == "Morning."
+
+
+usage_snapshot = usage_activation_fixtures.usage_snapshot
diff --git a/autogpt_platform/backend/backend/copilot/budget_signal.py b/autogpt_platform/backend/backend/copilot/budget_signal.py
index 0468a8a6f4..d7aede4c5b 100644
--- a/autogpt_platform/backend/backend/copilot/budget_signal.py
+++ b/autogpt_platform/backend/backend/copilot/budget_signal.py
@@ -151,6 +151,7 @@ async def _remaining_daily_usd(user_id: str | None) -> float | None:
# Negative is the "Redis said nothing" floor; a real $0.00 comes back
# as 0.0 and is the one figure worth telling the model.
floor_usd=-1.0,
+ expected_tier=_tier,
)
return None if remaining < 0 or remaining == float("inf") else remaining
diff --git a/autogpt_platform/backend/backend/copilot/dream/batch_callbacks.py b/autogpt_platform/backend/backend/copilot/dream/batch_callbacks.py
index 7532f2772c..01eb1af639 100644
--- a/autogpt_platform/backend/backend/copilot/dream/batch_callbacks.py
+++ b/autogpt_platform/backend/backend/copilot/dream/batch_callbacks.py
@@ -37,10 +37,14 @@ from __future__ import annotations
import json
import logging
+from contextlib import ExitStack
from typing import TYPE_CHECKING, Any, Literal
from pydantic import ValidationError
+from backend.copilot.trial_cost_context import TrialCostContext, restore_cost_context
+from backend.copilot.usage_activation import UsageActivationUnavailable
+
from .batch_submit import (
PHASE_RESPONSE_MODELS,
delete_input_bundle,
@@ -275,6 +279,48 @@ async def _release_lock(
async def handle_dream_batch_result(
entry: PendingEntry, rows: list[BatchResultRow]
+) -> None:
+ payload = entry.payload or {}
+ user_id = str(payload.get("user_id") or "")
+ if (
+ not user_id
+ or not payload.get("pass_id")
+ or payload.get("phase") not in NEXT_PHASE
+ ):
+ await _handle_dream_batch_result(entry, rows)
+ return
+ with ExitStack() as attribution:
+ try:
+ raw_context = payload.get("cost_context")
+ if raw_context is None:
+ raise UsageActivationUnavailable("Dream batch has no usage attribution")
+ context = TrialCostContext.model_validate(raw_context)
+ attribution.enter_context(restore_cost_context(user_id, context))
+ except (UsageActivationUnavailable, ValueError):
+ await _fail_unattributed_pass(payload)
+ raise
+ await _handle_dream_batch_result(entry, rows)
+
+
+async def _fail_unattributed_pass(payload: dict[str, Any]) -> None:
+ """Close a dead-end batch without charging against a new usage context."""
+ pass_id = str(payload["pass_id"])
+ await _mark_job_errored_best_effort(
+ str(payload.get("job_id") or ""), "batch usage attribution unavailable"
+ )
+ try:
+ input_bundle = await read_input_bundle(pass_id)
+ if input_bundle is not None:
+ await _release_lock(input_bundle.user_id, pass_id, input_bundle.expert_id)
+ except Exception:
+ logger.exception(
+ "Unattributed dream batch lock cleanup failed for pass=%s", pass_id
+ )
+ await _best_effort_cleanup(pass_id)
+
+
+async def _handle_dream_batch_result(
+ entry: PendingEntry, rows: list[BatchResultRow]
) -> None:
"""BatchExecutor entry — called once per finished phase batch.
diff --git a/autogpt_platform/backend/backend/copilot/dream/batch_callbacks_test.py b/autogpt_platform/backend/backend/copilot/dream/batch_callbacks_test.py
index ff9fc3d225..c255940a1e 100644
--- a/autogpt_platform/backend/backend/copilot/dream/batch_callbacks_test.py
+++ b/autogpt_platform/backend/backend/copilot/dream/batch_callbacks_test.py
@@ -8,14 +8,21 @@ submit phase 3 → phase 3 result → apply + mark JobStatus complete.
from __future__ import annotations
+import json
from datetime import datetime, timezone
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from backend.copilot.dream.batch_callbacks import handle_dream_batch_result
+from backend.copilot.dream.batch_submit import input_bundle_key, persist_input_bundle
+from backend.copilot.dream.fetch import DreamInput
+from backend.copilot.dream.job_status import read_status, write_initial_status
+from backend.copilot.dream.locks import _lock_key
from backend.copilot.dream.schemas import IngestionDrainStatus
-from backend.executor.batch_executor import PendingEntry
+from backend.copilot.trial_cost_context import get_trial_cost_context
+from backend.copilot.usage_activation import UsageActivationUnavailable
+from backend.executor.batch_executor import PendingEntry, _dispatch
from backend.util.llm.providers import BatchResultRow
@@ -89,6 +96,7 @@ def _entry(
custom_id = f"{pass_id}:{phase}"
payload = {
"user_id": "u1",
+ "cost_context": {"user_id": "u1", "trial_id": None, "generation": None},
"pass_id": pass_id,
"job_id": job_id,
"phase": phase,
@@ -316,13 +324,15 @@ class TestPhaseChaining:
)
update_status = AsyncMock()
- with patch(
- "backend.copilot.dream.batch_callbacks.submit_phase", submit_phase
- ), patch(
- "backend.copilot.dream.job_status.update_status_phase", update_status
- ), patch(
- "backend.copilot.dream.batch_callbacks._anthropic_api_key",
- return_value="sk-ant-test",
+ with (
+ patch("backend.copilot.dream.batch_callbacks.submit_phase", submit_phase),
+ patch(
+ "backend.copilot.dream.job_status.update_status_phase", update_status
+ ),
+ patch(
+ "backend.copilot.dream.batch_callbacks._anthropic_api_key",
+ return_value="sk-ant-test",
+ ),
):
await handle_dream_batch_result(
_entry(phase="consolidate"),
@@ -365,13 +375,13 @@ class TestPhaseChaining:
submit_phase = AsyncMock(
return_value=MagicMock(provider_batch_id="msgbatch_sanitize")
)
- with patch(
- "backend.copilot.dream.batch_callbacks.submit_phase", submit_phase
- ), patch(
- "backend.copilot.dream.batch_callbacks._anthropic_api_key",
- return_value="sk-ant-test",
- ), patch(
- "backend.copilot.dream.job_status.update_status_phase", AsyncMock()
+ with (
+ patch("backend.copilot.dream.batch_callbacks.submit_phase", submit_phase),
+ patch(
+ "backend.copilot.dream.batch_callbacks._anthropic_api_key",
+ return_value="sk-ant-test",
+ ),
+ patch("backend.copilot.dream.job_status.update_status_phase", AsyncMock()),
):
await handle_dream_batch_result(
_entry(phase="recombine"),
@@ -431,12 +441,15 @@ class TestPhaseChaining:
mark_complete = AsyncMock()
record_cost = AsyncMock()
release_lock = AsyncMock()
- with patch("backend.copilot.dream.apply.apply_operations", apply), patch(
- "backend.copilot.dream.job_status.mark_complete", mark_complete
- ), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
- ), patch(
- "backend.copilot.dream.batch_callbacks.release_dream_lock", release_lock
+ with (
+ patch("backend.copilot.dream.apply.apply_operations", apply),
+ patch("backend.copilot.dream.job_status.mark_complete", mark_complete),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
+ ),
+ patch(
+ "backend.copilot.dream.batch_callbacks.release_dream_lock", release_lock
+ ),
):
await handle_dream_batch_result(
_entry(phase="sanitize"),
@@ -568,10 +581,12 @@ class TestPhaseChaining:
apply = AsyncMock(return_value={"writes": 0, "snapshot": "..."})
record_cost = AsyncMock()
- with patch("backend.copilot.dream.apply.apply_operations", apply), patch(
- "backend.copilot.dream.job_status.mark_complete", AsyncMock()
- ), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
+ with (
+ patch("backend.copilot.dream.apply.apply_operations", apply),
+ patch("backend.copilot.dream.job_status.mark_complete", AsyncMock()),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
+ ),
):
await handle_dream_batch_result(
_entry(phase="sanitize"),
@@ -630,16 +645,19 @@ class TestPhaseChaining:
release_lock = AsyncMock()
# Crash-before-cleanup simulation: state + input bundle survive the
# first delivery, so the re-dispatch sees a fully populated pass.
- with patch("backend.copilot.dream.apply.apply_operations", apply), patch(
- "backend.copilot.dream.job_status.mark_complete", mark_complete
- ), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
- ), patch(
- "backend.copilot.dream.batch_callbacks.release_dream_lock", release_lock
- ), patch(
- "backend.copilot.dream.batch_callbacks._delete_state", AsyncMock()
- ), patch(
- "backend.copilot.dream.batch_callbacks.delete_input_bundle", AsyncMock()
+ with (
+ patch("backend.copilot.dream.apply.apply_operations", apply),
+ patch("backend.copilot.dream.job_status.mark_complete", mark_complete),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
+ ),
+ patch(
+ "backend.copilot.dream.batch_callbacks.release_dream_lock", release_lock
+ ),
+ patch("backend.copilot.dream.batch_callbacks._delete_state", AsyncMock()),
+ patch(
+ "backend.copilot.dream.batch_callbacks.delete_input_bundle", AsyncMock()
+ ),
):
await handle_dream_batch_result(
_entry(phase="sanitize"),
@@ -692,12 +710,14 @@ class TestPhaseChaining:
mark_complete = AsyncMock()
mark_errored = AsyncMock()
gate = AsyncMock(return_value="error")
- with patch("backend.copilot.dream.apply.apply_operations", apply), patch(
- "backend.copilot.dream.job_status.mark_complete", mark_complete
- ), patch("backend.copilot.dream.job_status.mark_errored", mark_errored), patch(
- "backend.copilot.dream.batch_callbacks._claim_apply_gate", gate
- ), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
+ with (
+ patch("backend.copilot.dream.apply.apply_operations", apply),
+ patch("backend.copilot.dream.job_status.mark_complete", mark_complete),
+ patch("backend.copilot.dream.job_status.mark_errored", mark_errored),
+ patch("backend.copilot.dream.batch_callbacks._claim_apply_gate", gate),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
+ ),
):
await handle_dream_batch_result(
_entry(phase="sanitize"),
@@ -760,10 +780,11 @@ class TestErrorPaths:
await _persist_autopilot_bundle()
mark_errored = AsyncMock()
record_cost = AsyncMock()
- with patch(
- "backend.copilot.dream.job_status.mark_errored", mark_errored
- ), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
+ with (
+ patch("backend.copilot.dream.job_status.mark_errored", mark_errored),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
+ ),
):
await handle_dream_batch_result(
_entry(phase="consolidate"),
@@ -791,10 +812,12 @@ class TestErrorPaths:
submit_phase = AsyncMock()
mark_errored = AsyncMock()
record_cost = AsyncMock()
- with patch(
- "backend.copilot.dream.batch_callbacks.submit_phase", submit_phase
- ), patch("backend.copilot.dream.job_status.mark_errored", mark_errored), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
+ with (
+ patch("backend.copilot.dream.batch_callbacks.submit_phase", submit_phase),
+ patch("backend.copilot.dream.job_status.mark_errored", mark_errored),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
+ ),
):
await handle_dream_batch_result(
_entry(phase="consolidate"),
@@ -839,10 +862,12 @@ class TestErrorPaths:
apply = AsyncMock(side_effect=RuntimeError("FalkorDB unreachable"))
mark_errored = AsyncMock()
record_cost = AsyncMock()
- with patch("backend.copilot.dream.apply.apply_operations", apply), patch(
- "backend.copilot.dream.job_status.mark_errored", mark_errored
- ), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
+ with (
+ patch("backend.copilot.dream.apply.apply_operations", apply),
+ patch("backend.copilot.dream.job_status.mark_errored", mark_errored),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
+ ),
):
await handle_dream_batch_result(
_entry(phase="sanitize"),
@@ -878,12 +903,15 @@ class TestErrorPaths:
mark_errored = AsyncMock()
record_cost = AsyncMock()
release_lock = AsyncMock()
- with patch(
- "backend.copilot.dream.batch_callbacks._chain_next_phase", chain
- ), patch("backend.copilot.dream.job_status.mark_errored", mark_errored), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
- ), patch(
- "backend.copilot.dream.batch_callbacks.release_dream_lock", release_lock
+ with (
+ patch("backend.copilot.dream.batch_callbacks._chain_next_phase", chain),
+ patch("backend.copilot.dream.job_status.mark_errored", mark_errored),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", record_cost
+ ),
+ patch(
+ "backend.copilot.dream.batch_callbacks.release_dream_lock", release_lock
+ ),
):
# Must not propagate — the crash guard finalizes and swallows.
await handle_dream_batch_result(
@@ -971,11 +999,15 @@ class TestLockTokenWiring:
)
async def _dispatch_sanitize(self) -> None:
- with patch(
- "backend.copilot.dream.apply.apply_operations",
- AsyncMock(return_value={"writes": 0}),
- ), patch("backend.copilot.dream.job_status.mark_complete", AsyncMock()), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
+ with (
+ patch(
+ "backend.copilot.dream.apply.apply_operations",
+ AsyncMock(return_value={"writes": 0}),
+ ),
+ patch("backend.copilot.dream.job_status.mark_complete", AsyncMock()),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
+ ),
):
await handle_dream_batch_result(
_entry(phase="sanitize"),
@@ -1009,19 +1041,20 @@ class TestLockTokenWiring:
mark_errored = AsyncMock()
release_lock = AsyncMock()
read_token = AsyncMock(side_effect=ConnectionError("redis blip"))
- with patch(
- "backend.copilot.dream.apply.apply_operations",
- AsyncMock(return_value={"writes": 0}),
- ), patch(
- "backend.copilot.dream.job_status.mark_complete", mark_complete
- ), patch(
- "backend.copilot.dream.job_status.mark_errored", mark_errored
- ), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
- ), patch(
- "backend.copilot.dream.batch_callbacks.read_lock_token", read_token
- ), patch(
- "backend.copilot.dream.batch_callbacks.release_dream_lock", release_lock
+ with (
+ patch(
+ "backend.copilot.dream.apply.apply_operations",
+ AsyncMock(return_value={"writes": 0}),
+ ),
+ patch("backend.copilot.dream.job_status.mark_complete", mark_complete),
+ patch("backend.copilot.dream.job_status.mark_errored", mark_errored),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
+ ),
+ patch("backend.copilot.dream.batch_callbacks.read_lock_token", read_token),
+ patch(
+ "backend.copilot.dream.batch_callbacks.release_dream_lock", release_lock
+ ),
):
await handle_dream_batch_result(
_entry(phase="sanitize"),
@@ -1045,19 +1078,20 @@ class TestLockTokenWiring:
mark_complete = AsyncMock()
mark_errored = AsyncMock()
delete_state = AsyncMock(side_effect=ConnectionError("redis blip"))
- with patch(
- "backend.copilot.dream.apply.apply_operations",
- AsyncMock(return_value={"writes": 0}),
- ), patch(
- "backend.copilot.dream.job_status.mark_complete", mark_complete
- ), patch(
- "backend.copilot.dream.job_status.mark_errored", mark_errored
- ), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
- ), patch(
- "backend.copilot.dream.batch_callbacks._delete_state", delete_state
- ), patch(
- "backend.copilot.dream.batch_callbacks.release_dream_lock", AsyncMock()
+ with (
+ patch(
+ "backend.copilot.dream.apply.apply_operations",
+ AsyncMock(return_value={"writes": 0}),
+ ),
+ patch("backend.copilot.dream.job_status.mark_complete", mark_complete),
+ patch("backend.copilot.dream.job_status.mark_errored", mark_errored),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
+ ),
+ patch("backend.copilot.dream.batch_callbacks._delete_state", delete_state),
+ patch(
+ "backend.copilot.dream.batch_callbacks.release_dream_lock", AsyncMock()
+ ),
):
await handle_dream_batch_result(
_entry(phase="sanitize"),
@@ -1090,10 +1124,14 @@ class TestLockTokenWiring:
await update_status_phase(kind="dream_pass", job_id="j1", state="submitted")
apply = AsyncMock()
- with patch("backend.copilot.dream.apply.apply_operations", apply), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
- ), patch(
- "backend.copilot.dream.batch_callbacks.release_dream_lock", AsyncMock()
+ with (
+ patch("backend.copilot.dream.apply.apply_operations", apply),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
+ ),
+ patch(
+ "backend.copilot.dream.batch_callbacks.release_dream_lock", AsyncMock()
+ ),
):
await handle_dream_batch_result(
_entry(phase="sanitize"),
@@ -1123,12 +1161,16 @@ class TestLockTokenWiring:
mark_complete = AsyncMock()
read_existing = AsyncMock(return_value=MagicMock(state="complete"))
- with patch("backend.copilot.dream.apply.apply_operations", AsyncMock()), patch(
- "backend.copilot.dream.job_status.mark_complete", mark_complete
- ), patch("backend.copilot.dream.job_status.read_status", read_existing), patch(
- "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
- ), patch(
- "backend.copilot.dream.batch_callbacks.release_dream_lock", AsyncMock()
+ with (
+ patch("backend.copilot.dream.apply.apply_operations", AsyncMock()),
+ patch("backend.copilot.dream.job_status.mark_complete", mark_complete),
+ patch("backend.copilot.dream.job_status.read_status", read_existing),
+ patch(
+ "backend.copilot.dream.batch_callbacks.record_phase_cost", AsyncMock()
+ ),
+ patch(
+ "backend.copilot.dream.batch_callbacks.release_dream_lock", AsyncMock()
+ ),
):
await handle_dream_batch_result(
_entry(phase="sanitize"),
@@ -1155,3 +1197,93 @@ class TestLockTokenWiring:
await self._dispatch_sanitize()
assert string_store["dream:inflight:u1"] == "tok-newer-pass"
+
+
+async def test_callback_restores_original_trial_generation_for_late_result():
+ entry = _entry()
+ entry.payload["cost_context"] = {
+ "user_id": "u1",
+ "trial_id": "trial-original",
+ "generation": None,
+ }
+ seen = []
+
+ async def handle(_entry, _rows):
+ seen.append(get_trial_cost_context("u1"))
+
+ with patch(
+ "backend.copilot.dream.batch_callbacks._handle_dream_batch_result", handle
+ ):
+ await handle_dream_batch_result(entry, [])
+ assert seen[0].trial_id == "trial-original"
+ assert seen[0].generation is None
+ assert get_trial_cost_context("u1") is None
+
+
+async def test_callback_refuses_missing_or_foreign_attribution(fake_redis):
+ entry = _entry()
+ del entry.payload["cost_context"]
+ with pytest.raises(UsageActivationUnavailable):
+ await handle_dream_batch_result(entry, [])
+ entry.payload["cost_context"] = {"user_id": "foreign", "trial_id": None}
+ with pytest.raises(ValueError, match="different user"):
+ await handle_dream_batch_result(entry, [])
+
+
[email protected]("attribution", ["missing", "malformed", "foreign"])
[email protected]("newer_lock", [False, True])
+async def test_dispatch_invalid_attribution_closes_job_without_billing(
+ fake_redis, attribution, newer_lock
+):
+ _, state_store, string_store = fake_redis
+ now = datetime.now(timezone.utc)
+ await persist_input_bundle(
+ "p1",
+ DreamInput(
+ user_id="owner",
+ expert_id="expert-original",
+ group_id="expert_original",
+ window_start=now,
+ window_end=now,
+ ),
+ lock_token="original-token",
+ )
+ await write_initial_status(kind="dream_pass", job_id="j1", user_id="owner")
+ lock_key = _lock_key("owner", "expert-original")
+ string_store[lock_key] = "newer-token" if newer_lock else "original-token"
+ string_store["dream:inflight:u1"] = "unrelated-token"
+ state_store["dream:batch:state:p1"] = {
+ "consolidate": json.dumps({"input_tokens": 10, "output_tokens": 20})
+ }
+ entry = _entry(phase="sanitize")
+ if attribution == "missing":
+ del entry.payload["cost_context"]
+ elif attribution == "malformed":
+ entry.payload["cost_context"] = {"generation": "paid-now"}
+ else:
+ entry.payload["cost_context"] = {"user_id": "foreign", "trial_id": None}
+
+ with (
+ patch("backend.copilot.dream.batch_callbacks.record_phase_cost") as bill,
+ patch("backend.copilot.dream.batch_callbacks.submit_phase") as submit,
+ patch("backend.copilot.dream.apply.apply_operations") as apply,
+ patch("backend.copilot.trial_cost_context.capture_cost_context") as capture,
+ ):
+ await _dispatch(
+ entry, [_row(custom_id="p1:sanitize", content=_SANITIZE_CONTENT)]
+ )
+
+ status = await read_status(kind="dream_pass", job_id="j1")
+ assert status is not None and status.state == "errored"
+ assert status.completed_at is not None
+ assert string_store.get(lock_key) == ("newer-token" if newer_lock else None)
+ assert string_store["dream:inflight:u1"] == "unrelated-token"
+ assert input_bundle_key("p1") not in string_store
+ assert "dream:batch:state:p1" not in state_store
+ bill.assert_not_called()
+ submit.assert_not_called()
+ apply.assert_not_called()
+ capture.assert_not_called()
diff --git a/autogpt_platform/backend/backend/copilot/dream/batch_submit.py b/autogpt_platform/backend/backend/copilot/dream/batch_submit.py
index 6596b7e834..5ab5f3ee96 100644
--- a/autogpt_platform/backend/backend/copilot/dream/batch_submit.py
+++ b/autogpt_platform/backend/backend/copilot/dream/batch_submit.py
@@ -24,6 +24,7 @@ from typing import TYPE_CHECKING, Literal
from pydantic import BaseModel
+from backend.copilot.trial_cost_context import capture_cost_context
from backend.executor.batch_executor import (
INITIAL_POLL_DELAY_SECONDS,
PendingEntry,
@@ -159,6 +160,7 @@ async def submit_phase(
# multi-phase chain can legitimately outlive a TTL stamped once at the
# first submit. Re-arm the bundle TTL at every submit so it stays alive
# exactly as long as some phase batch may still call back.
+ cost_context = await capture_cost_context(user_id)
await refresh_input_bundle_ttl(pass_id)
model = phase_models[phase]
messages = _build_phase_messages(
@@ -209,6 +211,7 @@ async def submit_phase(
poll_delay_seconds=INITIAL_POLL_DELAY_SECONDS,
payload={
"user_id": user_id,
+ "cost_context": cost_context.model_dump(mode="json"),
"expert_id": input_bundle.expert_id,
"pass_id": pass_id,
"job_id": job_id,
diff --git a/autogpt_platform/backend/backend/copilot/dream/batch_submit_test.py b/autogpt_platform/backend/backend/copilot/dream/batch_submit_test.py
index 61a85a3976..e5ea87a63a 100644
--- a/autogpt_platform/backend/backend/copilot/dream/batch_submit_test.py
+++ b/autogpt_platform/backend/backend/copilot/dream/batch_submit_test.py
@@ -14,6 +14,7 @@ from unittest.mock import AsyncMock, patch
import pytest
+from backend.copilot import usage_activation_fixtures
from backend.copilot.dream.batch_submit import (
INPUT_TTL_SECONDS,
input_bundle_key,
@@ -246,3 +247,6 @@ async def test_read_lock_token_none_when_bundle_corrupted(fake_redis):
string_store[input_bundle_key("p3")] = "not json {{{"
assert await read_lock_token("p3") is None
+
+
+usage_snapshot = usage_activation_fixtures.usage_snapshot
diff --git a/autogpt_platform/backend/backend/copilot/dream/billing.py b/autogpt_platform/backend/backend/copilot/dream/billing.py
index 6dcd241426..6a1ee741e7 100644
--- a/autogpt_platform/backend/backend/copilot/dream/billing.py
+++ b/autogpt_platform/backend/backend/copilot/dream/billing.py
@@ -127,6 +127,7 @@ async def check_dream_budget(
daily_cost_limit=daily_limit,
weekly_cost_limit=weekly_limit,
skip_daily=True,
+ expected_tier=_tier,
)
except RateLimitExceeded as exc:
logger.info(
diff --git a/autogpt_platform/backend/backend/copilot/dream/orchestrator.py b/autogpt_platform/backend/backend/copilot/dream/orchestrator.py
index e99e6bef0b..b00a2492fb 100644
--- a/autogpt_platform/backend/backend/copilot/dream/orchestrator.py
+++ b/autogpt_platform/backend/backend/copilot/dream/orchestrator.py
@@ -26,6 +26,7 @@ from typing import TypeVar
from backend.copilot.config import ChatConfig
from backend.copilot.graphiti.client import derive_memory_scope_key
+from backend.copilot.trial_cost_context import attributed_usage
from backend.util.feature_flag import Flag, is_feature_enabled
from .apply import apply_operations, drain_status_from_stats
@@ -732,6 +733,7 @@ def _has_new_episodes_since(episodes: list[EpisodeRow], marker: datetime) -> boo
return False
+@attributed_usage
async def _execute_dream_pass_async(
user_id: str,
*,
diff --git a/autogpt_platform/backend/backend/copilot/dream/orchestrator_test.py b/autogpt_platform/backend/backend/copilot/dream/orchestrator_test.py
index 068e5f33b7..1039643bc3 100644
--- a/autogpt_platform/backend/backend/copilot/dream/orchestrator_test.py
+++ b/autogpt_platform/backend/backend/copilot/dream/orchestrator_test.py
@@ -14,6 +14,7 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
+from backend.copilot import usage_activation_fixtures
from backend.executor.scheduler import SCHEDULER_DREAM_OPERATION_TIMEOUT_SECONDS
from . import orchestrator as orchestrator_mod
@@ -1817,3 +1818,6 @@ async def test_batch_handoff_revokes_batch_when_lock_extend_fails(mocker):
delete_bundle.assert_awaited_once_with("p-lock-lost")
handle.disown.assert_not_called()
assert result.error and "lock lost" in result.error
+
+
+usage_snapshot = usage_activation_fixtures.usage_snapshot
diff --git a/autogpt_platform/backend/backend/copilot/executor/processor.py b/autogpt_platform/backend/backend/copilot/executor/processor.py
index 3ce2274e77..45aaa8372c 100644
--- a/autogpt_platform/backend/backend/copilot/executor/processor.py
+++ b/autogpt_platform/backend/backend/copilot/executor/processor.py
@@ -733,7 +733,7 @@ class CoPilotProcessor:
log.info(f"Using {'SDK' if use_sdk else 'baseline'} service")
await cost_context_stack.enter_async_context(
- trial_cost_context(entry.user_id)
+ trial_cost_context(entry.user_id, entry.cost_context)
)
# Stream chat completion and publish chunks to Redis.
diff --git a/autogpt_platform/backend/backend/copilot/executor/processor_test.py b/autogpt_platform/backend/backend/copilot/executor/processor_test.py
index ff82c5a98d..4a9e1a57fa 100644
--- a/autogpt_platform/backend/backend/copilot/executor/processor_test.py
+++ b/autogpt_platform/backend/backend/copilot/executor/processor_test.py
@@ -57,9 +57,13 @@ from backend.util.exceptions import (
@pytest.fixture(autouse=True)
def no_trial_attribution(mocker):
store = MagicMock()
- store.get_subscription_trial = AsyncMock(return_value=None)
+ store.get_usage_activation_state = AsyncMock(
+ side_effect=lambda user_id: SimpleNamespace(
+ user_id=user_id, generation=None, trial_id=None, ready=True
+ )
+ )
mocker.patch(
- "backend.copilot.trial_cost_context.db_accessors.credit_db", return_value=store
+ "backend.copilot.usage_activation.pro_activation_db", return_value=store
)
diff --git a/autogpt_platform/backend/backend/copilot/executor/scheduled_turn_alert_test.py b/autogpt_platform/backend/backend/copilot/executor/scheduled_turn_alert_test.py
index 90127ebaf4..60024378bd 100644
--- a/autogpt_platform/backend/backend/copilot/executor/scheduled_turn_alert_test.py
+++ b/autogpt_platform/backend/backend/copilot/executor/scheduled_turn_alert_test.py
@@ -5,7 +5,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
-from backend.copilot import stream_registry
+from backend.copilot import stream_registry, usage_activation_fixtures
from backend.copilot.executor.processor import CoPilotProcessor
from backend.copilot.executor.scheduled_turn_alert import (
UNCLASSIFIED,
@@ -23,6 +23,8 @@ from backend.copilot.tools.models import ErrorResponse, ExecutionStartedResponse
from backend.integrations.codex.transport import CodexCredentialIntegrityError
from backend.monitoring.instrumentation import COPILOT_SCHEDULED_TURN_FAILURES
+usage_snapshot = usage_activation_fixtures.usage_snapshot
+
_ALERT = "backend.copilot.executor.scheduled_turn_alert"
_PRISMA_ERROR = (
"Client is not connected to the query engine, you must call `connect()` "
@@ -30,6 +32,14 @@ _PRISMA_ERROR = (
)
[email protected](autouse=True)
+def mock_stream_publication(mocker):
+ mocker.patch(
+ "backend.copilot.executor.processor.stream_registry.publish_chunk",
+ new_callable=AsyncMock,
+ )
+
+
def _entry(scheduled: ScheduledTurnOrigin | None) -> CoPilotExecutionEntry:
return CoPilotExecutionEntry(
session_id="sess-weekly-report",
diff --git a/autogpt_platform/backend/backend/copilot/executor/trial_cost_test.py b/autogpt_platform/backend/backend/copilot/executor/trial_cost_test.py
index aab21216aa..1101d5aefa 100644
--- a/autogpt_platform/backend/backend/copilot/executor/trial_cost_test.py
+++ b/autogpt_platform/backend/backend/copilot/executor/trial_cost_test.py
@@ -22,7 +22,14 @@ from backend.copilot.trial_cost_context import get_trial_cost_context
async def test_delayed_trial_cost_and_later_paid_turn_are_separate(use_sdk):
trial = SimpleNamespace(id="trial-1", active=True, consumed_at=True)
store = MagicMock()
- store.get_subscription_trial = AsyncMock(return_value=trial)
+ store.get_usage_activation_state = AsyncMock(
+ side_effect=lambda user_id: SimpleNamespace(
+ user_id=user_id,
+ ready=True,
+ generation=None if trial.active else "paid-1",
+ trial_id=trial.id if trial.active else None,
+ )
+ )
store.record_subscription_trial_cost = AsyncMock()
tier = AsyncMock(return_value=SubscriptionTier.TRIAL)
release = asyncio.Event()
@@ -47,6 +54,7 @@ async def test_delayed_trial_cost_and_later_paid_turn_are_separate(use_sdk):
)
with (
patch("backend.data.db_accessors.credit_db", return_value=store),
+ patch("backend.copilot.usage_activation.pro_activation_db", return_value=store),
patch("backend.copilot.rate_limit.credit_db", return_value=store),
patch("backend.copilot.rate_limit._fetch_user_tier", tier),
patch("backend.copilot.rate_limit.get_redis_async", AsyncMock()),
diff --git a/autogpt_platform/backend/backend/copilot/executor/utils.py b/autogpt_platform/backend/backend/copilot/executor/utils.py
index b17beb0307..fdf68922f9 100644
--- a/autogpt_platform/backend/backend/copilot/executor/utils.py
+++ b/autogpt_platform/backend/backend/copilot/executor/utils.py
@@ -37,6 +37,7 @@ from backend.copilot.tree import (
release_turn,
root_envelope,
)
+from backend.copilot.trial_cost_context import TrialCostContext, capture_cost_context
from backend.data.rabbitmq import Exchange, ExchangeType, Queue, RabbitMQConfig
from backend.util import tracing
from backend.util.logging import TruncatedLogger, is_structured_logging_enabled
@@ -356,6 +357,8 @@ class CoPilotExecutionEntry(BaseModel):
queue messages written before this field existed (they sort as "all
pending before current" — the pre-fix behaviour)."""
+ cost_context: TrialCostContext | None = None
+
scheduled: ScheduledTurnOrigin | None = None
"""Set when the scheduler fired this turn. ``None`` for every other
caller, and for entries queued before the field existed."""
@@ -458,6 +461,7 @@ async def enqueue_copilot_turn(
else tracing.trace_propagation_headers()
),
enqueued_at=time.time(),
+ cost_context=await capture_cost_context(user_id),
)
queue_client = await get_async_copilot_queue()
diff --git a/autogpt_platform/backend/backend/copilot/executor/utils_test.py b/autogpt_platform/backend/backend/copilot/executor/utils_test.py
index 5226b63629..5758b00477 100644
--- a/autogpt_platform/backend/backend/copilot/executor/utils_test.py
+++ b/autogpt_platform/backend/backend/copilot/executor/utils_test.py
@@ -5,6 +5,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
+from backend.copilot import usage_activation_fixtures
from backend.copilot.credential_selection import CredentialPin
from backend.copilot.executor import utils
from backend.copilot.executor.utils import (
@@ -491,3 +492,6 @@ async def test_queue_spawned_turn_stores_impersonation_with_the_queued_row() ->
)
assert enqueue.await_args.kwargs["impersonated"] is True
+
+
+usage_snapshot = usage_activation_fixtures.usage_snapshot
diff --git a/autogpt_platform/backend/backend/copilot/executor/utils_tracing_test.py b/autogpt_platform/backend/backend/copilot/executor/utils_tracing_test.py
index ee707555cb..92b43aef37 100644
--- a/autogpt_platform/backend/backend/copilot/executor/utils_tracing_test.py
+++ b/autogpt_platform/backend/backend/copilot/executor/utils_tracing_test.py
@@ -6,11 +6,14 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
+from backend.copilot import usage_activation_fixtures
from backend.copilot.executor import utils
from backend.copilot.executor.utils import CoPilotExecutionEntry
from backend.copilot.tree import root_envelope
from backend.util import tracing
+usage_snapshot = usage_activation_fixtures.usage_snapshot
+
def _published_entry(publish: AsyncMock) -> CoPilotExecutionEntry:
return CoPilotExecutionEntry.model_validate_json(
diff --git a/autogpt_platform/backend/backend/copilot/gate/__init__.py b/autogpt_platform/backend/backend/copilot/gate/__init__.py
index 964bf82441..42801f7b84 100644
--- a/autogpt_platform/backend/backend/copilot/gate/__init__.py
+++ b/autogpt_platform/backend/backend/copilot/gate/__init__.py
@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict
from backend.copilot.context import get_current_envelope
from backend.copilot.model import ChatSession
from backend.copilot.tree import raise_ceiling, spent_past_ceiling
+from backend.copilot.trial_cost_context import capture_cost_context
from backend.platform_linking.models import Platform
from backend.util.feature_flag import Flag, is_feature_enabled
@@ -229,6 +230,7 @@ async def check_action(
args=args,
rule_key=rule_key,
envelope=get_current_envelope(),
+ cost_context=await capture_cost_context(user_id),
)
return await _park(
call, user_id, session, reason, reason_kind, subject, decided_by, spend_shown
diff --git a/autogpt_platform/backend/backend/copilot/gate/gate_test.py b/autogpt_platform/backend/backend/copilot/gate/gate_test.py
index 78a78b7da1..169d8d4d26 100644
--- a/autogpt_platform/backend/backend/copilot/gate/gate_test.py
+++ b/autogpt_platform/backend/backend/copilot/gate/gate_test.py
@@ -31,6 +31,7 @@ from backend.copilot.model import (
ChatSessionMetadata,
ChatSessionOrigin,
)
+from backend.copilot.trial_cost_context import TrialCostContext
_GATE = "backend.copilot.gate"
# The fixtures stub the rule lookup; the outage tests need the real one.
@@ -71,6 +72,14 @@ def gate_on():
def clean_session_state():
"""No prior approval and nothing rejected in this chat."""
with (
+ patch(
+ f"{_GATE}.capture_cost_context",
+ AsyncMock(
+ side_effect=lambda user_id: TrialCostContext(
+ user_id=user_id, trial_id=None
+ )
+ ),
+ ),
patch(f"{_GATE}.review_store.find_review", AsyncMock(return_value=None)),
patch(f"{_GATE}.held.remember", AsyncMock(return_value=True)),
patch(f"{_GATE}.held._held", AsyncMock(return_value={})),
diff --git a/autogpt_platform/backend/backend/copilot/gate/held.py b/autogpt_platform/backend/backend/copilot/gate/held.py
index 017092d73c..5b47fc0eb5 100644
--- a/autogpt_platform/backend/backend/copilot/gate/held.py
+++ b/autogpt_platform/backend/backend/copilot/gate/held.py
@@ -23,6 +23,7 @@ from backend.copilot.constants import COPILOT_NODE_EXEC_ID_SEPARATOR
from backend.copilot.model import ChatSession
from backend.copilot.pending_messages import PendingMessage
from backend.copilot.tree import TreeRefusal, TurnEnvelope
+from backend.copilot.trial_cost_context import TrialCostContext, restore_cost_context
from backend.data.db_accessors import chat_db, review_db
from backend.data.redis_client import get_redis_async
from backend.util.encryption import JSONCryptor
@@ -87,6 +88,7 @@ class HeldCall(BaseModel):
# The turn that held it. Its wake starts under this, re-checked against the
# tree; a call rebuilt from its card has none and is not woken.
envelope: TurnEnvelope | None = None
+ cost_context: TrialCostContext | None = None
async def remember(session_id: str, call: HeldCall) -> bool:
@@ -241,75 +243,82 @@ async def wake(
if info is None or info.user_id != user_id:
return
refusal_id = str(uuid.uuid5(uuid.NAMESPACE_URL, f"{wake_id}:refused"))
- envelope = max(calls, key=lambda c: c.held_at).envelope
+ latest = max(calls, key=lambda c: c.held_at)
+ envelope = latest.envelope
if envelope is None and not is_users_own_chat(info):
# Deriving one from the turn that just ended would run the approved
# action under that turn's limits, not the ones it was held under.
await post_refusal(session_id, UNRECORDED_WAKE, message_id=refusal_id)
return
+ if latest.cost_context is None or latest.cost_context.user_id != user_id:
+ await post_refusal(session_id, _RESEND, message_id=refusal_id)
+ return
permissions = resolve_session_permissions(info)
metadata = {_WAKE_KEY: True}
capacity = get_delegated_turn_limit() if wakes_sub_work(info) else None
- try:
- async with acquire_turn_slot(
- user_id, session_id, capacity=capacity
- ) as slot:
- # Not admitted: a turn is already running, and its end wakes us.
- if not slot.admitted:
- return
- if (
- await append_and_save_message(
- session_id,
- ChatMessage(
- id=wake_id,
- role="user",
- content=WAKE_MESSAGE,
- metadata=metadata,
- ),
+ with restore_cost_context(user_id, latest.cost_context):
+ try:
+ async with acquire_turn_slot(
+ user_id, session_id, capacity=capacity
+ ) as slot:
+ # Not admitted: a turn is already running, and its end wakes us.
+ if not slot.admitted:
+ return
+ if (
+ await append_and_save_message(
+ session_id,
+ ChatMessage(
+ id=wake_id,
+ role="user",
+ content=WAKE_MESSAGE,
+ metadata=metadata,
+ ),
+ )
+ is None
+ ):
+ return
+ turn_id = str(uuid.uuid4())
+ await dispatch_turn(
+ slot,
+ session_id=session_id,
+ user_id=user_id,
+ turn_id=turn_id,
+ message=WAKE_MESSAGE,
+ organization_id=info.organization_id,
+ team_id=info.team_id,
+ llm_auth_provider=info.metadata.llm_auth_provider,
+ llm_credential_id=info.metadata.llm_credential_id,
+ permissions=permissions,
+ message_metadata=metadata,
+ envelope=envelope,
+ # Lost in the user's own chat: a root, as their message would be.
+ root=envelope is None,
)
- is None
- ):
- return
- turn_id = str(uuid.uuid4())
- await dispatch_turn(
- slot,
- session_id=session_id,
+ # A channel that answered one of these follows this turn.
+ await woken_turns.record(
+ session_id, [c.review_id for c in calls], turn_id
+ )
+ except ConcurrentTurnLimitError:
+ await try_enqueue_turn(
user_id=user_id,
- turn_id=turn_id,
+ inflight_cap=get_inflight_turn_limit(),
+ session_id=session_id,
message=WAKE_MESSAGE,
- organization_id=info.organization_id,
- team_id=info.team_id,
+ message_id=wake_id,
+ message_metadata=metadata,
llm_auth_provider=info.metadata.llm_auth_provider,
llm_credential_id=info.metadata.llm_credential_id,
- permissions=permissions,
- message_metadata=metadata,
+ permissions=(
+ permissions.model_dump(exclude_none=True)
+ if permissions
+ else None
+ ),
envelope=envelope,
- # Lost in the user's own chat: a root, as their message would be.
- root=envelope is None,
)
- # A channel that answered one of these follows this turn.
- await woken_turns.record(
- session_id, [c.review_id for c in calls], turn_id
+ except TreeRefusal as refused:
+ await post_refusal(
+ session_id, f"{refused.message} {WAKE_LATER}", message_id=refusal_id
)
- except ConcurrentTurnLimitError:
- await try_enqueue_turn(
- user_id=user_id,
- inflight_cap=get_inflight_turn_limit(),
- session_id=session_id,
- message=WAKE_MESSAGE,
- message_id=wake_id,
- message_metadata=metadata,
- llm_auth_provider=info.metadata.llm_auth_provider,
- llm_credential_id=info.metadata.llm_credential_id,
- permissions=(
- permissions.model_dump(exclude_none=True) if permissions else None
- ),
- envelope=envelope,
- )
- except TreeRefusal as refused:
- await post_refusal(
- session_id, f"{refused.message} {WAKE_LATER}", message_id=refusal_id
- )
except InflightCapExceeded:
logger.info(f"Held calls in {session_id} wait for the user's next turn")
except Exception:
@@ -321,11 +330,15 @@ async def _deliver(
) -> PendingMessage:
from backend.copilot.tools import get_tool
+ if call.cost_context is None or call.cost_context.user_id != user_id:
+ await review_store.consume(call.review_id, user_id)
+ return _result_row(call, _RESEND, "closed")
rows = await review_db().get_reviews_by_node_exec_ids([call.review_id], user_id)
card = rows.get(call.review_id)
- outcome, output = await _outcome(
- user_id, session, call, get_tool(call.tool_name), card
- )
+ with restore_cost_context(user_id, call.cost_context):
+ outcome, output = await _outcome(
+ user_id, session, call, get_tool(call.tool_name), card
+ )
shown = _card_copy(card)
try:
return _result_row(call, cap(output), outcome, shown)
diff --git a/autogpt_platform/backend/backend/copilot/gate/held_activation_integration_test.py b/autogpt_platform/backend/backend/copilot/gate/held_activation_integration_test.py
new file mode 100644
index 0000000000..c813d71244
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/gate/held_activation_integration_test.py
@@ -0,0 +1,123 @@
+"""Delayed approvals retain trial origin through Redis and the database FIFO."""
+
+import asyncio
+from contextlib import asynccontextmanager
+from datetime import UTC, datetime
+from unittest.mock import AsyncMock, MagicMock
+from uuid import uuid4
+
+import pytest
+from prisma.enums import ReviewStatus, SubscriptionTier
+
+from backend.copilot import db as chat_db
+from backend.copilot import rate_limit, turn_queue
+from backend.copilot.active_turns import ConcurrentTurnLimitError
+from backend.copilot.executor import utils
+from backend.copilot.gate import held
+from backend.copilot.gate.held_db_test import _answer, _hold, _new_session, _Post
+from backend.copilot.tools.models import ResponseType, ToolResponseBase
+from backend.copilot.trial_cost_context import (
+ TrialCostContext,
+ capture_cost_context,
+ get_trial_cost_context,
+)
+from backend.copilot.turn_queue_activation_integration_test import (
+ _publish_activation,
+ _start_trial,
+)
+from backend.copilot.usage_activation import usage_keys, verify_activation_usage
+from backend.data import subscription_trial_integration_fixtures as fixtures
+from backend.data.redis_client import get_redis_async
+from backend.data.subscription_trial import get_subscription_trial
+
+enrollment = fixtures.enrollment
+pytestmark = fixtures.pytestmark
+
+
[email protected]("paid_tier", [SubscriptionTier.PRO, SubscriptionTier.MAX])
[email protected]("include_paid_call", [False, True])
+async def test_queued_approvals_charge_their_original_allowances(
+ enrollment, paid_tier, include_paid_call, monkeypatch
+):
+ user_id, generation = enrollment.user_id, str(uuid4())
+ await _start_trial(enrollment.id, user_id)
+ monkeypatch.setattr(
+ "backend.copilot.gate.is_feature_enabled", AsyncMock(return_value=True)
+ )
+ monkeypatch.setattr(turn_queue, "track_user_message", MagicMock())
+ monkeypatch.setattr(
+ rate_limit, "get_feature_flag_value", AsyncMock(return_value=None)
+ )
+ session = await _new_session(user_id)
+ tool = _Post()
+ origins = []
+
+ async def execute(user_id, session, **kwargs):
+ origins.append(await capture_cost_context(user_id))
+ await asyncio.create_task(rate_limit.record_cost_usage(user_id, 17))
+ return ToolResponseBase(type=ResponseType.ERROR, message="delivered")
+
+ monkeypatch.setattr(tool, "_execute", execute)
+ monkeypatch.setattr("backend.copilot.tools.get_tool", lambda _: tool)
+ redis = await get_redis_async()
+ keys = [
+ *usage_keys(user_id, None, datetime.now(UTC)),
+ *usage_keys(user_id, generation, datetime.now(UTC)),
+ held._key(session.session_id),
+ ]
+ try:
+ await rate_limit.record_cost_usage(user_id, 40)
+ trial_review = await _hold(session, user_id, "trial action")
+ await _publish_activation(user_id, generation, paid_tier)
+ await rate_limit.record_cost_usage(user_id, 7)
+ review_ids = [trial_review]
+ if include_paid_call:
+ review_ids.append(await _hold(session, user_id, "paid action"))
+ for review_id in review_ids:
+ await _answer(review_id, ReviewStatus.APPROVED)
+
+ @asynccontextmanager
+ async def full(*args, **kwargs):
+ raise ConcurrentTurnLimitError()
+ yield
+
+ monkeypatch.setattr("backend.copilot.active_turns.acquire_turn_slot", full)
+ await held.wake(user_id, session.session_id)
+ queued = await chat_db.get_latest_user_message_in_session(session.session_id)
+ expected_paid = TrialCostContext(
+ user_id=user_id, trial_id=None, generation=generation
+ )
+ expected_trial = TrialCostContext(user_id=user_id, trial_id=enrollment.id)
+ wake_origin = expected_paid if include_paid_call else expected_trial
+ assert queued is not None and queued.metadata is not None
+ assert queued.metadata["cost_context"] == wake_origin.model_dump(mode="json")
+
+ async def dispatch(*args, **kwargs):
+ assert await capture_cost_context(user_id) == wake_origin
+ results = await asyncio.gather(
+ held.resolve_answered(user_id, session),
+ held.resolve_answered(user_id, session),
+ )
+ assert sum(map(len, results)) == len(review_ids)
+
+ monkeypatch.setattr(utils, "dispatch_turn", dispatch)
+ assert await turn_queue.dispatch_next_for_user(user_id)
+ assert len(origins) == len(review_ids)
+ assert expected_trial in origins
+ assert (expected_paid in origins) == include_paid_call
+ assert get_trial_cost_context(user_id) is None
+ assert await held.resolve_answered(user_id, session) == []
+ await verify_activation_usage(user_id, generation)
+ paid_usage = 24 if include_paid_call else 7
+ assert [int(await redis.get(key) or 0) for key in keys[:4]] == [
+ 57,
+ 57,
+ paid_usage,
+ paid_usage,
+ ]
+ trial = await get_subscription_trial(user_id)
+ assert trial is not None and trial.cost_microdollars == 57
+ assert trial.consumed_at is not None and trial.converted_at is not None
+ finally:
+ for key in keys:
+ await redis.delete(key)
diff --git a/autogpt_platform/backend/backend/copilot/gate/held_attribution_test.py b/autogpt_platform/backend/backend/copilot/gate/held_attribution_test.py
new file mode 100644
index 0000000000..debcade77b
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/gate/held_attribution_test.py
@@ -0,0 +1,81 @@
+"""Approval delivery retains each call's original usage generation."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from backend.copilot.gate import held
+from backend.copilot.model import ChatSession
+from backend.copilot.trial_cost_context import (
+ TrialCostContext,
+ get_trial_cost_context,
+ restore_cost_context,
+)
+
+
+async def test_mixed_trial_and_paid_deliveries_keep_their_own_origin(monkeypatch):
+ trial = TrialCostContext(user_id="user-1", trial_id="trial-1")
+ paid = TrialCostContext(user_id="user-1", trial_id=None, generation="paid-1")
+ calls = [
+ held.HeldCall(
+ review_id=f"review-{i}",
+ tool_name="post_to_chat_platform",
+ tool_call_id=f"call-{i}",
+ args={},
+ cost_context=context,
+ )
+ for i, context in enumerate((trial, paid))
+ ]
+ monkeypatch.setattr(held, "answered", AsyncMock(return_value=calls))
+ monkeypatch.setattr(held, "_claim", AsyncMock(return_value=True))
+ monkeypatch.setattr(
+ held,
+ "review_db",
+ lambda: MagicMock(get_reviews_by_node_exec_ids=AsyncMock(return_value={})),
+ )
+ origins = []
+
+ async def outcome(*args):
+ origins.append(get_trial_cost_context("user-1"))
+ return "approved", "done"
+
+ monkeypatch.setattr(held, "_outcome", outcome)
+ with restore_cost_context("user-1", paid):
+ delivered = await held.resolve_answered(
+ "user-1", ChatSession.new(user_id="user-1", dry_run=False)
+ )
+ assert get_trial_cost_context("user-1") == paid
+ assert len(delivered) == 2
+ assert origins == [trial, paid]
+ assert get_trial_cost_context("user-1") is None
+
+
+ "snapshot", [None, TrialCostContext(user_id="another-user", trial_id="trial-1")]
+)
+async def test_unknown_held_origin_closes_without_running(monkeypatch, snapshot):
+ call = held.HeldCall(
+ review_id="review-1",
+ tool_name="post_to_chat_platform",
+ tool_call_id="call-1",
+ args={},
+ cost_context=snapshot,
+ )
+ monkeypatch.setattr(held, "answered", AsyncMock(return_value=[call]))
+ monkeypatch.setattr(held, "_claim", AsyncMock(return_value=True))
+ monkeypatch.setattr(
+ held,
+ "review_db",
+ lambda: MagicMock(get_reviews_by_node_exec_ids=AsyncMock(return_value={})),
+ )
+ consume = AsyncMock()
+ outcome = AsyncMock(return_value=("approved", "done"))
+ monkeypatch.setattr(held.review_store, "consume", consume)
+ monkeypatch.setattr(held, "_outcome", outcome)
+ [result] = await held.resolve_answered(
+ "user-1", ChatSession.new(user_id="user-1", dry_run=False)
+ )
+ outcome.assert_not_awaited()
+ consume.assert_awaited_once_with("review-1", "user-1")
+ assert result.metadata["held_call"]["outcome"] == "closed"
+ assert "send the request again" in result.content
diff --git a/autogpt_platform/backend/backend/copilot/gate/held_db_test.py b/autogpt_platform/backend/backend/copilot/gate/held_db_test.py
index bf032a6ca5..3f0c80fe19 100644
--- a/autogpt_platform/backend/backend/copilot/gate/held_db_test.py
+++ b/autogpt_platform/backend/backend/copilot/gate/held_db_test.py
@@ -288,11 +288,10 @@ async def test_a_wake_in_a_sub_session_leaves_the_users_last_slot(
@pytest.mark.asyncio(loop_scope="session")
-async def test_a_call_rebuilt_from_its_card_wakes_as_a_root_in_the_users_own_chat(
+async def test_a_call_rebuilt_without_usage_origin_asks_for_resend_in_own_chat(
setup_test_user, test_user_id, gate_on, post_tool
):
- """Its record was lost, but a turn in the user's own chat is a root anyway:
- the wake starts as one, under the session's permissions as they are now."""
+ """The card alone cannot establish which allowance bought the work."""
session = await _new_session(test_user_id)
review_id = await _hold(session, test_user_id, "lost in Redis")
assert await held._claim(session.session_id, review_id)
@@ -310,9 +309,10 @@ async def test_a_call_rebuilt_from_its_card_wakes_as_a_root_in_the_users_own_cha
):
await held.wake(test_user_id, session.session_id, rows.values())
- woken = dispatch.await_args.kwargs
- assert (woken["envelope"], woken["root"]) == (None, True)
- assert woken["permissions"] == today
+ dispatch.assert_not_awaited()
+ reloaded = await get_chat_session(session.session_id, test_user_id)
+ assert reloaded is not None
+ assert any("send the request again" in (m.content or "") for m in reloaded.messages)
@pytest.mark.asyncio(loop_scope="session")
@@ -439,7 +439,7 @@ async def test_a_held_calls_arguments_are_never_stored_in_the_clear(
@pytest.mark.asyncio(loop_scope="session")
-async def test_an_approval_whose_held_call_was_lost_runs_from_the_card(
+async def test_an_approval_whose_usage_origin_was_lost_does_not_run_from_the_card(
setup_test_user, test_user_id, gate_on, post_tool
):
session = await _new_session(test_user_id)
@@ -448,8 +448,8 @@ async def test_an_approval_whose_held_call_was_lost_runs_from_the_card(
[delivered] = await held.resolve_answered(test_user_id, session)
- assert post_tool.runs == [{"text": "from the card"}]
- assert "posted from the card" in delivered.content
+ assert post_tool.runs == []
+ assert "send the request again" in delivered.content
# The card kept the call's id, so the chain row still finds its result.
assert delivered.metadata["held_call"]["tool_call_id"] == "call-1"
assert await _row(review_id, test_user_id) is None
diff --git a/autogpt_platform/backend/backend/copilot/gate/reads.py b/autogpt_platform/backend/backend/copilot/gate/reads.py
index 6d3d752d54..341ce1d8cd 100644
--- a/autogpt_platform/backend/backend/copilot/gate/reads.py
+++ b/autogpt_platform/backend/backend/copilot/gate/reads.py
@@ -32,6 +32,7 @@ from backend.copilot.constants import AUTOPILOT_NAME, COPILOT_NODE_PREFIX
from backend.copilot.context import get_current_envelope
from backend.copilot.model import ChatSession
from backend.copilot.tools.models import ApprovalRequiredResponse, ResponseType
+from backend.copilot.trial_cost_context import capture_cost_context
from backend.data.db_accessors import experts_db
from backend.data.workspace_scope import EXPERTS_ROOT, SKILLS_ROOT
@@ -252,6 +253,7 @@ async def screen_read(
tool_call_id=tool_call_id,
args=args,
envelope=get_current_envelope(),
+ cost_context=await capture_cost_context(user_id),
)
return await _hold(
call,
diff --git a/autogpt_platform/backend/backend/copilot/gate/reads_test.py b/autogpt_platform/backend/backend/copilot/gate/reads_test.py
index 829fa8de3d..cffa5585e2 100644
--- a/autogpt_platform/backend/backend/copilot/gate/reads_test.py
+++ b/autogpt_platform/backend/backend/copilot/gate/reads_test.py
@@ -37,6 +37,11 @@ from backend.copilot.sdk.tool_adapter import (
)
from backend.copilot.tools.base import BaseTool
from backend.copilot.tools.models import ResponseType, ToolResponseBase
+from backend.copilot.trial_cost_context import (
+ TrialCostContext,
+ capture_cost_context,
+ restore_cost_context,
+)
from backend.util.json import sanitize_json
_READS = "backend.copilot.gate.reads"
@@ -132,6 +137,10 @@ def _session(mode: AutopilotMode | None = "auto") -> ChatSession:
def rows():
fake = _Rows()
with (
+ patch(
+ f"{_READS}.capture_cost_context",
+ AsyncMock(return_value=TrialCostContext(user_id="user-1", trial_id=None)),
+ ),
patch("backend.copilot.gate.is_feature_enabled", AsyncMock(return_value=True)),
patch.object(review_store, "find_review", fake.find_review),
patch.object(review_store, "consume", fake.consume),
@@ -142,6 +151,18 @@ def rows():
yield fake
+async def test_held_read_keeps_the_origin_of_its_request(rows):
+ origin = TrialCostContext(user_id="user-1", trial_id="trial-1")
+ with (
+ restore_cost_context("user-1", origin),
+ patch(f"{_READS}.capture_cost_context", capture_cost_context),
+ patch(f"{_READS}.judge_content", _judge(_HELD)),
+ ):
+ await _call(_Fetch(_MARKER), _session())
+ assert len(rows.held) == 1
+ assert rows.held[0].cost_context == origin
+
+
def _experts(**by_name: str | None):
"""An ``experts_db`` whose ``get_expert`` knows each name's id."""
names = {expert_id: name for name, expert_id in by_name.items() if expert_id}
@@ -1166,6 +1187,10 @@ async def test_a_declared_part_the_cap_cut_is_judged_as_cut(rows):
patch(
"backend.copilot.sdk.tool_adapter.resolve_tool_dispatch", lambda *_: None
),
+ patch(
+ "backend.copilot.tools.base._persist_and_summarize",
+ AsyncMock(side_effect=lambda raw_output, *args: raw_output),
+ ),
):
to_model = _text_from_mcp_result(await wrapper({"url": "u"}))
diff --git a/autogpt_platform/backend/backend/copilot/gate/spend_test.py b/autogpt_platform/backend/backend/copilot/gate/spend_test.py
index 38ac6373df..2c37920007 100644
--- a/autogpt_platform/backend/backend/copilot/gate/spend_test.py
+++ b/autogpt_platform/backend/backend/copilot/gate/spend_test.py
@@ -43,6 +43,7 @@ from backend.copilot.tree import (
root_envelope,
)
from backend.copilot.tree_test import BrokenRedis, FakeRedis
+from backend.copilot.trial_cost_context import TrialCostContext
from backend.data.block_cost_config import BLOCK_COSTS
from backend.data.execution import ExecutionStatus
from backend.data.model import CredentialsMetaInput
@@ -119,6 +120,10 @@ def gate(redis):
consume=AsyncMock(return_value=True),
)
with (
+ patch(
+ f"{_GATE}.capture_cost_context",
+ AsyncMock(return_value=TrialCostContext(user_id="user-1", trial_id=None)),
+ ),
patch(f"{_GATE}.is_feature_enabled", AsyncMock(return_value=True)),
patch.object(tree, "is_feature_enabled", AsyncMock(return_value=True)),
patch(f"{_GATE}.review_store.find_review", store.find_review),
@@ -346,6 +351,9 @@ async def test_a_workflow_run_charges_its_pre_flight_estimate(gate, chat):
)
agent = SimpleNamespace(id="lib-1", graph_id="main", name="Digest")
execution = SimpleNamespace(id="exec-1", status=ExecutionStatus.RUNNING)
+ session = _session()
+ session.organization_id = "org-1"
+ session.team_id = "team-1"
with (
patch(f"{_RUN}.get_or_create_library_agent", AsyncMock(return_value=agent)),
patch(
@@ -353,10 +361,9 @@ async def test_a_workflow_run_charges_its_pre_flight_estimate(gate, chat):
AsyncMock(return_value=execution),
),
patch(f"{_RUN}.track_chat_outcome"),
+ patch(f"{_RUN}._safe_link_to_chat_share", AsyncMock()),
):
- await RunAgentTool()._run_agent(
- "user-1", _session(), graph, {}, {}, dry_run=False
- )
+ await RunAgentTool()._run_agent("user-1", session, graph, {}, {}, dry_run=False)
assert (await chat.snapshot(_ledger_id()))["spent"] == 20_000
diff --git a/autogpt_platform/backend/backend/copilot/rate_limit.py b/autogpt_platform/backend/backend/copilot/rate_limit.py
index 3cce9cb1dd..6e5fb9f59b 100644
--- a/autogpt_platform/backend/backend/copilot/rate_limit.py
+++ b/autogpt_platform/backend/backend/copilot/rate_limit.py
@@ -64,8 +64,13 @@ from prisma.models import User as PrismaUser
from pydantic import BaseModel, Field
from redis.exceptions import RedisClusterException, RedisError
-from backend.copilot.trial_cost_context import record_attributed_trial_cost
+from backend.copilot.trial_cost_context import capture_cost_context
from backend.copilot.trial_reads import shared_trial_read
+from backend.copilot.usage_activation import (
+ UsageActivationUnavailable,
+ get_ready_usage_state,
+ usage_keys,
+)
from backend.data.db_accessors import credit_db, user_db
from backend.data.redis_client import AsyncRedisClient, get_redis_async
from backend.data.subscription_trial import TrialState
@@ -471,16 +476,7 @@ class RateLimitExceeded(Exception):
)
-class RateLimitUnavailable(Exception):
- """Rate limit state is currently unreachable — request rejected to
- prevent USD-cap bypass. Maps to HTTP 503 in the API layer.
-
- Distinct from :class:`RateLimitExceeded` (HTTP 429): the user is not
- over their cap, but Redis is down so we cannot prove they are under it
- either. Failing closed avoids the brown-out bypass where a user could
- blast the LLM during a Redis outage and exceed their daily/weekly USD
- allowance by hundreds of dollars.
- """
+RateLimitUnavailable = UsageActivationUnavailable
async def get_usage_status(
@@ -505,19 +501,29 @@ async def get_usage_status(
CoPilotUsageStatus with current usage and limits in microdollars.
"""
now = datetime.now(UTC)
+ state = await get_ready_usage_state(user_id)
+ if await _effective_usage_tier(user_id, state.tier) != tier:
+ raise RateLimitUnavailable("Subscription changed while resolving usage limits")
+ d_key, w_key = usage_keys(user_id, state.generation, now)
daily_used = 0
weekly_used = 0
try:
redis = await get_redis_async()
daily_raw, weekly_raw = await asyncio.gather(
- redis.get(_daily_key(user_id, now=now)),
- redis.get(_weekly_key(user_id, now=now)),
+ redis.get(d_key),
+ redis.get(w_key),
)
daily_used = int(daily_raw or 0)
weekly_used = int(weekly_raw or 0)
- except (RedisError, RedisClusterException, ConnectionError, OSError, ValueError):
- # ValueError: corrupt non-numeric counter (partial write / wrong-type
- # SET) — same fail-open semantics, returns zeros.
+ except (
+ RedisError,
+ RedisClusterException,
+ ConnectionError,
+ OSError,
+ ValueError,
+ ) as exc:
+ if state.generation is not None:
+ raise RateLimitUnavailable("Paid usage state is unavailable") from exc
logger.warning("Redis unavailable for usage status, returning zeros")
weekly_reset = _weekly_reset_time(now=now)
@@ -554,6 +560,8 @@ async def get_remaining_usd_budget(
daily_cost_limit: int,
weekly_cost_limit: int,
floor_usd: float = 0.5,
+ *,
+ expected_tier: SubscriptionTier | str | None = None,
) -> float:
"""Return the user's remaining USD spend cap for the current windows.
@@ -589,8 +597,14 @@ async def get_remaining_usd_budget(
to start a turn. Set to ``0.0`` when the caller wants a
faithful "no remaining budget" signal instead of a floor.
"""
+ state = await get_ready_usage_state(user_id)
+ if (
+ expected_tier is not None
+ and await _effective_usage_tier(user_id, state.tier) != expected_tier
+ ):
+ raise RateLimitUnavailable("Subscription changed while resolving usage limits")
trial = None
- if await _fetch_user_tier(user_id) == SubscriptionTier.TRIAL:
+ if state.tier == SubscriptionTier.TRIAL:
trial = await _subscription_trial(user_id)
if trial is None or not trial.active:
return 0.0
@@ -600,11 +614,12 @@ async def get_remaining_usd_budget(
/ 1_000_000
)
now = datetime.now(UTC)
+ d_key, w_key = usage_keys(user_id, state.generation, now)
try:
redis = await get_redis_async()
daily_raw, weekly_raw = await asyncio.gather(
- redis.get(_daily_key(user_id, now=now)),
- redis.get(_weekly_key(user_id, now=now)),
+ redis.get(d_key),
+ redis.get(w_key),
)
daily_used = int(daily_raw or 0)
weekly_used = int(weekly_raw or 0)
@@ -674,6 +689,7 @@ async def build_budget_ctx(
# we map it back to "" below so the model doesn't see a
# misleading $0.00 hint when our metrics are degraded.
floor_usd=0.0,
+ expected_tier=_tier,
)
if remaining == float("inf") or remaining <= 0.0:
return ""
@@ -690,6 +706,7 @@ async def check_rate_limit(
weekly_cost_limit: int,
*,
skip_daily: bool = False,
+ expected_tier: SubscriptionTier | str | None = None,
) -> None:
"""Check if user is within rate limits.
@@ -723,7 +740,14 @@ async def check_rate_limit(
(the exact cost is unknown until after generation).
"""
now = datetime.now(UTC)
- if await _fetch_user_tier(user_id) == SubscriptionTier.TRIAL:
+ state = await get_ready_usage_state(user_id)
+ if (
+ expected_tier is not None
+ and await _effective_usage_tier(user_id, state.tier) != expected_tier
+ ):
+ raise RateLimitUnavailable("Subscription changed while resolving usage limits")
+ d_key, w_key = usage_keys(user_id, state.generation, now)
+ if state.tier == SubscriptionTier.TRIAL:
trial = await _subscription_trial(user_id)
if trial is None or not trial.active:
raise RateLimitExceeded("trial", now)
@@ -736,8 +760,8 @@ async def check_rate_limit(
try:
redis = await get_redis_async()
daily_raw, weekly_raw = await asyncio.gather(
- redis.get(_daily_key(user_id, now=now)),
- redis.get(_weekly_key(user_id, now=now)),
+ redis.get(d_key),
+ redis.get(w_key),
)
daily_used = int(daily_raw or 0)
weekly_used = int(weekly_raw or 0)
@@ -802,20 +826,26 @@ async def reset_daily_usage(user_id: str, daily_cost_limit: int = 0) -> bool:
try:
redis = await get_redis_async()
- d_key = _daily_key(user_id, now=now)
- w_key = _weekly_key(user_id, now=now) if daily_cost_limit > 0 else None
+ state = await get_ready_usage_state(user_id)
+ d_key, w_key = usage_keys(user_id, state.generation, now)
# Daily and weekly keys hash to different cluster slots, so cross-key
# MULTI/EXEC is not available. Issue the writes sequentially — the
# failure mode (daily deleted, weekly not decremented) is a
# best-effort refund budget that the read path already tolerates.
await redis.delete(d_key)
- if w_key is not None:
+ if daily_cost_limit > 0:
await _decr_counter_floor_zero(redis, w_key, daily_cost_limit)
logger.info("Reset daily usage for user %s", user_id[:8])
return True
- except (RedisError, RedisClusterException, ConnectionError, OSError):
+ except (
+ RedisError,
+ RedisClusterException,
+ ConnectionError,
+ OSError,
+ UsageActivationUnavailable,
+ ):
logger.warning("Redis unavailable for resetting daily usage")
return False
@@ -906,11 +936,11 @@ async def record_cost_usage(
cost_microdollars = max(0, cost_microdollars)
if cost_microdollars <= 0:
return
- if (
- not await record_attributed_trial_cost(user_id, cost_microdollars)
- and await _fetch_user_tier(user_id) == SubscriptionTier.TRIAL
- ):
- await credit_db().record_subscription_trial_cost(user_id, cost_microdollars)
+ context = await capture_cost_context(user_id)
+ if context.trial_id is not None:
+ await credit_db().record_subscription_trial_cost(
+ user_id, cost_microdollars, trial_id=context.trial_id
+ )
logger.info(
"Recording copilot spend: %d microdollars (skip_daily=%s)",
@@ -919,8 +949,7 @@ async def record_cost_usage(
)
now = datetime.now(UTC)
- d_key = _daily_key(user_id, now=now)
- w_key = _weekly_key(user_id, now=now)
+ d_key, w_key = usage_keys(user_id, context.generation, now)
daily_ttl = max(int((_daily_reset_time(now=now) - now).total_seconds()), 1)
weekly_ttl = max(int((_weekly_reset_time(now=now) - now).total_seconds()), 1)
try:
@@ -978,7 +1007,7 @@ class _UserNotFoundError(Exception):
"""Raised when a user record is missing or has no subscription tier.
Raising (rather than returning ``DEFAULT_TIER``) prevents ``@cached``
- from persisting the fallback, which would otherwise keep serving FREE
+ from persisting the fallback, which would otherwise keep serving NO_TIER
for up to the TTL after the user's real tier is set.
"""
@@ -1054,51 +1083,23 @@ async def _maybe_reconcile_stripe_tier(user_id: str) -> bool:
async def get_user_tier(user_id: str) -> SubscriptionTier:
- """Look up the user's rate-limit tier from the database.
-
- Successful results are cached for 5 minutes (via ``_fetch_user_tier``)
- to avoid a DB round-trip on every rate-limit check.
-
- Falls back to ``DEFAULT_TIER`` **without caching** when the DB is
- unreachable or returns an unrecognised value, so the next call retries
- the query instead of serving a stale fallback for up to 5 minutes.
+ """Read tier and activation readiness together, without the tier cache."""
+ state = await get_ready_usage_state(user_id)
+ tier = SubscriptionTier(state.tier)
+ if tier == SubscriptionTier.TRIAL:
+ return await _effective_usage_tier(user_id, tier)
+ if tier == SubscriptionTier.NO_TIER and await _maybe_reconcile_stripe_tier(user_id):
+ return SubscriptionTier((await get_ready_usage_state(user_id)).tier)
+ return tier
- When the resolved tier is NO_TIER and the user has a Stripe customer
- record, a lazy reconciliation check is attempted (gated to once per 5
- minutes via a Redis key) to recover from missed webhooks.
- """
- tier_from_db = True
- try:
- tier = await _fetch_user_tier(user_id)
- except _UserNotFoundError:
- # Row missing or tier is NULL — DB-confirmed NO_TIER, eligible for reconciliation.
- tier = SubscriptionTier.NO_TIER
- except Exception as exc:
- logger.warning(
- "Failed to resolve rate-limit tier for user %s, defaulting to %s: %s",
- user_id[:8],
- DEFAULT_TIER.value,
- exc,
- )
- tier = DEFAULT_TIER
- tier_from_db = False
+async def _effective_usage_tier(
+ user_id: str, tier: SubscriptionTier
+) -> SubscriptionTier:
if tier == SubscriptionTier.TRIAL:
trial = await _subscription_trial(user_id)
- return tier if trial and trial.active else SubscriptionTier.NO_TIER
- if tier != SubscriptionTier.NO_TIER:
- return tier
-
- if tier_from_db and await _maybe_reconcile_stripe_tier(user_id):
- try:
- return await _fetch_user_tier(user_id)
- except Exception as exc:
- logger.warning(
- "get_user_tier: tier re-read failed after reconciliation for %s: %s",
- user_id[:8],
- exc,
- )
-
+ if trial is None or not trial.active:
+ return SubscriptionTier.NO_TIER
return tier
@@ -1377,14 +1378,14 @@ async def reset_user_usage(user_id: str, *, reset_weekly: bool = False) -> None:
the admin believing the counters were zeroed when they were not.
"""
now = datetime.now(UTC)
- d_key = _daily_key(user_id, now=now)
- w_key = _weekly_key(user_id, now=now) if reset_weekly else None
+ state = await get_ready_usage_state(user_id)
+ d_key, w_key = usage_keys(user_id, state.generation, now)
try:
redis = await get_redis_async()
# Daily and weekly keys hash to different cluster slots — multi-key
# DELETE would raise CROSSSLOT, so issue separate calls.
await redis.delete(d_key)
- if w_key is not None:
+ if reset_weekly:
await redis.delete(w_key)
except (RedisError, RedisClusterException, ConnectionError, OSError):
logger.warning("Redis unavailable for resetting user usage")
@@ -1451,28 +1452,12 @@ def _weekly_reset_time(now: datetime | None = None) -> datetime:
async def is_user_paywalled(user_id: str) -> bool:
"""Return ``True`` if the user has no entitlement to paywalled features.
- A user with no DB tier record (``_UserNotFoundError`` — fresh signup
- that hasn't been provisioned yet, or row missing) is treated as
- ``NO_TIER`` here: paywalled iff ``ENABLE_PLATFORM_PAYMENT`` is on.
- Without this branch the missing-tier case would propagate as a 500
- in any caller that doesn't already have a generic ``except`` (e.g.
- the external API ``execute_graph_block`` route).
-
- Other tier-lookup errors propagate — callers decide (route → 503,
- background job → fail-open).
+ Missing users, incomplete activations, and lookup errors propagate:
+ HTTP gates return 503, and background work fails or retries without
+ spending while entitlement is unknown. A confirmed ``NO_TIER`` user
+ is paywalled iff ``ENABLE_PLATFORM_PAYMENT`` is on.
"""
- try:
- tier = await _fetch_user_tier(user_id)
- except _UserNotFoundError:
- # No DB row / no subscription_tier set — fresh signup that hasn't
- # been provisioned yet, or row missing entirely. Logged at debug
- # so ops can correlate "402s on fresh signups" with provisioning
- # gaps without spamming the warning level.
- logger.debug(
- "is_user_paywalled: tier lookup empty for %s, treating as NO_TIER",
- user_id[:8],
- )
- tier = SubscriptionTier.NO_TIER
+ tier = SubscriptionTier((await get_ready_usage_state(user_id)).tier)
if tier == SubscriptionTier.TRIAL:
trial = await _subscription_trial(user_id)
return trial is None or not trial.active
diff --git a/autogpt_platform/backend/backend/copilot/rate_limit_test.py b/autogpt_platform/backend/backend/copilot/rate_limit_test.py
index b77d68ae55..20c030c63e 100644
--- a/autogpt_platform/backend/backend/copilot/rate_limit_test.py
+++ b/autogpt_platform/backend/backend/copilot/rate_limit_test.py
@@ -6,6 +6,10 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from redis.exceptions import RedisClusterException, RedisError
+from backend.copilot import rate_limit, usage_activation
+from backend.copilot.trial_cost_context import TrialCostContext
+from backend.data import pro_activation
+from backend.data.pro_activation import UsageActivationState
from backend.data.subscription_trial import TrialState
from .rate_limit import (
@@ -50,6 +54,44 @@ from .rate_limit import (
_USER = "test-user-rl"
[email protected](autouse=True)
+def usage_state_boundary(mocker, request):
+ """Rate arithmetic tests use legacy generation; activation has integration coverage."""
+
+ async def state(user_id):
+ tier = await rate_limit._fetch_user_tier(user_id)
+ return UsageActivationState(user_id=user_id, tier=tier, ready=True)
+
+ # Each tier-specific test can still override the lower boundary explicitly.
+ if not (
+ request.cls
+ and request.cls.__name__
+ in {
+ "TestFetchUserTierErrorPropagation",
+ "TestGetUserTier",
+ "TestSetUserTier",
+ "TestMaybeReconcileStripeTier",
+ }
+ ):
+ mocker.patch.object(
+ rate_limit,
+ "_fetch_user_tier",
+ AsyncMock(
+ return_value=(
+ SubscriptionTier.NO_TIER
+ if request.cls and request.cls.__name__ == "TestGetUsageStatus"
+ else SubscriptionTier.PRO
+ )
+ ),
+ )
+ mocker.patch.object(rate_limit, "get_ready_usage_state", side_effect=state)
+ mocker.patch.object(
+ rate_limit,
+ "capture_cost_context",
+ AsyncMock(return_value=TrialCostContext(user_id=_USER, trial_id=None)),
+ )
+
+
# ---------------------------------------------------------------------------
# RateLimitExceeded
# ---------------------------------------------------------------------------
@@ -451,9 +493,8 @@ class TestCoPilotUsagePublicFromStatus:
class TestEnforcePaymentPaywall:
- """The dep bypasses ``get_user_tier``'s fail-open default and goes
- through ``_fetch_user_tier`` directly so a transient DB blip raises
- 503 instead of silently 402-ing every paid user."""
+ """The dependency requires a ready entitlement snapshot and maps lookup
+ failures to 503 rather than treating unknown entitlement as NO_TIER."""
@pytest.mark.asyncio
async def test_blocks_no_tier_user_when_flag_on(self, mocker):
@@ -524,7 +565,7 @@ class TestIsUserPaywalled:
"""``is_user_paywalled`` is the shared core check used by both the
route-level dep and the function-level gate inside ``add_graph_execution``.
Strict: propagates lookup failures so the caller decides how to respond
- (route → 503; background job → fail-open)."""
+ (route → 503; background job → fail or retry without spending)."""
@pytest.mark.asyncio
async def test_no_tier_with_flag_on_is_paywalled(self, mocker):
@@ -583,7 +624,7 @@ class TestIsUserPaywalled:
async def test_propagates_lookup_failure(self, mocker):
"""The helper does NOT swallow generic tier-lookup errors — callers
decide. The route-dep maps to 503; background callers
- (add_graph_execution) fail open."""
+ (add_graph_execution) fail or retry without spending."""
mocker.patch(
"backend.copilot.rate_limit._fetch_user_tier",
new=AsyncMock(side_effect=RuntimeError("DB down")),
@@ -594,38 +635,29 @@ class TestIsUserPaywalled:
await is_user_paywalled(_USER)
@pytest.mark.asyncio
- async def test_user_not_found_treated_as_no_tier_when_flag_on(self, mocker):
- """``_UserNotFoundError`` (no DB row, or no ``subscription_tier``
- set yet on a fresh signup) is treated as NO_TIER so callers without
- a generic ``except`` (e.g. the external API ``execute_graph_block``
- route) get a real 402 instead of a leaked 500."""
- from .rate_limit import _UserNotFoundError, is_user_paywalled
-
- mocker.patch(
- "backend.copilot.rate_limit._fetch_user_tier",
- new=AsyncMock(side_effect=_UserNotFoundError(_USER)),
+ @pytest.mark.parametrize("payment_enabled", [True, False])
+ async def test_user_not_found_fails_closed(self, mocker, payment_enabled):
+ """Missing users cannot establish entitlement, regardless of payment flags."""
+ accessor = MagicMock()
+ accessor.get_usage_activation_state = pro_activation.get_usage_activation_state
+ mocker.patch.object(
+ usage_activation, "pro_activation_db", return_value=accessor
)
- mocker.patch(
- "backend.copilot.rate_limit.is_feature_enabled",
- new=AsyncMock(return_value=True),
+ mocker.patch.object(
+ pro_activation, "query_raw_with_schema", AsyncMock(return_value=[])
)
- assert await is_user_paywalled(_USER) is True
-
- @pytest.mark.asyncio
- async def test_user_not_found_treated_as_no_tier_when_flag_off(self, mocker):
- """Beta cohort: missing tier + flag off → not paywalled (same
- passthrough as a real NO_TIER user with the flag off)."""
- from .rate_limit import _UserNotFoundError, is_user_paywalled
-
- mocker.patch(
- "backend.copilot.rate_limit._fetch_user_tier",
- new=AsyncMock(side_effect=_UserNotFoundError(_USER)),
+ mocker.patch.object(
+ rate_limit, "get_ready_usage_state", usage_activation.get_ready_usage_state
)
- mocker.patch(
- "backend.copilot.rate_limit.is_feature_enabled",
- new=AsyncMock(return_value=False),
+ flag = mocker.patch.object(
+ rate_limit, "is_feature_enabled", AsyncMock(return_value=payment_enabled)
)
- assert await is_user_paywalled(_USER) is False
+
+ with pytest.raises(RateLimitUnavailable) as error:
+ await rate_limit.is_user_paywalled(_USER)
+
+ assert isinstance(error.value.__cause__, ValueError)
+ flag.assert_not_awaited()
class TestUserPaywalledError:
@@ -1364,28 +1396,28 @@ class TestGetUserTier:
assert tier == SubscriptionTier.PRO
@pytest.mark.asyncio
- async def test_returns_default_when_user_not_found(self):
- """Should return DEFAULT_TIER when user is not in the DB."""
+ async def test_unavailable_user_fails_closed(self):
+ """Missing users must fail closed while their entitlement is unknown."""
mock_db = self._mock_user_db(raises=Exception("not found"))
with patch("backend.copilot.rate_limit.user_db", return_value=mock_db):
- tier = await get_user_tier(_USER)
- assert tier == DEFAULT_TIER
+ with pytest.raises(Exception):
+ await get_user_tier(_USER)
@pytest.mark.asyncio
- async def test_returns_default_when_tier_is_none(self):
- """Should return DEFAULT_TIER when subscription_tier is None."""
+ async def test_unknown_tier_fails_closed(self):
+ """A missing subscription tier must fail closed."""
mock_db = self._mock_user_db(subscription_tier=None)
with patch("backend.copilot.rate_limit.user_db", return_value=mock_db):
- tier = await get_user_tier(_USER)
- assert tier == DEFAULT_TIER
+ with pytest.raises(Exception):
+ await get_user_tier(_USER)
@pytest.mark.asyncio
- async def test_returns_default_on_db_error(self):
- """Should fall back to DEFAULT_TIER when DB raises."""
+ async def test_db_error_fails_closed(self):
+ """Database errors must fail closed rather than grant a fallback tier."""
mock_db = self._mock_user_db(raises=Exception("DB down"))
with patch("backend.copilot.rate_limit.user_db", return_value=mock_db):
- tier = await get_user_tier(_USER)
- assert tier == DEFAULT_TIER
+ with pytest.raises(Exception):
+ await get_user_tier(_USER)
@pytest.mark.asyncio
async def test_db_error_is_not_cached(self):
@@ -1396,8 +1428,8 @@ class TestGetUserTier:
"""
failing_db = self._mock_user_db(raises=Exception("DB down"))
with patch("backend.copilot.rate_limit.user_db", return_value=failing_db):
- tier1 = await get_user_tier(_USER)
- assert tier1 == DEFAULT_TIER
+ with pytest.raises(Exception):
+ await get_user_tier(_USER)
# Now DB recovers and returns PRO
ok_db = self._mock_user_db(subscription_tier="PRO")
@@ -1408,12 +1440,12 @@ class TestGetUserTier:
assert tier2 == SubscriptionTier.PRO
@pytest.mark.asyncio
- async def test_returns_default_on_invalid_tier_value(self):
- """Should fall back to DEFAULT_TIER when stored value is invalid."""
+ async def test_invalid_tier_fails_closed(self):
+ """An invalid stored tier must fail closed."""
mock_db = self._mock_user_db(subscription_tier="invalid-tier")
with patch("backend.copilot.rate_limit.user_db", return_value=mock_db):
- tier = await get_user_tier(_USER)
- assert tier == DEFAULT_TIER
+ with pytest.raises(Exception):
+ await get_user_tier(_USER)
@pytest.mark.asyncio
async def test_user_not_found_is_not_cached(self):
@@ -1427,8 +1459,8 @@ class TestGetUserTier:
# First call: user does not exist yet
missing_db = self._mock_user_db(raises=Exception("not found"))
with patch("backend.copilot.rate_limit.user_db", return_value=missing_db):
- tier1 = await get_user_tier(_USER)
- assert tier1 == DEFAULT_TIER
+ with pytest.raises(Exception):
+ await get_user_tier(_USER)
# Second call: user now exists with PRO tier
ok_db = self._mock_user_db(subscription_tier="PRO")
@@ -1520,7 +1552,7 @@ class TestMaybeReconcileStripeTier:
still resolves the DB-confirmed NO_TIER instead of raising."""
get_user_tier.cache_clear() # type: ignore[attr-defined]
mock_user = MagicMock()
- mock_user.subscription_tier = None
+ mock_user.subscription_tier = "NO_TIER"
mock_db = AsyncMock()
mock_db.get_user_by_id = AsyncMock(return_value=mock_user)
redis = self._mock_redis()
@@ -2939,7 +2971,7 @@ class TestBuildBudgetCtx:
def paid_user_tier(self, mocker):
mocker.patch(
"backend.copilot.rate_limit._fetch_user_tier",
- new=AsyncMock(return_value=SubscriptionTier.PRO),
+ new=AsyncMock(return_value=DEFAULT_TIER),
)
"""The helper combines ``get_global_rate_limits`` + ``get_remaining_usd_budget``
diff --git a/autogpt_platform/backend/backend/copilot/rate_limit_trial_state_test.py b/autogpt_platform/backend/backend/copilot/rate_limit_trial_state_test.py
new file mode 100644
index 0000000000..cfe2490adf
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/rate_limit_trial_state_test.py
@@ -0,0 +1,134 @@
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from backend.copilot import rate_limit, usage_activation
+from backend.data.pro_activation import UsageActivationState
+from backend.data.subscription_trial import TrialState
+
+USER = "trial-state-user"
+
+
+def state_db(mocker):
+ db = MagicMock()
+ db.get_usage_activation_state = AsyncMock(
+ return_value=UsageActivationState(user_id=USER, tier="TRIAL", ready=True)
+ )
+ mocker.patch.object(usage_activation, "pro_activation_db", return_value=db)
+ return db
+
+
+def trial_db(mocker):
+ trial = MagicMock(spec=TrialState)
+ trial.active = False
+ trial.cost_microdollars = 0
+ trial.offer = MagicMock(total_cost_limit=500)
+ trial.ends_at = None
+ db = MagicMock()
+ db.get_subscription_trial = AsyncMock(return_value=trial)
+ mocker.patch.object(rate_limit, "credit_db", return_value=db)
+ return db
+
+
+def limits(mocker, state_db, trial_db):
+ mocker.patch.object(
+ rate_limit, "_fetch_cost_limits_flag", AsyncMock(return_value=None)
+ )
+ mocker.patch.object(
+ rate_limit,
+ "get_tier_multipliers",
+ AsyncMock(return_value={"NO_TIER": 0.0}),
+ )
+ mocker.patch.object(rate_limit, "is_feature_enabled", AsyncMock(return_value=True))
+ redis = MagicMock()
+ redis.get = AsyncMock(return_value=None)
+ mocker.patch.object(rate_limit, "get_redis_async", AsyncMock(return_value=redis))
+
+
[email protected]("missing_trial", [False, True])
+async def test_inactive_trial_usage_remains_readable(limits, trial_db, missing_trial):
+ if missing_trial:
+ trial_db.get_subscription_trial.return_value = None
+ daily, weekly, tier = await rate_limit.get_global_rate_limits(USER, 100, 500)
+
+ status = await rate_limit.get_usage_status(USER, daily, weekly, tier=tier)
+
+ assert status.tier == rate_limit.SubscriptionTier.NO_TIER
+ assert status.daily.limit == status.weekly.limit == 0
+ public = rate_limit.CoPilotUsagePublic.from_status(status)
+ assert public.daily is not None and public.daily.percent_used == 100
+ assert public.weekly is not None and public.weekly.percent_used == 100
+
+
[email protected]("missing_trial", [False, True])
+async def test_inactive_trial_remaining_budget_is_zero(limits, trial_db, missing_trial):
+ if missing_trial:
+ trial_db.get_subscription_trial.return_value = None
+ daily, weekly, tier = await rate_limit.get_global_rate_limits(USER, 100, 500)
+
+ remaining = await rate_limit.get_remaining_usd_budget(
+ USER, daily, weekly, expected_tier=tier
+ )
+
+ assert remaining == 0.0
+
+
[email protected]("missing_trial", [False, True])
+async def test_inactive_trial_still_rejects_spending(limits, trial_db, missing_trial):
+ if missing_trial:
+ trial_db.get_subscription_trial.return_value = None
+ daily, weekly, tier = await rate_limit.get_global_rate_limits(USER, 100, 500)
+
+ with pytest.raises(rate_limit.RateLimitExceeded) as error:
+ await rate_limit.check_rate_limit(USER, daily, weekly, expected_tier=tier)
+
+ assert error.value.window == "trial"
+
+
[email protected]("consumer", ["status", "budget", "limit"])
+ "stored_tier,active,expected_tier",
+ [
+ ("PRO", False, "TRIAL"),
+ ("TRIAL", True, "NO_TIER"),
+ ("TRIAL", False, "TRIAL"),
+ ],
+)
+async def test_tier_transition_still_fails_closed(
+ limits, state_db, trial_db, stored_tier, active, expected_tier, consumer
+):
+ state_db.get_usage_activation_state.return_value = UsageActivationState(
+ user_id=USER, tier=stored_tier, ready=True
+ )
+ trial_db.get_subscription_trial.return_value.active = active
+ tier = rate_limit.SubscriptionTier(expected_tier)
+
+ with pytest.raises(rate_limit.RateLimitUnavailable):
+ await _read_usage(consumer, tier)
+
+
[email protected]("consumer", ["status", "budget", "limit"])
+async def test_unready_snapshot_still_fails_closed(limits, state_db, consumer):
+ state_db.get_usage_activation_state.return_value = UsageActivationState(
+ user_id=USER, tier="TRIAL", ready=False
+ )
+
+ with pytest.raises(rate_limit.RateLimitUnavailable):
+ await _read_usage(consumer, rate_limit.SubscriptionTier.NO_TIER)
+
+
+async def _read_usage(consumer: str, tier: rate_limit.SubscriptionTier) -> None:
+ if consumer == "status":
+ await rate_limit.get_usage_status(USER, 100, 500, tier=tier)
+ elif consumer == "budget":
+ await rate_limit.get_remaining_usd_budget(USER, 100, 500, expected_tier=tier)
+ else:
+ await rate_limit.check_rate_limit(USER, 100, 500, expected_tier=tier)
diff --git a/autogpt_platform/backend/backend/copilot/rate_limit_unlimited_test.py b/autogpt_platform/backend/backend/copilot/rate_limit_unlimited_test.py
index 9f16c08b5f..73f4a6ad01 100644
--- a/autogpt_platform/backend/backend/copilot/rate_limit_unlimited_test.py
+++ b/autogpt_platform/backend/backend/copilot/rate_limit_unlimited_test.py
@@ -9,6 +9,7 @@ from backend.copilot.rate_limit import (
check_rate_limit,
get_global_rate_limits,
)
+from backend.data.pro_activation import UsageActivationState
from backend.data.subscription_trial import TrialState
@@ -70,8 +71,12 @@ async def test_tier_scaling_preserves_unlimited_windows(
async def test_uncapped_windows_do_not_require_redis(daily: int, skip_daily: bool):
with (
patch(
- "backend.copilot.rate_limit._fetch_user_tier",
- new=AsyncMock(return_value=SubscriptionTier.NO_TIER),
+ "backend.copilot.rate_limit.get_ready_usage_state",
+ new=AsyncMock(
+ return_value=UsageActivationState(
+ user_id="unlimited-user", tier=SubscriptionTier.NO_TIER, ready=True
+ )
+ ),
),
patch(
"backend.copilot.rate_limit.get_redis_async",
@@ -90,8 +95,12 @@ async def test_active_window_still_fails_closed_without_redis(
):
with (
patch(
- "backend.copilot.rate_limit._fetch_user_tier",
- new=AsyncMock(return_value=SubscriptionTier.NO_TIER),
+ "backend.copilot.rate_limit.get_ready_usage_state",
+ new=AsyncMock(
+ return_value=UsageActivationState(
+ user_id="limited-user", tier=SubscriptionTier.NO_TIER, ready=True
+ )
+ ),
),
patch(
"backend.copilot.rate_limit.get_redis_async",
@@ -114,8 +123,15 @@ async def test_uncapped_windows_preserve_trial_enforcement(active: bool, cost: i
store.get_subscription_trial = AsyncMock(return_value=trial)
with (
patch(
- "backend.copilot.rate_limit._fetch_user_tier",
- new=AsyncMock(return_value=SubscriptionTier.TRIAL),
+ "backend.copilot.rate_limit.get_ready_usage_state",
+ new=AsyncMock(
+ return_value=UsageActivationState(
+ user_id="trial-user",
+ trial_id="trial",
+ tier=SubscriptionTier.TRIAL,
+ ready=True,
+ )
+ ),
),
patch("backend.copilot.rate_limit.credit_db", return_value=store),
patch("backend.copilot.rate_limit.get_redis_async", new=AsyncMock()) as redis,
diff --git a/autogpt_platform/backend/backend/copilot/sdk/service.py b/autogpt_platform/backend/backend/copilot/sdk/service.py
index 9f03fa6f7e..4bed142dab 100644
--- a/autogpt_platform/backend/backend/copilot/sdk/service.py
+++ b/autogpt_platform/backend/backend/copilot/sdk/service.py
@@ -329,6 +329,7 @@ async def _resolve_dynamic_max_budget_usd(user_id: str | None) -> float:
daily_cost_limit=daily_limit,
weekly_cost_limit=weekly_limit,
floor_usd=-1.0,
+ expected_tier=tier,
)
if tier == "TRIAL":
return resolve_trial_sdk_budget(static_cap, remaining)
diff --git a/autogpt_platform/backend/backend/copilot/speech.py b/autogpt_platform/backend/backend/copilot/speech.py
index 973d358733..e4f7c5f079 100644
--- a/autogpt_platform/backend/backend/copilot/speech.py
+++ b/autogpt_platform/backend/backend/copilot/speech.py
@@ -12,6 +12,7 @@ from openai import AsyncOpenAI
from backend.copilot.config import ChatConfig
from backend.copilot.token_tracking import persist_and_record_usage
+from backend.copilot.trial_cost_context import attributed_usage
from backend.util.settings import Settings
logger = logging.getLogger(__name__)
@@ -54,6 +55,7 @@ class SpeechUnavailable(Exception):
"""No OpenAI key is configured, so voice mode cannot synthesise."""
+@attributed_usage
async def synthesize_speech(
*,
user_id: str,
diff --git a/autogpt_platform/backend/backend/copilot/token_tracking.py b/autogpt_platform/backend/backend/copilot/token_tracking.py
index e34d65dff4..87098119e3 100644
--- a/autogpt_platform/backend/backend/copilot/token_tracking.py
+++ b/autogpt_platform/backend/backend/copilot/token_tracking.py
@@ -283,6 +283,7 @@ async def persist_and_record_usage(
trial_context = get_trial_cost_context(user_id)
if trial_context is not None:
metadata["subscription_trial_id"] = trial_context.trial_id
+ metadata["usage_generation"] = trial_context.generation
_schedule_cost_log(
PlatformCostEntry(
diff --git a/autogpt_platform/backend/backend/copilot/tools/gate_mcp_test.py b/autogpt_platform/backend/backend/copilot/tools/gate_mcp_test.py
index 1f0e70c5f1..869e3f1a30 100644
--- a/autogpt_platform/backend/backend/copilot/tools/gate_mcp_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/gate_mcp_test.py
@@ -13,6 +13,7 @@ from unittest.mock import AsyncMock, patch
import pytest
from prisma.enums import ReviewStatus
+from backend.copilot import usage_activation_fixtures
from backend.copilot.gate import chat_rules
from backend.copilot.gate.classifier import Judgement
from backend.copilot.gate.headline import Headline
@@ -21,6 +22,7 @@ from backend.copilot.model import AutopilotMode, ChatSession, ChatSessionMetadat
from backend.copilot.tools.models import MCPToolOutputResponse
from backend.copilot.tools.run_capability import RunCapabilityTool
+usage_snapshot = usage_activation_fixtures.usage_snapshot
_GATE = "backend.copilot.gate"
_CAP = "backend.copilot.tools.run_capability"
_GITHUB = "mcp:api.githubcopilot.com"
diff --git a/autogpt_platform/backend/backend/copilot/tools/gate_subject_test.py b/autogpt_platform/backend/backend/copilot/tools/gate_subject_test.py
index e078196601..6ec85832a2 100644
--- a/autogpt_platform/backend/backend/copilot/tools/gate_subject_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/gate_subject_test.py
@@ -30,6 +30,7 @@ from backend.blocks.http import SendWebRequestBlock
from backend.blocks.io import AgentInputBlock, AgentOutputBlock
from backend.blocks.search import GetWikipediaSummaryBlock
from backend.blocks.sql_query_block import SQLQueryBlock
+from backend.copilot import usage_activation_fixtures
from backend.copilot.gate import RUN_FILES_KEY
from backend.copilot.gate.classifier import Judgement
from backend.copilot.gate.content import ContentVerdict
@@ -53,6 +54,7 @@ from backend.util import sandbox_login
from backend.util.sandbox_login import READ_CAP
from backend.util.sandbox_login_test import FakeRedis, FakeSandbox, stock_files
+usage_snapshot = usage_activation_fixtures.usage_snapshot
_GATE = "backend.copilot.gate"
_BASH = "backend.copilot.tools.bash_exec"
_CLASSIFIER = "backend.copilot.gate.classifier"
diff --git a/autogpt_platform/backend/backend/copilot/tree.py b/autogpt_platform/backend/backend/copilot/tree.py
index 828db0df06..382d5e3a80 100644
--- a/autogpt_platform/backend/backend/copilot/tree.py
+++ b/autogpt_platform/backend/backend/copilot/tree.py
@@ -514,7 +514,7 @@ async def resolve_root_ceiling_microdollars(user_id: str | None) -> int:
# handing out the full cap is the one fail-open branch this module
# would otherwise contain.
return 0
- daily, weekly, _ = await get_global_rate_limits(
+ daily, weekly, usage_tier = await get_global_rate_limits(
user_id,
config.daily_cost_limit_microdollars,
config.weekly_cost_limit_microdollars,
@@ -522,7 +522,11 @@ async def resolve_root_ceiling_microdollars(user_id: str | None) -> int:
ceiling = _plan_ceiling_microdollars(daily)
remaining_usd = await get_remaining_usd_budget(
- user_id=user_id, daily_cost_limit=daily, weekly_cost_limit=weekly, floor_usd=0.0
+ user_id=user_id,
+ daily_cost_limit=daily,
+ weekly_cost_limit=weekly,
+ floor_usd=0.0,
+ expected_tier=usage_tier,
)
if remaining_usd == float("inf"):
return max(0, ceiling)
diff --git a/autogpt_platform/backend/backend/copilot/trial_cost_context.py b/autogpt_platform/backend/backend/copilot/trial_cost_context.py
index 330367faa6..a79443a2e7 100644
--- a/autogpt_platform/backend/backend/copilot/trial_cost_context.py
+++ b/autogpt_platform/backend/backend/copilot/trial_cost_context.py
@@ -1,15 +1,15 @@
-"""Keep delayed foreground usage attached to the trial that started the turn.
+"""Immutable usage attribution, inherited by child tasks and queued work."""
-This is attribution, not a spend reservation or a durable settlement queue.
-Async child tasks inherit the snapshot even after their parent turn exits.
-"""
-
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
+from contextlib import asynccontextmanager, contextmanager
from contextvars import ContextVar
+from functools import wraps
+from inspect import signature
+from typing import ParamSpec, TypeVar
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, TypeAdapter
+from backend.copilot.usage_activation import get_ready_usage_state
from backend.data import db_accessors
@@ -18,6 +18,7 @@ class TrialCostContext(BaseModel):
user_id: str | None
trial_id: str | None
+ generation: str | None = None
_trial_cost_context: ContextVar[TrialCostContext | None] = ContextVar(
@@ -25,21 +26,33 @@ _trial_cost_context: ContextVar[TrialCostContext | None] = ContextVar(
)
-@asynccontextmanager
-async def trial_cost_context(user_id: str | None) -> AsyncIterator[None]:
- trial = (
- await db_accessors.credit_db().get_subscription_trial(user_id)
- if user_id is not None
- else None
- )
- context = TrialCostContext(
- user_id=user_id,
- trial_id=(
- trial.id
- if trial is not None and trial.active and trial.consumed_at is not None
- else None
- ),
+async def capture_cost_context(user_id: str | None) -> TrialCostContext:
+ existing = get_trial_cost_context(user_id)
+ if existing is not None:
+ return existing
+ if user_id is None:
+ return TrialCostContext(user_id=None, trial_id=None)
+ state = await get_ready_usage_state(user_id)
+ return TrialCostContext(
+ user_id=user_id, trial_id=state.trial_id, generation=state.generation
)
+
+
+@asynccontextmanager
+async def trial_cost_context(
+ user_id: str | None, snapshot: TrialCostContext | None = None
+) -> AsyncIterator[None]:
+ context = snapshot or await capture_cost_context(user_id)
+ with restore_cost_context(user_id, context):
+ yield
+
+
+@contextmanager
+def restore_cost_context(
+ user_id: str | None, context: TrialCostContext
+) -> Iterator[None]:
+ if context.user_id != user_id:
+ raise ValueError("Trial cost attribution belongs to a different user")
token = _trial_cost_context.set(context)
try:
yield
@@ -55,7 +68,6 @@ def get_trial_cost_context(user_id: str | None) -> TrialCostContext | None:
async def record_attributed_trial_cost(user_id: str, cost_microdollars: int) -> bool:
- """Return whether the turn has a snapshot, including explicitly non-trial work."""
context = get_trial_cost_context(user_id)
if context is None:
return False
@@ -64,3 +76,24 @@ async def record_attributed_trial_cost(user_id: str, cost_microdollars: int) ->
user_id, cost_microdollars, trial_id=context.trial_id
)
return True
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def attributed_usage(function: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+ """Capture standalone/background work before its first provider request."""
+ parameters = signature(function)
+
+ @wraps(function)
+ async def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
+ arguments = parameters.bind(*args, **kwargs)
+ arguments.apply_defaults()
+ user_id = TypeAdapter(str | None).validate_python(
+ arguments.arguments["user_id"]
+ )
+ async with trial_cost_context(user_id):
+ return await function(*args, **kwargs)
+
+ return wrapped
diff --git a/autogpt_platform/backend/backend/copilot/trial_cost_context_test.py b/autogpt_platform/backend/backend/copilot/trial_cost_context_test.py
index d7498a4249..67dd85fe5b 100644
--- a/autogpt_platform/backend/backend/copilot/trial_cost_context_test.py
+++ b/autogpt_platform/backend/backend/copilot/trial_cost_context_test.py
@@ -1,26 +1,36 @@
import asyncio
-from datetime import UTC, datetime
from unittest.mock import AsyncMock, MagicMock
import pytest
+from prisma.enums import SubscriptionTier
from backend.copilot.trial_cost_context import (
+ TrialCostContext,
+ attributed_usage,
get_trial_cost_context,
record_attributed_trial_cost,
+ restore_cost_context,
trial_cost_context,
)
-from backend.data.subscription_trial import TrialState
+from backend.copilot.usage_activation import UsageActivationUnavailable
+from backend.data.pro_activation import UsageActivationState
@pytest.fixture
def store(mocker):
- trial = MagicMock(spec=TrialState)
- trial.id = "trial-1"
- trial.active = True
- trial.consumed_at = datetime.now(UTC)
store = MagicMock()
- store.get_subscription_trial = AsyncMock(return_value=trial)
+ store.get_usage_activation_state = AsyncMock(
+ return_value=UsageActivationState(
+ user_id="user-1",
+ trial_id="trial-1",
+ tier=SubscriptionTier.TRIAL,
+ ready=True,
+ )
+ )
store.record_subscription_trial_cost = AsyncMock()
+ mocker.patch(
+ "backend.copilot.usage_activation.pro_activation_db", return_value=store
+ )
mocker.patch(
"backend.copilot.trial_cost_context.db_accessors.credit_db", return_value=store
)
@@ -34,13 +44,13 @@ async def test_scope_restores_parent_even_on_failure(store, exit_error):
async with trial_cost_context("user-1"):
parent = get_trial_cost_context("user-1")
with pytest.raises(exit_error):
- async with trial_cost_context(None):
- anonymous = get_trial_cost_context(None)
- assert anonymous is not None and anonymous.trial_id is None
+ with restore_cost_context(
+ None, TrialCostContext(user_id=None, trial_id=None)
+ ):
raise exit_error()
assert get_trial_cost_context("user-1") is parent
assert get_trial_cost_context("user-1") is None
- store.get_subscription_trial.assert_awaited_once_with("user-1")
+ store.get_usage_activation_state.assert_awaited_once_with("user-1")
@pytest.mark.asyncio
@@ -52,34 +62,30 @@ async def test_cross_user_cost_is_rejected_before_writes(store):
@pytest.mark.asyncio
[email protected]("initial_state", ["absent", "inactive", "unconsumed"])
-async def test_non_trial_snapshot_never_picks_up_later_enrollment(store, initial_state):
- trial = store.get_subscription_trial.return_value
- if initial_state == "absent":
- store.get_subscription_trial.return_value = None
- elif initial_state == "inactive":
- trial.active = False
- else:
- trial.consumed_at = None
+async def test_non_trial_snapshot_never_picks_up_later_enrollment(store):
+ store.get_usage_activation_state.return_value.trial_id = None
async with trial_cost_context("user-1"):
- store.get_subscription_trial.return_value = trial
- trial.active = True
- trial.consumed_at = datetime.now(UTC)
+ store.get_usage_activation_state.return_value.trial_id = "trial-later"
assert await record_attributed_trial_cost("user-1", 100) is True
store.record_subscription_trial_cost.assert_not_awaited()
@pytest.mark.asyncio
-async def test_unscoped_call_preserves_legacy_recording(store):
+async def test_unscoped_call_does_not_guess_trial_attribution(store):
assert await record_attributed_trial_cost("user-1", 100) is False
- store.get_subscription_trial.assert_not_awaited()
- store.record_subscription_trial_cost.assert_not_awaited()
+ store.get_usage_activation_state.assert_not_awaited()
@pytest.mark.asyncio
-async def test_lookup_failure_prevents_work_and_does_not_leak_context(store):
- store.get_subscription_trial.side_effect = ConnectionError("Database unavailable")
- with pytest.raises(ConnectionError):
[email protected]("pending", [True, False])
+async def test_unavailable_state_prevents_work_and_does_not_leak_context(
+ store, pending
+):
+ if pending:
+ store.get_usage_activation_state.return_value.ready = False
+ else:
+ store.get_usage_activation_state.side_effect = ConnectionError("Database down")
+ with pytest.raises(UsageActivationUnavailable):
async with trial_cost_context("user-1"):
pytest.fail("Work must not start without an attribution snapshot")
assert get_trial_cost_context("user-1") is None
@@ -94,24 +100,39 @@ async def test_accounting_failure_is_not_silently_discarded(store):
@pytest.mark.asyncio
-async def test_parallel_users_do_not_share_attribution(store):
- async def lookup(user_id):
- trial = MagicMock(spec=TrialState)
- trial.id = f"trial-{user_id}"
- trial.active = True
- trial.consumed_at = datetime.now(UTC)
- return trial
-
- store.get_subscription_trial.side_effect = lookup
- barrier = asyncio.Barrier(2)
-
- async def turn(user_id):
- async with trial_cost_context(user_id):
- await barrier.wait()
- assert await record_attributed_trial_cost(user_id, 100) is True
-
- await asyncio.gather(turn("a"), turn("b"))
- assert store.record_subscription_trial_cost.await_count == 2
- store.record_subscription_trial_cost.assert_any_await("a", 100, trial_id="trial-a")
- store.record_subscription_trial_cost.assert_any_await("b", 100, trial_id="trial-b")
- assert get_trial_cost_context("a") is None
+async def test_child_and_background_work_keep_pre_activation_generation(store):
+ release = asyncio.Event()
+ snapshots = []
+
+ @attributed_usage
+ async def background(user_id):
+ await release.wait()
+ snapshots.append(get_trial_cost_context(user_id))
+ await record_attributed_trial_cost(user_id, 100)
+
+ async with trial_cost_context("user-1"):
+ child = asyncio.create_task(background("user-1"))
+ store.get_usage_activation_state.return_value = UsageActivationState(
+ user_id="user-1", generation="paid-1", tier=SubscriptionTier.PRO, ready=True
+ )
+ release.set()
+ await child
+ await background("user-1")
+ assert [(c.trial_id, c.generation) for c in snapshots] == [
+ ("trial-1", None),
+ (None, "paid-1"),
+ ]
+ store.record_subscription_trial_cost.assert_awaited_once_with(
+ "user-1", 100, trial_id="trial-1"
+ )
+
+
+async def test_serialized_child_context_survives_process_boundary(store):
+ async with trial_cost_context("user-1"):
+ original = get_trial_cost_context("user-1")
+ encoded = original.model_dump_json()
+ restored = TrialCostContext.model_validate_json(encoded)
+ async with trial_cost_context("user-1", restored):
+ assert get_trial_cost_context("user-1") == original
+ store.get_usage_activation_state.assert_awaited_once()
diff --git a/autogpt_platform/backend/backend/copilot/trial_reads_test.py b/autogpt_platform/backend/backend/copilot/trial_reads_test.py
index aac2fdacea..d8250b0585 100644
--- a/autogpt_platform/backend/backend/copilot/trial_reads_test.py
+++ b/autogpt_platform/backend/backend/copilot/trial_reads_test.py
@@ -18,6 +18,7 @@ from backend.copilot.trial_reads import (
sharing_trial_reads,
trial_reads_shared,
)
+from backend.data.pro_activation import UsageActivationState
from backend.data.subscription_trial import TrialState
@@ -188,8 +189,15 @@ async def test_the_chat_routes_trial_checks_read_the_trial_once():
redis.get = AsyncMock(return_value=None)
with (
patch(
- "backend.copilot.rate_limit._fetch_user_tier",
- new=AsyncMock(return_value=SubscriptionTier.TRIAL),
+ "backend.copilot.rate_limit.get_ready_usage_state",
+ new=AsyncMock(
+ return_value=UsageActivationState(
+ user_id="trial-user",
+ tier=SubscriptionTier.TRIAL,
+ trial_id="trial-1",
+ ready=True,
+ )
+ ),
),
patch(
"backend.copilot.rate_limit._fetch_cost_limits_flag",
diff --git a/autogpt_platform/backend/backend/copilot/trial_usage_limits_test.py b/autogpt_platform/backend/backend/copilot/trial_usage_limits_test.py
index 6a226c9cb5..c5e0ea6677 100644
--- a/autogpt_platform/backend/backend/copilot/trial_usage_limits_test.py
+++ b/autogpt_platform/backend/backend/copilot/trial_usage_limits_test.py
@@ -8,6 +8,7 @@ from pytest_mock import MockerFixture
from backend.copilot import rate_limit
from backend.data import subscription_trial_config
+from backend.data.pro_activation import UsageActivationState
from backend.data.subscription_trial import TrialState
from backend.data.subscription_trial_config import AcceptedTrialOffer
@@ -65,6 +66,15 @@ def trial(clock: MagicMock, mocker: MockerFixture) -> TrialState:
mocker.patch.object(
rate_limit, name, AsyncMock(return_value=rate_limit.SubscriptionTier.TRIAL)
)
+ mocker.patch.object(
+ rate_limit,
+ "get_ready_usage_state",
+ AsyncMock(
+ return_value=UsageActivationState(
+ user_id=_USER, trial_id=trial.id, tier="TRIAL", ready=True
+ )
+ ),
+ )
return trial
@@ -175,6 +185,13 @@ async def test_paid_tiers_keep_their_daily_and_weekly_limits(
rate_limit, "_fetch_tier_multipliers_flag", AsyncMock(return_value=None)
)
store = mocker.patch.object(rate_limit, "credit_db")
+ mocker.patch.object(
+ rate_limit,
+ "get_ready_usage_state",
+ AsyncMock(
+ return_value=UsageActivationState(user_id=_USER, tier=tier, ready=True)
+ ),
+ )
daily, weekly, resolved_tier = await rate_limit.get_global_rate_limits(
_USER, 4_000_000, 20_000_000
)
diff --git a/autogpt_platform/backend/backend/copilot/turn_queue.py b/autogpt_platform/backend/backend/copilot/turn_queue.py
index 11e8770d66..3ca71849bd 100644
--- a/autogpt_platform/backend/backend/copilot/turn_queue.py
+++ b/autogpt_platform/backend/backend/copilot/turn_queue.py
@@ -10,7 +10,7 @@ text column:
The user's pending message itself is just a normal ChatMessage row (no
status of its own). The dispatcher's submit-time payload (``file_ids``,
-``model``, ``permissions``, ``context``, ``request_arrival_at``,
+``model``, ``permissions``, ``context``, ``request_arrival_at``, ``cost_context``,
``impersonated``)
is stashed in that row's ``metadata`` JSONB so a later promotion can
replay the turn faithfully.
@@ -67,6 +67,11 @@ from backend.copilot.rate_limit import (
from backend.copilot.session_permissions import resolve_session_permissions
from backend.copilot.tracking import track_user_message
from backend.copilot.tree import TreeRefusal, TurnEnvelope, release_turn
+from backend.copilot.trial_cost_context import (
+ TrialCostContext,
+ capture_cost_context,
+ restore_cost_context,
+)
from backend.data.db_accessors import chat_db
from backend.integrations.codex.access import has_codex_access
@@ -211,6 +216,9 @@ async def enqueue_turn(
``metadata`` JSONB so a later promotion replays the turn faithfully.
"""
metadata = dict(message_metadata or {})
+ metadata["cost_context"] = (await capture_cost_context(user_id)).model_dump(
+ mode="json"
+ )
if context is not None:
metadata["context"] = dict(context)
if file_ids is not None:
@@ -500,34 +508,38 @@ async def _promote_head(user_id: str) -> bool | None:
# ``mark_session_completed`` → ``release_turn_slot``.
slot = TurnSlot(user_id, head.session_id)
slot.admitted = True
- await dispatch_turn(
- slot,
- session_id=head.session_id,
- user_id=user_id,
- turn_id=turn_id,
- message=pending.content,
- is_user_message=pending.role == "user",
- context=metadata.get("context"),
- file_ids=metadata.get("file_ids"),
- # Session-anchored tenancy: promoted turns attribute to the
- # session's org/team, same as directly-dispatched turns —
- # without this, capped users' queued turns would lose their
- # org context on promotion.
- organization_id=head.organization_id,
- team_id=head.team_id,
- model=metadata.get("model"),
- llm_auth_provider=head.metadata.llm_auth_provider,
- llm_credential_id=head.metadata.llm_credential_id,
- permissions=_promotion_permissions(head, metadata, spawned=spawned),
- request_arrival_at=float(metadata.get("request_arrival_at") or 0.0),
- impersonated=metadata.get("impersonated") is True,
- tool_call_id=metadata.get("tool_call_id") or "chat_stream",
- tool_name=metadata.get("tool_name") or "chat",
- # A typed message is a root, as the chat route makes it, not the
- # child of the turn this hook runs in; a wake or a child brings its own.
- envelope=queued_envelope,
- root=queued_envelope is None,
- )
+ # Missing legacy attribution must not be guessed from today's plan or
+ # the completing turn's context. Keep such work queued for recovery.
+ cost_context = TrialCostContext.model_validate(metadata.get("cost_context"))
+ with restore_cost_context(user_id, cost_context):
+ await dispatch_turn(
+ slot,
+ session_id=head.session_id,
+ user_id=user_id,
+ turn_id=turn_id,
+ message=pending.content,
+ is_user_message=pending.role == "user",
+ context=metadata.get("context"),
+ file_ids=metadata.get("file_ids"),
+ # Session-anchored tenancy: promoted turns attribute to the
+ # session's org/team, same as directly-dispatched turns —
+ # without this, capped users' queued turns would lose their
+ # org context on promotion.
+ organization_id=head.organization_id,
+ team_id=head.team_id,
+ model=metadata.get("model"),
+ llm_auth_provider=head.metadata.llm_auth_provider,
+ llm_credential_id=head.metadata.llm_credential_id,
+ permissions=_promotion_permissions(head, metadata, spawned=spawned),
+ request_arrival_at=float(metadata.get("request_arrival_at") or 0.0),
+ impersonated=metadata.get("impersonated") is True,
+ tool_call_id=metadata.get("tool_call_id") or "chat_stream",
+ tool_name=metadata.get("tool_name") or "chat",
+ # A typed message is a root, as the chat route makes it, not the
+ # child of the turn this hook runs in; a wake or a child brings its own.
+ envelope=queued_envelope,
+ root=queued_envelope is None,
+ )
except TreeRefusal as refused:
# Only a stored envelope is re-checked here; a root is never refused.
await _refuse_queued_turn(
@@ -809,7 +821,7 @@ async def turn_refusal(
return TurnRefusal(reason="paywalled")
cfg = ChatConfig()
try:
- daily_limit, weekly_limit, _ = await get_global_rate_limits(
+ daily_limit, weekly_limit, usage_tier = await get_global_rate_limits(
user_id,
cfg.daily_cost_limit_microdollars,
cfg.weekly_cost_limit_microdollars,
@@ -818,6 +830,7 @@ async def turn_refusal(
user_id=user_id,
daily_cost_limit=daily_limit,
weekly_cost_limit=weekly_limit,
+ expected_tier=usage_tier,
)
except RateLimitExceeded as exc:
return TurnRefusal(reason=f"rate-limited ({exc})")
diff --git a/autogpt_platform/backend/backend/copilot/turn_queue_activation_integration_test.py b/autogpt_platform/backend/backend/copilot/turn_queue_activation_integration_test.py
new file mode 100644
index 0000000000..9cfd80f0ff
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/turn_queue_activation_integration_test.py
@@ -0,0 +1,125 @@
+"""Persisted FIFO work retains trial attribution across paid activation."""
+
+import asyncio
+from datetime import UTC, datetime, timedelta
+from unittest.mock import AsyncMock, MagicMock
+from uuid import uuid4
+
+import pytest
+from prisma.enums import SubscriptionTier
+from prisma.models import SubscriptionTrial, User
+
+from backend.copilot import db as chat_db
+from backend.copilot import rate_limit, turn_queue
+from backend.copilot.executor import utils as executor_utils
+from backend.copilot.trial_cost_context import (
+ TrialCostContext,
+ capture_cost_context,
+ get_trial_cost_context,
+)
+from backend.copilot.usage_activation import usage_keys, verify_activation_usage
+from backend.data import subscription_trial_integration_fixtures as fixtures
+from backend.data.db import execute_raw_with_schema, transaction
+from backend.data.redis_client import get_redis_async
+from backend.data.subscription_trial import get_subscription_trial
+
+enrollment = fixtures.enrollment
+pytestmark = fixtures.pytestmark
+
+
[email protected]("paid_tier", [SubscriptionTier.PRO, SubscriptionTier.MAX])
+async def test_persisted_trial_turn_keeps_trial_costs_after_activation_and_retry(
+ enrollment, paid_tier, monkeypatch
+):
+ user_id, session_id, generation = enrollment.user_id, str(uuid4()), str(uuid4())
+ await _start_trial(enrollment.id, user_id)
+ await chat_db.create_chat_session(session_id, user_id)
+ monkeypatch.setattr(turn_queue, "track_user_message", MagicMock())
+ monkeypatch.setattr(
+ rate_limit, "get_feature_flag_value", AsyncMock(return_value=None)
+ )
+ dispatched: list[TrialCostContext] = []
+
+ async def dispatch(*args, **kwargs):
+ dispatched.append(await capture_cost_context(user_id))
+ if len(dispatched) == 1:
+ raise RuntimeError("Queue transport unavailable")
+ await asyncio.create_task(rate_limit.record_cost_usage(user_id, 17))
+
+ monkeypatch.setattr(executor_utils, "dispatch_turn", dispatch)
+ redis = await get_redis_async()
+ keys = [
+ *usage_keys(user_id, None, datetime.now(UTC)),
+ *usage_keys(user_id, generation, datetime.now(UTC)),
+ ]
+ try:
+ await rate_limit.record_cost_usage(user_id, 40)
+ await turn_queue.enqueue_turn(
+ user_id=user_id, session_id=session_id, message="Queued during trial"
+ )
+ pending = await chat_db.get_latest_user_message_in_session(session_id)
+ assert pending is not None and pending.metadata is not None
+ expected = TrialCostContext(user_id=user_id, trial_id=enrollment.id)
+ assert pending.metadata["cost_context"] == expected.model_dump(mode="json")
+ assert await chat_db.get_chat_session_status(session_id) == "queued"
+
+ await _publish_activation(user_id, generation, paid_tier)
+ await rate_limit.record_cost_usage(user_id, 7)
+ with pytest.raises(RuntimeError, match="Queue transport unavailable"):
+ await turn_queue.dispatch_next_for_user(user_id)
+ assert await chat_db.get_chat_session_status(session_id) == "queued"
+ assert get_trial_cost_context(user_id) is None
+
+ await rate_limit.record_cost_usage(user_id, 11)
+ await verify_activation_usage(user_id, generation)
+ assert await turn_queue.dispatch_next_for_user(user_id)
+ assert await chat_db.get_chat_session_status(session_id) == "running"
+ assert dispatched == [expected, expected]
+ assert get_trial_cost_context(user_id) is None
+ await verify_activation_usage(user_id, generation)
+ assert [int(await redis.get(key) or 0) for key in keys] == [57, 57, 18, 18]
+ trial = await get_subscription_trial(user_id)
+ assert trial is not None and trial.cost_microdollars == 57
+ assert trial.consumed_at is not None and trial.converted_at is not None
+ finally:
+ for key in keys:
+ await redis.delete(key)
+
+
+async def _start_trial(trial_id: str, user_id: str) -> None:
+ now = datetime.now(UTC)
+ await User.prisma().update(
+ where={"id": user_id}, data={"subscriptionTier": SubscriptionTier.TRIAL}
+ )
+ await SubscriptionTrial.prisma().update(
+ where={"id": trial_id},
+ data={
+ "status": "trialing",
+ "consumedAt": now,
+ "cardVerifiedAt": now,
+ "startedAt": now,
+ "endsAt": now + timedelta(days=7),
+ },
+ )
+
+
+async def _publish_activation(
+ user_id: str, generation: str, tier: SubscriptionTier
+) -> None:
+ async with transaction() as tx:
+ await execute_raw_with_schema(
+ """INSERT INTO {schema_prefix}"PaidUsageActivation"
+ ("id", "userId", "stripeSubscriptionId", "stripeInvoiceId", "readyAt")
+ VALUES ($1, $2, $3, $4, CURRENT_TIMESTAMP)""",
+ generation,
+ user_id,
+ f"sub_{generation}",
+ f"in_{generation}",
+ client=tx,
+ )
+ await tx.user.update(where={"id": user_id}, data={"subscriptionTier": tier})
+ await tx.subscriptiontrial.update(
+ where={"userId": user_id},
+ data={"status": "active", "convertedAt": datetime.now(UTC)},
+ )
diff --git a/autogpt_platform/backend/backend/copilot/turn_queue_attribution_test.py b/autogpt_platform/backend/backend/copilot/turn_queue_attribution_test.py
new file mode 100644
index 0000000000..ff626c109c
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/turn_queue_attribution_test.py
@@ -0,0 +1,195 @@
+"""Attribution survives the database FIFO before RabbitMQ publication."""
+
+from contextlib import asynccontextmanager
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from prisma.enums import SubscriptionTier
+
+from backend.copilot import stream_registry, turn_queue
+from backend.copilot.executor import utils
+from backend.copilot.model import ChatMessage, ChatSessionInfo
+from backend.copilot.tree import root_envelope
+from backend.copilot.trial_cost_context import (
+ TrialCostContext,
+ get_trial_cost_context,
+ restore_cost_context,
+)
+from backend.copilot.usage_activation import UsageActivationUnavailable
+from backend.data.pro_activation import UsageActivationState
+
+
+def fifo(monkeypatch: pytest.MonkeyPatch):
+ @asynccontextmanager
+ async def lock(_session_id):
+ yield True
+
+ db = MagicMock()
+ db.get_next_sequence = AsyncMock(return_value=1)
+ db.add_chat_message = AsyncMock()
+ db.update_chat_session_status = AsyncMock(return_value=True)
+ db.admit_chat_session_turn = AsyncMock(return_value="admitted")
+ db.get_latest_user_message_in_session = AsyncMock()
+ session = ChatSessionInfo(
+ session_id="session-1",
+ user_id="user-1",
+ usage=[],
+ started_at=datetime.now(timezone.utc),
+ updated_at=datetime.now(timezone.utc),
+ )
+ session.metadata.llm_auth_provider = "platform"
+ session.metadata.llm_credential_id = None
+ monkeypatch.setattr(turn_queue, "chat_db", lambda: db)
+ monkeypatch.setattr(turn_queue, "_get_session_lock", lock)
+ monkeypatch.setattr(turn_queue, "invalidate_session_cache", AsyncMock())
+ monkeypatch.setattr(turn_queue, "track_user_message", MagicMock())
+ monkeypatch.setattr(
+ turn_queue, "list_queued_sessions", AsyncMock(return_value=[session])
+ )
+ monkeypatch.setattr(turn_queue, "is_user_paywalled", AsyncMock(return_value=False))
+ monkeypatch.setattr(
+ turn_queue, "get_global_rate_limits", AsyncMock(return_value=(100, 1000, None))
+ )
+ monkeypatch.setattr(turn_queue, "check_rate_limit", AsyncMock())
+ monkeypatch.setattr(
+ utils,
+ "_admitted_turn_envelope",
+ AsyncMock(return_value=root_envelope("turn-1", session_id="session-1")),
+ )
+ monkeypatch.setattr(utils, "release_turn", AsyncMock())
+ monkeypatch.setattr(stream_registry, "create_session", AsyncMock())
+ monkeypatch.setattr(stream_registry, "delete_session_meta", AsyncMock())
+ publisher = AsyncMock()
+ monkeypatch.setattr(
+ "backend.util.clients.get_async_copilot_queue",
+ AsyncMock(return_value=publisher),
+ )
+ current = AsyncMock(
+ return_value=UsageActivationState(
+ user_id="user-1", generation="paid-1", tier=SubscriptionTier.PRO, ready=True
+ )
+ )
+ monkeypatch.setattr(
+ "backend.copilot.trial_cost_context.get_ready_usage_state", current
+ )
+ return db, publisher, current
+
+
+def pending(metadata):
+ return ChatMessage(
+ id="message-1",
+ session_id="session-1",
+ role="user",
+ content="queued work",
+ sequence=1,
+ created_at=datetime.now(timezone.utc),
+ metadata=metadata,
+ )
+
+
+async def test_admission_captures_authoritative_attribution_without_parent(fifo):
+ db, _publisher, current = fifo
+ await turn_queue.enqueue_turn(
+ user_id="user-1", session_id="session-1", message="queued work"
+ )
+ current.assert_awaited_once_with("user-1")
+ assert db.add_chat_message.call_args.kwargs["metadata"]["cost_context"] == {
+ "user_id": "user-1",
+ "trial_id": None,
+ "generation": "paid-1",
+ }
+
+
+async def test_unavailable_attribution_prevents_queue_admission(fifo):
+ db, publisher, current = fifo
+ current.side_effect = UsageActivationUnavailable("Usage activation is processing")
+ with pytest.raises(UsageActivationUnavailable):
+ await turn_queue.enqueue_turn(
+ user_id="user-1", session_id="session-1", message="queued work"
+ )
+ db.add_chat_message.assert_not_awaited()
+ db.update_chat_session_status.assert_not_awaited()
+ publisher.publish_message.assert_not_awaited()
+
+
[email protected]("trial_id,generation", [("trial-1", None), (None, "paid-1")])
+async def test_queued_turn_keeps_admission_context_across_activation(
+ fifo, trial_id, generation
+):
+ db, publisher, current = fifo
+ original = TrialCostContext(
+ user_id="user-1", trial_id=trial_id, generation=generation
+ )
+ with restore_cost_context("user-1", original):
+ await turn_queue.enqueue_turn(
+ user_id="user-1",
+ session_id="session-1",
+ message="queued work",
+ message_metadata={"cost_context": {"user_id": "forged"}},
+ )
+ metadata = db.add_chat_message.call_args.kwargs["metadata"]
+ assert metadata["cost_context"] == original.model_dump(mode="json")
+ db.get_latest_user_message_in_session.return_value = pending(metadata)
+ completing_turn = TrialCostContext(
+ user_id="user-1", trial_id=None, generation="other-generation"
+ )
+ with restore_cost_context("user-1", completing_turn):
+ assert await turn_queue.dispatch_next_for_user("user-1")
+ assert get_trial_cost_context("user-1") == completing_turn
+ entry = utils.CoPilotExecutionEntry.model_validate_json(
+ publisher.publish_message.call_args.kwargs["message"]
+ )
+ assert entry.cost_context == original
+ assert get_trial_cost_context("user-1") is None
+ current.assert_not_awaited()
+
+
+async def test_retry_uses_persisted_trial_snapshot_after_publish_failure(fifo):
+ db, publisher, current = fifo
+ snapshot = TrialCostContext(user_id="user-1", trial_id="trial-1")
+ db.get_latest_user_message_in_session.return_value = pending(
+ {"cost_context": snapshot.model_dump(mode="json")}
+ )
+ publisher.publish_message.side_effect = [RuntimeError("RabbitMQ blip"), None]
+ with pytest.raises(RuntimeError, match="RabbitMQ blip"):
+ await turn_queue.dispatch_next_for_user("user-1")
+ db.update_chat_session_status.assert_any_await(
+ session_id="session-1", expect_status="running", status="queued"
+ )
+ assert get_trial_cost_context("user-1") is None
+ assert await turn_queue.dispatch_next_for_user("user-1")
+ for call in publisher.publish_message.call_args_list:
+ entry = utils.CoPilotExecutionEntry.model_validate_json(call.kwargs["message"])
+ assert entry.cost_context == snapshot
+ current.assert_not_awaited()
+
+
+ "metadata",
+ [
+ None,
+ {"cost_context": None},
+ {"cost_context": {"user_id": "user-1"}},
+ {"cost_context": {"user_id": "other-user", "trial_id": "trial-other"}},
+ ],
+)
+async def test_unknown_queued_attribution_stays_queued_without_publishing(
+ fifo, metadata
+):
+ db, publisher, current = fifo
+ db.get_latest_user_message_in_session.return_value = pending(metadata)
+ with pytest.raises(ValueError):
+ await turn_queue.dispatch_next_for_user("user-1")
+ db.update_chat_session_status.assert_any_await(
+ session_id="session-1", expect_status="running", status="queued"
+ )
+ publisher.publish_message.assert_not_awaited()
+ current.assert_not_awaited()
+ assert get_trial_cost_context("user-1") is None
diff --git a/autogpt_platform/backend/backend/copilot/turn_queue_test.py b/autogpt_platform/backend/backend/copilot/turn_queue_test.py
index b9a5014d41..137b05527c 100644
--- a/autogpt_platform/backend/backend/copilot/turn_queue_test.py
+++ b/autogpt_platform/backend/backend/copilot/turn_queue_test.py
@@ -21,6 +21,9 @@ from backend.copilot.model import ChatMessage as PydanticChatMessage
from backend.copilot.model import ChatSessionInfo
from backend.copilot.permissions import CopilotPermissions
from backend.copilot.tree import TreeRefusal, TurnEnvelope
+from backend.copilot.trial_cost_context import TrialCostContext
+
+_COST_CONTEXT = TrialCostContext(user_id="u1", trial_id=None)
class _NoopAsyncCM:
@@ -52,6 +55,10 @@ def _pyd_message(**overrides) -> PydanticChatMessage:
"sequence": 1,
}
base.update(overrides)
+ base["metadata"] = {
+ "cost_context": _COST_CONTEXT.model_dump(mode="json"),
+ **(base["metadata"] or {}),
+ }
return PydanticChatMessage(**base)
@@ -86,6 +93,13 @@ def tracked_message(monkeypatch: pytest.MonkeyPatch) -> MagicMock:
return tracker
[email protected](autouse=True)
+def cost_context(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setattr(
+ turn_queue, "capture_cost_context", AsyncMock(return_value=_COST_CONTEXT)
+ )
+
+
# ── enqueue_turn payload encoding ──────────────────────────────────────
@@ -157,10 +171,8 @@ async def test_enqueue_turn_records_an_impersonated_turn() -> None:
@pytest.mark.asyncio
-async def test_enqueue_turn_only_includes_default_transport_without_extra_params() -> (
- None
-):
- """A turn with no extra params only persists its default LLM transport."""
+async def test_enqueue_turn_includes_default_transport_and_attribution() -> None:
+ """A turn with no extra params persists transport and usage attribution."""
db = MagicMock()
db.get_next_sequence = AsyncMock(return_value=1)
db.add_chat_message = AsyncMock(return_value=_pyd_message())
@@ -172,7 +184,8 @@ async def test_enqueue_turn_only_includes_default_transport_without_extra_params
):
await turn_queue.enqueue_turn(user_id="u1", session_id="s1", message="hello")
assert db.add_chat_message.call_args.kwargs["metadata"] == {
- "llm_auth_provider": "platform"
+ "llm_auth_provider": "platform",
+ "cost_context": _COST_CONTEXT.model_dump(mode="json"),
}
diff --git a/autogpt_platform/backend/backend/copilot/usage_activation.py b/autogpt_platform/backend/backend/copilot/usage_activation.py
new file mode 100644
index 0000000000..1c125a4db4
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/usage_activation.py
@@ -0,0 +1,43 @@
+"""Calendar usage namespaces published atomically with paid entitlement."""
+
+import asyncio
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
+
+from backend.data.db_accessors import pro_activation_db
+from backend.data.redis_client import get_redis_async
+
+if TYPE_CHECKING:
+ from backend.data.pro_activation import UsageActivationState
+
+
+class UsageActivationUnavailable(RuntimeError):
+ """No authoritative, completed entitlement/usage snapshot is available."""
+
+
+async def get_ready_usage_state(user_id: str) -> "UsageActivationState":
+ try:
+ state = await pro_activation_db().get_usage_activation_state(user_id)
+ except Exception as exc:
+ raise UsageActivationUnavailable("Usage activation state unavailable") from exc
+ if state.user_id != user_id or not state.ready:
+ raise UsageActivationUnavailable("Usage activation is processing")
+ return state
+
+
+def usage_keys(user_id: str, generation: str | None, now: datetime) -> tuple[str, str]:
+ owner = f"{user_id}:{generation}" if generation else user_id
+ year, week, _ = now.isocalendar()
+ return (
+ f"copilot:cost:daily:{owner}:{now.strftime('%Y-%m-%d')}",
+ f"copilot:cost:weekly:{owner}:{year}-W{week:02d}",
+ )
+
+
+async def verify_activation_usage(user_id: str, generation: str) -> None:
+ """Retry-safe readiness probe; never erase or initialize paid counters."""
+ redis = await get_redis_async()
+ keys = usage_keys(user_id, generation, datetime.now(UTC))
+ counters = await asyncio.gather(*(redis.get(key) for key in keys))
+ if any(int(value or 0) < 0 for value in counters):
+ raise UsageActivationUnavailable("Invalid paid usage counters")
diff --git a/autogpt_platform/backend/backend/copilot/usage_activation_fixtures.py b/autogpt_platform/backend/backend/copilot/usage_activation_fixtures.py
new file mode 100644
index 0000000000..07ce3df0db
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/usage_activation_fixtures.py
@@ -0,0 +1,19 @@
+"""Explicit billing-state boundary for unrelated provider/queue unit tests."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+from prisma.enums import SubscriptionTier
+
+from backend.data.pro_activation import UsageActivationState
+
+
[email protected](autouse=True)
+def usage_snapshot(mocker):
+ lookup = AsyncMock(
+ side_effect=lambda user_id: UsageActivationState(
+ user_id=user_id, tier=SubscriptionTier.NO_TIER, ready=True
+ )
+ )
+ mocker.patch("backend.copilot.trial_cost_context.get_ready_usage_state", lookup)
+ return lookup
diff --git a/autogpt_platform/backend/backend/copilot/usage_activation_integration_test.py b/autogpt_platform/backend/backend/copilot/usage_activation_integration_test.py
new file mode 100644
index 0000000000..745d795d1f
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/usage_activation_integration_test.py
@@ -0,0 +1,140 @@
+"""Real Postgres/Redis prove activation never deletes concurrent paid spend."""
+
+import asyncio
+from datetime import UTC, datetime, timedelta
+from uuid import uuid4
+
+import pytest
+from prisma.models import SubscriptionTrial, User
+
+from backend.copilot.rate_limit import (
+ RateLimitUnavailable,
+ SubscriptionTier,
+ check_rate_limit,
+ record_cost_usage,
+)
+from backend.copilot.trial_cost_context import (
+ capture_cost_context,
+ restore_cost_context,
+ trial_cost_context,
+)
+from backend.copilot.usage_activation import usage_keys, verify_activation_usage
+from backend.data import subscription_trial_integration_fixtures as fixtures
+from backend.data.db import execute_raw_with_schema, transaction
+from backend.data.pro_activation import get_usage_activation_state
+from backend.data.redis_client import get_redis_async
+from backend.data.subscription_trial import get_subscription_trial
+
+enrollment = fixtures.enrollment
+pytestmark = fixtures.pytestmark
+
+
+async def publish(user_id: str, generation: str) -> None:
+ async with transaction() as tx:
+ await execute_raw_with_schema(
+ """INSERT INTO {schema_prefix}"PaidUsageActivation"
+ ("id", "userId", "stripeSubscriptionId", "stripeInvoiceId", "readyAt")
+ VALUES ($1, $2, $3, $4, CURRENT_TIMESTAMP)""",
+ generation,
+ user_id,
+ f"sub_{generation}",
+ f"in_{generation}",
+ client=tx,
+ )
+ await tx.user.update(where={"id": user_id}, data={"subscriptionTier": "PRO"})
+ await tx.subscriptiontrial.update(
+ where={"userId": user_id},
+ data={"status": "active", "convertedAt": datetime.now(UTC)},
+ )
+
+
[email protected]("trial_spent", [40, 100])
+async def test_delayed_trial_children_and_retries_preserve_fresh_paid_usage(
+ enrollment, trial_spent
+):
+ now = datetime.now(UTC)
+ user_id = enrollment.user_id
+ generation = str(uuid4())
+ redis = await get_redis_async()
+ keys = [*usage_keys(user_id, None, now), *usage_keys(user_id, generation, now)]
+ release = asyncio.Event()
+ await User.prisma().update(
+ where={"id": user_id}, data={"subscriptionTier": "TRIAL"}
+ )
+ await SubscriptionTrial.prisma().update(
+ where={"id": enrollment.id},
+ data={
+ "status": "trialing",
+ "consumedAt": now,
+ "cardVerifiedAt": now,
+ "startedAt": now,
+ "endsAt": now + timedelta(days=7),
+ },
+ )
+
+ async def late_child():
+ await release.wait()
+ await record_cost_usage(user_id, 17, skip_daily=True)
+
+ child = None
+ try:
+ async with trial_cost_context(user_id):
+ await record_cost_usage(user_id, trial_spent)
+ child = asyncio.create_task(late_child())
+ await publish(user_id, generation)
+ state = await get_usage_activation_state(user_id)
+ assert state.ready and state.generation == generation and state.trial_id is None
+ release.set()
+ async with trial_cost_context(user_id):
+ await asyncio.gather(
+ child,
+ *(record_cost_usage(user_id, 3) for _ in range(20)),
+ *(verify_activation_usage(user_id, generation) for _ in range(20)),
+ )
+ values = [int(await redis.get(key) or 0) for key in keys]
+ assert values == [trial_spent, trial_spent + 17, 60, 60]
+ trial = await get_subscription_trial(user_id)
+ assert trial is not None and trial.cost_microdollars == trial_spent + 17
+ assert trial.consumed_at is not None and trial.converted_at is not None
+ assert all(
+ ttl > 0 for ttl in await asyncio.gather(*(redis.ttl(key) for key in keys))
+ )
+ finally:
+ release.set()
+ if child is not None:
+ await child
+ for key in keys:
+ await redis.delete(key)
+
+
+async def test_unpaid_work_keeps_legacy_namespace_after_initial_signup(enrollment):
+ user_id, generation = enrollment.user_id, str(uuid4())
+ redis = await get_redis_async()
+ keys = [
+ *usage_keys(user_id, None, datetime.now(UTC)),
+ *usage_keys(user_id, generation, datetime.now(UTC)),
+ ]
+ try:
+ old = await capture_cost_context(user_id)
+ await publish(user_id, generation)
+ with restore_cost_context(user_id, old):
+ await record_cost_usage(user_id, 50)
+ await record_cost_usage(user_id, 7)
+ assert [int(await redis.get(key) or 0) for key in keys] == [50, 50, 7, 7]
+ finally:
+ for key in keys:
+ await redis.delete(key)
+
+
+async def test_activation_between_limits_and_enforcement_fails_closed(enrollment):
+ await publish(enrollment.user_id, str(uuid4()))
+ with pytest.raises(RateLimitUnavailable, match="changed"):
+ await check_rate_limit(
+ enrollment.user_id,
+ 100_000_000,
+ 100_000_000,
+ expected_tier=SubscriptionTier.TRIAL,
+ )
diff --git a/autogpt_platform/backend/backend/copilot/usage_activation_test.py b/autogpt_platform/backend/backend/copilot/usage_activation_test.py
new file mode 100644
index 0000000000..e1254295f1
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/usage_activation_test.py
@@ -0,0 +1,46 @@
+from datetime import UTC, datetime
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from backend.copilot.rate_limit import (
+ RateLimitUnavailable,
+ SubscriptionTier,
+ get_usage_status,
+)
+from backend.copilot.usage_activation import usage_keys, verify_activation_usage
+from backend.data.pro_activation import UsageActivationState
+
+
+def test_generation_preserves_calendar_boundaries():
+ now = datetime(2027, 1, 1, 23, 59, tzinfo=UTC)
+ daily, weekly = usage_keys("user", "activation", now)
+ assert daily == "copilot:cost:daily:user:activation:2027-01-01"
+ assert weekly == "copilot:cost:weekly:user:activation:2026-W53"
+
+
+async def test_activation_verification_never_overwrites_paid_usage():
+ redis = AsyncMock()
+ redis.get.side_effect = [b"123", b"456", b"123", b"456"]
+ with patch("backend.copilot.usage_activation.get_redis_async", return_value=redis):
+ await verify_activation_usage("user", "activation")
+ await verify_activation_usage("user", "activation")
+ redis.set.assert_not_called()
+ redis.delete.assert_not_called()
+
+
+async def test_paid_usage_gauge_never_returns_false_zero_during_redis_failure():
+ state = UsageActivationState(
+ user_id="user", generation="activation", tier="PRO", ready=True
+ )
+ with (
+ patch("backend.copilot.rate_limit.get_ready_usage_state", return_value=state),
+ patch(
+ "backend.copilot.rate_limit.get_redis_async",
+ side_effect=ConnectionError("Redis temporarily unavailable"),
+ ),
+ ):
+ with pytest.raises(RateLimitUnavailable):
+ await get_usage_status("user", 100, 500, tier=SubscriptionTier.PRO)
diff --git a/autogpt_platform/backend/backend/data/credit.py b/autogpt_platform/backend/backend/data/credit.py
index 791172ac47..9865414796 100644
--- a/autogpt_platform/backend/backend/data/credit.py
+++ b/autogpt_platform/backend/backend/data/credit.py
@@ -4,6 +4,7 @@ import time
from abc import ABC, abstractmethod
from datetime import datetime, timedelta, timezone
from typing import TYPE_CHECKING, Any, Literal, cast
+from urllib.parse import urlsplit, urlunsplit
import stripe
from prisma.enums import (
@@ -22,9 +23,10 @@ from prisma.types import (
from pydantic import BaseModel
from backend.api.features.admin.model import UserHistoryResponse
+from backend.data import subscription_activation, subscription_trial_stripe
from backend.data.block_cost_config import BLOCK_COSTS
from backend.data.credit_history import get_credit_history
-from backend.data.db import query_raw_with_schema
+from backend.data.db import query_raw_with_schema, transaction
from backend.data.includes import MAX_CREDIT_REFUND_REQUESTS_FETCH
from backend.data.model import (
AutoTopUpConfig,
@@ -52,7 +54,7 @@ from backend.data.subscription_pending_cache import (
PendingChange,
invalidate_pending_subscription_change,
)
-from backend.data.subscription_trial_stripe import reconcile_trial_subscription
+from backend.data.subscription_trial import get_subscription_trial
from backend.data.user import get_user_by_id, get_user_email_by_id
from backend.notifications.queue import queue_notification_async
from backend.util import posthog_client
@@ -2739,6 +2741,10 @@ async def _create_subscription_checkout(
await _expire_open_subscription_sessions(customer_id)
await ensure_no_unconverted_trial(user_id, customer_id)
datafast = _datafast_metadata(datafast_visitor_id, datafast_session_id)
+ destination = urlsplit(success_url)
+ return_to = urlunsplit(
+ ("", "", destination.path or "/", destination.query, destination.fragment)
+ )
session = await stripe_call(
stripe.checkout.Session.create_async,
customer=customer_id,
@@ -2751,6 +2757,11 @@ async def _create_subscription_checkout(
"user_id": user_id,
"tier": tier.value,
"billing_cycle": billing_cycle,
+ **(
+ {"pro_activation_return_to": return_to}
+ if len(return_to) <= 500
+ else {}
+ ),
**datafast,
}
},
@@ -2892,10 +2903,29 @@ async def _sync_subscription_tier_from_stripe(stripe_subscription: dict) -> None
stripe_subscription.get("status", ""),
)
return
- status = stripe_subscription.get("status", "")
new_sub_id = stripe_subscription.get("id", "")
- if metadata.get("trial_enrollment_id") and new_sub_id:
- trial_result = await reconcile_trial_subscription(user.id, new_sub_id)
+ if not new_sub_id:
+ return
+ # Webhook payloads can be stale. Only current Stripe state changes access.
+ stripe_subscription = dict(
+ await stripe_call(stripe.Subscription.retrieve_async, new_sub_id)
+ )
+ subscription_activation.verify_subscription_owner(user, stripe_subscription)
+ metadata = stripe_subscription.get("metadata") or {}
+ status = stripe_subscription.get("status", "")
+ enrollment = await get_subscription_trial(user.id)
+ owns_trial = enrollment is not None and (
+ enrollment.subscription_id == new_sub_id
+ or (
+ not enrollment.subscription_id
+ and enrollment.converted_at is None
+ and stripe_subscription.get("trial_end") is not None
+ )
+ )
+ if metadata.get("trial_enrollment_id") or owns_trial:
+ trial_result = await subscription_trial_stripe.reconcile_trial_subscription(
+ user.id, new_sub_id
+ )
if trial_result is None:
raise ValueError("Stripe trial is missing its matching enrollment")
stripe_subscription, trial_tier = trial_result
@@ -2903,6 +2933,7 @@ async def _sync_subscription_tier_from_stripe(stripe_subscription: dict) -> None
if trial_tier is not None:
invalidate_subscription_caches(user.id)
return
+ price_id = ""
if status in ("active", "trialing"):
price_id = ""
items = stripe_subscription.get("items", {}).get("data", [])
@@ -2910,6 +2941,18 @@ async def _sync_subscription_tier_from_stripe(stripe_subscription: dict) -> None
price_id = items[0].get("price", {}).get("id", "")
price_to_tier = await build_price_to_tier_map()
matched = price_to_tier.get(price_id) if price_id else None
+ if (
+ matched is None
+ and enrollment is not None
+ and enrollment.converted_at is not None
+ and enrollment.subscription_id == new_sub_id
+ ):
+ async with transaction() as tx:
+ target = await subscription_activation.accepted_conversion_target(
+ enrollment, stripe_subscription, tx
+ )
+ if target:
+ matched = target[0]
if matched is not None:
tier = matched
else:
@@ -2981,6 +3024,50 @@ async def _sync_subscription_tier_from_stripe(stripe_subscription: dict) -> None
)
return
tier = SubscriptionTier.NO_TIER
+ if tier in subscription_activation.PAID_CONVERSION_TIERS:
+ if status != "active":
+ return
+ async with transaction() as tx:
+ locked_user = await subscription_activation.lock_activation_user(
+ user.id, tx
+ )
+ if locked_user.subscriptionTier == SubscriptionTier.ENTERPRISE:
+ return
+ # Refetch after acquiring the lock so competing deliveries cannot
+ # publish an older snapshot over a newer reconciliation.
+ current = dict(
+ await stripe_call(stripe.Subscription.retrieve_async, new_sub_id)
+ )
+ if (
+ current.get("items", {}).get("data", [{}])[0].get("price", {}).get("id")
+ != price_id
+ ):
+ raise ValueError(
+ "Subscription changed during activation reconciliation"
+ )
+ if not await subscription_activation.publish_initial_pro_activation(
+ locked_user, current, price_id, tx
+ ):
+ return
+ if locked_user.subscriptionTier != tier:
+ await tx.user.update(
+ where={"id": user.id}, data={"subscriptionTier": tier}
+ )
+ invalidate_subscription_caches(user.id)
+ if locked_user.subscriptionTier != tier:
+ await _cleanup_stale_subscriptions(customer_id, new_sub_id)
+ if is_tier_upgrade(SubscriptionTier(locked_user.subscriptionTier), tier):
+ _track_billing_event(
+ PostHogEvent.SUBSCRIPTION_CHANGED,
+ user.id,
+ {
+ "change_type": "upgrade",
+ "previous_subscription_tier": locked_user.subscriptionTier,
+ "subscription_tier": tier.value,
+ "billing_cycle": metadata.get("billing_cycle"),
+ },
+ )
+ return
# Idempotency: Stripe retries webhooks on delivery failure, and several event
# types map to the same final tier. Skip the DB write + cache invalidation
# when the tier is already correct to avoid redundant writes on replay.
@@ -3234,7 +3321,24 @@ async def handle_subscription_payment_failure(invoice: dict) -> None:
)
return
+ trial = await get_subscription_trial(user.id)
+ if (
+ trial
+ and trial.converted_at is None
+ and trial.subscription_id == _invoice_subscription_id(invoice)
+ ):
+ # Initial conversion stays on its existing invoice for authentication or
+ # card repair. Failure must not spend wallet credits or cancel the sub.
+ return
current_tier = user.subscriptionTier or SubscriptionTier.NO_TIER
+ if current_tier in (SubscriptionTier.NO_TIER, SubscriptionTier.TRIAL):
+ return
+ invoice_id: str = invoice.get("id") or ""
+ if not invoice_id:
+ return
+ invoice = dict(await stripe_call(stripe.Invoice.retrieve_async, invoice_id))
+ if invoice.get("status") != "open" or invoice.get("customer") != customer_id:
+ return
if current_tier == SubscriptionTier.ENTERPRISE:
logger.warning(
"handle_subscription_payment_failure: skipping ENTERPRISE user %s"
@@ -3246,7 +3350,6 @@ async def handle_subscription_payment_failure(invoice: dict) -> None:
amount_due: int = invoice.get("amount_due", 0)
sub_id = _invoice_subscription_id(invoice)
- invoice_id: str = invoice.get("id", "")
if invoice.get("billing_reason") == "subscription_create":
# A new plan's first payment failed inside Checkout, which lets the
@@ -3441,6 +3544,9 @@ async def handle_subscription_payment_success(invoice: dict) -> None:
)
return
+ current_subscription = await stripe_call(stripe.Subscription.retrieve_async, sub_id)
+ await sync_subscription_from_stripe(dict(current_subscription))
+
amount_paid: int = invoice.get("amount_paid", 0)
invoice_id: str = invoice.get("id", "")
if amount_paid <= 0 or not invoice_id:
diff --git a/autogpt_platform/backend/backend/data/credit_pending_update_test.py b/autogpt_platform/backend/backend/data/credit_pending_update_test.py
index 4236765c80..98dc467a54 100644
--- a/autogpt_platform/backend/backend/data/credit_pending_update_test.py
+++ b/autogpt_platform/backend/backend/data/credit_pending_update_test.py
@@ -1,6 +1,5 @@
"""A failed payment on a change Stripe holds until it's paid changed nothing,
-so it must not end the plans a lapsed payment otherwise ends. A trial that
-converts early waits like this for the customer's bank to confirm. The failure
+so it must not end the paid plans a lapsed payment otherwise ends. The failure
event can also arrive after the bank confirmed or the hold lapsed."""
from unittest.mock import AsyncMock, MagicMock, patch
@@ -19,6 +18,7 @@ def _failed_invoice(billing_reason: str) -> dict:
"customer": "cus_1",
"subscription": "sub_trial",
"amount_due": 32000,
+ "status": "open",
"billing_reason": billing_reason,
}
@@ -27,7 +27,7 @@ def _failed_invoice(billing_reason: str) -> dict:
def lapse():
user = MagicMock(spec=User)
user.id = "user-1"
- user.subscriptionTier = SubscriptionTier.TRIAL
+ user.subscriptionTier = SubscriptionTier.PRO
with (
patch(
"backend.data.credit.User.prisma",
@@ -44,12 +44,21 @@ def lapse():
) as cancel,
patch.object(credit, "set_subscription_tier", new_callable=AsyncMock) as tier,
patch.object(stripe.Invoice, "pay_async", new_callable=AsyncMock),
+ patch.object(credit, "get_subscription_trial", AsyncMock(return_value=None)),
+ patch.object(
+ stripe.Invoice,
+ "retrieve_async",
+ AsyncMock(return_value=_failed_invoice("subscription_cycle")),
+ ) as retrieve,
):
- yield MagicMock(settled=settled, deduct=deduct, cancel=cancel, tier=tier)
+ yield MagicMock(
+ settled=settled, deduct=deduct, cancel=cancel, tier=tier, retrieve=retrieve
+ )
@pytest.mark.asyncio
async def test_a_failed_payment_on_a_held_change_cancels_nothing(lapse):
+ lapse.retrieve.return_value = _failed_invoice("subscription_update")
await credit.handle_subscription_payment_failure(
_failed_invoice("subscription_update")
)
diff --git a/autogpt_platform/backend/backend/data/credit_subscription_test.py b/autogpt_platform/backend/backend/data/credit_subscription_test.py
index 733bbab980..d92c0c262e 100644
--- a/autogpt_platform/backend/backend/data/credit_subscription_test.py
+++ b/autogpt_platform/backend/backend/data/credit_subscription_test.py
@@ -11,6 +11,7 @@ from prisma.enums import SubscriptionTier
from prisma.errors import PrismaError, UniqueViolationError
from prisma.models import User
+from backend.data import credit
from backend.data.credit import (
PAYMENT_FAILURE_CANCELLATION_COMMENT,
UserCredit,
@@ -58,6 +59,43 @@ def _no_pending_update():
yield
[email protected](autouse=True)
+def billing_boundaries():
+ """Legacy billing tests isolate the new authoritative reconciliation boundary.
+
+ Real payment evidence, locks, and rollback are tested against PostgreSQL and
+ Redis in subscription_activation_*integration_test.py.
+ """
+ tx = MagicMock(user=MagicMock(update=AsyncMock()))
+ context = MagicMock()
+ context.__aenter__ = AsyncMock(return_value=tx)
+ context.__aexit__ = AsyncMock(return_value=False)
+
+ async def locked_user(user_id, client):
+ return await User.prisma().find_first(where={"id": user_id})
+
+ with (
+ patch.object(credit, "get_subscription_trial", AsyncMock(return_value=None)),
+ patch.object(credit, "transaction", return_value=context),
+ patch.object(
+ credit.subscription_activation, "lock_activation_user", locked_user
+ ),
+ patch.object(
+ credit.subscription_activation,
+ "publish_initial_pro_activation",
+ AsyncMock(return_value=True),
+ ),
+ patch.object(credit, "sync_subscription_from_stripe", AsyncMock()),
+ patch.object(
+ stripe.Subscription,
+ "retrieve_async",
+ AsyncMock(return_value={"id": "sub_paid"}),
+ ) as subscription,
+ patch.object(stripe.Invoice, "retrieve_async", AsyncMock()) as invoice,
+ ):
+ yield MagicMock(subscription=subscription, invoice=invoice, tx=tx)
+
+
# What the shared PostHog client adds to every event (see posthog_client.capture).
BASE_PROPERTIES = {"environment": "test", "source": "platform"}
@@ -95,12 +133,14 @@ def _make_user(
):
mock_user = MagicMock(spec=User)
mock_user.id = user_id
+ mock_user.stripeCustomerId = "cus_123"
mock_user.subscriptionTier = tier
return mock_user
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_active():
[email protected]("tier", [SubscriptionTier.PRO, SubscriptionTier.MAX])
+async def test_sync_subscription_from_stripe_active(billing_boundaries, tier):
mock_user = _make_user()
stripe_sub = {
"id": "sub_new",
@@ -110,13 +150,13 @@ async def test_sync_subscription_from_stripe_active():
}
async def mock_price_id(
- tier: SubscriptionTier, billing_cycle: str = "monthly"
+ requested_tier: SubscriptionTier, billing_cycle: str = "monthly"
) -> str | None:
if billing_cycle != "monthly":
return None
- if tier == SubscriptionTier.PRO:
+ if requested_tier == tier:
return "price_pro_monthly"
- if tier == SubscriptionTier.BUSINESS:
+ if requested_tier == SubscriptionTier.BUSINESS:
return "price_biz_monthly"
return None
@@ -137,16 +177,52 @@ async def test_sync_subscription_from_stripe_active():
"backend.data.credit.stripe.Subscription.list_async",
return_value=empty_list,
),
- patch(
- "backend.data.credit.set_subscription_tier", new_callable=AsyncMock
- ) as mock_set,
+ patch("backend.data.credit.set_subscription_tier", new_callable=AsyncMock),
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
- mock_set.assert_awaited_once_with("user-1", SubscriptionTier.PRO)
+ billing_boundaries.tx.user.update.assert_awaited_once_with(
+ where={"id": "user-1"}, data={"subscriptionTier": tier}
+ )
+
+
[email protected]("tier", [SubscriptionTier.PRO, SubscriptionTier.MAX])
+async def test_unsettled_paid_subscription_never_grants_tier(billing_boundaries, tier):
+ user = _make_user()
+ subscription = {
+ "id": "sub_new",
+ "customer": "cus_123",
+ "status": "active",
+ "items": {"data": [{"price": {"id": "price_paid"}, "quantity": 1}]},
+ }
+ billing_boundaries.subscription.return_value = subscription
+ with (
+ patch.object(
+ credit.User,
+ "prisma",
+ return_value=MagicMock(find_first=AsyncMock(return_value=user)),
+ ),
+ patch.object(
+ credit,
+ "build_price_to_tier_map",
+ AsyncMock(return_value={"price_paid": tier}),
+ ),
+ patch.object(
+ credit.subscription_activation,
+ "publish_initial_pro_activation",
+ AsyncMock(return_value=False),
+ ) as publish,
+ patch.object(credit, "set_subscription_tier", AsyncMock()) as direct,
+ ):
+ await sync_subscription_from_stripe(subscription)
+ publish.assert_awaited_once()
+ billing_boundaries.tx.user.update.assert_not_awaited()
+ direct.assert_not_awaited()
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_tracks_upgrade():
+async def test_sync_subscription_from_stripe_tracks_upgrade(billing_boundaries):
mock_user = _make_user(tier=SubscriptionTier.BASIC)
stripe_sub = {
"id": "sub_new",
@@ -187,6 +263,7 @@ async def test_sync_subscription_from_stripe_tracks_upgrade():
new_callable=AsyncMock,
),
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
track_mock.assert_called_once()
@@ -203,7 +280,7 @@ async def test_sync_subscription_from_stripe_tracks_upgrade():
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_yearly_pro_maps_to_pro():
+async def test_sync_subscription_from_stripe_yearly_pro_maps_to_pro(billing_boundaries):
"""A user on a yearly Pro plan still maps to SubscriptionTier.PRO."""
mock_user = _make_user()
stripe_sub = {
@@ -239,16 +316,19 @@ async def test_sync_subscription_from_stripe_yearly_pro_maps_to_pro():
"backend.data.credit.stripe.Subscription.list_async",
return_value=empty_list,
),
- patch(
- "backend.data.credit.set_subscription_tier", new_callable=AsyncMock
- ) as mock_set,
+ patch("backend.data.credit.set_subscription_tier", new_callable=AsyncMock),
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
- mock_set.assert_awaited_once_with("user-1", SubscriptionTier.PRO)
+ billing_boundaries.tx.user.update.assert_awaited_once_with(
+ where={"id": "user-1"}, data={"subscriptionTier": SubscriptionTier.PRO}
+ )
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_idempotent_no_write_if_unchanged():
+async def test_sync_subscription_from_stripe_idempotent_no_write_if_unchanged(
+ billing_boundaries,
+):
"""Stripe retries webhooks; re-sending the same event must not re-write the DB."""
mock_user = _make_user(tier=SubscriptionTier.PRO)
stripe_sub = {
@@ -290,12 +370,15 @@ async def test_sync_subscription_from_stripe_idempotent_no_write_if_unchanged():
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
mock_set.assert_not_awaited()
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_enterprise_not_overwritten():
+async def test_sync_subscription_from_stripe_enterprise_not_overwritten(
+ billing_boundaries,
+):
"""Webhook events must never overwrite an ENTERPRISE tier (admin-managed)."""
mock_user = _make_user(tier=SubscriptionTier.ENTERPRISE)
stripe_sub = {
@@ -314,12 +397,13 @@ async def test_sync_subscription_from_stripe_enterprise_not_overwritten():
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
mock_set.assert_not_awaited()
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_cancelled():
+async def test_sync_subscription_from_stripe_cancelled(billing_boundaries):
"""When the only active sub is cancelled, the user is downgraded to NO_TIER."""
mock_user = _make_user(tier=SubscriptionTier.PRO)
stripe_sub = {
@@ -344,12 +428,15 @@ async def test_sync_subscription_from_stripe_cancelled():
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
mock_set.assert_awaited_once_with("user-1", SubscriptionTier.NO_TIER)
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_past_due_downgrades_to_no_tier():
+async def test_sync_subscription_from_stripe_past_due_downgrades_to_no_tier(
+ billing_boundaries,
+):
"""``past_due`` is NOT active/trialing, so it falls into the non-active else
branch: with no OTHER active/trialing sub, the user is revoked to NO_TIER.
@@ -378,12 +465,15 @@ async def test_sync_subscription_from_stripe_past_due_downgrades_to_no_tier():
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
mock_set.assert_awaited_once_with("user-1", SubscriptionTier.NO_TIER)
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_cancelled_applies_no_tier_storage_limit():
+async def test_sync_subscription_from_stripe_cancelled_applies_no_tier_storage_limit(
+ billing_boundaries,
+):
"""After unsubscribe takes effect, workspace storage resolves against NO_TIER."""
from backend.copilot.rate_limit import get_workspace_storage_limit_bytes
@@ -440,6 +530,7 @@ async def test_sync_subscription_from_stripe_cancelled_applies_no_tier_storage_l
new_callable=AsyncMock,
) as mock_pending_cache_delete,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
result = await get_workspace_storage_limit_bytes("user-1")
@@ -448,7 +539,9 @@ async def test_sync_subscription_from_stripe_cancelled_applies_no_tier_storage_l
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_cancelled_but_other_active_sub_exists():
+async def test_sync_subscription_from_stripe_cancelled_but_other_active_sub_exists(
+ billing_boundaries,
+):
"""Cancelling sub_old must NOT downgrade the user if sub_new is still active.
This covers the race condition where `customer.subscription.deleted` for
@@ -489,14 +582,15 @@ async def test_sync_subscription_from_stripe_cancelled_but_other_active_sub_exis
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
# Must NOT write BASIC — another active sub is still present.
mock_set.assert_not_awaited()
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_trialing():
- """status='trialing' should map to the paid tier, same as 'active'."""
+async def test_sync_subscription_from_stripe_trialing(billing_boundaries):
+ """A trialing subscription is not paid activation evidence."""
mock_user = _make_user()
stripe_sub = {
"id": "sub_new",
@@ -535,12 +629,14 @@ async def test_sync_subscription_from_stripe_trialing():
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
- mock_set.assert_awaited_once_with("user-1", SubscriptionTier.PRO)
+ billing_boundaries.tx.user.update.assert_not_awaited()
+ mock_set.assert_not_awaited()
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_unknown_customer():
+async def test_sync_subscription_from_stripe_unknown_customer(billing_boundaries):
stripe_sub = {
"customer": "cus_unknown",
"status": "active",
@@ -551,6 +647,7 @@ async def test_sync_subscription_from_stripe_unknown_customer():
return_value=MagicMock(find_first=AsyncMock(return_value=None)),
):
# Should not raise even if user not found
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
@@ -1076,7 +1173,9 @@ def checkout_guard():
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_missing_customer_key_returns_early():
+async def test_sync_subscription_from_stripe_missing_customer_key_returns_early(
+ billing_boundaries,
+):
"""A webhook payload missing 'customer' must not raise KeyError — returns early with a warning."""
stripe_sub = {
# Omit "customer" entirely — simulates a valid HMAC but malformed payload
@@ -1092,16 +1191,20 @@ async def test_sync_subscription_from_stripe_missing_customer_key_returns_early(
) as mock_set,
):
# Should return early without querying the DB or writing a tier
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
mock_prisma.assert_not_called()
mock_set.assert_not_called()
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_unknown_price_id_preserves_current_tier():
+async def test_sync_subscription_from_stripe_unknown_price_id_preserves_current_tier(
+ billing_boundaries,
+):
"""Unknown price_id should preserve the current tier, not default to BASIC (no DB write)."""
mock_user = _make_user(tier=SubscriptionTier.PRO)
stripe_sub = {
+ "id": "sub_price_check",
"customer": "cus_123",
"status": "active",
"items": {"data": [{"price": {"id": "price_unknown"}}]},
@@ -1125,16 +1228,21 @@ async def test_sync_subscription_from_stripe_unknown_price_id_preserves_current_
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
+ billing_boundaries.subscription.assert_awaited_once_with("sub_price_check")
# Unknown price → preserve current tier (early return, no DB write)
mock_set.assert_not_awaited()
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_unconfigured_ld_price_preserves_current_tier():
+async def test_sync_subscription_from_stripe_unconfigured_ld_price_preserves_current_tier(
+ billing_boundaries,
+):
"""When LD flags are unconfigured (None price IDs), the current tier should be preserved, not defaulted to BASIC."""
mock_user = _make_user(tier=SubscriptionTier.PRO)
stripe_sub = {
+ "id": "sub_price_check",
"customer": "cus_123",
"status": "active",
"items": {"data": [{"price": {"id": "price_pro_monthly"}}]},
@@ -1154,13 +1262,15 @@ async def test_sync_subscription_from_stripe_unconfigured_ld_price_preserves_cur
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
+ billing_boundaries.subscription.assert_awaited_once_with("sub_price_check")
# None from LD → comparison guards prevent match → preserve current tier
mock_set.assert_not_awaited()
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_business_tier():
+async def test_sync_subscription_from_stripe_business_tier(billing_boundaries):
"""BUSINESS price_id should map to BUSINESS tier."""
mock_user = _make_user()
stripe_sub = {
@@ -1200,12 +1310,15 @@ async def test_sync_subscription_from_stripe_business_tier():
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
mock_set.assert_awaited_once_with("user-1", SubscriptionTier.BUSINESS)
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_basic_tier_via_ld_price():
+async def test_sync_subscription_from_stripe_basic_tier_via_ld_price(
+ billing_boundaries,
+):
"""BASIC price_id via LD should reconcile the user to BASIC.
Protects the new stripe-price-id-basic reconciliation path — webhooks for a
@@ -1252,12 +1365,13 @@ async def test_sync_subscription_from_stripe_basic_tier_via_ld_price():
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
mock_set.assert_awaited_once_with("user-1", SubscriptionTier.BASIC)
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_cancels_stale_subs():
+async def test_sync_subscription_from_stripe_cancels_stale_subs(billing_boundaries):
"""When a new subscription becomes active, older active subs are cancelled.
Covers the paid-to-paid upgrade case (e.g. PRO → BUSINESS) where Stripe
@@ -1307,6 +1421,7 @@ async def test_sync_subscription_from_stripe_cancels_stale_subs():
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
mock_set.assert_awaited_once_with("user-1", SubscriptionTier.BUSINESS)
# Only the stale sub should be cancelled — never the new one.
@@ -1314,7 +1429,9 @@ async def test_sync_subscription_from_stripe_cancels_stale_subs():
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_stale_cancel_errors_swallowed():
+async def test_sync_subscription_from_stripe_stale_cancel_errors_swallowed(
+ billing_boundaries,
+):
"""Errors cancelling stale subs must not block DB tier update for new sub."""
import stripe as stripe_mod
@@ -1356,13 +1473,14 @@ async def test_sync_subscription_from_stripe_stale_cancel_errors_swallowed():
"backend.data.credit.stripe.Subscription.cancel_async",
side_effect=stripe_mod.StripeError("cancel failed"),
),
- patch(
- "backend.data.credit.set_subscription_tier", new_callable=AsyncMock
- ) as mock_set,
+ patch("backend.data.credit.set_subscription_tier", new_callable=AsyncMock),
):
# Must not raise — tier update proceeds even if cleanup cancel fails.
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
- mock_set.assert_awaited_once_with("user-1", SubscriptionTier.PRO)
+ billing_boundaries.tx.user.update.assert_awaited_once_with(
+ where={"id": "user-1"}, data={"subscriptionTier": SubscriptionTier.PRO}
+ )
@pytest.mark.asyncio
@@ -1663,7 +1781,9 @@ async def test_cancel_stripe_subscription_raises_on_cancel_error():
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_metadata_user_id_matches():
+async def test_sync_subscription_from_stripe_metadata_user_id_matches(
+ billing_boundaries,
+):
"""metadata.user_id matching the DB user is accepted and the tier is updated normally."""
mock_user = _make_user(user_id="user-1", tier=SubscriptionTier.BASIC)
stripe_sub = {
@@ -1696,16 +1816,19 @@ async def test_sync_subscription_from_stripe_metadata_user_id_matches():
"backend.data.credit.stripe.Subscription.list_async",
return_value=empty_list,
),
- patch(
- "backend.data.credit.set_subscription_tier", new_callable=AsyncMock
- ) as mock_set,
+ patch("backend.data.credit.set_subscription_tier", new_callable=AsyncMock),
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
- mock_set.assert_awaited_once_with("user-1", SubscriptionTier.PRO)
+ billing_boundaries.tx.user.update.assert_awaited_once_with(
+ where={"id": "user-1"}, data={"subscriptionTier": SubscriptionTier.PRO}
+ )
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_metadata_user_id_mismatch_blocked():
+async def test_sync_subscription_from_stripe_metadata_user_id_mismatch_blocked(
+ billing_boundaries,
+):
"""metadata.user_id mismatching the DB user must block the tier update.
A customer↔user mapping inconsistency (e.g. a customer ID reassigned or
@@ -1729,13 +1852,16 @@ async def test_sync_subscription_from_stripe_metadata_user_id_mismatch_blocked()
"backend.data.credit.set_subscription_tier", new_callable=AsyncMock
) as mock_set,
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
# Mismatch → must not update any tier
mock_set.assert_not_awaited()
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_no_metadata_user_id_skips_check():
+async def test_sync_subscription_from_stripe_no_metadata_user_id_skips_check(
+ billing_boundaries,
+):
"""Absence of metadata.user_id (e.g. subs created outside Checkout) skips the cross-check."""
mock_user = _make_user(user_id="user-1", tier=SubscriptionTier.BASIC)
stripe_sub = {
@@ -1768,17 +1894,20 @@ async def test_sync_subscription_from_stripe_no_metadata_user_id_skips_check():
"backend.data.credit.stripe.Subscription.list_async",
return_value=empty_list,
),
- patch(
- "backend.data.credit.set_subscription_tier", new_callable=AsyncMock
- ) as mock_set,
+ patch("backend.data.credit.set_subscription_tier", new_callable=AsyncMock),
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
# No metadata → cross-check skipped → tier updated normally
- mock_set.assert_awaited_once_with("user-1", SubscriptionTier.PRO)
+ billing_boundaries.tx.user.update.assert_awaited_once_with(
+ where={"id": "user-1"}, data={"subscriptionTier": SubscriptionTier.PRO}
+ )
@pytest.mark.asyncio
-async def test_handle_subscription_payment_failure_balance_covers_pays_invoice():
+async def test_handle_subscription_payment_failure_balance_covers_pays_invoice(
+ billing_boundaries,
+):
"""When balance covers the invoice, Stripe Invoice.pay is called with
paid_out_of_band=True so the card isn't double-charged on top of the
balance debit (the card already failed; retrying it would let the
@@ -1804,6 +1933,7 @@ async def test_handle_subscription_payment_failure_balance_covers_pays_invoice()
"backend.data.credit.stripe.Invoice.pay_async", new_callable=AsyncMock
) as mock_pay,
):
+ billing_boundaries.invoice.return_value = {**invoice, "status": "open"}
await handle_subscription_payment_failure(invoice)
mock_pay.assert_called_once_with("in_abc123", paid_out_of_band=True)
@@ -1845,7 +1975,9 @@ async def test_handle_subscription_payment_failure_ignores_a_new_plans_first_pay
@pytest.mark.asyncio
-async def test_handle_subscription_payment_failure_invoice_pay_error_does_not_raise():
+async def test_handle_subscription_payment_failure_invoice_pay_error_does_not_raise(
+ billing_boundaries,
+):
"""Failure to mark the invoice as paid is logged but does not propagate."""
import stripe as stripe_mod
@@ -1875,6 +2007,7 @@ async def test_handle_subscription_payment_failure_invoice_pay_error_does_not_ra
) as invalidate,
):
# Must not raise — the pay failure is only logged as a warning
+ billing_boundaries.invoice.return_value = {**invoice, "status": "open"}
await handle_subscription_payment_failure(invoice)
# A timed-out call may still have been applied in Stripe, so the cached
# billing lookups are dropped either way.
@@ -1882,7 +2015,9 @@ async def test_handle_subscription_payment_failure_invoice_pay_error_does_not_ra
@pytest.mark.asyncio
-async def test_handle_subscription_payment_failure_passes_invoice_id_as_transaction_key():
+async def test_handle_subscription_payment_failure_passes_invoice_id_as_transaction_key(
+ billing_boundaries,
+):
"""invoice_id is used as the idempotency key to prevent double-charging on webhook retries."""
mock_user = _make_user(user_id="user-1", tier=SubscriptionTier.PRO)
invoice = {
@@ -1903,6 +2038,7 @@ async def test_handle_subscription_payment_failure_passes_invoice_id_as_transact
) as mock_add_tx,
patch("backend.data.credit.stripe.Invoice.pay_async", new_callable=AsyncMock),
):
+ billing_boundaries.invoice.return_value = {**invoice, "status": "open"}
await handle_subscription_payment_failure(invoice)
mock_add_tx.assert_called_once()
_, kwargs = mock_add_tx.call_args
@@ -1910,7 +2046,9 @@ async def test_handle_subscription_payment_failure_passes_invoice_id_as_transact
@pytest.mark.asyncio
-async def test_handle_subscription_payment_failure_marks_its_cancel_as_payment_failed():
+async def test_handle_subscription_payment_failure_marks_its_cancel_as_payment_failed(
+ billing_boundaries,
+):
"""Stripe stamps our API cancel ``cancellation_requested``; the comment is
what lets the deletion webhook report it as involuntary churn."""
mock_user = _make_user(user_id="user-1", tier=SubscriptionTier.PRO)
@@ -1956,6 +2094,7 @@ async def test_handle_subscription_payment_failure_marks_its_cancel_as_payment_f
) as mock_cancel,
patch("backend.data.credit.set_subscription_tier", new_callable=AsyncMock),
):
+ billing_boundaries.invoice.return_value = {**invoice, "status": "open"}
await handle_subscription_payment_failure(invoice)
mock_cancel.assert_called_once_with(
@@ -3925,10 +4064,13 @@ async def test_sync_subscription_schedule_from_stripe_missing_sub_id_returns():
@pytest.mark.asyncio
-async def test_sync_subscription_from_stripe_phase_transition_updates_tier():
+async def test_sync_subscription_from_stripe_phase_transition_updates_tier(
+ billing_boundaries,
+):
"""When a schedule advances phases, Stripe fires customer.subscription.updated with
the new price — the existing sync handler must update the DB tier accordingly."""
mock_user = _make_user(tier=SubscriptionTier.BUSINESS)
+ mock_user.stripeCustomerId = "cus_abc"
stripe_sub = {
"id": "sub_pro",
"customer": "cus_abc",
@@ -3963,12 +4105,13 @@ async def test_sync_subscription_from_stripe_phase_transition_updates_tier():
"backend.data.credit.stripe.Subscription.list_async",
return_value=empty_list,
),
- patch(
- "backend.data.credit.set_subscription_tier", new_callable=AsyncMock
- ) as mock_set,
+ patch("backend.data.credit.set_subscription_tier", new_callable=AsyncMock),
):
+ billing_boundaries.subscription.return_value = stripe_sub
await sync_subscription_from_stripe(stripe_sub)
- mock_set.assert_awaited_once_with("user-1", SubscriptionTier.PRO)
+ billing_boundaries.tx.user.update.assert_awaited_once_with(
+ where={"id": "user-1"}, data={"subscriptionTier": SubscriptionTier.PRO}
+ )
@pytest.mark.asyncio
diff --git a/autogpt_platform/backend/backend/data/credit_trial_subscription_test.py b/autogpt_platform/backend/backend/data/credit_trial_subscription_test.py
index 781905b3b3..e3fa04f423 100644
--- a/autogpt_platform/backend/backend/data/credit_trial_subscription_test.py
+++ b/autogpt_platform/backend/backend/data/credit_trial_subscription_test.py
@@ -8,6 +8,7 @@ import pytest
import stripe
from prisma.enums import SubscriptionTier
+from backend.data import credit_subscription_test
from backend.data.credit import (
_get_active_subscription_cached,
get_pending_subscription_change,
@@ -16,11 +17,18 @@ from backend.data.credit import (
)
from backend.data.credit_subscription_test import _make_user
+billing_boundaries = credit_subscription_test.billing_boundaries
+
@pytest.mark.asyncio
-async def test_new_plan_ends_cancel_pending_trial_without_invoice():
- """A plan bought while the trial is cancel-pending ends the trial at once,
- with no invoice or proration, once the new subscription is active."""
[email protected]("paid_ready", [False, True])
+async def test_new_plan_ends_cancel_pending_trial_without_invoice(
+ billing_boundaries, paid_ready
+):
+ """Only a reconciled paid plan may end the old cancel-pending trial.
+
+ Canceling the old trial creates neither an invoice nor proration.
+ """
metadata = {"user_id": "user-1"}
max_sub = {
"id": "sub_max",
@@ -48,21 +56,30 @@ async def test_new_plan_ends_cancel_pending_trial_without_invoice():
events.append(f"cancel:{sub_id}")
return ended_trial
- async def set_tier(user_id: str, tier: SubscriptionTier, **kwargs):
- events.append(f"tier:{tier.value}")
+ async def set_tier(*, where, data):
+ events.append(f"tier:{data['subscriptionTier'].value}")
+
+ async def publish(*args):
+ events.append("publish")
+ return paid_ready
async def price_id(tier: SubscriptionTier, billing_cycle: str = "monthly"):
return {SubscriptionTier.MAX: "price_max_monthly"}.get(tier)
+ user = _make_user(tier=SubscriptionTier.TRIAL)
with (
patch(
"backend.data.credit.User.prisma",
- return_value=MagicMock(
- find_first=AsyncMock(
- return_value=_make_user(tier=SubscriptionTier.TRIAL)
- )
- ),
+ return_value=MagicMock(find_first=AsyncMock(return_value=user)),
+ ),
+ patch(
+ "backend.data.credit.get_subscription_trial",
+ AsyncMock(return_value=MagicMock(subscription_id="sub_trial")),
),
+ patch(
+ "backend.data.credit.subscription_activation.publish_initial_pro_activation",
+ AsyncMock(side_effect=publish),
+ ) as publish_activation,
patch("backend.data.credit.get_subscription_price_id", side_effect=price_id),
patch(
"backend.data.credit.stripe.Subscription.list_async",
@@ -75,22 +92,37 @@ async def test_new_plan_ends_cancel_pending_trial_without_invoice():
side_effect=cancel,
) as mock_cancel,
patch(
- "backend.data.credit.reconcile_trial_subscription",
+ "backend.data.credit.sync_subscription_from_stripe",
new_callable=AsyncMock,
- return_value=(ended_trial, None),
) as reconcile,
patch(
"backend.data.credit.set_subscription_tier",
new_callable=AsyncMock,
- side_effect=set_tier,
) as mock_set,
):
+ billing_boundaries.subscription.return_value = max_sub
+ billing_boundaries.tx.user.update.side_effect = set_tier
await sync_subscription_from_stripe(max_sub)
+ publish_activation.assert_awaited_once_with(
+ user,
+ max_sub,
+ "price_max_monthly",
+ billing_boundaries.tx,
+ )
+ mock_set.assert_not_awaited()
+ if not paid_ready:
+ mock_cancel.assert_not_awaited()
+ reconcile.assert_not_awaited()
+ billing_boundaries.tx.user.update.assert_not_awaited()
+ assert events == ["publish"]
+ return
mock_cancel.assert_awaited_once_with("sub_trial", invoice_now=False, prorate=False)
- reconcile.assert_awaited_once_with("user-1", "sub_trial")
- mock_set.assert_awaited_once_with("user-1", SubscriptionTier.MAX)
- assert events == ["cancel:sub_trial", "tier:MAX"]
+ reconcile.assert_awaited_once_with(ended_trial)
+ billing_boundaries.tx.user.update.assert_awaited_once_with(
+ where={"id": "user-1"}, data={"subscriptionTier": SubscriptionTier.MAX}
+ )
+ assert events == ["publish", "tier:MAX", "cancel:sub_trial"]
async def _pending_change_for(subscription: dict):
diff --git a/autogpt_platform/backend/backend/data/db_accessors.py b/autogpt_platform/backend/backend/data/db_accessors.py
index 802636c51d..b710be297c 100644
--- a/autogpt_platform/backend/backend/data/db_accessors.py
+++ b/autogpt_platform/backend/backend/data/db_accessors.py
@@ -374,6 +374,16 @@ def bot_installs_db():
return bot_installs_db
+def pro_activation_db():
+ if db.is_connected():
+ from backend.data import pro_activation
+
+ return pro_activation
+ from backend.util.clients import get_database_manager_async_client
+
+ return get_database_manager_async_client()
+
+
def posthog_lifecycle_db():
if db.is_connected():
from backend.data import posthog_lifecycle_sync as _posthog_lifecycle_db
diff --git a/autogpt_platform/backend/backend/data/db_manager.py b/autogpt_platform/backend/backend/data/db_manager.py
index fc386f0b67..7ee00ff6c1 100644
--- a/autogpt_platform/backend/backend/data/db_manager.py
+++ b/autogpt_platform/backend/backend/data/db_manager.py
@@ -163,6 +163,7 @@ from backend.data.posthog_lifecycle_sync import (
request_posthog_lifecycle_sync,
start_posthog_lifecycle_sweep,
)
+from backend.data.pro_activation import get_usage_activation_state
from backend.data.push_subscription import (
cleanup_failed_subscriptions,
delete_push_subscription,
@@ -390,6 +391,7 @@ class DatabaseManager(AppService):
# The scheduler routes unattended chats by the user's saved default.
get_user_default_chat_route = _(get_user_default_chat_route)
get_user_subscription_tier = _(get_user_subscription_tier)
+ get_usage_activation_state = _(get_usage_activation_state)
get_subscription_trial = _(get_subscription_trial)
sync_subscription_from_stripe = _(sync_subscription_from_stripe)
record_subscription_trial_cost = _(record_subscription_trial_cost)
@@ -886,6 +888,7 @@ class DatabaseManagerAsyncClient(AppServiceClient):
get_user_by_id = d.get_user_by_id
get_user_default_chat_route = d.get_user_default_chat_route
get_user_subscription_tier = d.get_user_subscription_tier
+ get_usage_activation_state = d.get_usage_activation_state
get_subscription_trial = d.get_subscription_trial
sync_subscription_from_stripe = d.sync_subscription_from_stripe
record_subscription_trial_cost = d.record_subscription_trial_cost
diff --git a/autogpt_platform/backend/backend/data/posthog_lifecycle_hooks_test.py b/autogpt_platform/backend/backend/data/posthog_lifecycle_hooks_test.py
index e889417310..478cd3e960 100644
--- a/autogpt_platform/backend/backend/data/posthog_lifecycle_hooks_test.py
+++ b/autogpt_platform/backend/backend/data/posthog_lifecycle_hooks_test.py
@@ -88,14 +88,23 @@ async def test_trial_transitions_schedule_through_the_webhook_choke_point():
"""Trial start, cancel, conversion and expiry are all written by
``reconcile_trial_subscription``, which only runs inside
``sync_subscription_from_stripe``; its early return still schedules."""
- user = MagicMock(id="user-1", subscriptionTier=SubscriptionTier.NO_TIER)
+ user = MagicMock(
+ id="user-1", stripeCustomerId="cus_1", subscriptionTier=SubscriptionTier.NO_TIER
+ )
with (
patch(
"backend.data.credit.User.prisma",
return_value=MagicMock(find_first=AsyncMock(return_value=user)),
),
patch(
- "backend.data.credit.reconcile_trial_subscription",
+ "backend.data.credit.stripe.Subscription.retrieve_async",
+ AsyncMock(return_value=TRIAL_SUB),
+ ),
+ patch(
+ "backend.data.credit.get_subscription_trial", AsyncMock(return_value=None)
+ ),
+ patch(
+ "backend.data.credit.subscription_trial_stripe.reconcile_trial_subscription",
new_callable=AsyncMock,
return_value=(TRIAL_SUB, SubscriptionTier.TRIAL),
) as reconcile,
diff --git a/autogpt_platform/backend/backend/data/pro_activation.py b/autogpt_platform/backend/backend/data/pro_activation.py
new file mode 100644
index 0000000000..69bec05a74
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/pro_activation.py
@@ -0,0 +1,33 @@
+"""Uncached, atomic billing/usage snapshot shared with execution workers."""
+
+from prisma.enums import SubscriptionTier
+from pydantic import BaseModel
+
+from backend.data.db import query_raw_with_schema
+
+
+class UsageActivationState(BaseModel):
+ user_id: str
+ generation: str | None = None
+ trial_id: str | None = None
+ tier: SubscriptionTier
+ ready: bool
+
+
+async def get_usage_activation_state(user_id: str) -> UsageActivationState:
+ rows = await query_raw_with_schema(
+ """SELECT u."id" AS user_id, a."id" AS generation,
+ CASE WHEN u."subscriptionTier" = 'TRIAL' AND t."convertedAt" IS NULL AND t."consumedAt" IS NOT NULL
+ AND t."status" = 'trialing' AND t."cardVerifiedAt" IS NOT NULL
+ AND t."endsAt" > CURRENT_TIMESTAMP THEN t."id" END AS trial_id,
+ u."subscriptionTier"::text AS tier,
+ (a."id" IS NULL OR a."readyAt" IS NOT NULL) AS ready
+ FROM {schema_prefix}"User" u
+ LEFT JOIN {schema_prefix}"PaidUsageActivation" a ON a."userId" = u."id"
+ LEFT JOIN {schema_prefix}"SubscriptionTrial" t ON t."userId" = u."id"
+ WHERE u."id" = $1""",
+ user_id,
+ )
+ if len(rows) != 1:
+ raise ValueError("Cannot establish usage entitlement for this user")
+ return UsageActivationState.model_validate(rows[0])
diff --git a/autogpt_platform/backend/backend/data/stripe_activation_sweep_test.py b/autogpt_platform/backend/backend/data/stripe_activation_sweep_test.py
new file mode 100644
index 0000000000..c556e95d67
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/stripe_activation_sweep_test.py
@@ -0,0 +1,153 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from prisma.enums import SubscriptionTier
+
+from backend.data import stripe_reconciliation as sweep
+
+
[email protected](autouse=True)
+def activation_rows(mocker):
+ rows = MagicMock(find_unique=AsyncMock(return_value=None))
+ mocker.patch.object(sweep.PaidUsageActivation, "prisma", return_value=rows)
+ return rows
+
+
[email protected]("target", [SubscriptionTier.PRO, SubscriptionTier.MAX])
[email protected]("unchanged", [False, True])
+async def test_paid_sweep_reconciles_even_unchanged_tier(target, unchanged):
+ initial = target if unchanged else SubscriptionTier.NO_TIER
+ before = MagicMock(id="user", stripeCustomerId="cus", subscriptionTier=initial)
+ after = MagicMock(subscriptionTier=target)
+ raw = {"id": "sub", "customer": "cus"}
+ summary = sweep.ReconciliationSummary()
+ with (
+ patch.object(sweep, "sync_subscription_from_stripe", AsyncMock()) as sync,
+ patch.object(sweep, "set_subscription_tier", AsyncMock()) as direct,
+ patch.object(
+ sweep.User,
+ "prisma",
+ return_value=MagicMock(find_unique_or_raise=AsyncMock(return_value=after)),
+ ),
+ patch.object(
+ sweep, "log_tier_reconciliation_discrepancy", return_value="upgrade"
+ ),
+ ):
+ await sweep._reconcile_one(before, {"cus": target}, summary, True, {"cus": raw})
+ sync.assert_awaited_once_with(raw, track_lifecycle=False)
+ direct.assert_not_awaited()
+ assert summary.upgrades == (initial == SubscriptionTier.NO_TIER)
+ assert summary.unchanged == unchanged
+
+
[email protected]("target", [SubscriptionTier.PRO, SubscriptionTier.MAX])
+async def test_paid_sweep_does_not_grant_access_when_invoice_is_unsettled(target):
+ before = MagicMock(
+ id="user", stripeCustomerId="cus", subscriptionTier=SubscriptionTier.NO_TIER
+ )
+ summary = sweep.ReconciliationSummary()
+ raw = {"id": "sub", "customer": "cus", "status": "active"}
+ with (
+ patch.object(sweep, "sync_subscription_from_stripe", AsyncMock()) as sync,
+ patch.object(sweep, "set_subscription_tier", AsyncMock()) as direct,
+ patch.object(
+ sweep.User,
+ "prisma",
+ return_value=MagicMock(find_unique_or_raise=AsyncMock(return_value=before)),
+ ),
+ ):
+ await sweep._reconcile_one(before, {"cus": target}, summary, True, {"cus": raw})
+ sync.assert_awaited_once_with(raw, track_lifecycle=False)
+ direct.assert_not_awaited()
+ assert summary.unchanged == 1
+ assert summary.upgrades == 0
+
+
+ "failure", [ConnectionError("Redis unavailable"), ValueError("invalid evidence")]
+)
+async def test_pro_sweep_failure_never_falls_back_to_direct_grant(failure):
+ user = MagicMock(
+ id="user", stripeCustomerId="cus", subscriptionTier=SubscriptionTier.NO_TIER
+ )
+ summary = sweep.ReconciliationSummary()
+ with (
+ patch.object(
+ sweep, "sync_subscription_from_stripe", AsyncMock(side_effect=failure)
+ ),
+ patch.object(sweep, "set_subscription_tier", AsyncMock()) as direct,
+ ):
+ await sweep._reconcile_one(
+ user,
+ {"cus": SubscriptionTier.PRO},
+ summary,
+ True,
+ {"cus": {"id": "sub", "customer": "cus"}},
+ )
+ direct.assert_not_awaited()
+ assert summary.errors == 1
+ assert summary.upgrades == 0
+
+
+async def test_pro_sweep_missing_subscription_identity_fails_closed():
+ user = MagicMock(
+ id="user", stripeCustomerId="cus", subscriptionTier=SubscriptionTier.NO_TIER
+ )
+ summary = sweep.ReconciliationSummary()
+ with patch.object(sweep, "set_subscription_tier", AsyncMock()) as direct:
+ await sweep._reconcile_one(user, {"cus": SubscriptionTier.PRO}, summary, True)
+ direct.assert_not_awaited()
+ assert summary.errors == 1
+
+
+def test_pro_candidate_preserves_subscription_identity_alongside_highest_tier():
+ tiers = {}
+ subscriptions = {}
+ prices = {"pro": SubscriptionTier.PRO, "basic": SubscriptionTier.BASIC}
+ pro = {
+ "id": "sub_pro",
+ "customer": "cus",
+ "items": {"data": [{"price": {"id": "pro"}}]},
+ }
+ basic = {
+ "id": "sub_basic",
+ "customer": "cus",
+ "items": {"data": [{"price": {"id": "basic"}}]},
+ }
+ sweep._record_subscription(pro, prices, tiers, subscriptions)
+ sweep._record_subscription(basic, prices, tiers, subscriptions)
+ assert tiers == {"cus": SubscriptionTier.PRO}
+ assert subscriptions == {"cus": pro}
+
+
[email protected]("max_first", [True, False])
+def test_max_candidate_keeps_its_identity_over_lower_paid_subscription(max_first):
+ tiers, subscriptions = {}, {}
+ prices = {"pro": SubscriptionTier.PRO, "max": SubscriptionTier.MAX}
+ pro, maximum = (
+ {
+ "id": f"sub_{tier}",
+ "customer": "cus",
+ "items": {"data": [{"price": {"id": tier}}]},
+ }
+ for tier in ("pro", "max")
+ )
+ for subscription in (maximum, pro) if max_first else (pro, maximum):
+ sweep._record_subscription(subscription, prices, tiers, subscriptions)
+ assert tiers == {"cus": SubscriptionTier.MAX}
+ assert subscriptions == {"cus": maximum}
+
+
+async def test_completed_generation_does_not_skip_paid_plan_change(activation_rows):
+ activation_rows.find_unique.return_value = MagicMock(
+ stripeSubscriptionId="sub", readyAt="ready"
+ )
+ user = MagicMock(id="user", subscriptionTier=SubscriptionTier.PRO)
+ assert await sweep._requires_pro_reconciliation(
+ user, {"id": "sub"}, SubscriptionTier.MAX
+ )
diff --git a/autogpt_platform/backend/backend/data/stripe_reconciliation.py b/autogpt_platform/backend/backend/data/stripe_reconciliation.py
index 63bee907ed..ce41f1bda5 100644
--- a/autogpt_platform/backend/backend/data/stripe_reconciliation.py
+++ b/autogpt_platform/backend/backend/data/stripe_reconciliation.py
@@ -2,22 +2,23 @@
Webhooks give low-latency tier updates; this sweep is the safety net that makes
Stripe the eventual source of truth. It pages through every active/trialing
-Stripe subscription once, builds an authoritative ``{customer_id -> tier}`` map,
+Stripe subscription once, builds a candidate ``{customer_id -> tier}`` map,
then for every reconcilable user (has a Stripe customer, not ENTERPRISE) sets the
tier from the map (NO_TIER when the customer is absent). Manual grants (no Stripe
customer) and ENTERPRISE rows are never touched.
-Cost: one Stripe ``Subscription.list`` pass (not one call per user). The sweep
-skips users whose tier already matches the map (``target_tier == current_tier``
-in ``_reconcile_one``), so a steady-state run does no DB writes.
+Pro/Max candidates without a completed activation for their current subscription pass
+through subscription and settled-invoice reconciliation: tier assignment alone
+does not establish that first paid activation and its usage generation completed.
+Other unchanged tiers need no writes. Manual grants (no customer) remain excluded.
"""
import logging
import stripe
from prisma.enums import SubscriptionTier
-from prisma.models import User
-from pydantic import BaseModel
+from prisma.models import PaidUsageActivation, User
+from pydantic import BaseModel, Field
from backend.data.credit import (
alert_tier_reconciliation_discrepancy,
@@ -81,7 +82,13 @@ async def reconcile_all_stripe_tiers() -> ReconciliationSummary:
summary.candidate_users = len(candidates)
map_complete = not customer_to_tier.capped
for user in candidates:
- await _reconcile_one(user, customer_to_tier.tiers, summary, map_complete)
+ await _reconcile_one(
+ user,
+ customer_to_tier.tiers,
+ summary,
+ map_complete,
+ customer_to_tier.pro_subscriptions,
+ )
logger.info(
"reconcile_all_stripe_tiers: active_subs=%d candidates=%d upgrades=%d"
" downgrades=%d unchanged=%d skipped_incomplete=%d errors=%d capped=%s",
@@ -136,6 +143,7 @@ async def _reconcile_one(
customer_to_tier: dict[str, SubscriptionTier],
summary: ReconciliationSummary,
map_complete: bool,
+ pro_subscriptions: dict[str, dict] | None = None,
) -> None:
"""Set one user's tier from the Stripe map, updating the summary counts."""
current_tier = SubscriptionTier(user.subscriptionTier or SubscriptionTier.NO_TIER)
@@ -144,9 +152,6 @@ async def _reconcile_one(
target_tier = customer_to_tier.get(
user.stripeCustomerId, SubscriptionTier.NO_TIER
)
- if target_tier == current_tier:
- summary.unchanged += 1
- return
# When the Stripe snapshot is incomplete (a failed list page or the
# pagination cap), absence from the map is unreliable — the user may sit on
# a page we never fetched. Never revoke a tier off a partial snapshot;
@@ -156,7 +161,22 @@ async def _reconcile_one(
summary.skipped_incomplete += 1
return
try:
- await set_subscription_tier(user.id, target_tier)
+ pro_candidate = target_tier in (SubscriptionTier.PRO, SubscriptionTier.MAX)
+ if pro_candidate:
+ subscription = (pro_subscriptions or {}).get(user.stripeCustomerId or "")
+ if subscription is None:
+ raise ValueError("Paid reconciliation requires a subscription identity")
+ # The list price is only a routing hint. Reconciliation refetches
+ # Stripe under the activation lock and requires settled evidence.
+ # Run this even for an unchanged tier to recover incomplete usage
+ # activation; never grant Pro/Max by calling set_subscription_tier.
+ if await _requires_pro_reconciliation(user, subscription, target_tier):
+ target_tier = await _reconcile_pro_tier(user, subscription)
+ if target_tier == current_tier:
+ summary.unchanged += 1
+ return
+ if not pro_candidate:
+ await set_subscription_tier(user.id, target_tier)
except Exception:
summary.errors += 1
logger.exception(
@@ -188,9 +208,31 @@ async def _reconcile_one(
summary.upgrades += 1
+async def _requires_pro_reconciliation(
+ user: User, subscription: dict, target_tier: SubscriptionTier
+) -> bool:
+ if user.subscriptionTier != target_tier:
+ return True
+ activation = await PaidUsageActivation.prisma().find_unique(
+ where={"userId": user.id}
+ )
+ return not (
+ activation
+ and activation.readyAt is not None
+ and activation.stripeSubscriptionId == subscription.get("id")
+ )
+
+
+async def _reconcile_pro_tier(user: User, subscription: dict) -> SubscriptionTier:
+ await sync_subscription_from_stripe(subscription, track_lifecycle=False)
+ reconciled = await User.prisma().find_unique_or_raise(where={"id": user.id})
+ return SubscriptionTier(reconciled.subscriptionTier)
+
+
class _CustomerTierMap(BaseModel):
tiers: dict[str, SubscriptionTier]
capped: bool
+ pro_subscriptions: dict[str, dict] = Field(default_factory=dict)
async def _build_customer_tier_map() -> _CustomerTierMap:
@@ -201,17 +243,23 @@ async def _build_customer_tier_map() -> _CustomerTierMap:
"""
price_to_tier = await build_price_to_tier_map()
tiers: dict[str, SubscriptionTier] = {}
+ pro_subscriptions: dict[str, dict] = {}
capped = False
for status in ("active", "trialing"):
- page_capped = await _collect_status_page(status, price_to_tier, tiers)
+ page_capped = await _collect_status_page(
+ status, price_to_tier, tiers, pro_subscriptions
+ )
capped = capped or page_capped
- return _CustomerTierMap(tiers=tiers, capped=capped)
+ return _CustomerTierMap(
+ tiers=tiers, capped=capped, pro_subscriptions=pro_subscriptions
+ )
async def _collect_status_page(
status: str,
price_to_tier: dict[str, SubscriptionTier],
tiers: dict[str, SubscriptionTier],
+ pro_subscriptions: dict[str, dict] | None = None,
) -> bool:
"""Accumulate one Stripe status's subscriptions into ``tiers``. Returns
True if a list or trial sync failed, or pagination was capped."""
@@ -239,7 +287,7 @@ async def _collect_status_page(
await sync_subscription_from_stripe(
dict(sub), track_lifecycle=False
)
- except (ValueError, stripe.StripeError):
+ except Exception:
logger.exception(
"Trial reconciliation failed for subscription %s; snapshot is incomplete",
sub.id,
@@ -254,8 +302,13 @@ async def _collect_status_page(
existing = tiers.get(str(sub.customer))
if existing is None or _TIER_RANK[tier] > _TIER_RANK[existing]:
tiers[str(sub.customer)] = tier
+ if (
+ tier in (SubscriptionTier.PRO, SubscriptionTier.MAX)
+ and pro_subscriptions is not None
+ ):
+ pro_subscriptions[str(sub.customer)] = dict(sub)
continue
- _record_subscription(sub, price_to_tier, tiers)
+ _record_subscription(sub, price_to_tier, tiers, pro_subscriptions)
if not subs.has_more or not subs.data:
return incomplete
starting_after = subs.data[-1].id
@@ -272,6 +325,7 @@ def _record_subscription(
sub: stripe.Subscription,
price_to_tier: dict[str, SubscriptionTier],
tiers: dict[str, SubscriptionTier],
+ pro_subscriptions: dict[str, dict] | None = None,
) -> None:
"""Map one subscription's customer to its tier, keeping the highest tier."""
customer = sub.get("customer")
@@ -287,6 +341,12 @@ def _record_subscription(
existing = tiers.get(customer)
if existing is None or _TIER_RANK[tier] > _TIER_RANK[existing]:
tiers[customer] = tier
+ if (
+ tier in (SubscriptionTier.PRO, SubscriptionTier.MAX)
+ and pro_subscriptions is not None
+ and (existing is None or _TIER_RANK[tier] > _TIER_RANK[existing])
+ ):
+ pro_subscriptions[customer] = dict(sub)
_TIER_RANK: dict[SubscriptionTier, int] = {
diff --git a/autogpt_platform/backend/backend/data/stripe_reconciliation_test.py b/autogpt_platform/backend/backend/data/stripe_reconciliation_test.py
index 425fc54a57..9455d0149c 100644
--- a/autogpt_platform/backend/backend/data/stripe_reconciliation_test.py
+++ b/autogpt_platform/backend/backend/data/stripe_reconciliation_test.py
@@ -7,11 +7,13 @@ import pytest
import pytest_mock
import stripe
from prisma.enums import SubscriptionTier
+from prisma.models import PaidUsageActivation
from backend.data import stripe_client
from backend.data.stripe_reconciliation import (
ReconciliationSummary,
_collect_status_page,
+ _reconcile_one,
_record_subscription,
reconcile_all_stripe_tiers,
)
@@ -51,7 +53,7 @@ def _candidate(
def _patch_stripe_pages(
mocker: pytest_mock.MockFixture, by_status: dict[str, list[dict]]
-) -> None:
+) -> AsyncMock:
"""Make stripe.Subscription.list return one page per status."""
def _list(*, status: str, limit: int, starting_after: str | None = None):
@@ -64,6 +66,56 @@ def _patch_stripe_pages(
"backend.data.stripe_reconciliation.stripe.Subscription.list_async",
side_effect=_list,
)
+ return mocker.patch(
+ "backend.data.stripe_reconciliation._reconcile_pro_tier",
+ new_callable=AsyncMock,
+ return_value=SubscriptionTier.PRO,
+ )
+
+
[email protected](autouse=True)
+def activation_rows(mocker):
+ rows = MagicMock(find_unique=AsyncMock(return_value=None))
+ mocker.patch.object(PaidUsageActivation, "prisma", return_value=rows)
+ return rows
+
+
+ "subscription_id,ready",
+ [
+ ("sub_cus_pro", True),
+ ("sub_cus_pro", False),
+ ("sub_previous", True),
+ (None, True),
+ ],
+)
+async def test_sweep_skips_only_completed_activation_for_current_subscription(
+ mocker, activation_rows, subscription_id, ready
+):
+ user = _candidate("user", "cus_pro", SubscriptionTier.PRO)
+ if subscription_id:
+ activation_rows.find_unique.return_value = MagicMock(
+ stripeSubscriptionId=subscription_id, readyAt=object() if ready else None
+ )
+ reconcile = mocker.patch(
+ "backend.data.stripe_reconciliation._reconcile_pro_tier",
+ new_callable=AsyncMock,
+ return_value=SubscriptionTier.PRO,
+ )
+ summary = ReconciliationSummary()
+
+ await _reconcile_one(
+ user,
+ {"cus_pro": SubscriptionTier.PRO},
+ summary,
+ True,
+ {"cus_pro": _sub("cus_pro", "price_pro")},
+ )
+
+ assert summary.unchanged == 1 and summary.errors == 0
+ assert reconcile.await_count == (
+ 0 if subscription_id == "sub_cus_pro" and ready else 1
+ )
@pytest.fixture(autouse=True)
@@ -85,7 +137,7 @@ async def test_sweep_upgrades_downgrades_and_skips_unchanged(
new_callable=AsyncMock,
return_value={"price_pro": SubscriptionTier.PRO},
)
- _patch_stripe_pages(
+ reconcile_pro = _patch_stripe_pages(
mocker,
{"active": [_sub("cus_keep", "price_pro"), _sub("cus_up", "price_pro")]},
)
@@ -112,8 +164,10 @@ async def test_sweep_upgrades_downgrades_and_skips_unchanged(
assert summary.downgrades == 1
assert summary.unchanged == 1
assert summary.errors == 0
- set_tier.assert_any_await("u_up", SubscriptionTier.PRO)
- set_tier.assert_any_await("u_down", SubscriptionTier.NO_TIER)
+ set_tier.assert_awaited_once_with("u_down", SubscriptionTier.NO_TIER)
+ assert reconcile_pro.await_count == 2
+ reconcile_pro.assert_any_await(candidates[0], _sub("cus_keep", "price_pro"))
+ reconcile_pro.assert_any_await(candidates[1], _sub("cus_up", "price_pro"))
# Each correction is recorded, and the sweep alerts ops exactly once (not
# per-user) with the discrepancy counts.
assert {d.direction for d in summary.discrepancies} == {"upgrade", "downgrade"}
diff --git a/autogpt_platform/backend/backend/data/subscription_activation.py b/autogpt_platform/backend/backend/data/subscription_activation.py
new file mode 100644
index 0000000000..c344be205c
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation.py
@@ -0,0 +1,294 @@
+"""Publish a fresh usage generation only with settled Stripe billing evidence.
+
+The generation, trial conversion identity and entitlement commit together. Redis
+is only read, so a DB rollback or any replay cannot delete paid consumption.
+"""
+
+from datetime import UTC, datetime
+from uuid import NAMESPACE_URL, uuid5
+
+import stripe
+from prisma import Prisma
+from prisma.enums import SubscriptionTier
+from prisma.models import User
+
+from backend.copilot.usage_activation import verify_activation_usage
+from backend.data import credit
+from backend.data.db import query_raw_with_schema, transaction
+from backend.data.pro_activation import get_usage_activation_state
+from backend.data.stripe_client import stripe_call, stripe_list_items
+from backend.data.subscription_activation_evidence import (
+ INVOICE_REFERENCE,
+ first_settled_invoice,
+ invoice_subscription,
+ line_price,
+ qualifying_invoice,
+ settled_proration_invoice,
+ settled_recurring_invoice,
+)
+from backend.data.subscription_activation_models import PaidActivationResult
+from backend.data.subscription_activation_target import (
+ PAID_CONVERSION_TIERS,
+ accepted_conversion_target,
+ owns_consumed_trial,
+ subscription_price_id,
+)
+from backend.data.subscription_trial import TrialState
+
+
+async def reconcile_paid_activation(
+ user_id: str, subscription_id: str, *, expected_price_id: str | None = None
+) -> PaidActivationResult | None:
+ user = await User.prisma().find_unique_or_raise(where={"id": user_id})
+ raw = await stripe_call(stripe.Subscription.retrieve_async, subscription_id)
+ verify_subscription_owner(user, dict(raw))
+ await credit.sync_subscription_from_stripe(dict(raw))
+ state = await get_usage_activation_state(user_id)
+ if not state.ready or state.tier not in PAID_CONVERSION_TIERS:
+ return None
+ if raw.status != "active" or not await current_invoice_is_settled(
+ dict(raw), allow_proration=True
+ ):
+ return None
+ async with transaction() as tx:
+ locked = await lock_activation_user(user_id, tx)
+ if locked.subscriptionTier not in PAID_CONVERSION_TIERS:
+ return None
+ return await _reconcile_locked_activation(
+ locked, subscription_id, tx, expected_price_id
+ )
+
+
+async def _reconcile_locked_activation(
+ user: User, subscription_id: str, tx: Prisma, expected_price_id: str | None
+) -> PaidActivationResult | None:
+ await query_raw_with_schema(
+ 'SELECT "id" FROM {schema_prefix}"SubscriptionTrial" WHERE "userId" = $1 FOR UPDATE',
+ user.id,
+ client=tx,
+ )
+ row = await tx.subscriptiontrial.find_unique(where={"userId": user.id})
+ trial = (
+ TrialState.from_db(row)
+ if row and row.stripeSubscriptionId == subscription_id
+ else None
+ )
+ current = dict(
+ await stripe_call(stripe.Subscription.retrieve_async, subscription_id)
+ )
+ price_id = subscription_price_id(current)
+ if not price_id or (
+ expected_price_id is not None and price_id != expected_price_id
+ ):
+ return None
+ target = await accepted_conversion_target(trial, current, tx) if trial else None
+ if trial and trial.converted_at is None and target is None:
+ return None
+ tier = (
+ target[0] if target else (await credit.build_price_to_tier_map()).get(price_id)
+ )
+ if tier not in PAID_CONVERSION_TIERS or user.subscriptionTier != tier:
+ return None
+ # Even an admin paid label cannot hide incomplete payment reconciliation.
+ if not await publish_initial_pro_activation(user, current, price_id, tx, trial):
+ return None
+ return await _paid_activation_result(user.id, current, tx, trial)
+
+
+async def _paid_activation_result(
+ user_id: str, subscription: dict, tx: Prisma, trial: TrialState | None
+) -> PaidActivationResult | None:
+ activation = await tx.paidusageactivation.find_unique(where={"userId": user_id})
+ if activation and activation.readyAt is None:
+ return None
+ invoice_id = INVOICE_REFERENCE.validate_python(
+ subscription["latest_invoice"]
+ ).invoice_id
+ usage_reset = bool(
+ activation
+ and trial
+ and trial.consumed_at is not None
+ and trial.conversion_invoice_id == invoice_id
+ and activation.stripeSubscriptionId == subscription["id"]
+ and activation.stripeInvoiceId == invoice_id
+ )
+ if usage_reset:
+ invoice = await _retrieve_invoice(invoice_id)
+ usage_reset = qualifying_invoice(
+ invoice,
+ customer_id=subscription["customer"],
+ subscription_id=subscription["id"],
+ price_id=subscription_price_id(subscription) or "",
+ trial_end=subscription.get("trial_end"),
+ )
+ return PaidActivationResult(
+ invoice_id=invoice_id,
+ usage_reset=usage_reset,
+ activation_id=activation.id if activation and usage_reset else None,
+ )
+
+
+async def lock_activation_user(user_id: str, tx: Prisma) -> User:
+ await query_raw_with_schema(
+ 'SELECT "id" FROM {schema_prefix}"User" WHERE "id" = $1 FOR UPDATE',
+ user_id,
+ client=tx,
+ )
+ return await tx.user.find_unique_or_raise(where={"id": user_id})
+
+
+def verify_subscription_owner(user: User, subscription: dict) -> None:
+ if (
+ subscription.get("customer") != user.stripeCustomerId
+ or (subscription.get("metadata") or {}).get("user_id", user.id) != user.id
+ ):
+ raise ValueError("Subscription does not belong to this user")
+
+
+async def current_invoice_is_settled(
+ subscription: dict, *, allow_proration: bool = False
+) -> bool:
+ return (
+ await _current_settled_invoice(subscription, allow_proration=allow_proration)
+ is not None
+ )
+
+
+async def _current_settled_invoice(
+ subscription: dict, *, allow_proration: bool = False
+) -> dict | None:
+ latest = subscription.get("latest_invoice")
+ if not latest or subscription.get("status") != "active":
+ return None
+ invoice_id = INVOICE_REFERENCE.validate_python(latest).invoice_id
+ invoice = await _retrieve_invoice(invoice_id)
+ settled = (
+ (
+ settled_recurring_invoice(invoice)
+ or (
+ allow_proration
+ and settled_proration_invoice(
+ invoice, subscription_price_id(subscription)
+ )
+ )
+ )
+ and invoice.get("customer") == subscription.get("customer")
+ and invoice_subscription(invoice) == subscription.get("id")
+ and (
+ subscription.get("trial_end") is None
+ or invoice.get("created", 0) >= subscription["trial_end"]
+ )
+ )
+ return invoice if settled else None
+
+
+async def _retrieve_invoice(invoice_id: str) -> dict:
+ invoice = dict(await stripe_call(stripe.Invoice.retrieve_async, invoice_id))
+ if invoice.get("lines", {}).get("has_more"):
+ lines = await stripe_call(
+ stripe.Invoice.list_lines_async, invoice_id, limit=100
+ )
+ invoice["lines"] = {
+ "data": [dict(line) async for line in stripe_list_items(lines)],
+ "has_more": False,
+ }
+ return invoice
+
+
+async def publish_initial_pro_activation(
+ user: User,
+ subscription: dict,
+ price_id: str,
+ tx: Prisma,
+ trial: TrialState | None = None,
+) -> bool:
+ """Prove paid access; only an initial consumed trial conversion may reset.
+
+ The historical name and policy ID remain compatible with existing rows.
+ Call under User then Trial row locks when a trial enrollment is supplied.
+ """
+ verify_subscription_owner(user, subscription)
+ if subscription_price_id(subscription) != price_id:
+ return False
+ current_invoice = await _current_settled_invoice(subscription, allow_proration=True)
+ if current_invoice is None:
+ return False
+ existing = await tx.paidusageactivation.find_unique(where={"userId": user.id})
+ if existing:
+ if existing.stripeSubscriptionId == subscription["id"]:
+ await _complete_activation(existing.id, user.id, tx)
+ return True
+ # Enterprise remains manually managed. Paid history comes from Stripe,
+ # never from a tier label that an admin or delayed cache may have assigned.
+ if user.subscriptionTier == SubscriptionTier.ENTERPRISE:
+ return True
+ if (trial is None or trial.converted_at is not None) and settled_recurring_invoice(
+ current_invoice
+ ):
+ return True
+ first = await first_settled_invoice(user.stripeCustomerId or "")
+ if first is None:
+ return False
+ # Paid signups and already-converted trials retain their usage. In
+ # particular, replaying a legacy trial's original invoice cannot mint a
+ # generation merely because no activation row was recorded at that time.
+ if trial is None or trial.converted_at is not None:
+ return True
+ if not owns_consumed_trial(user, subscription, trial):
+ return False
+ if await accepted_conversion_target(trial, subscription, tx) is None:
+ return False
+ if invoice_subscription(first) != subscription["id"]:
+ return True # A returning subscriber keeps their existing consumption.
+ policy = await tx.paidusageactivationpolicy.find_unique_or_raise(
+ where={"id": "initial-pro-v1"}
+ )
+ paid_at = datetime.fromtimestamp(first["status_transitions"]["paid_at"], UTC)
+ if paid_at < policy.startsAt.replace(tzinfo=UTC):
+ return True
+ if not qualifying_invoice(
+ first,
+ customer_id=user.stripeCustomerId or "",
+ subscription_id=subscription["id"],
+ price_id=price_id,
+ trial_end=subscription.get("trial_end"),
+ ):
+ # A paid-plan change has historical service at another price. Missing
+ # first-period evidence is different: leave it recoverable, fail closed.
+ prices = {line_price(line) for line in first.get("lines", {}).get("data", [])}
+ return (
+ bool(prices)
+ and None not in prices
+ and (
+ price_id not in prices
+ or first.get("created", 0) < subscription["trial_end"]
+ )
+ )
+ generation = str(
+ uuid5(
+ NAMESPACE_URL,
+ f"autogpt:initial-pro:{user.id}:{subscription['id']}:{first['id']}",
+ )
+ )
+ await tx.paidusageactivation.create(
+ data={
+ "id": generation,
+ "userId": user.id,
+ "stripeSubscriptionId": subscription["id"],
+ "stripeInvoiceId": first["id"],
+ }
+ )
+ await _complete_activation(generation, user.id, tx)
+ await tx.subscriptiontrial.update(
+ where={"userId": user.id},
+ data={"convertedAt": paid_at, "stripeConversionInvoiceId": first["id"]},
+ )
+ return True
+
+
+async def _complete_activation(generation: str, user_id: str, tx: Prisma) -> None:
+ await verify_activation_usage(user_id, generation)
+ await tx.paidusageactivation.update_many(
+ where={"id": generation, "userId": user_id, "readyAt": None},
+ data={"readyAt": datetime.now(UTC)},
+ )
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_attempt.py b/autogpt_platform/backend/backend/data/subscription_activation_attempt.py
new file mode 100644
index 0000000000..3ce2dbf867
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_attempt.py
@@ -0,0 +1,81 @@
+"""Durable confirmation intent; Stripe calls never share its commit boundary."""
+
+from uuid import uuid4
+
+from backend.data.db import query_raw_with_schema
+from backend.data.subscription_activation_models import (
+ ActivationAttempt,
+ ActivationTerms,
+ ActivationUnavailable,
+)
+
+_COLUMNS = """"id", "userId" AS user_id,
+ "stripeSubscriptionId" AS subscription_id, "stripeCustomerId" AS customer_id,
+ "terms", "returnTo" AS return_to, "confirmedAt" AS confirmed_at,
+ "invoiceId" AS invoice_id"""
+
+
+async def get_attempt(
+ user_id: str, attempt_id: str | None = None
+) -> ActivationAttempt | None:
+ rows = await query_raw_with_schema(
+ "SELECT " + _COLUMNS + ' FROM {schema_prefix}"ProActivationAttempt" '
+ 'WHERE "userId" = $1 AND ($2::text IS NULL OR "id" = $2)',
+ user_id,
+ attempt_id,
+ model=ActivationAttempt,
+ )
+ return rows[0] if rows else None
+
+
+async def save_quote(
+ user_id: str,
+ subscription_id: str,
+ customer_id: str,
+ terms: ActivationTerms,
+ return_to: str,
+) -> ActivationAttempt:
+ rows = await query_raw_with_schema(
+ """INSERT INTO {schema_prefix}"ProActivationAttempt"
+ ("id", "userId", "stripeSubscriptionId", "stripeCustomerId", "terms",
+ "returnTo", "status", "createdAt", "updatedAt")
+ VALUES ($1, $2, $3, $4, $5::jsonb, $6, 'quoted', NOW(), NOW())
+ ON CONFLICT ("userId") DO UPDATE SET "terms" = EXCLUDED."terms",
+ "returnTo" = EXCLUDED."returnTo", "updatedAt" = NOW()
+ WHERE "ProActivationAttempt"."confirmedAt" IS NULL
+ AND "ProActivationAttempt"."stripeSubscriptionId" = EXCLUDED."stripeSubscriptionId"
+ AND "ProActivationAttempt"."stripeCustomerId" = EXCLUDED."stripeCustomerId"
+ RETURNING """
+ + _COLUMNS,
+ str(uuid4()),
+ user_id,
+ subscription_id,
+ customer_id,
+ terms.model_dump_json(),
+ return_to,
+ model=ActivationAttempt,
+ )
+ if not rows:
+ raise ActivationUnavailable("Activation confirmation is already in progress")
+ return rows[0]
+
+
+async def save_confirmation(attempt: ActivationAttempt) -> ActivationAttempt:
+ rows = await query_raw_with_schema(
+ """UPDATE {schema_prefix}"ProActivationAttempt"
+ SET "confirmedAt" = COALESCE("confirmedAt", NOW()),
+ "status" = 'processing', "updatedAt" = NOW()
+ WHERE "id" = $1 AND "userId" = $2
+ AND "terms" = $3::jsonb AND "stripeSubscriptionId" = $4
+ AND "stripeCustomerId" = $5 RETURNING """
+ + _COLUMNS,
+ attempt.id,
+ attempt.user_id,
+ attempt.terms.model_dump_json(),
+ attempt.subscription_id,
+ attempt.customer_id,
+ model=ActivationAttempt,
+ )
+ if not rows:
+ raise ActivationUnavailable("The terms changed. Review a fresh preview.")
+ return rows[0]
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_attempt_integration_test.py b/autogpt_platform/backend/backend/data/subscription_activation_attempt_integration_test.py
new file mode 100644
index 0000000000..c982d8f23a
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_attempt_integration_test.py
@@ -0,0 +1,187 @@
+"""Real PostgreSQL confirmation durability and cross-request serialization."""
+
+import asyncio
+import os
+from datetime import UTC, datetime, timedelta
+from unittest.mock import AsyncMock
+
+import pytest
+import stripe
+from prisma.models import User
+
+from backend.data import subscription_activation_checkout as checkout
+from backend.data.subscription_activation_attempt import (
+ get_attempt,
+ save_confirmation,
+ save_quote,
+)
+from backend.data.subscription_activation_models import (
+ ActivationConfirmRequest,
+ ActivationTerms,
+ ActivationUnavailable,
+ PaidActivationResult,
+)
+from backend.data.subscription_activation_stripe import (
+ BillingInvoice,
+ BillingSubscription,
+)
+from backend.data.subscription_checkout import (
+ SubscriptionCheckoutUnavailable,
+ subscription_checkout_lock,
+)
+
+pytest_plugins = ("backend.data.subscription_trial_integration_fixtures",)
+pytestmark = pytest.mark.skipif(
+ os.environ.get("TRIAL_TEST_DATABASE") != "1",
+ reason="Requires explicitly selected disposable trial database",
+)
+
+
+def terms():
+ return ActivationTerms(
+ price_id="price_test",
+ accepted_offer_token="a" * 64,
+ amount_due=2000,
+ currency="usd",
+ billing_interval="month",
+ renewal_unit_amount=2000,
+ renewal_terms="Renews monthly until canceled.",
+ expires_at=datetime.now(UTC) + timedelta(minutes=10),
+ )
+
+
+async def test_replaced_quote_cannot_be_confirmed_by_a_stale_request(enrollment):
+ original = await save_quote(
+ enrollment.user_id,
+ f"sub_{enrollment.id}",
+ enrollment.customer_id,
+ terms(),
+ "/chat/first",
+ )
+ replacement = await save_quote(
+ enrollment.user_id,
+ original.subscription_id,
+ enrollment.customer_id,
+ terms().model_copy(update={"amount_due": 2500}),
+ "/chat/second",
+ )
+ with pytest.raises(ActivationUnavailable, match="terms changed"):
+ await save_confirmation(original)
+ current = await get_attempt(enrollment.user_id)
+ assert current and current.confirmed_at is None
+ assert current.terms == replacement.terms
+
+
+async def test_confirmed_quote_is_immutable_and_user_scoped(enrollment):
+ attempt = await save_quote(
+ enrollment.user_id,
+ f"sub_{enrollment.id}",
+ enrollment.customer_id,
+ terms(),
+ "/chat/return-here",
+ )
+ async with subscription_checkout_lock(enrollment.user_id):
+ confirmed = await save_confirmation(attempt)
+ assert confirmed.confirmed_at is not None
+ assert await get_attempt("another-user", attempt.id) is None
+ with pytest.raises(ValueError, match="already in progress"):
+ await save_quote(
+ enrollment.user_id,
+ attempt.subscription_id,
+ enrollment.customer_id,
+ terms().model_copy(update={"amount_due": 3000}),
+ "/different-path",
+ )
+ persisted = await get_attempt(enrollment.user_id)
+ assert persisted is not None
+ assert persisted.terms.amount_due == 2000
+ assert persisted.return_to == "/chat/return-here"
+
+
+async def test_concurrent_confirmation_and_lost_stripe_response_do_not_charge_twice(
+ enrollment, monkeypatch
+):
+ await User.prisma().update(
+ where={"id": enrollment.user_id},
+ data={"stripeCustomerId": enrollment.customer_id},
+ )
+ attempt = await save_quote(
+ enrollment.user_id,
+ f"sub_{enrollment.id}",
+ enrollment.customer_id,
+ terms(),
+ "/chat/return-here",
+ )
+ sub = BillingSubscription.model_validate(
+ {
+ "id": attempt.subscription_id,
+ "customer": enrollment.customer_id,
+ "status": "trialing",
+ "trial_end": int(datetime.now(UTC).timestamp()) + 86400,
+ "metadata": {"user_id": enrollment.user_id},
+ "items": {
+ "data": [
+ {
+ "quantity": 1,
+ "price": {
+ "id": "price_test",
+ "unit_amount": 2000,
+ "currency": "usd",
+ "recurring": {"interval": "month", "interval_count": 1},
+ },
+ }
+ ]
+ },
+ }
+ )
+ monkeypatch.setattr(checkout, "owned_subscription", AsyncMock(return_value=sub))
+ monkeypatch.setattr(
+ checkout, "conversion_trial", AsyncMock(return_value=(enrollment, sub))
+ )
+ monkeypatch.setattr(checkout, "quote_terms", AsyncMock(return_value=attempt.terms))
+ monkeypatch.setattr(
+ checkout,
+ "reconcile_paid_activation",
+ AsyncMock(
+ return_value=PaidActivationResult(
+ invoice_id="in_confirmed",
+ usage_reset=True,
+ activation_id="generation-1",
+ )
+ ),
+ )
+
+ async def lost_response(*args, **kwargs):
+ persisted = await get_attempt(enrollment.user_id)
+ assert persisted and persisted.confirmed_at
+ sub.status = "active"
+ sub.latest_invoice = BillingInvoice(
+ id="in_confirmed", customer=sub.customer, status="paid"
+ )
+ raise stripe.APIConnectionError("Payment settled but response was lost")
+
+ mutation = AsyncMock(side_effect=lost_response)
+ monkeypatch.setattr(checkout, "stripe_call", mutation)
+ body = ActivationConfirmRequest(confirmed=True, terms_token=attempt.terms.token)
+
+ async def confirm_once():
+ try:
+ response = await checkout.confirm_activation(
+ enrollment.user_id, attempt.id, body
+ )
+ return response.status
+ except SubscriptionCheckoutUnavailable:
+ return "concurrent_confirmation"
+
+ results = await asyncio.gather(*[confirm_once() for _ in range(4)])
+ assert set(results) <= {"processing", "ready", "concurrent_confirmation"}
+ recovered = await checkout.get_activation(enrollment.user_id, attempt.id)
+ assert recovered.status == "ready"
+ assert recovered.return_to == "/chat/return-here"
+ assert (
+ await checkout.confirm_activation(enrollment.user_id, attempt.id, body)
+ ).status == "ready"
+ mutation.assert_awaited_once()
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_cache_test.py b/autogpt_platform/backend/backend/data/subscription_activation_cache_test.py
new file mode 100644
index 0000000000..05723c73f7
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_cache_test.py
@@ -0,0 +1,47 @@
+"""Trial activation mutations expire shared Stripe billing lookups."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+import stripe
+
+from backend.data import credit
+from backend.data import subscription_activation_checkout as checkout
+from backend.data import subscription_activation_checkout_fixtures as fixtures
+from backend.data import subscription_trial_fixtures as trial_fixtures
+from backend.data.subscription_activation_models import ActivationConfirmRequest
+
+trial = trial_fixtures.trial
+attempt = fixtures.attempt
+live_subscription = fixtures.live_subscription
+boundaries = fixtures.boundaries
+
+
[email protected]("lost_response", [False, True])
+async def test_confirm_invalidates_shared_lookups_even_when_stripe_response_is_lost(
+ attempt, boundaries, monkeypatch, lost_response
+):
+ invalidated = AsyncMock()
+ monkeypatch.setattr(credit, "invalidate_billing_lookups", invalidated)
+ if lost_response:
+ boundaries.stripe_call.side_effect = stripe.APIConnectionError("lost response")
+ response = await checkout.confirm_activation(
+ attempt.user_id,
+ attempt.id,
+ ActivationConfirmRequest(confirmed=True, terms_token=attempt.terms.token),
+ )
+ assert response.status == "processing"
+ boundaries.stripe_call.assert_awaited_once()
+ invalidated.assert_awaited_once_with(attempt.customer_id)
+
+
+async def test_status_polling_does_not_mutate_or_invalidate_billing_lookups(
+ attempt, boundaries, monkeypatch
+):
+ invalidated = AsyncMock()
+ monkeypatch.setattr(credit, "invalidate_billing_lookups", invalidated)
+ await checkout.get_activation(attempt.user_id, attempt.id)
+ boundaries.stripe_call.assert_not_awaited()
+ invalidated.assert_not_awaited()
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_checkout.py b/autogpt_platform/backend/backend/data/subscription_activation_checkout.py
new file mode 100644
index 0000000000..3c8b188a5a
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_checkout.py
@@ -0,0 +1,316 @@
+"""Explicit trial conversion, durable confirmation, and read-only payment recovery."""
+
+import logging
+from datetime import UTC, datetime, timedelta
+
+import stripe
+from prisma.models import User
+
+from backend.data import credit
+from backend.data.stripe_client import stripe_call, stripe_list_items
+from backend.data.subscription_activation import reconcile_paid_activation
+from backend.data.subscription_activation_attempt import (
+ get_attempt,
+ save_confirmation,
+ save_quote,
+)
+from backend.data.subscription_activation_models import (
+ ActivationAttempt,
+ ActivationConfirmRequest,
+ ActivationNotFound,
+ ActivationPlan,
+ ActivationResponse,
+ ActivationUnavailable,
+ BillingInvoice,
+)
+from backend.data.subscription_activation_return import activation_return_to
+from backend.data.subscription_activation_stripe import (
+ BillingSubscription,
+ conversion_trial,
+ invoice_payment_intent,
+ is_paid_activation_subscription,
+ matches_trial_source,
+ owned_subscription,
+ quote_terms,
+ subscription_item_update,
+)
+from backend.data.subscription_checkout import subscription_checkout_lock
+from backend.data.subscription_trial_conversion import PENDING_UPDATE_API_VERSION
+
+logger = logging.getLogger(__name__)
+
+
+async def preview_activation(
+ user_id: str, return_to: str, plan: ActivationPlan | None = None
+) -> ActivationResponse:
+ async with subscription_checkout_lock(user_id):
+ existing = await get_attempt(user_id)
+ if existing and existing.confirmed_at:
+ return await activation_status(existing)
+ trial, sub = await conversion_trial(user_id)
+ terms = await quote_terms(trial, sub, plan)
+ attempt = await save_quote(user_id, sub.id, sub.customer, terms, return_to)
+ return attempt.response("confirmation_required")
+
+
+async def confirm_activation(
+ user_id: str,
+ attempt_id: str,
+ body: ActivationConfirmRequest,
+) -> ActivationResponse:
+ async with subscription_checkout_lock(user_id):
+ attempt = await _require_attempt(user_id, attempt_id)
+ if body.terms_token != attempt.terms.token:
+ raise ActivationUnavailable("The terms changed. Review a fresh preview.")
+ if attempt.confirmed_at is None:
+ sub = await owned_subscription(user_id, attempt.subscription_id)
+ if sub.status != "trialing":
+ return await activation_status(attempt)
+ attempt = await _confirm_terms(attempt)
+ return await _submit_confirmed(attempt)
+
+
+async def get_activation(user_id: str, attempt_id: str) -> ActivationResponse:
+ return await activation_status(await _require_attempt(user_id, attempt_id))
+
+
+async def current_activation(user_id: str) -> ActivationResponse:
+ attempt = await get_attempt(user_id)
+ previous = None
+ if attempt:
+ previous = await activation_status(attempt)
+ if previous.error_code == "plan_changed" or previous.status not in (
+ "failed",
+ "not_applicable",
+ ):
+ return previous
+ user = await User.prisma().find_unique_or_raise(where={"id": user_id})
+ if not user.stripeCustomerId:
+ raise ActivationNotFound("No activation is available")
+ subscriptions = await stripe_call(
+ stripe.Subscription.list_async,
+ customer=user.stripeCustomerId,
+ status="all",
+ limit=100,
+ )
+ async for subscription in stripe_list_items(subscriptions):
+ if subscription.status in ("active", "incomplete", "past_due"):
+ sub = await owned_subscription(user_id, subscription.id)
+ response = ActivationResponse(status="processing", retry_after_seconds=3)
+ response.return_to = await activation_return_to(sub)
+ result = await _payment_status(user_id, sub, response)
+ if result.status != "not_applicable":
+ return result
+ if previous is None or previous.status == "failed":
+ previous = result
+ if previous:
+ return previous
+ raise ActivationNotFound("No activation is available")
+
+
+async def activation_status(attempt: ActivationAttempt) -> ActivationResponse:
+ response = attempt.response("processing", retry_after_seconds=3)
+ try:
+ sub = await owned_subscription(attempt.user_id, attempt.subscription_id)
+ if sub.customer != attempt.customer_id:
+ raise ActivationUnavailable("Subscription ownership changed")
+ return await _payment_status(
+ attempt.user_id,
+ sub,
+ response,
+ unconfirmed_trial=attempt.confirmed_at is None,
+ )
+ except Exception:
+ logger.exception(
+ "Activation status is pending reconciliation for %s", attempt.id
+ )
+ return response.model_copy(
+ update={
+ "status": "processing",
+ "retry_after_seconds": 3,
+ "hosted_invoice_url": None,
+ }
+ )
+
+
+async def _confirm_terms(attempt: ActivationAttempt) -> ActivationAttempt:
+ if attempt.terms.expires_at <= datetime.now(UTC):
+ raise ActivationUnavailable("The preview expired. Review a fresh preview.")
+ trial, sub = await conversion_trial(attempt.user_id)
+ if sub.id != attempt.subscription_id:
+ raise ActivationUnavailable("The trial subscription changed")
+ if not attempt.terms.same_charge_as(
+ await quote_terms(
+ trial, sub, attempt.terms.plan, accepted_price_id=attempt.terms.price_id
+ )
+ ):
+ raise ActivationUnavailable("The charge changed. Review a fresh preview.")
+ return await save_confirmation(attempt)
+
+
+async def _submit_confirmed(attempt: ActivationAttempt) -> ActivationResponse:
+ # Persist intent before Stripe; even an unknown network outcome retains the
+ # same operation. Only this explicitly confirmed POST can initiate payment.
+ try:
+ sub = await owned_subscription(attempt.user_id, attempt.subscription_id)
+ if sub.status == "trialing":
+ if not attempt.confirmed_at or (
+ datetime.now(UTC) - attempt.confirmed_at >= timedelta(hours=23)
+ ):
+ return attempt.response("processing", error_code="recovery_required")
+ if (
+ sub.trial_end is None
+ or sub.trial_end <= datetime.now(UTC).timestamp() + 300
+ ):
+ return attempt.response(
+ "processing",
+ retry_after_seconds=3,
+ error_code=(
+ "trial_ending"
+ if sub.items.data[0].price.id != attempt.terms.price_id
+ else None
+ ),
+ )
+ trial, sub = await conversion_trial(attempt.user_id)
+ if not attempt.terms.same_charge_as(
+ await quote_terms(
+ trial,
+ sub,
+ attempt.terms.plan,
+ accepted_price_id=attempt.terms.price_id,
+ )
+ ):
+ return attempt.response("processing", error_code="terms_changed")
+ try:
+ # Stripe applies a pending update only once its invoice is
+ # paid, so a declined card or an unfinished bank check leaves
+ # the trial running, and the invoice page takes another card.
+ # allow_incomplete ended the trial before the charge went
+ # through. The pending update's metadata needs the newer API.
+ await stripe_call(
+ stripe.Subscription.modify_async,
+ attempt.subscription_id,
+ trial_end="now",
+ proration_behavior="none",
+ payment_behavior="pending_if_incomplete",
+ metadata={"pro_activation_attempt_id": attempt.id},
+ idempotency_key=f"pro-activation:{attempt.id}",
+ stripe_version=PENDING_UPDATE_API_VERSION,
+ **subscription_item_update(sub, attempt.terms.price_id),
+ )
+ finally:
+ await credit.invalidate_billing_lookups(attempt.customer_id)
+ return await activation_status(attempt)
+ except Exception:
+ logger.exception("Confirmed activation needs recovery for %s", attempt.id)
+ return attempt.response("processing", retry_after_seconds=3)
+
+
+async def _payment_status(
+ user_id: str,
+ sub: BillingSubscription,
+ response: ActivationResponse,
+ *,
+ unconfirmed_trial: bool = False,
+) -> ActivationResponse:
+ invoice = sub.latest_invoice
+ if invoice:
+ response.invoice_id = invoice.id
+ if sub.status in ("canceled", "incomplete_expired") or (
+ invoice and invoice.status in ("void", "uncollectible")
+ ):
+ response.status = "failed"
+ response.error_code = "payment_canceled"
+ response.retry_after_seconds = None
+ return response
+ if sub.pending_update and invoice and invoice.status == "open":
+ # The trial runs on until this invoice is paid.
+ return await _open_invoice_status(sub, invoice, response)
+ if (
+ sub.status == "trialing"
+ and response.terms
+ and await matches_trial_source(user_id, sub, response.terms)
+ and sub.items.data[0].price.id != response.terms.price_id
+ ):
+ response.status = "confirmation_required" if unconfirmed_trial else "processing"
+ response.retry_after_seconds = None if unconfirmed_trial else 3
+ return response
+ paid_plan = await is_paid_activation_subscription(
+ user_id, sub, response.terms.price_id if response.terms else None
+ )
+ if paid_plan is not True:
+ response.status = "not_applicable" if paid_plan is False else "processing"
+ response.error_code = (
+ "not_paid_activation_subscription"
+ if paid_plan is False
+ else "plan_unavailable"
+ )
+ response.retry_after_seconds = None if paid_plan is False else 3
+ return response
+ if (
+ sub.status != "trialing"
+ and response.terms
+ and sub.items.data[0].price.id != response.terms.price_id
+ ):
+ response.status = "not_applicable"
+ response.error_code = "plan_changed"
+ response.retry_after_seconds = None
+ return response
+ if sub.status == "trialing" and (
+ unconfirmed_trial
+ or (response.terms and sub.items.data[0].price.id != response.terms.price_id)
+ ):
+ if (
+ response.terms is None
+ or sub.items.data[0].price.id != response.terms.price_id
+ ):
+ response.error_code = "terms_changed"
+ return response
+ response.status = "confirmation_required"
+ response.retry_after_seconds = None
+ return response
+ if invoice and invoice.status == "paid":
+ result = await reconcile_paid_activation(
+ user_id,
+ sub.id,
+ expected_price_id=response.terms.price_id if response.terms else None,
+ )
+ if result is not None:
+ response.status = "ready"
+ response.retry_after_seconds = None
+ response.invoice_id = result.invoice_id
+ response.usage_reset = result.usage_reset
+ response.activation_id = result.activation_id
+ return response
+ if invoice and invoice.status == "open":
+ return await _open_invoice_status(sub, invoice, response)
+ return response
+
+
+async def _open_invoice_status(
+ sub: BillingSubscription, invoice: BillingInvoice, response: ActivationResponse
+) -> ActivationResponse:
+ response.hosted_invoice_url = invoice.hosted_invoice_url
+ response.status = "payment_required"
+ response.retry_after_seconds = None
+ payment_intent_id = await invoice_payment_intent(invoice)
+ if payment_intent_id:
+ intent = await stripe_call(
+ stripe.PaymentIntent.retrieve_async,
+ payment_intent_id,
+ )
+ if intent.customer != sub.customer:
+ raise ActivationUnavailable("Payment ownership could not be established")
+ if intent.status == "requires_action":
+ response.status = "action_required"
+ elif intent.status in ("processing", "succeeded"):
+ response.status = "processing"
+ response.retry_after_seconds = 3
+ return response
+
+
+async def _require_attempt(user_id: str, attempt_id: str) -> ActivationAttempt:
+ attempt = await get_attempt(user_id, attempt_id)
+ if attempt is None:
+ raise ActivationNotFound("Activation was not found")
+ return attempt
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_checkout_fixtures.py b/autogpt_platform/backend/backend/data/subscription_activation_checkout_fixtures.py
new file mode 100644
index 0000000000..9d66f5513b
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_checkout_fixtures.py
@@ -0,0 +1,119 @@
+"""Shared Stripe-boundary fixtures for activation recovery tests."""
+
+from contextlib import asynccontextmanager
+from datetime import UTC, datetime, timedelta
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+from prisma.enums import SubscriptionTier
+
+from backend.data import subscription_activation_checkout as checkout
+from backend.data import subscription_activation_stripe as billing
+from backend.data.subscription_activation_models import (
+ ActivationAttempt,
+ ActivationTerms,
+)
+
+
+def attempt():
+ return ActivationAttempt(
+ id="operation-1",
+ user_id="user-1",
+ subscription_id="sub_1",
+ customer_id="cus_1",
+ return_to="/chat/thread-123?resume=true",
+ confirmed_at=None,
+ terms=ActivationTerms(
+ price_id="price_pro",
+ accepted_offer_token="a" * 64,
+ amount_due=4200,
+ currency="usd",
+ billing_interval="month",
+ renewal_unit_amount=5000,
+ renewal_terms="Renews every month; cancel before renewal.",
+ expires_at=datetime.now(UTC) + timedelta(minutes=10),
+ ),
+ )
+
+
+def live_subscription():
+ return billing.BillingSubscription.model_validate(
+ {
+ "id": "sub_1",
+ "customer": "cus_1",
+ "status": "trialing",
+ "trial_end": int((datetime.now(UTC) + timedelta(days=1)).timestamp()),
+ "metadata": {"user_id": "user-1", "trial_enrollment_id": "trial-1"},
+ "items": {
+ "data": [
+ {
+ "price": {
+ "id": "price_pro",
+ "unit_amount": 5000,
+ "currency": "usd",
+ "recurring": {"interval": "month", "interval_count": 1},
+ },
+ "quantity": 1,
+ }
+ ]
+ },
+ }
+ )
+
+
+def boundaries(monkeypatch, attempt, live_subscription, trial):
+ @asynccontextmanager
+ async def lock(user_id):
+ yield
+
+ confirmed = attempt.model_copy(update={"confirmed_at": datetime.now(UTC)})
+ mocks = {
+ "subscription_checkout_lock": lock,
+ "get_attempt": AsyncMock(return_value=attempt),
+ "save_confirmation": AsyncMock(return_value=confirmed),
+ "save_quote": AsyncMock(return_value=attempt),
+ "conversion_trial": AsyncMock(return_value=(trial, live_subscription)),
+ "quote_terms": AsyncMock(return_value=attempt.terms),
+ "owned_subscription": AsyncMock(return_value=live_subscription),
+ "reconcile_paid_activation": AsyncMock(return_value=None),
+ "stripe_call": AsyncMock(),
+ }
+ for name, value in mocks.items():
+ monkeypatch.setattr(checkout, name, value)
+ monkeypatch.setattr(
+ billing, "get_subscription_trial", AsyncMock(return_value=trial)
+ )
+ monkeypatch.setattr(
+ "backend.data.credit.build_price_to_tier_map",
+ AsyncMock(return_value={"price_pro": SubscriptionTier.PRO}),
+ )
+ monkeypatch.setattr(billing.credit, "invalidate_billing_lookups", AsyncMock())
+ return SimpleNamespace(**mocks)
+
+
+def max_attempt(attempt, boundaries, trial, live_subscription):
+ trial.subscription_id = live_subscription.id
+ trial.consumed_at = datetime.now(UTC)
+ attempt.terms = attempt.terms.model_copy(
+ update={
+ "plan": "MAX",
+ "price_id": "price_max",
+ "accepted_offer_token": trial.offer.token,
+ }
+ )
+ live_subscription.items.data[0] = billing.ActivationItem.model_validate(
+ {
+ **live_subscription.items.data[0].model_dump(),
+ "id": "si_owned",
+ }
+ )
+ boundaries.quote_terms.return_value = attempt.terms
+ boundaries.save_confirmation.return_value = attempt.model_copy(
+ update={"confirmed_at": datetime.now(UTC)}
+ )
+ return attempt
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_checkout_test.py b/autogpt_platform/backend/backend/data/subscription_activation_checkout_test.py
new file mode 100644
index 0000000000..6b0d03f75a
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_checkout_test.py
@@ -0,0 +1,332 @@
+"""Explicit confirmation and charge recovery contract."""
+
+from contextlib import asynccontextmanager
+from datetime import UTC, datetime
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+import stripe
+from pydantic import ValidationError
+
+from backend.api.features.subscription_activation_routes import confirm_pro_activation
+from backend.data import subscription_activation_checkout as checkout
+from backend.data import subscription_activation_checkout_fixtures as fixtures
+from backend.data import subscription_activation_stripe as billing
+from backend.data.subscription_activation_models import (
+ ActivationConfirmRequest,
+ ActivationNotFound,
+ ActivationPreviewRequest,
+ ActivationUnavailable,
+ PaidActivationResult,
+)
+from backend.data.subscription_trial_conversion import PENDING_UPDATE_API_VERSION
+
+pytest_plugins = ("backend.data.subscription_trial_fixtures",)
+
+attempt = fixtures.attempt
+boundaries = fixtures.boundaries
+live_subscription = fixtures.live_subscription
+max_attempt = fixtures.max_attempt
+
+
[email protected]("confirmation", [False, 1, "true", None])
+def test_conversion_requires_explicit_true_confirmation(confirmation):
+ with pytest.raises(ValidationError):
+ ActivationConfirmRequest(confirmed=confirmation, terms_token="a" * 64)
+
+
+ "path", ["https://attacker.test", "//attacker.test", "/\\evil", "/x\n"]
+)
+def test_return_destination_stays_on_application_origin(path):
+ with pytest.raises(ValidationError):
+ ActivationPreviewRequest(return_to=path)
+
+
+async def test_preview_never_charges_and_preserves_destination(attempt, boundaries):
+ response = await checkout.preview_activation(attempt.user_id, attempt.return_to)
+ assert response.status == "confirmation_required"
+ assert response.return_to == attempt.return_to
+ assert response.terms.amount_due == 4200
+ boundaries.stripe_call.assert_not_awaited()
+ boundaries.save_confirmation.assert_not_awaited()
+
+
+async def test_confirm_persists_intent_before_idempotent_existing_subscription_update(
+ attempt, boundaries
+):
+ async def stripe_update(fn, subscription_id, **kwargs):
+ boundaries.save_confirmation.assert_awaited_once()
+ assert subscription_id == "sub_1"
+ assert fn == stripe.Subscription.modify_async
+ assert kwargs == {
+ "trial_end": "now",
+ "proration_behavior": "none",
+ "payment_behavior": "pending_if_incomplete",
+ "metadata": {"pro_activation_attempt_id": attempt.id},
+ "idempotency_key": f"pro-activation:{attempt.id}",
+ "stripe_version": PENDING_UPDATE_API_VERSION,
+ }
+
+ boundaries.stripe_call.side_effect = stripe_update
+ response = await checkout.confirm_activation(
+ attempt.user_id,
+ attempt.id,
+ ActivationConfirmRequest(confirmed=True, terms_token=attempt.terms.token),
+ )
+ assert response.status == "processing"
+ boundaries.stripe_call.assert_awaited_once()
+
+
+async def test_changed_or_expired_terms_never_start_payment(attempt, boundaries):
+ boundaries.quote_terms.return_value = attempt.terms.model_copy(
+ update={"amount_due": 4201}
+ )
+ with pytest.raises(ActivationUnavailable, match="charge changed"):
+ await checkout.confirm_activation(
+ attempt.user_id,
+ attempt.id,
+ ActivationConfirmRequest(confirmed=True, terms_token=attempt.terms.token),
+ )
+ boundaries.save_confirmation.assert_not_awaited()
+ boundaries.stripe_call.assert_not_awaited()
+
+
+async def test_ownership_failure_does_not_reveal_attempt(attempt, boundaries):
+ boundaries.get_attempt.return_value = None
+ with pytest.raises(ActivationNotFound):
+ await checkout.get_activation("other-user", attempt.id)
+ boundaries.get_attempt.assert_awaited_once_with("other-user", attempt.id)
+ boundaries.owned_subscription.assert_not_awaited()
+
+
+async def test_network_uncertainty_is_processing_and_reuses_key(attempt, boundaries):
+ confirmed = attempt.model_copy(update={"confirmed_at": datetime.now(UTC)})
+ boundaries.get_attempt.return_value = confirmed
+ boundaries.stripe_call.side_effect = stripe.APIConnectionError("timeout")
+ body = ActivationConfirmRequest(confirmed=True, terms_token=attempt.terms.token)
+ for _ in range(2):
+ assert (
+ await checkout.confirm_activation(attempt.user_id, attempt.id, body)
+ ).status == "processing"
+ assert {
+ call.kwargs["idempotency_key"]
+ for call in boundaries.stripe_call.await_args_list
+ } == {f"pro-activation:{attempt.id}"}
+ boundaries.save_confirmation.assert_not_awaited()
+
+
+async def test_confirmed_get_never_resubmits_charge(attempt, boundaries):
+ boundaries.get_attempt.return_value = attempt.model_copy(
+ update={"confirmed_at": datetime.now(UTC)}
+ )
+ assert (
+ await checkout.get_activation(attempt.user_id, attempt.id)
+ ).status == "processing"
+ boundaries.stripe_call.assert_not_awaited()
+
+
+async def test_near_scheduled_boundary_never_mutates_trial(
+ attempt, boundaries, live_subscription
+):
+ live_subscription.trial_end = int(datetime.now(UTC).timestamp()) + 5
+ result = await checkout.confirm_activation(
+ attempt.user_id,
+ attempt.id,
+ ActivationConfirmRequest(confirmed=True, terms_token=attempt.terms.token),
+ )
+ assert result.status == "processing"
+ boundaries.stripe_call.assert_not_awaited()
+
+
[email protected]("ready", [False, True])
+async def test_paid_invoice_requires_authoritative_reset_completion(
+ attempt, boundaries, live_subscription, ready
+):
+ live_subscription.status = "active"
+ live_subscription.latest_invoice = billing.BillingInvoice(
+ id="in_paid", customer="cus_1", status="paid", amount_remaining=0
+ )
+ boundaries.reconcile_paid_activation.return_value = (
+ PaidActivationResult(
+ invoice_id="in_paid", usage_reset=True, activation_id="generation-1"
+ )
+ if ready
+ else None
+ )
+ response = await checkout.get_activation(attempt.user_id, attempt.id)
+ assert response.status == ("ready" if ready else "processing")
+ boundaries.stripe_call.assert_not_awaited()
+
+
+async def test_paid_database_failure_remains_processing(
+ attempt, boundaries, live_subscription
+):
+ live_subscription.status = "active"
+ live_subscription.latest_invoice = billing.BillingInvoice(
+ id="in_paid", customer="cus_1", status="paid"
+ )
+ boundaries.reconcile_paid_activation.side_effect = ConnectionError(
+ "database unavailable"
+ )
+ assert (
+ await checkout.get_activation(attempt.user_id, attempt.id)
+ ).status == "processing"
+ boundaries.stripe_call.assert_not_awaited()
+
+
+ "payment_status, expected",
+ [
+ ("requires_action", "action_required"),
+ ("requires_payment_method", "payment_required"),
+ ("processing", "processing"),
+ ],
+)
+async def test_payment_and_authentication_required_never_activate(
+ attempt, boundaries, live_subscription, payment_status, expected
+):
+ live_subscription.status = "past_due"
+ live_subscription.latest_invoice = billing.BillingInvoice(
+ id="in_open",
+ customer="cus_1",
+ status="open",
+ payment_intent="pi_1",
+ hosted_invoice_url="https://invoice.stripe.com/pay/in_open",
+ )
+ boundaries.stripe_call.return_value = SimpleNamespace(
+ customer="cus_1", status=payment_status
+ )
+ response = await checkout.get_activation(attempt.user_id, attempt.id)
+ assert response.status == expected
+ assert response.hosted_invoice_url == "https://invoice.stripe.com/pay/in_open"
+ boundaries.reconcile_paid_activation.assert_not_awaited()
+
+
+ "payment_status, expected",
+ [
+ ("requires_payment_method", "payment_required"),
+ ("requires_action", "action_required"),
+ ],
+)
+async def test_unpaid_conversion_keeps_the_trial_and_offers_its_invoice_page(
+ max_attempt, boundaries, live_subscription, payment_status, expected
+):
+ # A declined card or a bank check leaves Stripe's pending update
+ # unapplied: the subscription still trials on its old price, and the open
+ # invoice takes another card.
+ max_attempt.confirmed_at = datetime.now(UTC)
+ live_subscription.pending_update = {"expires_at": 1}
+ live_subscription.latest_invoice = billing.BillingInvoice(
+ id="in_pending",
+ customer="cus_1",
+ status="open",
+ payment_intent="pi_1",
+ hosted_invoice_url="https://invoice.stripe.com/pay/in_pending",
+ )
+ boundaries.stripe_call.return_value = SimpleNamespace(
+ customer="cus_1", status=payment_status
+ )
+ response = await checkout.get_activation(max_attempt.user_id, max_attempt.id)
+ assert live_subscription.status == "trialing"
+ assert response.status == expected
+ assert response.hosted_invoice_url == "https://invoice.stripe.com/pay/in_pending"
+ boundaries.reconcile_paid_activation.assert_not_awaited()
+
+
[email protected]("cost", [250000, 1000000])
+async def test_partially_used_and_exhausted_trials_keep_accepted_offer(
+ trial, live_subscription, monkeypatch, cost
+):
+ trial.cost_microdollars = cost
+ call = AsyncMock(
+ return_value={"customer": "cus_1", "currency": "usd", "amount_due": 4200}
+ )
+ monkeypatch.setattr(billing, "stripe_call", call)
+ terms = await billing.quote_terms(trial, live_subscription)
+ assert terms.accepted_offer_token == trial.offer.token
+ assert terms.renewal_unit_amount == trial.offer.unit_amount
+ assert terms.amount_due == 4200
+ assert trial.cost_microdollars == cost
+
+
+async def test_lock_exit_failure_after_charge_is_recoverable_processing(
+ attempt, boundaries, live_subscription, monkeypatch
+):
+ @asynccontextmanager
+ async def failed_lock_exit(user_id):
+ yield
+ raise ConnectionError("The checkout lock transaction expired after payment")
+
+ async def payment_succeeded(*args, **kwargs):
+ live_subscription.status = "active"
+ live_subscription.latest_invoice = billing.BillingInvoice(
+ id="in_paid", customer="cus_1", status="paid"
+ )
+
+ monkeypatch.setattr(checkout, "subscription_checkout_lock", failed_lock_exit)
+ boundaries.stripe_call.side_effect = payment_succeeded
+ boundaries.reconcile_paid_activation.return_value = PaidActivationResult(
+ invoice_id="in_paid", usage_reset=True, activation_id="generation-1"
+ )
+ response = await confirm_pro_activation(
+ attempt.id,
+ ActivationConfirmRequest(confirmed=True, terms_token=attempt.terms.token),
+ attempt.user_id,
+ )
+ assert response.status == "processing"
+ assert response.id == attempt.id
+ boundaries.stripe_call.assert_awaited_once()
+
+
+async def test_current_recovers_new_paid_signup_after_canceled_conversion(
+ attempt, boundaries, live_subscription, monkeypatch
+):
+ canceled = live_subscription.model_copy(update={"status": "canceled"})
+ paid = live_subscription.model_copy(
+ update={
+ "id": "sub_new",
+ "status": "active",
+ "latest_invoice": billing.BillingInvoice(
+ id="in_new", customer="cus_1", status="paid"
+ ),
+ }
+ )
+ boundaries.owned_subscription.side_effect = [canceled, paid]
+ boundaries.stripe_call.return_value = SimpleNamespace(data=[paid], has_more=False)
+ boundaries.reconcile_paid_activation.return_value = PaidActivationResult(
+ invoice_id="in_new", usage_reset=True, activation_id="generation-1"
+ )
+ monkeypatch.setattr(
+ checkout.User,
+ "prisma",
+ lambda: MagicMock(
+ find_unique_or_raise=AsyncMock(
+ return_value=SimpleNamespace(stripeCustomerId="cus_1")
+ )
+ ),
+ )
+ monkeypatch.setattr(
+ checkout, "activation_return_to", AsyncMock(return_value="/chat/new")
+ )
+ response = await checkout.current_activation(attempt.user_id)
+ assert response.status == "ready"
+ assert response.invoice_id == "in_new" and response.return_to == "/chat/new"
+ assert boundaries.stripe_call.await_count == 1
+ assert boundaries.stripe_call.await_args.args[0].__name__ == "list_async"
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_chosen_integration_test.py b/autogpt_platform/backend/backend/data/subscription_activation_chosen_integration_test.py
new file mode 100644
index 0000000000..78a9c97fe2
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_chosen_integration_test.py
@@ -0,0 +1,45 @@
+"""Upstream chosen-plan conversions use the same durable usage generation."""
+
+import os
+
+import pytest
+from prisma.models import PaidUsageActivation, SubscriptionTrial
+
+from backend.data import subscription_activation_integration_fixtures as fixtures
+
+activation_case = fixtures.activation_case
+pytestmark = pytest.mark.skipif(
+ os.environ.get("TRIAL_TEST_DATABASE") != "1",
+ reason="Requires disposable DB and Redis cluster",
+)
+
+
[email protected]("plan", ["PRO", "MAX"])
+async def test_chosen_conversion_preserves_trial_and_paid_costs_during_replay(
+ activation_case, plan
+):
+ case = activation_case
+ trial = await case.add_trial(73, tier="BASIC")
+ case.select_plan(plan)
+ case.subscription["metadata"].update(
+ trial_conversion_price_id=f"price_{plan.lower()}",
+ trial_conversion_tier=plan,
+ )
+
+ assert await case.activate()
+ activation = await PaidUsageActivation.prisma().find_unique_or_raise(
+ where={"userId": case.user_id}
+ )
+ assert activation.readyAt is not None
+ assert await case.counters(activation.id) == (0, 0)
+ await case.add_cost(activation.id, 29)
+ assert await case.activate()
+ assert await case.counters(activation.id) == (29, 29)
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == 1
+ saved = await SubscriptionTrial.prisma().find_unique_or_raise(
+ where={"id": trial.id}
+ )
+ assert saved.convertedAt and saved.stripeConversionInvoiceId == case.invoice["id"]
+ assert saved.consumedAt == trial.consumed_at
+ assert saved.costMicrodollars == 73
+ assert saved.offer == trial.offer.model_dump(mode="json")
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_chosen_target_test.py b/autogpt_platform/backend/backend/data/subscription_activation_chosen_target_test.py
new file mode 100644
index 0000000000..e0fb838c0f
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_chosen_target_test.py
@@ -0,0 +1,126 @@
+"""Existing cancel-pending conversions retain their owned, settled target."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from prisma.enums import SubscriptionTier
+
+from backend.data import subscription_activation_stripe as billing
+from backend.data import subscription_activation_target as target
+from backend.data import subscription_trial_fixtures as fixtures
+
+trial = fixtures.trial
+subscription = fixtures.subscription
+
+
+def chosen(trial, subscription, monkeypatch):
+ trial.subscription_id = subscription["id"]
+ subscription["status"] = "active"
+ subscription["items"]["data"][0]["price"]["id"] = "price_selected"
+ subscription["metadata"].update(
+ trial_conversion_price_id="price_selected", trial_conversion_tier="MAX"
+ )
+ monkeypatch.setattr(target, "query_raw_with_schema", AsyncMock(return_value=[]))
+ return subscription
+
+
[email protected]("plan", ["PRO", "MAX"])
+async def test_chosen_paid_target_preserves_retired_selected_price(trial, chosen, plan):
+ chosen["metadata"]["trial_conversion_tier"] = plan
+ assert await target.accepted_conversion_target(trial, chosen, MagicMock()) == (
+ SubscriptionTier(plan),
+ "price_selected",
+ )
+ target.query_raw_with_schema.assert_not_awaited()
+
+
+ "field,value",
+ [
+ ("user_id", "foreign"),
+ ("trial_enrollment_id", "foreign"),
+ ("trial_checkout_attempt", "1"),
+ ("trial_conversion_price_id", "price_other"),
+ ("trial_conversion_tier", "BASIC"),
+ ("trial_conversion_tier", "BUSINESS"),
+ ("trial_conversion_tier", "ENTERPRISE"),
+ ("trial_conversion_tier", "max"),
+ ("trial_conversion_tier", ""),
+ ("pro_activation_attempt_id", "unknown-confirmation"),
+ ],
+)
+async def test_chosen_metadata_cannot_bypass_ownership_or_confirmation(
+ trial, chosen, field, value
+):
+ chosen["metadata"][field] = value
+ assert await target.accepted_conversion_target(trial, chosen, MagicMock()) is None
+
+
[email protected]("status", ["trialing", "incomplete", "past_due", "canceled"])
+async def test_pending_chosen_target_does_not_authorize_activation(
+ trial, chosen, status
+):
+ chosen["status"] = status
+ assert await target.accepted_conversion_target(trial, chosen, MagicMock()) is None
+
+
[email protected]("quantity", [0, 2, None])
+async def test_chosen_target_requires_the_owned_single_item(trial, chosen, quantity):
+ chosen["items"]["data"][0]["quantity"] = quantity
+ assert await target.accepted_conversion_target(trial, chosen, MagicMock()) is None
+
+
[email protected]("plan", ["PRO", "MAX"])
+async def test_polling_recognizes_owned_chosen_price_after_catalog_repricing(
+ trial, billable_chosen, plan
+):
+ billable_chosen.metadata["trial_conversion_tier"] = plan
+ assert (
+ await billing.is_paid_activation_subscription(trial.user_id, billable_chosen)
+ is True
+ )
+
+
+ "field,value",
+ [
+ ("user_id", "foreign"),
+ ("trial_enrollment_id", "foreign"),
+ ("trial_checkout_attempt", "1"),
+ ("trial_conversion_price_id", "price_other"),
+ ("trial_conversion_tier", "BASIC"),
+ ("pro_activation_attempt_id", "unknown-confirmation"),
+ ],
+)
+async def test_polling_cannot_recognize_foreign_or_unconfirmed_chosen_plan(
+ trial, billable_chosen, field, value
+):
+ billable_chosen.metadata[field] = value
+ assert (
+ await billing.is_paid_activation_subscription(trial.user_id, billable_chosen)
+ is None
+ )
+
+
+def billable_chosen(trial, chosen, monkeypatch):
+ chosen["items"]["data"][0]["price"].update(
+ unit_amount=10000,
+ currency="usd",
+ recurring={"interval": "month", "interval_count": 1},
+ )
+ subscription = billing.BillingSubscription.model_validate(chosen)
+ monkeypatch.setattr(
+ billing, "get_subscription_trial", AsyncMock(return_value=trial)
+ )
+ monkeypatch.setattr(
+ billing.credit, "build_price_to_tier_map", AsyncMock(return_value={})
+ )
+ return subscription
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_confirmation_integration_test.py b/autogpt_platform/backend/backend/data/subscription_activation_confirmation_integration_test.py
new file mode 100644
index 0000000000..190d4963e8
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_confirmation_integration_test.py
@@ -0,0 +1,207 @@
+"""An explicit Max choice binds payment and reset to durable confirmed terms."""
+
+import os
+from copy import deepcopy
+from datetime import UTC, datetime, timedelta
+from functools import partial
+
+import pytest
+import stripe
+from prisma.enums import SubscriptionTier
+from prisma.models import PaidUsageActivation, SubscriptionTrial, User
+
+from backend.data import credit
+from backend.data import subscription_activation_checkout as checkout
+from backend.data import subscription_activation_integration_fixtures as fixtures
+from backend.data.pro_activation import get_usage_activation_state
+from backend.data.subscription_activation import reconcile_paid_activation
+from backend.data.subscription_activation_attempt import get_attempt
+from backend.data.subscription_activation_models import ActivationConfirmRequest
+
+activation_case = fixtures.activation_case
+pytestmark = pytest.mark.skipif(
+ os.environ.get("TRIAL_TEST_DATABASE") != "1",
+ reason="Requires disposable DB and Redis cluster",
+)
+
+
[email protected]("trial_cost", [25, 100])
[email protected]("source_tier", ["PRO", "BASIC", "BUSINESS"])
+async def test_confirmed_trial_to_max_uses_confirmed_price_and_one_reset(
+ activation_case, mocker, trial_cost, source_tier
+):
+ case = activation_case
+ trial = await prepare_trial_checkout(case, trial_cost, source_tier)
+ max_price = {
+ "id": "price_max",
+ "unit_amount": 6000,
+ "currency": "usd",
+ "recurring": {"interval": "month", "interval_count": 1},
+ }
+ mock_billing_boundaries(case, mocker, max_price)
+ mutation = mocker.patch(
+ "stripe.Subscription.modify_async",
+ side_effect=partial(settle_conversion, case, max_price),
+ )
+
+ preview = await checkout.preview_activation(case.user_id, "/chat/kept", "MAX")
+ assert preview.status == "confirmation_required" and preview.terms
+ assert preview.terms.plan == "MAX" and preview.terms.price_id == "price_max"
+ assert preview.terms.amount_due == 6000 and not preview.usage_reset
+ mutation.assert_not_called()
+ assert await case.counters(None) == (trial_cost, trial_cost)
+ assert preview.id
+ body = ActivationConfirmRequest(confirmed=True, terms_token=preview.terms.token)
+ result = await checkout.confirm_activation(case.user_id, preview.id, body)
+ assert result.status == "ready" and result.usage_reset and result.activation_id
+ assert result.return_to == "/chat/kept"
+ assert await case.counters(result.activation_id) == (0, 0)
+ await case.add_cost(result.activation_id, 197)
+ assert await checkout.get_activation(case.user_id, preview.id) == result
+ assert await checkout.confirm_activation(case.user_id, preview.id, body) == result
+ assert await case.counters(result.activation_id) == (197, 197)
+ mutation.assert_awaited_once()
+ row = await SubscriptionTrial.prisma().find_unique_or_raise(where={"id": trial.id})
+ assert row.convertedAt and row.costMicrodollars == trial_cost
+ assert row.offer == trial.offer.model_dump(mode="json")
+ assert row.consumedAt == trial.consumed_at
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == 1
+ await assert_retired_max_recovery(case, mocker, result.activation_id)
+
+
+async def assert_retired_max_recovery(case, mocker, generation):
+ mocker.patch.object(credit, "build_price_to_tier_map", return_value={})
+ for renewal in (False, True):
+ if renewal:
+ invoice = deepcopy(case.invoices[-1])
+ invoice.update(
+ id=f"renewal_{invoice['id']}", billing_reason="subscription_cycle"
+ )
+ invoice["created"] += 30 * 86400
+ invoice["status_transitions"]["paid_at"] += 30 * 86400
+ invoice["lines"]["data"][0]["period"]["start"] += 30 * 86400
+ invoice["lines"]["data"][0]["period"]["end"] += 30 * 86400
+ case.invoices.append(invoice)
+ case.subscription["latest_invoice"] = invoice["id"]
+ await User.prisma().update(
+ where={"id": case.user_id}, data={"subscriptionTier": "NO_TIER"}
+ )
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+ assert result is not None
+ if renewal:
+ assert not result.usage_reset and result.activation_id is None
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.tier == "MAX" and state.generation == generation
+ assert await case.counters(generation) == (197, 197)
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == 1
+
+
+async def test_unpaid_confirmed_max_conversion_keeps_trial_usage(
+ activation_case, mocker
+):
+ case = activation_case
+ trial = await prepare_trial_checkout(case, 100)
+ max_price = {
+ "id": "price_max",
+ "unit_amount": 6000,
+ "currency": "usd",
+ "recurring": {"interval": "month", "interval_count": 1},
+ }
+ mock_billing_boundaries(case, mocker, max_price)
+ mutation = mocker.patch(
+ "stripe.Subscription.modify_async",
+ side_effect=partial(settle_conversion, case, max_price, invoice_status="open"),
+ )
+ preview = await checkout.preview_activation(case.user_id, "/chat/kept", "MAX")
+ assert preview.id and preview.terms
+ body = ActivationConfirmRequest(confirmed=True, terms_token=preview.terms.token)
+
+ response = await checkout.confirm_activation(case.user_id, preview.id, body)
+
+ assert response.status == "payment_required" and not response.usage_reset
+ assert response.activation_id is None
+ assert await checkout.get_activation(case.user_id, preview.id) == response
+ assert (await get_usage_activation_state(case.user_id)).generation is None
+ assert await case.counters(None) == (100, 100)
+ row = await SubscriptionTrial.prisma().find_unique_or_raise(where={"id": trial.id})
+ assert row.convertedAt is None and row.costMicrodollars == 100
+ assert row.offer == trial.offer.model_dump(mode="json")
+ mutation.assert_awaited_once()
+
+
+async def prepare_trial_checkout(case, cost, tier="PRO"):
+ trial = await case.add_trial(cost, tier)
+ ends_at = datetime.now(UTC) + timedelta(days=4)
+ await SubscriptionTrial.prisma().update(
+ where={"id": trial.id}, data={"endsAt": ends_at}
+ )
+ case.subscription.update(status="trialing", trial_end=int(ends_at.timestamp()))
+ case.subscription["items"]["data"][0].update(id="si_owned")
+ case.subscription["items"]["data"][0]["price"].update(
+ unit_amount=2000,
+ currency="usd",
+ recurring={"interval": "month", "interval_count": 1},
+ )
+ case.invoice["amount_paid"] = 0
+ case.invoice["lines"]["data"][0]["amount"] = 0
+ await case.add_cost(None, cost)
+ return trial
+
+
+def mock_billing_boundaries(case, mocker, max_price):
+ mocker.patch.object(
+ credit,
+ "build_price_to_tier_map",
+ return_value={
+ "price_pro": SubscriptionTier.PRO,
+ "price_max": SubscriptionTier.MAX,
+ },
+ )
+ mocker.patch.object(credit, "get_subscription_price_id", return_value="price_max")
+ mocker.patch.object(credit, "schedule_posthog_lifecycle_sync")
+ mocker.patch(
+ "stripe.Price.retrieve_async",
+ return_value=stripe.Price.construct_from(max_price, None),
+ )
+ mocker.patch(
+ "stripe.Invoice.create_preview_async",
+ return_value=stripe.Invoice.construct_from(
+ {
+ "customer": case.subscription["customer"],
+ "currency": "usd",
+ "amount_due": 6000,
+ },
+ None,
+ ),
+ )
+
+
+async def settle_conversion(
+ case, max_price, subscription_id, *, invoice_status="paid", **kwargs
+):
+ attempt = await get_attempt(case.user_id)
+ assert attempt and attempt.confirmed_at and attempt.terms.plan == "MAX"
+ assert subscription_id == case.subscription["id"]
+ assert kwargs["items"] == [{"id": "si_owned", "price": "price_max", "quantity": 1}]
+ assert kwargs["metadata"]["pro_activation_attempt_id"] == attempt.id
+ assert kwargs["idempotency_key"] == f"pro-activation:{attempt.id}"
+ now = int(datetime.now(UTC).timestamp())
+ case.subscription["items"]["data"][0]["price"] = max_price
+ case.subscription.update(status="active", trial_end=now)
+ case.subscription["metadata"].update(kwargs["metadata"])
+ invoice = deepcopy(case.invoice)
+ invoice.update(
+ id=f"paid_{case.invoice['id']}",
+ created=now,
+ status=invoice_status,
+ amount_paid=6000 if invoice_status == "paid" else 0,
+ amount_remaining=0 if invoice_status == "paid" else 6000,
+ payments={"data": [], "has_more": False},
+ )
+ invoice["status_transitions"]["paid_at"] = now if invoice_status == "paid" else None
+ invoice["lines"]["data"][0].update(
+ amount=6000, price=max_price, period={"start": now, "end": now + 30 * 86400}
+ )
+ case.invoices.append(invoice)
+ case.subscription["latest_invoice"] = invoice["id"]
+ return stripe.Subscription.construct_from(case.subscription, None)
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_events.py b/autogpt_platform/backend/backend/data/subscription_activation_events.py
new file mode 100644
index 0000000000..eb71d16e60
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_events.py
@@ -0,0 +1,37 @@
+"""A crashed webhook claim must not suppress authoritative activation recovery."""
+
+import stripe
+
+from backend.data import credit
+from backend.data.stripe_client import stripe_call
+from backend.data.subscription_activation_evidence import invoice_subscription
+
+
+async def recover_claimed_billing_event(event_type: str, payload: dict) -> None:
+ """Only reconcile existing objects; never create checkout or retry collection."""
+ if event_type.startswith("customer.subscription."):
+ await credit.sync_subscription_from_stripe(payload)
+ return
+ if event_type in (
+ "checkout.session.completed",
+ "checkout.session.async_payment_succeeded",
+ ):
+ await credit.sync_tier_from_checkout_session(payload)
+ return
+ if event_type in ("invoice_payment.paid", "invoice_payment.payment_failed"):
+ invoice_id = payload.get("invoice")
+ if not invoice_id:
+ return
+ payload = dict(await stripe_call(stripe.Invoice.retrieve_async, invoice_id))
+ elif event_type not in (
+ "invoice.paid",
+ "invoice.payment_succeeded",
+ "invoice.payment_failed",
+ ):
+ return
+ subscription_id = invoice_subscription(payload)
+ if subscription_id:
+ subscription = await stripe_call(
+ stripe.Subscription.retrieve_async, subscription_id
+ )
+ await credit.sync_subscription_from_stripe(dict(subscription))
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_evidence.py b/autogpt_platform/backend/backend/data/subscription_activation_evidence.py
new file mode 100644
index 0000000000..ba676181a5
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_evidence.py
@@ -0,0 +1,170 @@
+"""Validate settled invoices independently of cash collected (credits count)."""
+
+import stripe
+from pydantic import BaseModel, RootModel, TypeAdapter
+
+from backend.data.stripe_client import stripe_call, stripe_list_items
+
+
+class InvoiceId(RootModel[str]):
+ @property
+ def invoice_id(self) -> str:
+ return self.root
+
+
+class ExpandedInvoiceId(BaseModel):
+ id: str
+
+ @property
+ def invoice_id(self) -> str:
+ return self.id
+
+
+INVOICE_REFERENCE = TypeAdapter(InvoiceId | ExpandedInvoiceId)
+
+
+def qualifying_invoice(
+ invoice: dict,
+ *,
+ customer_id: str,
+ subscription_id: str,
+ price_id: str,
+ trial_end: int | None,
+) -> bool:
+ if not settled_recurring_invoice(invoice):
+ return False
+ if (
+ invoice.get("customer") != customer_id
+ or invoice_subscription(invoice) != subscription_id
+ ):
+ return False
+ if trial_end is None:
+ if invoice.get("billing_reason") != "subscription_create":
+ return False
+ elif (
+ invoice.get("billing_reason")
+ not in ("subscription_cycle", "subscription_update")
+ or invoice.get("created", 0) < trial_end
+ ):
+ return False
+ for line in invoice.get("lines", {}).get("data", []):
+ period = line.get("period", {})
+ if (
+ _paid_recurring_line(line, subscription_id)
+ and line_price(line) == price_id
+ and line.get("quantity") == 1
+ and not line.get("proration", False)
+ and period.get("end", 0) > period.get("start", 0)
+ and (trial_end is None or period.get("start") == trial_end)
+ ):
+ return True
+ return False
+
+
+def settled_recurring_invoice(invoice: dict) -> bool:
+ return _settled_subscription_invoice(invoice) and any(
+ _paid_recurring_line(line, invoice_subscription(invoice))
+ for line in invoice.get("lines", {}).get("data", [])
+ )
+
+
+def settled_proration_invoice(invoice: dict, price_id: str | None) -> bool:
+ """Current paid access evidence; never evidence of an initial usage reset."""
+ return bool(
+ price_id
+ and invoice.get("billing_reason") == "subscription_update"
+ and _settled_subscription_invoice(invoice)
+ and any(
+ _paid_recurring_line(
+ line, invoice_subscription(invoice), allow_proration=True
+ )
+ and line_price(line) == price_id
+ and line.get("quantity") == 1
+ for line in invoice.get("lines", {}).get("data", [])
+ )
+ )
+
+
+def _settled_subscription_invoice(invoice: dict) -> bool:
+ return bool(
+ invoice.get("status") == "paid"
+ and invoice.get("amount_remaining") == 0
+ and (invoice.get("status_transitions") or {}).get("paid_at")
+ and invoice_subscription(invoice)
+ and invoice.get("billing_reason")
+ in ("subscription_create", "subscription_cycle", "subscription_update")
+ and not invoice.get("lines", {}).get("has_more", False)
+ )
+
+
+def _paid_recurring_line(
+ line: dict, subscription_id: str | None, *, allow_proration: bool = False
+) -> bool:
+ parent = line.get("parent") or {}
+ details = parent.get("subscription_item_details") or {}
+ recurring = (
+ line.get("type") == "subscription"
+ or parent.get("type") == "subscription_item_details"
+ )
+ owner = line.get("subscription") or details.get("subscription")
+ period = line.get("period") or {}
+ return bool(
+ recurring
+ and owner == subscription_id
+ and subscription_id
+ and (
+ allow_proration
+ or not line.get("proration", details.get("proration", False))
+ )
+ and period.get("end", 0) > period.get("start", 0)
+ and _priced_service(line)
+ )
+
+
+def _priced_service(line: dict) -> bool:
+ base = line.get("amount_excluding_tax") or line.get("amount", 0)
+ discounts = sum(
+ item.get("amount", 0) for item in line.get("discount_amounts") or []
+ )
+ return base > 0 or discounts > 0
+
+
+def invoice_subscription(invoice: dict) -> str | None:
+ return invoice.get("subscription") or (
+ (invoice.get("parent") or {}).get("subscription_details") or {}
+ ).get("subscription")
+
+
+def line_price(line: dict) -> str | None:
+ return (line.get("price") or {}).get("id") or (
+ (line.get("pricing") or {}).get("price_details") or {}
+ ).get("price")
+
+
+async def first_settled_invoice(customer_id: str) -> dict | None:
+ """Inspect all pages so returning subscribers never receive another reset."""
+ invoices = await stripe_call(
+ stripe.Invoice.list_async, customer=customer_id, status="paid", limit=100
+ )
+ first: dict | None = None
+ async for raw in stripe_list_items(invoices):
+ invoice = dict(raw)
+ if not raw.id:
+ raise ValueError("Stripe invoice has no durable identity")
+ if invoice.get("lines", {}).get("has_more"):
+ lines = await stripe_call(
+ stripe.Invoice.list_lines_async, raw.id, limit=100
+ )
+ invoice["lines"] = {
+ "data": [dict(line) async for line in stripe_list_items(lines)],
+ "has_more": False,
+ }
+ if not settled_recurring_invoice(invoice):
+ continue
+ if first is None or _settled_order(invoice) < _settled_order(first):
+ first = invoice
+ return first
+
+
+def _settled_order(invoice: dict) -> tuple[int, int, str]:
+ return (invoice["status_transitions"]["paid_at"], invoice["created"], invoice["id"])
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_evidence_test.py b/autogpt_platform/backend/backend/data/subscription_activation_evidence_test.py
new file mode 100644
index 0000000000..014e92993a
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_evidence_test.py
@@ -0,0 +1,145 @@
+from copy import deepcopy
+
+import pytest
+
+from backend.data import subscription_activation_evidence as evidence
+
+
+def invoice():
+ return {
+ "id": "in_paid",
+ "status": "paid",
+ "amount_remaining": 0,
+ "amount_paid": 5000,
+ "created": 200,
+ "status_transitions": {"paid_at": 200},
+ "customer": "cus",
+ "subscription": "sub",
+ "billing_reason": "subscription_cycle",
+ "lines": {
+ "data": [
+ {
+ "type": "subscription",
+ "subscription": "sub",
+ "amount": 5000,
+ "quantity": 1,
+ "price": {"id": "price"},
+ "period": {"start": 200, "end": 300},
+ }
+ ],
+ "has_more": False,
+ },
+ }
+
+
+def qualifies(value, trial_end=200):
+ return evidence.qualifying_invoice(
+ value,
+ customer_id="cus",
+ subscription_id="sub",
+ price_id="price",
+ trial_end=trial_end,
+ )
+
+
+def test_zero_dollar_trial_setup_is_not_paid_activation():
+ value = invoice()
+ value.update(billing_reason="subscription_create", created=100, amount_paid=0)
+ value["lines"]["data"][0].update(amount=0, period={"start": 100, "end": 200})
+ assert not qualifies(value)
+
+
[email protected]("amount_paid", [0, 2000, 5000])
+def test_settled_credits_and_discounts_are_valid(amount_paid):
+ value = invoice()
+ value["amount_paid"] = amount_paid
+ assert qualifies(value)
+
+
+ "change",
+ [
+ {"status": "open"},
+ {"status": "draft"},
+ {"status": "void"},
+ {"amount_remaining": 1},
+ {"customer": "other"},
+ {"subscription": "other"},
+ {"status_transitions": {"paid_at": None}},
+ {"created": 199},
+ {"billing_reason": "manual"},
+ ],
+)
+def test_unsettled_or_unowned_invoice_never_activates(change):
+ value = invoice()
+ value.update(change)
+ assert not qualifies(value)
+
+
+def test_initial_signup_requires_creation_invoice():
+ value = invoice()
+ assert not qualifies(value, trial_end=None)
+ value["billing_reason"] = "subscription_create"
+ assert qualifies(value, trial_end=None)
+
+
+def test_later_trial_renewal_cannot_be_initial_activation():
+ value = invoice()
+ value["lines"]["data"][0]["period"] = {"start": 300, "end": 400}
+ assert not qualifies(value)
+
+
+def test_basil_invoice_and_line_identity():
+ value = invoice()
+ del value["subscription"]
+ value["parent"] = {"subscription_details": {"subscription": "sub"}}
+ line = value["lines"]["data"][0]
+ del line["price"]
+ line["pricing"] = {"price_details": {"price": "price"}}
+ assert qualifies(value)
+
+
+ "change",
+ [
+ {"quantity": 2},
+ {"price": {"id": "other"}},
+ {"proration": True},
+ {"period": {"start": 199, "end": 300}},
+ ],
+)
+def test_foreign_plan_or_period_is_not_proof(change):
+ value = deepcopy(invoice())
+ value["lines"]["data"][0].update(change)
+ assert not qualifies(value)
+
+
+def test_trial_with_one_time_fee_is_not_paid_recurring_service():
+ value = invoice()
+ value["lines"]["data"][0]["amount"] = 0
+ value["lines"]["data"].append(
+ {"amount": 1000, "type": "invoiceitem", "period": {"start": 200, "end": 300}}
+ )
+ assert not evidence.settled_recurring_invoice(value)
+ assert not qualifies(value)
+
+
+def test_discounted_net_zero_recurring_line_counts_as_settled():
+ value = invoice()
+ value["amount_paid"] = 0
+ value["lines"]["data"][0].update(amount=0, discount_amounts=[{"amount": 5000}])
+ assert qualifies(value)
+
+
+def test_modern_subscription_line_binding():
+ value = invoice()
+ line = value["lines"]["data"][0]
+ del line["type"]
+ del line["subscription"]
+ line["parent"] = {
+ "type": "subscription_item_details",
+ "subscription_item_details": {"subscription": "sub", "proration": False},
+ }
+ assert qualifies(value)
+ line["parent"]["subscription_item_details"]["subscription"] = "other"
+ assert not qualifies(value)
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_integration_fixtures.py b/autogpt_platform/backend/backend/data/subscription_activation_integration_fixtures.py
new file mode 100644
index 0000000000..2393a55a16
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_integration_fixtures.py
@@ -0,0 +1,264 @@
+"""Disposable PostgreSQL + real Redis Cluster activation test fixtures."""
+
+import os
+from copy import deepcopy
+from datetime import UTC, datetime, timedelta
+from typing import Literal
+from urllib.parse import urlparse
+from uuid import uuid4
+
+import pytest_asyncio
+import stripe
+from prisma.enums import SubscriptionTier
+from prisma.models import SubscriptionTrialClaim, User
+from pydantic import BaseModel, ConfigDict
+
+from backend.copilot.usage_activation import usage_keys
+from backend.data import db
+from backend.data.redis_client import (
+ AsyncRedisClient,
+ disconnect_async,
+ get_redis_async,
+)
+from backend.data.subscription_activation import (
+ lock_activation_user,
+ publish_initial_pro_activation,
+)
+from backend.data.subscription_trial import TrialState
+from backend.data.subscription_trial_config import AcceptedTrialOffer
+from backend.util.json import SafeJson
+
+
+class ActivationCase(BaseModel):
+ model_config = ConfigDict(arbitrary_types_allowed=True)
+
+ user_id: str
+ subscription: dict
+ invoices: list[dict]
+ redis: AsyncRedisClient
+
+ @property
+ def invoice(self) -> dict:
+ return self.invoices[0]
+
+ async def activate(self, *, abort: bool = False) -> bool:
+ async with db.transaction() as tx:
+ user = await lock_activation_user(self.user_id, tx)
+ row = await tx.subscriptiontrial.find_unique(where={"userId": user.id})
+ allowed = await publish_initial_pro_activation(
+ user,
+ self.subscription,
+ self.subscription["items"]["data"][0]["price"]["id"],
+ tx,
+ TrialState.from_db(row) if row else None,
+ )
+ if allowed:
+ await tx.user.update(
+ where={"id": user.id},
+ data={
+ "subscriptionTier": (
+ "MAX"
+ if self.subscription["items"]["data"][0]["price"]["id"]
+ == "price_max"
+ else "PRO"
+ )
+ },
+ )
+ if abort:
+ await tx.execute_raw("SELECT 1 / 0")
+ return allowed
+
+ def select_plan(self, tier: Literal["BASIC", "PRO", "MAX", "BUSINESS"]) -> None:
+ price = f"price_{tier.lower()}"
+ self.subscription["items"]["data"][0]["price"]["id"] = price
+ self.invoice["lines"]["data"][0]["price"]["id"] = price
+
+ async def add_trial(
+ self, cost: int, tier: Literal["BASIC", "PRO", "MAX", "BUSINESS"] = "PRO"
+ ) -> TrialState:
+ self.select_plan(tier)
+ now = datetime.now(UTC)
+ end = datetime.fromtimestamp(self.invoice["created"], UTC)
+ offer = AcceptedTrialOffer(
+ version="activation-integration-v1",
+ new_users_from=now - timedelta(days=9),
+ duration_days=7,
+ tier=tier,
+ billing_cycle="monthly",
+ daily_cost_limit=100,
+ weekly_cost_limit=100,
+ total_cost_limit=100,
+ onboarding_credit_amount=300,
+ price_id=f"price_{tier.lower()}",
+ unit_amount=2000,
+ currency="usd",
+ )
+ row = await db.prisma.subscriptiontrial.create(
+ data={
+ "userId": self.user_id,
+ "stripeCustomerId": self.subscription["customer"],
+ "stripeSubscriptionId": self.subscription["id"],
+ "offer": SafeJson(offer.model_dump(mode="json")),
+ "checkoutSuccessUrl": "https://example.com/chat?thread=kept",
+ "checkoutCancelUrl": "https://example.com/chat?thread=kept",
+ "consumedAt": now - timedelta(days=7),
+ "startedAt": now - timedelta(days=7),
+ "endsAt": end,
+ "cardVerifiedAt": now - timedelta(days=7),
+ "status": "trialing",
+ "costMicrodollars": cost,
+ }
+ )
+ await User.prisma().update(
+ where={"id": self.user_id}, data={"subscriptionTier": "TRIAL"}
+ )
+ self.subscription["trial_end"] = int(end.timestamp())
+ assert row.startedAt is not None
+ self.subscription["trial_start"] = int(row.startedAt.timestamp())
+ self.subscription["metadata"].update(
+ {"trial_enrollment_id": row.id, "trial_checkout_attempt": "0"}
+ )
+ self.subscription["default_payment_method"] = {
+ "id": "pm_test",
+ "type": "card",
+ "card": {
+ "exp_month": 12,
+ "exp_year": 2099,
+ "fingerprint": f"fp_{self.user_id}",
+ },
+ }
+ self.invoice["billing_reason"] = "subscription_cycle"
+ self.invoice["lines"]["data"][0]["period"]["start"] = int(end.timestamp())
+ return TrialState.from_db(row)
+
+ async def counters(self, generation: str | None) -> tuple[int, int]:
+ keys = usage_keys(self.user_id, generation, datetime.now(UTC))
+ values = [int(await self.redis.get(key) or 0) for key in keys]
+ return values[0], values[1]
+
+ async def add_cost(self, generation: str | None, cost: int) -> None:
+ for key in usage_keys(self.user_id, generation, datetime.now(UTC)):
+ value = int(await self.redis.get(key) or 0) + cost
+ await self.redis.set(key, value)
+
+
+@pytest_asyncio.fixture
+async def activation_case(mocker):
+ target = urlparse(db.DATABASE_URL)
+ local = (target.hostname, target.port, target.path) == (
+ "127.0.0.1",
+ 15432,
+ "/trial_test",
+ )
+ ci = (
+ os.environ.get("GITHUB_ACTIONS") == "true"
+ and (target.hostname, target.port) == ("localhost", 5432)
+ and target.path in ("/postgres", "/ci_copilot")
+ )
+ assert (
+ local or ci
+ ), "Requires the explicitly selected disposable activation database"
+ owns_connection = not db.is_connected()
+ await db.connect()
+ user_id = str(uuid4())
+ customer_id, subscription_id, invoice_id = (
+ f"{prefix}_{user_id}" for prefix in ("cus", "sub", "in")
+ )
+ await User.prisma().create(
+ data={
+ "id": user_id,
+ "email": f"{user_id}@example.com",
+ "stripeCustomerId": customer_id,
+ "subscriptionTier": SubscriptionTier.NO_TIER,
+ }
+ )
+ now = int(datetime.now(UTC).timestamp())
+ invoice = {
+ "id": invoice_id,
+ "object": "invoice",
+ "customer": customer_id,
+ "subscription": subscription_id,
+ "status": "paid",
+ "amount_remaining": 0,
+ "amount_paid": 2000,
+ "created": now,
+ "status_transitions": {"paid_at": now},
+ "billing_reason": "subscription_create",
+ "lines": {
+ "has_more": False,
+ "data": [
+ {
+ "id": f"il_{user_id}",
+ "object": "line_item",
+ "type": "subscription",
+ "subscription": subscription_id,
+ "amount": 2000,
+ "price": {"id": "price_pro"},
+ "quantity": 1,
+ "proration": False,
+ "period": {"start": now, "end": now + 30 * 86400},
+ }
+ ],
+ },
+ }
+ case = ActivationCase(
+ user_id=user_id,
+ invoices=[invoice],
+ redis=await get_redis_async(),
+ subscription={
+ "id": subscription_id,
+ "object": "subscription",
+ "customer": customer_id,
+ "status": "active",
+ "metadata": {"user_id": user_id},
+ "latest_invoice": invoice_id,
+ "trial_end": None,
+ "items": {"data": [{"quantity": 1, "price": {"id": "price_pro"}}]},
+ },
+ )
+
+ async def retrieve_invoice(invoice_id, **kwargs):
+ return stripe.Invoice.construct_from(
+ next(i for i in case.invoices if i["id"] == invoice_id), None
+ )
+
+ async def list_invoices(**kwargs):
+ return stripe.ListObject.construct_from(
+ {"object": "list", "data": case.invoices, "has_more": False}, None
+ )
+
+ async def retrieve_subscription(subscription_id, **kwargs):
+ assert subscription_id == case.subscription["id"]
+ data = deepcopy(case.subscription)
+ if "latest_invoice" in kwargs.get("expand", []):
+ data["latest_invoice"] = next(
+ i for i in case.invoices if i["id"] == data["latest_invoice"]
+ )
+ return stripe.Subscription.construct_from(data, None)
+
+ async def list_subscriptions(**kwargs):
+ return stripe.ListObject.construct_from(
+ {"object": "list", "data": [], "has_more": False}, None
+ )
+
+ mocker.patch("stripe.Invoice.retrieve_async", side_effect=retrieve_invoice)
+ mocker.patch("stripe.Invoice.list_async", side_effect=list_invoices)
+ mocker.patch(
+ "stripe.Subscription.retrieve_async", side_effect=retrieve_subscription
+ )
+ mocker.patch("stripe.Subscription.list_async", side_effect=list_subscriptions)
+ try:
+ yield case
+ finally:
+ await db.prisma.credittransaction.delete_many(where={"userId": user_id})
+ trial = await db.prisma.subscriptiontrial.find_unique(where={"userId": user_id})
+ if trial:
+ await SubscriptionTrialClaim.prisma().delete_many(
+ where={"trialId": trial.id}
+ )
+ await User.prisma().delete_many(where={"id": user_id})
+ async for key in case.redis.scan_iter(match=f"*{user_id}*"):
+ await case.redis.delete(key)
+ await disconnect_async()
+ if owns_connection:
+ await db.disconnect()
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_integration_test.py b/autogpt_platform/backend/backend/data/subscription_activation_integration_test.py
new file mode 100644
index 0000000000..01dabf6dd8
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_integration_test.py
@@ -0,0 +1,304 @@
+"""Activation atomicity and replay safety on PostgreSQL and Redis Cluster."""
+
+import asyncio
+import os
+from copy import deepcopy
+from datetime import UTC, datetime, timedelta
+from uuid import NAMESPACE_URL, uuid5
+
+import pytest
+from prisma.enums import SubscriptionTier
+from prisma.errors import RawQueryError
+from prisma.models import PaidUsageActivation, SubscriptionTrial, User
+from redis.exceptions import ResponseError
+
+from backend.copilot.usage_activation import usage_keys
+from backend.data import db
+from backend.data import subscription_activation_integration_fixtures as fixtures
+from backend.data.credit import set_subscription_tier
+from backend.data.pro_activation import get_usage_activation_state
+from backend.data.subscription_trial import record_subscription_trial_cost
+
+activation_case = fixtures.activation_case
+pytestmark = pytest.mark.skipif(
+ os.environ.get("TRIAL_TEST_DATABASE") != "1",
+ reason="Requires disposable DB and Redis cluster",
+)
+
+
[email protected]("tier", ["PRO", "MAX"])
+async def test_initial_signup_preserves_calendar_usage(activation_case, tier):
+ case = activation_case
+ case.select_plan(tier)
+ await case.add_cost(None, 900)
+ assert await case.activate()
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.tier == tier and state.generation is None
+ assert await case.counters(None) == (900, 900)
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == 0
+
+
[email protected]("cost", [25, 100, 250])
[email protected]("tier", ["PRO", "MAX"])
+async def test_trial_conversion_preserves_lifetime_ledger_and_account_history(
+ activation_case, cost, tier
+):
+ case = activation_case
+ trial = await case.add_trial(cost, tier)
+ before = await SubscriptionTrial.prisma().find_unique_or_raise(
+ where={"userId": case.user_id}
+ )
+ claim = await db.prisma.subscriptiontrialclaim.create(
+ data={"key": f"claim:{trial.id}", "trialId": trial.id}
+ )
+ balance = await db.prisma.userbalance.create(
+ data={"userId": case.user_id, "balance": 321}
+ )
+ history = await db.prisma.credittransaction.create(
+ data={"userId": case.user_id, "amount": 123, "type": "GRANT"}
+ )
+ chat = await db.prisma.chatsession.create(
+ data={
+ "userId": case.user_id,
+ "totalPromptTokens": 1234,
+ "title": "Preserved conversation",
+ }
+ )
+ await case.add_cost(None, cost)
+ assert await case.activate()
+ after = await SubscriptionTrial.prisma().find_unique_or_raise(
+ where={"userId": case.user_id}
+ )
+ assert after.convertedAt and after.stripeConversionInvoiceId == case.invoice["id"]
+ assert after.costMicrodollars == cost
+ for name in ("id", "offer", "consumedAt", "startedAt", "endsAt", "cardVerifiedAt"):
+ assert before.model_dump()[name] == after.model_dump()[name]
+ assert (
+ await db.prisma.subscriptiontrialclaim.find_unique(where={"key": claim.key})
+ == claim
+ )
+ assert (
+ await db.prisma.userbalance.find_unique(where={"userId": case.user_id})
+ == balance
+ )
+ assert await db.prisma.credittransaction.find_many(
+ where={"userId": case.user_id}
+ ) == [history]
+ assert await db.prisma.chatsession.find_unique(where={"id": chat.id}) == chat
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.tier == tier and state.generation
+ assert state.trial_id is None
+ assert await case.counters(state.generation) == (0, 0)
+
+
[email protected]("tier", ["PRO", "MAX"])
+async def test_concurrent_duplicate_activation_publishes_one_generation(
+ activation_case, tier
+):
+ case = activation_case
+ await case.add_trial(100, tier)
+ assert all(await asyncio.gather(*(case.activate() for _ in range(4))))
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.generation
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == 1
+ await case.add_cost(state.generation, 37)
+ assert all(await asyncio.gather(*(case.activate() for _ in range(4))))
+ assert await get_usage_activation_state(case.user_id) == state
+ assert await case.counters(state.generation) == (37, 37)
+
+
+async def test_legacy_conversion_marker_preserves_calendar_usage(activation_case):
+ case = activation_case
+ await case.add_trial(100)
+ await SubscriptionTrial.prisma().update(
+ where={"userId": case.user_id},
+ data={"convertedAt": datetime.now(UTC)},
+ )
+ await case.add_cost(None, 100)
+ assert await case.activate()
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.generation is None
+ assert await case.counters(None) == (100, 100)
+
+
+async def test_database_failure_rolls_back_entitlement_and_retry_keeps_paid_cost(
+ activation_case,
+):
+ case = activation_case
+ trial = await case.add_trial(100)
+ generation = str(
+ uuid5(
+ NAMESPACE_URL,
+ f"autogpt:initial-pro:{case.user_id}:{case.subscription['id']}:{case.invoice['id']}",
+ )
+ )
+ await case.add_cost(generation, 29)
+ with pytest.raises(RawQueryError):
+ await case.activate(abort=True)
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == 0
+ pending_trial = await SubscriptionTrial.prisma().find_unique_or_raise(
+ where={"id": trial.id}
+ )
+ assert pending_trial.convertedAt is None and pending_trial.costMicrodollars == 100
+ assert (await get_usage_activation_state(case.user_id)).tier == "TRIAL"
+ assert await case.activate()
+ assert (await get_usage_activation_state(case.user_id)).generation == generation
+ assert await case.counters(generation) == (29, 29)
+
+
+async def test_redis_failure_rolls_back_database_and_recovers_without_erasing_usage(
+ activation_case,
+):
+ case = activation_case
+ await case.add_trial(100)
+ generation = str(
+ uuid5(
+ NAMESPACE_URL,
+ f"autogpt:initial-pro:{case.user_id}:{case.subscription['id']}:{case.invoice['id']}",
+ )
+ )
+ daily, weekly = usage_keys(case.user_id, generation, datetime.now(UTC))
+ await case.redis.lpush(daily, "invalid-counter")
+ await case.redis.set(weekly, 41)
+ with pytest.raises(ResponseError, match="WRONGTYPE"):
+ await case.activate()
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == 0
+ assert (await get_usage_activation_state(case.user_id)).tier == "TRIAL"
+ await case.redis.delete(daily)
+ await case.redis.set(daily, 17)
+ assert await case.activate()
+ assert await case.counters(generation) == (17, 41)
+
+
+async def test_incomplete_activation_is_processing_then_finishes_without_reset(
+ activation_case,
+):
+ case = activation_case
+ await case.add_trial(100)
+ row = await PaidUsageActivation.prisma().create(
+ data={
+ "userId": case.user_id,
+ "stripeSubscriptionId": case.subscription["id"],
+ "stripeInvoiceId": case.invoice["id"],
+ }
+ )
+ await case.add_cost(row.id, 53)
+ state = await get_usage_activation_state(case.user_id)
+ assert state.generation == row.id and not state.ready
+ assert await case.activate()
+ ready = await get_usage_activation_state(case.user_id)
+ assert ready.generation == row.id and ready.ready and ready.tier == "PRO"
+ assert await case.counters(row.id) == (53, 53)
+
+
[email protected]("tier", ["PRO", "MAX", "ENTERPRISE"])
+async def test_existing_paid_history_never_resets(activation_case, tier):
+ case = activation_case
+ await User.prisma().update(
+ where={"id": case.user_id}, data={"subscriptionTier": tier}
+ )
+ await case.add_cost(None, 73)
+ policy = await db.prisma.paidusageactivationpolicy.find_unique_or_raise(
+ where={"id": "initial-pro-v1"}
+ )
+ case.invoice["status_transitions"]["paid_at"] = int(policy.startsAt.timestamp()) - 1
+ case.invoice["created"] = int(policy.startsAt.timestamp()) - 2
+ assert await case.activate()
+ assert (await get_usage_activation_state(case.user_id)).generation is None
+ assert await case.counters(None) == (73, 73)
+
+
+async def test_admin_tier_edits_and_nontrial_payment_preserve_usage(
+ activation_case,
+):
+ case = activation_case
+ await case.add_cost(None, 71)
+ for tier in (SubscriptionTier.PRO, SubscriptionTier.MAX, SubscriptionTier.PRO):
+ await set_subscription_tier(case.user_id, tier)
+ assert (await get_usage_activation_state(case.user_id)).generation is None
+ assert await case.counters(None) == (71, 71)
+ assert await case.activate()
+ state = await get_usage_activation_state(case.user_id)
+ assert state.generation is None and state.ready
+ assert await case.counters(None) == (71, 71)
+
+
+async def test_returning_subscriber_never_receives_another_generation(activation_case):
+ case = activation_case
+ await case.add_trial(100)
+ previous = deepcopy(case.invoice)
+ previous.update(id=f"old_{case.invoice['id']}", subscription="sub_previous")
+ previous["lines"]["data"][0]["subscription"] = "sub_previous"
+ previous["created"] -= 60
+ previous["status_transitions"]["paid_at"] -= 60
+ case.invoices.append(previous)
+ await case.add_cost(None, 79)
+ assert await case.activate()
+ assert (await get_usage_activation_state(case.user_id)).generation is None
+ assert await case.counters(None) == (79, 79)
+
+
+async def test_payment_before_cutover_never_resets_on_delayed_event(activation_case):
+ case = activation_case
+ policy = await db.prisma.paidusageactivationpolicy.find_unique_or_raise(
+ where={"id": "initial-pro-v1"}
+ )
+ case.invoice["status_transitions"]["paid_at"] = int(
+ (policy.startsAt - timedelta(seconds=1)).timestamp()
+ )
+ case.invoice["created"] = case.invoice["status_transitions"]["paid_at"] - 1
+ await case.add_trial(100)
+ await case.add_cost(None, 83)
+ assert await case.activate()
+ assert (await get_usage_activation_state(case.user_id)).generation is None
+ assert await case.counters(None) == (83, 83)
+
+
+async def test_renewal_replay_preserves_current_generation_and_paid_usage(
+ activation_case,
+):
+ case = activation_case
+ await case.add_trial(100)
+ assert await case.activate()
+ state = await get_usage_activation_state(case.user_id)
+ await case.add_cost(state.generation, 89)
+ renewal = deepcopy(case.invoice)
+ renewal.update(
+ id=f"renewal_{case.invoice['id']}", billing_reason="subscription_cycle"
+ )
+ renewal["created"] += 30 * 86400
+ renewal["status_transitions"]["paid_at"] += 30 * 86400
+ case.invoices.append(renewal)
+ case.subscription["latest_invoice"] = renewal["id"]
+ assert await case.activate()
+ case.subscription["latest_invoice"] = case.invoice["id"]
+ assert await case.activate()
+ assert await get_usage_activation_state(case.user_id) == state
+ assert await case.counters(state.generation) == (89, 89)
+
+
[email protected]("field", ["customer", "metadata"])
+async def test_subscription_ownership_is_enforced_before_any_reset(
+ activation_case, field
+):
+ case = activation_case
+ case.subscription[field] = (
+ "cus_other" if field == "customer" else {"user_id": "someone_else"}
+ )
+ with pytest.raises(ValueError, match="does not belong"):
+ await case.activate()
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == 0
+
+
+async def test_late_trial_ledger_cost_does_not_consume_paid_generation(activation_case):
+ case = activation_case
+ trial = await case.add_trial(100)
+ assert await case.activate()
+ state = await get_usage_activation_state(case.user_id)
+ await case.add_cost(state.generation, 97)
+ await asyncio.gather(
+ *(record_subscription_trial_cost(case.user_id, 13, trial.id) for _ in range(8))
+ )
+ row = await SubscriptionTrial.prisma().find_unique_or_raise(where={"id": trial.id})
+ assert row.costMicrodollars == 204 and row.consumedAt == trial.consumed_at
+ assert await case.counters(state.generation) == (97, 97)
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_legacy_recovery_integration_test.py b/autogpt_platform/backend/backend/data/subscription_activation_legacy_recovery_integration_test.py
new file mode 100644
index 0000000000..bcc468ae20
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_legacy_recovery_integration_test.py
@@ -0,0 +1,130 @@
+"""Accepted trial prices remain reconcilable after leaving the live price map."""
+
+import os
+from copy import deepcopy
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+import stripe
+from prisma.enums import SubscriptionTier
+from prisma.models import User
+
+from backend.data import credit, stripe_reconciliation
+from backend.data import subscription_activation_integration_fixtures as fixtures
+from backend.data.pro_activation import get_usage_activation_state
+from backend.data.subscription_activation import reconcile_paid_activation
+
+activation_case = fixtures.activation_case
+pytestmark = pytest.mark.skipif(
+ os.environ.get("TRIAL_TEST_DATABASE") != "1",
+ reason="Requires disposable DB and Redis cluster",
+)
+
+
[email protected]("via", ["current", "sweep"])
+async def test_settled_renewal_restores_retired_accepted_plan_without_reset(
+ activation_case, mocker, via
+):
+ case = activation_case
+ await case.add_trial(100)
+ assert await case.activate()
+ before = await get_usage_activation_state(case.user_id)
+ await case.add_cost(before.generation, 173)
+ renewal = deepcopy(case.invoice)
+ renewal.update(id="in_legacy_renewal", status="open", amount_remaining=2000)
+ renewal["created"] += 60
+ renewal["status_transitions"]["paid_at"] += 60
+ renewal["lines"]["data"][0]["period"]["start"] += 60
+ case.invoices.append(renewal)
+ case.subscription.update(status="past_due", latest_invoice=renewal["id"])
+ mocker.patch.object(credit, "build_price_to_tier_map", return_value={})
+ mocker.patch.object(
+ stripe_reconciliation, "build_price_to_tier_map", return_value={}
+ )
+ mocker.patch.object(credit, "schedule_posthog_lifecycle_sync")
+
+ await credit.sync_subscription_from_stripe(case.subscription, track_lifecycle=False)
+ assert (await get_usage_activation_state(case.user_id)).tier == "NO_TIER"
+ case.subscription["status"] = "active"
+ await credit.sync_subscription_from_stripe(case.subscription, track_lifecycle=False)
+ assert (await get_usage_activation_state(case.user_id)).tier == "NO_TIER"
+
+ renewal.update(status="paid", amount_remaining=0)
+ if via == "current":
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+ assert (
+ result is not None
+ and not result.usage_reset
+ and result.activation_id is None
+ )
+ else:
+ await run_customer_sweep(case, mocker)
+
+ assert await get_usage_activation_state(case.user_id) == before
+ assert await case.counters(before.generation) == (173, 173)
+
+
+async def run_customer_sweep(case, mocker):
+ async def subscriptions(*, status, **kwargs):
+ return stripe.ListObject.construct_from(
+ {
+ "object": "list",
+ "data": [case.subscription] if status == "active" else [],
+ "has_more": False,
+ },
+ None,
+ )
+
+ async def candidates(**kwargs):
+ return [await User.prisma().find_unique_or_raise(where={"id": case.user_id})]
+
+ queries = MagicMock(wraps=User.prisma())
+ queries.find_many = AsyncMock(side_effect=candidates)
+ mocker.patch.object(
+ stripe_reconciliation, "User", MagicMock(prisma=MagicMock(return_value=queries))
+ )
+ mocker.patch.object(stripe.Subscription, "list_async", side_effect=subscriptions)
+ mocker.patch.object(stripe_reconciliation, "alert_tier_reconciliation_discrepancy")
+
+ summary = await stripe_reconciliation.reconcile_all_stripe_tiers()
+
+ assert summary.candidate_users == 1 and summary.errors == 0
+ assert summary.stripe_active_subscriptions == 1
+
+
[email protected]("mapped", [True, False])
+async def test_converted_trial_can_recover_a_paid_pro_price_change(
+ activation_case, mocker, mapped
+):
+ case = activation_case
+ await case.add_trial(100)
+ assert await case.activate()
+ before = await get_usage_activation_state(case.user_id)
+ await case.add_cost(before.generation, 179)
+ case.subscription["items"]["data"][0]["price"]["id"] = "price_pro_yearly"
+ invoice = deepcopy(case.invoice)
+ invoice.update(id="in_yearly_upgrade", billing_reason="subscription_update")
+ invoice["created"] += 60
+ invoice["status_transitions"]["paid_at"] += 60
+ invoice["lines"]["data"][0].update(proration=True, price={"id": "price_pro_yearly"})
+ case.invoices.append(invoice)
+ case.subscription["latest_invoice"] = invoice["id"]
+ mocker.patch.object(
+ credit,
+ "build_price_to_tier_map",
+ return_value={"price_pro_yearly": SubscriptionTier.PRO} if mapped else {},
+ )
+ mocker.patch.object(credit, "schedule_posthog_lifecycle_sync")
+
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+
+ if mapped:
+ assert (
+ result is not None
+ and not result.usage_reset
+ and result.activation_id is None
+ )
+ else:
+ assert result is None
+ assert await get_usage_activation_state(case.user_id) == before
+ assert await case.counters(before.generation) == (179, 179)
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_models.py b/autogpt_platform/backend/backend/data/subscription_activation_models.py
new file mode 100644
index 0000000000..d58faa3bd7
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_models.py
@@ -0,0 +1,241 @@
+"""Public contract and persisted terms for explicitly ending a trial on Pro or Max."""
+
+from datetime import datetime
+from hashlib import sha256
+from typing import Literal
+
+from pydantic import BaseModel, Field, Json, field_validator
+
+ActivationPlan = Literal["PRO", "MAX"]
+
+ActivationStatus = Literal[
+ "confirmation_required",
+ "payment_required",
+ "action_required",
+ "processing",
+ "ready",
+ "not_applicable",
+ "failed",
+]
+
+
+class RenewalDiscount(BaseModel):
+ amount_off: int | None = None
+ percent_off: float | None = None
+ currency: str | None = None
+ duration: str
+ duration_in_months: int | None = None
+ ends_at: int | None = None
+
+
+class RenewalTaxRate(BaseModel):
+ display_name: str
+ percentage: float
+ inclusive: bool
+ country: str | None = None
+ state: str | None = None
+
+
+class RenewalTax(BaseModel):
+ automatic: bool = False
+ price_tax_behavior: str = "unspecified"
+ rates: list[RenewalTaxRate] = Field(default_factory=list)
+
+
+class ActivationTerms(BaseModel):
+ plan: ActivationPlan = "PRO"
+ price_id: str
+ accepted_offer_token: str
+ amount_due: int = Field(ge=0)
+ currency: str
+ billing_interval: Literal["month", "year"]
+ billing_interval_count: int = 1
+ renewal_unit_amount: int = Field(ge=0)
+ renewal_discounts: list[RenewalDiscount] = Field(default_factory=list)
+ renewal_tax: RenewalTax = Field(default_factory=RenewalTax)
+ charge_timing: Literal["on_confirmation"] = "on_confirmation"
+ renewal_terms: str
+ expires_at: datetime
+
+ @property
+ def token(self) -> str:
+ return sha256(self.model_dump_json().encode()).hexdigest()
+
+ def same_charge_as(self, other: "ActivationTerms") -> bool:
+ return self.model_dump(exclude={"expires_at"}) == other.model_dump(
+ exclude={"expires_at"}
+ )
+
+
+class ActivationConfirmRequest(BaseModel):
+ confirmed: Literal[True]
+ terms_token: str = Field(pattern=r"^[a-f0-9]{64}$")
+
+ @field_validator("confirmed", mode="before")
+ @classmethod
+ def require_true(cls, value: object) -> object:
+ if value is not True:
+ raise ValueError("Explicit confirmation is required")
+ return value
+
+
+class ActivationPreviewRequest(BaseModel):
+ plan: ActivationPlan | None = None
+ return_to: str = "/settings/billing"
+
+ @field_validator("return_to")
+ @classmethod
+ def relative_destination(cls, value: str) -> str:
+ if (
+ not value.startswith("/")
+ or value.startswith("//")
+ or "\\" in value
+ or any(ord(char) < 32 for char in value)
+ ):
+ raise ValueError("return_to must be an application-relative path")
+ return value
+
+
+class PaidActivationResult(BaseModel):
+ invoice_id: str
+ usage_reset: bool
+ activation_id: str | None = None
+
+
+class ActivationResponse(BaseModel):
+ id: str | None = None
+ status: ActivationStatus
+ terms: ActivationTerms | None = None
+ terms_token: str | None = None
+ return_to: str = "/settings/billing"
+ invoice_id: str | None = None
+ hosted_invoice_url: str | None = None
+ retry_after_seconds: int | None = None
+ error_code: str | None = None
+ usage_reset: bool = False
+ activation_id: str | None = None
+
+
+class ActivationAttempt(BaseModel):
+ id: str
+ user_id: str
+ subscription_id: str
+ customer_id: str
+ terms: ActivationTerms | Json[ActivationTerms]
+ return_to: str
+ confirmed_at: datetime | None
+ invoice_id: str | None = None
+
+ def response(self, status: ActivationStatus, **kwargs) -> ActivationResponse:
+ return ActivationResponse(
+ id=self.id,
+ status=status,
+ terms=self.terms,
+ terms_token=self.terms.token,
+ return_to=self.return_to,
+ invoice_id=self.invoice_id,
+ **kwargs,
+ )
+
+
+class ActivationUnavailable(ValueError):
+ """The user must refresh terms, or has no eligible owned trial."""
+
+
+class ActivationNotFound(ValueError):
+ """No activation owned by this authenticated user."""
+
+
+class InvoicePaymentSource(BaseModel):
+ type: str
+ payment_intent: str | None = None
+
+
+class InvoicePayment(BaseModel):
+ invoice: str
+ is_default: bool = False
+ payment: InvoicePaymentSource
+
+
+class InvoicePayments(BaseModel):
+ data: list[InvoicePayment] = Field(default_factory=list)
+ has_more: bool = False
+
+
+class BillingInvoice(BaseModel):
+ id: str
+ customer: str
+ status: str | None = None
+ amount_remaining: int | None = None
+ hosted_invoice_url: str | None = None
+ payment_intent: str | None = None
+ payments: InvoicePayments | None = None
+
+
+class CouponProducts(BaseModel):
+ products: list[str]
+
+
+class Coupon(BaseModel):
+ applies_to: CouponProducts | None = None
+ amount_off: int | None = None
+ percent_off: float | None = None
+ currency: str | None = None
+ duration: str
+ duration_in_months: int | None = None
+
+
+class Discount(BaseModel):
+ coupon: Coupon
+ end: int | None = None
+
+
+class InvoicePreview(BaseModel):
+ customer: str
+ currency: str
+ amount_due: int
+ discounts: list[Discount] = Field(default_factory=list)
+
+
+class AutomaticTax(BaseModel):
+ enabled: bool = False
+
+
+class RecurringPrice(BaseModel):
+ interval: Literal["month", "year"]
+ interval_count: int
+
+
+class ActivationPrice(BaseModel):
+ id: str
+ product: str | None = None
+ unit_amount: int
+ currency: str
+ recurring: RecurringPrice
+ tax_behavior: str = "unspecified"
+
+
+class ActivationItem(BaseModel):
+ id: str | None = None
+ price: ActivationPrice
+ quantity: int
+
+
+class ActivationItems(BaseModel):
+ data: list[ActivationItem]
+ has_more: bool = False
+
+
+class BillingSubscription(BaseModel):
+ id: str
+ customer: str
+ status: str
+ metadata: dict[str, str] = Field(default_factory=dict)
+ cancel_at_period_end: bool = False
+ trial_end: int | None = None
+ items: ActivationItems
+ latest_invoice: BillingInvoice | None = None
+ # A change Stripe holds until its invoice is paid; the trial runs meanwhile.
+ pending_update: dict[str, object] | None = None
+ automatic_tax: AutomaticTax = Field(default_factory=AutomaticTax)
+ default_tax_rates: list[RenewalTaxRate] = Field(default_factory=list)
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_payment_integration_test.py b/autogpt_platform/backend/backend/data/subscription_activation_payment_integration_test.py
new file mode 100644
index 0000000000..eac393c869
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_payment_integration_test.py
@@ -0,0 +1,283 @@
+"""Settled payment evidence is required for activation and trial reconciliation."""
+
+import os
+from copy import deepcopy
+from datetime import UTC, datetime, timedelta
+from uuid import NAMESPACE_URL, uuid5
+
+import pytest
+from prisma.models import PaidUsageActivation, SubscriptionTrial, User
+from redis.exceptions import ResponseError
+
+from backend.copilot.usage_activation import usage_keys
+from backend.data import db
+from backend.data import subscription_activation_integration_fixtures as fixtures
+from backend.data.credit import sync_subscription_from_stripe
+from backend.data.pro_activation import get_usage_activation_state
+from backend.data.subscription_activation import reconcile_paid_activation
+from backend.data.subscription_trial_stripe import reconcile_trial_subscription
+
+activation_case = fixtures.activation_case
+pytestmark = pytest.mark.skipif(
+ os.environ.get("TRIAL_TEST_DATABASE") != "1",
+ reason="Requires disposable DB and Redis cluster",
+)
+
+
+async def test_malformed_matching_first_invoice_stays_unactivated(activation_case):
+ await activation_case.add_trial(100)
+ activation_case.invoice["lines"]["data"][0]["period"] = {}
+ assert not await activation_case.activate()
+ state = await get_usage_activation_state(activation_case.user_id)
+ assert state.generation is None and state.tier == "TRIAL"
+
+
[email protected]("status", ["open", "draft", "uncollectible", "void"])
[email protected]("tier", ["PRO", "MAX"])
+async def test_unsettled_invoice_does_not_publish_entitlement(
+ activation_case, status, tier
+):
+ case = activation_case
+ await case.add_trial(100, tier)
+ await case.add_cost(None, 137)
+ case.invoice["status"] = status
+ case.invoice["amount_remaining"] = 2000
+ assert not await case.activate()
+ state = await get_usage_activation_state(case.user_id)
+ assert state.generation is None and state.tier == "TRIAL"
+ assert await case.counters(None) == (137, 137)
+
+
+ "status",
+ [
+ "trialing",
+ "incomplete",
+ "incomplete_expired",
+ "past_due",
+ "canceled",
+ "unpaid",
+ "paused",
+ ],
+)
+async def test_inactive_subscription_does_not_publish_entitlement(
+ activation_case, status
+):
+ case = activation_case
+ await case.add_trial(100)
+ case.subscription["status"] = status
+ assert not await case.activate()
+ assert (await get_usage_activation_state(case.user_id)).generation is None
+
+
+async def test_zero_dollar_trial_setup_is_not_paid_activation(activation_case):
+ case = activation_case
+ await case.add_trial(100)
+ case.invoice["amount_paid"] = 0
+ case.invoice["lines"]["data"][0]["amount"] = 0
+ assert not await case.activate()
+ assert (await get_usage_activation_state(case.user_id)).generation is None
+
+
+async def test_settled_payment_using_credit_or_discount_qualifies(activation_case):
+ case = activation_case
+ await case.add_trial(100)
+ case.invoice["amount_paid"] = 0
+ assert await case.activate()
+ assert (await get_usage_activation_state(case.user_id)).generation
+
+
[email protected]("cost", [25, 100])
[email protected]("early", [False, True])
[email protected]("tier", ["PRO", "MAX"])
+async def test_full_trial_reconciliation_commits_entitlement_and_generation(
+ activation_case, cost, early, tier
+):
+ case = activation_case
+ trial = await case.add_trial(cost, tier)
+ if early:
+ await SubscriptionTrial.prisma().update(
+ where={"id": trial.id},
+ data={"endsAt": datetime.now(UTC) + timedelta(days=4)},
+ )
+ await case.add_cost(None, cost)
+ result = await reconcile_trial_subscription(case.user_id, case.subscription["id"])
+ assert result and result[1] == tier
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.tier == tier and state.generation
+ row = await SubscriptionTrial.prisma().find_unique_or_raise(where={"id": trial.id})
+ assert row.costMicrodollars == cost and row.consumedAt == trial.consumed_at
+ assert row.offer == trial.offer.model_dump(mode="json")
+ assert row.convertedAt and row.stripeConversionInvoiceId == case.invoice["id"]
+ assert await case.counters(state.generation) == (0, 0)
+ await case.add_cost(state.generation, 109)
+ await reconcile_trial_subscription(case.user_id, case.subscription["id"])
+ assert await get_usage_activation_state(case.user_id) == state
+ assert await case.counters(state.generation) == (109, 109)
+
+
+async def test_full_reconciliation_redis_error_leaves_paid_activation_recoverable(
+ activation_case,
+):
+ case = activation_case
+ trial = await case.add_trial(100)
+ generation = str(
+ uuid5(
+ NAMESPACE_URL,
+ f"autogpt:initial-pro:{case.user_id}:{case.subscription['id']}:{case.invoice['id']}",
+ )
+ )
+ daily, weekly = usage_keys(case.user_id, generation, datetime.now(UTC))
+ await case.redis.lpush(daily, "unavailable-counter")
+ await case.redis.set(weekly, 113)
+ with pytest.raises(ResponseError, match="WRONGTYPE"):
+ await reconcile_trial_subscription(case.user_id, case.subscription["id"])
+ row = await SubscriptionTrial.prisma().find_unique_or_raise(where={"id": trial.id})
+ assert row.convertedAt is None and row.costMicrodollars == 100
+ assert row.status == "trialing"
+ state = await get_usage_activation_state(case.user_id)
+ assert state.tier == "TRIAL" and state.generation is None
+ await case.redis.delete(daily)
+ result = await reconcile_trial_subscription(case.user_id, case.subscription["id"])
+ assert result and result[1] == "PRO"
+ assert await case.counters(generation) == (0, 113)
+
+
+async def test_delayed_conversion_retains_first_invoice_when_latest_is_renewal(
+ activation_case,
+):
+ case = activation_case
+ trial = await case.add_trial(100)
+ renewal = deepcopy(case.invoice)
+ renewal.update(
+ id=f"renewal_{case.invoice['id']}", created=case.invoice["created"] + 60
+ )
+ renewal["status_transitions"]["paid_at"] += 60
+ renewal["lines"]["data"][0]["period"]["start"] += 60
+ case.invoices.append(renewal)
+ case.subscription["latest_invoice"] = renewal["id"]
+ assert await reconcile_trial_subscription(case.user_id, case.subscription["id"])
+ row = await SubscriptionTrial.prisma().find_unique_or_raise(where={"id": trial.id})
+ activation = await PaidUsageActivation.prisma().find_unique_or_raise(
+ where={"userId": case.user_id}
+ )
+ assert (
+ row.stripeConversionInvoiceId
+ == activation.stripeInvoiceId
+ == case.invoice["id"]
+ )
+ assert (
+ int(row.convertedAt.timestamp())
+ == case.invoice["status_transitions"]["paid_at"]
+ )
+
+
+ "field,value", [("status", "open"), ("amount_remaining", 2000)]
+)
+async def test_full_reconciliation_rejects_unsettled_invoice(
+ activation_case, field, value
+):
+ case = activation_case
+ trial = await case.add_trial(100)
+ case.invoice[field] = value
+ result = await reconcile_trial_subscription(case.user_id, case.subscription["id"])
+ assert result and result[1] == "NO_TIER"
+ state = await get_usage_activation_state(case.user_id)
+ assert state.generation is None and state.tier == "NO_TIER"
+ row = await SubscriptionTrial.prisma().find_unique_or_raise(where={"id": trial.id})
+ assert row.convertedAt is None and row.costMicrodollars == 100
+
+
+async def test_stale_webhook_payload_cannot_override_current_stripe_state(
+ activation_case,
+):
+ case = activation_case
+ await case.add_trial(100)
+ stale_event = {**case.subscription, "status": "canceled"}
+ await sync_subscription_from_stripe(stale_event, track_lifecycle=False)
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.tier == "PRO" and state.generation
+ await case.add_cost(state.generation, 127)
+ case.subscription["status"] = "canceled"
+ await sync_subscription_from_stripe(
+ {**stale_event, "status": "active"}, track_lifecycle=False
+ )
+ ended = await get_usage_activation_state(case.user_id)
+ assert ended.tier == "NO_TIER" and ended.generation == state.generation
+ assert await case.counters(state.generation) == (127, 127)
+
+
+async def test_status_does_not_treat_admin_pro_label_as_completed_activation(
+ activation_case,
+):
+ case = activation_case
+ await case.add_trial(100)
+ enrollment_id = case.subscription["metadata"].pop("trial_enrollment_id")
+ await User.prisma().update(
+ where={"id": case.user_id}, data={"subscriptionTier": "PRO"}
+ )
+ with pytest.raises(ValueError, match="matching enrollment"):
+ await reconcile_paid_activation(case.user_id, case.subscription["id"])
+ case.subscription["metadata"]["trial_enrollment_id"] = enrollment_id
+ period = case.invoice["lines"]["data"][0].pop("period")
+ assert not await reconcile_paid_activation(case.user_id, case.subscription["id"])
+ assert (await get_usage_activation_state(case.user_id)).generation is None
+ case.invoice["lines"]["data"][0]["period"] = period
+ assert await reconcile_paid_activation(case.user_id, case.subscription["id"])
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.generation
+
+
[email protected]("tier", ["PRO", "MAX"])
[email protected]("history", ["returning", "prepolicy"])
+async def test_ineligible_reset_still_records_the_paid_trial_conversion(
+ activation_case, tier, history
+):
+ case = activation_case
+ if history == "prepolicy":
+ policy = await db.prisma.paidusageactivationpolicy.find_unique_or_raise(
+ where={"id": "initial-pro-v1"}
+ )
+ paid_at = int(policy.startsAt.timestamp()) - 1
+ case.invoice["created"] = paid_at
+ case.invoice["status_transitions"]["paid_at"] = paid_at
+ trial = await case.add_trial(100, tier)
+ if history == "returning":
+ previous = deepcopy(case.invoice)
+ previous.update(id="in_previous", subscription="sub_previous")
+ previous["lines"]["data"][0]["subscription"] = "sub_previous"
+ previous["created"] -= 60
+ previous["status_transitions"]["paid_at"] -= 60
+ case.invoices.append(previous)
+ await case.add_cost(None, 199)
+
+ result = await reconcile_trial_subscription(case.user_id, case.subscription["id"])
+
+ assert result and result[1] == tier
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.generation is None
+ assert await case.counters(None) == (199, 199)
+ row = await SubscriptionTrial.prisma().find_unique_or_raise(where={"id": trial.id})
+ assert row.convertedAt and row.stripeConversionInvoiceId == case.invoice["id"]
+ assert row.costMicrodollars == 100 and row.consumedAt == trial.consumed_at
+ assert row.offer == trial.offer.model_dump(mode="json")
+
+
[email protected]("tier", ["BASIC", "BUSINESS"])
+async def test_other_scheduled_trial_plans_keep_usage_without_activation(
+ activation_case, tier
+):
+ case = activation_case
+ trial = await case.add_trial(100, tier)
+ await case.add_cost(None, 211)
+
+ result = await reconcile_trial_subscription(case.user_id, case.subscription["id"])
+
+ assert result and result[1] == tier
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.tier == tier and state.generation is None
+ assert await case.counters(None) == (211, 211)
+ row = await SubscriptionTrial.prisma().find_unique_or_raise(where={"id": trial.id})
+ assert row.costMicrodollars == 100 and row.consumedAt == trial.consumed_at
+ assert row.offer == trial.offer.model_dump(mode="json")
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_policy_test.py b/autogpt_platform/backend/backend/data/subscription_activation_policy_test.py
new file mode 100644
index 0000000000..5113987e76
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_policy_test.py
@@ -0,0 +1,294 @@
+"""Only the initial paid conversion of a consumed trial creates a generation."""
+
+from datetime import UTC, datetime, timedelta
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from prisma.enums import SubscriptionTier
+
+from backend.data import subscription_activation as activation
+from backend.data import subscription_activation_target as target
+from backend.data import subscription_trial_fixtures as fixtures
+from backend.data.subscription_activation_models import (
+ ActivationAttempt,
+ ActivationTerms,
+)
+
+trial = fixtures.trial
+subscription = fixtures.subscription
+
+
+def policy_case(monkeypatch, trial, subscription):
+ now = datetime.now(UTC)
+ trial.subscription_id = subscription["id"]
+ trial.consumed_at = now - timedelta(days=7)
+ subscription.update(
+ status="active", trial_end=int(now.timestamp()), latest_invoice="in_first"
+ )
+ invoice = {
+ "id": "in_first",
+ "customer": trial.customer_id,
+ "subscription": subscription["id"],
+ "status": "paid",
+ "amount_remaining": 0,
+ "created": int(now.timestamp()),
+ "status_transitions": {"paid_at": int(now.timestamp())},
+ "billing_reason": "subscription_cycle",
+ "lines": {
+ "data": [
+ {
+ "type": "subscription",
+ "subscription": subscription["id"],
+ "quantity": 1,
+ "price": {"id": trial.offer.price_id},
+ "amount": 2000,
+ "period": {
+ "start": int(now.timestamp()),
+ "end": int(now.timestamp()) + 86400,
+ },
+ }
+ ]
+ },
+ }
+ tx = MagicMock()
+ tx.paidusageactivation.find_unique = AsyncMock(return_value=None)
+ tx.paidusageactivation.create = AsyncMock()
+ tx.paidusageactivation.update_many = AsyncMock()
+ tx.paidusageactivationpolicy.find_unique_or_raise = AsyncMock(
+ return_value=SimpleNamespace(startsAt=now - timedelta(days=30))
+ )
+ tx.subscriptiontrial.update = AsyncMock()
+ user = SimpleNamespace(
+ id=trial.user_id,
+ stripeCustomerId=trial.customer_id,
+ subscriptionTier=SubscriptionTier.TRIAL,
+ )
+ monkeypatch.setattr(
+ activation, "_retrieve_invoice", AsyncMock(return_value=invoice)
+ )
+ monkeypatch.setattr(
+ activation, "first_settled_invoice", AsyncMock(return_value=invoice)
+ )
+ monkeypatch.setattr(activation, "verify_activation_usage", AsyncMock())
+ return SimpleNamespace(
+ user=user, trial=trial, subscription=subscription, invoice=invoice, tx=tx
+ )
+
+
+async def test_initial_paid_signup_preserves_usage(policy_case):
+ case = policy_case
+ case.subscription["trial_end"] = None
+ case.invoice["billing_reason"] = "subscription_create"
+ activation.first_settled_invoice.side_effect = AssertionError("No history needed")
+ assert await activation.publish_initial_pro_activation(
+ case.user, case.subscription, "price_pro", case.tx
+ )
+ case.tx.paidusageactivation.create.assert_not_awaited()
+
+
+async def test_legacy_converted_trial_preserves_usage_on_original_invoice(policy_case):
+ case = policy_case
+ case.trial.converted_at = datetime.now(UTC)
+ case.trial.conversion_invoice_id = case.invoice["id"]
+ assert await activation.publish_initial_pro_activation(
+ case.user, case.subscription, "price_pro", case.tx, case.trial
+ )
+ case.tx.paidusageactivation.create.assert_not_awaited()
+
+
+async def test_unconsumed_trial_cannot_reset(policy_case):
+ case = policy_case
+ case.trial.consumed_at = None
+ assert not await activation.publish_initial_pro_activation(
+ case.user, case.subscription, "price_pro", case.tx, case.trial
+ )
+ case.tx.paidusageactivation.create.assert_not_awaited()
+
+
+ "changed",
+ [
+ {"user_id": "foreign"},
+ {"customer_id": "foreign"},
+ {"subscription_id": "foreign"},
+ ],
+)
+async def test_unrelated_trial_ledger_cannot_reset(policy_case, changed):
+ case = policy_case
+ trial = case.trial.model_copy(update=changed)
+ assert not await activation.publish_initial_pro_activation(
+ case.user, case.subscription, "price_pro", case.tx, trial
+ )
+ case.tx.paidusageactivation.create.assert_not_awaited()
+
+
[email protected]("plan", ["PRO", "MAX"])
[email protected]("chosen_plan", [False, True])
+async def test_consumed_initial_trial_conversion_creates_one_generation(
+ policy_case, plan, chosen_plan
+):
+ case = policy_case
+ price_id = f"price_{plan.lower()}"
+ case.trial.offer = case.trial.offer.model_copy(
+ update={
+ "tier": "BASIC" if chosen_plan else plan,
+ "price_id": "price_basic" if chosen_plan else price_id,
+ }
+ )
+ if chosen_plan:
+ case.subscription["metadata"].update(
+ trial_conversion_price_id=price_id, trial_conversion_tier=plan
+ )
+ case.subscription["items"]["data"][0]["price"]["id"] = price_id
+ case.invoice["lines"]["data"][0]["price"]["id"] = price_id
+ assert await activation.publish_initial_pro_activation(
+ case.user, case.subscription, price_id, case.tx, case.trial
+ )
+ case.tx.paidusageactivation.create.assert_awaited_once()
+ saved = case.tx.paidusageactivation.create.await_args.kwargs["data"]
+ assert saved["stripeInvoiceId"] == case.invoice["id"]
+ assert saved["stripeSubscriptionId"] == case.subscription["id"]
+ case.tx.paidusageactivation.find_unique.return_value = SimpleNamespace(
+ id=saved["id"], stripeSubscriptionId=case.subscription["id"]
+ )
+ assert await activation.publish_initial_pro_activation(
+ case.user, case.subscription, price_id, case.tx, case.trial
+ )
+ case.tx.paidusageactivation.create.assert_awaited_once()
+
+
+ "changed",
+ [
+ {},
+ {"user_id": "other"},
+ {"trial_enrollment_id": "other"},
+ {"trial_checkout_attempt": "1"},
+ ],
+)
+async def test_trial_metadata_cannot_invent_reset_ownership(policy_case, changed):
+ case = policy_case
+ if changed:
+ case.subscription["metadata"].update(changed)
+ else:
+ case.subscription["metadata"] = {}
+ if changed.get("user_id"):
+ with pytest.raises(ValueError, match="belong"):
+ await activation.publish_initial_pro_activation(
+ case.user, case.subscription, "price_pro", case.tx, case.trial
+ )
+ else:
+ assert not await activation.publish_initial_pro_activation(
+ case.user, case.subscription, "price_pro", case.tx, case.trial
+ )
+ case.tx.paidusageactivation.create.assert_not_awaited()
+
+
+def confirmed_target(monkeypatch, policy_case):
+ case = policy_case
+ case.subscription["items"]["data"][0]["price"]["id"] = "price_max"
+ case.subscription["metadata"]["pro_activation_attempt_id"] = "attempt-1"
+ attempt = ActivationAttempt(
+ id="attempt-1",
+ user_id=case.trial.user_id,
+ customer_id=case.trial.customer_id,
+ subscription_id=case.subscription["id"],
+ return_to="/chat/resume",
+ confirmed_at=datetime.now(UTC),
+ terms=ActivationTerms(
+ plan="MAX",
+ price_id="price_max",
+ accepted_offer_token=case.trial.offer.token,
+ amount_due=10000,
+ currency="usd",
+ billing_interval="month",
+ renewal_unit_amount=10000,
+ renewal_terms="Renews monthly",
+ expires_at=datetime.now(UTC) + timedelta(minutes=10),
+ ),
+ )
+ lookup = AsyncMock(return_value=[attempt])
+ monkeypatch.setattr(target, "query_raw_with_schema", lookup)
+ return attempt, lookup
+
+
+async def test_confirmed_selected_max_binds_target_under_transaction(
+ policy_case, confirmed_target
+):
+ attempt, lookup = confirmed_target
+ case = policy_case
+ assert await activation.accepted_conversion_target(
+ case.trial, case.subscription, case.tx
+ ) == (SubscriptionTier.MAX, "price_max")
+ assert lookup.await_args.kwargs["client"] is case.tx
+ case.invoice["lines"]["data"][0]["price"]["id"] = "price_max"
+ assert await activation.publish_initial_pro_activation(
+ case.user, case.subscription, "price_max", case.tx, case.trial
+ )
+ case.tx.paidusageactivation.create.assert_awaited_once()
+
+
+ "field,value",
+ [
+ ("confirmed_at", None),
+ ("user_id", "other"),
+ ("customer_id", "other"),
+ ("subscription_id", "other"),
+ ("id", "other"),
+ ],
+)
+async def test_foreign_or_unconfirmed_attempt_cannot_authorize_target(
+ policy_case, confirmed_target, field, value
+):
+ attempt, _ = confirmed_target
+ setattr(attempt, field, value)
+ case = policy_case
+ assert (
+ await activation.accepted_conversion_target(
+ case.trial, case.subscription, case.tx
+ )
+ is None
+ )
+
+
+ "field,value", [("price_id", "price_other"), ("accepted_offer_token", "b" * 64)]
+)
+async def test_changed_accepted_terms_cannot_authorize_target(
+ policy_case, confirmed_target, field, value
+):
+ attempt, _ = confirmed_target
+ setattr(attempt.terms, field, value)
+ case = policy_case
+ assert (
+ await activation.accepted_conversion_target(
+ case.trial, case.subscription, case.tx
+ )
+ is None
+ )
+
+
+async def test_unknown_attempt_cannot_authorize_target(policy_case, confirmed_target):
+ _, lookup = confirmed_target
+ lookup.return_value = []
+ case = policy_case
+ assert (
+ await activation.accepted_conversion_target(
+ case.trial, case.subscription, case.tx
+ )
+ is None
+ )
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_race_integration_test.py b/autogpt_platform/backend/backend/data/subscription_activation_race_integration_test.py
new file mode 100644
index 0000000000..b87b1eb082
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_race_integration_test.py
@@ -0,0 +1,124 @@
+"""A later paid plan cannot complete an earlier plan's activation response."""
+
+import os
+from datetime import UTC, datetime, timedelta
+
+import pytest
+from prisma.enums import SubscriptionTier
+from prisma.models import SubscriptionTrial, User
+
+from backend.data import credit
+from backend.data import subscription_activation as activation
+from backend.data import subscription_activation_checkout as checkout
+from backend.data import subscription_activation_integration_fixtures as fixtures
+from backend.data.pro_activation import get_usage_activation_state
+from backend.data.subscription_activation_attempt import save_confirmation, save_quote
+from backend.data.subscription_activation_models import ActivationTerms
+from backend.data.subscription_activation_transition_integration_test import (
+ prepare_paid_user,
+)
+from backend.data.subscription_trial import TrialState
+
+activation_case = fixtures.activation_case
+pytestmark = pytest.mark.skipif(
+ os.environ.get("TRIAL_TEST_DATABASE") != "1",
+ reason="Requires disposable DB and Redis cluster",
+)
+
+
[email protected]("source,target", [("PRO", "MAX"), ("MAX", "PRO")])
+async def test_attempt_price_change_during_reconciliation_stays_pending(
+ activation_case, mocker, source, target
+):
+ case = activation_case
+ trial, generation = await prepare_case(case, mocker, source)
+ attempt = await save_confirmation(
+ await save_quote(
+ case.user_id,
+ case.subscription["id"],
+ case.subscription["customer"],
+ ActivationTerms(
+ plan=source,
+ price_id=f"price_{source.lower()}",
+ accepted_offer_token=trial.offer.token,
+ amount_due=2000,
+ currency="usd",
+ billing_interval="month",
+ renewal_unit_amount=2000,
+ renewal_terms="Monthly",
+ expires_at=datetime.now(UTC) + timedelta(minutes=10),
+ ),
+ "/chat/kept",
+ )
+ )
+ reconcile = checkout.reconcile_paid_activation
+
+ async def changed_plan(user_id, subscription_id, **kwargs):
+ case.subscription["items"]["data"][0]["price"]["id"] = f"price_{target.lower()}"
+ return await reconcile(user_id, subscription_id, **kwargs)
+
+ mocker.patch.object(checkout, "reconcile_paid_activation", side_effect=changed_plan)
+ result = await checkout.get_activation(case.user_id, attempt.id)
+ assert result.status == "processing" and not result.usage_reset
+ assert result.activation_id is None
+ assert result.terms and result.terms.plan == source
+ result = await checkout.get_activation(case.user_id, attempt.id)
+ assert result.status == "not_applicable" and result.error_code == "plan_changed"
+ assert await case.counters(generation) == (191, 191)
+
+
[email protected]("source,target", [("PRO", "MAX"), ("MAX", "PRO")])
+async def test_price_change_after_sync_requires_matching_locked_entitlement(
+ activation_case, mocker, source, target
+):
+ case = activation_case
+ _, generation = await prepare_case(case, mocker, source)
+ sync = credit.sync_subscription_from_stripe
+
+ async def changed_plan(subscription):
+ await sync(subscription)
+ case.subscription["items"]["data"][0]["price"]["id"] = f"price_{target.lower()}"
+
+ mocker.patch.object(
+ credit, "sync_subscription_from_stripe", side_effect=changed_plan
+ )
+ assert (
+ await activation.reconcile_paid_activation(
+ case.user_id, case.subscription["id"]
+ )
+ is None
+ )
+ user = await User.prisma().find_unique_or_raise(where={"id": case.user_id})
+ assert user.subscriptionTier == source
+ result = await activation.reconcile_paid_activation(
+ case.user_id, case.subscription["id"]
+ )
+ assert result is not None and not result.usage_reset
+ user = await User.prisma().find_unique_or_raise(where={"id": case.user_id})
+ assert user.subscriptionTier == target
+ assert await case.counters(generation) == (191, 191)
+
+
+async def prepare_case(case, mocker, source):
+ mocker.patch.object(
+ credit,
+ "build_price_to_tier_map",
+ return_value={
+ "price_pro": SubscriptionTier.PRO,
+ "price_max": SubscriptionTier.MAX,
+ },
+ )
+ mocker.patch.object(credit, "schedule_posthog_lifecycle_sync")
+ await prepare_paid_user(case, source, "activation")
+ case.subscription["items"]["data"][0]["price"].update(
+ unit_amount=2000,
+ currency="usd",
+ recurring={"interval": "month", "interval_count": 1},
+ )
+ row = await SubscriptionTrial.prisma().find_unique_or_raise(
+ where={"userId": case.user_id}
+ )
+ state = await get_usage_activation_state(case.user_id)
+ assert state.generation
+ await case.add_cost(state.generation, 191)
+ return TrialState.from_db(row), state.generation
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_recovery_integration_test.py b/autogpt_platform/backend/backend/data/subscription_activation_recovery_integration_test.py
new file mode 100644
index 0000000000..13f303931e
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_recovery_integration_test.py
@@ -0,0 +1,285 @@
+"""Paid upgrade recovery must preserve the initial activation boundary."""
+
+import os
+from copy import deepcopy
+
+import pytest
+from prisma.enums import SubscriptionTier
+from prisma.models import PaidUsageActivation, SubscriptionTrial, User
+
+from backend.data import credit, db
+from backend.data import subscription_activation_integration_fixtures as fixtures
+from backend.data.pro_activation import get_usage_activation_state
+from backend.data.subscription_activation import reconcile_paid_activation
+
+activation_case = fixtures.activation_case
+pytestmark = pytest.mark.skipif(
+ os.environ.get("TRIAL_TEST_DATABASE") != "1",
+ reason="Requires disposable DB and Redis cluster",
+)
+
+
[email protected](autouse=True)
+def billing_boundaries(mocker):
+ mocker.patch.object(
+ credit,
+ "build_price_to_tier_map",
+ return_value={
+ "price_pro": SubscriptionTier.PRO,
+ "price_max": SubscriptionTier.MAX,
+ },
+ )
+ mocker.patch.object(credit, "schedule_posthog_lifecycle_sync")
+
+
+def add_proration(case):
+ invoice = deepcopy(case.invoice)
+ invoice.update(
+ id=f"proration_{case.invoice['id']}", billing_reason="subscription_update"
+ )
+ invoice["created"] += 60
+ invoice["status_transitions"]["paid_at"] += 60
+ invoice["lines"]["data"][0].update(
+ proration=True,
+ amount=1000,
+ price=deepcopy(case.subscription["items"]["data"][0]["price"]),
+ )
+ case.invoices.append(invoice)
+ case.subscription["latest_invoice"] = invoice["id"]
+ return invoice
+
+
+async def test_paid_basic_upgrade_recovers_without_a_new_usage_generation(
+ activation_case,
+):
+ case = activation_case
+ case.invoice["lines"]["data"][0]["price"]["id"] = "price_basic"
+ await User.prisma().update(
+ where={"id": case.user_id}, data={"subscriptionTier": "BASIC"}
+ )
+ await case.add_cost(None, 149)
+ add_proration(case)
+
+ await credit.sync_subscription_from_stripe(case.subscription, track_lifecycle=False)
+
+ state = await get_usage_activation_state(case.user_id)
+ assert state.tier == "PRO" and state.generation is None
+ assert await case.counters(None) == (149, 149)
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+ assert (
+ result is not None and not result.usage_reset and result.activation_id is None
+ )
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == 0
+
+
+async def test_paid_upgrade_preserves_existing_generation(activation_case):
+ case = activation_case
+ await case.add_trial(100)
+ assert await case.activate()
+ before = await get_usage_activation_state(case.user_id)
+ await case.add_cost(before.generation, 151)
+ await User.prisma().update(
+ where={"id": case.user_id}, data={"subscriptionTier": "BASIC"}
+ )
+ add_proration(case)
+
+ await credit.sync_subscription_from_stripe(case.subscription, track_lifecycle=False)
+
+ assert await get_usage_activation_state(case.user_id) == before
+ assert await case.counters(before.generation) == (151, 151)
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+ assert (
+ result is not None and not result.usage_reset and result.activation_id is None
+ )
+
+
[email protected]("history", [False, True])
+async def test_proration_without_initial_paid_service_does_not_activate(
+ activation_case, history
+):
+ case = activation_case
+ if history:
+ case.invoice["lines"]["data"][0]["amount"] = 0
+ add_proration(case)
+ else:
+ case.invoice["billing_reason"] = "subscription_update"
+ case.invoice["lines"]["data"][0]["proration"] = True
+
+ await credit.sync_subscription_from_stripe(case.subscription, track_lifecycle=False)
+
+ state = await get_usage_activation_state(case.user_id)
+ assert state.tier == "NO_TIER" and state.generation is None
+
+
+ "invalid", ["open", "foreign_price", "foreign_subscription", "quantity"]
+)
+async def test_paid_history_cannot_legitimize_invalid_current_proration(
+ activation_case, invalid
+):
+ case = activation_case
+ case.invoice["lines"]["data"][0]["price"]["id"] = "price_basic"
+ await User.prisma().update(
+ where={"id": case.user_id}, data={"subscriptionTier": "BASIC"}
+ )
+ invoice = add_proration(case)
+ line = invoice["lines"]["data"][0]
+ if invalid == "open":
+ invoice.update(status="open", amount_remaining=1000)
+ elif invalid == "foreign_price":
+ line["price"]["id"] = "price_other"
+ elif invalid == "foreign_subscription":
+ line["subscription"] = "sub_other"
+ else:
+ line["quantity"] = 2
+
+ await credit.sync_subscription_from_stripe(case.subscription, track_lifecycle=False)
+
+ state = await get_usage_activation_state(case.user_id)
+ assert state.tier == "BASIC" and state.generation is None
+
+
+async def test_known_different_trial_subscription_does_not_block_paid_signup(
+ activation_case,
+):
+ case = activation_case
+ trial = await case.add_trial(100)
+ await SubscriptionTrial.prisma().update(
+ where={"id": trial.id},
+ data={"stripeSubscriptionId": "sub_previous_trial", "status": "canceled"},
+ )
+ del case.subscription["metadata"]["trial_enrollment_id"]
+ before = await SubscriptionTrial.prisma().find_unique_or_raise(
+ where={"id": trial.id}
+ )
+ await case.add_cost(None, 153)
+
+ await credit.sync_subscription_from_stripe(case.subscription, track_lifecycle=False)
+
+ state = await get_usage_activation_state(case.user_id)
+ assert state.tier == "PRO" and state.generation is None
+ assert await case.counters(None) == (153, 153)
+ assert (
+ await SubscriptionTrial.prisma().find_unique_or_raise(where={"id": trial.id})
+ == before
+ )
+
+
[email protected]("identity", ["same", "unknown"])
+async def test_missing_trial_metadata_stays_closed_without_distinct_identity(
+ activation_case, identity
+):
+ case = activation_case
+ trial = await case.add_trial(100)
+ if identity == "unknown":
+ await SubscriptionTrial.prisma().update(
+ where={"id": trial.id}, data={"stripeSubscriptionId": None}
+ )
+ del case.subscription["metadata"]["trial_enrollment_id"]
+
+ with pytest.raises(ValueError, match="matching enrollment"):
+ await credit.sync_subscription_from_stripe(
+ case.subscription, track_lifecycle=False
+ )
+ assert (await get_usage_activation_state(case.user_id)).generation is None
+
+
+async def test_repeated_paid_result_identifies_current_activation_without_erasing_usage(
+ activation_case,
+):
+ case = activation_case
+ await case.add_trial(100)
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+ state = await get_usage_activation_state(case.user_id)
+ assert result is not None and result.usage_reset
+ assert result.activation_id == state.generation and state.generation
+ await case.add_cost(state.generation, 157)
+
+ assert (
+ await reconcile_paid_activation(case.user_id, case.subscription["id"]) == result
+ )
+ assert await get_usage_activation_state(case.user_id) == state
+ assert await case.counters(state.generation) == (157, 157)
+
+
+async def test_renewal_paid_result_does_not_announce_initial_reset(activation_case):
+ case = activation_case
+ await case.add_trial(100)
+ assert await case.activate()
+ before = await get_usage_activation_state(case.user_id)
+ await case.add_cost(before.generation, 159)
+ renewal = deepcopy(case.invoice)
+ renewal.update(id="in_renewal", billing_reason="subscription_cycle")
+ renewal["created"] += 30 * 86400
+ renewal["status_transitions"]["paid_at"] += 30 * 86400
+ renewal["lines"]["data"][0]["period"]["start"] += 30 * 86400
+ renewal["lines"]["data"][0]["period"]["end"] += 30 * 86400
+ case.invoices.append(renewal)
+ case.subscription["latest_invoice"] = renewal["id"]
+
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+
+ assert (
+ result is not None and not result.usage_reset and result.activation_id is None
+ )
+ assert await get_usage_activation_state(case.user_id) == before
+ assert await case.counters(before.generation) == (159, 159)
+
+
[email protected]("history", ["returning", "prepolicy"])
+async def test_paid_result_without_activation_does_not_announce_a_reset(
+ activation_case, history
+):
+ case = activation_case
+ if history == "returning":
+ previous = deepcopy(case.invoice)
+ previous.update(id="in_previous", subscription="sub_previous")
+ previous["lines"]["data"][0]["subscription"] = "sub_previous"
+ previous["created"] -= 60
+ previous["status_transitions"]["paid_at"] -= 60
+ case.invoices.append(previous)
+ else:
+ policy = await db.prisma.paidusageactivationpolicy.find_unique_or_raise(
+ where={"id": "initial-pro-v1"}
+ )
+ case.invoice["status_transitions"]["paid_at"] = (
+ int(policy.startsAt.timestamp()) - 1
+ )
+ await case.add_cost(None, 163)
+
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+
+ assert (
+ result is not None and not result.usage_reset and result.activation_id is None
+ )
+ assert (await get_usage_activation_state(case.user_id)).generation is None
+ assert await case.counters(None) == (163, 163)
+
+
+async def test_returning_subscription_does_not_announce_old_lifetime_generation(
+ activation_case,
+):
+ case = activation_case
+ await case.add_trial(100)
+ assert await case.activate()
+ before = await get_usage_activation_state(case.user_id)
+ await case.add_cost(before.generation, 167)
+ new_invoice = deepcopy(case.invoice)
+ new_invoice.update(id="in_returning", subscription="sub_returning")
+ new_invoice["lines"]["data"][0]["subscription"] = "sub_returning"
+ new_invoice["created"] += 60
+ new_invoice["status_transitions"]["paid_at"] += 60
+ case.invoices.append(new_invoice)
+ case.subscription.update(id="sub_returning", latest_invoice="in_returning")
+ del case.subscription["metadata"]["trial_enrollment_id"]
+ await User.prisma().update(
+ where={"id": case.user_id}, data={"subscriptionTier": "NO_TIER"}
+ )
+
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+
+ assert (
+ result is not None and not result.usage_reset and result.activation_id is None
+ )
+ assert await get_usage_activation_state(case.user_id) == before
+ assert await case.counters(before.generation) == (167, 167)
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_recovery_test.py b/autogpt_platform/backend/backend/data/subscription_activation_recovery_test.py
new file mode 100644
index 0000000000..ff7c87f6e7
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_recovery_test.py
@@ -0,0 +1,283 @@
+"""Recovery distinguishes paid access, initial resets, and unrelated plans."""
+
+from datetime import UTC, datetime
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from prisma.enums import SubscriptionTier
+
+from backend.data import subscription_activation_checkout as checkout
+from backend.data import subscription_activation_checkout_fixtures as fixtures
+from backend.data import subscription_activation_stripe as billing
+from backend.data.subscription_activation_models import PaidActivationResult
+
+pytest_plugins = ("backend.data.subscription_trial_fixtures",)
+
+attempt = fixtures.attempt
+boundaries = fixtures.boundaries
+live_subscription = fixtures.live_subscription
+
+
+async def test_confirmed_recovery_uses_invoice_settled_after_initial_snapshot(
+ recovery, live_subscription, attempt
+):
+ recovery.get_attempt.return_value = attempt.model_copy(
+ update={"confirmed_at": datetime.now(UTC)}
+ )
+ live_subscription.status = "trialing"
+ recovery.reconcile_paid_activation.return_value = PaidActivationResult(
+ invoice_id="in_conversion", usage_reset=True, activation_id="generation-1"
+ )
+ response = await checkout.get_activation(attempt.user_id, attempt.id)
+ assert response.status == "ready" and response.usage_reset
+ assert response.invoice_id == "in_conversion"
+ recovery.stripe_call.assert_not_awaited()
+
+
+def recovery(monkeypatch, boundaries, live_subscription):
+ live_subscription.status = "active"
+ live_subscription.latest_invoice = billing.BillingInvoice(
+ id="in_paid", customer=live_subscription.customer, status="paid"
+ )
+ monkeypatch.setattr(
+ checkout.User,
+ "prisma",
+ lambda: MagicMock(
+ find_unique_or_raise=AsyncMock(
+ return_value=SimpleNamespace(stripeCustomerId="cus_1")
+ )
+ ),
+ )
+ boundaries.get_attempt.return_value = None
+ boundaries.stripe_call.return_value = SimpleNamespace(
+ data=[live_subscription], has_more=False
+ )
+ monkeypatch.setattr(
+ checkout, "activation_return_to", AsyncMock(return_value="/chat/resume")
+ )
+ return boundaries
+
+
[email protected]("activation_id", [None, "generation-1"])
+async def test_current_distinguishes_paid_readiness_from_initial_reset(
+ recovery, activation_id
+):
+ recovery.reconcile_paid_activation.return_value = PaidActivationResult(
+ invoice_id="in_paid",
+ usage_reset=activation_id is not None,
+ activation_id=activation_id,
+ )
+ for _ in range(2):
+ response = await checkout.current_activation("user-1")
+ assert response.status == "ready"
+ assert response.usage_reset is (activation_id is not None)
+ assert response.activation_id == activation_id
+ assert response.return_to == "/chat/resume"
+ assert all(
+ call.args[0].__name__ == "list_async"
+ for call in recovery.stripe_call.await_args_list
+ )
+
+
[email protected]("tier", [SubscriptionTier.BASIC, SubscriptionTier.BUSINESS])
[email protected]("has_attempt", [False, True])
+async def test_non_target_recovery_is_terminal(
+ recovery, live_subscription, attempt, monkeypatch, tier, has_attempt
+):
+ live_subscription.items.data[0].price.id = "price_other"
+ monkeypatch.setattr(
+ "backend.data.credit.build_price_to_tier_map",
+ AsyncMock(return_value={"price_other": tier}),
+ )
+ monkeypatch.setattr(billing, "get_subscription_trial", AsyncMock(return_value=None))
+ if has_attempt:
+ recovery.get_attempt.return_value = attempt
+ for _ in range(2):
+ response = await checkout.current_activation("user-1")
+ assert response.status == "not_applicable"
+ assert response.retry_after_seconds is None
+ assert response.error_code == "not_paid_activation_subscription"
+ assert not response.usage_reset and response.activation_id is None
+ assert response.return_to == (
+ attempt.return_to if has_attempt else "/chat/resume"
+ )
+ recovery.reconcile_paid_activation.assert_not_awaited()
+
+
+async def test_unknown_price_is_processing_without_claiming_failure_or_reset(
+ recovery, live_subscription, monkeypatch
+):
+ live_subscription.items.data[0].price.id = "price_unknown"
+ monkeypatch.setattr(
+ "backend.data.credit.build_price_to_tier_map", AsyncMock(return_value={})
+ )
+ monkeypatch.setattr(billing, "get_subscription_trial", AsyncMock(return_value=None))
+ response = await checkout.current_activation("user-1")
+ assert response.status == "processing"
+ assert response.error_code == "plan_unavailable"
+ assert response.retry_after_seconds == 3
+ recovery.reconcile_paid_activation.assert_not_awaited()
+
+
+async def test_current_skips_non_target_to_recover_paid_signup(
+ recovery, live_subscription, monkeypatch
+):
+ other = live_subscription.model_copy(deep=True)
+ other.id = "sub_business"
+ other.items.data[0].price.id = "price_business"
+ recovery.stripe_call.return_value.data = [other, live_subscription]
+ recovery.owned_subscription.side_effect = [other, live_subscription]
+ recovery.reconcile_paid_activation.return_value = PaidActivationResult(
+ invoice_id="in_paid", usage_reset=True, activation_id="generation-1"
+ )
+ monkeypatch.setattr(
+ "backend.data.credit.build_price_to_tier_map",
+ AsyncMock(
+ return_value={
+ "price_business": SubscriptionTier.BUSINESS,
+ "price_pro": SubscriptionTier.PRO,
+ }
+ ),
+ )
+ response = await checkout.current_activation("user-1")
+ assert response.status == "ready" and response.activation_id == "generation-1"
+ recovery.reconcile_paid_activation.assert_awaited_once_with(
+ "user-1", "sub_1", expected_price_id=None
+ )
+
+
+async def test_current_recognizes_original_trial_price_after_offer_changes(
+ recovery, live_subscription, trial, monkeypatch
+):
+ trial.subscription_id = live_subscription.id
+ live_subscription.items.data[0].price.id = trial.offer.price_id
+ prices = AsyncMock(return_value={})
+ monkeypatch.setattr("backend.data.credit.build_price_to_tier_map", prices)
+ recovery.reconcile_paid_activation.return_value = PaidActivationResult(
+ invoice_id="in_paid", usage_reset=True, activation_id="generation-1"
+ )
+ response = await checkout.current_activation("user-1")
+ assert response.status == "ready" and response.usage_reset
+ prices.assert_not_awaited()
+
+
[email protected]("ambiguous", ["quantity", "multiple", "paginated"])
+async def test_ambiguous_plan_remains_processing(
+ recovery, live_subscription, ambiguous
+):
+ if ambiguous == "quantity":
+ live_subscription.items.data[0].quantity = 2
+ elif ambiguous == "multiple":
+ live_subscription.items.data.append(live_subscription.items.data[0])
+ else:
+ live_subscription.items.has_more = True
+ response = await checkout.current_activation("user-1")
+ assert response.status == "processing" and response.error_code == "plan_unavailable"
+ recovery.reconcile_paid_activation.assert_not_awaited()
+
+
+ "plan,status,error_code",
+ [
+ ("non_pro", "not_applicable", "not_paid_activation_subscription"),
+ ("unknown", "processing", "plan_unavailable"),
+ ("quantity", "processing", "plan_unavailable"),
+ ("multiple", "processing", "plan_unavailable"),
+ ("paginated", "processing", "plan_unavailable"),
+ ("changed_pro", "processing", "terms_changed"),
+ ],
+)
+async def test_unconfirmed_trial_classifies_changed_plan_before_confirmation(
+ recovery, live_subscription, attempt, monkeypatch, plan, status, error_code
+):
+ recovery.get_attempt.return_value = attempt
+ live_subscription.status = "trialing"
+ prices = AsyncMock(
+ return_value={
+ "price_other": SubscriptionTier.BUSINESS,
+ "price_changed": SubscriptionTier.PRO,
+ }
+ )
+ monkeypatch.setattr(billing, "get_subscription_trial", AsyncMock(return_value=None))
+ monkeypatch.setattr("backend.data.credit.build_price_to_tier_map", prices)
+ if plan == "non_pro":
+ live_subscription.items.data[0].price.id = "price_other"
+ elif plan == "unknown":
+ live_subscription.items.data[0].price.id = "price_unknown"
+ elif plan == "quantity":
+ live_subscription.items.data[0].quantity = 2
+ elif plan == "multiple":
+ live_subscription.items.data.append(live_subscription.items.data[0])
+ elif plan == "paginated":
+ live_subscription.items.has_more = True
+ else:
+ live_subscription.items.data[0].price.id = "price_changed"
+
+ response = await checkout.current_activation("user-1")
+
+ assert response.status == status
+ assert response.error_code == error_code
+ assert response.return_to == attempt.return_to
+ assert not response.usage_reset and response.activation_id is None
+ assert prices.await_count <= 1
+ recovery.reconcile_paid_activation.assert_not_awaited()
+ assert all(
+ call.args[0].__name__ == "list_async"
+ for call in recovery.stripe_call.await_args_list
+ )
+
+
+async def test_unconfirmed_original_trial_keeps_confirmation_without_reconciliation(
+ recovery, live_subscription, attempt, monkeypatch
+):
+ recovery.get_attempt.return_value = attempt
+ live_subscription.status = "trialing"
+ prices = AsyncMock(return_value={})
+ monkeypatch.setattr("backend.data.credit.build_price_to_tier_map", prices)
+
+ response = await checkout.current_activation("user-1")
+
+ assert response.status == "confirmation_required"
+ assert response.terms == attempt.terms
+ assert response.retry_after_seconds is None
+ prices.assert_not_awaited()
+ recovery.reconcile_paid_activation.assert_not_awaited()
+ recovery.stripe_call.assert_not_awaited()
+
+
+async def test_current_non_pro_subscription_supersedes_a_failed_old_attempt(
+ recovery, live_subscription, attempt, monkeypatch
+):
+ attempt.subscription_id = "sub_old"
+ old = live_subscription.model_copy(
+ update={"id": attempt.subscription_id, "status": "canceled"}, deep=True
+ )
+ live_subscription.id = "sub_new"
+ live_subscription.items.data[0].price.id = "price_business"
+ recovery.get_attempt.return_value = attempt
+ recovery.owned_subscription.side_effect = [old, live_subscription]
+ monkeypatch.setattr(billing, "get_subscription_trial", AsyncMock(return_value=None))
+ monkeypatch.setattr(
+ "backend.data.credit.build_price_to_tier_map",
+ AsyncMock(return_value={"price_business": SubscriptionTier.BUSINESS}),
+ )
+
+ response = await checkout.current_activation("user-1")
+
+ assert response.status == "not_applicable"
+ assert response.error_code == "not_paid_activation_subscription"
+ assert response.return_to == "/chat/resume"
+ assert not response.usage_reset and response.activation_id is None
+ recovery.reconcile_paid_activation.assert_not_awaited()
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_return.py b/autogpt_platform/backend/backend/data/subscription_activation_return.py
new file mode 100644
index 0000000000..08bd627d31
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_return.py
@@ -0,0 +1,54 @@
+"""Recover a paid Checkout's owned and origin-validated return destination."""
+
+from urllib.parse import urlsplit
+
+import stripe
+
+from backend.data.stripe_client import stripe_call, stripe_list_items
+from backend.data.subscription_activation_models import ActivationPreviewRequest
+from backend.data.subscription_activation_stripe import BillingSubscription
+from backend.util.settings import Settings
+
+
+async def activation_return_to(subscription: BillingSubscription) -> str:
+ destination = subscription.metadata.get("pro_activation_return_to")
+ if destination:
+ return ActivationPreviewRequest(return_to=destination).return_to
+ sessions = await stripe_call(
+ stripe.checkout.Session.list_async,
+ subscription=subscription.id,
+ customer=subscription.customer,
+ limit=100,
+ )
+ async for session in stripe_list_items(sessions):
+ if (
+ session.customer != subscription.customer
+ or session.subscription != subscription.id
+ or session.mode != "subscription"
+ or not session.success_url
+ ):
+ continue
+ return checkout_destination(
+ session.success_url.replace("{CHECKOUT_SESSION_ID}", session.id)
+ )
+ return "/settings/billing"
+
+
+def checkout_destination(success_url: str) -> str:
+ config = Settings().config
+ origin = config.frontend_base_url or config.platform_base_url
+ expected = urlsplit(origin or "")
+ parsed = urlsplit(success_url)
+ if (
+ not origin
+ or parsed.scheme not in ("http", "https")
+ or parsed.scheme != expected.scheme
+ or parsed.netloc != expected.netloc
+ or "@" in parsed.netloc
+ or "\\" in success_url
+ or any(ord(char) < 32 for char in success_url)
+ ):
+ return "/settings/billing"
+ path = (parsed.path or "/") + (f"?{parsed.query}" if parsed.query else "")
+ path += f"#{parsed.fragment}" if parsed.fragment else ""
+ return ActivationPreviewRequest(return_to=path).return_to
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_return_test.py b/autogpt_platform/backend/backend/data/subscription_activation_return_test.py
new file mode 100644
index 0000000000..83443b339e
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_return_test.py
@@ -0,0 +1,85 @@
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from backend.data import subscription_activation_return as destination
+from backend.data.subscription_activation_stripe import BillingSubscription
+
+
+def subscription(metadata=None):
+ return BillingSubscription.model_validate(
+ {
+ "id": "sub_1",
+ "customer": "cus_1",
+ "status": "active",
+ "metadata": metadata or {},
+ "items": {"data": []},
+ }
+ )
+
+
+async def test_short_metadata_destination_needs_no_checkout_fetch(monkeypatch):
+ fetch = AsyncMock()
+ monkeypatch.setattr(destination, "stripe_call", fetch)
+ assert (
+ await destination.activation_return_to(
+ subscription(
+ {
+ "pro_activation_return_to": "/chat/original?continue=true#latest",
+ }
+ )
+ )
+ == "/chat/original?continue=true#latest"
+ )
+ fetch.assert_not_awaited()
+
+
+async def test_owned_checkout_restores_long_destination(monkeypatch):
+ return_to = f"/chat/original?context={'a' * 700}#latest"
+ session = SimpleNamespace(
+ id="cs_1",
+ customer="cus_1",
+ subscription="sub_1",
+ mode="subscription",
+ success_url=f"https://app.test{return_to}",
+ )
+ monkeypatch.setattr(
+ destination,
+ "stripe_call",
+ AsyncMock(return_value=SimpleNamespace(data=[session], has_more=False)),
+ )
+ monkeypatch.setattr(
+ destination,
+ "Settings",
+ lambda: SimpleNamespace(
+ config=SimpleNamespace(
+ frontend_base_url="https://app.test", platform_base_url=None
+ )
+ ),
+ )
+ assert await destination.activation_return_to(subscription()) == return_to
+
+
+ "url",
+ [
+ "https://attacker.test/chat",
+ "//app.test/chat",
+ "https://[email protected]/chat",
+ "https://app.test/\\evil",
+ ],
+)
+def test_checkout_return_rejects_untrusted_origin(monkeypatch, url):
+ monkeypatch.setattr(
+ destination,
+ "Settings",
+ lambda: SimpleNamespace(
+ config=SimpleNamespace(
+ frontend_base_url="https://app.test", platform_base_url=None
+ )
+ ),
+ )
+ assert destination.checkout_destination(url) == "/settings/billing"
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_status_integration_test.py b/autogpt_platform/backend/backend/data/subscription_activation_status_integration_test.py
new file mode 100644
index 0000000000..4e9b2ba5ff
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_status_integration_test.py
@@ -0,0 +1,70 @@
+"""Full recovery reads publish one reset and preserve subsequent paid usage."""
+
+import os
+
+import pytest
+import stripe
+from prisma.enums import SubscriptionTier
+from prisma.models import SubscriptionTrial
+
+from backend.data import credit
+from backend.data import subscription_activation_integration_fixtures as fixtures
+from backend.data.subscription_activation_checkout import current_activation
+
+activation_case = fixtures.activation_case
+pytestmark = pytest.mark.skipif(
+ os.environ.get("TRIAL_TEST_DATABASE") != "1",
+ reason="Requires explicitly selected disposable database and Redis",
+)
+
+
[email protected]("trial_cost", [None, 25, 100])
[email protected]("tier", ["PRO", "MAX"])
+async def test_current_completes_activation_and_keeps_paid_usage_on_repeated_reads(
+ activation_case, mocker, trial_cost, tier
+):
+ case = activation_case
+ case.select_plan(tier)
+ trial = await case.add_trial(trial_cost, tier) if trial_cost is not None else None
+ await case.add_cost(None, 173)
+ case.subscription["metadata"]["pro_activation_return_to"] = "/chat/resume?kept=1"
+ case.subscription["items"]["data"][0]["price"].update(
+ unit_amount=2000,
+ currency="usd",
+ recurring={"interval": "month", "interval_count": 1},
+ )
+ mocker.patch.object(
+ credit,
+ "build_price_to_tier_map",
+ return_value={
+ "price_pro": SubscriptionTier.PRO,
+ "price_max": SubscriptionTier.MAX,
+ },
+ )
+ mocker.patch.object(credit, "schedule_posthog_lifecycle_sync")
+ mocker.patch(
+ "stripe.Subscription.list_async",
+ return_value=stripe.ListObject.construct_from(
+ {"object": "list", "data": [case.subscription], "has_more": False}, None
+ ),
+ )
+ charge = mocker.patch("stripe.Subscription.modify_async")
+ response = await current_activation(case.user_id)
+ assert response.status == "ready" and response.usage_reset == (trial is not None)
+ assert bool(response.activation_id) == (trial is not None)
+ assert response.return_to == "/chat/resume?kept=1"
+ initial_cost = 0 if trial else 173
+ assert await case.counters(response.activation_id) == (initial_cost, initial_cost)
+ await case.add_cost(response.activation_id, 179)
+
+ for _ in range(2):
+ assert await current_activation(case.user_id) == response
+ assert await case.counters(response.activation_id) == (initial_cost + 179,) * 2
+ assert await case.counters(None) == ((173 if trial else 352),) * 2
+ charge.assert_not_called()
+ if trial:
+ saved = await SubscriptionTrial.prisma().find_unique_or_raise(
+ where={"id": trial.id}
+ )
+ assert saved.convertedAt and saved.costMicrodollars == trial_cost
+ assert saved.consumedAt == trial.consumed_at
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_stripe.py b/autogpt_platform/backend/backend/data/subscription_activation_stripe.py
new file mode 100644
index 0000000000..ecc4aef6b7
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_stripe.py
@@ -0,0 +1,303 @@
+"""Live owned subscription and invoice previews for explicit trial conversion."""
+
+from datetime import UTC, datetime, timedelta
+from typing import TypedDict
+
+import stripe
+from prisma.enums import SubscriptionTier
+from prisma.models import User
+
+from backend.data import credit
+from backend.data.stripe_client import stripe_call
+from backend.data.subscription_activation_models import (
+ ActivationItem,
+ ActivationPlan,
+ ActivationPrice,
+ ActivationTerms,
+ ActivationUnavailable,
+ BillingInvoice,
+ BillingSubscription,
+ InvoicePreview,
+ RenewalDiscount,
+ RenewalTax,
+)
+from backend.data.subscription_trial import TrialState, get_subscription_trial
+from backend.data.subscription_trial_payment import SubscriptionPlanTerms
+
+
+class SubscriptionItemsUpdate(TypedDict, total=False):
+ items: list[stripe.Subscription.ModifyParamsItem]
+
+
+async def owned_subscription(user_id: str, subscription_id: str) -> BillingSubscription:
+ user = await User.prisma().find_unique_or_raise(where={"id": user_id})
+ sub = BillingSubscription.model_validate(
+ await stripe_call(
+ stripe.Subscription.retrieve_async,
+ subscription_id,
+ expand=["latest_invoice"],
+ )
+ )
+ if (
+ sub.id != subscription_id
+ or sub.customer != user.stripeCustomerId
+ or sub.metadata.get("user_id") != user_id
+ or (sub.latest_invoice and sub.latest_invoice.customer != sub.customer)
+ ):
+ raise ActivationUnavailable("Subscription ownership could not be established")
+ return sub
+
+
+async def is_paid_activation_subscription(
+ user_id: str, sub: BillingSubscription, accepted_price_id: str | None = None
+) -> bool | None:
+ if sub.items.has_more or len(sub.items.data) != 1:
+ return None
+ item = sub.items.data[0]
+ if item.quantity != 1:
+ return None
+ if accepted_price_id == item.price.id:
+ return True
+ trial = await get_subscription_trial(user_id)
+ if (
+ trial
+ and trial.subscription_id == sub.id
+ and trial.offer.tier in ("PRO", "MAX")
+ and trial.offer.price_id == item.price.id
+ ):
+ return True
+ chosen = SubscriptionPlanTerms.model_validate(sub.model_dump()).chosen_plan()
+ if (
+ trial
+ and sub.status == "active"
+ and trial.subscription_id == sub.id
+ and trial.customer_id == sub.customer
+ and sub.metadata.get("user_id") == trial.user_id == user_id
+ and sub.metadata.get("trial_enrollment_id") == trial.id
+ and sub.metadata.get("trial_checkout_attempt") == str(trial.checkout_attempt)
+ and not sub.metadata.get("pro_activation_attempt_id")
+ and chosen
+ and chosen.tier in (SubscriptionTier.PRO, SubscriptionTier.MAX)
+ ):
+ return True
+ tier = (await credit.build_price_to_tier_map()).get(item.price.id)
+ return (
+ tier in (SubscriptionTier.PRO, SubscriptionTier.MAX)
+ if tier is not None
+ else None
+ )
+
+
+async def conversion_trial(user_id: str) -> tuple[TrialState, BillingSubscription]:
+ trial = await get_subscription_trial(user_id)
+ if (
+ trial is None
+ or not trial.subscription_id
+ or not trial.consumed_at
+ or trial.converted_at
+ ):
+ raise ActivationUnavailable("No unconverted trial is available")
+ sub = await owned_subscription(user_id, trial.subscription_id)
+ if (
+ sub.status != "trialing"
+ or sub.cancel_at_period_end
+ or sub.metadata.get("trial_enrollment_id") != trial.id
+ or sub.customer != trial.customer_id
+ ):
+ raise ActivationUnavailable("The trial has ended or is no longer available")
+ return trial, sub
+
+
+async def quote_terms(
+ trial: TrialState,
+ sub: BillingSubscription,
+ plan: ActivationPlan | None = None,
+ *,
+ accepted_price_id: str | None = None,
+) -> ActivationTerms:
+ item = accepted_trial_item(trial, sub)
+ target = plan or trial.offer.tier
+ if target not in ("PRO", "MAX"):
+ raise ActivationUnavailable("The trial must convert to Pro or Max")
+ price = item.price
+ if target != trial.offer.tier:
+ require_plan_change_window(sub)
+ price = await alternate_price(trial, target, accepted_price_id)
+ updates = subscription_item_update(sub, price.id)
+ raw_preview = await stripe_call(
+ stripe.Invoice.create_preview_async,
+ customer=sub.customer,
+ subscription=sub.id,
+ subscription_details={
+ "trial_end": "now",
+ "proration_behavior": "none",
+ **updates,
+ },
+ expand=["discounts.coupon.applies_to"],
+ )
+ preview = InvoicePreview.model_validate(raw_preview)
+ if preview.customer != sub.customer or preview.currency != price.currency:
+ raise ActivationUnavailable(
+ "The invoice preview does not match the subscription"
+ )
+ return _quoted_terms(trial, sub, target, price, preview)
+
+
+def _quoted_terms(
+ trial: TrialState,
+ sub: BillingSubscription,
+ target: ActivationPlan,
+ price: ActivationPrice,
+ preview: InvoicePreview,
+) -> ActivationTerms:
+ return ActivationTerms(
+ plan=target,
+ price_id=price.id,
+ accepted_offer_token=trial.offer.token,
+ amount_due=preview.amount_due,
+ currency=price.currency,
+ billing_interval=price.recurring.interval,
+ billing_interval_count=price.recurring.interval_count,
+ renewal_unit_amount=price.unit_amount,
+ renewal_discounts=_applicable_discounts(preview, price),
+ renewal_tax=RenewalTax(
+ automatic=sub.automatic_tax.enabled,
+ price_tax_behavior=price.tax_behavior,
+ rates=sub.default_tax_rates,
+ ),
+ renewal_terms=(
+ f"Your {target.title()} subscription renews automatically every "
+ f"{price.recurring.interval} at the "
+ "displayed recurring price. The displayed discount terms and applicable "
+ "taxes apply. Your paid billing period starts when you confirm and end "
+ "the trial. Cancel before the next renewal to avoid the next charge."
+ ),
+ expires_at=datetime.now(UTC) + timedelta(minutes=15),
+ )
+
+
+def _applicable_discounts(
+ preview: InvoicePreview, price: ActivationPrice
+) -> list[RenewalDiscount]:
+ if (
+ any(discount.coupon.applies_to for discount in preview.discounts)
+ and not price.product
+ ):
+ raise ActivationUnavailable("Discount applicability could not be established")
+ return [
+ RenewalDiscount(**discount.coupon.model_dump(), ends_at=discount.end)
+ for discount in preview.discounts
+ if discount.coupon.applies_to is None
+ or price.product in discount.coupon.applies_to.products
+ ]
+
+
+def accepted_trial_item(trial: TrialState, sub: BillingSubscription) -> ActivationItem:
+ if sub.items.has_more or len(sub.items.data) != 1:
+ raise ActivationUnavailable("The subscription must retain its accepted plan")
+ item = sub.items.data[0]
+ price = item.price
+ interval = "month" if trial.offer.billing_cycle == "monthly" else "year"
+ if (
+ item.quantity != 1
+ or price.id != trial.offer.price_id
+ or price.unit_amount != trial.offer.unit_amount
+ or price.currency != trial.offer.currency
+ or price.recurring.interval != interval
+ or price.recurring.interval_count != 1
+ ):
+ raise ActivationUnavailable("The subscription no longer matches accepted terms")
+ return item
+
+
+async def alternate_price(
+ trial: TrialState, plan: ActivationPlan, accepted_price_id: str | None
+) -> ActivationPrice:
+ price_id = accepted_price_id or await credit.get_subscription_price_id(
+ SubscriptionTier(plan), trial.offer.billing_cycle
+ )
+ if not price_id or price_id == trial.offer.price_id:
+ raise ActivationUnavailable("The selected plan price is unavailable")
+ price = ActivationPrice.model_validate(
+ await stripe_call(stripe.Price.retrieve_async, price_id)
+ )
+ interval = "month" if trial.offer.billing_cycle == "monthly" else "year"
+ if (
+ price.id != price_id
+ or price.currency != trial.offer.currency
+ or price.recurring.interval != interval
+ or price.recurring.interval_count != 1
+ ):
+ raise ActivationUnavailable(
+ "The selected price does not match the billing cycle"
+ )
+ return price
+
+
+def subscription_item_update(
+ sub: BillingSubscription, price_id: str
+) -> SubscriptionItemsUpdate:
+ item = sub.items.data[0]
+ if item.price.id == price_id:
+ return {}
+ if not item.id:
+ raise ActivationUnavailable("The subscription item could not be established")
+ return {"items": [{"id": item.id, "price": price_id, "quantity": 1}]}
+
+
+def require_plan_change_window(sub: BillingSubscription) -> None:
+ if sub.trial_end is None or sub.trial_end <= datetime.now(UTC).timestamp() + 300:
+ raise ActivationUnavailable(
+ "The trial is ending. Recover its payment before changing plans."
+ )
+
+
+async def matches_trial_source(
+ user_id: str, sub: BillingSubscription, terms: ActivationTerms
+) -> bool:
+ trial = await get_subscription_trial(user_id)
+ if (
+ trial is None
+ or trial.subscription_id != sub.id
+ or trial.customer_id != sub.customer
+ or trial.offer.token != terms.accepted_offer_token
+ or sub.metadata.get("trial_enrollment_id") != trial.id
+ or not trial.consumed_at
+ or trial.converted_at
+ ):
+ return False
+ try:
+ accepted_trial_item(trial, sub)
+ except ActivationUnavailable:
+ return False
+ return True
+
+
+async def invoice_payment_intent(invoice: BillingInvoice) -> str | None:
+ if invoice.payment_intent:
+ return invoice.payment_intent
+ if invoice.payments is None:
+ expanded = BillingInvoice.model_validate(
+ await stripe_call(
+ stripe.Invoice.retrieve_async,
+ invoice.id,
+ expand=["payments"],
+ )
+ )
+ if expanded.id != invoice.id or expanded.customer != invoice.customer:
+ raise ActivationUnavailable(
+ "Invoice ownership changed during payment recovery"
+ )
+ invoice = expanded
+ if invoice.payments is None or invoice.payments.has_more:
+ raise ActivationUnavailable("Invoice payment state could not be established")
+ defaults = [
+ payment
+ for payment in invoice.payments.data
+ if payment.is_default
+ and payment.invoice == invoice.id
+ and payment.payment.type == "payment_intent"
+ ]
+ if len(defaults) != 1:
+ return None
+ return defaults[0].payment.payment_intent
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_stripe_test.py b/autogpt_platform/backend/backend/data/subscription_activation_stripe_test.py
new file mode 100644
index 0000000000..997df733e8
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_stripe_test.py
@@ -0,0 +1,158 @@
+"""Stripe API-version compatibility and commercial-term disclosure."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from backend.data import subscription_activation_stripe as billing
+
+pytest_plugins = ("backend.data.subscription_trial_fixtures",)
+
+
[email protected]("expanded", [False, True])
+async def test_basil_invoice_payment_finds_default_intent(monkeypatch, expanded):
+ invoice = {
+ "id": "in_1",
+ "customer": "cus_1",
+ "status": "open",
+ "payments": {
+ "has_more": False,
+ "data": [
+ {
+ "invoice": "in_1",
+ "is_default": True,
+ "payment": {"type": "payment_intent", "payment_intent": "pi_1"},
+ }
+ ],
+ },
+ }
+ retrieve = AsyncMock(return_value=invoice)
+ monkeypatch.setattr(billing, "stripe_call", retrieve)
+ initial = billing.BillingInvoice.model_validate(
+ invoice
+ if expanded
+ else {
+ "id": "in_1",
+ "customer": "cus_1",
+ "status": "open",
+ }
+ )
+ assert await billing.invoice_payment_intent(initial) == "pi_1"
+ assert retrieve.await_count == (0 if expanded else 1)
+
+
+async def test_acacia_invoice_payment_keeps_legacy_intent(monkeypatch):
+ retrieve = AsyncMock()
+ monkeypatch.setattr(billing, "stripe_call", retrieve)
+ invoice = billing.BillingInvoice(
+ id="in_1", customer="cus_1", payment_intent="pi_old"
+ )
+ assert await billing.invoice_payment_intent(invoice) == "pi_old"
+ retrieve.assert_not_awaited()
+
+
+async def test_discount_duration_and_tax_changes_require_new_consent(
+ trial, subscription, monkeypatch
+):
+ subscription["items"]["data"][0]["price"].update(
+ unit_amount=trial.offer.unit_amount,
+ currency=trial.offer.currency,
+ recurring={"interval": "month", "interval_count": 1},
+ )
+ live_subscription = billing.BillingSubscription.model_validate(subscription)
+ invoice = {
+ "customer": "cus_1",
+ "currency": "usd",
+ "amount_due": 2500,
+ "discounts": [{"coupon": {"percent_off": 50, "duration": "forever"}}],
+ }
+ monkeypatch.setattr(billing, "stripe_call", AsyncMock(return_value=invoice))
+ forever = await billing.quote_terms(trial, live_subscription)
+ assert forever.renewal_discounts[0].percent_off == 50
+ assert forever.renewal_discounts[0].duration == "forever"
+ invoice["discounts"][0]["coupon"]["duration"] = "once"
+ once = await billing.quote_terms(trial, live_subscription)
+ assert once.amount_due == forever.amount_due
+ assert not once.same_charge_as(forever)
+ assert once.token != forever.token
+ live_subscription.automatic_tax.enabled = True
+ taxed = await billing.quote_terms(trial, live_subscription)
+ assert not taxed.same_charge_as(once)
+
+
[email protected]("product,discount_count", [("prod_pro", 0), ("prod_max", 1)])
+async def test_alternate_quote_only_discloses_applicable_discounts(
+ trial, subscription, monkeypatch, product, discount_count
+):
+ subscription["items"]["data"][0].update(id="si_owned")
+ subscription["items"]["data"][0]["price"].update(
+ unit_amount=5000,
+ currency="usd",
+ product="prod_pro",
+ recurring={"interval": "month", "interval_count": 1},
+ )
+ live = billing.BillingSubscription.model_validate(subscription)
+ monkeypatch.setattr(
+ billing.credit, "get_subscription_price_id", AsyncMock(return_value="price_max")
+ )
+ price = {
+ "id": "price_max",
+ "product": "prod_max",
+ "unit_amount": 9000,
+ "currency": "usd",
+ "recurring": {"interval": "month", "interval_count": 1},
+ }
+ invoice = {
+ "customer": "cus_1",
+ "currency": "usd",
+ "amount_due": 9000,
+ "discounts": [
+ {
+ "coupon": {
+ "percent_off": 50,
+ "duration": "forever",
+ "applies_to": {"products": [product]},
+ }
+ }
+ ],
+ }
+ calls = AsyncMock(side_effect=[price, invoice])
+ monkeypatch.setattr(billing, "stripe_call", calls)
+ terms = await billing.quote_terms(trial, live, "MAX")
+ assert len(terms.renewal_discounts) == discount_count
+ assert terms.amount_due == 9000
+ assert "discounts.coupon.applies_to" in calls.await_args.kwargs["expand"]
+
+
+async def test_restricted_discount_requires_known_selected_product(
+ trial, subscription, monkeypatch
+):
+ subscription["items"]["data"][0]["price"].update(
+ unit_amount=5000,
+ currency="usd",
+ recurring={"interval": "month", "interval_count": 1},
+ )
+ invoice = {
+ "customer": "cus_1",
+ "currency": "usd",
+ "amount_due": 2500,
+ "discounts": [
+ {
+ "coupon": {
+ "percent_off": 50,
+ "duration": "forever",
+ "applies_to": {"products": ["prod_pro"]},
+ }
+ }
+ ],
+ }
+ monkeypatch.setattr(billing, "stripe_call", AsyncMock(return_value=invoice))
+ with pytest.raises(billing.ActivationUnavailable):
+ await billing.quote_terms(
+ trial, billing.BillingSubscription.model_validate(subscription)
+ )
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_target.py b/autogpt_platform/backend/backend/data/subscription_activation_target.py
new file mode 100644
index 0000000000..b6818e3ed5
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_target.py
@@ -0,0 +1,106 @@
+"""Bind paid trial conversions to accepted terms and consumed checkout proof."""
+
+from datetime import datetime
+
+from prisma import Prisma
+from prisma.enums import SubscriptionTier
+from prisma.models import User
+
+from backend.data.db import query_raw_with_schema
+from backend.data.subscription_activation_models import ActivationAttempt
+from backend.data.subscription_trial import TrialState
+from backend.data.subscription_trial_payment import SubscriptionPlanTerms
+
+PAID_CONVERSION_TIERS = (SubscriptionTier.PRO, SubscriptionTier.MAX)
+
+
+def subscription_price_id(subscription: dict) -> str | None:
+ items = subscription.get("items") or {}
+ data = items.get("data", [])
+ if items.get("has_more") or len(data) != 1 or data[0].get("quantity") != 1:
+ return None
+ return data[0].get("price", {}).get("id")
+
+
+async def accepted_conversion_target(
+ trial: TrialState, subscription: dict, tx: Prisma
+) -> tuple[SubscriptionTier, str] | None:
+ """Resolve original accepted terms or an immutable confirmed plan change."""
+ price_id = subscription_price_id(subscription)
+ metadata = subscription.get("metadata") or {}
+ if (
+ not price_id
+ or subscription.get("customer") != trial.customer_id
+ or metadata.get("user_id") != trial.user_id
+ or metadata.get("trial_enrollment_id") != trial.id
+ or metadata.get("trial_checkout_attempt") != str(trial.checkout_attempt)
+ or (trial.subscription_id and subscription.get("id") != trial.subscription_id)
+ ):
+ return None
+ if price_id == trial.offer.price_id and trial.offer.tier in PAID_CONVERSION_TIERS:
+ return SubscriptionTier(trial.offer.tier), price_id
+ attempt_id = metadata.get("pro_activation_attempt_id")
+ if not attempt_id:
+ chosen = SubscriptionPlanTerms.model_validate(subscription).chosen_plan()
+ if (
+ subscription.get("status") == "active"
+ and chosen
+ and chosen.tier in PAID_CONVERSION_TIERS
+ ):
+ return chosen.tier, chosen.price.id
+ return None
+ rows = await query_raw_with_schema(
+ 'SELECT "id", "userId" AS user_id, '
+ '"stripeSubscriptionId" AS subscription_id, '
+ '"stripeCustomerId" AS customer_id, "terms", "returnTo" AS return_to, '
+ '"confirmedAt" AS confirmed_at, "invoiceId" AS invoice_id '
+ 'FROM {schema_prefix}"ProActivationAttempt" '
+ 'WHERE "id" = $1 AND "userId" = $2 AND "confirmedAt" IS NOT NULL',
+ attempt_id,
+ trial.user_id,
+ client=tx,
+ model=ActivationAttempt,
+ )
+ if not rows:
+ return None
+ attempt = rows[0]
+ if (
+ attempt.id != attempt_id
+ or attempt.confirmed_at is None
+ or attempt.user_id != trial.user_id
+ or attempt.customer_id != trial.customer_id
+ or attempt.subscription_id != subscription.get("id")
+ or attempt.terms.accepted_offer_token != trial.offer.token
+ or attempt.terms.price_id != price_id
+ or attempt.terms.plan not in PAID_CONVERSION_TIERS
+ ):
+ return None
+ return SubscriptionTier(attempt.terms.plan), price_id
+
+
+def owns_consumed_trial(user: User, subscription: dict, trial: TrialState) -> bool:
+ metadata = subscription.get("metadata") or {}
+ return bool(
+ trial.consumed_at is not None
+ and trial.user_id == user.id
+ and trial.customer_id == user.stripeCustomerId == subscription.get("customer")
+ and trial.subscription_id == subscription.get("id")
+ and metadata.get("user_id") == trial.user_id
+ and metadata.get("trial_enrollment_id") == trial.id
+ and metadata.get("trial_checkout_attempt") == str(trial.checkout_attempt)
+ and subscription.get("trial_end") is not None
+ )
+
+
+async def record_checkout_consumption(
+ trial: TrialState, subscription_id: str, now: datetime, tx: Prisma
+) -> None:
+ """Persist verified Checkout proof before publishing a delayed conversion."""
+ if trial.consumed_at is not None and trial.subscription_id is not None:
+ return
+ trial.consumed_at = trial.consumed_at or now
+ trial.subscription_id = subscription_id
+ await tx.subscriptiontrial.update(
+ where={"userId": trial.user_id},
+ data={"consumedAt": trial.consumed_at, "stripeSubscriptionId": subscription_id},
+ )
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_target_recovery_test.py b/autogpt_platform/backend/backend/data/subscription_activation_target_recovery_test.py
new file mode 100644
index 0000000000..436f7fa2f9
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_target_recovery_test.py
@@ -0,0 +1,168 @@
+"""Recover selected targets without confusing scheduled or later paid plans."""
+
+from datetime import UTC, datetime
+from unittest.mock import AsyncMock
+
+import pytest
+import stripe
+
+from backend.data import subscription_activation_checkout as checkout
+from backend.data import subscription_activation_checkout_fixtures as fixtures
+from backend.data import subscription_activation_stripe as billing
+from backend.data.subscription_activation_models import ActivationConfirmRequest
+
+pytest_plugins = ("backend.data.subscription_trial_fixtures",)
+max_attempt = fixtures.max_attempt
+attempt = fixtures.attempt
+boundaries = fixtures.boundaries
+live_subscription = fixtures.live_subscription
+
+
+async def test_confirmed_max_retry_at_scheduled_boundary_reports_trial_ending(
+ max_attempt, boundaries, live_subscription
+):
+ max_attempt.confirmed_at = datetime.now(UTC)
+ live_subscription.trial_end = int(datetime.now(UTC).timestamp()) + 30
+ result = await checkout.confirm_activation(
+ max_attempt.user_id,
+ max_attempt.id,
+ ActivationConfirmRequest(confirmed=True, terms_token=max_attempt.terms.token),
+ )
+ assert result.status == "processing" and result.error_code == "trial_ending"
+ boundaries.stripe_call.assert_not_awaited()
+
+
[email protected]("getter", ["current", "attempt"])
+async def test_paid_original_plan_does_not_complete_selected_max(
+ max_attempt, boundaries, live_subscription, getter
+):
+ max_attempt.confirmed_at = datetime.now(UTC)
+ live_subscription.status = "active"
+ live_subscription.latest_invoice = billing.BillingInvoice(
+ id="in_pro", customer="cus_1", status="paid"
+ )
+ if getter == "current":
+ response = await checkout.current_activation(max_attempt.user_id)
+ else:
+ response = await checkout.get_activation(max_attempt.user_id, max_attempt.id)
+ assert response.status == "not_applicable" and response.error_code == "plan_changed"
+ assert response.return_to == max_attempt.return_to
+ assert not response.usage_reset and response.activation_id is None
+ boundaries.reconcile_paid_activation.assert_not_awaited()
+ boundaries.stripe_call.assert_not_awaited()
+
+
+ "change", [{"price_id": "price_max_new"}, {"amount_due": 9900}, {"plan": "PRO"}]
+)
+async def test_changed_max_quote_requires_fresh_confirmation(
+ max_attempt, boundaries, change
+):
+ boundaries.quote_terms.return_value = max_attempt.terms.model_copy(update=change)
+ with pytest.raises(billing.ActivationUnavailable, match="charge changed"):
+ await checkout.confirm_activation(
+ max_attempt.user_id,
+ max_attempt.id,
+ ActivationConfirmRequest(
+ confirmed=True, terms_token=max_attempt.terms.token
+ ),
+ )
+ boundaries.save_confirmation.assert_not_awaited()
+ boundaries.stripe_call.assert_not_awaited()
+
+
+async def test_changed_original_trial_terms_do_not_restore_max_confirmation(
+ max_attempt, boundaries, live_subscription
+):
+ live_subscription.items.data[0].price.unit_amount += 100
+ response = await checkout.get_activation(max_attempt.user_id, max_attempt.id)
+ assert response.status == "processing" and response.error_code == "terms_changed"
+ boundaries.stripe_call.assert_not_awaited()
+
+
+async def test_confirmed_max_does_not_reconcile_original_trial_setup_invoice(
+ max_attempt, boundaries, live_subscription
+):
+ max_attempt.confirmed_at = datetime.now(UTC)
+ live_subscription.latest_invoice = billing.BillingInvoice(
+ id="in_setup", customer="cus_1", status="paid"
+ )
+ await checkout.get_activation(max_attempt.user_id, max_attempt.id)
+ boundaries.reconcile_paid_activation.assert_not_awaited()
+
+
+async def test_basic_trial_can_preview_and_recover_selected_max(
+ max_attempt, boundaries, trial, live_subscription, monkeypatch
+):
+ trial.offer = trial.offer.model_copy(
+ update={"tier": "BASIC", "price_id": "price_basic"}
+ )
+ max_attempt.terms.accepted_offer_token = trial.offer.token
+ live_subscription.items.data[0].price.id = "price_basic"
+ monkeypatch.setattr(billing, "owned_subscription", boundaries.owned_subscription)
+ source, sub = await billing.conversion_trial(max_attempt.user_id)
+ assert source.offer.tier == "BASIC" and sub.id == live_subscription.id
+ result = await checkout.get_activation(max_attempt.user_id, max_attempt.id)
+ assert result.status == "confirmation_required" and result.error_code is None
+ boundaries.stripe_call.assert_not_awaited()
+
+
[email protected]("catalog_change_at", ["confirmation", "retry"])
+async def test_saved_max_price_survives_catalog_change(
+ max_attempt, boundaries, trial, live_subscription, monkeypatch, catalog_change_at
+):
+ async def read_stripe(fn, *args, **kwargs):
+ if fn == stripe.Price.retrieve_async:
+ return {
+ "id": args[0],
+ "unit_amount": 9000,
+ "currency": "usd",
+ "recurring": {"interval": "month", "interval_count": 1},
+ }
+ assert fn == stripe.Invoice.create_preview_async
+ return {"customer": "cus_1", "currency": "usd", "amount_due": 8700}
+
+ prices = AsyncMock(return_value="price_max")
+ reads = AsyncMock(side_effect=read_stripe)
+ monkeypatch.setattr(billing.credit, "get_subscription_price_id", prices)
+ monkeypatch.setattr(billing, "stripe_call", reads)
+ monkeypatch.setattr(checkout, "quote_terms", billing.quote_terms)
+ max_attempt.terms = await billing.quote_terms(trial, live_subscription, "MAX")
+ boundaries.save_confirmation.return_value = max_attempt.model_copy(
+ update={"confirmed_at": datetime.now(UTC)}
+ )
+ boundaries.stripe_call.side_effect = stripe.APIConnectionError("unknown outcome")
+ body = ActivationConfirmRequest(confirmed=True, terms_token=max_attempt.terms.token)
+ if catalog_change_at == "retry":
+ await checkout.confirm_activation(max_attempt.user_id, max_attempt.id, body)
+ boundaries.get_attempt.return_value = boundaries.save_confirmation.return_value
+ prices.return_value = "price_max_new"
+
+ result = await checkout.confirm_activation(
+ max_attempt.user_id, max_attempt.id, body
+ )
+
+ assert result.status == "processing" and result.error_code is None
+ assert boundaries.stripe_call.await_count == (
+ 2 if catalog_change_at == "retry" else 1
+ )
+ for call in boundaries.stripe_call.await_args_list:
+ assert call.kwargs["items"] == [
+ {"id": "si_owned", "price": "price_max", "quantity": 1}
+ ]
+ assert call.kwargs["idempotency_key"] == f"pro-activation:{max_attempt.id}"
+ assert all(
+ call.args[1] == "price_max"
+ for call in reads.await_args_list
+ if call.args[0] == stripe.Price.retrieve_async
+ )
+ prices.assert_awaited_once()
+ fresh = await billing.quote_terms(trial, live_subscription, "MAX")
+ assert fresh.price_id == "price_max_new"
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_target_test.py b/autogpt_platform/backend/backend/data/subscription_activation_target_test.py
new file mode 100644
index 0000000000..dfac6b418e
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_target_test.py
@@ -0,0 +1,245 @@
+"""Explicit target selection binds preview, consent, mutation, and recovery."""
+
+from datetime import UTC, datetime
+from unittest.mock import AsyncMock
+
+import pytest
+import stripe
+from prisma.enums import SubscriptionTier
+from pydantic import ValidationError
+
+from backend.data import subscription_activation_checkout as checkout
+from backend.data import subscription_activation_checkout_fixtures as fixtures
+from backend.data import subscription_activation_stripe as billing
+from backend.data.subscription_activation_models import (
+ ActivationConfirmRequest,
+ ActivationPreviewRequest,
+ ActivationResponse,
+ ActivationUnavailable,
+ PaidActivationResult,
+)
+
+pytest_plugins = ("backend.data.subscription_trial_fixtures",)
+attempt = fixtures.attempt
+max_attempt = fixtures.max_attempt
+boundaries = fixtures.boundaries
+live_subscription = fixtures.live_subscription
+
+
+def test_preview_selects_max_and_rejects_unrelated_plans():
+ assert ActivationPreviewRequest(plan="MAX").plan == "MAX"
+ assert ActivationPreviewRequest().plan is None
+ for value in ("BASIC", "BUSINESS", "max"):
+ with pytest.raises(ValidationError):
+ ActivationPreviewRequest(plan=value)
+
+
+async def test_default_quote_retains_original_max_offer(
+ trial, live_subscription, monkeypatch
+):
+ trial.offer = trial.offer.model_copy(
+ update={"tier": "MAX", "price_id": "price_retired_max"}
+ )
+ live_subscription.items.data[0].price.id = trial.offer.price_id
+ prices = AsyncMock()
+ monkeypatch.setattr(billing.credit, "get_subscription_price_id", prices)
+ monkeypatch.setattr(
+ billing,
+ "stripe_call",
+ AsyncMock(
+ return_value={
+ "customer": "cus_1",
+ "currency": "usd",
+ "amount_due": 4800,
+ }
+ ),
+ )
+ terms = await billing.quote_terms(trial, live_subscription)
+ assert terms.plan == "MAX" and terms.price_id == "price_retired_max"
+ assert terms.accepted_offer_token == trial.offer.token
+ prices.assert_not_awaited()
+
+
[email protected]("cycle,interval", [("monthly", "month"), ("yearly", "year")])
+ "source,target", [("PRO", "MAX"), ("MAX", "PRO"), ("BASIC", "MAX")]
+)
+async def test_alternate_plan_quote_matches_exact_owned_item_mutation(
+ trial, live_subscription, monkeypatch, cycle, interval, source, target
+):
+ trial.offer = trial.offer.model_copy(
+ update={"tier": source, "billing_cycle": cycle}
+ )
+ live_subscription.items.data[0].price.recurring.interval = interval
+ live_subscription.items.data[0] = billing.ActivationItem.model_validate(
+ {
+ **live_subscription.items.data[0].model_dump(),
+ "id": "si_owned",
+ }
+ )
+ original = trial.offer.model_dump()
+ target_price = {
+ "id": "price_target",
+ "unit_amount": 9000,
+ "currency": "usd",
+ "recurring": {"interval": interval, "interval_count": 1},
+ }
+ calls = AsyncMock(
+ side_effect=[
+ target_price,
+ {
+ "customer": "cus_1",
+ "currency": "usd",
+ "amount_due": 8700,
+ },
+ ]
+ )
+ prices = AsyncMock(return_value="price_target")
+ monkeypatch.setattr(billing, "stripe_call", calls)
+ monkeypatch.setattr(billing.credit, "get_subscription_price_id", prices)
+ terms = await billing.quote_terms(trial, live_subscription, target)
+ assert terms.plan == target and terms.price_id == "price_target"
+ assert terms.amount_due == 8700 and terms.renewal_unit_amount == 9000
+ assert terms.accepted_offer_token == trial.offer.token
+ assert trial.offer.model_dump() == original
+ prices.assert_awaited_once_with(SubscriptionTier(target), cycle)
+ calls.assert_any_await(stripe.Price.retrieve_async, "price_target")
+ assert calls.await_args.kwargs["subscription_details"] == {
+ "trial_end": "now",
+ "proration_behavior": "none",
+ "items": [{"id": "si_owned", "price": "price_target", "quantity": 1}],
+ }
+
+
+ "invalid",
+ [
+ "missing_price",
+ "currency",
+ "interval",
+ "price_id",
+ "missing_item",
+ "trial_ending",
+ ],
+)
+async def test_alternate_quote_fails_closed(
+ trial, live_subscription, monkeypatch, invalid
+):
+ live_subscription.items.data[0] = billing.ActivationItem.model_validate(
+ {
+ **live_subscription.items.data[0].model_dump(),
+ "id": "si_owned" if invalid != "missing_item" else None,
+ }
+ )
+ if invalid == "trial_ending":
+ live_subscription.trial_end = int(datetime.now(UTC).timestamp()) + 30
+ target_price = {
+ "id": "wrong" if invalid == "price_id" else "price_max",
+ "unit_amount": 9000,
+ "currency": "eur" if invalid == "currency" else "usd",
+ "recurring": {
+ "interval": "year" if invalid == "interval" else "month",
+ "interval_count": 1,
+ },
+ }
+ calls = AsyncMock(return_value=target_price)
+ monkeypatch.setattr(billing, "stripe_call", calls)
+ monkeypatch.setattr(
+ billing.credit,
+ "get_subscription_price_id",
+ AsyncMock(
+ return_value=None if invalid == "missing_price" else "price_max",
+ ),
+ )
+ with pytest.raises(ActivationUnavailable):
+ await billing.quote_terms(trial, live_subscription, "MAX")
+ assert all(
+ call.args[0] != stripe.Invoice.create_preview_async
+ for call in calls.await_args_list
+ )
+
+
+async def test_preview_passes_selected_target(
+ max_attempt, boundaries, trial, live_subscription
+):
+ response = await checkout.preview_activation(max_attempt.user_id, "/chat", "MAX")
+ assert response.terms.plan == "MAX"
+ boundaries.quote_terms.assert_awaited_once_with(trial, live_subscription, "MAX")
+ boundaries.stripe_call.assert_not_awaited()
+
+
+async def test_max_confirmation_and_retry_use_same_item_price_and_idempotency_key(
+ max_attempt, boundaries
+):
+ boundaries.stripe_call.side_effect = stripe.APIConnectionError("unknown outcome")
+ body = ActivationConfirmRequest(confirmed=True, terms_token=max_attempt.terms.token)
+ for _ in range(2):
+ response = await checkout.confirm_activation(
+ max_attempt.user_id, max_attempt.id, body
+ )
+ assert response.status == "processing"
+ boundaries.get_attempt.return_value = boundaries.save_confirmation.return_value
+ boundaries.save_confirmation.assert_awaited_once()
+ assert boundaries.stripe_call.await_count == 2
+ for call in boundaries.stripe_call.await_args_list:
+ assert call.args == (stripe.Subscription.modify_async, "sub_1")
+ assert call.kwargs["items"] == [
+ {"id": "si_owned", "price": "price_max", "quantity": 1}
+ ]
+ assert call.kwargs["idempotency_key"] == "pro-activation:operation-1"
+ assert call.kwargs["trial_end"] == "now"
+
+
[email protected]("confirmed", [False, True])
+async def test_max_recovery_accepts_original_trial_before_mutation(
+ max_attempt, boundaries, confirmed
+):
+ if confirmed:
+ max_attempt.confirmed_at = datetime.now(UTC)
+ result = await checkout.get_activation(max_attempt.user_id, max_attempt.id)
+ assert result.status == ("processing" if confirmed else "confirmation_required")
+ assert result.error_code is None
+ assert result.terms.plan == "MAX" and not result.usage_reset
+ boundaries.stripe_call.assert_not_awaited()
+
+
+async def test_paid_max_ready_does_not_imply_reset(
+ attempt, boundaries, live_subscription, monkeypatch
+):
+ live_subscription.status = "active"
+ live_subscription.items.data[0].price.id = "price_max"
+ live_subscription.latest_invoice = billing.BillingInvoice(
+ id="in_paid", customer="cus_1", status="paid"
+ )
+ monkeypatch.setattr(
+ billing.credit,
+ "build_price_to_tier_map",
+ AsyncMock(return_value={"price_max": SubscriptionTier.MAX}),
+ )
+ boundaries.reconcile_paid_activation.return_value = PaidActivationResult(
+ invoice_id="in_paid", usage_reset=False
+ )
+ response = await checkout._payment_status(
+ attempt.user_id, live_subscription, ActivationResponse(status="processing")
+ )
+ assert response.status == "ready" and not response.usage_reset
+ assert response.activation_id is None
+
+
+async def test_non_target_trial_requires_explicit_paid_plan(
+ trial, live_subscription, monkeypatch
+):
+ trial.offer = trial.offer.model_copy(update={"tier": "BASIC"})
+ calls = AsyncMock()
+ monkeypatch.setattr(billing, "stripe_call", calls)
+ with pytest.raises(ActivationUnavailable, match="convert to Pro or Max"):
+ await billing.quote_terms(trial, live_subscription)
+ calls.assert_not_awaited()
diff --git a/autogpt_platform/backend/backend/data/subscription_activation_transition_integration_test.py b/autogpt_platform/backend/backend/data/subscription_activation_transition_integration_test.py
new file mode 100644
index 0000000000..5590ab8865
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/subscription_activation_transition_integration_test.py
@@ -0,0 +1,138 @@
+"""Paid plan changes preserve usage, including pre-activation trial history."""
+
+import os
+from copy import deepcopy
+from datetime import UTC, datetime
+
+import pytest
+from prisma.enums import SubscriptionTier
+from prisma.models import PaidUsageActivation, SubscriptionTrial, User
+
+from backend.data import credit
+from backend.data import subscription_activation_integration_fixtures as fixtures
+from backend.data.pro_activation import get_usage_activation_state
+from backend.data.subscription_activation import reconcile_paid_activation
+
+activation_case = fixtures.activation_case
+pytestmark = pytest.mark.skipif(
+ os.environ.get("TRIAL_TEST_DATABASE") != "1",
+ reason="Requires disposable DB and Redis cluster",
+)
+
+
[email protected]("source,target", [("PRO", "MAX"), ("MAX", "PRO")])
[email protected]("history", ["no_trial", "converted_legacy", "activation"])
[email protected]("new_invoice", [False, True])
+async def test_paid_plan_change_never_resets_usage(
+ activation_case, mocker, source, target, history, new_invoice
+):
+ case = activation_case
+ mocker.patch.object(
+ credit,
+ "build_price_to_tier_map",
+ return_value={
+ "price_pro": SubscriptionTier.PRO,
+ "price_max": SubscriptionTier.MAX,
+ },
+ )
+ mocker.patch.object(credit, "schedule_posthog_lifecycle_sync")
+ await prepare_paid_user(case, source, history)
+ before = await get_usage_activation_state(case.user_id)
+ await case.add_cost(before.generation, 191)
+ trial_before = await SubscriptionTrial.prisma().find_unique(
+ where={"userId": case.user_id}
+ )
+ case.subscription["items"]["data"][0]["price"]["id"] = f"price_{target.lower()}"
+ if new_invoice:
+ add_plan_change_invoice(case)
+
+ for _ in range(2):
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+ assert result is not None and not result.usage_reset
+ assert result.activation_id is None
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.tier == target
+ assert state.generation == before.generation
+ assert await case.counters(state.generation) == (191, 191)
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == (
+ 1 if history == "activation" else 0
+ )
+ trial_after = await SubscriptionTrial.prisma().find_unique(
+ where={"userId": case.user_id}
+ )
+ if trial_before:
+ assert trial_after
+ for field in (
+ "id",
+ "userId",
+ "offer",
+ "consumedAt",
+ "costMicrodollars",
+ "convertedAt",
+ "stripeConversionInvoiceId",
+ "stripeSubscriptionId",
+ ):
+ assert trial_after.model_dump()[field] == trial_before.model_dump()[field]
+ else:
+ assert trial_after is None
+
+
[email protected]("tier", ["PRO", "MAX"])
+async def test_legacy_conversion_invoice_replay_never_resets_usage(
+ activation_case, mocker, tier
+):
+ case = activation_case
+ mocker.patch.object(
+ credit,
+ "build_price_to_tier_map",
+ return_value={
+ "price_pro": SubscriptionTier.PRO,
+ "price_max": SubscriptionTier.MAX,
+ },
+ )
+ mocker.patch.object(credit, "schedule_posthog_lifecycle_sync")
+ await prepare_paid_user(case, tier, "converted_legacy")
+ await case.add_cost(None, 193)
+ for _ in range(2):
+ result = await reconcile_paid_activation(case.user_id, case.subscription["id"])
+ assert result is not None and not result.usage_reset
+ assert result.activation_id is None
+ state = await get_usage_activation_state(case.user_id)
+ assert state.ready and state.tier == tier and state.generation is None
+ assert await case.counters(None) == (193, 193)
+ assert await PaidUsageActivation.prisma().count(where={"userId": case.user_id}) == 0
+
+
+async def prepare_paid_user(case, tier, history):
+ case.select_plan(tier)
+ if history != "no_trial":
+ trial = await case.add_trial(100, tier)
+ if history == "activation":
+ assert await case.activate()
+ return
+ await SubscriptionTrial.prisma().update(
+ where={"id": trial.id},
+ data={
+ "convertedAt": datetime.now(UTC),
+ "stripeConversionInvoiceId": case.invoice["id"],
+ "status": "active",
+ },
+ )
+ await User.prisma().update(
+ where={"id": case.user_id}, data={"subscriptionTier": tier}
+ )
+
+
+def add_plan_change_invoice(case):
+ invoice = deepcopy(case.invoice)
+ invoice.update(
+ id=f"change_{case.invoice['id']}", billing_reason="subscription_update"
+ )
+ invoice["created"] += 60
+ invoice["status_transitions"]["paid_at"] += 60
+ invoice["lines"]["data"][0].update(
+ proration=True,
+ price=deepcopy(case.subscription["items"]["data"][0]["price"]),
+ )
+ case.invoices.append(invoice)
+ case.subscription["latest_invoice"] = invoice["id"]
diff --git a/autogpt_platform/backend/backend/data/subscription_pending_cache_test.py b/autogpt_platform/backend/backend/data/subscription_pending_cache_test.py
index 9303d144c8..cb33fc5557 100644
--- a/autogpt_platform/backend/backend/data/subscription_pending_cache_test.py
+++ b/autogpt_platform/backend/backend/data/subscription_pending_cache_test.py
@@ -219,6 +219,7 @@ async def test_a_renewal_the_balance_cant_cover_clears_the_pending_change(
)
renewal = {
"id": "in_renewal",
+ "status": "open",
"customer": fake_stripe.subscription["customer"],
"amount_due": 5000,
"billing_reason": "subscription_cycle",
@@ -228,6 +229,8 @@ async def test_a_renewal_the_balance_cant_cover_clears_the_pending_change(
patch.object(worker_a, "User", users),
patch.object(worker_a, "UserCredit", MagicMock(return_value=balance)),
patch.object(worker_a, "set_subscription_tier", AsyncMock()) as set_tier,
+ patch.object(worker_a, "get_subscription_trial", AsyncMock(return_value=None)),
+ patch.object(stripe.Invoice, "retrieve_async", AsyncMock(return_value=renewal)),
):
await worker_a.handle_subscription_payment_failure(renewal)
diff --git a/autogpt_platform/backend/backend/data/subscription_trial_cancel_reconcile_test.py b/autogpt_platform/backend/backend/data/subscription_trial_cancel_reconcile_test.py
index 33f5401717..413e2f41e6 100644
--- a/autogpt_platform/backend/backend/data/subscription_trial_cancel_reconcile_test.py
+++ b/autogpt_platform/backend/backend/data/subscription_trial_cancel_reconcile_test.py
@@ -2,6 +2,7 @@
the trial ends, then ends, or converts once resumed."""
from datetime import UTC, datetime, timedelta
+from types import SimpleNamespace
from unittest.mock import AsyncMock, patch
import pytest
@@ -117,7 +118,10 @@ async def test_scheduled_cancellation_ends_access_when_stripe_ends_the_trial(
@pytest.mark.asyncio
-async def test_resumed_trial_converts_at_trial_end(trial, subscription, boundaries):
[email protected]("activation_ready", [False, True])
+async def test_resumed_trial_converts_at_trial_end(
+ trial, subscription, boundaries, monkeypatch, activation_ready
+):
now = datetime.now(UTC)
trial = trial.model_copy(
update={
@@ -139,11 +143,24 @@ async def test_resumed_trial_converts_at_trial_end(trial, subscription, boundari
"billing_reason": "subscription_cycle",
},
)
+ publish = AsyncMock(return_value=activation_ready)
+ monkeypatch.setattr(
+ fulfillment.subscription_activation, "publish_initial_pro_activation", publish
+ )
+ boundaries.user.find_unique_or_raise = AsyncMock()
+ boundaries.subscriptiontrial.find_unique_or_raise = AsyncMock(
+ return_value=SimpleNamespace(
+ convertedAt=now if activation_ready else None,
+ stripeConversionInvoiceId="in_1" if activation_ready else None,
+ )
+ )
result = await fulfillment._reconcile_locked(trial, "sub_1", boundaries)
- assert result is not None and result[1] == SubscriptionTier.PRO
+ expected = SubscriptionTier.PRO if activation_ready else SubscriptionTier.NO_TIER
+ assert result is not None and result[1] == expected
+ publish.assert_awaited_once()
saved = boundaries.subscriptiontrial.update.await_args.kwargs["data"]
- assert saved["convertedAt"] is not None
- assert saved["stripeConversionInvoiceId"] == "in_1"
+ assert (saved["convertedAt"] is not None) == activation_ready
+ assert saved["stripeConversionInvoiceId"] == ("in_1" if activation_ready else None)
assert saved["notificationRevision"] == 2
diff --git a/autogpt_platform/backend/backend/data/subscription_trial_chosen_plan_test.py b/autogpt_platform/backend/backend/data/subscription_trial_chosen_plan_test.py
index 92df7b2aef..bc5257a9bf 100644
--- a/autogpt_platform/backend/backend/data/subscription_trial_chosen_plan_test.py
+++ b/autogpt_platform/backend/backend/data/subscription_trial_chosen_plan_test.py
@@ -2,6 +2,8 @@
one: the reconcile grants that plan once it is paid for, and nothing else."""
from datetime import UTC, datetime
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
import pytest
from prisma.enums import SubscriptionTier
@@ -39,17 +41,49 @@ def switched(subscription: dict) -> dict:
@pytest.mark.asyncio
[email protected]("activation_ready", [False, True])
async def test_a_paid_switch_to_the_chosen_plan_converts_the_trial_onto_it(
- trial, switched, boundaries
+ trial, switched, boundaries, monkeypatch, activation_ready
):
+ publish = AsyncMock(return_value=activation_ready)
+ monkeypatch.setattr(
+ fulfillment.subscription_activation, "publish_initial_pro_activation", publish
+ )
+ boundaries.user.find_unique_or_raise = AsyncMock()
+ boundaries.subscriptiontrial.find_unique_or_raise = AsyncMock(
+ return_value=SimpleNamespace(
+ convertedAt=datetime.now(UTC) if activation_ready else None,
+ stripeConversionInvoiceId="in_max" if activation_ready else None,
+ )
+ )
result = await fulfillment._reconcile_locked(trial, "sub_1", boundaries)
- assert result is not None and result[1] == SubscriptionTier.MAX
+ expected = SubscriptionTier.MAX if activation_ready else SubscriptionTier.NO_TIER
+ assert result is not None and result[1] == expected
+ publish.assert_awaited_once()
+ assert publish.await_args.args[2] == "price_max"
saved = boundaries.subscriptiontrial.update.await_args.kwargs["data"]
- assert saved["convertedAt"] is not None
- assert saved["stripeConversionInvoiceId"] == "in_max"
+ assert (saved["convertedAt"] is not None) == activation_ready
+ assert saved["stripeConversionInvoiceId"] == (
+ "in_max" if activation_ready else None
+ )
granted = boundaries.user.update_many.await_args.kwargs["data"]
- assert granted == {"subscriptionTier": SubscriptionTier.MAX}
+ assert granted == {"subscriptionTier": expected}
+
+
[email protected]("tier", ["BASIC", "BUSINESS"])
+async def test_other_chosen_plans_keep_existing_conversion_without_a_usage_reset(
+ trial, switched, boundaries, monkeypatch, tier
+):
+ switched["metadata"]["trial_conversion_tier"] = tier
+ publish = AsyncMock()
+ monkeypatch.setattr(
+ fulfillment.subscription_activation, "publish_initial_pro_activation", publish
+ )
+ result = await fulfillment._reconcile_locked(trial, "sub_1", boundaries)
+ assert result is not None and result[1] == SubscriptionTier(tier)
+ publish.assert_not_awaited()
@pytest.mark.asyncio
diff --git a/autogpt_platform/backend/backend/data/subscription_trial_fulfillment_test.py b/autogpt_platform/backend/backend/data/subscription_trial_fulfillment_test.py
index 4313df5b85..6f28db98b0 100644
--- a/autogpt_platform/backend/backend/data/subscription_trial_fulfillment_test.py
+++ b/autogpt_platform/backend/backend/data/subscription_trial_fulfillment_test.py
@@ -205,3 +205,76 @@ async def test_canceled_subscription_revokes_access_even_if_items_changed(
boundaries.subscriptiontrial.update.await_args.kwargs["data"]["cardVerifiedAt"]
is None
)
+
+
[email protected]("tier", [SubscriptionTier.BASIC, SubscriptionTier.BUSINESS])
+async def test_other_accepted_trial_plan_converts_without_usage_reset(
+ trial, subscription, boundaries, tier
+):
+ now = datetime.now(UTC)
+ trial.offer = trial.offer.model_copy(update={"tier": tier.value})
+ subscription.update(
+ status="active",
+ trial_end=int(now.timestamp()) - 60,
+ latest_invoice={
+ "id": "in_other_plan",
+ "status": "paid",
+ "created": int(now.timestamp()),
+ "billing_reason": "subscription_cycle",
+ },
+ )
+ with patch.object(
+ fulfillment.subscription_activation,
+ "publish_initial_pro_activation",
+ AsyncMock(),
+ ) as publish:
+ result = await fulfillment._reconcile_locked(trial, "sub_1", boundaries)
+ assert result is not None and result[1] == tier
+ publish.assert_not_awaited()
+ saved = boundaries.subscriptiontrial.update.await_args.kwargs["data"]
+ assert saved["convertedAt"] is not None
+ assert saved["stripeConversionInvoiceId"] == "in_other_plan"
+
+
[email protected]("offer_tier", ["BASIC", "BUSINESS"])
+async def test_selected_paid_target_checks_payment_before_other_trial_plan_grant(
+ trial, subscription, boundaries, offer_tier
+):
+ now = int(datetime.now(UTC).timestamp())
+ trial.offer = trial.offer.model_copy(update={"tier": offer_tier})
+ subscription.update(
+ status="active",
+ trial_end=now - 60,
+ latest_invoice={
+ "id": "in_max",
+ "status": "paid",
+ "created": now,
+ "billing_reason": "subscription_update",
+ },
+ )
+ subscription["items"]["data"][0]["price"]["id"] = "price_max"
+ boundaries.user.find_unique_or_raise = AsyncMock()
+ boundaries.subscriptiontrial.find_unique_or_raise = AsyncMock(
+ return_value=MagicMock(convertedAt=None)
+ )
+ with (
+ patch.object(
+ fulfillment.subscription_activation,
+ "accepted_conversion_target",
+ AsyncMock(return_value=(SubscriptionTier.MAX, "price_max")),
+ ),
+ patch.object(
+ fulfillment.subscription_activation,
+ "publish_initial_pro_activation",
+ AsyncMock(return_value=False),
+ ) as publish,
+ ):
+ result = await fulfillment._reconcile_locked(trial, "sub_1", boundaries)
+ assert result is not None and result[1] == SubscriptionTier.NO_TIER
+ assert publish.await_args.args[2] == "price_max"
+ assert trial.consumed_at is not None
+ assert trial.subscription_id == "sub_1"
+ saved = boundaries.subscriptiontrial.update.await_args.kwargs["data"]
+ assert saved["convertedAt"] is None
diff --git a/autogpt_platform/backend/backend/data/subscription_trial_integration_fixtures.py b/autogpt_platform/backend/backend/data/subscription_trial_integration_fixtures.py
index 2ea4ba36bc..d13b2d2b97 100644
--- a/autogpt_platform/backend/backend/data/subscription_trial_integration_fixtures.py
+++ b/autogpt_platform/backend/backend/data/subscription_trial_integration_fixtures.py
@@ -25,11 +25,11 @@ async def enrollment():
15432,
"/trial_test",
)
- ci = os.environ.get("GITHUB_ACTIONS") == "true" and (
- target.hostname,
- target.port,
- target.path,
- ) == ("localhost", 5432, "/postgres")
+ ci = (
+ os.environ.get("GITHUB_ACTIONS") == "true"
+ and (target.hostname, target.port) == ("localhost", 5432)
+ and target.path in ("/postgres", "/ci_copilot")
+ )
assert (
local or ci
), "Trial integration tests require an approved disposable database"
diff --git a/autogpt_platform/backend/backend/data/subscription_trial_stripe.py b/autogpt_platform/backend/backend/data/subscription_trial_stripe.py
index 60d663f5a8..482af2633a 100644
--- a/autogpt_platform/backend/backend/data/subscription_trial_stripe.py
+++ b/autogpt_platform/backend/backend/data/subscription_trial_stripe.py
@@ -6,8 +6,10 @@ import stripe
from prisma import Prisma
from prisma.enums import SubscriptionTier
+from backend.data import subscription_activation
from backend.data.db import query_raw_with_schema, transaction
from backend.data.stripe_client import stripe_call, stripe_list_items
+from backend.data.subscription_activation_target import record_checkout_consumption
from backend.data.subscription_checkout import other_plan_has_access
from backend.data.subscription_trial import TrialState, get_subscription_trial
from backend.data.subscription_trial_claims import claim_trial_identities
@@ -30,6 +32,7 @@ async def reconcile_trial_subscription(
if trial is None:
return None
async with transaction() as tx:
+ await subscription_activation.lock_activation_user(user_id, tx)
await query_raw_with_schema(
'SELECT "id" FROM {schema_prefix}"SubscriptionTrial" '
'WHERE "userId" = $1 FOR UPDATE',
@@ -43,6 +46,7 @@ async def reconcile_trial_subscription(
async def _reconcile_locked(
trial: TrialState, subscription_id: str, tx: Prisma
) -> tuple[dict, SubscriptionTier | None] | None:
+ previously_converted = trial.converted_at is not None
raw = await stripe_call(
stripe.Subscription.retrieve_async,
subscription_id,
@@ -107,26 +111,54 @@ async def _reconcile_locked(
snapshot = SubscriptionSnapshot.model_validate(raw)
if snapshot.id != subscription_id or snapshot.status != "canceled":
raise ValueError("Stripe did not confirm trial cancellation")
- # The one other price a trial may end on is the plan the customer chose
- # to start in its place, once that switch has gone through.
- if (
- trial.converted_at is None
- and snapshot.status in ("active", "trialing")
- and not snapshot.has_accepted_price(trial.offer)
- and not (snapshot.status == "active" and snapshot.chosen_plan())
- ):
- raise ValueError(
- "Stripe items do not match the accepted trial price and quantity"
- )
+ target = None
+ if trial.converted_at is None and snapshot.status in ("active", "trialing"):
+ if snapshot.status == "active":
+ target = await subscription_activation.accepted_conversion_target(
+ trial, dict(raw), tx
+ )
+ if (
+ not snapshot.has_accepted_price(trial.offer)
+ and target is None
+ and not (snapshot.status == "active" and snapshot.chosen_plan())
+ ):
+ raise ValueError(
+ "Stripe items do not match the accepted trial price and quantity"
+ )
tier = (
trial_subscription_tier(trial, snapshot, now)
if checkout_complete
else SubscriptionTier.NO_TIER
)
+ if target is not None and tier not in (
+ SubscriptionTier.NO_TIER,
+ SubscriptionTier.TRIAL,
+ ):
+ tier = target[0]
+ if (
+ tier in subscription_activation.PAID_CONVERSION_TIERS
+ and not previously_converted
+ ):
+ assert target is not None
+ tier, price_id = target
+ await record_checkout_consumption(trial, snapshot.id, now, tx)
+ user = await tx.user.find_unique_or_raise(where={"id": trial.user_id})
+ if not await subscription_activation.publish_initial_pro_activation(
+ user, dict(raw), price_id, tx, trial
+ ):
+ tier = SubscriptionTier.NO_TIER
+ # Preserve the activation's first invoice, even if a later renewal is
+ # already latest_invoice when the delayed event is reconciled.
+ refreshed = await tx.subscriptiontrial.find_unique_or_raise(
+ where={"userId": trial.user_id}
+ )
+ if refreshed.convertedAt:
+ trial.converted_at = refreshed.convertedAt
+ trial.conversion_invoice_id = refreshed.stripeConversionInvoiceId
await _save_snapshot(
trial, snapshot, tier, now, tx, checkout_complete, rejection_reason
)
- if trial.converted_at:
+ if previously_converted:
return dict(raw), None
if tier == SubscriptionTier.NO_TIER:
for status in ("active", "trialing"):
diff --git a/autogpt_platform/backend/backend/executor/simulator.py b/autogpt_platform/backend/backend/executor/simulator.py
index b86e1b32ac..41bbe91480 100644
--- a/autogpt_platform/backend/backend/executor/simulator.py
+++ b/autogpt_platform/backend/backend/executor/simulator.py
@@ -44,6 +44,7 @@ from backend.blocks.io import AgentInputBlock, AgentOutputBlock
from backend.blocks.llm import LLMModel
from backend.blocks.orchestrator import ExecutionMode, OrchestratorBlock
from backend.copilot.token_tracking import persist_and_record_usage
+from backend.copilot.trial_cost_context import attributed_usage
from backend.util.clients import get_openai_client, openrouter_helper_cost_provider
logger = logging.getLogger(__name__)
@@ -149,6 +150,7 @@ def _describe_schema_pins(schema: dict[str, Any]) -> str:
# ---------------------------------------------------------------------------
+@attributed_usage
async def _call_llm_for_simulation(
system_prompt: str,
user_prompt: str,
diff --git a/autogpt_platform/backend/backend/executor/simulator_test.py b/autogpt_platform/backend/backend/executor/simulator_test.py
index 3510d8c7a9..1ab11794f3 100644
--- a/autogpt_platform/backend/backend/executor/simulator_test.py
+++ b/autogpt_platform/backend/backend/executor/simulator_test.py
@@ -21,6 +21,7 @@ from openai.types.chat.chat_completion_message import ChatCompletionMessage
from backend.blocks.llm import LLMModel
from backend.blocks.orchestrator import ExecutionMode, OrchestratorBlock
+from backend.copilot import usage_activation_fixtures
from backend.executor.simulator import (
_DEFAULT_SIMULATOR_MODEL,
_MAX_JSON_RETRIES,
@@ -996,3 +997,6 @@ class TestSchemaConformantSimulation:
assert parsed == {"main_result": ["still wrong"], "response": "ok"}
assert create_mock.call_count == _MAX_JSON_RETRIES
+
+
+usage_snapshot = usage_activation_fixtures.usage_snapshot
diff --git a/autogpt_platform/backend/backend/platform_linking/chat.py b/autogpt_platform/backend/backend/platform_linking/chat.py
index 41ce43f729..e579c07545 100644
--- a/autogpt_platform/backend/backend/platform_linking/chat.py
+++ b/autogpt_platform/backend/backend/platform_linking/chat.py
@@ -105,6 +105,7 @@ async def _check_usage_limits(user_id: str) -> TurnDenial | None:
user_id=user_id,
daily_cost_limit=daily,
weekly_cost_limit=weekly,
+ expected_tier=_tier,
)
except RateLimitExceeded as exc:
# str(exc) already reads e.g. "You've reached your daily usage limit.
diff --git a/autogpt_platform/backend/migrations/20261006213000_initial_pro_usage_activation/migration.sql b/autogpt_platform/backend/migrations/20261006213000_initial_pro_usage_activation/migration.sql
new file mode 100644
index 0000000000..9dcad24671
--- /dev/null
+++ b/autogpt_platform/backend/migrations/20261006213000_initial_pro_usage_activation/migration.sql
@@ -0,0 +1,27 @@
+CREATE TABLE "PaidUsageActivation" (
+ "id" TEXT NOT NULL PRIMARY KEY,
+ "userId" TEXT NOT NULL UNIQUE REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE,
+ "stripeSubscriptionId" TEXT NOT NULL UNIQUE,
+ "stripeInvoiceId" TEXT NOT NULL UNIQUE,
+ "readyAt" TIMESTAMP(3),
+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+CREATE TABLE "PaidUsageActivationPolicy" (
+ "id" TEXT NOT NULL PRIMARY KEY,
+ "startsAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+INSERT INTO "PaidUsageActivationPolicy" ("id", "startsAt")
+VALUES ('initial-pro-v1', date_trunc('second', CURRENT_TIMESTAMP));
+CREATE TABLE "ProActivationAttempt" (
+ "id" TEXT NOT NULL PRIMARY KEY,
+ "userId" TEXT NOT NULL UNIQUE REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE,
+ "stripeSubscriptionId" TEXT NOT NULL UNIQUE,
+ "stripeCustomerId" TEXT NOT NULL,
+ "terms" JSONB NOT NULL,
+ "returnTo" TEXT NOT NULL,
+ "status" TEXT NOT NULL DEFAULT 'quoted',
+ "confirmedAt" TIMESTAMP(3),
+ "invoiceId" TEXT,
+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ "updatedAt" TIMESTAMP(3) NOT NULL
+);
diff --git a/autogpt_platform/backend/schema.prisma b/autogpt_platform/backend/schema.prisma
index c7d046e9ee..1c2a6b8f7d 100644
--- a/autogpt_platform/backend/schema.prisma
+++ b/autogpt_platform/backend/schema.prisma
@@ -151,6 +151,8 @@ model User {
subscriptionTier SubscriptionTier @default(NO_TIER)
subscriptionTrial SubscriptionTrial?
+ paidUsageActivation PaidUsageActivation?
+ proActivationAttempt ProActivationAttempt?
// Relations
@@ -284,6 +286,38 @@ enum SubscriptionTier {
ENTERPRISE
}
+// One immutable generation for the first settled trial-to-Pro/Max conversion. Never reset on replay.
+model PaidUsageActivation {
+ id String @id @default(uuid())
+ userId String @unique
+ user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+ stripeSubscriptionId String @unique
+ stripeInvoiceId String @unique
+ readyAt DateTime?
+ createdAt DateTime @default(now())
+}
+
+// Cutover fence: old settled payments cannot become new activation resets on replay.
+model PaidUsageActivationPolicy {
+ id String @id
+ startsAt DateTime @default(now())
+}
+
+model ProActivationAttempt {
+ id String @id @default(uuid())
+ userId String @unique
+ user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+ stripeSubscriptionId String @unique
+ stripeCustomerId String
+ terms Json
+ returnTo String
+ status String @default("quoted")
+ confirmedAt DateTime?
+ invoiceId String?
+ createdAt DateTime @default(now())
+ updatedAt DateTime @updatedAt
+}
+
model SubscriptionTrial {
id String @id @default(uuid())
userId String @unique
diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index 59dd9a43eb..02a7971f08 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -5835,6 +5835,178 @@
"security": [{ "HTTPBearerJWT": [] }]
}
},
+ "/api/credits/pro-activation/current": {
+ "get": {
+ "tags": ["subscriptions"],
+ "summary": "Get Current Pro Activation",
+ "operationId": "getSubscriptionsGetCurrentProActivation",
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/ActivationResponse" }
+ }
+ }
+ },
+ "401": {
+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+ },
+ "404": { "description": "No owned activation" },
+ "409": {
+ "description": "Review fresh terms or retry a concurrent confirmation"
+ },
+ "502": {
+ "description": "Preview temporarily unavailable; no payment started"
+ }
+ },
+ "security": [{ "HTTPBearerJWT": [] }]
+ }
+ },
+ "/api/credits/pro-activation/preview": {
+ "post": {
+ "tags": ["subscriptions"],
+ "summary": "Preview Pro Activation",
+ "operationId": "postSubscriptionsPreviewProActivation",
+ "requestBody": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/ActivationPreviewRequest"
+ }
+ }
+ },
+ "required": true
+ },
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/ActivationResponse" }
+ }
+ }
+ },
+ "401": {
+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+ },
+ "404": { "description": "No owned activation" },
+ "409": {
+ "description": "Review fresh terms or retry a concurrent confirmation"
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+ }
+ }
+ },
+ "502": {
+ "description": "Preview temporarily unavailable; no payment started"
+ }
+ },
+ "security": [{ "HTTPBearerJWT": [] }]
+ }
+ },
+ "/api/credits/pro-activation/{attempt_id}": {
+ "get": {
+ "tags": ["subscriptions"],
+ "summary": "Get Pro Activation",
+ "operationId": "getSubscriptionsGetProActivation",
+ "security": [{ "HTTPBearerJWT": [] }],
+ "parameters": [
+ {
+ "name": "attempt_id",
+ "in": "path",
+ "required": true,
+ "schema": { "type": "string", "title": "Attempt Id" }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/ActivationResponse" }
+ }
+ }
+ },
+ "401": {
+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+ },
+ "404": { "description": "No owned activation" },
+ "409": {
+ "description": "Review fresh terms or retry a concurrent confirmation"
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+ }
+ }
+ },
+ "502": {
+ "description": "Preview temporarily unavailable; no payment started"
+ }
+ }
+ }
+ },
+ "/api/credits/pro-activation/{attempt_id}/confirm": {
+ "post": {
+ "tags": ["subscriptions"],
+ "summary": "Confirm Pro Activation",
+ "operationId": "postSubscriptionsConfirmProActivation",
+ "security": [{ "HTTPBearerJWT": [] }],
+ "parameters": [
+ {
+ "name": "attempt_id",
+ "in": "path",
+ "required": true,
+ "schema": { "type": "string", "title": "Attempt Id" }
+ }
+ ],
+ "requestBody": {
+ "required": true,
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/ActivationConfirmRequest"
+ }
+ }
+ }
+ },
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/ActivationResponse" }
+ }
+ }
+ },
+ "401": {
+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+ },
+ "404": { "description": "No owned activation" },
+ "409": {
+ "description": "Review fresh terms or retry a concurrent confirmation"
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+ }
+ }
+ },
+ "502": {
+ "description": "Preview temporarily unavailable; no payment started"
+ }
+ }
+ }
+ },
"/api/credits/refunds": {
"get": {
"tags": ["v1", "credits"],
@@ -18313,6 +18485,171 @@
"title": "AccuracyTrendsResponse",
"description": "Response model for accuracy trends and alerts."
},
+ "ActivationConfirmRequest": {
+ "properties": {
+ "confirmed": {
+ "type": "boolean",
+ "const": true,
+ "title": "Confirmed"
+ },
+ "terms_token": {
+ "type": "string",
+ "pattern": "^[a-f0-9]{64}$",
+ "title": "Terms Token"
+ }
+ },
+ "type": "object",
+ "required": ["confirmed", "terms_token"],
+ "title": "ActivationConfirmRequest"
+ },
+ "ActivationPreviewRequest": {
+ "properties": {
+ "plan": {
+ "anyOf": [
+ { "type": "string", "enum": ["PRO", "MAX"] },
+ { "type": "null" }
+ ],
+ "title": "Plan"
+ },
+ "return_to": {
+ "type": "string",
+ "title": "Return To",
+ "default": "/settings/billing"
+ }
+ },
+ "type": "object",
+ "title": "ActivationPreviewRequest"
+ },
+ "ActivationResponse": {
+ "properties": {
+ "id": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Id"
+ },
+ "status": {
+ "type": "string",
+ "enum": [
+ "confirmation_required",
+ "payment_required",
+ "action_required",
+ "processing",
+ "ready",
+ "not_applicable",
+ "failed"
+ ],
+ "title": "Status"
+ },
+ "terms": {
+ "anyOf": [
+ { "$ref": "#/components/schemas/ActivationTerms" },
+ { "type": "null" }
+ ]
+ },
+ "terms_token": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Terms Token"
+ },
+ "return_to": {
+ "type": "string",
+ "title": "Return To",
+ "default": "/settings/billing"
+ },
+ "invoice_id": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Invoice Id"
+ },
+ "hosted_invoice_url": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Hosted Invoice Url"
+ },
+ "retry_after_seconds": {
+ "anyOf": [{ "type": "integer" }, { "type": "null" }],
+ "title": "Retry After Seconds"
+ },
+ "error_code": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Error Code"
+ },
+ "usage_reset": {
+ "type": "boolean",
+ "title": "Usage Reset",
+ "default": false
+ },
+ "activation_id": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Activation Id"
+ }
+ },
+ "type": "object",
+ "required": ["status"],
+ "title": "ActivationResponse"
+ },
+ "ActivationTerms": {
+ "properties": {
+ "plan": {
+ "type": "string",
+ "enum": ["PRO", "MAX"],
+ "title": "Plan",
+ "default": "PRO"
+ },
+ "price_id": { "type": "string", "title": "Price Id" },
+ "accepted_offer_token": {
+ "type": "string",
+ "title": "Accepted Offer Token"
+ },
+ "amount_due": {
+ "type": "integer",
+ "minimum": 0.0,
+ "title": "Amount Due"
+ },
+ "currency": { "type": "string", "title": "Currency" },
+ "billing_interval": {
+ "type": "string",
+ "enum": ["month", "year"],
+ "title": "Billing Interval"
+ },
+ "billing_interval_count": {
+ "type": "integer",
+ "title": "Billing Interval Count",
+ "default": 1
+ },
+ "renewal_unit_amount": {
+ "type": "integer",
+ "minimum": 0.0,
+ "title": "Renewal Unit Amount"
+ },
+ "renewal_discounts": {
+ "items": { "$ref": "#/components/schemas/RenewalDiscount" },
+ "type": "array",
+ "title": "Renewal Discounts"
+ },
+ "renewal_tax": { "$ref": "#/components/schemas/RenewalTax" },
+ "charge_timing": {
+ "type": "string",
+ "const": "on_confirmation",
+ "title": "Charge Timing",
+ "default": "on_confirmation"
+ },
+ "renewal_terms": { "type": "string", "title": "Renewal Terms" },
+ "expires_at": {
+ "type": "string",
+ "format": "date-time",
+ "title": "Expires At"
+ }
+ },
+ "type": "object",
+ "required": [
+ "price_id",
+ "accepted_offer_token",
+ "amount_due",
+ "currency",
+ "billing_interval",
+ "renewal_unit_amount",
+ "renewal_terms",
+ "expires_at"
+ ],
+ "title": "ActivationTerms"
+ },
"ActiveStreamInfo": {
"properties": {
"turn_id": { "type": "string", "title": "Turn Id" },
@@ -29977,6 +30314,73 @@
"required": ["name"],
"title": "RenameFileRequest"
},
+ "RenewalDiscount": {
+ "properties": {
+ "amount_off": {
+ "anyOf": [{ "type": "integer" }, { "type": "null" }],
+ "title": "Amount Off"
+ },
+ "percent_off": {
+ "anyOf": [{ "type": "number" }, { "type": "null" }],
+ "title": "Percent Off"
+ },
+ "currency": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Currency"
+ },
+ "duration": { "type": "string", "title": "Duration" },
+ "duration_in_months": {
+ "anyOf": [{ "type": "integer" }, { "type": "null" }],
+ "title": "Duration In Months"
+ },
+ "ends_at": {
+ "anyOf": [{ "type": "integer" }, { "type": "null" }],
+ "title": "Ends At"
+ }
+ },
+ "type": "object",
+ "required": ["duration"],
+ "title": "RenewalDiscount"
+ },
+ "RenewalTax": {
+ "properties": {
+ "automatic": {
+ "type": "boolean",
+ "title": "Automatic",
+ "default": false
+ },
+ "price_tax_behavior": {
+ "type": "string",
+ "title": "Price Tax Behavior",
+ "default": "unspecified"
+ },
+ "rates": {
+ "items": { "$ref": "#/components/schemas/RenewalTaxRate" },
+ "type": "array",
+ "title": "Rates"
+ }
+ },
+ "type": "object",
+ "title": "RenewalTax"
+ },
+ "RenewalTaxRate": {
+ "properties": {
+ "display_name": { "type": "string", "title": "Display Name" },
+ "percentage": { "type": "number", "title": "Percentage" },
+ "inclusive": { "type": "boolean", "title": "Inclusive" },
+ "country": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Country"
+ },
+ "state": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "State"
+ }
+ },
+ "type": "object",
+ "required": ["display_name", "percentage", "inclusive"],
+ "title": "RenewalTaxRate"
+ },
"RequestTopUp": {
"properties": {
"credit_amount": { "type": "integer", "title": "Credit Amount" },
diff --git a/docs/engineering/pro-activation.md b/docs/engineering/pro-activation.md
new file mode 100644
index 0000000000..67c12b6ccc
--- /dev/null
+++ b/docs/engineering/pro-activation.md
@@ -0,0 +1,242 @@
+# Trial conversion to Pro or Max and usage
+
+This backend change is stacked on allowance PR #15184, tested parent
+`7a1b770438bd9315f685850ebadacedd09a27800`, rebased on dev
+`f62abe332b4e065815d55e56a2faa5d1915fb5bd`. It gives an eligible trial's first settled
+conversion to Pro or Max fresh daily and weekly consumption. Trial exhaustion
+never initiates a purchase. The trial's original accepted schedule can convert automatically;
+ending it early requires the separate explicit confirmation below.
+
+## Durable activation and accounting
+
+An owned, live Stripe subscription must be active, with an authoritative settled
+recurring invoice for that subscription. A checkout redirect, completed Checkout
+Session, trial setup invoice, subscription tier, or pending PaymentIntent does
+not establish readiness. Settlement can include a valid discount or customer
+credit; cash `amount_paid > 0` is not required.
+
+`PaidUsageActivation` records one initial trial-conversion subscription/invoice identity per user.
+The user row is locked before the trial row. Entitlement, conversion identity,
+and the completed generation are committed together after Redis can read the
+new generation's calendar counters. No daily or weekly key is deleted or zeroed.
+A repeated reconciliation probes the same generation, preserving any paid usage
+already written to it. Failed transactions can retry without destructive cleanup.
+
+The generation changes the namespace of the existing UTC daily and ISO-week
+counters. Configured Pro and Max limits and reset times stay the same. Work captures its
+billing origin before execution and propagates it into background and child work.
+Database FIFO turns persist that snapshot when queued and restore it at promotion,
+even when activation happens while they wait for a running slot.
+Held approvals retain their original snapshot for both the resumed turn and each
+approved action, including actions held before conversion and answered afterward.
+Delayed trial costs update the original lifetime trial ledger and retain their
+original usage attribution. Neither conversion nor recovery clears trial history,
+credits, runs, conversations, or historical costs.
+
+Only a consumed, owned trial that has not already converted can qualify for a new
+generation. A tier label alone cannot establish that history. These transitions
+have explicit behavior:
+
+| Transition | Fresh daily and weekly usage |
+| --- | --- |
+| Unconverted trial → first paid Pro | Yes, after settled payment and completed reconciliation. |
+| Unconverted trial → first paid Max | Yes, after settled payment and completed reconciliation. |
+| Paid Pro → Max | No; preserve consumption. |
+| Paid Max → Pro | No; preserve consumption. |
+| Unpaid account without a consumed trial → paid signup | No; preserve consumption. |
+| Previously converted trial, renewal, returning paid subscriber, or admin tier edit | No new activation. |
+
+Retries of a qualifying conversion finish the same activation and retain all paid
+usage already written. The migration records the policy start in
+`PaidUsageActivationPolicy` at Stripe's whole-second precision; pre-policy
+payments are not retroactively reset.
+An established paid-plan change can reconcile from a settled proration invoice
+with owned recurring service at the current price and qualifying prior paid
+history. Prorations never establish the initial-payment evidence for a reset.
+Authoritative database reads bypass process-local tier caches for enforcement.
+If entitlement or accounting state cannot be established, execution fails closed.
+
+## Authenticated API
+
+All routes below require the existing user bearer authentication and subscription
+status rate limiter. Attempt IDs are always scoped to the authenticated user.
+Foreign IDs return 404. The exported OpenAPI schema and generated client include
+these endpoints. The historical `pro-activation` route and storage identifiers
+remain compatible while supporting both Pro and Max. This PR contains no visual redesign.
+
+| Method and exact endpoint | Request | Effect |
+| --- | --- | --- |
+| `POST /api/credits/pro-activation/preview` | `{"plan":"MAX","return_to":"/chat/THREAD?resume=1"}` | Preview conversion of the user's existing unconverted trial to Pro or Max and persist quoted terms. Never starts payment. |
+| `POST /api/credits/pro-activation/{id}/confirm` | `{"confirmed":true,"terms_token":"HEX_SHA256"}` | Record explicit consent, then end the same trial subscription early with a stable idempotency key. |
+| `GET /api/credits/pro-activation/{id}` | None | Retrieve live payment state and retry entitlement/usage reconciliation. Never creates or retries a charge. |
+| `GET /api/credits/pro-activation/current` | None | Recover the user's persisted attempt after navigation, or reconcile their existing paid Pro/Max subscription. Never creates or retries a charge. |
+
+Preview accepts an application-relative `return_to` path, including its query and
+fragment; external destinations are rejected. The default is `/settings/billing`.
+The optional `plan` is `PRO` or `MAX`; omitting it retains the trial's accepted
+plan when that offer is Pro or Max. Other accepted trial offers require an
+explicit Pro/Max target for this flow. Keeping the original plan preserves its
+originally accepted price even if the current offer has changed. Selecting another
+plan previews its configured price in the trial's accepted currency and billing
+interval and requires fresh explicit confirmation of those terms. A saved preview
+retains its selected price through confirmation and recovery even if the catalog
+changes; expiry and charge, discount, and tax revalidation still apply. A fresh
+preview uses the current catalog. The trial's original offer remains in its
+lifetime history. A confirmed request changes the existing subscription item,
+never creates a second subscription, and uses exactly the item/price previewed.
+Once confirmed, the persisted destination and accepted terms are immutable.
+Initial paid signup continues through the existing authenticated
+`POST /api/credits/subscription` and Stripe Checkout, which presents the charge and
+requires payment confirmation. Signup without a consumed trial does not reset
+consumption; successful recovery reports `usage_reset=false`. Its validated success
+destination is also saved in subscription metadata for `/current` recovery. Destinations exceeding Stripe's
+metadata length limit are recovered from the owned Checkout's success URL after
+checking the application origin.
+
+Every successful activation response has these fields. Optional values are JSON
+`null`; `return_to` always has a value and `usage_reset` defaults to false:
+
+| Field | Type / meaning |
+| --- | --- |
+| `id` | Attempt ID, or null for initial paid signup without an early-conversion attempt. |
+| `status` | One of the states in the next table. |
+| `terms` | The persisted commercial terms below, or null for the existing Checkout flow. |
+| `terms_token` | SHA-256 of the exact persisted terms, required by confirm; otherwise null. |
+| `return_to` | Validated application-relative return destination. |
+| `invoice_id` | Authoritative current invoice ID, when available. A `ready` response uses the invoice verified during reconciliation, even if it changed after the initial status read. |
+| `hosted_invoice_url` | Stripe's hosted URL for the existing invoice when payment/action is required. |
+| `retry_after_seconds` | Suggested status polling delay, normally 3 while processing. |
+| `error_code` | Machine-readable diagnostic, otherwise null. |
+| `usage_reset` | True only for `ready` when this subscription's current invoice and price match its completed initial trial conversion. False for nontrial signup, renewals, paid-plan changes, and returning/pre-policy/legacy conversions without an activation. It describes the original completed conversion; this poll never resets consumption. |
+| `activation_id` | Stable completed initial activation ID when `usage_reset` is true; otherwise null. Repeated polling returns the same ID and never resets counters again. |
+
+Before showing confirmation, display the commercial `terms`: `plan` (`PRO` or `MAX`),
+`amount_due` formatted in `currency`, `billing_interval`
+(`month` or `year`), `billing_interval_count`, `charge_timing`
+(`on_confirmation`), `renewal_unit_amount`, and `renewal_terms`.
+`price_id` identifies the selected paid price. `accepted_offer_token` binds the
+conversion to the originally accepted trial offer without rewriting that offer;
+`expires_at` is the UTC quote expiry, 15 minutes after preview.
+
+Also display `renewal_discounts`: each contains `amount_off`, `percent_off`,
+`currency`, `duration`, `duration_in_months`, and `ends_at` (Unix seconds when
+available). A `once` discount applies to the initial invoice, not every renewal.
+Display `renewal_tax.automatic`, `renewal_tax.price_tax_behavior`, and any explicit
+`renewal_tax.rates` (`display_name`, `percentage`, `inclusive`, `country`, `state`).
+These modifiers are included in the token and revalidated even when today's
+amount happens to be unchanged. `amount_due` comes from a Stripe invoice preview
+with the existing subscription's discounts, taxes, and customer credit. The base
+renewal amount and modifiers explain subsequent charges without promising a
+fixed future tax amount or an indefinitely recurring introductory discount.
+
+| State | Client behavior |
+| --- | --- |
+| `confirmation_required` | Show the complete terms. Send confirm only after an explicit user action. Missing, false, string, or numeric confirmation is rejected. |
+| `payment_required` | Open `hosted_invoice_url` to pay or update the payment method for this invoice. Retain the attempt and destination; poll status after return. Do not open another Checkout. |
+| `action_required` | Complete authentication using the same hosted invoice. Then poll status; authentication itself is not readiness. |
+| `processing` | Keep the activation recoverable and poll GET using the delay. Do not announce failure or fresh allowance. A settled payment can remain here while database/Redis reconciliation recovers. |
+| `ready` | Paid Pro/Max entitlement and the applicable reset decision are authoritative. Refetch the three data sets below, then continue to `return_to`. Announce an initial fresh allowance only when `usage_reset=true`, once per `activation_id`. |
+| `not_applicable` | The owned live subscription is outside Pro/Max (`not_paid_activation_subscription`), or its paid price has changed away from this attempt's accepted target (`plan_changed`). Stop activation polling, refetch subscription/usage, and continue to the preserved `return_to`. This is not a failed payment and grants no new reset. |
+| `failed` | An authoritative canceled/expired subscription or void/uncollectible invoice has ended this attempt (`payment_canceled`). No fresh usage is granted. |
+
+401/403 require authentication; 404 means no owned attempt/subscription was found.
+409 means the unconfirmed terms expired/changed, ownership cannot be established,
+or another confirmation currently owns the account checkout lock. Fetch current
+state before deciding whether a fresh preview is appropriate. 422 means invalid
+input. A preview/terms-validation Stripe failure can return 502 before payment is
+submitted. After durable consent, an uncertain mutation or reconciliation result
+returns `processing`, not a payment-failure claim. The current-status route also
+returns `processing` during database/Stripe outages.
+An unknown price or ambiguous subscription items remain `processing` with
+`error_code=plan_unavailable`; a stale local tier alone never makes paid Pro/Max
+recovery fail. Accepted trial prices remain recognized after offer changes.
+If the plan changes during reconciliation, readiness waits for the locked tier,
+current subscription price, and attempt's accepted target to agree. A subsequent
+poll observes any changed attempt target as `not_applicable` (`plan_changed`).
+`/current` skips subscriptions outside Pro/Max while looking for an applicable paid
+subscription, returning `not_applicable` if no applicable subscription exists.
+
+On refresh/navigation, call `/current`; do not derive success from URL parameters,
+an old tier response, or a cached completed Checkout. If the original confirmation
+request had no definitive response, it can be retried with the **same** persisted
+attempt ID and terms token. A live subscription that already left `trialing` is
+only reconciled. If still trialing, the exact Stripe request uses the same key
+`pro-activation:{id}`; this is recovery of existing consent, never a new purchase.
+Routine polling uses GET exclusively. After 23 hours the backend stops replaying
+an ambiguous mutation (`processing`, `error_code=recovery_required`), before
+Stripe's minimum idempotency retention expires; an operator must establish its
+outcome. Never create a replacement attempt or invoice to resolve that state.
+If accepted terms change after consent was persisted, the backend also stops
+submission (`processing`, `error_code=terms_changed`); establish the existing
+payment outcome before arranging any new consent.
+An unconfirmed trial whose live accepted price changed also returns `terms_changed`
+instead of offering confirmation against stale terms. Refresh the preview only
+after the subscription again matches its accepted offer; no payment was submitted.
+
+In the final five minutes before the live scheduled trial end, confirmation of
+the original plan returns processing and lets the already accepted scheduled
+conversion happen. Preview or confirmation of a different plan is rejected with
+409 in this window; it must not silently charge the original plan after showing
+the other plan's terms. A previously confirmed alternate-plan attempt that reaches
+this window without a definitive mutation outcome returns `processing` with
+`error_code=trial_ending`; poll its existing state rather than retrying a charge.
+This avoids racing a scheduled Stripe transition with an early-end request.
+
+After `ready`, invalidate and **await refetch** of queries for:
+
+- `GET /api/credits/trial` (active/converted state and preserved lifetime history).
+- `GET /api/credits/subscription` (entitlement and billing state).
+- `GET /api/chat/usage` (the applicable Pro or Max allowance and current consumption).
+
+Use the generated query-key helpers for these exact endpoints; discard any old
+paywall/exhaustion decision derived from their previous results. Preserve
+`return_to` throughout hosted payment/authentication navigation.
+`usage_reset=true` describes the completed initial invoice, not an operation
+performed by this poll. Preserve the last announced `activation_id` across
+navigation. Later renewal or plan-change invoices return false and no activation
+ID; repeated recovery of the initial invoice must not repeat the fresh-usage claim.
+
+## Rollout and recovery requirements
+
+Pause new work and checkout/early-conversion admission, then drain all foreground,
+queued, background, batch, and child-task work from old workers **before applying
+the migration**. The migration records the policy start time: applying it while
+old workers can still admit paid work would allow a later reconciliation to
+exclude that work from the fresh allowance. Install the schema, roll out API,
+reconciliation services and every worker/producer together, then resume admission.
+Scheduled Stripe payments during this window reconcile after the new code starts.
+Legacy batch callbacks without a stored accounting context fail closed, mark the
+job errored, and release the original lock without billing under a new context.
+Legacy FIFO entries with missing, invalid, or foreign accounting snapshots remain
+queued without dispatch. Use the existing queue cancellation controls and submit
+a new turn; do not fabricate a snapshot from the user's current paid allowance.
+Held approvals without an owned accounting snapshot require a new request and
+cannot execute against the current paid allowance.
+These entries must still be drained before rollout. Mixed old/new usage writers must not account newly
+admitted work after activation. Keep the
+generation-aware accounting code during rollback for accounts already activated;
+rolling back to readers of only the old Redis keys would lose correct enforcement.
+
+Subscribe Stripe webhooks to `invoice.paid`, payment-success/failure events, and
+subscription changes. Leave the periodic Stripe reconciliation sweep enabled.
+Webhook retries, status polling, and the sweep all converge on the same database
+activation identity. Recovery must never DELETE usage keys, clear an activation
+row, clear the lifetime trial ledger, or call a billing mutation merely because
+the allowance is exhausted. Retry a paid-but-unreconciled activation through GET
+or the reconciliation function after the dependency recovers.
+
+Before enabling the future frontend action, validate the pinned Stripe API using
+test-mode trials/test clocks: exhausted and partial early conversion to Pro and Max,
+scheduled conversion, Pro↔Max changes preserving consumption, nontrial signup
+without a reset, SCA, declines, 100% discounts/customer credit, product-restricted
+discounts when changing plans, duplicate events, and a
+lost mutation response. Local tests use Stripe boundary doubles and real
+disposable PostgreSQL/Redis for transaction/concurrency/accounting behavior; they
+do not exercise production billing. No rollout or production data change is part
+of this PR.
+
+Stripe references: [subscription update and payment behavior](https://docs.stripe.com/api/subscriptions/update),
+[invoice previews](https://docs.stripe.com/api/invoices/create_preview), and
+[invoice payment relationships](https://docs.stripe.com/api/invoice-payment).
+Product restrictions are described by the
+[coupon object](https://docs.stripe.com/api/coupons/object?api-version=2025-02-24.acacia).