Skip to content

🙌 OpenHands: AI-Driven Development

feat: enforce conversation limits (#14168)

HeyItsChloeea2d95bf5308
diff --git a/enterprise/integrations/bitbucket/bitbucket_manager.py b/enterprise/integrations/bitbucket/bitbucket_manager.py
index 479c7ed98b..aaf24b04fe 100644
--- a/enterprise/integrations/bitbucket/bitbucket_manager.py
+++ b/enterprise/integrations/bitbucket/bitbucket_manager.py
@@ -23,6 +23,7 @@ from pydantic import SecretStr
from server.auth.token_manager import TokenManager
from storage.bitbucket_webhook_store import BitbucketWebhookStore
+from openhands.app_server.errors import ConcurrencyLimitError
from openhands.app_server.integrations.provider import ProviderToken, ProviderType
from openhands.app_server.secrets.secrets_models import Secrets
from openhands.app_server.types import (
@@ -254,6 +255,19 @@ class BitbucketManager(Manager[BitbucketViewType]):
)
msg_info = get_session_expired_message(user_info.username)
+ except ConcurrencyLimitError as e:
+ detail = e.detail if isinstance(e.detail, dict) else {}
+ limit = detail.get('limit', '?')
+ logger.warning(
+ f'[Bitbucket] Concurrency limit reached for user {user_info.username}',
+ extra={'limit': limit, 'current': detail.get('current')},
+ )
+ msg_info = (
+ f'@{user_info.username} You have reached your limit of {limit} '
+ 'concurrent conversation(s). Please close an existing conversation '
+ f'to start a new one: {HOST_URL}'
+ )
+
await self.send_message(msg_info, bitbucket_view)
except Exception as e:
diff --git a/enterprise/integrations/bitbucket_data_center/bitbucket_dc_manager.py b/enterprise/integrations/bitbucket_data_center/bitbucket_dc_manager.py
index 584772d542..3dcbf7250a 100644
--- a/enterprise/integrations/bitbucket_data_center/bitbucket_dc_manager.py
+++ b/enterprise/integrations/bitbucket_data_center/bitbucket_dc_manager.py
@@ -26,6 +26,7 @@ from server.auth.constants import BITBUCKET_DATA_CENTER_BOT_TOKEN
from server.auth.token_manager import TokenManager
from storage.bitbucket_dc_webhook_store import BitbucketDCWebhookStore
+from openhands.app_server.errors import ConcurrencyLimitError
from openhands.app_server.integrations.provider import ProviderToken, ProviderType
from openhands.app_server.secrets.secrets_models import Secrets
from openhands.app_server.types import (
@@ -433,6 +434,19 @@ class BitbucketDCManager(Manager[BitbucketDCViewType]):
)
msg_info = get_session_expired_message(user_info.username)
+ except ConcurrencyLimitError as e:
+ detail = e.detail if isinstance(e.detail, dict) else {}
+ limit = detail.get('limit', '?')
+ logger.warning(
+ f'[Bitbucket DC] Concurrency limit reached for user {user_info.username}',
+ extra={'limit': limit, 'current': detail.get('current')},
+ )
+ msg_info = (
+ f'@{user_info.username} You have reached your limit of {limit} '
+ 'concurrent conversation(s). Please close an existing conversation '
+ f'to start a new one: {HOST_URL}'
+ )
+
await self.send_message(msg_info, bitbucket_view)
except Exception as e:
diff --git a/enterprise/integrations/github/github_manager.py b/enterprise/integrations/github/github_manager.py
index 9990766aab..c2bc530785 100644
--- a/enterprise/integrations/github/github_manager.py
+++ b/enterprise/integrations/github/github_manager.py
@@ -31,6 +31,7 @@ from server.auth.auth_error import ExpiredError
from server.auth.constants import GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEY
from server.auth.token_manager import TokenManager
+from openhands.app_server.errors import ConcurrencyLimitError
from openhands.app_server.integrations.provider import ProviderToken, ProviderType
from openhands.app_server.integrations.service_types import AuthenticationError
from openhands.app_server.secrets.secrets_models import Secrets
@@ -402,6 +403,19 @@ class GithubManager(Manager[GithubViewType]):
msg_info = get_session_expired_message(user_info.username)
+ except ConcurrencyLimitError as e:
+ detail = e.detail if isinstance(e.detail, dict) else {}
+ limit = detail.get('limit', '?')
+ logger.warning(
+ f'[GitHub] Concurrency limit reached for user {user_info.username}',
+ extra={'limit': limit, 'current': detail.get('current')},
+ )
+ msg_info = (
+ f'@{user_info.username} You have reached your limit of {limit} '
+ 'concurrent conversation(s). Please close an existing conversation '
+ f'to start a new one: {HOST_URL}'
+ )
+
await self.send_message(msg_info, github_view)
except Exception:
diff --git a/enterprise/integrations/gitlab/gitlab_manager.py b/enterprise/integrations/gitlab/gitlab_manager.py
index 0e515c8d34..4566940e34 100644
--- a/enterprise/integrations/gitlab/gitlab_manager.py
+++ b/enterprise/integrations/gitlab/gitlab_manager.py
@@ -25,6 +25,7 @@ from jinja2 import Environment, FileSystemLoader
from pydantic import SecretStr
from server.auth.token_manager import TokenManager
+from openhands.app_server.errors import ConcurrencyLimitError
from openhands.app_server.integrations.gitlab.gitlab_service import GitLabServiceImpl
from openhands.app_server.integrations.provider import ProviderToken, ProviderType
from openhands.app_server.secrets.secrets_models import Secrets
@@ -254,6 +255,19 @@ class GitlabManager(Manager[GitlabViewType]):
msg_info = get_session_expired_message(user_info.username)
+ except ConcurrencyLimitError as e:
+ detail = e.detail if isinstance(e.detail, dict) else {}
+ limit = detail.get('limit', '?')
+ logger.warning(
+ f'[GitLab] Concurrency limit reached for user {user_info.username}',
+ extra={'limit': limit, 'current': detail.get('current')},
+ )
+ msg_info = (
+ f'@{user_info.username} You have reached your limit of {limit} '
+ 'concurrent conversation(s). Please close an existing conversation '
+ f'to start a new one: {HOST_URL}'
+ )
+
# Send the acknowledgment message
await self.send_message(msg_info, gitlab_view)
diff --git a/enterprise/integrations/jira/jira_manager.py b/enterprise/integrations/jira/jira_manager.py
index 8aa5483dda..a50239389d 100644
--- a/enterprise/integrations/jira/jira_manager.py
+++ b/enterprise/integrations/jira/jira_manager.py
@@ -42,6 +42,7 @@ from storage.jira_integration_store import JiraIntegrationStore
from storage.jira_user import JiraUser
from storage.jira_workspace import JiraWorkspace
+from openhands.app_server.errors import ConcurrencyLimitError
from openhands.app_server.types import (
LLMAuthenticationError,
MissingSettingsError,
@@ -311,6 +312,22 @@ class JiraManager(Manager[JiraViewInterface]):
)
msg_info = str(e)
+ except ConcurrencyLimitError as e:
+ detail = e.detail if isinstance(e.detail, dict) else {}
+ limit = detail.get('limit', '?')
+ logger.warning(
+ '[Jira] Concurrency limit reached',
+ extra={
+ 'issue_key': view.payload.issue_key,
+ 'limit': limit,
+ 'current': detail.get('current'),
+ },
+ )
+ msg_info = (
+ f'You have reached your limit of {limit} concurrent conversation(s). '
+ f'Please close an existing conversation at {HOST_URL} to start a new one.'
+ )
+
except Exception as e:
logger.error(
'[Jira] Unexpected error starting job',
diff --git a/enterprise/integrations/jira_dc/jira_dc_manager.py b/enterprise/integrations/jira_dc/jira_dc_manager.py
index 3aa5e322dc..6fee31ce14 100644
--- a/enterprise/integrations/jira_dc/jira_dc_manager.py
+++ b/enterprise/integrations/jira_dc/jira_dc_manager.py
@@ -35,6 +35,7 @@ from storage.jira_dc_integration_store import JiraDcIntegrationStore
from storage.jira_dc_user import JiraDcUser
from storage.jira_dc_workspace import JiraDcWorkspace
+from openhands.app_server.errors import ConcurrencyLimitError
from openhands.app_server.integrations.provider import ProviderHandler
from openhands.app_server.integrations.service_types import Comment, Repository
from openhands.app_server.shared import server_config
@@ -508,6 +509,18 @@ class JiraDcManager(Manager[JiraDcViewInterface]):
logger.warning(f'[Jira DC] Session expired: {str(e)}')
msg_info = get_session_expired_message()
+ except ConcurrencyLimitError as e:
+ detail = e.detail if isinstance(e.detail, dict) else {}
+ limit = detail.get('limit', '?')
+ logger.warning(
+ '[Jira DC] Concurrency limit reached',
+ extra={'limit': limit, 'current': detail.get('current')},
+ )
+ msg_info = (
+ f'You have reached your limit of {limit} concurrent conversation(s). '
+ f'Please close an existing conversation at {HOST_URL} to start a new one.'
+ )
+
except Exception as e:
logger.error(
f'[Jira DC] Unexpected error starting job: {str(e)}', exc_info=True
diff --git a/enterprise/integrations/resolver_context.py b/enterprise/integrations/resolver_context.py
index 43f5a86430..c82ed20305 100644
--- a/enterprise/integrations/resolver_context.py
+++ b/enterprise/integrations/resolver_context.py
@@ -101,3 +101,6 @@ class ResolverUserContext(UserContext):
async def get_user_git_info(self) -> UserGitInfo | None:
return await self.saas_user_auth.get_user_git_info()
+
+ async def get_max_concurrent_sandboxes(self, default: int = 10) -> int:
+ return await self.saas_user_auth.get_max_concurrent_sandboxes(default)
diff --git a/enterprise/integrations/slack/slack_errors.py b/enterprise/integrations/slack/slack_errors.py
index fd336fc1c2..8ed2d34312 100644
--- a/enterprise/integrations/slack/slack_errors.py
+++ b/enterprise/integrations/slack/slack_errors.py
@@ -27,6 +27,7 @@ class SlackErrorCode(Enum):
LLM_AUTH_FAILED = 'SLACK_ERR_007'
MISSING_SETTINGS = 'SLACK_ERR_008'
MISSING_SLACK_SCOPES = 'SLACK_ERR_009'
+ CONCURRENCY_LIMIT = 'SLACK_ERR_010'
UNEXPECTED_ERROR = 'SLACK_ERR_999'
@@ -104,6 +105,10 @@ _USER_MESSAGES: dict[SlackErrorCode, str] = {
f'Please ask your workspace admin to re-install the OpenHands Slack App at {HOST_URL}/slack/install '
'to authorize the updated permissions.'
),
+ SlackErrorCode.CONCURRENCY_LIMIT: (
+ '🚦 {username} You have reached your limit of {limit} concurrent conversation(s). '
+ f'Please close an existing conversation at {HOST_URL} to start a new one.'
+ ),
SlackErrorCode.UNEXPECTED_ERROR: (
'Uh oh! There was an unexpected error (ref: {code}). Please try again later.'
),
diff --git a/enterprise/integrations/slack/slack_manager.py b/enterprise/integrations/slack/slack_manager.py
index f8fdec4d52..3ed5a0aa79 100644
--- a/enterprise/integrations/slack/slack_manager.py
+++ b/enterprise/integrations/slack/slack_manager.py
@@ -30,6 +30,7 @@ from storage.database import a_session_maker
from storage.redis import get_redis_client_async
from storage.slack_user import SlackUser
+from openhands.app_server.errors import ConcurrencyLimitError
from openhands.app_server.integrations.provider import ProviderHandler
from openhands.app_server.integrations.service_types import (
AuthenticationError,
@@ -738,6 +739,21 @@ class SlackManager(Manager[SlackViewInterface]):
msg_info = get_session_expired_message(user_info.slack_display_name)
+ except ConcurrencyLimitError as e:
+ detail = e.detail if isinstance(e.detail, dict) else {}
+ limit = detail.get('limit', '?')
+ logger.warning(
+ f'[Slack] Concurrency limit reached for user {user_info.slack_display_name}',
+ extra={'limit': limit, 'current': detail.get('current')},
+ )
+ msg_info = SlackError(
+ SlackErrorCode.CONCURRENCY_LIMIT,
+ message_kwargs={
+ 'username': user_info.slack_display_name,
+ 'limit': limit,
+ },
+ ).get_user_message()
+
except StartingConvoException as e:
msg_info = str(e)
diff --git a/enterprise/migrations/versions/120_add_max_concurrent_sandboxes.py b/enterprise/migrations/versions/120_add_max_concurrent_sandboxes.py
new file mode 100644
index 0000000000..bacd32e203
--- /dev/null
+++ b/enterprise/migrations/versions/120_add_max_concurrent_sandboxes.py
@@ -0,0 +1,64 @@
+"""Add max_concurrent_sandboxes to org and org_member tables.
+
+Adds per-org default and per-user override for concurrent sandbox limits.
+- org.max_concurrent_sandboxes: org-wide default
+ - Personal orgs (org.id == user.id): default 3 (set at user creation time)
+ - Commercial orgs: default 10 (set at org creation time, server_default used for existing)
+- org_member.max_concurrent_sandboxes_override: per-user override (NULL = use org default)
+
+Note: Hardcoded values (3, 10) are intentional in migrations - they represent the
+state at migration time and should not change if constants are updated later.
+See server.constants for current values: DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES,
+DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES.
+
+Revision ID: 120
+Revises: 119
+Create Date: 2026-04-29
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = '120'
+down_revision: Union[str, None] = '119'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ # Add max_concurrent_sandboxes to org table with default of 10 for commercial orgs
+ # Personal orgs get limit of 3 set explicitly at user creation time
+ op.add_column(
+ 'org',
+ sa.Column(
+ 'max_concurrent_sandboxes',
+ sa.Integer(),
+ nullable=False,
+ server_default='10',
+ ),
+ )
+
+ # Add max_concurrent_sandboxes_override to org_member table (NULL = use org default)
+ op.add_column(
+ 'org_member',
+ sa.Column(
+ 'max_concurrent_sandboxes_override',
+ sa.Integer(),
+ nullable=True,
+ ),
+ )
+
+ # Set personal orgs (where org.id exists in user table) to have a limit of 3
+ op.execute("""
+ UPDATE org
+ SET max_concurrent_sandboxes = 3
+ WHERE id IN (SELECT id FROM "user")
+ """)
+
+
+def downgrade() -> None:
+ op.drop_column('org_member', 'max_concurrent_sandboxes_override')
+ op.drop_column('org', 'max_concurrent_sandboxes')
diff --git a/enterprise/server/auth/authorization.py b/enterprise/server/auth/authorization.py
index 196b836906..06c7a87f9c 100644
--- a/enterprise/server/auth/authorization.py
+++ b/enterprise/server/auth/authorization.py
@@ -40,7 +40,7 @@ from storage.org_member_store import OrgMemberStore
from storage.role import Role
from storage.role_store import RoleStore
-from openhands.app_server.user_auth import get_user_auth, get_user_id
+from openhands.app_server.user_auth import get_user_id
from openhands.app_server.utils.logger import openhands_logger as logger
@@ -390,10 +390,9 @@ async def require_financial_data_access(
)
# Check if user has @openhands.dev email
- user_auth = await get_user_auth(request)
- user_email = await user_auth.get_user_email()
+ from server.email_validation import is_openhands_member
- if user_email and user_email.endswith('@openhands.dev'):
+ if await is_openhands_member(request):
logger.debug(
'Financial data access granted via @openhands.dev email',
extra={'user_id': user_id, 'org_id': str(org_id)},
@@ -432,3 +431,35 @@ async def require_financial_data_access(
extra={'user_id': user_id, 'org_id': str(org_id), 'role': user_role.name},
)
return user_id
+
+
+async def require_openhands_email_for_sandbox_limits(
+ request: Request,
+ has_sandbox_limit_field: bool,
+) -> None:
+ """Require @openhands.dev email when modifying sandbox concurrency limits.
+
+ This function should be called in route handlers when a request includes
+ fields that modify sandbox concurrency limits (max_concurrent_sandboxes or
+ max_concurrent_sandboxes_override).
+
+ Args:
+ request: FastAPI request object
+ has_sandbox_limit_field: Whether the request includes a sandbox limit field
+
+ Raises:
+ HTTPException: 403 if field is present and user doesn't have @openhands.dev email
+ """
+ from server.email_validation import is_openhands_member
+
+ if not has_sandbox_limit_field:
+ return
+
+ if not await is_openhands_member(request):
+ logger.warning(
+ 'Non-OpenHands user attempted to modify sandbox limits',
+ )
+ raise HTTPException(
+ status_code=status.HTTP_403_FORBIDDEN,
+ detail='Only OpenHands team members can modify concurrency limits',
+ )
diff --git a/enterprise/server/auth/saas_user_auth.py b/enterprise/server/auth/saas_user_auth.py
index a356e56f02..1878810453 100644
--- a/enterprise/server/auth/saas_user_auth.py
+++ b/enterprise/server/auth/saas_user_auth.py
@@ -580,6 +580,45 @@ class SaasUserAuth(UserAuth):
logger.error(f'Error fetching org info for user {self.user_id}: {e}')
return None
+ async def get_max_concurrent_sandboxes(self, default: int = 10) -> int:
+ """Get the user's maximum concurrent sandboxes limit.
+
+ Resolution order:
+ 1. OrgMember.max_concurrent_sandboxes_override (if not NULL)
+ 2. Org.max_concurrent_sandboxes (org default)
+ 3. The provided default value
+
+ Args:
+ default: The fallback limit if no user/org-specific limit is set.
+
+ Returns:
+ The effective maximum number of concurrent sandboxes allowed.
+ """
+ from storage.org_member_store import OrgMemberStore
+
+ try:
+ # Get user to find their current org
+ user = await UserStore.get_user_by_id(self.user_id)
+ if not user or not user.current_org_id:
+ return default
+
+ org_id = user.current_org_id
+
+ # Check for user-specific override in OrgMember
+ org_member = await OrgMemberStore.get_org_member(org_id, UUID(self.user_id))
+ if org_member and org_member.max_concurrent_sandboxes_override is not None:
+ return org_member.max_concurrent_sandboxes_override
+
+ # Fall back to org default
+ org = await OrgStore.get_org_by_id(org_id)
+ if org and org.max_concurrent_sandboxes is not None:
+ return org.max_concurrent_sandboxes
+
+ except Exception as e:
+ logger.warning(f'Failed to get user sandbox limit: {e}')
+
+ return default
+
@classmethod
async def get_instance(cls, request: Request) -> UserAuth:
logger.debug('saas_user_auth_get_instance')
diff --git a/enterprise/server/constants.py b/enterprise/server/constants.py
index fdcc44ca76..1aeeea375d 100644
--- a/enterprise/server/constants.py
+++ b/enterprise/server/constants.py
@@ -51,6 +51,12 @@ ROLE_OWNER = 'owner'
ROLE_ADMIN = 'admin'
ROLE_MEMBER = 'member'
+# Concurrent sandbox limits
+# Personal orgs (org.id == user.id) get a lower limit
+DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES = 3
+# Commercial orgs get a higher limit
+DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES = 10
+
# Deprecated - billing margins are now handled internally in litellm
DEFAULT_BILLING_MARGIN = float(os.environ.get('DEFAULT_BILLING_MARGIN', '1.0'))
diff --git a/enterprise/server/email_validation.py b/enterprise/server/email_validation.py
index 37627d32bf..93541786cc 100644
--- a/enterprise/server/email_validation.py
+++ b/enterprise/server/email_validation.py
@@ -7,6 +7,26 @@ from fastapi import Depends, HTTPException, Request, status
from openhands.app_server.user_auth import get_user_auth, get_user_id
from openhands.app_server.utils.logger import openhands_logger as logger
+# Email domain for OpenHands team members
+OPENHANDS_EMAIL_DOMAIN = '@openhands.dev'
+
+
+async def is_openhands_member(request: Request) -> bool:
+ """Check if the current user has an @openhands.dev email.
+
+ This is a generic helper function that can be used anywhere in the codebase
+ to check if the current user is an OpenHands team member.
+
+ Args:
+ request: FastAPI request object
+
+ Returns:
+ bool: True if user has @openhands.dev email, False otherwise
+ """
+ user_auth = await get_user_auth(request)
+ email = await user_auth.get_user_email()
+ return email is not None and email.endswith(OPENHANDS_EMAIL_DOMAIN)
+
async def get_admin_user_id(
request: Request, user_id: str | None = Depends(get_user_id)
@@ -55,7 +75,7 @@ async def get_admin_user_id(
detail='User email not available',
)
- if not user_email.endswith('@openhands.dev'):
+ if not user_email.endswith(OPENHANDS_EMAIL_DOMAIN):
logger.warning(
'Access denied - invalid email domain',
extra={'user_id': user_id, 'email_domain': user_email.split('@')[-1]},
diff --git a/enterprise/server/routes/org_models.py b/enterprise/server/routes/org_models.py
index 7632602d07..79bd8a762f 100644
--- a/enterprise/server/routes/org_models.py
+++ b/enterprise/server/routes/org_models.py
@@ -9,7 +9,11 @@ from pydantic import (
field_validator,
model_validator,
)
-from server.constants import LITE_LLM_API_URL
+from server.constants import (
+ DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES,
+ DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES,
+ LITE_LLM_API_URL,
+)
from storage.org import Org
from storage.org_member import OrgMember
from storage.role import Role
@@ -183,6 +187,7 @@ class OrgResponse(BaseModel):
v1_enabled: bool | None = None
credits: float | None = None
is_personal: bool = False
+ max_concurrent_sandboxes: int = DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
@classmethod
def from_org(
@@ -213,6 +218,13 @@ class OrgResponse(BaseModel):
v1_enabled=org.v1_enabled,
credits=credits,
is_personal=str(org.id) == user_id if user_id else False,
+ max_concurrent_sandboxes=org.max_concurrent_sandboxes
+ if org.max_concurrent_sandboxes is not None
+ else (
+ DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
+ if str(org.id) == user_id
+ else DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES
+ ),
)
@@ -251,6 +263,7 @@ class OrgUpdate(BaseModel):
llm_api_key: str | None = None
agent_settings_diff: dict[str, Any] | None = None
conversation_settings_diff: dict[str, Any] | None = None
+ max_concurrent_sandboxes: int | None = Field(default=None, gt=0, le=100)
@model_validator(mode='after')
def _normalize_settings_diffs(self) -> 'OrgUpdate':
@@ -476,6 +489,8 @@ class OrgMemberResponse(BaseModel):
role: str
role_rank: int
status: str | None
+ max_concurrent_sandboxes_override: int | None = None
+ effective_max_concurrent_sandboxes: int = DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
class OrgMemberPage(BaseModel):
@@ -490,6 +505,7 @@ class OrgMemberUpdate(BaseModel):
"""Request model for updating an organization member."""
role: str | None = None # Role name: 'owner', 'admin', or 'member'
+ max_concurrent_sandboxes_override: int | None = Field(default=None, gt=0, le=100)
class MeResponse(BaseModel):
@@ -508,6 +524,8 @@ class MeResponse(BaseModel):
agent_settings_diff: dict[str, Any] = Field(default_factory=dict)
conversation_settings_diff: dict[str, Any] = Field(default_factory=dict)
status: str | None = None
+ max_concurrent_sandboxes_override: int | None = None
+ effective_max_concurrent_sandboxes: int = DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
@staticmethod
def _mask_key(secret: str | SecretStr | None) -> str:
@@ -527,8 +545,14 @@ class MeResponse(BaseModel):
member: OrgMember,
role: Role,
email: str,
+ org_max_concurrent_sandboxes: int = DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES,
) -> 'MeResponse':
"""Create a MeResponse from an OrgMember, Role, and user email."""
+ effective_limit = (
+ member.max_concurrent_sandboxes_override
+ if member.max_concurrent_sandboxes_override is not None
+ else org_max_concurrent_sandboxes
+ )
return cls(
org_id=str(member.org_id),
user_id=str(member.user_id),
@@ -539,6 +563,8 @@ class MeResponse(BaseModel):
agent_settings_diff=dict(member.agent_settings_diff or {}),
conversation_settings_diff=dict(member.conversation_settings_diff or {}),
status=member.status,
+ max_concurrent_sandboxes_override=member.max_concurrent_sandboxes_override,
+ effective_max_concurrent_sandboxes=effective_limit,
)
@@ -547,6 +573,7 @@ class OrgAppSettingsResponse(BaseModel):
enable_proactive_conversation_starters: bool = True
max_budget_per_task: float | None = None
+ max_concurrent_sandboxes: int = DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
@classmethod
def from_org(cls, org: Org) -> 'OrgAppSettingsResponse':
@@ -563,6 +590,9 @@ class OrgAppSettingsResponse(BaseModel):
if org.enable_proactive_conversation_starters is not None
else True,
max_budget_per_task=org.max_budget_per_task,
+ max_concurrent_sandboxes=org.max_concurrent_sandboxes
+ if org.max_concurrent_sandboxes is not None
+ else DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES,
)
@@ -571,6 +601,7 @@ class OrgAppSettingsUpdate(BaseModel):
enable_proactive_conversation_starters: bool | None = None
max_budget_per_task: float | None = None
+ max_concurrent_sandboxes: int | None = Field(default=None, gt=0, le=100)
@field_validator('max_budget_per_task')
@classmethod
diff --git a/enterprise/server/routes/orgs.py b/enterprise/server/routes/orgs.py
index a83abb4601..be57de4b43 100644
--- a/enterprise/server/routes/orgs.py
+++ b/enterprise/server/routes/orgs.py
@@ -1,10 +1,11 @@
from typing import Annotated
from uuid import UUID
-from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
from server.auth.authorization import (
Permission,
require_financial_data_access,
+ require_openhands_email_for_sandbox_limits,
require_permission,
)
from server.auth.org_context import EFFECTIVE_ORG_ID, REJECT_X_ORG_ID_PATH_MISMATCH
@@ -438,6 +439,7 @@ async def get_org_app_settings(
dependencies=[Depends(require_permission(Permission.MANAGE_APPLICATION_SETTINGS))],
)
async def update_org_app_settings(
+ request: Request,
update_data: OrgAppSettingsUpdate,
service: OrgAppSettingsService = org_app_settings_service_dependency,
) -> OrgAppSettingsResponse:
@@ -448,6 +450,7 @@ async def update_org_app_settings(
which is granted to all organization members (member, admin, and owner roles).
Args:
+ request: FastAPI request object
update_data: App settings update data
service: OrgAppSettingsService (injected by dependency)
@@ -456,11 +459,17 @@ async def update_org_app_settings(
Raises:
HTTPException: 401 if user is not authenticated
- HTTPException: 403 if user lacks MANAGE_APPLICATION_SETTINGS permission
+ HTTPException: 403 if user lacks MANAGE_APPLICATION_SETTINGS permission or
+ attempts to modify sandbox limits without @openhands.dev email
HTTPException: 404 if current organization not found
HTTPException: 422 if validation errors occur (handled by FastAPI)
HTTPException: 500 if update fails
"""
+ # Restrict sandbox limit changes to @openhands.dev users
+ await require_openhands_email_for_sandbox_limits(
+ request, update_data.max_concurrent_sandboxes is not None
+ )
+
try:
return await service.update_org_app_settings(update_data)
except OrgNotFoundError:
@@ -700,6 +709,7 @@ async def delete_org(
response_model=OrgResponse,
)
async def update_org(
+ request: Request,
org_id: UUID,
update_data: OrgUpdate,
user_id: str = Depends(require_permission(Permission.EDIT_ORG_SETTINGS)),
@@ -710,6 +720,7 @@ async def update_org(
permission, which is granted to admin and owner roles.
Args:
+ request: FastAPI request object
org_id: Organization ID to update (UUID)
update_data: Organization update data
user_id: Authenticated user ID (injected by require_permission dependency)
@@ -719,12 +730,18 @@ async def update_org(
Raises:
HTTPException: 401 if user is not authenticated
- HTTPException: 403 if user lacks EDIT_ORG_SETTINGS permission
+ HTTPException: 403 if user lacks EDIT_ORG_SETTINGS permission or attempts
+ to modify sandbox limits without @openhands.dev email
HTTPException: 404 if organization not found
HTTPException: 409 if organization name already exists
HTTPException: 422 if validation errors occur (handled by FastAPI)
HTTPException: 500 if update fails
"""
+ # Restrict sandbox limit changes to @openhands.dev users
+ await require_openhands_email_for_sandbox_limits(
+ request, update_data.max_concurrent_sandboxes is not None
+ )
+
logger.info(
'Updating organization',
extra={
@@ -1228,6 +1245,7 @@ async def switch_org(
response_model=OrgMemberResponse,
)
async def update_org_member(
+ request: Request,
org_id: UUID,
user_id: str,
update_data: OrgMemberUpdate,
@@ -1242,7 +1260,14 @@ async def update_org_member(
- Owners cannot modify other Owners
Members cannot modify their own role. The last owner cannot be demoted.
+
+ Sandbox limit overrides can only be modified by users with @openhands.dev email.
"""
+ # Restrict sandbox limit changes to @openhands.dev users
+ await require_openhands_email_for_sandbox_limits(
+ request, update_data.max_concurrent_sandboxes_override is not None
+ )
+
try:
return await OrgMemberService.update_org_member(
org_id=org_id,
diff --git a/enterprise/server/services/org_member_service.py b/enterprise/server/services/org_member_service.py
index cb5383720d..1151634641 100644
--- a/enterprise/server/services/org_member_service.py
+++ b/enterprise/server/services/org_member_service.py
@@ -2,7 +2,11 @@
from uuid import UUID
-from server.constants import ROLE_ADMIN, ROLE_OWNER
+from server.constants import (
+ DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES,
+ ROLE_ADMIN,
+ ROLE_OWNER,
+)
from server.routes.org_models import (
CannotModifySelfError,
InsufficientPermissionError,
@@ -18,6 +22,7 @@ from server.routes.org_models import (
)
from storage.lite_llm_manager import LiteLlmManager
from storage.org_member_store import OrgMemberStore
+from storage.org_store import OrgStore
from storage.role_store import RoleStore
from storage.user_store import UserStore
@@ -59,7 +64,17 @@ class OrgMemberService:
user = await UserStore.get_user_by_id(str(user_id))
email = user.email if user and user.email else ''
- return MeResponse.from_org_member(org_member, role, email)
+ # Get org's max_concurrent_sandboxes for effective limit calculation
+ org = await OrgStore.get_org_by_id(org_id)
+ org_max_concurrent_sandboxes = (
+ org.max_concurrent_sandboxes
+ if org and org.max_concurrent_sandboxes
+ else DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
+ )
+
+ return MeResponse.from_org_member(
+ org_member, role, email, org_max_concurrent_sandboxes
+ )
@staticmethod
async def get_org_members(
@@ -98,6 +113,14 @@ class OrgMemberService:
except ValueError:
return False, 'invalid_page_id', None
+ # Get org's max_concurrent_sandboxes for effective limit calculation
+ org = await OrgStore.get_org_by_id(org_id)
+ org_max_concurrent_sandboxes = (
+ org.max_concurrent_sandboxes
+ if org and org.max_concurrent_sandboxes
+ else DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
+ )
+
# Call store to get paginated members
members, _ = await OrgMemberStore.get_org_members_paginated(
org_id=org_id,
@@ -113,6 +136,13 @@ class OrgMemberService:
user = member.user
role = member.role
+ # Calculate effective limit: user override > org default
+ effective_limit = (
+ member.max_concurrent_sandboxes_override
+ if member.max_concurrent_sandboxes_override is not None
+ else org_max_concurrent_sandboxes
+ )
+
items.append(
OrgMemberResponse(
user_id=str(member.user_id),
@@ -121,6 +151,8 @@ class OrgMemberService:
role=role.name if role else '',
role_rank=role.rank if role else 0,
status=member.status,
+ max_concurrent_sandboxes_override=member.max_concurrent_sandboxes_override,
+ effective_max_concurrent_sandboxes=effective_limit,
)
)
@@ -254,7 +286,7 @@ class OrgMemberService:
current_user_id: UUID,
update_data: OrgMemberUpdate,
) -> OrgMemberResponse:
- """Update a member's role in an organization.
+ """Update a member's role or settings in an organization.
Permission rules:
- Owners can modify anyone (including other owners), can set any role
@@ -288,8 +320,8 @@ class OrgMemberService:
if not requester_membership:
raise OrgMemberNotFoundError(str(org_id), str(current_user_id))
- # Check if trying to modify self
- if str(current_user_id) == str(target_user_id):
+ # Check if trying to modify self (only for role changes)
+ if str(current_user_id) == str(target_user_id) and new_role_name is not None:
raise CannotModifySelfError('modify')
# Get target user's membership
@@ -306,56 +338,88 @@ class OrgMemberService:
if not target_role:
raise RoleNotFoundError(target_membership.role_id)
- # If no role change requested, return current state
- if new_role_name is None:
- user = await UserStore.get_user_by_id(str(target_user_id))
- return OrgMemberResponse(
- user_id=str(target_membership.user_id),
- email=user.email if user else None,
- role_id=target_membership.role_id,
- role=target_role.name,
- role_rank=target_role.rank,
- status=target_membership.status,
- )
+ # Get org for effective limit calculation
+ org = await OrgStore.get_org_by_id(org_id)
+ org_max_concurrent_sandboxes = (
+ org.max_concurrent_sandboxes
+ if org and org.max_concurrent_sandboxes
+ else DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
+ )
- # Validate new role exists
- new_role = await RoleStore.get_role_by_name(new_role_name.lower())
- if not new_role:
- raise InvalidRoleError(new_role_name)
+ # Track if any updates were made
+ updated = False
+ final_role = target_role
+
+ # Handle role update if requested
+ if new_role_name is not None:
+ # Validate new role exists
+ new_role = await RoleStore.get_role_by_name(new_role_name.lower())
+ if not new_role:
+ raise InvalidRoleError(new_role_name)
+
+ # Check permission to modify target
+ if not OrgMemberService._can_update_member_role(
+ requester_role.name, target_role.name, new_role.name
+ ):
+ raise InsufficientPermissionError(
+ 'You do not have permission to modify this member'
+ )
- # Check permission to modify target
- if not OrgMemberService._can_update_member_role(
- requester_role.name, target_role.name, new_role.name
- ):
- raise InsufficientPermissionError(
- 'You do not have permission to modify this member'
+ # Check if demoting the last owner
+ if (
+ target_role.name == ROLE_OWNER
+ and new_role.name != ROLE_OWNER
+ and await OrgMemberService._is_last_owner(org_id, target_user_id)
+ ):
+ raise LastOwnerError('demote')
+
+ # Perform the role update
+ updated_member = await OrgMemberStore.update_user_role_in_org(
+ org_id, target_user_id, new_role.id
)
+ if not updated_member:
+ raise MemberUpdateError('Failed to update member')
+ target_membership = updated_member
+ final_role = new_role
+ updated = True
+
+ # Handle max_concurrent_sandboxes_override update if requested
+ # Only owners/admins can modify this field
+ if update_data.max_concurrent_sandboxes_override is not None:
+ # Check permission (must be owner or admin)
+ if requester_role.name not in [ROLE_OWNER, ROLE_ADMIN]:
+ raise InsufficientPermissionError(
+ 'Only owners and admins can modify sandbox limits'
+ )
+ target_membership.max_concurrent_sandboxes_override = (
+ update_data.max_concurrent_sandboxes_override
+ )
+ await OrgMemberStore.update_org_member(target_membership)
+ updated = True
- # Check if demoting the last owner
- if (
- target_role.name == ROLE_OWNER
- and new_role.name != ROLE_OWNER
- and await OrgMemberService._is_last_owner(org_id, target_user_id)
- ):
- raise LastOwnerError('demote')
-
- # Perform the update
- updated_member = await OrgMemberStore.update_user_role_in_org(
- org_id, target_user_id, new_role.id
- )
- if not updated_member:
- raise MemberUpdateError('Failed to update member')
+ if not updated:
+ # No updates requested, return current state
+ pass
# Get user email for response
user = await UserStore.get_user_by_id(str(target_user_id))
+ # Calculate effective limit
+ effective_limit = (
+ target_membership.max_concurrent_sandboxes_override
+ if target_membership.max_concurrent_sandboxes_override is not None
+ else org_max_concurrent_sandboxes
+ )
+
return OrgMemberResponse(
- user_id=str(updated_member.user_id),
+ user_id=str(target_membership.user_id),
email=user.email if user else None,
- role_id=updated_member.role_id,
- role=new_role.name,
- role_rank=new_role.rank,
- status=updated_member.status,
+ role_id=target_membership.role_id,
+ role=final_role.name,
+ role_rank=final_role.rank,
+ status=target_membership.status,
+ max_concurrent_sandboxes_override=target_membership.max_concurrent_sandboxes_override,
+ effective_max_concurrent_sandboxes=effective_limit,
)
@staticmethod
diff --git a/enterprise/storage/org.py b/enterprise/storage/org.py
index 4ebbdc68e5..c3b68366c0 100644
--- a/enterprise/storage/org.py
+++ b/enterprise/storage/org.py
@@ -1,12 +1,13 @@
-"""
-SQLAlchemy model for Organization.
-"""
+"""SQLAlchemy model for Organization."""
from typing import TYPE_CHECKING, Any
from uuid import UUID, uuid4
from pydantic import SecretStr
-from server.constants import DEFAULT_BILLING_MARGIN
+from server.constants import (
+ DEFAULT_BILLING_MARGIN,
+ DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES,
+)
from sqlalchemy import JSON, String
from sqlalchemy.orm import Mapped, mapped_column, relationship
from storage.base import Base
@@ -68,6 +69,9 @@ class Org(Base):
# Set by completed billing sessions or when positive org credits are detected.
byor_export_enabled: Mapped[bool] = mapped_column(nullable=False, default=False)
sandbox_grouping_strategy: Mapped[str | None] = mapped_column(String, nullable=True)
+ max_concurrent_sandboxes: Mapped[int] = mapped_column(
+ nullable=False, default=DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES
+ )
# Encrypted column for LLM profiles (contains API keys)
llm_profiles: Mapped[dict[str, Any] | None] = mapped_column(
EncryptedJSON, nullable=True
diff --git a/enterprise/storage/org_member.py b/enterprise/storage/org_member.py
index 581cd505fb..3a3daa682e 100644
--- a/enterprise/storage/org_member.py
+++ b/enterprise/storage/org_member.py
@@ -1,6 +1,4 @@
-"""
-SQLAlchemy model for Organization-Member relationship.
-"""
+"""SQLAlchemy model for Organization-Member relationship."""
from typing import TYPE_CHECKING, Any
from uuid import UUID
@@ -35,6 +33,7 @@ class OrgMember(Base):
JSON, nullable=False, default=dict
)
status: Mapped[str | None] = mapped_column(String, nullable=True)
+ max_concurrent_sandboxes_override: Mapped[int | None] = mapped_column(nullable=True)
# Relationships
org: Mapped['Org'] = relationship('Org', back_populates='org_members')
diff --git a/enterprise/storage/org_service.py b/enterprise/storage/org_service.py
index bf6466fac9..be82afe473 100644
--- a/enterprise/storage/org_service.py
+++ b/enterprise/storage/org_service.py
@@ -8,6 +8,7 @@ from uuid import UUID, uuid4
from uuid import UUID as parse_uuid
from server.constants import (
+ DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES,
ORG_SETTINGS_VERSION,
get_default_llm_base_url,
get_default_llm_model,
@@ -124,6 +125,7 @@ class OrgService:
org_version=ORG_SETTINGS_VERSION,
agent_settings=agent_settings,
conversation_settings=ConversationSettings(),
+ max_concurrent_sandboxes=DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES,
)
@staticmethod
diff --git a/enterprise/storage/user_store.py b/enterprise/storage/user_store.py
index e1ee4e0725..5f8b7cd719 100644
--- a/enterprise/storage/user_store.py
+++ b/enterprise/storage/user_store.py
@@ -7,6 +7,7 @@ from uuid import UUID
from server.auth.token_manager import TokenManager
from server.constants import (
+ DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES,
DEFAULT_V1_ENABLED,
LITE_LLM_API_URL,
ORG_SETTINGS_VERSION,
@@ -78,6 +79,7 @@ class UserStore:
or user_info.get('preferred_username', ''),
contact_email=user_info['email'],
v1_enabled=True,
+ max_concurrent_sandboxes=DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES,
)
session.add(org)
@@ -214,6 +216,7 @@ class UserStore:
or user_info.get('username', ''),
contact_email=user_info['email'],
byor_export_enabled=has_completed_billing,
+ max_concurrent_sandboxes=DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES,
)
session.add(org)
diff --git a/enterprise/tests/unit/server/routes/test_orgs.py b/enterprise/tests/unit/server/routes/test_orgs.py
index a356a8afe7..0e781a41f7 100644
--- a/enterprise/tests/unit/server/routes/test_orgs.py
+++ b/enterprise/tests/unit/server/routes/test_orgs.py
@@ -1588,6 +1588,10 @@ async def test_update_org_personal_workspace_preserved():
'server.routes.orgs.OrgService.get_org_credits',
AsyncMock(return_value=75.0),
),
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
async with httpx.AsyncClient(
transport=httpx.ASGITransport(app=app), base_url='http://test'
@@ -1649,6 +1653,10 @@ async def test_update_org_team_workspace_preserved():
'server.routes.orgs.OrgService.get_org_credits',
AsyncMock(return_value=150.0),
),
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
async with httpx.AsyncClient(
transport=httpx.ASGITransport(app=app), base_url='http://test'
@@ -1687,6 +1695,10 @@ async def test_update_org_not_found(mock_update_app, mock_owner_role):
side_effect=ValueError(f'Organization with ID {org_id} not found')
),
),
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
async with httpx.AsyncClient(
transport=httpx.ASGITransport(app=mock_update_app), base_url='http://test'
@@ -1758,6 +1770,10 @@ async def test_update_org_permission_denied_llm_settings(
)
),
),
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
async with httpx.AsyncClient(
transport=httpx.ASGITransport(app=mock_update_app), base_url='http://test'
@@ -1795,6 +1811,10 @@ async def test_update_org_duplicate_name_returns_409(mock_update_app, mock_owner
'server.routes.orgs.OrgService.update_org_with_permissions',
AsyncMock(side_effect=OrgNameExistsError('Existing Organization')),
),
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
async with httpx.AsyncClient(
transport=httpx.ASGITransport(app=mock_update_app), base_url='http://test'
@@ -1829,6 +1849,10 @@ async def test_update_org_database_error(mock_update_app, mock_owner_role):
'server.routes.orgs.OrgService.update_org_with_permissions',
AsyncMock(side_effect=OrgDatabaseError('Database connection failed')),
),
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
async with httpx.AsyncClient(
transport=httpx.ASGITransport(app=mock_update_app), base_url='http://test'
@@ -1863,6 +1887,10 @@ async def test_update_org_unexpected_error(mock_update_app, mock_owner_role):
'server.routes.orgs.OrgService.update_org_with_permissions',
AsyncMock(side_effect=RuntimeError('Unexpected system error')),
),
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
async with httpx.AsyncClient(
transport=httpx.ASGITransport(app=mock_update_app), base_url='http://test'
@@ -2633,9 +2661,14 @@ class TestRemoveOrgMemberEndpoint:
class TestUpdateOrgMemberEndpoint:
"""Test cases for PATCH /api/organizations/{org_id}/members/{user_id} endpoint."""
+ @pytest.fixture
+ def mock_request(self):
+ """Create a mock request object."""
+ return MagicMock(spec=Request)
+
@pytest.mark.asyncio
async def test_update_member_role_succeeds_returns_member_response(
- self, org_id, current_user_id, target_user_id
+ self, org_id, current_user_id, target_user_id, mock_request
):
"""GIVEN valid role update request WHEN PATCH is called THEN returns 200 with updated OrgMemberResponse."""
# Arrange
@@ -2647,13 +2680,20 @@ class TestUpdateOrgMemberEndpoint:
role_rank=20,
status='active',
)
- with patch(
- 'server.routes.orgs.OrgMemberService.update_org_member'
- ) as mock_update:
+ with (
+ patch(
+ 'server.routes.orgs.OrgMemberService.update_org_member'
+ ) as mock_update,
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ new_callable=AsyncMock,
+ ),
+ ):
mock_update.return_value = updated
# Act - endpoint now expects UUID type for org_id
result = await update_org_member(
+ request=mock_request,
org_id=uuid.UUID(org_id),
user_id=target_user_id,
update_data=OrgMemberUpdate(role='admin'),
@@ -2671,18 +2711,25 @@ class TestUpdateOrgMemberEndpoint:
@pytest.mark.asyncio
async def test_not_a_member_returns_403(
- self, org_id, current_user_id, target_user_id
+ self, org_id, current_user_id, target_user_id, mock_request
):
"""GIVEN requester is not a member WHEN PATCH is called THEN returns 403."""
# Arrange
- with patch(
- 'server.routes.orgs.OrgMemberService.update_org_member'
- ) as mock_update:
+ with (
+ patch(
+ 'server.routes.orgs.OrgMemberService.update_org_member'
+ ) as mock_update,
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ new_callable=AsyncMock,
+ ),
+ ):
mock_update.side_effect = OrgMemberNotFoundError(org_id, current_user_id)
# Act & Assert
with pytest.raises(HTTPException) as exc_info:
await update_org_member(
+ request=mock_request,
org_id=uuid.UUID(org_id),
user_id=target_user_id,
update_data=OrgMemberUpdate(role='user'),
@@ -2692,17 +2739,26 @@ class TestUpdateOrgMemberEndpoint:
assert 'not a member' in exc_info.value.detail
@pytest.mark.asyncio
- async def test_cannot_modify_self_returns_403(self, org_id, current_user_id):
+ async def test_cannot_modify_self_returns_403(
+ self, org_id, current_user_id, mock_request
+ ):
"""GIVEN target user is self WHEN PATCH is called THEN returns 403."""
# Arrange
- with patch(
- 'server.routes.orgs.OrgMemberService.update_org_member'
- ) as mock_update:
+ with (
+ patch(
+ 'server.routes.orgs.OrgMemberService.update_org_member'
+ ) as mock_update,
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ new_callable=AsyncMock,
+ ),
+ ):
mock_update.side_effect = CannotModifySelfError('modify')
# Act & Assert
with pytest.raises(HTTPException) as exc_info:
await update_org_member(
+ request=mock_request,
org_id=uuid.UUID(org_id),
user_id=current_user_id,
update_data=OrgMemberUpdate(role='admin'),
@@ -2713,18 +2769,25 @@ class TestUpdateOrgMemberEndpoint:
@pytest.mark.asyncio
async def test_member_not_found_returns_404(
- self, org_id, current_user_id, target_user_id
+ self, org_id, current_user_id, target_user_id, mock_request
):
"""GIVEN target member does not exist WHEN PATCH is called THEN returns 404."""
# Arrange
- with patch(
- 'server.routes.orgs.OrgMemberService.update_org_member'
- ) as mock_update:
+ with (
+ patch(
+ 'server.routes.orgs.OrgMemberService.update_org_member'
+ ) as mock_update,
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ new_callable=AsyncMock,
+ ),
+ ):
mock_update.side_effect = OrgMemberNotFoundError(org_id, target_user_id)
# Act & Assert
with pytest.raises(HTTPException) as exc_info:
await update_org_member(
+ request=mock_request,
org_id=uuid.UUID(org_id),
user_id=target_user_id,
update_data=OrgMemberUpdate(role='user'),
@@ -2735,18 +2798,25 @@ class TestUpdateOrgMemberEndpoint:
@pytest.mark.asyncio
async def test_invalid_role_returns_400(
- self, org_id, current_user_id, target_user_id
+ self, org_id, current_user_id, target_user_id, mock_request
):
"""GIVEN invalid role name WHEN PATCH is called THEN returns 400."""
# Arrange
- with patch(
- 'server.routes.orgs.OrgMemberService.update_org_member'
- ) as mock_update:
+ with (
+ patch(
+ 'server.routes.orgs.OrgMemberService.update_org_member'
+ ) as mock_update,
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ new_callable=AsyncMock,
+ ),
+ ):
mock_update.side_effect = InvalidRoleError('superuser')
# Act & Assert
with pytest.raises(HTTPException) as exc_info:
await update_org_member(
+ request=mock_request,
org_id=uuid.UUID(org_id),
user_id=target_user_id,
update_data=OrgMemberUpdate(role='superuser'),
@@ -2757,13 +2827,19 @@ class TestUpdateOrgMemberEndpoint:
@pytest.mark.asyncio
async def test_insufficient_permission_returns_403(
- self, org_id, current_user_id, target_user_id
+ self, org_id, current_user_id, target_user_id, mock_request
):
"""GIVEN requester lacks permission to change target WHEN PATCH is called THEN returns 403."""
# Arrange
- with patch(
- 'server.routes.orgs.OrgMemberService.update_org_member'
- ) as mock_update:
+ with (
+ patch(
+ 'server.routes.orgs.OrgMemberService.update_org_member'
+ ) as mock_update,
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ new_callable=AsyncMock,
+ ),
+ ):
mock_update.side_effect = InsufficientPermissionError(
'You do not have permission to modify this member'
)
@@ -2771,6 +2847,7 @@ class TestUpdateOrgMemberEndpoint:
# Act & Assert
with pytest.raises(HTTPException) as exc_info:
await update_org_member(
+ request=mock_request,
org_id=uuid.UUID(org_id),
user_id=target_user_id,
update_data=OrgMemberUpdate(role='admin'),
@@ -2781,18 +2858,25 @@ class TestUpdateOrgMemberEndpoint:
@pytest.mark.asyncio
async def test_cannot_demote_last_owner_returns_400(
- self, org_id, current_user_id, target_user_id
+ self, org_id, current_user_id, target_user_id, mock_request
):
"""GIVEN demoting last owner WHEN PATCH is called THEN returns 400."""
# Arrange
- with patch(
- 'server.routes.orgs.OrgMemberService.update_org_member'
- ) as mock_update:
+ with (
+ patch(
+ 'server.routes.orgs.OrgMemberService.update_org_member'
+ ) as mock_update,
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ new_callable=AsyncMock,
+ ),
+ ):
mock_update.side_effect = LastOwnerError('demote')
# Act & Assert
with pytest.raises(HTTPException) as exc_info:
await update_org_member(
+ request=mock_request,
org_id=uuid.UUID(org_id),
user_id=target_user_id,
update_data=OrgMemberUpdate(role='admin'),
@@ -2821,6 +2905,33 @@ class TestUpdateOrgMemberEndpoint:
)
assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+ @pytest.mark.asyncio
+ async def test_sandbox_limit_update_rejected_for_non_openhands_email(
+ self, org_id, current_user_id, target_user_id, mock_request
+ ):
+ """GIVEN [email protected] user updates sandbox limit WHEN PATCH is called THEN returns 403."""
+ # Arrange
+ with patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ new_callable=AsyncMock,
+ ) as mock_email_check:
+ mock_email_check.side_effect = HTTPException(
+ status_code=status.HTTP_403_FORBIDDEN,
+ detail='Only OpenHands team members can modify concurrency limits',
+ )
+
+ # Act & Assert
+ with pytest.raises(HTTPException) as exc_info:
+ await update_org_member(
+ request=mock_request,
+ org_id=uuid.UUID(org_id),
+ user_id=target_user_id,
+ update_data=OrgMemberUpdate(max_concurrent_sandboxes_override=10),
+ current_user_id=current_user_id,
+ )
+ assert exc_info.value.status_code == status.HTTP_403_FORBIDDEN
+ assert 'Only OpenHands team members' in exc_info.value.detail
+
class TestGetMeEndpoint:
"""Tests for GET /api/organizations/{org_id}/me endpoint.
@@ -3446,6 +3557,10 @@ async def test_update_org_app_settings_success(
'server.routes.orgs.OrgAppSettingsService.update_org_app_settings',
AsyncMock(return_value=mock_response),
) as mock_update,
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
client = TestClient(mock_app_with_get_user_id)
@@ -3490,6 +3605,10 @@ async def test_update_org_app_settings_partial_update(
'server.routes.orgs.OrgAppSettingsService.update_org_app_settings',
AsyncMock(return_value=mock_response),
) as mock_update,
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
client = TestClient(mock_app_with_get_user_id)
@@ -3532,6 +3651,10 @@ async def test_update_org_app_settings_set_null(
'server.routes.orgs.OrgAppSettingsService.update_org_app_settings',
AsyncMock(return_value=mock_response),
),
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
client = TestClient(mock_app_with_get_user_id)
@@ -3618,6 +3741,10 @@ async def test_update_org_app_settings_not_found(
'server.routes.orgs.OrgAppSettingsService.update_org_app_settings',
AsyncMock(side_effect=OrgNotFoundError('current')),
),
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
client = TestClient(mock_app_with_get_user_id)
@@ -3651,6 +3778,10 @@ async def test_update_org_app_settings_database_error(
'server.routes.orgs.OrgAppSettingsService.update_org_app_settings',
AsyncMock(side_effect=Exception('Database connection failed')),
),
+ patch(
+ 'server.routes.orgs.require_openhands_email_for_sandbox_limits',
+ AsyncMock(),
+ ),
):
client = TestClient(mock_app_with_get_user_id)
diff --git a/enterprise/tests/unit/server/services/test_org_member_service.py b/enterprise/tests/unit/server/services/test_org_member_service.py
index b0ad3ed383..1f073cb8bf 100644
--- a/enterprise/tests/unit/server/services/test_org_member_service.py
+++ b/enterprise/tests/unit/server/services/test_org_member_service.py
@@ -5,8 +5,10 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from pydantic import SecretStr
+from server.constants import DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
from server.routes.org_models import (
CannotModifySelfError,
+ InsufficientPermissionError,
InvalidRoleError,
LastOwnerError,
MeResponse,
@@ -109,6 +111,14 @@ def target_membership_admin(org_id, target_user_id, admin_role):
return membership
+def mock_org():
+ """Create a mock organization with default max_concurrent_sandboxes."""
+ org = MagicMock()
+ org.max_concurrent_sandboxes = DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
+ return org
+
+
class TestOrgMemberServiceGetOrgMembers:
"""Test cases for OrgMemberService.get_org_members."""
@@ -142,7 +152,12 @@ class TestOrgMemberServiceGetOrgMembers:
@pytest.mark.asyncio
async def test_get_members_succeeds_returns_paginated_data(
- self, org_id, current_user_id, mock_org_member, requester_membership_owner
+ self,
+ org_id,
+ current_user_id,
+ mock_org_member,
+ requester_membership_owner,
+ mock_org,
):
"""Test that successful retrieval returns paginated member data."""
# Arrange
@@ -157,9 +172,14 @@ class TestOrgMemberServiceGetOrgMembers:
'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
new_callable=AsyncMock,
) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = requester_membership_owner
mock_get_paginated.return_value = ([mock_org_member], False)
+ mock_get_org.return_value = mock_org
# Act
success, error_code, data = await OrgMemberService.get_org_members(
@@ -259,7 +279,12 @@ class TestOrgMemberServiceGetOrgMembers:
@pytest.mark.asyncio
async def test_first_page_pagination_no_page_id(
- self, org_id, current_user_id, mock_org_member, requester_membership_owner
+ self,
+ org_id,
+ current_user_id,
+ mock_org_member,
+ requester_membership_owner,
+ mock_org,
):
"""Test first page pagination when page_id is None."""
# Arrange
@@ -272,9 +297,14 @@ class TestOrgMemberServiceGetOrgMembers:
'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
new_callable=AsyncMock,
) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = requester_membership_owner
mock_get_paginated.return_value = ([mock_org_member], False)
+ mock_get_org.return_value = mock_org
# Act
success, error_code, data = await OrgMemberService.get_org_members(
@@ -294,7 +324,12 @@ class TestOrgMemberServiceGetOrgMembers:
@pytest.mark.asyncio
async def test_next_page_pagination_with_page_id(
- self, org_id, current_user_id, mock_org_member, requester_membership_owner
+ self,
+ org_id,
+ current_user_id,
+ mock_org_member,
+ requester_membership_owner,
+ mock_org,
):
"""Test next page pagination when page_id is provided."""
# Arrange
@@ -307,9 +342,14 @@ class TestOrgMemberServiceGetOrgMembers:
'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
new_callable=AsyncMock,
) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = requester_membership_owner
mock_get_paginated.return_value = ([mock_org_member], True)
+ mock_get_org.return_value = mock_org
# Act
success, error_code, data = await OrgMemberService.get_org_members(
@@ -329,7 +369,12 @@ class TestOrgMemberServiceGetOrgMembers:
@pytest.mark.asyncio
async def test_last_page_has_more_false(
- self, org_id, current_user_id, mock_org_member, requester_membership_owner
+ self,
+ org_id,
+ current_user_id,
+ mock_org_member,
+ requester_membership_owner,
+ mock_org,
):
"""Test last page when has_more is False."""
# Arrange
@@ -342,9 +387,14 @@ class TestOrgMemberServiceGetOrgMembers:
'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
new_callable=AsyncMock,
) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = requester_membership_owner
mock_get_paginated.return_value = ([mock_org_member], False)
+ mock_get_org.return_value = mock_org
# Act
success, error_code, data = await OrgMemberService.get_org_members(
@@ -361,7 +411,7 @@ class TestOrgMemberServiceGetOrgMembers:
@pytest.mark.asyncio
async def test_empty_organization_no_members(
- self, org_id, current_user_id, requester_membership_owner
+ self, org_id, current_user_id, requester_membership_owner, mock_org
):
"""Test empty organization with no members."""
# Arrange
@@ -374,9 +424,14 @@ class TestOrgMemberServiceGetOrgMembers:
'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
new_callable=AsyncMock,
) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = requester_membership_owner
mock_get_paginated.return_value = ([], False)
+ mock_get_org.return_value = mock_org
# Act
success, error_code, data = await OrgMemberService.get_org_members(
@@ -393,7 +448,7 @@ class TestOrgMemberServiceGetOrgMembers:
@pytest.mark.asyncio
async def test_missing_user_relationship_handles_gracefully(
- self, org_id, current_user_id, mock_role, requester_membership_owner
+ self, org_id, current_user_id, mock_role, requester_membership_owner, mock_org
):
"""Test that missing user relationship is handled gracefully."""
# Arrange
@@ -414,9 +469,14 @@ class TestOrgMemberServiceGetOrgMembers:
'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
new_callable=AsyncMock,
) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = requester_membership_owner
mock_get_paginated.return_value = ([member_no_user], False)
+ mock_get_org.return_value = mock_org
# Act
success, error_code, data = await OrgMemberService.get_org_members(
@@ -434,7 +494,7 @@ class TestOrgMemberServiceGetOrgMembers:
@pytest.mark.asyncio
async def test_missing_role_relationship_handles_gracefully(
- self, org_id, current_user_id, mock_user, requester_membership_owner
+ self, org_id, current_user_id, mock_user, requester_membership_owner, mock_org
):
"""Test that missing role relationship is handled gracefully."""
# Arrange
@@ -455,9 +515,14 @@ class TestOrgMemberServiceGetOrgMembers:
'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
new_callable=AsyncMock,
) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = requester_membership_owner
mock_get_paginated.return_value = ([member_no_role], False)
+ mock_get_org.return_value = mock_org
# Act
success, error_code, data = await OrgMemberService.get_org_members(
@@ -476,7 +541,13 @@ class TestOrgMemberServiceGetOrgMembers:
@pytest.mark.asyncio
async def test_multiple_members_returns_all(
- self, org_id, current_user_id, mock_user, mock_role, requester_membership_owner
+ self,
+ org_id,
+ current_user_id,
+ mock_user,
+ mock_role,
+ requester_membership_owner,
+ mock_org,
):
"""Test that multiple members are returned correctly."""
# Arrange
@@ -505,9 +576,14 @@ class TestOrgMemberServiceGetOrgMembers:
'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
new_callable=AsyncMock,
) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = requester_membership_owner
mock_get_paginated.return_value = ([member1, member2], False)
+ mock_get_org.return_value = mock_org
# Act
success, error_code, data = await OrgMemberService.get_org_members(
@@ -524,7 +600,12 @@ class TestOrgMemberServiceGetOrgMembers:
@pytest.mark.asyncio
async def test_email_filter_passed_to_store(
- self, org_id, current_user_id, mock_org_member, requester_membership_owner
+ self,
+ org_id,
+ current_user_id,
+ mock_org_member,
+ requester_membership_owner,
+ mock_org,
):
"""Test that email filter is passed to store methods."""
# Arrange
@@ -537,9 +618,14 @@ class TestOrgMemberServiceGetOrgMembers:
'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
new_callable=AsyncMock,
) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = requester_membership_owner
mock_get_paginated.return_value = ([mock_org_member], False)
+ mock_get_org.return_value = mock_org
# Act
await OrgMemberService.get_org_members(
@@ -557,7 +643,12 @@ class TestOrgMemberServiceGetOrgMembers:
@pytest.mark.asyncio
async def test_pagination_metadata_correct_for_page_2(
- self, org_id, current_user_id, mock_org_member, requester_membership_owner
+ self,
+ org_id,
+ current_user_id,
+ mock_org_member,
+ requester_membership_owner,
+ mock_org,
):
"""Test pagination metadata is correct for page 2."""
# Arrange
@@ -570,9 +661,14 @@ class TestOrgMemberServiceGetOrgMembers:
'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
new_callable=AsyncMock,
) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = requester_membership_owner
mock_get_paginated.return_value = ([mock_org_member], True)
+ mock_get_org.return_value = mock_org
# Act - Request page 2 (offset 10) with limit 10
success, error_code, data = await OrgMemberService.get_org_members(
@@ -1610,6 +1706,7 @@ class TestOrgMemberServiceUpdateOrgMember:
owner_role,
member_role,
admin_role,
+ mock_org,
):
"""GIVEN owner and target user WHEN owner sets target role to admin THEN update succeeds and returns OrgMemberResponse."""
# Arrange
@@ -1640,6 +1737,10 @@ class TestOrgMemberServiceUpdateOrgMember:
'server.services.org_member_service.UserStore.get_user_by_id',
new_callable=AsyncMock,
) as mock_get_user,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.side_effect = [
requester_membership_owner,
@@ -1649,6 +1750,7 @@ class TestOrgMemberServiceUpdateOrgMember:
mock_get_role_by_name.return_value = admin_role
mock_update.return_value = updated_member
mock_get_user.return_value = mock_user
+ mock_get_org.return_value = mock_org
# Act
data = await OrgMemberService.update_org_member(
@@ -1671,6 +1773,7 @@ class TestOrgMemberServiceUpdateOrgMember:
target_membership_user,
admin_role,
member_role,
+ mock_org,
):
"""GIVEN admin and target user WHEN admin sets target role to admin THEN update succeeds."""
# Arrange
@@ -1701,6 +1804,10 @@ class TestOrgMemberServiceUpdateOrgMember:
'server.services.org_member_service.UserStore.get_user_by_id',
new_callable=AsyncMock,
) as mock_get_user,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.side_effect = [
requester_membership_admin,
@@ -1710,6 +1817,7 @@ class TestOrgMemberServiceUpdateOrgMember:
mock_get_role_by_name.return_value = admin_role
mock_update.return_value = updated_member
mock_get_user.return_value = mock_user
+ mock_get_org.return_value = mock_org
# Act
data = await OrgMemberService.update_org_member(
@@ -1730,6 +1838,7 @@ class TestOrgMemberServiceUpdateOrgMember:
target_membership_admin,
admin_role,
member_role,
+ mock_org,
):
"""GIVEN admin and target admin WHEN admin changes target role to member THEN update succeeds."""
# Arrange
@@ -1760,6 +1869,10 @@ class TestOrgMemberServiceUpdateOrgMember:
'server.services.org_member_service.UserStore.get_user_by_id',
new_callable=AsyncMock,
) as mock_get_user,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.side_effect = [
requester_membership_admin,
@@ -1769,6 +1882,7 @@ class TestOrgMemberServiceUpdateOrgMember:
mock_get_role_by_name.return_value = member_role
mock_update.return_value = updated_member
mock_get_user.return_value = mock_user
+ mock_get_org.return_value = mock_org
# Act
data = await OrgMemberService.update_org_member(
@@ -1793,6 +1907,7 @@ class TestOrgMemberServiceUpdateOrgMember:
target_membership_owner,
owner_role,
admin_role,
+ mock_org,
):
"""GIVEN owner and target owner WHEN owner changes target role to admin THEN update succeeds."""
# Arrange
@@ -1823,6 +1938,10 @@ class TestOrgMemberServiceUpdateOrgMember:
'server.services.org_member_service.UserStore.get_user_by_id',
new_callable=AsyncMock,
) as mock_get_user,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
patch.object(
OrgMemberService,
'_is_last_owner',
@@ -1838,6 +1957,7 @@ class TestOrgMemberServiceUpdateOrgMember:
mock_get_role_by_name.return_value = admin_role
mock_update.return_value = updated_member
mock_get_user.return_value = mock_user
+ mock_get_org.return_value = mock_org
# Act
data = await OrgMemberService.update_org_member(
@@ -1930,6 +2050,7 @@ class TestOrgMemberServiceUpdateOrgMember:
target_membership_user,
owner_role,
member_role,
+ mock_org,
):
"""GIVEN unknown role name WHEN update_org_member THEN raises InvalidRoleError."""
# Arrange
@@ -1946,6 +2067,10 @@ class TestOrgMemberServiceUpdateOrgMember:
'server.services.org_member_service.RoleStore.get_role_by_name',
new_callable=AsyncMock,
) as mock_get_role_by_name,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.side_effect = [
requester_membership_owner,
@@ -1953,6 +2078,7 @@ class TestOrgMemberServiceUpdateOrgMember:
]
mock_get_role.side_effect = [owner_role, member_role]
mock_get_role_by_name.return_value = None
+ mock_get_org.return_value = mock_org
# Act & Assert
with pytest.raises(InvalidRoleError):
@@ -1973,6 +2099,7 @@ class TestOrgMemberServiceUpdateOrgMember:
target_membership_owner,
owner_role,
admin_role,
+ mock_org,
):
"""GIVEN last owner would be demoted WHEN update_org_member THEN raises LastOwnerError."""
# Arrange: patch _can_update_member_role so we reach the last-owner check (owner cannot normally modify owner)
@@ -1989,6 +2116,10 @@ class TestOrgMemberServiceUpdateOrgMember:
'server.services.org_member_service.RoleStore.get_role_by_name',
new_callable=AsyncMock,
) as mock_get_role_by_name,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
patch(
'server.services.org_member_service.OrgMemberService._can_update_member_role'
) as mock_can_update,
@@ -2003,6 +2134,7 @@ class TestOrgMemberServiceUpdateOrgMember:
]
mock_get_role.side_effect = [owner_role, owner_role]
mock_get_role_by_name.return_value = admin_role
+ mock_get_org.return_value = mock_org
mock_can_update.return_value = True
mock_is_last_owner.return_value = True
@@ -2025,6 +2157,7 @@ class TestOrgMemberServiceUpdateOrgMember:
target_membership_user,
owner_role,
member_role,
+ mock_org,
):
"""GIVEN update with no role WHEN update_org_member THEN returns current member without changing role."""
# Arrange
@@ -2044,6 +2177,10 @@ class TestOrgMemberServiceUpdateOrgMember:
'server.services.org_member_service.UserStore.get_user_by_id',
new_callable=AsyncMock,
) as mock_get_user,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.side_effect = [
requester_membership_owner,
@@ -2051,6 +2188,7 @@ class TestOrgMemberServiceUpdateOrgMember:
]
mock_get_role.side_effect = [owner_role, member_role]
mock_get_user.return_value = mock_user
+ mock_get_org.return_value = mock_org
# Act
data = await OrgMemberService.update_org_member(
@@ -2246,7 +2384,7 @@ class TestOrgMemberServiceGetMe:
@pytest.mark.asyncio
async def test_get_me_success_returns_me_response(
- self, org_id, current_user_id, mock_org_member, mock_user, owner_role
+ self, org_id, current_user_id, mock_org_member, mock_user, owner_role, mock_org
):
"""GIVEN: User is a member of the organization
WHEN: get_me is called
@@ -2266,10 +2404,15 @@ class TestOrgMemberServiceGetMe:
'server.services.org_member_service.UserStore.get_user_by_id',
new_callable=AsyncMock,
) as mock_get_user,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = mock_org_member
mock_get_role.return_value = owner_role
mock_get_user.return_value = mock_user
+ mock_get_org.return_value = mock_org
# Act
result = await OrgMemberService.get_me(org_id, current_user_id)
@@ -2333,7 +2476,7 @@ class TestOrgMemberServiceGetMe:
@pytest.mark.asyncio
async def test_get_me_user_not_found_returns_empty_email(
- self, org_id, current_user_id, mock_org_member, owner_role
+ self, org_id, current_user_id, mock_org_member, owner_role, mock_org
):
"""GIVEN: Member exists but user lookup returns None
WHEN: get_me is called
@@ -2353,13 +2496,417 @@ class TestOrgMemberServiceGetMe:
'server.services.org_member_service.UserStore.get_user_by_id',
new_callable=AsyncMock,
) as mock_get_user,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
):
mock_get_member.return_value = mock_org_member
mock_get_role.return_value = owner_role
mock_get_user.return_value = None
+ mock_get_org.return_value = mock_org
# Act
result = await OrgMemberService.get_me(org_id, current_user_id)
# Assert
assert result.email == ''
+
+
+class TestOrgMemberServiceConcurrencyLimits:
+ """Test cases for OrgMemberService concurrency limits functionality.
+
+ Tests the max_concurrent_sandboxes feature including:
+ - MeResponse including effective_max_concurrent_sandboxes
+ - OrgMemberResponse including effective_max_concurrent_sandboxes
+ - OrgMemberUpdate handling max_concurrent_sandboxes_override
+ - Limit resolution order: member override → org default → global fallback
+ """
+
+ @pytest.fixture
+ def mock_org(self, org_id):
+ """Create a mock organization with max_concurrent_sandboxes."""
+ from storage.org import Org
+
+ org = MagicMock(spec=Org)
+ org.id = org_id
+ org.max_concurrent_sandboxes = 5
+ return org
+
+ @pytest.fixture
+ def mock_org_member_with_override(self, org_id, current_user_id):
+ """Create a mock OrgMember with max_concurrent_sandboxes_override."""
+ member = MagicMock(spec=OrgMember)
+ member.org_id = org_id
+ member.user_id = current_user_id
+ member.role_id = 1
+ member.llm_api_key = SecretStr('sk-test-key-12345')
+ member.llm_api_key_for_byor = None
+ member.agent_settings_diff = {}
+ member.conversation_settings_diff = {}
+ member.status = 'active'
+ member.max_concurrent_sandboxes_override = 10
+ return member
+
+ @pytest.fixture
+ def mock_org_member_no_override(self, org_id, current_user_id):
+ """Create a mock OrgMember without max_concurrent_sandboxes_override."""
+ member = MagicMock(spec=OrgMember)
+ member.org_id = org_id
+ member.user_id = current_user_id
+ member.role_id = 1
+ member.llm_api_key = SecretStr('sk-test-key-12345')
+ member.llm_api_key_for_byor = None
+ member.agent_settings_diff = {}
+ member.conversation_settings_diff = {}
+ member.status = 'active'
+ member.max_concurrent_sandboxes_override = None
+ return member
+
+ @pytest.fixture
+ def mock_user(self, current_user_id):
+ """Create a mock User."""
+ user = MagicMock(spec=User)
+ user.id = current_user_id
+ user.email = '[email protected]'
+ return user
+
+ @pytest.mark.asyncio
+ async def test_get_me_with_member_override_returns_override_as_effective(
+ self,
+ org_id,
+ current_user_id,
+ mock_org_member_with_override,
+ mock_user,
+ mock_org,
+ owner_role,
+ ):
+ """GIVEN: Member has max_concurrent_sandboxes_override set
+ WHEN: get_me is called
+ THEN: effective_max_concurrent_sandboxes equals member override
+ """
+ with (
+ patch(
+ 'server.services.org_member_service.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_member,
+ patch(
+ 'server.services.org_member_service.RoleStore.get_role_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_role,
+ patch(
+ 'server.services.org_member_service.UserStore.get_user_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_user,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_get_member.return_value = mock_org_member_with_override
+ mock_get_role.return_value = owner_role
+ mock_get_user.return_value = mock_user
+ mock_get_org.return_value = mock_org
+
+ result = await OrgMemberService.get_me(org_id, current_user_id)
+
+ assert isinstance(result, MeResponse)
+ assert result.max_concurrent_sandboxes_override == 10
+ assert result.effective_max_concurrent_sandboxes == 10
+
+ @pytest.mark.asyncio
+ async def test_get_me_without_member_override_uses_org_default(
+ self,
+ org_id,
+ current_user_id,
+ mock_org_member_no_override,
+ mock_user,
+ mock_org,
+ owner_role,
+ ):
+ """GIVEN: Member has no max_concurrent_sandboxes_override
+ WHEN: get_me is called
+ THEN: effective_max_concurrent_sandboxes equals org default
+ """
+ with (
+ patch(
+ 'server.services.org_member_service.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_member,
+ patch(
+ 'server.services.org_member_service.RoleStore.get_role_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_role,
+ patch(
+ 'server.services.org_member_service.UserStore.get_user_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_user,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_get_member.return_value = mock_org_member_no_override
+ mock_get_role.return_value = owner_role
+ mock_get_user.return_value = mock_user
+ mock_get_org.return_value = mock_org
+
+ result = await OrgMemberService.get_me(org_id, current_user_id)
+
+ assert isinstance(result, MeResponse)
+ assert result.max_concurrent_sandboxes_override is None
+ assert result.effective_max_concurrent_sandboxes == 5 # org default
+
+ @pytest.mark.asyncio
+ async def test_get_me_without_org_uses_fallback(
+ self,
+ org_id,
+ current_user_id,
+ mock_org_member_no_override,
+ mock_user,
+ owner_role,
+ ):
+ """GIVEN: Org lookup returns None
+ WHEN: get_me is called
+ THEN: effective_max_concurrent_sandboxes uses fallback (3)
+ """
+ with (
+ patch(
+ 'server.services.org_member_service.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_member,
+ patch(
+ 'server.services.org_member_service.RoleStore.get_role_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_role,
+ patch(
+ 'server.services.org_member_service.UserStore.get_user_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_user,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_get_member.return_value = mock_org_member_no_override
+ mock_get_role.return_value = owner_role
+ mock_get_user.return_value = mock_user
+ mock_get_org.return_value = None
+
+ result = await OrgMemberService.get_me(org_id, current_user_id)
+
+ assert result.max_concurrent_sandboxes_override is None
+ # fallback to personal org default when org is None
+ assert (
+ result.effective_max_concurrent_sandboxes
+ == DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
+ )
+
+ @pytest.mark.asyncio
+ async def test_get_org_members_returns_effective_limits(
+ self,
+ org_id,
+ current_user_id,
+ target_user_id,
+ mock_org,
+ owner_role,
+ member_role,
+ ):
+ """GIVEN: Org with members having different override settings
+ WHEN: get_org_members is called
+ THEN: Each member has correct effective_max_concurrent_sandboxes
+ """
+ # Create mock members with different override settings
+ mock_member_with_override = MagicMock(spec=OrgMember)
+ mock_member_with_override.org_id = org_id
+ mock_member_with_override.user_id = target_user_id
+ mock_member_with_override.role_id = member_role.id
+ mock_member_with_override.status = 'active'
+ mock_member_with_override.max_concurrent_sandboxes_override = 15
+ mock_member_with_override.user = MagicMock()
+ mock_member_with_override.user.email = '[email protected]'
+ mock_member_with_override.role = member_role
+
+ mock_member_no_override = MagicMock(spec=OrgMember)
+ mock_member_no_override.org_id = org_id
+ mock_member_no_override.user_id = current_user_id
+ mock_member_no_override.role_id = owner_role.id
+ mock_member_no_override.status = 'active'
+ mock_member_no_override.max_concurrent_sandboxes_override = None
+ mock_member_no_override.user = MagicMock()
+ mock_member_no_override.user.email = '[email protected]'
+ mock_member_no_override.role = owner_role
+
+ with (
+ patch(
+ 'server.services.org_member_service.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_member,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ patch(
+ 'server.services.org_member_service.OrgMemberStore.get_org_members_paginated',
+ new_callable=AsyncMock,
+ ) as mock_get_paginated,
+ ):
+ mock_get_member.return_value = mock_member_no_override
+ mock_get_org.return_value = mock_org
+ mock_get_paginated.return_value = (
+ [mock_member_with_override, mock_member_no_override],
+ False,
+ )
+
+ success, error_code, data = await OrgMemberService.get_org_members(
+ org_id=org_id,
+ current_user_id=current_user_id,
+ page_id=None,
+ limit=10,
+ )
+
+ assert success is True
+ assert error_code is None
+ assert data is not None
+ assert len(data.items) == 2
+
+ # Member with override
+ member_with_override = data.items[0]
+ assert member_with_override.max_concurrent_sandboxes_override == 15
+ assert member_with_override.effective_max_concurrent_sandboxes == 15
+
+ # Member without override (uses org default)
+ member_no_override = data.items[1]
+ assert member_no_override.max_concurrent_sandboxes_override is None
+ assert member_no_override.effective_max_concurrent_sandboxes == 5
+
+ @pytest.mark.asyncio
+ async def test_update_org_member_owner_can_update_sandbox_override(
+ self,
+ org_id,
+ current_user_id,
+ target_user_id,
+ owner_role,
+ member_role,
+ mock_org,
+ ):
+ """GIVEN: Requester is owner
+ WHEN: update_org_member is called with max_concurrent_sandboxes_override
+ THEN: Override is updated successfully
+ """
+ requester_membership = MagicMock(spec=OrgMember)
+ requester_membership.org_id = org_id
+ requester_membership.user_id = current_user_id
+ requester_membership.role_id = owner_role.id
+
+ target_membership = MagicMock(spec=OrgMember)
+ target_membership.org_id = org_id
+ target_membership.user_id = target_user_id
+ target_membership.role_id = member_role.id
+ target_membership.status = 'active'
+ target_membership.max_concurrent_sandboxes_override = None
+
+ mock_user = MagicMock(spec=User)
+ mock_user.id = target_user_id
+ mock_user.email = '[email protected]'
+
+ update_data = OrgMemberUpdate(max_concurrent_sandboxes_override=20)
+
+ with (
+ patch(
+ 'server.services.org_member_service.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_member,
+ patch(
+ 'server.services.org_member_service.RoleStore.get_role_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_role,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ patch(
+ 'server.services.org_member_service.OrgMemberStore.update_org_member',
+ new_callable=AsyncMock,
+ ) as mock_update_member,
+ patch(
+ 'server.services.org_member_service.UserStore.get_user_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_user,
+ ):
+ mock_get_member.side_effect = [
+ requester_membership,
+ target_membership,
+ ]
+ mock_get_role.side_effect = [owner_role, member_role]
+ mock_get_org.return_value = mock_org
+ mock_get_user.return_value = mock_user
+
+ result = await OrgMemberService.update_org_member(
+ org_id=org_id,
+ target_user_id=target_user_id,
+ current_user_id=current_user_id,
+ update_data=update_data,
+ )
+
+ assert isinstance(result, OrgMemberResponse)
+ mock_update_member.assert_called_once()
+ assert target_membership.max_concurrent_sandboxes_override == 20
+
+ @pytest.mark.asyncio
+ async def test_update_org_member_member_cannot_update_sandbox_override(
+ self,
+ org_id,
+ current_user_id,
+ target_user_id,
+ member_role,
+ mock_org,
+ ):
+ """GIVEN: Requester is regular member
+ WHEN: update_org_member is called with max_concurrent_sandboxes_override
+ THEN: Raises InsufficientPermissionError
+ """
+ requester_membership = MagicMock(spec=OrgMember)
+ requester_membership.org_id = org_id
+ requester_membership.user_id = current_user_id
+ requester_membership.role_id = member_role.id
+
+ target_membership = MagicMock(spec=OrgMember)
+ target_membership.org_id = org_id
+ target_membership.user_id = target_user_id
+ target_membership.role_id = member_role.id
+ target_membership.status = 'active'
+ target_membership.max_concurrent_sandboxes_override = None
+
+ update_data = OrgMemberUpdate(max_concurrent_sandboxes_override=20)
+
+ with (
+ patch(
+ 'server.services.org_member_service.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_member,
+ patch(
+ 'server.services.org_member_service.RoleStore.get_role_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_role,
+ patch(
+ 'server.services.org_member_service.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_get_member.side_effect = [
+ requester_membership,
+ target_membership,
+ ]
+ mock_get_role.side_effect = [member_role, member_role]
+ mock_get_org.return_value = mock_org
+
+ with pytest.raises(InsufficientPermissionError) as exc_info:
+ await OrgMemberService.update_org_member(
+ org_id=org_id,
+ target_user_id=target_user_id,
+ current_user_id=current_user_id,
+ update_data=update_data,
+ )
+
+ assert 'sandbox limits' in str(exc_info.value)
diff --git a/enterprise/tests/unit/test_authorization.py b/enterprise/tests/unit/test_authorization.py
index 62394fec94..f1f0713a5b 100644
--- a/enterprise/tests/unit/test_authorization.py
+++ b/enterprise/tests/unit/test_authorization.py
@@ -1049,7 +1049,7 @@ class TestRequireFinancialDataAccess:
mock_request = _create_mock_request_with_email(user_email='[email protected]')
with patch(
- 'server.auth.authorization.get_user_auth',
+ 'server.email_validation.get_user_auth',
AsyncMock(return_value=mock_request.state.user_auth),
):
# Act
@@ -1078,7 +1078,7 @@ class TestRequireFinancialDataAccess:
with (
patch(
- 'server.auth.authorization.get_user_auth',
+ 'server.email_validation.get_user_auth',
AsyncMock(return_value=mock_request.state.user_auth),
),
patch(
@@ -1112,7 +1112,7 @@ class TestRequireFinancialDataAccess:
with (
patch(
- 'server.auth.authorization.get_user_auth',
+ 'server.email_validation.get_user_auth',
AsyncMock(return_value=mock_request.state.user_auth),
),
patch(
@@ -1146,7 +1146,7 @@ class TestRequireFinancialDataAccess:
with (
patch(
- 'server.auth.authorization.get_user_auth',
+ 'server.email_validation.get_user_auth',
AsyncMock(return_value=mock_request.state.user_auth),
),
patch(
@@ -1179,7 +1179,7 @@ class TestRequireFinancialDataAccess:
with (
patch(
- 'server.auth.authorization.get_user_auth',
+ 'server.email_validation.get_user_auth',
AsyncMock(return_value=mock_request.state.user_auth),
),
patch(
@@ -1243,3 +1243,124 @@ class TestRequireFinancialDataAccess:
assert exc_info.value.status_code == 403
assert 'API key is not authorized' in exc_info.value.detail
+
+
+# =============================================================================
+# Tests for require_openhands_email_for_sandbox_limits
+# =============================================================================
+
+
+class TestRequireOpenhandsEmailForSandboxLimits:
+ """Tests for require_openhands_email_for_sandbox_limits helper function."""
+
+ @pytest.mark.asyncio
+ async def test_allows_when_field_is_not_present(self):
+ """
+ GIVEN: has_sandbox_limit_field is False
+ WHEN: require_openhands_email_for_sandbox_limits is called
+ THEN: Returns without checking email (no exception)
+ """
+ from server.auth.authorization import require_openhands_email_for_sandbox_limits
+
+ # Arrange - mock request doesn't need email setup since it won't be checked
+ mock_request = MagicMock()
+
+ # Act & Assert - should not raise
+ await require_openhands_email_for_sandbox_limits(
+ request=mock_request, has_sandbox_limit_field=False
+ )
+
+ @pytest.mark.asyncio
+ async def test_allows_openhands_email(self):
+ """
+ GIVEN: User has @openhands.dev email and field is being updated
+ WHEN: require_openhands_email_for_sandbox_limits is called
+ THEN: Returns without exception
+ """
+ from server.auth.authorization import require_openhands_email_for_sandbox_limits
+
+ # Arrange
+ mock_request = _create_mock_request_with_email(user_email='[email protected]')
+
+ with patch(
+ 'server.email_validation.get_user_auth',
+ AsyncMock(return_value=mock_request.state.user_auth),
+ ):
+ # Act & Assert - should not raise
+ await require_openhands_email_for_sandbox_limits(
+ request=mock_request, has_sandbox_limit_field=True
+ )
+
+ @pytest.mark.asyncio
+ async def test_rejects_non_openhands_email(self):
+ """
+ GIVEN: User has [email protected] email and field is being updated
+ WHEN: require_openhands_email_for_sandbox_limits is called
+ THEN: Raises HTTPException with 403
+ """
+ from server.auth.authorization import require_openhands_email_for_sandbox_limits
+
+ # Arrange
+ mock_request = _create_mock_request_with_email(user_email='[email protected]')
+
+ with patch(
+ 'server.email_validation.get_user_auth',
+ AsyncMock(return_value=mock_request.state.user_auth),
+ ):
+ # Act & Assert
+ with pytest.raises(HTTPException) as exc_info:
+ await require_openhands_email_for_sandbox_limits(
+ request=mock_request, has_sandbox_limit_field=True
+ )
+
+ assert exc_info.value.status_code == 403
+ assert 'Only OpenHands team members' in exc_info.value.detail
+
+ @pytest.mark.asyncio
+ async def test_rejects_no_email(self):
+ """
+ GIVEN: User has no email and field is being updated
+ WHEN: require_openhands_email_for_sandbox_limits is called
+ THEN: Raises HTTPException with 403
+ """
+ from server.auth.authorization import require_openhands_email_for_sandbox_limits
+
+ # Arrange
+ mock_request = _create_mock_request_with_email(user_email=None)
+
+ with patch(
+ 'server.email_validation.get_user_auth',
+ AsyncMock(return_value=mock_request.state.user_auth),
+ ):
+ # Act & Assert
+ with pytest.raises(HTTPException) as exc_info:
+ await require_openhands_email_for_sandbox_limits(
+ request=mock_request, has_sandbox_limit_field=True
+ )
+
+ assert exc_info.value.status_code == 403
+ assert 'Only OpenHands team members' in exc_info.value.detail
+
+ @pytest.mark.asyncio
+ async def test_email_check_is_case_sensitive(self):
+ """
+ GIVEN: User has @OPENHANDS.DEV email (uppercase)
+ WHEN: require_openhands_email_for_sandbox_limits is called
+ THEN: Raises HTTPException (case sensitive, following existing pattern)
+ """
+ from server.auth.authorization import require_openhands_email_for_sandbox_limits
+
+ # Arrange - uppercase domain should NOT match (case sensitive)
+ mock_request = _create_mock_request_with_email(user_email='[email protected]')
+
+ with patch(
+ 'server.email_validation.get_user_auth',
+ AsyncMock(return_value=mock_request.state.user_auth),
+ ):
+ # Act & Assert - should raise because email check is case-sensitive
+ with pytest.raises(HTTPException) as exc_info:
+ await require_openhands_email_for_sandbox_limits(
+ request=mock_request, has_sandbox_limit_field=True
+ )
+
+ assert exc_info.value.status_code == 403
diff --git a/enterprise/tests/unit/test_email_validation_dependency.py b/enterprise/tests/unit/test_email_validation_dependency.py
index 8ac481a6e2..06c6846bad 100644
--- a/enterprise/tests/unit/test_email_validation_dependency.py
+++ b/enterprise/tests/unit/test_email_validation_dependency.py
@@ -1,5 +1,5 @@
"""
-Unit tests for email validation dependency (get_admin_user_id).
+Unit tests for email validation dependency (get_admin_user_id and is_openhands_member).
Tests the FastAPI dependency that validates @openhands.dev email domain.
"""
@@ -8,7 +8,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from fastapi import HTTPException, Request
-from server.email_validation import get_admin_user_id
+from server.email_validation import get_admin_user_id, is_openhands_member
@pytest.fixture
@@ -270,3 +270,106 @@ async def test_get_openhands_user_id_empty_email(mock_request, mock_user_auth):
assert exc_info.value.status_code == 401
assert 'email not available' in exc_info.value.detail.lower()
+
+
+# Tests for is_openhands_member helper function
+
+
+async def test_is_openhands_member_true_for_valid_email(mock_request, mock_user_auth):
+ """
+ GIVEN: User with @openhands.dev email
+ WHEN: is_openhands_member is called
+ THEN: Returns True
+ """
+ mock_user_auth.get_user_email.return_value = '[email protected]'
+
+ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):
+ result = await is_openhands_member(mock_request)
+ assert result is True
+
+
+async def test_is_openhands_member_false_for_external_email(
+ mock_request, mock_user_auth
+):
+ """
+ GIVEN: User with [email protected] email
+ WHEN: is_openhands_member is called
+ THEN: Returns False
+ """
+ mock_user_auth.get_user_email.return_value = '[email protected]'
+
+ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):
+ result = await is_openhands_member(mock_request)
+ assert result is False
+
+
+async def test_is_openhands_member_false_for_none_email(mock_request, mock_user_auth):
+ """
+ GIVEN: User with no email (None)
+ WHEN: is_openhands_member is called
+ THEN: Returns False
+ """
+ mock_user_auth.get_user_email.return_value = None
+
+ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):
+ result = await is_openhands_member(mock_request)
+ assert result is False
+
+
+async def test_is_openhands_member_false_for_empty_email(mock_request, mock_user_auth):
+ """
+ GIVEN: User with empty string email
+ WHEN: is_openhands_member is called
+ THEN: Returns False
+ """
+ mock_user_auth.get_user_email.return_value = ''
+
+ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):
+ result = await is_openhands_member(mock_request)
+ assert result is False
+
+
+async def test_is_openhands_member_case_sensitive(mock_request, mock_user_auth):
+ """
+ GIVEN: User with uppercase @OPENHANDS.DEV email
+ WHEN: is_openhands_member is called
+ THEN: Returns False (case-sensitive check)
+ """
+ mock_user_auth.get_user_email.return_value = '[email protected]'
+
+ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):
+ result = await is_openhands_member(mock_request)
+ assert result is False
+
+
+async def test_is_openhands_member_subdomain_not_allowed(mock_request, mock_user_auth):
+ """
+ GIVEN: User with subdomain email like @test.openhands.dev
+ WHEN: is_openhands_member is called
+ THEN: Returns False
+ """
+ mock_user_auth.get_user_email.return_value = '[email protected]'
+
+ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):
+ result = await is_openhands_member(mock_request)
+ assert result is False
+
+
+async def test_is_openhands_member_with_plus_addressing(mock_request, mock_user_auth):
+ """
+ GIVEN: User with plus addressing ([email protected])
+ WHEN: is_openhands_member is called
+ THEN: Returns True
+ """
+ mock_user_auth.get_user_email.return_value = '[email protected]'
+
+ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):
+ result = await is_openhands_member(mock_request)
+ assert result is True
diff --git a/enterprise/tests/unit/test_org_models_concurrency_limits.py b/enterprise/tests/unit/test_org_models_concurrency_limits.py
new file mode 100644
index 0000000000..8ecd107439
--- /dev/null
+++ b/enterprise/tests/unit/test_org_models_concurrency_limits.py
@@ -0,0 +1,287 @@
+"""Tests for org_models concurrency limit fields.
+
+This module tests the Pydantic models for concurrency limits including:
+- OrgResponse max_concurrent_sandboxes field
+- OrgUpdate max_concurrent_sandboxes field validation
+- OrgMemberResponse concurrency fields
+- OrgMemberUpdate max_concurrent_sandboxes_override validation
+- OrgAppSettingsResponse and OrgAppSettingsUpdate
+"""
+
+import uuid
+from unittest.mock import MagicMock
+
+import pytest
+from pydantic import ValidationError
+from server.constants import (
+ DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES,
+ DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES,
+)
+from server.routes.org_models import (
+ OrgAppSettingsResponse,
+ OrgAppSettingsUpdate,
+ OrgMemberUpdate,
+ OrgResponse,
+ OrgUpdate,
+)
+from storage.org import Org
+
+
+class TestOrgResponseConcurrencyLimits:
+ """Test cases for OrgResponse concurrency limit fields."""
+
+ def test_org_response_includes_max_concurrent_sandboxes(self):
+ """Test that OrgResponse includes max_concurrent_sandboxes field."""
+ response = OrgResponse(
+ id='test-org-id',
+ name='Test Org',
+ contact_name='Test Contact',
+ contact_email='[email protected]',
+ max_concurrent_sandboxes=5,
+ )
+
+ assert response.max_concurrent_sandboxes == 5
+
+ def test_org_response_default_max_concurrent_sandboxes(self):
+ """Test that OrgResponse has default for max_concurrent_sandboxes."""
+ response = OrgResponse(
+ id='test-org-id',
+ name='Test Org',
+ contact_name='Test Contact',
+ contact_email='[email protected]',
+ )
+
+ assert (
+ response.max_concurrent_sandboxes
+ == DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
+ )
+
+ def test_org_response_from_org_includes_max_concurrent_sandboxes(self):
+ """Test that OrgResponse.from_org includes max_concurrent_sandboxes."""
+ mock_org = MagicMock(spec=Org)
+ mock_org.id = uuid.uuid4()
+ mock_org.name = 'Test Org'
+ mock_org.contact_name = 'Test Contact'
+ mock_org.contact_email = '[email protected]'
+ mock_org.conversation_expiration = None
+ mock_org.remote_runtime_resource_factor = None
+ mock_org.billing_margin = None
+ mock_org.enable_proactive_conversation_starters = True
+ mock_org.sandbox_base_container_image = None
+ mock_org.sandbox_runtime_container_image = None
+ mock_org.org_version = 1
+ mock_org.agent_settings = {}
+ mock_org.conversation_settings = {}
+ mock_org.max_budget_per_task = None
+ mock_org.enable_solvability_analysis = None
+ mock_org.v1_enabled = None
+ mock_org.max_concurrent_sandboxes = 8
+
+ response = OrgResponse.from_org(mock_org)
+
+ assert response.max_concurrent_sandboxes == 8
+
+ def test_org_response_from_org_uses_personal_default_when_none(self):
+ """Test that OrgResponse.from_org uses 3 for personal orgs when None."""
+ mock_org = MagicMock(spec=Org)
+ mock_org.id = uuid.uuid4()
+ mock_org.name = 'Test Org'
+ mock_org.contact_name = 'Test Contact'
+ mock_org.contact_email = '[email protected]'
+ mock_org.conversation_expiration = None
+ mock_org.remote_runtime_resource_factor = None
+ mock_org.billing_margin = None
+ mock_org.enable_proactive_conversation_starters = True
+ mock_org.sandbox_base_container_image = None
+ mock_org.sandbox_runtime_container_image = None
+ mock_org.org_version = 1
+ mock_org.agent_settings = {}
+ mock_org.conversation_settings = {}
+ mock_org.max_budget_per_task = None
+ mock_org.enable_solvability_analysis = None
+ mock_org.v1_enabled = None
+ mock_org.max_concurrent_sandboxes = None
+
+ # Pass user_id matching org.id to simulate personal org
+ response = OrgResponse.from_org(mock_org, user_id=str(mock_org.id))
+
+ assert (
+ response.max_concurrent_sandboxes
+ == DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
+ )
+
+ def test_org_response_from_org_uses_commercial_default_when_none(self):
+ """Test that OrgResponse.from_org uses commercial default for commercial orgs when None."""
+ mock_org = MagicMock(spec=Org)
+ mock_org.id = uuid.uuid4()
+ mock_org.name = 'Test Org'
+ mock_org.contact_name = 'Test Contact'
+ mock_org.contact_email = '[email protected]'
+ mock_org.conversation_expiration = None
+ mock_org.remote_runtime_resource_factor = None
+ mock_org.billing_margin = None
+ mock_org.enable_proactive_conversation_starters = True
+ mock_org.sandbox_base_container_image = None
+ mock_org.sandbox_runtime_container_image = None
+ mock_org.org_version = 1
+ mock_org.agent_settings = {}
+ mock_org.conversation_settings = {}
+ mock_org.max_budget_per_task = None
+ mock_org.enable_solvability_analysis = None
+ mock_org.v1_enabled = None
+ mock_org.max_concurrent_sandboxes = None
+
+ # No user_id = commercial org
+ response = OrgResponse.from_org(mock_org)
+
+ assert (
+ response.max_concurrent_sandboxes
+ == DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES
+ )
+
+
+class TestOrgUpdateConcurrencyLimits:
+ """Test cases for OrgUpdate concurrency limit validation."""
+
+ def test_org_update_accepts_valid_max_concurrent_sandboxes(self):
+ """Test that OrgUpdate accepts valid max_concurrent_sandboxes values."""
+ update = OrgUpdate(max_concurrent_sandboxes=10)
+
+ assert update.max_concurrent_sandboxes == 10
+
+ def test_org_update_accepts_none_max_concurrent_sandboxes(self):
+ """Test that OrgUpdate accepts None (no change)."""
+ update = OrgUpdate(max_concurrent_sandboxes=None)
+
+ assert update.max_concurrent_sandboxes is None
+
+ def test_org_update_rejects_zero_max_concurrent_sandboxes(self):
+ """Test that OrgUpdate rejects 0 value."""
+ with pytest.raises(ValidationError) as exc_info:
+ OrgUpdate(max_concurrent_sandboxes=0)
+
+ assert 'max_concurrent_sandboxes' in str(exc_info.value)
+
+ def test_org_update_rejects_negative_max_concurrent_sandboxes(self):
+ """Test that OrgUpdate rejects negative values."""
+ with pytest.raises(ValidationError) as exc_info:
+ OrgUpdate(max_concurrent_sandboxes=-5)
+
+ assert 'max_concurrent_sandboxes' in str(exc_info.value)
+
+ def test_org_update_rejects_over_100_max_concurrent_sandboxes(self):
+ """Test that OrgUpdate rejects values over 100."""
+ with pytest.raises(ValidationError) as exc_info:
+ OrgUpdate(max_concurrent_sandboxes=101)
+
+ assert 'max_concurrent_sandboxes' in str(exc_info.value)
+
+ def test_org_update_accepts_boundary_values(self):
+ """Test that OrgUpdate accepts boundary values 1 and 100."""
+ update_min = OrgUpdate(max_concurrent_sandboxes=1)
+ update_max = OrgUpdate(max_concurrent_sandboxes=100)
+
+ assert update_min.max_concurrent_sandboxes == 1
+ assert update_max.max_concurrent_sandboxes == 100
+
+
+class TestOrgMemberUpdateConcurrencyLimits:
+ """Test cases for OrgMemberUpdate concurrency limit validation."""
+
+ def test_org_member_update_accepts_valid_override(self):
+ """Test that OrgMemberUpdate accepts valid override values."""
+ update = OrgMemberUpdate(max_concurrent_sandboxes_override=15)
+
+ assert update.max_concurrent_sandboxes_override == 15
+
+ def test_org_member_update_accepts_none_override(self):
+ """Test that OrgMemberUpdate accepts None (no change)."""
+ update = OrgMemberUpdate(max_concurrent_sandboxes_override=None)
+
+ assert update.max_concurrent_sandboxes_override is None
+
+ def test_org_member_update_rejects_zero_override(self):
+ """Test that OrgMemberUpdate rejects 0 value."""
+ with pytest.raises(ValidationError) as exc_info:
+ OrgMemberUpdate(max_concurrent_sandboxes_override=0)
+
+ assert 'max_concurrent_sandboxes_override' in str(exc_info.value)
+
+ def test_org_member_update_rejects_negative_override(self):
+ """Test that OrgMemberUpdate rejects negative values."""
+ with pytest.raises(ValidationError) as exc_info:
+ OrgMemberUpdate(max_concurrent_sandboxes_override=-1)
+
+ assert 'max_concurrent_sandboxes_override' in str(exc_info.value)
+
+ def test_org_member_update_rejects_over_100_override(self):
+ """Test that OrgMemberUpdate rejects values over 100."""
+ with pytest.raises(ValidationError) as exc_info:
+ OrgMemberUpdate(max_concurrent_sandboxes_override=101)
+
+ assert 'max_concurrent_sandboxes_override' in str(exc_info.value)
+
+ def test_org_member_update_can_set_both_role_and_override(self):
+ """Test that OrgMemberUpdate can set both role and override."""
+ update = OrgMemberUpdate(
+ role='admin',
+ max_concurrent_sandboxes_override=20,
+ )
+
+ assert update.role == 'admin'
+ assert update.max_concurrent_sandboxes_override == 20
+
+
+class TestOrgAppSettingsResponseConcurrencyLimits:
+ """Test cases for OrgAppSettingsResponse concurrency limit fields."""
+
+ def test_org_app_settings_response_includes_max_concurrent_sandboxes(self):
+ """Test that OrgAppSettingsResponse includes max_concurrent_sandboxes."""
+ response = OrgAppSettingsResponse(max_concurrent_sandboxes=7)
+
+ assert response.max_concurrent_sandboxes == 7
+
+ def test_org_app_settings_response_default_value(self):
+ """Test that OrgAppSettingsResponse has default value."""
+ response = OrgAppSettingsResponse()
+
+ assert (
+ response.max_concurrent_sandboxes
+ == DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES
+ )
+
+ def test_org_app_settings_response_from_org(self):
+ """Test that OrgAppSettingsResponse.from_org includes max_concurrent_sandboxes."""
+ mock_org = MagicMock(spec=Org)
+ mock_org.enable_proactive_conversation_starters = True
+ mock_org.enable_solvability_analysis = False
+ mock_org.max_budget_per_task = 10.0
+ mock_org.max_concurrent_sandboxes = 12
+
+ response = OrgAppSettingsResponse.from_org(mock_org)
+
+ assert response.max_concurrent_sandboxes == 12
+
+
+class TestOrgAppSettingsUpdateConcurrencyLimits:
+ """Test cases for OrgAppSettingsUpdate concurrency limit validation."""
+
+ def test_org_app_settings_update_accepts_valid_value(self):
+ """Test that OrgAppSettingsUpdate accepts valid max_concurrent_sandboxes."""
+ update = OrgAppSettingsUpdate(max_concurrent_sandboxes=8)
+
+ assert update.max_concurrent_sandboxes == 8
+
+ def test_org_app_settings_update_rejects_zero(self):
+ """Test that OrgAppSettingsUpdate rejects 0 value."""
+ with pytest.raises(ValidationError) as exc_info:
+ OrgAppSettingsUpdate(max_concurrent_sandboxes=0)
+
+ assert 'max_concurrent_sandboxes' in str(exc_info.value)
+
+ def test_org_app_settings_update_rejects_over_100(self):
+ """Test that OrgAppSettingsUpdate rejects values over 100."""
+ with pytest.raises(ValidationError) as exc_info:
+ OrgAppSettingsUpdate(max_concurrent_sandboxes=101)
+
+ assert 'max_concurrent_sandboxes' in str(exc_info.value)
diff --git a/enterprise/tests/unit/test_saas_user_auth.py b/enterprise/tests/unit/test_saas_user_auth.py
index 9daaa13d46..3bd87db74c 100644
--- a/enterprise/tests/unit/test_saas_user_auth.py
+++ b/enterprise/tests/unit/test_saas_user_auth.py
@@ -1175,3 +1175,386 @@ class TestOpenHandsApiKey:
assert result is not None
assert 'OPENHANDS_API_KEY' in result.custom_secrets
assert len(result.custom_secrets) == 1
+
+
+class TestGetMaxConcurrentSandboxes:
+ """Tests for SaasUserAuth.get_max_concurrent_sandboxes() method.
+
+ This method resolves concurrent sandbox limits in the following order:
+ 1. OrgMember.max_concurrent_sandboxes_override (if not NULL)
+ 2. Org.max_concurrent_sandboxes (org default)
+ 3. The provided default value
+ """
+
+ @pytest.fixture
+ def user_id(self):
+ """Create a test user ID."""
+ return str(uuid.uuid4())
+
+ @pytest.fixture
+ def org_id(self):
+ """Create a test organization ID."""
+ return uuid.uuid4()
+
+ @pytest.fixture
+ def mock_user(self, org_id):
+ """Create a mock user with current_org_id."""
+ user = MagicMock()
+ user.current_org_id = org_id
+ return user
+
+ @pytest.fixture
+ def mock_org_member_with_override(self, org_id, user_id):
+ """Create a mock org member with override set."""
+ member = MagicMock()
+ member.org_id = org_id
+ member.user_id = uuid.UUID(user_id)
+ member.max_concurrent_sandboxes_override = 15
+ return member
+
+ @pytest.fixture
+ def mock_org_member_no_override(self, org_id, user_id):
+ """Create a mock org member with override as None."""
+ member = MagicMock()
+ member.org_id = org_id
+ member.user_id = uuid.UUID(user_id)
+ member.max_concurrent_sandboxes_override = None
+ return member
+
+ @pytest.fixture
+ def mock_org_with_limit(self, org_id):
+ """Create a mock org with max_concurrent_sandboxes set."""
+ org = MagicMock()
+ org.id = org_id
+ org.max_concurrent_sandboxes = 8
+ return org
+
+ # HAPPY PATH TESTS
+
+ @pytest.mark.asyncio
+ async def test_returns_org_member_override_when_set(
+ self,
+ user_id,
+ org_id,
+ mock_user,
+ mock_org_member_with_override,
+ mock_org_with_limit,
+ ):
+ """
+ GIVEN: User has an org_member with max_concurrent_sandboxes_override set
+ WHEN: get_max_concurrent_sandboxes is called
+ THEN: Returns the override value (15)
+ """
+ user_auth = SaasUserAuth(
+ user_id=user_id,
+ refresh_token=SecretStr('refresh_token'),
+ )
+
+ with (
+ patch('server.auth.saas_user_auth.UserStore') as mock_user_store,
+ # OrgMemberStore is imported locally inside the function
+ patch(
+ 'storage.org_member_store.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_org_member,
+ patch(
+ 'storage.org_store.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)
+ mock_get_org_member.return_value = mock_org_member_with_override
+ mock_get_org.return_value = mock_org_with_limit
+
+ result = await user_auth.get_max_concurrent_sandboxes()
+
+ assert result == 15
+ # OrgStore should not be called when override exists
+ mock_get_org.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_returns_org_default_when_override_is_none(
+ self,
+ user_id,
+ org_id,
+ mock_user,
+ mock_org_member_no_override,
+ mock_org_with_limit,
+ ):
+ """
+ GIVEN: User has org_member with override=None, org has max_concurrent_sandboxes set
+ WHEN: get_max_concurrent_sandboxes is called
+ THEN: Returns the org's max_concurrent_sandboxes (8)
+ """
+ user_auth = SaasUserAuth(
+ user_id=user_id,
+ refresh_token=SecretStr('refresh_token'),
+ )
+
+ with (
+ patch('server.auth.saas_user_auth.UserStore') as mock_user_store,
+ patch(
+ 'storage.org_member_store.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_org_member,
+ patch(
+ 'storage.org_store.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)
+ mock_get_org_member.return_value = mock_org_member_no_override
+ mock_get_org.return_value = mock_org_with_limit
+
+ result = await user_auth.get_max_concurrent_sandboxes()
+
+ assert result == 8
+
+ @pytest.mark.asyncio
+ async def test_returns_default_when_both_org_and_override_unset(
+ self, user_id, org_id, mock_user, mock_org_member_no_override
+ ):
+ """
+ GIVEN: User has org_member with override=None, org has max_concurrent_sandboxes=None
+ WHEN: get_max_concurrent_sandboxes is called
+ THEN: Returns the default value (10)
+ """
+ mock_org_no_limit = MagicMock()
+ mock_org_no_limit.id = org_id
+ mock_org_no_limit.max_concurrent_sandboxes = None
+
+ user_auth = SaasUserAuth(
+ user_id=user_id,
+ refresh_token=SecretStr('refresh_token'),
+ )
+
+ with (
+ patch('server.auth.saas_user_auth.UserStore') as mock_user_store,
+ patch(
+ 'storage.org_member_store.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_org_member,
+ patch(
+ 'storage.org_store.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)
+ mock_get_org_member.return_value = mock_org_member_no_override
+ mock_get_org.return_value = mock_org_no_limit
+
+ result = await user_auth.get_max_concurrent_sandboxes()
+
+ assert result == 10 # default
+
+ @pytest.mark.asyncio
+ async def test_returns_custom_default_when_no_limits_set(
+ self, user_id, org_id, mock_user, mock_org_member_no_override
+ ):
+ """
+ GIVEN: No limits are set anywhere
+ WHEN: get_max_concurrent_sandboxes is called with custom default (5)
+ THEN: Returns the custom default (5)
+ """
+ mock_org_no_limit = MagicMock()
+ mock_org_no_limit.id = org_id
+ mock_org_no_limit.max_concurrent_sandboxes = None
+
+ user_auth = SaasUserAuth(
+ user_id=user_id,
+ refresh_token=SecretStr('refresh_token'),
+ )
+
+ with (
+ patch('server.auth.saas_user_auth.UserStore') as mock_user_store,
+ patch(
+ 'storage.org_member_store.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_org_member,
+ patch(
+ 'storage.org_store.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)
+ mock_get_org_member.return_value = mock_org_member_no_override
+ mock_get_org.return_value = mock_org_no_limit
+
+ result = await user_auth.get_max_concurrent_sandboxes(default=5)
+
+ assert result == 5
+
+ @pytest.mark.asyncio
+ async def test_returns_default_when_user_has_no_current_org_id(self, user_id):
+ """
+ GIVEN: User has no current_org_id
+ WHEN: get_max_concurrent_sandboxes is called
+ THEN: Returns the default value (10) immediately
+ """
+ mock_user_no_org = MagicMock()
+ mock_user_no_org.current_org_id = None
+
+ user_auth = SaasUserAuth(
+ user_id=user_id,
+ refresh_token=SecretStr('refresh_token'),
+ )
+
+ with patch('server.auth.saas_user_auth.UserStore') as mock_user_store:
+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user_no_org)
+
+ result = await user_auth.get_max_concurrent_sandboxes()
+
+ assert result == 10
+
+ @pytest.mark.asyncio
+ async def test_returns_default_when_user_does_not_exist(self, user_id):
+ """
+ GIVEN: User does not exist in database
+ WHEN: get_max_concurrent_sandboxes is called
+ THEN: Returns the default value (10)
+ """
+ user_auth = SaasUserAuth(
+ user_id=user_id,
+ refresh_token=SecretStr('refresh_token'),
+ )
+
+ with patch('server.auth.saas_user_auth.UserStore') as mock_user_store:
+ mock_user_store.get_user_by_id = AsyncMock(return_value=None)
+
+ result = await user_auth.get_max_concurrent_sandboxes()
+
+ assert result == 10
+
+ @pytest.mark.asyncio
+ async def test_returns_org_default_when_org_member_not_found(
+ self, user_id, org_id, mock_user, mock_org_with_limit
+ ):
+ """
+ GIVEN: User exists but has no org_member record
+ WHEN: get_max_concurrent_sandboxes is called
+ THEN: Falls back to org's max_concurrent_sandboxes
+ """
+ user_auth = SaasUserAuth(
+ user_id=user_id,
+ refresh_token=SecretStr('refresh_token'),
+ )
+
+ with (
+ patch('server.auth.saas_user_auth.UserStore') as mock_user_store,
+ patch(
+ 'storage.org_member_store.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_org_member,
+ patch(
+ 'storage.org_store.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)
+ mock_get_org_member.return_value = None
+ mock_get_org.return_value = mock_org_with_limit
+
+ result = await user_auth.get_max_concurrent_sandboxes()
+
+ assert result == 8
+
+ @pytest.mark.asyncio
+ async def test_returns_default_when_org_not_found(
+ self, user_id, org_id, mock_user, mock_org_member_no_override
+ ):
+ """
+ GIVEN: OrgMember exists but org does not exist
+ WHEN: get_max_concurrent_sandboxes is called
+ THEN: Returns the default value (10)
+ """
+ user_auth = SaasUserAuth(
+ user_id=user_id,
+ refresh_token=SecretStr('refresh_token'),
+ )
+
+ with (
+ patch('server.auth.saas_user_auth.UserStore') as mock_user_store,
+ patch(
+ 'storage.org_member_store.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_org_member,
+ patch(
+ 'storage.org_store.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)
+ mock_get_org_member.return_value = mock_org_member_no_override
+ mock_get_org.return_value = None
+
+ result = await user_auth.get_max_concurrent_sandboxes()
+
+ assert result == 10
+
+ # UNHAPPY PATH TESTS
+
+ @pytest.mark.asyncio
+ async def test_handles_database_error_gracefully(
+ self, user_id, org_id, mock_user, mock_org_member_no_override
+ ):
+ """
+ GIVEN: A database error occurs during lookup
+ WHEN: get_max_concurrent_sandboxes is called
+ THEN: Returns the default value (10) without raising
+ """
+ user_auth = SaasUserAuth(
+ user_id=user_id,
+ refresh_token=SecretStr('refresh_token'),
+ )
+
+ with (
+ patch('server.auth.saas_user_auth.UserStore') as mock_user_store,
+ patch(
+ 'storage.org_member_store.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_org_member,
+ patch(
+ 'storage.org_store.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)
+ mock_get_org_member.side_effect = Exception('Database connection failed')
+ mock_get_org.return_value = mock_org_member_no_override
+
+ result = await user_auth.get_max_concurrent_sandboxes()
+
+ assert result == 10
+
+ @pytest.mark.asyncio
+ async def test_handles_org_store_error_gracefully(
+ self, user_id, org_id, mock_user, mock_org_member_no_override
+ ):
+ """
+ GIVEN: OrgStore raises an error
+ WHEN: get_max_concurrent_sandboxes is called after org_member check
+ THEN: Returns the default value (10) without raising
+ """
+ user_auth = SaasUserAuth(
+ user_id=user_id,
+ refresh_token=SecretStr('refresh_token'),
+ )
+
+ with (
+ patch('server.auth.saas_user_auth.UserStore') as mock_user_store,
+ patch(
+ 'storage.org_member_store.OrgMemberStore.get_org_member',
+ new_callable=AsyncMock,
+ ) as mock_get_org_member,
+ patch(
+ 'storage.org_store.OrgStore.get_org_by_id',
+ new_callable=AsyncMock,
+ ) as mock_get_org,
+ ):
+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)
+ mock_get_org_member.return_value = mock_org_member_no_override
+ mock_get_org.side_effect = Exception('Org lookup failed')
+
+ result = await user_auth.get_max_concurrent_sandboxes()
+
+ assert result == 10
diff --git a/frontend/__tests__/components/features/org/conversation-limit-modal.test.tsx b/frontend/__tests__/components/features/org/conversation-limit-modal.test.tsx
new file mode 100644
index 0000000000..b224f4177a
--- /dev/null
+++ b/frontend/__tests__/components/features/org/conversation-limit-modal.test.tsx
@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { renderWithProviders } from "test-utils";
+import { ConversationLimitModal } from "#/components/features/org/conversation-limit-modal";
+import { DEFAULT_CONCURRENT_SANDBOX_LIMIT } from "#/utils/constants";
+
+vi.mock("react-i18next", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("react-i18next")>()),
+ useTranslation: () => ({
+ t: (key: string, options?: { limit?: number }) => {
+ if (key === "CONVERSATION_LIMIT$DESCRIPTION" && options?.limit) {
+ return `Description with limit ${options.limit}`;
+ }
+ return key;
+ },
+ i18n: {
+ changeLanguage: vi.fn(),
+ },
+ }),
+}));
+
+describe("ConversationLimitModal", () => {
+ const onCloseMock = vi.fn();
+
+ const renderModal = (props: {
+ onClose?: () => void;
+ limit?: number;
+ } = {}) => {
+ const user = userEvent.setup();
+ renderWithProviders(
+ <ConversationLimitModal
+ onClose={props.onClose ?? onCloseMock}
+ limit={props.limit}
+ />,
+ );
+ return { user };
+ };
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ });
+
+ describe("Rendering", () => {
+ it("should render the modal with correct test id", () => {
+ renderModal();
+
+ expect(screen.getByTestId("conversation-limit-modal")).toBeInTheDocument();
+ });
+
+ it("should display the title", () => {
+ renderModal();
+
+ expect(screen.getByText("CONVERSATION_LIMIT$TITLE")).toBeInTheDocument();
+ });
+
+ it("should display the close button", () => {
+ renderModal();
+
+ expect(
+ screen.getByTestId("conversation-limit-close-button"),
+ ).toBeInTheDocument();
+ });
+
+ it("should not display a learn more button", () => {
+ renderModal();
+
+ expect(
+ screen.queryByTestId("conversation-limit-learn-more-button"),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should display description with provided limit", () => {
+ renderModal({ limit: 5 });
+
+ expect(screen.getByText("Description with limit 5")).toBeInTheDocument();
+ });
+
+ it("should use default limit when not provided", () => {
+ renderModal();
+
+ expect(
+ screen.getByText(`Description with limit ${DEFAULT_CONCURRENT_SANDBOX_LIMIT}`),
+ ).toBeInTheDocument();
+ });
+ });
+
+ describe("Close Button", () => {
+ it("should call onClose when close button is clicked", async () => {
+ const { user } = renderModal();
+
+ const closeButton = screen.getByTestId("conversation-limit-close-button");
+ await user.click(closeButton);
+
+ expect(onCloseMock).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe("Different Limit Values", () => {
+ it("should display limit of 1", () => {
+ renderModal({ limit: 1 });
+ expect(screen.getByText("Description with limit 1")).toBeInTheDocument();
+ });
+
+ it("should display limit of 10", () => {
+ renderModal({ limit: 10 });
+ expect(screen.getByText("Description with limit 10")).toBeInTheDocument();
+ });
+
+ it("should display limit of 100", () => {
+ renderModal({ limit: 100 });
+ expect(screen.getByText("Description with limit 100")).toBeInTheDocument();
+ });
+ });
+});
diff --git a/frontend/__tests__/stores/conversation-limit-store.test.ts b/frontend/__tests__/stores/conversation-limit-store.test.ts
new file mode 100644
index 0000000000..3426a105db
--- /dev/null
+++ b/frontend/__tests__/stores/conversation-limit-store.test.ts
@@ -0,0 +1,143 @@
+import { describe, expect, it, beforeEach } from "vitest";
+import { useConversationLimitStore } from "#/stores/conversation-limit-store";
+
+describe("useConversationLimitStore", () => {
+ beforeEach(() => {
+ // Reset store to initial state before each test
+ useConversationLimitStore.setState({
+ isOpen: false,
+ limit: null,
+ });
+ });
+
+ describe("initial state", () => {
+ it("has isOpen set to false", () => {
+ const { isOpen } = useConversationLimitStore.getState();
+ expect(isOpen).toBe(false);
+ });
+
+ it("has limit set to null", () => {
+ const { limit } = useConversationLimitStore.getState();
+ expect(limit).toBeNull();
+ });
+ });
+
+ describe("showLimitModal", () => {
+ it("sets isOpen to true", () => {
+ const { showLimitModal } = useConversationLimitStore.getState();
+ showLimitModal(3);
+
+ const { isOpen } = useConversationLimitStore.getState();
+ expect(isOpen).toBe(true);
+ });
+
+ it("stores the limit value", () => {
+ const { showLimitModal } = useConversationLimitStore.getState();
+ showLimitModal(5);
+
+ const { limit } = useConversationLimitStore.getState();
+ expect(limit).toBe(5);
+ });
+
+ it("stores different limit values correctly", () => {
+ const { showLimitModal } = useConversationLimitStore.getState();
+
+ showLimitModal(1);
+ expect(useConversationLimitStore.getState().limit).toBe(1);
+
+ showLimitModal(10);
+ expect(useConversationLimitStore.getState().limit).toBe(10);
+
+ showLimitModal(100);
+ expect(useConversationLimitStore.getState().limit).toBe(100);
+ });
+
+ it("updates state when called multiple times", () => {
+ const { showLimitModal } = useConversationLimitStore.getState();
+
+ showLimitModal(3);
+ expect(useConversationLimitStore.getState().isOpen).toBe(true);
+ expect(useConversationLimitStore.getState().limit).toBe(3);
+
+ showLimitModal(5);
+ expect(useConversationLimitStore.getState().isOpen).toBe(true);
+ expect(useConversationLimitStore.getState().limit).toBe(5);
+ });
+ });
+
+ describe("closeLimitModal", () => {
+ it("sets isOpen to false", () => {
+ const { showLimitModal, closeLimitModal } =
+ useConversationLimitStore.getState();
+
+ // First open the modal
+ showLimitModal(3);
+ expect(useConversationLimitStore.getState().isOpen).toBe(true);
+
+ // Then close it
+ closeLimitModal();
+ expect(useConversationLimitStore.getState().isOpen).toBe(false);
+ });
+
+ it("resets limit to null", () => {
+ const { showLimitModal, closeLimitModal } =
+ useConversationLimitStore.getState();
+
+ // First open the modal with a limit
+ showLimitModal(5);
+ expect(useConversationLimitStore.getState().limit).toBe(5);
+
+ // Then close it
+ closeLimitModal();
+ expect(useConversationLimitStore.getState().limit).toBeNull();
+ });
+
+ it("resets to initial state", () => {
+ const { showLimitModal, closeLimitModal } =
+ useConversationLimitStore.getState();
+
+ // Open modal
+ showLimitModal(10);
+
+ // Close modal
+ closeLimitModal();
+
+ const state = useConversationLimitStore.getState();
+ expect(state.isOpen).toBe(false);
+ expect(state.limit).toBeNull();
+ });
+
+ it("can be called when modal is already closed", () => {
+ const { closeLimitModal } = useConversationLimitStore.getState();
+
+ // Should not throw when called on already closed modal
+ expect(() => closeLimitModal()).not.toThrow();
+
+ const state = useConversationLimitStore.getState();
+ expect(state.isOpen).toBe(false);
+ expect(state.limit).toBeNull();
+ });
+ });
+
+ describe("workflow", () => {
+ it("supports open -> close -> open cycle", () => {
+ const { showLimitModal, closeLimitModal } =
+ useConversationLimitStore.getState();
+
+ // Open
+ showLimitModal(3);
+ expect(useConversationLimitStore.getState().isOpen).toBe(true);
+ expect(useConversationLimitStore.getState().limit).toBe(3);
+
+ // Close
+ closeLimitModal();
+ expect(useConversationLimitStore.getState().isOpen).toBe(false);
+ expect(useConversationLimitStore.getState().limit).toBeNull();
+
+ // Open again with different limit
+ showLimitModal(5);
+ expect(useConversationLimitStore.getState().isOpen).toBe(true);
+ expect(useConversationLimitStore.getState().limit).toBe(5);
+ });
+ });
+});
diff --git a/frontend/__tests__/utils/concurrency-limit-error.test.ts b/frontend/__tests__/utils/concurrency-limit-error.test.ts
new file mode 100644
index 0000000000..d08f9698cb
--- /dev/null
+++ b/frontend/__tests__/utils/concurrency-limit-error.test.ts
@@ -0,0 +1,198 @@
+import { describe, expect, it } from "vitest";
+import { AxiosError, AxiosHeaders } from "axios";
+import {
+ isConcurrencyLimitError,
+ getConcurrencyLimit,
+} from "#/utils/concurrency-limit-error";
+import { DEFAULT_CONCURRENT_SANDBOX_LIMIT } from "#/utils/constants";
+
+describe("isConcurrencyLimitError", () => {
+ it("returns true for valid 429 concurrency limit error", () => {
+ // FastAPI wraps HTTPException detail in a "detail" field
+ const error = new AxiosError("Too Many Requests", "429", undefined, null, {
+ status: 429,
+ statusText: "Too Many Requests",
+ headers: new AxiosHeaders(),
+ config: { headers: new AxiosHeaders() },
+ data: {
+ detail: {
+ error: "CONCURRENCY_LIMIT_REACHED",
+ message: "You have reached your limit",
+ limit: 3,
+ current: 3,
+ },
+ },
+ });
+
+ expect(isConcurrencyLimitError(error)).toBe(true);
+ });
+
+ it("returns false for non-AxiosError", () => {
+ const error = new Error("Some error");
+ expect(isConcurrencyLimitError(error)).toBe(false);
+ });
+
+ it("returns false for null", () => {
+ expect(isConcurrencyLimitError(null)).toBe(false);
+ });
+
+ it("returns false for undefined", () => {
+ expect(isConcurrencyLimitError(undefined)).toBe(false);
+ });
+
+ it("returns false for string error", () => {
+ expect(isConcurrencyLimitError("some error")).toBe(false);
+ });
+
+ it("returns false for non-429 status code", () => {
+ const error = new AxiosError("Server Error", "500", undefined, null, {
+ status: 500,
+ statusText: "Internal Server Error",
+ headers: new AxiosHeaders(),
+ config: { headers: new AxiosHeaders() },
+ data: {
+ detail: {
+ error: "CONCURRENCY_LIMIT_REACHED",
+ message: "You have reached your limit",
+ limit: 3,
+ current: 3,
+ },
+ },
+ });
+
+ expect(isConcurrencyLimitError(error)).toBe(false);
+ });
+
+ it("returns false for 429 with different error code", () => {
+ const error = new AxiosError("Too Many Requests", "429", undefined, null, {
+ status: 429,
+ statusText: "Too Many Requests",
+ headers: new AxiosHeaders(),
+ config: { headers: new AxiosHeaders() },
+ data: {
+ detail: {
+ error: "RATE_LIMITED",
+ message: "Too many requests",
+ },
+ },
+ });
+
+ expect(isConcurrencyLimitError(error)).toBe(false);
+ });
+
+ it("returns false for 429 with no error code", () => {
+ const error = new AxiosError("Too Many Requests", "429", undefined, null, {
+ status: 429,
+ statusText: "Too Many Requests",
+ headers: new AxiosHeaders(),
+ config: { headers: new AxiosHeaders() },
+ data: {
+ detail: {
+ message: "Too many requests",
+ },
+ },
+ });
+
+ expect(isConcurrencyLimitError(error)).toBe(false);
+ });
+
+ it("returns false for 429 with no response data", () => {
+ const error = new AxiosError("Too Many Requests", "429", undefined, null, {
+ status: 429,
+ statusText: "Too Many Requests",
+ headers: new AxiosHeaders(),
+ config: { headers: new AxiosHeaders() },
+ data: null,
+ });
+
+ expect(isConcurrencyLimitError(error)).toBe(false);
+ });
+
+ it("returns false for AxiosError with no response", () => {
+ const error = new AxiosError("Network Error", "ERR_NETWORK");
+ expect(isConcurrencyLimitError(error)).toBe(false);
+ });
+});
+
+describe("getConcurrencyLimit", () => {
+ it("extracts limit from error response", () => {
+ // FastAPI wraps HTTPException detail in a "detail" field
+ const error = new AxiosError("Too Many Requests", "429", undefined, null, {
+ status: 429,
+ statusText: "Too Many Requests",
+ headers: new AxiosHeaders(),
+ config: { headers: new AxiosHeaders() },
+ data: {
+ detail: {
+ error: "CONCURRENCY_LIMIT_REACHED" as const,
+ message: "You have reached your limit",
+ limit: 5,
+ current: 5,
+ },
+ },
+ });
+
+ expect(getConcurrencyLimit(error)).toBe(5);
+ });
+
+ it("returns default limit when limit is missing", () => {
+ const error = new AxiosError("Too Many Requests", "429", undefined, null, {
+ status: 429,
+ statusText: "Too Many Requests",
+ headers: new AxiosHeaders(),
+ config: { headers: new AxiosHeaders() },
+ data: {
+ detail: {
+ error: "CONCURRENCY_LIMIT_REACHED" as const,
+ message: "You have reached your limit",
+ limit: undefined as unknown as number,
+ current: 3,
+ },
+ },
+ });
+
+ expect(getConcurrencyLimit(error)).toBe(DEFAULT_CONCURRENT_SANDBOX_LIMIT);
+ });
+
+ it("returns default limit when response data is null", () => {
+ const error = new AxiosError("Too Many Requests", "429", undefined, null, {
+ status: 429,
+ statusText: "Too Many Requests",
+ headers: new AxiosHeaders(),
+ config: { headers: new AxiosHeaders() },
+ data: null,
+ });
+
+ // @ts-expect-error - testing with invalid data type
+ expect(getConcurrencyLimit(error)).toBe(DEFAULT_CONCURRENT_SANDBOX_LIMIT);
+ });
+
+ it("returns default limit when response is undefined", () => {
+ const error = new AxiosError("Network Error", "ERR_NETWORK");
+ // @ts-expect-error - testing with no response
+ expect(getConcurrencyLimit(error)).toBe(DEFAULT_CONCURRENT_SANDBOX_LIMIT);
+ });
+
+ it("extracts different limit values correctly", () => {
+ // FastAPI wraps HTTPException detail in a "detail" field
+ const createError = (limit: number) =>
+ new AxiosError("Too Many Requests", "429", undefined, null, {
+ status: 429,
+ statusText: "Too Many Requests",
+ headers: new AxiosHeaders(),
+ config: { headers: new AxiosHeaders() },
+ data: {
+ detail: {
+ error: "CONCURRENCY_LIMIT_REACHED" as const,
+ message: "You have reached your limit",
+ limit,
+ current: limit,
+ },
+ },
+ });
+
+ expect(getConcurrencyLimit(createError(1))).toBe(1);
+ expect(getConcurrencyLimit(createError(10))).toBe(10);
+ expect(getConcurrencyLimit(createError(100))).toBe(100);
+ });
+});
diff --git a/frontend/src/components/features/org/conversation-limit-modal.tsx b/frontend/src/components/features/org/conversation-limit-modal.tsx
new file mode 100644
index 0000000000..a530c647ce
--- /dev/null
+++ b/frontend/src/components/features/org/conversation-limit-modal.tsx
@@ -0,0 +1,52 @@
+import { useTranslation } from "react-i18next";
+import { ModalBackdrop } from "#/components/shared/modals/modal-backdrop";
+import { BrandButton } from "#/components/features/settings/brand-button";
+import { I18nKey } from "#/i18n/declaration";
+import { Typography } from "#/ui/typography";
+import { DEFAULT_CONCURRENT_SANDBOX_LIMIT } from "#/utils/constants";
+
+interface ConversationLimitModalProps {
+ onClose: () => void;
+ limit?: number;
+}
+
+export function ConversationLimitModal({
+ onClose,
+ limit = DEFAULT_CONCURRENT_SANDBOX_LIMIT,
+}: ConversationLimitModalProps) {
+ const { t } = useTranslation();
+
+ return (
+ <ModalBackdrop onClose={onClose}>
+ <div
+ data-testid="conversation-limit-modal"
+ className="flex flex-col gap-6 rounded-xl border border-[#454545] bg-[#25272D] p-[30px] w-[523px] shadow-2xl"
+ >
+ {/* Header */}
+ <div className="flex items-center gap-[17px]">
+ <Typography.H3 className="text-xl font-semibold leading-6 text-white tracking-[-0.01em]">
+ {t(I18nKey.CONVERSATION_LIMIT$TITLE)}
+ </Typography.H3>
+ </div>
+
+ {/* Body */}
+ <Typography.Paragraph className="text-sm leading-5 text-[#A3A3A3]">
+ {t(I18nKey.CONVERSATION_LIMIT$DESCRIPTION, { limit })}
+ </Typography.Paragraph>
+
+ {/* Footer */}
+ <div className="flex gap-6">
+ <BrandButton
+ type="button"
+ variant="primary"
+ onClick={onClose}
+ className="flex-1 bg-white text-black hover:bg-gray-100"
+ testId="conversation-limit-close-button"
+ >
+ {t(I18nKey.BUTTON$CLOSE)}
+ </BrandButton>
+ </div>
+ </div>
+ </ModalBackdrop>
+ );
+}
diff --git a/frontend/src/hooks/mutation/use-create-conversation.ts b/frontend/src/hooks/mutation/use-create-conversation.ts
index 1f3e6c0d42..6e2c0611c8 100644
--- a/frontend/src/hooks/mutation/use-create-conversation.ts
+++ b/frontend/src/hooks/mutation/use-create-conversation.ts
@@ -3,6 +3,11 @@ import V1ConversationService from "#/api/conversation-service/v1-conversation-se
import { PluginSpec } from "#/api/conversation-service/v1-conversation-service.types";
import { SuggestedTask } from "#/utils/types";
import { Provider } from "#/types/settings";
+import { useConversationLimitStore } from "#/stores/conversation-limit-store";
+import {
+ isConcurrencyLimitError,
+ getConcurrencyLimit,
+} from "#/utils/concurrency-limit-error";
interface CreateConversationVariables {
query?: string;
@@ -29,6 +34,7 @@ interface CreateConversationResponse {
export const useCreateConversation = () => {
const queryClient = useQueryClient();
+ const { showLimitModal } = useConversationLimitStore();
return useMutation({
mutationKey: ["create-conversation"],
@@ -75,5 +81,10 @@ export const useCreateConversation = () => {
queryKey: ["user", "conversations"],
});
},
+ onError: (error) => {
+ if (isConcurrencyLimitError(error)) {
+ showLimitModal(getConcurrencyLimit(error));
+ }
+ },
});
};
diff --git a/frontend/src/hooks/mutation/use-new-conversation-command.ts b/frontend/src/hooks/mutation/use-new-conversation-command.ts
index 8a84a6b594..7063616e2b 100644
--- a/frontend/src/hooks/mutation/use-new-conversation-command.ts
+++ b/frontend/src/hooks/mutation/use-new-conversation-command.ts
@@ -10,12 +10,18 @@ import {
TOAST_OPTIONS,
} from "#/utils/custom-toast-handlers";
import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { useConversationLimitStore } from "#/stores/conversation-limit-store";
+import {
+ isConcurrencyLimitError,
+ getConcurrencyLimit,
+} from "#/utils/concurrency-limit-error";
export const useNewConversationCommand = () => {
const queryClient = useQueryClient();
const navigate = useNavigate();
const { t } = useTranslation();
const { data: conversation } = useActiveConversation();
+ const { showLimitModal } = useConversationLimitStore();
const mutation = useMutation({
mutationFn: async () => {
@@ -100,6 +106,12 @@ export const useNewConversationCommand = () => {
},
onError: (error) => {
toast.dismiss("clear-conversation");
+
+ if (isConcurrencyLimitError(error)) {
+ showLimitModal(getConcurrencyLimit(error));
+ return;
+ }
+
let clearError = t(I18nKey.CONVERSATION$CLEAR_UNKNOWN_ERROR);
if (error instanceof Error) {
clearError = error.message;
diff --git a/frontend/src/i18n/declaration.ts b/frontend/src/i18n/declaration.ts
index 8aa14eacff..28cd4fb68b 100644
--- a/frontend/src/i18n/declaration.ts
+++ b/frontend/src/i18n/declaration.ts
@@ -413,6 +413,9 @@ export enum I18nKey {
API$DONT_KNOW_KEY = "API$DONT_KNOW_KEY",
BUTTON$SAVE = "BUTTON$SAVE",
BUTTON$CLOSE = "BUTTON$CLOSE",
+ COMMON$LEARN_MORE = "COMMON$LEARN_MORE",
+ CONVERSATION_LIMIT$TITLE = "CONVERSATION_LIMIT$TITLE",
+ CONVERSATION_LIMIT$DESCRIPTION = "CONVERSATION_LIMIT$DESCRIPTION",
MODAL$CONFIRM_RESET_TITLE = "MODAL$CONFIRM_RESET_TITLE",
MODAL$CONFIRM_RESET_MESSAGE = "MODAL$CONFIRM_RESET_MESSAGE",
MODAL$END_SESSION_TITLE = "MODAL$END_SESSION_TITLE",
diff --git a/frontend/src/i18n/translation.json b/frontend/src/i18n/translation.json
index ae1c9912af..7c82c570db 100644
--- a/frontend/src/i18n/translation.json
+++ b/frontend/src/i18n/translation.json
@@ -7020,6 +7020,57 @@
"uk": "Закрити",
"ca": "Tanca"
},
+ "COMMON$LEARN_MORE": {
+ "en": "Learn more",
+ "ja": "詳細を見る",
+ "zh-CN": "了解更多",
+ "zh-TW": "了解更多",
+ "ko-KR": "자세히 알아보기",
+ "no": "Lær mer",
+ "ar": "اعرف المزيد",
+ "de": "Mehr erfahren",
+ "fr": "En savoir plus",
+ "it": "Scopri di più",
+ "pt": "Saiba mais",
+ "es": "Más información",
+ "ca": "Més informació",
+ "tr": "Daha fazla bilgi",
+ "uk": "Дізнатися більше"
+ },
+ "CONVERSATION_LIMIT$TITLE": {
+ "en": "Conversation Limit Reached",
+ "ja": "会話数の上限に達しました",
+ "zh-CN": "已达到会话限制",
+ "zh-TW": "已達到會話限制",
+ "ko-KR": "대화 한도에 도달했습니다",
+ "no": "Samtalegrense nådd",
+ "ar": "تم الوصول إلى حد المحادثات",
+ "de": "Konversationslimit erreicht",
+ "fr": "Limite de conversations atteinte",
+ "it": "Limite di conversazioni raggiunto",
+ "pt": "Limite de conversas atingido",
+ "es": "Límite de conversaciones alcanzado",
+ "ca": "S'ha assolit el límit de converses",
+ "tr": "Konuşma sınırına ulaşıldı",
+ "uk": "Досягнуто ліміту розмов"
+ },
+ "CONVERSATION_LIMIT$DESCRIPTION": {
+ "en": "Based on your plan you've reached the maximum number of concurrent conversations ({{limit}}). In order to start another conversation you must stop the runtime of another conversation.",
+ "ja": "ご利用のプランでは、同時会話数の上限({{limit}})に達しました。新しい会話を開始するには、別の会話のランタイムを停止してください。",
+ "zh-CN": "根据您的计划,您已达到同时进行的会话数量上限({{limit}})。要开始新的会话,您必须停止另一个会话的运行时。",
+ "zh-TW": "根據您的計劃,您已達到同時進行的會話數量上限({{limit}})。要開始新的會話,您必須停止另一個會話的運行時。",
+ "ko-KR": "플랜에 따라 동시 대화 최대 수({{limit}})에 도달했습니다. 다른 대화를 시작하려면 다른 대화의 런타임을 중지해야 합니다.",
+ "no": "Basert på planen din har du nådd maksimalt antall samtidige samtaler ({{limit}}). For å starte en ny samtale må du stoppe kjøretiden til en annen samtale.",
+ "ar": "بناءً على خطتك، لقد وصلت إلى الحد الأقصى لعدد المحادثات المتزامنة ({{limit}}). لبدء محادثة أخرى، يجب عليك إيقاف وقت التشغيل لمحادثة أخرى.",
+ "de": "Basierend auf Ihrem Plan haben Sie die maximale Anzahl gleichzeitiger Konversationen erreicht ({{limit}}). Um eine weitere Konversation zu starten, müssen Sie die Laufzeit einer anderen Konversation beenden.",
+ "fr": "Selon votre plan, vous avez atteint le nombre maximum de conversations simultanées ({{limit}}). Pour démarrer une autre conversation, vous devez arrêter le runtime d'une autre conversation.",
+ "it": "In base al tuo piano, hai raggiunto il numero massimo di conversazioni simultanee ({{limit}}). Per iniziare un'altra conversazione, devi interrompere il runtime di un'altra conversazione.",
+ "pt": "Com base no seu plano, você atingiu o número máximo de conversas simultâneas ({{limit}}). Para iniciar outra conversa, você deve parar o runtime de outra conversa.",
+ "es": "Según tu plan, has alcanzado el número máximo de conversaciones simultáneas ({{limit}}). Para iniciar otra conversación, debes detener el runtime de otra conversación.",
+ "ca": "Segons el teu pla, has assolit el nombre màxim de converses simultànies ({{limit}}). Per iniciar una altra conversa, has d'aturar el runtime d'una altra conversa.",
+ "tr": "Planınıza göre, maksimum eşzamanlı konuşma sayısına ({{limit}}) ulaştınız. Başka bir konuşma başlatmak için başka bir konuşmanın çalışma zamanını durdurmalısınız.",
+ "uk": "Відповідно до вашого плану, ви досягли максимальної кількості одночасних розмов ({{limit}}). Щоб розпочати іншу розмову, вам потрібно зупинити середовище виконання іншої розмови."
+ },
"MODAL$CONFIRM_RESET_TITLE": {
"en": "Are you sure?",
"ja": "本当によろしいですか?",
diff --git a/frontend/src/routes/root-layout.tsx b/frontend/src/routes/root-layout.tsx
index dc365ffb70..e185a65fe0 100644
--- a/frontend/src/routes/root-layout.tsx
+++ b/frontend/src/routes/root-layout.tsx
@@ -32,6 +32,8 @@ import { cn } from "#/utils/utils";
import { LoadingSpinner } from "#/components/shared/loading-spinner";
import { useAppTitle } from "#/hooks/use-app-title";
import { useAutoAcceptInvitation } from "#/hooks/use-auto-accept-invitation";
+import { ConversationLimitModal } from "#/components/features/org/conversation-limit-modal";
+import { useConversationLimitStore } from "#/stores/conversation-limit-store";
export function ErrorBoundary() {
const error = useRouteError();
@@ -89,6 +91,13 @@ export default function MainApp() {
// Accept a pending invitation token once authenticated
useAutoAcceptInvitation();
+ // Conversation limit modal state
+ const {
+ isOpen: isConversationLimitModalOpen,
+ limit: conversationLimit,
+ closeLimitModal,
+ } = useConversationLimitStore();
+
// Auto-login if login method is stored in local storage
useAutoLogin();
@@ -269,6 +278,12 @@ export default function MainApp() {
}}
/>
)}
+ {isConversationLimitModalOpen && conversationLimit !== null && (
+ <ConversationLimitModal
+ onClose={closeLimitModal}
+ limit={conversationLimit}
+ />
+ )}
</div>
);
}
diff --git a/frontend/src/stores/conversation-limit-store.ts b/frontend/src/stores/conversation-limit-store.ts
new file mode 100644
index 0000000000..793c8f9b31
--- /dev/null
+++ b/frontend/src/stores/conversation-limit-store.ts
@@ -0,0 +1,36 @@
+import { create } from "zustand";
+
+interface ConversationLimitState {
+ isOpen: boolean;
+ limit: number | null;
+}
+
+interface ConversationLimitActions {
+ showLimitModal: (limit: number) => void;
+ closeLimitModal: () => void;
+}
+
+type ConversationLimitStore = ConversationLimitState & ConversationLimitActions;
+
+const initialState: ConversationLimitState = {
+ isOpen: false,
+ limit: null,
+};
+
+export const useConversationLimitStore = create<ConversationLimitStore>(
+ (set) => ({
+ ...initialState,
+
+ showLimitModal: (limit: number) =>
+ set(() => ({
+ isOpen: true,
+ limit,
+ })),
+
+ closeLimitModal: () =>
+ set(() => ({
+ isOpen: false,
+ limit: null,
+ })),
+ }),
+);
diff --git a/frontend/src/utils/concurrency-limit-error.ts b/frontend/src/utils/concurrency-limit-error.ts
new file mode 100644
index 0000000000..bb25f6b43c
--- /dev/null
+++ b/frontend/src/utils/concurrency-limit-error.ts
@@ -0,0 +1,30 @@
+import { AxiosError } from "axios";
+import { DEFAULT_CONCURRENT_SANDBOX_LIMIT } from "./constants";
+
+interface ConcurrencyLimitErrorDetail {
+ error: "CONCURRENCY_LIMIT_REACHED";
+ message: string;
+ limit: number;
+ current: number;
+}
+
+// FastAPI wraps HTTPException detail in a "detail" field
+interface FastAPIErrorResponse {
+ detail: ConcurrencyLimitErrorDetail;
+}
+
+export function isConcurrencyLimitError(
+ error: unknown,
+): error is AxiosError<FastAPIErrorResponse> {
+ if (!(error instanceof AxiosError)) return false;
+ if (error.response?.status !== 429) return false;
+ return error.response?.data?.detail?.error === "CONCURRENCY_LIMIT_REACHED";
+}
+
+export function getConcurrencyLimit(
+ error: AxiosError<FastAPIErrorResponse>,
+): number {
+ return (
+ error.response?.data?.detail?.limit ?? DEFAULT_CONCURRENT_SANDBOX_LIMIT
+ );
+}
diff --git a/frontend/src/utils/constants.ts b/frontend/src/utils/constants.ts
index d4a7fa0330..1b7fa73733 100644
--- a/frontend/src/utils/constants.ts
+++ b/frontend/src/utils/constants.ts
@@ -118,3 +118,12 @@ export const METADATA_PREFIXES: readonly string[] = [
"Skill location:",
"(Use this path to resolve",
];
+
+/**
+ * Fallback concurrent sandbox limit used when the backend error does not
+ * include a limit value. Matches DEFAULT_COMMERCIAL_ORG_CONCURRENT_SANDBOXES
+ * in the backend (enterprise/server/constants.py).
+ * Personal workspaces have a lower limit (3) — the backend always sends the
+ * actual limit in the error detail, so this constant is only a safety net.
+ */
+export const DEFAULT_CONCURRENT_SANDBOX_LIMIT = 10;
diff --git a/openhands/app_server/app_conversation/live_status_app_conversation_service.py b/openhands/app_server/app_conversation/live_status_app_conversation_service.py
index 5ff51f2916..c48ad001b2 100644
--- a/openhands/app_server/app_conversation/live_status_app_conversation_service.py
+++ b/openhands/app_server/app_conversation/live_status_app_conversation_service.py
@@ -244,6 +244,11 @@ class LiveStatusAppConversationService(AppConversationServiceBase):
async def _start_app_conversation(
self, request: AppConversationStartRequest
) -> AsyncGenerator[AppConversationStartTask, None]:
+ # Check concurrency limit before creating task if we might need a new sandbox
+ # This allows the API to return 429 immediately instead of failing asynchronously
+ if not request.sandbox_id:
+ await self.sandbox_service.check_concurrency_limit()
+
# Create and yield the start task
user_id = await self.user_context.get_user_id()
# Prefer the user's email as the Laminar trace user id so traces are
diff --git a/openhands/app_server/app_lifespan/alembic/versions/011.py b/openhands/app_server/app_lifespan/alembic/versions/011.py
new file mode 100644
index 0000000000..d5a110e993
--- /dev/null
+++ b/openhands/app_server/app_lifespan/alembic/versions/011.py
@@ -0,0 +1,43 @@
+"""Add is_paused column to v1_remote_sandbox table
+
+Revision ID: 011
+Revises: 010
+Create Date: 2026-06-02 00:00:00.000000
+"""
+
+from typing import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = '011'
+down_revision: str | None = '010'
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+ """Add is_paused column to v1_remote_sandbox.
+
+ Enables the concurrency-limit check to query the DB directly by
+ (created_by_user_id, is_paused) instead of calling the runtime
+ API's global /list endpoint on every conversation start.
+
+ Existing rows default to False (not paused), which is the safe
+ assumption: rows without an API-confirmed paused state are treated
+ as running, matching the previous behaviour.
+ """
+ with op.batch_alter_table('v1_remote_sandbox') as batch_op:
+ batch_op.add_column(
+ sa.Column(
+ 'is_paused',
+ sa.Boolean(),
+ nullable=False,
+ server_default='0',
+ )
+ )
+
+
+def downgrade() -> None:
+ with op.batch_alter_table('v1_remote_sandbox') as batch_op:
+ batch_op.drop_column('is_paused')
diff --git a/openhands/app_server/errors.py b/openhands/app_server/errors.py
index c7cf9614c0..a23e9d7693 100644
--- a/openhands/app_server/errors.py
+++ b/openhands/app_server/errors.py
@@ -41,3 +41,15 @@ class PermissionsError(OpenHandsError):
class SandboxError(OpenHandsError):
"""Error in Sandbox."""
+
+
+class ConcurrencyLimitError(OpenHandsError):
+ """Error when user has reached their concurrent sandbox limit."""
+
+ def __init__(
+ self,
+ detail: Any = None,
+ headers: dict[str, str] | None = None,
+ status_code: int = status.HTTP_429_TOO_MANY_REQUESTS,
+ ):
+ super().__init__(status_code=status_code, detail=detail, headers=headers)
diff --git a/openhands/app_server/sandbox/remote_sandbox_service.py b/openhands/app_server/sandbox/remote_sandbox_service.py
index 4532efcd75..f722dcb068 100644
--- a/openhands/app_server/sandbox/remote_sandbox_service.py
+++ b/openhands/app_server/sandbox/remote_sandbox_service.py
@@ -12,7 +12,7 @@ import base62
import httpx
from fastapi import Request
from pydantic import Field
-from sqlalchemy import String, func, select
+from sqlalchemy import Boolean, String, func, select
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import Mapped, mapped_column
@@ -24,7 +24,7 @@ from openhands.agent_server.utils import utc_now
from openhands.app_server.app_conversation.app_conversation_models import (
AppConversationInfo,
)
-from openhands.app_server.errors import SandboxError
+from openhands.app_server.errors import ConcurrencyLimitError, SandboxError
from openhands.app_server.sandbox.sandbox_models import (
AGENT_SERVER,
VSCODE,
@@ -93,6 +93,7 @@ class StoredRemoteSandbox(Base):
created_at: Mapped[datetime] = mapped_column(
UtcDateTime, server_default=func.now(), index=True
)
+ is_paused: Mapped[bool] = mapped_column(Boolean, default=False, server_default='0')
@dataclass
@@ -212,6 +213,35 @@ class RemoteSandboxService(SandboxService):
query = query.where(StoredRemoteSandbox.created_by_user_id == user_id)
return query
+ async def _get_user_effective_sandbox_limit(self) -> int:
+ """Get the effective sandbox limit for the current user.
+
+ Delegates to UserContext.get_max_concurrent_sandboxes() which handles:
+ 1. OrgMember.max_concurrent_sandboxes_override (if not NULL) - enterprise only
+ 2. Org.max_concurrent_sandboxes (org default) - enterprise only
+ 3. Global fallback (self.max_num_sandboxes) - OSS mode
+
+ Returns:
+ int: The effective maximum number of concurrent sandboxes
+ """
+ return await self.user_context.get_max_concurrent_sandboxes(
+ self.max_num_sandboxes
+ )
+
+ async def _count_user_running_sandboxes(self) -> int:
+ """Count the number of running (non-paused) sandboxes for the current user.
+
+ Queries the DB directly by created_by_user_id and is_paused, avoiding
+ a global runtime API call for every concurrency check.
+
+ Returns:
+ int: Number of running sandboxes
+ """
+ query = await self._secure_select()
+ query = query.filter(StoredRemoteSandbox.is_paused == False) # noqa: E712
+ result = await self.db_session.execute(query)
+ return len(result.scalars().all())
+
async def _get_stored_sandbox(self, sandbox_id: str) -> StoredRemoteSandbox | None:
stmt = await self._secure_select()
stmt = stmt.where(StoredRemoteSandbox.id == sandbox_id)
@@ -372,6 +402,35 @@ class RemoteSandboxService(SandboxService):
)
return self._to_sandbox_info(stored_sandbox, None)
+ async def check_concurrency_limit(self) -> None:
+ """Check if the user has reached their concurrent sandbox limit.
+
+ This check is performed synchronously before creating a task to allow
+ the API to return a 429 error immediately instead of failing asynchronously.
+
+ Raises:
+ ConcurrencyLimitError: If the user has reached their limit
+ """
+ effective_limit = await self._get_user_effective_sandbox_limit()
+ current_count = await self._count_user_running_sandboxes()
+
+ if current_count >= effective_limit:
+ _logger.info(
+ f'User has reached sandbox limit: {current_count}/{effective_limit}'
+ )
+ raise ConcurrencyLimitError(
+ detail={
+ 'error': 'CONCURRENCY_LIMIT_REACHED',
+ 'message': (
+ f'You have reached your limit of {effective_limit} '
+ 'concurrent conversations. Please close an existing '
+ 'conversation to start a new one.'
+ ),
+ 'limit': effective_limit,
+ 'current': current_count,
+ }
+ )
+
async def get_sandbox_record_by_session_api_key(
self, session_api_key: str
) -> SandboxRecord | None:
@@ -396,12 +455,15 @@ class RemoteSandboxService(SandboxService):
async def start_sandbox(
self, sandbox_spec_id: str | None = None, sandbox_id: str | None = None
) -> SandboxInfo:
- """Start a new sandbox by creating a remote runtime."""
- try:
- # Enforce sandbox limits by cleaning up old sandboxes
- await self.pause_old_sandboxes(self.max_num_sandboxes - 1)
+ """Start a new sandbox by creating a remote runtime.
- # Get sandbox spec
+ Uses SELECT FOR UPDATE within a nested transaction to acquire a row-level
+ lock, preventing race conditions (TOCTOU) when checking concurrency limits.
+ The lock is released after the sandbox record is inserted (before the
+ long-running runtime startup) to avoid blocking concurrent requests.
+ """
+ try:
+ # Get sandbox spec early (before locking) to minimize lock hold time
if sandbox_spec_id is None:
sandbox_spec = (
await self.sandbox_spec_service.get_default_sandbox_spec()
@@ -418,17 +480,67 @@ class RemoteSandboxService(SandboxService):
if sandbox_id is None:
sandbox_id = base62.encodebytes(os.urandom(16))
- # get user id
+ # Get user id for locking and record creation
user_id = await self.user_context.get_user_id()
- # Store the sandbox
- stored_sandbox = StoredRemoteSandbox(
- id=sandbox_id,
- created_by_user_id=user_id,
- sandbox_spec_id=sandbox_spec.id,
- created_at=utc_now(),
- )
- self.db_session.add(stored_sandbox)
+ # Use a nested transaction (savepoint) for the lock + check + insert.
+ # This allows us to release the row-level lock after inserting the
+ # sandbox record, before the long-running runtime startup begins.
+ # Without this, the lock would be held for the entire request duration
+ # (up to 120s for sandbox startup), blocking concurrent requests.
+ async with self.db_session.begin_nested():
+ # Acquire row-level lock to prevent TOCTOU race condition.
+ # This serializes concurrent sandbox creation requests for the same user.
+ # We lock the user's most recent sandbox row (if any) to coordinate access.
+ # If no sandbox exists, the INSERT below will still serialize due to
+ # unique constraint checks, and the next request will have a row to lock.
+ await self.db_session.execute(
+ select(StoredRemoteSandbox.id)
+ .filter(StoredRemoteSandbox.created_by_user_id == user_id)
+ .order_by(StoredRemoteSandbox.created_at.desc())
+ .limit(1)
+ .with_for_update()
+ )
+
+ # Get user's effective limit and current count (now serialized)
+ effective_limit = await self._get_user_effective_sandbox_limit()
+ current_count = await self._count_user_running_sandboxes()
+
+ # Check if user has reached their limit
+ if current_count >= effective_limit:
+ _logger.info(
+ f'User has reached sandbox limit: {current_count}/{effective_limit}'
+ )
+ raise ConcurrencyLimitError(
+ detail={
+ 'error': 'CONCURRENCY_LIMIT_REACHED',
+ 'message': (
+ f'You have reached your limit of {effective_limit} '
+ 'concurrent conversations. Please close an existing '
+ 'conversation to start a new one.'
+ ),
+ 'limit': effective_limit,
+ 'current': current_count,
+ }
+ )
+
+ # Enforce sandbox limits by cleaning up old sandboxes if approaching limit
+ # Use effective_limit - 1 to leave room for the new sandbox
+ if current_count >= effective_limit - 1:
+ await self.pause_old_sandboxes(effective_limit - 1)
+
+ # Store the sandbox record (this reserves the slot)
+ stored_sandbox = StoredRemoteSandbox(
+ id=sandbox_id,
+ created_by_user_id=user_id,
+ sandbox_spec_id=sandbox_spec.id,
+ created_at=utc_now(),
+ )
+ self.db_session.add(stored_sandbox)
+
+ # Nested transaction committed - lock is now released.
+ # The sandbox record exists, so the concurrency slot is reserved.
+ # Other requests can now proceed with their own concurrency checks.
# Prepare environment variables
environment = await self._init_environment(sandbox_spec, sandbox_id)
@@ -472,6 +584,9 @@ class RemoteSandboxService(SandboxService):
return self._to_sandbox_info(stored_sandbox, runtime_data)
+ except ConcurrencyLimitError:
+ # Re-raise concurrency limit errors without wrapping
+ raise
except httpx.HTTPError as e:
_logger.error(f'Failed to start sandbox: {e}')
raise SandboxError(f'Failed to start sandbox: {e}')
@@ -512,6 +627,7 @@ class RemoteSandboxService(SandboxService):
f'Updated session_api_key_hash for sandbox {sandbox_id} after resume'
)
+ stored_sandbox.is_paused = False
return True
except httpx.HTTPError as e:
_logger.error(f'Error resuming sandbox {sandbox_id}: {e}')
@@ -531,6 +647,7 @@ class RemoteSandboxService(SandboxService):
# Security: Invalidate the session API key hash to prevent
# leaked keys from being used while the sandbox is paused.
stored_sandbox.session_api_key_hash = None
+ stored_sandbox.is_paused = True
runtime_data = await self._get_runtime(sandbox_id)
response = await self._send_runtime_api_request(
@@ -586,17 +703,10 @@ class RemoteSandboxService(SandboxService):
if max_num_sandboxes <= 0:
raise ValueError('max_num_sandboxes must be greater than 0')
- response = await self._send_runtime_api_request(
- 'GET',
- '/list',
- )
- content = response.json()
- running_session_ids = [
- runtime.get('session_id') for runtime in content['runtimes']
- ]
-
+ # Query running sandboxes from DB directly using is_paused flag, avoiding
+ # a global runtime API call that returns all users' runtimes.
query = await self._secure_select()
- query = query.filter(StoredRemoteSandbox.id.in_(running_session_ids)).order_by(
+ query = query.filter(StoredRemoteSandbox.is_paused == False).order_by( # noqa: E712
StoredRemoteSandbox.created_at.desc()
)
running_sandboxes = list(await self.db_session.execute(query))
diff --git a/openhands/app_server/sandbox/sandbox_service.py b/openhands/app_server/sandbox/sandbox_service.py
index e372c7a5a0..a765c910db 100644
--- a/openhands/app_server/sandbox/sandbox_service.py
+++ b/openhands/app_server/sandbox/sandbox_service.py
@@ -200,6 +200,20 @@ class SandboxService(ABC):
Return False if the sandbox did not exist.
"""
+ async def check_concurrency_limit(self) -> None: # noqa: B027
+ """Check if the user has reached their concurrent sandbox limit.
+
+ This method should be called before starting a new sandbox to fail fast
+ with an appropriate error response.
+
+ Raises:
+ ConcurrencyLimitError: If the user has reached their limit
+
+ Default implementation does nothing (no limits enforced).
+ Subclasses can override to implement limit checking.
+ """
+ pass # Default: no limits enforced
+
async def pause_old_sandboxes(self, max_num_sandboxes: int) -> list[str]:
"""Pause the oldest sandboxes if there are more than max_num_sandboxes running.
In a multi user environment, this will pause sandboxes only for the current user.
diff --git a/openhands/app_server/user/auth_user_context.py b/openhands/app_server/user/auth_user_context.py
index 6bfd416d20..8ac22fbf81 100644
--- a/openhands/app_server/user/auth_user_context.py
+++ b/openhands/app_server/user/auth_user_context.py
@@ -145,6 +145,9 @@ class AuthUserContext(UserContext):
async def get_user_git_info(self) -> UserGitInfo | None:
return await self.user_auth.get_user_git_info()
+ async def get_max_concurrent_sandboxes(self, default: int = 10) -> int:
+ return await self.user_auth.get_max_concurrent_sandboxes(default)
+
USER_ID_ATTR = 'user_id'
diff --git a/openhands/app_server/user/user_context.py b/openhands/app_server/user/user_context.py
index 55c2fd84f4..81a95859f7 100644
--- a/openhands/app_server/user/user_context.py
+++ b/openhands/app_server/user/user_context.py
@@ -77,6 +77,23 @@ class UserContext(ABC):
async def get_user_git_info(self) -> UserGitInfo | None:
"""Get an User Meta"""
+ async def get_max_concurrent_sandboxes(self, default: int = 10) -> int:
+ """Get the user's maximum concurrent sandboxes limit.
+
+ This method returns the effective limit for concurrent sandboxes for the user.
+ The resolution order is:
+ 1. User-specific override (if set)
+ 2. Organization default (if in enterprise/SaaS mode)
+ 3. The provided default value (OSS mode fallback)
+
+ Args:
+ default: The fallback limit if no user/org-specific limit is set.
+
+ Returns:
+ The effective maximum number of concurrent sandboxes allowed.
+ """
+ return default
+
class UserContextInjector(DiscriminatedUnionMixin, Injector[UserContext], ABC):
"""Injector for user contexts."""
diff --git a/openhands/app_server/user_auth/user_auth.py b/openhands/app_server/user_auth/user_auth.py
index 554f4e8aa8..be36815666 100644
--- a/openhands/app_server/user_auth/user_auth.py
+++ b/openhands/app_server/user_auth/user_auth.py
@@ -105,6 +105,20 @@ class UserAuth(ABC):
user: UserGitInfo = await client.get_user()
return user
+ async def get_max_concurrent_sandboxes(self, default: int = 10) -> int:
+ """Get the user's maximum concurrent sandboxes limit.
+
+ In OSS mode, this returns the default value.
+ Enterprise implementations can override to check org/user-specific limits.
+
+ Args:
+ default: The fallback limit if no user/org-specific limit is set.
+
+ Returns:
+ The effective maximum number of concurrent sandboxes allowed.
+ """
+ return default
+
@classmethod
@abstractmethod
async def get_instance(cls, request: Request) -> UserAuth:
diff --git a/tests/unit/app_server/test_concurrency_limit_error.py b/tests/unit/app_server/test_concurrency_limit_error.py
new file mode 100644
index 0000000000..10e8f28b13
--- /dev/null
+++ b/tests/unit/app_server/test_concurrency_limit_error.py
@@ -0,0 +1,103 @@
+"""Tests for ConcurrencyLimitError.
+
+This module tests the ConcurrencyLimitError exception including:
+- HTTP 429 status code
+- Structured error detail
+- Limit and current count in response
+"""
+
+from fastapi import status
+
+from openhands.app_server.errors import ConcurrencyLimitError
+
+
+def _make_detail(limit: int, current: int) -> dict:
+ """Helper to create standard concurrency limit error detail."""
+ return {
+ 'error': 'CONCURRENCY_LIMIT_REACHED',
+ 'message': (
+ f'You have reached your limit of {limit} '
+ 'concurrent conversations. Please close an existing '
+ 'conversation to start a new one.'
+ ),
+ 'limit': limit,
+ 'current': current,
+ }
+
+
+class TestConcurrencyLimitError:
+ """Test cases for ConcurrencyLimitError exception."""
+
+ def test_creates_with_correct_status_code(self):
+ """Test that ConcurrencyLimitError has HTTP 429 status code."""
+ error = ConcurrencyLimitError(detail=_make_detail(5, 5))
+
+ assert error.status_code == status.HTTP_429_TOO_MANY_REQUESTS
+
+ def test_creates_detail_message(self):
+ """Test that ConcurrencyLimitError creates appropriate detail message."""
+ error = ConcurrencyLimitError(detail=_make_detail(3, 3))
+
+ assert error.detail['error'] == 'CONCURRENCY_LIMIT_REACHED'
+ assert 'limit of 3' in error.detail['message']
+ assert error.detail['limit'] == 3
+ assert error.detail['current'] == 3
+
+ def test_includes_limit_and_current_in_detail(self):
+ """Test that limit and current values are included in detail."""
+ error = ConcurrencyLimitError(detail=_make_detail(10, 10))
+
+ assert error.detail['limit'] == 10
+ assert error.detail['current'] == 10
+
+ def test_custom_detail(self):
+ """Test that custom detail is used."""
+ custom_detail = {'custom': 'error message'}
+ error = ConcurrencyLimitError(detail=custom_detail)
+
+ assert error.detail == custom_detail
+
+ def test_headers_are_optional(self):
+ """Test that headers parameter is optional."""
+ error = ConcurrencyLimitError(detail=_make_detail(5, 5))
+
+ # Should not raise, headers defaults to None
+ assert error.headers is None
+
+ def test_custom_headers_are_passed_through(self):
+ """Test that custom headers are passed to parent."""
+ custom_headers = {'Retry-After': '60'}
+ error = ConcurrencyLimitError(detail=_make_detail(5, 5), headers=custom_headers)
+
+ assert error.headers == custom_headers
+
+ def test_message_includes_close_conversation_hint(self):
+ """Test that error message hints to close existing conversation."""
+ error = ConcurrencyLimitError(detail=_make_detail(5, 5))
+
+ assert 'close an existing conversation' in error.detail['message']
+
+ def test_different_limits_produce_different_messages(self):
+ """Test that different limit values produce different messages."""
+ error_3 = ConcurrencyLimitError(detail=_make_detail(3, 3))
+ error_10 = ConcurrencyLimitError(detail=_make_detail(10, 10))
+
+ assert 'limit of 3' in error_3.detail['message']
+ assert 'limit of 10' in error_10.detail['message']
+ assert error_3.detail['message'] != error_10.detail['message']
+
+ def test_is_http_exception(self):
+ """Test that ConcurrencyLimitError is an HTTPException."""
+ from fastapi import HTTPException
+
+ error = ConcurrencyLimitError(detail=_make_detail(5, 5))
+
+ assert isinstance(error, HTTPException)
+
+ def test_is_openhands_error(self):
+ """Test that ConcurrencyLimitError is an OpenHandsError."""
+ from openhands.app_server.errors import OpenHandsError
+
+ error = ConcurrencyLimitError(detail=_make_detail(5, 5))
+
+ assert isinstance(error, OpenHandsError)
diff --git a/tests/unit/app_server/test_live_status_app_conversation_service.py b/tests/unit/app_server/test_live_status_app_conversation_service.py
index 5f34920d02..b9441e39df 100644
--- a/tests/unit/app_server/test_live_status_app_conversation_service.py
+++ b/tests/unit/app_server/test_live_status_app_conversation_service.py
@@ -141,6 +141,8 @@ class TestLiveStatusAppConversationService:
self.mock_user_context.get_user_email = AsyncMock(return_value=None)
self.mock_jwt_service = Mock()
self.mock_sandbox_service = Mock()
+ # Default: check_concurrency_limit does not raise (no limit reached)
+ self.mock_sandbox_service.check_concurrency_limit = AsyncMock()
self.mock_sandbox_spec_service = Mock()
self.mock_app_conversation_info_service = Mock()
self.mock_app_conversation_start_task_service = Mock()
@@ -2277,6 +2279,8 @@ class TestPluginHandling:
self.mock_user_context.get_user_email = AsyncMock(return_value=None)
self.mock_jwt_service = Mock()
self.mock_sandbox_service = Mock()
+ # Default: check_concurrency_limit does not raise (no limit reached)
+ self.mock_sandbox_service.check_concurrency_limit = AsyncMock()
self.mock_sandbox_spec_service = Mock()
self.mock_app_conversation_info_service = Mock()
self.mock_app_conversation_start_task_service = Mock()
@@ -2939,6 +2943,8 @@ class TestLoadHooksFromWorkspace:
self.mock_user_context = Mock(spec=UserContext)
self.mock_jwt_service = Mock()
self.mock_sandbox_service = Mock()
+ # Default: check_concurrency_limit does not raise (no limit reached)
+ self.mock_sandbox_service.check_concurrency_limit = AsyncMock()
self.mock_sandbox_spec_service = Mock()
self.mock_app_conversation_info_service = Mock()
self.mock_app_conversation_start_task_service = Mock()
@@ -3490,3 +3496,158 @@ class TestBuildAcpStartConversationRequestSecrets:
assert request.agent.acp_env.get('GH_TOKEN') == 'explicit-token'
assert request.secrets.get('GH_TOKEN') is panel_secret
+
+
+class TestConcurrencyLimitCheck:
+ """Test cases for concurrency limit checking in _start_app_conversation."""
+
+ def setup_method(self):
+ """Set up test fixtures."""
+ self.mock_user_context = Mock(spec=UserContext)
+ self.mock_user_auth = Mock()
+ self.mock_user_context.user_auth = self.mock_user_auth
+ self.mock_jwt_service = Mock()
+ self.mock_sandbox_service = Mock()
+ # Default: check_concurrency_limit does not raise (individual tests override this)
+ self.mock_sandbox_service.check_concurrency_limit = AsyncMock()
+ self.mock_sandbox_spec_service = Mock()
+ self.mock_app_conversation_info_service = Mock()
+ self.mock_app_conversation_start_task_service = Mock()
+ self.mock_event_callback_service = Mock()
+ self.mock_event_service = Mock()
+ self.mock_httpx_client = Mock()
+ self.mock_pending_message_service = Mock()
+
+ self.service = LiveStatusAppConversationService(
+ init_git_in_empty_workspace=True,
+ user_context=self.mock_user_context,
+ app_conversation_info_service=self.mock_app_conversation_info_service,
+ app_conversation_start_task_service=self.mock_app_conversation_start_task_service,
+ event_callback_service=self.mock_event_callback_service,
+ event_service=self.mock_event_service,
+ sandbox_service=self.mock_sandbox_service,
+ sandbox_spec_service=self.mock_sandbox_spec_service,
+ jwt_service=self.mock_jwt_service,
+ pending_message_service=self.mock_pending_message_service,
+ sandbox_startup_timeout=30,
+ sandbox_startup_poll_frequency=1,
+ max_num_conversations_per_sandbox=20,
+ httpx_client=self.mock_httpx_client,
+ web_url='https://test.example.com',
+ openhands_provider_base_url='https://provider.example.com',
+ access_token_hard_timeout=None,
+ app_mode='test',
+ )
+
+ @pytest.mark.asyncio
+ async def test_start_app_conversation_checks_concurrency_limit_when_no_sandbox_id(
+ self,
+ ):
+ """Test that _start_app_conversation calls check_concurrency_limit when sandbox_id is not provided."""
+ from openhands.app_server.errors import ConcurrencyLimitError
+
+ # Arrange
+ self.mock_sandbox_service.check_concurrency_limit = AsyncMock(
+ side_effect=ConcurrencyLimitError(
+ detail={
+ 'error': 'CONCURRENCY_LIMIT_REACHED',
+ 'message': 'Limit reached',
+ 'limit': 3,
+ 'current': 3,
+ }
+ )
+ )
+ request = AppConversationStartRequest() # No sandbox_id
+
+ # Act & Assert
+ with pytest.raises(ConcurrencyLimitError) as exc_info:
+ async for _ in self.service._start_app_conversation(request):
+ pass
+
+ assert exc_info.value.detail['limit'] == 3
+ assert exc_info.value.detail['current'] == 3
+ assert exc_info.value.status_code == 429
+ self.mock_sandbox_service.check_concurrency_limit.assert_called_once()
+
+ @pytest.mark.asyncio
+ async def test_start_app_conversation_skips_concurrency_check_when_sandbox_id_provided(
+ self,
+ ):
+ """Test that _start_app_conversation skips check_concurrency_limit when sandbox_id is provided."""
+ # Arrange
+ self.mock_sandbox_service.check_concurrency_limit = AsyncMock()
+ self.mock_user_context.get_user_id = AsyncMock(return_value='test_user')
+
+ # Create request with sandbox_id (reusing existing sandbox)
+ request = AppConversationStartRequest(sandbox_id='existing-sandbox-123')
+
+ # Mock the rest of the flow to allow the generator to start
+ # We only need to verify check_concurrency_limit is NOT called
+ # So we can let it fail after that point
+ try:
+ async for _ in self.service._start_app_conversation(request):
+ break # Just get the first yield, don't need full flow
+ except Exception:
+ pass # Expected to fail since we didn't mock everything
+
+ # Assert - check_concurrency_limit should NOT have been called
+ self.mock_sandbox_service.check_concurrency_limit.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_start_app_conversation_propagates_concurrency_error(self):
+ """Test that ConcurrencyLimitError is propagated without being caught."""
+ from openhands.app_server.errors import ConcurrencyLimitError
+
+ # Arrange
+ self.mock_sandbox_service.check_concurrency_limit = AsyncMock(
+ side_effect=ConcurrencyLimitError(
+ detail={
+ 'error': 'CONCURRENCY_LIMIT_REACHED',
+ 'message': 'Limit reached',
+ 'limit': 5,
+ 'current': 7,
+ }
+ )
+ )
+ request = AppConversationStartRequest()
+
+ # Act & Assert - error should propagate directly
+ with pytest.raises(ConcurrencyLimitError) as exc_info:
+ async for _ in self.service._start_app_conversation(request):
+ pass
+
+ # Verify it's the exact error we raised, not wrapped
+ assert exc_info.value.detail['limit'] == 5
+ assert exc_info.value.detail['current'] == 7
+
+ @pytest.mark.asyncio
+ async def test_start_app_conversation_concurrency_check_before_task_creation(self):
+ """Test that concurrency limit is checked BEFORE task is created/yielded."""
+ from openhands.app_server.errors import ConcurrencyLimitError
+
+ # Arrange
+ self.mock_sandbox_service.check_concurrency_limit = AsyncMock(
+ side_effect=ConcurrencyLimitError(
+ detail={
+ 'error': 'CONCURRENCY_LIMIT_REACHED',
+ 'message': 'Limit reached',
+ 'limit': 3,
+ 'current': 3,
+ }
+ )
+ )
+ self.mock_user_context.get_user_id = AsyncMock(return_value='test_user')
+
+ request = AppConversationStartRequest()
+
+ # Track if any task was yielded
+ tasks_yielded = []
+
+ # Act
+ with pytest.raises(ConcurrencyLimitError):
+ async for task in self.service._start_app_conversation(request):
+ tasks_yielded.append(task)
+
+ # Assert - no tasks should have been yielded since error happens first
+ assert len(tasks_yielded) == 0
+ self.mock_sandbox_service.check_concurrency_limit.assert_called_once()
diff --git a/tests/unit/app_server/test_remote_sandbox_service.py b/tests/unit/app_server/test_remote_sandbox_service.py
index 7ee7ec9f8b..8a01c5cd07 100644
--- a/tests/unit/app_server/test_remote_sandbox_service.py
+++ b/tests/unit/app_server/test_remote_sandbox_service.py
@@ -120,6 +120,7 @@ def create_stored_sandbox(
spec_id: str = 'test-image:latest',
created_at: datetime | None = None,
session_api_key_hash: str | None = None,
+ is_paused: bool = False,
) -> StoredRemoteSandbox:
"""Helper function to create StoredRemoteSandbox for testing."""
if created_at is None:
@@ -131,6 +132,7 @@ def create_stored_sandbox(
sandbox_spec_id=spec_id,
session_api_key_hash=session_api_key_hash,
created_at=created_at,
+ is_paused=is_paused,
)
@@ -397,6 +399,12 @@ class TestSandboxLifecycle:
remote_sandbox_service.httpx_client.request.return_value = mock_response
remote_sandbox_service.pause_old_sandboxes = AsyncMock(return_value=[])
+ # Mock concurrency limit methods
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=10
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=0)
+
# Mock database operations
remote_sandbox_service.db_session.add = MagicMock()
remote_sandbox_service.db_session.commit = AsyncMock()
@@ -408,9 +416,6 @@ class TestSandboxLifecycle:
# Verify
assert sandbox_info.id == 'test-sandbox-123'
assert sandbox_info.status == SandboxStatus.RUNNING
- remote_sandbox_service.pause_old_sandboxes.assert_called_once_with(
- 9
- ) # max_num_sandboxes - 1
remote_sandbox_service.db_session.add.assert_called_once()
remote_sandbox_service.db_session.commit.assert_not_called()
@@ -424,6 +429,13 @@ class TestSandboxLifecycle:
mock_response.json.return_value = create_runtime_data()
remote_sandbox_service.httpx_client.request.return_value = mock_response
remote_sandbox_service.pause_old_sandboxes = AsyncMock(return_value=[])
+
+ # Mock concurrency limit methods
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=10
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=0)
+
remote_sandbox_service.db_session.add = MagicMock()
remote_sandbox_service.db_session.commit = AsyncMock()
@@ -445,6 +457,12 @@ class TestSandboxLifecycle:
mock_sandbox_spec_service.get_sandbox_spec.return_value = None
remote_sandbox_service.pause_old_sandboxes = AsyncMock(return_value=[])
+ # Mock concurrency limit methods
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=10
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=0)
+
# Execute & Verify
with pytest.raises(ValueError, match='Sandbox Spec not found'):
await remote_sandbox_service.start_sandbox('non-existent-spec')
@@ -462,6 +480,12 @@ class TestSandboxLifecycle:
remote_sandbox_service.httpx_client.request.return_value = mock_response
remote_sandbox_service.pause_old_sandboxes = AsyncMock(return_value=[])
+ # Mock concurrency limit methods
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=10
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=0)
+
# Mock database operations
remote_sandbox_service.db_session.add = MagicMock()
remote_sandbox_service.db_session.commit = AsyncMock()
@@ -485,6 +509,13 @@ class TestSandboxLifecycle:
'API Error'
)
remote_sandbox_service.pause_old_sandboxes = AsyncMock(return_value=[])
+
+ # Mock concurrency limit methods
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=10
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=0)
+
remote_sandbox_service.db_session.add = MagicMock()
remote_sandbox_service.db_session.commit = AsyncMock()
@@ -502,6 +533,13 @@ class TestSandboxLifecycle:
mock_response.json.return_value = create_runtime_data()
remote_sandbox_service.httpx_client.request.return_value = mock_response
remote_sandbox_service.pause_old_sandboxes = AsyncMock(return_value=[])
+
+ # Mock concurrency limit methods
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=10
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=0)
+
remote_sandbox_service.db_session.add = MagicMock()
remote_sandbox_service.db_session.commit = AsyncMock()
@@ -1157,6 +1195,293 @@ class TestConstants:
assert ALLOW_CORS_ORIGINS_VARIABLE == 'OH_ALLOW_CORS_ORIGINS_0'
+class TestConcurrencyLimits:
+ """Test cases for sandbox concurrency limit enforcement.
+
+ Tests the _get_user_effective_sandbox_limit, _count_user_running_sandboxes,
+ and start_sandbox limit enforcement functionality.
+
+ NOTE: Tests involving enterprise storage modules (UserStore, OrgMemberStore,
+ OrgStore) are in enterprise/tests/unit/ since they require enterprise modules.
+ """
+
+ @pytest.mark.asyncio
+ async def test_get_effective_limit_delegates_to_user_context(
+ self, remote_sandbox_service
+ ):
+ """Test that _get_user_effective_sandbox_limit delegates to UserContext."""
+ remote_sandbox_service.user_context.get_max_concurrent_sandboxes = AsyncMock(
+ return_value=5
+ )
+
+ result = await remote_sandbox_service._get_user_effective_sandbox_limit()
+
+ assert result == 5
+ remote_sandbox_service.user_context.get_max_concurrent_sandboxes.assert_called_once_with(
+ 10 # max_num_sandboxes passed as default
+ )
+
+ @pytest.mark.asyncio
+ async def test_get_effective_limit_passes_max_num_sandboxes_as_default(
+ self, remote_sandbox_service
+ ):
+ """Test that _get_user_effective_sandbox_limit passes max_num_sandboxes as default.
+
+ The global fallback (max_num_sandboxes=10) is passed to UserContext,
+ which can use it as the default in OSS mode.
+ """
+ remote_sandbox_service.user_context.get_max_concurrent_sandboxes = AsyncMock(
+ return_value=10
+ )
+
+ result = await remote_sandbox_service._get_user_effective_sandbox_limit()
+
+ assert result == 10 # global fallback (max_num_sandboxes)
+
+ @pytest.mark.asyncio
+ async def test_count_running_sandboxes_returns_zero_when_no_db_records(
+ self, remote_sandbox_service
+ ):
+ """Test that _count_user_running_sandboxes returns 0 when user has no sandboxes."""
+ mock_result = MagicMock()
+ mock_result.scalars.return_value.all.return_value = []
+ remote_sandbox_service.db_session.execute = AsyncMock(return_value=mock_result)
+
+ result = await remote_sandbox_service._count_user_running_sandboxes()
+
+ assert result == 0
+ # No runtime API call should be made
+ remote_sandbox_service.httpx_client.request.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_count_running_sandboxes_excludes_paused_sandboxes(
+ self, remote_sandbox_service
+ ):
+ """Test that _count_user_running_sandboxes only counts non-paused sandboxes."""
+ # DB returns 2 running sandboxes (is_paused=False) filtered by the query;
+ # paused sandboxes are excluded at the query level.
+ mock_result = MagicMock()
+ mock_result.scalars.return_value.all.return_value = [
+ create_stored_sandbox(sandbox_id='sandbox-1', is_paused=False),
+ create_stored_sandbox(sandbox_id='sandbox-2', is_paused=False),
+ ]
+ remote_sandbox_service.db_session.execute = AsyncMock(return_value=mock_result)
+
+ result = await remote_sandbox_service._count_user_running_sandboxes()
+
+ assert result == 2
+ # No runtime API call should be made
+ remote_sandbox_service.httpx_client.request.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_start_sandbox_raises_concurrency_error_when_at_limit(
+ self, remote_sandbox_service
+ ):
+ """Test that start_sandbox raises ConcurrencyLimitError when user is at limit."""
+ from openhands.app_server.errors import ConcurrencyLimitError
+
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=3
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=3)
+
+ with pytest.raises(ConcurrencyLimitError) as exc_info:
+ await remote_sandbox_service.start_sandbox()
+
+ assert exc_info.value.detail['limit'] == 3
+ assert exc_info.value.detail['current'] == 3
+ assert exc_info.value.status_code == 429
+
+ @pytest.mark.asyncio
+ async def test_start_sandbox_raises_concurrency_error_when_over_limit(
+ self, remote_sandbox_service
+ ):
+ """Test that start_sandbox raises ConcurrencyLimitError when user exceeds limit."""
+ from openhands.app_server.errors import ConcurrencyLimitError
+
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=5
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=7)
+
+ with pytest.raises(ConcurrencyLimitError) as exc_info:
+ await remote_sandbox_service.start_sandbox()
+
+ assert exc_info.value.detail['limit'] == 5
+ assert exc_info.value.detail['current'] == 7
+
+ @pytest.mark.asyncio
+ async def test_start_sandbox_allows_creation_when_under_limit(
+ self, remote_sandbox_service
+ ):
+ """Test that start_sandbox succeeds when user is under their limit."""
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=5
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=2)
+ remote_sandbox_service.pause_old_sandboxes = AsyncMock(return_value=[])
+
+ mock_response = MagicMock()
+ mock_response.raise_for_status.return_value = None
+ mock_response.json.return_value = {
+ 'session_id': 'new-sandbox-123',
+ 'status': 'running',
+ 'url': 'https://sandbox.example.com',
+ 'session_api_key': 'test-key',
+ 'runtime_id': 'runtime-456',
+ }
+ remote_sandbox_service.httpx_client.request = AsyncMock(
+ return_value=mock_response
+ )
+
+ result = await remote_sandbox_service.start_sandbox()
+
+ assert result is not None
+ assert result.id is not None
+
+ @pytest.mark.asyncio
+ async def test_start_sandbox_pauses_old_sandboxes_when_approaching_limit(
+ self, remote_sandbox_service
+ ):
+ """Test that start_sandbox calls pause_old_sandboxes when approaching limit."""
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=5
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=4)
+ remote_sandbox_service.pause_old_sandboxes = AsyncMock(return_value=[])
+
+ mock_response = MagicMock()
+ mock_response.raise_for_status.return_value = None
+ mock_response.json.return_value = {
+ 'session_id': 'new-sandbox-123',
+ 'status': 'running',
+ 'url': 'https://sandbox.example.com',
+ 'session_api_key': 'test-key',
+ 'runtime_id': 'runtime-456',
+ }
+ remote_sandbox_service.httpx_client.request = AsyncMock(
+ return_value=mock_response
+ )
+
+ await remote_sandbox_service.start_sandbox()
+
+ remote_sandbox_service.pause_old_sandboxes.assert_called_once_with(4)
+
+ @pytest.mark.asyncio
+ async def test_start_sandbox_does_not_pause_when_well_under_limit(
+ self, remote_sandbox_service
+ ):
+ """Test that start_sandbox does not pause sandboxes when well under limit."""
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=10
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=2)
+ remote_sandbox_service.pause_old_sandboxes = AsyncMock(return_value=[])
+
+ mock_response = MagicMock()
+ mock_response.raise_for_status.return_value = None
+ mock_response.json.return_value = {
+ 'session_id': 'new-sandbox-123',
+ 'status': 'running',
+ 'url': 'https://sandbox.example.com',
+ 'session_api_key': 'test-key',
+ 'runtime_id': 'runtime-456',
+ }
+ remote_sandbox_service.httpx_client.request = AsyncMock(
+ return_value=mock_response
+ )
+
+ await remote_sandbox_service.start_sandbox()
+
+ remote_sandbox_service.pause_old_sandboxes.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_start_sandbox_concurrency_error_not_wrapped_in_sandbox_error(
+ self, remote_sandbox_service
+ ):
+ """Test that ConcurrencyLimitError is raised directly, not wrapped in SandboxError."""
+ from openhands.app_server.errors import ConcurrencyLimitError
+
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=3
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=3)
+
+ with pytest.raises(ConcurrencyLimitError):
+ await remote_sandbox_service.start_sandbox()
+
+ # Verify it's not wrapped in SandboxError
+ try:
+ await remote_sandbox_service.start_sandbox()
+ except ConcurrencyLimitError:
+ pass # Expected
+ except SandboxError:
+ pytest.fail('ConcurrencyLimitError should not be wrapped in SandboxError')
+
+ @pytest.mark.asyncio
+ async def test_check_concurrency_limit_raises_when_at_limit(
+ self, remote_sandbox_service
+ ):
+ """Test that check_concurrency_limit raises ConcurrencyLimitError when at limit."""
+ from openhands.app_server.errors import ConcurrencyLimitError
+
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=3
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=3)
+
+ with pytest.raises(ConcurrencyLimitError) as exc_info:
+ await remote_sandbox_service.check_concurrency_limit()
+
+ assert exc_info.value.detail['limit'] == 3
+ assert exc_info.value.detail['current'] == 3
+ assert exc_info.value.status_code == 429
+
+ @pytest.mark.asyncio
+ async def test_check_concurrency_limit_raises_when_over_limit(
+ self, remote_sandbox_service
+ ):
+ """Test that check_concurrency_limit raises ConcurrencyLimitError when over limit."""
+ from openhands.app_server.errors import ConcurrencyLimitError
+
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=5
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=7)
+
+ with pytest.raises(ConcurrencyLimitError) as exc_info:
+ await remote_sandbox_service.check_concurrency_limit()
+
+ assert exc_info.value.detail['limit'] == 5
+ assert exc_info.value.detail['current'] == 7
+
+ @pytest.mark.asyncio
+ async def test_check_concurrency_limit_succeeds_when_under_limit(
+ self, remote_sandbox_service
+ ):
+ """Test that check_concurrency_limit succeeds when under limit."""
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=5
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=2)
+
+ # Should not raise
+ await remote_sandbox_service.check_concurrency_limit()
+
+ @pytest.mark.asyncio
+ async def test_check_concurrency_limit_succeeds_when_well_under_limit(
+ self, remote_sandbox_service
+ ):
+ """Test that check_concurrency_limit succeeds when well under limit."""
+ remote_sandbox_service._get_user_effective_sandbox_limit = AsyncMock(
+ return_value=10
+ )
+ remote_sandbox_service._count_user_running_sandboxes = AsyncMock(return_value=0)
+
+ # Should not raise
+ await remote_sandbox_service.check_concurrency_limit()
+
+
def _async_cm_factory(value):
"""Return a callable that yields ``value`` as an async context manager.
diff --git a/tests/unit/app_server/test_sandbox_service.py b/tests/unit/app_server/test_sandbox_service.py
index f5464196a3..66890824da 100644
--- a/tests/unit/app_server/test_sandbox_service.py
+++ b/tests/unit/app_server/test_sandbox_service.py
@@ -366,3 +366,35 @@ class TestCleanupOldSandboxes:
# Verify: No sandboxes should be stopped
assert result == []
mock_sandbox_service.pause_sandbox_mock.assert_not_called()
+
+
+class TestCheckConcurrencyLimit:
+ """Test cases for the check_concurrency_limit method."""
+
+ @pytest.mark.asyncio
+ async def test_check_concurrency_limit_default_does_nothing(
+ self, mock_sandbox_service
+ ):
+ """Test that default check_concurrency_limit implementation does nothing.
+
+ The base SandboxService class provides a default no-op implementation
+ that subclasses can override to implement limit checking.
+ """
+ # Execute - should not raise
+ await mock_sandbox_service.check_concurrency_limit()
+
+ @pytest.mark.asyncio
+ async def test_check_concurrency_limit_returns_none(self, mock_sandbox_service):
+ """Test that default check_concurrency_limit returns None (implicitly)."""
+ result = await mock_sandbox_service.check_concurrency_limit()
+ assert result is None
+
+ @pytest.mark.asyncio
+ async def test_check_concurrency_limit_can_be_called_multiple_times(
+ self, mock_sandbox_service
+ ):
+ """Test that check_concurrency_limit can be called multiple times safely."""
+ # Should not raise on any call
+ await mock_sandbox_service.check_concurrency_limit()
+ await mock_sandbox_service.check_concurrency_limit()
+ await mock_sandbox_service.check_concurrency_limit()