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(platform): add whitelisting-backed beta user provisioning (#12347)

Swiftyba301a3912c1
diff --git a/autogpt_platform/backend/.env.default b/autogpt_platform/backend/.env.default
index f73c652387..41068dd31a 100644
--- a/autogpt_platform/backend/.env.default
+++ b/autogpt_platform/backend/.env.default
@@ -37,6 +37,10 @@ JWT_VERIFY_KEY=your-super-secret-jwt-token-with-at-least-32-characters-long
ENCRYPTION_KEY=dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw=
UNSUBSCRIBE_SECRET_KEY=HlP8ivStJjmbf6NKi78m_3FnOogut0t5ckzjsIqeaio=
+## ===== SIGNUP / INVITE GATE ===== ##
+# Set to true to require an invite before users can sign up
+ENABLE_INVITE_GATE=false
+
## ===== IMPORTANT OPTIONAL CONFIGURATION ===== ##
# Platform URLs (set these for webhooks and OAuth to work)
PLATFORM_BASE_URL=http://localhost:8000
diff --git a/autogpt_platform/backend/backend/api/features/admin/model.py b/autogpt_platform/backend/backend/api/features/admin/model.py
index 82f51e8e7a..b2693bd3a7 100644
--- a/autogpt_platform/backend/backend/api/features/admin/model.py
+++ b/autogpt_platform/backend/backend/api/features/admin/model.py
@@ -1,8 +1,17 @@
-from pydantic import BaseModel
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Literal, Optional
+
+import prisma.enums
+from pydantic import BaseModel, EmailStr
from backend.data.model import UserTransaction
from backend.util.models import Pagination
+if TYPE_CHECKING:
+ from backend.data.invited_user import BulkInvitedUsersResult, InvitedUserRecord
+
class UserHistoryResponse(BaseModel):
"""Response model for listings with version history"""
@@ -14,3 +23,70 @@ class UserHistoryResponse(BaseModel):
class AddUserCreditsResponse(BaseModel):
new_balance: int
transaction_key: str
+
+
+class CreateInvitedUserRequest(BaseModel):
+ email: EmailStr
+ name: Optional[str] = None
+
+
+class InvitedUserResponse(BaseModel):
+ id: str
+ email: str
+ status: prisma.enums.InvitedUserStatus
+ auth_user_id: Optional[str] = None
+ name: Optional[str] = None
+ tally_understanding: Optional[dict[str, Any]] = None
+ tally_status: prisma.enums.TallyComputationStatus
+ tally_computed_at: Optional[datetime] = None
+ tally_error: Optional[str] = None
+ created_at: datetime
+ updated_at: datetime
+
+ @classmethod
+ def from_record(cls, record: InvitedUserRecord) -> InvitedUserResponse:
+ return cls.model_validate(record.model_dump())
+
+
+class InvitedUsersResponse(BaseModel):
+ invited_users: list[InvitedUserResponse]
+ pagination: Pagination
+
+
+class BulkInvitedUserRowResponse(BaseModel):
+ row_number: int
+ email: Optional[str] = None
+ name: Optional[str] = None
+ status: Literal["CREATED", "SKIPPED", "ERROR"]
+ message: str
+ invited_user: Optional[InvitedUserResponse] = None
+
+
+class BulkInvitedUsersResponse(BaseModel):
+ created_count: int
+ skipped_count: int
+ error_count: int
+ results: list[BulkInvitedUserRowResponse]
+
+ @classmethod
+ def from_result(cls, result: BulkInvitedUsersResult) -> BulkInvitedUsersResponse:
+ return cls(
+ created_count=result.created_count,
+ skipped_count=result.skipped_count,
+ error_count=result.error_count,
+ results=[
+ BulkInvitedUserRowResponse(
+ row_number=row.row_number,
+ email=row.email,
+ name=row.name,
+ status=row.status,
+ message=row.message,
+ invited_user=(
+ InvitedUserResponse.from_record(row.invited_user)
+ if row.invited_user is not None
+ else None
+ ),
+ )
+ for row in result.results
+ ],
+ )
diff --git a/autogpt_platform/backend/backend/api/features/admin/user_admin_routes.py b/autogpt_platform/backend/backend/api/features/admin/user_admin_routes.py
new file mode 100644
index 0000000000..bc276ec68d
--- /dev/null
+++ b/autogpt_platform/backend/backend/api/features/admin/user_admin_routes.py
@@ -0,0 +1,137 @@
+import logging
+import math
+
+from autogpt_libs.auth import get_user_id, requires_admin_user
+from fastapi import APIRouter, File, Query, Security, UploadFile
+
+from backend.data.invited_user import (
+ bulk_create_invited_users_from_file,
+ create_invited_user,
+ list_invited_users,
+ retry_invited_user_tally,
+ revoke_invited_user,
+)
+from backend.data.tally import mask_email
+from backend.util.models import Pagination
+
+from .model import (
+ BulkInvitedUsersResponse,
+ CreateInvitedUserRequest,
+ InvitedUserResponse,
+ InvitedUsersResponse,
+)
+
+logger = logging.getLogger(__name__)
+
+
+router = APIRouter(
+ prefix="/admin",
+ tags=["users", "admin"],
+ dependencies=[Security(requires_admin_user)],
+)
+
+
+ "/invited-users",
+ response_model=InvitedUsersResponse,
+ summary="List Invited Users",
+)
+async def get_invited_users(
+ admin_user_id: str = Security(get_user_id),
+ page: int = Query(1, ge=1),
+ page_size: int = Query(50, ge=1, le=200),
+) -> InvitedUsersResponse:
+ logger.info("Admin user %s requested invited users", admin_user_id)
+ invited_users, total = await list_invited_users(page=page, page_size=page_size)
+ return InvitedUsersResponse(
+ invited_users=[InvitedUserResponse.from_record(iu) for iu in invited_users],
+ pagination=Pagination(
+ total_items=total,
+ total_pages=max(1, math.ceil(total / page_size)),
+ current_page=page,
+ page_size=page_size,
+ ),
+ )
+
+
+ "/invited-users",
+ response_model=InvitedUserResponse,
+ summary="Create Invited User",
+)
+async def create_invited_user_route(
+ request: CreateInvitedUserRequest,
+ admin_user_id: str = Security(get_user_id),
+) -> InvitedUserResponse:
+ logger.info(
+ "Admin user %s creating invited user for %s",
+ admin_user_id,
+ mask_email(request.email),
+ )
+ invited_user = await create_invited_user(request.email, request.name)
+ logger.info(
+ "Admin user %s created invited user %s",
+ admin_user_id,
+ invited_user.id,
+ )
+ return InvitedUserResponse.from_record(invited_user)
+
+
+ "/invited-users/bulk",
+ response_model=BulkInvitedUsersResponse,
+ summary="Bulk Create Invited Users",
+ operation_id="postV2BulkCreateInvitedUsers",
+)
+async def bulk_create_invited_users_route(
+ file: UploadFile = File(...),
+ admin_user_id: str = Security(get_user_id),
+) -> BulkInvitedUsersResponse:
+ logger.info(
+ "Admin user %s bulk invited users from %s",
+ admin_user_id,
+ file.filename or "<unnamed>",
+ )
+ content = await file.read()
+ result = await bulk_create_invited_users_from_file(file.filename, content)
+ return BulkInvitedUsersResponse.from_result(result)
+
+
+ "/invited-users/{invited_user_id}/revoke",
+ response_model=InvitedUserResponse,
+ summary="Revoke Invited User",
+)
+async def revoke_invited_user_route(
+ invited_user_id: str,
+ admin_user_id: str = Security(get_user_id),
+) -> InvitedUserResponse:
+ logger.info(
+ "Admin user %s revoking invited user %s", admin_user_id, invited_user_id
+ )
+ invited_user = await revoke_invited_user(invited_user_id)
+ logger.info("Admin user %s revoked invited user %s", admin_user_id, invited_user_id)
+ return InvitedUserResponse.from_record(invited_user)
+
+
+ "/invited-users/{invited_user_id}/retry-tally",
+ response_model=InvitedUserResponse,
+ summary="Retry Invited User Tally",
+)
+async def retry_invited_user_tally_route(
+ invited_user_id: str,
+ admin_user_id: str = Security(get_user_id),
+) -> InvitedUserResponse:
+ logger.info(
+ "Admin user %s retrying Tally seed for invited user %s",
+ admin_user_id,
+ invited_user_id,
+ )
+ invited_user = await retry_invited_user_tally(invited_user_id)
+ logger.info(
+ "Admin user %s retried Tally seed for invited user %s",
+ admin_user_id,
+ invited_user_id,
+ )
+ return InvitedUserResponse.from_record(invited_user)
diff --git a/autogpt_platform/backend/backend/api/features/admin/user_admin_routes_test.py b/autogpt_platform/backend/backend/api/features/admin/user_admin_routes_test.py
new file mode 100644
index 0000000000..a0964aa0f0
--- /dev/null
+++ b/autogpt_platform/backend/backend/api/features/admin/user_admin_routes_test.py
@@ -0,0 +1,168 @@
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock
+
+import fastapi
+import fastapi.testclient
+import prisma.enums
+import pytest
+import pytest_mock
+from autogpt_libs.auth.jwt_utils import get_jwt_payload
+
+from backend.data.invited_user import (
+ BulkInvitedUserRowResult,
+ BulkInvitedUsersResult,
+ InvitedUserRecord,
+)
+
+from .user_admin_routes import router as user_admin_router
+
+app = fastapi.FastAPI()
+app.include_router(user_admin_router)
+
+client = fastapi.testclient.TestClient(app)
+
+
[email protected](autouse=True)
+def setup_app_admin_auth(mock_jwt_admin):
+ app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
+ yield
+ app.dependency_overrides.clear()
+
+
+def _sample_invited_user() -> InvitedUserRecord:
+ now = datetime.now(timezone.utc)
+ return InvitedUserRecord(
+ id="invite-1",
+ status=prisma.enums.InvitedUserStatus.INVITED,
+ auth_user_id=None,
+ name="Invited User",
+ tally_understanding=None,
+ tally_status=prisma.enums.TallyComputationStatus.PENDING,
+ tally_computed_at=None,
+ tally_error=None,
+ created_at=now,
+ updated_at=now,
+ )
+
+
+def _sample_bulk_invited_users_result() -> BulkInvitedUsersResult:
+ return BulkInvitedUsersResult(
+ created_count=1,
+ skipped_count=1,
+ error_count=0,
+ results=[
+ BulkInvitedUserRowResult(
+ row_number=1,
+ name=None,
+ status="CREATED",
+ message="Invite created",
+ invited_user=_sample_invited_user(),
+ ),
+ BulkInvitedUserRowResult(
+ row_number=2,
+ name=None,
+ status="SKIPPED",
+ message="An invited user with this email already exists",
+ invited_user=None,
+ ),
+ ],
+ )
+
+
+def test_get_invited_users(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ mocker.patch(
+ "backend.api.features.admin.user_admin_routes.list_invited_users",
+ AsyncMock(return_value=([_sample_invited_user()], 1)),
+ )
+
+ response = client.get("/admin/invited-users")
+
+ assert response.status_code == 200
+ data = response.json()
+ assert len(data["invited_users"]) == 1
+ assert data["invited_users"][0]["email"] == "[email protected]"
+ assert data["invited_users"][0]["status"] == "INVITED"
+ assert data["pagination"]["total_items"] == 1
+ assert data["pagination"]["current_page"] == 1
+ assert data["pagination"]["page_size"] == 50
+
+
+def test_create_invited_user(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ mocker.patch(
+ "backend.api.features.admin.user_admin_routes.create_invited_user",
+ AsyncMock(return_value=_sample_invited_user()),
+ )
+
+ response = client.post(
+ "/admin/invited-users",
+ json={"email": "[email protected]", "name": "Invited User"},
+ )
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["email"] == "[email protected]"
+ assert data["name"] == "Invited User"
+
+
+def test_bulk_create_invited_users(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ mocker.patch(
+ "backend.api.features.admin.user_admin_routes.bulk_create_invited_users_from_file",
+ AsyncMock(return_value=_sample_bulk_invited_users_result()),
+ )
+
+ response = client.post(
+ "/admin/invited-users/bulk",
+ files={
+ "file": ("invites.txt", b"[email protected]\[email protected]\n")
+ },
+ )
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["created_count"] == 1
+ assert data["skipped_count"] == 1
+ assert data["results"][0]["status"] == "CREATED"
+ assert data["results"][1]["status"] == "SKIPPED"
+
+
+def test_revoke_invited_user(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ revoked = _sample_invited_user().model_copy(
+ update={"status": prisma.enums.InvitedUserStatus.REVOKED}
+ )
+ mocker.patch(
+ "backend.api.features.admin.user_admin_routes.revoke_invited_user",
+ AsyncMock(return_value=revoked),
+ )
+
+ response = client.post("/admin/invited-users/invite-1/revoke")
+
+ assert response.status_code == 200
+ assert response.json()["status"] == "REVOKED"
+
+
+def test_retry_invited_user_tally(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ retried = _sample_invited_user().model_copy(
+ update={"tally_status": prisma.enums.TallyComputationStatus.RUNNING}
+ )
+ mocker.patch(
+ "backend.api.features.admin.user_admin_routes.retry_invited_user_tally",
+ AsyncMock(return_value=retried),
+ )
+
+ response = client.post("/admin/invited-users/invite-1/retry-tally")
+
+ assert response.status_code == 200
+ assert response.json()["tally_status"] == "RUNNING"
diff --git a/autogpt_platform/backend/backend/api/features/v1.py b/autogpt_platform/backend/backend/api/features/v1.py
index a7fc2fa69c..4d07d53c7f 100644
--- a/autogpt_platform/backend/backend/api/features/v1.py
+++ b/autogpt_platform/backend/backend/api/features/v1.py
@@ -55,6 +55,7 @@ from backend.data.credit import (
set_auto_top_up,
)
from backend.data.graph import GraphSettings
+from backend.data.invited_user import get_or_activate_user
from backend.data.model import CredentialsMetaInput, UserOnboarding
from backend.data.notifications import NotificationPreference, NotificationPreferenceDTO
from backend.data.onboarding import (
@@ -70,7 +71,6 @@ from backend.data.onboarding import (
update_user_onboarding,
)
from backend.data.user import (
- get_or_create_user,
get_user_by_id,
get_user_notification_preference,
update_user_email,
@@ -136,12 +136,10 @@ _tally_background_tasks: set[asyncio.Task] = set()
dependencies=[Security(requires_user)],
)
async def get_or_create_user_route(user_data: dict = Security(get_jwt_payload)):
- user = await get_or_create_user(user_data)
+ user = await get_or_activate_user(user_data)
- # Fire-and-forget: populate business understanding from Tally form.
- # We use created_at proximity instead of an is_new flag because
- # get_or_create_user is cached — a separate is_new return value would be
- # unreliable on repeated calls within the cache TTL.
+ # Fire-and-forget: backfill Tally understanding when invite pre-seeding did
+ # not produce a stored result before first activation.
age_seconds = (datetime.now(timezone.utc) - user.created_at).total_seconds()
if age_seconds < 30:
try:
@@ -165,7 +163,8 @@ async def get_or_create_user_route(user_data: dict = Security(get_jwt_payload)):
dependencies=[Security(requires_user)],
)
async def update_user_email_route(
- user_id: Annotated[str, Security(get_user_id)], email: str = Body(...)
+ user_id: Annotated[str, Security(get_user_id)],
+ email: str = Body(...),
) -> dict[str, str]:
await update_user_email(user_id, email)
@@ -179,10 +178,16 @@ async def update_user_email_route(
dependencies=[Security(requires_user)],
)
async def get_user_timezone_route(
- user_data: dict = Security(get_jwt_payload),
+ user_id: Annotated[str, Security(get_user_id)],
) -> TimezoneResponse:
"""Get user timezone setting."""
- user = await get_or_create_user(user_data)
+ try:
+ user = await get_user_by_id(user_id)
+ except ValueError:
+ raise HTTPException(
+ status_code=HTTP_404_NOT_FOUND,
+ detail="User not found. Please complete activation via /auth/user first.",
+ )
return TimezoneResponse(timezone=user.timezone)
@@ -193,7 +198,8 @@ async def get_user_timezone_route(
dependencies=[Security(requires_user)],
)
async def update_user_timezone_route(
- user_id: Annotated[str, Security(get_user_id)], request: UpdateTimezoneRequest
+ user_id: Annotated[str, Security(get_user_id)],
+ request: UpdateTimezoneRequest,
) -> TimezoneResponse:
"""Update user timezone. The timezone should be a valid IANA timezone identifier."""
user = await update_user_timezone(user_id, str(request.timezone))
diff --git a/autogpt_platform/backend/backend/api/features/v1_test.py b/autogpt_platform/backend/backend/api/features/v1_test.py
index 25f68d0a85..7fb2a6037e 100644
--- a/autogpt_platform/backend/backend/api/features/v1_test.py
+++ b/autogpt_platform/backend/backend/api/features/v1_test.py
@@ -51,7 +51,7 @@ def test_get_or_create_user_route(
}
mocker.patch(
- "backend.api.features.v1.get_or_create_user",
+ "backend.api.features.v1.get_or_activate_user",
return_value=mock_user,
)
diff --git a/autogpt_platform/backend/backend/api/rest_api.py b/autogpt_platform/backend/backend/api/rest_api.py
index d48620ee62..d0d59eb529 100644
--- a/autogpt_platform/backend/backend/api/rest_api.py
+++ b/autogpt_platform/backend/backend/api/rest_api.py
@@ -19,6 +19,7 @@ from prisma.errors import PrismaError
import backend.api.features.admin.credit_admin_routes
import backend.api.features.admin.execution_analytics_routes
import backend.api.features.admin.store_admin_routes
+import backend.api.features.admin.user_admin_routes
import backend.api.features.builder
import backend.api.features.builder.routes
import backend.api.features.chat.routes as chat_routes
@@ -311,6 +312,11 @@ app.include_router(
tags=["v2", "admin"],
prefix="/api/executions",
)
+app.include_router(
+ backend.api.features.admin.user_admin_routes.router,
+ tags=["v2", "admin"],
+ prefix="/api/users",
+)
app.include_router(
backend.api.features.executions.review.routes.router,
tags=["v2", "executions", "review"],
diff --git a/autogpt_platform/backend/backend/data/invited_user.py b/autogpt_platform/backend/backend/data/invited_user.py
new file mode 100644
index 0000000000..077b29bf69
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/invited_user.py
@@ -0,0 +1,750 @@
+import asyncio
+import csv
+import io
+import logging
+import os
+import re
+import socket
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Literal, Optional
+from uuid import uuid4
+
+import prisma.enums
+import prisma.models
+import prisma.types
+from prisma.errors import UniqueViolationError
+from pydantic import BaseModel, EmailStr, TypeAdapter, ValidationError
+
+from backend.data.db import transaction
+from backend.data.model import User
+from backend.data.redis_client import get_redis_async
+from backend.data.tally import get_business_understanding_input_from_tally, mask_email
+from backend.data.understanding import (
+ BusinessUnderstandingInput,
+ merge_business_understanding_data,
+)
+from backend.data.user import get_user_by_email, get_user_by_id
+from backend.executor.cluster_lock import AsyncClusterLock
+from backend.util.exceptions import (
+ NotAuthorizedError,
+ NotFoundError,
+ PreconditionFailed,
+)
+from backend.util.json import SafeJson
+from backend.util.settings import Settings
+
+logger = logging.getLogger(__name__)
+_settings = Settings()
+
+_WORKER_ID = f"{socket.gethostname()}:{os.getpid()}"
+
+_tally_seed_tasks: dict[str, asyncio.Task] = {}
+_TALLY_STALE_SECONDS = 300
+_MAX_TALLY_ERROR_LENGTH = 200
+_email_adapter = TypeAdapter(EmailStr)
+
+MAX_BULK_INVITE_FILE_BYTES = 1024 * 1024
+MAX_BULK_INVITE_ROWS = 500
+
+
+class InvitedUserRecord(BaseModel):
+ id: str
+ email: str
+ status: prisma.enums.InvitedUserStatus
+ auth_user_id: Optional[str] = None
+ name: Optional[str] = None
+ tally_understanding: Optional[dict[str, Any]] = None
+ tally_status: prisma.enums.TallyComputationStatus
+ tally_computed_at: Optional[datetime] = None
+ tally_error: Optional[str] = None
+ created_at: datetime
+ updated_at: datetime
+
+ @classmethod
+ def from_db(cls, invited_user: "prisma.models.InvitedUser") -> "InvitedUserRecord":
+ payload = (
+ invited_user.tallyUnderstanding
+ if isinstance(invited_user.tallyUnderstanding, dict)
+ else None
+ )
+ return cls(
+ id=invited_user.id,
+ email=invited_user.email,
+ status=invited_user.status,
+ auth_user_id=invited_user.authUserId,
+ name=invited_user.name,
+ tally_understanding=payload,
+ tally_status=invited_user.tallyStatus,
+ tally_computed_at=invited_user.tallyComputedAt,
+ tally_error=invited_user.tallyError,
+ created_at=invited_user.createdAt,
+ updated_at=invited_user.updatedAt,
+ )
+
+
+class BulkInvitedUserRowResult(BaseModel):
+ row_number: int
+ email: Optional[str] = None
+ name: Optional[str] = None
+ status: Literal["CREATED", "SKIPPED", "ERROR"]
+ message: str
+ invited_user: Optional[InvitedUserRecord] = None
+
+
+class BulkInvitedUsersResult(BaseModel):
+ created_count: int
+ skipped_count: int
+ error_count: int
+ results: list[BulkInvitedUserRowResult]
+
+
+@dataclass(frozen=True)
+class _ParsedInviteRow:
+ row_number: int
+ email: str
+ name: Optional[str]
+
+
+def normalize_email(email: str) -> str:
+ return email.strip().lower()
+
+
+def _normalize_name(name: Optional[str]) -> Optional[str]:
+ if name is None:
+ return None
+ normalized = name.strip()
+ return normalized or None
+
+
+def _default_profile_name(email: str, preferred_name: Optional[str]) -> str:
+ if preferred_name:
+ return preferred_name
+ local_part = email.split("@", 1)[0].strip()
+ return local_part or "user"
+
+
+def _sanitize_username_base(email: str) -> str:
+ local_part = email.split("@", 1)[0].lower()
+ sanitized = re.sub(r"[^a-z0-9-]", "", local_part)
+ sanitized = sanitized.strip("-")
+ return sanitized[:40] or "user"
+
+
+async def _generate_unique_profile_username(email: str, tx) -> str:
+ base = _sanitize_username_base(email)
+
+ for _ in range(2):
+ candidate = f"{base}-{uuid4().hex[:6]}"
+ existing = await prisma.models.Profile.prisma(tx).find_unique(
+ where={"username": candidate}
+ )
+ if existing is None:
+ return candidate
+
+ raise RuntimeError(f"Unable to generate unique username for {email}")
+
+
+async def _ensure_default_profile(
+ user_id: str,
+ email: str,
+ preferred_name: Optional[str],
+ tx,
+) -> None:
+ existing_profile = await prisma.models.Profile.prisma(tx).find_unique(
+ where={"userId": user_id}
+ )
+ if existing_profile is not None:
+ return
+
+ username = await _generate_unique_profile_username(email, tx)
+ await prisma.models.Profile.prisma(tx).create(
+ data=prisma.types.ProfileCreateInput(
+ userId=user_id,
+ name=_default_profile_name(email, preferred_name),
+ username=username,
+ description="I'm new here",
+ links=[],
+ avatarUrl="",
+ )
+ )
+
+
+async def _ensure_default_onboarding(user_id: str, tx) -> None:
+ await prisma.models.UserOnboarding.prisma(tx).upsert(
+ where={"userId": user_id},
+ data={
+ "create": prisma.types.UserOnboardingCreateInput(userId=user_id),
+ "update": {},
+ },
+ )
+
+
+async def _apply_tally_understanding(
+ user_id: str,
+ invited_user: "prisma.models.InvitedUser",
+ tx,
+) -> None:
+ if not isinstance(invited_user.tallyUnderstanding, dict):
+ return
+
+ try:
+ input_data = BusinessUnderstandingInput.model_validate(
+ invited_user.tallyUnderstanding
+ )
+ except Exception:
+ logger.warning(
+ "Malformed tallyUnderstanding for invited user %s; skipping",
+ invited_user.id,
+ exc_info=True,
+ )
+ return
+
+ payload = merge_business_understanding_data({}, input_data)
+ await prisma.models.CoPilotUnderstanding.prisma(tx).upsert(
+ where={"userId": user_id},
+ data={
+ "create": {"userId": user_id, "data": SafeJson(payload)},
+ "update": {"data": SafeJson(payload)},
+ },
+ )
+
+
+async def list_invited_users(
+ page: int = 1,
+ page_size: int = 50,
+) -> tuple[list[InvitedUserRecord], int]:
+ total = await prisma.models.InvitedUser.prisma().count()
+ invited_users = await prisma.models.InvitedUser.prisma().find_many(
+ order={"createdAt": "desc"},
+ skip=(page - 1) * page_size,
+ take=page_size,
+ )
+ return [InvitedUserRecord.from_db(iu) for iu in invited_users], total
+
+
+async def create_invited_user(
+ email: str, name: Optional[str] = None
+) -> InvitedUserRecord:
+ normalized_email = normalize_email(email)
+ normalized_name = _normalize_name(name)
+
+ existing_user = await prisma.models.User.prisma().find_unique(
+ where={"email": normalized_email}
+ )
+ if existing_user is not None:
+ raise PreconditionFailed("An active user with this email already exists")
+
+ existing_invited_user = await prisma.models.InvitedUser.prisma().find_unique(
+ where={"email": normalized_email}
+ )
+ if existing_invited_user is not None:
+ raise PreconditionFailed("An invited user with this email already exists")
+
+ try:
+ invited_user = await prisma.models.InvitedUser.prisma().create(
+ data={
+ "email": normalized_email,
+ "name": normalized_name,
+ "status": prisma.enums.InvitedUserStatus.INVITED,
+ "tallyStatus": prisma.enums.TallyComputationStatus.PENDING,
+ }
+ )
+ except UniqueViolationError:
+ raise PreconditionFailed("An invited user with this email already exists")
+ schedule_invited_user_tally_precompute(invited_user.id)
+ return InvitedUserRecord.from_db(invited_user)
+
+
+async def revoke_invited_user(invited_user_id: str) -> InvitedUserRecord:
+ invited_user = await prisma.models.InvitedUser.prisma().find_unique(
+ where={"id": invited_user_id}
+ )
+ if invited_user is None:
+ raise NotFoundError(f"Invited user {invited_user_id} not found")
+
+ if invited_user.status == prisma.enums.InvitedUserStatus.CLAIMED:
+ raise PreconditionFailed("Claimed invited users cannot be revoked")
+
+ if invited_user.status == prisma.enums.InvitedUserStatus.REVOKED:
+ return InvitedUserRecord.from_db(invited_user)
+
+ revoked_user = await prisma.models.InvitedUser.prisma().update(
+ where={"id": invited_user_id},
+ data={"status": prisma.enums.InvitedUserStatus.REVOKED},
+ )
+ if revoked_user is None:
+ raise NotFoundError(f"Invited user {invited_user_id} not found")
+ return InvitedUserRecord.from_db(revoked_user)
+
+
+async def retry_invited_user_tally(invited_user_id: str) -> InvitedUserRecord:
+ invited_user = await prisma.models.InvitedUser.prisma().find_unique(
+ where={"id": invited_user_id}
+ )
+ if invited_user is None:
+ raise NotFoundError(f"Invited user {invited_user_id} not found")
+
+ if invited_user.status == prisma.enums.InvitedUserStatus.REVOKED:
+ raise PreconditionFailed("Revoked invited users cannot retry Tally seeding")
+
+ refreshed_user = await prisma.models.InvitedUser.prisma().update(
+ where={"id": invited_user_id},
+ data={
+ "tallyUnderstanding": None,
+ "tallyStatus": prisma.enums.TallyComputationStatus.PENDING,
+ "tallyComputedAt": None,
+ "tallyError": None,
+ },
+ )
+ if refreshed_user is None:
+ raise NotFoundError(f"Invited user {invited_user_id} not found")
+ schedule_invited_user_tally_precompute(invited_user_id)
+ return InvitedUserRecord.from_db(refreshed_user)
+
+
+def _decode_bulk_invite_file(content: bytes) -> str:
+ if len(content) > MAX_BULK_INVITE_FILE_BYTES:
+ raise ValueError("Invite file exceeds the maximum size of 1 MB")
+
+ try:
+ return content.decode("utf-8-sig")
+ except UnicodeDecodeError as exc:
+ raise ValueError("Invite file must be UTF-8 encoded") from exc
+
+
+def _parse_bulk_invite_csv(text: str) -> list[_ParsedInviteRow]:
+ indexed_rows: list[tuple[int, list[str]]] = []
+
+ for row_number, row in enumerate(csv.reader(io.StringIO(text)), start=1):
+ normalized_row = [cell.strip() for cell in row]
+ if any(normalized_row):
+ indexed_rows.append((row_number, normalized_row))
+
+ if not indexed_rows:
+ return []
+
+ header = [cell.lower() for cell in indexed_rows[0][1]]
+ has_header = "email" in header
+ email_index = header.index("email") if has_header else 0
+ name_index: Optional[int] = (
+ header.index("name")
+ if has_header and "name" in header
+ else (1 if not has_header else None)
+ )
+ data_rows = indexed_rows[1:] if has_header else indexed_rows
+
+ parsed_rows: list[_ParsedInviteRow] = []
+ for row_number, row in data_rows:
+ if len(parsed_rows) >= MAX_BULK_INVITE_ROWS:
+ break
+ email = row[email_index].strip() if len(row) > email_index else ""
+ name = (
+ row[name_index].strip()
+ if name_index is not None and len(row) > name_index
+ else ""
+ )
+ parsed_rows.append(
+ _ParsedInviteRow(
+ row_number=row_number,
+ email=email,
+ name=name or None,
+ )
+ )
+
+ return parsed_rows
+
+
+def _parse_bulk_invite_text(text: str) -> list[_ParsedInviteRow]:
+ parsed_rows: list[_ParsedInviteRow] = []
+
+ for row_number, raw_line in enumerate(text.splitlines(), start=1):
+ if len(parsed_rows) >= MAX_BULK_INVITE_ROWS:
+ break
+ line = raw_line.strip()
+ if not line or line.startswith("#"):
+ continue
+
+ parsed_rows.append(
+ _ParsedInviteRow(
+ row_number=row_number,
+ email=line,
+ name=None,
+ )
+ )
+
+ return parsed_rows
+
+
+def _parse_bulk_invite_file(
+ filename: Optional[str],
+ content: bytes,
+) -> list[_ParsedInviteRow]:
+ text = _decode_bulk_invite_file(content)
+ file_name = filename.lower() if filename else ""
+ parsed_rows = (
+ _parse_bulk_invite_csv(text)
+ if file_name.endswith(".csv")
+ else _parse_bulk_invite_text(text)
+ )
+
+ if not parsed_rows:
+ raise ValueError("Invite file did not contain any emails")
+
+ return parsed_rows
+
+
+async def bulk_create_invited_users_from_file(
+ filename: Optional[str],
+ content: bytes,
+) -> BulkInvitedUsersResult:
+ parsed_rows = _parse_bulk_invite_file(filename, content)
+
+ created_count = 0
+ skipped_count = 0
+ error_count = 0
+ results: list[BulkInvitedUserRowResult] = []
+ seen_emails: set[str] = set()
+
+ for row in parsed_rows:
+ row_name = _normalize_name(row.name)
+
+ try:
+ validated_email = _email_adapter.validate_python(row.email)
+ except ValidationError:
+ error_count += 1
+ results.append(
+ BulkInvitedUserRowResult(
+ row_number=row.row_number,
+ email=row.email or None,
+ name=row_name,
+ status="ERROR",
+ message="Invalid email address",
+ )
+ )
+ continue
+
+ normalized_email = normalize_email(str(validated_email))
+ if normalized_email in seen_emails:
+ skipped_count += 1
+ results.append(
+ BulkInvitedUserRowResult(
+ row_number=row.row_number,
+ email=normalized_email,
+ name=row_name,
+ status="SKIPPED",
+ message="Duplicate email in upload file",
+ )
+ )
+ continue
+
+ seen_emails.add(normalized_email)
+
+ try:
+ invited_user = await create_invited_user(normalized_email, row_name)
+ except PreconditionFailed as exc:
+ skipped_count += 1
+ results.append(
+ BulkInvitedUserRowResult(
+ row_number=row.row_number,
+ email=normalized_email,
+ name=row_name,
+ status="SKIPPED",
+ message=str(exc),
+ )
+ )
+ except Exception:
+ masked = mask_email(normalized_email)
+ logger.exception(
+ "Failed to create bulk invite for row %s (%s)",
+ row.row_number,
+ masked,
+ )
+ error_count += 1
+ results.append(
+ BulkInvitedUserRowResult(
+ row_number=row.row_number,
+ email=normalized_email,
+ name=row_name,
+ status="ERROR",
+ message="Unexpected error creating invite",
+ )
+ )
+ else:
+ created_count += 1
+ results.append(
+ BulkInvitedUserRowResult(
+ row_number=row.row_number,
+ email=normalized_email,
+ name=row_name,
+ status="CREATED",
+ message="Invite created",
+ invited_user=invited_user,
+ )
+ )
+
+ return BulkInvitedUsersResult(
+ created_count=created_count,
+ skipped_count=skipped_count,
+ error_count=error_count,
+ results=results,
+ )
+
+
+async def _compute_invited_user_tally_seed(invited_user_id: str) -> None:
+ invited_user = await prisma.models.InvitedUser.prisma().find_unique(
+ where={"id": invited_user_id}
+ )
+ if invited_user is None:
+ return
+
+ if invited_user.status == prisma.enums.InvitedUserStatus.REVOKED:
+ return
+
+ try:
+ r = await get_redis_async()
+ except Exception:
+ r = None
+
+ lock: AsyncClusterLock | None = None
+
+ if r is not None:
+ lock = AsyncClusterLock(
+ redis=r,
+ key=f"tally_seed:{invited_user_id}",
+ owner_id=_WORKER_ID,
+ timeout=_TALLY_STALE_SECONDS,
+ )
+ current_owner = await lock.try_acquire()
+
+ if current_owner is None:
+ logger.warn("Redis unvailable for tally lock - skipping tally enrichement")
+ return
+ elif current_owner != _WORKER_ID:
+ logger.debug(
+ "Tally seed for %s already locked by %s, skipping",
+ invited_user_id,
+ current_owner,
+ )
+ return
+ if (
+ invited_user.tallyStatus == prisma.enums.TallyComputationStatus.RUNNING
+ and invited_user.updatedAt is not None
+ ):
+ age = (datetime.now(timezone.utc) - invited_user.updatedAt).total_seconds()
+ if age < _TALLY_STALE_SECONDS:
+ logger.debug(
+ "Tally task for %s still RUNNING (age=%ds), skipping",
+ invited_user_id,
+ int(age),
+ )
+ return
+ logger.info(
+ "Tally task for %s is stale (age=%ds), re-running",
+ invited_user_id,
+ int(age),
+ )
+
+ await prisma.models.InvitedUser.prisma().update(
+ where={"id": invited_user_id},
+ data={
+ "tallyStatus": prisma.enums.TallyComputationStatus.RUNNING,
+ "tallyError": None,
+ },
+ )
+
+ try:
+ input_data = await get_business_understanding_input_from_tally(
+ invited_user.email,
+ require_api_key=True,
+ )
+ payload = (
+ SafeJson(input_data.model_dump(exclude_none=True))
+ if input_data is not None
+ else None
+ )
+ await prisma.models.InvitedUser.prisma().update(
+ where={"id": invited_user_id},
+ data={
+ "tallyUnderstanding": payload,
+ "tallyStatus": prisma.enums.TallyComputationStatus.READY,
+ "tallyComputedAt": datetime.now(timezone.utc),
+ "tallyError": None,
+ },
+ )
+ except Exception as exc:
+ logger.exception(
+ "Failed to compute Tally understanding for invited user %s",
+ invited_user_id,
+ )
+ sanitized_error = re.sub(
+ r"https?://\S+", "<url>", f"{type(exc).__name__}: {exc}"
+ )[:_MAX_TALLY_ERROR_LENGTH]
+ await prisma.models.InvitedUser.prisma().update(
+ where={"id": invited_user_id},
+ data={
+ "tallyStatus": prisma.enums.TallyComputationStatus.FAILED,
+ "tallyError": sanitized_error,
+ },
+ )
+
+
+def schedule_invited_user_tally_precompute(invited_user_id: str) -> None:
+ existing = _tally_seed_tasks.get(invited_user_id)
+ if existing is not None and not existing.done():
+ logger.debug("Tally task already running for %s, skipping", invited_user_id)
+ return
+
+ task = asyncio.create_task(_compute_invited_user_tally_seed(invited_user_id))
+ _tally_seed_tasks[invited_user_id] = task
+
+ def _on_done(t: asyncio.Task, _id: str = invited_user_id) -> None:
+ if _tally_seed_tasks.get(_id) is t:
+ del _tally_seed_tasks[_id]
+
+ task.add_done_callback(_on_done)
+
+
+async def _open_signup_create_user(
+ auth_user_id: str,
+ normalized_email: str,
+ metadata_name: Optional[str],
+) -> User:
+ """Create a user without requiring an invite (open signup mode)."""
+ preferred_name = _normalize_name(metadata_name)
+ try:
+ async with transaction() as tx:
+ user = await prisma.models.User.prisma(tx).create(
+ data=prisma.types.UserCreateInput(
+ id=auth_user_id,
+ email=normalized_email,
+ name=preferred_name,
+ )
+ )
+ await _ensure_default_profile(
+ auth_user_id, normalized_email, preferred_name, tx
+ )
+ await _ensure_default_onboarding(auth_user_id, tx)
+ except UniqueViolationError:
+ existing = await prisma.models.User.prisma().find_unique(
+ where={"id": auth_user_id}
+ )
+ if existing is not None:
+ return User.from_db(existing)
+ raise
+
+ return User.from_db(user)
+
+
+# TODO: We need to change this functions logic before going live
+async def get_or_activate_user(user_data: dict) -> User:
+ auth_user_id = user_data.get("sub")
+ if not auth_user_id:
+ raise NotAuthorizedError("User ID not found in token")
+
+ auth_email = user_data.get("email")
+ if not auth_email:
+ raise NotAuthorizedError("Email not found in token")
+
+ normalized_email = normalize_email(auth_email)
+ user_metadata = user_data.get("user_metadata")
+ metadata_name = (
+ user_metadata.get("name") if isinstance(user_metadata, dict) else None
+ )
+
+ existing_user = None
+ try:
+ existing_user = await get_user_by_id(auth_user_id)
+ except ValueError:
+ existing_user = None
+ except Exception:
+ logger.exception("Error on get user by id during tally enrichment process")
+ raise
+
+ if existing_user is not None:
+ return existing_user
+
+ if not _settings.config.enable_invite_gate or normalized_email.endswith("@agpt.co"):
+ return await _open_signup_create_user(
+ auth_user_id, normalized_email, metadata_name
+ )
+
+ invited_user = await prisma.models.InvitedUser.prisma().find_unique(
+ where={"email": normalized_email}
+ )
+ if invited_user is None:
+ raise NotAuthorizedError("Your email is not allowed to access the platform")
+
+ if invited_user.status != prisma.enums.InvitedUserStatus.INVITED:
+ raise NotAuthorizedError("Your invitation is no longer active")
+
+ try:
+ async with transaction() as tx:
+ current_user = await prisma.models.User.prisma(tx).find_unique(
+ where={"id": auth_user_id}
+ )
+ if current_user is not None:
+ return User.from_db(current_user)
+
+ current_invited_user = await prisma.models.InvitedUser.prisma(
+ tx
+ ).find_unique(where={"email": normalized_email})
+ if current_invited_user is None:
+ raise NotAuthorizedError(
+ "Your email is not allowed to access the platform"
+ )
+
+ if current_invited_user.status != prisma.enums.InvitedUserStatus.INVITED:
+ raise NotAuthorizedError("Your invitation is no longer active")
+
+ if current_invited_user.authUserId not in (None, auth_user_id):
+ raise NotAuthorizedError("Your invitation has already been claimed")
+
+ preferred_name = current_invited_user.name or _normalize_name(metadata_name)
+ await prisma.models.User.prisma(tx).create(
+ data=prisma.types.UserCreateInput(
+ id=auth_user_id,
+ email=normalized_email,
+ name=preferred_name,
+ )
+ )
+
+ await prisma.models.InvitedUser.prisma(tx).update(
+ where={"id": current_invited_user.id},
+ data={
+ "status": prisma.enums.InvitedUserStatus.CLAIMED,
+ "authUserId": auth_user_id,
+ },
+ )
+
+ await _ensure_default_profile(
+ auth_user_id,
+ normalized_email,
+ preferred_name,
+ tx,
+ )
+ await _ensure_default_onboarding(auth_user_id, tx)
+ await _apply_tally_understanding(auth_user_id, current_invited_user, tx)
+ except UniqueViolationError:
+ logger.info("Concurrent activation for user %s; re-fetching", auth_user_id)
+ already_created = await prisma.models.User.prisma().find_unique(
+ where={"id": auth_user_id}
+ )
+ if already_created is not None:
+ return User.from_db(already_created)
+ raise RuntimeError(
+ f"UniqueViolationError during activation but user {auth_user_id} not found"
+ )
+
+ get_user_by_id.cache_delete(auth_user_id)
+ get_user_by_email.cache_delete(normalized_email)
+
+ activated_user = await prisma.models.User.prisma().find_unique(
+ where={"id": auth_user_id}
+ )
+ if activated_user is None:
+ raise RuntimeError(
+ f"Activated user {auth_user_id} was not found after creation"
+ )
+
+ return User.from_db(activated_user)
diff --git a/autogpt_platform/backend/backend/data/invited_user_test.py b/autogpt_platform/backend/backend/data/invited_user_test.py
new file mode 100644
index 0000000000..48e2d822b8
--- /dev/null
+++ b/autogpt_platform/backend/backend/data/invited_user_test.py
@@ -0,0 +1,335 @@
+from contextlib import asynccontextmanager
+from datetime import datetime, timezone
+from types import SimpleNamespace
+from typing import cast
+from unittest.mock import AsyncMock, Mock
+
+import prisma.enums
+import prisma.models
+import pytest
+import pytest_mock
+
+from backend.util.exceptions import NotAuthorizedError, PreconditionFailed
+
+from .invited_user import (
+ InvitedUserRecord,
+ bulk_create_invited_users_from_file,
+ create_invited_user,
+ get_or_activate_user,
+ retry_invited_user_tally,
+)
+
+
+def _invited_user_db_record(
+ *,
+ status: prisma.enums.InvitedUserStatus = prisma.enums.InvitedUserStatus.INVITED,
+ tally_understanding: dict | None = None,
+):
+ now = datetime.now(timezone.utc)
+ return SimpleNamespace(
+ id="invite-1",
+ status=status,
+ authUserId=None,
+ name="Invited User",
+ tallyUnderstanding=tally_understanding,
+ tallyStatus=prisma.enums.TallyComputationStatus.PENDING,
+ tallyComputedAt=None,
+ tallyError=None,
+ createdAt=now,
+ updatedAt=now,
+ )
+
+
+def _invited_user_record(
+ *,
+ status: prisma.enums.InvitedUserStatus = prisma.enums.InvitedUserStatus.INVITED,
+ tally_understanding: dict | None = None,
+):
+ return InvitedUserRecord.from_db(
+ cast(
+ prisma.models.InvitedUser,
+ _invited_user_db_record(
+ status=status,
+ tally_understanding=tally_understanding,
+ ),
+ )
+ )
+
+
+def _user_db_record():
+ now = datetime.now(timezone.utc)
+ return SimpleNamespace(
+ id="auth-user-1",
+ emailVerified=True,
+ name="Invited User",
+ createdAt=now,
+ updatedAt=now,
+ metadata={},
+ integrations="",
+ stripeCustomerId=None,
+ topUpConfig=None,
+ maxEmailsPerDay=3,
+ notifyOnAgentRun=True,
+ notifyOnZeroBalance=True,
+ notifyOnLowBalance=True,
+ notifyOnBlockExecutionFailed=True,
+ notifyOnContinuousAgentError=True,
+ notifyOnDailySummary=True,
+ notifyOnWeeklySummary=True,
+ notifyOnMonthlySummary=True,
+ notifyOnAgentApproved=True,
+ notifyOnAgentRejected=True,
+ timezone="not-set",
+ )
+
+
+async def test_create_invited_user_rejects_existing_active_user(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ user_repo = Mock()
+ user_repo.find_unique = AsyncMock(return_value=_user_db_record())
+ invited_user_repo = Mock()
+ invited_user_repo.find_unique = AsyncMock()
+
+ mocker.patch(
+ "backend.data.invited_user.prisma.models.User.prisma", return_value=user_repo
+ )
+ mocker.patch(
+ "backend.data.invited_user.prisma.models.InvitedUser.prisma",
+ return_value=invited_user_repo,
+ )
+
+ with pytest.raises(PreconditionFailed):
+ await create_invited_user("[email protected]")
+
+
+async def test_create_invited_user_schedules_tally_seed(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ user_repo = Mock()
+ user_repo.find_unique = AsyncMock(return_value=None)
+ invited_user_repo = Mock()
+ invited_user_repo.find_unique = AsyncMock(return_value=None)
+ invited_user_repo.create = AsyncMock(return_value=_invited_user_db_record())
+ schedule = mocker.patch(
+ "backend.data.invited_user.schedule_invited_user_tally_precompute"
+ )
+
+ mocker.patch(
+ "backend.data.invited_user.prisma.models.User.prisma", return_value=user_repo
+ )
+ mocker.patch(
+ "backend.data.invited_user.prisma.models.InvitedUser.prisma",
+ return_value=invited_user_repo,
+ )
+
+ invited_user = await create_invited_user("[email protected]", "Invited User")
+
+ assert invited_user.email == "[email protected]"
+ invited_user_repo.create.assert_awaited_once()
+ schedule.assert_called_once_with("invite-1")
+
+
+async def test_retry_invited_user_tally_resets_state_and_schedules(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ invited_user_repo = Mock()
+ invited_user_repo.find_unique = AsyncMock(return_value=_invited_user_db_record())
+ invited_user_repo.update = AsyncMock(return_value=_invited_user_db_record())
+ schedule = mocker.patch(
+ "backend.data.invited_user.schedule_invited_user_tally_precompute"
+ )
+
+ mocker.patch(
+ "backend.data.invited_user.prisma.models.InvitedUser.prisma",
+ return_value=invited_user_repo,
+ )
+
+ invited_user = await retry_invited_user_tally("invite-1")
+
+ assert invited_user.id == "invite-1"
+ invited_user_repo.update.assert_awaited_once()
+ schedule.assert_called_once_with("invite-1")
+
+
+async def test_get_or_activate_user_requires_invite(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ invited_user_repo = Mock()
+ invited_user_repo.find_unique = AsyncMock(return_value=None)
+
+ mock_get_user_by_id = AsyncMock(side_effect=ValueError("User not found"))
+ mock_get_user_by_id.cache_delete = Mock()
+ mocker.patch(
+ "backend.data.invited_user.get_user_by_id",
+ mock_get_user_by_id,
+ )
+ mocker.patch(
+ "backend.data.invited_user._settings.config.enable_invite_gate",
+ True,
+ )
+ mocker.patch(
+ "backend.data.invited_user.prisma.models.InvitedUser.prisma",
+ return_value=invited_user_repo,
+ )
+
+ with pytest.raises(NotAuthorizedError):
+ await get_or_activate_user(
+ {"sub": "auth-user-1", "email": "[email protected]"}
+ )
+
+
+async def test_get_or_activate_user_creates_user_from_invite(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ tx = object()
+ invited_user = _invited_user_db_record(
+ tally_understanding={"user_name": "Invited User", "industry": "Automation"}
+ )
+ created_user = _user_db_record()
+
+ outside_user_repo = Mock()
+ # Only called once at post-transaction verification (line 741);
+ # get_user_by_id (line 657) uses prisma.user.find_unique, not this mock.
+ outside_user_repo.find_unique = AsyncMock(return_value=created_user)
+
+ inside_user_repo = Mock()
+ inside_user_repo.find_unique = AsyncMock(return_value=None)
+ inside_user_repo.create = AsyncMock(return_value=created_user)
+
+ outside_invited_repo = Mock()
+ outside_invited_repo.find_unique = AsyncMock(return_value=invited_user)
+
+ inside_invited_repo = Mock()
+ inside_invited_repo.find_unique = AsyncMock(return_value=invited_user)
+ inside_invited_repo.update = AsyncMock(return_value=invited_user)
+
+ def user_prisma(client=None):
+ return inside_user_repo if client is tx else outside_user_repo
+
+ def invited_user_prisma(client=None):
+ return inside_invited_repo if client is tx else outside_invited_repo
+
+ @asynccontextmanager
+ async def fake_transaction():
+ yield tx
+
+ # Mock get_user_by_id since it uses prisma.user.find_unique (global client),
+ # not prisma.models.User.prisma().find_unique which we mock above.
+ mock_get_user_by_id = AsyncMock(side_effect=ValueError("User not found"))
+ mock_get_user_by_id.cache_delete = Mock()
+ mocker.patch(
+ "backend.data.invited_user.get_user_by_id",
+ mock_get_user_by_id,
+ )
+ mock_get_user_by_email = AsyncMock()
+ mock_get_user_by_email.cache_delete = Mock()
+ mocker.patch(
+ "backend.data.invited_user.get_user_by_email",
+ mock_get_user_by_email,
+ )
+ ensure_profile = mocker.patch(
+ "backend.data.invited_user._ensure_default_profile",
+ AsyncMock(),
+ )
+ ensure_onboarding = mocker.patch(
+ "backend.data.invited_user._ensure_default_onboarding",
+ AsyncMock(),
+ )
+ apply_tally = mocker.patch(
+ "backend.data.invited_user._apply_tally_understanding",
+ AsyncMock(),
+ )
+ mocker.patch("backend.data.invited_user.transaction", fake_transaction)
+ mocker.patch(
+ "backend.data.invited_user.prisma.models.User.prisma", side_effect=user_prisma
+ )
+ mocker.patch(
+ "backend.data.invited_user.prisma.models.InvitedUser.prisma",
+ side_effect=invited_user_prisma,
+ )
+
+ user = await get_or_activate_user(
+ {
+ "sub": "auth-user-1",
+ "email": "[email protected]",
+ "user_metadata": {"name": "Invited User"},
+ }
+ )
+
+ assert user.id == "auth-user-1"
+ inside_user_repo.create.assert_awaited_once()
+ inside_invited_repo.update.assert_awaited_once()
+ ensure_profile.assert_awaited_once()
+ ensure_onboarding.assert_awaited_once_with("auth-user-1", tx)
+ apply_tally.assert_awaited_once_with("auth-user-1", invited_user, tx)
+
+
+async def test_bulk_create_invited_users_from_text_file(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ create_invited = mocker.patch(
+ "backend.data.invited_user.create_invited_user",
+ AsyncMock(
+ side_effect=[
+ _invited_user_record(),
+ _invited_user_record(),
+ ]
+ ),
+ )
+
+ result = await bulk_create_invited_users_from_file(
+ "invites.txt",
+ )
+
+ assert result.created_count == 2
+ assert result.skipped_count == 0
+ assert result.error_count == 0
+ assert [row.status for row in result.results] == ["CREATED", "CREATED"]
+ assert create_invited.await_count == 2
+
+
+async def test_bulk_create_invited_users_handles_csv_duplicates_and_invalid_rows(
+ mocker: pytest_mock.MockerFixture,
+) -> None:
+ create_invited = mocker.patch(
+ "backend.data.invited_user.create_invited_user",
+ AsyncMock(
+ side_effect=[
+ _invited_user_record(),
+ PreconditionFailed("An invited user with this email already exists"),
+ ]
+ ),
+ )
+
+ result = await bulk_create_invited_users_from_file(
+ "invites.csv",
+ (
+ "email,name\n"
+ "[email protected],Valid User\n"
+ "not-an-email,Bad Row\n"
+ "[email protected],Duplicate In File\n"
+ "[email protected],Existing User\n"
+ ).encode("utf-8"),
+ )
+
+ assert result.created_count == 1
+ assert result.skipped_count == 2
+ assert result.error_count == 1
+ assert [row.status for row in result.results] == [
+ "CREATED",
+ "ERROR",
+ "SKIPPED",
+ "SKIPPED",
+ ]
+ assert create_invited.await_count == 2
diff --git a/autogpt_platform/backend/backend/data/tally.py b/autogpt_platform/backend/backend/data/tally.py
index 03c5d0d138..814f886cf5 100644
--- a/autogpt_platform/backend/backend/data/tally.py
+++ b/autogpt_platform/backend/backend/data/tally.py
@@ -41,7 +41,7 @@ _MAX_PAGES = 100
_LLM_TIMEOUT = 30
-def _mask_email(email: str) -> str:
+def mask_email(email: str) -> str:
"""Mask an email for safe logging: '[email protected]' -> 'a***[email protected]'."""
try:
local, domain = email.rsplit("@", 1)
@@ -196,8 +196,7 @@ async def _refresh_cache(form_id: str) -> tuple[dict, list]:
Returns (email_index, questions).
"""
- settings = Settings()
- client = _make_tally_client(settings.secrets.tally_api_key)
+ client = _make_tally_client(_settings.secrets.tally_api_key)
redis = await get_redis_async()
last_fetch_key = _LAST_FETCH_KEY.format(form_id=form_id)
@@ -346,8 +345,7 @@ async def extract_business_understanding(
Raises on timeout or unparseable response so the caller can handle it.
"""
- settings = Settings()
- api_key = settings.secrets.open_router_api_key
+ api_key = _settings.secrets.open_router_api_key
client = AsyncOpenAI(api_key=api_key, base_url=OPENROUTER_BASE_URL)
try:
@@ -381,6 +379,34 @@ async def extract_business_understanding(
return BusinessUnderstandingInput(**cleaned)
+async def get_business_understanding_input_from_tally(
+ email: str,
+ *,
+ require_api_key: bool = False,
+) -> Optional[BusinessUnderstandingInput]:
+ if not _settings.secrets.tally_api_key:
+ if require_api_key:
+ raise RuntimeError("Tally API key is not configured")
+ logger.debug("Tally: no API key configured, skipping")
+ return None
+
+ masked = mask_email(email)
+ result = await find_submission_by_email(TALLY_FORM_ID, email)
+ if result is None:
+ logger.debug(f"Tally: no submission found for {masked}")
+ return None
+
+ submission, questions = result
+ logger.info(f"Tally: found submission for {masked}, extracting understanding")
+
+ formatted = format_submission_for_llm(submission, questions)
+ if not formatted.strip():
+ logger.warning("Tally: formatted submission was empty, skipping")
+ return None
+
+ return await extract_business_understanding(formatted)
+
+
async def populate_understanding_from_tally(user_id: str, email: str) -> None:
"""Main orchestrator: check Tally for a matching submission and populate understanding.
@@ -395,30 +421,10 @@ async def populate_understanding_from_tally(user_id: str, email: str) -> None:
)
return
- # Check API key is configured
- settings = Settings()
- if not settings.secrets.tally_api_key:
- logger.debug("Tally: no API key configured, skipping")
- return
-
- # Look up submission by email
- masked = _mask_email(email)
- result = await find_submission_by_email(TALLY_FORM_ID, email)
- if result is None:
- logger.debug(f"Tally: no submission found for {masked}")
+ understanding_input = await get_business_understanding_input_from_tally(email)
+ if understanding_input is None:
return
- submission, questions = result
- logger.info(f"Tally: found submission for {masked}, extracting understanding")
-
- # Format and extract
- formatted = format_submission_for_llm(submission, questions)
- if not formatted.strip():
- logger.warning("Tally: formatted submission was empty, skipping")
- return
-
- understanding_input = await extract_business_understanding(formatted)
-
# Upsert into database
await upsert_business_understanding(user_id, understanding_input)
logger.info(f"Tally: successfully populated understanding for user {user_id}")
diff --git a/autogpt_platform/backend/backend/data/tally_test.py b/autogpt_platform/backend/backend/data/tally_test.py
index ee8536f253..bbed42f88a 100644
--- a/autogpt_platform/backend/backend/data/tally_test.py
+++ b/autogpt_platform/backend/backend/data/tally_test.py
@@ -12,11 +12,11 @@ from backend.data.tally import (
_build_email_index,
_format_answer,
_make_tally_client,
- _mask_email,
_refresh_cache,
extract_business_understanding,
find_submission_by_email,
format_submission_for_llm,
+ mask_email,
populate_understanding_from_tally,
)
@@ -248,7 +248,7 @@ async def test_populate_understanding_skips_no_api_key():
new_callable=AsyncMock,
return_value=None,
),
- patch("backend.data.tally.Settings", return_value=mock_settings),
+ patch("backend.data.tally._settings", mock_settings),
patch(
"backend.data.tally.find_submission_by_email",
new_callable=AsyncMock,
@@ -291,7 +291,7 @@ async def test_populate_understanding_full_flow():
new_callable=AsyncMock,
return_value=None,
),
- patch("backend.data.tally.Settings", return_value=mock_settings),
+ patch("backend.data.tally._settings", mock_settings),
patch(
"backend.data.tally.find_submission_by_email",
new_callable=AsyncMock,
@@ -331,7 +331,7 @@ async def test_populate_understanding_handles_llm_timeout():
new_callable=AsyncMock,
return_value=None,
),
- patch("backend.data.tally.Settings", return_value=mock_settings),
+ patch("backend.data.tally._settings", mock_settings),
patch(
"backend.data.tally.find_submission_by_email",
new_callable=AsyncMock,
@@ -356,13 +356,13 @@ async def test_populate_understanding_handles_llm_timeout():
def test_mask_email():
- assert _mask_email("[email protected]") == "a***[email protected]"
- assert _mask_email("[email protected]") == "a***@example.com"
- assert _mask_email("[email protected]") == "a***@example.com"
+ assert mask_email("[email protected]") == "a***[email protected]"
+ assert mask_email("[email protected]") == "a***@example.com"
+ assert mask_email("[email protected]") == "a***@example.com"
def test_mask_email_invalid():
- assert _mask_email("no-at-sign") == "***"
+ assert mask_email("no-at-sign") == "***"
# ── Prompt construction (curly-brace safety) ─────────────────────────────────
@@ -492,7 +492,7 @@ async def test_refresh_cache_full_fetch():
submissions = SAMPLE_SUBMISSIONS
with (
- patch("backend.data.tally.Settings", return_value=mock_settings),
+ patch("backend.data.tally._settings", mock_settings),
patch(
"backend.data.tally.get_redis_async",
new_callable=AsyncMock,
@@ -540,7 +540,7 @@ async def test_refresh_cache_incremental_fetch():
new_submissions = [SAMPLE_SUBMISSIONS[0]] # Just Alice
with (
- patch("backend.data.tally.Settings", return_value=mock_settings),
+ patch("backend.data.tally._settings", mock_settings),
patch(
"backend.data.tally.get_redis_async",
new_callable=AsyncMock,
diff --git a/autogpt_platform/backend/backend/data/understanding.py b/autogpt_platform/backend/backend/data/understanding.py
index c604e046b6..07a8196ca3 100644
--- a/autogpt_platform/backend/backend/data/understanding.py
+++ b/autogpt_platform/backend/backend/data/understanding.py
@@ -166,6 +166,56 @@ def _merge_lists(existing: list | None, new: list | None) -> list | None:
return merged
+def merge_business_understanding_data(
+ existing_data: dict[str, Any],
+ input_data: BusinessUnderstandingInput,
+) -> dict[str, Any]:
+ merged_data = dict(existing_data)
+
+ merged_business: dict[str, Any] = {}
+ if isinstance(merged_data.get("business"), dict):
+ merged_business = dict(merged_data["business"])
+
+ business_string_fields = [
+ "job_title",
+ "business_name",
+ "industry",
+ "business_size",
+ "user_role",
+ "additional_notes",
+ ]
+ business_list_fields = [
+ "key_workflows",
+ "daily_activities",
+ "pain_points",
+ "bottlenecks",
+ "manual_tasks",
+ "automation_goals",
+ "current_software",
+ "existing_automation",
+ ]
+
+ if input_data.user_name is not None:
+ merged_data["name"] = input_data.user_name
+
+ for field in business_string_fields:
+ value = getattr(input_data, field)
+ if value is not None:
+ merged_business[field] = value
+
+ for field in business_list_fields:
+ value = getattr(input_data, field)
+ if value is not None:
+ existing_list = _json_to_list(merged_business.get(field))
+ merged_list = _merge_lists(existing_list, value)
+ merged_business[field] = merged_list
+
+ merged_business["version"] = 1
+ merged_data["business"] = merged_business
+
+ return merged_data
+
+
async def _get_from_cache(user_id: str) -> Optional[BusinessUnderstanding]:
"""Get business understanding from Redis cache."""
try:
@@ -245,63 +295,18 @@ async def upsert_business_understanding(
where={"userId": user_id}
)
- # Get existing data structure or start fresh
existing_data: dict[str, Any] = {}
if existing and isinstance(existing.data, dict):
existing_data = dict(existing.data)
- existing_business: dict[str, Any] = {}
- if isinstance(existing_data.get("business"), dict):
- existing_business = dict(existing_data["business"])
-
- # Business fields (stored inside business object)
- business_string_fields = [
- "job_title",
- "business_name",
- "industry",
- "business_size",
- "user_role",
- "additional_notes",
- ]
- business_list_fields = [
- "key_workflows",
- "daily_activities",
- "pain_points",
- "bottlenecks",
- "manual_tasks",
- "automation_goals",
- "current_software",
- "existing_automation",
- ]
-
- # Handle top-level name field
- if input_data.user_name is not None:
- existing_data["name"] = input_data.user_name
-
- # Business string fields - overwrite if provided
- for field in business_string_fields:
- value = getattr(input_data, field)
- if value is not None:
- existing_business[field] = value
-
- # Business list fields - merge with existing
- for field in business_list_fields:
- value = getattr(input_data, field)
- if value is not None:
- existing_list = _json_to_list(existing_business.get(field))
- merged = _merge_lists(existing_list, value)
- existing_business[field] = merged
-
- # Set version and nest business data
- existing_business["version"] = 1
- existing_data["business"] = existing_business
+ merged_data = merge_business_understanding_data(existing_data, input_data)
# Upsert with the merged data
record = await CoPilotUnderstanding.prisma().upsert(
where={"userId": user_id},
data={
- "create": {"userId": user_id, "data": SafeJson(existing_data)},
- "update": {"data": SafeJson(existing_data)},
+ "create": {"userId": user_id, "data": SafeJson(merged_data)},
+ "update": {"data": SafeJson(merged_data)},
},
)
diff --git a/autogpt_platform/backend/backend/util/settings.py b/autogpt_platform/backend/backend/util/settings.py
index 8f12679d14..b7e4d5c8a8 100644
--- a/autogpt_platform/backend/backend/util/settings.py
+++ b/autogpt_platform/backend/backend/util/settings.py
@@ -117,6 +117,10 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):
default=True,
description="If authentication is enabled or not",
)
+ enable_invite_gate: bool = Field(
+ default=True,
+ description="If the invite-only signup gate is enforced",
+ )
enable_credit: bool = Field(
default=False,
description="If user credit system is enabled or not",
diff --git a/autogpt_platform/backend/migrations/20260310090914_add_invite_system/migration.sql b/autogpt_platform/backend/migrations/20260310090914_add_invite_system/migration.sql
new file mode 100644
index 0000000000..c85be3440c
--- /dev/null
+++ b/autogpt_platform/backend/migrations/20260310090914_add_invite_system/migration.sql
@@ -0,0 +1,46 @@
+/*
+ Warnings:
+
+ - You are about to drop the column `search` on the `StoreListingVersion` table. All the data in the column will be lost.
+
+*/-- CreateEnum
+CREATE TYPE "InvitedUserStatus" AS ENUM('INVITED',
+'CLAIMED',
+'REVOKED');
+-- CreateEnum
+CREATE TYPE "TallyComputationStatus" AS ENUM('PENDING',
+'RUNNING',
+'READY',
+'FAILED');
+-- CreateTable
+CREATE TABLE "InvitedUser"(
+ "id" TEXT NOT NULL,
+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ "updatedAt" TIMESTAMP(3) NOT NULL,
+ "email" TEXT NOT NULL,
+ "status" "InvitedUserStatus" NOT NULL DEFAULT 'INVITED',
+ "authUserId" TEXT,
+ "name" TEXT,
+ "tallyUnderstanding" JSONB,
+ "tallyStatus" "TallyComputationStatus" NOT NULL DEFAULT 'PENDING',
+ "tallyComputedAt" TIMESTAMP(3),
+ "tallyError" TEXT,
+ CONSTRAINT "InvitedUser_pkey" PRIMARY KEY("id")
+);
+-- CreateIndex
+CREATE UNIQUE INDEX "InvitedUser_email_key"
+ON "InvitedUser"("email");
+-- CreateIndex
+CREATE UNIQUE INDEX "InvitedUser_authUserId_key"
+ON "InvitedUser"("authUserId");
+-- CreateIndex
+CREATE INDEX "InvitedUser_status_idx"
+ON "InvitedUser"("status");
+-- CreateIndex
+CREATE INDEX "InvitedUser_tallyStatus_idx"
+ON "InvitedUser"("tallyStatus");
+-- AddForeignKey
+ALTER TABLE "InvitedUser" ADD CONSTRAINT "InvitedUser_authUserId_fkey" FOREIGN KEY("authUserId") REFERENCES "User"("id")
+ON DELETE
+SET NULL
+ON UPDATE CASCADE;
diff --git a/autogpt_platform/backend/migrations/20260311000000_drop_auto_user_trigger/migration.sql b/autogpt_platform/backend/migrations/20260311000000_drop_auto_user_trigger/migration.sql
new file mode 100644
index 0000000000..bb4aeda72a
--- /dev/null
+++ b/autogpt_platform/backend/migrations/20260311000000_drop_auto_user_trigger/migration.sql
@@ -0,0 +1,15 @@
+-- Drop the trigger that auto-creates User + Profile on auth.users INSERT.
+-- The invite activation flow in get_or_activate_user() now handles this.
+DO $$
+BEGIN
+ IF EXISTS (
+ SELECT 1 FROM information_schema.tables
+ WHERE table_schema = 'auth' AND table_name = 'users'
+ ) THEN
+ DROP TRIGGER IF EXISTS user_added_to_platform ON auth.users;
+ END IF;
+END $$;
+
+DROP FUNCTION IF EXISTS add_user_and_profile_to_platform();
+DROP FUNCTION IF EXISTS add_user_to_platform();
+-- Keep generate_username() — used by backfill migration 20250205110132
diff --git a/autogpt_platform/backend/migrations/20260312093554_update_invites_indexs/migration.sql b/autogpt_platform/backend/migrations/20260312093554_update_invites_indexs/migration.sql
new file mode 100644
index 0000000000..58f944aedf
--- /dev/null
+++ b/autogpt_platform/backend/migrations/20260312093554_update_invites_indexs/migration.sql
@@ -0,0 +1,7 @@
+-- DropIndex
+DROP INDEX "InvitedUser_status_idx";
+-- DropIndex
+DROP INDEX "InvitedUser_tallyStatus_idx";
+-- CreateIndex
+CREATE INDEX "InvitedUser_createdAt_idx"
+ON "InvitedUser"("createdAt");
diff --git a/autogpt_platform/backend/schema.prisma b/autogpt_platform/backend/schema.prisma
index f269d45016..8495b9f46b 100644
--- a/autogpt_platform/backend/schema.prisma
+++ b/autogpt_platform/backend/schema.prisma
@@ -65,6 +65,7 @@ model User {
NotificationBatches UserNotificationBatch[]
PendingHumanReviews PendingHumanReview[]
Workspace UserWorkspace?
+ ClaimedInvite InvitedUser? @relation("InvitedUserAuthUser")
// OAuth Provider relations
OAuthApplications OAuthApplication[]
@@ -73,6 +74,38 @@ model User {
OAuthRefreshTokens OAuthRefreshToken[]
}
+enum InvitedUserStatus {
+ INVITED
+ CLAIMED
+ REVOKED
+}
+
+enum TallyComputationStatus {
+ PENDING
+ RUNNING
+ READY
+ FAILED
+}
+
+model InvitedUser {
+ id String @id @default(uuid())
+ createdAt DateTime @default(now())
+ updatedAt DateTime @updatedAt
+
+ email String @unique
+ status InvitedUserStatus @default(INVITED)
+ authUserId String? @unique
+ AuthUser User? @relation("InvitedUserAuthUser", fields: [authUserId], references: [id], onDelete: SetNull)
+ name String?
+
+ tallyUnderstanding Json?
+ tallyStatus TallyComputationStatus @default(PENDING)
+ tallyComputedAt DateTime?
+ tallyError String?
+
+ @@index([createdAt])
+}
+
enum OnboardingStep {
// Introductory onboarding (Library)
WELCOME
@@ -992,7 +1025,7 @@ model StoreListing {
ActiveVersion StoreListingVersion? @relation("ActiveVersion", fields: [activeVersionId], references: [id])
// The agent link here is only so we can do lookup on agentId
- agentGraphId String @unique
+ agentGraphId String @unique
owningUserId String
OwningUser User @relation(fields: [owningUserId], references: [id])
diff --git a/autogpt_platform/backend/test/e2e_test_data.py b/autogpt_platform/backend/test/e2e_test_data.py
index 500075da21..01d5fb740e 100644
--- a/autogpt_platform/backend/test/e2e_test_data.py
+++ b/autogpt_platform/backend/test/e2e_test_data.py
@@ -34,7 +34,7 @@ from backend.data.auth.api_key import create_api_key
from backend.data.credit import get_user_credit_model
from backend.data.db import prisma
from backend.data.graph import Graph, Link, Node, create_graph
-from backend.data.user import get_or_create_user
+from backend.data.invited_user import get_or_activate_user
from backend.util.clients import get_supabase
faker = Faker()
@@ -151,7 +151,7 @@ class TestDataCreator:
}
# Use the API function to create user in local database
- user = await get_or_create_user(user_data)
+ user = await get_or_activate_user(user_data)
users.append(user.model_dump())
except Exception as e:
diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx
index fec14244c7..a1ec3788b2 100644
--- a/autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx
@@ -1,7 +1,14 @@
-import { Sidebar } from "@/components/__legacy__/Sidebar";
-import { Users, DollarSign, UserSearch, FileText } from "lucide-react";
+"use client";
-import { IconSliders } from "@/components/__legacy__/ui/icons";
+import { Sidebar } from "@/components/__legacy__/Sidebar";
+import {
+ UsersIcon,
+ CurrencyDollarSimpleIcon,
+ UserPlusIcon,
+ MagnifyingGlassIcon,
+ FileTextIcon,
+ SlidersHorizontalIcon,
+} from "@phosphor-icons/react";
const sidebarLinkGroups = [
{
@@ -9,27 +16,32 @@ const sidebarLinkGroups = [
{
text: "Marketplace Management",
href: "/admin/marketplace",
- icon: <Users className="h-6 w-6" />,
+ icon: <UsersIcon size={24} />,
},
{
text: "User Spending",
href: "/admin/spending",
- icon: <DollarSign className="h-6 w-6" />,
+ icon: <CurrencyDollarSimpleIcon size={24} />,
+ },
+ {
+ text: "Beta Invites",
+ href: "/admin/users",
+ icon: <UserPlusIcon size={24} />,
},
{
text: "User Impersonation",
href: "/admin/impersonation",
- icon: <UserSearch className="h-6 w-6" />,
+ icon: <MagnifyingGlassIcon size={24} />,
},
{
text: "Execution Analytics",
href: "/admin/execution-analytics",
- icon: <FileText className="h-6 w-6" />,
+ icon: <FileTextIcon size={24} />,
},
{
text: "Admin User Management",
href: "/admin/settings",
- icon: <IconSliders className="h-6 w-6" />,
+ icon: <SlidersHorizontalIcon size={24} />,
},
],
},
diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/users/components/AdminUsersPage/AdminUsersPage.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/users/components/AdminUsersPage/AdminUsersPage.tsx
new file mode 100644
index 0000000000..794e4f6e75
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/users/components/AdminUsersPage/AdminUsersPage.tsx
@@ -0,0 +1,80 @@
+"use client";
+
+import { Card } from "@/components/atoms/Card/Card";
+import { BulkInviteForm } from "../BulkInviteForm/BulkInviteForm";
+import { InviteUserForm } from "../InviteUserForm/InviteUserForm";
+import { InvitedUsersTable } from "../InvitedUsersTable/InvitedUsersTable";
+import { useAdminUsersPage } from "../../useAdminUsersPage";
+
+export function AdminUsersPage() {
+ const {
+ email,
+ name,
+ bulkInviteFile,
+ bulkInviteInputKey,
+ lastBulkInviteResult,
+ invitedUsers,
+ isLoadingInvitedUsers,
+ isRefreshingInvitedUsers,
+ isCreatingInvite,
+ isBulkInviting,
+ pendingInviteAction,
+ setEmail,
+ setName,
+ handleBulkInviteFileChange,
+ handleBulkInviteSubmit,
+ handleCreateInvite,
+ handleRetryTally,
+ handleRevoke,
+ } = useAdminUsersPage();
+
+ return (
+ <div className="mx-auto flex max-w-7xl flex-col gap-6 p-6">
+ <div className="flex flex-col gap-2">
+ <h1 className="text-3xl font-bold text-zinc-900">Beta Invites</h1>
+ <p className="max-w-3xl text-sm text-zinc-600">
+ Pre-provision beta users before they sign up. Invites store the
+ platform-side record, run Tally understanding extraction, and activate
+ the real account on the user&apos;s first authenticated request.
+ </p>
+ </div>
+
+ <div className="grid gap-6 xl:grid-cols-[24rem,1fr]">
+ <div className="flex flex-col gap-6">
+ <Card className="border border-zinc-200 shadow-sm">
+ <InviteUserForm
+ email={email}
+ name={name}
+ isSubmitting={isCreatingInvite}
+ onEmailChange={setEmail}
+ onNameChange={setName}
+ onSubmit={handleCreateInvite}
+ />
+ </Card>
+
+ <Card className="border border-zinc-200 shadow-sm">
+ <BulkInviteForm
+ selectedFile={bulkInviteFile}
+ inputKey={bulkInviteInputKey}
+ isSubmitting={isBulkInviting}
+ lastResult={lastBulkInviteResult}
+ onFileChange={handleBulkInviteFileChange}
+ onSubmit={handleBulkInviteSubmit}
+ />
+ </Card>
+ </div>
+
+ <Card className="border border-zinc-200 shadow-sm">
+ <InvitedUsersTable
+ invitedUsers={invitedUsers}
+ isLoading={isLoadingInvitedUsers}
+ isRefreshing={isRefreshingInvitedUsers}
+ pendingInviteAction={pendingInviteAction}
+ onRetryTally={handleRetryTally}
+ onRevoke={handleRevoke}
+ />
+ </Card>
+ </div>
+ </div>
+ );
+}
diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/users/components/BulkInviteForm/BulkInviteForm.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/users/components/BulkInviteForm/BulkInviteForm.tsx
new file mode 100644
index 0000000000..a91702597a
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/users/components/BulkInviteForm/BulkInviteForm.tsx
@@ -0,0 +1,135 @@
+"use client";
+
+import type { BulkInvitedUsersResponse } from "@/app/api/__generated__/models/bulkInvitedUsersResponse";
+import { Badge } from "@/components/atoms/Badge/Badge";
+import { Button } from "@/components/atoms/Button/Button";
+import type { FormEvent } from "react";
+
+interface Props {
+ selectedFile: File | null;
+ inputKey: number;
+ isSubmitting: boolean;
+ lastResult: BulkInvitedUsersResponse | null;
+ onFileChange: (file: File | null) => void;
+ onSubmit: (event: FormEvent<HTMLFormElement>) => void;
+}
+
+function getStatusVariant(status: "CREATED" | "SKIPPED" | "ERROR") {
+ if (status === "CREATED") {
+ return "success";
+ }
+
+ if (status === "ERROR") {
+ return "error";
+ }
+
+ return "info";
+}
+
+export function BulkInviteForm({
+ selectedFile,
+ inputKey,
+ isSubmitting,
+ lastResult,
+ onFileChange,
+ onSubmit,
+}: Props) {
+ return (
+ <form className="flex flex-col gap-4" onSubmit={onSubmit}>
+ <div className="flex flex-col gap-1">
+ <h2 className="text-xl font-semibold text-zinc-900">Bulk invite</h2>
+ <p className="text-sm text-zinc-600">
+ Upload a <span className="font-medium text-zinc-800">.txt</span> file
+ with one email per line, or a{" "}
+ <span className="font-medium text-zinc-800">.csv</span> with
+ <span className="font-medium text-zinc-800"> email</span> and optional
+ <span className="font-medium text-zinc-800"> name</span> columns.
+ </p>
+ </div>
+
+ <label
+ htmlFor="bulk-invite-file-input"
+ className="flex cursor-pointer flex-col gap-2 rounded-2xl border border-dashed border-zinc-300 bg-zinc-50 px-4 py-5 text-sm text-zinc-600 transition-colors focus-within:ring-2 focus-within:ring-zinc-500 focus-within:ring-offset-2 hover:border-zinc-400 hover:bg-zinc-100"
+ >
+ <span className="font-medium text-zinc-900">
+ {selectedFile ? selectedFile.name : "Choose invite file"}
+ </span>
+ <span>Maximum 500 rows, UTF-8 encoded.</span>
+ <input
+ id="bulk-invite-file-input"
+ key={inputKey}
+ type="file"
+ accept=".txt,.csv,text/plain,text/csv"
+ disabled={isSubmitting}
+ className="sr-only"
+ onChange={(event) =>
+ onFileChange(event.target.files?.item(0) ?? null)
+ }
+ />
+ </label>
+
+ <Button
+ type="submit"
+ variant="primary"
+ loading={isSubmitting}
+ disabled={!selectedFile}
+ className="w-full"
+ >
+ {isSubmitting ? "Uploading invites..." : "Upload invite file"}
+ </Button>
+
+ {lastResult ? (
+ <div className="flex flex-col gap-3 rounded-2xl border border-zinc-200 bg-zinc-50 p-4">
+ <div className="grid grid-cols-3 gap-2 text-center">
+ <div className="rounded-xl bg-white px-3 py-2">
+ <div className="text-lg font-semibold text-zinc-900">
+ {lastResult.created_count}
+ </div>
+ <div className="text-xs uppercase tracking-[0.16em] text-zinc-500">
+ Created
+ </div>
+ </div>
+ <div className="rounded-xl bg-white px-3 py-2">
+ <div className="text-lg font-semibold text-zinc-900">
+ {lastResult.skipped_count}
+ </div>
+ <div className="text-xs uppercase tracking-[0.16em] text-zinc-500">
+ Skipped
+ </div>
+ </div>
+ <div className="rounded-xl bg-white px-3 py-2">
+ <div className="text-lg font-semibold text-zinc-900">
+ {lastResult.error_count}
+ </div>
+ <div className="text-xs uppercase tracking-[0.16em] text-zinc-500">
+ Errors
+ </div>
+ </div>
+ </div>
+
+ <div className="max-h-64 overflow-y-auto rounded-xl border border-zinc-200 bg-white">
+ <div className="flex flex-col divide-y divide-zinc-100">
+ {lastResult.results.map((row) => (
+ <div
+ key={`${row.row_number}-${row.email ?? row.message}`}
+ className="flex items-start gap-3 px-3 py-3"
+ >
+ <Badge variant={getStatusVariant(row.status)} size="small">
+ {row.status}
+ </Badge>
+ <div className="flex min-w-0 flex-1 flex-col gap-1">
+ <span className="text-sm font-medium text-zinc-900">
+ Row {row.row_number}
+ {row.email ? ` · ${row.email}` : ""}
+ </span>
+ <span className="text-xs text-zinc-500">{row.message}</span>
+ </div>
+ </div>
+ ))}
+ </div>
+ </div>
+ </div>
+ ) : null}
+ </form>
+ );
+}
diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/users/components/InviteUserForm/InviteUserForm.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/users/components/InviteUserForm/InviteUserForm.tsx
new file mode 100644
index 0000000000..ceee13dac1
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/users/components/InviteUserForm/InviteUserForm.tsx
@@ -0,0 +1,66 @@
+"use client";
+
+import { Button } from "@/components/atoms/Button/Button";
+import { Input } from "@/components/atoms/Input/Input";
+import type { FormEvent } from "react";
+
+interface Props {
+ email: string;
+ name: string;
+ isSubmitting: boolean;
+ onEmailChange: (value: string) => void;
+ onNameChange: (value: string) => void;
+ onSubmit: (event: FormEvent<HTMLFormElement>) => void;
+}
+
+export function InviteUserForm({
+ email,
+ name,
+ isSubmitting,
+ onEmailChange,
+ onNameChange,
+ onSubmit,
+}: Props) {
+ return (
+ <form className="flex flex-col gap-4" onSubmit={onSubmit}>
+ <div className="flex flex-col gap-1">
+ <h2 className="text-xl font-semibold text-zinc-900">Create invite</h2>
+ <p className="text-sm text-zinc-600">
+ The invite is stored immediately, then Tally pre-seeding starts in the
+ background.
+ </p>
+ </div>
+
+ <Input
+ id="invite-email"
+ label="Email"
+ type="email"
+ value={email}
+ placeholder="[email protected]"
+ autoComplete="email"
+ disabled={isSubmitting}
+ onChange={(event) => onEmailChange(event.target.value)}
+ />
+
+ <Input
+ id="invite-name"
+ label="Name"
+ type="text"
+ value={name}
+ placeholder="Jane Doe"
+ disabled={isSubmitting}
+ onChange={(event) => onNameChange(event.target.value)}
+ />
+
+ <Button
+ type="submit"
+ variant="primary"
+ loading={isSubmitting}
+ disabled={!email.trim()}
+ className="w-full"
+ >
+ {isSubmitting ? "Creating invite..." : "Create invite"}
+ </Button>
+ </form>
+ );
+}
diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/users/components/InvitedUsersTable/InvitedUsersTable.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/users/components/InvitedUsersTable/InvitedUsersTable.tsx
new file mode 100644
index 0000000000..df4d6e1836
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/users/components/InvitedUsersTable/InvitedUsersTable.tsx
@@ -0,0 +1,209 @@
+"use client";
+
+import type { InvitedUserResponse } from "@/app/api/__generated__/models/invitedUserResponse";
+import { Badge } from "@/components/atoms/Badge/Badge";
+import { Button } from "@/components/atoms/Button/Button";
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+} from "@/components/__legacy__/ui/table";
+
+interface Props {
+ invitedUsers: InvitedUserResponse[];
+ isLoading: boolean;
+ isRefreshing: boolean;
+ pendingInviteAction: string | null;
+ onRetryTally: (invitedUserId: string) => void;
+ onRevoke: (invitedUserId: string) => void;
+}
+
+function getInviteBadgeVariant(status: InvitedUserResponse["status"]) {
+ if (status === "CLAIMED") {
+ return "success";
+ }
+
+ if (status === "REVOKED") {
+ return "error";
+ }
+
+ return "info";
+}
+
+function getTallyBadgeVariant(status: InvitedUserResponse["tally_status"]) {
+ if (status === "READY") {
+ return "success";
+ }
+
+ if (status === "FAILED") {
+ return "error";
+ }
+
+ return "info";
+}
+
+function formatDate(value: Date | undefined) {
+ if (!value) {
+ return "-";
+ }
+
+ return value.toLocaleString();
+}
+
+function getTallySummary(invitedUser: InvitedUserResponse) {
+ if (invitedUser.tally_status === "FAILED" && invitedUser.tally_error) {
+ return invitedUser.tally_error;
+ }
+
+ if (invitedUser.tally_status === "READY" && invitedUser.tally_understanding) {
+ return "Stored and ready for activation";
+ }
+
+ if (invitedUser.tally_status === "READY") {
+ return "No matching Tally submission found";
+ }
+
+ if (invitedUser.tally_status === "RUNNING") {
+ return "Extraction in progress";
+ }
+
+ return "Waiting to run";
+}
+
+function isActionPending(
+ pendingInviteAction: string | null,
+ action: "retry" | "revoke",
+ invitedUserId: string,
+) {
+ return pendingInviteAction === `${action}:${invitedUserId}`;
+}
+
+export function InvitedUsersTable({
+ invitedUsers,
+ isLoading,
+ isRefreshing,
+ pendingInviteAction,
+ onRetryTally,
+ onRevoke,
+}: Props) {
+ return (
+ <div className="flex flex-col gap-4">
+ <div className="flex items-center justify-between gap-4">
+ <div className="flex flex-col gap-1">
+ <h2 className="text-xl font-semibold text-zinc-900">Invited users</h2>
+ <p className="text-sm text-zinc-600">
+ Live invite state, claim status, and Tally pre-seeding progress.
+ </p>
+ </div>
+ <span className="text-xs uppercase tracking-[0.18em] text-zinc-400">
+ {isRefreshing ? "Refreshing" : `${invitedUsers.length} total`}
+ </span>
+ </div>
+
+ <div className="overflow-hidden rounded-2xl border border-zinc-200">
+ <Table>
+ <TableHeader className="bg-zinc-50">
+ <TableRow>
+ <TableHead>Email</TableHead>
+ <TableHead>Name</TableHead>
+ <TableHead>Invite</TableHead>
+ <TableHead>Tally</TableHead>
+ <TableHead>Claimed User</TableHead>
+ <TableHead>Created</TableHead>
+ <TableHead className="text-right">Actions</TableHead>
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {isLoading ? (
+ <TableRow>
+ <TableCell
+ colSpan={7}
+ className="py-10 text-center text-zinc-500"
+ >
+ Loading invited users...
+ </TableCell>
+ </TableRow>
+ ) : invitedUsers.length === 0 ? (
+ <TableRow>
+ <TableCell
+ colSpan={7}
+ className="py-10 text-center text-zinc-500"
+ >
+ No invited users yet
+ </TableCell>
+ </TableRow>
+ ) : (
+ invitedUsers.map((invitedUser) => (
+ <TableRow key={invitedUser.id} className="align-top">
+ <TableCell className="font-medium text-zinc-900">
+ {invitedUser.email}
+ </TableCell>
+ <TableCell>{invitedUser.name || "-"}</TableCell>
+ <TableCell>
+ <Badge variant={getInviteBadgeVariant(invitedUser.status)}>
+ {invitedUser.status}
+ </Badge>
+ </TableCell>
+ <TableCell>
+ <div className="flex max-w-xs flex-col gap-2">
+ <Badge
+ variant={getTallyBadgeVariant(invitedUser.tally_status)}
+ >
+ {invitedUser.tally_status}
+ </Badge>
+ <span className="text-xs text-zinc-500">
+ {getTallySummary(invitedUser)}
+ </span>
+ <span className="text-xs text-zinc-400">
+ {formatDate(invitedUser.tally_computed_at ?? undefined)}
+ </span>
+ </div>
+ </TableCell>
+ <TableCell className="font-mono text-xs text-zinc-500">
+ {invitedUser.auth_user_id || "-"}
+ </TableCell>
+ <TableCell className="text-sm text-zinc-500">
+ {formatDate(invitedUser.created_at)}
+ </TableCell>
+ <TableCell>
+ <div className="flex justify-end gap-2">
+ <Button
+ variant="outline"
+ size="small"
+ disabled={invitedUser.status === "REVOKED"}
+ loading={isActionPending(
+ pendingInviteAction,
+ "retry",
+ invitedUser.id,
+ )}
+ onClick={() => onRetryTally(invitedUser.id)}
+ >
+ Retry Tally
+ </Button>
+ <Button
+ variant="secondary"
+ size="small"
+ disabled={invitedUser.status !== "INVITED"}
+ loading={isActionPending(
+ pendingInviteAction,
+ "revoke",
+ invitedUser.id,
+ )}
+ onClick={() => onRevoke(invitedUser.id)}
+ >
+ Revoke
+ </Button>
+ </div>
+ </TableCell>
+ </TableRow>
+ ))
+ )}
+ </TableBody>
+ </Table>
+ </div>
+ </div>
+ );
+}
diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/users/page.tsx b/autogpt_platform/frontend/src/app/(platform)/admin/users/page.tsx
index 5c25206cd1..d0368ef895 100644
--- a/autogpt_platform/frontend/src/app/(platform)/admin/users/page.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/users/page.tsx
@@ -1,16 +1,11 @@
import { withRoleAccess } from "@/lib/withRoleAccess";
-import React from "react";
+import { AdminUsersPage } from "./components/AdminUsersPage/AdminUsersPage";
function AdminUsers() {
- return (
- <div>
- <h1>Users Dashboard</h1>
- {/* Add your admin-only content here */}
- </div>
- );
+ return <AdminUsersPage />;
}
-export default async function AdminUsersPage() {
+export default async function AdminUsersRoute() {
"use server";
const withAdminAccess = await withRoleAccess(["admin"]);
const ProtectedAdminUsers = await withAdminAccess(AdminUsers);
diff --git a/autogpt_platform/frontend/src/app/(platform)/admin/users/useAdminUsersPage.ts b/autogpt_platform/frontend/src/app/(platform)/admin/users/useAdminUsersPage.ts
new file mode 100644
index 0000000000..e2e23bf020
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/admin/users/useAdminUsersPage.ts
@@ -0,0 +1,197 @@
+"use client";
+
+import type { BulkInvitedUsersResponse } from "@/app/api/__generated__/models/bulkInvitedUsersResponse";
+import { okData } from "@/app/api/helpers";
+import {
+ getGetV2ListInvitedUsersQueryKey,
+ useGetV2ListInvitedUsers,
+ usePostV2BulkCreateInvitedUsers,
+ usePostV2CreateInvitedUser,
+ usePostV2RetryInvitedUserTally,
+ usePostV2RevokeInvitedUser,
+} from "@/app/api/__generated__/endpoints/admin/admin";
+import { useToast } from "@/components/molecules/Toast/use-toast";
+import { useQueryClient } from "@tanstack/react-query";
+import { type FormEvent, useState } from "react";
+
+function getErrorMessage(error: unknown) {
+ if (error instanceof Error) {
+ return error.message;
+ }
+
+ return "Something went wrong";
+}
+
+export function useAdminUsersPage() {
+ const queryClient = useQueryClient();
+ const { toast } = useToast();
+ const [email, setEmail] = useState("");
+ const [name, setName] = useState("");
+ const [bulkInviteFile, setBulkInviteFile] = useState<File | null>(null);
+ const [bulkInviteInputKey, setBulkInviteInputKey] = useState(0);
+ const [lastBulkInviteResult, setLastBulkInviteResult] =
+ useState<BulkInvitedUsersResponse | null>(null);
+ const [pendingInviteAction, setPendingInviteAction] = useState<string | null>(
+ null,
+ );
+
+ const invitedUsersQuery = useGetV2ListInvitedUsers(undefined, {
+ query: {
+ select: okData,
+ refetchInterval: 30_000,
+ },
+ });
+
+ const createInvitedUserMutation = usePostV2CreateInvitedUser({
+ mutation: {
+ onSuccess: async () => {
+ setEmail("");
+ setName("");
+ await queryClient.invalidateQueries({
+ queryKey: getGetV2ListInvitedUsersQueryKey(),
+ });
+ toast({
+ title: "Invited user created",
+ variant: "default",
+ });
+ },
+ onError: (error) => {
+ toast({
+ title: getErrorMessage(error),
+ variant: "destructive",
+ });
+ },
+ },
+ });
+
+ const bulkCreateInvitedUsersMutation = usePostV2BulkCreateInvitedUsers({
+ mutation: {
+ onSuccess: async (response) => {
+ const result = okData(response) ?? null;
+ setBulkInviteFile(null);
+ setBulkInviteInputKey((currentValue) => currentValue + 1);
+ setLastBulkInviteResult(result);
+ await queryClient.invalidateQueries({
+ queryKey: getGetV2ListInvitedUsersQueryKey(),
+ });
+ toast({
+ title: result
+ ? `${result.created_count} invites created`
+ : "Bulk invite upload complete",
+ variant: "default",
+ });
+ },
+ onError: (error) => {
+ toast({
+ title: getErrorMessage(error),
+ variant: "destructive",
+ });
+ },
+ },
+ });
+
+ const retryInvitedUserTallyMutation = usePostV2RetryInvitedUserTally({
+ mutation: {
+ onSuccess: async () => {
+ setPendingInviteAction(null);
+ await queryClient.invalidateQueries({
+ queryKey: getGetV2ListInvitedUsersQueryKey(),
+ });
+ toast({
+ title: "Tally pre-seeding restarted",
+ variant: "default",
+ });
+ },
+ onError: (error) => {
+ setPendingInviteAction(null);
+ toast({
+ title: getErrorMessage(error),
+ variant: "destructive",
+ });
+ },
+ },
+ });
+
+ const revokeInvitedUserMutation = usePostV2RevokeInvitedUser({
+ mutation: {
+ onSuccess: async () => {
+ setPendingInviteAction(null);
+ await queryClient.invalidateQueries({
+ queryKey: getGetV2ListInvitedUsersQueryKey(),
+ });
+ toast({
+ title: "Invite revoked",
+ variant: "default",
+ });
+ },
+ onError: (error) => {
+ setPendingInviteAction(null);
+ toast({
+ title: getErrorMessage(error),
+ variant: "destructive",
+ });
+ },
+ },
+ });
+
+ function handleCreateInvite(event: FormEvent<HTMLFormElement>) {
+ event.preventDefault();
+
+ createInvitedUserMutation.mutate({
+ data: {
+ email,
+ name: name.trim() || null,
+ },
+ });
+ }
+
+ function handleRetryTally(invitedUserId: string) {
+ setPendingInviteAction(`retry:${invitedUserId}`);
+ retryInvitedUserTallyMutation.mutate({ invitedUserId });
+ }
+
+ function handleBulkInviteFileChange(file: File | null) {
+ setBulkInviteFile(file);
+ }
+
+ function handleBulkInviteSubmit(event: FormEvent<HTMLFormElement>) {
+ event.preventDefault();
+
+ if (!bulkInviteFile) {
+ return;
+ }
+
+ bulkCreateInvitedUsersMutation.mutate({
+ data: {
+ file: bulkInviteFile,
+ },
+ });
+ }
+
+ function handleRevoke(invitedUserId: string) {
+ setPendingInviteAction(`revoke:${invitedUserId}`);
+ revokeInvitedUserMutation.mutate({ invitedUserId });
+ }
+
+ return {
+ email,
+ name,
+ bulkInviteFile,
+ bulkInviteInputKey,
+ lastBulkInviteResult,
+ invitedUsers: invitedUsersQuery.data?.invited_users ?? [],
+ invitedUsersError: invitedUsersQuery.error,
+ isLoadingInvitedUsers: invitedUsersQuery.isLoading,
+ isRefreshingInvitedUsers: invitedUsersQuery.isFetching,
+ isCreatingInvite: createInvitedUserMutation.isPending,
+ isBulkInviting: bulkCreateInvitedUsersMutation.isPending,
+ pendingInviteAction,
+ setEmail,
+ setName,
+ handleBulkInviteFileChange,
+ handleBulkInviteSubmit,
+ handleCreateInvite,
+ handleRetryTally,
+ handleRevoke,
+ };
+}
diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index a2c4fd7ee9..b8d0a7a74b 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -6646,6 +6646,214 @@
}
}
},
+ "/api/users/admin/invited-users": {
+ "get": {
+ "tags": ["v2", "admin", "users", "admin"],
+ "summary": "List Invited Users",
+ "operationId": "getV2List invited users",
+ "security": [{ "HTTPBearerJWT": [] }],
+ "parameters": [
+ {
+ "name": "page",
+ "in": "query",
+ "required": false,
+ "schema": {
+ "type": "integer",
+ "minimum": 1,
+ "default": 1,
+ "title": "Page"
+ }
+ },
+ {
+ "name": "page_size",
+ "in": "query",
+ "required": false,
+ "schema": {
+ "type": "integer",
+ "maximum": 200,
+ "minimum": 1,
+ "default": 50,
+ "title": "Page Size"
+ }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/InvitedUsersResponse"
+ }
+ }
+ }
+ },
+ "401": {
+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+ }
+ }
+ }
+ }
+ },
+ "post": {
+ "tags": ["v2", "admin", "users", "admin"],
+ "summary": "Create Invited User",
+ "operationId": "postV2Create invited user",
+ "security": [{ "HTTPBearerJWT": [] }],
+ "requestBody": {
+ "required": true,
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/CreateInvitedUserRequest"
+ }
+ }
+ }
+ },
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/InvitedUserResponse" }
+ }
+ }
+ },
+ "401": {
+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+ }
+ }
+ }
+ }
+ }
+ },
+ "/api/users/admin/invited-users/bulk": {
+ "post": {
+ "tags": ["v2", "admin", "users", "admin"],
+ "summary": "Bulk Create Invited Users",
+ "operationId": "postV2BulkCreateInvitedUsers",
+ "requestBody": {
+ "content": {
+ "multipart/form-data": {
+ "schema": {
+ "$ref": "#/components/schemas/Body_postV2BulkCreateInvitedUsers"
+ }
+ }
+ },
+ "required": true
+ },
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/BulkInvitedUsersResponse"
+ }
+ }
+ }
+ },
+ "401": {
+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+ }
+ }
+ }
+ },
+ "security": [{ "HTTPBearerJWT": [] }]
+ }
+ },
+ "/api/users/admin/invited-users/{invited_user_id}/retry-tally": {
+ "post": {
+ "tags": ["v2", "admin", "users", "admin"],
+ "summary": "Retry Invited User Tally",
+ "operationId": "postV2Retry invited user tally",
+ "security": [{ "HTTPBearerJWT": [] }],
+ "parameters": [
+ {
+ "name": "invited_user_id",
+ "in": "path",
+ "required": true,
+ "schema": { "type": "string", "title": "Invited User Id" }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/InvitedUserResponse" }
+ }
+ }
+ },
+ "401": {
+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+ }
+ }
+ }
+ }
+ }
+ },
+ "/api/users/admin/invited-users/{invited_user_id}/revoke": {
+ "post": {
+ "tags": ["v2", "admin", "users", "admin"],
+ "summary": "Revoke Invited User",
+ "operationId": "postV2Revoke invited user",
+ "security": [{ "HTTPBearerJWT": [] }],
+ "parameters": [
+ {
+ "name": "invited_user_id",
+ "in": "path",
+ "required": true,
+ "schema": { "type": "string", "title": "Invited User Id" }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/InvitedUserResponse" }
+ }
+ }
+ },
+ "401": {
+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+ }
+ }
+ }
+ }
+ }
+ },
"/api/workspace/files/upload": {
"post": {
"tags": ["workspace"],
@@ -8032,6 +8240,14 @@
"required": ["store_listing_version_id"],
"title": "Body_postV2Add marketplace agent"
},
+ "Body_postV2BulkCreateInvitedUsers": {
+ "properties": {
+ "file": { "type": "string", "format": "binary", "title": "File" }
+ },
+ "type": "object",
+ "required": ["file"],
+ "title": "Body_postV2BulkCreateInvitedUsers"
+ },
"Body_postV2Execute_a_preset": {
"properties": {
"inputs": {
@@ -8066,6 +8282,56 @@
"required": ["file"],
"title": "Body_postWorkspaceUpload file to workspace"
},
+ "BulkInvitedUserRowResponse": {
+ "properties": {
+ "row_number": { "type": "integer", "title": "Row Number" },
+ "email": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Email"
+ },
+ "name": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Name"
+ },
+ "status": {
+ "type": "string",
+ "enum": ["CREATED", "SKIPPED", "ERROR"],
+ "title": "Status"
+ },
+ "message": { "type": "string", "title": "Message" },
+ "invited_user": {
+ "anyOf": [
+ { "$ref": "#/components/schemas/InvitedUserResponse" },
+ { "type": "null" }
+ ]
+ }
+ },
+ "type": "object",
+ "required": ["row_number", "status", "message"],
+ "title": "BulkInvitedUserRowResponse"
+ },
+ "BulkInvitedUsersResponse": {
+ "properties": {
+ "created_count": { "type": "integer", "title": "Created Count" },
+ "skipped_count": { "type": "integer", "title": "Skipped Count" },
+ "error_count": { "type": "integer", "title": "Error Count" },
+ "results": {
+ "items": {
+ "$ref": "#/components/schemas/BulkInvitedUserRowResponse"
+ },
+ "type": "array",
+ "title": "Results"
+ }
+ },
+ "type": "object",
+ "required": [
+ "created_count",
+ "skipped_count",
+ "error_count",
+ "results"
+ ],
+ "title": "BulkInvitedUsersResponse"
+ },
"BulkMoveAgentsRequest": {
"properties": {
"agent_ids": {
@@ -8242,6 +8508,18 @@
"required": ["graph"],
"title": "CreateGraph"
},
+ "CreateInvitedUserRequest": {
+ "properties": {
+ "email": { "type": "string", "format": "email", "title": "Email" },
+ "name": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Name"
+ }
+ },
+ "type": "object",
+ "required": ["email"],
+ "title": "CreateInvitedUserRequest"
+ },
"CreateSessionResponse": {
"properties": {
"id": { "type": "string", "title": "Id" },
@@ -9706,6 +9984,80 @@
"title": "InputValidationErrorResponse",
"description": "Response when run_agent receives unknown input fields."
},
+ "InvitedUserResponse": {
+ "properties": {
+ "id": { "type": "string", "title": "Id" },
+ "email": { "type": "string", "title": "Email" },
+ "status": { "$ref": "#/components/schemas/InvitedUserStatus" },
+ "auth_user_id": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Auth User Id"
+ },
+ "name": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Name"
+ },
+ "tally_understanding": {
+ "anyOf": [
+ { "additionalProperties": true, "type": "object" },
+ { "type": "null" }
+ ],
+ "title": "Tally Understanding"
+ },
+ "tally_status": {
+ "$ref": "#/components/schemas/TallyComputationStatus"
+ },
+ "tally_computed_at": {
+ "anyOf": [
+ { "type": "string", "format": "date-time" },
+ { "type": "null" }
+ ],
+ "title": "Tally Computed At"
+ },
+ "tally_error": {
+ "anyOf": [{ "type": "string" }, { "type": "null" }],
+ "title": "Tally Error"
+ },
+ "created_at": {
+ "type": "string",
+ "format": "date-time",
+ "title": "Created At"
+ },
+ "updated_at": {
+ "type": "string",
+ "format": "date-time",
+ "title": "Updated At"
+ }
+ },
+ "type": "object",
+ "required": [
+ "id",
+ "email",
+ "status",
+ "tally_status",
+ "created_at",
+ "updated_at"
+ ],
+ "title": "InvitedUserResponse"
+ },
+ "InvitedUserStatus": {
+ "type": "string",
+ "enum": ["INVITED", "CLAIMED", "REVOKED"],
+ "title": "InvitedUserStatus"
+ },
+ "InvitedUsersResponse": {
+ "properties": {
+ "invited_users": {
+ "items": { "$ref": "#/components/schemas/InvitedUserResponse" },
+ "type": "array",
+ "title": "Invited Users"
+ },
+ "pagination": { "$ref": "#/components/schemas/Pagination" }
+ },
+ "type": "object",
+ "required": ["invited_users", "pagination"],
+ "title": "InvitedUsersResponse"
+ },
"LibraryAgent": {
"properties": {
"id": { "type": "string", "title": "Id" },
@@ -12683,6 +13035,11 @@
"required": ["recent_searches", "providers", "top_blocks"],
"title": "SuggestionsResponse"
},
+ "TallyComputationStatus": {
+ "type": "string",
+ "enum": ["PENDING", "RUNNING", "READY", "FAILED"],
+ "title": "TallyComputationStatus"
+ },
"TimezoneResponse": {
"properties": {
"timezone": {