From 68f6c032889471a31b5bc06a8b0f505b8d738ec1 Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Wed, 28 Oct 2026 14:48:49 -0700 Subject: [PATCH 01/10] fix(proxy): ignore stored general_settings keys no settings API manages --- .../proxy/config_resolvers/settings_store.py | 19 +++++-- litellm/proxy/proxy_server.py | 21 ++++++- .../configuration/test_effective_settings.py | 56 ++++++++++++++++++- .../config_resolvers/test_settings_store.py | 30 ++++++++++ .../proxy/proxy_server/test_proxy_config.py | 23 ++++++++ ...test_proxy_server_endpoints_and_startup.py | 4 +- 6 files changed, 145 insertions(+), 8 deletions(-) diff --git a/litellm/proxy/config_resolvers/settings_store.py b/litellm/proxy/config_resolvers/settings_store.py index 70486be0068..3be66821915 100644 --- a/litellm/proxy/config_resolvers/settings_store.py +++ b/litellm/proxy/config_resolvers/settings_store.py @@ -42,10 +42,12 @@ _EMPTY_ROWS: Final[Mapping[DbRow, Mapping[str, JsonValue]]] = MappingProxyType({ class SettingsStore(MutableMapping[str, JsonValue]): - def __init__(self, section: Section) -> None: + def __init__(self, section: Section, *, managed_db_keys: frozenset[str] | None = None) -> None: self._section: Final = section + self._managed_db_keys: Final = managed_db_keys self._yaml_values: Mapping[str, JsonValue] = _EMPTY_VALUES self._database_rows: Mapping[DbRow, Mapping[str, JsonValue]] = _EMPTY_ROWS + self._unmanaged_db_keys: frozenset[str] = frozenset() self._runtime_values: Mapping[str, JsonValue] = _EMPTY_VALUES self._deleted_runtime_keys: frozenset[str] = frozenset() @@ -77,15 +79,24 @@ class SettingsStore(MutableMapping[str, JsonValue]): return self.owned_by_config(key) and self._db_value_is_shadowed(key) def apply_db_row(self, row: DbRow, db_row: Mapping[str, JsonValue]) -> None: + applied_row: Final = MappingProxyType({key: db_row[key] for key in db_row if self._db_manages(row, key)}) previous_row: Final = self._database_rows.get(row, _EMPTY_VALUES) changed: Final = frozenset( key - for key in (*previous_row, *db_row) - if previous_row.get(key, ABSENT) != db_row.get(key, ABSENT) # pyright: ignore[reportUnknownArgumentType] # JsonValue vs Absent compare + for key in (*previous_row, *applied_row) + if previous_row.get(key, ABSENT) != applied_row.get(key, ABSENT) # pyright: ignore[reportUnknownArgumentType] # JsonValue vs Absent compare ) - self._database_rows = MappingProxyType({**self._database_rows, row: MappingProxyType(dict(db_row))}) + self._database_rows = MappingProxyType({**self._database_rows, row: applied_row}) + if row == self._section: + self._unmanaged_db_keys = frozenset(key for key in db_row if key not in applied_row) self._clear_runtime_keys(changed) + def unmanaged_db_keys(self) -> tuple[str, ...]: + return tuple(sorted(self._unmanaged_db_keys)) + + def _db_manages(self, row: DbRow, key: str) -> bool: + return row != self._section or self._managed_db_keys is None or key in self._managed_db_keys + def resolved(self) -> Mapping[str, JsonValue]: return MappingProxyType(dict(self)) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 64fb2791913..80cbdaf79f8 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -5549,6 +5549,10 @@ def _reload_settings_store(section: Section, store: SettingsStore, section_confi store["pass_through_endpoints"] = serving_pass_throughs +def _db_managed_general_settings_keys() -> frozenset[str]: + return frozenset((*ConfigGeneralSettings.model_fields, *_CLEANUP_SCHEDULE_KEYS, "allowed_ips", "email_settings")) + + def _bind_general_settings_store(settings: SettingsStore) -> None: global general_settings general_settings = settings # pyright: ignore[reportAssignmentType] # legacy global accepts mappings @@ -5699,7 +5703,9 @@ class ProxyConfig: # whether an existing request predates the prices it just fetched, and re-serving one # costs a single fetch where skipping one leaves it priced wrong indefinitely self.model_cost_map_applied_revision: int = 0 - self.settings: Final[SettingsStore] = SettingsStore("general_settings") + self.settings: Final[SettingsStore] = SettingsStore( + "general_settings", managed_db_keys=_db_managed_general_settings_keys() + ) self.router_settings: Final[SettingsStore] = SettingsStore("router_settings") self.litellm_settings: Final[SettingsStore] = SettingsStore("litellm_settings") self.environment_variables: Final[SettingsStore] = SettingsStore("environment_variables") @@ -5710,6 +5716,7 @@ class ProxyConfig: self._db_environment_keys: frozenset[str] = frozenset() self._sso_environment_removals: frozenset[str] = frozenset() self._warned_shadowed_keys: frozenset[tuple[Section, str]] = frozenset() + self._warned_unmanaged_keys: frozenset[str] = frozenset() self._db_config_callback_entries: Mapping[tuple[str, str], _DbCallbackRegistration] = MappingProxyType({}) self._settings_stores: Final[Mapping[Section, SettingsStore]] = MappingProxyType( { @@ -8208,6 +8215,7 @@ class ProxyConfig: cache_size_was_db: Final = self.settings.source("user_api_key_cache_max_size") == "db" previous_cleanup_schedule: Final = self._resolved_cleanup_schedule() self.settings.apply_db_row("general_settings", db_general_settings) + self._warn_about_unmanaged_db_settings() _bind_general_settings_store(self.settings) await self._apply_general_settings_side_effects( db_general_settings, @@ -8425,6 +8433,7 @@ class ProxyConfig: ) self._warn_about_shadowed_db_settings() + self._warn_about_unmanaged_db_settings() return self._config_with_resolved_settings(config) async def _apply_db_environment_variables_row( @@ -8483,6 +8492,16 @@ class ProxyConfig: ) self._warned_shadowed_keys = shadowed + def _warn_about_unmanaged_db_settings(self) -> None: + unmanaged: Final = frozenset(self.settings.unmanaged_db_keys()) + for key in sorted(unmanaged - self._warned_unmanaged_keys): + verbose_proxy_logger.warning( + "general_settings.%s is stored in the database, but no settings API manages it, so the stored value " + "is ignored. Set it in the config file to use it.", + key, + ) + self._warned_unmanaged_keys = unmanaged + def _prepared_db_settings_values(self, section: Section, value: object) -> Mapping[str, SettingsJsonValue]: scrubbed: Final = _scrub_db_overlay_remote_module_loads(section=section, db_value=value) return _as_settings_mapping(scrubbed) diff --git a/tests/integration/configuration/test_effective_settings.py b/tests/integration/configuration/test_effective_settings.py index 07477f1f048..ca016755ef5 100644 --- a/tests/integration/configuration/test_effective_settings.py +++ b/tests/integration/configuration/test_effective_settings.py @@ -20,7 +20,7 @@ from pydantic import BaseModel, JsonValue, TypeAdapter from tests.integration._support.client import Gateway, eventually, object_value, string_value from tests.integration._support.database import read_rows, scratch_database -from tests.integration._support.process import owned_proxy +from tests.integration._support.process import owned_proxy, owned_proxy_process from tests.integration._support.wire import Reply, Request, Wire, wire_server pytestmark: Final = pytest.mark.shares_worker_state @@ -1701,3 +1701,57 @@ def test_db_environment_variables_saved_from_a_session_outside_the_tables_schema assert isinstance(first, int) and isinstance(second, int) assert 0 < first < second + + +def test_a_stored_general_setting_no_settings_api_manages_stays_off_and_the_rest_of_the_row_applies( + gateway: Gateway, tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + alias: Final = "stale-database-setting-" + uuid.uuid4().hex + with scratch_database() as database_url, wire_server(lambda _request: _completion_reply("pong")) as provider: + monkeypatch.setenv("DATABASE_URL", database_url) + _push_schema() + with psycopg.connect(database_url, autocommit=True) as writer: + writer.execute( + 'INSERT INTO "LiteLLM_Config" (param_name, param_value) VALUES (%s, %s)', + ("general_settings", Jsonb({"enforce_user_param": True, "store_prompts_in_spend_logs": True})), + ) + config: Final = tmp_path / "stale-database-setting.yaml" + config.write_text( + json.dumps( + { + "model_list": [ + { + "model_name": alias, + "litellm_params": { + "model": "openai/gpt-4o-mini", + "api_base": provider.url + "/v1", + "api_key": "integration-provider-key", + }, + } + ], + "general_settings": {"master_key": gateway.key, "store_model_in_db": True}, + } + ) + ) + with owned_proxy_process( + gateway, + tmp_path / "stale-database-setting", + {"DATABASE_URL": database_url, "DISABLE_SCHEMA_UPDATE": "true"}, + config=config, + database_setup=(), + ) as owned: + answer: Final = owned.gateway.request( + "POST", "/v1/chat/completions", {"model": alias, "messages": [{"role": "user", "content": "ping"}]} + ) + listed: Final = owned.gateway.request("GET", "/config/list", params={"config_type": "general_settings"}) + log: Final = owned.log.read_text() + + assert answer.status_code == 200, answer.text + assert listed.status_code == 200, listed.text + stored_prompts: Final = next( + entry + for entry in TypeAdapter(list[dict[str, JsonValue]]).validate_json(listed.content) + if entry["field_name"] == "store_prompts_in_spend_logs" + ) + assert (stored_prompts["field_value"], stored_prompts["source"]) == (True, "db") + assert "general_settings.enforce_user_param is stored in the database, but no settings API manages it" in log diff --git a/tests/unit/proxy/config_resolvers/test_settings_store.py b/tests/unit/proxy/config_resolvers/test_settings_store.py index 7b2cd404b46..f6b8f672a04 100644 --- a/tests/unit/proxy/config_resolvers/test_settings_store.py +++ b/tests/unit/proxy/config_resolvers/test_settings_store.py @@ -471,3 +471,33 @@ def test_settings_store_truthiness_matches_emptiness() -> None: assert bool(store) is True del store["max_parallel_requests"] assert bool(store) is False + + +def test_settings_store_ignores_stored_keys_outside_its_managed_db_keys_and_still_applies_them_from_yaml() -> None: + store: Final = SettingsStore("general_settings", managed_db_keys=frozenset({"max_parallel_requests"})) + stored_row: Final[dict[str, JsonValue]] = {"enforce_user_param": True, "max_parallel_requests": 5} + + store.apply_db_row("general_settings", stored_row) + + assert dict(store) == {"max_parallel_requests": 5} + assert store.source("enforce_user_param") == "unset" + assert store.unmanaged_db_keys() == ("enforce_user_param",) + + store.load_yaml({"enforce_user_param": True}) + store.apply_db_row("general_settings", stored_row) + + assert dict(store) == {"enforce_user_param": True, "max_parallel_requests": 5} + assert store.source("enforce_user_param") == "config" + + +def test_settings_store_managed_db_keys_leave_other_rows_and_unrestricted_stores_whole() -> None: + restricted: Final = SettingsStore("general_settings", managed_db_keys=frozenset()) + unrestricted: Final = SettingsStore("general_settings") + + restricted.apply_db_row("ui_settings", {"disable_custom_api_keys": True}) + unrestricted.apply_db_row("general_settings", {"enforce_user_param": True}) + + assert dict(restricted) == {"disable_custom_api_keys": True} + assert restricted.unmanaged_db_keys() == () + assert dict(unrestricted) == {"enforce_user_param": True} + assert unrestricted.unmanaged_db_keys() == () diff --git a/tests/unit/proxy/proxy_server/test_proxy_config.py b/tests/unit/proxy/proxy_server/test_proxy_config.py index e59dd19271c..36afbc5ad78 100644 --- a/tests/unit/proxy/proxy_server/test_proxy_config.py +++ b/tests/unit/proxy/proxy_server/test_proxy_config.py @@ -4355,6 +4355,29 @@ async def test_ProxyConfig__update_general_settings_updates_health_check_retenti reschedule.assert_awaited_once() + +@pytest.mark.asyncio +async def test_ProxyConfig__update_general_settings_ignores_a_stored_key_no_settings_api_manages_and_warns_once( + monkeypatch, caplog +): + monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", {}) + pc = ProxyConfig() + stored_row = {"enforce_user_param": True, "store_prompts_in_spend_logs": True} + + with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"): + await pc._update_general_settings(stored_row) + await pc._update_general_settings(stored_row) + from litellm.proxy import proxy_server + + assert proxy_server.general_settings["store_prompts_in_spend_logs"] is True + assert "enforce_user_param" not in proxy_server.general_settings + warnings = [record.getMessage() for record in caplog.records if "enforce_user_param" in record.getMessage()] + assert warnings == [ + "general_settings.enforce_user_param is stored in the database, but no settings API manages it, so the " + "stored value is ignored. Set it in the config file to use it." + ] + + def _paused_scheduler(monkeypatch): from apscheduler.schedulers.asyncio import AsyncIOScheduler diff --git a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py index 55d1587669a..11c9bca6ca0 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -7038,7 +7038,7 @@ def test_deep_merge_dicts_skips_none_and_empty_lists(monkeypatch): db_param_value = { "max_parallel_requests": None, "allowed_models": [], - "new_key": "new_value", + "store_prompts_in_spend_logs": True, "nested": { "key1": "updated_value1", "key3": "value3", @@ -7051,7 +7051,7 @@ def test_deep_merge_dicts_skips_none_and_empty_lists(monkeypatch): assert result["max_parallel_requests"] == 10 assert result["allowed_models"] == ["gpt-3.5-turbo", "gpt-4"] - assert result["new_key"] == "new_value" + assert result["store_prompts_in_spend_logs"] is True assert result["nested"] == {"key1": "value1", "key2": "value2"} From 9263ee873d6802449fc4cf49c3cfcaa23c4510f4 Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Wed, 28 Oct 2026 16:11:22 -0700 Subject: [PATCH 02/10] fix(proxy): skip the ignored-key warning for keys the config file sets --- litellm/proxy/config_resolvers/settings_store.py | 2 +- tests/unit/proxy/config_resolvers/test_settings_store.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/litellm/proxy/config_resolvers/settings_store.py b/litellm/proxy/config_resolvers/settings_store.py index 3be66821915..91069a7e15e 100644 --- a/litellm/proxy/config_resolvers/settings_store.py +++ b/litellm/proxy/config_resolvers/settings_store.py @@ -92,7 +92,7 @@ class SettingsStore(MutableMapping[str, JsonValue]): self._clear_runtime_keys(changed) def unmanaged_db_keys(self) -> tuple[str, ...]: - return tuple(sorted(self._unmanaged_db_keys)) + return tuple(sorted(key for key in self._unmanaged_db_keys if not self.owned_by_config(key))) def _db_manages(self, row: DbRow, key: str) -> bool: return row != self._section or self._managed_db_keys is None or key in self._managed_db_keys diff --git a/tests/unit/proxy/config_resolvers/test_settings_store.py b/tests/unit/proxy/config_resolvers/test_settings_store.py index f6b8f672a04..27ca7d4a583 100644 --- a/tests/unit/proxy/config_resolvers/test_settings_store.py +++ b/tests/unit/proxy/config_resolvers/test_settings_store.py @@ -488,6 +488,7 @@ def test_settings_store_ignores_stored_keys_outside_its_managed_db_keys_and_stil assert dict(store) == {"enforce_user_param": True, "max_parallel_requests": 5} assert store.source("enforce_user_param") == "config" + assert store.unmanaged_db_keys() == () def test_settings_store_managed_db_keys_leave_other_rows_and_unrestricted_stores_whole() -> None: From 8fd9c71c46d6b564871d39e5850fc9029339dad2 Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Wed, 28 Oct 2026 21:24:40 -0700 Subject: [PATCH 03/10] fix(proxy): let /config/field/delete remove ignored stored general_settings keys --- litellm/proxy/proxy_server.py | 19 ++++--- .../proxy/proxy_server/test_proxy_config.py | 13 +++-- ...test_proxy_server_endpoints_and_startup.py | 50 +++++++++++++++++++ 3 files changed, 67 insertions(+), 15 deletions(-) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 52a19eb6aa0..105287b28e2 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -8501,7 +8501,7 @@ class ProxyConfig: for key in sorted(unmanaged - self._warned_unmanaged_keys): verbose_proxy_logger.warning( "general_settings.%s is stored in the database, but no settings API manages it, so the stored value " - "is ignored. Set it in the config file to use it.", + "is ignored. Set it in the config file to use it, or remove it with POST /config/field/delete.", key, ) self._warned_unmanaged_keys = unmanaged @@ -20646,7 +20646,16 @@ async def delete_config_general_settings( if data.field_name in _GENERAL_SETTINGS_UI_LITELLM_FIELDS: return await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict) - if data.field_name not in ConfigGeneralSettings.model_fields: + db_general_settings: Final[_ConfigParamRow | None] = await _config_param_table(prisma_client).find_first( + where={"param_name": "general_settings"} + ) + stored_keys: Final[frozenset[str]] = ( + frozenset(dict(db_general_settings.param_value)) + if db_general_settings is not None and db_general_settings.param_value is not None + else frozenset() + ) + + if data.field_name not in ConfigGeneralSettings.model_fields and data.field_name not in stored_keys: raise HTTPException( status_code=400, detail={"error": f"Invalid field={data.field_name} passed in."}, @@ -20654,12 +20663,6 @@ async def delete_config_general_settings( proxy_config.reject_config_owned_deletes(section_name="general_settings", keys=(data.field_name,)) - ## 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 - if db_general_settings is None or db_general_settings.param_value is None: raise HTTPException( status_code=400, diff --git a/tests/unit/proxy/proxy_server/test_proxy_config.py b/tests/unit/proxy/proxy_server/test_proxy_config.py index 36afbc5ad78..629d39efd3f 100644 --- a/tests/unit/proxy/proxy_server/test_proxy_config.py +++ b/tests/unit/proxy/proxy_server/test_proxy_config.py @@ -4355,14 +4355,13 @@ async def test_ProxyConfig__update_general_settings_updates_health_check_retenti reschedule.assert_awaited_once() - @pytest.mark.asyncio async def test_ProxyConfig__update_general_settings_ignores_a_stored_key_no_settings_api_manages_and_warns_once( - monkeypatch, caplog -): + monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture +) -> None: monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", {}) - pc = ProxyConfig() - stored_row = {"enforce_user_param": True, "store_prompts_in_spend_logs": True} + pc: Final = ProxyConfig() + stored_row: Final = {"enforce_user_param": True, "store_prompts_in_spend_logs": True} with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"): await pc._update_general_settings(stored_row) @@ -4371,10 +4370,10 @@ async def test_ProxyConfig__update_general_settings_ignores_a_stored_key_no_sett assert proxy_server.general_settings["store_prompts_in_spend_logs"] is True assert "enforce_user_param" not in proxy_server.general_settings - warnings = [record.getMessage() for record in caplog.records if "enforce_user_param" in record.getMessage()] + warnings: Final = [record.getMessage() for record in caplog.records if "enforce_user_param" in record.getMessage()] assert warnings == [ "general_settings.enforce_user_param is stored in the database, but no settings API manages it, so the " - "stored value is ignored. Set it in the config file to use it." + "stored value is ignored. Set it in the config file to use it, or remove it with POST /config/field/delete." ] diff --git a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py index 11c9bca6ca0..812fb020e21 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -15417,6 +15417,56 @@ async def test_delete_config_general_settings_still_removes_a_key_the_database_o assert "max_request_size_mb" not in pc.settings +@pytest.mark.asyncio +async def test_delete_config_general_settings_removes_a_stored_key_no_settings_api_manages( + monkeypatch: pytest.MonkeyPatch, +) -> None: + from litellm.proxy._types import ConfigFieldDelete + from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings + + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {}}) + stored_row: Final = {"enforce_user_param": True, "store_prompts_in_spend_logs": True} + pc.settings.apply_db_row("general_settings", stored_row) + fake_prisma: Final = _fake_prisma_with_config(stored_row) + monkeypatch.setattr(proxy_server_module, "proxy_config", pc) + monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) + + admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) + await delete_config_general_settings( + data=ConfigFieldDelete(field_name="enforce_user_param", config_type="general_settings"), + user_api_key_dict=admin, + ) + + written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"]) + assert written == {"store_prompts_in_spend_logs": True} + assert pc.settings.unmanaged_db_keys() == () + + +@pytest.mark.asyncio +async def test_delete_config_general_settings_refuses_a_key_neither_managed_nor_stored( + monkeypatch: pytest.MonkeyPatch, +) -> None: + from litellm.proxy._types import ConfigFieldDelete + from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings + + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {}}) + fake_prisma: Final = _fake_prisma_with_config({"store_prompts_in_spend_logs": True}) + monkeypatch.setattr(proxy_server_module, "proxy_config", pc) + monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) + + admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) + with pytest.raises(HTTPException) as refused: + await delete_config_general_settings( + data=ConfigFieldDelete(field_name="enforce_user_param", config_type="general_settings"), + user_api_key_dict=admin, + ) + + assert refused.value.status_code == 400 + fake_prisma.db.litellm_config.upsert.assert_not_awaited() + + @pytest.mark.asyncio async def test_config_field_info_reports_the_declared_value_of_a_config_owned_secret(monkeypatch): from litellm.proxy.proxy_server import ProxyConfig, get_config_general_settings From 6ed155916a2675ee9862c66f7e7f9d6f2c12c25c Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Thu, 29 Oct 2026 01:45:14 -0700 Subject: [PATCH 04/10] fix(proxy): warn about and allow deleting an ignored stored general setting config.yaml also sets --- .../proxy/config_resolvers/settings_store.py | 2 +- litellm/proxy/proxy_server.py | 8 ++++-- .../config_resolvers/test_settings_store.py | 2 +- .../proxy/proxy_server/test_proxy_config.py | 21 +++++++++++++++ ...test_proxy_server_endpoints_and_startup.py | 27 +++++++++++++++++++ 5 files changed, 56 insertions(+), 4 deletions(-) diff --git a/litellm/proxy/config_resolvers/settings_store.py b/litellm/proxy/config_resolvers/settings_store.py index 91069a7e15e..3be66821915 100644 --- a/litellm/proxy/config_resolvers/settings_store.py +++ b/litellm/proxy/config_resolvers/settings_store.py @@ -92,7 +92,7 @@ class SettingsStore(MutableMapping[str, JsonValue]): self._clear_runtime_keys(changed) def unmanaged_db_keys(self) -> tuple[str, ...]: - return tuple(sorted(key for key in self._unmanaged_db_keys if not self.owned_by_config(key))) + return tuple(sorted(self._unmanaged_db_keys)) def _db_manages(self, row: DbRow, key: str) -> bool: return row != self._section or self._managed_db_keys is None or key in self._managed_db_keys diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 0c17ce9d565..126988fdc6d 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -8502,8 +8502,11 @@ class ProxyConfig: for key in sorted(unmanaged - self._warned_unmanaged_keys): verbose_proxy_logger.warning( "general_settings.%s is stored in the database, but no settings API manages it, so the stored value " - "is ignored. Set it in the config file to use it, or remove it with POST /config/field/delete.", + "is ignored. %s", key, + "The config file's value applies. Remove the stored copy with POST /config/field/delete." + if self.settings.owned_by_config(key) + else "Set it in the config file to use it, or remove it with POST /config/field/delete.", ) self._warned_unmanaged_keys = unmanaged @@ -20651,7 +20654,8 @@ async def delete_config_general_settings( detail={"error": f"Invalid field={data.field_name} passed in."}, ) - proxy_config.reject_config_owned_deletes(section_name="general_settings", keys=(data.field_name,)) + if data.field_name in _db_managed_general_settings_keys(): + proxy_config.reject_config_owned_deletes(section_name="general_settings", keys=(data.field_name,)) if db_general_settings is None or db_general_settings.param_value is None: raise HTTPException( diff --git a/tests/unit/proxy/config_resolvers/test_settings_store.py b/tests/unit/proxy/config_resolvers/test_settings_store.py index 27ca7d4a583..76850825937 100644 --- a/tests/unit/proxy/config_resolvers/test_settings_store.py +++ b/tests/unit/proxy/config_resolvers/test_settings_store.py @@ -488,7 +488,7 @@ def test_settings_store_ignores_stored_keys_outside_its_managed_db_keys_and_stil assert dict(store) == {"enforce_user_param": True, "max_parallel_requests": 5} assert store.source("enforce_user_param") == "config" - assert store.unmanaged_db_keys() == () + assert store.unmanaged_db_keys() == ("enforce_user_param",) def test_settings_store_managed_db_keys_leave_other_rows_and_unrestricted_stores_whole() -> None: diff --git a/tests/unit/proxy/proxy_server/test_proxy_config.py b/tests/unit/proxy/proxy_server/test_proxy_config.py index 629d39efd3f..b3718028de5 100644 --- a/tests/unit/proxy/proxy_server/test_proxy_config.py +++ b/tests/unit/proxy/proxy_server/test_proxy_config.py @@ -4377,6 +4377,27 @@ async def test_ProxyConfig__update_general_settings_ignores_a_stored_key_no_sett ] +@pytest.mark.asyncio +async def test_ProxyConfig__update_general_settings_warns_about_an_ignored_stored_key_the_config_file_also_sets( + monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture +) -> None: + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {"enforce_user_param": False}}) + monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", pc.settings) + + with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"): + await pc._update_general_settings({"enforce_user_param": True}) + from litellm.proxy import proxy_server + + assert proxy_server.general_settings["enforce_user_param"] is False + warnings: Final = [record.getMessage() for record in caplog.records if "enforce_user_param" in record.getMessage()] + assert warnings == [ + "general_settings.enforce_user_param is stored in the database, but no settings API manages it, so the " + "stored value is ignored. The config file's value applies. Remove the stored copy with POST " + "/config/field/delete." + ] + + def _paused_scheduler(monkeypatch): from apscheduler.schedulers.asyncio import AsyncIOScheduler diff --git a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py index 812fb020e21..f7f3b3a8c8b 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -15443,6 +15443,33 @@ async def test_delete_config_general_settings_removes_a_stored_key_no_settings_a assert pc.settings.unmanaged_db_keys() == () +@pytest.mark.asyncio +async def test_delete_config_general_settings_removes_an_ignored_stored_key_the_config_file_also_sets( + monkeypatch: pytest.MonkeyPatch, +) -> None: + from litellm.proxy._types import ConfigFieldDelete + from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings + + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {"enforce_user_param": False}}) + stored_row: Final = {"enforce_user_param": True, "store_prompts_in_spend_logs": True} + pc.settings.apply_db_row("general_settings", stored_row) + fake_prisma: Final = _fake_prisma_with_config(stored_row) + monkeypatch.setattr(proxy_server_module, "proxy_config", pc) + monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) + + admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) + await delete_config_general_settings( + data=ConfigFieldDelete(field_name="enforce_user_param", config_type="general_settings"), + user_api_key_dict=admin, + ) + + written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"]) + assert written == {"store_prompts_in_spend_logs": True} + assert pc.settings["enforce_user_param"] is False + assert pc.settings.unmanaged_db_keys() == () + + @pytest.mark.asyncio async def test_delete_config_general_settings_refuses_a_key_neither_managed_nor_stored( monkeypatch: pytest.MonkeyPatch, From f700a8867b31c10f18f93425ea9b36d9267f9ab9 Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Thu, 29 Oct 2026 07:44:53 -0700 Subject: [PATCH 05/10] fix(proxy): let /config/field/delete remove every ignored stored key and read a JSON-string row A stored general_settings copy of a UI litellm field such as budget_rollover is now removed along with the litellm_settings reset, so the boot warning's remedy works for it. The route also decodes a general_settings row stored as a JSON string, so an unknown field answers 400 instead of 500. The warning no longer says that no settings API manages the key, which was wrong for ui_settings keys. --- litellm/proxy/proxy_server.py | 61 ++++++---- .../configuration/test_effective_settings.py | 2 +- .../proxy/proxy_server/test_proxy_config.py | 33 ++--- ...test_proxy_server_endpoints_and_startup.py | 114 ++++++++++++++++-- 4 files changed, 155 insertions(+), 55 deletions(-) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 126988fdc6d..607fc2f783d 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -8501,7 +8501,7 @@ class ProxyConfig: unmanaged: Final = frozenset(self.settings.unmanaged_db_keys()) for key in sorted(unmanaged - self._warned_unmanaged_keys): verbose_proxy_logger.warning( - "general_settings.%s is stored in the database, but no settings API manages it, so the stored value " + "general_settings.%s is stored in the database, but the proxy does not apply that stored value, so it " "is ignored. %s", key, "The config file's value applies. Remove the stored copy with POST /config/field/delete." @@ -20411,7 +20411,9 @@ async def _persist_general_settings_ui_litellm_field( return {"message": f"Field {field_name} updated", "status": "success"} -async def _reset_general_settings_ui_litellm_field(field_name: str, user_api_key_dict: UserAPIKeyAuth) -> dict: +async def _reset_general_settings_ui_litellm_field( + field_name: str, user_api_key_dict: UserAPIKeyAuth +) -> dict[str, str]: default_value: Final = _general_settings_ui_litellm_default(_GENERAL_SETTINGS_UI_LITELLM_FIELDS[field_name]) proxy_config.reject_config_owned_writes(section_name="litellm_settings", changed_keys={field_name: default_value}) config: Final = await proxy_config.get_config() @@ -20637,18 +20639,15 @@ async def delete_config_general_settings( ) if data.field_name in _GENERAL_SETTINGS_UI_LITELLM_FIELDS: - return await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict) + reset: Final = await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict) + stored_copy: Final = await _stored_general_settings() + if stored_copy is not None and data.field_name in stored_copy: + await _remove_stored_general_setting(data.field_name, stored_copy, user_api_key_dict) + return reset - db_general_settings: Final[_ConfigParamRow | None] = await _config_param_table(prisma_client).find_first( - where={"param_name": "general_settings"} - ) - stored_keys: Final[frozenset[str]] = ( - frozenset(dict(db_general_settings.param_value)) - if db_general_settings is not None and db_general_settings.param_value is not None - else frozenset() - ) + stored: Final = await _stored_general_settings() - if data.field_name not in ConfigGeneralSettings.model_fields and data.field_name not in stored_keys: + if data.field_name not in ConfigGeneralSettings.model_fields and (stored is None or data.field_name not in stored): raise HTTPException( status_code=400, detail={"error": f"Invalid field={data.field_name} passed in."}, @@ -20657,39 +20656,49 @@ async def delete_config_general_settings( if data.field_name in _db_managed_general_settings_keys(): proxy_config.reject_config_owned_deletes(section_name="general_settings", keys=(data.field_name,)) - if db_general_settings is None or db_general_settings.param_value is None: + if stored is None: raise HTTPException( status_code=400, detail={"error": f"Field name={data.field_name} not in config"}, ) - else: - general_settings = dict(db_general_settings.param_value) - before_general_settings: Final = copy.deepcopy(general_settings) + return await _remove_stored_general_setting(data.field_name, stored, user_api_key_dict) - ## update db - general_settings.pop(data.field_name, None) +async def _stored_general_settings() -> Mapping[str, SettingsJsonValue] | None: + config_table: Final[TableActions[_ConfigParamValueRow]] = _config_param_table(prisma_client) + row: Final = await config_table.find_first(where={"param_name": "general_settings"}) + if row is None or row.param_value is None: + return None + value: Final = ( + cast(object, json.loads(row.param_value)) # cast-ok: json.loads is untyped; the row is opaque JSON + if isinstance(row.param_value, str) + else row.param_value + ) + return _SETTINGS_MAPPING.validate_python(value) if isinstance(value, Mapping) else None + +async def _remove_stored_general_setting( + field_name: str, stored: Mapping[str, SettingsJsonValue], user_api_key_dict: UserAPIKeyAuth +) -> _ConfigParamValueRow: + remaining: Final = {key: value for key, value in stored.items() if key != field_name} response: Final = await ConfigRepository(prisma_client).table.upsert( where={"param_name": "general_settings"}, data={ "create": { "param_name": "general_settings", - "param_value": json.dumps(general_settings), + "param_value": json.dumps(remaining), }, - "update": {"param_value": json.dumps(general_settings)}, + "update": {"param_value": json.dumps(remaining)}, }, ) await invalidate_config_param("general_settings") - proxy_config.settings.apply_db_row("general_settings", general_settings) - if is_resource_list("general_settings", data.field_name): - stored_endpoints: Final = general_settings.get("pass_through_endpoints") + proxy_config.settings.apply_db_row("general_settings", remaining) + if is_resource_list("general_settings", field_name): + stored_endpoints: Final = remaining.get("pass_through_endpoints") await proxy_config.serve_pass_through_endpoints(stored_endpoints if isinstance(stored_endpoints, list) else ()) asyncio.create_task( - create_config_audit_log( - "general_settings", "deleted", before_general_settings, general_settings, user_api_key_dict - ) + create_config_audit_log("general_settings", "deleted", dict(stored), remaining, user_api_key_dict) ) return response diff --git a/tests/integration/configuration/test_effective_settings.py b/tests/integration/configuration/test_effective_settings.py index ca016755ef5..1b0086c619a 100644 --- a/tests/integration/configuration/test_effective_settings.py +++ b/tests/integration/configuration/test_effective_settings.py @@ -1754,4 +1754,4 @@ def test_a_stored_general_setting_no_settings_api_manages_stays_off_and_the_rest if entry["field_name"] == "store_prompts_in_spend_logs" ) assert (stored_prompts["field_value"], stored_prompts["source"]) == (True, "db") - assert "general_settings.enforce_user_param is stored in the database, but no settings API manages it" in log + assert "general_settings.enforce_user_param is stored in the database, but the proxy does not apply" in log diff --git a/tests/unit/proxy/proxy_server/test_proxy_config.py b/tests/unit/proxy/proxy_server/test_proxy_config.py index b3718028de5..a211b4ed920 100644 --- a/tests/unit/proxy/proxy_server/test_proxy_config.py +++ b/tests/unit/proxy/proxy_server/test_proxy_config.py @@ -99,7 +99,9 @@ def test_proxy_config_upserts_existing_deployment_without_duplicating_it(monkeyp @pytest.mark.asyncio -async def test_proxy_config_preserves_models_when_config_read_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: +async def test_proxy_config_preserves_models_when_config_read_fails( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: from litellm.proxy import proxy_server router = litellm.Router(model_list=[_deployment("config-deployment").to_json(exclude_none=True)]) @@ -132,6 +134,8 @@ async def test_proxy_config_keeps_database_models_and_deletes_stale_models( assert desired == frozenset({"kept-deployment"}) assert router.get_model_ids() == ["kept-deployment"] + + from tests._master_key import MASTER_KEY @@ -147,7 +151,6 @@ async def test_proxy_config_loads_lens_store_from_yaml(tmp_path, monkeypatch) -> assert is_lens_tracing_enabled(settings["tracing"], {}) is True - @pytest.mark.asyncio @pytest.mark.parametrize("shutdown_error", [False, True]) async def test_tracing_config_automatically_exports_spend_without_a_storage_dependency( @@ -173,7 +176,9 @@ async def test_tracing_config_automatically_exports_spend_without_a_storage_depe outcome: Final = pytest.raises(RuntimeError, match="shutdown failure") if shutdown_error else nullcontext() with outcome: async with manage_tracing(enabled=True, client_factory=client): - logger: Final = next(callback for callback in litellm._async_success_callback if isinstance(callback, LensExporter)) + logger: Final = next( + callback for callback in litellm._async_success_callback if isinstance(callback, LensExporter) + ) await logger.async_log_success_event( {"standard_logging_object": {"id": "response-1", "response_cost": 0.25}}, None, None, None ) @@ -2579,7 +2584,6 @@ async def test_load_config_rejects_non_boolean_deny_by_default( await ProxyConfig().load_config(router=None, config_file_path=str(config_file)) - @pytest.mark.asyncio @pytest.mark.parametrize( "yaml_value", ["files-api-2025-04-14", "[files-api-2025-04-14, 7]"], ids=["bare-string", "non-string-entry"] @@ -2599,6 +2603,7 @@ async def test_load_config_rejects_a_malformed_vertex_drop_anthropic_betas_list( with pytest.raises(ValidationError, match="vertex_ai_pass_through_drop_anthropic_betas"): await ProxyConfig().load_config(router=None, config_file_path=str(config_file)) + @pytest.mark.asyncio async def test_ProxyConfig_load_config_resolves_router_settings_plugins(tmp_path, monkeypatch): """Regression: router_settings.plugins dotted-path strings must be resolved to @@ -4372,8 +4377,8 @@ async def test_ProxyConfig__update_general_settings_ignores_a_stored_key_no_sett assert "enforce_user_param" not in proxy_server.general_settings warnings: Final = [record.getMessage() for record in caplog.records if "enforce_user_param" in record.getMessage()] assert warnings == [ - "general_settings.enforce_user_param is stored in the database, but no settings API manages it, so the " - "stored value is ignored. Set it in the config file to use it, or remove it with POST /config/field/delete." + "general_settings.enforce_user_param is stored in the database, but the proxy does not apply that stored " + "value, so it is ignored. Set it in the config file to use it, or remove it with POST /config/field/delete." ] @@ -4392,8 +4397,8 @@ async def test_ProxyConfig__update_general_settings_warns_about_an_ignored_store assert proxy_server.general_settings["enforce_user_param"] is False warnings: Final = [record.getMessage() for record in caplog.records if "enforce_user_param" in record.getMessage()] assert warnings == [ - "general_settings.enforce_user_param is stored in the database, but no settings API manages it, so the " - "stored value is ignored. The config file's value applies. Remove the stored copy with POST " + "general_settings.enforce_user_param is stored in the database, but the proxy does not apply that stored " + "value, so it is ignored. The config file's value applies. Remove the stored copy with POST " "/config/field/delete." ] @@ -5008,7 +5013,9 @@ async def test_ProxyConfig__update_config_from_db_keeps_keys_the_config_file_omi @pytest.mark.asyncio @pytest.mark.parametrize("ui_settings_already_synced", [False, True]) -async def test_ProxyConfig_add_deployment_continues_after_null_pass_through_endpoints(monkeypatch, ui_settings_already_synced): +async def test_ProxyConfig_add_deployment_continues_after_null_pass_through_endpoints( + monkeypatch, ui_settings_already_synced +): from litellm.proxy import proxy_server pc = ProxyConfig() @@ -5213,9 +5220,7 @@ def revision_test_environment(monkeypatch: pytest.MonkeyPatch) -> None: monkeypatch.delenv(key) -def _environment_variables_row( - values: Mapping[str, str | None] | None, revision: int | None -) -> SimpleNamespace | None: +def _environment_variables_row(values: Mapping[str, str | None] | None, revision: int | None) -> SimpleNamespace | None: if values is None: return None return SimpleNamespace( @@ -5401,9 +5406,7 @@ async def test_environment_variables_row_read_before_an_overlapping_newer_sync_i await newer_sync_finished.wait() older_sync: Final = asyncio.create_task( - _sync_from( - pc, _config_database(read_older_row, AsyncMock(return_value=older_row), wait_for_the_newer_sync) - ) + _sync_from(pc, _config_database(read_older_row, AsyncMock(return_value=older_row), wait_for_the_newer_sync)) ) await older_environment_row_read.wait() await _sync_from(pc, _rows_database(newer_row, newer_row)) diff --git a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py index f7f3b3a8c8b..501c551d6b8 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -1792,9 +1792,7 @@ class _DatabaseWithOneStoredCredential: @pytest.mark.asyncio -@pytest.mark.parametrize( - "encrypted_with, asks_to_migrate", [(PUBLICLY_KNOWN_KEY, True), ("sk-some-other-key", False)] -) +@pytest.mark.parametrize("encrypted_with, asks_to_migrate", [(PUBLICLY_KNOWN_KEY, True), ("sk-some-other-key", False)]) async def test_proxy_startup_asks_to_migrate_only_when_the_database_holds_values_under_the_unsafe_key( monkeypatch, tmp_path, encrypted_with, asks_to_migrate ): @@ -1877,9 +1875,7 @@ async def test_proxy_startup_names_the_config_file_that_set_the_unsafe_key(monke from litellm.proxy.auth.master_key_boot_check import UnsafeMasterKeyError from litellm.proxy.proxy_server import proxy_startup_event - config_path, announced = _boot_with_general_settings( - monkeypatch, tmp_path, {"master_key": PUBLICLY_KNOWN_KEY} - ) + config_path, announced = _boot_with_general_settings(monkeypatch, tmp_path, {"master_key": PUBLICLY_KNOWN_KEY}) with pytest.raises(UnsafeMasterKeyError): async with proxy_startup_event(FastAPI()): @@ -8104,10 +8100,18 @@ async def test_update_general_settings_db_pass_through_endpoint_overrides_yaml_e request.headers = {} request.query_params = {} - settings: Final = patch("litellm.proxy.proxy_server.general_settings", {"pass_through_endpoints": [yaml_endpoint]}) # test-quality-ok: the method reads this module global; no injection seam - yaml_endpoints: Final = patch("litellm.proxy.proxy_server.config_passthrough_endpoints", [yaml_endpoint]) # test-quality-ok: module global holding the YAML endpoints the fix merges in - initialize: Final = patch("litellm.proxy.proxy_server.initialize_pass_through_endpoints", AsyncMock()) # test-quality-ok: route registration needs the FastAPI app; auth is the observable here - master_key: Final = patch("litellm.proxy.proxy_server.master_key", MASTER_KEY) # test-quality-ok: a set master key is what makes a missing Authorization header a 401 + settings: Final = patch( + "litellm.proxy.proxy_server.general_settings", {"pass_through_endpoints": [yaml_endpoint]} + ) # test-quality-ok: the method reads this module global; no injection seam + yaml_endpoints: Final = patch( + "litellm.proxy.proxy_server.config_passthrough_endpoints", [yaml_endpoint] + ) # test-quality-ok: module global holding the YAML endpoints the fix merges in + initialize: Final = patch( + "litellm.proxy.proxy_server.initialize_pass_through_endpoints", AsyncMock() + ) # test-quality-ok: route registration needs the FastAPI app; auth is the observable here + master_key: Final = patch( + "litellm.proxy.proxy_server.master_key", MASTER_KEY + ) # test-quality-ok: a set master key is what makes a missing Authorization header a 401 with settings, yaml_endpoints, initialize, master_key: await ProxyConfig()._update_general_settings(db_general_settings={"pass_through_endpoints": [db_endpoint]}) @@ -12220,8 +12224,6 @@ async def test_update_config_field_prompt_caching_rejects_invalid(monkeypatch, f async def test_reset_config_field_restores_type_default(monkeypatch, field_name, expected_default): """Reset must restore each field's own default. Blanket None would leave the boolean flag set to None, which is not a bool and would read as neither on nor off.""" - from unittest.mock import MagicMock - import litellm.proxy.proxy_server as ps from litellm.proxy._types import ( ConfigFieldDelete, @@ -12238,9 +12240,10 @@ async def test_reset_config_field_restores_type_default(monkeypatch, field_name, async def fake_save_config(new_config=None): saved.update(new_config or {}) + fake_prisma = _fake_prisma_with_config({"store_prompts_in_spend_logs": True}) monkeypatch.setattr(ps.proxy_config, "get_config", fake_get_config) monkeypatch.setattr(ps.proxy_config, "save_config", fake_save_config) - monkeypatch.setattr(ps, "prisma_client", MagicMock()) + monkeypatch.setattr(ps, "prisma_client", fake_prisma) monkeypatch.setattr(litellm, "store_audit_logs", False) monkeypatch.setattr(litellm, field_name, "stale") @@ -12252,6 +12255,7 @@ async def test_reset_config_field_restores_type_default(monkeypatch, field_name, assert getattr(litellm, field_name) is expected_default assert field_name not in saved["litellm_settings"] + fake_prisma.db.litellm_config.upsert.assert_not_awaited() @pytest.mark.parametrize("bad_value", [0, -0.1, 1.5, True]) @@ -15470,6 +15474,90 @@ async def test_delete_config_general_settings_removes_an_ignored_stored_key_the_ assert pc.settings.unmanaged_db_keys() == () +@pytest.mark.asyncio +async def test_delete_config_general_settings_removes_a_stored_general_settings_copy_of_a_ui_litellm_field( + monkeypatch: pytest.MonkeyPatch, +) -> None: + from litellm.proxy._types import ConfigFieldDelete + from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings + + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {}}) + stored_row: Final = {"budget_rollover": True, "store_prompts_in_spend_logs": True} + pc.settings.apply_db_row("general_settings", stored_row) + fake_prisma: Final = _fake_prisma_with_config(stored_row) + + async def litellm_settings_with_rollover() -> dict[str, dict[str, bool]]: + return {"litellm_settings": {"budget_rollover": True}} + + async def discard_save(new_config: object = None) -> None: + return None + + monkeypatch.setattr(pc, "get_config", litellm_settings_with_rollover) + monkeypatch.setattr(pc, "save_config", discard_save) + monkeypatch.setattr(proxy_server_module, "proxy_config", pc) + monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) + monkeypatch.setattr(litellm, "budget_rollover", True) + + admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) + await delete_config_general_settings( + data=ConfigFieldDelete(field_name="budget_rollover", config_type="general_settings"), + user_api_key_dict=admin, + ) + + written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"]) + assert written == {"store_prompts_in_spend_logs": True} + assert litellm.budget_rollover is False + assert pc.settings.unmanaged_db_keys() == () + + +@pytest.mark.asyncio +async def test_delete_config_general_settings_refuses_an_unknown_key_when_the_stored_row_is_a_json_string( + monkeypatch: pytest.MonkeyPatch, +) -> None: + from litellm.proxy._types import ConfigFieldDelete + from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings + + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {}}) + fake_prisma: Final = _fake_prisma_with_config('{"store_prompts_in_spend_logs": true}') + monkeypatch.setattr(proxy_server_module, "proxy_config", pc) + monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) + + admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) + with pytest.raises(HTTPException) as refused: + await delete_config_general_settings( + data=ConfigFieldDelete(field_name="not_a_setting", config_type="general_settings"), + user_api_key_dict=admin, + ) + + assert refused.value.status_code == 400 + fake_prisma.db.litellm_config.upsert.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_delete_config_general_settings_removes_a_key_from_a_json_string_row( + monkeypatch: pytest.MonkeyPatch, +) -> None: + from litellm.proxy._types import ConfigFieldDelete + from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings + + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {}}) + fake_prisma: Final = _fake_prisma_with_config('{"max_request_size_mb": 42, "store_prompts_in_spend_logs": true}') + monkeypatch.setattr(proxy_server_module, "proxy_config", pc) + monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) + + admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) + await delete_config_general_settings( + data=ConfigFieldDelete(field_name="max_request_size_mb", config_type="general_settings"), + user_api_key_dict=admin, + ) + + written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"]) + assert written == {"store_prompts_in_spend_logs": True} + + @pytest.mark.asyncio async def test_delete_config_general_settings_refuses_a_key_neither_managed_nor_stored( monkeypatch: pytest.MonkeyPatch, From edc32593e9111ad546e3d05bec4115af2a39872c Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Thu, 29 Oct 2026 10:28:39 -0700 Subject: [PATCH 06/10] fix(proxy): skip a non-object general_settings row on reload and remove a stored copy of a config-owned litellm_settings field --- litellm/proxy/proxy_server.py | 18 +++++--- .../proxy/proxy_server/test_proxy_config.py | 3 -- ...test_proxy_server_endpoints_and_startup.py | 44 +++++++++++++++++++ 3 files changed, 56 insertions(+), 9 deletions(-) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 607fc2f783d..45c4ddf6f3f 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -5926,6 +5926,10 @@ class ProxyConfig: store.apply_db_row(cast(DbRow, section_name), wrote_section) await invalidate_config_param(section_name) + def config_owns(self, *, section_name: Section, key: str) -> bool: + store: Final = self._settings_stores.get(section_name) + return store is not None and store.owned_by_config(key) + def reject_config_owned_deletes(self, *, section_name: str, keys: tuple[str, ...]) -> None: """Refuse a delete of a setting the config file owns; unlike a write, the value never makes it allowed.""" store: Final = self._settings_stores.get(cast(Section, section_name)) @@ -8211,9 +8215,9 @@ class ProxyConfig: general_settings.get("maximum_spend_logs_retention_interval", "1d"), ) - async def _update_general_settings(self, db_general_settings: Mapping[str, SettingsJsonValue] | None) -> None: + async def _update_general_settings(self, db_general_settings: Mapping[str, SettingsJsonValue] | str | None) -> None: global general_settings - if db_general_settings is None: + if not isinstance(db_general_settings, Mapping): return if not isinstance(general_settings, SettingsStore): self.settings.load_yaml(_as_settings_mapping(general_settings)) @@ -20639,11 +20643,13 @@ async def delete_config_general_settings( ) if data.field_name in _GENERAL_SETTINGS_UI_LITELLM_FIELDS: - reset: Final = await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict) stored_copy: Final = await _stored_general_settings() - if stored_copy is not None and data.field_name in stored_copy: - await _remove_stored_general_setting(data.field_name, stored_copy, user_api_key_dict) - return reset + if stored_copy is None or data.field_name not in stored_copy: + return await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict) + removed: Final = await _remove_stored_general_setting(data.field_name, stored_copy, user_api_key_dict) + if proxy_config.config_owns(section_name="litellm_settings", key=data.field_name): + return removed + return await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict) stored: Final = await _stored_general_settings() diff --git a/tests/unit/proxy/proxy_server/test_proxy_config.py b/tests/unit/proxy/proxy_server/test_proxy_config.py index a211b4ed920..08c43164f47 100644 --- a/tests/unit/proxy/proxy_server/test_proxy_config.py +++ b/tests/unit/proxy/proxy_server/test_proxy_config.py @@ -4851,9 +4851,6 @@ async def test_ProxyConfig__update_general_settings_none_input_noop(): # None input returns early. result = await pc._update_general_settings(db_general_settings=None) assert result is None - # Error-style: dict() will fail on non-mapping non-None input. - with pytest.raises(TypeError): - await pc._update_general_settings(db_general_settings=12345) # type: ignore[arg-type] @pytest.mark.asyncio diff --git a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py index 501c551d6b8..cdc3887448e 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -3756,6 +3756,22 @@ async def test_db_reload_keeps_the_resolved_value_of_a_config_owned_env_referenc assert proxy_server_module.store_model_in_db is True +@pytest.mark.asyncio +async def test_db_reload_of_a_json_string_general_settings_row_reports_no_ignored_keys(monkeypatch): + from litellm.proxy import proxy_server as proxy_server_module + from litellm.proxy.proxy_server import ProxyConfig + + monkeypatch.setattr(proxy_server_module, "user_api_key_cache", MagicMock(), raising=False) + proxy_config: Final = ProxyConfig() + proxy_config.settings.load_yaml({}) + monkeypatch.setattr(proxy_server_module, "general_settings", proxy_config.settings, raising=False) + + await proxy_config._update_general_settings('{"budget_rollover": true, "master_key": "sk-stored"}') + + assert proxy_config.settings.unmanaged_db_keys() == () + assert proxy_config.settings.source("master_key") != "db" + + def test_max_ui_session_budget_default_is_one_dollar(): """LIT-4662: the dashboard session budget default is a product decision; the old 0.25 default locked admins out of auto router Test Connection and the @@ -15511,6 +15527,34 @@ async def test_delete_config_general_settings_removes_a_stored_general_settings_ assert pc.settings.unmanaged_db_keys() == () +@pytest.mark.asyncio +async def test_delete_config_general_settings_removes_a_stored_copy_of_a_ui_litellm_field_the_config_file_sets( + monkeypatch: pytest.MonkeyPatch, +) -> None: + from litellm.proxy._types import ConfigFieldDelete + from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings + + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {}, "litellm_settings": {"budget_rollover": True}}) + stored_row: Final = {"budget_rollover": True, "store_prompts_in_spend_logs": True} + pc.settings.apply_db_row("general_settings", stored_row) + fake_prisma: Final = _fake_prisma_with_config(stored_row) + monkeypatch.setattr(proxy_server_module, "proxy_config", pc) + monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) + monkeypatch.setattr(litellm, "budget_rollover", True) + + admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) + await delete_config_general_settings( + data=ConfigFieldDelete(field_name="budget_rollover", config_type="general_settings"), + user_api_key_dict=admin, + ) + + written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"]) + assert written == {"store_prompts_in_spend_logs": True} + assert litellm.budget_rollover is True + assert pc.settings.unmanaged_db_keys() == () + + @pytest.mark.asyncio async def test_delete_config_general_settings_refuses_an_unknown_key_when_the_stored_row_is_a_json_string( monkeypatch: pytest.MonkeyPatch, From 2dc56dd784af2dc288d62455209ef88bcaff29c3 Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Thu, 29 Oct 2026 12:17:00 -0700 Subject: [PATCH 07/10] fix(proxy): say the config file applies for a stored copy of a UI field config.yaml sets under litellm_settings --- litellm/proxy/proxy_server.py | 7 +++++- .../proxy/proxy_server/test_proxy_config.py | 23 +++++++++++++++++-- ...test_proxy_server_endpoints_and_startup.py | 4 +++- 3 files changed, 30 insertions(+), 4 deletions(-) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 45c4ddf6f3f..351f19e1638 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -8509,11 +8509,16 @@ class ProxyConfig: "is ignored. %s", key, "The config file's value applies. Remove the stored copy with POST /config/field/delete." - if self.settings.owned_by_config(key) + if self._config_sets_ignored_db_key(key) else "Set it in the config file to use it, or remove it with POST /config/field/delete.", ) self._warned_unmanaged_keys = unmanaged + def _config_sets_ignored_db_key(self, key: str) -> bool: + return self.settings.owned_by_config(key) or ( + key in _GENERAL_SETTINGS_UI_LITELLM_FIELDS and self.config_owns(section_name="litellm_settings", key=key) + ) + def _prepared_db_settings_values(self, section: Section, value: object) -> Mapping[str, SettingsJsonValue]: scrubbed: Final = _scrub_db_overlay_remote_module_loads(section=section, db_value=value) return _as_settings_mapping(scrubbed) diff --git a/tests/unit/proxy/proxy_server/test_proxy_config.py b/tests/unit/proxy/proxy_server/test_proxy_config.py index 08c43164f47..a4f81c1645b 100644 --- a/tests/unit/proxy/proxy_server/test_proxy_config.py +++ b/tests/unit/proxy/proxy_server/test_proxy_config.py @@ -4403,6 +4403,25 @@ async def test_ProxyConfig__update_general_settings_warns_about_an_ignored_store ] +@pytest.mark.asyncio +async def test_ProxyConfig__update_general_settings_says_the_config_file_applies_for_a_stored_ui_field_it_sets( + monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture +) -> None: + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {}, "litellm_settings": {"budget_rollover": True}}) + monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", pc.settings) + + with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"): + await pc._update_general_settings({"budget_rollover": False}) + + warnings: Final = [record.getMessage() for record in caplog.records if "budget_rollover" in record.getMessage()] + assert warnings == [ + "general_settings.budget_rollover is stored in the database, but the proxy does not apply that stored " + "value, so it is ignored. The config file's value applies. Remove the stored copy with POST " + "/config/field/delete." + ] + + def _paused_scheduler(monkeypatch): from apscheduler.schedulers.asyncio import AsyncIOScheduler @@ -5011,8 +5030,8 @@ async def test_ProxyConfig__update_config_from_db_keeps_keys_the_config_file_omi @pytest.mark.asyncio @pytest.mark.parametrize("ui_settings_already_synced", [False, True]) async def test_ProxyConfig_add_deployment_continues_after_null_pass_through_endpoints( - monkeypatch, ui_settings_already_synced -): + monkeypatch: pytest.MonkeyPatch, ui_settings_already_synced: bool +) -> None: from litellm.proxy import proxy_server pc = ProxyConfig() diff --git a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py index cdc3887448e..f33a38df00d 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -3757,7 +3757,9 @@ async def test_db_reload_keeps_the_resolved_value_of_a_config_owned_env_referenc @pytest.mark.asyncio -async def test_db_reload_of_a_json_string_general_settings_row_reports_no_ignored_keys(monkeypatch): +async def test_db_reload_of_a_json_string_general_settings_row_reports_no_ignored_keys( + monkeypatch: pytest.MonkeyPatch, +) -> None: from litellm.proxy import proxy_server as proxy_server_module from litellm.proxy.proxy_server import ProxyConfig From fb915ff85e0821da921edc5ca9da8543f8b399d1 Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Thu, 29 Oct 2026 14:17:04 -0700 Subject: [PATCH 08/10] fix(proxy): leave a string general_settings row untouched on delete, warn once about it, and answer a stored-copy removal with a message --- litellm/proxy/proxy_server.py | 26 ++++++++++++------- .../proxy/proxy_server/test_proxy_config.py | 20 ++++++++++++++ ...test_proxy_server_endpoints_and_startup.py | 23 +++++++++------- 3 files changed, 50 insertions(+), 19 deletions(-) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 351f19e1638..fbd73f947fe 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -5722,6 +5722,7 @@ class ProxyConfig: self._sso_environment_removals: frozenset[str] = frozenset() self._warned_shadowed_keys: frozenset[tuple[Section, str]] = frozenset() self._warned_unmanaged_keys: frozenset[str] = frozenset() + self._warned_unreadable_db_general_settings: bool = False self._db_config_callback_entries: Mapping[tuple[str, str], _DbCallbackRegistration] = MappingProxyType({}) self._settings_stores: Final[Mapping[Section, SettingsStore]] = MappingProxyType( { @@ -8217,7 +8218,10 @@ class ProxyConfig: async def _update_general_settings(self, db_general_settings: Mapping[str, SettingsJsonValue] | str | None) -> None: global general_settings + if db_general_settings is None: + return if not isinstance(db_general_settings, Mapping): + self._warn_about_unreadable_db_general_settings() return if not isinstance(general_settings, SettingsStore): self.settings.load_yaml(_as_settings_mapping(general_settings)) @@ -8514,6 +8518,15 @@ class ProxyConfig: ) self._warned_unmanaged_keys = unmanaged + def _warn_about_unreadable_db_general_settings(self) -> None: + if self._warned_unreadable_db_general_settings: + return + verbose_proxy_logger.warning( + "general_settings is stored in the database as something other than a JSON object, so the proxy " + "ignores every stored general setting." + ) + self._warned_unreadable_db_general_settings = True + def _config_sets_ignored_db_key(self, key: str) -> bool: return self.settings.owned_by_config(key) or ( key in _GENERAL_SETTINGS_UI_LITELLM_FIELDS and self.config_owns(section_name="litellm_settings", key=key) @@ -20651,9 +20664,9 @@ async def delete_config_general_settings( stored_copy: Final = await _stored_general_settings() if stored_copy is None or data.field_name not in stored_copy: return await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict) - removed: Final = await _remove_stored_general_setting(data.field_name, stored_copy, user_api_key_dict) + await _remove_stored_general_setting(data.field_name, stored_copy, user_api_key_dict) if proxy_config.config_owns(section_name="litellm_settings", key=data.field_name): - return removed + return {"message": f"Field {data.field_name} removed", "status": "success"} return await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict) stored: Final = await _stored_general_settings() @@ -20679,14 +20692,9 @@ async def delete_config_general_settings( async def _stored_general_settings() -> Mapping[str, SettingsJsonValue] | None: config_table: Final[TableActions[_ConfigParamValueRow]] = _config_param_table(prisma_client) row: Final = await config_table.find_first(where={"param_name": "general_settings"}) - if row is None or row.param_value is None: + if row is None or not isinstance(row.param_value, Mapping): return None - value: Final = ( - cast(object, json.loads(row.param_value)) # cast-ok: json.loads is untyped; the row is opaque JSON - if isinstance(row.param_value, str) - else row.param_value - ) - return _SETTINGS_MAPPING.validate_python(value) if isinstance(value, Mapping) else None + return _SETTINGS_MAPPING.validate_python(row.param_value) async def _remove_stored_general_setting( diff --git a/tests/unit/proxy/proxy_server/test_proxy_config.py b/tests/unit/proxy/proxy_server/test_proxy_config.py index a4f81c1645b..b7959b00f03 100644 --- a/tests/unit/proxy/proxy_server/test_proxy_config.py +++ b/tests/unit/proxy/proxy_server/test_proxy_config.py @@ -4422,6 +4422,26 @@ async def test_ProxyConfig__update_general_settings_says_the_config_file_applies ] +@pytest.mark.asyncio +async def test_ProxyConfig__update_general_settings_warns_once_about_a_stored_row_that_is_not_an_object( + monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture +) -> None: + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {}}) + monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", pc.settings) + + with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"): + await pc._update_general_settings(None) + await pc._update_general_settings('{"enforce_user_param": true}') + await pc._update_general_settings('{"enforce_user_param": true}') + + warnings: Final = [record.getMessage() for record in caplog.records if "JSON object" in record.getMessage()] + assert warnings == [ + "general_settings is stored in the database as something other than a JSON object, so the proxy ignores " + "every stored general setting." + ] + + def _paused_scheduler(monkeypatch): from apscheduler.schedulers.asyncio import AsyncIOScheduler diff --git a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py index f33a38df00d..06234de8723 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -15546,13 +15546,14 @@ async def test_delete_config_general_settings_removes_a_stored_copy_of_a_ui_lite monkeypatch.setattr(litellm, "budget_rollover", True) admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) - await delete_config_general_settings( + response: Final = await delete_config_general_settings( data=ConfigFieldDelete(field_name="budget_rollover", config_type="general_settings"), user_api_key_dict=admin, ) written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"]) assert written == {"store_prompts_in_spend_logs": True} + assert response == {"message": "Field budget_rollover removed", "status": "success"} assert litellm.budget_rollover is True assert pc.settings.unmanaged_db_keys() == () @@ -15582,26 +15583,28 @@ async def test_delete_config_general_settings_refuses_an_unknown_key_when_the_st @pytest.mark.asyncio -async def test_delete_config_general_settings_removes_a_key_from_a_json_string_row( - monkeypatch: pytest.MonkeyPatch, +@pytest.mark.parametrize("stored_row", ['{"max_request_size_mb": 42, "store_prompts_in_spend_logs": true}', "not json"]) +async def test_delete_config_general_settings_leaves_a_string_row_untouched( + monkeypatch: pytest.MonkeyPatch, stored_row: str ) -> None: from litellm.proxy._types import ConfigFieldDelete from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings pc: Final = ProxyConfig() pc._load_yaml_settings_stores({"general_settings": {}}) - fake_prisma: Final = _fake_prisma_with_config('{"max_request_size_mb": 42, "store_prompts_in_spend_logs": true}') + fake_prisma: Final = _fake_prisma_with_config(stored_row) monkeypatch.setattr(proxy_server_module, "proxy_config", pc) monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) - await delete_config_general_settings( - data=ConfigFieldDelete(field_name="max_request_size_mb", config_type="general_settings"), - user_api_key_dict=admin, - ) + with pytest.raises(HTTPException) as refused: + await delete_config_general_settings( + data=ConfigFieldDelete(field_name="max_request_size_mb", config_type="general_settings"), + user_api_key_dict=admin, + ) - written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"]) - assert written == {"store_prompts_in_spend_logs": True} + assert refused.value.status_code == 400 + fake_prisma.db.litellm_config.upsert.assert_not_awaited() @pytest.mark.asyncio From 9d34d7acc0746427587e5ddf38184a7a4d08b8c1 Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Thu, 29 Oct 2026 17:08:06 -0700 Subject: [PATCH 09/10] fix(proxy): keep pass-through routes when the stored general_settings row is not an object, warn again on each episode, and leave Admin UI field copies alone --- litellm/proxy/proxy_server.py | 76 +++++----- .../proxy/proxy_server/test_proxy_config.py | 50 +++++-- ...test_proxy_server_endpoints_and_startup.py | 131 ++++++++---------- 3 files changed, 133 insertions(+), 124 deletions(-) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index fbd73f947fe..1307fbf2fbc 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -5554,6 +5554,10 @@ def _reload_settings_store(section: Section, store: SettingsStore, section_confi store["pass_through_endpoints"] = serving_pass_throughs +def _general_settings_row_is_readable(row: _ConfigParamValueRow | None) -> bool: + return row is None or row.param_value is None or isinstance(row.param_value, Mapping) + + def _db_managed_general_settings_keys() -> frozenset[str]: return frozenset((*ConfigGeneralSettings.model_fields, *_CLEANUP_SCHEDULE_KEYS, "allowed_ips", "email_settings")) @@ -5927,10 +5931,6 @@ class ProxyConfig: store.apply_db_row(cast(DbRow, section_name), wrote_section) await invalidate_config_param(section_name) - def config_owns(self, *, section_name: Section, key: str) -> bool: - store: Final = self._settings_stores.get(section_name) - return store is not None and store.owned_by_config(key) - def reject_config_owned_deletes(self, *, section_name: str, keys: tuple[str, ...]) -> None: """Refuse a delete of a setting the config file owns; unlike a write, the value never makes it allowed.""" store: Final = self._settings_stores.get(cast(Section, section_name)) @@ -8223,6 +8223,7 @@ class ProxyConfig: if not isinstance(db_general_settings, Mapping): self._warn_about_unreadable_db_general_settings() return + self._warned_unreadable_db_general_settings = False if not isinstance(general_settings, SettingsStore): self.settings.load_yaml(_as_settings_mapping(general_settings)) cache_size_was_db: Final = self.settings.source("user_api_key_cache_max_size") == "db" @@ -8506,14 +8507,16 @@ class ProxyConfig: self._warned_shadowed_keys = shadowed def _warn_about_unmanaged_db_settings(self) -> None: - unmanaged: Final = frozenset(self.settings.unmanaged_db_keys()) + unmanaged: Final = frozenset( + key for key in self.settings.unmanaged_db_keys() if key not in _GENERAL_SETTINGS_UI_LITELLM_FIELDS + ) for key in sorted(unmanaged - self._warned_unmanaged_keys): verbose_proxy_logger.warning( "general_settings.%s is stored in the database, but the proxy does not apply that stored value, so it " "is ignored. %s", key, "The config file's value applies. Remove the stored copy with POST /config/field/delete." - if self._config_sets_ignored_db_key(key) + if self.settings.owned_by_config(key) else "Set it in the config file to use it, or remove it with POST /config/field/delete.", ) self._warned_unmanaged_keys = unmanaged @@ -8527,11 +8530,6 @@ class ProxyConfig: ) self._warned_unreadable_db_general_settings = True - def _config_sets_ignored_db_key(self, key: str) -> bool: - return self.settings.owned_by_config(key) or ( - key in _GENERAL_SETTINGS_UI_LITELLM_FIELDS and self.config_owns(section_name="litellm_settings", key=key) - ) - def _prepared_db_settings_values(self, section: Section, value: object) -> Mapping[str, SettingsJsonValue]: scrubbed: Final = _scrub_db_overlay_remote_module_loads(section=section, db_value=value) return _as_settings_mapping(scrubbed) @@ -8698,7 +8696,10 @@ class ProxyConfig: ) # initialize vector stores, guardrails, etc. table in db - await self._init_non_llm_objects_in_db(prisma_client=prisma_client) + await self._init_non_llm_objects_in_db( + prisma_client=prisma_client, + refresh_pass_through_endpoints=_general_settings_row_is_readable(db_general_settings), + ) except Exception as e: verbose_proxy_logger.exception("litellm.proxy.proxy_server.py::ProxyConfig:add_deployment - %s", e) @@ -8766,7 +8767,9 @@ class ProxyConfig: except Exception as e: # noqa: BLE001 # best-effort: a failing stop must not break proxy shutdown verbose_proxy_logger.error("Error stopping auth cache invalidation subscriber: %s", e) - async def _init_non_llm_objects_in_db(self, prisma_client: PrismaClient): + async def _init_non_llm_objects_in_db( + self, prisma_client: PrismaClient, *, refresh_pass_through_endpoints: bool = True + ): """ Use this to read non-llm objects from the db and initialize them @@ -8790,7 +8793,7 @@ class ProxyConfig: if self._should_load_db_object(object_type="agents"): await self._init_agents_in_db(prisma_client=prisma_client) - if self._should_load_db_object(object_type="pass_through_endpoints"): + if refresh_pass_through_endpoints and self._should_load_db_object(object_type="pass_through_endpoints"): await self._init_pass_through_endpoints_in_db() if self._should_load_db_object(object_type="prompts"): @@ -20433,9 +20436,7 @@ async def _persist_general_settings_ui_litellm_field( return {"message": f"Field {field_name} updated", "status": "success"} -async def _reset_general_settings_ui_litellm_field( - field_name: str, user_api_key_dict: UserAPIKeyAuth -) -> dict[str, str]: +async def _reset_general_settings_ui_litellm_field(field_name: str, user_api_key_dict: UserAPIKeyAuth) -> dict: default_value: Final = _general_settings_ui_litellm_default(_GENERAL_SETTINGS_UI_LITELLM_FIELDS[field_name]) proxy_config.reject_config_owned_writes(section_name="litellm_settings", changed_keys={field_name: default_value}) config: Final = await proxy_config.get_config() @@ -20661,15 +20662,15 @@ async def delete_config_general_settings( ) if data.field_name in _GENERAL_SETTINGS_UI_LITELLM_FIELDS: - stored_copy: Final = await _stored_general_settings() - if stored_copy is None or data.field_name not in stored_copy: - return await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict) - await _remove_stored_general_setting(data.field_name, stored_copy, user_api_key_dict) - if proxy_config.config_owns(section_name="litellm_settings", key=data.field_name): - return {"message": f"Field {data.field_name} removed", "status": "success"} return await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict) - stored: Final = await _stored_general_settings() + config_table: Final[TableActions[_ConfigParamValueRow]] = _config_param_table(prisma_client) + stored_row: Final = await config_table.find_first(where={"param_name": "general_settings"}) + stored: Final = ( + _SETTINGS_MAPPING.validate_python(stored_row.param_value) + if stored_row is not None and isinstance(stored_row.param_value, Mapping) + else None + ) if data.field_name not in ConfigGeneralSettings.model_fields and (stored is None or data.field_name not in stored): raise HTTPException( @@ -20683,24 +20684,17 @@ async def delete_config_general_settings( if stored is None: raise HTTPException( status_code=400, - detail={"error": f"Field name={data.field_name} not in config"}, + detail={ + "error": ( + f"Field name={data.field_name} not in config" + if _general_settings_row_is_readable(stored_row) + else "general_settings is stored in the database as something other than a JSON object, so no " + "field can be removed from it" + ) + }, ) - return await _remove_stored_general_setting(data.field_name, stored, user_api_key_dict) - - -async def _stored_general_settings() -> Mapping[str, SettingsJsonValue] | None: - config_table: Final[TableActions[_ConfigParamValueRow]] = _config_param_table(prisma_client) - row: Final = await config_table.find_first(where={"param_name": "general_settings"}) - if row is None or not isinstance(row.param_value, Mapping): - return None - return _SETTINGS_MAPPING.validate_python(row.param_value) - - -async def _remove_stored_general_setting( - field_name: str, stored: Mapping[str, SettingsJsonValue], user_api_key_dict: UserAPIKeyAuth -) -> _ConfigParamValueRow: - remaining: Final = {key: value for key, value in stored.items() if key != field_name} + remaining: Final = {key: value for key, value in stored.items() if key != data.field_name} response: Final = await ConfigRepository(prisma_client).table.upsert( where={"param_name": "general_settings"}, data={ @@ -20713,7 +20707,7 @@ async def _remove_stored_general_setting( ) await invalidate_config_param("general_settings") proxy_config.settings.apply_db_row("general_settings", remaining) - if is_resource_list("general_settings", field_name): + if is_resource_list("general_settings", data.field_name): stored_endpoints: Final = remaining.get("pass_through_endpoints") await proxy_config.serve_pass_through_endpoints(stored_endpoints if isinstance(stored_endpoints, list) else ()) asyncio.create_task( diff --git a/tests/unit/proxy/proxy_server/test_proxy_config.py b/tests/unit/proxy/proxy_server/test_proxy_config.py index b7959b00f03..133bfba54d3 100644 --- a/tests/unit/proxy/proxy_server/test_proxy_config.py +++ b/tests/unit/proxy/proxy_server/test_proxy_config.py @@ -4404,26 +4404,22 @@ async def test_ProxyConfig__update_general_settings_warns_about_an_ignored_store @pytest.mark.asyncio -async def test_ProxyConfig__update_general_settings_says_the_config_file_applies_for_a_stored_ui_field_it_sets( +async def test_ProxyConfig__update_general_settings_does_not_warn_about_a_stored_copy_of_an_admin_ui_field( monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture ) -> None: pc: Final = ProxyConfig() - pc._load_yaml_settings_stores({"general_settings": {}, "litellm_settings": {"budget_rollover": True}}) + pc._load_yaml_settings_stores({"general_settings": {}}) monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", pc.settings) with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"): - await pc._update_general_settings({"budget_rollover": False}) + await pc._update_general_settings({"budget_rollover": True, "enforce_user_param": True}) - warnings: Final = [record.getMessage() for record in caplog.records if "budget_rollover" in record.getMessage()] - assert warnings == [ - "general_settings.budget_rollover is stored in the database, but the proxy does not apply that stored " - "value, so it is ignored. The config file's value applies. Remove the stored copy with POST " - "/config/field/delete." - ] + warned: Final = [record.getMessage().split(" ")[0] for record in caplog.records if "is ignored" in record.getMessage()] + assert warned == ["general_settings.enforce_user_param"] @pytest.mark.asyncio -async def test_ProxyConfig__update_general_settings_warns_once_about_a_stored_row_that_is_not_an_object( +async def test_ProxyConfig__update_general_settings_warns_once_each_time_the_stored_row_stops_being_an_object( monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture ) -> None: pc: Final = ProxyConfig() @@ -4432,14 +4428,16 @@ async def test_ProxyConfig__update_general_settings_warns_once_about_a_stored_ro with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"): await pc._update_general_settings(None) - await pc._update_general_settings('{"enforce_user_param": true}') - await pc._update_general_settings('{"enforce_user_param": true}') + await pc._update_general_settings('{"store_prompts_in_spend_logs": true}') + await pc._update_general_settings('{"store_prompts_in_spend_logs": true}') + await pc._update_general_settings({"store_prompts_in_spend_logs": True}) + await pc._update_general_settings('{"store_prompts_in_spend_logs": true}') warnings: Final = [record.getMessage() for record in caplog.records if "JSON object" in record.getMessage()] assert warnings == [ "general_settings is stored in the database as something other than a JSON object, so the proxy ignores " "every stored general setting." - ] + ] * 2 def _paused_scheduler(monkeypatch): @@ -5077,6 +5075,32 @@ async def test_ProxyConfig_add_deployment_continues_after_null_pass_through_endp assert settings_refresh.await_count == (0 if ui_settings_already_synced else 1) +@pytest.mark.asyncio +@pytest.mark.parametrize( + "stored_row, rebuilds_routes", + [({"pass_through_endpoints": []}, True), ('{"pass_through_endpoints": []}', False), ([], False)], + ids=["object", "json-string", "array"], +) +async def test_ProxyConfig_add_deployment_rebuilds_pass_through_routes_only_from_an_object_general_settings_row( + monkeypatch: pytest.MonkeyPatch, stored_row: object, rebuilds_routes: bool +) -> None: + from litellm.proxy import proxy_server + from litellm.proxy.pass_through_endpoints import pass_through_endpoints + + pc: Final = ProxyConfig() + rebuild_routes: Final = AsyncMock() + monkeypatch.setattr(proxy_server, "general_settings", {}) + monkeypatch.setattr(proxy_server, "prefetch_config_params", AsyncMock()) + monkeypatch.setattr(proxy_server, "get_config_param", AsyncMock(return_value=SimpleNamespace(param_value=stored_row))) + monkeypatch.setattr(pass_through_endpoints, "initialize_pass_through_endpoints_in_db", rebuild_routes) + monkeypatch.setattr(pc, "_should_load_db_object", lambda *, object_type: object_type == "pass_through_endpoints") + monkeypatch.setattr(pc, "get_credentials", AsyncMock()) + + await pc.add_deployment(prisma_client=MagicMock(), proxy_logging_obj=MagicMock(), ui_settings_already_synced=True) + + assert rebuild_routes.await_count == (1 if rebuilds_routes else 0) + + # --------------------------------------------------------------------------- # ProxyConfig._update_config_from_db # --------------------------------------------------------------------------- diff --git a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py index 06234de8723..a6f479c104e 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -12242,6 +12242,8 @@ async def test_update_config_field_prompt_caching_rejects_invalid(monkeypatch, f async def test_reset_config_field_restores_type_default(monkeypatch, field_name, expected_default): """Reset must restore each field's own default. Blanket None would leave the boolean flag set to None, which is not a bool and would read as neither on nor off.""" + from unittest.mock import MagicMock + import litellm.proxy.proxy_server as ps from litellm.proxy._types import ( ConfigFieldDelete, @@ -12258,10 +12260,9 @@ async def test_reset_config_field_restores_type_default(monkeypatch, field_name, async def fake_save_config(new_config=None): saved.update(new_config or {}) - fake_prisma = _fake_prisma_with_config({"store_prompts_in_spend_logs": True}) monkeypatch.setattr(ps.proxy_config, "get_config", fake_get_config) monkeypatch.setattr(ps.proxy_config, "save_config", fake_save_config) - monkeypatch.setattr(ps, "prisma_client", fake_prisma) + monkeypatch.setattr(ps, "prisma_client", MagicMock()) monkeypatch.setattr(litellm, "store_audit_logs", False) monkeypatch.setattr(litellm, field_name, "stale") @@ -12273,7 +12274,6 @@ async def test_reset_config_field_restores_type_default(monkeypatch, field_name, assert getattr(litellm, field_name) is expected_default assert field_name not in saved["litellm_settings"] - fake_prisma.db.litellm_config.upsert.assert_not_awaited() @pytest.mark.parametrize("bad_value", [0, -0.1, 1.5, True]) @@ -15465,6 +15465,57 @@ async def test_delete_config_general_settings_removes_a_stored_key_no_settings_a assert pc.settings.unmanaged_db_keys() == () +@pytest.mark.asyncio +async def test_delete_config_general_settings_stops_serving_the_removed_pass_through_routes( + monkeypatch: pytest.MonkeyPatch, +) -> None: + from fastapi import FastAPI + from starlette.routing import Route + + from litellm.proxy._types import ConfigFieldDelete + from litellm.proxy.pass_through_endpoints.pass_through_endpoints import _registered_pass_through_routes + from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings + from litellm.types.passthrough_endpoints.pass_through_endpoints import LITELLM_PASS_THROUGH_ENDPOINT_MARKER + + endpoint: Final = {"id": "stored-route", "path": "/stored-route", "target": "http://example.com"} + stored_row: Final = {"pass_through_endpoints": [endpoint], "store_prompts_in_spend_logs": True} + app: Final = FastAPI() + monkeypatch.setattr(proxy_server_module, "app", app) + monkeypatch.setattr(proxy_server_module, "premium_user", True) + monkeypatch.setattr(proxy_server_module, "config_passthrough_endpoints", None) + pc: Final = ProxyConfig() + pc._load_yaml_settings_stores({"general_settings": {}}) + pc.settings.apply_db_row("general_settings", stored_row) + monkeypatch.setattr(proxy_server_module, "proxy_config", pc) + monkeypatch.setattr(proxy_server_module, "prisma_client", _fake_prisma_with_config(stored_row)) + + def served_paths() -> frozenset[str]: + return frozenset( + route.path + for route in app.router.routes + if isinstance(route, Route) and getattr(route.endpoint, LITELLM_PASS_THROUGH_ENDPOINT_MARKER, False) is True + ) + + saved_registry: Final = dict(_registered_pass_through_routes) + try: + _registered_pass_through_routes.clear() + await pc.serve_pass_through_endpoints([endpoint]) + served_before: Final = served_paths() + await delete_config_general_settings( + data=ConfigFieldDelete(field_name="pass_through_endpoints", config_type="general_settings"), + user_api_key_dict=UserAPIKeyAuth( + api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN + ), + ) + served_after: Final = served_paths() + finally: + _registered_pass_through_routes.clear() + _registered_pass_through_routes.update(saved_registry) + + assert "/stored-route" in served_before + assert "/stored-route" not in served_after + + @pytest.mark.asyncio async def test_delete_config_general_settings_removes_an_ignored_stored_key_the_config_file_also_sets( monkeypatch: pytest.MonkeyPatch, @@ -15492,72 +15543,6 @@ async def test_delete_config_general_settings_removes_an_ignored_stored_key_the_ assert pc.settings.unmanaged_db_keys() == () -@pytest.mark.asyncio -async def test_delete_config_general_settings_removes_a_stored_general_settings_copy_of_a_ui_litellm_field( - monkeypatch: pytest.MonkeyPatch, -) -> None: - from litellm.proxy._types import ConfigFieldDelete - from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings - - pc: Final = ProxyConfig() - pc._load_yaml_settings_stores({"general_settings": {}}) - stored_row: Final = {"budget_rollover": True, "store_prompts_in_spend_logs": True} - pc.settings.apply_db_row("general_settings", stored_row) - fake_prisma: Final = _fake_prisma_with_config(stored_row) - - async def litellm_settings_with_rollover() -> dict[str, dict[str, bool]]: - return {"litellm_settings": {"budget_rollover": True}} - - async def discard_save(new_config: object = None) -> None: - return None - - monkeypatch.setattr(pc, "get_config", litellm_settings_with_rollover) - monkeypatch.setattr(pc, "save_config", discard_save) - monkeypatch.setattr(proxy_server_module, "proxy_config", pc) - monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) - monkeypatch.setattr(litellm, "budget_rollover", True) - - admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) - await delete_config_general_settings( - data=ConfigFieldDelete(field_name="budget_rollover", config_type="general_settings"), - user_api_key_dict=admin, - ) - - written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"]) - assert written == {"store_prompts_in_spend_logs": True} - assert litellm.budget_rollover is False - assert pc.settings.unmanaged_db_keys() == () - - -@pytest.mark.asyncio -async def test_delete_config_general_settings_removes_a_stored_copy_of_a_ui_litellm_field_the_config_file_sets( - monkeypatch: pytest.MonkeyPatch, -) -> None: - from litellm.proxy._types import ConfigFieldDelete - from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings - - pc: Final = ProxyConfig() - pc._load_yaml_settings_stores({"general_settings": {}, "litellm_settings": {"budget_rollover": True}}) - stored_row: Final = {"budget_rollover": True, "store_prompts_in_spend_logs": True} - pc.settings.apply_db_row("general_settings", stored_row) - fake_prisma: Final = _fake_prisma_with_config(stored_row) - monkeypatch.setattr(proxy_server_module, "proxy_config", pc) - monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) - monkeypatch.setattr(litellm, "budget_rollover", True) - - admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) - response: Final = await delete_config_general_settings( - data=ConfigFieldDelete(field_name="budget_rollover", config_type="general_settings"), - user_api_key_dict=admin, - ) - - written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"]) - assert written == {"store_prompts_in_spend_logs": True} - assert response == {"message": "Field budget_rollover removed", "status": "success"} - assert litellm.budget_rollover is True - assert pc.settings.unmanaged_db_keys() == () - - @pytest.mark.asyncio async def test_delete_config_general_settings_refuses_an_unknown_key_when_the_stored_row_is_a_json_string( monkeypatch: pytest.MonkeyPatch, @@ -15603,7 +15588,13 @@ async def test_delete_config_general_settings_leaves_a_string_row_untouched( user_api_key_dict=admin, ) - assert refused.value.status_code == 400 + assert (refused.value.status_code, refused.value.detail) == ( + 400, + { + "error": "general_settings is stored in the database as something other than a JSON object, so no field " + "can be removed from it" + }, + ) fake_prisma.db.litellm_config.upsert.assert_not_awaited() From 351a60d924e9579bd6cd97ee78f057f6cbb7a4cf Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Thu, 29 Oct 2026 19:01:46 -0700 Subject: [PATCH 10/10] fix(proxy): say the row shape for every delete on a non-object general_settings row --- litellm/proxy/proxy_server.py | 18 ++++++----- ...test_proxy_server_endpoints_and_startup.py | 31 +++---------------- 2 files changed, 14 insertions(+), 35 deletions(-) diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 1307fbf2fbc..3557b2f85fa 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -20672,6 +20672,15 @@ async def delete_config_general_settings( else None ) + if not _general_settings_row_is_readable(stored_row): + raise HTTPException( + status_code=400, + detail={ + "error": "general_settings is stored in the database as something other than a JSON object, so no " + "field can be removed from it" + }, + ) + if data.field_name not in ConfigGeneralSettings.model_fields and (stored is None or data.field_name not in stored): raise HTTPException( status_code=400, @@ -20684,14 +20693,7 @@ async def delete_config_general_settings( if stored is None: raise HTTPException( status_code=400, - detail={ - "error": ( - f"Field name={data.field_name} not in config" - if _general_settings_row_is_readable(stored_row) - else "general_settings is stored in the database as something other than a JSON object, so no " - "field can be removed from it" - ) - }, + detail={"error": f"Field name={data.field_name} not in config"}, ) remaining: Final = {key: value for key, value in stored.items() if key != data.field_name} diff --git a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py index a6f479c104e..b08c84b1ff6 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -15544,33 +15544,10 @@ async def test_delete_config_general_settings_removes_an_ignored_stored_key_the_ @pytest.mark.asyncio -async def test_delete_config_general_settings_refuses_an_unknown_key_when_the_stored_row_is_a_json_string( - monkeypatch: pytest.MonkeyPatch, -) -> None: - from litellm.proxy._types import ConfigFieldDelete - from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings - - pc: Final = ProxyConfig() - pc._load_yaml_settings_stores({"general_settings": {}}) - fake_prisma: Final = _fake_prisma_with_config('{"store_prompts_in_spend_logs": true}') - monkeypatch.setattr(proxy_server_module, "proxy_config", pc) - monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma) - - admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) - with pytest.raises(HTTPException) as refused: - await delete_config_general_settings( - data=ConfigFieldDelete(field_name="not_a_setting", config_type="general_settings"), - user_api_key_dict=admin, - ) - - assert refused.value.status_code == 400 - fake_prisma.db.litellm_config.upsert.assert_not_awaited() - - -@pytest.mark.asyncio -@pytest.mark.parametrize("stored_row", ['{"max_request_size_mb": 42, "store_prompts_in_spend_logs": true}', "not json"]) +@pytest.mark.parametrize("stored_row", ['{"max_request_size_mb": 42, "disable_custom_api_keys": true}', "not json"]) +@pytest.mark.parametrize("field_name", ["max_request_size_mb", "disable_custom_api_keys", "not_a_setting"]) async def test_delete_config_general_settings_leaves_a_string_row_untouched( - monkeypatch: pytest.MonkeyPatch, stored_row: str + monkeypatch: pytest.MonkeyPatch, stored_row: str, field_name: str ) -> None: from litellm.proxy._types import ConfigFieldDelete from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings @@ -15584,7 +15561,7 @@ async def test_delete_config_general_settings_leaves_a_string_row_untouched( admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN) with pytest.raises(HTTPException) as refused: await delete_config_general_settings( - data=ConfigFieldDelete(field_name="max_request_size_mb", config_type="general_settings"), + data=ConfigFieldDelete(field_name=field_name, config_type="general_settings"), user_api_key_dict=admin, )