feat(platform): Implement Auto-Top-Up credits capability

autogpt_platform/backend/backend/data/credit.py

@@ -1,3 +1,4 @@
+import logging
 from abc import ABC, abstractmethod
 from datetime import datetime, timezone
 
@@ -13,11 +14,13 @@
 from backend.data.block_cost_config import BLOCK_COSTS
 from backend.data.cost import BlockCost, BlockCostType
 from backend.data.execution import NodeExecutionEntry
+from backend.data.model import AutoTopUpConfig
 from backend.data.user import get_user_by_id
 from backend.util.settings import Settings
 
 settings = Settings()
 stripe.api_key = settings.secrets.stripe_api_key
+logger = logging.getLogger(__name__)
 
 
 class UserCreditBase(ABC):
@@ -177,10 +180,11 @@ async def _add_transaction(
         is_active: bool = True,
         transaction_key: str | None = None,
         metadata: Json = Json({}),
-    ):
+    ) -> int:
         async with db.locked_transaction(f"usr_trx_{user_id}"):
             # Get latest balance snapshot
-            user_balance, _ = await self._get_credits(user_id)
+            user_balance = await self.get_credits(user_id)
+
             if amount < 0 and user_balance < abs(amount):
                 raise ValueError(
                     f"Insufficient balance for user {user_id}, balance: {user_balance}, amount: {amount}"
@@ -271,7 +275,7 @@ async def spend_credits(
         if cost == 0:
             return 0
 
-        await self._add_transaction(
+        balance = await self._add_transaction(
             user_id=entry.user_id,
             amount=-cost,
             transaction_type=CreditTransactionType.USAGE,
@@ -287,17 +291,73 @@ async def spend_credits(
                 }
             ),
         )
+        user_id = entry.user_id
+
+        # Auto top-up if balance just went below threshold due to this transaction.
+        auto_top_up = await get_auto_top_up(user_id)
+        if balance < auto_top_up.threshold <= balance - cost:
+            try:
+                await self.top_up_credits(user_id=user_id, amount=auto_top_up.amount)
+            except Exception as e:
+                # Failed top-up is not critical, we can move on.
+                logger.error(
+                    f"Auto top-up failed for user {user_id}, balance: {balance}, amount: {auto_top_up.amount}, error: {e}"
+                )
 
         return cost
 
     async def top_up_credits(self, user_id: str, amount: int):
         if amount < 0:
             raise ValueError(f"Top up amount must not be negative: {amount}")
 
-        await self._add_transaction(
-            user_id=user_id,
-            amount=amount,
-            transaction_type=CreditTransactionType.TOP_UP,
+        customer_id = await get_stripe_customer_id(user_id)
+
+        payment_methods = stripe.PaymentMethod.list(customer=customer_id, type="card")
+        if not payment_methods:
+            raise ValueError("No payment method found, please add it on the platform.")
+
+        for payment_method in payment_methods:
+            if amount == 0:
+                setup_intent = stripe.SetupIntent.create(
+                    customer=customer_id,
+                    usage="off_session",
+                    confirm=True,
+                    payment_method=payment_method.id,
+                    automatic_payment_methods={
+                        "enabled": True,
+                        "allow_redirects": "never",
+                    },
+                )
+                if setup_intent.status == "succeeded":
+                    return
+
+            else:
+                payment_intent = stripe.PaymentIntent.create(
+                    amount=amount,
+                    currency="usd",
+                    description="AutoGPT Platform Credits",
+                    customer=customer_id,
+                    off_session=True,
+                    confirm=True,
+                    payment_method=payment_method.id,
+                    automatic_payment_methods={
+                        "enabled": True,
+                        "allow_redirects": "never",
+                    },
+                )
+                if payment_intent.status == "succeeded":
+                    await self._add_transaction(
+                        user_id=user_id,
+                        amount=amount,
+                        transaction_type=CreditTransactionType.TOP_UP,
+                        transaction_key=payment_intent.id,
+                        metadata=Json({"payment_intent": payment_intent}),
+                        is_active=True,
+                    )
+                    return
+
+        raise ValueError(
+            f"Out of {len(payment_methods)} payment methods tried, none is supported"
         )
 
     async def top_up_intent(self, user_id: str, amount: int) -> str:
@@ -320,13 +380,14 @@ async def top_up_intent(self, user_id: str, amount: int) -> str:
                 }
             ],
             mode="payment",
+            payment_intent_data={"setup_future_usage": "off_session"},
+            saved_payment_method_options={"payment_method_save": "enabled"},
             success_url=settings.config.platform_base_url
             + "/marketplace/credits?topup=success",
             cancel_url=settings.config.platform_base_url
             + "/marketplace/credits?topup=cancel",
         )
 
