🙌 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.pyindex 479c7ed98b..aaf24b04fe 100644--- a/enterprise/integrations/bitbucket/bitbucket_manager.py+++ b/enterprise/integrations/bitbucket/bitbucket_manager.py@@ -23,6 +23,7 @@ from pydantic import SecretStrfrom server.auth.token_manager import TokenManagerfrom storage.bitbucket_webhook_store import BitbucketWebhookStore+from openhands.app_server.errors import ConcurrencyLimitErrorfrom openhands.app_server.integrations.provider import ProviderToken, ProviderTypefrom openhands.app_server.secrets.secrets_models import Secretsfrom 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.pyindex 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_TOKENfrom server.auth.token_manager import TokenManagerfrom storage.bitbucket_dc_webhook_store import BitbucketDCWebhookStore+from openhands.app_server.errors import ConcurrencyLimitErrorfrom openhands.app_server.integrations.provider import ProviderToken, ProviderTypefrom openhands.app_server.secrets.secrets_models import Secretsfrom 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.pyindex 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 ExpiredErrorfrom server.auth.constants import GITHUB_APP_CLIENT_ID, GITHUB_APP_PRIVATE_KEYfrom server.auth.token_manager import TokenManager+from openhands.app_server.errors import ConcurrencyLimitErrorfrom openhands.app_server.integrations.provider import ProviderToken, ProviderTypefrom openhands.app_server.integrations.service_types import AuthenticationErrorfrom 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.pyindex 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, FileSystemLoaderfrom pydantic import SecretStrfrom server.auth.token_manager import TokenManager+from openhands.app_server.errors import ConcurrencyLimitErrorfrom openhands.app_server.integrations.gitlab.gitlab_service import GitLabServiceImplfrom openhands.app_server.integrations.provider import ProviderToken, ProviderTypefrom 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 messageawait self.send_message(msg_info, gitlab_view)diff --git a/enterprise/integrations/jira/jira_manager.py b/enterprise/integrations/jira/jira_manager.pyindex 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 JiraIntegrationStorefrom storage.jira_user import JiraUserfrom storage.jira_workspace import JiraWorkspace+from openhands.app_server.errors import ConcurrencyLimitErrorfrom 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.pyindex 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 JiraDcIntegrationStorefrom storage.jira_dc_user import JiraDcUserfrom storage.jira_dc_workspace import JiraDcWorkspace+from openhands.app_server.errors import ConcurrencyLimitErrorfrom openhands.app_server.integrations.provider import ProviderHandlerfrom openhands.app_server.integrations.service_types import Comment, Repositoryfrom 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=Truediff --git a/enterprise/integrations/resolver_context.py b/enterprise/integrations/resolver_context.pyindex 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.pyindex 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.pyindex 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_makerfrom storage.redis import get_redis_client_asyncfrom storage.slack_user import SlackUser+from openhands.app_server.errors import ConcurrencyLimitErrorfrom openhands.app_server.integrations.provider import ProviderHandlerfrom 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.pynew file mode 100644index 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.pyindex 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 OrgMemberStorefrom storage.role import Rolefrom 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_idfrom 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.pyindex 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+@classmethodasync 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.pyindex 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 litellmDEFAULT_BILLING_MARGIN = float(os.environ.get('DEFAULT_BILLING_MARGIN', '1.0'))diff --git a/enterprise/server/email_validation.py b/enterprise/server/email_validation.pyindex 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, statusfrom openhands.app_server.user_auth import get_user_auth, get_user_idfrom 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.pyindex 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 Orgfrom storage.org_member import OrgMemberfrom storage.role import Role@@ -183,6 +187,7 @@ class OrgResponse(BaseModel):v1_enabled: bool | None = Nonecredits: float | None = Noneis_personal: bool = False+ max_concurrent_sandboxes: int = DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES@classmethoddef 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 = Noneagent_settings_diff: dict[str, Any] | None = Noneconversation_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: strrole_rank: intstatus: str | None+ max_concurrent_sandboxes_override: int | None = None+ effective_max_concurrent_sandboxes: int = DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXESclass 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@staticmethoddef _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 = Truemax_budget_per_task: float | None = None+ max_concurrent_sandboxes: int = DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXES@classmethoddef from_org(cls, org: Org) -> 'OrgAppSettingsResponse':@@ -563,6 +590,9 @@ class OrgAppSettingsResponse(BaseModel):if org.enable_proactive_conversation_starters is not Noneelse 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 = Nonemax_budget_per_task: float | None = None+ max_concurrent_sandboxes: int | None = Field(default=None, gt=0, le=100)@field_validator('max_budget_per_task')@classmethoddiff --git a/enterprise/server/routes/orgs.py b/enterprise/server/routes/orgs.pyindex a83abb4601..be57de4b43 100644--- a/enterprise/server/routes/orgs.py+++ b/enterprise/server/routes/orgs.py@@ -1,10 +1,11 @@from typing import Annotatedfrom uuid import UUID-from fastapi import APIRouter, Depends, HTTPException, Query, status+from fastapi import APIRouter, Depends, HTTPException, Query, Request, statusfrom 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 objectupdate_data: App settings update dataservice: 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 emailHTTPException: 404 if current organization not foundHTTPException: 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 objectorg_id: Organization ID to update (UUID)update_data: Organization update datauser_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 emailHTTPException: 404 if organization not foundHTTPException: 409 if organization name already existsHTTPException: 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 OwnersMembers 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.pyindex 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 LiteLlmManagerfrom storage.org_member_store import OrgMemberStore+from storage.org_store import OrgStorefrom storage.role_store import RoleStorefrom 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+ )@staticmethodasync 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 membersmembers, _ = await OrgMemberStore.get_org_members_paginated(org_id=org_id,@@ -113,6 +136,13 @@ class OrgMemberService:user = member.userrole = 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 responseuser = 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,)@staticmethoddiff --git a/enterprise/storage/org.py b/enterprise/storage/org.pyindex 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, Anyfrom uuid import UUID, uuid4from 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, Stringfrom sqlalchemy.orm import Mapped, mapped_column, relationshipfrom 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=Truediff --git a/enterprise/storage/org_member.py b/enterprise/storage/org_member.pyindex 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, Anyfrom 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)# Relationshipsorg: Mapped['Org'] = relationship('Org', back_populates='org_members')diff --git a/enterprise/storage/org_service.py b/enterprise/storage/org_service.pyindex bf6466fac9..be82afe473 100644--- a/enterprise/storage/org_service.py+++ b/enterprise/storage/org_service.py@@ -8,6 +8,7 @@ from uuid import UUID, uuid4from uuid import UUID as parse_uuidfrom 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,)@staticmethoddiff --git a/enterprise/storage/user_store.py b/enterprise/storage/user_store.pyindex e1ee4e0725..5f8b7cd719 100644--- a/enterprise/storage/user_store.py+++ b/enterprise/storage/user_store.py@@ -7,6 +7,7 @@ from uuid import UUIDfrom server.auth.token_manager import TokenManagerfrom 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.pyindex 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.asyncioasync 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_idresult = 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.asyncioasync 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 & Assertwith 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 & Assertwith 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.asyncioasync 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 & Assertwith 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.asyncioasync 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 & Assertwith 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.asyncioasync 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 & Assertwith 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.asyncioasync 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 & Assertwith 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.pyindex 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, patchimport pytestfrom pydantic import SecretStr+from server.constants import DEFAULT_PERSONAL_ORG_CONCURRENT_SANDBOXESfrom 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.asyncioasync 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_ownermock_get_paginated.return_value = ([mock_org_member], False)+ mock_get_org.return_value = mock_org# Actsuccess, error_code, data = await OrgMemberService.get_org_members(@@ -259,7 +279,12 @@ class TestOrgMemberServiceGetOrgMembers:@pytest.mark.asyncioasync 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_ownermock_get_paginated.return_value = ([mock_org_member], False)+ mock_get_org.return_value = mock_org# Actsuccess, error_code, data = await OrgMemberService.get_org_members(@@ -294,7 +324,12 @@ class TestOrgMemberServiceGetOrgMembers:@pytest.mark.asyncioasync 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_ownermock_get_paginated.return_value = ([mock_org_member], True)+ mock_get_org.return_value = mock_org# Actsuccess, error_code, data = await OrgMemberService.get_org_members(@@ -329,7 +369,12 @@ class TestOrgMemberServiceGetOrgMembers:@pytest.mark.asyncioasync 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_ownermock_get_paginated.return_value = ([mock_org_member], False)+ mock_get_org.return_value = mock_org# Actsuccess, error_code, data = await OrgMemberService.get_org_members(@@ -361,7 +411,7 @@ class TestOrgMemberServiceGetOrgMembers:@pytest.mark.asyncioasync 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_ownermock_get_paginated.return_value = ([], False)+ mock_get_org.return_value = mock_org# Actsuccess, error_code, data = await OrgMemberService.get_org_members(@@ -393,7 +448,7 @@ class TestOrgMemberServiceGetOrgMembers:@pytest.mark.asyncioasync 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_ownermock_get_paginated.return_value = ([member_no_user], False)+ mock_get_org.return_value = mock_org# Actsuccess, error_code, data = await OrgMemberService.get_org_members(@@ -434,7 +494,7 @@ class TestOrgMemberServiceGetOrgMembers:@pytest.mark.asyncioasync 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_ownermock_get_paginated.return_value = ([member_no_role], False)+ mock_get_org.return_value = mock_org# Actsuccess, error_code, data = await OrgMemberService.get_org_members(@@ -476,7 +541,13 @@ class TestOrgMemberServiceGetOrgMembers:@pytest.mark.asyncioasync 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_ownermock_get_paginated.return_value = ([member1, member2], False)+ mock_get_org.return_value = mock_org# Actsuccess, error_code, data = await OrgMemberService.get_org_members(@@ -524,7 +600,12 @@ class TestOrgMemberServiceGetOrgMembers:@pytest.mark.asyncioasync 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_ownermock_get_paginated.return_value = ([mock_org_member], False)+ mock_get_org.return_value = mock_org# Actawait OrgMemberService.get_org_members(@@ -557,7 +643,12 @@ class TestOrgMemberServiceGetOrgMembers:@pytest.mark.asyncioasync 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_ownermock_get_paginated.return_value = ([mock_org_member], True)+ mock_get_org.return_value = mock_org# Act - Request page 2 (offset 10) with limit 10success, 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_rolemock_update.return_value = updated_membermock_get_user.return_value = mock_user+ mock_get_org.return_value = mock_org# Actdata = 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_rolemock_update.return_value = updated_membermock_get_user.return_value = mock_user+ mock_get_org.return_value = mock_org# Actdata = 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_rolemock_update.return_value = updated_membermock_get_user.return_value = mock_user+ mock_get_org.return_value = mock_org# Actdata = 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_rolemock_update.return_value = updated_membermock_get_user.return_value = mock_user+ mock_get_org.return_value = mock_org# Actdata = 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 & Assertwith 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_orgmock_can_update.return_value = Truemock_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# Actdata = await OrgMemberService.update_org_member(@@ -2246,7 +2384,7 @@ class TestOrgMemberServiceGetMe:@pytest.mark.asyncioasync 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 organizationWHEN: 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_membermock_get_role.return_value = owner_rolemock_get_user.return_value = mock_user+ mock_get_org.return_value = mock_org# Actresult = await OrgMemberService.get_me(org_id, current_user_id)@@ -2333,7 +2476,7 @@ class TestOrgMemberServiceGetMe:@pytest.mark.asyncioasync 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 NoneWHEN: 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_membermock_get_role.return_value = owner_rolemock_get_user.return_value = None+ mock_get_org.return_value = mock_org# Actresult = await OrgMemberService.get_me(org_id, current_user_id)# Assertassert 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.pyindex 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 == 403assert '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 == 403diff --git a/enterprise/tests/unit/test_email_validation_dependency.py b/enterprise/tests/unit/test_email_validation_dependency.pyindex 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, patchimport pytestfrom 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 == 401assert '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 Truediff --git a/enterprise/tests/unit/test_org_models_concurrency_limits.py b/enterprise/tests/unit/test_org_models_concurrency_limits.pynew file mode 100644index 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.pyindex 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 Noneassert 'OPENHANDS_API_KEY' in result.custom_secretsassert 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 == 10diff --git a/frontend/__tests__/components/features/org/conversation-limit-modal.test.tsx b/frontend/__tests__/components/features/org/conversation-limit-modal.test.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsindex 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-seimport { 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.tsindex 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.tsindex 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.jsonindex 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.tsxindex 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 authenticateduseAutoAcceptInvitation();+ // Conversation limit modal state+ const {+ isOpen: isConversationLimitModalOpen,+ limit: conversationLimit,+ closeLimitModal,+ } = useConversationLimitStore();+// Auto-login if login method is stored in local storageuseAutoLogin();@@ -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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.pyindex 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 taskuser_id = await self.user_context.get_user_id()# Prefer the user's email as the Laminar trace user id so traces arediff --git a/openhands/app_server/app_lifespan/alembic/versions/011.py b/openhands/app_server/app_lifespan/alembic/versions/011.pynew file mode 100644index 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.pyindex 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.pyindex 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 base62import httpxfrom fastapi import Requestfrom pydantic import Field-from sqlalchemy import String, func, select+from sqlalchemy import Boolean, String, func, selectfrom sqlalchemy.ext.asyncio import AsyncSessionfrom sqlalchemy.orm import Mapped, mapped_column@@ -24,7 +24,7 @@ from openhands.agent_server.utils import utc_nowfrom openhands.app_server.app_conversation.app_conversation_models import (AppConversationInfo,)-from openhands.app_server.errors import SandboxError+from openhands.app_server.errors import ConcurrencyLimitError, SandboxErrorfrom 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 timeif 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 creationuser_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 variablesenvironment = 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+ raiseexcept 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 = Falsereturn Trueexcept 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 = Trueruntime_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: E712StoredRemoteSandbox.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.pyindex 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.pyindex 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.pyindex 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.pyindex 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@abstractmethodasync 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.pynew file mode 100644index 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.pyindex 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.pyindex 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_responseremote_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 operationsremote_sandbox_service.db_session.add = MagicMock()remote_sandbox_service.db_session.commit = AsyncMock()@@ -408,9 +416,6 @@ class TestSandboxLifecycle:# Verifyassert 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 - 1remote_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_responseremote_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 = Noneremote_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 & Verifywith 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_responseremote_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 operationsremote_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_responseremote_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.pyindex 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 stoppedassert 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()