From 5a8d1f5ecaedac9348f93fd87873e7a16b9fba0f Mon Sep 17 00:00:00 2001 From: Yuneng Jiang Date: Fri, 18 Sep 2026 00:05:43 -0700 Subject: [PATCH 1/8] feat(proxy): report sources in config read endpoints --- litellm/proxy/_types.py | 3 + litellm/proxy/config_resolvers/__init__.py | 11 +- .../proxy/config_resolvers/settings_store.py | 12 +- .../router_settings_endpoints.py | 12 +- litellm/proxy/proxy_server.py | 168 ++++++++++-------- .../proxy_setting_endpoints.py | 65 +++++-- .../test_router_settings_endpoints.py | 30 ++++ .../proxy/proxy_server/test_routes_config.py | 137 ++++++++++++++ .../proxy_server/test_routes_model_metrics.py | 38 ++++ .../test_proxy_setting_endpoints.py | 39 ++++ ui/litellm-dashboard/src/lib/http/schema.d.ts | 29 +++ 11 files changed, 450 insertions(+), 94 deletions(-) diff --git a/litellm/proxy/_types.py b/litellm/proxy/_types.py index b0d31df92ce..8574f2d8bf4 100644 --- a/litellm/proxy/_types.py +++ b/litellm/proxy/_types.py @@ -2410,6 +2410,7 @@ class FieldDetail(BaseModel): field_description: str field_default_value: Any = None stored_in_db: bool | None + source: Literal["config", "db", "default", "unset"] = "unset" class ConfigList(LiteLLMPydanticObjectBase): @@ -2418,6 +2419,7 @@ class ConfigList(LiteLLMPydanticObjectBase): field_description: str field_value: Any stored_in_db: bool | None + source: Literal["config", "db", "default", "unset"] = "unset" field_default_value: Any premium_field: bool = False nested_fields: list[FieldDetail] | None = None # For nested dictionary or Pydantic fields @@ -3693,6 +3695,7 @@ class InvitationClaim(LiteLLMPydanticObjectBase): class ConfigFieldInfo(LiteLLMPydanticObjectBase): field_name: str field_value: Any + source: Literal["config", "db", "default", "unset"] = "unset" class CallbackOnUI(LiteLLMPydanticObjectBase): diff --git a/litellm/proxy/config_resolvers/__init__.py b/litellm/proxy/config_resolvers/__init__.py index ebd339b34c3..77da2c413c2 100644 --- a/litellm/proxy/config_resolvers/__init__.py +++ b/litellm/proxy/config_resolvers/__init__.py @@ -5,6 +5,13 @@ from litellm.proxy.config_resolvers._descriptors import ( FieldSource, resolve_fields, ) -from litellm.proxy.config_resolvers.settings_store import SettingsStore +from litellm.proxy.config_resolvers.settings_store import SettingsSource, SettingsStore, source_for -__all__ = ("FieldDescriptor", "FieldSource", "SettingsStore", "resolve_fields") +__all__ = ( + "FieldDescriptor", + "FieldSource", + "SettingsSource", + "SettingsStore", + "resolve_fields", + "source_for", +) diff --git a/litellm/proxy/config_resolvers/settings_store.py b/litellm/proxy/config_resolvers/settings_store.py index 3fe869ee2ce..8f400853fa9 100644 --- a/litellm/proxy/config_resolvers/settings_store.py +++ b/litellm/proxy/config_resolvers/settings_store.py @@ -2,7 +2,7 @@ from __future__ import annotations from collections.abc import Iterator, Mapping, MutableMapping from types import MappingProxyType -from typing import Final +from typing import Final, Literal, TypeAlias from litellm.proxy.config_resolvers._descriptors import FieldSource from litellm.proxy.config_resolvers.settings_rules import ( @@ -19,6 +19,7 @@ from litellm.proxy.config_resolvers.settings_rules import ( _EMPTY_VALUES: Final[Mapping[str, JsonValue]] = MappingProxyType({}) _EMPTY_ROWS: Final[Mapping[DbRow, Mapping[str, JsonValue]]] = MappingProxyType({}) +SettingsSource: TypeAlias = Literal["config", "db", "default", "unset"] class SettingsStore(MutableMapping[str, JsonValue]): @@ -109,3 +110,12 @@ class SettingsStore(MutableMapping[str, JsonValue]): yaml_value: Final[SettingValue] = self._yaml_values.get(key, ABSENT) db_value: Final[SettingValue] = self._database_rows.get(rule.db_row, _EMPTY_VALUES).get(key, ABSENT) return resolve(rule, yaml_value, db_value) + + +def source_for(settings: SettingsStore, key: str, default: object = None) -> SettingsSource: + source: Final = settings.source(key) + if source == "unset": + return "default" if default is not None else "unset" + if source in ("config", "db", "default"): + return source + return "unset" diff --git a/litellm/proxy/management_endpoints/router_settings_endpoints.py b/litellm/proxy/management_endpoints/router_settings_endpoints.py index fc000b1638b..5d3b6d40601 100644 --- a/litellm/proxy/management_endpoints/router_settings_endpoints.py +++ b/litellm/proxy/management_endpoints/router_settings_endpoints.py @@ -8,7 +8,7 @@ GET /router/fields - Get router settings field definitions without values (for U """ import inspect -from typing import Any, Final, get_args +from typing import Any, Final, cast, get_args from fastapi import APIRouter, Depends from pydantic import BaseModel, Field @@ -16,6 +16,7 @@ from pydantic import BaseModel, Field from litellm._logging import verbose_proxy_logger from litellm.proxy._types import UserAPIKeyAuth from litellm.proxy.auth.user_api_key_auth import user_api_key_auth +from litellm.proxy.config_resolvers import SettingsSource, source_for from litellm.router import Router from litellm.types.management_endpoints import ( ROUTER_SETTINGS_FIELDS, @@ -30,6 +31,7 @@ class RouterSettingsResponse(BaseModel): fields: list[RouterSettingsField] = Field(description="List of all configurable router settings with metadata") current_values: dict[str, Any] = Field(description="Current values of router settings") routing_strategy_descriptions: dict[str, str] = Field(description="Descriptions for each routing strategy option") + source: dict[str, SettingsSource] = Field(description="Source of each current router setting") class RouterFieldsResponse(BaseModel): @@ -109,15 +111,21 @@ async def get_router_settings( # Merge with config values (config takes precedence) current_values.update(router_settings_from_config) - # Update field values with current values for field in router_fields: if field.field_name in current_values: field.field_value = current_values[field.field_name] + field_defaults: Final[dict[str, object]] = { + field.field_name: cast(object, field.field_default) for field in router_fields + } + source: Final[dict[str, SettingsSource]] = { + key: source_for(proxy_config.router_settings, key, field_defaults.get(key)) for key in current_values + } return RouterSettingsResponse( fields=router_fields, current_values=current_values, routing_strategy_descriptions=ROUTING_STRATEGY_DESCRIPTIONS, + source=source, ) except Exception as e: verbose_proxy_logger.error("Error fetching router settings: %s", e) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 6a720a066b4..1131d7bea86 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -50,6 +50,7 @@ import anyio import websockets import websockets.exceptions from pydantic import BaseModel, Json, JsonValue, TypeAdapter, ValidationError +from pydantic.fields import FieldInfo, PydanticUndefined from typing_extensions import NotRequired, ReadOnly, assert_never from litellm._uuid import uuid @@ -431,7 +432,7 @@ from litellm.proxy.common_utils.user_api_key_cache import ( model_access_group_spend_counter_key, tag_cache_key, ) -from litellm.proxy.config_resolvers import SettingsStore, resolve_fields +from litellm.proxy.config_resolvers import SettingsStore, resolve_fields, source_for from litellm.proxy.config_resolvers.alerting import ( EMAIL_DESCRIPTORS, MS_TEAMS_DESCRIPTORS, @@ -4816,6 +4817,12 @@ def _as_settings_mapping(value: object) -> Mapping[str, SettingsJsonValue]: return _SETTINGS_MAPPING.validate_python(value) +def _get_field_default(field_info: FieldInfo) -> JsonValue: + if field_info.default is PydanticUndefined: + return None + return cast(JsonValue, field_info.default) + + def _bind_general_settings_store(settings: SettingsStore) -> None: global general_settings general_settings = settings # pyright: ignore[reportAssignmentType] # legacy global accepts mappings @@ -15635,17 +15642,16 @@ async def alerting_settings( where={"param_name": "general_settings"} ) - if db_general_settings is not None and db_general_settings.param_value is not None: - db_general_settings_dict: Final = dict(db_general_settings.param_value) - alerting_args_dict: dict = cast( # cast-ok: ConfigGeneralSettings validates alerting_args as a dict on write - dict[str, JsonValue], db_general_settings_dict.get("alerting_args", {}) - ) - alerting_values: list | None = cast( # cast-ok: ConfigGeneralSettings validates alerting as a list on write - list[JsonValue] | None, db_general_settings_dict.get("alerting") - ) - else: - alerting_args_dict = {} - alerting_values = None + db_general_settings_dict: Final[Mapping[str, JsonValue]] = ( + dict(db_general_settings.param_value) + if db_general_settings is not None and db_general_settings.param_value is not None + else {} + ) + alerting_args_dict: Final = cast(dict[str, JsonValue], db_general_settings_dict.get("alerting_args", {})) + alerting_values: Final = cast(list[JsonValue] | None, db_general_settings_dict.get("alerting")) + + settings: Final = proxy_config.settings + settings.apply_db_row("general_settings", db_general_settings_dict) allowed_args: Final = MappingProxyType( { @@ -15674,9 +15680,9 @@ async def alerting_settings( is_slack_enabled = False - if general_settings.get("alerting") and isinstance(general_settings["alerting"], list): - if "slack" in general_settings["alerting"]: - is_slack_enabled = True + alerting: Final = settings.get("alerting") + if isinstance(alerting, list) and "slack" in alerting: + is_slack_enabled = True _response_obj = ConfigList( field_name="slack_alerting", @@ -15684,6 +15690,7 @@ async def alerting_settings( field_description="Enable slack alerting for monitoring proxy in production: llm outages, budgets, spend tracking failures.", field_value=is_slack_enabled, stored_in_db=True if alerting_values is not None else False, + source=source_for(settings, "alerting"), field_default_value=None, premium_field=False, ) @@ -15691,6 +15698,7 @@ async def alerting_settings( for field_name, field_info in SlackAlertingArgs.model_fields.items(): if field_name in allowed_args: + field_default: JsonValue = _get_field_default(field_info) _stored_in_db: bool | None = None if field_name in alerting_args_dict: _stored_in_db = True @@ -15701,9 +15709,10 @@ async def alerting_settings( field_name=field_name, field_type=allowed_args[field_name], field_description=field_info.description or "", - field_value=_slack_alerting_args_dict.get(field_name, None), + field_value=_slack_alerting_args_dict.get(field_name, field_default), stored_in_db=_stored_in_db, - field_default_value=field_info.default, + source=source_for(settings, "alerting_args", field_default), + field_default_value=field_default, premium_field=(True if field_name == "region_outage_alert_ttl" else False), ) return_val.append(_response_obj) @@ -17390,20 +17399,6 @@ async def get_config_general_settings( field_name: str, user_api_key_dict: UserAPIKeyAuth = Depends(user_api_key_auth), ): - global prisma_client - - ## VALIDATION ## - """ - - Check if prisma_client is None - - Check if user allowed to call this endpoint (admin-only) - - Check if param in general settings - """ - if prisma_client is None: - raise HTTPException( - status_code=400, - detail={"error": CommonProxyErrors.db_not_connected_error.value}, - ) - if not _user_has_admin_view(user_api_key_dict): raise HTTPException( status_code=400, @@ -17416,37 +17411,47 @@ async def get_config_general_settings( detail={"error": f"Invalid field={field_name} passed in."}, ) - ## get general settings from db - db_general_settings: Final[_ConfigParamRow | None] = await _config_param_table(prisma_client).find_first( - where={"param_name": "general_settings"} - ) - ### pop the value + field_info: Final = ConfigGeneralSettings.model_fields[field_name] + field_default: JsonValue = _get_field_default(field_info) + settings: Final = proxy_config.settings + db_values: Mapping[str, JsonValue] + if prisma_client is None: + db_values = {} + else: + db_general_settings: Final[_ConfigParamRow | None] = await _config_param_table(prisma_client).find_first( + where={"param_name": "general_settings"} + ) + db_values = ( + dict(db_general_settings.param_value) + if db_general_settings is not None and db_general_settings.param_value is not None + else {} + ) + settings.apply_db_row("general_settings", db_values) - if db_general_settings is None or db_general_settings.param_value is None: + if field_name not in settings and field_default is None: raise HTTPException( status_code=400, detail={"error": f"Field name={field_name} not in DB"}, ) - else: - general_settings = dict(db_general_settings.param_value) - if field_name in general_settings: - field_value = _redact_general_setting_value( - field_name, - general_settings[field_name], - user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN, - ) - if field_name == "plugins" and isinstance(field_value, list): - field_value = [ - ({k: ("***" if k == "plugin_key" else v) for k, v in p.items()} if isinstance(p, dict) else p) - for p in field_value - ] - return ConfigFieldInfo(field_name=field_name, field_value=field_value) - else: - raise HTTPException( - status_code=400, - detail={"error": f"Field name={field_name} not in DB"}, - ) + redacted_field_value: Final = _redact_general_setting_value( + field_name, + settings.get(field_name, field_default), + user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN, + ) + field_value: Final = ( + [ + ({k: ("***" if k == "plugin_key" else v) for k, v in p.items()} if isinstance(p, dict) else p) + for p in redacted_field_value + ] + if field_name == "plugins" and isinstance(redacted_field_value, list) + else redacted_field_value + ) + return ConfigFieldInfo( + field_name=field_name, + field_value=field_value, + source=source_for(settings, field_name, field_default), + ) GeneralSettingsUILiteLLMValue = float | bool | str | None @@ -17600,7 +17605,7 @@ async def get_config_list( """ List the available fields + current values for a given type of setting (currently just 'general_settings'user_api_key_dict: UserAPIKeyAuth = Depends(user_api_key_auth),) """ - global prisma_client, general_settings + global prisma_client ## VALIDATION ## """ @@ -17627,10 +17632,16 @@ async def get_config_list( where={"param_name": "general_settings"} ) - if db_general_settings is not None and db_general_settings.param_value is not None: - db_general_settings_dict: Mapping[str, JsonValue] = dict(db_general_settings.param_value) - else: - db_general_settings_dict = {} + db_general_settings_dict: Final[Mapping[str, JsonValue]] = ( + dict(db_general_settings.param_value) + if db_general_settings is not None and db_general_settings.param_value is not None + else {} + ) + settings: Final = proxy_config.settings + settings.apply_db_row("general_settings", db_general_settings_dict) + runtime_settings: Final[Mapping[str, JsonValue]] = ( + cast(Mapping[str, JsonValue], general_settings) if not isinstance(general_settings, SettingsStore) else settings + ) allowed_args: Final = _GENERAL_SETTINGS_CONFIG_LIST_FIELD_TYPES @@ -17638,6 +17649,7 @@ async def get_config_list( for field_name, field_info in ConfigGeneralSettings.model_fields.items(): if field_name in allowed_args: + field_default: JsonValue = _get_field_default(field_info) ## HANDLE TYPED DICT typed_dict_type = allowed_args[field_name] @@ -17657,10 +17669,11 @@ async def get_config_list( field_description="", # Add custom logic if descriptions are available field_default_value=_redact_general_setting_value( sub_field, - general_settings.get(sub_field, None), + runtime_settings.get(sub_field, None), is_full_admin, ), stored_in_db=None, + source=source_for(settings, field_name), ) for sub_field, sub_field_type in pydantic_class.__annotations__.items() ] @@ -17677,7 +17690,7 @@ async def get_config_list( _stored_in_db = None if field_name in db_general_settings_dict: _stored_in_db = True - elif field_name in general_settings: + elif field_name in runtime_settings: _stored_in_db = False _response_obj = ConfigList( @@ -17686,11 +17699,12 @@ async def get_config_list( field_description=field_info.description or "", field_value=_redact_general_setting_value( field_name, - general_settings.get(field_name, None), + runtime_settings.get(field_name, field_default), is_full_admin, ), stored_in_db=_stored_in_db, - field_default_value=field_info.default, + source=source_for(settings, field_name, field_default), + field_default_value=field_default, nested_fields=nested_fields, ) return_val.append(_response_obj) @@ -17701,12 +17715,10 @@ async def get_config_list( _stored_in_db = None if field_name in db_general_settings_dict: _stored_in_db = True - elif field_name in general_settings: + elif field_name in runtime_settings: _stored_in_db = False - _field_value = general_settings.get(field_name, None) - if _field_value is None and field_name in db_general_settings_dict: - _field_value = db_general_settings_dict[field_name] + _field_value: JsonValue = runtime_settings.get(field_name, field_default) _response_obj = ConfigList( field_name=field_name, @@ -17714,7 +17726,8 @@ async def get_config_list( field_description=field_info.description or "", field_value=_redact_general_setting_value(field_name, _field_value, is_full_admin), stored_in_db=_stored_in_db, - field_default_value=field_info.default, + source=source_for(settings, field_name, field_default), + field_default_value=field_default, nested_fields=nested_fields, ) return_val.append(_response_obj) @@ -17722,18 +17735,24 @@ async def get_config_list( db_litellm_settings_row: Final[_ConfigParamRow | None] = await _config_param_table(prisma_client).find_first( where={"param_name": "litellm_settings"} ) - db_litellm_settings: Final[dict] = ( + db_litellm_settings: Final[Mapping[str, JsonValue]] = ( dict(db_litellm_settings_row.param_value) if db_litellm_settings_row is not None and db_litellm_settings_row.param_value is not None else {} ) + litellm_settings_store: Final = proxy_config.litellm_settings + litellm_settings_store.apply_db_row("litellm_settings", db_litellm_settings) for litellm_field_name, spec in _GENERAL_SETTINGS_UI_LITELLM_FIELDS.items(): - current_value: GeneralSettingsUILiteLLMValue = getattr(litellm, litellm_field_name, None) - default_value = _general_settings_ui_litellm_default(spec) + default_value: GeneralSettingsUILiteLLMValue = _general_settings_ui_litellm_default(spec) + current_value: GeneralSettingsUILiteLLMValue = cast( + GeneralSettingsUILiteLLMValue, + litellm_settings_store.get(litellm_field_name, default_value), + ) + source = source_for(litellm_settings_store, litellm_field_name, default_value) stored_in_db_litellm: bool | None if litellm_field_name in db_litellm_settings: stored_in_db_litellm = True - elif current_value != default_value: + elif source == "config": stored_in_db_litellm = False else: stored_in_db_litellm = None @@ -17744,6 +17763,7 @@ async def get_config_list( field_description=spec["description"], field_value=current_value, stored_in_db=stored_in_db_litellm, + source=source, field_default_value=default_value, field_options=list(spec.get("options", ())) or None, field_tab=spec.get("tab"), diff --git a/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py b/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py index fd160636d46..4cd031b8780 100644 --- a/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py +++ b/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py @@ -14,8 +14,8 @@ from typing import ( from urllib.parse import urlparse from fastapi import APIRouter, Body, Depends, File, HTTPException, UploadFile -from pydantic import ConfigDict, JsonValue, TypeAdapter, ValidationError, create_model -from pydantic.fields import FieldInfo +from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter, ValidationError, create_model +from pydantic.fields import FieldInfo, PydanticUndefined from typing_extensions import NotRequired, ReadOnly, TypedDict import litellm @@ -24,6 +24,7 @@ from litellm.litellm_core_utils.sensitive_data_masker import mask_sensitive_keys from litellm.proxy._experimental.mcp_server.tool_search import MCP_TOOL_SEARCH_SETTINGS_KEY from litellm.proxy._types import * from litellm.proxy.auth.user_api_key_auth import user_api_key_auth +from litellm.proxy.config_resolvers import SettingsSource, source_for from litellm.proxy.config_resolvers.sso import ( SSO_FIELD_ENV_VARS, SSO_SECRET_FIELDS, @@ -197,6 +198,11 @@ class SettingsResponse(BaseModel): """Schema information including descriptions and property types for UI display""" +class _SettingsWithSchema(BaseModel): + values: dict[str, object] + field_schema: dict[str, object] + + class SSOSettingsResponse(SettingsResponse): """Response model for SSO settings""" @@ -327,6 +333,8 @@ class UISettings(BaseModel): class UISettingsResponse(SettingsResponse): """Response model for UI settings""" + source: dict[str, SettingsSource] + # Allowlist of UI settings that can be stored ALLOWED_UI_SETTINGS_FIELDS: Final = { @@ -658,6 +666,13 @@ def _root_schema(settings_class: type[BaseModel]) -> _RootSchema: ) +def _model_field_default(settings_class: type[BaseModel], field_name: str) -> object: + field_info: Final = settings_class.model_fields.get(field_name) + if field_info is None or field_info.default is PydanticUndefined: + return None + return cast(object, field_info.default) + + async def _get_settings_with_schema( settings_key: str, settings_class: type[BaseModel], @@ -1527,7 +1542,7 @@ async def get_ui_settings(): Get UI-specific configuration flags. All authenticated users can fetch these settings for client-side behavior. """ - from litellm.proxy.proxy_server import prisma_client + from litellm.proxy.proxy_server import prisma_client, proxy_config if prisma_client is None: raise HTTPException( @@ -1546,26 +1561,46 @@ async def get_ui_settings(): ui_settings: Final = {k: v for k, v in parsed.items() if k in ALLOWED_UI_SETTINGS_FIELDS} apply_runtime_general_settings_flags(ui_settings) + proxy_config.settings.apply_db_row("ui_settings", ui_settings) # Refresh DualCache so other code paths (e.g. /user/filter/ui) see fresh values from litellm.proxy.proxy_server import user_api_key_cache await user_api_key_cache.async_set_cache(key=UI_SETTINGS_CACHE_KEY, value=ui_settings, ttl=UI_SETTINGS_CACHE_TTL) - # Build config-like object for schema helper - config: Final[dict[str, object]] = {"litellm_settings": {"ui_settings": ui_settings}} - - settings: Final = await _get_settings_with_schema( - settings_key="ui_settings", - settings_class=_get_effective_ui_settings_class(), - config=config, + effective_ui_settings: Final = { + **{key: proxy_config.settings[key] for key in ALLOWED_UI_SETTINGS_FIELDS if key in proxy_config.settings}, + **ui_settings, + } + config: Final[dict[str, object]] = {"litellm_settings": {"ui_settings": effective_ui_settings}} + settings_class: Final = _get_effective_ui_settings_class() + resolved_settings: Final = _SettingsWithSchema.model_validate( + await _get_settings_with_schema( + settings_key="ui_settings", + settings_class=settings_class, + config=config, + ) ) + values: Final = { + **resolved_settings.values, + ENABLE_PTU_COST_ATTRIBUTION_UI_SETTING: is_ptu_cost_attribution_enabled(), + } + source: Final[dict[str, SettingsSource]] = { + key: ( + "db" + if key in ui_settings + else source_for( + proxy_config.settings, + key, + _model_field_default(settings_class, key), + ) + ) + for key in values + } return UISettingsResponse( - values={ - **settings["values"], - ENABLE_PTU_COST_ATTRIBUTION_UI_SETTING: is_ptu_cost_attribution_enabled(), - }, - field_schema=settings["field_schema"], + values=values, + field_schema=resolved_settings.field_schema, + source=source, ) diff --git a/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py index 308f4d88f02..148f30f517b 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py +++ b/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py @@ -75,6 +75,36 @@ class TestRouterSettingsEndpoints: assert isinstance(routing_strategy_field["options"], list) assert len(routing_strategy_field["options"]) > 0 + @pytest.mark.asyncio + async def test_get_router_settings_reports_sources(self, monkeypatch): + from litellm.proxy.config_resolvers import SettingsStore + + store = SettingsStore("router_settings") + store.load_yaml({"routing_strategy": "simple-shuffle"}) + store.apply_db_row("router_settings", {"num_retries": 3}) + monkeypatch.setattr(proxy_server.proxy_config, "router_settings", store) + monkeypatch.setattr(proxy_server, "llm_router", None) + + async def fake_get_config(self, config_file_path=None): + return { + "router_settings": { + "routing_strategy": "simple-shuffle", + "num_retries": 3, + } + } + + monkeypatch.setattr( + proxy_server.ProxyConfig, "get_config", fake_get_config, raising=True + ) + + admin_user = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, api_key="sk-x" + ) + response = await get_router_settings(user_api_key_dict=admin_user) + + assert response.source["routing_strategy"] == "config" + assert response.source["num_retries"] == "db" + @pytest.mark.asyncio async def test_get_router_settings_includes_routing_groups_from_live_router( self, monkeypatch diff --git a/tests/test_litellm/proxy/proxy_server/test_routes_config.py b/tests/test_litellm/proxy/proxy_server/test_routes_config.py index dd3914e3ad5..d6c63ec9a78 100644 --- a/tests/test_litellm/proxy/proxy_server/test_routes_config.py +++ b/tests/test_litellm/proxy/proxy_server/test_routes_config.py @@ -15,10 +15,15 @@ from __future__ import annotations import asyncio import json +from collections.abc import Mapping +from typing import Final from unittest.mock import AsyncMock, MagicMock import pytest +from litellm.proxy.config_resolvers import SettingsStore +from litellm.proxy.config_resolvers.settings_rules import JsonValue + from .conftest import VOLATILE_KEYS, normalize @@ -37,6 +42,21 @@ def _install_litellm_config(mock_prisma: MagicMock) -> MagicMock: return table +def _install_settings_store( + monkeypatch: pytest.MonkeyPatch, + config_values: Mapping[str, JsonValue], + db_values: Mapping[str, JsonValue], +) -> SettingsStore: + from litellm.proxy import proxy_server + + store: Final = SettingsStore("general_settings") + store.load_yaml(config_values) + store.apply_db_row("general_settings", db_values) + monkeypatch.setattr(proxy_server.proxy_config, "settings", store) + monkeypatch.setattr(proxy_server, "general_settings", store) + return store + + # --------------------------------------------------------------------------- # POST /config/update # --------------------------------------------------------------------------- @@ -338,6 +358,7 @@ def test_config_field_info_happy_admin(client, auth_as, mock_prisma, monkeypatch assert normalize(response.json()) == { "field_name": "max_parallel_requests", "field_value": 7, + "source": "db", } @@ -566,6 +587,122 @@ def test_config_list_happy_admin(client, auth_as, mock_prisma, monkeypatch): } +def test_config_read_routes_report_effective_values_and_sources(client, auth_as, mock_prisma, monkeypatch): + from litellm.proxy import proxy_server as ps + from litellm.proxy._types import LitellmUserRoles + + table = _install_litellm_config(mock_prisma) + row = MagicMock() + row.param_value = {"max_parallel_requests": 7, "max_file_size_mb": 222} + table.find_first = AsyncMock(return_value=row) + monkeypatch.setattr(ps, "prisma_client", mock_prisma) + _install_settings_store( + monkeypatch, + { + "max_parallel_requests": 5, + "max_file_size_mb": 111, + "pass_through_endpoints": [{"path": "/synthetic"}], + }, + {"max_parallel_requests": 7, "max_file_size_mb": 222}, + ) + + with auth_as(LitellmUserRoles.PROXY_ADMIN): + list_response = client.get("/config/list", params={"config_type": "general_settings"}) + config_only_response = client.get( + "/config/field/info", params={"field_name": "max_file_size_mb"} + ) + db_wins_response = client.get( + "/config/field/info", params={"field_name": "max_parallel_requests"} + ) + + assert list_response.status_code == 200 + by_name: Final = {entry["field_name"]: entry for entry in list_response.json()} + assert by_name["max_file_size_mb"]["field_value"] == 111 + assert by_name["max_file_size_mb"]["source"] == "config" + assert by_name["pass_through_endpoints"]["source"] == "config" + assert by_name["pass_through_endpoints"]["nested_fields"][0]["source"] == "config" + assert by_name["max_parallel_requests"]["field_value"] == 7 + assert by_name["max_parallel_requests"]["source"] == "db" + + assert config_only_response.status_code == 200 + assert config_only_response.json() == { + "field_name": "max_file_size_mb", + "field_value": 111, + "source": "config", + } + assert db_wins_response.status_code == 200 + assert db_wins_response.json() == { + "field_name": "max_parallel_requests", + "field_value": 7, + "source": "db", + } + + +def test_config_read_routes_report_default_source(client, auth_as, mock_prisma, monkeypatch): + from litellm.proxy import proxy_server as ps + from litellm.proxy._types import LitellmUserRoles + + table = _install_litellm_config(mock_prisma) + row = MagicMock() + row.param_value = {} + table.find_first = AsyncMock(return_value=row) + monkeypatch.setattr(ps, "prisma_client", mock_prisma) + _install_settings_store(monkeypatch, {}, {}) + + with auth_as(LitellmUserRoles.PROXY_ADMIN): + list_response = client.get("/config/list", params={"config_type": "general_settings"}) + field_response = client.get( + "/config/field/info", params={"field_name": "proxy_config_reload_interval_seconds"} + ) + + assert list_response.status_code == 200 + by_name: Final = {entry["field_name"]: entry for entry in list_response.json()} + assert by_name["proxy_config_reload_interval_seconds"]["field_value"] == 30 + assert by_name["proxy_config_reload_interval_seconds"]["source"] == "default" + assert field_response.status_code == 200 + assert field_response.json() == { + "field_name": "proxy_config_reload_interval_seconds", + "field_value": 30, + "source": "default", + } + + +def test_config_field_info_uses_store_without_db(client, auth_as, monkeypatch): + from litellm.proxy import proxy_server as ps + from litellm.proxy._types import LitellmUserRoles + + monkeypatch.setattr(ps, "prisma_client", None) + _install_settings_store(monkeypatch, {"max_file_size_mb": 111}, {}) + + with auth_as(LitellmUserRoles.PROXY_ADMIN): + response = client.get("/config/field/info", params={"field_name": "max_file_size_mb"}) + + assert response.status_code == 200 + assert response.json() == { + "field_name": "max_file_size_mb", + "field_value": 111, + "source": "config", + } + + +def test_config_field_info_unset_source_remains_an_error(client, auth_as, mock_prisma, monkeypatch): + from litellm.proxy import proxy_server as ps + from litellm.proxy._types import LitellmUserRoles + + table = _install_litellm_config(mock_prisma) + row = MagicMock() + row.param_value = {} + table.find_first = AsyncMock(return_value=row) + monkeypatch.setattr(ps, "prisma_client", mock_prisma) + _install_settings_store(monkeypatch, {}, {}) + + with auth_as(LitellmUserRoles.PROXY_ADMIN): + response = client.get("/config/field/info", params={"field_name": "max_parallel_requests"}) + + assert response.status_code == 400 + assert "not in" in response.json()["detail"]["error"] + + def test_config_list_exposes_config_reload_interval(client, auth_as, mock_prisma, monkeypatch): """proxy_config_reload_interval_seconds must surface in the admin UI general-settings list as an Integer field defaulting to 30, so operators can tune multi-pod convergence diff --git a/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py b/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py index 246e2cbba54..6a57ad1636d 100644 --- a/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py +++ b/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py @@ -179,6 +179,44 @@ def test_model_settings_method_not_allowed(client, auth_as): # --------------------------------------------------------------------------- +def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): + from litellm.proxy.config_resolvers import SettingsStore + + pc = MagicMock() + row = MagicMock() + row.param_value = {"alerting_args": {"daily_report_frequency": 7}} + pc.db.litellm_config.find_first = AsyncMock(return_value=row) + monkeypatch.setattr(proxy_server, "prisma_client", pc) + + logging_obj = MagicMock() + args_model = MagicMock() + args_model.model_dump = MagicMock(return_value={"daily_report_frequency": 7}) + logging_obj.slack_alerting_instance.alerting_args = args_model + monkeypatch.setattr(proxy_server, "proxy_logging_obj", logging_obj) + + store = SettingsStore("general_settings") + store.load_yaml( + { + "alerting": ["slack"], + "alerting_args": {"daily_report_frequency": 3}, + } + ) + store.apply_db_row( + "general_settings", + {"alerting_args": {"daily_report_frequency": 7}}, + ) + monkeypatch.setattr(proxy_server.proxy_config, "settings", store) + monkeypatch.setattr(proxy_server, "general_settings", store) + + with auth_as(LitellmUserRoles.PROXY_ADMIN): + response = client.get("/alerting/settings") + + assert response.status_code == 200 + by_name = {entry["field_name"]: entry for entry in response.json()} + assert by_name["slack_alerting"]["source"] == "config" + assert by_name["daily_report_frequency"]["source"] == "db" + + def test_alerting_settings_no_db_error(client, auth_as, no_prisma): """Pins ``GET /alerting/settings`` (error: db not connected).""" with auth_as(LitellmUserRoles.PROXY_ADMIN): diff --git a/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py b/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py index 93fb54f84eb..faf5b336410 100644 --- a/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py +++ b/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py @@ -1342,6 +1342,45 @@ class TestProxySettingEndpoints: where={"id": "ui_settings"} ) + def test_get_ui_settings_reports_sources(self, monkeypatch): + from unittest.mock import AsyncMock, MagicMock + + from litellm.proxy import proxy_server + from litellm.proxy.config_resolvers import SettingsStore + + mock_prisma = MagicMock() + mock_db_record = MagicMock() + mock_db_record.ui_settings = { + "disable_model_add_for_internal_users": True, + } + mock_prisma.db.litellm_uisettings.find_unique = AsyncMock( + return_value=mock_db_record + ) + monkeypatch.setattr(proxy_server, "prisma_client", mock_prisma) + + store = SettingsStore("general_settings") + store.load_yaml( + { + "disable_model_add_for_internal_users": False, + "forward_client_headers_to_llm_api": True, + } + ) + store.apply_db_row( + "ui_settings", + {"disable_model_add_for_internal_users": True}, + ) + monkeypatch.setattr(proxy_server.proxy_config, "settings", store) + monkeypatch.setattr(proxy_server, "general_settings", store) + + response = client.get("/get/ui_settings") + + assert response.status_code == 200 + data = response.json() + assert data["values"]["disable_model_add_for_internal_users"] is True + assert data["values"]["forward_client_headers_to_llm_api"] is True + assert data["source"]["disable_model_add_for_internal_users"] == "db" + assert data["source"]["forward_client_headers_to_llm_api"] == "config" + def test_get_ui_settings_schema_description_preserved_with_extensions( self, mock_auth, monkeypatch ): diff --git a/ui/litellm-dashboard/src/lib/http/schema.d.ts b/ui/litellm-dashboard/src/lib/http/schema.d.ts index fd882937e79..790ddb93546 100644 --- a/ui/litellm-dashboard/src/lib/http/schema.d.ts +++ b/ui/litellm-dashboard/src/lib/http/schema.d.ts @@ -26393,6 +26393,12 @@ export interface components { field_name: string; /** Field Value */ field_value: unknown; + /** + * Source + * @default unset + * @enum {string} + */ + source: "config" | "db" | "default" | "unset"; }; /** ConfigFieldUpdate */ ConfigFieldUpdate: { @@ -26895,6 +26901,12 @@ export interface components { * @default false */ premium_field: boolean; + /** + * Source + * @default unset + * @enum {string} + */ + source: "config" | "db" | "default" | "unset"; /** Stored In Db */ stored_in_db: boolean | null; }; @@ -28286,6 +28298,12 @@ export interface components { field_name: string; /** Field Type */ field_type: string; + /** + * Source + * @default unset + * @enum {string} + */ + source: "config" | "db" | "default" | "unset"; /** Stored In Db */ stored_in_db: boolean | null; }; @@ -36439,6 +36457,13 @@ export interface components { routing_strategy_descriptions: { [key: string]: string; }; + /** + * Source + * @description Source of each current router setting + */ + source: { + [key: string]: "config" | "db" | "default" | "unset"; + }; }; /** * RoutingGroup @@ -38856,6 +38881,10 @@ export interface components { field_schema: { [key: string]: unknown; }; + /** Source */ + source: { + [key: string]: "config" | "db" | "default" | "unset"; + }; /** Values */ values: { [key: string]: unknown; From 8dcf9e8b78509e0392eaef34abb43d2754e2a43f Mon Sep 17 00:00:00 2001 From: Yuneng Jiang Date: Fri, 18 Sep 2026 01:26:10 -0700 Subject: [PATCH 2/8] fix(proxy): correct settings source provenance --- litellm/proxy/_lazy_openapi_snapshot.json | 2 +- .../proxy/config_resolvers/settings_store.py | 20 ++++++ .../router_settings_endpoints.py | 25 ++++++- litellm/proxy/proxy_server.py | 65 +++++++++++++----- .../proxy_setting_endpoints.py | 30 ++++++--- .../config_resolvers/test_settings_store.py | 33 +++++++++ .../test_router_settings_endpoints.py | 2 + .../proxy/proxy_server/test_routes_config.py | 44 +++++++++--- .../proxy_server/test_routes_model_metrics.py | 67 ++++++++++++++++--- .../test_proxy_setting_endpoints.py | 42 ++++++++++++ 10 files changed, 280 insertions(+), 50 deletions(-) diff --git a/litellm/proxy/_lazy_openapi_snapshot.json b/litellm/proxy/_lazy_openapi_snapshot.json index b244678e201..fa046ef0a72 100644 --- a/litellm/proxy/_lazy_openapi_snapshot.json +++ b/litellm/proxy/_lazy_openapi_snapshot.json @@ -19346,7 +19346,7 @@ } } }, - "description": "\n Unified rate-limit error.\n\n Every rate-limit condition surfaced by litellm \u2014 whether it originated from\n an upstream LLM provider, a vendor batch endpoint, or one of litellm's own\n proxy-side limiters (parallel-requests, dynamic-rate, batch-rate, budget,\n max-iterations, etc.) \u2014 is raised as an instance of this class.\n\n The :attr:`category` attribute lets callers distinguish the source. See\n :class:`RateLimitErrorCategory` for the available values.\n " + "description": "\nUnified rate-limit error.\n\nEvery rate-limit condition surfaced by litellm \u2014 whether it originated from\nan upstream LLM provider, a vendor batch endpoint, or one of litellm's own\nproxy-side limiters (parallel-requests, dynamic-rate, batch-rate, budget,\nmax-iterations, etc.) \u2014 is raised as an instance of this class.\n\nThe :attr:`category` attribute lets callers distinguish the source. See\n:class:`RateLimitErrorCategory` for the available values.\n" }, "500": { "content": { diff --git a/litellm/proxy/config_resolvers/settings_store.py b/litellm/proxy/config_resolvers/settings_store.py index 8f400853fa9..73bca3222ea 100644 --- a/litellm/proxy/config_resolvers/settings_store.py +++ b/litellm/proxy/config_resolvers/settings_store.py @@ -28,6 +28,7 @@ class SettingsStore(MutableMapping[str, JsonValue]): self._yaml_values: Mapping[str, JsonValue] = _EMPTY_VALUES self._database_rows: Mapping[DbRow, Mapping[str, JsonValue]] = _EMPTY_ROWS self._runtime_values: Mapping[str, JsonValue] = _EMPTY_VALUES + self._runtime_sources: Mapping[str, FieldSource] = MappingProxyType({}) self._deleted_runtime_keys: frozenset[str] = frozenset() def load_yaml(self, mapping: Mapping[str, JsonValue]) -> None: @@ -39,11 +40,22 @@ class SettingsStore(MutableMapping[str, JsonValue]): self._database_rows = MappingProxyType({**self._database_rows, row: MappingProxyType(dict(db_row))}) self._clear_runtime_keys(frozenset((*previous_row, *db_row))) + def without_db(self) -> SettingsStore: + copy: Final = SettingsStore(self._section) + copy.load_yaml(self._yaml_values) + runtime_values: Final = { + key: value for key, value in self._runtime_values.items() if self._runtime_sources.get(key) != "db" + } + copy.apply_runtime_values(runtime_values) + copy._deleted_runtime_keys = self._deleted_runtime_keys + return copy + def resolved(self) -> Mapping[str, JsonValue]: return MappingProxyType(dict(self)) def apply_runtime_values(self, values: Mapping[str, JsonValue]) -> None: self._runtime_values = MappingProxyType(dict(values)) + self._runtime_sources = MappingProxyType({key: self.source(key) for key in values}) self._deleted_runtime_keys = frozenset() def source(self, key: str) -> FieldSource: @@ -61,6 +73,7 @@ class SettingsStore(MutableMapping[str, JsonValue]): def __setitem__(self, key: str, value: JsonValue) -> None: self._runtime_values = MappingProxyType({**self._runtime_values, key: value}) + self._runtime_sources = MappingProxyType({**self._runtime_sources, key: self.source(key)}) self._deleted_runtime_keys = self._deleted_runtime_keys - frozenset((key,)) def __delitem__(self, key: str) -> None: @@ -69,6 +82,9 @@ class SettingsStore(MutableMapping[str, JsonValue]): self._runtime_values = MappingProxyType( {key_: value for key_, value in self._runtime_values.items() if key_ != key} ) + self._runtime_sources = MappingProxyType( + {key_: source for key_, source in self._runtime_sources.items() if key_ != key} + ) self._deleted_runtime_keys = self._deleted_runtime_keys | frozenset((key,)) def __iter__(self) -> Iterator[str]: @@ -84,6 +100,7 @@ class SettingsStore(MutableMapping[str, JsonValue]): def _clear_runtime(self) -> None: self._runtime_values = _EMPTY_VALUES + self._runtime_sources = MappingProxyType({}) self._deleted_runtime_keys = frozenset() def _clear_runtime_keys(self, keys: frozenset[str]) -> None: @@ -92,6 +109,9 @@ class SettingsStore(MutableMapping[str, JsonValue]): self._runtime_values = MappingProxyType( {key: value for key, value in self._runtime_values.items() if key not in keys} ) + self._runtime_sources = MappingProxyType( + {key: source for key, source in self._runtime_sources.items() if key not in keys} + ) self._deleted_runtime_keys = self._deleted_runtime_keys - keys def _keys(self) -> tuple[str, ...]: diff --git a/litellm/proxy/management_endpoints/router_settings_endpoints.py b/litellm/proxy/management_endpoints/router_settings_endpoints.py index 5d3b6d40601..1869be88d1b 100644 --- a/litellm/proxy/management_endpoints/router_settings_endpoints.py +++ b/litellm/proxy/management_endpoints/router_settings_endpoints.py @@ -16,7 +16,7 @@ from pydantic import BaseModel, Field from litellm._logging import verbose_proxy_logger from litellm.proxy._types import UserAPIKeyAuth from litellm.proxy.auth.user_api_key_auth import user_api_key_auth -from litellm.proxy.config_resolvers import SettingsSource, source_for +from litellm.proxy.config_resolvers import SettingsSource, SettingsStore, source_for from litellm.router import Router from litellm.types.management_endpoints import ( ROUTER_SETTINGS_FIELDS, @@ -41,6 +41,18 @@ class RouterFieldsResponse(BaseModel): routing_strategy_descriptions: dict[str, str] = Field(description="Descriptions for each routing strategy option") +def _router_setting_source( + settings: SettingsStore, + key: str, + current_value: object, + field_default: object, +) -> SettingsSource: + source: Final = source_for(settings, key, field_default) + if source != "unset": + return source + return "default" if current_value is not None else "unset" + + def _get_routing_strategies_from_router_class() -> list[str]: """ Dynamically extract routing strategies from the Router class __init__ method. @@ -116,10 +128,17 @@ async def get_router_settings( field.field_value = current_values[field.field_name] field_defaults: Final[dict[str, object]] = { - field.field_name: cast(object, field.field_default) for field in router_fields + field.field_name: cast(object, field.field_default) # cast-ok: Pydantic field defaults are untyped + for field in router_fields } source: Final[dict[str, SettingsSource]] = { - key: source_for(proxy_config.router_settings, key, field_defaults.get(key)) for key in current_values + key: _router_setting_source( + proxy_config.router_settings, + key, + cast(object, current_values[key]), # cast-ok: current values are stored in a typed response map + field_defaults.get(key), + ) + for key in current_values } return RouterSettingsResponse( fields=router_fields, diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 1131d7bea86..3898f522feb 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -432,7 +432,7 @@ from litellm.proxy.common_utils.user_api_key_cache import ( model_access_group_spend_counter_key, tag_cache_key, ) -from litellm.proxy.config_resolvers import SettingsStore, resolve_fields, source_for +from litellm.proxy.config_resolvers import SettingsSource, SettingsStore, resolve_fields, source_for from litellm.proxy.config_resolvers.alerting import ( EMAIL_DESCRIPTORS, MS_TEAMS_DESCRIPTORS, @@ -4820,7 +4820,7 @@ def _as_settings_mapping(value: object) -> Mapping[str, SettingsJsonValue]: def _get_field_default(field_info: FieldInfo) -> JsonValue: if field_info.default is PydanticUndefined: return None - return cast(JsonValue, field_info.default) + return cast(JsonValue, field_info.default) # cast-ok: Pydantic field defaults are JSON values at runtime def _bind_general_settings_store(settings: SettingsStore) -> None: @@ -15605,6 +15605,22 @@ async def model_settings(): #### ALERTING MANAGEMENT ENDPOINTS #### +def _nested_setting_source( + settings: SettingsStore, + db_values: Mapping[str, JsonValue], + parent_key: str, + field_name: str, + field_default: JsonValue, +) -> SettingsSource: + db_value: Final = db_values.get(field_name) + if db_value is not None and db_value != []: + return "db" + parent_value: Final = settings.without_db().get(parent_key) + if isinstance(parent_value, Mapping) and field_name in parent_value: + return "config" + return "default" if field_default is not None else "unset" + + @router.get( "/alerting/settings", description="Return the configurable alerting param, description, and current value", @@ -15647,8 +15663,13 @@ async def alerting_settings( if db_general_settings is not None and db_general_settings.param_value is not None else {} ) - alerting_args_dict: Final = cast(dict[str, JsonValue], db_general_settings_dict.get("alerting_args", {})) - alerting_values: Final = cast(list[JsonValue] | None, db_general_settings_dict.get("alerting")) + alerting_args_value: Final = db_general_settings_dict.get("alerting_args") + alerting_args_dict: Final[Mapping[str, JsonValue]] = ( + alerting_args_value if isinstance(alerting_args_value, dict) else {} + ) + alerting_values: Final = cast( # cast-ok: alerting is stored as a JSON list when present + list[JsonValue] | None, db_general_settings_dict.get("alerting") + ) settings: Final = proxy_config.settings settings.apply_db_row("general_settings", db_general_settings_dict) @@ -15711,7 +15732,13 @@ async def alerting_settings( field_description=field_info.description or "", field_value=_slack_alerting_args_dict.get(field_name, field_default), stored_in_db=_stored_in_db, - source=source_for(settings, "alerting_args", field_default), + source=_nested_setting_source( + settings, + alerting_args_dict, + "alerting_args", + field_name, + field_default, + ), field_default_value=field_default, premium_field=(True if field_name == "region_outage_alert_ttl" else False), ) @@ -17414,21 +17441,19 @@ async def get_config_general_settings( field_info: Final = ConfigGeneralSettings.model_fields[field_name] field_default: JsonValue = _get_field_default(field_info) settings: Final = proxy_config.settings - db_values: Mapping[str, JsonValue] - if prisma_client is None: - db_values = {} - else: + if prisma_client is not None: db_general_settings: Final[_ConfigParamRow | None] = await _config_param_table(prisma_client).find_first( where={"param_name": "general_settings"} ) - db_values = ( + db_values: Final[Mapping[str, JsonValue]] = ( dict(db_general_settings.param_value) if db_general_settings is not None and db_general_settings.param_value is not None else {} ) settings.apply_db_row("general_settings", db_values) + effective_settings: Final = settings.without_db() if prisma_client is None else settings - if field_name not in settings and field_default is None: + if field_name not in effective_settings and field_default is None: raise HTTPException( status_code=400, detail={"error": f"Field name={field_name} not in DB"}, @@ -17436,7 +17461,7 @@ async def get_config_general_settings( redacted_field_value: Final = _redact_general_setting_value( field_name, - settings.get(field_name, field_default), + effective_settings.get(field_name, field_default), user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN, ) field_value: Final = ( @@ -17450,7 +17475,7 @@ async def get_config_general_settings( return ConfigFieldInfo( field_name=field_name, field_value=field_value, - source=source_for(settings, field_name, field_default), + source=source_for(effective_settings, field_name, field_default), ) @@ -17640,7 +17665,11 @@ async def get_config_list( settings: Final = proxy_config.settings settings.apply_db_row("general_settings", db_general_settings_dict) runtime_settings: Final[Mapping[str, JsonValue]] = ( - cast(Mapping[str, JsonValue], general_settings) if not isinstance(general_settings, SettingsStore) else settings + cast( # cast-ok: legacy general_settings remains a mapping at this route boundary + Mapping[str, JsonValue], general_settings + ) + if not isinstance(general_settings, SettingsStore) + else settings ) allowed_args: Final = _GENERAL_SETTINGS_CONFIG_LIST_FIELD_TYPES @@ -17744,9 +17773,11 @@ async def get_config_list( litellm_settings_store.apply_db_row("litellm_settings", db_litellm_settings) for litellm_field_name, spec in _GENERAL_SETTINGS_UI_LITELLM_FIELDS.items(): default_value: GeneralSettingsUILiteLLMValue = _general_settings_ui_litellm_default(spec) - current_value: GeneralSettingsUILiteLLMValue = cast( - GeneralSettingsUILiteLLMValue, - litellm_settings_store.get(litellm_field_name, default_value), + current_value: GeneralSettingsUILiteLLMValue = ( + cast( # cast-ok: UI field defaults are validated by the field spec + GeneralSettingsUILiteLLMValue, + litellm_settings_store.get(litellm_field_name, default_value), + ) ) source = source_for(litellm_settings_store, litellm_field_name, default_value) stored_in_db_litellm: bool | None diff --git a/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py b/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py index 4cd031b8780..aba65719f9b 100644 --- a/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py +++ b/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py @@ -24,7 +24,7 @@ from litellm.litellm_core_utils.sensitive_data_masker import mask_sensitive_keys from litellm.proxy._experimental.mcp_server.tool_search import MCP_TOOL_SEARCH_SETTINGS_KEY from litellm.proxy._types import * from litellm.proxy.auth.user_api_key_auth import user_api_key_auth -from litellm.proxy.config_resolvers import SettingsSource, source_for +from litellm.proxy.config_resolvers import SettingsSource, SettingsStore, source_for from litellm.proxy.config_resolvers.sso import ( SSO_FIELD_ENV_VARS, SSO_SECRET_FIELDS, @@ -34,7 +34,10 @@ from litellm.proxy.management_endpoints.team_admin_field_permissions import ( SUPPORTED_TEAM_ADMIN_EDITABLE_TEAM_FIELDS, TEAM_ADMIN_EDITABLE_TEAM_FIELDS_SETTING, ) -from litellm.proxy.spend_tracking.ptu_feature_flag import is_ptu_cost_attribution_enabled +from litellm.proxy.spend_tracking.ptu_feature_flag import ( + PTU_COST_ATTRIBUTION_ENV_VAR, + is_ptu_cost_attribution_enabled, +) from litellm.proxy.utils import invalidate_config_param from litellm.repositories.config_repository import ConfigRepository from litellm.repositories.organization_repository import OrganizationRepository @@ -44,6 +47,7 @@ from litellm.repositories.table_repositories import ( UISettingsRepository, ) from litellm.repositories.team_repository import TeamRepository +from litellm.secret_managers.main import get_secret from litellm.types.mcp import MCPToolSearchSettings from litellm.types.proxy.management_endpoints.ui_sso import ( DefaultTeamSSOParams, @@ -670,7 +674,19 @@ def _model_field_default(settings_class: type[BaseModel], field_name: str) -> ob field_info: Final = settings_class.model_fields.get(field_name) if field_info is None or field_info.default is PydanticUndefined: return None - return cast(object, field_info.default) + return cast(object, field_info.default) # cast-ok: Pydantic field defaults are untyped + + +def _ui_setting_source( + key: str, + value: object, + settings: SettingsStore, + settings_class: type[BaseModel], +) -> SettingsSource: + if key == ENABLE_PTU_COST_ATTRIBUTION_UI_SETTING: + configured_value: Final = get_secret(PTU_COST_ATTRIBUTION_ENV_VAR, None) + return "config" if configured_value is not None or value is True else "default" + return source_for(settings, key, _model_field_default(settings_class, key)) async def _get_settings_with_schema( @@ -1587,13 +1603,7 @@ async def get_ui_settings(): } source: Final[dict[str, SettingsSource]] = { key: ( - "db" - if key in ui_settings - else source_for( - proxy_config.settings, - key, - _model_field_default(settings_class, key), - ) + "db" if key in ui_settings else _ui_setting_source(key, values[key], proxy_config.settings, settings_class) ) for key in values } diff --git a/tests/test_litellm/proxy/config_resolvers/test_settings_store.py b/tests/test_litellm/proxy/config_resolvers/test_settings_store.py index e41c852eacb..efff9ad24c8 100644 --- a/tests/test_litellm/proxy/config_resolvers/test_settings_store.py +++ b/tests/test_litellm/proxy/config_resolvers/test_settings_store.py @@ -82,6 +82,39 @@ def test_settings_store_keeps_unaffected_runtime_values_on_a_db_row_refresh() -> assert store.source("changed") == "db" +def test_settings_store_without_db_uses_yaml_without_mutating_runtime_values() -> None: + store: Final = SettingsStore("general_settings") + store.load_yaml({"max_parallel_requests": 5}) + store.apply_db_row("general_settings", {"max_parallel_requests": 7}) + store.apply_runtime_values({"max_parallel_requests": 7}) + + without_db: Final = store.without_db() + + assert without_db["max_parallel_requests"] == 5 + assert without_db.source("max_parallel_requests") == "config" + assert store["max_parallel_requests"] == 7 + assert store.source("max_parallel_requests") == "db" + + +def test_settings_store_without_db_preserves_non_db_runtime_values() -> None: + store: Final = SettingsStore("general_settings") + store.load_yaml({"max_parallel_requests": "os.environ/MAX_PARALLEL_REQUESTS"}) + store.apply_runtime_values({"max_parallel_requests": 7}) + + without_db: Final = store.without_db() + + assert without_db["max_parallel_requests"] == 7 + assert without_db.source("max_parallel_requests") == "config" + + +def test_settings_store_without_db_preserves_runtime_deletions() -> None: + store: Final = SettingsStore("general_settings") + store.load_yaml({"deleted": 1}) + del store["deleted"] + + assert "deleted" not in store.without_db() + + def test_settings_store_removes_only_runtime_values_affected_by_a_cleared_db_row() -> None: store: Final = SettingsStore("general_settings") store.load_yaml({"template": "os.environ/SETTING"}) diff --git a/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py index 148f30f517b..3af7de62abe 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py +++ b/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py @@ -146,6 +146,8 @@ class TestRouterSettingsEndpoints: response = await get_router_settings(user_api_key_dict=admin_user) assert response.current_values.get("routing_groups") == groups + assert response.current_values["timeout"] is not None + assert response.source["timeout"] == "default" rg_field = next(f for f in response.fields if f.field_name == "routing_groups") assert rg_field.field_value == groups diff --git a/tests/test_litellm/proxy/proxy_server/test_routes_config.py b/tests/test_litellm/proxy/proxy_server/test_routes_config.py index d6c63ec9a78..fdaa2476219 100644 --- a/tests/test_litellm/proxy/proxy_server/test_routes_config.py +++ b/tests/test_litellm/proxy/proxy_server/test_routes_config.py @@ -15,8 +15,11 @@ from __future__ import annotations import asyncio import json -from collections.abc import Mapping +from collections.abc import Callable, Mapping +from contextlib import AbstractContextManager from typing import Final + +from fastapi.testclient import TestClient from unittest.mock import AsyncMock, MagicMock import pytest @@ -362,6 +365,33 @@ def test_config_field_info_happy_admin(client, auth_as, mock_prisma, monkeypatch } +def test_config_field_info_clears_stale_db_source_without_connection( + client: TestClient, + auth_as: Callable[..., AbstractContextManager[None]], + monkeypatch: pytest.MonkeyPatch, +): + from litellm.proxy import proxy_server as ps + from litellm.proxy._types import LitellmUserRoles + + store = SettingsStore("general_settings") + store.load_yaml({"max_parallel_requests": 5}) + store.apply_db_row("general_settings", {"max_parallel_requests": 7}) + store.apply_runtime_values({"max_parallel_requests": 7}) + monkeypatch.setattr(ps.proxy_config, "settings", store) + monkeypatch.setattr(ps, "prisma_client", None) + + with auth_as(LitellmUserRoles.PROXY_ADMIN): + response = client.get("/config/field/info", params={"field_name": "max_parallel_requests"}) + + assert response.status_code == 200 + assert normalize(response.json()) == { + "field_name": "max_parallel_requests", + "field_value": 5, + "source": "config", + } + assert store["max_parallel_requests"] == 7 + + def test_config_field_info_non_admin_rejected(client, auth_as, mock_prisma, monkeypatch): """Non-admin (INTERNAL_USER) is denied — admin-view gate fires.""" from litellm.proxy import proxy_server as ps @@ -608,12 +638,8 @@ def test_config_read_routes_report_effective_values_and_sources(client, auth_as, with auth_as(LitellmUserRoles.PROXY_ADMIN): list_response = client.get("/config/list", params={"config_type": "general_settings"}) - config_only_response = client.get( - "/config/field/info", params={"field_name": "max_file_size_mb"} - ) - db_wins_response = client.get( - "/config/field/info", params={"field_name": "max_parallel_requests"} - ) + config_only_response = client.get("/config/field/info", params={"field_name": "max_file_size_mb"}) + db_wins_response = client.get("/config/field/info", params={"field_name": "max_parallel_requests"}) assert list_response.status_code == 200 by_name: Final = {entry["field_name"]: entry for entry in list_response.json()} @@ -651,9 +677,7 @@ def test_config_read_routes_report_default_source(client, auth_as, mock_prisma, with auth_as(LitellmUserRoles.PROXY_ADMIN): list_response = client.get("/config/list", params={"config_type": "general_settings"}) - field_response = client.get( - "/config/field/info", params={"field_name": "proxy_config_reload_interval_seconds"} - ) + field_response = client.get("/config/field/info", params={"field_name": "proxy_config_reload_interval_seconds"}) assert list_response.status_code == 200 by_name: Final = {entry["field_name"]: entry for entry in list_response.json()} diff --git a/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py b/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py index 6a57ad1636d..97ca3b3dbbe 100644 --- a/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py +++ b/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py @@ -11,13 +11,17 @@ Pins (PR2): from __future__ import annotations +from collections.abc import Callable +from contextlib import AbstractContextManager from unittest.mock import AsyncMock, MagicMock import pytest +from fastapi.testclient import TestClient import litellm from litellm.proxy import proxy_server from litellm.proxy._types import LitellmUserRoles +from litellm.proxy.config_resolvers.settings_rules import JsonValue from .conftest import normalize # type: ignore[import-not-found] @@ -53,9 +57,7 @@ def test_model_streaming_metrics_happy(client, auth_as, prisma_with_query_raw): pin can rely on the exact response shape. """ with auth_as(): - response = client.get( - "/model/streaming_metrics", params={"_selected_model_group": "gpt-4"} - ) + response = client.get("/model/streaming_metrics", params={"_selected_model_group": "gpt-4"}) assert response.status_code == 200 assert normalize(response.json()) == {"data": [], "all_api_bases": []} @@ -94,9 +96,7 @@ def test_model_metrics_no_prisma_error(client, auth_as, no_prisma): # --------------------------------------------------------------------------- -def test_model_metrics_slow_responses_happy( - client, auth_as, prisma_with_query_raw, monkeypatch -): +def test_model_metrics_slow_responses_happy(client, auth_as, prisma_with_query_raw, monkeypatch): """Pins ``GET /model/metrics/slow_responses`` (happy: empty list).""" logging_obj = MagicMock() logging_obj.slack_alerting_instance.alerting_threshold = 30 @@ -184,7 +184,12 @@ def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): pc = MagicMock() row = MagicMock() - row.param_value = {"alerting_args": {"daily_report_frequency": 7}} + row.param_value = { + "alerting_args": { + "daily_report_frequency": 7, + "report_check_interval": None, + } + } pc.db.litellm_config.find_first = AsyncMock(return_value=row) monkeypatch.setattr(proxy_server, "prisma_client", pc) @@ -198,12 +203,20 @@ def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): store.load_yaml( { "alerting": ["slack"], - "alerting_args": {"daily_report_frequency": 3}, + "alerting_args": { + "daily_report_frequency": 3, + "report_check_interval": 300, + }, } ) store.apply_db_row( "general_settings", - {"alerting_args": {"daily_report_frequency": 7}}, + { + "alerting_args": { + "daily_report_frequency": 7, + "report_check_interval": None, + } + }, ) monkeypatch.setattr(proxy_server.proxy_config, "settings", store) monkeypatch.setattr(proxy_server, "general_settings", store) @@ -215,6 +228,42 @@ def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): by_name = {entry["field_name"]: entry for entry in response.json()} assert by_name["slack_alerting"]["source"] == "config" assert by_name["daily_report_frequency"]["source"] == "db" + assert by_name["report_check_interval"]["source"] == "config" + assert by_name["budget_alert_ttl"]["source"] == "default" + + +@pytest.mark.parametrize("db_alerting_args", [None, []]) +def test_alerting_settings_handles_empty_db_args( + client: TestClient, + auth_as: Callable[..., AbstractContextManager[None]], + monkeypatch: pytest.MonkeyPatch, + db_alerting_args: JsonValue, +): + from litellm.proxy.config_resolvers import SettingsStore + + pc = MagicMock() + row = MagicMock() + row.param_value = {"alerting_args": db_alerting_args} + pc.db.litellm_config.find_first = AsyncMock(return_value=row) + monkeypatch.setattr(proxy_server, "prisma_client", pc) + + logging_obj = MagicMock() + args_model = MagicMock() + args_model.model_dump = MagicMock(return_value={}) + logging_obj.slack_alerting_instance.alerting_args = args_model + monkeypatch.setattr(proxy_server, "proxy_logging_obj", logging_obj) + + store = SettingsStore("general_settings") + store.load_yaml({"alerting_args": {"report_check_interval": 300}}) + monkeypatch.setattr(proxy_server.proxy_config, "settings", store) + monkeypatch.setattr(proxy_server, "general_settings", store) + + with auth_as(LitellmUserRoles.PROXY_ADMIN): + response = client.get("/alerting/settings") + + assert response.status_code == 200 + by_name = {entry["field_name"]: entry for entry in response.json()} + assert by_name["report_check_interval"]["source"] == "config" def test_alerting_settings_no_db_error(client, auth_as, no_prisma): diff --git a/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py b/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py index faf5b336410..d8308d7831f 100644 --- a/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py +++ b/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py @@ -3198,6 +3198,7 @@ class TestPtuCostAttributionUISetting: assert response.status_code == 200 assert response.json()["values"]["enable_ptu_cost_attribution"] is False + assert response.json()["source"]["enable_ptu_cost_attribution"] == "default" def test_reported_true_once_the_env_var_is_set(self, mock_auth, monkeypatch): from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR @@ -3209,6 +3210,47 @@ class TestPtuCostAttributionUISetting: assert response.status_code == 200 assert response.json()["values"]["enable_ptu_cost_attribution"] is True + assert response.json()["source"]["enable_ptu_cost_attribution"] == "config" + + def test_reported_config_when_secret_manager_enables_the_flag( + self, mock_auth: None, monkeypatch: pytest.MonkeyPatch + ): + from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR + + monkeypatch.delenv(PTU_COST_ATTRIBUTION_ENV_VAR, raising=False) + monkeypatch.setattr( + "litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.is_ptu_cost_attribution_enabled", + lambda: True, + ) + self._mock_prisma(monkeypatch) + + response = client.get("/get/ui_settings") + + assert response.status_code == 200 + assert response.json()["values"]["enable_ptu_cost_attribution"] is True + assert response.json()["source"]["enable_ptu_cost_attribution"] == "config" + + def test_reported_config_when_secret_manager_disables_the_flag( + self, mock_auth: None, monkeypatch: pytest.MonkeyPatch + ): + from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR + + monkeypatch.delenv(PTU_COST_ATTRIBUTION_ENV_VAR, raising=False) + monkeypatch.setattr( + "litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.is_ptu_cost_attribution_enabled", + lambda: False, + ) + monkeypatch.setattr( + "litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_secret", + lambda *_args: False, + ) + self._mock_prisma(monkeypatch) + + response = client.get("/get/ui_settings") + + assert response.status_code == 200 + assert response.json()["values"]["enable_ptu_cost_attribution"] is False + assert response.json()["source"]["enable_ptu_cost_attribution"] == "config" def test_a_persisted_true_cannot_forge_the_derived_value(self, mock_auth, monkeypatch): """A row written before the allowlist existed must not be able to turn the feature on.""" From be2f0d081b6c7ac41090ad9300b18402f226ef5f Mon Sep 17 00:00:00 2001 From: Yuneng Jiang Date: Mon, 21 Sep 2026 13:25:39 -0700 Subject: [PATCH 3/8] fix(proxy): report sources only on the read endpoints main does not cover /config/field/info and /config/list already report per-key source on main, so this drops the branch's versions of those and keeps /alerting/settings, /get/ui_settings and /router/settings. Read endpoints no longer write the freshly read database row back into the shared settings store; the reload path already keeps it current, and a GET that mutates global state leaks across callers. Regenerates the lazy OpenAPI snapshot on Python 3.12, matching CI, and the dashboard API types for the two new response fields. --- litellm/proxy/_lazy_openapi_snapshot.json | 2 +- .../router_settings_endpoints.py | 31 +++++++------- litellm/proxy/proxy_server.py | 9 ++-- .../proxy_setting_endpoints.py | 41 +++++++++++-------- .../test_router_settings_endpoints.py | 41 ++++++++++--------- ui/litellm-dashboard/src/lib/http/schema.d.ts | 11 +++++ 6 files changed, 80 insertions(+), 55 deletions(-) diff --git a/litellm/proxy/_lazy_openapi_snapshot.json b/litellm/proxy/_lazy_openapi_snapshot.json index 391f0042ed0..06e157498aa 100644 --- a/litellm/proxy/_lazy_openapi_snapshot.json +++ b/litellm/proxy/_lazy_openapi_snapshot.json @@ -19632,7 +19632,7 @@ } } }, - "description": "\nUnified rate-limit error.\n\nEvery rate-limit condition surfaced by litellm \u2014 whether it originated from\nan upstream LLM provider, a vendor batch endpoint, or one of litellm's own\nproxy-side limiters (parallel-requests, dynamic-rate, batch-rate, budget,\nmax-iterations, etc.) \u2014 is raised as an instance of this class.\n\nThe :attr:`category` attribute lets callers distinguish the source. See\n:class:`RateLimitErrorCategory` for the available values.\n" + "description": "\n Unified rate-limit error.\n\n Every rate-limit condition surfaced by litellm \u2014 whether it originated from\n an upstream LLM provider, a vendor batch endpoint, or one of litellm's own\n proxy-side limiters (parallel-requests, dynamic-rate, batch-rate, budget,\n max-iterations, etc.) \u2014 is raised as an instance of this class.\n\n The :attr:`category` attribute lets callers distinguish the source. See\n :class:`RateLimitErrorCategory` for the available values.\n " }, "500": { "content": { diff --git a/litellm/proxy/management_endpoints/router_settings_endpoints.py b/litellm/proxy/management_endpoints/router_settings_endpoints.py index 019ac68ae23..d6d74ada35a 100644 --- a/litellm/proxy/management_endpoints/router_settings_endpoints.py +++ b/litellm/proxy/management_endpoints/router_settings_endpoints.py @@ -8,7 +8,9 @@ GET /router/fields - Get router settings field definitions without values (for U """ import inspect -from typing import Any, Final, cast, get_args +from collections.abc import Mapping +from types import MappingProxyType +from typing import Any, Final, get_args from fastapi import APIRouter, Depends from pydantic import BaseModel, Field @@ -127,19 +129,20 @@ async def get_router_settings( if field.field_name in current_values: field.field_value = current_values[field.field_name] - field_defaults: Final[dict[str, object]] = { - field.field_name: cast(object, field.field_default) # cast-ok: Pydantic field defaults are untyped - for field in router_fields - } - source: Final[dict[str, FieldSource]] = { - key: _router_setting_source( - proxy_config.router_settings, - key, - cast(object, current_values[key]), # cast-ok: current values are stored in a typed response map - field_defaults.get(key), - ) - for key in current_values - } + field_defaults: Final[Mapping[str, object]] = MappingProxyType( + {field.field_name: field.field_default for field in router_fields} + ) + source: Final[Mapping[str, FieldSource]] = MappingProxyType( + { + key: _router_setting_source( + proxy_config.router_settings, + key, + current_values[key], + field_defaults.get(key), + ) + for key in current_values + } + ) return RouterSettingsResponse( fields=router_fields, current_values=current_values, diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 4b2781e031b..24af6d7f7d3 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -15991,7 +15991,7 @@ def _nested_setting_source( field_default: JsonValue, ) -> FieldSource: db_value: Final = db_values.get(field_name) - if db_value is not None and db_value != []: + if db_value is not None and not (isinstance(db_value, list) and len(db_value) == 0): return "db" parent_value: Final = settings.config_value(parent_key) if isinstance(parent_value, Mapping) and field_name in parent_value: @@ -16036,13 +16036,13 @@ async def alerting_settings( where={"param_name": "general_settings"} ) - db_general_settings_dict: Final[Mapping[str, JsonValue]] = ( - dict(db_general_settings.param_value) + db_general_settings_dict: Final[Mapping[str, JsonValue]] = MappingProxyType( + dict(db_general_settings.param_value) # mutable-ok: Prisma returns the JSON column as a plain dict if db_general_settings is not None and db_general_settings.param_value is not None else {} ) alerting_args_value: Final = db_general_settings_dict.get("alerting_args") - alerting_args_dict: Final[Mapping[str, JsonValue]] = ( + alerting_args_dict: Final[Mapping[str, JsonValue]] = MappingProxyType( alerting_args_value if isinstance(alerting_args_value, dict) else {} ) alerting_values: Final = cast( # cast-ok: alerting is stored as a JSON list when present @@ -16050,7 +16050,6 @@ async def alerting_settings( ) settings: Final = proxy_config.settings - settings.apply_db_row("general_settings", db_general_settings_dict) allowed_args: Final = MappingProxyType( { diff --git a/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py b/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py index 4505f3144ee..ed626bdb624 100644 --- a/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py +++ b/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py @@ -1755,18 +1755,21 @@ async def get_ui_settings(): ui_settings: Final = {k: v for k, v in parsed.items() if k in ALLOWED_UI_SETTINGS_FIELDS} apply_runtime_general_settings_flags(ui_settings) - proxy_config.settings.apply_db_row("ui_settings", ui_settings) # Refresh DualCache so other code paths (e.g. /user/filter/ui) see fresh values from litellm.proxy.proxy_server import user_api_key_cache await user_api_key_cache.async_set_cache(key=UI_SETTINGS_CACHE_KEY, value=ui_settings, ttl=UI_SETTINGS_CACHE_TTL) - effective_ui_settings: Final = { - **{key: proxy_config.settings[key] for key in ALLOWED_UI_SETTINGS_FIELDS if key in proxy_config.settings}, - **ui_settings, - } - config: Final[dict[str, object]] = {"litellm_settings": {"ui_settings": effective_ui_settings}} + effective_ui_settings: Final[Mapping[str, object]] = MappingProxyType( + { + **{key: proxy_config.settings[key] for key in ALLOWED_UI_SETTINGS_FIELDS if key in proxy_config.settings}, + **ui_settings, + } + ) + config: Final[Mapping[str, object]] = MappingProxyType( + {"litellm_settings": MappingProxyType({"ui_settings": effective_ui_settings})} + ) settings_class: Final = _get_effective_ui_settings_class() resolved_settings: Final = _SettingsWithSchema.model_validate( await _get_settings_with_schema( @@ -1775,16 +1778,22 @@ async def get_ui_settings(): config=config, ) ) - values: Final = { - **resolved_settings.values, - ENABLE_PTU_COST_ATTRIBUTION_UI_SETTING: is_ptu_cost_attribution_enabled(), - } - source: Final[dict[str, FieldSource]] = { - key: ( - "db" if key in ui_settings else _ui_setting_source(key, values[key], proxy_config.settings, settings_class) - ) - for key in values - } + values: Final[Mapping[str, object]] = MappingProxyType( + { + **resolved_settings.values, + ENABLE_PTU_COST_ATTRIBUTION_UI_SETTING: is_ptu_cost_attribution_enabled(), + } + ) + source: Final[Mapping[str, FieldSource]] = MappingProxyType( + { + key: ( + "db" + if key in ui_settings + else _ui_setting_source(key, values[key], proxy_config.settings, settings_class) + ) + for key in values + } + ) return UISettingsResponse( values=values, field_schema=resolved_settings.field_schema, diff --git a/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py index 3af7de62abe..51c8679e89e 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py +++ b/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py @@ -15,12 +15,24 @@ from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth from litellm.proxy.management_endpoints.router_settings_endpoints import ( get_router_settings, ) +from litellm.proxy.config_resolvers import SettingsStore from litellm.proxy.proxy_server import app from litellm.router import Router client = TestClient(app) +def _stub_proxy_config(router_settings, config_router_settings): + class _StubProxyConfig: + def __init__(self): + self.router_settings = router_settings + + async def get_config(self, config_file_path=None): + return {"router_settings": dict(config_router_settings)} + + return _StubProxyConfig() + + class TestRouterSettingsEndpoints: """Test suite for router settings endpoints""" @@ -77,25 +89,18 @@ class TestRouterSettingsEndpoints: @pytest.mark.asyncio async def test_get_router_settings_reports_sources(self, monkeypatch): - from litellm.proxy.config_resolvers import SettingsStore - store = SettingsStore("router_settings") store.load_yaml({"routing_strategy": "simple-shuffle"}) store.apply_db_row("router_settings", {"num_retries": 3}) - monkeypatch.setattr(proxy_server.proxy_config, "router_settings", store) - monkeypatch.setattr(proxy_server, "llm_router", None) - - async def fake_get_config(self, config_file_path=None): - return { - "router_settings": { - "routing_strategy": "simple-shuffle", - "num_retries": 3, - } - } - monkeypatch.setattr( - proxy_server.ProxyConfig, "get_config", fake_get_config, raising=True + proxy_server, + "proxy_config", + _stub_proxy_config( + store, + {"routing_strategy": "simple-shuffle", "num_retries": 3}, + ), ) + monkeypatch.setattr(proxy_server, "llm_router", None) admin_user = UserAPIKeyAuth( user_role=LitellmUserRoles.PROXY_ADMIN, api_key="sk-x" @@ -132,12 +137,10 @@ class TestRouterSettingsEndpoints: ) monkeypatch.setattr(proxy_server, "llm_router", llm_router) - - async def fake_get_config(self, config_file_path=None): - return {} - monkeypatch.setattr( - proxy_server.ProxyConfig, "get_config", fake_get_config, raising=True + proxy_server, + "proxy_config", + _stub_proxy_config(SettingsStore("router_settings"), {}), ) admin_user = UserAPIKeyAuth( diff --git a/ui/litellm-dashboard/src/lib/http/schema.d.ts b/ui/litellm-dashboard/src/lib/http/schema.d.ts index 6211eeaf962..ac89d676921 100644 --- a/ui/litellm-dashboard/src/lib/http/schema.d.ts +++ b/ui/litellm-dashboard/src/lib/http/schema.d.ts @@ -37069,6 +37069,13 @@ export interface components { routing_strategy_descriptions: { [key: string]: string; }; + /** + * Source + * @description Source of each current router setting + */ + source: { + [key: string]: "config" | "db" | "env" | "default" | "unset"; + }; }; /** * RoutingGroup @@ -39532,6 +39539,10 @@ export interface components { field_schema: { [key: string]: unknown; }; + /** Source */ + source: { + [key: string]: "config" | "db" | "env" | "default" | "unset"; + }; /** Values */ values: { [key: string]: unknown; From a45be4f276e2628248026731dc4f8b7b014fef1a Mon Sep 17 00:00:00 2001 From: Yuneng Jiang Date: Mon, 21 Sep 2026 13:48:37 -0700 Subject: [PATCH 4/8] fix(proxy): let the config file win when reporting nested alerting sources _nested_setting_source returned "db" whenever the stored row held a value, without first asking whether the config file declares the same key. For a config-owned alerting_args field that disagrees with the database, the endpoint reported source "db" while the proxy actually serves the file's value and rejects any write to it. Config ownership is now checked first, matching SettingsStore.source and the precedence the rest of the resolver applies. The source test set grows a field that only the database sets, a field only the file sets, and a stored empty list, so each reported source is discriminating. --- litellm/proxy/proxy_server.py | 6 +- .../proxy_server/test_routes_model_metrics.py | 69 +++++++++++++------ 2 files changed, 51 insertions(+), 24 deletions(-) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 5f0295f8208..7b5086f3e8b 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -15993,12 +15993,12 @@ def _nested_setting_source( field_name: str, field_default: JsonValue, ) -> FieldSource: - db_value: Final = db_values.get(field_name) - if db_value is not None and not (isinstance(db_value, list) and len(db_value) == 0): - return "db" parent_value: Final = settings.config_value(parent_key) if isinstance(parent_value, Mapping) and field_name in parent_value: return "config" + db_value: Final = db_values.get(field_name) + if db_value is not None and not (isinstance(db_value, list) and len(db_value) == 0): + return "db" return "default" if field_default is not None else "unset" diff --git a/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py b/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py index f65db69ce89..c5287db5027 100644 --- a/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py +++ b/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py @@ -186,20 +186,21 @@ def test_model_settings_method_not_allowed(client, auth_as): def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): from litellm.proxy.config_resolvers import SettingsStore + db_alerting_args = { + "daily_report_frequency": 7, + "outage_alert_ttl": 99, + "region_outage_alert_ttl": [], + } + pc = MagicMock() row = MagicMock() - row.param_value = { - "alerting_args": { - "daily_report_frequency": 7, - "report_check_interval": None, - } - } + row.param_value = {"alerting_args": db_alerting_args} pc.db.litellm_config.find_first = AsyncMock(return_value=row) monkeypatch.setattr(proxy_server, "prisma_client", pc) logging_obj = MagicMock() args_model = MagicMock() - args_model.model_dump = MagicMock(return_value={"daily_report_frequency": 7}) + args_model.model_dump = MagicMock(return_value={"daily_report_frequency": 3}) logging_obj.slack_alerting_instance.alerting_args = args_model monkeypatch.setattr(proxy_server, "proxy_logging_obj", logging_obj) @@ -207,21 +208,10 @@ def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): store.load_yaml( { "alerting": ["slack"], - "alerting_args": { - "daily_report_frequency": 3, - "report_check_interval": 300, - }, + "alerting_args": {"daily_report_frequency": 3, "report_check_interval": 300}, } ) - store.apply_db_row( - "general_settings", - { - "alerting_args": { - "daily_report_frequency": 7, - "report_check_interval": None, - } - }, - ) + store.apply_db_row("general_settings", {"alerting_args": db_alerting_args}) monkeypatch.setattr(proxy_server.proxy_config, "settings", store) monkeypatch.setattr(proxy_server, "general_settings", store) @@ -230,12 +220,48 @@ def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): assert response.status_code == 200 by_name = {entry["field_name"]: entry for entry in response.json()} + assert by_name["slack_alerting"]["source"] == "config" - assert by_name["daily_report_frequency"]["source"] == "db" + assert by_name["daily_report_frequency"]["source"] == "config" assert by_name["report_check_interval"]["source"] == "config" + assert by_name["outage_alert_ttl"]["source"] == "db" + assert by_name["region_outage_alert_ttl"]["source"] == "default" assert by_name["budget_alert_ttl"]["source"] == "default" +def test_alerting_settings_reports_config_source_when_db_disagrees(client, auth_as, monkeypatch): + from litellm.proxy.config_resolvers import SettingsStore + + db_alerting_args = {"daily_report_frequency": 7} + + pc = MagicMock() + row = MagicMock() + row.param_value = {"alerting_args": db_alerting_args} + pc.db.litellm_config.find_first = AsyncMock(return_value=row) + monkeypatch.setattr(proxy_server, "prisma_client", pc) + + logging_obj = MagicMock() + args_model = MagicMock() + args_model.model_dump = MagicMock(return_value={"daily_report_frequency": 3}) + logging_obj.slack_alerting_instance.alerting_args = args_model + monkeypatch.setattr(proxy_server, "proxy_logging_obj", logging_obj) + + store = SettingsStore("general_settings") + store.load_yaml({"alerting_args": {"daily_report_frequency": 3}}) + store.apply_db_row("general_settings", {"alerting_args": db_alerting_args}) + monkeypatch.setattr(proxy_server.proxy_config, "settings", store) + monkeypatch.setattr(proxy_server, "general_settings", store) + + with auth_as(LitellmUserRoles.PROXY_ADMIN): + response = client.get("/alerting/settings") + + assert response.status_code == 200 + by_name = {entry["field_name"]: entry for entry in response.json()} + assert store.source("alerting_args") == "config" + assert by_name["daily_report_frequency"]["field_value"] == 3 + assert by_name["daily_report_frequency"]["source"] == "config" + + @pytest.mark.parametrize("db_alerting_args", [None, []]) def test_alerting_settings_handles_empty_db_args( client: TestClient, @@ -268,6 +294,7 @@ def test_alerting_settings_handles_empty_db_args( assert response.status_code == 200 by_name = {entry["field_name"]: entry for entry in response.json()} assert by_name["report_check_interval"]["source"] == "config" + assert by_name["budget_alert_ttl"]["source"] == "default" def test_alerting_settings_no_db_error(client, auth_as, no_prisma): From f998ab53d5e68d46c05238bf8ff05d711ddf7085 Mon Sep 17 00:00:00 2001 From: Yuneng Jiang Date: Mon, 21 Sep 2026 13:52:16 -0700 Subject: [PATCH 5/8] fix(proxy): treat a config-owned alerting_args as shadowing the stored row When the config file declares alerting_args at all, the resolver hands the file's dict to every reader and the stored row never reaches one. Reporting a nested field as "db" because the row happens to carry it told the admin a value was in effect that the proxy does not serve: a live proxy answered source "db" for outage_alert_ttl while serving the default. A config-owned parent now reports the field's own default, and the DB is consulted only when the file leaves the parent alone. --- litellm/proxy/proxy_server.py | 5 +- .../proxy_server/test_routes_model_metrics.py | 53 +++++++++++++------ 2 files changed, 41 insertions(+), 17 deletions(-) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 7b5086f3e8b..d162ce2914e 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -15996,10 +15996,13 @@ def _nested_setting_source( parent_value: Final = settings.config_value(parent_key) if isinstance(parent_value, Mapping) and field_name in parent_value: return "config" + unset_source: Final[FieldSource] = "default" if field_default is not None else "unset" + if settings.owned_by_config(parent_key): + return unset_source db_value: Final = db_values.get(field_name) if db_value is not None and not (isinstance(db_value, list) and len(db_value) == 0): return "db" - return "default" if field_default is not None else "unset" + return unset_source @router.get( diff --git a/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py b/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py index c5287db5027..3fb6e6fcb45 100644 --- a/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py +++ b/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py @@ -183,37 +183,39 @@ def test_model_settings_method_not_allowed(client, auth_as): # --------------------------------------------------------------------------- -def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): +def _alerting_client(monkeypatch, *, yaml_values, db_row, live_args): from litellm.proxy.config_resolvers import SettingsStore - db_alerting_args = { - "daily_report_frequency": 7, - "outage_alert_ttl": 99, - "region_outage_alert_ttl": [], - } - pc = MagicMock() row = MagicMock() - row.param_value = {"alerting_args": db_alerting_args} + row.param_value = db_row pc.db.litellm_config.find_first = AsyncMock(return_value=row) monkeypatch.setattr(proxy_server, "prisma_client", pc) logging_obj = MagicMock() args_model = MagicMock() - args_model.model_dump = MagicMock(return_value={"daily_report_frequency": 3}) + args_model.model_dump = MagicMock(return_value=live_args) logging_obj.slack_alerting_instance.alerting_args = args_model monkeypatch.setattr(proxy_server, "proxy_logging_obj", logging_obj) store = SettingsStore("general_settings") - store.load_yaml( - { - "alerting": ["slack"], - "alerting_args": {"daily_report_frequency": 3, "report_check_interval": 300}, - } - ) - store.apply_db_row("general_settings", {"alerting_args": db_alerting_args}) + store.load_yaml(yaml_values) + store.apply_db_row("general_settings", db_row) monkeypatch.setattr(proxy_server.proxy_config, "settings", store) monkeypatch.setattr(proxy_server, "general_settings", store) + return store + + +def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): + _alerting_client( + monkeypatch, + yaml_values={ + "alerting": ["slack"], + "alerting_args": {"daily_report_frequency": 3, "report_check_interval": 300}, + }, + db_row={"alerting_args": {"daily_report_frequency": 7, "outage_alert_ttl": 4242}}, + live_args={"daily_report_frequency": 3}, + ) with auth_as(LitellmUserRoles.PROXY_ADMIN): response = client.get("/alerting/settings") @@ -224,6 +226,25 @@ def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): assert by_name["slack_alerting"]["source"] == "config" assert by_name["daily_report_frequency"]["source"] == "config" assert by_name["report_check_interval"]["source"] == "config" + assert by_name["outage_alert_ttl"]["source"] == "default" + assert by_name["budget_alert_ttl"]["source"] == "default" + + +def test_alerting_settings_reports_db_source_when_the_file_omits_alerting_args(client, auth_as, monkeypatch): + store = _alerting_client( + monkeypatch, + yaml_values={"alerting": ["slack"]}, + db_row={"alerting_args": {"outage_alert_ttl": 4242, "region_outage_alert_ttl": []}}, + live_args={"outage_alert_ttl": 4242}, + ) + + with auth_as(LitellmUserRoles.PROXY_ADMIN): + response = client.get("/alerting/settings") + + assert response.status_code == 200 + by_name = {entry["field_name"]: entry for entry in response.json()} + + assert store.owned_by_config("alerting_args") is False assert by_name["outage_alert_ttl"]["source"] == "db" assert by_name["region_outage_alert_ttl"]["source"] == "default" assert by_name["budget_alert_ttl"]["source"] == "default" From 46023769774e018d6fe75f4b5102e01dbd507146 Mon Sep 17 00:00:00 2001 From: Yuneng Jiang Date: Mon, 21 Sep 2026 14:24:32 -0700 Subject: [PATCH 6/8] fix(proxy): report a stored alerting value as db even when it is null A stored null or empty list for a nested alerting field is still the value the proxy serves when the config file leaves alerting_args alone, so the source is db. Keying off the value rather than its presence reported those fields as default and hid a stored setting that is genuinely in effect. Presence in the stored row now decides, with the config file still checked first so a config-owned key keeps reporting config. Test helpers are typed and the router test injects a stub rather than patching a class attribute. --- litellm/proxy/proxy_server.py | 7 +-- .../test_router_settings_endpoints.py | 21 +++---- .../proxy_server/test_routes_model_metrics.py | 59 +++++++++++++++---- .../test_proxy_setting_endpoints.py | 6 +- 4 files changed, 64 insertions(+), 29 deletions(-) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index d162ce2914e..2ee8d1627c0 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -15993,16 +15993,13 @@ def _nested_setting_source( field_name: str, field_default: JsonValue, ) -> FieldSource: + unset_source: Final[FieldSource] = "default" if field_default is not None else "unset" parent_value: Final = settings.config_value(parent_key) if isinstance(parent_value, Mapping) and field_name in parent_value: return "config" - unset_source: Final[FieldSource] = "default" if field_default is not None else "unset" if settings.owned_by_config(parent_key): return unset_source - db_value: Final = db_values.get(field_name) - if db_value is not None and not (isinstance(db_value, list) and len(db_value) == 0): - return "db" - return unset_source + return "db" if field_name in db_values else unset_source @router.get( diff --git a/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py index 51c8679e89e..889bed13099 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py +++ b/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py @@ -4,6 +4,8 @@ Tests for router settings management endpoints. Tests the GET endpoints for router settings and router fields. """ +from collections.abc import Mapping +from typing import Any, Final from unittest.mock import AsyncMock, MagicMock, patch import pytest @@ -22,15 +24,14 @@ from litellm.router import Router client = TestClient(app) -def _stub_proxy_config(router_settings, config_router_settings): - class _StubProxyConfig: - def __init__(self): - self.router_settings = router_settings +class _StubProxyConfig: + def __init__(self, router_settings: SettingsStore, config_router_settings: Mapping[str, Any]) -> None: + self.router_settings: Final = router_settings + self._config_router_settings: Final = dict(config_router_settings) - async def get_config(self, config_file_path=None): - return {"router_settings": dict(config_router_settings)} - - return _StubProxyConfig() + async def get_config(self, config_file_path: str | None = None) -> dict[str, Any]: + del config_file_path + return {"router_settings": dict(self._config_router_settings)} class TestRouterSettingsEndpoints: @@ -95,7 +96,7 @@ class TestRouterSettingsEndpoints: monkeypatch.setattr( proxy_server, "proxy_config", - _stub_proxy_config( + _StubProxyConfig( store, {"routing_strategy": "simple-shuffle", "num_retries": 3}, ), @@ -140,7 +141,7 @@ class TestRouterSettingsEndpoints: monkeypatch.setattr( proxy_server, "proxy_config", - _stub_proxy_config(SettingsStore("router_settings"), {}), + _StubProxyConfig(SettingsStore("router_settings"), {}), ) admin_user = UserAPIKeyAuth( diff --git a/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py b/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py index 3fb6e6fcb45..b5536b7618c 100644 --- a/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py +++ b/tests/test_litellm/proxy/proxy_server/test_routes_model_metrics.py @@ -11,7 +11,7 @@ Pins (PR2): from __future__ import annotations -from collections.abc import Callable +from collections.abc import Callable, Mapping from contextlib import AbstractContextManager from unittest.mock import AsyncMock, MagicMock @@ -22,6 +22,7 @@ import litellm from litellm.proxy import proxy_server from litellm.proxy._types import LitellmUserRoles from litellm.proxy.config_resolvers.settings_rules import JsonValue +from litellm.proxy.config_resolvers.settings_store import SettingsStore from .conftest import normalize # type: ignore[import-not-found] @@ -183,9 +184,13 @@ def test_model_settings_method_not_allowed(client, auth_as): # --------------------------------------------------------------------------- -def _alerting_client(monkeypatch, *, yaml_values, db_row, live_args): - from litellm.proxy.config_resolvers import SettingsStore - +def _alerting_client( + monkeypatch: pytest.MonkeyPatch, + *, + yaml_values: Mapping[str, JsonValue], + db_row: Mapping[str, JsonValue], + live_args: Mapping[str, JsonValue], +) -> "SettingsStore": pc = MagicMock() row = MagicMock() row.param_value = db_row @@ -206,7 +211,11 @@ def _alerting_client(monkeypatch, *, yaml_values, db_row, live_args): return store -def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): +def test_alerting_settings_reports_sources( + client: TestClient, + auth_as: Callable[..., AbstractContextManager[None]], + monkeypatch: pytest.MonkeyPatch, +) -> None: _alerting_client( monkeypatch, yaml_values={ @@ -230,11 +239,21 @@ def test_alerting_settings_reports_sources(client, auth_as, monkeypatch): assert by_name["budget_alert_ttl"]["source"] == "default" -def test_alerting_settings_reports_db_source_when_the_file_omits_alerting_args(client, auth_as, monkeypatch): +def test_alerting_settings_reports_db_source_when_the_file_omits_alerting_args( + client: TestClient, + auth_as: Callable[..., AbstractContextManager[None]], + monkeypatch: pytest.MonkeyPatch, +) -> None: store = _alerting_client( monkeypatch, yaml_values={"alerting": ["slack"]}, - db_row={"alerting_args": {"outage_alert_ttl": 4242, "region_outage_alert_ttl": []}}, + db_row={ + "alerting_args": { + "outage_alert_ttl": 4242, + "region_outage_alert_ttl": [], + "report_check_interval": None, + } + }, live_args={"outage_alert_ttl": 4242}, ) @@ -244,13 +263,18 @@ def test_alerting_settings_reports_db_source_when_the_file_omits_alerting_args(c assert response.status_code == 200 by_name = {entry["field_name"]: entry for entry in response.json()} - assert store.owned_by_config("alerting_args") is False + assert store.source("alerting_args") == "db" assert by_name["outage_alert_ttl"]["source"] == "db" - assert by_name["region_outage_alert_ttl"]["source"] == "default" + assert by_name["region_outage_alert_ttl"]["source"] == "db" + assert by_name["report_check_interval"]["source"] == "db" assert by_name["budget_alert_ttl"]["source"] == "default" -def test_alerting_settings_reports_config_source_when_db_disagrees(client, auth_as, monkeypatch): +def test_alerting_settings_reports_config_source_when_db_disagrees( + client: TestClient, + auth_as: Callable[..., AbstractContextManager[None]], + monkeypatch: pytest.MonkeyPatch, +) -> None: from litellm.proxy.config_resolvers import SettingsStore db_alerting_args = {"daily_report_frequency": 7} @@ -289,7 +313,7 @@ def test_alerting_settings_handles_empty_db_args( auth_as: Callable[..., AbstractContextManager[None]], monkeypatch: pytest.MonkeyPatch, db_alerting_args: JsonValue, -): +) -> None: from litellm.proxy.config_resolvers import SettingsStore pc = MagicMock() @@ -318,6 +342,19 @@ def test_alerting_settings_handles_empty_db_args( assert by_name["budget_alert_ttl"]["source"] == "default" +@pytest.mark.parametrize( + ("field_default", "expected"), + [(43200, "default"), (None, "unset")], +) +def test_nested_setting_source_without_a_config_or_db_value(field_default: JsonValue, expected: str) -> None: + store = SettingsStore("general_settings") + store.load_yaml({}) + + assert ( + proxy_server._nested_setting_source(store, {}, "alerting_args", "budget_alert_ttl", field_default) == expected + ) + + def test_alerting_settings_no_db_error(client, auth_as, no_prisma): """Pins ``GET /alerting/settings`` (error: db not connected).""" with auth_as(LitellmUserRoles.PROXY_ADMIN): diff --git a/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py b/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py index 524ab647099..75feb746bd7 100644 --- a/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py +++ b/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py @@ -1342,7 +1342,7 @@ class TestProxySettingEndpoints: where={"id": "ui_settings"} ) - def test_get_ui_settings_reports_sources(self, monkeypatch): + def test_get_ui_settings_reports_sources(self, monkeypatch: pytest.MonkeyPatch) -> None: from unittest.mock import AsyncMock, MagicMock from litellm.proxy import proxy_server @@ -3532,7 +3532,7 @@ class TestPtuCostAttributionUISetting: def test_reported_config_when_secret_manager_enables_the_flag( self, mock_auth: None, monkeypatch: pytest.MonkeyPatch - ): + ) -> None: from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR monkeypatch.delenv(PTU_COST_ATTRIBUTION_ENV_VAR, raising=False) @@ -3550,7 +3550,7 @@ class TestPtuCostAttributionUISetting: def test_reported_config_when_secret_manager_disables_the_flag( self, mock_auth: None, monkeypatch: pytest.MonkeyPatch - ): + ) -> None: from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR monkeypatch.delenv(PTU_COST_ATTRIBUTION_ENV_VAR, raising=False) From 1cc38f05f43c1e2108fc3a35f1e81b8498e35805 Mon Sep 17 00:00:00 2001 From: Yuneng Jiang Date: Mon, 21 Sep 2026 15:00:24 -0700 Subject: [PATCH 7/8] test(proxy): type the router settings source test parameters --- .../management_endpoints/test_router_settings_endpoints.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py index 889bed13099..3fcda310435 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py +++ b/tests/test_litellm/proxy/management_endpoints/test_router_settings_endpoints.py @@ -89,7 +89,9 @@ class TestRouterSettingsEndpoints: assert len(routing_strategy_field["options"]) > 0 @pytest.mark.asyncio - async def test_get_router_settings_reports_sources(self, monkeypatch): + async def test_get_router_settings_reports_sources( + self, monkeypatch: pytest.MonkeyPatch + ) -> None: store = SettingsStore("router_settings") store.load_yaml({"routing_strategy": "simple-shuffle"}) store.apply_db_row("router_settings", {"num_retries": 3}) From a5cce1b85966debd1468575d83fddb6910750a73 Mon Sep 17 00:00:00 2001 From: Yuneng Jiang Date: Mon, 21 Sep 2026 15:49:09 -0700 Subject: [PATCH 8/8] fix(proxy): let the config file win over the stored row in ui settings --- .../proxy/ui_crud_endpoints/proxy_setting_endpoints.py | 8 ++++---- .../ui_crud_endpoints/test_proxy_setting_endpoints.py | 7 +++++-- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py b/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py index ed626bdb624..f4d4ccf5851 100644 --- a/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py +++ b/litellm/proxy/ui_crud_endpoints/proxy_setting_endpoints.py @@ -1763,8 +1763,8 @@ async def get_ui_settings(): effective_ui_settings: Final[Mapping[str, object]] = MappingProxyType( { - **{key: proxy_config.settings[key] for key in ALLOWED_UI_SETTINGS_FIELDS if key in proxy_config.settings}, **ui_settings, + **{key: proxy_config.settings[key] for key in ALLOWED_UI_SETTINGS_FIELDS if key in proxy_config.settings}, } ) config: Final[Mapping[str, object]] = MappingProxyType( @@ -1787,9 +1787,9 @@ async def get_ui_settings(): source: Final[Mapping[str, FieldSource]] = MappingProxyType( { key: ( - "db" - if key in ui_settings - else _ui_setting_source(key, values[key], proxy_config.settings, settings_class) + _ui_setting_source(key, values[key], proxy_config.settings, settings_class) + if key in proxy_config.settings or key not in ui_settings + else "db" ) for key in values } diff --git a/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py b/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py index 75feb746bd7..eecee2fd0f1 100644 --- a/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py +++ b/tests/test_litellm/proxy/ui_crud_endpoints/test_proxy_setting_endpoints.py @@ -1352,6 +1352,7 @@ class TestProxySettingEndpoints: mock_db_record = MagicMock() mock_db_record.ui_settings = { "disable_model_add_for_internal_users": True, + "require_auth_for_public_ai_hub": True, } mock_prisma.db.litellm_uisettings.find_unique = AsyncMock( return_value=mock_db_record @@ -1376,10 +1377,12 @@ class TestProxySettingEndpoints: assert response.status_code == 200 data = response.json() - assert data["values"]["disable_model_add_for_internal_users"] is True + assert data["values"]["disable_model_add_for_internal_users"] is False assert data["values"]["forward_client_headers_to_llm_api"] is True - assert data["source"]["disable_model_add_for_internal_users"] == "db" + assert data["values"]["require_auth_for_public_ai_hub"] is True + assert data["source"]["disable_model_add_for_internal_users"] == "config" assert data["source"]["forward_client_headers_to_llm_api"] == "config" + assert data["source"]["require_auth_for_public_ai_hub"] == "db" def test_get_ui_settings_schema_description_preserved_with_extensions( self, mock_auth, monkeypatch