diff --git a/litellm/proxy/common_utils/callback_config_validation.py b/litellm/proxy/common_utils/callback_config_validation.py index 2760e9f0546..b18598dc860 100644 --- a/litellm/proxy/common_utils/callback_config_validation.py +++ b/litellm/proxy/common_utils/callback_config_validation.py @@ -6,14 +6,14 @@ per-integration checks here. """ import math -from collections.abc import Callable, Mapping, Sequence +from collections.abc import Callable, Iterator, Mapping, Sequence from types import MappingProxyType from typing import Final, cast # noqa: TID251 # preserve arbitrary keys from validated callback mappings from pydantic import TypeAdapter import litellm -from litellm.types.utils import CAPTURE_MESSAGE_CONTENT_VAR, EXCLUDED_SERVICES_VAR +from litellm.types.utils import CAPTURE_MESSAGE_CONTENT_VAR, EXCLUDED_SERVICES_VAR, StandardCallbackDynamicParams _NEWRELIC_CALLBACK: Final = "newrelic" _NEWRELIC_VAR_PREFIX: Final = "newrelic_" @@ -25,7 +25,11 @@ _ARIZE_SAMPLING_RATE_VARS: Final[frozenset[str]] = frozenset( {"arize_success_sampling_rate", "arize_error_sampling_rate"} ) _GENERIC_API_CALLBACK_TYPE: Final = "generic_api" +_CALLBACK_TYPE_FIELD: Final = "callback_type" _STRING_KEYED_MAPPING: Final = TypeAdapter(Mapping[str, object]) +_DEFINITION_VAR_KEYS: Final[frozenset[str]] = frozenset( + {*StandardCallbackDynamicParams.__annotations__, CAPTURE_MESSAGE_CONTENT_VAR, EXCLUDED_SERVICES_VAR} +) def is_named_callback_definition(definition: object) -> bool: @@ -53,6 +57,48 @@ def callback_backend_name(callback_name: str) -> str: return callback_name if definition is None else str(definition["callback_type"]) +def callback_settings_definition_error(callback_settings: Mapping[str, object]) -> str | None: + """Why a named ``callback_settings`` definition can never work from a key, checked at config load. + + A definition named after a callback would be handed to that callback's constructor + and would reroute every inline key entry naming that callback to the definition's + backend with its secrets merged in. Other mistakes would only surface on + ``/key/health`` of a key that already depends on the definition. + """ + return next((error for error in _definition_errors(callback_settings) if error is not None), None) + + +def _definition_errors(callback_settings: Mapping[str, object]) -> Iterator[str | None]: + for name, definition in callback_settings.items(): + if is_named_callback_definition(definition): + yield _definition_error(name, _STRING_KEYED_MAPPING.validate_python(definition)) + + +def _definition_error(name: str, definition: Mapping[str, object]) -> str | None: + known_callbacks: Final = litellm._known_custom_logger_compatible_callbacks # pyright: ignore[reportPrivateUsage] # the registry of callback names has no public accessor + if name in known_callbacks: + return f"callback_settings.{name} is named after the {name} callback, so a key could not tell them apart" + backend: Final = str(definition[_CALLBACK_TYPE_FIELD]) + if backend not in known_callbacks: + return f"callback_settings.{name}.callback_type {backend!r} is not a known callback" + unknown: Final = tuple(key for key in definition if key != _CALLBACK_TYPE_FIELD and key not in _DEFINITION_VAR_KEYS) + if unknown: + return f"callback_settings.{name} sets {', '.join(unknown)}, which no callback accepts as a callback var" + return None + + +def team_callback_reference_error(logging_entries: object) -> str | None: + """A ``callback_settings`` reference only resolves on a key, so a team entry naming one is refused.""" + return next( + ( + f"callback_settings.{name} can only be referenced from a key's logging metadata, not a team's" + for name, _ in stored_callback_entries(logging_entries) + if name is not None and named_callback_definition(name) is not None + ), + None, + ) + + def callback_config_error( callback_name: str | None, callback_vars: Mapping[str, str] | None, callback_type: str | None = None ) -> str | None: @@ -396,9 +442,11 @@ def _logging_entry_error(entry: object) -> str | None: ) ) callback_name: Final = typed_entry.get("callback_name") - callback_vars_raw: Final = typed_entry.get("callback_vars") - if not isinstance(callback_name, str) or not isinstance(callback_vars_raw, Mapping): + if not isinstance(callback_name, str): return None + callback_vars_raw: Final = typed_entry.get("callback_vars") + if not isinstance(callback_vars_raw, Mapping): + return f"logging entry {callback_name!r} needs a callback_vars object, pass {{}} when it has no values" callback_vars: Final[Mapping[object, object]] = cast( # cast-ok: Mapping check preserves arbitrary key types Mapping[object, object], callback_vars_raw ) diff --git a/litellm/proxy/management_endpoints/key_management_endpoints.py b/litellm/proxy/management_endpoints/key_management_endpoints.py index adabc6e7329..44e25c29cb2 100644 --- a/litellm/proxy/management_endpoints/key_management_endpoints.py +++ b/litellm/proxy/management_endpoints/key_management_endpoints.py @@ -21,12 +21,12 @@ import traceback from collections.abc import Awaitable, Callable, Iterator, Mapping, Sequence from datetime import datetime, timedelta, timezone from types import MappingProxyType -from typing import TYPE_CHECKING, Final, Literal, Optional, Protocol, TypeVar, cast +from typing import TYPE_CHECKING, Final, Literal, Optional, Protocol, TypeAlias, TypeVar, cast import fastapi import yaml from fastapi import APIRouter, Depends, Header, HTTPException, Query, Request, status -from pydantic import TypeAdapter +from pydantic import TypeAdapter, ValidationError from typing_extensions import ReadOnly, TypedDict import litellm @@ -434,6 +434,15 @@ _KEY_METADATA_REQUEST_FIELDS: Final = frozenset( _DECODED_JSON: Final = TypeAdapter(object) +_STORED_METADATA: Final[TypeAdapter[Mapping[str, object] | None]] = TypeAdapter(Mapping[str, object] | None) + + +def _stored_metadata(metadata: object) -> Mapping[str, object] | None: + """A key row's metadata with its callback vars decrypted, or None when the row carries no metadata object.""" + try: + return _STORED_METADATA.validate_python(_DECODED_JSON.validate_python(decrypt_callback_vars(metadata))) + except ValidationError: + return None def _decode_json_string_column(column: str, value: object) -> object: @@ -934,33 +943,59 @@ def raise_on_invalid_key_logging_config(metadata: Mapping[str, object] | None) - raise HTTPException(status_code=400, detail={"error": error}) +_CallbackReference: TypeAlias = tuple[str, Mapping[str, str], Mapping[str, object]] + + def raise_on_unauthorized_callback_reference( - metadata: Mapping[str, object] | None, user_api_key_dict: UserAPIKeyAuth + metadata: Mapping[str, object] | None, + user_api_key_dict: UserAPIKeyAuth, + *, + existing_metadata: Mapping[str, object] | None = None, ) -> None: - """Only a proxy admin may point a key at a ``callback_settings`` definition. + """Only a proxy admin may point a key at a ``callback_settings`` definition, or change or drop that reference. The definition carries the operator's secret-manager references, so a key that names it must not be writable by the team admins and members who can otherwise - edit key metadata, and must not override the values the definition sets. + edit key metadata, and must not override the values the definition sets. Those + callers may still edit the rest of the key's metadata as long as they send the + stored reference back unchanged. """ - references: Final = tuple( + if metadata is None: + return + references: Final = _callback_references(metadata) + if user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN.value: + overridden: Final = next( + (error for reference in references if (error := _overridden_definition_var_error(reference)) is not None), + None, + ) + if overridden is not None: + raise HTTPException(status_code=400, detail={"error": overridden}) + return + stored: Final = _callback_references(existing_metadata or {}) + if _reference_keys(references) == _reference_keys(stored): + return + raise HTTPException( + status_code=403, + detail={ + "error": ( + "Only a proxy admin can point a key at a callback_settings definition" + if not stored + else "Only a proxy admin can change or remove a key's callback_settings reference" + ) + }, + ) + + +def _callback_references(metadata: Mapping[str, object]) -> tuple[_CallbackReference, ...]: + return tuple( (callback_name, callback_vars, definition) - for callback_name, callback_vars in stored_callback_entries((metadata or {}).get("logging")) + for callback_name, callback_vars in stored_callback_entries(metadata.get("logging")) if callback_name is not None and (definition := named_callback_definition(callback_name)) is not None ) - if not references: - return - if user_api_key_dict.user_role != LitellmUserRoles.PROXY_ADMIN.value: - raise HTTPException( - status_code=403, - detail={"error": "Only a proxy admin can point a key at a callback_settings definition"}, - ) - overridden: Final = next( - (error for reference in references if (error := _overridden_definition_var_error(reference)) is not None), - None, - ) - if overridden is not None: - raise HTTPException(status_code=400, detail={"error": overridden}) + + +def _reference_keys(references: Sequence[_CallbackReference]) -> tuple[tuple[str, tuple[tuple[str, str], ...]], ...]: + return tuple((name, tuple(sorted(callback_vars.items()))) for name, callback_vars, _ in references) def _overridden_definition_var_error( @@ -981,6 +1016,7 @@ def common_key_access_checks( llm_router: Router | None, premium_user: bool, user_id: str | None = None, + existing_metadata: Mapping[str, object] | None = None, ) -> Literal[True]: """ Check if user is allowed to make a key request, for this key @@ -1007,7 +1043,7 @@ def common_key_access_checks( llm_router=llm_router, premium_user=premium_user, ) - raise_on_unauthorized_callback_reference(data.metadata, user_api_key_dict) + raise_on_unauthorized_callback_reference(data.metadata, user_api_key_dict, existing_metadata=existing_metadata) return True @@ -3816,6 +3852,7 @@ async def _validate_update_key_data( user_id=user_api_key_dict.user_id if acting_as_team_admin else existing_key_row.user_id, llm_router=llm_router, premium_user=premium_user, + existing_metadata=_stored_metadata(existing_key_row.metadata), # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType] # LiteLLM_VerificationToken.metadata is a bare dict ) await TeamMemberPermissionChecks.can_team_member_execute_key_management_endpoint( @@ -6509,7 +6546,11 @@ def _check_regenerate_guardrail_opt_out( user_api_key_dict, existing_metadata=existing_metadata, ) - raise_on_unauthorized_callback_reference(data.metadata, user_api_key_dict) + raise_on_unauthorized_callback_reference( + data.metadata, + user_api_key_dict, + existing_metadata=_stored_metadata(existing_metadata), + ) @router.post( diff --git a/litellm/proxy/management_endpoints/team_callback_endpoints.py b/litellm/proxy/management_endpoints/team_callback_endpoints.py index 5b778392664..3f821466af6 100644 --- a/litellm/proxy/management_endpoints/team_callback_endpoints.py +++ b/litellm/proxy/management_endpoints/team_callback_endpoints.py @@ -38,6 +38,7 @@ from litellm.proxy.common_utils.callback_config_validation import ( conflicting_span_scope_error, cross_entry_family_error, stored_callback_entries, + team_callback_reference_error, ) from litellm.proxy.common_utils.callback_utils import ( # noqa: F401 # legacy module exports _CALLBACK_VAR_ENCRYPTED_PREFIX, # pyright: ignore[reportPrivateUsage,reportUnusedImport] # backwards-compatible package export @@ -78,6 +79,9 @@ def _callback_config_error(message: str) -> HTTPException: def _validate_team_callback(data: "AddTeamCallback") -> None: + reference_error: Final = team_callback_reference_error([data.model_dump()]) + if reference_error is not None: + raise _callback_config_error(reference_error) error: Final = callback_config_error(data.callback_name, data.callback_vars, data.callback_type) if error is not None: raise _callback_config_error(error) diff --git a/litellm/proxy/management_endpoints/team_endpoints.py b/litellm/proxy/management_endpoints/team_endpoints.py index 54b9b26123e..4ded3781058 100644 --- a/litellm/proxy/management_endpoints/team_endpoints.py +++ b/litellm/proxy/management_endpoints/team_endpoints.py @@ -131,6 +131,7 @@ from litellm.proxy.common_utils.auth_cache_invalidation_pubsub import ( evict_shared, publish_auth_cache_invalidation, ) +from litellm.proxy.common_utils.callback_config_validation import team_callback_reference_error from litellm.proxy.common_utils.callback_utils import encrypt_callback_vars from litellm.proxy.common_utils.json_merge_patch import apply_json_merge_patch from litellm.proxy.common_utils.openai_error_payload import proxy_exception_for @@ -292,6 +293,12 @@ class _TeamIdGroupRow(TypedDict): _count: _TeamIdKeyCount +def _raise_on_team_callback_reference(metadata: Mapping[str, object] | None) -> None: + error: Final = team_callback_reference_error((metadata or {}).get("logging")) + if error is not None: + raise HTTPException(status_code=400, detail={"error": error}) + + def _as_object(value: object) -> object: return value @@ -1907,6 +1914,7 @@ async def new_team( if isinstance(data.metadata, dict): TeamMemberBudgetHandler.strip_system_managed_metadata_keys(data.metadata) + _raise_on_team_callback_reference(data.metadata) # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType] # request models declare `metadata` as bare dict await validate_team_metadata_if_configured( operation="create", metadata=data.metadata, @@ -2616,6 +2624,7 @@ async def update_team( metadata_sent="metadata" in data.model_fields_set, existing_metadata=_existing_team_metadata if isinstance(_existing_team_metadata, dict) else None, # pyright: ignore[reportUnknownArgumentType] # existing_team_row.metadata is a bare dict ) + _raise_on_team_callback_reference(data.metadata) # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType] # request models declare `metadata` as bare dict if data.soft_budget is not None: max_budget_to_check = data.max_budget if data.max_budget is not None else existing_team_row.max_budget diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 8ed0b969d52..6e56a9d8cb2 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -167,7 +167,10 @@ from litellm.proxy._types import ( TransformRequestBody, UserAPIKeyAuth, ) -from litellm.proxy.common_utils.callback_config_validation import is_named_callback_definition +from litellm.proxy.common_utils.callback_config_validation import ( + callback_settings_definition_error, + is_named_callback_definition, +) from litellm.proxy.common_utils.callback_utils import ( is_sensitive_callback_key, normalize_callback_names, @@ -6868,6 +6871,11 @@ class ProxyConfig: ## Callback settings callback_settings: Final = config.get("callback_settings", {}) if callback_settings: + definition_error: Final = callback_settings_definition_error( + _SETTINGS_ADAPTER.validate_python(callback_settings) + ) + if definition_error is not None: + raise ValueError(definition_error) litellm.callback_settings = callback_settings ## LITELLM MODULE SETTINGS (e.g. litellm.drop_params=True,..) diff --git a/tests/unit/proxy/common_utils/test_callback_config_validation.py b/tests/unit/proxy/common_utils/test_callback_config_validation.py index 952d375fc6c..25e0ddb742e 100644 --- a/tests/unit/proxy/common_utils/test_callback_config_validation.py +++ b/tests/unit/proxy/common_utils/test_callback_config_validation.py @@ -6,10 +6,12 @@ import pytest import litellm from litellm.proxy.common_utils.callback_config_validation import ( callback_config_error, + callback_settings_definition_error, conflicting_callback_var_error, conflicting_span_scope_error, cross_entry_family_error, logging_metadata_config_error, + team_callback_reference_error, ) @@ -567,3 +569,83 @@ class TestCallbackReferenceEntries: } assert logging_metadata_config_error({"logging": [reference, inline]}) is None + + +class TestCallbackSettingsDefinitionError: + def test_a_well_formed_definition_next_to_plain_settings_passes(self): + assert ( + callback_settings_definition_error( + { + "arize_space_a": { + "callback_type": "arize", + "arize_api_key": "os.environ/LIT10061_ARIZE_API_KEY", + "arize_space_id": "os.environ/LIT10061_ARIZE_SPACE_ID", + "excluded_services": "postgres,redis", + }, + "audit_sink": {"callback_type": "generic_api", "endpoint": "https://sink.local", "headers": {}}, + "otel": {"message_logging": False}, + } + ) + is None + ) + + def test_a_definition_named_after_a_callback_is_rejected(self): + error: Final = callback_settings_definition_error( + {"langfuse": {"callback_type": "arize", "arize_api_key": "k"}} + ) + + assert error is not None and "callback_settings.langfuse" in error + + def test_an_unknown_backend_is_rejected(self): + error: Final = callback_settings_definition_error( + {"arize_space_a": {"callback_type": "arise", "arize_api_key": "k"}} + ) + + assert error is not None and "'arise'" in error + + def test_a_field_no_callback_accepts_is_rejected(self): + error: Final = callback_settings_definition_error( + {"arize_space_a": {"callback_type": "arize", "arize_api_kye": "k", "arize_space_id": "s"}} + ) + + assert error is not None and "arize_api_kye" in error and "arize_space_id" not in error + + +class TestTeamCallbackReferenceError: + @pytest.fixture(autouse=True) + def definitions(self, monkeypatch) -> None: + monkeypatch.setattr( + litellm, "callback_settings", {"arize_space_a": {"callback_type": "arize", "arize_api_key": "k"}} + ) + + def test_a_team_entry_naming_a_definition_is_refused(self): + error: Final = team_callback_reference_error( + [{"callback_name": "arize_space_a", "callback_type": "success", "callback_vars": {}}] + ) + + assert error is not None and "arize_space_a" in error + + def test_inline_team_entries_are_not_affected(self): + inline: Final = {"callback_name": "arize", "callback_type": "success", "callback_vars": {"arize_api_key": "k"}} + + assert team_callback_reference_error([inline]) is None + assert team_callback_reference_error(None) is None + + +def test_a_logging_entry_without_callback_vars_is_refused_at_write_time(monkeypatch): + """Such an entry fails model validation at request time and is dropped, so accepting it would store a no-op.""" + monkeypatch.setattr( + litellm, "callback_settings", {"arize_space_a": {"callback_type": "arize", "arize_api_key": "k"}} + ) + + error: Final = logging_metadata_config_error( + {"logging": [{"callback_name": "arize_space_a", "callback_type": "success"}]} + ) + + assert error is not None and "callback_vars" in error and "arize_space_a" in error + assert ( + logging_metadata_config_error( + {"logging": [{"callback_name": "arize_space_a", "callback_type": "success", "callback_vars": {}}]} + ) + is None + ) diff --git a/tests/unit/proxy/management_endpoints/test_callback_management_endpoints.py b/tests/unit/proxy/management_endpoints/test_callback_management_endpoints.py index c8183e860f2..4701ec501f6 100644 --- a/tests/unit/proxy/management_endpoints/test_callback_management_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_callback_management_endpoints.py @@ -552,3 +552,68 @@ class TestCallbackReferenceKeyWrites: assert raise_on_unauthorized_callback_reference(metadata, UserAPIKeyAuth(user_role="proxy_admin")) is None finally: is_otel_v2_enabled.cache_clear() + + +class TestCallbackReferenceKeyUpdates: + """A non-admin may edit a referencing key only by sending its stored reference back unchanged.""" + + _STORED: Final = { + "logging": [ + { + "callback_name": "arize_space_a", + "callback_type": "success", + "callback_vars": {"turn_off_message_logging": "true"}, + } + ], + "note": "original", + } + + @pytest.fixture(autouse=True) + def definitions(self, monkeypatch) -> None: + monkeypatch.setattr(litellm, "callback_settings", _ARIZE_REFERENCE_SETTINGS) + + @staticmethod + def _check(metadata, role: str): + from litellm.proxy._types import UserAPIKeyAuth + from litellm.proxy.management_endpoints.key_management_endpoints import ( + raise_on_unauthorized_callback_reference, + ) + + return raise_on_unauthorized_callback_reference( + metadata, UserAPIKeyAuth(user_role=role), existing_metadata=TestCallbackReferenceKeyUpdates._STORED + ) + + def test_a_non_admin_can_edit_other_metadata_while_resending_the_stored_reference(self): + assert self._check({**self._STORED, "note": "edited"}, "internal_user") is None + + def test_a_non_admin_sending_no_metadata_leaves_the_reference_alone(self): + assert self._check(None, "internal_user") is None + + @pytest.mark.parametrize( + "new_metadata", + [ + {"note": "edited"}, + {"logging": [], "note": "edited"}, + {"logging": [{"callback_name": "arize_space_a", "callback_type": "success", "callback_vars": {}}]}, + { + "logging": [ + { + "callback_name": "arize", + "callback_type": "success", + "callback_vars": {"arize_api_key": "mine", "arize_space_id": "space-b"}, + } + ] + }, + ], + ids=["dropped", "emptied", "vars-changed", "swapped-for-inline"], + ) + def test_a_non_admin_cannot_drop_or_change_the_stored_reference(self, new_metadata): + from fastapi import HTTPException + + with pytest.raises(HTTPException) as exc: + self._check(new_metadata, "internal_user") + assert exc.value.status_code == 403 + assert "change or remove" in str(exc.value.detail) + + def test_a_proxy_admin_can_remove_the_reference(self): + assert self._check({"note": "edited"}, "proxy_admin") is None diff --git a/tests/unit/proxy/management_endpoints/test_key_management_endpoints.py b/tests/unit/proxy/management_endpoints/test_key_management_endpoints.py index 1d119d254fe..17ef8736d98 100644 --- a/tests/unit/proxy/management_endpoints/test_key_management_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_key_management_endpoints.py @@ -24265,3 +24265,52 @@ async def test_key_health_reports_a_callback_settings_secret_it_cannot_read(monk assert health["key"] == "unhealthy" assert health["logging_callbacks"]["callbacks"] == ["arize_space_b"] assert "callback_settings.arize_space_b.arize_api_key" in str(health["logging_callbacks"]["details"]) + + +@pytest.mark.asyncio +async def test_update_key_by_a_non_admin_cannot_drop_a_stored_callback_settings_reference(monkeypatch): + """The gate has to see the stored metadata, or sending ``metadata`` without ``logging`` silently removes the reference.""" + from unittest.mock import AsyncMock, MagicMock + + from litellm.proxy._types import LitellmUserRoles, UpdateKeyRequest, UserAPIKeyAuth + from litellm.proxy.management_endpoints.key_management_endpoints import _validate_update_key_data + + monkeypatch.setattr( + litellm, + "callback_settings", + {"arize_space_a": {"callback_type": "arize", "arize_api_key": "os.environ/LIT10061_ARIZE_API_KEY"}}, + ) + mock_prisma_client = AsyncMock() + mock_prisma_client.jsonify_object = lambda data: data + mock_prisma_client.db = MagicMock() + monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) + monkeypatch.setattr("litellm.proxy.proxy_server.user_api_key_cache", MagicMock()) + existing_key_row = MagicMock( + token="hashed_alice_personal_key", + user_id="alice", + team_id=None, + created_by="alice", + max_budget=None, + organization_id=None, + project_id=None, + metadata={ + "logging": [{"callback_name": "arize_space_a", "callback_type": "success", "callback_vars": {}}], + "note": "original", + }, + ) + + with pytest.raises(HTTPException) as exc: + await _validate_update_key_data( + data=UpdateKeyRequest(key="sk-alice-personal", metadata={"note": "edited"}), + existing_key_row=existing_key_row, + user_api_key_dict=UserAPIKeyAuth( + user_role=LitellmUserRoles.INTERNAL_USER, api_key="sk-alice", user_id="alice" + ), + llm_router=None, + premium_user=True, + prisma_client=mock_prisma_client, + user_api_key_cache=MagicMock(), + ) + + assert exc.value.status_code == 403 + assert "callback_settings reference" in str(exc.value.detail) diff --git a/tests/unit/proxy/management_endpoints/test_team_callback_endpoints.py b/tests/unit/proxy/management_endpoints/test_team_callback_endpoints.py index ac78085ca47..7a4bd7007bc 100644 --- a/tests/unit/proxy/management_endpoints/test_team_callback_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_team_callback_endpoints.py @@ -1897,3 +1897,25 @@ def test_add_team_callback_rejects_non_string_destination_callback_vars(callback with pytest.raises(ValidationError) as exc: AddTeamCallback(callback_name="newrelic", callback_vars=callback_vars) assert f"{callback_var} must be a string, got {type(value).__name__}" in str(exc.value) + + +@pytest.mark.asyncio +async def test_add_team_callbacks_refuses_a_callback_settings_reference(patched_prisma, monkeypatch): + """A reference only resolves on a key, so storing one on a team must fail loudly instead of logging nowhere.""" + monkeypatch.setattr( + litellm, + "callback_settings", + {"arize_space_a": {"callback_type": "arize", "arize_api_key": "os.environ/LIT10061_ARIZE_API_KEY"}}, + ) + + with pytest.raises(HTTPException) as exc: + await add_team_callbacks( + data=AddTeamCallback(callback_name="arize_space_a", callback_type="success", callback_vars={}), + http_request=Mock(spec=Request), + team_id="team-victim", + user_api_key_dict=_admin_auth(), + ) + + assert exc.value.status_code == 400 + assert "arize_space_a" in str(exc.value.detail) + patched_prisma.db.litellm_teamtable.update.assert_not_called() diff --git a/tests/unit/proxy/management_endpoints/test_team_endpoints.py b/tests/unit/proxy/management_endpoints/test_team_endpoints.py index 697d9810284..22262ed2fd3 100644 --- a/tests/unit/proxy/management_endpoints/test_team_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_team_endpoints.py @@ -19450,3 +19450,61 @@ async def test_team_info_keeps_the_auth_label_for_a_caller_outside_the_team(monk ) assert (exc_info.value.code, exc_info.value.type) == ("403", "auth_error") + + +_REFERENCE_LOGGING: Final = { + "logging": [{"callback_name": "arize_space_a", "callback_type": "success", "callback_vars": {}}] +} + + +@pytest.mark.asyncio +async def test_new_team_refuses_a_callback_settings_reference_in_its_logging_metadata( + mock_db_client: MagicMock, + mock_admin_auth: UserAPIKeyAuth, + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.setattr(litellm, "default_team_settings", None) + monkeypatch.setattr(litellm, "default_team_params", {}) + monkeypatch.setattr( + litellm, "callback_settings", {"arize_space_a": {"callback_type": "arize", "arize_api_key": "k"}} + ) + mock_team_create: Final = _wire_new_team_prisma(mock_db_client) + + exc: Final[pytest.ExceptionInfo[ProxyException]] + with pytest.raises(ProxyException) as exc: + await new_team( + data=NewTeamRequest(team_alias="t", metadata=dict(_REFERENCE_LOGGING)), + http_request=MagicMock(spec=Request), + user_api_key_dict=mock_admin_auth, + ) + + assert str(exc.value.code) == "400" + assert "arize_space_a" in str(exc.value.message) + mock_team_create.assert_not_called() + + +@pytest.mark.asyncio +async def test_update_team_refuses_a_callback_settings_reference_in_its_logging_metadata( + mock_db_client: MagicMock, + mock_admin_auth: UserAPIKeyAuth, + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.setattr( + litellm, "callback_settings", {"arize_space_a": {"callback_type": "arize", "arize_api_key": "k"}} + ) + existing: Final[MagicMock] = MagicMock() + existing.metadata = {} + existing.model_dump.return_value = {"team_id": "t1", "organization_id": "org-1", "metadata": {}} + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing) + + exc: Final[pytest.ExceptionInfo[ProxyException]] + with pytest.raises(ProxyException) as exc: + await update_team( + data=UpdateTeamRequest(team_id="t1", metadata=dict(_REFERENCE_LOGGING)), + http_request=MagicMock(spec=Request), + user_api_key_dict=mock_admin_auth, + ) + + assert str(exc.value.code) == "400" + assert "arize_space_a" in str(exc.value.message) + mock_db_client.db.litellm_teamtable.update.assert_not_called() diff --git a/tests/unit/proxy/proxy_server/test_proxy_config.py b/tests/unit/proxy/proxy_server/test_proxy_config.py index d8e671131f5..86fb0bd0738 100644 --- a/tests/unit/proxy/proxy_server/test_proxy_config.py +++ b/tests/unit/proxy/proxy_server/test_proxy_config.py @@ -6621,3 +6621,25 @@ async def test_proxy_config_validates_advertised_mcp_versions_at_load(tmp_path, return with pytest.raises(ValidationError): await ProxyConfig().load_config(router=None, config_file_path=str(config)) + + +@pytest.mark.asyncio +async def test_ProxyConfig_load_config_fails_on_a_callback_definition_no_key_could_use(tmp_path, monkeypatch): + f = tmp_path / "c.yaml" + f.write_text( + "model_list: []\n" + "general_settings: {}\n" + "callback_settings:\n" + " arize_space_a:\n" + " callback_type: arize\n" + " arize_api_kye: os.environ/LIT10061_ARIZE_API_KEY\n" + ) + monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", None) + monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", False) + monkeypatch.delenv("LITELLM_CONFIG_BUCKET_NAME", raising=False) + monkeypatch.setattr(litellm, "callback_settings", {}) + + with pytest.raises(ValueError, match="arize_api_kye"): + await ProxyConfig().load_config(router=None, config_file_path=str(f)) + + assert litellm.callback_settings == {} diff --git a/tests/unit/proxy/test_litellm_pre_call_utils.py b/tests/unit/proxy/test_litellm_pre_call_utils.py index 4e2b488d3ec..e15cd7bc9a8 100644 --- a/tests/unit/proxy/test_litellm_pre_call_utils.py +++ b/tests/unit/proxy/test_litellm_pre_call_utils.py @@ -11574,3 +11574,45 @@ def test_caller_tags_reach_litellm_metadata_whether_metadata_is_a_dict_or_a_json LiteLLMProxyRequestSetup.merge_caller_body_tags(request_data=data) assert set(data["litellm_metadata"]["tags"]) == {"key-tag", "client-tag"} assert data["metadata"] == caller_metadata + + +@pytest.mark.asyncio +async def test_a_referencing_keys_resolved_secret_never_reaches_the_spend_log_row(monkeypatch): + """The request carries the resolved secret for the logger, but the spend log row built from it must not.""" + from litellm.proxy.litellm_pre_call_utils import add_litellm_data_to_request + + monkeypatch.setattr(litellm, "callback_settings", _ARIZE_REFERENCE_SETTINGS) + monkeypatch.setenv("LIT10061_ARIZE_API_KEY", "resolved-arize-secret-lit10061") + monkeypatch.setenv("LIT10061_ARIZE_SPACE_ID", "space-a") + + updated: Final = await add_litellm_data_to_request( + data={"model": "gpt-5-mini", "messages": [{"role": "user", "content": "hello"}]}, + request=_make_request_mock("/v1/chat/completions", {"Content-Type": "application/json"}), + user_api_key_dict=_key_auth_referencing("arize_space_a"), + proxy_config=MagicMock(), + general_settings={}, + version="test-version", + ) + assert updated["arize_api_key"] == "resolved-arize-secret-lit10061" + + row: Final = get_logging_payload( + kwargs={ + "model": "gpt-5-mini", + "custom_llm_provider": "openai", + "litellm_params": { + "metadata": updated["metadata"], + "proxy_server_request": updated["proxy_server_request"], + }, + "standard_callback_dynamic_params": { + "arize_api_key": updated["arize_api_key"], + "arize_space_id": updated["arize_space_id"], + }, + }, + response_obj={}, + start_time=datetime.now(timezone.utc), + end_time=datetime.now(timezone.utc), + ) + + assert "resolved-arize-secret-lit10061" not in json.dumps(row, default=repr) + assert "resolved-arize-secret-lit10061" not in json.dumps(updated["metadata"], default=repr) + assert "resolved-arize-secret-lit10061" not in json.dumps(updated["proxy_server_request"], default=repr)