π OpenHands: AI-Driven Development
fix(backend): repair org-defaults LLM save flow and sync managed keys to members (#14044)
Hiep Led8c67a4d3dba
diff --git a/enterprise/server/routes/org_models.py b/enterprise/server/routes/org_models.pyindex dc0de1bdbf..18e3c2a830 100644--- a/enterprise/server/routes/org_models.py+++ b/enterprise/server/routes/org_models.py@@ -7,12 +7,15 @@ from pydantic import (SecretStr,StringConstraints,field_validator,+ model_validator,)+from server.constants import LITE_LLM_API_URLfrom storage.org import Orgfrom storage.org_member import OrgMemberfrom storage.role import Rolefrom openhands.sdk.settings import AgentSettings, ConversationSettings+from openhands.utils.llm import MASKED_API_KEY, resolve_llm_base_urlclass OrgCreationError(Exception):@@ -208,7 +211,13 @@ class OrgPage(BaseModel):class OrgUpdate(BaseModel):- """Request model for updating an organization."""+ """Request model for updating an organization.++ ``agent_settings`` and ``conversation_settings`` match the wire format+ the frontend already uses for ``OrgLLMSettingsUpdate``; they're+ applied to the org row as partial/diff patches via ``deep_merge`` in+ ``OrgStore.update_org``.+ """name: Annotated[str | None,@@ -227,8 +236,8 @@ class OrgUpdate(BaseModel):enable_solvability_analysis: bool | None = Nonev1_enabled: bool | None = Nonesearch_api_key: str | None = None- agent_settings_diff: dict[str, Any] | None = None- conversation_settings_diff: dict[str, Any] | None = None+ agent_settings: dict[str, Any] | None = None+ conversation_settings: dict[str, Any] | None = Noneclass OrgLLMSettingsResponse(BaseModel):@@ -255,11 +264,22 @@ class OrgLLMSettingsResponse(BaseModel):@classmethoddef from_org(cls, org: Org) -> 'OrgLLMSettingsResponse':- """Create response from Org entity."""+ """Create response from Org entity.++ Denormalizes the SDK's ``litellm_proxy/`` prefix back to+ ``openhands/`` so the frontend's basic-view provider/model dropdowns+ can be populated, and nulls ``api_key`` so neither the raw secret+ nor the ``MASKED_API_KEY`` marker leaks in the response.+ ``base_url`` is returned exactly as stored so ``org.agent_settings``,+ ``org_member.agent_settings_diff`` and this response always carry+ the same value.+ """+ agent_settings = AgentSettings.model_validate(+ dict(org.agent_settings) if org.agent_settings else {}+ )+ cls._denormalize_llm_for_response(agent_settings)return cls(- agent_settings=AgentSettings.model_validate(- dict(org.agent_settings) if org.agent_settings else {}- ),+ agent_settings=agent_settings,conversation_settings=ConversationSettings.model_validate(dict(org.conversation_settings) if org.conversation_settings else {}),@@ -267,13 +287,54 @@ class OrgLLMSettingsResponse(BaseModel):search_api_key=cls._mask_key(org.search_api_key),)+ @staticmethod+ def _denormalize_llm_for_response(agent_settings: AgentSettings) -> None:+ """Rewrite ``agent_settings.llm`` in-place for UI consumption.++ * ``litellm_proxy/X`` β ``openhands/X`` so the basic-view provider+ dropdown matches (the SDK's ``AgentSettings`` validator+ normalizes the other direction on load).+ * ``base_url`` is returned **as stored** so the three sync targets+ (``org.agent_settings.llm.base_url``,+ ``org_member.agent_settings_diff.llm.base_url``, and the GET+ response) always agree. The frontend is responsible for+ recognizing the managed LiteLLM proxy URL / provider-default URL+ as "basic mode" β see ``KNOWN_PROVIDER_DEFAULT_BASE_URLS`` in+ ``frontend/src/routes/llm-settings.tsx``.+ * ``api_key`` is nulled so neither the raw secret nor the+ ``MASKED_API_KEY`` marker leaks in the response β the frontend+ reads ``llm_api_key_set`` to know whether a key exists.++ Pydantic v2 field assignment bypasses ``field_validator`` /+ ``model_validator`` by default (``validate_assignment`` is off on+ the SDK's ``LLM`` model), so the rename survives without being+ re-normalized back to ``litellm_proxy/``.+ """+ llm = agent_settings.llm+ if llm.model and llm.model.startswith('litellm_proxy/'):+ llm.model = f'openhands/{llm.model.removeprefix("litellm_proxy/")}'+ llm.api_key = None+class OrgMemberLLMSettings(BaseModel):- """Shared LLM settings that may be propagated to organization members."""+ """Shared LLM settings that may be propagated to organization members.++ ``llm_api_key`` is typed as ``SecretStr`` so the raw value never ends up+ in logs or ``model_dump(mode='json')`` output by accident β the+ column-backed ``OrgMember.llm_api_key`` setter accepts ``SecretStr``+ directly and unwraps via ``get_secret_value()``.++ ``has_custom_llm_api_key`` propagates through+ ``update_all_members_llm_settings_async`` so an org-defaults save can+ reset every member's "I have a personal BYOR key" flag in one pass β+ managed-mode switches rely on this to stop load-time fallthrough from+ returning stale custom markers.+ """agent_settings_diff: dict[str, Any] | None = Noneconversation_settings_diff: dict[str, Any] | None = None- llm_api_key: str | None = None+ llm_api_key: SecretStr | None = None+ has_custom_llm_api_key: bool | None = Nonedef has_updates(self) -> bool:"""Check if any field is set (not None)."""@@ -283,13 +344,97 @@ class OrgMemberLLMSettings(BaseModel):class OrgLLMSettingsUpdate(BaseModel):- """Request model for updating organization LLM settings."""+ """Request model for updating organization LLM settings.- agent_settings_diff: dict[str, Any] | None = None- conversation_settings_diff: dict[str, Any] | None = None+ ``agent_settings`` and ``conversation_settings`` are applied to the org+ as partial/diff patches via ``deep_merge`` and are also propagated to+ each member's stored diff so stale member overrides don't mask the new+ org defaults.+ """++ agent_settings: dict[str, Any] | None = None+ conversation_settings: dict[str, Any] | None = Nonesearch_api_key: str | None = Nonellm_api_key: str | None = None+ @model_validator(mode='after')+ def _normalize_agent_settings(self) -> 'OrgLLMSettingsUpdate':+ """Normalize ``agent_settings`` so post-save stored state stays+ consistent between the org row, every member row, and the encrypted+ ``_llm_api_key`` column.++ Two jobs:++ * **Lift ``llm.api_key`` and mask it in the JSON.** The frontend+ posts the raw key nested inside ``agent_settings``. Leaving it+ nested would push a raw secret into the ``org.agent_settings``+ JSON column while ``org._llm_api_key`` (the encrypted column read+ by ``_get_effective_llm_api_key`` at load time) stays stale. We+ move the raw value up to ``self.llm_api_key`` (for the encrypted+ column) and leave a universal ``MASKED_API_KEY`` marker in the+ JSON. That marker then propagates through ``deep_merge`` into+ ``org.agent_settings.llm.api_key`` and through+ ``get_member_updates`` into every member's+ ``agent_settings_diff.llm.api_key`` β matching the convention+ ``SaasSettingsStore.store`` already follows via+ ``model_dump(mode='json')``.++ * **Fill ``llm.base_url`` for OpenHands / managed models.** The+ basic-view payload sends ``base_url: null`` when the user picks+ the OpenHands provider. ``deep_merge`` treats ``None`` as "delete+ this key," which would leave ``org.agent_settings.llm`` without a+ ``base_url`` (and the frontend then can't tell which provider is+ configured β see the empty basic-view dropdowns). Substitute the+ managed LiteLLM proxy URL so the stored state is complete and+ self-describing.+ """+ if self.agent_settings is None:+ return self+ llm = self.agent_settings.get('llm')+ if not isinstance(llm, dict):+ return self++ if 'api_key' in llm:+ nested_key = llm.pop('api_key')+ # Don't re-lift the masked placeholder β the frontend echoes+ # it back when the user saves without editing the api_key+ # field. Treating it as a raw key would encrypt ``**********``+ # into the column and nuke the real key.+ if (+ self.llm_api_key is None+ and nested_key is not None+ and nested_key != MASKED_API_KEY+ ):+ self.llm_api_key = nested_key+ if nested_key is not None:+ # Keep the JSON in sync with the encrypted column β both+ # ``org.agent_settings.llm.api_key`` and every member's+ # ``agent_settings_diff.llm.api_key`` will carry this marker+ # after ``deep_merge`` / propagation. An empty string still+ # gets the marker: the rotation step that runs after the+ # store update will write a freshly generated managed key+ # into the column, so "masked" in the JSON still reflects+ # reality by end of transaction.+ llm['api_key'] = MASKED_API_KEY++ # Auto-fill ``base_url`` when the wire payload sends ``null``+ # (basic-view pattern). ``resolve_llm_base_url`` is shared with+ # ``_post_merge_llm_fixups`` in the personal-settings router so+ # both save paths agree on "this provider uses this base URL."+ resolved_base_url = resolve_llm_base_url(+ model=llm.get('model'),+ base_url=llm.get('base_url'),+ managed_proxy_url=LITE_LLM_API_URL,+ )+ if resolved_base_url is not None:+ llm['base_url'] = resolved_base_url++ if not llm:+ self.agent_settings.pop('llm', None)+ if not self.agent_settings:+ self.agent_settings = None+ return self+def has_updates(self) -> bool:"""Check if any field is set (not None)."""return any(@@ -304,8 +449,20 @@ class OrgLLMSettingsUpdate(BaseModel):org.llm_api_key = self.llm_api_key or Nonedef get_member_updates(self) -> OrgMemberLLMSettings | None:- """Get updates that need to be propagated to org members."""- member_settings = OrgMemberLLMSettings(llm_api_key=self.llm_api_key)+ """Get updates that need to be propagated to org members.++ An empty ``llm_api_key`` means the orgβwide custom key is being cleared+ (e.g. owner switching to a managed/OpenHands provider). It must not+ land in member rows β ``OrgMember.llm_api_key``'s setter has no+ ``if raw else None`` guard because the column is ``nullable=False``,+ so an empty string would become an encrypted empty blob rather than a+ cleared value. Coerce ``""`` to ``None`` so member rows are untouched.+ """+ member_settings = OrgMemberLLMSettings(+ agent_settings_diff=self.agent_settings,+ conversation_settings_diff=self.conversation_settings,+ llm_api_key=self.llm_api_key or None,+ )return member_settings if member_settings.has_updates() else Nonediff --git a/enterprise/server/services/org_llm_settings_service.py b/enterprise/server/services/org_llm_settings_service.pyindex b6ca42d87d..d06dee5ad7 100644--- a/enterprise/server/services/org_llm_settings_service.py+++ b/enterprise/server/services/org_llm_settings_service.py@@ -6,20 +6,30 @@ Uses dependency injection for db_session and user_context.from __future__ import annotations+import uuidfrom dataclasses import dataclassfrom typing import AsyncGeneratorfrom fastapi import Request+from pydantic import SecretStr+from server.constants import LITE_LLM_API_URLfrom server.routes.org_models import (OrgLLMSettingsResponse,OrgLLMSettingsUpdate,+ OrgMemberLLMSettings,OrgNotFoundError,)+from sqlalchemy import select+from storage.lite_llm_manager import LiteLlmManager, get_openhands_cloud_key_alias+from storage.org import Orgfrom storage.org_llm_settings_store import OrgLLMSettingsStore+from storage.org_member import OrgMember+from storage.org_member_store import OrgMemberStorefrom openhands.app_server.services.injector import Injector, InjectorStatefrom openhands.app_server.user.user_context import UserContextfrom openhands.core.logger import openhands_logger as logger+from openhands.utils.llm import is_openhands_model@dataclass@@ -105,6 +115,39 @@ class OrgLLMSettingsService:if not updated_org:raise OrgNotFoundError(str(org.id))+ # Build the member-propagation payload from the update diff, then+ # let the managed-key rotation merge in a freshly generated /+ # reused managed key (OpenHands / LiteLLM proxy case). A single+ # ``update_all_members_llm_settings_async`` call at the end writes+ # the ``agent_settings_diff``, ``llm_api_key``, and a+ # ``has_custom_llm_api_key=False`` reset to every member row in one+ # pass. The flag reset is load-bearing: org-defaults saves are an+ # org-wide "use the org default" signal, so any lingering+ # "I have a personal BYOR key" marker on a member row would make+ # ``_get_effective_llm_api_key`` return the wrong key at read time.+ member_updates = update_data.get_member_updates()++ effective_managed_key = await self._maybe_rotate_managed_llm_key_for_user(+ updated_org=updated_org,+ user_id=user_id,+ )+ if effective_managed_key is not None:+ if member_updates is None:+ member_updates = OrgMemberLLMSettings()+ member_updates.llm_api_key = SecretStr(effective_managed_key)++ if member_updates is not None:+ member_updates.has_custom_llm_api_key = False+ await OrgMemberStore.update_all_members_llm_settings_async(+ self.store.db_session,+ org.id,+ member_updates,+ )+ logger.info(+ 'Propagated org LLM settings to members',+ extra={'user_id': user_id, 'org_id': str(org.id)},+ )+logger.info('Organization LLM settings updated successfully',extra={'user_id': user_id, 'org_id': str(org.id)},@@ -112,6 +155,110 @@ class OrgLLMSettingsService:return OrgLLMSettingsResponse.from_org(updated_org)+ async def _maybe_rotate_managed_llm_key_for_user(+ self,+ updated_org: Org,+ user_id: str,+ ) -> str | None:+ """Return the managed LLM key every member row should carry, or+ ``None`` if the org isn't in managed mode.++ When the updated org defaults target a managed LLM (OpenHands+ provider or the LiteLLM proxy base URL), this reuses the acting+ user's (any admin or owner with ``EDIT_LLM_SETTINGS``) current+ managed key if ``verify_existing_key`` confirms it's still valid,+ otherwise generates a fresh one. The returned key is what every+ member's ``_llm_api_key`` column should hold β the caller bundles+ it into the single ``update_all_members_llm_settings_async`` call+ alongside the ``agent_settings_diff`` and a+ ``has_custom_llm_api_key=False`` reset so one DB pass covers all+ three. Detection matches ``SaasSettingsStore.store`` so the two+ save paths agree on when managed mode is in play; propagation+ semantics differ because org-defaults saves are intentionally an+ org-wide operation.+ """+ llm = (updated_org.agent_settings or {}).get('llm') or {}+ llm_model = llm.get('model')+ llm_base_url = llm.get('base_url')+ normalized_llm_base_url = llm_base_url.rstrip('/') if llm_base_url else None+ normalized_managed_base_url = LITE_LLM_API_URL.rstrip('/')+ openhands_type = is_openhands_model(llm_model)+ uses_managed_llm_key = (+ normalized_llm_base_url == normalized_managed_base_url+ or (normalized_llm_base_url is None and openhands_type)+ )+ if not uses_managed_llm_key:+ return None++ result = await self.store.db_session.execute(+ select(OrgMember).where(+ OrgMember.org_id == updated_org.id,+ OrgMember.user_id == uuid.UUID(user_id),+ )+ )+ acting_member = result.scalars().first()+ if acting_member is None:+ # Shouldn't happen β the caller already resolved the user's+ # current org via ``get_current_org_by_user_id`` before calling+ # us, so the ``OrgMember`` row must exist. If it's missing+ # anyway, the org-wide managed-key propagation skips the+ # ``llm_api_key`` write (``effective_managed_key`` returns+ # ``None``) and members keep whatever was in their columns.+ # Log loudly so this data-consistency issue surfaces instead of+ # silently leaving stale keys on member rows.+ logger.error(+ 'Acting member row not found during managed LLM key '+ 'rotation; skipping managed-key propagation. Members may '+ 'retain stale keys until they save personal settings.',+ extra={'user_id': user_id, 'org_id': str(updated_org.id)},+ )+ return None++ existing_key = acting_member.llm_api_key+ existing_key_raw = existing_key.get_secret_value() if existing_key else None+ if existing_key_raw and await LiteLlmManager.verify_existing_key(+ existing_key_raw,+ user_id,+ str(updated_org.id),+ openhands_type=openhands_type,+ ):+ # Reuse the acting user's still-valid managed key β no need to+ # burn a LiteLLM key rotation on a no-op save.+ effective_key = existing_key_raw+ rotated = False+ else:+ if openhands_type:+ effective_key = await LiteLlmManager.generate_key(+ user_id,+ str(updated_org.id),+ None,+ {'type': 'openhands'},+ )+ else:+ key_alias = get_openhands_cloud_key_alias(user_id, str(updated_org.id))+ await LiteLlmManager.delete_key_by_alias(key_alias=key_alias)+ effective_key = await LiteLlmManager.generate_key(+ user_id,+ str(updated_org.id),+ key_alias,+ None,+ )+ rotated = True++ # The caller merges ``effective_key`` into ``member_updates`` and+ # issues a single ``update_all_members_llm_settings_async`` call+ # that writes the key column AND resets ``has_custom_llm_api_key``+ # on every member β including this acting row β so we don't touch+ # the row directly here.++ if rotated:+ logger.info(+ 'Generated managed LLM key for acting user on org-defaults save',+ extra={'user_id': user_id, 'org_id': str(updated_org.id)},+ )++ return effective_key+class OrgLLMSettingsServiceInjector(Injector[OrgLLMSettingsService]):"""Injector that composes store and user_context for OrgLLMSettingsService."""diff --git a/enterprise/storage/org_llm_settings_store.py b/enterprise/storage/org_llm_settings_store.pyindex 6eebee7b5a..ebc15dfa5d 100644--- a/enterprise/storage/org_llm_settings_store.py+++ b/enterprise/storage/org_llm_settings_store.py@@ -68,15 +68,15 @@ class OrgLLMSettingsStore:return Noneupdate_data.apply_to_org(org)- if update_data.agent_settings_diff:+ if update_data.agent_settings:org.agent_settings = deep_merge(org.agent_settings,- update_data.agent_settings_diff,+ update_data.agent_settings,)- if update_data.conversation_settings_diff:+ if update_data.conversation_settings:org.conversation_settings = deep_merge(org.conversation_settings,- update_data.conversation_settings_diff,+ update_data.conversation_settings,)# flush instead of commit - DbSessionInjector auto-commits at request enddiff --git a/enterprise/storage/org_service.py b/enterprise/storage/org_service.pyindex 80a941bb73..69656a58e4 100644--- a/enterprise/storage/org_service.py+++ b/enterprise/storage/org_service.py@@ -549,8 +549,8 @@ class OrgService:return existing_orgrestricted_fields = {- 'agent_settings_diff',- 'conversation_settings_diff',+ 'agent_settings',+ 'conversation_settings','search_api_key','sandbox_api_key',}diff --git a/enterprise/storage/org_store.py b/enterprise/storage/org_store.pyindex 1f52e38ea7..a6d5b75610 100644--- a/enterprise/storage/org_store.py+++ b/enterprise/storage/org_store.py@@ -133,7 +133,7 @@ class OrgStore:org.id,{'org_version': ORG_SETTINGS_VERSION,- 'agent_settings_diff': {+ 'agent_settings': {'llm': {'model': get_default_litellm_model(),'base_url': LITE_LLM_API_URL,@@ -226,8 +226,11 @@ class OrgStore:if 'id' in kwargs:kwargs.pop('id')- agent_settings_diff = kwargs.pop('agent_settings_diff', None)- conversation_settings_diff = kwargs.pop('conversation_settings_diff', None)+ # Pop the diff-style kwargs before the setattr loop β otherwise+ # ``hasattr(org, 'agent_settings')`` is True and the loop would+ # *overwrite* the JSON column instead of deep-merging into it.+ agent_settings_diff = kwargs.pop('agent_settings', None)+ conversation_settings_diff = kwargs.pop('conversation_settings', None)for key, value in kwargs.items():if hasattr(org, key):setattr(org, key, value)@@ -464,15 +467,15 @@ class OrgStore:return Nonellm_settings.apply_to_org(org)- if llm_settings.agent_settings_diff is not None:+ if llm_settings.agent_settings is not None:org.agent_settings = deep_merge(org.agent_settings,- llm_settings.agent_settings_diff,+ llm_settings.agent_settings,)- if llm_settings.conversation_settings_diff is not None:+ if llm_settings.conversation_settings is not None:org.conversation_settings = deep_merge(org.conversation_settings,- llm_settings.conversation_settings_diff,+ llm_settings.conversation_settings,)# Propagate relevant settings to all org membersdiff --git a/enterprise/tests/unit/server/services/test_org_llm_settings_service.py b/enterprise/tests/unit/server/services/test_org_llm_settings_service.pyindex 7a5d1f5185..30be9173fe 100644--- a/enterprise/tests/unit/server/services/test_org_llm_settings_service.py+++ b/enterprise/tests/unit/server/services/test_org_llm_settings_service.py@@ -8,13 +8,19 @@ import uuidfrom unittest.mock import AsyncMock, MagicMockimport pytest+from pydantic import SecretStr+from server.constants import LITE_LLM_API_URLfrom server.routes.org_models import (+ MASKED_API_KEY,OrgLLMSettingsResponse,OrgLLMSettingsUpdate,OrgNotFoundError,)+from server.services import org_llm_settings_service as service_modulefrom server.services.org_llm_settings_service import OrgLLMSettingsServicefrom storage.org import Org+from storage.org_member import OrgMember+from storage.org_member_store import OrgMemberStore@pytest.fixture@@ -126,7 +132,7 @@ async def test_get_org_llm_settings_org_not_found(@pytest.mark.asyncioasync def test_update_org_llm_settings_success(- user_id, mock_org, mock_store, mock_user_context+ user_id, mock_org, mock_store, mock_user_context, monkeypatch):"""GIVEN: A user with a current organization@@ -149,17 +155,21 @@ async def test_update_org_llm_settings_success(updated_org.search_api_key = Noneupdate_data = OrgLLMSettingsUpdate(- agent_settings_diff={+ agent_settings={'llm': {'model': 'new-model'},},- conversation_settings_diff={+ conversation_settings={'confirmation_mode': False,'max_iterations': 100,},)+ mock_store.db_session = MagicMock()mock_store.get_current_org_by_user_id = AsyncMock(return_value=mock_org)mock_store.update_org_llm_settings = AsyncMock(return_value=updated_org)+ monkeypatch.setattr(+ OrgMemberStore, 'update_all_members_llm_settings_async', AsyncMock()+ )service = OrgLLMSettingsService(store=mock_store, user_context=mock_user_context)# Act@@ -211,9 +221,7 @@ async def test_update_org_llm_settings_org_not_found(THEN: OrgNotFoundError is raised"""# Arrange- update_data = OrgLLMSettingsUpdate(- agent_settings_diff={'llm': {'model': 'new-model'}}- )+ update_data = OrgLLMSettingsUpdate(agent_settings={'llm': {'model': 'new-model'}})mock_store.get_current_org_by_user_id = AsyncMock(return_value=None)service = OrgLLMSettingsService(store=mock_store, user_context=mock_user_context)@@ -223,3 +231,583 @@ async def test_update_org_llm_settings_org_not_found(await service.update_org_llm_settings(update_data)assert 'No current organization' in str(exc_info.value)+++async def test_update_org_llm_settings_accepts_wire_payload_and_propagates(+ mock_org, mock_store, mock_user_context, monkeypatch+):+ """+ GIVEN: The exact wire payload the frontend posts to /api/organizations/llm+ ({"agent_settings": {...}}) and an org with members carrying stale+ agent_settings_diff overrides+ WHEN: update_org_llm_settings is called+ THEN: 1) the org is actually updated (was a silent no-op before the+ field-name fix because the payload keys didn't match the model),+ 2) OrgMemberStore.update_all_members_llm_settings_async is invoked+ so members' stale diffs are overwritten by the new org defaults+ """+ # Arrange+ updated_org = MagicMock(spec=Org)+ updated_org.id = mock_org.id+ updated_org.agent_settings = {+ 'schema_version': 1,+ 'agent': 'CodeActAgent',+ 'llm': {+ 'model': 'claude-3',+ 'base_url': 'https://llm-proxy.staging.all-hands.dev',+ },+ }+ updated_org.conversation_settings = {}+ updated_org.llm_api_key = None+ updated_org.search_api_key = None++ update_data = OrgLLMSettingsUpdate.model_validate(+ {+ 'agent_settings': {+ 'llm': {'base_url': 'https://llm-proxy.staging.all-hands.dev'},+ },+ }+ )++ mock_store.db_session = MagicMock()+ mock_store.get_current_org_by_user_id = AsyncMock(return_value=mock_org)+ mock_store.update_org_llm_settings = AsyncMock(return_value=updated_org)++ propagation_mock = AsyncMock()+ monkeypatch.setattr(+ OrgMemberStore,+ 'update_all_members_llm_settings_async',+ propagation_mock,+ )++ service = OrgLLMSettingsService(store=mock_store, user_context=mock_user_context)++ # Act+ await service.update_org_llm_settings(update_data)++ # Assert+ mock_store.update_org_llm_settings.assert_awaited_once_with(+ org_id=mock_org.id,+ update_data=update_data,+ )+ propagation_mock.assert_awaited_once()+ call_args = propagation_mock.await_args+ assert call_args.args[0] is mock_store.db_session+ assert call_args.args[1] == mock_org.id+ member_settings = call_args.args[2]+ assert member_settings.agent_settings_diff == {+ 'llm': {'base_url': 'https://llm-proxy.staging.all-hands.dev'},+ }+ assert member_settings.conversation_settings_diff is None+ assert member_settings.llm_api_key is None+++async def test_update_org_llm_settings_does_not_propagate_when_only_org_fields(+ mock_org, mock_store, mock_user_context, monkeypatch+):+ """+ GIVEN: An update that only touches org-scoped fields (search_api_key),+ with nothing that should land on members+ WHEN: update_org_llm_settings is called+ THEN: member propagation is not invoked, guarding against regressions+ that would needlessly rewrite every member's row+ """+ # Arrange+ updated_org = MagicMock(spec=Org)+ updated_org.id = mock_org.id+ updated_org.agent_settings = mock_org.agent_settings+ updated_org.conversation_settings = {}+ updated_org.llm_api_key = None+ updated_org.search_api_key = None++ update_data = OrgLLMSettingsUpdate(search_api_key='new-search-key')++ mock_store.db_session = MagicMock()+ mock_store.get_current_org_by_user_id = AsyncMock(return_value=mock_org)+ mock_store.update_org_llm_settings = AsyncMock(return_value=updated_org)++ propagation_mock = AsyncMock()+ monkeypatch.setattr(+ OrgMemberStore,+ 'update_all_members_llm_settings_async',+ propagation_mock,+ )++ service = OrgLLMSettingsService(store=mock_store, user_context=mock_user_context)++ # Act+ await service.update_org_llm_settings(update_data)++ # Assert+ propagation_mock.assert_not_awaited()+++async def test_update_org_llm_settings_lifts_nested_api_key_for_column_sync(+ mock_org, mock_store, mock_user_context, monkeypatch+):+ """+ GIVEN: The frontend posts the api_key nested inside agent_settings.llm+ WHEN: update_org_llm_settings is called+ THEN: the raw key is routed through the top-level llm_api_key field,+ so every member's encrypted _llm_api_key column is updated via+ the propagation call. Without this, members' encrypted columns+ stay stale and _get_effective_llm_api_key returns the old key+ when they refetch settings.+ """+ # Arrange+ updated_org = MagicMock(spec=Org)+ updated_org.id = mock_org.id+ updated_org.agent_settings = {+ 'schema_version': 1,+ 'agent': 'CodeActAgent',+ 'llm': {'model': 'claude-3', 'base_url': 'https://example.com'},+ }+ updated_org.conversation_settings = {}+ updated_org.llm_api_key = None+ updated_org.search_api_key = None++ update_data = OrgLLMSettingsUpdate.model_validate(+ {+ 'agent_settings': {+ 'llm': {+ 'api_key': 'sk-new-raw-key',+ 'base_url': 'https://example.com',+ },+ },+ }+ )++ # The validator must move the raw key out of agent_settings and into the+ # top-level field the rest of the pipeline actually wires to the column,+ # AND leave a masked marker in the JSON so ``org.agent_settings.llm``+ # and member ``agent_settings_diff.llm`` stay consistent with the+ # encrypted column.+ assert update_data.llm_api_key == 'sk-new-raw-key'+ assert update_data.agent_settings == {+ 'llm': {'api_key': MASKED_API_KEY, 'base_url': 'https://example.com'},+ }++ mock_store.db_session = MagicMock()+ mock_store.get_current_org_by_user_id = AsyncMock(return_value=mock_org)+ mock_store.update_org_llm_settings = AsyncMock(return_value=updated_org)++ propagation_mock = AsyncMock()+ monkeypatch.setattr(+ OrgMemberStore,+ 'update_all_members_llm_settings_async',+ propagation_mock,+ )++ service = OrgLLMSettingsService(store=mock_store, user_context=mock_user_context)++ # Act+ await service.update_org_llm_settings(update_data)++ # Assert+ propagation_mock.assert_awaited_once()+ member_settings = propagation_mock.await_args.args[2]+ assert isinstance(member_settings.llm_api_key, SecretStr)+ assert member_settings.llm_api_key.get_secret_value() == 'sk-new-raw-key'+ assert member_settings.agent_settings_diff == {+ 'llm': {'api_key': MASKED_API_KEY, 'base_url': 'https://example.com'},+ }+ # org-defaults saves are org-wide: always reset members' personal+ # BYOR flag so load-time fallthrough won't return a stale custom key.+ assert member_settings.has_custom_llm_api_key is False+++def test_get_member_updates_treats_empty_llm_api_key_as_none():+ """+ GIVEN: The frontend posts an empty api_key to signal "switch to the+ managed/OpenHands provider" (clear the org-wide custom key)+ WHEN: get_member_updates builds the payload for member propagation+ THEN: llm_api_key is coerced to None β because OrgMember.llm_api_key's+ setter has no ``if raw else None`` guard (the column is+ ``nullable=False``), an empty string would be encrypted into an+ empty blob on every member rather than cleared. agent_settings_diff+ still carries the model diff so the org default actually lands on+ members.+ """+ # Arrange+ update = OrgLLMSettingsUpdate(+ agent_settings={'llm': {'model': 'openhands/x'}}, llm_api_key=''+ )++ # Act+ member_updates = update.get_member_updates()++ # Assert β llm_api_key is coerced to None, and the agent_settings_diff+ # carries both the model diff AND the auto-filled LiteLLM proxy URL so+ # the stored state is self-describing.+ assert member_updates is not None+ assert member_updates.llm_api_key is None+ assert member_updates.agent_settings_diff == {+ 'llm': {'model': 'openhands/x', 'base_url': LITE_LLM_API_URL},+ }+++async def test_update_org_llm_settings_generates_managed_key_for_openhands(+ user_id, mock_org, mock_store, mock_user_context, monkeypatch+):+ """+ GIVEN: An admin or owner saves org-defaults with the OpenHands provider+ in basic view (payload: model="openhands/...", api_key="",+ base_url=None), and their OrgMember row still holds the custom key+ from a prior *All*-tab save+ WHEN: update_org_llm_settings runs+ THEN: a managed LiteLLM key is generated for the acting user, their+ has_custom_llm_api_key flag is cleared, and a single propagation+ call writes the generated key + agent_settings_diff to every+ member row in one DB pass β so the whole org shares one managed+ key column value without doubling the row-write churn.+ """+ # Arrange+ updated_org = MagicMock(spec=Org)+ updated_org.id = mock_org.id+ updated_org.agent_settings = {+ 'schema_version': 1,+ 'agent': 'CodeActAgent',+ 'llm': {'model': 'openhands/claude-3'},+ }+ updated_org.conversation_settings = {}+ updated_org.llm_api_key = None+ updated_org.search_api_key = None++ update_data = OrgLLMSettingsUpdate.model_validate(+ {+ 'agent_settings': {+ 'llm': {+ 'model': 'openhands/claude-3',+ 'api_key': '',+ 'base_url': None,+ },+ },+ }+ )++ # The acting user's member row β carries the stale custom key from the+ # prior *All*-tab save.+ acting_member = MagicMock(spec=OrgMember)+ acting_member.llm_api_key = SecretStr('old-custom-key')+ acting_member.has_custom_llm_api_key = True++ scalars_result = MagicMock()+ scalars_result.first.return_value = acting_member+ execute_result = MagicMock()+ execute_result.scalars.return_value = scalars_result++ db_session = MagicMock()+ db_session.execute = AsyncMock(return_value=execute_result)++ mock_store.db_session = db_session+ mock_store.get_current_org_by_user_id = AsyncMock(return_value=mock_org)+ mock_store.update_org_llm_settings = AsyncMock(return_value=updated_org)++ propagation_mock = AsyncMock()+ monkeypatch.setattr(+ OrgMemberStore,+ 'update_all_members_llm_settings_async',+ propagation_mock,+ )+ monkeypatch.setattr(+ service_module.LiteLlmManager,+ 'verify_existing_key',+ AsyncMock(return_value=False),+ )+ generate_key_mock = AsyncMock(return_value='litellm-new-key')+ monkeypatch.setattr(+ service_module.LiteLlmManager, 'generate_key', generate_key_mock+ )++ service = OrgLLMSettingsService(store=mock_store, user_context=mock_user_context)++ # Act+ await service.update_org_llm_settings(update_data)++ # Assert β key was generated with openhands metadata.+ generate_key_mock.assert_awaited_once()+ assert generate_key_mock.await_args.args[0] == user_id+ assert generate_key_mock.await_args.args[1] == str(mock_org.id)+ assert generate_key_mock.await_args.args[2] is None+ assert generate_key_mock.await_args.args[3] == {'type': 'openhands'}++ # Assert β a single propagation call writes the diff, the generated+ # key, AND the has_custom_llm_api_key=False reset to every member row+ # (including the acting user's own row) in one DB pass.+ propagation_mock.assert_awaited_once()+ member_settings = propagation_mock.await_args.args[2]+ assert isinstance(member_settings.llm_api_key, SecretStr)+ assert member_settings.llm_api_key.get_secret_value() == 'litellm-new-key'+ assert member_settings.has_custom_llm_api_key is False+ assert member_settings.agent_settings_diff == {+ 'llm': {+ 'model': 'openhands/claude-3',+ 'api_key': MASKED_API_KEY,+ 'base_url': LITE_LLM_API_URL,+ },+ }+++async def test_update_org_llm_settings_does_not_generate_key_for_non_managed_model(+ mock_org, mock_store, mock_user_context, monkeypatch+):+ """+ GIVEN: The owner saves org-defaults with a BYOR model (non-OpenHands,+ non-proxy base_url)+ WHEN: update_org_llm_settings runs+ THEN: no LiteLLM key is generated β the managed-key path is reserved for+ the OpenHands provider / managed-proxy case, mirroring the personal+ save flow's detection logic.+ """+ # Arrange+ updated_org = MagicMock(spec=Org)+ updated_org.id = mock_org.id+ updated_org.agent_settings = {+ 'schema_version': 1,+ 'agent': 'CodeActAgent',+ 'llm': {+ 'model': 'anthropic/claude-3',+ 'base_url': 'https://example.com',+ },+ }+ updated_org.conversation_settings = {}+ updated_org.llm_api_key = None+ updated_org.search_api_key = None++ update_data = OrgLLMSettingsUpdate.model_validate(+ {+ 'agent_settings': {+ 'llm': {+ 'model': 'anthropic/claude-3',+ 'base_url': 'https://example.com',+ 'api_key': 'custom',+ },+ },+ }+ )++ mock_store.db_session = MagicMock()+ mock_store.get_current_org_by_user_id = AsyncMock(return_value=mock_org)+ mock_store.update_org_llm_settings = AsyncMock(return_value=updated_org)++ monkeypatch.setattr(+ OrgMemberStore,+ 'update_all_members_llm_settings_async',+ AsyncMock(),+ )+ generate_key_mock = AsyncMock(return_value='should-not-be-called')+ monkeypatch.setattr(+ service_module.LiteLlmManager, 'generate_key', generate_key_mock+ )+ monkeypatch.setattr(+ service_module.LiteLlmManager,+ 'verify_existing_key',+ AsyncMock(return_value=True),+ )++ service = OrgLLMSettingsService(store=mock_store, user_context=mock_user_context)++ # Act+ await service.update_org_llm_settings(update_data)++ # Assert+ generate_key_mock.assert_not_awaited()+++def test_normalize_agent_settings_masks_api_key_in_json_on_empty_and_real_keys():+ """+ GIVEN: Wire payloads that either carry a real raw api_key (BYOR save) or+ an empty string api_key (managed/OpenHands switch)+ WHEN: OrgLLMSettingsUpdate's model validator runs+ THEN: both shapes lift the raw value to ``llm_api_key`` for encrypted+ column sync AND leave the universal ``MASKED_API_KEY`` marker in+ ``agent_settings.llm.api_key``, so the three storage locations+ (``org._llm_api_key``, ``org.agent_settings.llm.api_key``,+ ``org_member.agent_settings_diff.llm.api_key``) stay in sync once+ the update is applied + propagated.+ """+ # Arrange + Act+ real_key = OrgLLMSettingsUpdate.model_validate(+ {'agent_settings': {'llm': {'model': 'anthropic/x', 'api_key': 'sk-raw'}}}+ )+ empty_key = OrgLLMSettingsUpdate.model_validate(+ {+ 'agent_settings': {+ 'llm': {'model': 'openhands/x', 'api_key': '', 'base_url': None},+ },+ }+ )++ # Assert β masked in JSON in both cases; lifted raw value on top-level.+ assert real_key.llm_api_key == 'sk-raw'+ assert real_key.agent_settings is not None+ assert real_key.agent_settings['llm']['api_key'] == MASKED_API_KEY+ assert empty_key.llm_api_key == ''+ assert empty_key.agent_settings is not None+ assert empty_key.agent_settings['llm']['api_key'] == MASKED_API_KEY+++def test_normalize_agent_settings_fills_base_url_for_all_providers():+ """+ GIVEN: Wire payloads from the basic view that send ``base_url: null`` for+ various providers (OpenHands managed + BYOR providers like OpenAI+ and Anthropic)+ WHEN: OrgLLMSettingsUpdate's model validator runs+ THEN: ``base_url`` is populated for every recognised provider β+ ``LITE_LLM_API_URL`` for OpenHands/managed models and the+ litellm-derived default URL for non-managed providers (via+ ``get_provider_api_base``). Mirrors the ``_post_merge_llm_fixups``+ behavior the personal-save flow already performs, so+ ``org.agent_settings.llm`` and every member's+ ``agent_settings_diff.llm`` carry a usable, self-describing+ base URL.+ """+ # Arrange + Act β covers: OpenHands explicit null, OpenHands missing,+ # BYOR provider explicit null (base_url auto-filled to provider default).+ openhands_null = OrgLLMSettingsUpdate.model_validate(+ {+ 'agent_settings': {+ 'llm': {'model': 'openhands/claude-3', 'base_url': None},+ },+ }+ )+ openhands_missing = OrgLLMSettingsUpdate.model_validate(+ {'agent_settings': {'llm': {'model': 'openhands/claude-3'}}}+ )+ anthropic_null = OrgLLMSettingsUpdate.model_validate(+ {+ 'agent_settings': {+ 'llm': {'model': 'anthropic/claude-3-opus-20240229', 'base_url': None},+ },+ }+ )++ # Assert β OpenHands gets the proxy URL; non-OpenHands provider gets the+ # provider default that ``litellm.get_api_base`` reports.+ assert openhands_null.agent_settings is not None+ assert openhands_null.agent_settings['llm']['base_url'] == LITE_LLM_API_URL+ assert openhands_missing.agent_settings is not None+ assert openhands_missing.agent_settings['llm']['base_url'] == LITE_LLM_API_URL+ assert anthropic_null.agent_settings is not None+ # get_provider_api_base('anthropic/claude-3-opus-20240229') returns the+ # Anthropic public API. Be lenient about the exact suffix litellm returns+ # across versions β only require that it got filled with Anthropic's host.+ anthropic_base = anthropic_null.agent_settings['llm']['base_url']+ assert isinstance(anthropic_base, str)+ assert 'anthropic.com' in anthropic_base+++def test_from_org_denormalizes_litellm_proxy_prefix_and_returns_base_url_as_stored():+ """+ GIVEN: An org whose stored ``agent_settings.llm.model`` is in the SDK's+ normalized ``litellm_proxy/`` form with ``base_url`` equal to the+ managed proxy URL (the state produced by+ ``_normalize_agent_settings`` on save)+ WHEN: OrgLLMSettingsResponse.from_org serializes for the frontend+ THEN: the response shows ``openhands/X`` so the basic-view provider+ dropdown matches, returns ``base_url`` exactly as stored so the+ three sync targets (``org.agent_settings.llm.base_url``,+ ``org_member.agent_settings_diff.llm.base_url``, and this+ response) agree, and nulls ``api_key`` so neither the raw secret+ nor the ``MASKED_API_KEY`` marker leaks in the response.+ """+ # Arrange+ org = MagicMock(spec=Org)+ org.agent_settings = {+ 'schema_version': 1,+ 'agent': 'CodeActAgent',+ 'llm': {+ 'model': 'litellm_proxy/minimax-m2.5',+ 'base_url': LITE_LLM_API_URL,+ 'api_key': MASKED_API_KEY,+ },+ }+ org.conversation_settings = {}+ org.llm_api_key = None+ org.search_api_key = None++ # Act+ response = OrgLLMSettingsResponse.from_org(org)++ # Assert+ assert response.agent_settings.llm.model == 'openhands/minimax-m2.5'+ assert response.agent_settings.llm.base_url == LITE_LLM_API_URL+ assert response.agent_settings.llm.api_key is None+++def test_from_org_returns_provider_default_base_url_as_stored_for_non_managed_models():+ """+ GIVEN: An org saved with a BYOR provider whose stored ``base_url`` equals+ that provider's canonical base URL (what ``_normalize_agent_settings``+ auto-filled on save via ``get_provider_api_base``)+ WHEN: OrgLLMSettingsResponse.from_org serializes for the frontend+ THEN: ``base_url`` is passed through unchanged β the response must+ reflect stored state so a future drift that re-introduces+ clearing fails this test. The frontend+ (``KNOWN_PROVIDER_DEFAULT_BASE_URLS``) is responsible for+ recognizing provider defaults as "basic mode."+ """+ # Arrange β look up the canonical anthropic base URL the same way the+ # validator does so the test stays in sync with whatever litellm reports.+ from openhands.utils.llm import get_provider_api_base as _provider_base++ anthropic_default = _provider_base('anthropic/claude-3-opus-20240229')+ assert anthropic_default is not None++ org = MagicMock(spec=Org)+ org.agent_settings = {+ 'schema_version': 1,+ 'agent': 'CodeActAgent',+ 'llm': {+ 'model': 'anthropic/claude-3-opus-20240229',+ 'base_url': anthropic_default,+ },+ }+ org.conversation_settings = {}+ org.llm_api_key = None+ org.search_api_key = None++ # Act+ response = OrgLLMSettingsResponse.from_org(org)++ # Assert β model is unchanged (no litellm_proxy/ prefix), base_url is+ # returned as stored so stored state and response agree.+ assert response.agent_settings.llm.model == 'anthropic/claude-3-opus-20240229'+ assert response.agent_settings.llm.base_url == anthropic_default+++def test_from_org_keeps_custom_base_url_that_is_not_provider_default():+ """+ GIVEN: An org saved with a BYOR provider and a genuinely custom base URL+ (e.g. a company-run proxy) that does NOT match the provider default+ WHEN: OrgLLMSettingsResponse.from_org serializes for the frontend+ THEN: ``base_url`` is preserved so the "advanced" view can display it β+ we only clear values we're certain match a canonical default.+ """+ # Arrange+ org = MagicMock(spec=Org)+ org.agent_settings = {+ 'schema_version': 1,+ 'agent': 'CodeActAgent',+ 'llm': {+ 'model': 'anthropic/claude-3-opus-20240229',+ 'base_url': 'https://company-proxy.internal/anthropic',+ },+ }+ org.conversation_settings = {}+ org.llm_api_key = None+ org.search_api_key = None++ # Act+ response = OrgLLMSettingsResponse.from_org(org)++ # Assert+ assert (+ response.agent_settings.llm.base_url+ == 'https://company-proxy.internal/anthropic'+ )diff --git a/enterprise/tests/unit/storage/test_org_llm_settings_store.py b/enterprise/tests/unit/storage/test_org_llm_settings_store.pyindex a27a2ff0d4..24c7e08c09 100644--- a/enterprise/tests/unit/storage/test_org_llm_settings_store.py+++ b/enterprise/tests/unit/storage/test_org_llm_settings_store.py@@ -105,11 +105,11 @@ async def test_update_org_llm_settings_success(async_session_maker):org_id = org.idupdate_data = OrgLLMSettingsUpdate(- agent_settings_diff={+ agent_settings={'llm': {'model': 'new-model'},'agent': 'CodeActAgent',},- conversation_settings_diff={+ conversation_settings={'confirmation_mode': True,},)@@ -134,9 +134,7 @@ async def test_update_org_llm_settings_org_not_found(async_session_maker):"""# Arrangenon_existent_org_id = uuid.uuid4()- update_data = OrgLLMSettingsUpdate(- agent_settings_diff={'llm': {'model': 'new-model'}}- )+ update_data = OrgLLMSettingsUpdate(agent_settings={'llm': {'model': 'new-model'}})# Actasync with async_session_maker() as session:@@ -166,7 +164,7 @@ async def test_update_org_llm_settings_updates_org_defaults_only(async_session_mresult = await store.update_org_llm_settings(org.id,OrgLLMSettingsUpdate(- agent_settings_diff={'llm': {'model': 'new-model'}},+ agent_settings={'llm': {'model': 'new-model'}},llm_api_key='new-api-key',search_api_key='search-key',),diff --git a/enterprise/tests/unit/test_org_member_store.py b/enterprise/tests/unit/test_org_member_store.pyindex f972c37b7d..758d01f90a 100644--- a/enterprise/tests/unit/test_org_member_store.py+++ b/enterprise/tests/unit/test_org_member_store.py@@ -1227,15 +1227,15 @@ def test_org_llm_settings_update_apply_to_org_updates_secret_fields():def test_org_llm_settings_update_get_member_updates_includes_llm_api_key():"""- GIVEN: OrgLLMSettingsUpdate with llm_api_key set+ GIVEN: OrgLLMSettingsUpdate with agent_settings and llm_api_key setWHEN: get_member_updates() is called- THEN: Returns OrgMemberLLMSettings with llm_api_key included+ THEN: Returns OrgMemberLLMSettings including both the diff and llm_api_key"""from server.routes.org_models import OrgLLMSettingsUpdate# Arrangesettings = OrgLLMSettingsUpdate(- agent_settings_diff={'llm': {'model': 'claude-3'}},+ agent_settings={'llm': {'model': 'claude-3'}},llm_api_key='new-member-key',)@@ -1244,8 +1244,8 @@ def test_org_llm_settings_update_get_member_updates_includes_llm_api_key():# Assertassert member_updates is not None- assert member_updates.llm_api_key == 'new-member-key'- assert member_updates.agent_settings_diff is None+ assert member_updates.llm_api_key.get_secret_value() == 'new-member-key'+ assert member_updates.agent_settings_diff == {'llm': {'model': 'claude-3'}}def test_org_llm_settings_update_get_member_updates_only_llm_api_key():@@ -1264,7 +1264,7 @@ def test_org_llm_settings_update_get_member_updates_only_llm_api_key():# Assertassert member_updates is not None- assert member_updates.llm_api_key == 'member-key-only'+ assert member_updates.llm_api_key.get_secret_value() == 'member-key-only'assert member_updates.agent_settings_diff is Nonediff --git a/enterprise/tests/unit/test_org_service.py b/enterprise/tests/unit/test_org_service.pyindex 9d2fdd253d..a126eef4ce 100644--- a/enterprise/tests/unit/test_org_service.py+++ b/enterprise/tests/unit/test_org_service.py@@ -1200,7 +1200,7 @@ async def test_update_org_with_permissions_success_llm_fields_admin(from server.routes.org_models import OrgUpdateupdate_data = OrgUpdate(- agent_settings_diff={+ agent_settings={'llm': {'model': 'claude-opus-4-5-20251101','base_url': 'https://api.anthropic.com',@@ -1266,10 +1266,10 @@ async def test_update_org_with_permissions_success_llm_fields_owner(from server.routes.org_models import OrgUpdateupdate_data = OrgUpdate(- agent_settings_diff={+ agent_settings={'llm': {'model': 'claude-opus-4-5-20251101'},},- conversation_settings_diff={+ conversation_settings={'security_analyzer': 'llm',},)@@ -1333,7 +1333,7 @@ async def test_update_org_with_permissions_success_mixed_fields_admin(update_data = OrgUpdate(contact_name='Jane Doe',- agent_settings_diff={'llm': {'model': 'claude-opus-4-5-20251101'}},+ agent_settings={'llm': {'model': 'claude-opus-4-5-20251101'}},conversation_expiration=30,)@@ -1537,7 +1537,7 @@ async def test_update_org_with_permissions_llm_fields_insufficient_permission(from server.routes.org_models import OrgUpdateupdate_data = OrgUpdate(- agent_settings_diff={'llm': {'model': 'claude-opus-4-5-20251101'}}+ agent_settings={'llm': {'model': 'claude-opus-4-5-20251101'}})with (@@ -1781,11 +1781,11 @@ async def test_update_org_with_permissions_only_llm_fields(from server.routes.org_models import OrgUpdateupdate_data = OrgUpdate(- agent_settings_diff={+ agent_settings={'llm': {'model': 'claude-opus-4-5-20251101'},'agent': 'agent-mode',},- conversation_settings_diff={+ conversation_settings={'security_analyzer': 'llm',},)diff --git a/enterprise/tests/unit/test_org_store.py b/enterprise/tests/unit/test_org_store.pyindex b31423e94c..dd9c7375ae 100644--- a/enterprise/tests/unit/test_org_store.py+++ b/enterprise/tests/unit/test_org_store.py@@ -114,7 +114,7 @@ async def test_update_org(async_session_maker, mock_litellm_api):org_id=org_id,kwargs={'name': 'updated-org',- 'agent_settings_diff': {'agent': 'PlannerAgent'},+ 'agent_settings': {'agent': 'PlannerAgent'},},)@@ -1053,7 +1053,7 @@ async def test_update_org_llm_settings_async_with_llm_api_key():)llm_settings = OrgLLMSettingsUpdate(- agent_settings_diff={'llm': {'model': 'new-model'}},+ agent_settings={'llm': {'model': 'new-model'}},llm_api_key='new-member-api-key',)@@ -1087,8 +1087,8 @@ async def test_update_org_llm_settings_async_with_llm_api_key():mock_member_update.assert_called_once()call_args = mock_member_update.call_argsmember_settings = call_args[0][2] # Third positional arg is member_settings- assert member_settings.llm_api_key == 'new-member-api-key'- assert member_settings.agent_settings_diff is None+ assert member_settings.llm_api_key.get_secret_value() == 'new-member-api-key'+ assert member_settings.agent_settings_diff == {'llm': {'model': 'new-model'}}@pytest.mark.asyncio@@ -1102,9 +1102,7 @@ async def test_update_org_llm_settings_async_org_not_found():# Arrangenon_existent_org_id = uuid.uuid4()- llm_settings = OrgLLMSettingsUpdate(- agent_settings_diff={'llm': {'model': 'new-model'}}- )+ llm_settings = OrgLLMSettingsUpdate(agent_settings={'llm': {'model': 'new-model'}})# Mock the async session to return None for orgmock_session = AsyncMock()diff --git a/openhands/app_server/settings/settings_router.py b/openhands/app_server/settings/settings_router.pyindex 90398acc10..ad722dbed0 100644--- a/openhands/app_server/settings/settings_router.py+++ b/openhands/app_server/settings/settings_router.py@@ -30,7 +30,11 @@ from openhands.storage.data_models.secrets import Secretsfrom openhands.storage.data_models.settings import Settingsfrom openhands.storage.secrets.secrets_store import SecretsStorefrom openhands.storage.settings.settings_store import SettingsStore-from openhands.utils.llm import get_provider_api_base, is_openhands_model+from openhands.utils.llm import (+ get_provider_api_base,+ is_openhands_model,+ resolve_llm_base_url,+)LITE_LLM_API_URL = os.environ.get('LITE_LLM_API_URL', 'https://llm-proxy.app.all-hands.dev'@@ -47,25 +51,16 @@ router = APIRouter(def _post_merge_llm_fixups(settings: Settings) -> None:"""Apply LLM-specific fixups after merging settings.- When the merged LLM base_url is empty-string, treat it as cleared.- When it is None, try to auto-detect the provider default.+ Delegates the empty-string β cleared and provider-default inference+ rules to :func:`openhands.utils.llm.resolve_llm_base_url` so the+ personal-save and enterprise org-defaults paths stay in lockstep."""llm = settings.agent_settings.llm-- if llm.base_url == '':- llm.base_url = None- elif llm.base_url is None and llm.model:- if is_openhands_model(llm.model):- llm.base_url = LITE_LLM_API_URL- else:- try:- api_base = get_provider_api_base(llm.model)- if api_base:- llm.base_url = api_base- except Exception as e:- logger.error(- f'Failed to get api_base from litellm for model {llm.model}: {e}'- )+ llm.base_url = resolve_llm_base_url(+ model=llm.model,+ base_url=llm.base_url,+ managed_proxy_url=LITE_LLM_API_URL,+ )# NOTE: We use response_model=None for endpoints that return JSONResponse directly.diff --git a/openhands/utils/llm.py b/openhands/utils/llm.pyindex dfdea2a1b1..2739e34a73 100644--- a/openhands/utils/llm.py+++ b/openhands/utils/llm.py@@ -111,6 +111,59 @@ def is_openhands_model(model: str | None) -> bool:)+# Canonical masked placeholder for LLM API keys. Matches pydantic's+# ``SecretStr`` default representation so request/response payloads that pass+# through ``model_dump(mode='json')`` stay consistent with payloads that the+# enterprise org-settings validator constructs by hand. Importers should treat+# this as the single source of truth for "a key exists but its value is+# intentionally hidden."+MASKED_API_KEY = '**********'+++def resolve_llm_base_url(+ model: str | None,+ base_url: str | None,+ *,+ managed_proxy_url: str,+) -> str | None:+ """Resolve the ``base_url`` to persist for an LLM configuration.++ Single source of truth for two code paths that otherwise duplicated the+ same logic:++ * ``openhands/app_server/settings/settings_router._post_merge_llm_fixups``+ (personal-settings save path).+ * ``enterprise/server/routes/org_models.OrgLLMSettingsUpdate._normalize_agent_settings``+ (org-defaults save path).++ Semantics:++ * ``base_url == ''`` β ``None`` (explicit "clear" signal from the UI;+ don't auto-infer on top of it).+ * ``base_url`` non-empty β returned unchanged.+ * ``base_url is None`` + known OpenHands / managed model β ``managed_proxy_url``.+ * ``base_url is None`` + known BYOR provider β default from+ :func:`get_provider_api_base`.+ * Any other combination β ``None``.++ Exceptions from ``litellm`` are logged and swallowed so a flaky provider+ lookup can never break a settings save.+ """+ if base_url == '':+ return None+ if base_url is not None:+ return base_url+ if not model:+ return None+ if is_openhands_model(model):+ return managed_proxy_url+ try:+ return get_provider_api_base(model)+ except Exception as e:+ logger.error(f'Failed to get api_base from litellm for model {model}: {e}')+ return None++def get_provider_api_base(model: str) -> str | None:"""Get the API base URL for a model using litellm.