-        # Create pending transaction
         await self._add_transaction(
             user_id=user_id,
             amount=amount,
@@ -356,7 +417,7 @@ async def fulfill_checkout(
             find_filter["userId"] = user_id
 
         # Find the most recent inactive top-up transaction
-        credit_transaction = await CreditTransaction.prisma().find_first_or_raise(
+        credit_transaction = await CreditTransaction.prisma().find_first(
             where=find_filter,
             order={"createdAt": "desc"},
         )
@@ -455,3 +516,21 @@ async def get_stripe_customer_id(user_id: str) -> str:
         where={"id": user_id}, data={"stripeCustomerId": customer.id}
     )
     return customer.id
+
+
+async def set_auto_top_up(user_id: str, threshold: int, amount: int):
+    await User.prisma().update(
+        where={"id": user_id},
+        data={"topUpConfig": Json({"threshold": threshold, "amount": amount})},
+    )
+
+
+async def get_auto_top_up(user_id: str) -> AutoTopUpConfig:
+    user = await get_user_by_id(user_id)
+    if not user:
+        raise ValueError("Invalid user ID")
+
+    if not user.topUpConfig:
+        return AutoTopUpConfig(threshold=0, amount=0)
+
+    return AutoTopUpConfig.model_validate(user.topUpConfig)

autogpt_platform/backend/backend/data/model.py

@@ -347,3 +347,10 @@ def CredentialsField(
 
 class ContributorDetails(BaseModel):
     name: str = Field(title="Name", description="The name of the contributor.")
+
+
+class AutoTopUpConfig(BaseModel):
+    amount: int
+    """Amount of credits to top up."""
+    threshold: int
+    """Threshold to trigger auto top up."""

autogpt_platform/backend/backend/server/routers/v1.py

@@ -30,9 +30,12 @@
 )
 from backend.data.block import BlockInput, CompletedBlockOutput
 from backend.data.credit import (
+    AutoTopUpConfig,
+    get_auto_top_up,
     get_block_costs,
     get_stripe_customer_id,
     get_user_credit_model,
+    set_auto_top_up,
 )
 from backend.data.user import get_or_create_user
 from backend.executor import ExecutionManager, ExecutionScheduler, scheduler
@@ -71,7 +74,6 @@ def execution_scheduler_client() -> ExecutionScheduler:
 logger = logging.getLogger(__name__)
 integration_creds_manager = IntegrationCredentialsManager()
 
-
 _user_credit_model = get_user_credit_model()
 
 # Define the API routes
@@ -161,6 +163,41 @@ async def fulfill_checkout(user_id: Annotated[str, Depends(get_user_id)]):
     return Response(status_code=200)
 
 
+@v1_router.post(
+    path="/credits/auto-top-up",
+    tags=["credits"],
+    dependencies=[Depends(auth_middleware)],
+)
+async def configure_user_auto_top_up(
+    request: AutoTopUpConfig, user_id: Annotated[str, Depends(get_user_id)]
+) -> str:
+    if request.threshold < 0:
+        raise ValueError("Threshold must be greater than 0")
+    if request.amount < request.threshold:
+        raise ValueError("Amount must be greater than or equal to threshold")
+
+    current_balance = await _user_credit_model.get_credits(user_id)
+
+    if current_balance < request.threshold:
+        await _user_credit_model.top_up_credits(user_id, request.amount)
+    else:
+        await _user_credit_model.top_up_credits(user_id, 0)
+
+    await set_auto_top_up(user_id, threshold=request.threshold, amount=request.amount)
+    return "Auto top-up settings updated"
+
+
+@v1_router.get(
+    path="/credits/auto-top-up",
+    tags=["credits"],
+    dependencies=[Depends(auth_middleware)],
+)
+async def get_user_auto_top_up(
+    user_id: Annotated[str, Depends(get_user_id)]
+) -> AutoTopUpConfig:
+    return await get_auto_top_up(user_id)
+
+
 @v1_router.post(path="/credits/stripe_webhook", tags=["credits"])
 async def stripe_webhook(request: Request):
     # Get the raw request body

autogpt_platform/backend/migrations/20250115432618_add_auto_top_up_config/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "User" ADD COLUMN     "topUpConfig" JSONB;

autogpt_platform/backend/schema.prisma

@@ -21,6 +21,7 @@ model User {
   metadata         Json     @default("{}")
   integrations     String   @default("")
   stripeCustomerId String?
+  topUpConfig      Json?
 
   // Relations
   AgentGraphs          AgentGraph[]

autogpt_platform/backend/test/data/test_credit.py

@@ -1,6 +1,7 @@
 from datetime import datetime, timezone
 
 import pytest
+from prisma.enums import CreditTransactionType
 from prisma.models import CreditTransaction
 
 from backend.blocks.llm import AITextGeneratorBlock
@@ -18,10 +19,18 @@ async def disable_test_user_transactions():
     await CreditTransaction.prisma().delete_many(where={"userId": DEFAULT_USER_ID})
 
 
+async def top_up(amount: int):
+    await user_credit._add_transaction(
+        DEFAULT_USER_ID,
+        amount,
+        CreditTransactionType.TOP_UP,
+    )
+
+
 @pytest.mark.asyncio(scope="session")
 async def test_block_credit_usage(server: SpinTestServer):
     await disable_test_user_transactions()
-    await user_credit.top_up_credits(DEFAULT_USER_ID, 100)
+    await top_up(100)
     current_credit = await user_credit.get_credits(DEFAULT_USER_ID)
 
     spending_amount_1 = await user_credit.spend_credits(
@@ -70,7 +79,7 @@ async def test_block_credit_top_up(server: SpinTestServer):
     await disable_test_user_transactions()
     current_credit = await user_credit.get_credits(DEFAULT_USER_ID)
 
-    await user_credit.top_up_credits(DEFAULT_USER_ID, 100)
+    await top_up(100)
 
     new_credit = await user_credit.get_credits(DEFAULT_USER_ID)
     assert new_credit == current_credit + 100
@@ -89,7 +98,7 @@ async def test_block_credit_reset(server: SpinTestServer):
     # Month 1 result should only affect month 1
     user_credit.time_now = lambda: datetime.now(timezone.utc).replace(month=month1)
     month1credit = await user_credit.get_credits(DEFAULT_USER_ID)
-    await user_credit.top_up_credits(DEFAULT_USER_ID, 100)
+    await top_up(100)
     assert await user_credit.get_credits(DEFAULT_USER_ID) == month1credit + 100
 
     # Month 2 balance is unaffected