Skip to content

πŸ™Œ 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.py
index 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 LiteLlmManager
from storage.org_member import OrgMember
from storage.org_member_store import OrgMemberStore
from storage.org_service import OrgService
+from storage.saas_settings_store import (
+ ManagedLlmKeyStatus,
+ SaasSettingsStore,
+)
from storage.user_store import UserStore
from 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.py
index 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_config
from 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)
+
+
@dataclass
class SaasSettingsStore(SettingsStore):
user_id: str
@@ -56,21 +115,21 @@ class SaasSettingsStore(SettingsStore):
effective_org_id: UUID | None = None
def _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_id
async 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_url
or (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 it
is 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.py
index 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 contextlib
import uuid
from datetime import UTC, datetime, timedelta
from unittest.mock import AsyncMock, MagicMock, patch
@@ -9,19 +10,31 @@ import pytest
from fastapi import HTTPException
from pydantic import SecretStr
from 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_VERSION
from 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 User
from 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.py
index 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 LLM
llm = 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 builder
if 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.py
index 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, Callable
from dataclasses import dataclass
from types import MappingProxyType
-from typing import Any, AsyncGenerator
+from typing import Any, AsyncGenerator, cast
+from uuid import UUID
from fastapi import Request
from 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.py
index 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 io
import json
import os
+import sys
+import types
import zipfile
from datetime import datetime
from 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.asyncio
async 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.py
index 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 OSS
mode or for admin-scoped contexts).
"""
-from unittest.mock import AsyncMock
+from unittest.mock import AsyncMock, MagicMock
+from uuid import uuid4
import 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 UserAuth
class 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."""