π OpenHands: AI-Driven Development
fix: add managed LLM key refresh endpoint (#15023)
Graham Neubigfad3228f0cfe
diff --git a/enterprise/server/routes/api_keys.py b/enterprise/server/routes/api_keys.pyindex 8f8049571a..8f79822109 100644--- a/enterprise/server/routes/api_keys.py+++ b/enterprise/server/routes/api_keys.py@@ -14,6 +14,10 @@ from storage.lite_llm_manager import LiteLlmManagerfrom storage.org_member import OrgMemberfrom storage.org_member_store import OrgMemberStorefrom storage.org_service import OrgService+from storage.saas_settings_store import (+ ManagedLlmKeyStatus,+ SaasSettingsStore,+)from storage.user_store import UserStorefrom openhands.app_server.user_auth import get_user_auth, get_user_id@@ -171,6 +175,10 @@ class LlmApiKeyResponse(BaseModel):key: str | None+class ManagedLlmApiKeyRefreshResponse(BaseModel):+ refreshed: bool++class ByorPermittedResponse(BaseModel):permitted: bool@@ -427,6 +435,91 @@ async def get_current_api_key()+@api_router.post(+ '/llm/managed/refresh',+ tags=['Keys'],+ response_model=ManagedLlmApiKeyRefreshResponse,+)+async def refresh_managed_llm_api_key(+ user_id: str = Depends(get_user_id),+ effective_org_id: UUID = EFFECTIVE_ORG_ID,+) -> ManagedLlmApiKeyRefreshResponse:+ """Refresh the managed OpenHands LiteLLM key for the current user/org.++ Delegates the full managed-key lifecycle (effective-config classification,+ alias cleanup, key generation with OpenHands metadata, and persistence) to+ ``SaasSettingsStore.rotate_managed_llm_key`` so the route does not+ duplicate the storage-layer machinery. Only managed LiteLLM/OpenHands-+ provider effective configs are rotated; BYOK/custom and non-managed configs+ are rejected before any key is generated. The previous key token is deleted+ best-effort only after the replacement is persisted.+ """+ logger.info(+ 'Starting managed LLM API key refresh',+ extra={'user_id': user_id, 'org_id': str(effective_org_id)},+ )++ try:+ settings_store = await SaasSettingsStore.get_instance(+ user_id, effective_org_id=effective_org_id+ )+ rotation = await settings_store.rotate_managed_llm_key()++ if rotation.status == ManagedLlmKeyStatus.NOT_MANAGED:+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail='Cannot refresh a non-managed LLM API key as a managed key.',+ )+ if rotation.status == ManagedLlmKeyStatus.BYOK:+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail='Cannot refresh a custom BYOK LLM API key as a managed key.',+ )+ if rotation.status == ManagedLlmKeyStatus.MISSING_MEMBER:+ raise HTTPException(+ status_code=status.HTTP_404_NOT_FOUND,+ detail=(f'User {user_id} is not a member of org {effective_org_id}'),+ )++ # The replacement is already persisted; clean up the previous token+ # best-effort. The deterministic alias was already deleted by the+ # rotation, so failure here only leaves a stale token, not an orphan.+ if rotation.old_key and rotation.old_key != rotation.new_key:+ try:+ await LiteLlmManager.delete_key(rotation.old_key)+ except Exception as exc:+ logger.warning(+ 'Failed to delete previous managed LLM key after refresh',+ extra={+ 'user_id': user_id,+ 'org_id': str(effective_org_id),+ 'error': str(exc),+ },+ )++ logger.info(+ 'Managed LLM API key refresh completed successfully',+ extra={'user_id': user_id, 'org_id': str(effective_org_id)},+ )+ return ManagedLlmApiKeyRefreshResponse(refreshed=True)+ except HTTPException:+ raise+ except Exception as e:+ logger.exception(+ 'Unexpected error refreshing managed LLM API key',+ extra={+ 'user_id': user_id,+ 'org_id': str(effective_org_id),+ 'error': str(e),+ 'exception_type': type(e).__name__,+ },+ )+ raise HTTPException(+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ detail='Failed to refresh managed LLM API key',+ )++@api_router.get('/llm/byor', tags=['Keys'])async def get_llm_api_key_for_byor(user_id: str = Depends(get_user_id),diff --git a/enterprise/storage/saas_settings_store.py b/enterprise/storage/saas_settings_store.pyindex 5029d0452a..f91b77ace4 100644--- a/enterprise/storage/saas_settings_store.py+++ b/enterprise/storage/saas_settings_store.py@@ -45,6 +45,65 @@ from openhands.sdk.mcp.config import MCPServer, coerce_mcp_configfrom openhands.sdk.profiles import resolve_agent_profile+class ManagedLlmKeyStatus:+ """Outcomes for ``SaasSettingsStore.rotate_managed_llm_key``.++ Kept as plain string constants (not an Enum) so callers can compare+ against the literals without importing a type.+ """++ ROTATED = 'rotated'+ NOT_MANAGED = 'not_managed'+ BYOK = 'byok'+ MISSING_MEMBER = 'missing_member'+++@dataclass(frozen=True)+class ManagedLlmKeyConfig:+ """Whether an effective LLM config uses a managed LiteLLM/OpenHands key."""++ openhands_type: bool+++@dataclass(frozen=True)+class ManagedLlmKeyRotation:+ """Result of a managed-key rotation attempt."""++ status: str+ old_key: str | None = None+ new_key: str | None = None+ openhands_type: bool = False+++def managed_llm_key_config_from_model(+ llm_model: str | None, llm_base_url: str | None+) -> ManagedLlmKeyConfig | None:+ """Classify an effective LLM config as managed.++ Uses the same model/base_url logic as ``store()`` and+ ``OrgStore._maybe_get_managed_llm_key_for_user``.++ Returns ``None`` when the config is not a managed LiteLLM/OpenHands-provider+ configuration (e.g. member/org BYOK pointing at a third-party base_url).+ """+ openhands_type = is_openhands_model(llm_model)+ normalized_llm_base_url = llm_base_url.rstrip('/') if llm_base_url else None+ normalized_managed_base_url = (+ LITE_LLM_API_URL.rstrip('/') if LITE_LLM_API_URL else None+ )+ uses_openhands_provider_proxy = openhands_type and (+ normalized_llm_base_url is None+ or 'all-hands.dev' in normalized_llm_base_url.lower()+ )+ uses_managed_llm_key = (+ normalized_managed_base_url is not None+ and normalized_llm_base_url == normalized_managed_base_url+ ) or uses_openhands_provider_proxy+ if not uses_managed_llm_key:+ return None+ return ManagedLlmKeyConfig(openhands_type=openhands_type)++@dataclassclass SaasSettingsStore(SettingsStore):user_id: str@@ -56,21 +115,21 @@ class SaasSettingsStore(SettingsStore):effective_org_id: UUID | None = Nonedef _resolve_org_id(self, user: User) -> UUID:- """Return the effective org id for this request, or the user's- current org id as a fallback. The caller still needs to verify- that the user is a member of the returned org (handled in load/- store by the existing org_members lookup).+ """Return the effective org id for this request.- `user.current_org_id` is non-nullable on the ORM model, so the- result is always a UUID.+ Falls back to the user's current org id. The caller still needs to verify+ that the user is a member of the returned org (handled in load/store by+ the existing org_members lookup).++ `user.current_org_id` is non-nullable on the ORM model, so the result is+ always a UUID."""return self.effective_org_id or user.current_org_idasync def _get_user_settings_by_keycloak_id_async(self, keycloak_user_id: str, session=None) -> UserSettings | None:- """- Get UserSettings by keycloak_user_id (async version).+ """Get UserSettings by keycloak_user_id (async version).Args:keycloak_user_id: The keycloak user ID to search for@@ -564,6 +623,16 @@ class SaasSettingsStore(SettingsStore):normalized_llm_base_url == normalized_managed_base_urlor (normalized_llm_base_url is None and is_openhands_model(llm_model)))+ logger.info(+ 'saas_settings_store:store:managed_llm_config_decision',+ extra={+ 'user_id': self.user_id,+ 'org_id': str(org_id),+ 'model': llm_model,+ 'base_url': llm_base_url or '',+ 'uses_managed_llm_key': uses_managed_llm_key,+ },+ )if uses_managed_llm_key:await self._ensure_api_key(@@ -766,16 +835,42 @@ class SaasSettingsStore(SettingsStore):First checks if an existing key exists for the user and verifies itis valid in LiteLLM. If valid, reuses it. Otherwise, generates a new key."""-llm_api_key = item.agent_settings.llm.api_key+ logger.info(+ 'saas_settings_store:ensure_api_key:evaluate',+ extra={+ 'user_id': self.user_id,+ 'org_id': org_id,+ 'openhands_type': openhands_type,+ 'has_api_key': bool(llm_api_key),+ },+ )- # First, check if our current key is valid- if llm_api_key and not await LiteLlmManager.verify_existing_key(+ if not llm_api_key:+ logger.info(+ 'saas_settings_store:ensure_api_key:skip_missing_api_key',+ extra={'user_id': self.user_id, 'org_id': org_id},+ )+ return++ existing_key_valid = await LiteLlmManager.verify_existing_key(llm_api_key.get_secret_value(), # type: ignore[union-attr]self.user_id,org_id,openhands_type=openhands_type,- ):+ )+ logger.info(+ 'saas_settings_store:ensure_api_key:verify_existing_key',+ extra={+ 'user_id': self.user_id,+ 'org_id': org_id,+ 'openhands_type': openhands_type,+ 'existing_key_valid': existing_key_valid,+ },+ )++ # First, check if our current key is valid+ if not existing_key_valid:# Both branches mint one managed key per (user, org) under the same# deterministic alias, deleting any prior key first β so switching# the default to/from an openhands/* model never orphans a key.@@ -791,5 +886,140 @@ class SaasSettingsStore(SettingsStore):item.agent_settings.llm.api_key = SecretStr(generated_key)logger.info('saas_settings_store:store:generated_openhands_key',- extra={'user_id': self.user_id},+ extra={+ 'user_id': self.user_id,+ 'org_id': org_id,+ 'openhands_type': openhands_type,+ },+ )++ async def get_current_managed_llm_key(self) -> str | None:+ """Return the acting member's current managed key, if effective config uses it.++ This is intentionally stricter than ``load()``'s effective-key resolution:+ org-level keys and member BYOK/custom keys are treated as non-managed for+ this helper because rotating the member managed key would not affect the+ effective key used at runtime.+ """+ settings = await self.load()+ if settings is None:+ return None++ llm = settings.agent_settings.llm+ if managed_llm_key_config_from_model(llm.model, llm.base_url) is None:+ return None++ async with a_session_maker() as session:+ result = await session.execute(+ select(User)+ .options(joinedload(User.org_members))+ .filter(User.id == uuid.UUID(self.user_id))+ )+ user = result.scalars().first()+ if user is None:+ return None++ org_id = self._resolve_org_id(user)+ org = await session.get(Org, org_id)+ if org is None or org._llm_api_key:+ return None++ org_member = next(+ (om for om in user.org_members if om.org_id == org_id), None+ )+ if (+ org_member is None+ or org_member.has_custom_llm_api_key+ or not org_member._llm_api_key+ ):+ return None+ return org_member.llm_api_key.get_secret_value()++ async def rotate_managed_llm_key(self) -> ManagedLlmKeyRotation:+ """Force-rotate the managed LiteLLM/OpenHands key for this user/org.++ Centralizes the managed-key lifecycle so callers (e.g. the API-key+ refresh endpoint) don't re-implement it. The effective LLM config is+ resolved through ``load()`` (org defaults merged with the member+ diff, with org-default precedence), so non-managed configs β member+ BYOK or org-level BYOK pointing at a third-party base_url β are+ rejected before any key is generated.++ The new key is generated under the same deterministic alias as+ ``_ensure_api_key`` / ``OrgStore._maybe_get_managed_llm_key_for_user``+ (deleting any prior alias first to avoid orphaned keys) and carries+ ``{'type': 'openhands'}`` metadata when the effective model is an+ ``openhands/*`` model, matching ``verify_existing_key``'s contract.++ The replacement key is persisted on the acting member's row in the+ same session used to load it, so a member that disappears mid-rotation+ is reported explicitly (``MISSING_MEMBER``) rather than silently+ swallowed. The previous key token is returned for best-effort cleanup+ and is only exposed after a successful persist.+ """+ settings = await self.load()+ if settings is None:+ return ManagedLlmKeyRotation(status=ManagedLlmKeyStatus.MISSING_MEMBER)++ llm = settings.agent_settings.llm+ config = managed_llm_key_config_from_model(llm.model, llm.base_url)+ if config is None:+ return ManagedLlmKeyRotation(status=ManagedLlmKeyStatus.NOT_MANAGED)++ async with a_session_maker() as session:+ result = await session.execute(+ select(User)+ .options(joinedload(User.org_members))+ .filter(User.id == uuid.UUID(self.user_id))+ )+ user = result.scalars().first()+ if user is None:+ return ManagedLlmKeyRotation(status=ManagedLlmKeyStatus.MISSING_MEMBER)++ org_id = self._resolve_org_id(user)+ org = await session.get(Org, org_id)+ if org is None:+ return ManagedLlmKeyRotation(status=ManagedLlmKeyStatus.MISSING_MEMBER)+ if org._llm_api_key:+ return ManagedLlmKeyRotation(status=ManagedLlmKeyStatus.BYOK)++ org_member = next(+ (om for om in user.org_members if om.org_id == org_id), None+ )+ if org_member is None:+ return ManagedLlmKeyRotation(status=ManagedLlmKeyStatus.MISSING_MEMBER)++ if org_member.has_custom_llm_api_key:+ return ManagedLlmKeyRotation(status=ManagedLlmKeyStatus.BYOK)++ existing_key = org_member.llm_api_key if org_member._llm_api_key else None+ old_key = existing_key.get_secret_value() if existing_key else None++ org_id_str = str(org_id)+ # One managed key per (user, org) under the deterministic alias;+ # delete the alias first so rotation never orphans a prior key.+ key_alias = get_openhands_cloud_key_alias(self.user_id, org_id_str)+ await LiteLlmManager.delete_key_by_alias(key_alias=key_alias)+ new_key = await LiteLlmManager.generate_key(+ self.user_id,+ org_id_str,+ key_alias,+ {'type': 'openhands'} if config.openhands_type else None,+ )++ # Persist on the same member row we loaded, in the same session,+ # before exposing the old token for cleanup.+ org_member.llm_api_key = SecretStr(new_key)+ org_member.has_custom_llm_api_key = False+ await session.commit()++ logger.info(+ 'saas_settings_store:rotate_managed_llm_key:rotated',+ extra={'user_id': self.user_id, 'org_id': org_id_str},+ )+ return ManagedLlmKeyRotation(+ status=ManagedLlmKeyStatus.ROTATED,+ old_key=old_key,+ new_key=new_key,+ openhands_type=config.openhands_type,)diff --git a/enterprise/tests/unit/server/routes/test_api_keys.py b/enterprise/tests/unit/server/routes/test_api_keys.pyindex 823b6871cd..1f5b6f57eb 100644--- a/enterprise/tests/unit/server/routes/test_api_keys.py+++ b/enterprise/tests/unit/server/routes/test_api_keys.py@@ -1,5 +1,6 @@"""Unit tests for API keys routes, focusing on BYOR key validation and retrieval."""+import contextlibimport uuidfrom datetime import UTC, datetime, timedeltafrom unittest.mock import AsyncMock, MagicMock, patch@@ -9,19 +10,31 @@ import pytestfrom fastapi import HTTPExceptionfrom pydantic import SecretStrfrom server.auth.saas_user_auth import SaasUserAuth-from server.constants import BYOR_KEY_ALIAS_PATTERN+from server.constants import BYOR_KEY_ALIAS_PATTERN, ORG_SETTINGS_VERSIONfrom server.routes.api_keys import (ByorPermittedResponse,CurrentApiKeyResponse,LlmApiKeyResponse,+ ManagedLlmApiKeyRefreshResponse,_create_byor_key_alias,check_byor_permitted,delete_byor_key_from_litellm,generate_byor_key,get_current_api_key,get_llm_api_key_for_byor,+ refresh_managed_llm_api_key,)-from storage.lite_llm_manager import LiteLlmManager+from storage.lite_llm_manager import LiteLlmManager, get_openhands_cloud_key_alias+from storage.org import Org+from storage.org_member import OrgMember+from storage.role import Role+from storage.saas_settings_store import (+ ManagedLlmKeyConfig,+ ManagedLlmKeyStatus,+ SaasSettingsStore,+ managed_llm_key_config_from_model,+)+from storage.user import Userfrom openhands.app_server.user_auth.user_auth import AuthType@@ -392,6 +405,553 @@ class TestGetLlmApiKeyForByor:assert 'BYOR key export is not enabled' in exc_info.value.detail+class TestRefreshManagedLlmApiKey:+ """Test the managed LLM API key refresh endpoint.++ These tests exercise the REAL managed-key lifecycle+ (``SaasSettingsStore.rotate_managed_llm_key``) against an in-memory SQLite+ database, mocking only the external LiteLLM HTTP calls. They prove the+ actual managed-config classification (from effective org+member settings,+ with org-default precedence), the OpenHands metadata attachment, and the+ persist/missing-member behavior β not stubs of the route helpers.+ """++ MANAGED_BASE_URL = 'https://litellm.example.com'++ @pytest.fixture+ def managed_env(self):+ """Point the managed base_url at a constant value for classification."""+ with (+ patch('server.constants.LITE_LLM_API_URL', self.MANAGED_BASE_URL),+ patch('storage.lite_llm_manager.LITE_LLM_API_URL', self.MANAGED_BASE_URL),+ patch(+ 'storage.saas_settings_store.LITE_LLM_API_URL',+ self.MANAGED_BASE_URL,+ ),+ ):+ yield++ @staticmethod+ async def _seed(+ async_session_maker,+ *,+ llm_model='openhands/claude-sonnet-4',+ llm_base_url=None,+ member_custom=False,+ member_key='sk-old-managed-key',+ org_key=None,+ ):+ """Create a user/org/role/member with the given effective LLM config.++ The org's agent_settings carry the LLM model/base_url, so the effective+ config (org defaults merged with an empty member diff) is what+ ``load()`` resolves β exercising org-default precedence.+ Returns (user_id_str, org_id).+ """+ org_id = uuid.uuid4()+ user_id = uuid.uuid4()+ llm_settings = {'model': llm_model}+ if llm_base_url is not None:+ llm_settings['base_url'] = llm_base_url++ async with async_session_maker() as session:+ role = Role(name='owner', rank=1)+ org_kwargs = {+ 'id': org_id,+ 'name': f'test-org-{org_id}',+ 'org_version': ORG_SETTINGS_VERSION,+ 'agent_settings': {'llm': llm_settings},+ 'enable_proactive_conversation_starters': True,+ 'sandbox_grouping_strategy': 'NO_GROUPING',+ }+ if org_key is not None:+ org_kwargs['llm_api_key'] = org_key+ org = Org(**org_kwargs)+ user = User(+ id=user_id,+ current_org_id=org_id,+ enable_sound_notifications=False,+ git_full_clone=False,+ sandbox_grouping_strategy='NO_GROUPING',+ )+ session.add_all([role, org, user])+ await session.flush()+ member = OrgMember(+ org_id=org_id,+ user_id=user_id,+ role_id=role.id,+ llm_api_key=member_key,+ )+ member.has_custom_llm_api_key = member_custom+ session.add(member)+ await session.commit()+ return str(user_id), org_id++ @staticmethod+ async def _member_key(async_session_maker, org_id, user_id):+ from sqlalchemy import select++ async with async_session_maker() as session:+ member = (+ (+ await session.execute(+ select(OrgMember).where(+ OrgMember.org_id == org_id,+ OrgMember.user_id == uuid.UUID(user_id),+ )+ )+ )+ .scalars()+ .one()+ )+ return member++ @staticmethod+ def _session_patches(async_session_maker):+ """Point every store's session maker at the test DB."""+ return (+ patch('storage.user_store.a_session_maker', async_session_maker),+ patch('storage.org_store.a_session_maker', async_session_maker),+ patch('storage.saas_settings_store.a_session_maker', async_session_maker),+ )++ @staticmethod+ def _litellm_patches(*, generated_key='sk-new-managed-key'):+ """Patch only the external LiteLLM HTTP calls."""+ return (+ patch(+ 'storage.lite_llm_manager.LiteLlmManager.delete_key_by_alias',+ new_callable=AsyncMock,+ ),+ patch(+ 'storage.lite_llm_manager.LiteLlmManager.generate_key',+ new_callable=AsyncMock,+ return_value=generated_key,+ ),+ patch(+ 'storage.lite_llm_manager.LiteLlmManager.delete_key',+ new_callable=AsyncMock,+ ),+ )++ @classmethod+ @contextlib.contextmanager+ def _patched(cls, async_session_maker, *, generated_key='sk-new-managed-key'):+ """Enter session + LiteLLM patches together, yielding the LiteLLM mocks.++ (mock_delete_alias, mock_generate, mock_delete_token)+ """+ with contextlib.ExitStack() as stack:+ for p in cls._session_patches(async_session_maker):+ stack.enter_context(p)+ mock_delete_alias, mock_generate, mock_delete_token = (+ stack.enter_context(p)+ for p in cls._litellm_patches(generated_key=generated_key)+ )+ yield mock_delete_alias, mock_generate, mock_delete_token++ @classmethod+ @contextlib.contextmanager+ def _patched_route(+ cls, async_session_maker, user_id, org_id, *, generated_key='sk-new-managed-key'+ ):+ """Like ``_patched`` but also patches ``get_instance`` to return a real+ ``SaasSettingsStore`` bound to the test DB, so the route exercises the+ real rotation end-to-end.+ """+ with contextlib.ExitStack() as stack:+ for p in cls._session_patches(async_session_maker):+ stack.enter_context(p)+ mock_delete_alias, mock_generate, mock_delete_token = (+ stack.enter_context(p)+ for p in cls._litellm_patches(generated_key=generated_key)+ )+ stack.enter_context(+ patch(+ 'storage.saas_settings_store.SaasSettingsStore.get_instance',+ new_callable=AsyncMock,+ return_value=SaasSettingsStore(user_id, effective_org_id=org_id),+ )+ )+ yield mock_delete_alias, mock_generate, mock_delete_token++ # --- pure classification (no DB) ---++ def test_managed_config_detects_managed_base_url(self):+ with patch(+ 'storage.saas_settings_store.LITE_LLM_API_URL',+ 'https://litellm.example.com/',+ ):+ assert managed_llm_key_config_from_model(+ 'anthropic/claude-sonnet-4', 'https://litellm.example.com'+ ) == ManagedLlmKeyConfig(openhands_type=False)++ def test_managed_config_detects_openhands_model_without_base_url(self):+ with patch(+ 'storage.saas_settings_store.LITE_LLM_API_URL',+ 'https://litellm.example.com',+ ):+ assert managed_llm_key_config_from_model(+ 'openhands/claude-sonnet-4', None+ ) == ManagedLlmKeyConfig(openhands_type=True)++ def test_managed_config_detects_openhands_model_with_all_hands_base_url(self):+ with patch(+ 'storage.saas_settings_store.LITE_LLM_API_URL',+ 'https://litellm.example.com',+ ):+ assert managed_llm_key_config_from_model(+ 'openhands/claude-sonnet-4',+ 'https://llm-proxy.staging.all-hands.dev/v1',+ ) == ManagedLlmKeyConfig(openhands_type=True)++ def test_managed_config_rejects_openhands_model_custom_base_url(self):+ with patch(+ 'storage.saas_settings_store.LITE_LLM_API_URL',+ 'https://litellm.example.com',+ ):+ assert (+ managed_llm_key_config_from_model(+ 'openhands/claude-sonnet-4', 'https://custom-llm.example.com'+ )+ is None+ )++ def test_managed_config_rejects_non_managed_provider_base_url(self):+ with patch(+ 'storage.saas_settings_store.LITE_LLM_API_URL',+ 'https://litellm.example.com',+ ):+ assert (+ managed_llm_key_config_from_model(+ 'anthropic/claude-sonnet-4', 'https://api.anthropic.com'+ )+ is None+ )++ # --- real rotate_managed_llm_key behavior ---++ @pytest.mark.asyncio+ async def test_rotate_openhands_model_attaches_openhands_metadata(+ self, async_session_maker, managed_env+ ):+ """An openhands/* effective config rotates with {'type': 'openhands'}."""+ user_id, org_id = await self._seed(async_session_maker)++ with self._patched(async_session_maker) as (+ mock_delete_alias,+ mock_generate,+ mock_delete_token,+ ):+ store = SaasSettingsStore(user_id, effective_org_id=org_id)+ rotation = await store.rotate_managed_llm_key()++ assert rotation.status == ManagedLlmKeyStatus.ROTATED+ assert rotation.openhands_type is True+ assert rotation.old_key == 'sk-old-managed-key'+ assert rotation.new_key == 'sk-new-managed-key'++ expected_alias = get_openhands_cloud_key_alias(user_id, str(org_id))+ # The alias is deleted before generating, so rotation never orphans.+ mock_delete_alias.assert_awaited_once_with(key_alias=expected_alias)+ mock_generate.assert_awaited_once_with(+ user_id, str(org_id), expected_alias, {'type': 'openhands'}+ )+ # The previous token is NOT deleted by the store; the route does that.+ mock_delete_token.assert_not_called()++ member = await self._member_key(async_session_maker, org_id, user_id)+ assert member.llm_api_key.get_secret_value() == 'sk-new-managed-key'+ assert member.has_custom_llm_api_key is False++ @pytest.mark.asyncio+ async def test_rotate_managed_base_url_attaches_no_openhands_metadata(+ self, async_session_maker, managed_env+ ):+ """A non-openhands model on the managed base_url rotates without the+ openhands metadata marker.+ """+ user_id, org_id = await self._seed(+ async_session_maker,+ llm_model='anthropic/claude-sonnet-4',+ llm_base_url=self.MANAGED_BASE_URL,+ )++ with self._patched(async_session_maker) as (+ mock_delete_alias,+ mock_generate,+ _mock_delete_token,+ ):+ store = SaasSettingsStore(user_id, effective_org_id=org_id)+ rotation = await store.rotate_managed_llm_key()++ assert rotation.status == ManagedLlmKeyStatus.ROTATED+ assert rotation.openhands_type is False+ expected_alias = get_openhands_cloud_key_alias(user_id, str(org_id))+ mock_delete_alias.assert_awaited_once_with(key_alias=expected_alias)+ mock_generate.assert_awaited_once_with(+ user_id, str(org_id), expected_alias, None+ )++ @pytest.mark.asyncio+ async def test_rotate_non_managed_byok_base_url_is_rejected(+ self, async_session_maker, managed_env+ ):+ """A config pointing at a third-party base_url is NOT managed and is+ rejected before any key is generated or stored.+ """+ user_id, org_id = await self._seed(+ async_session_maker,+ llm_model='anthropic/claude-sonnet-4',+ llm_base_url='https://api.anthropic.com',+ )++ with self._patched(async_session_maker) as (+ mock_delete_alias,+ mock_generate,+ mock_delete_token,+ ):+ store = SaasSettingsStore(user_id, effective_org_id=org_id)+ rotation = await store.rotate_managed_llm_key()++ assert rotation.status == ManagedLlmKeyStatus.NOT_MANAGED+ mock_delete_alias.assert_not_called()+ mock_generate.assert_not_called()+ mock_delete_token.assert_not_called()++ member = await self._member_key(async_session_maker, org_id, user_id)+ assert member.llm_api_key.get_secret_value() == 'sk-old-managed-key'++ @pytest.mark.asyncio+ async def test_rotate_custom_byok_member_is_rejected(+ self, async_session_maker, managed_env+ ):+ """A member flagged BYOK (has_custom_llm_api_key) is rejected even when+ the effective model/base_url would otherwise be managed.+ """+ user_id, org_id = await self._seed(async_session_maker, member_custom=True)++ with self._patched(async_session_maker) as (+ mock_delete_alias,+ mock_generate,+ _mock_delete_token,+ ):+ store = SaasSettingsStore(user_id, effective_org_id=org_id)+ rotation = await store.rotate_managed_llm_key()++ assert rotation.status == ManagedLlmKeyStatus.BYOK+ mock_delete_alias.assert_not_called()+ mock_generate.assert_not_called()++ @pytest.mark.asyncio+ async def test_rotate_org_level_byok_key_is_rejected(+ self, async_session_maker, managed_env+ ):+ """An org-level key has precedence over the member managed key, so+ rotating the member key would not affect the effective runtime key.+ """+ user_id, org_id = await self._seed(async_session_maker, org_key='sk-org-byok')++ with self._patched(async_session_maker) as (+ mock_delete_alias,+ mock_generate,+ _mock_delete_token,+ ):+ store = SaasSettingsStore(user_id, effective_org_id=org_id)+ rotation = await store.rotate_managed_llm_key()+ current_key = await store.get_current_managed_llm_key()++ assert rotation.status == ManagedLlmKeyStatus.BYOK+ assert current_key is None+ mock_delete_alias.assert_not_called()+ mock_generate.assert_not_called()++ @pytest.mark.asyncio+ async def test_rotate_missing_member_does_not_persist_or_delete_old_key(+ self, async_session_maker, managed_env, session_maker+ ):+ """If the member row is gone at persist time, rotation reports+ MISSING_MEMBER, generates nothing, and does not delete the old key.+ """+ user_id, org_id = await self._seed(async_session_maker)+ # Drop the membership so load() resolves no acting member.+ with session_maker() as sync_session:+ from sqlalchemy import delete as sa_delete++ sync_session.execute(+ sa_delete(OrgMember).where(+ OrgMember.org_id == org_id,+ OrgMember.user_id == uuid.UUID(user_id),+ )+ )+ sync_session.commit()++ with self._patched(async_session_maker) as (+ mock_delete_alias,+ mock_generate,+ mock_delete_token,+ ):+ store = SaasSettingsStore(user_id, effective_org_id=org_id)+ rotation = await store.rotate_managed_llm_key()++ assert rotation.status == ManagedLlmKeyStatus.MISSING_MEMBER+ assert rotation.old_key is None+ assert rotation.new_key is None+ mock_delete_alias.assert_not_called()+ mock_generate.assert_not_called()+ mock_delete_token.assert_not_called()++ # --- endpoint wiring (delegates to the real store) ---++ @pytest.mark.asyncio+ async def test_route_refreshes_and_deletes_previous_token(+ self, async_session_maker, managed_env+ ):+ """The endpoint delegates to the real store and best-effort deletes the+ old token only after the new key is persisted.+ """+ user_id, org_id = await self._seed(async_session_maker)++ with self._patched_route(async_session_maker, user_id, org_id) as (+ mock_delete_alias,+ mock_generate,+ mock_delete_token,+ ):+ result = await refresh_managed_llm_api_key(+ user_id=user_id, effective_org_id=org_id+ )++ assert result == ManagedLlmApiKeyRefreshResponse(refreshed=True)+ mock_delete_alias.assert_awaited_once()+ mock_generate.assert_awaited_once()+ # The old token is deleted best-effort after persist.+ mock_delete_token.assert_awaited_once_with('sk-old-managed-key')++ @pytest.mark.asyncio+ async def test_route_rejects_non_managed_effective_config(+ self, async_session_maker, managed_env+ ):+ user_id, org_id = await self._seed(+ async_session_maker,+ llm_model='anthropic/claude-sonnet-4',+ llm_base_url='https://api.anthropic.com',+ )++ with self._patched_route(async_session_maker, user_id, org_id) as (+ mock_delete_alias,+ mock_generate,+ mock_delete_token,+ ):+ with pytest.raises(HTTPException) as exc_info:+ await refresh_managed_llm_api_key(+ user_id=user_id, effective_org_id=org_id+ )++ assert exc_info.value.status_code == 400+ assert 'non-managed LLM API key' in exc_info.value.detail+ mock_delete_alias.assert_not_called()+ mock_generate.assert_not_called()+ mock_delete_token.assert_not_called()++ @pytest.mark.asyncio+ async def test_route_custom_byok_member_returns_400(+ self, async_session_maker, managed_env+ ):+ user_id, org_id = await self._seed(async_session_maker, member_custom=True)++ with self._patched_route(async_session_maker, user_id, org_id) as (+ mock_delete_alias,+ mock_generate,+ _mock_delete_token,+ ):+ with pytest.raises(HTTPException) as exc_info:+ await refresh_managed_llm_api_key(+ user_id=user_id, effective_org_id=org_id+ )++ assert exc_info.value.status_code == 400+ assert 'custom BYOK' in exc_info.value.detail+ mock_delete_alias.assert_not_called()+ mock_generate.assert_not_called()++ @pytest.mark.asyncio+ async def test_route_missing_member_returns_404_without_rotating(+ self, async_session_maker, managed_env+ ):+ """User belongs to no member row for the effective org."""+ user_id, _org_id = await self._seed(async_session_maker)+ other_org_id = uuid.uuid4()+ async with async_session_maker() as session:+ session.add(+ Org(+ id=other_org_id,+ name=f'other-org-{other_org_id}',+ org_version=ORG_SETTINGS_VERSION,+ agent_settings={'llm': {'model': 'openhands/claude-sonnet-4'}},+ )+ )+ await session.commit()++ with self._patched_route(async_session_maker, user_id, other_org_id) as (+ mock_delete_alias,+ mock_generate,+ mock_delete_token,+ ):+ with pytest.raises(HTTPException) as exc_info:+ await refresh_managed_llm_api_key(+ user_id=user_id, effective_org_id=other_org_id+ )++ assert exc_info.value.status_code == 404+ mock_delete_alias.assert_not_called()+ mock_generate.assert_not_called()+ mock_delete_token.assert_not_called()++ @pytest.mark.asyncio+ async def test_route_continues_when_old_key_delete_fails(+ self, async_session_maker, managed_env+ ):+ user_id, org_id = await self._seed(async_session_maker)++ with (+ self._patched_route(async_session_maker, user_id, org_id) as (+ _mock_delete_alias,+ _mock_generate,+ _mock_delete_token_ok,+ ),+ patch(+ 'storage.lite_llm_manager.LiteLlmManager.delete_key',+ new_callable=AsyncMock,+ side_effect=Exception('delete failed'),+ ) as mock_delete_token,+ ):+ result = await refresh_managed_llm_api_key(+ user_id=user_id, effective_org_id=org_id+ )++ assert result == ManagedLlmApiKeyRefreshResponse(refreshed=True)+ mock_delete_token.assert_awaited_once_with('sk-old-managed-key')++ @pytest.mark.asyncio+ async def test_route_unexpected_error_returns_500(self, managed_env):+ user_id = str(uuid.uuid4())+ org_id = uuid.uuid4()+ mock_store = MagicMock()+ mock_store.rotate_managed_llm_key = AsyncMock(side_effect=RuntimeError('boom'))+ with patch(+ 'storage.saas_settings_store.SaasSettingsStore.get_instance',+ new_callable=AsyncMock,+ return_value=mock_store,+ ):+ with pytest.raises(HTTPException) as exc_info:+ await refresh_managed_llm_api_key(+ user_id=user_id, effective_org_id=org_id+ )++ assert exc_info.value.status_code == 500+ assert 'Failed to refresh managed LLM API key' in exc_info.value.detail++class TestDeleteByorKeyFromLitellm:"""Test the delete_byor_key_from_litellm function with alias cleanup."""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 e5a5f7686b..a9e3968dc5 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@@ -483,6 +483,16 @@ class LiveStatusAppConversationService(AppConversationServiceBase):):yield updated_task+ _logger.info(+ 'app_conversation_start:building_start_request',+ extra={+ 'user_id': user_id,+ 'task_id': str(task.id),+ 'conversation_id': str(conversation_id),+ 'agent_type': request.agent_type.value,+ 'llm_model_override': request.llm_model,+ },+ )launch_snapshot = await self._resolve_conversation_launch_snapshot(request.agent_profile_id)@@ -1291,6 +1301,197 @@ class LiveStatusAppConversationService(AppConversationServiceBase):})+ async def _maybe_refresh_managed_llm_key(self, user: UserInfo, llm: LLM) -> LLM:+ """Best-effort refresh for stale SaaS managed LiteLLM keys.++ This intentionally only runs for SaaS managed LiteLLM keys that are the+ current member's stored managed key. BYOK/custom keys and OSS/local+ deployments are left untouched.+ """+ _logger.debug(+ 'managed_llm_key_refresh:evaluate',+ extra={+ 'app_mode': self.app_mode,+ 'user_id': user.id,+ 'model': llm.model,+ 'base_url': str(llm.base_url or ''),+ 'has_api_key': bool(llm.api_key),+ },+ )++ if self.app_mode != 'saas':+ _logger.debug(+ 'managed_llm_key_refresh:skip_non_saas',+ extra={'app_mode': self.app_mode, 'user_id': user.id},+ )+ return llm++ if not user.id or not llm.api_key:+ _logger.debug(+ 'managed_llm_key_refresh:skip_prerequisite',+ extra={+ 'has_user_id': bool(user.id),+ 'has_api_key': bool(llm.api_key),+ 'model': llm.model,+ },+ )+ return llm++ try:+ from storage.lite_llm_manager import ( # type: ignore[import-not-found]+ LiteLlmManager,+ )+ from storage.saas_settings_store import ( # type: ignore[import-not-found]+ ManagedLlmKeyStatus,+ SaasSettingsStore,+ )++ from openhands.app_server.settings.settings_router import LITE_LLM_API_URL+ except Exception:+ _logger.warning(+ 'managed_llm_key_refresh:dependency_import_failed',+ extra={'user_id': user.id, 'model': llm.model},+ exc_info=True,+ )+ return llm++ normalized_base_url = (llm.base_url or '').strip().rstrip('/')+ managed_base_url = LITE_LLM_API_URL.rstrip('/')+ is_openhands_provider = bool(llm.model and llm.model.startswith('openhands/'))+ uses_openhands_provider_proxy = is_openhands_provider and (+ not normalized_base_url or 'all-hands.dev' in normalized_base_url.lower()+ )+ if (+ normalized_base_url != managed_base_url+ and not uses_openhands_provider_proxy+ ):+ _logger.debug(+ 'managed_llm_key_refresh:skip_non_managed_base_url',+ extra={+ 'user_id': user.id,+ 'model': llm.model,+ 'base_url': normalized_base_url or None,+ 'is_openhands_provider': is_openhands_provider,+ },+ )+ return llm++ key = (+ llm.api_key.get_secret_value()+ if isinstance(llm.api_key, SecretStr)+ else str(llm.api_key)+ )+ if not key or key == '**********':+ _logger.debug(+ 'managed_llm_key_refresh:skip_empty_or_masked_key',+ extra={+ 'user_id': user.id,+ 'model': llm.model,+ 'has_key': bool(key),+ 'is_masked_key': key == '**********',+ },+ )+ return llm++ get_effective_org_id = getattr(self.user_context, 'get_effective_org_id', None)+ if get_effective_org_id is None:+ _logger.debug(+ 'managed_llm_key_refresh:skip_missing_effective_org_getter',+ extra={'user_id': user.id, 'model': llm.model},+ )+ return llm++ try:+ org_id = await get_effective_org_id()+ if org_id is None:+ _logger.debug(+ 'managed_llm_key_refresh:skip_missing_effective_org',+ extra={'user_id': user.id, 'model': llm.model},+ )+ return llm++ _logger.debug(+ 'managed_llm_key_refresh:checking_current_key',+ extra={+ 'user_id': user.id,+ 'org_id': str(org_id),+ 'model': llm.model,+ 'base_url': normalized_base_url or None,+ 'uses_openhands_provider_proxy': uses_openhands_provider_proxy,+ },+ )+ settings_store = await SaasSettingsStore.get_instance(+ user.id, effective_org_id=org_id+ )+ managed_key = await settings_store.get_current_managed_llm_key()+ if managed_key is None:+ _logger.debug(+ 'managed_llm_key_refresh:skip_no_current_managed_key',+ extra={+ 'user_id': user.id,+ 'org_id': str(org_id),+ 'model': llm.model,+ },+ )+ return llm+ if managed_key != key:+ _logger.debug(+ 'managed_llm_key_refresh:skip_key_mismatch',+ extra={+ 'user_id': user.id,+ 'org_id': str(org_id),+ 'model': llm.model,+ },+ )+ return llm++ key_is_valid = await LiteLlmManager.verify_key(key, user.id)+ if key_is_valid:+ _logger.debug(+ 'managed_llm_key_refresh:skip_key_still_valid',+ extra={+ 'user_id': user.id,+ 'org_id': str(org_id),+ 'model': llm.model,+ },+ )+ return llm++ _logger.info(+ 'managed_llm_key_refresh:stale_key_detected',+ extra={'user_id': user.id, 'org_id': str(org_id), 'model': llm.model},+ )+ rotation = await settings_store.rotate_managed_llm_key()+ if rotation.status == ManagedLlmKeyStatus.ROTATED and rotation.new_key:+ _logger.info(+ 'managed_llm_key_refresh:rotated',+ extra={+ 'user_id': user.id,+ 'org_id': str(org_id),+ 'model': llm.model,+ 'openhands_type': getattr(rotation, 'openhands_type', None),+ },+ )+ return llm.model_copy(update={'api_key': SecretStr(rotation.new_key)})++ _logger.warning(+ 'managed_llm_key_refresh:rotation_not_applied',+ extra={+ 'user_id': user.id,+ 'org_id': str(org_id),+ 'model': llm.model,+ 'status': rotation.status,+ 'has_new_key': bool(rotation.new_key),+ },+ )+ except Exception:+ _logger.warning(+ 'Failed to refresh stale managed LLM key before conversation startup',+ extra={'user_id': user.id, 'model': llm.model},+ exc_info=True,+ )+ return llm+async def _add_system_mcp_servers(self, mcp_servers: dict[str, MCPServer], conversation_id: UUID) -> None:@@ -1373,8 +1574,20 @@ class LiveStatusAppConversationService(AppConversationServiceBase):"""# Configure LLMllm = self._configure_llm(user, llm_model)+ _logger.debug(+ 'managed_llm_key_refresh:configured_llm',+ extra={+ 'user_id': user.id,+ 'conversation_id': str(conversation_id),+ 'model': llm.model,+ 'base_url': str(llm.base_url or ''),+ 'has_api_key': bool(llm.api_key),+ 'llm_model_override': llm_model,+ },+ )+ llm = await self._maybe_refresh_managed_llm_key(user, llm)- mcp_servers: dict[str, Any] = {}+ mcp_servers: dict[str, MCPServer] = {}# Add system-generated servers (default MCP server with Tavily proxy)await self._add_system_mcp_servers(mcp_servers, conversation_id)@@ -1725,6 +1938,18 @@ class LiveStatusAppConversationService(AppConversationServiceBase):await self._resolve_conversation_launch_snapshot(agent_profile_id))user = launch_snapshot.user+ llm_settings = getattr(user.agent_settings, 'llm', None)+ _logger.debug(+ 'managed_llm_key_refresh:build_request_context',+ extra={+ 'user_id': user.id,+ 'conversation_id': str(conversation_id),+ 'agent_settings_type': type(user.agent_settings).__name__,+ 'model': getattr(llm_settings, 'model', None),+ 'base_url': str(getattr(llm_settings, 'base_url', None) or ''),+ 'has_api_key': bool(getattr(llm_settings, 'api_key', None)),+ },+ )# Compose instance + org + user marketplaces once for both arms below.# Enabled by default; inert (None) only when ENABLE_MARKETPLACE_PLUGIN_LOADING@@ -1733,6 +1958,16 @@ class LiveStatusAppConversationService(AppConversationServiceBase):# Route ACP agent settings to the ACP-specific builderif isinstance(user.agent_settings, ACPAgentSettings):+ _logger.debug(+ 'managed_llm_key_refresh:skip_acp_agent_settings',+ extra={+ 'user_id': user.id,+ 'conversation_id': str(conversation_id),+ 'model': getattr(llm_settings, 'model', None),+ 'base_url': str(getattr(llm_settings, 'base_url', None) or ''),+ 'has_api_key': bool(getattr(llm_settings, 'api_key', None)),+ },+ )acp_request = await self._build_acp_start_conversation_request(sandbox=sandbox,conversation_id=conversation_id,diff --git a/openhands/app_server/user/auth_user_context.py b/openhands/app_server/user/auth_user_context.pyindex b61a2ab726..dece9dd850 100644--- a/openhands/app_server/user/auth_user_context.py+++ b/openhands/app_server/user/auth_user_context.py@@ -1,7 +1,9 @@import logging+from collections.abc import Awaitable, Callablefrom dataclasses import dataclassfrom types import MappingProxyType-from typing import Any, AsyncGenerator+from typing import Any, AsyncGenerator, cast+from uuid import UUIDfrom fastapi import Requestfrom pydantic import PrivateAttr, SecretStr@@ -178,6 +180,12 @@ class AuthUserContext(UserContext):user_info = await self.get_user_info()return user_info.default_sandbox_spec_id+ async def get_effective_org_id(self) -> UUID | None:+ get_effective_org_id = getattr(self.user_auth, 'get_effective_org_id', None)+ if get_effective_org_id is None:+ return None+ return await cast(Callable[[], Awaitable[UUID | None]], get_effective_org_id)()+USER_ID_ATTR = 'user_id'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 ddc6b3a41e..1c0eab7079 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@@ -3,6 +3,8 @@import ioimport jsonimport os+import sys+import typesimport zipfilefrom datetime import datetimefrom types import SimpleNamespace@@ -764,6 +766,167 @@ class TestLiveStatusAppConversationService:assert isinstance(result['MY_SECRET'], StaticSecret)assert result['MY_SECRET'].description == ''+ @staticmethod+ def _install_managed_key_refresh_modules(+ monkeypatch, *, get_key, rotate_key, verify_key+ ):+ storage_mod = types.ModuleType('storage')+ lite_llm_mod = types.ModuleType('storage.lite_llm_manager')+ lite_llm_mod.LiteLlmManager = SimpleNamespace(verify_key=verify_key)++ store = SimpleNamespace(+ get_current_managed_llm_key=get_key,+ rotate_managed_llm_key=rotate_key,+ )+ saas_settings_mod = types.ModuleType('storage.saas_settings_store')+ saas_settings_mod.ManagedLlmKeyStatus = SimpleNamespace(ROTATED='rotated')+ saas_settings_mod.SaasSettingsStore = SimpleNamespace(+ get_instance=AsyncMock(return_value=store)+ )++ monkeypatch.setitem(sys.modules, 'storage', storage_mod)+ monkeypatch.setitem(sys.modules, 'storage.lite_llm_manager', lite_llm_mod)+ monkeypatch.setitem(+ sys.modules, 'storage.saas_settings_store', saas_settings_mod+ )++ @pytest.mark.asyncio+ @pytest.mark.parametrize(+ 'llm_base_url',+ [+ 'https://llm-proxy.app.all-hands.dev',+ 'https://llm-proxy.staging.all-hands.dev',+ None,+ ],+ )+ async def test_maybe_refresh_managed_llm_key_refreshes_stale_key(+ self, monkeypatch, llm_base_url+ ):+ org_id = uuid4()+ self.service.app_mode = 'saas'+ self.mock_user.id = 'user-123'+ self.mock_user_context.get_effective_org_id = AsyncMock(return_value=org_id)++ get_key = AsyncMock(return_value='sk-old-managed-key')+ rotate_key = AsyncMock(+ return_value=SimpleNamespace(status='rotated', new_key='sk-new-managed-key')+ )+ verify_key = AsyncMock(return_value=False)+ self._install_managed_key_refresh_modules(+ monkeypatch, get_key=get_key, rotate_key=rotate_key, verify_key=verify_key+ )++ llm = LLM(+ model='openhands/gpt-5.5',+ base_url=llm_base_url,+ api_key=SecretStr('sk-old-managed-key'),+ )++ refreshed = await self.service._maybe_refresh_managed_llm_key(+ self.mock_user, llm+ )++ assert refreshed.api_key.get_secret_value() == 'sk-new-managed-key'+ get_key.assert_awaited_once_with()+ verify_key.assert_awaited_once_with('sk-old-managed-key', 'user-123')+ rotate_key.assert_awaited_once_with()++ @pytest.mark.asyncio+ async def test_maybe_refresh_managed_llm_key_skips_non_saas(self, monkeypatch):+ self.service.app_mode = 'test'+ get_key = AsyncMock()+ rotate_key = AsyncMock()+ verify_key = AsyncMock()+ self._install_managed_key_refresh_modules(+ monkeypatch, get_key=get_key, rotate_key=rotate_key, verify_key=verify_key+ )+ llm = LLM(+ model='openhands/gpt-5.5',+ base_url='https://llm-proxy.app.all-hands.dev',+ api_key=SecretStr('sk-old-managed-key'),+ )++ result = await self.service._maybe_refresh_managed_llm_key(self.mock_user, llm)++ assert result is llm+ get_key.assert_not_called()+ verify_key.assert_not_called()+ rotate_key.assert_not_called()++ @pytest.mark.asyncio+ async def test_maybe_refresh_managed_llm_key_skips_non_managed_base_url(+ self, monkeypatch+ ):+ self.service.app_mode = 'saas'+ self.mock_user.id = 'user-123'+ get_key = AsyncMock()+ rotate_key = AsyncMock()+ verify_key = AsyncMock()+ self._install_managed_key_refresh_modules(+ monkeypatch, get_key=get_key, rotate_key=rotate_key, verify_key=verify_key+ )+ llm = LLM(+ model='openai/gpt-4',+ base_url='https://api.openai.com/v1',+ api_key=SecretStr('sk-byok-key'),+ )++ result = await self.service._maybe_refresh_managed_llm_key(self.mock_user, llm)++ assert result is llm+ get_key.assert_not_called()+ verify_key.assert_not_called()+ rotate_key.assert_not_called()++ @pytest.mark.asyncio+ async def test_maybe_refresh_managed_llm_key_skips_openhands_custom_base_url(+ self, monkeypatch+ ):+ self.service.app_mode = 'saas'+ self.mock_user.id = 'user-123'+ get_key = AsyncMock()+ rotate_key = AsyncMock()+ verify_key = AsyncMock()+ self._install_managed_key_refresh_modules(+ monkeypatch, get_key=get_key, rotate_key=rotate_key, verify_key=verify_key+ )+ llm = LLM(+ model='openhands/gpt-5.5',+ base_url='https://custom-llm-proxy.example.com',+ api_key=SecretStr('sk-byok-key'),+ )++ result = await self.service._maybe_refresh_managed_llm_key(self.mock_user, llm)++ assert result is llm+ get_key.assert_not_called()+ verify_key.assert_not_called()+ rotate_key.assert_not_called()++ @pytest.mark.asyncio+ async def test_maybe_refresh_managed_llm_key_skips_key_mismatch(self, monkeypatch):+ org_id = uuid4()+ self.service.app_mode = 'saas'+ self.mock_user.id = 'user-123'+ self.mock_user_context.get_effective_org_id = AsyncMock(return_value=org_id)+ get_key = AsyncMock(return_value='sk-different-managed-key')+ rotate_key = AsyncMock()+ verify_key = AsyncMock()+ self._install_managed_key_refresh_modules(+ monkeypatch, get_key=get_key, rotate_key=rotate_key, verify_key=verify_key+ )+ llm = LLM(+ model='openhands/gpt-5.5',+ base_url='https://llm-proxy.app.all-hands.dev',+ api_key=SecretStr('sk-profile-or-byok-key'),+ )++ result = await self.service._maybe_refresh_managed_llm_key(self.mock_user, llm)++ assert result is llm+ verify_key.assert_not_called()+ rotate_key.assert_not_called()+@pytest.mark.asyncioasync def test_configure_llm_and_mcp_with_custom_model(self):"""Test _configure_llm_and_mcp with custom LLM model."""diff --git a/tests/unit/app_server/test_user_context_email.py b/tests/unit/app_server/test_user_context_email.pyindex 1d0586de74..c33de2683e 100644--- a/tests/unit/app_server/test_user_context_email.py+++ b/tests/unit/app_server/test_user_context_email.py@@ -6,7 +6,8 @@ Laminar UI, while still falling back to the internal user id (e.g. in OSSmode or for admin-scoped contexts)."""-from unittest.mock import AsyncMock+from unittest.mock import AsyncMock, MagicMock+from uuid import uuid4import pytest@@ -15,6 +16,7 @@ from openhands.app_server.user.specifiy_user_context import (ADMIN,SpecifyUserContext,)+from openhands.app_server.user_auth.user_auth import UserAuthclass TestAuthUserContextEmail:@@ -45,6 +47,29 @@ class TestAuthUserContextEmail:user_auth.get_user_email.assert_awaited_once()+class TestAuthUserContextEffectiveOrg:+ """``AuthUserContext.get_effective_org_id()`` delegates when supported."""++ @pytest.mark.asyncio+ async def test_delegates_to_user_auth_when_available(self):+ org_id = uuid4()+ user_auth = MagicMock(spec=UserAuth)+ user_auth.get_effective_org_id = AsyncMock(return_value=org_id)+ ctx = AuthUserContext(user_auth=user_auth)++ effective_org_id = await ctx.get_effective_org_id()++ assert effective_org_id == org_id+ user_auth.get_effective_org_id.assert_awaited_once()++ @pytest.mark.asyncio+ async def test_returns_none_when_user_auth_does_not_support_effective_org(self):+ user_auth = MagicMock(spec=UserAuth)+ ctx = AuthUserContext(user_auth=user_auth)++ assert await ctx.get_effective_org_id() is None++class TestSpecifyUserContextEmail:"""Admin contexts have no associated end-user email."""