AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.
feat(platform): add subscription tier billing with lazy credit deduction
Zamil Majdyba7929205d4d
diff --git a/autogpt_platform/backend/backend/api/features/v1.py b/autogpt_platform/backend/backend/api/features/v1.pyindex 5f53a91750..5c98673b32 100644--- a/autogpt_platform/backend/backend/api/features/v1.py+++ b/autogpt_platform/backend/backend/api/features/v1.py@@ -51,8 +51,10 @@ from backend.data.credit import (TransactionHistory,UserCredit,get_auto_top_up,+ get_subscription_cost,get_user_credit_model,set_auto_top_up,+ set_subscription_tier,)from backend.data.graph import GraphSettingsfrom backend.data.model import CredentialsMetaInput, UserOnboarding@@ -626,9 +628,12 @@ async def configure_user_auto_top_up(raise HTTPException(status_code=422, detail=str(e))raise- await set_auto_top_up(- user_id, AutoTopUpConfig(threshold=request.threshold, amount=request.amount)- )+ try:+ await set_auto_top_up(+ user_id, AutoTopUpConfig(threshold=request.threshold, amount=request.amount)+ )+ except ValueError as e:+ raise HTTPException(status_code=422, detail=str(e))return "Auto top-up settings updated"@@ -644,6 +649,80 @@ async def get_user_auto_top_up(return await get_auto_top_up(user_id)+class SubscriptionTierRequest(BaseModel):+ tier: str+++class SubscriptionStatusResponse(BaseModel):+ tier: str+ monthly_cost: int+ tier_costs: dict[str, int]+++@v1_router.get(+ path="/credits/subscription",+ summary="Get subscription tier, current cost, and all tier costs",+ tags=["credits"],+ dependencies=[Security(requires_user)],+)+async def get_subscription_status(+ user_id: Annotated[str, Security(get_user_id)],+) -> SubscriptionStatusResponse:+ from prisma.enums import SubscriptionTier++ from backend.data.user import get_user_by_id++ user = await get_user_by_id(user_id)+ tier = user.subscription_tier or SubscriptionTier.FREE+ cost = await get_subscription_cost(user_id, tier)+ pro_cost, biz_cost = await asyncio.gather(+ get_subscription_cost(user_id, SubscriptionTier.PRO),+ get_subscription_cost(user_id, SubscriptionTier.BUSINESS),+ )+ return SubscriptionStatusResponse(+ tier=tier.value,+ monthly_cost=cost,+ tier_costs={"FREE": 0, "PRO": pro_cost, "BUSINESS": biz_cost, "ENTERPRISE": 0},+ )+++@v1_router.post(+ path="/credits/subscription",+ summary="Upgrade or downgrade subscription tier",+ tags=["credits"],+ dependencies=[Security(requires_user)],+)+async def update_subscription_tier(+ request: SubscriptionTierRequest,+ user_id: Annotated[str, Security(get_user_id)],+) -> SubscriptionStatusResponse:+ from prisma.enums import SubscriptionTier++ try:+ tier = SubscriptionTier(request.tier.upper())+ except ValueError:+ raise HTTPException(+ status_code=422,+ detail=f"Invalid tier '{request.tier}'. Valid values: {[t.value for t in SubscriptionTier]}",+ )++ try:+ await set_subscription_tier(user_id, tier)+ except ValueError as e:+ raise HTTPException(status_code=422, detail=str(e))++ cost, pro_cost, biz_cost = await asyncio.gather(+ get_subscription_cost(user_id, tier),+ get_subscription_cost(user_id, SubscriptionTier.PRO),+ get_subscription_cost(user_id, SubscriptionTier.BUSINESS),+ )+ return SubscriptionStatusResponse(+ tier=tier.value,+ monthly_cost=cost,+ tier_costs={"FREE": 0, "PRO": pro_cost, "BUSINESS": biz_cost, "ENTERPRISE": 0},+ )++@v1_router.post(path="/credits/stripe_webhook", summary="Handle Stripe webhooks", tags=["credits"])diff --git a/autogpt_platform/backend/backend/copilot/rate_limit.py b/autogpt_platform/backend/backend/copilot/rate_limit.pyindex b72de3cdbf..f19bf65ede 100644--- a/autogpt_platform/backend/backend/copilot/rate_limit.py+++ b/autogpt_platform/backend/backend/copilot/rate_limit.py@@ -113,8 +113,18 @@ async def check_rate_limit(This is acceptable because token-based limits are approximate by nature(the exact token count is unknown until after generation).+ Also triggers lazy monthly subscription deduction (idempotent).+Fails open: if Redis is unavailable, allows the request."""+ # Lazy subscription deduction — idempotent, only writes once per month.+ try:+ from backend.data.credit import ensure_subscription_paid++ await ensure_subscription_paid(user_id)+ except Exception as e:+ logger.warning(f"Subscription check failed for {user_id}: {e}")+# Short-circuit: when both limits are 0 (unlimited) skip the Redis# round-trip entirely.if daily_token_limit <= 0 and weekly_token_limit <= 0:diff --git a/autogpt_platform/backend/backend/data/credit.py b/autogpt_platform/backend/backend/data/credit.pyindex 04f91d8d61..a7a2287c29 100644--- a/autogpt_platform/backend/backend/data/credit.py+++ b/autogpt_platform/backend/backend/data/credit.py@@ -1,7 +1,7 @@import loggingfrom abc import ABC, abstractmethodfrom collections import defaultdict-from datetime import datetime, timezone+from datetime import UTC, datetime, timezonefrom typing import TYPE_CHECKING, Any, castimport stripe@@ -10,6 +10,7 @@ from prisma.enums import (CreditTransactionType,NotificationType,OnboardingStep,+ SubscriptionTier,)from prisma.errors import UniqueViolationErrorfrom prisma.models import CreditRefundRequest, CreditTransaction, User, UserBalance@@ -604,6 +605,8 @@ class UserCredit(UserCreditBase):if cost == 0:return 0+ await ensure_subscription_paid(user_id)+balance, _ = await self._add_transaction(user_id=user_id,amount=-cost,@@ -1144,10 +1147,17 @@ class BetaUserCredit(UserCredit):if (snapshot_time.year, snapshot_time.month) == (cur_time.year, cur_time.month):return balance+ # Include subscription cost in grant so the upcoming subscription deduction+ # does not reduce the user's effective usage credits below num_user_credits_refill.+ user = await get_user_by_id(user_id)+ tier = user.subscription_tier or SubscriptionTier.FREE+ sub_cost = await get_subscription_cost(user_id, tier)+ target = self.num_user_credits_refill + sub_cost+try:balance, _ = await self._add_transaction(user_id=user_id,- amount=max(self.num_user_credits_refill - balance, 0),+ amount=max(target - balance, 0),transaction_type=CreditTransactionType.GRANT,transaction_key=f"MONTHLY-CREDIT-TOP-UP-{cur_time}",metadata=SafeJson({"reason": "Monthly credit refill"}),@@ -1246,12 +1256,61 @@ async def get_stripe_customer_id(user_id: str) -> str:async def set_auto_top_up(user_id: str, config: AutoTopUpConfig):+ user = await get_user_by_id(user_id)+ tier = user.subscription_tier or SubscriptionTier.FREE+ sub_cost = await get_subscription_cost(user_id, tier)+ if sub_cost > 0 and config.amount < sub_cost:+ raise ValueError(+ f"Auto top-up amount must be at least {sub_cost} credits to maintain "+ f"your {tier.value} subscription. Set amount >= {sub_cost} or downgrade to Free."+ )await User.prisma().update(where={"id": user_id},data={"topUpConfig": SafeJson(config.model_dump())},)+async def set_subscription_tier(user_id: str, tier: SubscriptionTier) -> None:+ """+ Upgrade or downgrade a user's subscription tier.++ Upgrade: validates auto top-up is configured with amount >= subscription cost,+ sets the tier immediately, and charges the first month's subscription.+ Downgrade: sets the new tier immediately (takes effect on next monthly cycle).+ No proration — full month is charged on upgrade.+ """+ current_user = await get_user_by_id(user_id)+ current_tier = current_user.subscription_tier or SubscriptionTier.FREE++ sub_cost = await get_subscription_cost(user_id, tier)++ if sub_cost > 0:+ auto_top_up = await get_auto_top_up(user_id)+ if auto_top_up.amount < sub_cost:+ raise ValueError(+ f"Auto top-up must be configured with amount >= {sub_cost} credits "+ f"before upgrading to {tier.value}. Current amount: {auto_top_up.amount}."+ )++ await User.prisma().update(+ where={"id": user_id},+ data={"subscriptionTier": tier},+ )+ get_user_by_id.cache_delete(user_id) # type: ignore[attr-defined]++ # Charge immediately on upgrade (full month, no proration).+ # Downgrade resets cleanly on next monthly cycle.+ tier_order = [+ SubscriptionTier.FREE,+ SubscriptionTier.PRO,+ SubscriptionTier.BUSINESS,+ SubscriptionTier.ENTERPRISE,+ ]+ is_upgrade = tier_order.index(tier) > tier_order.index(current_tier)+ if is_upgrade and sub_cost > 0:+ await ensure_subscription_paid(user_id)++async def get_auto_top_up(user_id: str) -> AutoTopUpConfig:user = await get_user_by_id(user_id)@@ -1261,6 +1320,69 @@ async def get_auto_top_up(user_id: str) -> AutoTopUpConfig:return AutoTopUpConfig.model_validate(user.top_up_config)+async def get_subscription_cost(user_id: str, tier: SubscriptionTier) -> int:+ """Return monthly subscription cost in credits from LD. 0 = free or disabled."""+ from backend.util.feature_flag import get_feature_flag_value++ flag_map = {+ SubscriptionTier.PRO: Flag.SUBSCRIPTION_COST_PRO,+ SubscriptionTier.BUSINESS: Flag.SUBSCRIPTION_COST_BUSINESS,+ }+ flag = flag_map.get(tier)+ if flag is None:+ return 0++ cost = await get_feature_flag_value(flag.value, user_id, default=0)+ return int(cost) if isinstance(cost, (int, float)) else 0+++async def ensure_subscription_paid(user_id: str) -> None:+ """+ Lazy monthly subscription deduction. Idempotent — safe to call from+ spend_credits() and rate-limit checks. Triggers auto top-up when balance+ drops below threshold after deduction.++ On auto top-up failure: logs only (grace period). Does not downgrade tier.+ """+ user = await get_user_by_id(user_id)+ tier = user.subscription_tier or SubscriptionTier.FREE+ sub_cost = await get_subscription_cost(user_id, tier)+ if sub_cost == 0:+ return++ cur_month = datetime.now(UTC).strftime("%Y-%m")+ key = f"SUBSCRIPTION-{user_id}-{cur_month}"++ credit = UserCredit()+ try:+ balance, _ = await credit._add_transaction(+ user_id=user_id,+ amount=-sub_cost,+ transaction_type=CreditTransactionType.SUBSCRIPTION,+ transaction_key=key,+ fail_insufficient_credits=False,+ metadata=SafeJson({"reason": f"Monthly {tier.value} subscription"}),+ )+ except UniqueViolationError:+ return # already paid this month++ auto_top_up = await get_auto_top_up(user_id)+ if auto_top_up.threshold and balance < auto_top_up.threshold:+ try:+ await credit._top_up_credits(+ user_id=user_id,+ amount=auto_top_up.amount,+ key=f"AUTO-TOP-UP-SUB-{user_id}-{cur_month}",+ ceiling_balance=auto_top_up.threshold,+ top_up_type=TopUpType.AUTO,+ )+ except Exception as e:+ logger.error(+ f"Auto top-up failed during subscription deduction for {user_id}: {e}. "+ f"Balance: {balance}, subscription cost: {sub_cost}."+ )++async def admin_get_user_history(page: int = 1,page_size: int = 20,diff --git a/autogpt_platform/backend/backend/data/model.py b/autogpt_platform/backend/backend/data/model.pyindex bd8b5bcdcc..50b983d4e5 100644--- a/autogpt_platform/backend/backend/data/model.py+++ b/autogpt_platform/backend/backend/data/model.py@@ -21,7 +21,7 @@ from typing import ()from uuid import uuid4-from prisma.enums import CreditTransactionType, OnboardingStep+from prisma.enums import CreditTransactionType, OnboardingStep, SubscriptionTierfrom pydantic import (BaseModel,ConfigDict,@@ -72,6 +72,9 @@ class User(BaseModel):top_up_config: Optional["AutoTopUpConfig"] = Field(None, description="Top up configuration")+ subscription_tier: SubscriptionTier = Field(+ default=SubscriptionTier.FREE, description="User subscription tier"+ )# Notification preferencesmax_emails_per_day: int = Field(default=3, description="Maximum emails per day")@@ -146,6 +149,7 @@ class User(BaseModel):integrations=prisma_user.integrations or "",stripe_customer_id=prisma_user.stripeCustomerId,top_up_config=top_up_config,+ subscription_tier=prisma_user.subscriptionTier or SubscriptionTier.FREE,max_emails_per_day=prisma_user.maxEmailsPerDay or 3,notify_on_agent_run=prisma_user.notifyOnAgentRun or True,notify_on_zero_balance=prisma_user.notifyOnZeroBalance or True,diff --git a/autogpt_platform/backend/backend/util/feature_flag.py b/autogpt_platform/backend/backend/util/feature_flag.pyindex 2af9659011..3777a76985 100644--- a/autogpt_platform/backend/backend/util/feature_flag.py+++ b/autogpt_platform/backend/backend/util/feature_flag.py@@ -41,6 +41,8 @@ class Flag(str, Enum):COPILOT_SDK = "copilot-sdk"COPILOT_DAILY_TOKEN_LIMIT = "copilot-daily-token-limit"COPILOT_WEEKLY_TOKEN_LIMIT = "copilot-weekly-token-limit"+ SUBSCRIPTION_COST_PRO = "subscription-cost-pro"+ SUBSCRIPTION_COST_BUSINESS = "subscription-cost-business"def is_configured() -> bool:diff --git a/autogpt_platform/backend/migrations/20260409000000_add_subscription_tier/migration.sql b/autogpt_platform/backend/migrations/20260409000000_add_subscription_tier/migration.sqlnew file mode 100644index 0000000000..72872c1872--- /dev/null+++ b/autogpt_platform/backend/migrations/20260409000000_add_subscription_tier/migration.sql@@ -0,0 +1,8 @@+-- CreateEnum+CREATE TYPE "SubscriptionTier" AS ENUM ('FREE', 'PRO', 'BUSINESS', 'ENTERPRISE');++-- AlterEnum+ALTER TYPE "CreditTransactionType" ADD VALUE 'SUBSCRIPTION';++-- AlterTable+ALTER TABLE "User" ADD COLUMN "subscriptionTier" "SubscriptionTier" NOT NULL DEFAULT 'FREE';diff --git a/autogpt_platform/backend/schema.prisma b/autogpt_platform/backend/schema.prismaindex f269d45016..58904d5b9b 100644--- a/autogpt_platform/backend/schema.prisma+++ b/autogpt_platform/backend/schema.prisma@@ -40,6 +40,8 @@ model User {timezone String @default("not-set")+ subscriptionTier SubscriptionTier @default(FREE)+// RelationsAgentGraphs AgentGraph[]@@ -745,12 +747,20 @@ model AnalyticsMetrics {////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////+enum SubscriptionTier {+ FREE+ PRO+ BUSINESS+ ENTERPRISE+}+enum CreditTransactionType {TOP_UPUSAGEGRANTREFUNDCARD_CHECK+ SUBSCRIPTION}model CreditTransaction {diff --git a/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/components/SubscriptionTierSection/SubscriptionTierSection.tsx b/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/components/SubscriptionTierSection/SubscriptionTierSection.tsxnew file mode 100644index 0000000000..214e9445db--- /dev/null+++ b/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/components/SubscriptionTierSection/SubscriptionTierSection.tsx@@ -0,0 +1,127 @@+"use client";+import { useState } from "react";+import { Button } from "@/components/__legacy__/ui/button";+import { useSubscriptionTierSection } from "./useSubscriptionTierSection";++type TierInfo = {+ key: string;+ label: string;+ multiplier: string;+ description: string;+};++const TIERS: TierInfo[] = [+ {+ key: "FREE",+ label: "Free",+ multiplier: "1x",+ description: "Base rate limits",+ },+ {+ key: "PRO",+ label: "Pro",+ multiplier: "5x",+ description: "5x more AutoPilot capacity",+ },+ {+ key: "BUSINESS",+ label: "Business",+ multiplier: "20x",+ description: "20x more AutoPilot capacity",+ },+];++function formatCost(cents: number): string {+ if (cents === 0) return "Free";+ return `$${(cents / 100).toFixed(2)}/mo`;+}++export function SubscriptionTierSection() {+ const { subscription, isLoading, isPending, changeTier } =+ useSubscriptionTierSection();+ const [tierError, setTierError] = useState<string | null>(null);++ if (isLoading || !subscription) return null;++ async function handleTierChange(tierKey: string) {+ setTierError(null);+ const err = await changeTier(tierKey);+ if (err) setTierError(err);+ }++ return (+ <div className="space-y-4">+ <h3 className="text-lg font-medium">Subscription Plan</h3>++ {tierError && (+ <p className="rounded-md border border-red-200 bg-red-50 px-3 py-2 text-sm text-red-700 dark:border-red-800 dark:bg-red-900/20 dark:text-red-400">+ {tierError}+ </p>+ )}++ <div className="grid grid-cols-1 gap-3 sm:grid-cols-3">+ {TIERS.map((tier) => {+ const isCurrent = subscription.tier === tier.key;+ const cost = subscription.tier_costs[tier.key] ?? 0;+ const currentTierOrder = ["FREE", "PRO", "BUSINESS", "ENTERPRISE"];+ const currentIdx = currentTierOrder.indexOf(subscription.tier);+ const targetIdx = currentTierOrder.indexOf(tier.key);+ const isUpgrade = targetIdx > currentIdx;+ const isDowngrade = targetIdx < currentIdx;++ return (+ <div+ key={tier.key}+ className={`rounded-lg border p-4 ${+ isCurrent+ ? "border-violet-500 bg-violet-50 dark:bg-violet-900/20"+ : "border-neutral-200 dark:border-neutral-700"+ }`}+ >+ <div className="mb-2 flex items-center justify-between">+ <span className="font-semibold">{tier.label}</span>+ {isCurrent && (+ <span className="rounded-full bg-violet-100 px-2 py-0.5 text-xs font-medium text-violet-700 dark:bg-violet-800 dark:text-violet-200">+ Current+ </span>+ )}+ </div>++ <p className="mb-1 text-2xl font-bold">{formatCost(cost)}</p>+ <p className="mb-1 text-sm font-medium text-neutral-600 dark:text-neutral-400">+ {tier.multiplier} rate limits+ </p>+ <p className="mb-4 text-sm text-neutral-500 dark:text-neutral-400">+ {tier.description}+ </p>++ {!isCurrent && (+ <Button+ className="w-full"+ variant={isUpgrade ? "default" : "outline"}+ disabled={isPending}+ onClick={() => handleTierChange(tier.key)}+ >+ {isPending+ ? "Updating..."+ : isUpgrade+ ? `Upgrade to ${tier.label}`+ : isDowngrade+ ? `Downgrade to ${tier.label}`+ : `Switch to ${tier.label}`}+ </Button>+ )}+ </div>+ );+ })}+ </div>++ {subscription.tier !== "FREE" && (+ <p className="text-sm text-neutral-500">+ Subscription charged monthly from your credits. Auto top-up required ≥+ subscription cost.+ </p>+ )}+ </div>+ );+}diff --git a/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/components/SubscriptionTierSection/useSubscriptionTierSection.ts b/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/components/SubscriptionTierSection/useSubscriptionTierSection.tsnew file mode 100644index 0000000000..d1af19763a--- /dev/null+++ b/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/components/SubscriptionTierSection/useSubscriptionTierSection.ts@@ -0,0 +1,78 @@+import AutoGPTServerAPI from "@/lib/autogpt-server-api";+import { useCallback, useEffect, useMemo, useState } from "react";++export type SubscriptionStatus = {+ tier: string;+ monthly_cost: number;+ tier_costs: Record<string, number>;+};++export type AutoTopUpConfig = {+ amount: number;+ threshold: number;+};++export function useSubscriptionTierSection() {+ const api = useMemo(() => new AutoGPTServerAPI(), []);++ const [subscription, setSubscription] = useState<SubscriptionStatus | null>(+ null,+ );+ const [autoTopUp, setAutoTopUp] = useState<AutoTopUpConfig | null>(null);+ const [isLoading, setIsLoading] = useState(true);+ const [error, setError] = useState<string | null>(null);+ const [isPending, setIsPending] = useState(false);++ const fetchSubscription = useCallback(async () => {+ try {+ const [sub, topUp] = await Promise.all([+ api.getSubscription(),+ api.getAutoTopUpConfig(),+ ]);+ setSubscription(sub);+ setAutoTopUp(topUp);+ } catch (e) {+ setError("Failed to load subscription info");+ } finally {+ setIsLoading(false);+ }+ }, [api]);++ useEffect(() => {+ fetchSubscription();+ }, [fetchSubscription]);++ const changeTier = useCallback(+ async (tier: string): Promise<string | null> => {+ const targetCost = subscription?.tier_costs[tier] ?? 0;++ if (targetCost > 0 && (!autoTopUp || autoTopUp.amount < targetCost)) {+ return `Auto top-up amount must be at least $${(targetCost / 100).toFixed(2)} to subscribe to this tier. Configure it below first.`;+ }++ setIsPending(true);+ try {+ const updated = await api.setSubscriptionTier(tier);+ setSubscription(updated);+ return null;+ } catch (e: unknown) {+ const msg =+ e instanceof Error ? e.message : "Failed to change subscription tier";+ return msg;+ } finally {+ setIsPending(false);+ }+ },+ [api, subscription, autoTopUp],+ );++ return {+ subscription,+ autoTopUp,+ isLoading,+ error,+ isPending,+ changeTier,+ refetch: fetchSubscription,+ };+}diff --git a/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/page.tsx b/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/page.tsxindex 34dbb12287..fb565c048b 100644--- a/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/page.tsx+++ b/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/page.tsx@@ -10,6 +10,7 @@ import {} from "@/components/molecules/Toast/use-toast";import { RefundModal } from "./RefundModal";+import { SubscriptionTierSection } from "./components/SubscriptionTierSection/SubscriptionTierSection";import { CreditTransaction } from "@/lib/autogpt-server-api";import { UsagePanelContent } from "@/app/(platform)/copilot/components/UsageLimits/UsageLimits";import type { CoPilotUsageStatus } from "@/app/api/__generated__/models/coPilotUsageStatus";@@ -141,6 +142,11 @@ export default function CreditsPage() {Billing</h1>+ {/* Subscription Tier */}+ <div className="mb-8">+ <SubscriptionTierSection />+ </div>+<div className="grid grid-cols-1 gap-8 lg:grid-cols-2">{/* Top-up Form */}<div className="space-y-4">diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.jsonindex dab1160ea9..341d08fa2a 100644--- a/autogpt_platform/frontend/src/app/api/openapi.json+++ b/autogpt_platform/frontend/src/app/api/openapi.json@@ -1785,6 +1785,68 @@}}},+ "/api/credits/subscription": {+ "get": {+ "tags": ["v1", "credits"],+ "summary": "Get subscription tier, current cost, and all tier costs",+ "operationId": "getV1Get subscription tier, current cost, and all tier costs",+ "responses": {+ "200": {+ "description": "Successful Response",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/SubscriptionStatusResponse"+ }+ }+ }+ },+ "401": {+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"+ }+ },+ "security": [{ "HTTPBearerJWT": [] }]+ },+ "post": {+ "tags": ["v1", "credits"],+ "summary": "Upgrade or downgrade subscription tier",+ "operationId": "postV1Upgrade or downgrade subscription tier",+ "requestBody": {+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/SubscriptionTierRequest"+ }+ }+ },+ "required": true+ },+ "responses": {+ "200": {+ "description": "Successful Response",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/SubscriptionStatusResponse"+ }+ }+ }+ },+ "401": {+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"+ },+ "422": {+ "description": "Validation Error",+ "content": {+ "application/json": {+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }+ }+ }+ }+ },+ "security": [{ "HTTPBearerJWT": [] }]+ }+ },"/api/credits/transactions": {"get": {"tags": ["v1", "credits"],@@ -8617,7 +8679,14 @@},"CreditTransactionType": {"type": "string",- "enum": ["TOP_UP", "USAGE", "GRANT", "REFUND", "CARD_CHECK"],+ "enum": [+ "TOP_UP",+ "USAGE",+ "GRANT",+ "REFUND",+ "CARD_CHECK",+ "SUBSCRIPTION"+ ],"title": "CreditTransactionType"},"DeleteFileResponse": {@@ -12832,6 +12901,26 @@"enum": ["DRAFT", "PENDING", "APPROVED", "REJECTED"],"title": "SubmissionStatus"},+ "SubscriptionStatusResponse": {+ "properties": {+ "tier": { "type": "string", "title": "Tier" },+ "monthly_cost": { "type": "integer", "title": "Monthly Cost" },+ "tier_costs": {+ "additionalProperties": { "type": "integer" },+ "type": "object",+ "title": "Tier Costs"+ }+ },+ "type": "object",+ "required": ["tier", "monthly_cost", "tier_costs"],+ "title": "SubscriptionStatusResponse"+ },+ "SubscriptionTierRequest": {+ "properties": { "tier": { "type": "string", "title": "Tier" } },+ "type": "object",+ "required": ["tier"],+ "title": "SubscriptionTierRequest"+ },"SuggestedGoalResponse": {"properties": {"type": {diff --git a/autogpt_platform/frontend/src/lib/autogpt-server-api/client.ts b/autogpt_platform/frontend/src/lib/autogpt-server-api/client.tsindex 961776e79e..1dbc16e357 100644--- a/autogpt_platform/frontend/src/lib/autogpt-server-api/client.ts+++ b/autogpt_platform/frontend/src/lib/autogpt-server-api/client.ts@@ -194,6 +194,22 @@ export default class BackendAPI {return this._request("PATCH", "/credits");}+ getSubscription(): Promise<{+ tier: string;+ monthly_cost: number;+ tier_costs: Record<string, number>;+ }> {+ return this._get("/credits/subscription");+ }++ setSubscriptionTier(tier: string): Promise<{+ tier: string;+ monthly_cost: number;+ tier_costs: Record<string, number>;+ }> {+ return this._request("POST", "/credits/subscription", { tier });+ }+//////////////////////////////////////////////////////// GRAPHS ////////////////////////////////////////////////////////