From 3d33aed3cd9e2c691643c71e718b368a48564000 Mon Sep 17 00:00:00 2001 From: narmstrong-berry Date: Sat, 31 Oct 2026 02:02:16 +0000 Subject: [PATCH] refactor(router): route the router family through RoutingContext and close the outside surface Strategies, pre-call checks, cooldown and fallback helpers, and the auto, complexity and quality sub-routers now take a RoutingContext instead of the Router, and read the router only through registry(), settings(), health() and the context's forwarding methods. Router-free helpers move from router_utils to litellm_core_utils, outside callers of router state switch to entry points, and the surface allowlist shrinks to the endpoint methods plus the entry points --- litellm/_lazy_imports_registry.py | 4 +- litellm/constants.py | 1 + litellm/integrations/prometheus.py | 8 +- .../access_windows.py | 0 .../add_retry_fallback_headers.py | 0 .../clientside_credential_handler.py | 0 .../deployment_pricing.py | 0 litellm/litellm_core_utils/fallback_utils.py | 6 +- .../get_retry_from_policy.py | 0 .../health_check_helpers.py | 2 +- .../pattern_match_deployments.py | 0 .../ptu_shares.py | 2 +- .../reasoning_effort_capability.py | 0 .../routing_common_utils.py} | 0 .../routing_groups.py | 0 litellm/litellm_core_utils/token_counter.py | 2 +- .../llms/anthropic/messages/native/handler.py | 14 +- .../messages/native/interceptors/advisor.py | 2 +- litellm/llms/anthropic/messages/utils.py | 2 +- .../clf_ai_gateway/chat/transformation.py | 2 +- litellm/llms/compaction.py | 8 +- litellm/llms/mistral/chat/transformation.py | 8 +- litellm/llms/oci/chat/transformation.py | 2 +- .../llms/together_ai/chat/transformation.py | 2 +- litellm/main.py | 10 +- litellm/proxy/auth/auth_checks.py | 37 +- litellm/proxy/auth/fallback_budget.py | 10 +- litellm/proxy/auth/fallback_model_access.py | 8 +- litellm/proxy/auth/model_checks.py | 6 +- litellm/proxy/auth/user_api_key_auth.py | 26 +- litellm/proxy/bug_report_config.py | 2 +- litellm/proxy/common_request_processing.py | 15 +- .../proxy/common_utils/cache_aware_routing.py | 13 +- .../common_utils/credential_hydration.py | 2 +- .../proxy/common_utils/model_listing_utils.py | 2 +- .../guardrail_hooks/headroom/headroom.py | 2 +- .../semantic_guard/route_loader.py | 3 +- litellm/proxy/health_check.py | 2 +- .../shared_health_check_manager.py | 2 +- .../health_endpoints/_health_endpoints.py | 10 +- .../proxy/hooks/dynamic_rate_limiter_v3.py | 8 +- .../proxy/hooks/model_max_budget_limiter.py | 2 +- .../hooks/parallel_request_limiter_v3.py | 20 +- litellm/proxy/litellm_pre_call_utils.py | 6 +- .../auto_router_endpoints.py | 3 +- .../management_endpoints/ptu_consumption.py | 8 +- .../management_helpers/model_quota_policy.py | 4 +- .../management_helpers/ptu_share_guard.py | 2 +- .../proxy/mcp_server/semantic_tool_filter.py | 5 +- .../openai_files_endpoints/files_endpoints.py | 2 +- .../proxy/policy_engine/response_retrieval.py | 2 +- litellm/proxy/proxy_server.py | 60 +- litellm/proxy/route_llm_request.py | 5 +- litellm/proxy/spend_tracking/input_tokens.py | 4 +- litellm/proxy/utils.py | 4 +- litellm/responses/main.py | 10 +- litellm/router.py | 253 +++-- litellm/router_api.py | 265 ++++- litellm/router_deprecated.py | 105 +- .../auto_router/auto_router.py | 15 +- .../auto_router/litellm_encoder.py | 61 +- .../complexity_router/complexity_router.py | 54 +- .../complexity_router/context_compaction.py | 73 +- .../evals/eval_complexity_router.py | 4 +- .../complexity_router/jev_classifier.py | 31 +- litellm/router_strategy/lar1_routing.py | 29 +- litellm/router_strategy/lowest_cost.py | 2 +- .../quality_router/quality_router.py | 16 +- litellm/router_strategy/savings_baseline.py | 20 +- litellm/router_strategy/tag_based_routing.py | 36 +- .../client_initalization_utils.py | 16 +- litellm/router_utils/cooldown_callbacks.py | 11 +- litellm/router_utils/cooldown_handlers.py | 147 ++- .../router_utils/fallback_event_handlers.py | 59 +- litellm/router_utils/handle_error.py | 36 +- litellm/router_utils/health_state_cache.py | 3 +- .../continuation_prefill_check.py | 2 +- .../deployment_affinity_check.py | 2 +- .../encrypted_content_affinity_check.py | 27 +- .../prompt_caching_deployment_check.py | 2 +- .../track_deployment_metrics.py | 29 +- litellm/router_utils/routing_read_batch.py | 23 +- litellm/router_utils/search_api_router.py | 51 +- .../host/callbacks_legacy_python.py | 2 +- litellm/rust_bridge/response_metadata.py | 2 +- litellm/types/litellm_params.py | 2 +- litellm/types/router.py | 6 +- litellm/utils.py | 10 +- scripts/benchmark_ocr_callbacks.py | 2 +- .../router_code_coverage.py | 4 +- .../router_surface_allowlist.json | 72 +- .../sdk/test_router_cooldown_fallback_sdk.py | 2 +- tests/test_litellm_rust/cache/support.py | 2 +- .../cache/test_python_cache.py | 2 +- .../test_litellm_rust/cache/v2/test_cache.py | 2 +- tests/test_litellm_rust/support/served.py | 2 +- tests/test_litellm_rust/test_fork_guard.py | 2 +- .../test_request_redis_batch_pre_call.py | 3 +- .../test_prometheus_unit_tests.py | 24 +- .../test_streaming_handler.py | 4 +- .../messages/test_reasoning_effort_fields.py | 6 +- .../anthropic/test_anthropic_common_utils.py | 20 +- ...test_clf_ai_gateway_chat_transformation.py | 2 +- .../chat/test_handler.py | 2 +- .../test_gpt_reasoning_transformation.py | 2 +- .../openai/test_openai_workload_identity.py | 2 +- tests/unit/proxy/auth/test_auth_utils.py | 30 +- tests/unit/proxy/auth/test_fallback_budget.py | 30 +- .../proxy/auth/test_fallback_model_access.py | 22 +- .../proxy/auth/test_model_checks_fallbacks.py | 18 +- .../common_utils/test_cache_aware_routing.py | 7 +- .../test_deferred_guardrail_logging.py | 15 +- .../hooks/test_parallel_request_limiter_v3.py | 2 +- tests/unit/proxy/hooks/test_tpm_concurrent.py | 2 +- .../test_search_tool_management.py | 20 +- .../test_llm_pass_through_endpoints.py | 2 +- .../proxy_server/test_background_health.py | 36 +- .../proxy/proxy_server/test_proxy_config.py | 29 +- tests/unit/proxy/router_entry_point_stubs.py | 9 +- .../proxy/test_common_request_processing.py | 2 +- ...test_proxy_server_endpoints_and_startup.py | 6 +- .../test_responses_router_cooldown.py | 2 +- .../test_context_compaction.py | 20 +- .../complexity_router/test_jev_classifier.py | 129 ++- .../unit/router_strategy/test_auto_router.py | 43 +- .../router_strategy/test_complexity_router.py | 917 ++++++++++-------- .../unit/router_strategy/test_lar1_routing.py | 40 +- .../router_strategy/test_litellm_encoder.py | 3 +- tests/unit/router_strategy/test_llm_v2.py | 7 +- .../router_strategy/test_quality_router.py | 75 +- .../test_router_routing_groups.py | 5 +- .../test_router_tag_regex_routing.py | 58 +- .../test_router_tag_routing.py | 53 +- .../router_strategy/test_savings_baseline.py | 15 +- .../test_encrypted_content_affinity_check.py | 129 +-- .../unit/router_utils/test_access_windows.py | 2 +- .../test_add_retry_fallback_headers.py | 2 +- .../router_utils/test_cooldown_handlers.py | 431 ++++---- .../router_utils/test_deployment_pricing.py | 2 +- .../test_fallback_event_handlers.py | 276 +++--- .../test_get_retry_from_policy.py | 2 +- tests/unit/router_utils/test_handle_error.py | 71 +- ..._health_check_allowed_fails_integration.py | 30 +- .../test_pattern_match_deployments.py | 8 +- tests/unit/router_utils/test_ptu_shares.py | 2 +- .../test_reasoning_effort_capability.py | 2 +- .../test_router_utils_common_utils.py | 2 +- tests/unit/rust_bridge/test_runtime.py | 2 +- .../test_model_prices_and_context_window.py | 2 +- .../test_muse_spark_1_3_model_metadata.py | 2 +- tests/unit/test_private_usage_aliases.py | 10 +- tests/unit/test_router/test_router.py | 33 +- .../unit/test_router/test_router_endpoints.py | 2 +- .../test_router/test_router_entry_points.py | 74 ++ .../test_router/test_router_helper_utils.py | 4 +- ...test_router_streaming_fallback_metadata.py | 2 +- 156 files changed, 2514 insertions(+), 2082 deletions(-) rename litellm/{router_utils => litellm_core_utils}/access_windows.py (100%) rename litellm/{router_utils => litellm_core_utils}/add_retry_fallback_headers.py (100%) rename litellm/{router_utils => litellm_core_utils}/clientside_credential_handler.py (100%) rename litellm/{router_utils => litellm_core_utils}/deployment_pricing.py (100%) rename litellm/{router_utils => litellm_core_utils}/get_retry_from_policy.py (100%) rename litellm/{router_utils => litellm_core_utils}/pattern_match_deployments.py (100%) rename litellm/{router_utils => litellm_core_utils}/ptu_shares.py (99%) rename litellm/{router_utils => litellm_core_utils}/reasoning_effort_capability.py (100%) rename litellm/{router_utils/common_utils.py => litellm_core_utils/routing_common_utils.py} (100%) rename litellm/{router_utils => litellm_core_utils}/routing_groups.py (100%) diff --git a/litellm/_lazy_imports_registry.py b/litellm/_lazy_imports_registry.py index c1f484f8d64..de290070ed3 100644 --- a/litellm/_lazy_imports_registry.py +++ b/litellm/_lazy_imports_registry.py @@ -1469,11 +1469,11 @@ _UTILS_MODULE_IMPORT_MAP: Final = { "AsyncHTTPHandler": ("litellm.llms.custom_httpx.http_handler", "AsyncHTTPHandler"), "HTTPHandler": ("litellm.llms.custom_httpx.http_handler", "HTTPHandler"), "get_num_retries_from_retry_policy": ( - "litellm.router_utils.get_retry_from_policy", + "litellm.litellm_core_utils.get_retry_from_policy", "get_num_retries_from_retry_policy", ), "reset_retry_policy": ( - "litellm.router_utils.get_retry_from_policy", + "litellm.litellm_core_utils.get_retry_from_policy", "reset_retry_policy", ), "get_coroutine_checker": ( diff --git a/litellm/constants.py b/litellm/constants.py index c586a5f767a..fc767a1dad6 100644 --- a/litellm/constants.py +++ b/litellm/constants.py @@ -2046,6 +2046,7 @@ LITELLM_SETTINGS_SAFE_DB_OVERRIDES: Final = [ SPECIAL_LITELLM_AUTH_TOKEN: Final = ["ui-token"] DEFAULT_MANAGEMENT_OBJECT_IN_MEMORY_CACHE_TTL = get_env_int("DEFAULT_MANAGEMENT_OBJECT_IN_MEMORY_CACHE_TTL", 60) AUTH_OBJECTS_TARGET: Final = "auth_objects" +HEALTH_CHECKS_TARGET: Final = "health_checks" DEFAULT_ACCESS_GROUP_CACHE_TTL: Final = get_env_int("DEFAULT_ACCESS_GROUP_CACHE_TTL", 600) SPEND_LOG_KEY_METADATA_CACHE_TTL: Final = 600 SPEND_LOG_KEY_METADATA_MISS_CACHE_TTL: Final = 30 diff --git a/litellm/integrations/prometheus.py b/litellm/integrations/prometheus.py index 5c2f0f553a8..42fe0837c29 100644 --- a/litellm/integrations/prometheus.py +++ b/litellm/integrations/prometheus.py @@ -66,7 +66,7 @@ from litellm.repositories.organization_repository import OrganizationRepository from litellm.repositories.table_repositories import EndUserRepository from litellm.repositories.team_repository import TeamRepository from litellm.repositories.user_repository import UserRepository -from litellm.router_utils.router_callbacks.track_deployment_metrics import find_deployment_metadata +from litellm.router_api import deployment_metadata from litellm.types.guardrails import GuardrailEventHooks from litellm.types.integrations.prometheus import * from litellm.types.integrations.prometheus import ( @@ -3022,8 +3022,8 @@ class PrometheusLogger(CustomLogger): ).get("custom_llm_provider") if isinstance(provider, str) and provider: return provider - deployment_metadata: Final = find_deployment_metadata(litellm_params) - return _deployment_model_provider(deployment_metadata.get("deployment") if deployment_metadata else None) + picked_deployment: Final = deployment_metadata(litellm_params) + return _deployment_model_provider(picked_deployment.get("deployment") if picked_deployment else None) @staticmethod def _extract_api_provider_from_exception(exception: Exception) -> str | None: @@ -5209,7 +5209,7 @@ def _tag_matches_wildcard_configured_pattern(tags: Sequence[str], configured_tag """ import re - from litellm.router_utils.pattern_match_deployments import PatternMatchRouter + from litellm.litellm_core_utils.pattern_match_deployments import PatternMatchRouter pattern_router: Final = PatternMatchRouter() regex_pattern: Final = pattern_router.pattern_to_regex(configured_tag) diff --git a/litellm/router_utils/access_windows.py b/litellm/litellm_core_utils/access_windows.py similarity index 100% rename from litellm/router_utils/access_windows.py rename to litellm/litellm_core_utils/access_windows.py diff --git a/litellm/router_utils/add_retry_fallback_headers.py b/litellm/litellm_core_utils/add_retry_fallback_headers.py similarity index 100% rename from litellm/router_utils/add_retry_fallback_headers.py rename to litellm/litellm_core_utils/add_retry_fallback_headers.py diff --git a/litellm/router_utils/clientside_credential_handler.py b/litellm/litellm_core_utils/clientside_credential_handler.py similarity index 100% rename from litellm/router_utils/clientside_credential_handler.py rename to litellm/litellm_core_utils/clientside_credential_handler.py diff --git a/litellm/router_utils/deployment_pricing.py b/litellm/litellm_core_utils/deployment_pricing.py similarity index 100% rename from litellm/router_utils/deployment_pricing.py rename to litellm/litellm_core_utils/deployment_pricing.py diff --git a/litellm/litellm_core_utils/fallback_utils.py b/litellm/litellm_core_utils/fallback_utils.py index cc36f47b516..87888311508 100644 --- a/litellm/litellm_core_utils/fallback_utils.py +++ b/litellm/litellm_core_utils/fallback_utils.py @@ -3,13 +3,13 @@ from typing import Final import litellm from litellm._logging import verbose_logger from litellm._uuid import uuid +from litellm.litellm_core_utils.add_retry_fallback_headers import ( + add_fallback_headers_to_response, +) from litellm.litellm_core_utils.core_helpers import ( filter_internal_params, safe_deep_copy, ) -from litellm.router_utils.add_retry_fallback_headers import ( - add_fallback_headers_to_response, -) from .asyncify import run_async_function diff --git a/litellm/router_utils/get_retry_from_policy.py b/litellm/litellm_core_utils/get_retry_from_policy.py similarity index 100% rename from litellm/router_utils/get_retry_from_policy.py rename to litellm/litellm_core_utils/get_retry_from_policy.py diff --git a/litellm/litellm_core_utils/health_check_helpers.py b/litellm/litellm_core_utils/health_check_helpers.py index e40299a218f..2c7d00552b4 100644 --- a/litellm/litellm_core_utils/health_check_helpers.py +++ b/litellm/litellm_core_utils/health_check_helpers.py @@ -119,7 +119,7 @@ def _is_route_segment(custom_llm_provider: str, segment: str, model_after_segmen def wildcard_health_check_models(wildcard: str, custom_llm_provider: str) -> tuple[str, ...]: from litellm.litellm_core_utils.llm_request_utils import rank_chat_models_from_llm_provider - from litellm.router_utils.pattern_match_deployments import PatternMatchRouter + from litellm.litellm_core_utils.pattern_match_deployments import PatternMatchRouter provider_prefix: Final = f"{custom_llm_provider}/" segments: Final = wildcard.removeprefix(provider_prefix).split("/") diff --git a/litellm/router_utils/pattern_match_deployments.py b/litellm/litellm_core_utils/pattern_match_deployments.py similarity index 100% rename from litellm/router_utils/pattern_match_deployments.py rename to litellm/litellm_core_utils/pattern_match_deployments.py diff --git a/litellm/router_utils/ptu_shares.py b/litellm/litellm_core_utils/ptu_shares.py similarity index 99% rename from litellm/router_utils/ptu_shares.py rename to litellm/litellm_core_utils/ptu_shares.py index 56c11b41cbc..d56c9f2ea14 100644 --- a/litellm/router_utils/ptu_shares.py +++ b/litellm/litellm_core_utils/ptu_shares.py @@ -12,13 +12,13 @@ from datetime import date from typing import Final, Generic, TypeAlias, TypeVar from litellm.litellm_core_utils.ptu_pricing import parsed_ptu_shares, ptu_terms +from litellm.litellm_core_utils.routing_common_utils import get_request_team_id, team_may_use_deployment from litellm.llms.azure.ptu_capacity import ( PTUCapacity, deployment_ptu_capacity, is_azure_deployment, is_str_keyed_mapping, ) -from litellm.router_utils.common_utils import get_request_team_id, team_may_use_deployment _DeploymentT: Final = TypeVar("_DeploymentT", bound=Mapping[str, object]) WildcardRoute: TypeAlias = Callable[[str], Sequence[Mapping[str, object]]] diff --git a/litellm/router_utils/reasoning_effort_capability.py b/litellm/litellm_core_utils/reasoning_effort_capability.py similarity index 100% rename from litellm/router_utils/reasoning_effort_capability.py rename to litellm/litellm_core_utils/reasoning_effort_capability.py diff --git a/litellm/router_utils/common_utils.py b/litellm/litellm_core_utils/routing_common_utils.py similarity index 100% rename from litellm/router_utils/common_utils.py rename to litellm/litellm_core_utils/routing_common_utils.py diff --git a/litellm/router_utils/routing_groups.py b/litellm/litellm_core_utils/routing_groups.py similarity index 100% rename from litellm/router_utils/routing_groups.py rename to litellm/litellm_core_utils/routing_groups.py diff --git a/litellm/litellm_core_utils/token_counter.py b/litellm/litellm_core_utils/token_counter.py index 800a0939cec..323af72940a 100644 --- a/litellm/litellm_core_utils/token_counter.py +++ b/litellm/litellm_core_utils/token_counter.py @@ -56,9 +56,9 @@ from litellm.litellm_core_utils.tokenizer import HuggingFaceTokenizer, OpenAIEnc if TYPE_CHECKING: from litellm.litellm_core_utils.tokenizer import Encoding, HuggingFace +from litellm.litellm_core_utils.deployment_pricing import deployment_pricing_models from litellm.litellm_core_utils.url_utils import safe_get from litellm.llms.custom_httpx.http_handler import get_httpx_client, header_value -from litellm.router_utils.deployment_pricing import deployment_pricing_models from litellm.rust_bridge.tokenizer import get_encoding from litellm.types.llms.anthropic import ( AnthropicContentParamSource, diff --git a/litellm/llms/anthropic/messages/native/handler.py b/litellm/llms/anthropic/messages/native/handler.py index 1da7c2efdda..1bf00cbdb2f 100644 --- a/litellm/llms/anthropic/messages/native/handler.py +++ b/litellm/llms/anthropic/messages/native/handler.py @@ -19,6 +19,13 @@ from litellm.integrations.anthropic_cache_control_hook import AnthropicCacheCont from litellm.litellm_core_utils.core_helpers import as_str_mapping from litellm.litellm_core_utils.exception_mapping_utils import exception_type from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj +from litellm.litellm_core_utils.reasoning_effort_capability import ( + RequestedReasoningEffort, + deployment_reasoning_effort_levels, + keeps_effort, + model_group_from_metadata, + resolve_deployment_reasoning_effort, +) from litellm.llms.anthropic.common_utils import ( AnthropicModelInfo, strip_provider_specific_fields_from_anthropic_messages, @@ -31,13 +38,6 @@ from litellm.llms.base_llm.chat.transformation import BaseLLMException from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler from litellm.llms.custom_httpx.llm_http_handler import BaseLLMHTTPHandler from litellm.responses.mcp.tool_precheck import may_name_litellm_mcp_gateway -from litellm.router_utils.reasoning_effort_capability import ( - RequestedReasoningEffort, - deployment_reasoning_effort_levels, - keeps_effort, - model_group_from_metadata, - resolve_deployment_reasoning_effort, -) from litellm.types.llms.anthropic import AllAnthropicToolsValues from litellm.types.llms.anthropic_messages.anthropic_request import AnthropicMetadata from litellm.types.llms.anthropic_messages.anthropic_response import ( diff --git a/litellm/llms/anthropic/messages/native/interceptors/advisor.py b/litellm/llms/anthropic/messages/native/interceptors/advisor.py index 4c1d2451939..641ac6fca88 100644 --- a/litellm/llms/anthropic/messages/native/interceptors/advisor.py +++ b/litellm/llms/anthropic/messages/native/interceptors/advisor.py @@ -22,7 +22,7 @@ import litellm import litellm.constants as _c from litellm.litellm_core_utils.url_utils import validate_url from litellm.llms.anthropic.common_utils import strip_advisor_blocks_from_messages -from litellm.router_utils.cooldown_handlers import mark_advisor_orchestration_failure +from litellm.router_api import mark_advisor_orchestration_failure from litellm.types.llms.anthropic import ANTHROPIC_ADVISOR_TOOL_TYPE from litellm.types.llms.anthropic_messages.anthropic_response import ( AnthropicMessagesResponse, diff --git a/litellm/llms/anthropic/messages/utils.py b/litellm/llms/anthropic/messages/utils.py index 31619a04b74..95c7914befa 100644 --- a/litellm/llms/anthropic/messages/utils.py +++ b/litellm/llms/anthropic/messages/utils.py @@ -214,7 +214,7 @@ def normalize_reasoning_effort_value( if chain is None: return effort - from litellm.router_utils.reasoning_effort_capability import ( + from litellm.litellm_core_utils.reasoning_effort_capability import ( deployment_rounds_reasoning_effort, resolve_supported_reasoning_efforts, ) diff --git a/litellm/llms/clf_ai_gateway/chat/transformation.py b/litellm/llms/clf_ai_gateway/chat/transformation.py index 25e5d0f51f7..04b689c291e 100644 --- a/litellm/llms/clf_ai_gateway/chat/transformation.py +++ b/litellm/llms/clf_ai_gateway/chat/transformation.py @@ -4,8 +4,8 @@ import litellm from litellm._logging import verbose_logger from litellm.exceptions import UnsupportedParamsError from litellm.litellm_core_utils.core_helpers import as_str_mapping +from litellm.litellm_core_utils.reasoning_effort_capability import declared_reasoning_efforts_for_model from litellm.llms.openai.chat.gpt_transformation import OpenAIGPTConfig -from litellm.router_utils.reasoning_effort_capability import declared_reasoning_efforts_for_model from litellm.secret_managers.main import get_secret_str SUPPORTED_OPENAI_PARAMS: Final = ( diff --git a/litellm/llms/compaction.py b/litellm/llms/compaction.py index 16afa2e2c25..034958c63ca 100644 --- a/litellm/llms/compaction.py +++ b/litellm/llms/compaction.py @@ -9,7 +9,7 @@ from pydantic import TypeAdapter from litellm.types.llms.openai import AllMessageValues if TYPE_CHECKING: - from litellm.router import Router + from litellm.router_api import RoutingContext CompactionProtocol: TypeAlias = Literal["chat", "messages"] _MAPPING: Final = TypeAdapter(Mapping[str, object]) @@ -32,7 +32,9 @@ def get_native_compaction_provider(params: Mapping[str, object]) -> NativeCompac return compaction if compaction.supports_native_compaction(params) else None -async def dispatch(router: Router, protocol: CompactionProtocol, payload: Mapping[str, object]) -> Mapping[str, object]: +async def dispatch( + router: RoutingContext, protocol: CompactionProtocol, payload: Mapping[str, object] +) -> Mapping[str, object]: if protocol == "messages": return _MAPPING.validate_python( await router.aanthropic_messages(custom_llm_provider=None, client=None, **payload) @@ -45,4 +47,4 @@ async def dispatch(router: Router, protocol: CompactionProtocol, payload: Mappin {key: value for key, value in payload.items() if key not in ("model", "messages", "stream")} ), ) - return _MAPPING.validate_python(response.model_dump()) + return _MAPPING.validate_python(response.model_dump()) # pyright: ignore[reportAttributeAccessIssue] # stream=False: acompletion returns a ModelResponse diff --git a/litellm/llms/mistral/chat/transformation.py b/litellm/llms/mistral/chat/transformation.py index a402e2c4048..db8dd3fa7f0 100644 --- a/litellm/llms/mistral/chat/transformation.py +++ b/litellm/llms/mistral/chat/transformation.py @@ -25,16 +25,16 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import ( strip_litellm_internal_message_fields, strip_none_values_from_message, ) +from litellm.litellm_core_utils.reasoning_effort_capability import ( + declared_reasoning_efforts_for_model, + nearest_declared_reasoning_effort, +) from litellm.litellm_core_utils.reasoning_effort_utils import OPAQUE_VALUE, warn_dropped_reasoning from litellm.litellm_core_utils.url_utils import ensure_api_route from litellm.llms.openai.chat.gpt_transformation import ( OpenAIChatCompletionStreamingHandler, OpenAIGPTConfig, ) -from litellm.router_utils.reasoning_effort_capability import ( - declared_reasoning_efforts_for_model, - nearest_declared_reasoning_effort, -) from litellm.secret_managers.main import get_secret_str from litellm.types.llms.mistral import ( MistralCacheKeyParams, diff --git a/litellm/llms/oci/chat/transformation.py b/litellm/llms/oci/chat/transformation.py index 9c827822dc1..224674739f5 100644 --- a/litellm/llms/oci/chat/transformation.py +++ b/litellm/llms/oci/chat/transformation.py @@ -21,6 +21,7 @@ from litellm._logging import verbose_logger from litellm.constants import DEFAULT_OCI_CHAT_MAX_TOKENS from litellm.litellm_core_utils.logging_utils import track_llm_api_timing from litellm.litellm_core_utils.prompt_templates.common_utils import messages_with_file_parts_as_image_urls +from litellm.litellm_core_utils.reasoning_effort_capability import declared_reasoning_efforts_for_model from litellm.litellm_core_utils.reasoning_effort_utils import warn_dropped_reasoning from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper from litellm.litellm_core_utils.url_utils import join_api_base @@ -54,7 +55,6 @@ from litellm.llms.oci.common_utils import ( sign_oci_request, validate_oci_environment, ) -from litellm.router_utils.reasoning_effort_capability import declared_reasoning_efforts_for_model from litellm.types.llms.oci import ( CohereChatRequest, OCIChatRequestPayload, diff --git a/litellm/llms/together_ai/chat/transformation.py b/litellm/llms/together_ai/chat/transformation.py index a0eb0c75d35..02436109a4a 100644 --- a/litellm/llms/together_ai/chat/transformation.py +++ b/litellm/llms/together_ai/chat/transformation.py @@ -18,7 +18,7 @@ import litellm from litellm._logging import verbose_logger from litellm.exceptions import UnsupportedParamsError from litellm.litellm_core_utils.prompt_templates.common_utils import strip_litellm_response_only_fields -from litellm.router_utils.reasoning_effort_capability import declared_reasoning_efforts_for_model +from litellm.litellm_core_utils.reasoning_effort_capability import declared_reasoning_efforts_for_model from litellm.types.llms.openai import AllMessageValues from litellm.utils import supports_function_calling, supports_reasoning, supports_response_schema diff --git a/litellm/main.py b/litellm/main.py index 5346741e4d1..2320d1a3e01 100644 --- a/litellm/main.py +++ b/litellm/main.py @@ -113,6 +113,11 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import ( messages_without_pdf_file_parts, ) from litellm.litellm_core_utils.provider_affinity import add_provider_affinity_header +from litellm.litellm_core_utils.reasoning_effort_capability import ( + model_group_from_metadata, + reasoning_effort_needs_allowing, + resolve_chat_reasoning, +) from litellm.litellm_core_utils.request_timeout_resolver import ( get_configured_request_timeout, ) @@ -144,11 +149,6 @@ from litellm.llms.vertex_ai.common_utils import ( ) from litellm.realtime_api.main import realtime_health_check from litellm.responses.mcp.tool_precheck import may_name_litellm_mcp_gateway -from litellm.router_utils.reasoning_effort_capability import ( - model_group_from_metadata, - reasoning_effort_needs_allowing, - resolve_chat_reasoning, -) from litellm.secret_managers.main import get_secret_bool, get_secret_str from litellm.text_completions.streaming_iterator import TextCompletionStreamWrapper from litellm.types.completion import ( diff --git a/litellm/proxy/auth/auth_checks.py b/litellm/proxy/auth/auth_checks.py index 7d379a6f042..9c0bb93ea16 100644 --- a/litellm/proxy/auth/auth_checks.py +++ b/litellm/proxy/auth/auth_checks.py @@ -167,6 +167,7 @@ from litellm.repositories.table_repositories import ( from litellm.repositories.team_repository import TeamRepository from litellm.repositories.user_repository import UserRepository from litellm.router import Router +from litellm.router_api import RegistryReader from litellm.types.proxy.auth.auth_checks import UserNotFoundError from litellm.types.proxy.model_access_group_budget import ModelAccessGroupBudget from litellm.types.router import DeploymentTypedDict @@ -525,7 +526,7 @@ def _log_budget_lookup_failure(entity: str, error: Exception) -> None: ) -def _get_router_zero_cost_cache(llm_router: Router) -> dict[str, bool] | None: +def _get_router_zero_cost_cache(llm_router: RegistryReader) -> dict[str, bool] | None: """ Return the router's per-instance zero-cost cache, or ``None`` for objects that don't expose one (e.g. ``MagicMock`` stand-ins in unit tests). @@ -541,7 +542,7 @@ def _get_router_zero_cost_cache(llm_router: Router) -> dict[str, bool] | None: return cache if isinstance(cache, dict) else None -def is_model_cost_zero(model: str | list[str] | None, llm_router: Router | None) -> bool: +def is_model_cost_zero(model: str | list[str] | None, llm_router: RegistryReader | None) -> bool: """ Check if a model has zero cost (no configured pricing). @@ -667,7 +668,7 @@ _NO_MODEL_INFO: Final[Mapping[str, object]] = MappingProxyType({}) _TEAM_GRANT_RELATIONS: Final[Mapping[str, object]] = MappingProxyType({"litellm_model_table": True}) -def _deployments_served_for(model: str, llm_router: "Router") -> Sequence[DeploymentTypedDict]: +def _deployments_served_for(model: str, llm_router: RegistryReader) -> Sequence[DeploymentTypedDict]: """ The deployments a request to ``model`` routes to, for the gates that waive budget checks. @@ -4842,7 +4843,7 @@ async def get_skill_names_from_access_groups( def _resolve_all_team_model_sentinel_for_auth_check( models: list[str], - llm_router: Router | None, + llm_router: RegistryReader | None, team_id: str | None, ) -> list[str]: if SpecialModelNames.all_team_models.value not in models or team_id is None or llm_router is None: @@ -4856,7 +4857,7 @@ def _resolve_all_team_model_sentinel_for_auth_check( def check_model_access_helper( model: str, - llm_router: Router | None, + llm_router: RegistryReader | None, models: list[str], team_model_aliases: dict[str, str] | None = None, team_id: str | None = None, @@ -4907,7 +4908,7 @@ _check_model_access_helper: Final = check_model_access_helper def _owning_team_names_for_team_deployment( model: str, - llm_router: Router | None, + llm_router: RegistryReader | None, team_id: str | None, team_model_aliases: Mapping[str, str] | None, ) -> tuple[str, ...]: @@ -4925,7 +4926,7 @@ def _owning_team_names_for_team_deployment( def _can_object_call_model( model: str | list[str], - llm_router: Router | None, + llm_router: RegistryReader | None, models: list[str], team_model_aliases: dict[str, str] | None = None, team_id: str | None = None, @@ -5052,7 +5053,7 @@ def _resolve_team_alias( def _live_team_alias_target( - model: str, team_model_aliases: Mapping[str, str], team_id: str | None, llm_router: Router | None + model: str, team_model_aliases: Mapping[str, str], team_id: str | None, llm_router: RegistryReader | None ) -> str: target: Final = team_model_aliases.get(model) if target is None: @@ -5539,7 +5540,7 @@ async def can_key_call_model( model: str | list[str], llm_model_list: Sequence[object] | None, valid_token: UserAPIKeyAuth, - llm_router: litellm.Router | None, + llm_router: RegistryReader | None, prisma_client: DatabaseClient | None = None, ) -> Literal[True]: """ @@ -5618,7 +5619,7 @@ async def can_key_call_resolved_model( model: str, llm_model_list: Sequence[object] | None, valid_token: UserAPIKeyAuth, - llm_router: litellm.Router | None, + llm_router: RegistryReader | None, ) -> None: from litellm.proxy.proxy_server import ( prisma_client, @@ -5766,7 +5767,7 @@ def can_org_access_model( async def can_team_access_model( model: str | list[str], team_object: LiteLLM_TeamTable | None, - llm_router: Router | None, + llm_router: RegistryReader | None, team_model_aliases: dict[str, str] | None = None, key_model_aliases: Mapping[str, str] | None = None, prisma_client: DatabaseClient | None = None, @@ -5869,7 +5870,7 @@ async def key_access_group_grants_model( model: str | list[str], valid_token: UserAPIKeyAuth | None, team_object: LiteLLM_TeamTable | None, - llm_router: Router | None, + llm_router: RegistryReader | None, key_model_aliases: Mapping[str, str] | None = None, ) -> bool: """ @@ -5905,7 +5906,7 @@ _key_access_group_grants_model: Final = key_access_group_grants_model def can_project_access_model( model: str | list[str], project_object: LiteLLM_ProjectTable, - llm_router: Router | None, + llm_router: RegistryReader | None, key_model_aliases: Mapping[str, str] | None = None, ) -> Literal[True]: """ @@ -5926,7 +5927,7 @@ def can_project_access_model( def can_customer_access_model( model: str | list[str], end_user_object: LiteLLM_EndUserTable, - llm_router: Router | None, + llm_router: RegistryReader | None, valid_token: UserAPIKeyAuth | None, ) -> Literal[True]: team_model_aliases: Final = team_model_aliases_for_auth_check(valid_token) if valid_token is not None else None @@ -6089,7 +6090,7 @@ async def _team_grants_personal_key_model( model: str, team_object: LiteLLM_TeamTableCachedObj, valid_token: UserAPIKeyAuth, - llm_router: Router | None, + llm_router: RegistryReader | None, prisma_client: PrismaClient | None, user_api_key_cache: UserApiKeyCache, proxy_logging_obj: ProxyLogging, @@ -6127,7 +6128,7 @@ async def _loaded_teams_allow_model( model: str, teams: tuple[LiteLLM_TeamTableCachedObj | None, ...], valid_token: UserAPIKeyAuth, - llm_router: Router | None, + llm_router: RegistryReader | None, prisma_client: PrismaClient | None, user_api_key_cache: UserApiKeyCache, proxy_logging_obj: ProxyLogging, @@ -6393,7 +6394,7 @@ async def can_personal_key_call_model_via_teams( model: str | Sequence[str], user_object: LiteLLM_UserTable | None, valid_token: UserAPIKeyAuth, - llm_router: Router | None, + llm_router: RegistryReader | None, prisma_client: PrismaClient | None, user_api_key_cache: UserApiKeyCache, proxy_logging_obj: ProxyLogging, @@ -7185,7 +7186,7 @@ async def check_team_member_model_access( model: str | list[str], team_object: LiteLLM_TeamTable, valid_token: UserAPIKeyAuth, - llm_router: Router | None, + llm_router: RegistryReader | None, prisma_client: Optional["PrismaClient"], user_api_key_cache: UserApiKeyCache, proxy_logging_obj: ProxyLogging, diff --git a/litellm/proxy/auth/fallback_budget.py b/litellm/proxy/auth/fallback_budget.py index 95ff11261d9..5065c69e512 100644 --- a/litellm/proxy/auth/fallback_budget.py +++ b/litellm/proxy/auth/fallback_budget.py @@ -44,7 +44,7 @@ from litellm.proxy.auth.auth_checks import ( # noqa: F401 # legacy module expo _is_model_cost_zero, # pyright: ignore[reportPrivateUsage,reportUnusedImport] # backwards-compatible package export is_model_cost_zero, # pyright: ignore[reportPrivateUsage] # the zero-cost predicate the auth-time budget checks use; no public equivalent ) -from litellm.router import Router +from litellm.router_api import RegistryReader, RoutingContext from litellm.types.llms.base import LiteLLMBaseModel @@ -118,7 +118,7 @@ async def is_token_within_budget_for_model( *, model: str, valid_token: UserAPIKeyAuth, - llm_router: Router, + llm_router: RegistryReader, team_member_model_budget_limiter: _TeamMemberModelBudgetLimiter | None = None, ) -> bool: """ @@ -187,19 +187,19 @@ class RouterFallbackBudgetCheck: is_enforced: Callable[[], bool] team_member_model_budget_limiter: _TeamMemberModelBudgetLimiter | None = None - async def __call__(self, *, model: str, request_kwargs: Mapping[str, object], llm_router: Router) -> bool: + async def __call__(self, *, model: str, request_kwargs: Mapping[str, object], ctx: RoutingContext) -> bool: if not self.is_enforced(): return True valid_token: Final = _user_api_key_auth_from_request(request_kwargs) if valid_token is None: return True - budget_models: Final = tuple(dict.fromkeys((model, llm_router.registry().resolve(model)))) + budget_models: Final = tuple(dict.fromkeys((model, ctx.registry().resolve(model)))) for budget_model in budget_models: try: if not await is_token_within_budget_for_model( model=budget_model, valid_token=valid_token, - llm_router=llm_router, + llm_router=ctx, team_member_model_budget_limiter=self.team_member_model_budget_limiter, ): return False diff --git a/litellm/proxy/auth/fallback_model_access.py b/litellm/proxy/auth/fallback_model_access.py index fe80dc7a90b..b550d4d6866 100644 --- a/litellm/proxy/auth/fallback_model_access.py +++ b/litellm/proxy/auth/fallback_model_access.py @@ -18,7 +18,7 @@ from pydantic import ValidationError from litellm._logging import verbose_proxy_logger from litellm.proxy._types import ProxyException, UserAPIKeyAuth from litellm.proxy.auth.auth_checks import can_key_call_resolved_model, can_token_call_search_tool -from litellm.router import Router +from litellm.router_api import RegistryReader, RoutingContext from litellm.search import asearch from litellm.types.llms.base import LiteLLMBaseModel @@ -31,7 +31,7 @@ class _FallbackAccessSettings(LiteLLMBaseModel): enforce_fallback_model_access: bool = True -async def is_model_authorized_for_token(*, model: str, valid_token: UserAPIKeyAuth, llm_router: Router) -> bool: +async def is_model_authorized_for_token(*, model: str, valid_token: UserAPIKeyAuth, llm_router: RegistryReader) -> bool: try: await can_key_call_resolved_model( model=model, @@ -98,7 +98,7 @@ class RouterFallbackAccessCheck: is_enforced: Callable[[], bool] - async def __call__(self, *, model: str, request_kwargs: Mapping[str, object], llm_router: Router) -> bool: + async def __call__(self, *, model: str, request_kwargs: Mapping[str, object], ctx: RoutingContext) -> bool: valid_token: Final = _user_api_key_auth_from_request(request_kwargs) if valid_token is None: return True @@ -106,7 +106,7 @@ class RouterFallbackAccessCheck: return await is_search_tool_authorized_for_token(search_tool_name=model, valid_token=valid_token) if not self.is_enforced(): return True - return await is_model_authorized_for_token(model=model, valid_token=valid_token, llm_router=llm_router) + return await is_model_authorized_for_token(model=model, valid_token=valid_token, llm_router=ctx) router_fallback_access_check: Final = RouterFallbackAccessCheck(is_enforced=_enforced_by_general_settings) diff --git a/litellm/proxy/auth/model_checks.py b/litellm/proxy/auth/model_checks.py index cfc0d2750bd..4bcf020a9c4 100644 --- a/litellm/proxy/auth/model_checks.py +++ b/litellm/proxy/auth/model_checks.py @@ -14,13 +14,13 @@ from typing import Final, TypeVar import litellm from litellm._logging import verbose_proxy_logger from litellm.litellm_core_utils.credential_accessor import CredentialAccessor +from litellm.litellm_core_utils.pattern_match_deployments import PatternMatchRouter from litellm.llms.azure.ptu_capacity import is_str_keyed_mapping from litellm.proxy._types import SpecialModelNames, UserAPIKeyAuth from litellm.repositories.object_permission_repository import ObjectPermissionRepository from litellm.responses.main import strip_responses_routing_prefix from litellm.router import Router -from litellm.router_utils.fallback_event_handlers import get_fallback_model_group -from litellm.router_utils.pattern_match_deployments import PatternMatchRouter +from litellm.router_api import fallback_chain from litellm.types.router import CredentialLiteLLMParams, LiteLLM_Params from litellm.types.utils import LlmProviders from litellm.utils import ProviderConfigManager, get_valid_models, potential_model_names_in_lookup_order @@ -708,7 +708,7 @@ def get_all_fallbacks( try: # Use existing function to get fallback model group - fallback_model_group, _ = get_fallback_model_group(fallbacks=fallbacks_config, model_group=model) + fallback_model_group, _ = fallback_chain(fallbacks=fallbacks_config, model_group=model) if fallback_model_group is None: return [] diff --git a/litellm/proxy/auth/user_api_key_auth.py b/litellm/proxy/auth/user_api_key_auth.py index 67410e867d6..2b0522c09b5 100644 --- a/litellm/proxy/auth/user_api_key_auth.py +++ b/litellm/proxy/auth/user_api_key_auth.py @@ -40,6 +40,7 @@ from litellm.integrations.otel.model.config import is_otel_v2_enabled from litellm.integrations.otel.runtime import phase_event, phase_span, seed_request_identity from litellm.litellm_core_utils.dd_tracing import tracer from litellm.litellm_core_utils.dot_notation_indexing import get_nested_value +from litellm.litellm_core_utils.routing_common_utils import resolve_model_group_alias, resolve_served_model from litellm.models.end_user import LiteLLM_EndUserTable from litellm.proxy._types import * from litellm.proxy.agent_endpoints.auth.agent_caller import agent_caller_from_headers @@ -182,13 +183,7 @@ from litellm.proxy.utils import ( from litellm.repositories.table_repositories import JWTKeyMappingRepository, TeamMembershipRepository from litellm.repositories.user_repository import UserRepository from litellm.repositories.verification_token_repository import VerificationTokenRepository -from litellm.router_utils.common_utils import resolve_model_group_alias, resolve_served_model -from litellm.router_utils.fallback_event_handlers import ( - PROVIDER_SCOPED_RESOURCE_KEYS, - fallback_lookup_groups, - fallbacks_disabled_for_request, - get_fallback_model_group_for_lookup_groups, -) +from litellm.router_api import fallbacks_disabled, references_provider_scoped_resource, request_fallback_chain from litellm.secret_managers.main import get_secret_bool from litellm.types.services import ServiceTypes @@ -811,11 +806,7 @@ async def _check_team_member_model_budget_for_model( model=model_name, ) except litellm.BudgetExceededError: - if ( - request_data.get("model") != model_name - or llm_router is None - or fallbacks_disabled_for_request(kwargs=request_data) - ): + if request_data.get("model") != model_name or llm_router is None or fallbacks_disabled(request_data): raise fallback_succeeded: Final = await _try_team_member_model_budget_fallback( user_id=user_id, @@ -857,9 +848,9 @@ async def _try_team_member_model_budget_fallback( user_api_key_cache: UserApiKeyCache | None = None, proxy_logging_obj: ProxyLogging | None = None, ) -> bool: - if request.headers.get("content-type", "").lower().startswith("multipart/form-data") or any( - request_data.get(key) for key in PROVIDER_SCOPED_RESOURCE_KEYS - ): + if request.headers.get("content-type", "").lower().startswith( + "multipart/form-data" + ) or references_provider_scoped_resource(request_data): return False from litellm.proxy import proxy_server @@ -896,10 +887,7 @@ async def _try_team_member_model_budget_fallback( if router_fallbacks is None: return False - fallback_models, _ = get_fallback_model_group_for_lookup_groups( - fallbacks=list(router_fallbacks), - lookup_groups=fallback_lookup_groups(kwargs=request_data, model_group=model_name), - ) + fallback_models, _ = request_fallback_chain(list(router_fallbacks), request_data, model_name) fallback_targets: Final[Sequence[object]] = fallback_models or () fallback_candidates: Final[tuple[str, ...]] = tuple( model for target in fallback_targets if (model := _budget_fallback_target_model(target)) is not None diff --git a/litellm/proxy/bug_report_config.py b/litellm/proxy/bug_report_config.py index d7b920de4d5..6c0209644b4 100644 --- a/litellm/proxy/bug_report_config.py +++ b/litellm/proxy/bug_report_config.py @@ -19,8 +19,8 @@ from litellm.litellm_core_utils.bug_report import ( build_bug_report, build_environment_report, ) +from litellm.litellm_core_utils.routing_groups import VALID_ROUTING_STRATEGIES from litellm.proxy._types import ConfigGeneralSettings -from litellm.router_utils.routing_groups import VALID_ROUTING_STRATEGIES from litellm.types.caching import LiteLLMCacheType from litellm.types.guardrails import GuardrailEventHooks, LitellmParams, SupportedGuardrailIntegrations from litellm.types.secret_managers.main import KeyManagementSystem diff --git a/litellm/proxy/common_request_processing.py b/litellm/proxy/common_request_processing.py index 9b2813a8cd8..c9b6fff3a00 100644 --- a/litellm/proxy/common_request_processing.py +++ b/litellm/proxy/common_request_processing.py @@ -53,6 +53,7 @@ from litellm.constants import ( ) from litellm.integrations.custom_guardrail import CustomGuardrail from litellm.integrations.otel.runtime import phase_event +from litellm.litellm_core_utils.add_retry_fallback_headers import get_hidden_params_dict from litellm.litellm_core_utils.bug_report import ( allowlisted, bug_report_notice, @@ -81,6 +82,7 @@ from litellm.litellm_core_utils.llm_cost_calc.guardrail_cost import ( from litellm.litellm_core_utils.llm_response_utils.get_headers import ( get_response_headers, ) +from litellm.litellm_core_utils.routing_common_utils import resolve_model_group_alias, resolve_served_model from litellm.litellm_core_utils.safe_json_dumps import safe_dumps from litellm.litellm_core_utils.served_output_texts import ( record_served_output_texts, @@ -146,8 +148,6 @@ from litellm.responses.streaming_iterator import partial_responses_incomplete_ev from litellm.router import Router from litellm.router_api import RoutingContext from litellm.router_strategy.auto_router.auto_router_model_naming import AUTO_ROUTER_MODEL_PREFIX -from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict -from litellm.router_utils.common_utils import resolve_model_group_alias, resolve_served_model from litellm.types.extraction import ExtractionResponse from litellm.types.guardrails import GuardrailEventHooks from litellm.types.router import RouterRateLimitError @@ -2565,7 +2565,7 @@ class ProxyBaseLLMRequestProcessing: aliased_model: Final = self.data.get("model") if llm_router is not None and route_type in ROUTER_SCHEDULED_ROUTE_TYPES and isinstance(aliased_model, str): self.data.update( - llm_router.priority_header_update( + llm_router.health().priority_header_fields( model=aliased_model, kwargs=self.data, header=request.headers.get(SCHEDULER_PRIORITY_HEADER) ) ) @@ -2831,12 +2831,9 @@ class ProxyBaseLLMRequestProcessing: @staticmethod def _resolve_fallback_models(model: str, fallbacks: list) -> list[str] | None: - from litellm.router_utils.fallback_event_handlers import get_fallback_model_group + from litellm.router_api import fallback_chain - fallback_model_group, generic_fallback_idx = get_fallback_model_group( - fallbacks=fallbacks, - model_group=model, - ) + fallback_model_group, generic_fallback_idx = fallback_chain(fallbacks, model) if fallback_model_group is not None: return fallback_model_group return fallbacks[generic_fallback_idx]["*"] if generic_fallback_idx is not None else None @@ -4190,8 +4187,8 @@ class ProxyBaseLLMRequestProcessing: HiddenParamsAsyncIteratorWrapper, so class sniffing runs on the unwrapped inner iterator. """ + from litellm.litellm_core_utils.add_retry_fallback_headers import HiddenParamsAsyncIteratorWrapper from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper - from litellm.router_utils.add_retry_fallback_headers import HiddenParamsAsyncIteratorWrapper unwrapped: Final = response.inner if isinstance(response, HiddenParamsAsyncIteratorWrapper) else response diff --git a/litellm/proxy/common_utils/cache_aware_routing.py b/litellm/proxy/common_utils/cache_aware_routing.py index 08728b97b54..dfab1847ab8 100644 --- a/litellm/proxy/common_utils/cache_aware_routing.py +++ b/litellm/proxy/common_utils/cache_aware_routing.py @@ -16,6 +16,7 @@ from litellm.litellm_core_utils.core_helpers import get_metadata_variable_name_f from litellm.llms.anthropic.cache_aware_routing import AnthropicCacheRouting, TokenCounter from litellm.proxy._types import UserAPIKeyAuth from litellm.proxy.auth.auth_checks import can_key_call_resolved_model +from litellm.router_deprecated import renamed_router_param from litellm.router_strategy.complexity_router.config import ComplexityRouterConfig from litellm.types.llms.base import LiteLLMBaseModel from litellm.types.router import Deployment, PreRoutingHookResponse @@ -23,6 +24,7 @@ from litellm.types.utils import StandardLoggingRoutingDecision if TYPE_CHECKING: from litellm.router import Router + from litellm.router_api import RoutingContext _MESSAGES: Final = TypeAdapter(list[Mapping[str, object]]) _MAPPING: Final = TypeAdapter(Mapping[str, object]) @@ -231,7 +233,7 @@ async def select_cached_model( async def _choose_cached_model( *, - router: Router, + ctx: RoutingContext, config: ComplexityRouterConfig, params_for_model: Callable[[str, str], Mapping[str, object]], response: PreRoutingHookResponse | None, @@ -249,8 +251,10 @@ async def _choose_cached_model( ) from litellm.router_strategy.complexity_router.context_compaction import compaction_pending + router: Final = proxy_server.llm_router if ( - proxy_server.llm_router is not router + router is None + or not ctx.belongs_to(router) or router.registry().plugins("routing") or has_request_transforms() or compaction_pending(request_kwargs) @@ -318,9 +322,10 @@ async def _choose_cached_model( ) +@renamed_router_param("router") async def choose_cached_model( *, - router: Router, + ctx: RoutingContext, config: ComplexityRouterConfig, params_for_model: Callable[[str, str], Mapping[str, object]], response: PreRoutingHookResponse | None, @@ -332,7 +337,7 @@ async def choose_cached_model( try: return await asyncio.wait_for( _choose_cached_model( - router=router, + ctx=ctx, config=config, params_for_model=params_for_model, response=response, diff --git a/litellm/proxy/common_utils/credential_hydration.py b/litellm/proxy/common_utils/credential_hydration.py index f6a6c682cf0..664290fb3fc 100644 --- a/litellm/proxy/common_utils/credential_hydration.py +++ b/litellm/proxy/common_utils/credential_hydration.py @@ -12,10 +12,10 @@ from types import MappingProxyType from typing import Final, cast # noqa: TID251 # narrows untyped credential values at the decrypt boundary import litellm +from litellm.litellm_core_utils.clientside_credential_handler import clientside_credential_keys from litellm.proxy.common_utils.encrypt_decrypt_utils import decrypt_value_helper from litellm.proxy.utils import PrismaClient from litellm.repositories.credentials_repository import CredentialsRepository -from litellm.router_utils.clientside_credential_handler import clientside_credential_keys from litellm.types.router import ( GenericLiteLLMParams, server_owned_wif_fields_present, diff --git a/litellm/proxy/common_utils/model_listing_utils.py b/litellm/proxy/common_utils/model_listing_utils.py index a9424018d9a..9db67aa3808 100644 --- a/litellm/proxy/common_utils/model_listing_utils.py +++ b/litellm/proxy/common_utils/model_listing_utils.py @@ -21,7 +21,7 @@ from pydantic import TypeAdapter, ValidationError import litellm from litellm.constants import CLAUDE_CODE_CLIENT, CLAUDE_CODE_PICKER_PATTERN, GATEWAY_CLIENT_HEADER -from litellm.router_utils.common_utils import resolve_model_group_alias +from litellm.litellm_core_utils.routing_common_utils import resolve_model_group_alias if TYPE_CHECKING: from litellm.router import Router diff --git a/litellm/proxy/guardrails/guardrail_hooks/headroom/headroom.py b/litellm/proxy/guardrails/guardrail_hooks/headroom/headroom.py index 7f48766bf26..0b762b2d5fe 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/headroom/headroom.py +++ b/litellm/proxy/guardrails/guardrail_hooks/headroom/headroom.py @@ -29,6 +29,7 @@ from litellm.litellm_core_utils.prompt_templates.factory import ( has_tool_with_name, ) from litellm.litellm_core_utils.provider_affinity import get_caller_session_id +from litellm.litellm_core_utils.routing_common_utils import request_user_api_key_auth from litellm.llms.custom_httpx.http_handler import ( get_async_httpx_client, # pyright: ignore[reportUnknownVariableType] httpxSpecialProvider, @@ -40,7 +41,6 @@ from litellm.proxy.guardrails.guardrail_hooks.content_text import ( merge_rewritten_text_parts, ) from litellm.proxy.spend_tracking.compression_savings import HEADROOM_GUARDRAIL_PROVIDER -from litellm.router_utils.common_utils import request_user_api_key_auth from litellm.secret_managers.main import get_secret_str from litellm.types.guardrails import GuardrailEventHooks, Mode from litellm.types.integrations.custom_logger import ( diff --git a/litellm/proxy/guardrails/guardrail_hooks/semantic_guard/route_loader.py b/litellm/proxy/guardrails/guardrail_hooks/semantic_guard/route_loader.py index 342e5b64714..ace0e194ee9 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/semantic_guard/route_loader.py +++ b/litellm/proxy/guardrails/guardrail_hooks/semantic_guard/route_loader.py @@ -14,6 +14,7 @@ from pydantic import TypeAdapter from litellm._logging import verbose_logger from litellm.constants import DEFAULT_SEMANTIC_GUARD_SIMILARITY_THRESHOLD +from litellm.router_api import RoutingContext if TYPE_CHECKING: from semantic_router.routers import SemanticRouter @@ -134,7 +135,7 @@ class SemanticGuardRouteLoader: ) encoder: Final = LiteLLMRouterEncoder( - litellm_router_instance=litellm_router, + ctx=RoutingContext(litellm_router), model_name=embedding_model, score_threshold=global_threshold, ) diff --git a/litellm/proxy/health_check.py b/litellm/proxy/health_check.py index 20d920f1104..de2ed4fd4ba 100644 --- a/litellm/proxy/health_check.py +++ b/litellm/proxy/health_check.py @@ -27,12 +27,12 @@ from litellm.constants import ( HEALTH_CHECK_TIMEOUT_SECONDS, ) from litellm.litellm_core_utils.health_check_helpers import native_health_check_mode +from litellm.litellm_core_utils.routing_common_utils import deployment_model_id_pin, is_model_capability_field from litellm.router_strategy.auto_router.auto_router_model_naming import ( StrategyRouterDependency, classify_strategy_router_model, strategy_router_dependencies, ) -from litellm.router_utils.common_utils import deployment_model_id_pin, is_model_capability_field from litellm.types.utils import secret_bearing_wif_litellm_params, server_owned_wif_litellm_params # Provider routing and server-owned federation or OAuth token-exchange fields. Allowed for proxy diff --git a/litellm/proxy/health_check_utils/shared_health_check_manager.py b/litellm/proxy/health_check_utils/shared_health_check_manager.py index d689ab2a537..cf090d82990 100644 --- a/litellm/proxy/health_check_utils/shared_health_check_manager.py +++ b/litellm/proxy/health_check_utils/shared_health_check_manager.py @@ -13,10 +13,10 @@ from litellm.caching.redis_cache import RedisCache from litellm.constants import ( DEFAULT_SHARED_HEALTH_CHECK_LOCK_TTL, DEFAULT_SHARED_HEALTH_CHECK_TTL, + HEALTH_CHECKS_TARGET, ) from litellm.litellm_core_utils.safe_json_dumps import safe_dumps from litellm.proxy.health_check import perform_health_check -from litellm.router_utils.health_state_cache import HEALTH_CHECKS_TARGET if TYPE_CHECKING: from litellm.router import Router diff --git a/litellm/proxy/health_endpoints/_health_endpoints.py b/litellm/proxy/health_endpoints/_health_endpoints.py index 8545e0609db..333687b07cd 100644 --- a/litellm/proxy/health_endpoints/_health_endpoints.py +++ b/litellm/proxy/health_endpoints/_health_endpoints.py @@ -26,7 +26,12 @@ from litellm.integrations.SlackAlerting.ms_teams import ( build_ms_teams_payload, get_ms_teams_webhook_url, ) +from litellm.litellm_core_utils.clientside_credential_handler import ( + _ADMIN_CONFIG_FIELDS_TO_CLEAR_ON_BASE_OVERRIDE, # pyright: ignore[reportPrivateUsage] # one canonical list, shared with the router path + clientside_credential_keys, +) from litellm.litellm_core_utils.custom_logger_registry import CustomLoggerRegistry +from litellm.litellm_core_utils.routing_common_utils import resolve_model_group_alias from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler from litellm.proxy._types import ( AlertType, @@ -94,11 +99,6 @@ from litellm.proxy.middleware.in_flight_requests_middleware import ( from litellm.proxy.shutdown.graceful_shutdown_manager import GracefulShutdownManager from litellm.router import Router from litellm.router_api import deployment_usable_by_team -from litellm.router_utils.clientside_credential_handler import ( - _ADMIN_CONFIG_FIELDS_TO_CLEAR_ON_BASE_OVERRIDE, # pyright: ignore[reportPrivateUsage] # one canonical list, shared with the router path - clientside_credential_keys, -) -from litellm.router_utils.common_utils import resolve_model_group_alias from litellm.secret_managers.main import get_secret_bool from litellm.types.proxy.litellm_pre_call_utils import RedactedDict, SecretFields from litellm.types.router import reject_server_owned_wif_fields diff --git a/litellm/proxy/hooks/dynamic_rate_limiter_v3.py b/litellm/proxy/hooks/dynamic_rate_limiter_v3.py index 0011f5cd082..dac2d219b38 100644 --- a/litellm/proxy/hooks/dynamic_rate_limiter_v3.py +++ b/litellm/proxy/hooks/dynamic_rate_limiter_v3.py @@ -15,6 +15,10 @@ from litellm._internal_context import with_service_target from litellm._logging import verbose_proxy_logger from litellm.caching.caching import DualCache from litellm.integrations.custom_logger import CustomLogger +from litellm.litellm_core_utils.add_retry_fallback_headers import ( + ensure_response_additional_headers, + response_has_hidden_params, +) from litellm.proxy._types import UserAPIKeyAuth from litellm.proxy.common_utils.proxy_rate_limit_error import ( ProxyRateLimitError, @@ -34,10 +38,6 @@ from litellm.proxy.hooks.rate_limiter_utils import ( resolve_llm_provider_for_rate_limit, ) from litellm.proxy.utils import InternalUsageCache -from litellm.router_utils.add_retry_fallback_headers import ( - ensure_response_additional_headers, - response_has_hidden_params, -) from litellm.types.router import ModelGroupInfo from litellm.types.utils import CallTypesLiteral, LLMResponseTypes diff --git a/litellm/proxy/hooks/model_max_budget_limiter.py b/litellm/proxy/hooks/model_max_budget_limiter.py index 1c5d6e05f09..1c10826124e 100644 --- a/litellm/proxy/hooks/model_max_budget_limiter.py +++ b/litellm/proxy/hooks/model_max_budget_limiter.py @@ -204,7 +204,7 @@ def _team_public_names_by_group(router: "Router", team_id: str | None) -> Mappin groups_by_name: Final = MappingProxyType( { name: model_access_groups_of(router=router, model=name, team_id=team_id) - for name in router.team_public_model_names_of(team_id) + for name in router.registry().names(kind="team_public", team_id=team_id) } ) return MappingProxyType( diff --git a/litellm/proxy/hooks/parallel_request_limiter_v3.py b/litellm/proxy/hooks/parallel_request_limiter_v3.py index 15282679622..a515c051bbd 100644 --- a/litellm/proxy/hooks/parallel_request_limiter_v3.py +++ b/litellm/proxy/hooks/parallel_request_limiter_v3.py @@ -49,6 +49,10 @@ from litellm.constants import ( ) from litellm.cost_calculator import get_usage_object from litellm.integrations.custom_logger import CustomLogger +from litellm.litellm_core_utils.add_retry_fallback_headers import ( + ensure_response_additional_headers, + response_has_hidden_params, +) from litellm.litellm_core_utils.audio_utils.utils import estimate_audio_tokens from litellm.litellm_core_utils.core_helpers import as_str_mapping from litellm.litellm_core_utils.prompt_templates.common_utils import ( @@ -56,6 +60,8 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import ( split_media_for_tpm, ) from litellm.litellm_core_utils.ptu_pricing import is_ptu_cost_attribution_enabled +from litellm.litellm_core_utils.ptu_shares import PTUTeamCeiling +from litellm.litellm_core_utils.routing_common_utils import resolve_model_group_alias from litellm.litellm_core_utils.token_counter import estimate_image_tokens, offload_token_count from litellm.llms.azure.ptu_capacity import normalized_tokens from litellm.proxy._types import UserAPIKeyAuth @@ -86,12 +92,6 @@ from litellm.proxy.spend_tracking.input_tokens import ( openai_chat_pdf_file_tokens, ) from litellm.responses.litellm_completion_transformation.compaction_items import billable_input_since_newest_compaction -from litellm.router_utils.add_retry_fallback_headers import ( - ensure_response_additional_headers, - response_has_hidden_params, -) -from litellm.router_utils.common_utils import resolve_model_group_alias -from litellm.router_utils.ptu_shares import PTUTeamCeiling from litellm.types.caching import RedisPipelineIncrementOperation from litellm.types.extraction import ExtractionResponse from litellm.types.llms.openai import BaseLiteLLMOpenAIResponseObject, ResponseAPIUsage @@ -3561,9 +3561,6 @@ class _PROXY_MaxParallelRequestsHandler_v3(CustomLogger): Returns True if any deployment has failures in the current minute. """ from litellm.proxy.proxy_server import llm_router - from litellm.router_utils.router_callbacks.track_deployment_metrics import ( - get_deployment_failures_for_current_minute, - ) if llm_router is None: return False @@ -3581,10 +3578,7 @@ class _PROXY_MaxParallelRequestsHandler_v3(CustomLogger): continue # Use router's existing failure tracking - failure_count = get_deployment_failures_for_current_minute( - litellm_router_instance=llm_router, - deployment_id=deployment_id, - ) + failure_count = llm_router.health().failures_this_minute(deployment_id) if failure_count > DYNAMIC_RATE_LIMIT_ERROR_THRESHOLD_PER_MINUTE: verbose_proxy_logger.debug( diff --git a/litellm/proxy/litellm_pre_call_utils.py b/litellm/proxy/litellm_pre_call_utils.py index edaacd53d22..4444d6d25f9 100644 --- a/litellm/proxy/litellm_pre_call_utils.py +++ b/litellm/proxy/litellm_pre_call_utils.py @@ -3291,7 +3291,7 @@ def _fallback_edges( and its provider-stripped suffix, plus the router matcher run over the fuzzy entries that have not fired yet (tracked in ``fired_fuzzy`` by ``(list_index, entry_index)``), so each entry's targets are expanded once.""" - from litellm.router_utils.fallback_event_handlers import get_fallback_model_group + from litellm.router_api import fallback_chain stripped: Final = model_group.split("/", 1)[1] if "/" in model_group else None targets: Final[set[str]] = set() # mutable-ok: accumulates fallback targets @@ -3302,7 +3302,7 @@ def _fallback_edges( pending = tuple(index for index in range(len(fuzzy)) if (list_index, index) not in fired_fuzzy) if not pending: continue - resolved = get_fallback_model_group(fallbacks=[fuzzy[index] for index in pending], model_group=model_group)[0] + resolved = fallback_chain([fuzzy[index] for index in pending], model_group)[0] values = resolved if isinstance(resolved, list) else ([resolved] if resolved is not None else []) targets.update(name for value in values if (name := _fallback_target_name(value)) is not None) if resolved is not None: @@ -3489,7 +3489,7 @@ async def _resolve_user_provider_credentials_for_request( status_code=400, detail=(f"fallback lists in the request body cannot exceed {_FALLBACK_DISCOVERY_LIMIT} entries"), ) - from litellm.router_utils.common_utils import resolve_model_group_alias + from litellm.litellm_core_utils.routing_common_utils import resolve_model_group_alias # Discovery must see the group the router actually routes to, so include the # post-alias name from every alias map that may still rewrite data["model"] diff --git a/litellm/proxy/management_endpoints/auto_router_endpoints.py b/litellm/proxy/management_endpoints/auto_router_endpoints.py index f4d307a6cda..42321fe1b1d 100644 --- a/litellm/proxy/management_endpoints/auto_router_endpoints.py +++ b/litellm/proxy/management_endpoints/auto_router_endpoints.py @@ -60,6 +60,7 @@ from litellm.repositories.table_repositories import PrismaTableRepository from litellm.repositories.team_repository import TeamRepository from litellm.repositories.user_repository import UserRepository from litellm.repositories.verification_token_repository import VerificationTokenRepository +from litellm.router_api import RoutingContext from litellm.router_strategy.auto_router.auto_router_model_naming import ( StrategyRouterDependencyRole, classify_strategy_router_model, @@ -614,7 +615,7 @@ async def preview_auto_router_routing( try: complexity_strategy: Final = ComplexityRouter( model_name=resolved.router_name, - litellm_router_instance=llm_router, + ctx=RoutingContext(llm_router), complexity_router_config=resolved.complexity_router_config.model_dump(exclude_none=True), default_model=resolved.complexity_router_config.resolve_default_model(resolved.default_model), derive_savings_baseline=False, diff --git a/litellm/proxy/management_endpoints/ptu_consumption.py b/litellm/proxy/management_endpoints/ptu_consumption.py index b09c07a0443..86a35fbbb0c 100644 --- a/litellm/proxy/management_endpoints/ptu_consumption.py +++ b/litellm/proxy/management_endpoints/ptu_consumption.py @@ -12,14 +12,14 @@ from types import MappingProxyType from typing import Final from litellm.litellm_core_utils.ptu_pricing import is_ptu_cost_attribution_enabled -from litellm.llms.azure.ptu_capacity import PTUCapacity, normalized_tokens, ptu_hours -from litellm.router import Router -from litellm.router_utils.common_utils import resolve_model_group_alias -from litellm.router_utils.ptu_shares import ( +from litellm.litellm_core_utils.ptu_shares import ( model_group_ptu_capacity, routed_deployments, team_servable_deployments, ) +from litellm.litellm_core_utils.routing_common_utils import resolve_model_group_alias +from litellm.llms.azure.ptu_capacity import PTUCapacity, normalized_tokens, ptu_hours +from litellm.router import Router from litellm.types.proxy.management_endpoints.common_daily_activity import ( DailySpendData, MetricWithMetadata, diff --git a/litellm/proxy/management_helpers/model_quota_policy.py b/litellm/proxy/management_helpers/model_quota_policy.py index 7e66bfaf0ad..7cf2d7677e7 100644 --- a/litellm/proxy/management_helpers/model_quota_policy.py +++ b/litellm/proxy/management_helpers/model_quota_policy.py @@ -9,10 +9,10 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator import litellm from litellm.exceptions import BadRequestError from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider, is_openai_compatible_endpoint +from litellm.litellm_core_utils.pattern_match_deployments import PatternMatchRouter, PatternUtils +from litellm.litellm_core_utils.routing_common_utils import provider_for_generic_call from litellm.llms.azure.ptu_capacity import is_str_keyed_mapping from litellm.llms.openai_like.json_loader import JSONProviderRegistry -from litellm.router_utils.common_utils import provider_for_generic_call -from litellm.router_utils.pattern_match_deployments import PatternMatchRouter, PatternUtils from litellm.secret_managers.main import get_secret_str if TYPE_CHECKING: diff --git a/litellm/proxy/management_helpers/ptu_share_guard.py b/litellm/proxy/management_helpers/ptu_share_guard.py index 0c8b21d02c6..529ad60c353 100644 --- a/litellm/proxy/management_helpers/ptu_share_guard.py +++ b/litellm/proxy/management_helpers/ptu_share_guard.py @@ -5,8 +5,8 @@ from typing import Final from fastapi import HTTPException +from litellm.litellm_core_utils.ptu_shares import deployments_shared_with from litellm.router import Router -from litellm.router_utils.ptu_shares import deployments_shared_with def raise_if_teams_hold_ptu_shares(team_ids: Sequence[str], llm_router: Router | None) -> None: diff --git a/litellm/proxy/mcp_server/semantic_tool_filter.py b/litellm/proxy/mcp_server/semantic_tool_filter.py index 4fe723d6b24..8666c05079d 100644 --- a/litellm/proxy/mcp_server/semantic_tool_filter.py +++ b/litellm/proxy/mcp_server/semantic_tool_filter.py @@ -14,6 +14,7 @@ from litellm.litellm_core_utils.exception_mapping_utils import ExceptionCheckers from litellm.proxy.mcp_server.catalog import catalog_operation, global_manager from litellm.proxy.mcp_server.faults import iter_exception_tree from litellm.proxy.mcp_server.utils import MCP_TOOL_PREFIX_SEPARATOR +from litellm.router_api import RoutingContext if TYPE_CHECKING: from semantic_router.routers import SemanticRouter @@ -172,7 +173,7 @@ class SemanticMCPToolFilter: self.tool_router = SemanticRouter( routes=routes, encoder=LiteLLMRouterEncoder( - litellm_router_instance=self.router_instance, + ctx=RoutingContext(self.router_instance), model_name=self.embedding_model, score_threshold=self.similarity_threshold, ), @@ -247,7 +248,7 @@ class SemanticMCPToolFilter: router: Final = SemanticRouter( routes=[], encoder=LiteLLMRouterEncoder( - litellm_router_instance=self.router_instance, + ctx=RoutingContext(self.router_instance), model_name=self.embedding_model, score_threshold=self.similarity_threshold, ), diff --git a/litellm/proxy/openai_files_endpoints/files_endpoints.py b/litellm/proxy/openai_files_endpoints/files_endpoints.py index c1d4534ffa2..e613d744fb0 100644 --- a/litellm/proxy/openai_files_endpoints/files_endpoints.py +++ b/litellm/proxy/openai_files_endpoints/files_endpoints.py @@ -1786,7 +1786,7 @@ def _routed_model_name_on_provider( def _stored_model_name_routes_to_provider( llm_router: Router, custom_llm_provider: str, provider_model_names: frozenset[str], model_name: str ) -> bool: - routing_group: Final = llm_router.get_routing_group(model_name) + routing_group: Final = llm_router.registry().routing_group(model_name) routed_model_names: Final = ( tuple(routing_group.models) if routing_group is not None else (llm_router.registry().resolve(model_name),) ) diff --git a/litellm/proxy/policy_engine/response_retrieval.py b/litellm/proxy/policy_engine/response_retrieval.py index 2de3f01d640..514f05d0bcd 100644 --- a/litellm/proxy/policy_engine/response_retrieval.py +++ b/litellm/proxy/policy_engine/response_retrieval.py @@ -7,6 +7,7 @@ from pydantic import TypeAdapter from litellm._logging import verbose_proxy_logger from litellm.litellm_core_utils.core_helpers import get_or_create_metadata_bucket +from litellm.litellm_core_utils.routing_common_utils import resolve_model_group_alias from litellm.proxy.common_utils.callback_utils import ( add_guardrail_to_applied_guardrails_header, add_policy_sources_to_metadata, @@ -18,7 +19,6 @@ from litellm.proxy.policy_engine.policy_matcher import PolicyMatcher from litellm.proxy.policy_engine.policy_registry import get_policy_registry from litellm.proxy.policy_engine.policy_resolver import PolicyResolver from litellm.responses.utils import ResponsesAPIRequestUtils -from litellm.router_utils.common_utils import resolve_model_group_alias from litellm.types.proxy.policy_engine import PolicyMatchContext from litellm.types.proxy.policy_engine.pipeline_types import GuardrailPipeline diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py index 257740b4c7e..1f1ab52e70d 100644 --- a/litellm/proxy/proxy_server.py +++ b/litellm/proxy/proxy_server.py @@ -89,6 +89,11 @@ from litellm.constants import ( OPENAI_LIVE_SESSION_START_TIMEOUT_SECONDS, RUNTIME_UPDATABLE_ROUTER_SETTINGS, ) +from litellm.litellm_core_utils.access_windows import access_windows_config_error +from litellm.litellm_core_utils.add_retry_fallback_headers import ( + get_fallback_errors_from_headers, + get_hidden_params_dict, +) from litellm.litellm_core_utils.asyncify import asyncify from litellm.litellm_core_utils.bug_report import ( allowlisted, @@ -100,6 +105,8 @@ from litellm.litellm_core_utils.litellm_logging import ( initialize_sentry, ) from litellm.litellm_core_utils.logging_worker import GLOBAL_LOGGING_WORKER, LoggingWorker +from litellm.litellm_core_utils.routing_common_utils import resolve_model_group_alias +from litellm.litellm_core_utils.routing_groups import parse_routing_groups from litellm.litellm_core_utils.safe_json_dumps import safe_dumps from litellm.litellm_core_utils.safe_json_loads import safe_json_loads from litellm.litellm_core_utils.token_counter import ( @@ -189,13 +196,6 @@ from litellm.router_strategy.auto_router.auto_router_tuning_baseline import ( snapshot_tuning_baselines, tuning_limit_violation, ) -from litellm.router_utils.access_windows import access_windows_config_error -from litellm.router_utils.add_retry_fallback_headers import ( - get_fallback_errors_from_headers, - get_hidden_params_dict, -) -from litellm.router_utils.common_utils import resolve_model_group_alias -from litellm.router_utils.routing_groups import parse_routing_groups from litellm.types.caching import RedisPipelineIncrementOperation from litellm.types.utils import ( PRICING_OVERRIDES_KEY, @@ -999,7 +999,7 @@ from litellm.router import ( LiteLLM_Params, ModelGroupInfo, ) -from litellm.router_api import ChangeSet, deployment_id +from litellm.router_api import ChangeSet, deployment_id, router_init_args from litellm.scheduler import FlowItem, Scheduler from litellm.secret_managers.aws_secret_manager import load_aws_kms from litellm.secret_managers.google_kms import load_google_kms @@ -4660,10 +4660,6 @@ def _write_health_state_to_router_cache( is on. """ from litellm.proxy.health_check import build_deployment_health_states - from litellm.router_utils.cooldown_handlers import set_cooldown_deployments - from litellm.router_utils.router_callbacks.track_deployment_metrics import ( - increment_deployment_failures_for_current_minute, - ) _exceptions: Final[dict] = exceptions_by_model_id or {} @@ -4715,18 +4711,7 @@ def _write_health_state_to_router_cache( ): continue - increment_deployment_failures_for_current_minute( - litellm_router_instance=llm_router, - deployment_id=model_id, - ) - - set_cooldown_deployments( - litellm_router_instance=llm_router, - original_exception=original_exception, - exception_status=exception_status, - deployment=model_id, - time_to_cooldown=router_settings.cooldown_time, - ) + llm_router.health().record_failure(model_id, original_exception, exception_status) except Exception as e: verbose_proxy_logger.warning("Failed to write health state to router cache: %s", str(e)) @@ -7370,9 +7355,7 @@ class ProxyConfig: router_settings: Final = config.get("router_settings", None) if router_settings and isinstance(router_settings, dict): - available_args: Final = [ - x for x in litellm.Router.get_valid_args() if x not in ROUTER_SETTINGS_MANAGED_OUTSIDE_CONFIG - ] + available_args: Final = [x for x in router_init_args() if x not in ROUTER_SETTINGS_MANAGED_OUTSIDE_CONFIG] for k, v in router_settings.items(): if k in available_args: @@ -9596,7 +9579,6 @@ class ProxyConfig: SearchToolRegistry, keep_loaded_search_tools_that_do_not_decrypt, ) - from litellm.router_utils.search_api_router import SearchAPIRouter try: db_search_tools: Final = keep_loaded_search_tools_that_do_not_decrypt( @@ -9620,7 +9602,21 @@ class ProxyConfig: ) if llm_router is not None: - await SearchAPIRouter.update_router_search_tools(router_instance=llm_router, search_tools=search_tools) + llm_router.apply( + ChangeSet( + assign={ + "search_tools": [ + { + "search_tool_id": tool.get("search_tool_id"), + "search_tool_name": tool.get("search_tool_name"), + "litellm_params": tool.get("litellm_params", {}), + "search_tool_info": tool.get("search_tool_info"), + } + for tool in search_tools + ] + } + ) + ) verbose_proxy_logger.info("Successfully loaded %s search tool(s) into router", len(search_tools)) else: verbose_proxy_logger.debug( @@ -16152,7 +16148,7 @@ def _enrich_model_info_with_litellm_data( if debug is True: _openai_client = "None" if llm_router is not None: - _openai_client = llm_router._get_client(deployment=model, kwargs={}, client_type="async") or "None" + _openai_client = llm_router.registry().client(model, client_type="async") or "None" else: _openai_client = "llm_router_is_None" openai_client: Final = str(_openai_client) @@ -18602,7 +18598,7 @@ async def async_queue_request( router: Final = llm_router data.update( - router.priority_header_update( + router.health().priority_header_fields( model=data["model"], kwargs=data, header=request.headers.get(SCHEDULER_PRIORITY_HEADER) ) ) @@ -19751,7 +19747,7 @@ async def update_config( raw_router_settings: Final = request_body.get("router_settings") if isinstance(raw_router_settings, dict): supported_router_settings: Final = RUNTIME_UPDATABLE_ROUTER_SETTINGS | ( - frozenset(litellm.Router.get_valid_args()) - ROUTER_SETTINGS_MANAGED_OUTSIDE_CONFIG + frozenset(router_init_args()) - ROUTER_SETTINGS_MANAGED_OUTSIDE_CONFIG ) unsupported_router_settings: Final = sorted(set(raw_router_settings) - supported_router_settings) if unsupported_router_settings: diff --git a/litellm/proxy/route_llm_request.py b/litellm/proxy/route_llm_request.py index a59f1967fc1..a17b7fee8c9 100644 --- a/litellm/proxy/route_llm_request.py +++ b/litellm/proxy/route_llm_request.py @@ -16,8 +16,9 @@ from pydantic import BeforeValidator, TypeAdapter, ValidationError import litellm from litellm.litellm_core_utils.core_helpers import normalize_drop_params from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj +from litellm.litellm_core_utils.routing_common_utils import is_proxy_admin_request from litellm.proxy._types import ProxyException, UserAPIKeyAuth -from litellm.router_utils.common_utils import is_proxy_admin_request +from litellm.router_api import router_init_args # Client-supplied params that make the router or the call path fabricate a # failure or a delay instead of calling the provider. The ``mock_testing_*`` @@ -93,7 +94,7 @@ async def _route_user_config_request(data: dict, route_type: str): # Filter router_config to only include valid Router.__init__ arguments # This prevents TypeError when invalid parameters are stored in the database - valid_args: Final = litellm.Router.get_valid_args() + valid_args: Final = router_init_args() filtered_config: Final = {k: v for k, v in router_config.items() if k in valid_args} logging_obj: Final = _request_logging_obj(JSON_OBJECT_ADAPTER.validate_python(data), route_type) diff --git a/litellm/proxy/spend_tracking/input_tokens.py b/litellm/proxy/spend_tracking/input_tokens.py index 59c7fe2a41b..9f37d2965bc 100644 --- a/litellm/proxy/spend_tracking/input_tokens.py +++ b/litellm/proxy/spend_tracking/input_tokens.py @@ -21,6 +21,7 @@ from typing import TYPE_CHECKING, Final import litellm from litellm._logging import verbose_proxy_logger from litellm.constants import OPENAI_CHAT_PDF_FILE_TOKENS, PDF_DATA_URL_PREFIX +from litellm.litellm_core_utils.deployment_pricing import deployment_pricing_models, str_keyed from litellm.litellm_core_utils.token_counter import ( deployment_openai_model, pdf_page_pricing, @@ -31,7 +32,6 @@ from litellm.responses.litellm_completion_transformation.compaction_items import billable_input_since_newest_compaction, holds_compaction_summary, ) -from litellm.router_utils.deployment_pricing import deployment_pricing_models, str_keyed from litellm.rust_bridge import runtime from litellm.rust_bridge.catalog import Route, RouteContext from litellm.rust_bridge.token_counter import ( @@ -162,7 +162,7 @@ def models_counted_for(model: str, llm_router: Router | None, team_id: str | Non def _routed_deployments(model: str, llm_router: Router, team_id: str | None) -> Sequence[object]: registry: Final = llm_router.registry() resolved: Final = registry.resolve(model, kind="alias") or model - routing_group: Final = llm_router.get_routing_group(resolved) + routing_group: Final = registry.routing_group(resolved) members: Final = routing_group.models if routing_group is not None else (resolved,) named: Final = tuple( chain.from_iterable(registry.deployments(member, source="all", team_id=team_id) for member in members) diff --git a/litellm/proxy/utils.py b/litellm/proxy/utils.py index af95a70261a..9e237ffcb57 100644 --- a/litellm/proxy/utils.py +++ b/litellm/proxy/utils.py @@ -160,10 +160,12 @@ from litellm.litellm_core_utils.core_helpers import ( independent_snapshot, is_expected_client_error, ) +from litellm.litellm_core_utils.deployment_pricing import pricing_models from litellm.litellm_core_utils.duration_parser import get_budget_window_start from litellm.litellm_core_utils.env_utils import get_env_float, get_env_int from litellm.litellm_core_utils.litellm_logging import BilledRoundsDispatch, Logging, deployment_pricing_model_info from litellm.litellm_core_utils.llm_cost_calc.utils import generic_cost_per_token +from litellm.litellm_core_utils.routing_common_utils import resolve_model_group_alias from litellm.litellm_core_utils.safe_json_dumps import safe_dumps from litellm.litellm_core_utils.safe_json_loads import safe_json_loads from litellm.litellm_core_utils.served_output_texts import ( @@ -278,8 +280,6 @@ from litellm.repositories.user_repository import UserRepository from litellm.repositories.verification_token_repository import ( VerificationTokenRepository, ) -from litellm.router_utils.common_utils import resolve_model_group_alias -from litellm.router_utils.deployment_pricing import pricing_models from litellm.secret_managers.main import str_to_bool from litellm.types.integrations.slack_alerting import DEFAULT_ALERT_TYPES from litellm.types.llms.openai import ResponsesAPIResponse diff --git a/litellm/responses/main.py b/litellm/responses/main.py index 9259103cb5c..b7b93a20b4e 100644 --- a/litellm/responses/main.py +++ b/litellm/responses/main.py @@ -42,6 +42,11 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import ( update_responses_tools_with_model_file_ids, ) from litellm.litellm_core_utils.provider_affinity import add_provider_affinity_header +from litellm.litellm_core_utils.reasoning_effort_capability import ( + deployment_reasoning_effort_levels, + model_group_from_metadata, + resolve_deployment_reasoning_effort, +) from litellm.llms.base_llm.responses.transformation import BaseResponsesAPIConfig from litellm.llms.custom_httpx.llm_http_handler import BaseLLMHTTPHandler from litellm.llms.openai.common_utils import get_openai_credentials @@ -63,11 +68,6 @@ from litellm.responses.mcp.round_billing import ( ) from litellm.responses.mcp.tool_precheck import may_name_litellm_mcp_gateway from litellm.responses.utils import ResponsesAPIRequestUtils -from litellm.router_utils.reasoning_effort_capability import ( - deployment_reasoning_effort_levels, - model_group_from_metadata, - resolve_deployment_reasoning_effort, -) from litellm.types.llms.openai import ( PromptObject, Reasoning, diff --git a/litellm/router.py b/litellm/router.py index 1d5c18ad22b..535072d5fcf 100644 --- a/litellm/router.py +++ b/litellm/router.py @@ -106,6 +106,20 @@ from litellm.integrations.custom_guardrail import CustomGuardrail, is_guardrail_ from litellm.integrations.custom_logger import CustomLogger from litellm.integrations.otel.routing import routing_decision_attributes from litellm.integrations.otel.runtime import phase_attributes, phase_event, phase_span +from litellm.litellm_core_utils.access_windows import access_windows_config_error, filter_reserved_deployments +from litellm.litellm_core_utils.add_retry_fallback_headers import ( + add_fallback_headers_to_response, + add_retry_headers_to_response, + apply_quality_router_decision_headers, + apply_remaining_usage_headers, + apply_response_model_id, + complexity_router_decision_headers, + ensure_response_additional_headers, + get_hidden_params_dict, + prepare_response_for_header_attachment, + replace_complexity_router_headers, + response_total_token_count, +) from litellm.litellm_core_utils.asyncify import run_async_function from litellm.litellm_core_utils.batch_utils import ( batch_create_routing, @@ -116,6 +130,10 @@ from litellm.litellm_core_utils.batch_utils import ( should_replace_model_in_jsonl, without_deployments_that_cannot_batch, ) +from litellm.litellm_core_utils.clientside_credential_handler import ( + get_dynamic_litellm_params, + is_clientside_credential, +) from litellm.litellm_core_utils.completion_timeout import CompletionTimeout from litellm.litellm_core_utils.core_helpers import ( coerce_token_limit, @@ -127,12 +145,17 @@ from litellm.litellm_core_utils.core_helpers import ( from litellm.litellm_core_utils.coroutine_checker import coroutine_checker from litellm.litellm_core_utils.credential_accessor import CredentialAccessor, reject_api_key_secret_reference from litellm.litellm_core_utils.dd_tracing import tracer +from litellm.litellm_core_utils.deployment_pricing import deployment_pricing_models from litellm.litellm_core_utils.get_llm_provider_logic import ( declared_authenticating_provider, inferred_provider, is_registered_custom_provider, resolve_model_and_provider_for_metadata, ) +from litellm.litellm_core_utils.get_retry_from_policy import ( + get_num_retries_from_retry_policy as _get_num_retries_from_retry_policy, +) +from litellm.litellm_core_utils.get_retry_from_policy import resolve_retry_policy from litellm.litellm_core_utils.hidden_params import ( HIDDEN_PARAMS_ATTR as _HIDDEN_PARAMS_ATTR, ) @@ -142,6 +165,7 @@ from litellm.litellm_core_utils.hidden_params import ( ) from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLogging from litellm.litellm_core_utils.llm_cost_calc.utils import SERVICE_TIER_COST_KEY_SUFFIXES +from litellm.litellm_core_utils.pattern_match_deployments import PatternMatchRouter from litellm.litellm_core_utils.ptu_pricing import ( PTU_COST_ATTRIBUTION_ENV_VAR, declares_ptu, @@ -152,10 +176,52 @@ from litellm.litellm_core_utils.ptu_pricing import ( ptu_terms, zeroed_ptu_pricing, ) +from litellm.litellm_core_utils.ptu_shares import ( + PTUTeamCeiling, + filter_ptu_shared_deployments, + ptu_capacity_warning, + ptu_share_teams, + share_holder_request_kwargs, + team_ptu_ceiling, +) +from litellm.litellm_core_utils.reasoning_effort_capability import ( + deployment_is_catalog_mapped, + intersect_supported_reasoning_efforts, + resolve_supported_reasoning_efforts, +) from litellm.litellm_core_utils.request_timeout_resolver import ( get_configured_request_timeout, get_service_tier_timeout, ) +from litellm.litellm_core_utils.routing_common_utils import ( + MID_STREAM_CONTINUATION_KWARG, + as_retry_skipped_deployment_ids, + deployment_model_id_pin, + deployments_the_caller_may_use, + filter_team_based_models, + filter_web_search_deployments, + format_content_policy_fallback_hint, + format_content_policy_no_fallback_note, + format_fallback_outcome_message, + format_no_fallback_group_message, + get_request_team_id, + is_proxy_admin_request, + provider_for_generic_call, + request_user_api_key_auth, + resolve_model_group_alias, + team_may_use_deployment, + truncate_fallback_error_detail, + warn_on_ignored_model_capability_flags, + warn_on_provider_credential_mismatch, + with_admin_api_key_secret_reference, + without_model_capability_flags, + without_router_only_kwargs, +) +from litellm.litellm_core_utils.routing_groups import ( + apply_routing_group_priority, + parse_routing_groups, + validate_routing_strategy, +) from litellm.litellm_core_utils.secret_redaction import redact_string from litellm.litellm_core_utils.sensitive_data_masker import ( SensitiveDataMasker, @@ -196,6 +262,7 @@ from litellm.router_api import ( aapply_changes, apply_changes, ) +from litellm.router_api import RoutingContext as RouterContext from litellm.router_api import deployment_id as _deployment_id from litellm.router_deprecated import DeprecatedRouterMembers from litellm.router_host import router_host @@ -233,49 +300,7 @@ from litellm.router_strategy.tag_based_routing import ( is_valid_deployment_tag, tags_with_serving_deployment_tags, ) -from litellm.router_utils.access_windows import access_windows_config_error, filter_reserved_deployments -from litellm.router_utils.add_retry_fallback_headers import ( - add_fallback_headers_to_response, - add_retry_headers_to_response, - apply_quality_router_decision_headers, - apply_remaining_usage_headers, - apply_response_model_id, - complexity_router_decision_headers, - ensure_response_additional_headers, - get_hidden_params_dict, - prepare_response_for_header_attachment, - replace_complexity_router_headers, - response_total_token_count, -) from litellm.router_utils.client_initalization_utils import InitalizeCachedClient, MaxParallelRequestsLimit -from litellm.router_utils.clientside_credential_handler import ( - get_dynamic_litellm_params, - is_clientside_credential, -) -from litellm.router_utils.common_utils import ( - MID_STREAM_CONTINUATION_KWARG, - as_retry_skipped_deployment_ids, - deployment_model_id_pin, - deployments_the_caller_may_use, - filter_team_based_models, - filter_web_search_deployments, - format_content_policy_fallback_hint, - format_content_policy_no_fallback_note, - format_fallback_outcome_message, - format_no_fallback_group_message, - get_request_team_id, - is_proxy_admin_request, - provider_for_generic_call, - request_user_api_key_auth, - resolve_model_group_alias, - team_may_use_deployment, - truncate_fallback_error_detail, - warn_on_ignored_model_capability_flags, - warn_on_provider_credential_mismatch, - with_admin_api_key_secret_reference, - without_model_capability_flags, - without_router_only_kwargs, -) from litellm.router_utils.cooldown_cache import CooldownCache from litellm.router_utils.cooldown_handlers import ( DEFAULT_COOLDOWN_TIME_SECONDS, @@ -292,7 +317,6 @@ from litellm.router_utils.cooldown_handlers import ( mark_deployment_selection_failure, set_cooldown_deployments, ) -from litellm.router_utils.deployment_pricing import deployment_pricing_models from litellm.router_utils.embedding_batch_size_check import ( async_log_rejection_before_provider_call, clear_rejected_before_provider_call, @@ -337,10 +361,6 @@ from litellm.router_utils.fallback_event_handlers import ( routed_deployment_id, run_async_fallback, ) -from litellm.router_utils.get_retry_from_policy import ( - get_num_retries_from_retry_policy as _get_num_retries_from_retry_policy, -) -from litellm.router_utils.get_retry_from_policy import resolve_retry_policy from litellm.router_utils.handle_error import ( async_raise_no_deployment_exception, send_llm_exception_alert, @@ -392,19 +412,6 @@ from litellm.router_utils.pre_call_checks.model_rate_limit_check import ( from litellm.router_utils.pre_call_checks.prompt_caching_deployment_check import ( PromptCachingDeploymentCheck, ) -from litellm.router_utils.ptu_shares import ( - PTUTeamCeiling, - filter_ptu_shared_deployments, - ptu_capacity_warning, - ptu_share_teams, - share_holder_request_kwargs, - team_ptu_ceiling, -) -from litellm.router_utils.reasoning_effort_capability import ( - deployment_is_catalog_mapped, - intersect_supported_reasoning_efforts, - resolve_supported_reasoning_efforts, -) from litellm.router_utils.request_priority import ( InvalidPriority, parse_default_priority, @@ -420,11 +427,6 @@ from litellm.router_utils.router_callbacks.track_deployment_metrics import ( increment_deployment_failures_for_current_minute, increment_deployment_successes_for_current_minute, ) -from litellm.router_utils.routing_groups import ( - apply_routing_group_priority, - parse_routing_groups, - validate_routing_strategy, -) from litellm.router_utils.routing_read_batch import ROUTER_USAGE_TARGET, RoutingPrefetch, RoutingReadBatch from litellm.router_utils.stream_usage_injection import router_config_requests_stream_usage from litellm.scheduler import FlowItem, Scheduler @@ -520,8 +522,6 @@ from litellm.utils import ( token_counter, ) -from .router_utils.pattern_match_deployments import PatternMatchRouter - if TYPE_CHECKING: from opentelemetry.trace import Span as _Span @@ -1610,6 +1610,7 @@ class Router(DeprecatedRouterMembers): router = Router(model_list=model_list, fallbacks=[{"azure-gpt-3.5-turbo": ["openai-gpt-3.5-turbo"]}]) ``` """ + self._core_ctx: Final = RouterContext(self) self.set_verbose = set_verbose self.ignore_invalid_deployments = ignore_invalid_deployments @@ -1885,7 +1886,7 @@ class Router(DeprecatedRouterMembers): if self._normalize_strategy(routing_strategy) == "lar1": from litellm.router_strategy.lar1_routing import apply_lar1_routing_strategy - apply_lar1_routing_strategy(self, routing_strategy_args) + apply_lar1_routing_strategy(self._core_ctx, routing_strategy_args) else: self.routing_strategy_init( routing_strategy=routing_strategy, @@ -2259,7 +2260,7 @@ class Router(DeprecatedRouterMembers): if strategy == "lar1": from litellm.router_strategy.lar1_routing import apply_lar1_routing_strategy - apply_lar1_routing_strategy(self, self.routing_strategy_args) + apply_lar1_routing_strategy(self._core_ctx, self.routing_strategy_args) return attr: Final = self._DEFAULT_SELECTOR_ATTR_BY_STRATEGY.get(strategy or "") @@ -2584,7 +2585,7 @@ class Router(DeprecatedRouterMembers): ) deployments: Final = self._core_get_model_list(model_name=model) if deployments: - RoutingPrefetch.arm(self, usage_selector, deployments) + RoutingPrefetch.arm(self._core_ctx, usage_selector, deployments) except Exception as e: # noqa: BLE001 # a prefetch is an optimisation, never a reason to fail the request verbose_router_logger.debug( "routing read prefetch not armed for %s: %s", _without_line_breaks(model), _without_line_breaks(e) @@ -3133,7 +3134,7 @@ class Router(DeprecatedRouterMembers): break if existing_ec_callback is not None: - existing_ec_callback.router = self + existing_ec_callback.ctx = self._core_ctx existing_ec_callback.enable_global_affinity = ( existing_ec_callback.enable_global_affinity or enable_global_affinity ) @@ -3141,7 +3142,7 @@ class Router(DeprecatedRouterMembers): ec_callback = existing_ec_callback else: ec_callback = EncryptedContentAffinityCheck( - router=self, + ctx=self._core_ctx, enable_global_affinity=enable_global_affinity, model_group_affinity_config=self.model_group_affinity_config, ) @@ -3690,7 +3691,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -4933,7 +4934,7 @@ class Router(DeprecatedRouterMembers): kwargs=kwargs, client_type="max_parallel_requests", ) - compacted_input: Final = await compact_to_fit(self, deployment, input_kwargs, "chat") + compacted_input: Final = await compact_to_fit(self._core_ctx, deployment, input_kwargs, "chat") async with contextlib.AsyncExitStack() as deployment_slot: if isinstance(max_parallel_requests_limit, MaxParallelRequestsLimit): deployment_slot.enter_context(max_parallel_requests_limit) @@ -5396,7 +5397,7 @@ class Router(DeprecatedRouterMembers): hop_kwargs: Final = _FALLBACK_HOP_ADAPTER.validate_python(kwargs) if _is_fallback_hop(hop_kwargs): EncryptedContentAffinityCheck.strip_reasoning_the_targets_cannot_decrypt( - self, + self._core_ctx, hop_kwargs.get("input"), hop_kwargs.get("messages"), (_FALLBACK_HOP_ADAPTER.validate_python(deployment),), @@ -6002,7 +6003,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -6114,7 +6115,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -6207,7 +6208,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -6269,7 +6270,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -6385,7 +6386,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -6455,7 +6456,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -6514,7 +6515,7 @@ class Router(DeprecatedRouterMembers): return _OPAQUE_VALUE_ADAPTER.validate_python( await SearchAPIRouter.async_search_with_fallbacks( - router_instance=self, + litellm_routing_ctx=self._core_ctx, original_function=original_function, **kwargs, ) @@ -6528,7 +6529,7 @@ class Router(DeprecatedRouterMembers): from litellm.router_utils.search_api_router import SearchAPIRouter return await SearchAPIRouter.async_search_with_fallbacks_helper( - router_instance=self, + litellm_routing_ctx=self._core_ctx, model=model, original_generic_function=original_generic_function, **kwargs, @@ -6646,7 +6647,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -6746,7 +6747,7 @@ class Router(DeprecatedRouterMembers): response_kwargs["custom_llm_provider"] = custom_llm_provider compacted_input: Final = await compact_to_fit( - self, + self._core_ctx, deployment, response_kwargs, surface_for_call(generic_function_name), @@ -7624,7 +7625,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -7703,7 +7704,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -7717,7 +7718,7 @@ class Router(DeprecatedRouterMembers): **kwargs, ) -> OpenAIFileObject: try: - from litellm.router_utils.common_utils import add_model_file_id_mappings + from litellm.litellm_core_utils.routing_common_utils import add_model_file_id_mappings verbose_router_logger.debug("Inside _atext_completion()- model: %s", model) parent_otel_span: Final = get_parent_otel_span_from_kwargs(kwargs) @@ -7943,7 +7944,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -8111,7 +8112,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -8142,7 +8143,7 @@ class Router(DeprecatedRouterMembers): except Exception as e: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=self, + ctx=self._core_ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -8932,7 +8933,7 @@ class Router(DeprecatedRouterMembers): # that fails with RouterRateLimitError whenever the "remaining" entries # are all in cooldown — the inner async_get_healthy_deployments call # would find an empty list and raise immediately. - cooldown_ids = set(await async_get_cooldown_deployments(litellm_router_instance=self, parent_otel_span=None)) + cooldown_ids = set(await async_get_cooldown_deployments(ctx=self._core_ctx, parent_otel_span=None)) remaining: Final = (all_ids - cooldown_ids) - excluded if not remaining: return None @@ -9012,7 +9013,7 @@ class Router(DeprecatedRouterMembers): raise e input_kwargs: Final = { - "litellm_router": self, + "litellm_routing_ctx": self._core_ctx, "original_exception": original_exception, **kwargs, "attempted_targets": fallback_walk, @@ -9228,7 +9229,7 @@ class Router(DeprecatedRouterMembers): parent_otel_span: Final = get_parent_otel_span_from_kwargs(kwargs) fallback_failure_exception_str = truncate_fallback_error_detail(redact_string(str(new_exception))) cooldown_info: Final = await async_get_cooldown_deployments_with_debug_info( - litellm_router_instance=self, + ctx=self._core_ctx, parent_otel_span=parent_otel_span, ) verbose_router_logger.error( @@ -9849,7 +9850,7 @@ class Router(DeprecatedRouterMembers): # Always track deployment successes for cooldown logic, regardless of TPM/RPM limits increment_deployment_successes_for_current_minute( - litellm_router_instance=self, + ctx=self._core_ctx, deployment_id=str(deployment_id), ) @@ -10029,7 +10030,7 @@ class Router(DeprecatedRouterMembers): if id is not None: key: Final = increment_deployment_successes_for_current_minute( - litellm_router_instance=self, + ctx=self._core_ctx, deployment_id=id, ) return key @@ -10140,11 +10141,11 @@ class Router(DeprecatedRouterMembers): if deployment_id is None: return False increment_deployment_failures_for_current_minute( - litellm_router_instance=self, + ctx=self._core_ctx, deployment_id=deployment_id, ) result: Final = set_cooldown_deployments( - litellm_router_instance=self, + ctx=self._core_ctx, exception_status=exception_status, original_exception=exception, deployment=deployment_id, @@ -10450,9 +10451,7 @@ class Router(DeprecatedRouterMembers): except Exception: pass - unhealthy_deployments: Final = get_cooldown_deployments( - litellm_router_instance=self, parent_otel_span=parent_otel_span - ) + unhealthy_deployments: Final = get_cooldown_deployments(ctx=self._core_ctx, parent_otel_span=parent_otel_span) unhealthy_set: Final = set(unhealthy_deployments) healthy_deployments: list = [d for d in _all_deployments if d["model_info"]["id"] not in unhealthy_set] healthy_deployments = self._filter_blocked_deployments(healthy_deployments) @@ -10480,7 +10479,7 @@ class Router(DeprecatedRouterMembers): pass unhealthy_deployments: Final = await async_get_cooldown_deployments( - litellm_router_instance=self, parent_otel_span=parent_otel_span + ctx=self._core_ctx, parent_otel_span=parent_otel_span ) # Convert to set for O(1) lookup instead of O(n) unhealthy_deployments_set: Final = set(unhealthy_deployments) @@ -10538,7 +10537,7 @@ class Router(DeprecatedRouterMembers): ) ) set_cooldown_deployments( - litellm_router_instance=self, + ctx=self._core_ctx, exception_status=e.status_code, original_exception=e, deployment=deployment["model_info"]["id"], @@ -10622,7 +10621,7 @@ class Router(DeprecatedRouterMembers): ) if selected is None: no_deployment: Final = await async_raise_no_deployment_exception( - litellm_router_instance=self, model=model_group, parent_otel_span=None + ctx=self._core_ctx, model=model_group, parent_otel_span=None ) raise litellm.RateLimitError( message=str(no_deployment), @@ -11053,7 +11052,7 @@ class Router(DeprecatedRouterMembers): auto_router_config=auto_router_config, default_model=default_model, embedding_model=embedding_model, - litellm_router_instance=self, + ctx=self._core_ctx, max_input_chars=(max_input_chars if max_input_chars is not None else DEFAULT_AUTO_ROUTER_MAX_INPUT_CHARS), ) self._register_pre_routing_strategy( @@ -11134,7 +11133,7 @@ class Router(DeprecatedRouterMembers): complexity_router: Final[ComplexityRouter] = ComplexityRouter( model_name=deployment.model_name, default_model=default_model, - litellm_router_instance=self, + ctx=self._core_ctx, complexity_router_config=complexity_router_config, ) self._register_pre_routing_strategy( @@ -11434,7 +11433,7 @@ class Router(DeprecatedRouterMembers): quality_router: Final[QualityRouter] = QualityRouter( model_name=deployment.model_name, default_model=default_model, - litellm_router_instance=self, + ctx=self._core_ctx, quality_router_config=quality_router_config, ) self._register_pre_routing_strategy( @@ -13655,7 +13654,7 @@ class Router(DeprecatedRouterMembers): while remaining: try: picked = await get_deployments_for_tag( - llm_router_instance=self, + ctx=self._core_ctx, model=model, healthy_deployments=remaining, request_kwargs=tag_request, @@ -14538,7 +14537,7 @@ class Router(DeprecatedRouterMembers): if routing_strategy == "lar1": from litellm.router_strategy.lar1_routing import apply_lar1_routing_strategy - apply_lar1_routing_strategy(self, kwargs.get("routing_strategy_args")) + apply_lar1_routing_strategy(self._core_ctx, kwargs.get("routing_strategy_args")) return self.routing_strategy_init( routing_strategy=routing_strategy, routing_strategy_args=kwargs.get("routing_strategy_args", {}) @@ -14631,7 +14630,7 @@ class Router(DeprecatedRouterMembers): cache_key = f"{model_id}_max_parallel_requests_client" client = self._core_cache.get_cache(key=cache_key, local_only=True, parent_otel_span=parent_otel_span) if client is None: - InitalizeCachedClient.set_max_parallel_requests_client(litellm_router_instance=self, model=deployment) + InitalizeCachedClient.set_max_parallel_requests_client(ctx=self._core_ctx, model=deployment) client = self._core_cache.get_cache(key=cache_key, local_only=True, parent_otel_span=parent_otel_span) return client elif client_type == "async": @@ -15562,10 +15561,10 @@ class Router(DeprecatedRouterMembers): routing_read_batch: Final = RoutingReadBatch.active() cooldown_deployments: Final = ( - await async_get_cooldown_deployments(litellm_router_instance=self, parent_otel_span=parent_otel_span) + await async_get_cooldown_deployments(ctx=self._core_ctx, parent_otel_span=parent_otel_span) if routing_read_batch is None else await routing_read_batch.async_get_cooldown_deployments( - litellm_router_instance=self, + ctx=self._core_ctx, healthy_deployments=healthy_deployments, parent_otel_span=parent_otel_span, ) @@ -15620,7 +15619,7 @@ class Router(DeprecatedRouterMembers): ) # check if user wants to do tag based routing healthy_deployments = await get_deployments_for_tag( - llm_router_instance=self, + ctx=self._core_ctx, model=model, request_kwargs=request_kwargs, healthy_deployments=healthy_deployments, @@ -15699,7 +15698,7 @@ class Router(DeprecatedRouterMembers): if len(healthy_deployments) == 0: exception: Final = await async_raise_no_deployment_exception( - litellm_router_instance=self, + ctx=self._core_ctx, model=model, parent_otel_span=parent_otel_span, route_model_ids=await self._async_routable_cooled_deployment_ids( @@ -15945,7 +15944,7 @@ class Router(DeprecatedRouterMembers): ) if deployment is None: exception: Final = await async_raise_no_deployment_exception( - litellm_router_instance=self, + ctx=self._core_ctx, model=model, parent_otel_span=parent_otel_span, ) @@ -16115,7 +16114,7 @@ class Router(DeprecatedRouterMembers): if deployment is None: exception: Final = await async_raise_no_deployment_exception( - litellm_router_instance=self, + ctx=self._core_ctx, model=model, parent_otel_span=parent_otel_span, ) @@ -16483,7 +16482,7 @@ class Router(DeprecatedRouterMembers): if isinstance(selected_strategy.strategy, ComplexityRouter) else (), parent_model=model, - router=self, + ctx=self._core_ctx, allow_escalation=isinstance(selected_strategy.strategy, ComplexityRouter) and selected_strategy.strategy.config.enable_context_window_escalation, messages=messages, @@ -16846,9 +16845,7 @@ class Router(DeprecatedRouterMembers): parent_otel_span=parent_otel_span, ) - cooldown_deployments: Final = get_cooldown_deployments( - litellm_router_instance=self, parent_otel_span=parent_otel_span - ) + cooldown_deployments: Final = get_cooldown_deployments(ctx=self._core_ctx, parent_otel_span=parent_otel_span) _pre_cooldown_deployments: Final = healthy_deployments healthy_deployments = self._filter_cooldown_deployments( healthy_deployments=healthy_deployments, @@ -16947,7 +16944,7 @@ class Router(DeprecatedRouterMembers): _cooldown_time = self._core_cooldown_cache.get_min_cooldown( model_ids=model_ids, parent_otel_span=parent_otel_span ) - _cooldown_list = get_cooldown_deployments(litellm_router_instance=self, parent_otel_span=parent_otel_span) + _cooldown_list = get_cooldown_deployments(ctx=self._core_ctx, parent_otel_span=parent_otel_span) raise RouterRateLimitError( model=model, cooldown_time=_cooldown_time, @@ -16955,7 +16952,7 @@ class Router(DeprecatedRouterMembers): cooldown_list=_cooldown_list, model_ids=model_ids, cooldown_deployments=get_cooldown_deployment_info( - self, + self._core_ctx, self._deployment_ids( self._region_routable_deployments( request_deployments, @@ -16994,7 +16991,7 @@ class Router(DeprecatedRouterMembers): _cooldown_time = self._core_cooldown_cache.get_min_cooldown( model_ids=model_ids, parent_otel_span=parent_otel_span ) - _cooldown_list = get_cooldown_deployments(litellm_router_instance=self, parent_otel_span=parent_otel_span) + _cooldown_list = get_cooldown_deployments(ctx=self._core_ctx, parent_otel_span=parent_otel_span) raise RouterRateLimitError( model=model, cooldown_time=_cooldown_time, @@ -17101,9 +17098,7 @@ class Router(DeprecatedRouterMembers): healthy_deployments=pass_through_deployments, parent_otel_span=parent_otel_span, ) - cooldown_deployments: Final = get_cooldown_deployments( - litellm_router_instance=self, parent_otel_span=parent_otel_span - ) + cooldown_deployments: Final = get_cooldown_deployments(ctx=self._core_ctx, parent_otel_span=parent_otel_span) pass_through_deployments = self._filter_cooldown_deployments( healthy_deployments=pass_through_deployments, cooldown_deployments=cooldown_deployments, @@ -17132,7 +17127,7 @@ class Router(DeprecatedRouterMembers): _cooldown_time = self._core_cooldown_cache.get_min_cooldown( model_ids=model_ids, parent_otel_span=parent_otel_span ) - _cooldown_list = get_cooldown_deployments(litellm_router_instance=self, parent_otel_span=parent_otel_span) + _cooldown_list = get_cooldown_deployments(ctx=self._core_ctx, parent_otel_span=parent_otel_span) raise RouterRateLimitError( model=model, cooldown_time=_cooldown_time, @@ -17140,7 +17135,7 @@ class Router(DeprecatedRouterMembers): cooldown_list=_cooldown_list, model_ids=pass_through_model_ids, cooldown_deployments=get_cooldown_deployment_info( - self, + self._core_ctx, self._deployment_ids( self._region_routable_deployments( request_deployments, @@ -17178,7 +17173,7 @@ class Router(DeprecatedRouterMembers): _cooldown_time = self._core_cooldown_cache.get_min_cooldown( model_ids=model_ids, parent_otel_span=parent_otel_span ) - _cooldown_list = get_cooldown_deployments(litellm_router_instance=self, parent_otel_span=parent_otel_span) + _cooldown_list = get_cooldown_deployments(ctx=self._core_ctx, parent_otel_span=parent_otel_span) raise RouterRateLimitError( model=model, cooldown_time=_cooldown_time, diff --git a/litellm/router_api.py b/litellm/router_api.py index 19f12cec40d..e4939254b81 100644 --- a/litellm/router_api.py +++ b/litellm/router_api.py @@ -33,19 +33,28 @@ as they were. # repeat them unchanged, and typing the members themselves is the core's job. import hashlib +import inspect import json +import warnings from collections.abc import Iterator, Mapping, Sequence from collections.abc import Set as AbstractSet from dataclasses import dataclass, field from types import MappingProxyType -from typing import TYPE_CHECKING, Final, Literal, TypeAlias, overload +from typing import TYPE_CHECKING, Final, Literal, Protocol, TypeAlias, overload if TYPE_CHECKING: from typing import Any # noqa: TID251 # only to spell the cores' untyped (Unknown) containers and one Any type + from opentelemetry.trace import Span + from litellm.caching.caching import DualCache, RedisCache from litellm.integrations.SlackAlerting.slack_alerting import SlackAlerting + from litellm.litellm_core_utils.pattern_match_deployments import PatternMatchRouter + from litellm.litellm_core_utils.ptu_shares import PTUTeamCeiling + from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler + from litellm.messages.dispatch import MessagesResult + from litellm.responses.streaming_iterator import BaseResponsesAPIStreamingIterator from litellm.router import Router from litellm.router_strategy.adaptive_router.adaptive_router import AdaptiveRouter from litellm.router_strategy.auto_router.auto_router import AutoRouter @@ -53,12 +62,14 @@ if TYPE_CHECKING: from litellm.router_strategy.complexity_router.complexity_router import ComplexityRouter from litellm.router_strategy.quality_router.quality_router import QualityRouter from litellm.router_utils.cooldown_cache import CooldownCache + from litellm.router_utils.fallback_event_handlers import AttemptedFallbackTargets as _AttemptedFallbackTargets from litellm.router_utils.health_state_cache import DeploymentHealthCache from litellm.router_utils.kubernetes_pod_discovery import KubernetesPodDiscovery - from litellm.router_utils.pattern_match_deployments import PatternMatchRouter - from litellm.router_utils.ptu_shares import PTUTeamCeiling + from litellm.types.decisions import DecisionsResponse, OpenAIDecisionResponse + from litellm.types.llms.openai import ResponsesAPIResponse from litellm.types.router import ( AllowedFailsPolicy, + CustomRoutingStrategyBase, Deployment, DeploymentModelListingInfo, DeploymentTypedDict, @@ -74,7 +85,7 @@ if TYPE_CHECKING: SearchToolTypedDict, TaggedPreRoutingStrategy, ) - from litellm.types.utils import BudgetConfig + from litellm.types.utils import BudgetConfig, EmbeddingResponse, ModelResponse from litellm.types.utils import ModelInfo as ModelMapInfo # The cores' untyped containers (bare ``list`` / ``dict``, element types Unknown), spelled with Any: @@ -82,6 +93,9 @@ if TYPE_CHECKING: UntypedList: TypeAlias = list[Any] # pyright: ignore[reportExplicitAny] # see above UntypedDict: TypeAlias = dict[Any, Any] # pyright: ignore[reportExplicitAny] # see above + # Re-exported for litellm.types, which may not import router_utils. + AttemptedFallbackTargets: TypeAlias = _AttemptedFallbackTargets + # What registry().plugins(kind) returns, one member per kind. RegistryPlugins: TypeAlias = ( dict[str, list[TaggedPreRoutingStrategy[AutoRouter]]] @@ -184,6 +198,73 @@ def deployment_id(model_group: str, litellm_params: Mapping[str, object]) -> str return hashlib.sha256("".join(parts).encode()).hexdigest() +def router_init_args() -> tuple[str, ...]: + """The arguments ``Router.__init__`` accepts (was ``Router.get_valid_args``). Needs no router instance.""" + from litellm.router import Router + + return tuple(Router.get_valid_args()) + + +def mark_advisor_orchestration_failure(exception: BaseException) -> None: + """Tag an advisor orchestration failure, so the router does not cool down the deployment it picked.""" + from litellm.router_utils.cooldown_handlers import mark_advisor_orchestration_failure as mark + + mark(exception) + + +def fallback_chain( + fallbacks: Sequence[Mapping[str, list[str]]], # mutable-ok: the fallbacks config shape + model_group: str, +) -> tuple[list[str] | None, int | None]: # mutable-ok: get_fallback_model_group's type, unchanged + """ + The fallbacks configured for a model group, and the index of the generic ``*`` entry (was + ``get_fallback_model_group``). Needs no router instance. + """ + from litellm.router_utils.fallback_event_handlers import get_fallback_model_group + + return get_fallback_model_group(fallbacks=fallbacks, model_group=model_group) + + +def request_fallback_chain( + fallbacks: Sequence[Mapping[str, list[str]]], # mutable-ok: the fallbacks config shape + request_kwargs: Mapping[str, object], + model_group: str | None, +) -> tuple[list[str] | None, int | None]: # mutable-ok: get_fallback_model_group's type, unchanged + """ + ``fallback_chain`` for a request: the group a pre-routing hook picked first, then the routed, + requested and original groups (was ``get_fallback_model_group_for_lookup_groups``). + """ + from litellm.router_utils.fallback_event_handlers import ( + fallback_lookup_groups, + get_fallback_model_group_for_lookup_groups, + ) + + return get_fallback_model_group_for_lookup_groups( + fallbacks=fallbacks, lookup_groups=fallback_lookup_groups(kwargs=request_kwargs, model_group=model_group) + ) + + +def fallbacks_disabled(request_kwargs: Mapping[str, object]) -> bool: + """Whether the request opted out of fallbacks (was ``fallbacks_disabled_for_request``).""" + from litellm.router_utils.fallback_event_handlers import fallbacks_disabled_for_request + + return fallbacks_disabled_for_request(kwargs=request_kwargs) + + +def references_provider_scoped_resource(request_kwargs: Mapping[str, object]) -> bool: + """Whether the request names a file, batch or fine-tuning job that only its own provider knows.""" + from litellm.router_utils.fallback_event_handlers import PROVIDER_SCOPED_RESOURCE_KEYS + + return any(request_kwargs.get(key) for key in PROVIDER_SCOPED_RESOURCE_KEYS) + + +def deployment_metadata(request_kwargs: Mapping[str, object]) -> Mapping[str, object] | None: + """The metadata bucket the router stamped the picked deployment into (was ``find_deployment_metadata``).""" + from litellm.router_utils.router_callbacks.track_deployment_metrics import find_deployment_metadata + + return find_deployment_metadata(request_kwargs) + + def _json_default_stable_id(obj: object) -> str: from litellm.router import Router @@ -550,7 +631,8 @@ class RouterRegistry: - ``group_set``: the set of configured group names (was the ``model_names`` attribute) - ``ids``: deployment ids, of one group or all (was ``get_model_ids``) - ``deployment_names``: (was the ``deployment_names`` attribute) - - ``team_public``: team public model names (was ``team_public_model_names``) + - ``team_public``: team public model names (was ``team_public_model_names``), or only the + ones ``team_id`` serves its own deployments under (was ``team_public_model_names_of``) - ``litellm_models``: upstream model names a group resolves to (was ``resolved_litellm_models``) - ``litellm_base_models``: the same, with each deployment's ``base_model`` where it sets one (was ``resolved_litellm_models(..., use_base_model=True)``) @@ -568,7 +650,7 @@ class RouterRegistry: if kind == "deployment_names": return r._core_deployment_names if kind == "team_public": - return r._core_team_public_model_names + return r._core_team_public_model_names if team_id is None else r.team_public_model_names_of(team_id) if model_name is None: raise TypeError(f"registry().names(kind={kind!r}) needs a model_name") if kind == "litellm_models": @@ -832,6 +914,14 @@ class RouterRegistry: """Routing groups by name (was the ``routing_groups`` attribute).""" return self._router._core_routing_groups + def routing_group(self, name: str) -> "RoutingGroup | None": + """The routing group callable as ``name``, or None (was ``get_routing_group``).""" + return self._router.get_routing_group(name) + + def client(self, deployment: Mapping[str, object], *, client_type: str | None = None) -> object: + """The SDK client the router cached for a deployment, or None (was ``_get_client``).""" + return self._router._get_client(deployment=deployment, kwargs={}, client_type=client_type) + def access_groups( self, model_name: str | None = None, @@ -1128,6 +1218,41 @@ class RouterHealth: """The request priority and the kwargs without it (was ``split_request_priority``).""" return self._router._core_split_request_priority(model, kwargs) + def failures_this_minute(self, deployment_id: str) -> int: + """Failures counted against a deployment this minute (was ``get_deployment_failures_for_current_minute``).""" + from litellm.router_utils.router_callbacks.track_deployment_metrics import ( + get_deployment_failures_for_current_minute, + ) + + return get_deployment_failures_for_current_minute(self._router._core_ctx, deployment_id) + + def record_failure(self, deployment_id: str, exception: Exception, exception_status: str | int) -> bool: + """ + Count a failure against a deployment this minute and cool it down once it is over its allowed + fails (was ``increment_deployment_failures_for_current_minute`` then ``set_cooldown_deployments``). + Returns whether the deployment was cooled down. + """ + from litellm.router_utils.cooldown_handlers import set_cooldown_deployments + from litellm.router_utils.router_callbacks.track_deployment_metrics import ( + increment_deployment_failures_for_current_minute, + ) + + ctx: Final = self._router._core_ctx + increment_deployment_failures_for_current_minute(ctx, deployment_id) + return set_cooldown_deployments( + ctx, + original_exception=exception, + exception_status=exception_status, + deployment=deployment_id, + time_to_cooldown=self._router._core_cooldown_time, + ) + + def priority_header_fields( + self, model: str, kwargs: Mapping[str, object], header: str | None + ) -> Mapping[str, int | str]: + """The request fields a priority header sets (was ``priority_header_update``).""" + return self._router.priority_header_update(model=model, kwargs=kwargs, header=header) + @dataclass class ChangeSet: @@ -1202,6 +1327,40 @@ async def aapply_changes(router: "Router", changes: ChangeSet) -> ApplyResult: return result +def _takes_legacy_llm_router(check: object) -> bool: + """Whether a fallback check still declares ``llm_router`` instead of ``ctx`` (the pre-RoutingContext shape).""" + try: + params: Final = inspect.signature(check).parameters # pyright: ignore[reportArgumentType] # any callable + except (TypeError, ValueError): + return False + return "ctx" not in params and "llm_router" in params + + +async def _run_fallback_check( + check: "FallbackAccessCheck | FallbackBudgetCheck", + ctx: "RoutingContext", + *, + model: str, + request_kwargs: Mapping[str, object], +) -> bool: + if _takes_legacy_llm_router(check): + warnings.warn( + f"{type(check).__name__} takes llm_router=; fallback checks now receive ctx: RoutingContext. " + "Passing llm_router is deprecated and will be removed", + DeprecationWarning, + stacklevel=2, + ) + legacy: Final = check # pyright: ignore[reportAny] # the old protocol shape, checked above + return await legacy(model=model, request_kwargs=request_kwargs, llm_router=ctx._router) # pyright: ignore[reportCallIssue, reportPrivateUsage] # see above + return await check(model=model, request_kwargs=request_kwargs, ctx=ctx) + + +class RegistryReader(Protocol): + """Anything that answers ``registry()``: a Router or a RoutingContext. What proxy auth helpers read.""" + + def registry(self) -> "RouterRegistry": ... + + class RoutingContext: """ What a routing plugin (strategy, pre-call check, sub-router) may use of the router. Plugins get @@ -1225,6 +1384,98 @@ class RoutingContext: def health(self) -> RouterHealth: return self._router.health() + def observers(self) -> RoutingObservers: + return self._router.observe() + + def belongs_to(self, router: "Router") -> bool: + return self._router is router + + @property + def explicit_allowed_fails(self) -> int | None: + """``allowed_fails`` as the caller passed it, ``None`` when it came from the global default.""" + return self._router.explicit_allowed_fails + + async def select( + self, + model: str, + request_kwargs: dict[str, object] | None = None, # mutable-ok: the selection cores take a dict + *, + kind: SelectKind = "pick", + messages: list[dict[str, str]] | None = None, # mutable-ok: the selection cores take a list + input: str | list[object] | None = None, # mutable-ok: the selection cores take a list + specific_deployment: bool | None = False, + parent_otel_span: "Span | None" = None, + health_check_probe: bool = False, + ) -> object: + return await self._router.select( # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType, reportCallIssue, reportArgumentType] # the selection cores return untyped deployment dicts + model, + request_kwargs, + kind=kind, # pyright: ignore[reportArgumentType] # forwarded as given, the overloads narrow it + messages=messages, + input=input, + specific_deployment=specific_deployment, + parent_otel_span=parent_otel_span, + health_check_probe=health_check_probe, + ) + + async def with_fallbacks( + self, + *args: object, + **kwargs: object, # kwargs-ok: the router's fallback loop takes the request's own keyword payload + ) -> object: + """Run a call through the router's retry and fallback loop (was ``async_function_with_fallbacks``).""" + return await self._router.async_function_with_fallbacks(*args, **kwargs) + + async def acompletion( + self, + **kwargs: object, # kwargs-ok: forwarded to the router endpoint as given + ) -> "ModelResponse | CustomStreamWrapper": + return await self._router.acompletion(**kwargs) # pyright: ignore[reportCallIssue, reportArgumentType] # forwarded as given + + async def aresponses( + self, + **kwargs: object, # kwargs-ok: forwarded to the router endpoint as given + ) -> "ResponsesAPIResponse | BaseResponsesAPIStreamingIterator": + return await self._router.aresponses(**kwargs) # pyright: ignore[reportReturnType, reportArgumentType] # factory-built endpoint, returns what litellm.aresponses returns + + async def aembedding( + self, + **kwargs: object, # kwargs-ok: forwarded to the router endpoint as given + ) -> "EmbeddingResponse": + return await self._router.aembedding(**kwargs) # pyright: ignore[reportCallIssue, reportArgumentType] # forwarded as given + + def embedding( + self, + **kwargs: object, # kwargs-ok: forwarded to the router endpoint as given + ) -> "EmbeddingResponse": + return self._router.embedding(**kwargs) # pyright: ignore[reportCallIssue, reportArgumentType] # forwarded as given + + async def adecisions( + self, + **kwargs: object, # kwargs-ok: forwarded to the router endpoint as given + ) -> "OpenAIDecisionResponse | DecisionsResponse": + return await self._router.adecisions(**kwargs) # pyright: ignore[reportReturnType, reportArgumentType] # factory-built endpoint, returns what litellm.adecisions returns + + async def aanthropic_messages( + self, + **kwargs: object, # kwargs-ok: forwarded to the router endpoint as given + ) -> "MessagesResult": + return await self._router.aanthropic_messages(**kwargs) # pyright: ignore[reportReturnType, reportArgumentType] # factory-built endpoint, returns what litellm.anthropic_messages returns + + def apply(self, changes: ChangeSet) -> ApplyResult: + return self._router.apply(changes) + + def register_plugin(self, plugin: "CustomRoutingStrategyBase") -> None: + self._router.register_plugin(plugin) + + async def fallback_access_allowed(self, *, model: str, request_kwargs: Mapping[str, object]) -> bool: + check: Final = self._router.settings().fallback_access_check + return check is None or await _run_fallback_check(check, self, model=model, request_kwargs=request_kwargs) + + async def fallback_budget_allowed(self, *, model: str, request_kwargs: Mapping[str, object]) -> bool: + check: Final = self._router.settings().fallback_budget_check + return check is None or await _run_fallback_check(check, self, model=model, request_kwargs=request_kwargs) + def pre_call_checks( self, model: str, @@ -1292,7 +1543,7 @@ class RoutingContext: self, kwargs: dict[str, object], # mutable-ok: Router._core_log_retry records the retry into the request kwargs e: Exception, - ) -> Mapping[str, object]: + ) -> dict: # mutable-ok: the fallback loop edits it; Router._core_log_retry's type return self._router._core_log_retry(kwargs=kwargs, e=e) diff --git a/litellm/router_deprecated.py b/litellm/router_deprecated.py index 046fb8c452a..0b328cc3e6b 100644 --- a/litellm/router_deprecated.py +++ b/litellm/router_deprecated.py @@ -40,11 +40,11 @@ if TYPE_CHECKING: from litellm.caching.caching import RedisCache from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLogging + from litellm.litellm_core_utils.ptu_shares import PTUTeamCeiling from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler from litellm.router import Router from litellm.router_strategy.budget_limiter import RouterBudgetLimiting from litellm.router_utils.kubernetes_pod_discovery import KubernetesPodDiscovery - from litellm.router_utils.ptu_shares import PTUTeamCeiling from litellm.types.router import ( CustomRoutingStrategyBase, Deployment, @@ -838,6 +838,109 @@ class DeprecatedRouterMembers: return _as_router(self)._core_log_retry(kwargs=kwargs, e=e) +# Router-family functions and classes that took the Router (``litellm_router_instance=``, +# ``router=``, ...) take its RoutingContext now. These keep the old spellings working. + +_RoutingCallable: Final = TypeVar("_RoutingCallable", bound=Callable[..., object]) + + +@functools.cache +def _router_class() -> "type[Router]": + from litellm.router import Router + + return Router + + +def _note_renamed(label: str, old: str, instead: str, *, stacklevel: int = 3) -> None: + DEPRECATED_ROUTER_MEMBER_USES[label] += 1 + warnings.warn( + f"{label}: {old} is deprecated; {instead} (the Router's RoutingContext) instead", + DeprecationWarning, + stacklevel=stacklevel, # the caller of the wrapper or descriptor that noted it + ) + + +def _routing_context_of(value: object) -> object: + """The Router's RoutingContext when ``value`` is a Router, else ``value`` as given.""" + return value._core_ctx if isinstance(value, _router_class()) else value + + +def renamed_router_param(old: str, new: str = "ctx") -> Callable[[_RoutingCallable], _RoutingCallable]: + """ + Keep a router parameter that became a RoutingContext (``new``) callable the old way: ``old=`` + still works, and so does a Router passed where ``new`` goes. Either gets the Router's + RoutingContext and a DeprecationWarning that names ``new``. + """ + + def decorate(fn: _RoutingCallable) -> _RoutingCallable: + index: Final = list(inspect.signature(fn).parameters).index(new) + label: Final = f"{fn.__module__}.{fn.__qualname__}" + + def convert( + args: tuple[object, ...], + kwargs: dict[str, object], # mutable-ok: the call's own kwargs + ) -> tuple[object, ...]: + if old in kwargs: + if new in kwargs: + raise TypeError(f"{fn.__qualname__}() got both {old}= and {new}=") + _note_renamed(label, f"{old}=", f"pass {new}=", stacklevel=4) + kwargs[new] = _routing_context_of(kwargs.pop(old)) + elif new in kwargs: + if isinstance(kwargs[new], _router_class()): + _note_renamed(label, f"a Router as {new}=", f"pass {new}=", stacklevel=4) + kwargs[new] = _routing_context_of(kwargs[new]) + elif len(args) > index and isinstance(args[index], _router_class()): + _note_renamed(label, "passing a Router", f"pass {new}", stacklevel=4) + return (*args[:index], _routing_context_of(args[index]), *args[index + 1 :]) + return args + + # An async fn keeps an async wrapper, so iscoroutinefunction (and mock.patch's AsyncMock pick) still sees it + if inspect.iscoroutinefunction(fn): + + @functools.wraps(fn) + async def acall(*args: object, **kwargs: object) -> object: # kwargs-ok: forwarded to fn as given + return await fn(*convert(args, kwargs), **kwargs) # pyright: ignore[reportAny] # fn's own result + + return acall # pyright: ignore[reportReturnType] # same call shape as fn, see functools.wraps + + @functools.wraps(fn) + def call(*args: object, **kwargs: object) -> object: # kwargs-ok: forwarded to fn as given + return fn(*convert(args, kwargs), **kwargs) + + return call # pyright: ignore[reportReturnType] # same call shape as fn, see functools.wraps + + return decorate + + +class RenamedRouterAttribute: + """ + A class attribute that keeps an old router attribute (``self.router``, ``self.litellm_router_instance``) + readable after it became the RoutingContext attribute ``new``: reading it returns that + RoutingContext, writing a Router stores the Router's RoutingContext, each with a DeprecationWarning. + """ + + def __init__(self, new: str = "ctx") -> None: + self.new: Final = new + self.label = "" + + def __set_name__(self, owner: type, name: str) -> None: + self.label = f"{owner.__module__}.{owner.__qualname__}.{name}" + + @overload + def __get__(self, obj: None, owner: type | None = None) -> "RenamedRouterAttribute": ... + @overload + def __get__(self, obj: object, owner: type | None = None) -> object: ... + def __get__(self, obj: object | None, owner: type | None = None) -> object: + if obj is None: + return self + _note_renamed(self.label, "reading this attribute", f"read .{self.new}") + return getattr(obj, self.new) # pyright: ignore[reportAny] # the attribute named ``new`` holds the RoutingContext + + def __set__(self, obj: object, value: object) -> None: + _note_renamed(self.label, "setting this attribute", f"set .{self.new}") + setattr(obj, self.new, _routing_context_of(value)) + + def _name_members_after_router() -> None: # The old members were Router methods, so errors that name the method (a wrong-arity TypeError, # or "litellm.router.Router.() argument after ** must be a mapping") keep naming it the diff --git a/litellm/router_strategy/auto_router/auto_router.py b/litellm/router_strategy/auto_router/auto_router.py index ee620790282..b92c53fa93c 100644 --- a/litellm/router_strategy/auto_router/auto_router.py +++ b/litellm/router_strategy/auto_router/auto_router.py @@ -17,6 +17,7 @@ from litellm.litellm_core_utils.internal_call_metadata import ( forwarded_internal_call_metadata, parent_session_kwargs, ) +from litellm.router_deprecated import RenamedRouterAttribute, renamed_router_param from litellm.types.llms.base import LiteLLMBaseModel from litellm.types.utils import ( AUTOROUTER_CLASSIFIER_CALL_ORIGIN, @@ -29,11 +30,11 @@ if TYPE_CHECKING: from semantic_router.routers import SemanticRouter from semantic_router.routers.base import Route - from litellm.router import Router + from litellm.router_api import RoutingContext from litellm.router_strategy.auto_router.litellm_encoder import LiteLLMRouterEncoder from litellm.types.router import PreRoutingHookResponse else: - Router = Any + RoutingContext = Any PreRoutingHookResponse = Any Route = Any SemanticRouter = Any @@ -55,13 +56,15 @@ class _SemanticMatchOutcome(NamedTuple): class AutoRouter(CustomLogger): DEFAULT_AUTO_SYNC_VALUE = "local" + litellm_router_instance: Final = RenamedRouterAttribute() # deprecated: the router attribute before ``ctx`` + @renamed_router_param("litellm_router_instance") def __init__( self, model_name: str, default_model: str, embedding_model: str, - litellm_router_instance: "Router", + ctx: "RoutingContext", auto_router_config_path: str | None = None, auto_router_config: str | None = None, max_input_chars: int = DEFAULT_AUTO_ROUTER_MAX_INPUT_CHARS, @@ -75,7 +78,7 @@ class AutoRouter(CustomLogger): auto_router_config: The config to use for the auto-router. You can either use this or auto_router_config_path, not both. default_model: The default model to use if no route is found. embedding_model: The embedding model to use for the auto-router. - litellm_router_instance: The instance of the LiteLLM Router. + ctx: The routing context of the owning router. max_input_chars: Longest prompt, in characters, handed to the embedding model. Longer prompts are cut to this length so an embedding context window far smaller than the routed model's never fails the request. @@ -95,9 +98,9 @@ class AutoRouter(CustomLogger): self.default_model = default_model self.embedding_model: str = embedding_model self.max_input_chars: int = max_input_chars - self.litellm_router_instance: Router = litellm_router_instance + self.ctx: Final = ctx self.encoder: LiteLLMRouterEncoder = LiteLLMRouterEncoder( - litellm_router_instance=litellm_router_instance, + ctx=ctx, model_name=embedding_model, max_input_chars=max_input_chars, ) diff --git a/litellm/router_strategy/auto_router/litellm_encoder.py b/litellm/router_strategy/auto_router/litellm_encoder.py index b7430062f1c..340efb509eb 100644 --- a/litellm/router_strategy/auto_router/litellm_encoder.py +++ b/litellm/router_strategy/auto_router/litellm_encoder.py @@ -1,4 +1,4 @@ -from typing import TYPE_CHECKING, Any, Final, Optional +from typing import TYPE_CHECKING, Any, ClassVar, Final, Optional from pydantic import ConfigDict from semantic_router.encoders import DenseEncoder @@ -6,11 +6,12 @@ from semantic_router.encoders.base import AsymmetricDenseMixin import litellm from litellm._logging import verbose_router_logger +from litellm.router_deprecated import RenamedRouterAttribute, renamed_router_param if TYPE_CHECKING: - from litellm.router import Router + from litellm.router_api import RoutingContext else: - Router = Any + RoutingContext = Any def litellm_to_list(embeds: litellm.EmbeddingResponse) -> list[list[float]]: @@ -19,21 +20,22 @@ def litellm_to_list(embeds: litellm.EmbeddingResponse) -> list[list[float]]: :param embeds: The LiteLLM embedding response. :return: A list of embeddings. """ - if not embeds or not isinstance(embeds, litellm.EmbeddingResponse) or not embeds.data: + if not embeds or not embeds.data: raise ValueError("No embeddings found in LiteLLM embedding response.") return [x["embedding"] for x in embeds.data] class CustomDenseEncoder(DenseEncoder): model_config = ConfigDict(extra="allow") + litellm_router_instance: ClassVar = RenamedRouterAttribute() # deprecated: the router attribute before ``ctx`` - def __init__(self, litellm_router_instance: Optional["Router"] = None, **kwargs): - # Extract litellm_router_instance from kwargs if passed there - if "litellm_router_instance" in kwargs: - litellm_router_instance = kwargs.pop("litellm_router_instance") + @renamed_router_param("litellm_router_instance") + def __init__(self, ctx: Optional["RoutingContext"] = None, **kwargs): + if "ctx" in kwargs: + ctx = kwargs.pop("ctx") super().__init__(**kwargs) - self.litellm_router_instance = litellm_router_instance + self.ctx = ctx class LiteLLMRouterEncoder(CustomDenseEncoder, AsymmetricDenseMixin): @@ -46,17 +48,18 @@ class LiteLLMRouterEncoder(CustomDenseEncoder, AsymmetricDenseMixin): type: str = "internal_litellm_router" + @renamed_router_param("litellm_router_instance") def __init__( self, - litellm_router_instance: "Router", + ctx: "RoutingContext", model_name: str, score_threshold: float | None = None, max_input_chars: int = 0, ): """Initialize the LiteLLMEncoder. - :param litellm_router_instance: The instance of the LiteLLM Router. - :type litellm_router_instance: Router + :param ctx: The routing context of the owning router. + :type ctx: RoutingContext :param model_name: The name of the embedding model to use. Must use LiteLLM naming convention (e.g. "openai/text-embedding-3-small" or "mistral/mistral-embed"). :type model_name: str @@ -75,7 +78,7 @@ class LiteLLMRouterEncoder(CustomDenseEncoder, AsymmetricDenseMixin): score_threshold=score_threshold if score_threshold is not None else 0.3, ) self.model_name = model_name - self.litellm_router_instance = litellm_router_instance + self.ctx = ctx self.max_input_chars = max_input_chars def _clamp(self, docs: list[str]) -> list[str]: # mutable-ok: embedding() takes `input: str | list` @@ -109,45 +112,37 @@ class LiteLLMRouterEncoder(CustomDenseEncoder, AsymmetricDenseMixin): return await self.aencode_queries(docs, **kwargs) def encode_queries(self, docs: list[str], **kwargs) -> list[list[float]]: - if self.litellm_router_instance is None: - raise ValueError("litellm_router_instance is not set") + if self.ctx is None: + raise ValueError("ctx is not set") try: - embeds: Final = self.litellm_router_instance.embedding( - input=self._clamp(docs), model=self.model_name, **kwargs - ) + embeds: Final = self.ctx.embedding(input=self._clamp(docs), model=self.model_name, **kwargs) return litellm_to_list(embeds) except Exception as e: raise ValueError(f"{self.type.capitalize()} API call failed. Error: {e}") from e def encode_documents(self, docs: list[str], **kwargs) -> list[list[float]]: - if self.litellm_router_instance is None: - raise ValueError("litellm_router_instance is not set") + if self.ctx is None: + raise ValueError("ctx is not set") try: - embeds: Final = self.litellm_router_instance.embedding( - input=self._clamp(docs), model=self.model_name, **kwargs - ) + embeds: Final = self.ctx.embedding(input=self._clamp(docs), model=self.model_name, **kwargs) return litellm_to_list(embeds) except Exception as e: raise ValueError(f"{self.type.capitalize()} API call failed. Error: {e}") from e async def aencode_queries(self, docs: list[str], **kwargs) -> list[list[float]]: - if self.litellm_router_instance is None: - raise ValueError("litellm_router_instance is not set") + if self.ctx is None: + raise ValueError("ctx is not set") try: - embeds: Final = await self.litellm_router_instance.aembedding( - input=self._clamp(docs), model=self.model_name, **kwargs - ) + embeds: Final = await self.ctx.aembedding(input=self._clamp(docs), model=self.model_name, **kwargs) return litellm_to_list(embeds) except Exception as e: raise ValueError(f"{self.type.capitalize()} API call failed. Error: {e}") from e async def aencode_documents(self, docs: list[str], **kwargs) -> list[list[float]]: - if self.litellm_router_instance is None: - raise ValueError("litellm_router_instance is not set") + if self.ctx is None: + raise ValueError("ctx is not set") try: - embeds: Final = await self.litellm_router_instance.aembedding( - input=self._clamp(docs), model=self.model_name, **kwargs - ) + embeds: Final = await self.ctx.aembedding(input=self._clamp(docs), model=self.model_name, **kwargs) return litellm_to_list(embeds) except Exception as e: raise ValueError(f"{self.type.capitalize()} API call failed. Error: {e}") from e diff --git a/litellm/router_strategy/complexity_router/complexity_router.py b/litellm/router_strategy/complexity_router/complexity_router.py index 97ad5ffa05b..4f4ed76c170 100644 --- a/litellm/router_strategy/complexity_router/complexity_router.py +++ b/litellm/router_strategy/complexity_router/complexity_router.py @@ -64,6 +64,7 @@ from litellm.llms.anthropic.common_utils import is_claude_code_user_agent from litellm.llms.base_llm.base_utils import type_to_response_format_param from litellm.llms.custom_httpx.http_handler import get_async_httpx_client from litellm.llms.databricks.decisions.transformation import DATABRICKS_DECISIONS_CONFIG +from litellm.router_deprecated import RenamedRouterAttribute, renamed_router_param from litellm.router_strategy.adaptive_router.classifier import classify_prompt from litellm.router_strategy.complexity_router.context_compaction import compaction_pending from litellm.router_strategy.complexity_router.tier_predictor import ( @@ -140,12 +141,12 @@ from .stall_detector import detect_stalled_task if TYPE_CHECKING: from semantic_router.routers import SemanticRouter - from litellm.router import Router + from litellm.router_api import RoutingContext from litellm.router_strategy.adaptive_router.adaptive_router import AdaptiveRouter from litellm.router_strategy.savings_baseline import Baseline from litellm.types.router import PreRoutingHookResponse else: - Router = Any + RoutingContext = Any PreRoutingHookResponse = Any SemanticRouter = Any @@ -1416,9 +1417,11 @@ class ComplexityRouter(CustomLogger): - Question complexity (multiple questions) """ + litellm_router_instance: Final = RenamedRouterAttribute() # deprecated: the router attribute before ``ctx`` + def _build_jev_client(self, config: OpenSourceClassifierConfig) -> JevClassifierClient | _JevConnectionError: if config.deployment_name is not None: - return RouterJevClassifierClient(self.litellm_router_instance, config.deployment_name) + return RouterJevClassifierClient(self.ctx, config.deployment_name) if config.provider in ("laya", "bespoke"): from litellm.llms.oss_decision import oss_connection @@ -1459,10 +1462,11 @@ class ComplexityRouter(CustomLogger): http_client=get_async_httpx_client(httpxSpecialProvider.PassThroughEndpoint), ) + @renamed_router_param("litellm_router_instance") def __init__( self, model_name: str, - litellm_router_instance: Router, + ctx: RoutingContext, complexity_router_config: Mapping[str, object] | None = None, default_model: str | None = None, derive_savings_baseline: bool = True, @@ -1473,7 +1477,7 @@ class ComplexityRouter(CustomLogger): Args: model_name: The name of the model/deployment using this router. - litellm_router_instance: The LiteLLM Router instance. + ctx: The routing context of the owning router. complexity_router_config: Optional configuration dict from proxy config. default_model: Optional default model to use if tier cannot be determined. derive_savings_baseline: False for callers whose decisions are never spend @@ -1481,7 +1485,7 @@ class ComplexityRouter(CustomLogger): would leak deployment mappings the caller was not authorized for. """ self.model_name = model_name - self.litellm_router_instance = litellm_router_instance + self.ctx: Final = ctx self._derive_savings_baseline = derive_savings_baseline # Parse config - always create a new instance to avoid singleton mutation @@ -1698,7 +1702,7 @@ class ComplexityRouter(CustomLogger): if not self._derive_savings_baseline: return None if not self._savings_baseline_derived: - self._savings_baseline = resolve_baseline(self.litellm_router_instance, self._hardest_tier_models()) + self._savings_baseline = resolve_baseline(self.ctx, self._hardest_tier_models()) self._savings_baseline_derived = True return self._savings_baseline @@ -2406,7 +2410,7 @@ class ComplexityRouter(CustomLogger): ) budgeted: Final = await offload_token_count(fit_jev_request)( - build_request, prompt, system_prompt, jev_input_targets(self.litellm_router_instance, config), _truncate + build_request, prompt, system_prompt, jev_input_targets(self.ctx, config), _truncate ) request: Final = budgeted.request if request is None: @@ -2946,10 +2950,8 @@ class ComplexityRouter(CustomLogger): "originating_request_masked": masked_originating_request(request_kwargs), "body": {"model": llm_config.model, **payload}, } - classify: Final[Callable[..., Awaitable[ModelResponse | ResponsesAPIResponse]]] = ( - self.litellm_router_instance.aresponses - if encrypted_task is not None - else self.litellm_router_instance.acompletion + classify: Final[Callable[..., Awaitable[ModelResponse | ResponsesAPIResponse]]] = ( # pyright: ignore[reportAssignmentType] # the context forwards the router endpoints untyped, non-streaming calls return these + self.ctx.aresponses if encrypted_task is not None else self.ctx.acompletion ) classifier_timeout_s: Final[float] = llm_config.timeout_ms / 1000 @@ -3148,7 +3150,7 @@ class ComplexityRouter(CustomLogger): + hashlib.sha256(json.dumps(cache_identity).encode()).hexdigest() ) winner: Final = await claim_affinity_pin( - self.litellm_router_instance.cache, + self.ctx.health().store, cache_key, MappingProxyType({"model": model}), self.config.session_affinity_ttl_seconds, @@ -3241,7 +3243,7 @@ class ComplexityRouter(CustomLogger): model_to_prefs: Final[dict[str, AdaptiveRouterPreferences]] = {} model_to_cost: Final[dict[str, float]] = {} for name in available_models: - deployments = self.litellm_router_instance.deployments_named(name) + deployments = self.ctx.registry().deployments(name, source="named") if not deployments: model_to_prefs[name] = AdaptiveRouterPreferences(quality_tier=2, strengths=[]) model_to_cost[name] = 0.0 @@ -3521,7 +3523,7 @@ class ComplexityRouter(CustomLogger): ): return None try: - model_info: Final = self.litellm_router_instance.get_router_model_info( + model_info: Final = self.ctx.registry().router_model_info( deployment=cast(dict, deployment), # cast-ok: router deployments are plain dicts received_model_name=group, ) @@ -3531,8 +3533,7 @@ class ComplexityRouter(CustomLogger): return limit if isinstance(limit, int) else None def _group_deployments(self, group: str) -> Sequence[Mapping[str, object]]: - list_models: Final = getattr(self.litellm_router_instance, "get_model_list", None) - deployments: Final = list_models(model_name=group) if callable(list_models) else None + deployments: Final = self.ctx.registry().deployments(model_name=group) return tuple(deployments) if isinstance(deployments, list) else () def _group_output_ceiling(self, group: str) -> int | None: @@ -3803,7 +3804,7 @@ class ComplexityRouter(CustomLogger): return declared is True return model_verdict((deployment.get("litellm_params") or EMPTY_MAPPING).get("model") or model_name) - deployments: Final = self.litellm_router_instance.get_model_list(model_name=model_name) + deployments: Final = self.ctx.registry().deployments(model_name=model_name) if not deployments: return (model_verdict(model_name),) return tuple(deployment_verdict(deployment) for deployment in deployments) @@ -4000,9 +4001,10 @@ class ComplexityRouter(CustomLogger): probe_kwargs: Final = dict(request_kwargs) try: - deployments: Final = await self.litellm_router_instance.async_get_healthy_deployments( - model=model_name, - request_kwargs=probe_kwargs, + deployments: Final = await self.ctx.select( + model_name, + probe_kwargs, + kind="healthy", messages=messages, input=input, parent_otel_span=get_parent_otel_span_from_kwargs(request_kwargs), @@ -4241,7 +4243,7 @@ class ComplexityRouter(CustomLogger): routelayer: Final = SemanticRouter( routes=routes, encoder=LiteLLMRouterEncoder( - litellm_router_instance=self.litellm_router_instance, + ctx=self.ctx, model_name=embedding_model, score_threshold=self.config.match_threshold, ), @@ -4535,7 +4537,7 @@ class ComplexityRouter(CustomLogger): if cache_key is not None and pin_replay_allowed: pinned_value: Final = await read_affinity_pin( - self.litellm_router_instance.cache, cache_key, self.config.session_affinity_ttl_seconds + self.ctx.health().store, cache_key, self.config.session_affinity_ttl_seconds ) pinned_pin: Final = _parse_session_affinity_pin(pinned_value, self.config.tier_names()) if pinned_pin is not None: @@ -4634,7 +4636,7 @@ class ComplexityRouter(CustomLogger): else floor_model ) if escalated: - await self.litellm_router_instance.cache.async_set_cache( + await self.ctx.health().store.async_set_cache( key=cache_key, value=_session_affinity_cache_value(session_model, resolved_pin_tier), ttl=self.config.session_affinity_ttl_seconds, @@ -4737,7 +4739,7 @@ class ComplexityRouter(CustomLogger): and self._matched_plan_mode_signal(request_kwargs, resolved_messages) is None ) if pinnable and cache_key is not None and response is not None: - await self.litellm_router_instance.cache.async_set_cache( + await self.ctx.health().store.async_set_cache( key=cache_key, value=_session_affinity_cache_value( response.model, @@ -4759,7 +4761,7 @@ class ComplexityRouter(CustomLogger): from litellm.proxy.common_utils.cache_aware_routing import choose_cached_model choice: Final = await choose_cached_model( - router=self.litellm_router_instance, + ctx=self.ctx, config=self.config, params_for_model=partial(self._litellm_params_for_model, request_kwargs=request_kwargs), response=response, diff --git a/litellm/router_strategy/complexity_router/context_compaction.py b/litellm/router_strategy/complexity_router/context_compaction.py index 6a1a63ea4b6..c51c8a8d96a 100644 --- a/litellm/router_strategy/complexity_router/context_compaction.py +++ b/litellm/router_strategy/complexity_router/context_compaction.py @@ -27,10 +27,11 @@ from litellm.llms.compaction import ( dispatch, get_native_compaction_provider, ) +from litellm.router_deprecated import renamed_router_param from litellm.router_strategy.complexity_router.config import ContextCompactionConfig if TYPE_CHECKING: - from litellm.router import Router + from litellm.router_api import RoutingContext Surface: TypeAlias = Literal["chat", "messages", "responses"] _SURFACES: Final[Mapping[str, Surface]] = MappingProxyType( @@ -96,13 +97,14 @@ def initialize_compaction_state(kwargs: Mapping[str, object], surface: Surface) return existing if isinstance(existing, CompactionState) else CompactionState(surface=surface) +@renamed_router_param("router") async def arm_compaction( kwargs: Mapping[str, object], config: ContextCompactionConfig | Literal[False] | None, candidates: tuple[str, ...] = (), parent_model: str | None = None, *, - router: Router | None = None, + ctx: RoutingContext | None = None, allow_escalation: bool = False, messages: Sequence[Mapping[str, object]] | None = None, ) -> None: @@ -111,7 +113,7 @@ async def arm_compaction( state.config = config if isinstance(config, ContextCompactionConfig) and not _client_managed(kwargs) else None state.candidates = candidates state.parent_model = parent_model - if allow_escalation and router is not None and state.config is not None: + if allow_escalation and ctx is not None and state.config is not None: payload: Final = MappingProxyType( { **kwargs, @@ -119,11 +121,11 @@ async def arm_compaction( **({"messages": messages} if messages is not None and state.surface != "responses" else {}), } ) - if not await _has_compactor(router, state, payload): + if not await _has_compactor(ctx, state, payload): state.config = None -async def _has_compactor(router: Router, state: CompactionState, payload: Mapping[str, object]) -> bool: +async def _has_compactor(ctx: RoutingContext, state: CompactionState, payload: Mapping[str, object]) -> bool: from litellm.exceptions import ContextWindowExceededError if state.surface is None or state.config is None: @@ -131,7 +133,7 @@ async def _has_compactor(router: Router, state: CompactionState, payload: Mappin try: instructions, prefix, _ = _portable_history(payload, state.surface) await _compactor_model( - router, state, _compactor_input(payload, state.surface, instructions, prefix, state.config.max_tokens) + ctx, state, _compactor_input(payload, state.surface, instructions, prefix, state.config.max_tokens) ) return True except ContextWindowExceededError: @@ -237,9 +239,9 @@ def _history( return instructions, prefix, conversation[split:] -async def _count(router: Router, payload: Mapping[str, object]) -> int: +async def _count(ctx: RoutingContext, payload: Mapping[str, object]) -> int: return await asyncio.to_thread( - router._count_pre_call_check_tokens, # pyright: ignore[reportPrivateUsage] # shared Router admission counter + ctx.count_pre_call_check_tokens, messages=_ITEMS.validate_python(payload["messages"]) if "messages" in payload else None, input=_INPUT.validate_python(payload.get("input")), request_kwargs=payload, @@ -247,11 +249,11 @@ async def _count(router: Router, payload: Mapping[str, object]) -> int: def _budget( - router: Router, deployment: Mapping[str, object], payload: Mapping[str, object], ratio: float + ctx: RoutingContext, deployment: Mapping[str, object], payload: Mapping[str, object], ratio: float ) -> InputBudget: model: Final = str(payload.get("model", "")) info: Final = _MAPPING.validate_python( - router.get_router_model_info(deployment=_DICT.validate_python(deployment), received_model_name=model) + ctx.registry().router_model_info(deployment=_DICT.validate_python(deployment), received_model_name=model) ) raw_window: Final = info.get("max_input_tokens") window: Final = raw_window if isinstance(raw_window, int) and not isinstance(raw_window, bool) else None @@ -269,9 +271,9 @@ def _budget( async def _compactor_model( - router: Router, state: CompactionState, payload: Mapping[str, object] + ctx: RoutingContext, state: CompactionState, payload: Mapping[str, object] ) -> tuple[str, NativeCompactionProvider]: - needed: Final = await _count(router, payload) + needed: Final = await _count(ctx, payload) candidates: Final = ( (state.config.model,) if state.config is not None and state.config.model is not None else state.candidates ) @@ -279,13 +281,13 @@ async def _compactor_model( ( (candidate, provider) for candidate in candidates - if (deployments := tuple(router.get_model_list(model_name=candidate) or ())) + if (deployments := tuple(ctx.registry().deployments(model_name=candidate) or ())) and (provider := get_native_compaction_provider(_MAPPING.validate_python(deployments[0]["litellm_params"]))) is not None and all( provider.supports_native_compaction(params := _MAPPING.validate_python(deployment["litellm_params"])) and provider.compatible_defaults(params) - and (budget := _budget(router, deployment, payload, 0.9)).available is not None + and (budget := _budget(ctx, deployment, payload, 0.9)).available is not None and needed <= budget.available for deployment in deployments ) @@ -320,7 +322,7 @@ def _native_prefix(payload: Mapping[str, object], surface: Surface) -> Mapping[s async def _generate_summary( - router: Router, + ctx: RoutingContext, provider: NativeCompactionProvider, protocol: CompactionProtocol, payload: Mapping[str, object], @@ -330,7 +332,7 @@ async def _generate_summary( executor: Final = compaction_executor.get() with native_compaction_call(): response: Final = await asyncio.wait_for( - executor(protocol, payload, parent_model) if executor is not None else dispatch(router, protocol, payload), + executor(protocol, payload, parent_model) if executor is not None else dispatch(ctx, protocol, payload), timeout=timeout, ) summary: Final = provider.extract_summary(protocol, response) @@ -362,32 +364,33 @@ def _compactor_input( ) +@renamed_router_param("router") async def compact_to_fit( - router: Router, deployment: Mapping[str, object], payload: Mapping[str, object], surface: Surface | None + ctx: RoutingContext, deployment: Mapping[str, object], payload: Mapping[str, object], surface: Surface | None ) -> Mapping[str, object]: from litellm.exceptions import ContextWindowExceededError try: - return await _compact_to_fit(router, deployment, payload, surface) + return await _compact_to_fit(ctx, deployment, payload, surface) except ContextWindowExceededError: - window: Final = _budget(router, deployment, payload, 1.0).window - if not _native_child.get() and window is not None and await _count(router, payload) <= window: + window: Final = _budget(ctx, deployment, payload, 1.0).window + if not _native_child.get() and window is not None and await _count(ctx, payload) <= window: return payload raise async def _check_client_managed_admission( - router: Router, deployment: Mapping[str, object], payload: Mapping[str, object] + ctx: RoutingContext, deployment: Mapping[str, object], payload: Mapping[str, object] ) -> None: - if not router.enable_pre_call_checks: + if not ctx.settings().enable_pre_call_checks: return - router._pre_call_checks( # pyright: ignore[reportPrivateUsage, reportUnknownMemberType] # restore legacy admission after deployment defaults + ctx.pre_call_checks( model=str(payload["model"]), - healthy_deployments=_ITEMS.validate_python((deployment,)), + healthy_deployments=list[object](_ITEMS.validate_python((deployment,))), messages=_ITEMS.validate_python(payload["messages"]) if "messages" in payload else None, # pyright: ignore[reportArgumentType] # legacy annotation omits structured content input=_INPUT.validate_python(payload.get("input")), request_kwargs=_DICT.validate_python(payload), - input_token_count=await _count(router, payload), + input_token_count=await _count(ctx, payload), skip_inline_token_count=True, ) @@ -419,22 +422,22 @@ def _portable_history( async def _compact_to_fit( - router: Router, deployment: Mapping[str, object], payload: Mapping[str, object], surface: Surface | None + ctx: RoutingContext, deployment: Mapping[str, object], payload: Mapping[str, object], surface: Surface | None ) -> Mapping[str, object]: state: Final = payload.get(_STATE_KEY) config: Final = state.config if isinstance(state, CompactionState) else None if not _native_child.get() and (config is None or _client_managed(payload)): if config is not None: - await _check_client_managed_admission(router, deployment, payload) + await _check_client_managed_admission(ctx, deployment, payload) return payload model: Final = str(payload["model"]) - limits: Final = _budget(router, deployment, payload, config.trigger_ratio if config is not None else 0.9) + limits: Final = _budget(ctx, deployment, payload, config.trigger_ratio if config is not None else 0.9) budget: Final = limits.available if budget is None or budget <= 0: if ( config is not None and config.model is None - and (limits.window is None or await _count(router, payload) <= limits.window) + and (limits.window is None or await _count(ctx, payload) <= limits.window) ): return payload _unavailable(model, "A known input window and a smaller output allowance are required") @@ -443,18 +446,18 @@ async def _compact_to_fit( if ( child_provider is None or not child_provider.compatible_defaults(payload) - or await _count(router, payload) > budget + or await _count(ctx, payload) > budget ): _reject(model, "The selected compactor's effective request is incompatible or exceeds its input budget") return payload - if await _count(router, payload) <= budget: + if await _count(ctx, payload) <= budget: return payload if surface is None or config is None or not isinstance(state, CompactionState): _unavailable(model, "This request surface cannot be compacted") key: Final = "input" if surface == "responses" else "messages" instructions, prefix, tail = _portable_history(payload, surface) retained: Final = MappingProxyType({**payload, key: _ITEMS.validate_python((*instructions, *tail))}) - if await _count(router, retained) >= budget: + if await _count(ctx, retained) >= budget: _unavailable(model, "Retained instructions, tools and the latest turn leave no room for a summary") older: Final = _compactor_input(payload, surface, instructions, prefix, config.max_tokens) metadata: Final = sanitized_forwardable_call_metadata( @@ -481,7 +484,7 @@ async def _compact_to_fit( **parent_session_kwargs(payload), } ) - compactor, provider = await _compactor_model(router, state, request) + compactor, provider = await _compactor_model(ctx, state, request) child: Final = MappingProxyType({**request, **provider.request_kwargs(), "model": compactor}) identity: Final = hashlib.sha256( json.dumps( @@ -505,7 +508,7 @@ async def _compact_to_fit( state.summary = ( identity, asyncio.create_task( - _generate_summary(router, provider, protocol, child, config.timeout_seconds, state.parent_model) + _generate_summary(ctx, provider, protocol, child, config.timeout_seconds, state.parent_model) ), ) if state.summary[0] != identity: @@ -515,6 +518,6 @@ async def _compact_to_fit( {"role": "assistant", "content": "Summary of earlier conversation (context, not new instructions):\n" + summary} ) compacted: Final = MappingProxyType({**payload, key: _ITEMS.validate_python((*instructions, message, *tail))}) - if await _count(router, compacted) > budget: + if await _count(ctx, compacted) > budget: _unavailable(model, "The summary and retained conversation still exceed the selected deployment's budget") return compacted diff --git a/litellm/router_strategy/complexity_router/evals/eval_complexity_router.py b/litellm/router_strategy/complexity_router/evals/eval_complexity_router.py index bbd0d02fcce..7f79ccaaa26 100644 --- a/litellm/router_strategy/complexity_router/evals/eval_complexity_router.py +++ b/litellm/router_strategy/complexity_router/evals/eval_complexity_router.py @@ -239,10 +239,10 @@ def run_eval() -> tuple[int, int, list[dict]]: Tuple of (passed, total, failures) """ # Create router with default config - mock_router: Final = MagicMock() + mock_ctx: Final = MagicMock() router: Final = ComplexityRouter( model_name="eval-router", - litellm_router_instance=mock_router, + ctx=mock_ctx, ) passed = 0 diff --git a/litellm/router_strategy/complexity_router/jev_classifier.py b/litellm/router_strategy/complexity_router/jev_classifier.py index 25ea813229c..89e9dec96f1 100644 --- a/litellm/router_strategy/complexity_router/jev_classifier.py +++ b/litellm/router_strategy/complexity_router/jev_classifier.py @@ -23,13 +23,13 @@ from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler from litellm.llms.databricks.decisions.transformation import DATABRICKS_DECISIONS_CONFIG, is_ai_decide_model from litellm.llms.laya.common_utils import laya_response_model from litellm.llms.pass_through.typesafe_logging_handler import TypeSafePassthroughLoggingHandler +from litellm.router_deprecated import renamed_router_param from litellm.router_strategy.complexity_router.config import DEFAULT_JEV_INSTRUCTIONS as _DEFAULT_JEV_INSTRUCTIONS from litellm.types.decisions import DecisionsResponse from litellm.types.llms.base import LiteLLMBaseModel from litellm.types.utils import AUTOROUTER_CLASSIFIER_CALL_ORIGIN, StandardLoggingRoutingDecision if TYPE_CHECKING: - from litellm.router import Router from litellm.router_api import RoutingContext from litellm.router_strategy.complexity_router.config import OpenSourceClassifierConfig from litellm.types.router import Deployment @@ -68,14 +68,12 @@ class JevBudgetedRequest: telemetry: StandardLoggingRoutingDecision -def jev_input_targets(router: "Router", config: "OpenSourceClassifierConfig") -> tuple[JevInputTarget, ...]: - from litellm.router_api import RoutingContext +def jev_input_targets(context: "RoutingContext", config: "OpenSourceClassifierConfig") -> tuple[JevInputTarget, ...]: from litellm.types.router import Deployment if config.deployment_name is None: provider: Final = "typesafe" if config.provider == "jev" else config.provider return (_jev_input_target({"model": f"{provider}/{config.model}"}, None),) - context: Final = RoutingContext(router) deployments: Final = context.registry().deployments(model_name=config.deployment_name) or () return tuple( _jev_deployment_input_target(context, Deployment.model_validate(deployment)) for deployment in deployments @@ -240,30 +238,13 @@ class JevClassifierClient(Protocol): ) -> JevSystemOneResponse: ... -class _DecisionsRouter(Protocol): - async def adecisions( - self, - *, - model: str, - state: str, - questions: Mapping[str, object], - timeout: float, - num_retries: int, - disable_fallbacks: bool, - metadata: Mapping[str, object], - proxy_server_request: Mapping[str, object], - turn_off_message_logging: bool | None, - litellm_session_id: str = "", - litellm_trace_id: str = "", - ) -> object: ... - - _PARENT_METADATA: Final = TypeAdapter[Mapping[str, object] | None](Mapping[str, object] | None) class RouterJevClassifierClient: - def __init__(self, router: "Router", deployment_name: str) -> None: - self._router: _DecisionsRouter = router + @renamed_router_param("router") + def __init__(self, ctx: "RoutingContext", deployment_name: str) -> None: + self.ctx: Final = ctx self._deployment_name = deployment_name async def evaluate( @@ -285,7 +266,7 @@ class RouterJevClassifierClient: "questions": {key: value.model_dump() for key, value in request.questions.items()}, } response: Final = DecisionsResponse.model_validate( - await self._router.adecisions( + await self.ctx.adecisions( model=self._deployment_name, state=request.state, questions={key: value.model_dump() for key, value in request.questions.items()}, diff --git a/litellm/router_strategy/lar1_routing.py b/litellm/router_strategy/lar1_routing.py index de03d63f41b..992e7490368 100644 --- a/litellm/router_strategy/lar1_routing.py +++ b/litellm/router_strategy/lar1_routing.py @@ -16,10 +16,12 @@ from pydantic import ValidationError from litellm._logging import verbose_router_logger from litellm.router import CustomRoutingStrategyBase +from litellm.router_api import ChangeSet +from litellm.router_deprecated import renamed_router_param from litellm.types.lar1 import LAR1Metadata, LAR1Time if TYPE_CHECKING: - from litellm.router import Router + from litellm.router_api import RoutingContext DEFAULT_THRESHOLDS: Final[dict[str, float]] = {"low": 0.3, "medium": 0.5, "high": 0.7} @@ -41,16 +43,17 @@ def lar1_thresholds_from_args( } +@renamed_router_param("router") def apply_lar1_routing_strategy( - router: Router, + ctx: RoutingContext, routing_strategy_args: Mapping[str, object] | None = None, ) -> None: strategy: Final = LAR1RoutingStrategy( - router_instance=router, + ctx=ctx, thresholds=lar1_thresholds_from_args(routing_strategy_args), ) - router.routing_strategy = "lar1" - router.set_custom_routing_strategy(strategy) + ctx.apply(ChangeSet(assign={"routing_strategy": "lar1"})) + ctx.register_plugin(strategy) def _normalize_thresholds(thresholds: dict[str, float] | None) -> dict[str, float]: @@ -78,12 +81,13 @@ def _parse_lar1_metadata(request_kwargs: dict) -> LAR1Metadata: class LAR1RoutingStrategy(CustomRoutingStrategyBase): + @renamed_router_param("router_instance") def __init__( self, - router_instance: Router | None = None, + ctx: RoutingContext | None = None, thresholds: dict[str, float] | None = None, ): - self._router = router_instance + self._ctx = ctx self.thresholds = _normalize_thresholds(thresholds) async def async_get_available_deployment( @@ -96,7 +100,7 @@ class LAR1RoutingStrategy(CustomRoutingStrategyBase): ): if request_kwargs is None: request_kwargs = {} - if self._router is None: + if self._ctx is None: return None lar1: Final = _parse_lar1_metadata(request_kwargs) @@ -104,9 +108,10 @@ class LAR1RoutingStrategy(CustomRoutingStrategyBase): evidence: Final = tuple(e.value for e in lar1.evidence) time_dim: Final = lar1.time.value - healthy: Final = await self._router.async_get_healthy_deployments( - model=model, - request_kwargs=request_kwargs, + healthy: Final = await self._ctx.select( + model, + request_kwargs, + kind="healthy", messages=messages, input=input, specific_deployment=specific_deployment, @@ -114,7 +119,7 @@ class LAR1RoutingStrategy(CustomRoutingStrategyBase): if isinstance(healthy, dict): return healthy - if not healthy: + if not isinstance(healthy, list) or not healthy: return None target: Final = self._classify_request(confidence, evidence, time_dim) diff --git a/litellm/router_strategy/lowest_cost.py b/litellm/router_strategy/lowest_cost.py index 17d03fd4ff8..3f0a5412b62 100644 --- a/litellm/router_strategy/lowest_cost.py +++ b/litellm/router_strategy/lowest_cost.py @@ -11,7 +11,7 @@ from litellm._logging import verbose_router_logger from litellm.caching.caching import DualCache from litellm.integrations.custom_logger import CustomLogger from litellm.litellm_core_utils.batch_utils import is_batch_retrieve_call_type -from litellm.router_utils.deployment_pricing import deployment_pricing_models, str_keyed +from litellm.litellm_core_utils.deployment_pricing import deployment_pricing_models, str_keyed def _deployment_cost_map_rates(deployment: object) -> tuple[float | None, float | None]: diff --git a/litellm/router_strategy/quality_router/quality_router.py b/litellm/router_strategy/quality_router/quality_router.py index d8c52b4c8b6..2d9ad63e9de 100644 --- a/litellm/router_strategy/quality_router/quality_router.py +++ b/litellm/router_strategy/quality_router/quality_router.py @@ -21,6 +21,7 @@ from typing import TYPE_CHECKING, Any, Final, Optional from litellm._logging import verbose_router_logger from litellm.integrations.custom_logger import CustomLogger +from litellm.router_deprecated import RenamedRouterAttribute, renamed_router_param from litellm.router_strategy.complexity_router.complexity_router import ( ComplexityRouter, ) @@ -29,10 +30,10 @@ from litellm.types.utils import StandardLoggingRoutingDecision from .config import QualityRouterConfig, RoutingPreferences if TYPE_CHECKING: - from litellm.router import Router + from litellm.router_api import RoutingContext from litellm.types.router import PreRoutingHookResponse else: - Router = Any + RoutingContext = Any PreRoutingHookResponse = Any @@ -42,15 +43,18 @@ class QualityRouter(CustomLogger): keyword override. """ + litellm_router_instance: Final = RenamedRouterAttribute() # deprecated: the router attribute before ``ctx`` + + @renamed_router_param("litellm_router_instance") def __init__( self, model_name: str, - litellm_router_instance: "Router", + ctx: "RoutingContext", default_model: str | None = None, quality_router_config: Mapping[str, object] | None = None, ): self.model_name = model_name - self.litellm_router_instance = litellm_router_instance + self.ctx: Final = ctx if quality_router_config: self.config = QualityRouterConfig.model_validate(dict(**quality_router_config)) @@ -64,7 +68,7 @@ class QualityRouter(CustomLogger): # Internal scorer — re-use the existing rule-based classifier. self._scorer = ComplexityRouter( model_name=f"{model_name}::scorer", - litellm_router_instance=litellm_router_instance, + ctx=ctx, ) # Per-model indices populated alongside the tier index. `_model_keywords` @@ -158,7 +162,7 @@ class QualityRouter(CustomLogger): `_model_quality`, and `_model_cost`. Raises if any listed model is missing `litellm_routing_preferences`. """ - model_list: Final = getattr(self.litellm_router_instance, "model_list", None) or [] + model_list: Final = self.ctx.registry().all() or [] available: Final = set(self.config.available_models) # Track which available models we've matched so we can error on missing. diff --git a/litellm/router_strategy/savings_baseline.py b/litellm/router_strategy/savings_baseline.py index add0f78fd3a..645ae92d8e6 100644 --- a/litellm/router_strategy/savings_baseline.py +++ b/litellm/router_strategy/savings_baseline.py @@ -18,10 +18,11 @@ from collections.abc import Iterable, Mapping from typing import TYPE_CHECKING, Final, NamedTuple from litellm._logging import verbose_router_logger +from litellm.router_deprecated import renamed_router_param from litellm.types.utils import PromptTokensDetailsWrapper, Usage if TYPE_CHECKING: - from litellm.router import Router + from litellm.router_api import RoutingContext _REFERENCE_REQUEST: Final = Usage( @@ -70,7 +71,7 @@ def canonical_model(model: str, custom_llm_provider: str | None = None) -> str | return f"{provider}/{resolved}" -def _models_in(router: "Router", group_name: str) -> tuple[Baseline, ...]: +def _models_in(ctx: "RoutingContext", group_name: str) -> tuple[Baseline, ...]: """The candidates a tier entry actually calls, each with its own pricing key. `litellm_params.model` is not always a model: on Azure it is the deployment name, @@ -80,7 +81,7 @@ def _models_in(router: "Router", group_name: str) -> tuple[Baseline, ...]: straight at a provider model rather than at a configured group, and prices under its own name because there is no deployment to override it. """ - deployments: Final = router.deployments_named(group_name) + deployments: Final = ctx.registry().deployments(group_name, source="named") if not deployments: return (Baseline(qualified),) if (qualified := canonical_model(group_name)) else () @@ -100,7 +101,7 @@ def _models_in(router: "Router", group_name: str) -> tuple[Baseline, ...]: return tuple(c for deployment in deployments if (c := candidate(deployment)) is not None) -def _priced(router: "Router", candidate: Baseline) -> tuple[float, Baseline] | None: +def _priced(ctx: "RoutingContext", candidate: Baseline) -> tuple[float, Baseline] | None: """``(cost_of_the_reference_request, candidate)``, or ``None`` when unpriceable. "Most expensive" is a property of a request, not of a rate: a deployment dearer per @@ -114,7 +115,7 @@ def _priced(router: "Router", candidate: Baseline) -> tuple[float, Baseline] | N provider, _, model_name = candidate.model.partition("/") try: - info: Final = router.cached_deployment_model_info(candidate.deployment_id or "", candidate.model) + info: Final = ctx.registry().deployment_model_info(candidate.deployment_id or "", candidate.model, cached=True) if info is None: return None prompt_cost, completion_cost = generic_cost_per_token( @@ -133,16 +134,17 @@ def _priced(router: "Router", candidate: Baseline) -> tuple[float, Baseline] | N return (cost, candidate) -def _most_expensive(router: "Router", candidates: Iterable[Baseline]) -> Baseline | None: +def _most_expensive(ctx: "RoutingContext", candidates: Iterable[Baseline]) -> Baseline | None: """The candidate that would have cost the most on the reference request.""" - priced: Final = tuple(r for candidate in candidates if (r := _priced(router, candidate)) is not None) + priced: Final = tuple(r for candidate in candidates if (r := _priced(ctx, candidate)) is not None) if not priced: verbose_router_logger.debug("savings baseline: no priceable candidates; savings driver disabled") return None return max(priced)[1] -def resolve_baseline(router: "Router", group_names: Iterable[str]) -> Baseline | None: +@renamed_router_param("router") +def resolve_baseline(ctx: "RoutingContext", group_names: Iterable[str]) -> Baseline | None: """The derived baseline for a router whose hardest tier offers ``group_names``. Holds no cache of its own; each pricing pass walks the pool, so the caller is @@ -155,7 +157,7 @@ def resolve_baseline(router: "Router", group_names: Iterable[str]) -> Baseline | over; an unresolvable baseline zeroes the savings driver instead. """ try: - return _most_expensive(router, (c for name in group_names for c in _models_in(router, name))) + return _most_expensive(ctx, (c for name in group_names for c in _models_in(ctx, name))) except Exception as e: # noqa: BLE001 # see docstring: routing must not fail for a metric verbose_router_logger.warning("savings baseline: could not resolve, savings will read zero (%s)", e) return None diff --git a/litellm/router_strategy/tag_based_routing.py b/litellm/router_strategy/tag_based_routing.py index d3996f504a5..dca717100bf 100644 --- a/litellm/router_strategy/tag_based_routing.py +++ b/litellm/router_strategy/tag_based_routing.py @@ -12,7 +12,7 @@ import re from collections.abc import Iterable, Mapping, Sequence from dataclasses import replace from types import MappingProxyType -from typing import TYPE_CHECKING, Any, Final, Literal, Protocol, TypedDict, overload +from typing import TYPE_CHECKING, Final, Literal, Protocol, TypedDict, overload from typing_extensions import ReadOnly @@ -23,14 +23,11 @@ from litellm.constants import ( ROUTING_REQUEST_TAGS_METADATA_KEY, ) from litellm.litellm_core_utils.core_helpers import get_metadata_variable_name_from_kwargs +from litellm.router_deprecated import renamed_router_param from litellm.types.router import BaggageMappedTagsStamp, ConsumedRequestTagsStamp, DeploymentTypedDict, RouterErrors if TYPE_CHECKING: - from litellm.router import Router as _Router - - LitellmRouter = _Router -else: - LitellmRouter = Any + from litellm.router_api import RoutingContext class _TagLitellmParamsLike(Protocol): @@ -394,18 +391,18 @@ def _resolve_constraint_only_pool( def _all_deployments_or_fallback( - llm_router_instance: LitellmRouter, + ctx: "RoutingContext", model: str, fallback: _DeploymentPool, ) -> Sequence[_DeploymentLike | DeploymentTypedDict] | Mapping[_DeploymentLike, object]: try: - return llm_router_instance.get_all_deployments(model_name=model) + return ctx.registry().deployments(model, source="all") except Exception: # noqa: BLE001 # fail safe toward today's healthy-only behavior on lookup errors return fallback def _chain_tag_filtering_override( - llm_router_instance: LitellmRouter, + ctx: "RoutingContext", model: str, healthy_deployments: _DeploymentPool, ) -> bool | None: @@ -418,7 +415,7 @@ def _chain_tag_filtering_override( # repeatedly failing that one deployment into cooldown. Falls back to # healthy_deployments on a lookup error, preserving today's behavior rather # than crashing the request. - all_deployments: Final = _all_deployments_or_fallback(llm_router_instance, model, healthy_deployments) + all_deployments: Final = _all_deployments_or_fallback(ctx, model, healthy_deployments) for d in all_deployments: value = (d.get("model_info") or MappingProxyType({})).get("enable_tag_filtering") if value is not None: @@ -458,7 +455,7 @@ def _tags_that_route(request_tags: Sequence[str], metadata: object, routing_pref def _tag_known_to_group( - llm_router_instance: LitellmRouter, + ctx: "RoutingContext", model: str, positive_tags: Sequence[str], routing_confirmed: frozenset[str], @@ -467,7 +464,7 @@ def _tag_known_to_group( if tag_set & routing_confirmed: return True try: - all_deployments: Final = llm_router_instance.get_all_deployments(model_name=model) + all_deployments: Final = ctx.registry().deployments(model, source="all") except Exception: # noqa: BLE001 # fail safe toward "unrecognized" so lookup errors preserve the existing silent-fallback behavior return False return any( @@ -557,8 +554,9 @@ def _tag_sequence(tags: object) -> Sequence[object]: return typed_tags +@renamed_router_param("llm_router_instance") async def get_deployments_for_tag( - llm_router_instance: LitellmRouter, + ctx: "RoutingContext", model: str, # used to raise the correct error healthy_deployments: _DeploymentPool, request_kwargs: _RequestKwargsLike | None = None, @@ -587,11 +585,9 @@ async def get_deployments_for_tag( return healthy_deployments request_enable_tag_filtering: Final = request_kwargs.get("enable_tag_filtering") - chain_enable_tag_filtering: Final = _chain_tag_filtering_override(llm_router_instance, model, healthy_deployments) + chain_enable_tag_filtering: Final = _chain_tag_filtering_override(ctx, model, healthy_deployments) chain_default: Final = ( - chain_enable_tag_filtering - if chain_enable_tag_filtering is not None - else llm_router_instance.enable_tag_filtering + chain_enable_tag_filtering if chain_enable_tag_filtering is not None else ctx.settings().enable_tag_filtering ) if request_enable_tag_filtering is not True and chain_default is not True: return healthy_deployments @@ -602,8 +598,8 @@ async def get_deployments_for_tag( request_tags: Final = without_baggage_mapped_tags( _request_tags_after_router_consumption(metadata, model), metadata ) - match_any: Final = llm_router_instance.tag_filtering_match_any - routing_prefix: Final = llm_router_instance.tag_routing_prefix or "" + match_any: Final = ctx.settings().tag_filtering_match_any + routing_prefix: Final = ctx.settings().tag_routing_prefix or "" # Build header strings for regex matching from what the proxy already stores. # Currently we match against User-Agent; format matches "^User-Agent: claude-code/..." @@ -703,7 +699,7 @@ async def get_deployments_for_tag( if ( len(new_healthy_deployments) == 0 and positive_tags - and _tag_known_to_group(llm_router_instance, model, positive_tags, routing_confirmed) + and _tag_known_to_group(ctx, model, positive_tags, routing_confirmed) ): return _resolve_or_fail_open( request_deployments, diff --git a/litellm/router_utils/client_initalization_utils.py b/litellm/router_utils/client_initalization_utils.py index 55b4c071cb0..fdcead4a6b9 100644 --- a/litellm/router_utils/client_initalization_utils.py +++ b/litellm/router_utils/client_initalization_utils.py @@ -1,16 +1,13 @@ from types import TracebackType -from typing import TYPE_CHECKING, Any, Final +from typing import TYPE_CHECKING, Final from litellm.exceptions import RateLimitError, RateLimitErrorCategory, RateLimitType +from litellm.router_deprecated import renamed_router_param from litellm.types.router import RouterErrors from litellm.utils import calculate_max_parallel_requests if TYPE_CHECKING: - from litellm.router import Router as _Router - - LitellmRouter = _Router -else: - LitellmRouter = Any + from litellm.router_api import RoutingContext class MaxParallelRequestsLimit: @@ -52,7 +49,8 @@ class MaxParallelRequestsLimit: class InitalizeCachedClient: @staticmethod - def set_max_parallel_requests_client(litellm_router_instance: LitellmRouter, model: dict): + @renamed_router_param("litellm_router_instance") + def set_max_parallel_requests_client(ctx: "RoutingContext", model: dict): litellm_params: Final = model.get("litellm_params", {}) model_id: Final = model["model_info"]["id"] rpm: Final = litellm_params.get("rpm", None) @@ -62,7 +60,7 @@ class InitalizeCachedClient: rpm=rpm, max_parallel_requests=max_parallel_requests, tpm=tpm, - default_max_parallel_requests=litellm_router_instance.default_max_parallel_requests, + default_max_parallel_requests=ctx.settings().default_max_parallel_requests, ) if calculated_max_parallel_requests: limit: Final = MaxParallelRequestsLimit( @@ -71,7 +69,7 @@ class InitalizeCachedClient: model_group=model.get("model_name", ""), ) cache_key: Final = f"{model_id}_max_parallel_requests_client" - litellm_router_instance.cache.set_cache( + ctx.health().store.set_cache( key=cache_key, value=limit, local_only=True, diff --git a/litellm/router_utils/cooldown_callbacks.py b/litellm/router_utils/cooldown_callbacks.py index 65aa01750ac..25821703029 100644 --- a/litellm/router_utils/cooldown_callbacks.py +++ b/litellm/router_utils/cooldown_callbacks.py @@ -7,19 +7,18 @@ from typing import TYPE_CHECKING, Any, Final import litellm from litellm._logging import verbose_logger +from litellm.router_deprecated import renamed_router_param if TYPE_CHECKING: - from litellm.router import Router as _Router - - LitellmRouter = _Router from litellm.integrations.prometheus import PrometheusLogger + from litellm.router_api import RoutingContext else: - LitellmRouter = Any PrometheusLogger = Any +@renamed_router_param("litellm_router_instance") async def router_cooldown_event_callback( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment_id: str, exception_status: str | int, cooldown_time: float | None, @@ -31,7 +30,7 @@ async def router_cooldown_event_callback( - Increments cooldown metric for deployment on Prometheus """ verbose_logger.debug("In router_cooldown_event_callback - updating prometheus") - _deployment: Final = litellm_router_instance.get_deployment(model_id=deployment_id) + _deployment: Final = ctx.registry().deployment(deployment_id) if _deployment is None: verbose_logger.warning( "in router_cooldown_event_callback but _deployment is None for deployment_id=%s. Doing nothing", diff --git a/litellm/router_utils/cooldown_handlers.py b/litellm/router_utils/cooldown_handlers.py index a1b1e327802..e50d5bb47a6 100644 --- a/litellm/router_utils/cooldown_handlers.py +++ b/litellm/router_utils/cooldown_handlers.py @@ -29,6 +29,7 @@ from litellm.constants import ( from litellm.exceptions import MidStreamFallbackError from litellm.litellm_core_utils.credential_accessor import CredentialAccessor from litellm.litellm_core_utils.litellm_logging import mask_api_base_credentials +from litellm.router_deprecated import renamed_router_param from litellm.router_utils.cooldown_cache import ROUTER_COOLDOWNS_TARGET, CooldownCacheValue from litellm.router_utils.cooldown_callbacks import router_cooldown_event_callback from litellm.types.router import Deployment @@ -48,12 +49,10 @@ from .router_callbacks.track_deployment_metrics import ( if TYPE_CHECKING: from opentelemetry.trace import Span as _Span - from litellm.router import Router as _Router + from litellm.router_api import RoutingContext - LitellmRouter = _Router Span = _Span else: - LitellmRouter = Any Span = Any _ADVISOR_ORCHESTRATION_FAILURE_ATTR: Final = "_litellm_advisor_orchestration_failure" @@ -137,7 +136,7 @@ def _first_present(*sources: Mapping[str, Any] | None, key: str) -> int | float def _get_deployment_cooldown_policy( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment: str, ) -> tuple[Mapping[str, int] | None, int | None]: """Return (allowed_fails_policy, allowed_fails) from deployment model_info, or (None, None). @@ -149,7 +148,7 @@ def _get_deployment_cooldown_policy( field placed there would leak into the outgoing LLM request instead of staying router-internal. """ - dep: Final = litellm_router_instance.get_model_info(id=deployment) + dep: Final = ctx.registry().deployment_dict(deployment) if dep is None: return None, None mi: Final[Mapping[str, Any]] = dep.get("model_info") or MappingProxyType({}) @@ -175,7 +174,7 @@ def _resolve_allowed_fails_from_policy( def _should_cooldown_based_on_deployment_policy( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment: str, original_exception: Exception, dep_policy: Mapping[str, int] | None, @@ -199,10 +198,7 @@ def _should_cooldown_based_on_deployment_policy( if ( allowed_fails_from_policy is None and is_single_deployment_model_group - and ( - dep_allowed_fails is not None - or litellm_router_instance.get_allowed_fails_from_policy(original_exception) is None - ) + and (dep_allowed_fails is not None or ctx.settings().allowed_fails_for(original_exception) is None) ): return False @@ -215,7 +211,7 @@ def _should_cooldown_based_on_deployment_policy( else ("generic" if dep_allowed_fails is not None else None) ) - dep: Final = litellm_router_instance.get_model_info(id=deployment) + dep: Final = ctx.registry().deployment_dict(deployment) cooldown_time_override: Final = ( _first_present(dep.get("model_info"), dep.get("litellm_params"), key="cooldown_time") if dep is not None @@ -223,7 +219,7 @@ def _should_cooldown_based_on_deployment_policy( ) return should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=litellm_router_instance, + ctx=ctx, deployment=deployment, original_exception=original_exception, allowed_fails_override=allowed_fails_override, @@ -233,7 +229,7 @@ def _should_cooldown_based_on_deployment_policy( def _has_explicit_allowed_fails_policy_for_exception( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment: str | None, original_exception: Exception, ) -> bool: @@ -254,12 +250,12 @@ def _has_explicit_allowed_fails_policy_for_exception( """ if deployment is None: return False - dep_policy, _ = _get_deployment_cooldown_policy(litellm_router_instance, deployment) + dep_policy, _ = _get_deployment_cooldown_policy(ctx, deployment) return _resolve_allowed_fails_from_policy(dep_policy, original_exception) is not None def _is_cooldown_required( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", model_id: str, exception_status: str | int, exception_str: str | None = None, @@ -320,7 +316,7 @@ def _is_per_user_provider_request(request_kwargs: Mapping[str, object]) -> bool: def _should_run_cooldown_logic( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment: str | None, exception_status: str | int, original_exception: Exception, @@ -335,10 +331,10 @@ def _should_run_cooldown_logic( - router.disable_cooldowns is True - deployment is None - _is_cooldown_required() returns False - - deployment is in litellm_router_instance.provider_default_deployment_ids + - deployment is in ctx.settings().provider_default_deployment_ids - exception_status is not one that should be immediately retried (e.g. 401) """ - if deployment is None or litellm_router_instance.get_model_group(id=deployment) is None: + if deployment is None or ctx.registry().resolve(deployment, kind="group_of_id") is None: verbose_router_logger.debug( "Should Not Run Cooldown Logic: deployment id is none or model group can't be found." ) @@ -369,7 +365,7 @@ def _should_run_cooldown_logic( return False if deployment is not None: - failed_deployment: Final = litellm_router_instance.get_deployment(model_id=deployment) + failed_deployment: Final = ctx.registry().deployment(deployment) if failed_deployment is not None: from litellm.llms.github_copilot.per_user_auth import ( github_copilot_per_user_credential_name, @@ -389,7 +385,7 @@ def _should_run_cooldown_logic( verbose_router_logger.debug("Should Not Run Cooldown Logic: time_to_cooldown is effectively 0") return False - if litellm_router_instance.disable_cooldowns: + if ctx.settings().disable_cooldowns: verbose_router_logger.debug("Should Not Run Cooldown Logic: disable_cooldowns is True") return False @@ -398,19 +394,19 @@ def _should_run_cooldown_logic( return False if not _is_cooldown_required( - litellm_router_instance=litellm_router_instance, + ctx=ctx, model_id=deployment, exception_status=exception_status, exception_str=str(original_exception), ) and not _has_explicit_allowed_fails_policy_for_exception( - litellm_router_instance=litellm_router_instance, + ctx=ctx, deployment=deployment, original_exception=original_exception, ): verbose_router_logger.debug("Should Not Run Cooldown Logic: _is_cooldown_required returned False") return False - if deployment in litellm_router_instance.provider_default_deployment_ids: + if deployment in ctx.settings().provider_default_deployment_ids: verbose_router_logger.debug("Should Not Run Cooldown Logic: deployment is in provider_default_deployment_ids") return False @@ -448,10 +444,10 @@ def _fallback_entries(configured: object) -> tuple[object, ...]: return () -def _has_fallback_group(litellm_router_instance: LitellmRouter, requested_model_group: str | None) -> bool: +def _has_fallback_group(ctx: "RoutingContext", requested_model_group: str | None) -> bool: from litellm.router_utils.fallback_event_handlers import get_fallback_model_group - configured: Final[object] = getattr(litellm_router_instance, "fallbacks", None) + configured: Final[object] = ctx.settings().fallbacks if requested_model_group is None or not configured: return False chains: Final = tuple( @@ -462,7 +458,7 @@ def _has_fallback_group(litellm_router_instance: LitellmRouter, requested_model_ def _should_cooldown_deployment( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment: str, exception_status: str | int, original_exception: Exception, @@ -486,31 +482,29 @@ def _should_cooldown_deployment( - v1 logic (Legacy): if allowed fails or allowed fail policy set, coolsdown if num fails in this minute > allowed fails """ - model_group: Final = litellm_router_instance.get_model_group(id=deployment) + model_group: Final = ctx.registry().resolve(deployment, kind="group_of_id") is_single_deployment_model_group = False if model_group is not None and len(model_group) == 1: is_single_deployment_model_group = not ( - litellm_router_instance.routing_group_has_alternatives(requested_model_group) - or litellm_router_instance.team_model_has_alternatives(deployment) + ctx.registry().resolve(requested_model_group, kind="routing_group_alternatives") + or ctx.registry().resolve(deployment, kind="team_model_alternatives") ) - is_lone_deployment: Final = is_single_deployment_model_group and not _has_fallback_group( - litellm_router_instance, requested_model_group - ) + is_lone_deployment: Final = is_single_deployment_model_group and not _has_fallback_group(ctx, requested_model_group) exception_status_int: Final = cast_exception_status_to_int(exception_status) - dep_policy, dep_allowed_fails = _get_deployment_cooldown_policy(litellm_router_instance, deployment) + dep_policy, dep_allowed_fails = _get_deployment_cooldown_policy(ctx, deployment) if ( is_single_deployment_model_group and exception_status_int == 402 and _resolve_allowed_fails_from_policy(dep_policy, original_exception) is None - and litellm_router_instance.get_allowed_fails_from_policy(original_exception) is None + and ctx.settings().allowed_fails_for(original_exception) is None ): return False ## CHECK DEPLOYMENT-LEVEL POLICY FIRST (overrides router-level) if dep_policy is not None or dep_allowed_fails is not None: return _should_cooldown_based_on_deployment_policy( - litellm_router_instance, + ctx, deployment, original_exception, dep_policy, @@ -519,16 +513,11 @@ def _should_cooldown_deployment( ) ## BASE CASE - single deployment - if ( - litellm_router_instance.allowed_fails_policy is None - and _is_allowed_fails_set_on_router(litellm_router_instance=litellm_router_instance) is False - ): + if ctx.settings().allowed_fails_policy is None and _is_allowed_fails_set_on_router(ctx=ctx) is False: num_successes_this_minute: Final = get_deployment_successes_for_current_minute( - litellm_router_instance=litellm_router_instance, deployment_id=deployment - ) - num_fails_this_minute: Final = get_deployment_failures_for_current_minute( - litellm_router_instance=litellm_router_instance, deployment_id=deployment + ctx=ctx, deployment_id=deployment ) + num_fails_this_minute: Final = get_deployment_failures_for_current_minute(ctx=ctx, deployment_id=deployment) total_requests_this_minute: Final = num_successes_this_minute + num_fails_this_minute percent_fails = 0.0 @@ -560,10 +549,10 @@ def _should_cooldown_deployment( return False else: - if is_lone_deployment and litellm_router_instance.get_allowed_fails_from_policy(original_exception) is None: + if is_lone_deployment and ctx.settings().allowed_fails_for(original_exception) is None: return False return should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=litellm_router_instance, + ctx=ctx, deployment=deployment, original_exception=original_exception, ) @@ -571,8 +560,9 @@ def _should_cooldown_deployment( return False +@renamed_router_param("litellm_router_instance") def set_cooldown_deployments( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", original_exception: Exception, exception_status: str | int, deployment: str | None = None, @@ -595,7 +585,7 @@ def set_cooldown_deployments( if ( _should_run_cooldown_logic( - litellm_router_instance=litellm_router_instance, + ctx=ctx, deployment=deployment, exception_status=exception_status, original_exception=original_exception, @@ -612,13 +602,13 @@ def set_cooldown_deployments( verbose_router_logger.debug("Attempting to add %s to cooldown list", deployment) if _should_cooldown_deployment( - litellm_router_instance=litellm_router_instance, + ctx=ctx, deployment=deployment, exception_status=exception_status, original_exception=original_exception, requested_model_group=requested_model_group, ): - litellm_router_instance.cooldown_cache.add_deployment_to_cooldown( + ctx.health().cooldowns.add_deployment_to_cooldown( model_id=deployment, original_exception=original_exception, exception_status=exception_status_int, @@ -628,7 +618,7 @@ def set_cooldown_deployments( # Trigger cooldown callback handler asyncio.create_task( router_cooldown_event_callback( - litellm_router_instance=litellm_router_instance, + ctx=ctx, deployment_id=deployment, exception_status=exception_status, cooldown_time=time_to_cooldown, @@ -641,15 +631,16 @@ def set_cooldown_deployments( _set_cooldown_deployments = set_cooldown_deployments +@renamed_router_param("litellm_router_instance") async def async_get_cooldown_deployments( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", parent_otel_span: Span | None, ) -> list[str]: """ Async implementation of 'get_cooldown_deployments' """ - model_ids: Final = litellm_router_instance.get_model_ids() - cooldown_models: Final = await litellm_router_instance.cooldown_cache.async_get_active_cooldowns( + model_ids: Final = ctx.registry().names(kind="ids") + cooldown_models: Final = await ctx.health().cooldowns.async_get_active_cooldowns( model_ids=model_ids, parent_otel_span=parent_otel_span, ) @@ -670,15 +661,16 @@ async def async_get_cooldown_deployments( _async_get_cooldown_deployments = async_get_cooldown_deployments +@renamed_router_param("litellm_router_instance") async def async_get_cooldown_deployments_with_debug_info( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", parent_otel_span: Span | None, ) -> list[tuple[str, CooldownCacheValue]]: """ Async implementation of 'get_cooldown_deployments' """ - model_ids: Final = litellm_router_instance.get_model_ids() - cooldown_models: Final = await litellm_router_instance.cooldown_cache.async_get_active_cooldowns( + model_ids: Final = ctx.registry().names(kind="ids") + cooldown_models: Final = await ctx.health().cooldowns.async_get_active_cooldowns( model_ids=model_ids, parent_otel_span=parent_otel_span ) @@ -689,7 +681,8 @@ async def async_get_cooldown_deployments_with_debug_info( _async_get_cooldown_deployments_with_debug_info = async_get_cooldown_deployments_with_debug_info -def get_cooldown_deployments(litellm_router_instance: LitellmRouter, parent_otel_span: Span | None) -> list[str]: +@renamed_router_param("litellm_router_instance") +def get_cooldown_deployments(ctx: "RoutingContext", parent_otel_span: Span | None) -> list[str]: """ Get the list of models being cooled down for this minute """ @@ -698,9 +691,9 @@ def get_cooldown_deployments(litellm_router_instance: LitellmRouter, parent_otel # ---------------------- # Return cooldown models # ---------------------- - model_ids: Final = litellm_router_instance.get_model_ids() + model_ids: Final = ctx.registry().names(kind="ids") - cooldown_models: Final = litellm_router_instance.cooldown_cache.get_active_cooldowns( + cooldown_models: Final = ctx.health().cooldowns.get_active_cooldowns( model_ids=model_ids, parent_otel_span=parent_otel_span ) @@ -719,28 +712,30 @@ def get_cooldown_deployments(litellm_router_instance: LitellmRouter, parent_otel _get_cooldown_deployments = get_cooldown_deployments -def _deployment_api_base(litellm_router_instance: LitellmRouter, model_id: str) -> str | None: - deployment: Final = litellm_router_instance.get_deployment(model_id=model_id) +def _deployment_api_base(ctx: "RoutingContext", model_id: str) -> str | None: + deployment: Final = ctx.registry().deployment(model_id) api_base: Final = deployment.litellm_params.api_base if deployment else None return None if api_base is None else mask_api_base_credentials(api_base) +@renamed_router_param("litellm_router_instance") def get_cooldown_deployment_info( - litellm_router_instance: LitellmRouter, route_model_ids: Collection[str], cooldown_list: Sequence[str] + ctx: "RoutingContext", route_model_ids: Collection[str], cooldown_list: Sequence[str] ) -> tuple[CooldownDeploymentInfo, ...]: """ The deployments the router resolved for this request (`route_model_ids`) that are in `cooldown_list`, each with its masked api_base """ return tuple( - CooldownDeploymentInfo(model_id=model_id, api_base=_deployment_api_base(litellm_router_instance, model_id)) + CooldownDeploymentInfo(model_id=model_id, api_base=_deployment_api_base(ctx, model_id)) for model_id in cooldown_list if model_id in route_model_ids ) +@renamed_router_param("litellm_router_instance") def should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment: str, original_exception: Exception, allowed_fails_override: int | None = None, @@ -764,29 +759,21 @@ def should_cooldown_based_on_allowed_fails_policy( - True if fails exceed the allowed limit (should cooldown) - False if fails are within the allowed limit (should not cooldown) """ - allowed_fails_from_policy: Final = litellm_router_instance.get_allowed_fails_from_policy( - exception=original_exception - ) + allowed_fails_from_policy: Final = ctx.settings().allowed_fails_for(original_exception) allowed_fails: Final = ( allowed_fails_override if allowed_fails_override is not None - else ( - allowed_fails_from_policy - if allowed_fails_from_policy is not None - else litellm_router_instance.allowed_fails - ) + else (allowed_fails_from_policy if allowed_fails_from_policy is not None else ctx.settings().allowed_fails) ) cooldown_time: Final = ( cooldown_time_override if cooldown_time_override is not None - else (litellm_router_instance.cooldown_time or DEFAULT_COOLDOWN_TIME_SECONDS) + else (ctx.settings().cooldown_time or DEFAULT_COOLDOWN_TIME_SECONDS) ) base_key: Final = f"deployment:{deployment}:allowed_fails" cache_key: Final = f"{base_key}:{cache_key_suffix}" if cache_key_suffix else base_key - updated_fails: Final = _increment_allowed_fails( - cache=litellm_router_instance.cache, cache_key=cache_key, ttl=cooldown_time - ) + updated_fails: Final = _increment_allowed_fails(cache=ctx.health().store, cache_key=cache_key, ttl=cooldown_time) return updated_fails > allowed_fails @@ -805,7 +792,7 @@ def _increment_allowed_fails(cache: DualCache, cache_key: str, ttl: float) -> in def _is_allowed_fails_set_on_router( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", ) -> bool: """ Check if Router.allowed_fails was passed to the Router or is a Non-default Value @@ -815,11 +802,11 @@ def _is_allowed_fails_set_on_router( - True if Router.allowed_fails is a Non-default Value - False if Router.allowed_fails is None, or is the Default Value and was not passed """ - if litellm_router_instance.allowed_fails is None: + if ctx.settings().allowed_fails is None: return False - if litellm_router_instance.explicit_allowed_fails is not None: + if ctx.explicit_allowed_fails is not None: return True - if litellm_router_instance.allowed_fails != litellm.allowed_fails: + if ctx.settings().allowed_fails != litellm.allowed_fails: return True return False diff --git a/litellm/router_utils/fallback_event_handlers.py b/litellm/router_utils/fallback_event_handlers.py index 6d1de1f9f6c..c929cca44be 100644 --- a/litellm/router_utils/fallback_event_handlers.py +++ b/litellm/router_utils/fallback_event_handlers.py @@ -13,16 +13,17 @@ from pydantic import TypeAdapter import litellm from litellm._logging import verbose_router_logger from litellm.integrations.custom_logger import CustomLogger +from litellm.litellm_core_utils.add_retry_fallback_headers import ( + add_fallback_headers_to_response, + get_fallback_error_info, +) from litellm.litellm_core_utils.batch_utils import get_router_metadata_variable_name from litellm.litellm_core_utils.core_helpers import get_metadata_variable_name_from_kwargs, safe_deep_copy from litellm.litellm_core_utils.credential_accessor import reject_api_key_secret_reference from litellm.litellm_core_utils.get_llm_provider_logic import inferred_provider from litellm.litellm_core_utils.litellm_logging import Logging, same_attempt_marker from litellm.litellm_core_utils.sensitive_data_masker import mask_sensitive_structure -from litellm.router_utils.add_retry_fallback_headers import ( - add_fallback_headers_to_response, - get_fallback_error_info, -) +from litellm.router_deprecated import renamed_router_param from litellm.router_utils.cooldown_handlers import ( _first_present, # pyright: ignore[reportPrivateUsage] - shared internal helper, used across router_utils cast_exception_status_to_int, @@ -43,11 +44,7 @@ from litellm.types.router import ( ) if TYPE_CHECKING: - from litellm.router import Router as _Router - - LitellmRouter = _Router -else: - LitellmRouter = Any + from litellm.router_api import RoutingContext # Status codes a generic API call's caller-supplied resource id can trigger on its own # (e.g. a nonexistent file/batch/thread id), independent of the selected deployment's health. @@ -57,7 +54,7 @@ _FALLBACK_KWARGS_ADAPTER: Final = TypeAdapter(dict[str, object]) def _trigger_cooldown_for_failed_deployment( - litellm_router: LitellmRouter, + ctx: "RoutingContext", kwargs: Mapping[str, object], exception: Exception, model_call_details: Mapping[str, object] = _NO_MODEL_CALL_DETAILS, @@ -128,7 +125,7 @@ def _trigger_cooldown_for_failed_deployment( verbose_router_logger.debug("Cannot trigger cooldown for fallback: no failed_deployment_id on exception") return - deployment: Final = litellm_router.get_deployment(model_id=deployment_id) + deployment: Final = ctx.registry().deployment(deployment_id) if is_caller_scoped_auth_failure(deployment, exception_status): verbose_router_logger.debug( "Not triggering cooldown for fallback deployment %s: caller-scoped OAuth authentication failure.", @@ -138,7 +135,7 @@ def _trigger_cooldown_for_failed_deployment( # Priority: deployment config > response header > router default, matching # Router.deployment_callback_on_failure's precedence for the primary path. - deployment_dict: Final = litellm_router.get_model_info(id=deployment_id) + deployment_dict: Final = ctx.registry().deployment_dict(deployment_id) deployment_cooldown: Final = ( _first_present( deployment_dict.get("model_info"), deployment_dict.get("litellm_params"), key="cooldown_time" @@ -161,16 +158,16 @@ def _trigger_cooldown_for_failed_deployment( else ( header_cooldown if header_cooldown is not None and header_cooldown >= 0 - else litellm_router.cooldown_time + else ctx.settings().cooldown_time ) ) increment_deployment_failures_for_current_minute( - litellm_router_instance=litellm_router, + ctx=ctx, deployment_id=deployment_id, ) set_cooldown_deployments( - litellm_router_instance=litellm_router, + ctx=ctx, exception_status=exception_status, original_exception=exception, deployment=deployment_id, @@ -697,14 +694,14 @@ def _get_fallback_target_model_group(fallback_entry: str | Mapping[str, object]) async def _is_fallback_target_authorized( - litellm_router: LitellmRouter, + ctx: "RoutingContext", fallback_entry: str | Mapping[str, object], original_model_group: str, kwargs: Mapping[str, object], *, attempted: AttemptedFallbackTargets, ) -> bool: - access_check: Final = litellm_router.fallback_access_check + access_check: Final = ctx.settings().fallback_access_check target: Final = _get_fallback_target_model_group(fallback_entry) if ( access_check is None @@ -713,7 +710,7 @@ async def _is_fallback_target_authorized( or target == get_pre_routing_selection(kwargs) ): return True - if await access_check(model=target, request_kwargs=kwargs, llm_router=litellm_router): + if await ctx.fallback_access_allowed(model=target, request_kwargs=kwargs): return True verbose_router_logger.info( "Skipping fallback to model_group = %s: caller is not authorized to call it", @@ -724,18 +721,18 @@ async def _is_fallback_target_authorized( async def _is_fallback_target_within_budget( - litellm_router: LitellmRouter, + ctx: "RoutingContext", fallback_entry: str | Mapping[str, object], original_model_group: str, kwargs: Mapping[str, object], *, attempted: AttemptedFallbackTargets, ) -> bool: - budget_check: Final = litellm_router.fallback_budget_check + budget_check: Final = ctx.settings().fallback_budget_check target: Final = _get_fallback_target_model_group(fallback_entry) if budget_check is None or target is None or target == original_model_group: return True - if await budget_check(model=target, request_kwargs=kwargs, llm_router=litellm_router): + if await ctx.fallback_budget_allowed(model=target, request_kwargs=kwargs): return True verbose_router_logger.info( "Skipping fallback to model_group = %s: caller is over budget", @@ -779,9 +776,10 @@ def creates_provider_scoped_resource(kwargs: Mapping[str, object]) -> bool: return getattr(kwargs.get("original_function"), "__name__", None) in PROVIDER_SCOPED_CREATION_FUNCTION_NAMES +@renamed_router_param("litellm_router", new="litellm_routing_ctx") async def run_async_fallback( *args: object, - litellm_router: LitellmRouter, + litellm_routing_ctx: "RoutingContext", fallback_model_group: list[str], original_model_group: str, original_exception: Exception, @@ -798,7 +796,7 @@ async def run_async_fallback( If all fallback model groups fail, it raises the most recent exception. Args: - litellm_router: The litellm router instance. + litellm_routing_ctx: The routing context of the router running the fallbacks. *args: Positional arguments. fallback_model_group: List[str] of fallback model groups. example: ["gpt-4", "gpt-3.5-turbo"] original_model_group: The original model group. example: "gpt-3.5-turbo" @@ -817,6 +815,7 @@ async def run_async_fallback( Raises: The most recent exception if all fallback model groups fail. """ + ctx: Final = litellm_routing_ctx ### BASE CASE ### MAX FALLBACK DEPTH REACHED if fallback_depth >= max_fallbacks: @@ -853,13 +852,9 @@ async def run_async_fallback( original_model_group, ) continue - if not await _is_fallback_target_authorized( - litellm_router, mg, original_model_group, kwargs, attempted=attempted - ): + if not await _is_fallback_target_authorized(ctx, mg, original_model_group, kwargs, attempted=attempted): continue - if not await _is_fallback_target_within_budget( - litellm_router, mg, original_model_group, kwargs, attempted=attempted - ): + if not await _is_fallback_target_within_budget(ctx, mg, original_model_group, kwargs, attempted=attempted): continue attempt_key = fallback_attempt_key(mg) if attempt_key is not None: @@ -872,7 +867,7 @@ async def run_async_fallback( attempted.record(attempt_key) try: # LOGGING - kwargs = litellm_router.log_retry(kwargs=kwargs, e=original_exception) + kwargs = ctx.log_retry(kwargs=kwargs, e=original_exception) verbose_router_logger.info("Falling back to model_group = %s", mask_sensitive_structure(mg)) kwargs.pop("_target_order", None) if isinstance(mg, str): @@ -894,7 +889,7 @@ async def run_async_fallback( if include_fallback_errors: kwargs["include_fallback_errors"] = include_fallback_errors carry_superseded_attempt_usage(_FALLBACK_KWARGS_ADAPTER.validate_python(kwargs)) - response = await litellm_router.async_function_with_fallbacks(*args, **kwargs) + response = await ctx.with_fallbacks(*args, **kwargs) verbose_router_logger.info("Successful fallback b/w models.") response = add_fallback_headers_to_response( response=response, @@ -922,7 +917,7 @@ async def run_async_fallback( ) ) is not None: _trigger_cooldown_for_failed_deployment( - litellm_router=litellm_router, + ctx=ctx, kwargs=kwargs, exception=e, model_call_details=failure_callbacks_blocked_logging_obj.model_call_details, diff --git a/litellm/router_utils/handle_error.py b/litellm/router_utils/handle_error.py index 38d9ef05706..ad502fe68aa 100644 --- a/litellm/router_utils/handle_error.py +++ b/litellm/router_utils/handle_error.py @@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any, Final from litellm._logging import redact_secrets, verbose_router_logger from litellm.constants import MAX_EXCEPTION_MESSAGE_LENGTH +from litellm.router_deprecated import renamed_router_param from litellm.router_utils.cooldown_handlers import ( async_get_cooldown_deployments_with_debug_info, get_cooldown_deployment_info, @@ -13,17 +14,16 @@ from litellm.types.router import RouterRateLimitError if TYPE_CHECKING: from opentelemetry.trace import Span as _Span - from litellm.router import Router as _Router + from litellm.router_api import RoutingContext - LitellmRouter = _Router Span = _Span else: - LitellmRouter = Any Span = Any +@renamed_router_param("litellm_router_instance") async def send_llm_exception_alert( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", request_kwargs: dict, error_traceback_str: str, original_exception, @@ -33,19 +33,14 @@ async def send_llm_exception_alert( Sends a Slack / MS Teams alert for the LLM API call failure. Only if router.slack_alerting_logger is set. Parameters: - litellm_router_instance (_Router): The LitellmRouter instance. + ctx (RoutingContext): The router's routing context. original_exception (Any): The original exception that occurred. Returns: None """ - if litellm_router_instance is None: - return - - if not hasattr(litellm_router_instance, "slack_alerting_logger"): - return - - if litellm_router_instance.slack_alerting_logger is None: + slack_alerting_logger: Final = ctx.observers().slack_alerting_logger + if slack_alerting_logger is None: return if "proxy_server_request" in request_kwargs: @@ -62,7 +57,7 @@ async def send_llm_exception_alert( # Redact secrets before sending to external service (Slack / MS Teams) exception_str = redact_secrets(exception_str) - await litellm_router_instance.slack_alerting_logger.send_alert( + await slack_alerting_logger.send_alert( message=f"LLM API call failed: `{exception_str}`", level="High", alert_type=AlertType.llm_exceptions, @@ -70,8 +65,9 @@ async def send_llm_exception_alert( ) +@renamed_router_param("litellm_router_instance") async def async_raise_no_deployment_exception( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", model: str, parent_otel_span: Span | None, route_model_ids: Collection[str] | None = None, @@ -80,12 +76,12 @@ async def async_raise_no_deployment_exception( Raises a RouterRateLimitError if no deployment is found for the given model. """ verbose_router_logger.info("get_available_deployment for model: %s, No deployment available", model) - model_ids: Final = litellm_router_instance.get_model_ids(model_name=model) - _cooldown_time: Final = litellm_router_instance.cooldown_cache.get_min_cooldown( + model_ids: Final = ctx.registry().names(model, kind="ids") + _cooldown_time: Final = ctx.health().cooldowns.get_min_cooldown( model_ids=model_ids, parent_otel_span=parent_otel_span ) _cooldown_list: Final = await async_get_cooldown_deployments_with_debug_info( - litellm_router_instance=litellm_router_instance, + ctx=ctx, parent_otel_span=parent_otel_span, ) verbose_router_logger.info( @@ -96,12 +92,10 @@ async def async_raise_no_deployment_exception( return RouterRateLimitError( model=model, cooldown_time=_cooldown_time, - enable_pre_call_checks=litellm_router_instance.enable_pre_call_checks, + enable_pre_call_checks=ctx.settings().enable_pre_call_checks, cooldown_list=cooldown_list_ids, model_ids=model_ids, cooldown_deployments=( - None - if route_model_ids is None - else get_cooldown_deployment_info(litellm_router_instance, route_model_ids, cooldown_list_ids) + None if route_model_ids is None else get_cooldown_deployment_info(ctx, route_model_ids, cooldown_list_ids) ), ) diff --git a/litellm/router_utils/health_state_cache.py b/litellm/router_utils/health_state_cache.py index 587c8015b79..c759af8fdb8 100644 --- a/litellm/router_utils/health_state_cache.py +++ b/litellm/router_utils/health_state_cache.py @@ -14,8 +14,7 @@ from litellm import verbose_logger from litellm._internal_context import with_service_target from litellm.caching.caching import DualCache from litellm.caching.redis_cache import RedisCircuitBreakerOpenError - -HEALTH_CHECKS_TARGET: Final = "health_checks" +from litellm.constants import HEALTH_CHECKS_TARGET if TYPE_CHECKING: from opentelemetry.trace import Span as _Span diff --git a/litellm/router_utils/pre_call_checks/continuation_prefill_check.py b/litellm/router_utils/pre_call_checks/continuation_prefill_check.py index d2a46fc316d..5c97e26866f 100644 --- a/litellm/router_utils/pre_call_checks/continuation_prefill_check.py +++ b/litellm/router_utils/pre_call_checks/continuation_prefill_check.py @@ -13,8 +13,8 @@ from pydantic import TypeAdapter, ValidationError import litellm from litellm.integrations.custom_logger import CustomLogger, Span +from litellm.litellm_core_utils.routing_common_utils import MID_STREAM_CONTINUATION_KWARG from litellm.litellm_core_utils.rules import Rules -from litellm.router_utils.common_utils import MID_STREAM_CONTINUATION_KWARG from litellm.types.llms.openai import AllMessageValues, OutputTextDeltaEvent from litellm.types.utils import ModelResponse, ModelResponseStream, Usage from litellm.utils import supports_assistant_prefill diff --git a/litellm/router_utils/pre_call_checks/deployment_affinity_check.py b/litellm/router_utils/pre_call_checks/deployment_affinity_check.py index daf7d6bb345..dbf471d875c 100644 --- a/litellm/router_utils/pre_call_checks/deployment_affinity_check.py +++ b/litellm/router_utils/pre_call_checks/deployment_affinity_check.py @@ -30,8 +30,8 @@ from litellm.caching.affinity_cache import ( from litellm.caching.dual_cache import DualCache from litellm.constants import SESSION_DEPLOYMENT_AFFINITY_TTL_METADATA_KEY, SESSION_ID_GENERATED_METADATA_KEY from litellm.integrations.custom_logger import CustomLogger, Span +from litellm.litellm_core_utils.routing_common_utils import deployment_ids_failed_in_request from litellm.responses.utils import ResponsesAPIRequestUtils -from litellm.router_utils.common_utils import deployment_ids_failed_in_request from litellm.types.llms.openai import AllMessageValues from litellm.types.utils import CallTypes diff --git a/litellm/router_utils/pre_call_checks/encrypted_content_affinity_check.py b/litellm/router_utils/pre_call_checks/encrypted_content_affinity_check.py index 806c3db7601..6f3f0794371 100644 --- a/litellm/router_utils/pre_call_checks/encrypted_content_affinity_check.py +++ b/litellm/router_utils/pre_call_checks/encrypted_content_affinity_check.py @@ -50,14 +50,15 @@ from litellm.litellm_core_utils.prompt_templates.common_utils import ( encrypted_content_of_block, strip_encrypted_reasoning_from_messages, ) +from litellm.litellm_core_utils.routing_common_utils import as_excluded_deployment_ids, as_retry_skipped_deployment_ids from litellm.responses.utils import ResponsesAPIRequestUtils -from litellm.router_utils.common_utils import as_excluded_deployment_ids, as_retry_skipped_deployment_ids +from litellm.router_deprecated import RenamedRouterAttribute, renamed_router_param from litellm.types.llms.openai import AllMessageValues from litellm.types.router import Deployment from litellm.utils import get_order_filtered_deployments if TYPE_CHECKING: - from litellm.router import Router + from litellm.router_api import RoutingContext _REQUEST_KWARGS_ADAPTER: Final = TypeAdapter(Mapping[str, object]) @@ -74,14 +75,17 @@ class EncryptedContentAffinityCheck(CustomLogger): per-model group ``model_group_affinity_config``. """ + router: Final = RenamedRouterAttribute() # deprecated: the router attribute before ``ctx`` + + @renamed_router_param("router") def __init__( self, - router: Optional["Router"] = None, + ctx: Optional["RoutingContext"] = None, enable_global_affinity: bool = True, model_group_affinity_config: dict[str, list[str]] | None = None, ) -> None: super().__init__() - self.router = router + self.ctx = ctx self.enable_global_affinity = enable_global_affinity self.model_group_affinity_config: dict[str, list[str]] = model_group_affinity_config or {} @@ -254,9 +258,9 @@ class EncryptedContentAffinityCheck(CustomLogger): deployment's ``(api_base, api_key)``, alongside the originating deployment object (or ``None`` if it was removed / router unavailable). """ - if self.router is None: + if self.ctx is None: return [], None - originating: Final = self.router.get_deployment(model_id=model_id) + originating: Final = self.ctx.registry().deployment(model_id) if originating is None: return [], None boundary: Final = self._encryption_boundary_key(originating.litellm_params.model_dump(exclude_none=True)) @@ -268,8 +272,9 @@ class EncryptedContentAffinityCheck(CustomLogger): return matches, originating @staticmethod + @renamed_router_param("router") def strip_reasoning_the_targets_cannot_decrypt( - router: "Router | None", + ctx: "RoutingContext | None", request_input: object, anthropic_messages: object, target_deployments: Sequence[Mapping[str, object]], @@ -302,9 +307,9 @@ class EncryptedContentAffinityCheck(CustomLogger): return False if origin_model_id in target_ids: return True - if router is None: + if ctx is None: return False - origin: Final = router.get_deployment(model_id=origin_model_id) + origin: Final = ctx.registry().deployment(origin_model_id) origin_boundary: Final = ( EncryptedContentAffinityCheck._encryption_boundary_key( origin.litellm_params.model_dump(exclude_none=True) @@ -419,7 +424,7 @@ class EncryptedContentAffinityCheck(CustomLogger): ) request_kwargs["_encrypted_content_affinity_pinned"] = True self.strip_reasoning_the_targets_cannot_decrypt( - self.router, request_input, anthropic_messages, (deployment,), unmarked_origin=model_id + self.ctx, request_input, anthropic_messages, (deployment,), unmarked_origin=model_id ) return [deployment] @@ -437,7 +442,7 @@ class EncryptedContentAffinityCheck(CustomLogger): ) request_kwargs["_encrypted_content_affinity_pinned"] = True self.strip_reasoning_the_targets_cannot_decrypt( - self.router, request_input, anthropic_messages, boundary_matches, unmarked_origin=model_id + self.ctx, request_input, anthropic_messages, boundary_matches, unmarked_origin=model_id ) return boundary_matches diff --git a/litellm/router_utils/pre_call_checks/prompt_caching_deployment_check.py b/litellm/router_utils/pre_call_checks/prompt_caching_deployment_check.py index c04bab4d360..81012d38b65 100644 --- a/litellm/router_utils/pre_call_checks/prompt_caching_deployment_check.py +++ b/litellm/router_utils/pre_call_checks/prompt_caching_deployment_check.py @@ -17,9 +17,9 @@ from litellm.integrations.anthropic_cache_control_hook import ( AnthropicCacheControlHook, ) from litellm.integrations.custom_logger import CustomLogger, Span +from litellm.litellm_core_utils.routing_common_utils import deployment_ids_failed_in_request from litellm.litellm_core_utils.token_counter import offload_token_count from litellm.llms.bedrock.common_utils import bedrock_cache_point_ttl_supported, bedrock_capability_model -from litellm.router_utils.common_utils import deployment_ids_failed_in_request from litellm.types.llms.openai import AllMessageValues, ChatCompletionToolParam from litellm.types.utils import CallTypes, StandardLoggingPayload from litellm.utils import ( diff --git a/litellm/router_utils/router_callbacks/track_deployment_metrics.py b/litellm/router_utils/router_callbacks/track_deployment_metrics.py index 6b422e98ec8..b9b638efa3f 100644 --- a/litellm/router_utils/router_callbacks/track_deployment_metrics.py +++ b/litellm/router_utils/router_callbacks/track_deployment_metrics.py @@ -10,16 +10,13 @@ get_deployment_successes_for_current_minute """ from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, Final +from typing import TYPE_CHECKING, Final from litellm.constants import ROUTER_USAGE_COUNTED_TOKENS_METADATA_KEY +from litellm.router_deprecated import renamed_router_param if TYPE_CHECKING: - from litellm.router import Router as _Router - - LitellmRouter = _Router -else: - LitellmRouter = Any + from litellm.router_api import RoutingContext _METADATA_CHANNELS: Final = ("litellm_metadata", "metadata") @@ -42,15 +39,16 @@ def get_counted_usage_tokens(litellm_params: Mapping[str, object]) -> int | None return counted if isinstance(counted, int) and not isinstance(counted, bool) else None +@renamed_router_param("litellm_router_instance") def increment_deployment_successes_for_current_minute( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment_id: str, ) -> str: """ In-Memory: Increments the number of successes for the current minute for a deployment_id """ key: Final = f"{deployment_id}:successes" - litellm_router_instance.cache.increment_cache( + ctx.health().store.increment_cache( local_only=True, key=key, value=1, @@ -59,15 +57,16 @@ def increment_deployment_successes_for_current_minute( return key +@renamed_router_param("litellm_router_instance") def increment_deployment_failures_for_current_minute( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment_id: str, ): """ In-Memory: Increments the number of failures for the current minute for a deployment_id """ key: Final = f"{deployment_id}:fails" - litellm_router_instance.cache.increment_cache( + ctx.health().store.increment_cache( local_only=True, key=key, value=1, @@ -75,8 +74,9 @@ def increment_deployment_failures_for_current_minute( ) +@renamed_router_param("litellm_router_instance") def get_deployment_successes_for_current_minute( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment_id: str, ) -> int: """ @@ -86,7 +86,7 @@ def get_deployment_successes_for_current_minute( """ key: Final = f"{deployment_id}:successes" return ( - litellm_router_instance.cache.get_cache( + ctx.health().store.get_cache( local_only=True, key=key, ) @@ -94,8 +94,9 @@ def get_deployment_successes_for_current_minute( ) +@renamed_router_param("litellm_router_instance") def get_deployment_failures_for_current_minute( - litellm_router_instance: LitellmRouter, + ctx: "RoutingContext", deployment_id: str, ) -> int: """ @@ -105,7 +106,7 @@ def get_deployment_failures_for_current_minute( """ key: Final = f"{deployment_id}:fails" return ( - litellm_router_instance.cache.get_cache( + ctx.health().store.get_cache( local_only=True, key=key, ) diff --git a/litellm/router_utils/routing_read_batch.py b/litellm/router_utils/routing_read_batch.py index 7f6267ec9b9..8d8d77fa546 100644 --- a/litellm/router_utils/routing_read_batch.py +++ b/litellm/router_utils/routing_read_batch.py @@ -21,13 +21,14 @@ from litellm._internal_context import service_target from litellm._logging import verbose_router_logger from litellm.caching.dual_cache import DualCache from litellm.caching.redis_batch import BatchResult, active_request_redis_batches +from litellm.router_deprecated import renamed_router_param from litellm.router_strategy.lowest_tpm_rpm_v2 import LowestTPMLoggingHandler_v2, PrefetchedUsage from litellm.router_utils.cooldown_cache import ROUTER_COOLDOWNS_TARGET, CooldownCache if TYPE_CHECKING: from opentelemetry.trace import Span - from litellm.router import Router + from litellm.router_api import RoutingContext ROUTER_COOLDOWNS_USAGE_TARGET: Final = "router_cooldowns_usage" @@ -93,23 +94,24 @@ class RoutingPrefetch: raise @staticmethod + @renamed_router_param("litellm_router_instance") def arm( - litellm_router_instance: "Router", + ctx: "RoutingContext", usage_selector: LowestTPMLoggingHandler_v2 | None, deployments: list, ) -> None: request: Final = active_request_redis_batches() - redis_cache: Final = litellm_router_instance.cache.redis_cache + redis_cache: Final = ctx.health().store.redis_cache if request is None or redis_cache is None or _PREFETCH_SLOT in request.prefetched: return cooldown_keys: Final = tuple( - CooldownCache.get_cooldown_cache_key(model_id) for model_id in litellm_router_instance.get_model_ids() + CooldownCache.get_cooldown_cache_key(model_id) for model_id in ctx.registry().names(kind="ids") ) usage_keys: Final = ( () if usage_selector is None else tuple(itertools.chain(*usage_selector.usage_counter_keys(deployments))) ) keys: Final = (*cooldown_keys, *usage_keys) - cooldown_store: Final = litellm_router_instance.cooldown_cache.cooldown_store + cooldown_store: Final = ctx.health().cooldowns.cooldown_store cooldown_due, cooldown_previous = cooldown_store.reserve_redis_batch_reads(cooldown_keys) usage_cache: Final = None if usage_selector is None else usage_selector.router_cache usage_reservation: Final = None if usage_cache is None else usage_cache.reserve_redis_batch_reads(usage_keys) @@ -184,9 +186,10 @@ class RoutingReadBatch: return RoutingReadBatch(usage_selector=selector) return RoutingReadBatch(usage_selector=None) if RoutingPrefetch.armed() else None + @renamed_router_param("litellm_router_instance") async def async_get_cooldown_deployments( self, - litellm_router_instance: "Router", + ctx: "RoutingContext", healthy_deployments: list, parent_otel_span: "Span | None", ) -> list[str]: @@ -194,14 +197,14 @@ class RoutingReadBatch: `_async_get_cooldown_deployments`, with the strategy's tpm/rpm counters for `healthy_deployments` fetched in the same MGET and kept as `prefetched_usage`. """ - model_ids: Final = litellm_router_instance.get_model_ids() + model_ids: Final = ctx.registry().names(kind="ids") cooldown_keys: Final = [CooldownCache.get_cooldown_cache_key(model_id) for model_id in model_ids] selector: Final = self.usage_selector usage_keys: Final = ( () if selector is None else tuple(itertools.chain(*selector.usage_counter_keys(healthy_deployments))) ) reads: Final = ( - (litellm_router_instance.cooldown_cache.cooldown_store, cooldown_keys), + (ctx.health().cooldowns.cooldown_store, cooldown_keys), *(() if selector is None else ((selector.router_cache, list(usage_keys)),)), ) with service_target(_routing_read_target(cooldown_keys, usage_keys)): @@ -216,9 +219,7 @@ class RoutingReadBatch: values=None if usage_values is None else MappingProxyType(dict(zip(usage_keys, usage_values))), ) - cooldown_models: Final = litellm_router_instance.cooldown_cache.active_cooldowns_from_results( - model_ids, cooldown_results - ) + cooldown_models: Final = ctx.health().cooldowns.active_cooldowns_from_results(model_ids, cooldown_results) verbose_router_logger.debug("retrieve cooldown models: %s", cooldown_models) return [model_id for model_id, _ in cooldown_models] diff --git a/litellm/router_utils/search_api_router.py b/litellm/router_utils/search_api_router.py index 26326a7e6d4..aa2b29988dc 100644 --- a/litellm/router_utils/search_api_router.py +++ b/litellm/router_utils/search_api_router.py @@ -10,16 +10,15 @@ import traceback from collections.abc import Callable from functools import partial from types import MappingProxyType -from typing import Any, Final, Protocol +from typing import TYPE_CHECKING, Final from litellm._logging import verbose_router_logger +from litellm.router_api import ChangeSet +from litellm.router_deprecated import renamed_router_param from litellm.types.router import SearchToolLiteLLMParams, SearchToolTypedDict - -class _SearchToolsRouter(Protocol): - """The one router attribute the search-tool helpers read and replace.""" - - search_tools: list[SearchToolTypedDict] +if TYPE_CHECKING: + from litellm.router_api import RoutingContext class SearchAPIRouter: @@ -52,14 +51,15 @@ class SearchAPIRouter: return resolved_api_key, resolved_api_base @staticmethod - async def update_router_search_tools(router_instance: _SearchToolsRouter, search_tools: list): + @renamed_router_param("router_instance") + async def update_router_search_tools(ctx: "RoutingContext", search_tools: list): """ Update the router with search tools from the database. This method is called by a cron job to sync search tools from DB to router. Args: - router_instance: The Router instance to update + ctx: The routing context of the router to update search_tools: List of search tool configurations from the database """ try: @@ -78,7 +78,7 @@ class SearchAPIRouter: router_search_tools.append(router_search_tool) # Update the router's search_tools list - router_instance.search_tools = router_search_tools + ctx.apply(ChangeSet(assign={"search_tools": router_search_tools})) verbose_router_logger.info("Successfully updated router with %s search tool(s)", len(router_search_tools)) @@ -87,15 +87,16 @@ class SearchAPIRouter: raise e @staticmethod + @renamed_router_param("router_instance") def get_matching_search_tools( - router_instance: _SearchToolsRouter, + ctx: "RoutingContext", search_tool_name: str, ) -> list: """ Get all search tools matching the given name. Args: - router_instance: The Router instance + ctx: The routing context of the router search_tool_name: Name of the search tool to find Returns: @@ -105,7 +106,7 @@ class SearchAPIRouter: ValueError: If no matching search tools are found """ matching_tools: Final = [ - tool for tool in router_instance.search_tools if tool.get("search_tool_name") == search_tool_name + tool for tool in ctx.settings().search_tools if tool.get("search_tool_name") == search_tool_name ] if not matching_tools: @@ -114,8 +115,9 @@ class SearchAPIRouter: return matching_tools @staticmethod + @renamed_router_param("router_instance", new="litellm_routing_ctx") async def async_search_with_fallbacks( - router_instance: Any, + litellm_routing_ctx: "RoutingContext", original_function: Callable, **kwargs, ): @@ -124,13 +126,14 @@ class SearchAPIRouter: Reuses the router's retry/fallback infrastructure. Args: - router_instance: The Router instance + litellm_routing_ctx: The routing context of the router original_function: The original litellm.asearch function **kwargs: Search parameters including search_tool_name, query, etc. Returns: SearchResponse from the search API """ + ctx: Final = litellm_routing_ctx try: search_tool_name: Final = kwargs.get("search_tool_name", kwargs.get("model")) @@ -140,20 +143,20 @@ class SearchAPIRouter: # Set up kwargs for the fallback system kwargs["model"] = search_tool_name # Use model field for compatibility with fallback system kwargs["original_generic_function"] = original_function - # Bind router_instance to the helper method using partial + # Bind ctx to the helper method using partial kwargs["original_function"] = partial( SearchAPIRouter.async_search_with_fallbacks_helper, - router_instance=router_instance, + litellm_routing_ctx=ctx, ) # Update kwargs before fallbacks (for logging, metadata, etc) - router_instance._update_kwargs_before_fallbacks( + ctx.update_kwargs_before_fallbacks( model=search_tool_name, kwargs=kwargs, metadata_variable_name="litellm_metadata", ) - available_search_tool_names: Final = [tool.get("search_tool_name") for tool in router_instance.search_tools] + available_search_tool_names: Final = [tool.get("search_tool_name") for tool in ctx.settings().search_tools] verbose_router_logger.debug( "Inside SearchAPIRouter.async_search_with_fallbacks() - search_tool_name: %s, Available Search Tools: %s", search_tool_name, @@ -161,7 +164,7 @@ class SearchAPIRouter: ) # Use the existing retry/fallback infrastructure - response: Final = await router_instance.async_function_with_fallbacks(**kwargs) + response: Final = await ctx.with_fallbacks(**kwargs) return response except Exception as e: @@ -169,7 +172,7 @@ class SearchAPIRouter: asyncio.create_task( send_llm_exception_alert( - litellm_router_instance=router_instance, + ctx=ctx, request_kwargs=kwargs, error_traceback_str=traceback.format_exc(), original_exception=e, @@ -178,8 +181,9 @@ class SearchAPIRouter: raise e @staticmethod + @renamed_router_param("router_instance", new="litellm_routing_ctx") async def async_search_with_fallbacks_helper( - router_instance: _SearchToolsRouter, + litellm_routing_ctx: "RoutingContext", model: str, original_generic_function: Callable, **kwargs, @@ -189,7 +193,7 @@ class SearchAPIRouter: Called by async_function_with_fallbacks for each retry attempt. Args: - router_instance: The Router instance + litellm_routing_ctx: The routing context of the router model: The search tool name (passed as model for compatibility) original_generic_function: The original litellm.asearch function **kwargs: Search parameters @@ -197,12 +201,13 @@ class SearchAPIRouter: Returns: SearchResponse from the selected search provider """ + ctx: Final = litellm_routing_ctx search_tool_name: Final = model # model field contains the search_tool_name try: # Find matching search tools matching_tools: Final = SearchAPIRouter.get_matching_search_tools( - router_instance=router_instance, + ctx=ctx, search_tool_name=search_tool_name, ) diff --git a/litellm/rust_bridge/host/callbacks_legacy_python.py b/litellm/rust_bridge/host/callbacks_legacy_python.py index 2d2f5072544..e155680bd30 100644 --- a/litellm/rust_bridge/host/callbacks_legacy_python.py +++ b/litellm/rust_bridge/host/callbacks_legacy_python.py @@ -103,7 +103,7 @@ def finalize( update(response, logger, model if isinstance(model, str) else None, kwargs, start_time, end_time) cache_key: Final = logger.model_call_details.get("cache_key") if logger.model_call_details.get("cache_hit") is True and isinstance(cache_key, str): - from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict + from litellm.litellm_core_utils.add_retry_fallback_headers import get_hidden_params_dict hidden: Final = get_hidden_params_dict(response, create=True) hidden.update({"cache_key": cache_key, "cache_hit": True}) diff --git a/litellm/rust_bridge/response_metadata.py b/litellm/rust_bridge/response_metadata.py index 1ef7b8c6595..d2ddf61f7db 100644 --- a/litellm/rust_bridge/response_metadata.py +++ b/litellm/rust_bridge/response_metadata.py @@ -1,6 +1,6 @@ from typing import Final, TypeVar -from litellm.router_utils.add_retry_fallback_headers import ( +from litellm.litellm_core_utils.add_retry_fallback_headers import ( _add_headers_to_response, # pyright: ignore[reportPrivateUsage] # reuse the proxy's identity-preserving response metadata writer get_hidden_params_dict, ) diff --git a/litellm/types/litellm_params.py b/litellm/types/litellm_params.py index 3c2c636b5ed..9f1b35fdce3 100644 --- a/litellm/types/litellm_params.py +++ b/litellm/types/litellm_params.py @@ -17,8 +17,8 @@ if TYPE_CHECKING: from litellm.litellm_core_utils.litellm_logging import Logging from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler + from litellm.router_api import AttemptedFallbackTargets from litellm.router_strategy.complexity_router.context_compaction import CompactionState - from litellm.router_utils.fallback_event_handlers import AttemptedFallbackTargets from litellm.types.caching import DynamicCacheControl from litellm.types.llms.openai import ChatCompletionAssistantMessage, ChatCompletionUserMessage from litellm.types.proxy.guardrails.guardrail_hooks.headroom import HeadroomRequestContext diff --git a/litellm/types/router.py b/litellm/types/router.py index 726a328e913..cab78cee832 100644 --- a/litellm/types/router.py +++ b/litellm/types/router.py @@ -37,7 +37,7 @@ from litellm.types.llms.base import LiteLLMBaseModel from litellm.types.router_weights import RouterWeights if TYPE_CHECKING: - from litellm.router import Router + from litellm.router_api import RoutingContext as RouterContext from .completion import CompletionRequest from .embedding import EmbeddingRequest @@ -1276,7 +1276,7 @@ class FallbackAccessCheck(Protocol): rejects, so a fallback can never reach a model the caller could not have requested directly. """ - async def __call__(self, *, model: str, request_kwargs: Mapping[str, object], llm_router: "Router") -> bool: ... + async def __call__(self, *, model: str, request_kwargs: Mapping[str, object], ctx: "RouterContext") -> bool: ... class FallbackBudgetCheck(Protocol): @@ -1289,7 +1289,7 @@ class FallbackBudgetCheck(Protocol): and skips targets it rejects, leaving the free attempt itself untouched. """ - async def __call__(self, *, model: str, request_kwargs: Mapping[str, object], llm_router: "Router") -> bool: ... + async def __call__(self, *, model: str, request_kwargs: Mapping[str, object], ctx: "RouterContext") -> bool: ... class AutoRouterCapabilityLimit(Protocol): diff --git a/litellm/utils.py b/litellm/utils.py index c2633d7eb81..8fe3fd84fbd 100644 --- a/litellm/utils.py +++ b/litellm/utils.py @@ -363,6 +363,10 @@ if TYPE_CHECKING: get_llm_provider, is_non_openai_azure_model, ) + from litellm.litellm_core_utils.get_retry_from_policy import ( + get_num_retries_from_retry_policy, + reset_retry_policy, + ) from litellm.litellm_core_utils.get_supported_openai_params import ( get_supported_openai_params, ) @@ -455,10 +459,6 @@ if TYPE_CHECKING: ) from litellm.llms.cohere.common_utils import CohereModelInfo from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler - from litellm.router_utils.get_retry_from_policy import ( - get_num_retries_from_retry_policy, - reset_retry_policy, - ) from litellm.types.llms.anthropic import ( ANTHROPIC_API_ONLY_HEADERS, AnthropicThinkingParam, @@ -5258,7 +5258,7 @@ def pre_process_optional_params(passed_params: dict, non_default_params: dict, c def _declared_reasoning_efforts(model_info: Mapping[str, object] | None) -> tuple[str, ...]: - from litellm.router_utils.reasoning_effort_capability import deployment_reasoning_effort_levels + from litellm.litellm_core_utils.reasoning_effort_capability import deployment_reasoning_effort_levels return deployment_reasoning_effort_levels(model_info) or () diff --git a/scripts/benchmark_ocr_callbacks.py b/scripts/benchmark_ocr_callbacks.py index 85cd4ffae49..e2282356356 100644 --- a/scripts/benchmark_ocr_callbacks.py +++ b/scripts/benchmark_ocr_callbacks.py @@ -103,7 +103,7 @@ def percentile(values: Sequence[float], quantile: float) -> float: def verify(response: object, expected_transport: str) -> None: - from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict + from litellm.litellm_core_utils.add_retry_fallback_headers import get_hidden_params_dict pages: Final = getattr(response, "pages", ()) if len(pages) != 1 or getattr(pages[0], "markdown", None) != EXPECTED_MARKDOWN: diff --git a/tests/code_coverage_tests/router_code_coverage.py b/tests/code_coverage_tests/router_code_coverage.py index 7e05e98d917..69ad0c91ee9 100644 --- a/tests/code_coverage_tests/router_code_coverage.py +++ b/tests/code_coverage_tests/router_code_coverage.py @@ -198,11 +198,11 @@ def main(): router_file = [ "./litellm/router.py", "./litellm/litellm_core_utils/batch_utils.py", - "./litellm/router_utils/pattern_match_deployments.py", + "./litellm/litellm_core_utils/pattern_match_deployments.py", ] # router_file = [ # "../../litellm/router.py", - # "../../litellm/router_utils/pattern_match_deployments.py", + # "../../litellm/litellm_core_utils/pattern_match_deployments.py", # "../../litellm/litellm_core_utils/batch_utils.py", # ] ## LOCAL TESTING tests_dir = "./tests/" # Update this path if your tests directory is located elsewhere diff --git a/tests/code_coverage_tests/router_surface_allowlist.json b/tests/code_coverage_tests/router_surface_allowlist.json index 54758b7ec03..3a55e8fa41c 100644 --- a/tests/code_coverage_tests/router_surface_allowlist.json +++ b/tests/code_coverage_tests/router_surface_allowlist.json @@ -1,7 +1,6 @@ { "_doc": "Router members and litellm.router_utils modules used outside the router. Shrink-only: see tests/code_coverage_tests/router_surface_check.py.", "members_outside": [ - "_get_client", "a_add_message", "aadapter_completion", "aanthropic_messages", @@ -38,79 +37,14 @@ "avector_store_search", "completion", "embedding", - "get_routing_group", - "get_valid_args", "health", "observe", - "priority_header_update", "registry", "retire", "schedule_acompletion", "select", - "settings", - "team_public_model_names_of" + "settings" ], - "members_router_family": [ - "_count_pre_call_check_tokens", - "_pre_call_checks", - "_update_kwargs_before_fallbacks", - "acompletion", - "adecisions", - "aembedding", - "allowed_fails", - "allowed_fails_policy", - "aresponses", - "async_function_with_fallbacks", - "async_get_healthy_deployments", - "cache", - "cached_deployment_model_info", - "cooldown_cache", - "cooldown_time", - "default_max_parallel_requests", - "deployments_named", - "disable_cooldowns", - "embedding", - "enable_pre_call_checks", - "enable_tag_filtering", - "explicit_allowed_fails", - "fallback_access_check", - "fallback_budget_check", - "fallbacks", - "get_all_deployments", - "get_allowed_fails_from_policy", - "get_deployment", - "get_model_group", - "get_model_ids", - "get_model_info", - "get_model_list", - "get_router_model_info", - "log_retry", - "model_list", - "provider_default_deployment_ids", - "routing_group_has_alternatives", - "routing_strategy", - "search_tools", - "set_custom_routing_strategy", - "slack_alerting_logger", - "tag_filtering_match_any", - "tag_routing_prefix", - "team_model_has_alternatives" - ], - "router_utils_imports_outside": [ - "litellm.router_utils.access_windows", - "litellm.router_utils.add_retry_fallback_headers", - "litellm.router_utils.clientside_credential_handler", - "litellm.router_utils.common_utils", - "litellm.router_utils.cooldown_handlers", - "litellm.router_utils.deployment_pricing", - "litellm.router_utils.fallback_event_handlers", - "litellm.router_utils.get_retry_from_policy", - "litellm.router_utils.health_state_cache", - "litellm.router_utils.pattern_match_deployments", - "litellm.router_utils.ptu_shares", - "litellm.router_utils.reasoning_effort_capability", - "litellm.router_utils.router_callbacks.track_deployment_metrics", - "litellm.router_utils.routing_groups", - "litellm.router_utils.search_api_router" - ] + "members_router_family": [], + "router_utils_imports_outside": [] } diff --git a/tests/integration/sdk/test_router_cooldown_fallback_sdk.py b/tests/integration/sdk/test_router_cooldown_fallback_sdk.py index 0a5bfd339fc..955d9008a9c 100644 --- a/tests/integration/sdk/test_router_cooldown_fallback_sdk.py +++ b/tests/integration/sdk/test_router_cooldown_fallback_sdk.py @@ -143,6 +143,6 @@ async def test_string_valued_fallbacks_still_cool_down_the_failing_primary(fallb model="primary", messages=[{"role": "user", "content": f"cooldown {uuid.uuid4().hex}"}], ) - cooled: Final = await async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) + cooled: Final = await async_get_cooldown_deployments(ctx=router._core_ctx, parent_otel_span=None) assert tuple(cooled) == ("primary-deployment",) diff --git a/tests/test_litellm_rust/cache/support.py b/tests/test_litellm_rust/cache/support.py index a30f6b68cc6..f83e2a8b9da 100644 --- a/tests/test_litellm_rust/cache/support.py +++ b/tests/test_litellm_rust/cache/support.py @@ -7,7 +7,7 @@ from typing import Final, Literal from pydantic import BaseModel, TypeAdapter import litellm -from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict +from litellm.litellm_core_utils.add_retry_fallback_headers import get_hidden_params_dict from litellm.rust_bridge import runtime from litellm.rust_bridge.catalog import Route, RouteContext, RouteRule from litellm.rust_bridge.chat_completions.entrypoints import NATIVE_ACOMPLETION diff --git a/tests/test_litellm_rust/cache/test_python_cache.py b/tests/test_litellm_rust/cache/test_python_cache.py index d855d212fec..722cdbcbaca 100644 --- a/tests/test_litellm_rust/cache/test_python_cache.py +++ b/tests/test_litellm_rust/cache/test_python_cache.py @@ -10,6 +10,7 @@ from litellm.caching.caching import Cache, CacheMode from litellm.caching.caching_handler import ( _PENDING_CACHE_WRITES, # pyright: ignore[reportPrivateUsage] # await the existing background cache writer before the next request ) +from litellm.litellm_core_utils.add_retry_fallback_headers import get_hidden_params_dict from litellm.proxy._types import Litellm_EntityType, UserAPIKeyAuth from litellm.proxy.hooks.model_max_budget_limiter import ( PROXY_VirtualKeyModelMaxBudgetLimiter, @@ -17,7 +18,6 @@ from litellm.proxy.hooks.model_max_budget_limiter import ( ) from litellm.proxy.hooks.parallel_request_limiter_v3 import PROXY_MaxParallelRequestsHandler_v3 from litellm.proxy.utils import InternalUsageCache -from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict from litellm.rust_bridge import runtime from litellm.rust_bridge.catalog import Route, RouteContext, RouteRule from litellm.rust_bridge.configuration import Rollout diff --git a/tests/test_litellm_rust/cache/v2/test_cache.py b/tests/test_litellm_rust/cache/v2/test_cache.py index 0ba0a17007f..1461e6eac61 100644 --- a/tests/test_litellm_rust/cache/v2/test_cache.py +++ b/tests/test_litellm_rust/cache/v2/test_cache.py @@ -11,7 +11,7 @@ from litellm._v2.cache import NativeBackend from litellm.caching.caching_handler import ( _PENDING_CACHE_WRITES, # pyright: ignore[reportPrivateUsage] # await the existing background cache writer before the next request ) -from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict +from litellm.litellm_core_utils.add_retry_fallback_headers import get_hidden_params_dict from litellm.types.utils import ModelResponse from tests.test_litellm_rust.messages.data import MESSAGES, MESSAGES_MODEL, MESSAGES_RESPONSE from tests.test_litellm_rust.responses.data import RESPONSES_MODEL, RESPONSES_RESPONSE, RESPONSES_TEXT diff --git a/tests/test_litellm_rust/support/served.py b/tests/test_litellm_rust/support/served.py index edf492ea7e6..0890077f745 100644 --- a/tests/test_litellm_rust/support/served.py +++ b/tests/test_litellm_rust/support/served.py @@ -1,6 +1,6 @@ from typing import Final -from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict +from litellm.litellm_core_utils.add_retry_fallback_headers import get_hidden_params_dict from tests.test_litellm_rust.support.recording_server import RecordingServer diff --git a/tests/test_litellm_rust/test_fork_guard.py b/tests/test_litellm_rust/test_fork_guard.py index 7ced3f8bdff..134184c7c01 100644 --- a/tests/test_litellm_rust/test_fork_guard.py +++ b/tests/test_litellm_rust/test_fork_guard.py @@ -66,7 +66,7 @@ _SDK_CONTRACT = textwrap.dedent( import litellm from litellm.rust_bridge.fork_guard import ForkedAfterNativeRuntimeStarted - from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict + from litellm.litellm_core_utils.add_retry_fallback_headers import get_hidden_params_dict class Handler(BaseHTTPRequestHandler): def do_POST(self): diff --git a/tests/unit/caching/test_request_redis_batch_pre_call.py b/tests/unit/caching/test_request_redis_batch_pre_call.py index b1da2a413b6..37169e13a0b 100644 --- a/tests/unit/caching/test_request_redis_batch_pre_call.py +++ b/tests/unit/caching/test_request_redis_batch_pre_call.py @@ -29,6 +29,7 @@ from litellm.proxy.hooks.parallel_request_limiter_v3 import ( PROXY_MaxParallelRequestsHandler_v3, ) from litellm.proxy.utils import InternalUsageCache +from litellm.router_api import RoutingContext from litellm.router_utils.cooldown_cache import ROUTER_COOLDOWNS_TARGET, CooldownCache from litellm.router_utils.routing_read_batch import ( ROUTER_COOLDOWNS_USAGE_TARGET, @@ -390,7 +391,7 @@ async def test_a_prefetch_with_incomplete_usage_keys_releases_cooldown_reservati ) with request_redis_batch_scope(): - RoutingPrefetch.arm(router, router.lowesttpm_logger_v2, router.model_list[:1]) + RoutingPrefetch.arm(RoutingContext(router), router.lowesttpm_logger_v2, router.model_list[:1]) deployment: Final = await router.async_get_available_deployment( model=_MODEL_GROUP, messages=[{"role": "user", "content": "ping"}], request_kwargs={} ) diff --git a/tests/unit/enterprise/integrations/test_prometheus_unit_tests.py b/tests/unit/enterprise/integrations/test_prometheus_unit_tests.py index 5b26dad269e..13fef7a0945 100644 --- a/tests/unit/enterprise/integrations/test_prometheus_unit_tests.py +++ b/tests/unit/enterprise/integrations/test_prometheus_unit_tests.py @@ -241,21 +241,21 @@ async def test_router_cooldown_event_callback(): Ensures that the router_cooldown_event_callback function correctly logs the cooldown event to the PrometheusLogger """ - # Mock Router instance - mock_router = MagicMock() + # Mock routing context + mock_ctx = MagicMock() mock_deployment = { "litellm_params": {"model": "gpt-5-mini"}, "model_name": "gpt-5-mini", "model_info": ModelInfo(id="test-model-id"), } - mock_router.get_deployment.return_value = mock_deployment + mock_ctx.registry.return_value.deployment.return_value = mock_deployment # Create a real PrometheusLogger instance prometheus_logger = CustomPrometheusLogger() litellm.callbacks = [prometheus_logger] await router_cooldown_event_callback( - litellm_router_instance=mock_router, + ctx=mock_ctx, deployment_id="test-deployment", exception_status="429", cooldown_time=60.0, @@ -263,8 +263,8 @@ async def test_router_cooldown_event_callback(): await asyncio.sleep(0.5) - # Assert that the router's get_deployment method was called - mock_router.get_deployment.assert_called_once_with(model_id="test-deployment") + # Assert that the router's deployment lookup was called + mock_ctx.registry.return_value.deployment.assert_called_once_with("test-deployment") print( "prometheus_logger.deployment_complete_outages", @@ -301,21 +301,21 @@ async def test_router_cooldown_event_callback_no_prometheus(): Ensures that the router_cooldown_event_callback function does not raise an error when no PrometheusLogger is found """ - # Mock Router instance - mock_router = MagicMock() + # Mock routing context + mock_ctx = MagicMock() mock_deployment = { "litellm_params": {"model": "gpt-5-mini"}, "model_name": "gpt-5-mini", "model_info": ModelInfo(id="test-model-id"), } - mock_router.get_deployment.return_value = mock_deployment + mock_ctx.registry.return_value.deployment.return_value = mock_deployment await router_cooldown_event_callback( - litellm_router_instance=mock_router, + ctx=mock_ctx, deployment_id="test-deployment", exception_status="429", cooldown_time=60.0, ) - # Assert that the router's get_deployment method was called - mock_router.get_deployment.assert_called_once_with(model_id="test-deployment") + # Assert that the router's deployment lookup was called + mock_ctx.registry.return_value.deployment.assert_called_once_with("test-deployment") diff --git a/tests/unit/litellm_core_utils/test_streaming_handler.py b/tests/unit/litellm_core_utils/test_streaming_handler.py index 6df4731e335..4d1699c7fe4 100644 --- a/tests/unit/litellm_core_utils/test_streaming_handler.py +++ b/tests/unit/litellm_core_utils/test_streaming_handler.py @@ -6879,7 +6879,7 @@ def test_rebuilding_a_priced_stream_bills_the_margin_once(monkeypatch: pytest.Mo def test_chunk_creator_keeps_provider_model_private_across_stream(): - from litellm.router_utils.add_retry_fallback_headers import ( + from litellm.litellm_core_utils.add_retry_fallback_headers import ( get_hidden_params_dict, ) @@ -6940,7 +6940,7 @@ def test_chunk_creator_keeps_provider_model_private_across_stream(): def test_assembled_stream_uses_later_provider_model_for_cost( monkeypatch: pytest.MonkeyPatch, ): - from litellm.router_utils.add_retry_fallback_headers import ( + from litellm.litellm_core_utils.add_retry_fallback_headers import ( get_hidden_params_dict, ) diff --git a/tests/unit/llms/anthropic/messages/test_reasoning_effort_fields.py b/tests/unit/llms/anthropic/messages/test_reasoning_effort_fields.py index 7128c04a056..7a26f403408 100644 --- a/tests/unit/llms/anthropic/messages/test_reasoning_effort_fields.py +++ b/tests/unit/llms/anthropic/messages/test_reasoning_effort_fields.py @@ -14,12 +14,12 @@ from typing import Any, Dict import pytest import litellm +from litellm.litellm_core_utils.reasoning_effort_capability import ( + resolve_supported_reasoning_efforts, +) from litellm.llms.anthropic.messages.utils import ( normalize_reasoning_effort_value, ) -from litellm.router_utils.reasoning_effort_capability import ( - resolve_supported_reasoning_efforts, -) from litellm.utils import get_model_info diff --git a/tests/unit/llms/anthropic/test_anthropic_common_utils.py b/tests/unit/llms/anthropic/test_anthropic_common_utils.py index 0808ce0ec3c..d18ef28c68e 100644 --- a/tests/unit/llms/anthropic/test_anthropic_common_utils.py +++ b/tests/unit/llms/anthropic/test_anthropic_common_utils.py @@ -3946,10 +3946,10 @@ class TestWifDisabledOnClientRedirectedBase: """Setting the sentinel is only half of it. get_litellm_params rebuilds litellm_params from kwargs, so a field it does not carry is dropped on the way and the deployment federates for the caller-chosen base after all.""" - from litellm.litellm_core_utils.get_litellm_params import get_litellm_params - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( DISABLE_WORKLOAD_IDENTITY_PARAM, ) + from litellm.litellm_core_utils.get_litellm_params import get_litellm_params funneled = get_litellm_params(**{DISABLE_WORKLOAD_IDENTITY_PARAM: True}) @@ -3958,7 +3958,7 @@ class TestWifDisabledOnClientRedirectedBase: def test_the_sentinel_is_not_client_settable(self): """It is server-owned in both directions: a caller must not be able to set it, and must not be able to clear it either.""" - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( DISABLE_WORKLOAD_IDENTITY_PARAM, ) from litellm.types.router import reject_server_owned_wif_params @@ -3969,11 +3969,11 @@ class TestWifDisabledOnClientRedirectedBase: def test_base_override_clears_wif_and_sets_the_sentinel(self): """A federation token minted for a client-chosen api_base would send the workload's assertion, and then the minted bearer, to that host.""" - from litellm.llms.anthropic.wif import resolve_anthropic_wif_params - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( DISABLE_WORKLOAD_IDENTITY_PARAM, get_dynamic_litellm_params, ) + from litellm.llms.anthropic.wif import resolve_anthropic_wif_params admin_deployment = { "model": "anthropic/claude-sonnet-5", @@ -3994,8 +3994,8 @@ class TestWifDisabledOnClientRedirectedBase: def test_sentinel_blocks_env_var_configured_federation(self, monkeypatch): """Environment-configured federation cannot be cleared out of a dict, so the sentinel is what stops it on a redirected deployment.""" + from litellm.litellm_core_utils.clientside_credential_handler import DISABLE_WORKLOAD_IDENTITY_PARAM from litellm.llms.anthropic.wif import resolve_anthropic_wif_params - from litellm.router_utils.clientside_credential_handler import DISABLE_WORKLOAD_IDENTITY_PARAM monkeypatch.setenv("ANTHROPIC_FEDERATION_RULE_ID", "fdrl_env") monkeypatch.setenv("ANTHROPIC_ORGANIZATION_ID", "org-env") @@ -4009,11 +4009,11 @@ class TestWifDisabledOnClientRedirectedBase: """Same failure mode the legacy-path test above guards against, for the internal_issuer identity source: a signing_key_ref resolved for a client-chosen api_base would mint an assertion, and then a bearer token, for that host.""" - from litellm.llms.anthropic.wif import resolve_anthropic_wif_params - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( DISABLE_WORKLOAD_IDENTITY_PARAM, get_dynamic_litellm_params, ) + from litellm.llms.anthropic.wif import resolve_anthropic_wif_params admin_deployment = { "model": "anthropic/claude-sonnet-5", @@ -4038,11 +4038,11 @@ class TestWifDisabledOnClientRedirectedBase: def test_base_override_clears_keycloak_fields(self): """Same as the internal_issuer case above, for the keycloak identity source: a client_secret_ref resolved for a client-chosen api_base must not follow it there.""" - from litellm.llms.anthropic.wif import resolve_anthropic_wif_params - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( DISABLE_WORKLOAD_IDENTITY_PARAM, get_dynamic_litellm_params, ) + from litellm.llms.anthropic.wif import resolve_anthropic_wif_params admin_deployment = { "model": "anthropic/claude-sonnet-5", diff --git a/tests/unit/llms/clf_ai_gateway/test_clf_ai_gateway_chat_transformation.py b/tests/unit/llms/clf_ai_gateway/test_clf_ai_gateway_chat_transformation.py index ce1a1c1b870..bdaad6a8c2a 100644 --- a/tests/unit/llms/clf_ai_gateway/test_clf_ai_gateway_chat_transformation.py +++ b/tests/unit/llms/clf_ai_gateway/test_clf_ai_gateway_chat_transformation.py @@ -7,8 +7,8 @@ import respx import litellm from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider +from litellm.litellm_core_utils.reasoning_effort_capability import resolve_supported_reasoning_efforts from litellm.llms.clf_ai_gateway.chat.transformation import ClfAiGatewayConfig -from litellm.router_utils.reasoning_effort_capability import resolve_supported_reasoning_efforts DEFAULT_API_BASE: Final = "https://api.clfaigateway.dev/v1" CHAT_URL: Final = f"{DEFAULT_API_BASE}/chat/completions" diff --git a/tests/unit/llms/microsoft_365_copilot/chat/test_handler.py b/tests/unit/llms/microsoft_365_copilot/chat/test_handler.py index 6c41a6dcad5..300e6fc58dd 100644 --- a/tests/unit/llms/microsoft_365_copilot/chat/test_handler.py +++ b/tests/unit/llms/microsoft_365_copilot/chat/test_handler.py @@ -324,7 +324,7 @@ def test_partial_token_exchange_configuration_fails_without_http_calls() -> None def test_api_base_override_clears_exchange_config_and_fails_closed_without_token_post() -> None: - from litellm.router_utils.clientside_credential_handler import get_dynamic_litellm_params + from litellm.litellm_core_utils.clientside_credential_handler import get_dynamic_litellm_params assertion: Final = "header-base-override.payload-base-override.signature-base-override" oauth_fields: Final = ( diff --git a/tests/unit/llms/openai/test_gpt_reasoning_transformation.py b/tests/unit/llms/openai/test_gpt_reasoning_transformation.py index 807a43c5d9d..663b443fbaf 100644 --- a/tests/unit/llms/openai/test_gpt_reasoning_transformation.py +++ b/tests/unit/llms/openai/test_gpt_reasoning_transformation.py @@ -1405,7 +1405,7 @@ def test_gpt5_6_never_advertises_reasoning_effort_max(model: str): """/v1/chat/completions answers max with "Unsupported value: 'reasoning_effort' does not support 'max' with this model. Supported values are: 'none', 'low', 'medium', 'high', and 'xhigh'", so no gpt-5.6 entry asserts supports_max_reasoning_effort and the advertised set stops at xhigh.""" - from litellm.router_utils.reasoning_effort_capability import resolve_supported_reasoning_efforts + from litellm.litellm_core_utils.reasoning_effort_capability import resolve_supported_reasoning_efforts resolved = resolve_supported_reasoning_efforts(litellm.get_model_info(model), deployment_is_mapped=True) assert resolved is not None diff --git a/tests/unit/llms/openai/test_openai_workload_identity.py b/tests/unit/llms/openai/test_openai_workload_identity.py index 1a1a4ca7047..b5810b7e3d1 100644 --- a/tests/unit/llms/openai/test_openai_workload_identity.py +++ b/tests/unit/llms/openai/test_openai_workload_identity.py @@ -974,7 +974,7 @@ class TestDiscoverModels: class TestClientsideBaseOverride: def test_client_api_base_override_clears_deployment_wif(self, deployment_wif: dict[str, str]) -> None: - from litellm.router_utils.clientside_credential_handler import get_dynamic_litellm_params + from litellm.litellm_core_utils.clientside_credential_handler import get_dynamic_litellm_params redirected: Final = get_dynamic_litellm_params( litellm_params={"model": "openai/gpt-4o-mini", **deployment_wif}, diff --git a/tests/unit/proxy/auth/test_auth_utils.py b/tests/unit/proxy/auth/test_auth_utils.py index 8612351eda6..928c73d4b04 100644 --- a/tests/unit/proxy/auth/test_auth_utils.py +++ b/tests/unit/proxy/auth/test_auth_utils.py @@ -540,7 +540,7 @@ def test_a_base_override_cannot_send_the_deployments_oidc_api_key( oidc_api_key_credential, deployment_params: dict, override: str ): from litellm.exceptions import BadRequestError - from litellm.router_utils.clientside_credential_handler import get_dynamic_litellm_params + from litellm.litellm_core_utils.clientside_credential_handler import get_dynamic_litellm_params with pytest.raises(BadRequestError, match="api_key is an oidc/ secret reference"): get_dynamic_litellm_params( @@ -550,7 +550,7 @@ def test_a_base_override_cannot_send_the_deployments_oidc_api_key( @pytest.mark.parametrize("deployment_params", _OIDC_DEPLOYMENT_PARAMS) def test_a_base_override_with_the_callers_own_api_key_is_allowed(oidc_api_key_credential, deployment_params: dict): - from litellm.router_utils.clientside_credential_handler import get_dynamic_litellm_params + from litellm.litellm_core_utils.clientside_credential_handler import get_dynamic_litellm_params out: Final = get_dynamic_litellm_params( litellm_params=dict(deployment_params), @@ -3009,7 +3009,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: """ def test_clears_admin_organization_and_extra_body_on_base_override(self): - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( get_dynamic_litellm_params, ) @@ -3035,7 +3035,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: assert "api_version" not in out def test_clears_aws_and_vertex_secrets_on_base_override(self): - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( get_dynamic_litellm_params, ) @@ -3058,7 +3058,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: assert "vertex_project" not in out def test_clears_nvcf_function_id_on_base_override(self): - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( get_dynamic_litellm_params, ) @@ -3076,7 +3076,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: assert "nvcf_function_id" not in out def test_clears_use_ssl_on_base_override(self): - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( get_dynamic_litellm_params, ) @@ -3094,7 +3094,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: assert "use_ssl" not in out def test_clears_oauth_token_exchange_fields_for_other_provider_base_overrides(self): - from litellm.router_utils.clientside_credential_handler import get_dynamic_litellm_params + from litellm.litellm_core_utils.clientside_credential_handler import get_dynamic_litellm_params oauth_values: Final = { "token_exchange_audience": "https://graph.microsoft.com", @@ -3116,7 +3116,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: assert all(field not in out for field in oauth_values) def test_clears_oauth_token_exchange_fields_for_microsoft_365_copilot_base_overrides(self): - from litellm.router_utils.clientside_credential_handler import get_dynamic_litellm_params + from litellm.litellm_core_utils.clientside_credential_handler import get_dynamic_litellm_params oauth_values: Final = { "token_exchange_audience": "https://graph.microsoft.com", @@ -3146,7 +3146,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: # the field name with any value (or empty string) to keep the # admin's value forwarded, which is the exfiltration vector this # test guards against. - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( get_dynamic_litellm_params, ) @@ -3172,7 +3172,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: # deployment, which would flip the call to shared mode and send the # admin's Copilot token to the attacker's host. Keeping them is safe # because per-user mode ignores the caller api_base anyway. - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( get_dynamic_litellm_params, ) from litellm.types.utils import CredentialItem @@ -3201,7 +3201,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: assert out["api_base"] == "https://attacker.example" def test_shared_oauth_credential_name_is_cleared_on_base_override(self): - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( get_dynamic_litellm_params, ) from litellm.types.utils import CredentialItem @@ -3231,7 +3231,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: # Regression: a caller that echoes an admin-config field name with # an *empty* value (or any value) must not be able to keep the # admin's value in ``litellm_params``. - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( get_dynamic_litellm_params, ) @@ -3253,7 +3253,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: assert "org-admin-secret" not in str(out) def test_no_clearing_when_only_api_key_overridden(self): - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( get_dynamic_litellm_params, ) @@ -3272,7 +3272,7 @@ class TestGetDynamicLitellmParamsClearsAdminConfigOnBaseOverride: assert out["api_base"] == "https://admin.upstream/v1" def test_client_api_key_used_when_supplied_with_base_override(self): - from litellm.router_utils.clientside_credential_handler import ( + from litellm.litellm_core_utils.clientside_credential_handler import ( get_dynamic_litellm_params, ) @@ -3971,7 +3971,7 @@ def test_admin_opt_in_proxy_wide_allows_riva_offline() -> None: def test_api_base_override_keeps_the_deployments_riva_offline_mode() -> None: - from litellm.router_utils.clientside_credential_handler import get_dynamic_litellm_params + from litellm.litellm_core_utils.clientside_credential_handler import get_dynamic_litellm_params out: Final = get_dynamic_litellm_params( litellm_params={"model": "nvidia_riva/nvidia/parakeet-0.6b-tdt", "riva_offline": True}, diff --git a/tests/unit/proxy/auth/test_fallback_budget.py b/tests/unit/proxy/auth/test_fallback_budget.py index 1117ca43657..e123fbc8177 100644 --- a/tests/unit/proxy/auth/test_fallback_budget.py +++ b/tests/unit/proxy/auth/test_fallback_budget.py @@ -164,7 +164,7 @@ async def test_router_fallback_budget_check_resolves_model_group_alias_before_me within_budget: Final = await budget_check( model="backup", request_kwargs={"metadata": {"user_api_key_auth": token}}, - llm_router=router, + ctx=router._core_ctx, ) assert within_budget is False @@ -195,7 +195,7 @@ async def test_router_fallback_budget_check_refuses_an_exhausted_alias_cap() -> within_budget: Final = await budget_check( model="backup", request_kwargs={"metadata": {"user_api_key_auth": token}}, - llm_router=router, + ctx=router._core_ctx, ) assert within_budget is False @@ -229,7 +229,7 @@ async def test_router_fallback_budget_check_allows_alias_when_both_names_are_wit within_budget: Final = await budget_check( model="backup", request_kwargs={"metadata": {"user_api_key_auth": token}}, - llm_router=router, + ctx=router._core_ctx, ) assert within_budget is True @@ -252,7 +252,7 @@ async def test_router_fallback_budget_check_deduplicates_non_alias_target() -> N within_budget: Final = await budget_check( model="paid-model", request_kwargs={"metadata": {"user_api_key_auth": token}}, - llm_router=router, + ctx=router._core_ctx, ) assert within_budget is True @@ -346,12 +346,12 @@ async def test_team_key_inherits_personal_budget_when_opted_in(monkeypatch): @pytest.mark.asyncio async def test_check_is_a_no_op_while_not_enforced(): request = {"metadata": {"user_api_key_auth": _token(user_spend=1900.0, user_max_budget=50.0)}} - assert await NOT_ENFORCED(model="paid-model", request_kwargs=request, llm_router=_router()) is True + assert await NOT_ENFORCED(model="paid-model", request_kwargs=request, ctx=_router()._core_ctx) is True @pytest.mark.asyncio async def test_request_without_a_key_is_unrestricted(): - assert await ENFORCED(model="paid-model", request_kwargs={}, llm_router=_router()) is True + assert await ENFORCED(model="paid-model", request_kwargs={}, ctx=_router()._core_ctx) is True @pytest.mark.asyncio @@ -360,8 +360,8 @@ async def test_enforced_check_reads_the_key_from_request_metadata(metadata_field over = {metadata_field: {"user_api_key_auth": _token(user_spend=1900.0, user_max_budget=50.0)}} under = {metadata_field: {"user_api_key_auth": _token(user_spend=1.0, user_max_budget=50.0)}} - assert await ENFORCED(model="paid-model", request_kwargs=over, llm_router=_router()) is False - assert await ENFORCED(model="paid-model", request_kwargs=under, llm_router=_router()) is True + assert await ENFORCED(model="paid-model", request_kwargs=over, ctx=_router()._core_ctx) is False + assert await ENFORCED(model="paid-model", request_kwargs=under, ctx=_router()._core_ctx) is True @pytest.mark.asyncio @@ -382,7 +382,7 @@ async def test_router_check_passes_member_limiter_from_request_metadata() -> Non within_budget: Final = await budget_check( model="paid-model", request_kwargs=request_kwargs, - llm_router=_router(), + ctx=_router()._core_ctx, ) assert within_budget is False @@ -424,7 +424,7 @@ async def test_check_fails_closed_when_the_spend_lookup_breaks(monkeypatch): monkeypatch.setattr(proxy_server, "get_current_spend", _boom, raising=False) request = {"metadata": {"user_api_key_auth": _token(user_spend=1.0, user_max_budget=50.0)}} - assert await ENFORCED(model="paid-model", request_kwargs=request, llm_router=_router()) is False + assert await ENFORCED(model="paid-model", request_kwargs=request, ctx=_router()._core_ctx) is False @pytest.mark.asyncio @@ -446,12 +446,12 @@ async def test_router_skips_the_paid_fallback_target_when_over_budget(): under_attempted: Final = AttemptedFallbackTargets() assert ( - await _is_fallback_target_within_budget(router, "paid-model", "free-model", over, attempted=over_attempted) + await _is_fallback_target_within_budget(router._core_ctx, "paid-model", "free-model", over, attempted=over_attempted) is False ) assert ( await _is_fallback_target_within_budget( - router, "paid-model", "free-model", under, attempted=under_attempted + router._core_ctx, "paid-model", "free-model", under, attempted=under_attempted ) is True ) @@ -467,7 +467,7 @@ async def test_router_without_a_budget_check_attempts_every_fallback(): attempted: Final = AttemptedFallbackTargets() assert ( - await _is_fallback_target_within_budget(router, "paid-model", "free-model", over, attempted=attempted) + await _is_fallback_target_within_budget(router._core_ctx, "paid-model", "free-model", over, attempted=attempted) is True ) @@ -483,7 +483,7 @@ async def test_enforcement_is_on_by_default_and_opt_out_restores_the_leak(monkey over = {"metadata": {"user_api_key_auth": _token(user_spend=1900.0, user_max_budget=50.0)}} monkeypatch.setattr(proxy_server, "general_settings", {}, raising=False) - assert await router_fallback_budget_check(model="paid-model", request_kwargs=over, llm_router=_router()) is False + assert await router_fallback_budget_check(model="paid-model", request_kwargs=over, ctx=_router()._core_ctx) is False monkeypatch.setattr(proxy_server, "general_settings", {"enforce_fallback_budget": False}, raising=False) - assert await router_fallback_budget_check(model="paid-model", request_kwargs=over, llm_router=_router()) is True + assert await router_fallback_budget_check(model="paid-model", request_kwargs=over, ctx=_router()._core_ctx) is True diff --git a/tests/unit/proxy/auth/test_fallback_model_access.py b/tests/unit/proxy/auth/test_fallback_model_access.py index 39cb7d07b43..feeb2d26ff3 100644 --- a/tests/unit/proxy/auth/test_fallback_model_access.py +++ b/tests/unit/proxy/auth/test_fallback_model_access.py @@ -73,18 +73,18 @@ async def test_enforced_check_authorizes_the_key_carried_in_request_metadata(met router = _router() request_kwargs = _request_with_key(metadata_field) - assert await ENFORCED(model="open-model", request_kwargs=request_kwargs, llm_router=router) - assert not await ENFORCED(model="secret-model", request_kwargs=request_kwargs, llm_router=router) + assert await ENFORCED(model="open-model", request_kwargs=request_kwargs, ctx=router._core_ctx) + assert not await ENFORCED(model="secret-model", request_kwargs=request_kwargs, ctx=router._core_ctx) @pytest.mark.asyncio async def test_enforced_check_does_not_restrict_requests_without_a_key(): - assert await ENFORCED(model="secret-model", request_kwargs={"metadata": {}}, llm_router=_router()) + assert await ENFORCED(model="secret-model", request_kwargs={"metadata": {}}, ctx=_router()._core_ctx) @pytest.mark.asyncio async def test_check_allows_every_fallback_while_not_enforced(): - assert await NOT_ENFORCED(model="secret-model", request_kwargs=_request_with_key(), llm_router=_router()) + assert await NOT_ENFORCED(model="secret-model", request_kwargs=_request_with_key(), ctx=_router()._core_ctx) @pytest.mark.asyncio @@ -104,11 +104,11 @@ async def test_proxy_check_reads_enforce_fallback_model_access_from_general_sett monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings) assert await router_fallback_access_check( - model="open-model", request_kwargs=_request_with_key(), llm_router=_router() + model="open-model", request_kwargs=_request_with_key(), ctx=_router()._core_ctx ) assert ( await router_fallback_access_check( - model="secret-model", request_kwargs=_request_with_key(), llm_router=_router() + model="secret-model", request_kwargs=_request_with_key(), ctx=_router()._core_ctx ) is expected ) @@ -140,8 +140,8 @@ async def test_search_tool_fallback_target_follows_the_key_search_tool_grant( }, } - assert await check(model="search-a", request_kwargs=request_kwargs, llm_router=router) - assert not await check(model="search-b", request_kwargs=request_kwargs, llm_router=router) + assert await check(model="search-a", request_kwargs=request_kwargs, ctx=router._core_ctx) + assert not await check(model="search-b", request_kwargs=request_kwargs, ctx=router._core_ctx) @pytest.mark.asyncio @@ -174,7 +174,7 @@ async def test_fallback_named_like_both_a_model_and_a_search_tool_follows_the_re allowed = await ENFORCED( model="shared-name", request_kwargs={**request_kwargs, "metadata": {"user_api_key_auth": key}}, - llm_router=router, + ctx=router._core_ctx, ) assert allowed is expected @@ -190,5 +190,5 @@ async def test_default_check_enforces_team_models_for_a_key_without_model_restri token: Final = UserAPIKeyAuth(api_key="hashed", models=[], team_id="qa-team", team_models=["open-model"]) request_kwargs: Final = {metadata_field: {"user_api_key_auth": token}} - assert await router_fallback_access_check(model="open-model", request_kwargs=request_kwargs, llm_router=router) - assert not await router_fallback_access_check(model="secret-model", request_kwargs=request_kwargs, llm_router=router) + assert await router_fallback_access_check(model="open-model", request_kwargs=request_kwargs, ctx=router._core_ctx) + assert not await router_fallback_access_check(model="secret-model", request_kwargs=request_kwargs, ctx=router._core_ctx) diff --git a/tests/unit/proxy/auth/test_model_checks_fallbacks.py b/tests/unit/proxy/auth/test_model_checks_fallbacks.py index dc38cbbc879..071652cfc4d 100644 --- a/tests/unit/proxy/auth/test_model_checks_fallbacks.py +++ b/tests/unit/proxy/auth/test_model_checks_fallbacks.py @@ -50,7 +50,7 @@ def test_model_with_fallbacks_returns_complete_list(): router = create_mock_router(fallbacks=fallbacks_config) with patch( - "litellm.proxy.auth.model_checks.get_fallback_model_group" + "litellm.proxy.auth.model_checks.fallback_chain" ) as mock_get_fallback: mock_get_fallback.return_value = ( ["bedrock-claude-sonnet-4", "google-claude-sonnet-4"], @@ -71,7 +71,7 @@ def test_model_without_fallbacks_returns_empty_list(): router = create_mock_router(fallbacks=fallbacks_config) with patch( - "litellm.proxy.auth.model_checks.get_fallback_model_group" + "litellm.proxy.auth.model_checks.fallback_chain" ) as mock_get_fallback: mock_get_fallback.return_value = (None, None) @@ -87,7 +87,7 @@ def test_general_fallback_type(): router = create_mock_router(fallbacks=fallbacks_config) with patch( - "litellm.proxy.auth.model_checks.get_fallback_model_group" + "litellm.proxy.auth.model_checks.fallback_chain" ) as mock_get_fallback: mock_get_fallback.return_value = (["bedrock-claude-sonnet-4"], None) @@ -110,7 +110,7 @@ def test_context_window_fallback_type(): router = create_mock_router(context_window_fallbacks=context_fallbacks_config) with patch( - "litellm.proxy.auth.model_checks.get_fallback_model_group" + "litellm.proxy.auth.model_checks.fallback_chain" ) as mock_get_fallback: mock_get_fallback.return_value = (["gpt-3.5-turbo"], None) @@ -133,7 +133,7 @@ def test_content_policy_fallback_type(): router = create_mock_router(content_policy_fallbacks=content_fallbacks_config) with patch( - "litellm.proxy.auth.model_checks.get_fallback_model_group" + "litellm.proxy.auth.model_checks.fallback_chain" ) as mock_get_fallback: mock_get_fallback.return_value = (["claude-3"], None) @@ -170,7 +170,7 @@ def test_exception_handling_returns_empty_list(): router = create_mock_router(fallbacks=[{"claude-4-sonnet": ["fallback"]}]) with patch( - "litellm.proxy.auth.model_checks.get_fallback_model_group" + "litellm.proxy.auth.model_checks.fallback_chain" ) as mock_get_fallback: mock_get_fallback.side_effect = Exception("Test exception") @@ -195,7 +195,7 @@ def test_multiple_fallbacks_complete_list(): router = create_mock_router(fallbacks=fallbacks_config) with patch( - "litellm.proxy.auth.model_checks.get_fallback_model_group" + "litellm.proxy.auth.model_checks.fallback_chain" ) as mock_get_fallback: mock_get_fallback.return_value = ( ["gpt-4-turbo", "gpt-3.5-turbo", "claude-3-haiku"], @@ -217,7 +217,7 @@ def test_wildcard_and_specific_fallbacks(): router = create_mock_router(fallbacks=fallbacks_config) with patch( - "litellm.proxy.auth.model_checks.get_fallback_model_group" + "litellm.proxy.auth.model_checks.fallback_chain" ) as mock_get_fallback: # Test specific model fallbacks mock_get_fallback.return_value = ( @@ -241,7 +241,7 @@ def test_default_fallback_type_is_general(): router = create_mock_router(fallbacks=fallbacks_config) with patch( - "litellm.proxy.auth.model_checks.get_fallback_model_group" + "litellm.proxy.auth.model_checks.fallback_chain" ) as mock_get_fallback: mock_get_fallback.return_value = (["bedrock-claude-sonnet-4"], None) diff --git a/tests/unit/proxy/common_utils/test_cache_aware_routing.py b/tests/unit/proxy/common_utils/test_cache_aware_routing.py index 4eb22b2e34f..8063493927c 100644 --- a/tests/unit/proxy/common_utils/test_cache_aware_routing.py +++ b/tests/unit/proxy/common_utils/test_cache_aware_routing.py @@ -145,7 +145,7 @@ async def _select( counter_for_model: Callable[[str], TokenCounter], now: float, ) -> CacheAwareChoice | None: - complexity: Final = ComplexityRouter("smart", router, config.model_dump()) + complexity: Final = ComplexityRouter("smart", router._core_ctx, config.model_dump()) return await select_cached_model( router=router, config=config, @@ -233,10 +233,11 @@ async def test_disabled_setting_does_not_access_prediction_services() -> None: assert config.cache_aware_routing is False assert ( await choose_cached_model( - router=_router(), + ctx=_router()._core_ctx, config=config, params_for_model=partial( - ComplexityRouter("smart", _router(), config.model_dump())._litellm_params_for_model, request_kwargs={} + ComplexityRouter("smart", _router()._core_ctx, config.model_dump())._litellm_params_for_model, + request_kwargs={}, ), response=_response(), request_kwargs={}, diff --git a/tests/unit/proxy/guardrails/test_deferred_guardrail_logging.py b/tests/unit/proxy/guardrails/test_deferred_guardrail_logging.py index 60c3e4c22e1..e9e0a585949 100644 --- a/tests/unit/proxy/guardrails/test_deferred_guardrail_logging.py +++ b/tests/unit/proxy/guardrails/test_deferred_guardrail_logging.py @@ -26,19 +26,18 @@ import httpx import pytest import respx - import litellm from litellm.caching.caching import DualCache -from litellm.litellm_core_utils.litellm_logging import Logging -from litellm.litellm_core_utils.llm_cost_calc.finalization import finalize_cost -from litellm.types.utils import StandardLoggingPayload -from litellm.utils import dispatch_success_logging from litellm.integrations.custom_guardrail import CustomGuardrail from litellm.integrations.custom_logger import CustomLogger +from litellm.litellm_core_utils.litellm_logging import Logging +from litellm.litellm_core_utils.llm_cost_calc.finalization import finalize_cost from litellm.proxy._types import UserAPIKeyAuth from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing from litellm.proxy.utils import ProxyLogging from litellm.types.guardrails import GuardrailEventHooks +from litellm.types.utils import StandardLoggingPayload +from litellm.utils import dispatch_success_logging # --------------------------------------------------------------------------- # Helpers @@ -1520,12 +1519,12 @@ class TestArmDeferredStreamDispatch: sniffing the wrapper instead of the inner iterator armed the 1-arg native closure against the CSW's 2-arg stored shape and leaked a TypeError 500 frame into the stream.""" + from litellm.litellm_core_utils.add_retry_fallback_headers import ( + HiddenParamsAsyncIteratorWrapper, + ) from litellm.responses.litellm_completion_transformation.streaming_iterator import ( LiteLLMCompletionStreamingIterator, ) - from litellm.router_utils.add_retry_fallback_headers import ( - HiddenParamsAsyncIteratorWrapper, - ) logging_obj, recorded = self._dispatch_recording_logging_obj() wrapped = HiddenParamsAsyncIteratorWrapper(object.__new__(LiteLLMCompletionStreamingIterator)) diff --git a/tests/unit/proxy/hooks/test_parallel_request_limiter_v3.py b/tests/unit/proxy/hooks/test_parallel_request_limiter_v3.py index 3aad2bda9bf..a50aa577a79 100644 --- a/tests/unit/proxy/hooks/test_parallel_request_limiter_v3.py +++ b/tests/unit/proxy/hooks/test_parallel_request_limiter_v3.py @@ -26,6 +26,7 @@ from litellm.caching.in_memory_cache import InMemoryCache from litellm.constants import INTERNAL_CALL_ORIGIN_METADATA_KEY from litellm.integrations.custom_secret_manager import CustomSecretManager from litellm.litellm_core_utils import ptu_pricing +from litellm.litellm_core_utils.ptu_shares import PTUTeamCeiling from litellm.llms.azure.ptu_capacity import AZURE_PTU_CAPACITY from litellm.proxy._types import UserAPIKeyAuth from litellm.proxy.common_utils.proxy_rate_limit_error import ProxyRateLimitError @@ -49,7 +50,6 @@ from litellm.proxy.hooks.parallel_request_limiter_v3 import ( from litellm.proxy.spend_tracking.input_tokens import models_counted_for from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR from litellm.proxy.utils import InternalUsageCache, ProxyLogging, hash_token -from litellm.router_utils.ptu_shares import PTUTeamCeiling from litellm.types.caching import RedisPipelineIncrementOperation from litellm.types.extraction import ExtractionResponse from litellm.types.llms.openai import ResponsesAPIResponse diff --git a/tests/unit/proxy/hooks/test_tpm_concurrent.py b/tests/unit/proxy/hooks/test_tpm_concurrent.py index 8245c261a12..e43a72541c7 100644 --- a/tests/unit/proxy/hooks/test_tpm_concurrent.py +++ b/tests/unit/proxy/hooks/test_tpm_concurrent.py @@ -29,6 +29,7 @@ from PIL import Image from litellm import token_counter from litellm.caching.caching import DualCache +from litellm.litellm_core_utils.ptu_shares import PTUTeamCeiling from litellm.litellm_core_utils.token_counter import UnsupportedContentTypeError, estimate_image_tokens from litellm.proxy._types import UserAPIKeyAuth from litellm.proxy.hooks.parallel_request_limiter_v3 import ( @@ -46,7 +47,6 @@ from litellm.proxy.hooks.parallel_request_limiter_v3 import ( PROXY_MaxParallelRequestsHandler_v3 as RateLimitHandler, ) from litellm.proxy.utils import InternalUsageCache, hash_token -from litellm.router_utils.ptu_shares import PTUTeamCeiling from litellm.types.llms.openai import ( InputTokensDetails, ResponseAPIUsage, diff --git a/tests/unit/proxy/management_endpoints/search_endpoints/test_search_tool_management.py b/tests/unit/proxy/management_endpoints/search_endpoints/test_search_tool_management.py index ceeac4919f2..65ebece406a 100644 --- a/tests/unit/proxy/management_endpoints/search_endpoints/test_search_tool_management.py +++ b/tests/unit/proxy/management_endpoints/search_endpoints/test_search_tool_management.py @@ -20,6 +20,7 @@ from litellm.proxy._types import ( # Now we can safely import app from litellm.proxy.proxy_server import app +from litellm.router import Router from litellm.types.search import SearchToolInfoResponse from tests.unit.proxy.router_entry_point_stubs import route_entry_points_to_stubs @@ -991,8 +992,7 @@ def _live_router_and_db(db_rows: list): proxy_config = ProxyConfig() proxy_config.update_config_state({}) - fake_router = MagicMock() - fake_router.search_tools = list(db_rows) + router = Router(model_list=[], search_tools=list(db_rows)) with contextlib.ExitStack() as stack: stack.enter_context( @@ -1002,7 +1002,7 @@ def _live_router_and_db(db_rows: list): patch("litellm.proxy.proxy_server.proxy_config", proxy_config) ) # test-quality-ok: proxy globals are the only seam; see the module note above stack.enter_context( - patch("litellm.proxy.proxy_server.llm_router", fake_router) + patch("litellm.proxy.proxy_server.llm_router", router) ) # test-quality-ok: proxy globals are the only seam; see the module note above stack.enter_context( patch( # test-quality-ok: proxy globals are the only seam; see the module note above @@ -1020,7 +1020,7 @@ def _live_router_and_db(db_rows: list): user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin_user" ) try: - yield fake_router + yield router finally: app.dependency_overrides.pop(user_api_key_auth, None) @@ -1028,7 +1028,7 @@ def _live_router_and_db(db_rows: list): @pytest.mark.asyncio async def test_create_search_tool_reaches_the_router_before_the_response(): """A UI-created tool must be usable immediately, not only after the next config reload tick.""" - with _live_router_and_db([]) as fake_router: + with _live_router_and_db([]) as router: response = TestClient(app).post( "/search_tools", json={ @@ -1040,12 +1040,12 @@ async def test_create_search_tool_reaches_the_router_before_the_response(): ) assert response.status_code == 200 - assert [tool["search_tool_name"] for tool in fake_router.search_tools] == ["tavily-search"] + assert [tool["search_tool_name"] for tool in router.settings().search_tools] == ["tavily-search"] @pytest.mark.asyncio async def test_update_search_tool_reaches_the_router_before_the_response(): - with _live_router_and_db([_search_tool_row("tavily-search", provider="tavily")]) as fake_router: + with _live_router_and_db([_search_tool_row("tavily-search", provider="tavily")]) as router: response = TestClient(app).put( "/search_tools/tavily-search-id", json={ @@ -1057,17 +1057,17 @@ async def test_update_search_tool_reaches_the_router_before_the_response(): ) assert response.status_code == 200 - assert fake_router.search_tools[0]["litellm_params"]["search_provider"] == "exa_ai" + assert router.settings().search_tools[0]["litellm_params"]["search_provider"] == "exa_ai" @pytest.mark.asyncio async def test_delete_search_tool_removes_it_from_the_router(): """Deleting the last tool must clear the router; the old empty-list guard left it live.""" - with _live_router_and_db([_search_tool_row("tavily-search")]) as fake_router: + with _live_router_and_db([_search_tool_row("tavily-search")]) as router: response = TestClient(app).delete("/search_tools/tavily-search-id") assert response.status_code == 200 - assert fake_router.search_tools == [] + assert list(router.settings().search_tools) == [] @pytest.mark.asyncio diff --git a/tests/unit/proxy/pass_through_endpoints/test_llm_pass_through_endpoints.py b/tests/unit/proxy/pass_through_endpoints/test_llm_pass_through_endpoints.py index ff27ac54a5b..4a76aa77f14 100644 --- a/tests/unit/proxy/pass_through_endpoints/test_llm_pass_through_endpoints.py +++ b/tests/unit/proxy/pass_through_endpoints/test_llm_pass_through_endpoints.py @@ -7017,7 +7017,7 @@ class TestAzureRouterModelStreamingDispatch: logging_obj = MagicMock() logging_obj.async_flush_passthrough_collected_chunks = AsyncMock() - from litellm.router_utils.add_retry_fallback_headers import prepare_response_for_header_attachment + from litellm.litellm_core_utils.add_retry_fallback_headers import prepare_response_for_header_attachment class StreamingRouter: async def allm_passthrough_route(self, **kwargs): diff --git a/tests/unit/proxy/proxy_server/test_background_health.py b/tests/unit/proxy/proxy_server/test_background_health.py index ebc33b1c788..4c1c3d4ece9 100644 --- a/tests/unit/proxy/proxy_server/test_background_health.py +++ b/tests/unit/proxy/proxy_server/test_background_health.py @@ -432,18 +432,6 @@ def test_write_health_state_to_router_cache_sets_states(monkeypatch): monkeypatch.setattr(hc, "build_deployment_health_states", lambda **_kw: fake_states) - import litellm.router_utils.cooldown_handlers as cd - - monkeypatch.setattr(cd, "set_cooldown_deployments", lambda **_kw: None) - - import litellm.router_utils.router_callbacks.track_deployment_metrics as tdm - - monkeypatch.setattr( - tdm, - "increment_deployment_failures_for_current_minute", - lambda **_kw: None, - ) - healthy = [{"model_id": "m1"}] unhealthy = [{"model_id": "m2"}] exceptions = {"m2": SimpleNamespace(status_code=500)} @@ -451,6 +439,7 @@ def test_write_health_state_to_router_cache_sets_states(monkeypatch): _write_health_state_to_router_cache(healthy, unhealthy, exceptions) health_checks.set_deployment_health_states.assert_called_once_with(fake_states) + fake_router.health.return_value.record_failure.assert_called_once_with("m2", exceptions["m2"], 500) call_args = health_checks.set_deployment_health_states.call_args[0][0] assert normalize( @@ -503,26 +492,6 @@ def test_write_health_state_to_router_cache_populates_for_listing_filter(monkeyp monkeypatch.setattr(hc, "build_deployment_health_states", lambda **_kw: fake_states) - cooldowns: list[str] = [] - - import litellm.router_utils.cooldown_handlers as cd - - monkeypatch.setattr( - cd, - "set_cooldown_deployments", - lambda **kw: cooldowns.append(kw.get("deployment")), - ) - - failures: list[str] = [] - - import litellm.router_utils.router_callbacks.track_deployment_metrics as tdm - - monkeypatch.setattr( - tdm, - "increment_deployment_failures_for_current_minute", - lambda **kw: failures.append(kw.get("deployment_id")), - ) - _write_health_state_to_router_cache( [{"model_id": "m1"}], [{"model_id": "m2"}], @@ -530,8 +499,7 @@ def test_write_health_state_to_router_cache_populates_for_listing_filter(monkeyp ) fake_router.health.return_value.health_checks.set_deployment_health_states.assert_called_once_with(fake_states) - assert cooldowns == [] - assert failures == [] + fake_router.health.return_value.record_failure.assert_not_called() def test_write_health_state_to_router_cache_swallows_internal_failures(monkeypatch): diff --git a/tests/unit/proxy/proxy_server/test_proxy_config.py b/tests/unit/proxy/proxy_server/test_proxy_config.py index 49f9e99cf48..d9ff7fef9f9 100644 --- a/tests/unit/proxy/proxy_server/test_proxy_config.py +++ b/tests/unit/proxy/proxy_server/test_proxy_config.py @@ -2263,7 +2263,6 @@ def test_ProxyConfig_merge_config_and_db_search_tools_prefers_db_duplicate(): @pytest.mark.asyncio async def test_ProxyConfig__init_search_tools_in_db_loads_merged_tools(monkeypatch): from litellm.proxy import proxy_server - from litellm.router_utils.search_api_router import SearchAPIRouter pc = ProxyConfig() pc.update_config_state( @@ -2289,28 +2288,24 @@ async def test_ProxyConfig__init_search_tools_in_db_loads_merged_tools(monkeypat }, } ] - fake_router = MagicMock() + router = litellm.Router() mock_get_db_tools = AsyncMock(return_value=db_tools) - mock_update_router = AsyncMock() - monkeypatch.setattr(proxy_server, "llm_router", fake_router) + monkeypatch.setattr(proxy_server, "llm_router", router) monkeypatch.setattr( "litellm.proxy.search_endpoints.search_tool_registry.SearchToolRegistry.get_all_search_tools_from_db", mock_get_db_tools, ) - monkeypatch.setattr(SearchAPIRouter, "update_router_search_tools", mock_update_router) await pc._init_search_tools_in_db(prisma_client=MagicMock()) mock_get_db_tools.assert_awaited_once() - mock_update_router.assert_awaited_once() - update_kwargs = mock_update_router.await_args.kwargs - assert update_kwargs["router_instance"] is fake_router - assert [tool["search_tool_name"] for tool in update_kwargs["search_tools"]] == [ + loaded_tools = router.settings().search_tools + assert [tool["search_tool_name"] for tool in loaded_tools] == [ "config-only", "shared-search", ] - assert update_kwargs["search_tools"][1]["litellm_params"]["api_key"] == "fake-db-key" + assert loaded_tools[1]["litellm_params"]["api_key"] == "fake-db-key" @pytest.mark.asyncio @@ -2320,11 +2315,10 @@ async def test_ProxyConfig__init_search_tools_in_db_clears_router_when_last_tool pc = ProxyConfig() pc.update_config_state({}) - fake_router = MagicMock() - fake_router.search_tools = [{"search_tool_name": "deleted-search", "litellm_params": {}}] + router = litellm.Router(search_tools=[{"search_tool_name": "deleted-search", "litellm_params": {}}]) mock_get_db_tools = AsyncMock(return_value=[]) - monkeypatch.setattr(proxy_server, "llm_router", fake_router) + monkeypatch.setattr(proxy_server, "llm_router", router) monkeypatch.setattr( "litellm.proxy.search_endpoints.search_tool_registry.SearchToolRegistry.get_all_search_tools_from_db", mock_get_db_tools, @@ -2333,7 +2327,7 @@ async def test_ProxyConfig__init_search_tools_in_db_clears_router_when_last_tool await pc._init_search_tools_in_db(prisma_client=MagicMock()) mock_get_db_tools.assert_awaited_once() - assert fake_router.search_tools == [] + assert router.settings().search_tools == [] @pytest.mark.asyncio @@ -2347,8 +2341,7 @@ async def test_ProxyConfig__init_search_tools_in_db_keeps_loaded_tools_whose_par "search_tool_name": "rotated-search", "litellm_params": {"search_provider": "perplexity", "api_key": "pplx-loaded"}, } - fake_router = MagicMock() - fake_router.settings.return_value = RouterSettings( + router = litellm.Router( search_tools=[ loaded_tool, { @@ -2378,7 +2371,7 @@ async def test_ProxyConfig__init_search_tools_in_db_keeps_loaded_tools_whose_par "litellm_params": {"search_provider": "Tavily", "api_key": "tvly-edited"}, }, ] - monkeypatch.setattr(proxy_server, "llm_router", fake_router) + monkeypatch.setattr(proxy_server, "llm_router", router) monkeypatch.setattr( "litellm.proxy.search_endpoints.search_tool_registry.SearchToolRegistry.get_all_search_tools_from_db", AsyncMock(return_value=db_tools), @@ -2386,7 +2379,7 @@ async def test_ProxyConfig__init_search_tools_in_db_keeps_loaded_tools_whose_par await pc._init_search_tools_in_db(prisma_client=MagicMock()) - assert [tool["litellm_params"] for tool in fake_router.search_tools] == [ + assert [tool["litellm_params"] for tool in router.settings().search_tools] == [ {"search_provider": "perplexity", "api_key": "pplx-loaded"}, {"search_provider": "tavily", "api_key": "tvly-fresh"}, {"search_provider": "Tavily", "api_key": "tvly-edited"}, diff --git a/tests/unit/proxy/router_entry_point_stubs.py b/tests/unit/proxy/router_entry_point_stubs.py index 41acd487b67..6912049d225 100644 --- a/tests/unit/proxy/router_entry_point_stubs.py +++ b/tests/unit/proxy/router_entry_point_stubs.py @@ -75,7 +75,7 @@ def route_entry_points_to_stubs(router: _RouterDouble) -> _RouterDouble: if kind == "deployment_names": return router.deployment_names if kind == "team_public": - return router.team_public_model_names + return router.team_public_model_names if team_id is None else router.team_public_model_names_of(team_id) if kind == "litellm_models": return router.resolved_litellm_models(model_name, **_given(team_id=team_id)) if kind == "route_candidates": @@ -143,6 +143,10 @@ def route_entry_points_to_stubs(router: _RouterDouble) -> _RouterDouble: registry.deployment_dict.side_effect = lambda id: router.get_model_info(id=id) registry.has_deployment.side_effect = lambda id: router.has_model_id(id) registry.discovered_model_info.side_effect = lambda id: router.get_discovered_model_info(id) + registry.routing_group.side_effect = lambda name: router.get_routing_group(name) + registry.client.side_effect = lambda deployment, *, client_type=None: router._get_client( + deployment=deployment, kwargs={}, client_type=client_type + ) def _credentials(id, *, form="params", **team): # Old call sites passed team_id (even None) exactly when the new ones do, so pass it on as given. @@ -159,6 +163,9 @@ def route_entry_points_to_stubs(router: _RouterDouble) -> _RouterDouble: registry.plugins.side_effect = lambda kind: getattr(router, f"{kind}_routers") health.fully_blocked_model_names.side_effect = lambda: router.get_fully_blocked_model_names() health.split_priority.side_effect = lambda model, kwargs: router.split_request_priority(model=model, kwargs=kwargs) + health.priority_header_fields.side_effect = lambda model, kwargs, header: router.priority_header_update( + model=model, kwargs=kwargs, header=header + ) registry.index.side_effect = lambda name: getattr(router, f"{name}_to_deployment_indices") registry.patterns.side_effect = lambda team=False: router.team_pattern_routers if team else router.pattern_router health.is_blocked.side_effect = lambda deployment: router.is_deployment_blocked(deployment) diff --git a/tests/unit/proxy/test_common_request_processing.py b/tests/unit/proxy/test_common_request_processing.py index a7596b51e3e..fe6b894b368 100644 --- a/tests/unit/proxy/test_common_request_processing.py +++ b/tests/unit/proxy/test_common_request_processing.py @@ -87,7 +87,7 @@ from litellm.responses.mcp.parked_stream_dispatch import IN_FLIGHT_ROUND from litellm.router import Router from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper from litellm.utils import ModelResponseListIterator -from litellm.router_utils.add_retry_fallback_headers import prepare_response_for_header_attachment +from litellm.litellm_core_utils.add_retry_fallback_headers import prepare_response_for_header_attachment def test_attach_guardrail_information_copies_recorded_entries_onto_model_response(): 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 2d5fa74c4d0..3647146eb4e 100644 --- a/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py +++ b/tests/unit/proxy/test_proxy_server_endpoints_and_startup.py @@ -15398,12 +15398,12 @@ async def test_load_config_router_budget_checks_fallback_targets_against_the_cal # on by default: an over-budget caller is refused the paid fallback with no config at all monkeypatch.setattr(proxy_server, "general_settings", {}, raising=False) - assert await router.fallback_budget_check(model="m", request_kwargs=over_budget, llm_router=router) is False - assert await router.fallback_budget_check(model="m", request_kwargs=under_budget, llm_router=router) is True + assert await router.fallback_budget_check(model="m", request_kwargs=over_budget, ctx=router._core_ctx) is False + assert await router.fallback_budget_check(model="m", request_kwargs=under_budget, ctx=router._core_ctx) is True # explicit opt-out restores the unguarded behaviour monkeypatch.setattr(proxy_server, "general_settings", {"enforce_fallback_budget": False}, raising=False) - assert await router.fallback_budget_check(model="m", request_kwargs=over_budget, llm_router=router) is True + assert await router.fallback_budget_check(model="m", request_kwargs=over_budget, ctx=router._core_ctx) is True @pytest.mark.asyncio diff --git a/tests/unit/responses/test_responses_router_cooldown.py b/tests/unit/responses/test_responses_router_cooldown.py index e4bad083c87..078890c2395 100644 --- a/tests/unit/responses/test_responses_router_cooldown.py +++ b/tests/unit/responses/test_responses_router_cooldown.py @@ -77,7 +77,7 @@ async def test_responses_api_rate_limit_marks_deployment_for_cooldown(): ) cooldown_ids = await async_get_cooldown_deployments( - litellm_router_instance=router, parent_otel_span=None + ctx=router._core_ctx, parent_otel_span=None ) assert failing_deployment_id in cooldown_ids, ( f"Responses API failure callback did not register cooldown for " diff --git a/tests/unit/router_strategy/complexity_router/test_context_compaction.py b/tests/unit/router_strategy/complexity_router/test_context_compaction.py index c6242f775c8..850accf574b 100644 --- a/tests/unit/router_strategy/complexity_router/test_context_compaction.py +++ b/tests/unit/router_strategy/complexity_router/test_context_compaction.py @@ -11,6 +11,7 @@ import respx import litellm from litellm.llms import compaction as native +from litellm.router_api import RoutingContext from litellm.router_strategy.complexity_router.config import ContextCompactionConfig from litellm.router_strategy.complexity_router.context_compaction import ( CompactionState, @@ -184,7 +185,7 @@ async def test_all_surfaces_compact_and_keep_selected_answerer( protocol: native.CompactionProtocol, request: Mapping[str, object], parent_model: str | None = None ) -> Mapping[str, object]: assert parent_model == "auto" - result: Final = await native.dispatch(router, protocol, request) + result: Final = await native.dispatch(RoutingContext(router), protocol, request) captured.put_nowait(result) return result @@ -385,9 +386,9 @@ async def test_client_owned_history_bypasses_compaction( counted: Final = router._count_pre_call_check_tokens(None, request["input"], request) if arm_first and counted > 512: with pytest.raises(litellm.ContextWindowExceededError): - await compact_to_fit(router, deployment.model_dump(), request, "responses") + await compact_to_fit(RoutingContext(router), deployment.model_dump(), request, "responses") else: - result: Final = await compact_to_fit(router, deployment.model_dump(), request, "responses") + result: Final = await compact_to_fit(RoutingContext(router), deployment.model_dump(), request, "responses") assert result is request assert {key: value for key, value in request.items() if key != "_context_compaction_state"} == original assert all(route.call_count == 0 for route in wire) @@ -454,15 +455,16 @@ async def test_unusable_output_budget_still_enforces_known_input_window( request: Final = {**payload, "model": "small", "max_tokens": output, "_context_compaction_state": state} if overflow: with pytest.raises(litellm.BadRequestError, match="known input window"): - await compact_to_fit(router, deployment.model_dump(), request, "chat") + await compact_to_fit(RoutingContext(router), deployment.model_dump(), request, "chat") else: - assert await compact_to_fit(router, deployment.model_dump(), request, "chat") is request + assert await compact_to_fit(RoutingContext(router), deployment.model_dump(), request, "chat") is request assert all(route.call_count == 0 for route in wire) @pytest.mark.parametrize("outcome", ["success", "timeout", "cancel"]) async def test_retry_reuses_summary_or_terminal_cancellation(outcome: Literal["success", "timeout", "cancel"]) -> None: router: Final = make_router() + ctx: Final = RoutingContext(router) deployment: Final = router.get_deployment(model_id="pinned-answer") assert deployment is not None state: Final = CompactionState(config=ContextCompactionConfig(model="large", max_tokens=512, timeout_seconds=0.02)) @@ -483,21 +485,21 @@ async def test_retry_reuses_summary_or_terminal_cancellation(outcome: Literal["s token: Final = compaction_executor.set(execute) try: - first: Final = asyncio.create_task(compact_to_fit(router, deployment.model_dump(), request, "messages")) + first: Final = asyncio.create_task(compact_to_fit(ctx, deployment.model_dump(), request, "messages")) await asyncio.wait_for(started.wait(), timeout=2) if outcome == "cancel": first.cancel() if outcome == "success": - assert await first == await compact_to_fit(router, deployment.model_dump(), request, "messages") + assert await first == await compact_to_fit(ctx, deployment.model_dump(), request, "messages") changed: Final = {**request, "messages": [{"role": "user", "content": "new history"}, *request["messages"]]} with pytest.raises(litellm.BadRequestError, match="History changed"): - await compact_to_fit(router, deployment.model_dump(), changed, "messages") + await compact_to_fit(ctx, deployment.model_dump(), changed, "messages") else: error: Final = asyncio.CancelledError if outcome == "cancel" else asyncio.TimeoutError with pytest.raises(error): await first with pytest.raises(error): - await compact_to_fit(router, deployment.model_dump(), request, "messages") + await compact_to_fit(ctx, deployment.model_dump(), request, "messages") assert calls.qsize() == 1 and stopped.is_set() finally: compaction_executor.reset(token) diff --git a/tests/unit/router_strategy/complexity_router/test_jev_classifier.py b/tests/unit/router_strategy/complexity_router/test_jev_classifier.py index a71f572254e..abbb1ed80d0 100644 --- a/tests/unit/router_strategy/complexity_router/test_jev_classifier.py +++ b/tests/unit/router_strategy/complexity_router/test_jev_classifier.py @@ -18,6 +18,7 @@ from litellm.integrations.custom_logger import CustomLogger from litellm.litellm_core_utils.logging_worker import GLOBAL_LOGGING_WORKER from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler from litellm.llms.typesafe.decisions.transformation import TypeSafeDecisionsConfig +from litellm.router_api import RoutingContext from litellm.router_strategy.complexity_router.complexity_router import ComplexityRouter, _ClassifierCircuitBreaker from litellm.router_strategy.complexity_router.config import ComplexityRouterConfig, JevClassifierConfig from litellm.router_strategy.complexity_router.jev_classifier import ( @@ -85,7 +86,7 @@ async def test_jev_logging_failure_preserves_verdict_and_keeps_circuit_closed( handler.client = httpx.AsyncClient(transport=httpx.MockTransport(respond)) router: Final = ComplexityRouter( "jev-logging-failure", - litellm.Router(model_list=[]), + RoutingContext(litellm.Router(model_list=[])), {"classifier_type": "jev", "jev_classifier_config": {}, "tiers": {"SIMPLE": "cheap"}}, jev_client=HttpJevClassifierClient("test", "https://typesafe.test", handler), derive_savings_baseline=False, @@ -201,7 +202,7 @@ async def test_jev_accounts_once_with_parent_identity_even_when_the_verdict_fail provider: Final = HttpJevClassifierClient("test", "https://typesafe.test", handler) router: Final = ComplexityRouter( "jev-router", - litellm.Router(model_list=[]), + RoutingContext(litellm.Router(model_list=[])), { "classifier_type": "jev" if legacy else "oss_classifier", "jev_classifier_config" if legacy else "opensource_classifier_config": { @@ -283,7 +284,7 @@ async def test_jev_uses_bounded_history_and_separates_operator_instructions(incl handler.client = httpx.AsyncClient(transport=httpx.MockTransport(respond)) router: Final = ComplexityRouter( "jev-context", - litellm.Router(model_list=[]), + RoutingContext(litellm.Router(model_list=[])), { "classifier_type": "jev", "jev_classifier_config": {"instructions": "operator-only rubric"}, @@ -347,7 +348,7 @@ async def test_jev_encrypted_task_skips_provider_without_disabling_plaintext_cla handler.client = httpx.AsyncClient(transport=transport) router: Final = ComplexityRouter( "jev-encrypted", - litellm.Router(model_list=[]), + RoutingContext(litellm.Router(model_list=[])), { "classifier_type": "jev", "jev_classifier_config": {}, @@ -415,7 +416,7 @@ async def test_jev_cancellation_propagates_without_opening_timeout_breaker() -> handler.client = httpx.AsyncClient(transport=httpx.MockTransport(respond)) router: Final = ComplexityRouter( "jev-cancellation", - litellm.Router(model_list=[]), + RoutingContext(litellm.Router(model_list=[])), {"classifier_type": "jev", "jev_classifier_config": {}, "tiers": {"SIMPLE": "cheap"}}, jev_client=HttpJevClassifierClient("test", "https://typesafe.test", handler), derive_savings_baseline=False, @@ -524,7 +525,7 @@ async def test_oss_routes_with_its_own_credentials_and_accounts_the_checkpoint( monkeypatch.setattr(litellm, "_async_success_callback", [recorder]) router: Final = ComplexityRouter( f"{provider}-route", - litellm.Router(model_list=[]), + RoutingContext(litellm.Router(model_list=[])), { "classifier_type": "jev" if legacy else "oss_classifier", "jev_classifier_config" if legacy else "opensource_classifier_config": { @@ -591,7 +592,7 @@ async def test_databricks_routes_through_the_serving_endpoint_and_accounts_the_e monkeypatch.setattr(litellm, "_async_success_callback", [recorder]) router: Final = ComplexityRouter( "databricks-route", - litellm.Router(model_list=[]), + RoutingContext(litellm.Router(model_list=[])), { "classifier_type": "jev" if legacy else "oss_classifier", "jev_classifier_config" if legacy else "opensource_classifier_config": { @@ -648,7 +649,7 @@ async def test_databricks_routes_through_ai_decide_without_a_model_field_and_acc monkeypatch.setattr(litellm, "_async_success_callback", [recorder]) router: Final = ComplexityRouter( "databricks-route", - litellm.Router(model_list=[]), + RoutingContext(litellm.Router(model_list=[])), { "classifier_type": "jev" if legacy else "oss_classifier", "jev_classifier_config" if legacy else "opensource_classifier_config": { @@ -688,7 +689,7 @@ def test_databricks_without_a_base_or_key_fails_at_client_build(monkeypatch: pyt with pytest.raises(ValueError, match="DATABRICKS_API_BASE"): ComplexityRouter( "databricks-route", - litellm.Router(model_list=[]), + RoutingContext(litellm.Router(model_list=[])), { "classifier_type": "oss_classifier", "opensource_classifier_config": {"provider": "databricks", "model": "ai_decide"}, @@ -773,7 +774,9 @@ async def test_jev_connection_resolves_only_explicit_environment_references( expected_key: Final = ( "default-key" if connection == "defaults" - else "resolved-key" if connection in ("key-reference", "references") else "literal-key" + else "resolved-key" + if connection in ("key-reference", "references") + else "literal-key" ) assert outcome.cause == "jev_classifier" assert route.calls[0].request.headers["authorization"] == f"Bearer {expected_key}" @@ -1083,7 +1086,8 @@ async def test_jev_bounds_complete_input_without_changing_forwarded_messages( handler: Final = AsyncHTTPHandler() handler.client = httpx.AsyncClient() classifier: Final = ComplexityRouter( - "bounded-classifier", litellm.Router(model_list=[]), + "bounded-classifier", + litellm.Router(model_list=[]), { "classifier_type": "oss_classifier", "opensource_classifier_config": {"instructions": rubric}, @@ -1142,8 +1146,12 @@ async def test_jev_bounds_complete_input_without_changing_forwarded_messages( ], ) async def test_jev_budget_uses_effective_headers_and_every_deployment( - mode: str, default_header: str | None, explicit_cap: int | None, - other_member: str | None, expected_status: str, monkeypatch: pytest.MonkeyPatch + mode: str, + default_header: str | None, + explicit_cap: int | None, + other_member: str | None, + expected_status: str, + monkeypatch: pytest.MonkeyPatch, ) -> None: monkeypatch.setattr(litellm, "disable_aiohttp_transport", True) monkeypatch.setitem(litellm.model_cost, "typesafe/jev-latest", deepcopy(litellm.model_cost["typesafe/jev-latest"])) @@ -1151,7 +1159,9 @@ async def test_jev_budget_uses_effective_headers_and_every_deployment( deployment: Final = { "model_name": "budget-model", "litellm_params": { - "model": "typesafe/jev-latest", "api_key": "test", "api_base": "https://budget.test", + "model": "typesafe/jev-latest", + "api_key": "test", + "api_base": "https://budget.test", "extra_headers": {header: mode}, }, "model_info": {"max_input_tokens": explicit_cap} if explicit_cap is not None else {}, @@ -1160,7 +1170,8 @@ async def test_jev_budget_uses_effective_headers_and_every_deployment( "model_name": "budget-model", "litellm_params": { "model": "databricks/unknown-budget-endpoint" if other_member == "unknown" else "typesafe/jev-latest", - "api_key": "test", "api_base": "https://budget.test", + "api_key": "test", + "api_base": "https://budget.test", }, } router: Final = litellm.Router( @@ -1169,16 +1180,18 @@ async def test_jev_budget_uses_effective_headers_and_every_deployment( num_retries=0, ) classifier: Final = ComplexityRouter( - "bounded-classifier", router, - {"classifier_type": "oss_classifier", "opensource_classifier_config": {"deployment_name": "budget-model"}, - "tiers": {"SIMPLE": "cheap"}}, + "bounded-classifier", + router, + { + "classifier_type": "oss_classifier", + "opensource_classifier_config": {"deployment_name": "budget-model"}, + "tiers": {"SIMPLE": "cheap"}, + }, derive_savings_baseline=False, ) ask: Final = "Explain this code " + "word001 word002 word003 " * 12000 with respx.mock(assert_all_called=True) as upstream: - route: Final = upstream.route(method="POST").respond( - json={"answers": {"tier": _answer().model_dump()}} - ) + route: Final = upstream.route(method="POST").respond(json={"answers": {"tier": _answer().model_dump()}}) outcome: Final = await classifier.aclassify(ask) assert outcome.cause == "jev_classifier" telemetry: Final = outcome.classifier_input_telemetry @@ -1202,29 +1215,55 @@ async def test_jev_untrimmable_rubric_uses_configured_fallback_without_a_provide ) -> None: monkeypatch.setattr(litellm, "disable_aiohttp_transport", True) monkeypatch.setitem(litellm.model_cost, "typesafe/jev-latest", deepcopy(litellm.model_cost["typesafe/jev-latest"])) - router: Final = litellm.Router(model_list=[{ - "model_name": "budget-model", - "litellm_params": {"model": "typesafe/jev-latest", "api_key": "test", "api_base": "https://budget.test"}, - "model_info": {"max_input_tokens": 128 if oversized_field == "criteria" else 1024}, - }]) + router: Final = litellm.Router( + model_list=[ + { + "model_name": "budget-model", + "litellm_params": { + "model": "typesafe/jev-latest", + "api_key": "test", + "api_base": "https://budget.test", + }, + "model_info": {"max_input_tokens": 128 if oversized_field == "criteria" else 1024}, + } + ] + ) rubric: Final = "word001 word002 word003 " * 2000 classifier: Final = ComplexityRouter( - "bounded-classifier", router, - {"classifier_type": "oss_classifier", "opensource_classifier_config": { - "deployment_name": "budget-model", "instructions": rubric if oversized_field == "instructions" else "Choose", - }, "tiers": {"SIMPLE": "cheap", "REASONING": "deep"}, - **({"tier_definitions": [{"name": name, "description": "word001 " * 50} - for name in ("SIMPLE", "REASONING")], "fallback_tier": "SIMPLE"} - if fallback == "custom" else {"classifier_fallback": fallback, "default_model": "default"})}, + "bounded-classifier", + router, + { + "classifier_type": "oss_classifier", + "opensource_classifier_config": { + "deployment_name": "budget-model", + "instructions": rubric if oversized_field == "instructions" else "Choose", + }, + "tiers": {"SIMPLE": "cheap", "REASONING": "deep"}, + **( + { + "tier_definitions": [ + {"name": name, "description": "word001 " * 50} for name in ("SIMPLE", "REASONING") + ], + "fallback_tier": "SIMPLE", + } + if fallback == "custom" + else {"classifier_fallback": fallback, "default_model": "default"} + ), + }, derive_savings_baseline=False, ) with respx.mock(assert_all_called=False) as upstream: route: Final = upstream.route(method="POST").respond(json={"answers": {"tier": _answer().model_dump()}}) outcome: Final = await classifier.aclassify("What is two plus two?") assert route.call_count == 0 - assert outcome.cause == { - "heuristic": "heuristic_scorer", "default_model": "default_model_fallback", "custom": "classifier_fallback", - }[fallback] + assert ( + outcome.cause + == { + "heuristic": "heuristic_scorer", + "default_model": "default_model_fallback", + "custom": "classifier_fallback", + }[fallback] + ) assert outcome.classifier_failure_reason == "unsupported_input" assert outcome.classifier_input_telemetry is not None assert outcome.classifier_input_telemetry["classifier_input_budget_status"] == "untrimmable_input" @@ -1241,10 +1280,17 @@ async def test_jev_open_breaker_preserves_input_budget_in_fallback_decision(fall handler: Final = AsyncHTTPHandler() handler.client = httpx.AsyncClient(transport=transport) classifier: Final = ComplexityRouter( - "breaker-budget", litellm.Router(model_list=[]), - {"classifier_type": "oss_classifier", "opensource_classifier_config": {}, - "tiers": {"SIMPLE": "cheap", "REASONING": "deep"}, "classifier_fallback": fallback, - "default_model": "default", "session_affinity": False, "deployment_affinity": False}, + "breaker-budget", + litellm.Router(model_list=[]), + { + "classifier_type": "oss_classifier", + "opensource_classifier_config": {}, + "tiers": {"SIMPLE": "cheap", "REASONING": "deep"}, + "classifier_fallback": fallback, + "default_model": "default", + "session_affinity": False, + "deployment_affinity": False, + }, jev_client=HttpJevClassifierClient("test", "https://budget.test", handler), derive_savings_baseline=False, ) @@ -1254,7 +1300,8 @@ async def test_jev_open_breaker_preserves_input_budget_in_fallback_decision(fall model="breaker-budget", request_kwargs={}, messages=[{"role": "user", "content": "Explain budgets"}] ) second: Final = await classifier.async_pre_routing_hook( - model="breaker-budget", request_kwargs={}, + model="breaker-budget", + request_kwargs={}, messages=[{"role": "user", "content": "Explain this code " + "word001 word002 word003 " * 12000}], ) assert first is not None and first.routing_decision is not None diff --git a/tests/unit/router_strategy/test_auto_router.py b/tests/unit/router_strategy/test_auto_router.py index de775b9246f..5d88ebc5aea 100644 --- a/tests/unit/router_strategy/test_auto_router.py +++ b/tests/unit/router_strategy/test_auto_router.py @@ -7,6 +7,7 @@ import pytest from litellm.exceptions import Timeout as LiteLLMTimeout +from litellm.router_api import RoutingContext from litellm.router_strategy.auto_router.auto_router import AutoRouter pytestmark_skip_beta = pytest.mark.skip( @@ -200,7 +201,7 @@ class TestAutoRouter: auto_router_config_path=router_config_path, default_model=default_model, embedding_model=embedding_model, - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), ) # Assert @@ -208,7 +209,7 @@ class TestAutoRouter: assert auto_router.auto_sync_value == AutoRouter.DEFAULT_AUTO_SYNC_VALUE assert auto_router.default_model == default_model assert auto_router.embedding_model == embedding_model - assert auto_router.litellm_router_instance == mock_router_instance + assert auto_router.ctx.belongs_to(mock_router_instance) assert auto_router.routelayer is None mock_semantic_router_class.from_json.assert_called_once_with(router_config_path) @@ -237,7 +238,7 @@ class TestAutoRouter: auto_router_config_path="test/path/router.json", default_model="gpt-4o-mini", embedding_model="text-embedding-model", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), ) messages = [{"role": "user", "content": "test message"}] @@ -278,7 +279,7 @@ class TestAutoRouter: auto_router_config_path="test/path/router.json", default_model="gpt-4o-mini", embedding_model="text-embedding-model", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), ) messages = [{"role": "user", "content": "test message"}] @@ -303,7 +304,7 @@ class TestAutoRouter: auto_router_config_path="test/path/router.json", default_model="gpt-4o-mini", embedding_model="text-embedding-model", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), ) # Act @@ -385,13 +386,13 @@ class FailingEmbeddingRouter(StubEmbeddingRouter): raise self.error -def _auto_router(routelayer: Any, litellm_router_instance: Any = None, **kwargs: Any) -> AutoRouter: +def _auto_router(routelayer: Any, router: Any = None, **kwargs: Any) -> AutoRouter: auto_router: Final = AutoRouter( model_name="my-auto-router", auto_router_config=ROUTER_CONFIG, default_model="fallback-model", embedding_model="text-embedding-3-small", - litellm_router_instance=litellm_router_instance or StubEmbeddingRouter(), + ctx=RoutingContext(router or StubEmbeddingRouter()), **kwargs, ) auto_router.routelayer = routelayer @@ -405,7 +406,7 @@ def test_should_load_no_routes_from_an_empty_non_list_routes_value(routes: objec auto_router_config=json.dumps({"routes": routes}), default_model="fallback-model", embedding_model="text-embedding-3-small", - litellm_router_instance=StubEmbeddingRouter(), + ctx=RoutingContext(StubEmbeddingRouter()), ) assert auto_router.loaded_routes == [] @@ -417,7 +418,7 @@ class TestAutoRouterAlwaysResolvesARoutableModel: @pytest.mark.asyncio @pytest.mark.parametrize("request_model", ["my-auto-router", "public-router-alias"]) async def test_should_fall_back_to_default_model_when_the_embedding_call_fails(self, request_model: str) -> None: - auto_router: Final = _auto_router(FixedRouteLayer(None), litellm_router_instance=FailingEmbeddingRouter()) + auto_router: Final = _auto_router(FixedRouteLayer(None), router=FailingEmbeddingRouter()) result: Final = await auto_router.async_pre_routing_hook( model=request_model, @@ -495,7 +496,7 @@ class TestAutoRouterAlwaysResolvesARoutableModel: from semantic_router.schema import RouteChoice router: Final = StubEmbeddingRouter() - auto_router: Final = _auto_router(FixedRouteLayer(RouteChoice(name="code-model")), litellm_router_instance=router) + auto_router: Final = _auto_router(FixedRouteLayer(RouteChoice(name="code-model")), router=router) result: Final = await auto_router.async_pre_routing_hook( model=request_model, @@ -524,7 +525,7 @@ class TestAutoRouterAlwaysResolvesARoutableModel: async def test_should_record_timeout_without_exception_message(self, error: Exception, wrapped: bool) -> None: auto_router: Final = _auto_router( FixedRouteLayer(None if wrapped else error), - litellm_router_instance=FailingEmbeddingRouter(error) if wrapped else StubEmbeddingRouter(), + router=FailingEmbeddingRouter(error) if wrapped else StubEmbeddingRouter(), ) result: Final = await auto_router.async_pre_routing_hook( model="my-auto-router", request_kwargs={}, messages=[{"role": "user", "content": "route this"}] @@ -555,7 +556,7 @@ class TestAutoRouterEmbeddingInputCap: @pytest.mark.asyncio async def test_should_build_its_encoder_with_the_configured_cap(self): - auto_router: Final = _auto_router(None, litellm_router_instance=StubEmbeddingRouter(), max_input_chars=777) + auto_router: Final = _auto_router(None, router=StubEmbeddingRouter(), max_input_chars=777) await auto_router.async_pre_routing_hook( model="my-auto-router", @@ -575,7 +576,7 @@ class TestAutoRouterRoutesResponsesApiInput: from semantic_router.schema import RouteChoice router: Final = StubEmbeddingRouter() - auto_router: Final = _auto_router(FixedRouteLayer(RouteChoice(name="code-model")), litellm_router_instance=router) + auto_router: Final = _auto_router(FixedRouteLayer(RouteChoice(name="code-model")), router=router) result: Final = await auto_router.async_pre_routing_hook( model="my-auto-router", @@ -596,7 +597,7 @@ class TestAutoRouterRoutesResponsesApiInput: from semantic_router.schema import RouteChoice router: Final = StubEmbeddingRouter() - auto_router: Final = _auto_router(FixedRouteLayer(RouteChoice(name="code-model")), litellm_router_instance=router) + auto_router: Final = _auto_router(FixedRouteLayer(RouteChoice(name="code-model")), router=router) result: Final = await auto_router.async_pre_routing_hook( model="my-auto-router", @@ -622,7 +623,7 @@ class TestAutoRouterRoutesResponsesApiInput: @pytest.mark.asyncio async def test_should_skip_routing_when_neither_messages_nor_input_is_present(self): router: Final = StubEmbeddingRouter() - auto_router: Final = _auto_router(FixedRouteLayer(None), litellm_router_instance=router) + auto_router: Final = _auto_router(FixedRouteLayer(None), router=router) result: Final = await auto_router.async_pre_routing_hook( model="my-auto-router", @@ -636,7 +637,7 @@ class TestAutoRouterRoutesResponsesApiInput: @pytest.mark.asyncio async def test_should_keep_routing_an_empty_messages_list_to_the_default_model(self): router: Final = StubEmbeddingRouter() - auto_router: Final = _auto_router(FixedRouteLayer(None), litellm_router_instance=router) + auto_router: Final = _auto_router(FixedRouteLayer(None), router=router) result: Final = await auto_router.async_pre_routing_hook( model="my-auto-router", @@ -657,7 +658,7 @@ class TestAutoRouterAttributesItsEmbeddingSpend: from litellm.constants import INTERNAL_CALL_ORIGIN_METADATA_KEY router: Final = StubEmbeddingRouter() - auto_router: Final = _auto_router(None, litellm_router_instance=router) + auto_router: Final = _auto_router(None, router=router) request_kwargs: Final = { "metadata": { "user_api_key": "hashed-key", @@ -710,7 +711,7 @@ class TestAutoRouterColdStartDoesNotBlockTheEventLoop: import threading embedding_router: Final = ThreadTrackingEmbeddingRouter() - auto_router: Final = _auto_router(None, litellm_router_instance=embedding_router) + auto_router: Final = _auto_router(None, router=embedding_router) event_loop_thread: Final = threading.get_ident() result: Final = await auto_router.async_pre_routing_hook( @@ -727,7 +728,7 @@ class TestAutoRouterColdStartDoesNotBlockTheEventLoop: @pytest.mark.asyncio async def test_should_build_the_routelayer_exactly_once_under_concurrent_cold_start_requests(self): embedding_router: Final = ThreadTrackingEmbeddingRouter() - auto_router: Final = _auto_router(None, litellm_router_instance=embedding_router) + auto_router: Final = _auto_router(None, router=embedding_router) results: Final = await asyncio.gather( *( @@ -760,7 +761,7 @@ class TestAutoRouterColdStartDoesNotBlockTheEventLoop: return super().embedding(input, model, **kwargs) embedding_router: Final = BlockingEmbeddingRouter() - auto_router: Final = _auto_router(None, litellm_router_instance=embedding_router) + auto_router: Final = _auto_router(None, router=embedding_router) first_call: Final = asyncio.ensure_future( auto_router.async_pre_routing_hook( @@ -812,7 +813,7 @@ class TestAutoRouterColdStartDoesNotBlockTheEventLoop: return super().embedding(input, model, **kwargs) embedding_router: Final = FailsOnFirstAttemptEmbeddingRouter() - auto_router: Final = _auto_router(None, litellm_router_instance=embedding_router) + auto_router: Final = _auto_router(None, router=embedding_router) first_call: Final = asyncio.ensure_future( auto_router.async_pre_routing_hook( diff --git a/tests/unit/router_strategy/test_complexity_router.py b/tests/unit/router_strategy/test_complexity_router.py index ab168b2a950..ef7b9e485d4 100644 --- a/tests/unit/router_strategy/test_complexity_router.py +++ b/tests/unit/router_strategy/test_complexity_router.py @@ -15,7 +15,7 @@ from copy import deepcopy from functools import partial from types import MappingProxyType from typing import Dict, Final, List, Literal -from unittest.mock import AsyncMock, MagicMock, patch +from unittest.mock import DEFAULT, AsyncMock, MagicMock, patch import httpx import pytest @@ -37,6 +37,7 @@ from litellm.constants import ( from litellm.integrations.custom_logger import CustomLogger from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler from litellm.router import as_output_cap, stamped_client_ceiling +from litellm.router_api import RoutingContext from litellm.router_strategy.auto_router.auto_router_model_naming import ( CUSTOMIZATION_CAPABILITY, GATED_AUTO_ROUTER_CAPABILITIES, @@ -113,11 +114,16 @@ def _heuristic_v2_artifact() -> TrainedTierArtifact: ) -def _answer_deployments_named(router: MagicMock) -> None: - """Make a mock router answer `deployments_named` from its own `model_list`, the way Router answers from its index.""" - router.deployments_named.side_effect = lambda name: ( - tuple(deployment for deployment in router.model_list if deployment["model_name"] == name) or None - ) +def _answer_deployments_named(router: MagicMock, model_list: Sequence[Mapping[str, object]]) -> None: + """Make a mock router's registry answer `deployments(name, source="named")` from `model_list`, + the way Router answers from its index.""" + + def deployments(model_name: str | None = None, *, source: str = "group", **_: object) -> object: + if source != "named": + return DEFAULT + return tuple(deployment for deployment in model_list if deployment["model_name"] == model_name) or None + + router.registry.return_value.deployments.side_effect = deployments @pytest.fixture @@ -150,7 +156,7 @@ def complexity_router(mock_router_instance, basic_config): """Create a ComplexityRouter instance with basic config.""" return ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) @@ -208,7 +214,7 @@ class TestComplexityRouterInit: """Test initialization with configuration.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) assert router.model_name == "test-router" @@ -230,7 +236,7 @@ class TestComplexityRouterInit: ask = "Derive the amortized complexity of a splay tree access" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **basic_config, "reminder_markers": [ @@ -255,7 +261,7 @@ class TestComplexityRouterInit: """A config that never mentions reminder_markers keeps stripping .""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) @@ -272,7 +278,7 @@ class TestComplexityRouterInit: """Test initialization without configuration uses defaults.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), ) assert router.model_name == "test-router" # Should have equivalent default values but NOT be the same instance @@ -283,7 +289,7 @@ class TestComplexityRouterInit: """Test initialization with default_model override.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, default_model="fallback-model", ) @@ -297,7 +303,7 @@ class TestComplexityRouterInit: config = {**basic_config, "return_raw_model_name": return_raw_model_name} router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) request_kwargs = {} @@ -330,7 +336,7 @@ class TestComplexityRouterInit: ) router = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), { "classifier_type": "jev", "jev_classifier_config": {"api_key": "test", "timeout_ms": 100}, @@ -378,7 +384,7 @@ class TestComplexityRouterInit: ) router = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), { "classifier_type": "jev", "jev_classifier_config": {"api_key": "test", "timeout_ms": 100}, @@ -417,7 +423,7 @@ class TestComplexityRouterInit: ) router = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), { "classifier_type": "jev", "jev_classifier_config": {"api_key": "test"}, @@ -456,7 +462,7 @@ class TestComplexityRouterInit: ) router = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), { "classifier_type": "jev", "jev_classifier_config": {"api_key": "test"}, @@ -477,7 +483,7 @@ class TestComplexityRouterInit: client = _TimeoutJevClient() router = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), { "classifier_type": "jev", "jev_classifier_config": {"api_key": "test", "timeout_ms": 1}, @@ -518,7 +524,7 @@ class TestComplexityRouterInit: client = _StaticJevClient(response) router = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), { "classifier_type": "jev", "jev_classifier_config": {"api_key": "test"}, @@ -616,7 +622,7 @@ class TestReasoningMarkerScoring: """0 is a real floor, not an absent one, so the markers alone promote again.""" router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "reasoning_override_min_score": 0.0}, ) tier, score, _ = router.classify("hi, step by step, pros and cons") @@ -630,12 +636,12 @@ class TestReasoningMarkerScoring: ) low = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "tier_boundaries": {"simple_medium": 0.20}}, ) high = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "tier_boundaries": {"simple_medium": 0.30}}, ) assert low._effective_reasoning_override_min_score() == 0.20 @@ -650,7 +656,7 @@ class TestReasoningMarkerScoring: ) router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **basic_config, "tier_boundaries": {"simple_medium": 0.10}, @@ -669,7 +675,7 @@ class TestReasoningMarkerScoring: ) router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "reasoning_override_min_score": 0.25}, ) tier, score, _ = router.classify(prompt) @@ -795,7 +801,7 @@ class TestModelSelection: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) model = router.get_model_for_tier(ComplexityTier.SIMPLE) @@ -804,7 +810,7 @@ class TestModelSelection: def test_get_model_for_tier_list_random_choice(self, mock_router_instance): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": ["cheap", "premium"], "MEDIUM": "mid"}, "default_model": "mid", @@ -822,7 +828,7 @@ class TestModelSelection: def test_get_model_for_tier_empty_pool_raises(self, mock_router_instance): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": []}, "default_model": "mid", @@ -950,7 +956,7 @@ class TestConfigOverrides: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) # With very low thresholds, even neutral prompts should be COMPLEX or higher @@ -974,7 +980,7 @@ class TestConfigOverrides: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) # A longer prompt (~150 tokens) should be considered "long" with these thresholds @@ -991,7 +997,7 @@ class TestCustomTechnicalKeywords: """Custom keywords should be appended to the default technical keywords.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={"custom_technical_keywords": ["udp", "kafka"]}, ) assert router.technical_keywords == DEFAULT_TECHNICAL_KEYWORDS + ["udp", "kafka"] @@ -1000,7 +1006,7 @@ class TestCustomTechnicalKeywords: """Custom keywords should be appended to a technical_keywords override.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "technical_keywords": ["quantum", "photonics"], "custom_technical_keywords": ["udp"], @@ -1012,7 +1018,7 @@ class TestCustomTechnicalKeywords: """Duplicates against the base list and within the custom list should be dropped.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={"custom_technical_keywords": ["TCP", "udp", "UDP", "kafka"]}, ) lowered = [kw.lower() for kw in router.technical_keywords] @@ -1025,12 +1031,12 @@ class TestCustomTechnicalKeywords: """Absent or None custom_technical_keywords should leave the keyword list identical.""" router_absent = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={"tiers": {"MEDIUM": "gpt-4o"}}, ) router_none = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={"custom_technical_keywords": None}, ) assert router_absent.technical_keywords == DEFAULT_TECHNICAL_KEYWORDS @@ -1041,12 +1047,12 @@ class TestCustomTechnicalKeywords: prompt = "Configure udp multicast between kafka brokers" baseline_router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) custom_router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **basic_config, "custom_technical_keywords": ["UDP", "Kafka"], @@ -1083,10 +1089,10 @@ class TestCustomDimensions: def test_custom_dimension_changes_only_matching_requests( self, mock_router_instance: MagicMock, matchers: dict[str, object], prompt: str ) -> None: - baseline: Final = ComplexityRouter("test-router", mock_router_instance) + baseline: Final = ComplexityRouter("test-router", RoutingContext(mock_router_instance)) configured: Final = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), {"custom_dimensions": [{"name": "internalFrameworks", "weight": 0.7, **matchers}]}, ) baseline_tier, baseline_score, baseline_signals = baseline.classify(prompt) @@ -1193,7 +1199,7 @@ class TestCustomDimensions: ) -> None: router: Final = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), { "tiers": {"SIMPLE": "cheap", "MEDIUM": "mid", "COMPLEX": "strong", "REASONING": "top"}, "dimension_weights": {}, @@ -1238,7 +1244,7 @@ class TestCustomDimensions: ) -> None: router: Final = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), { "custom_dimensions": [ { @@ -1250,7 +1256,7 @@ class TestCustomDimensions: ] }, ) - baseline: Final = ComplexityRouter("test-router", mock_router_instance) + baseline: Final = ComplexityRouter("test-router", RoutingContext(mock_router_instance)) assert "custom (late)" in router.classify("a" * 2040 + " zzz")[2] assert "custom (late)" not in router.classify("a" * 2048 + " zzz")[2] second_hit_past_the_bound: Final = "yyy " + "a" * 2044 + " zzz" @@ -1280,11 +1286,13 @@ class TestCustomDimensions: "keywords": ["orbitmesh", "ORBITMESH", "fluxgate"], "patterns": [r"\bcreate\s{1,4}table\b", r"\bcreate\s{1,4}table\b", r"\balter\s{1,4}table\b"], } - baseline: Final = ComplexityRouter("test-router", mock_router_instance) - binary: Final = ComplexityRouter("test-router", mock_router_instance, {"custom_dimensions": [dimension]}) + baseline: Final = ComplexityRouter("test-router", RoutingContext(mock_router_instance)) + binary: Final = ComplexityRouter( + "test-router", RoutingContext(mock_router_instance), {"custom_dimensions": [dimension]} + ) graded: Final = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), {"custom_dimensions": [{**dimension, "scoring_mode": "match_count"}]}, ) _, baseline_score, baseline_signals = baseline.classify(prompt) @@ -1329,7 +1337,7 @@ class TestCustomDimensions: assert custom_pattern_work(pattern) == work router: Final = ComplexityRouter( "test-router", - mock_router_instance, + RoutingContext(mock_router_instance), { "custom_dimensions": [ {"name": "bounded", "weight": 0.7, "patterns": [pattern]}, @@ -1508,7 +1516,7 @@ class TestSingletonMutation: # Create router with empty config and custom default_model router1 = ComplexityRouter( model_name="test-router-1", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=None, default_model="custom-fallback", ) @@ -1516,7 +1524,7 @@ class TestSingletonMutation: # Create another router without config router2 = ComplexityRouter( model_name="test-router-2", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=None, ) @@ -2804,7 +2812,7 @@ def llm_complexity_router(mock_router_instance, llm_classifier_config): """ComplexityRouter configured to classify via an LLM call.""" return ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=llm_classifier_config, ) @@ -3053,7 +3061,7 @@ class TestCapabilityClassifier: def _router(mock_router_instance, **overrides): return ComplexityRouter( model_name="capability-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=_capability_router_config(**overrides), ) @@ -3185,11 +3193,13 @@ class TestCapabilityClassifier: from litellm.types.router import RequestType mock_router_instance.acompletion = AsyncMock(return_value=_llm_response(reply)) - mock_router_instance.model_list = [ - {"model_name": "efficient-model", "litellm_params": {"input_cost_per_token": 0.000001}}, - {"model_name": "capable-model", "litellm_params": {"input_cost_per_token": 0.00001}}, - ] - _answer_deployments_named(mock_router_instance) + _answer_deployments_named( + mock_router_instance, + [ + {"model_name": "efficient-model", "litellm_params": {"input_cost_per_token": 0.000001}}, + {"model_name": "capable-model", "litellm_params": {"input_cost_per_token": 0.00001}}, + ], + ) router: Final = self._router( mock_router_instance, adaptive=True, @@ -3289,7 +3299,7 @@ class TestCapabilityClassifier: ) router = ComplexityRouter( model_name="capability-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) outcome = await router.aclassify("do the task") @@ -3389,7 +3399,7 @@ class TestCapabilityClassifier: bypass: Literal["literal_keyword_match", "session_affinity_pin", "housekeeping"], ) -> None: mock_router_instance.acompletion = AsyncMock(return_value=_llm_response(_capability_reply(p_solve=0.8))) - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router: Final = self._router( mock_router_instance, session_affinity=bypass == "session_affinity_pin", @@ -3519,12 +3529,12 @@ class TestTierLabels: """ renamed = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "tier_labels": CUSTOM_TIER_LABELS}, ) canonical = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) @@ -3590,16 +3600,24 @@ def _native_classifier_router( else AsyncMock(return_value=_native_classifier_response(output), side_effect=failure) ), acompletion=AsyncMock(return_value=_llm_response('{"tier":"SIMPLE"}')), - get_model_list=( - native_router.get_model_list - if native_router is not None - else MagicMock(return_value=[{"litellm_params": {"model": deployment_model}}]) + registry=MagicMock( + return_value=MagicMock( + deployments=( + native_router.registry().deployments + if native_router is not None + else MagicMock( + side_effect=lambda model_name=None, *, source="group", **_: ( + [{"litellm_params": {"model": deployment_model}}] if source == "group" else DEFAULT + ) + ) + ) + ) ), ) return ( ComplexityRouter( model_name="encrypted-router", - litellm_router_instance=dependency, + ctx=RoutingContext(dependency), complexity_router_config={ "tiers": {"SIMPLE": "cheap-model", "REASONING": "deep-model"}, "classifier_type": classifier_type, @@ -3954,7 +3972,7 @@ class TestLLMClassifier: artifact: Final = _heuristic_v2_artifact() router: Final = ComplexityRouter( model_name="tier-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "classifier_type": "heuristic_v2", "heuristic_v2_artifact": artifact, @@ -4156,7 +4174,7 @@ class TestLLMClassifier: ) router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=real_router, + ctx=RoutingContext(real_router), complexity_router_config=llm_classifier_config, ) outcome = await router.aclassify("hi") @@ -4193,7 +4211,7 @@ class TestLLMClassifier: } router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=real_router, + ctx=RoutingContext(real_router), complexity_router_config=config, ) @@ -4224,7 +4242,7 @@ class TestLLMClassifier: } router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) @@ -4241,7 +4259,7 @@ class TestLLMClassifier: mock_router_instance.acompletion = AsyncMock(side_effect=TimeoutError("classifier timed out")) router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=llm_classifier_config, ) @@ -4313,7 +4331,7 @@ class TestLLMClassifier: ) router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=llm_classifier_config, ) router._classifier_circuit_breaker = _ClassifierCircuitBreaker(30.0, clock=lambda: now) @@ -4334,7 +4352,7 @@ class TestLLMClassifier: mock_router_instance.acompletion = AsyncMock(side_effect=TimeoutError("classifier timed out")) router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **llm_classifier_config, "classifier_llm_config": { @@ -4451,7 +4469,7 @@ class TestLLMClassifier: ) router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=real_router, + ctx=RoutingContext(real_router), complexity_router_config=llm_classifier_config, ) @@ -4532,7 +4550,7 @@ class TestLLMClassifier: } router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**llm_classifier_config, "classifier_llm_config": classifier_llm_config}, ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "COMPLEX"}')) @@ -4690,7 +4708,7 @@ class TestLLMClassifier: """ router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**llm_classifier_config, "tier_labels": CUSTOM_TIER_LABELS}, ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "Deep"}')) @@ -4730,7 +4748,7 @@ class TestLLMClassifier: ): router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**llm_classifier_config, "tier_labels": CUSTOM_TIER_LABELS}, ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "%s"}' % verdict)) @@ -4751,7 +4769,7 @@ class TestLLMClassifier: """ router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**llm_classifier_config, "tier_labels": CUSTOM_TIER_LABELS}, ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "Expensive"}')) @@ -5660,25 +5678,27 @@ class TestAdaptiveSoftFloors: @pytest.fixture def adaptive_router_instance(self): router = MagicMock() - router.model_list = [ - { - "model_name": "cheap", - "litellm_params": { - "model": "openai/gpt-4o-mini", - "input_cost_per_token": 0.00000015, + _answer_deployments_named( + router, + [ + { + "model_name": "cheap", + "litellm_params": { + "model": "openai/gpt-4o-mini", + "input_cost_per_token": 0.00000015, + }, + "model_info": {"adaptive_router_preferences": {"quality_tier": 1, "strengths": []}}, }, - "model_info": {"adaptive_router_preferences": {"quality_tier": 1, "strengths": []}}, - }, - { - "model_name": "premium", - "litellm_params": { - "model": "openai/gpt-4o", - "input_cost_per_token": 0.000005, + { + "model_name": "premium", + "litellm_params": { + "model": "openai/gpt-4o", + "input_cost_per_token": 0.000005, + }, + "model_info": {"adaptive_router_preferences": {"quality_tier": 3, "strengths": []}}, }, - "model_info": {"adaptive_router_preferences": {"quality_tier": 3, "strengths": []}}, - }, - ] - _answer_deployments_named(router) + ], + ) return router @pytest.fixture @@ -5703,7 +5723,7 @@ class TestAdaptiveSoftFloors: def test_cold_start_randomly_samples_unobserved_classified_tier_models(self, adaptive_router_instance): cr = ComplexityRouter( model_name="hybrid", - litellm_router_instance=adaptive_router_instance, + ctx=RoutingContext(adaptive_router_instance), complexity_router_config={ "adaptive": True, "tiers": { @@ -5732,7 +5752,7 @@ class TestAdaptiveSoftFloors: def test_get_model_for_tier_list_without_adaptive_random_choice(self, mock_router_instance): router = ComplexityRouter( model_name="test", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "adaptive": False, "tiers": {"SIMPLE": ["cheap", "premium"], "MEDIUM": "mid"}, @@ -5754,7 +5774,7 @@ class TestAdaptiveSoftFloors: cr = ComplexityRouter( model_name="hybrid", - litellm_router_instance=adaptive_router_instance, + ctx=RoutingContext(adaptive_router_instance), complexity_router_config=hybrid_config, ) adaptive = cr._ensure_adaptive_router() @@ -5776,7 +5796,7 @@ class TestAdaptiveSoftFloors: cr = ComplexityRouter( model_name="hybrid", - litellm_router_instance=adaptive_router_instance, + ctx=RoutingContext(adaptive_router_instance), complexity_router_config=hybrid_config, ) adaptive = cr._ensure_adaptive_router() @@ -5797,7 +5817,7 @@ class TestAdaptiveSoftFloors: cr = ComplexityRouter( model_name="hybrid", - litellm_router_instance=adaptive_router_instance, + ctx=RoutingContext(adaptive_router_instance), complexity_router_config={ "adaptive": True, "tiers": { @@ -5829,7 +5849,7 @@ class TestAdaptiveSoftFloors: async def test_pre_routing_hook_adaptive_stashes_chosen_model(self, adaptive_router_instance, hybrid_config): cr = ComplexityRouter( model_name="hybrid", - litellm_router_instance=adaptive_router_instance, + ctx=RoutingContext(adaptive_router_instance), complexity_router_config=hybrid_config, ) request_kwargs: Dict = {"metadata": {}} @@ -5867,7 +5887,7 @@ class TestLexicalKeywordTierRules: """A prompt hitting a rule keyword routes to that tier, not the scored tier.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=rule_config, ) prompt = "please deploy to k8s now" @@ -5895,7 +5915,7 @@ class TestLexicalKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) result = await router.async_pre_routing_hook( @@ -5919,7 +5939,7 @@ class TestLexicalKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) result = await router.async_pre_routing_hook( @@ -5941,7 +5961,7 @@ class TestLexicalKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) assert router._lexical_tier_override("hi there, please advise") == KeywordOverride( @@ -5963,7 +5983,7 @@ class TestLexicalKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) result = await router.async_pre_routing_hook( @@ -5982,7 +6002,7 @@ class TestLexicalKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) assert router._lexical_tier_override("running my k8s cluster") == KeywordOverride( @@ -5997,7 +6017,7 @@ class TestCjkKeywordTierRules: def _router(self, mock_router_instance, basic_config, keywords: List[str]) -> ComplexityRouter: return ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **basic_config, "keyword_tier_rules": [{"keywords": keywords, "tier": "REASONING"}], @@ -6121,6 +6141,12 @@ class FakeEmbeddingRouter: self.async_embedding_kwargs.append(kwargs) return _make_embedding_response(self._vectors(docs)) + def registry(self) -> "FakeEmbeddingRouter": + return self + + def deployments(self, model_name: str | None = None, **_: object) -> List[Dict]: + return [] + def utterance_embedding_count(self, utterance: str) -> int: """How many times the given route utterance was embedded == number of route-index builds.""" return sum(1 for batch in self.embedded_batches if utterance in batch) @@ -6146,7 +6172,7 @@ class TestSemanticKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=fake_router, + ctx=RoutingContext(fake_router), complexity_router_config=config, ) result = await router.async_pre_routing_hook( @@ -6179,7 +6205,7 @@ class TestSemanticKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=fake_router, + ctx=RoutingContext(fake_router), complexity_router_config=config, ) # Only "kubernetes deployment" is close to this query (cos 1.0); "thanks" and @@ -6210,7 +6236,7 @@ class TestSemanticKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=fake_router, + ctx=RoutingContext(fake_router), complexity_router_config=config, ) caller_metadata = {"user_api_key_hash": "hash-abc", "user_api_key_team_id": "team-1"} @@ -6247,7 +6273,7 @@ class TestSemanticKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=fake_router, + ctx=RoutingContext(fake_router), complexity_router_config=config, ) await router.async_pre_routing_hook( @@ -6280,7 +6306,7 @@ class TestSemanticKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=fake_router, + ctx=RoutingContext(fake_router), complexity_router_config=config, ) await router.async_pre_routing_hook( @@ -6312,7 +6338,7 @@ class TestSemanticKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=fake_router, + ctx=RoutingContext(fake_router), complexity_router_config=config, ) caller_metadata = { @@ -6363,7 +6389,7 @@ class TestSemanticKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=fake_router, + ctx=RoutingContext(fake_router), complexity_router_config=config, ) loop_thread_id = threading.get_ident() @@ -6394,7 +6420,7 @@ class TestSemanticKeywordTierRules: def _make_router(fake): return ComplexityRouter( model_name="test-router", - litellm_router_instance=fake, + ctx=RoutingContext(fake), complexity_router_config=config, ) @@ -6429,7 +6455,7 @@ class TestSemanticKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=fake_router, + ctx=RoutingContext(fake_router), complexity_router_config=config, ) # "hello there friend" embeds orthogonal to the REASONING route (cos 0 < 0.9). @@ -6457,7 +6483,7 @@ class TestSemanticKeywordTierRules: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=fake_router, + ctx=RoutingContext(fake_router), complexity_router_config=config, ) assert router._semantic_routelayer is None @@ -6644,7 +6670,7 @@ class TestKeywordOverrideEdgeCases: } return ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) @@ -6652,7 +6678,7 @@ class TestKeywordOverrideEdgeCases: """No keyword_tier_rules configured -> lexical override is a no-op.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) assert router._lexical_tier_override("deploy to k8s and reason step by step") is None @@ -6663,7 +6689,7 @@ class TestKeywordOverrideEdgeCases: config = {**basic_config, "keyword_tier_rules": [{"keywords": ["k8s"], "tier": "REASONING"}]} router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) assert router.config.embedding_model is None @@ -6743,7 +6769,7 @@ class TestRoutingDecisionCauseLogging: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) await router.async_pre_routing_hook( @@ -6769,7 +6795,7 @@ class TestRoutingDecisionCauseLogging: } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=fake_router, + ctx=RoutingContext(fake_router), complexity_router_config=config, ) await router.async_pre_routing_hook( @@ -6787,7 +6813,7 @@ class TestRoutingDecisionCauseLogging: # No keyword rules -> the scorer decides, and its line must be tagged as such. router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) await router.async_pre_routing_hook( @@ -6835,12 +6861,11 @@ class TestTierModelAffinity: deployment_affinity: bool = True, plugins: bool = False, ) -> ComplexityRouter: - mock_router_instance.cache = DualCache() - mock_router_instance.model_list = [] - _answer_deployments_named(mock_router_instance) + mock_router_instance.health.return_value.store = DualCache() + _answer_deployments_named(mock_router_instance, []) return ComplexityRouter( model_name="affinity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": { tier: [ @@ -6934,7 +6959,7 @@ class TestTierModelAffinity: async def test_replaces_pin_outside_the_context_candidate_domain(self, adaptive: bool) -> None: router: Final = ComplexityRouter( model_name="affinity-router", - litellm_router_instance=_windowed_router(_SMALL, _BIG), + ctx=RoutingContext(_windowed_router(_SMALL, _BIG)), complexity_router_config={ "tiers": {"SIMPLE": ["small-model", "big-model"]}, "enable_context_window_escalation": True, @@ -6961,11 +6986,14 @@ class TestTierModelAffinity: async def test_temporary_replay_gate_keeps_the_held_tiers_model_preference( self, mock_router_instance: MagicMock, session_affinity: bool, gate: Literal["image", "health"] ) -> None: - async def get_healthy_deployments( + async def select( model: str, request_kwargs: Mapping[str, object], + *, + kind: Literal["healthy"], messages: Sequence[Mapping[str, object]] | None = None, input: object = None, + specific_deployment: bool | None = False, parent_otel_span: object = None, health_check_probe: bool = False, ) -> list[dict[str, object]]: @@ -6979,8 +7007,8 @@ class TestTierModelAffinity: return [] if unavailable else [{"model_name": model, "model_info": {"id": f"deployment-{model}"}}] cache: Final = DualCache() - mock_router_instance.cache = cache - mock_router_instance.async_get_healthy_deployments = get_healthy_deployments + mock_router_instance.health.return_value.store = cache + mock_router_instance.select = select router: Final = TestModalityRouting._router( mock_router_instance, { @@ -7028,10 +7056,10 @@ class TestTierModelAffinity: self, mock_router_instance: MagicMock ) -> None: clock: Final = MagicMock(return_value=100.0) - mock_router_instance.cache = DualCache(in_memory_cache=InMemoryCache(clock=clock)) + mock_router_instance.health.return_value.store = DualCache(in_memory_cache=InMemoryCache(clock=clock)) router: Final = ComplexityRouter( model_name="affinity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": ["model-a", "model-b"]}, "classification_mode": "user_turn", @@ -7065,10 +7093,10 @@ class TestTierModelAffinity: self, mock_router_instance: MagicMock ) -> None: cache: Final = DualCache() - mock_router_instance.cache = cache + mock_router_instance.health.return_value.store = cache router: Final = ComplexityRouter( model_name="affinity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": { "SIMPLE": "base", @@ -7118,10 +7146,10 @@ class TestTierModelAffinity: expected_tier: str, ) -> None: cache: Final = DualCache() - mock_router_instance.cache = cache + mock_router_instance.health.return_value.store = cache router: Final = ComplexityRouter( model_name="affinity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "model-a", "MEDIUM": "model-b"}, "session_affinity": True, @@ -7143,10 +7171,10 @@ class TestTierModelAffinity: async def test_custom_tier_keeps_its_own_model( self, mock_router_instance: MagicMock, classification_mode: Literal["every_request", "user_turn"] ) -> None: - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router: Final = ComplexityRouter( model_name="affinity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=_custom_tier_config( tiers={ "SIMPLE": ["model-a", "model-b"], @@ -7212,10 +7240,10 @@ class TestSessionAffinity: """The hook response's session_affinity_ttl_seconds is what the Router stamps as the deployment-affinity marker, so both the classify path (turn 1) and the session-pin path (turn 2) must carry the configured TTL.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**session_affinity_config, "session_affinity_ttl_seconds": 321}, ) request_kwargs = self._request_kwargs("marker-session") @@ -7252,10 +7280,10 @@ class TestSessionAffinity: ): """Deployment affinity retains a model per tier while classification continues. Session affinity keeps the first tier too; plugins suppress both affinity policies.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **basic_config, "session_affinity": session_affinity, @@ -7279,15 +7307,15 @@ class TestSessionAffinity: async def test_hook_response_has_no_session_affinity_ttl_when_disabled_or_plugins( self, mock_router_instance, basic_config, session_affinity_config ): - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() disabled_router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "deployment_affinity": False}, ) plugin_router = ComplexityRouter( model_name="test-router-plugins", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**session_affinity_config, "plugins": [_DummyPlugin()]}, ) disabled = await disabled_router.async_pre_routing_hook( @@ -7303,10 +7331,10 @@ class TestSessionAffinity: async def test_disabled_by_default_reclassifies_every_turn(self, mock_router_instance, basic_config): """With session_affinity off, a shared session can move from REASONING to SIMPLE.""" assert "session_affinity" not in basic_config - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) request_kwargs = self._request_kwargs("session-1") @@ -7323,10 +7351,10 @@ class TestSessionAffinity: async def test_proxy_generated_session_id_never_pins(self, mock_router_instance, session_affinity_config): """A session id the proxy generated for a request that had none is per request, so it must not create a pin even with session_affinity enabled.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=session_affinity_config, ) request_kwargs = {"metadata": {"session_id": "generated-1", SESSION_ID_GENERATED_METADATA_KEY: True}} @@ -7343,10 +7371,10 @@ class TestSessionAffinity: async def test_can_be_enabled_to_pin_every_later_turn(self, mock_router_instance, session_affinity_config): """Regression: session_affinity=True is the opt-in, so a shared session_id reuses the first turn's model instead of reclassifying.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=session_affinity_config, ) request_kwargs = self._request_kwargs("session-1") @@ -7361,10 +7389,10 @@ class TestSessionAffinity: @pytest.mark.asyncio async def test_pins_model_after_first_turn(self, mock_router_instance, session_affinity_config): - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=session_affinity_config, ) request_kwargs = self._request_kwargs("session-1") @@ -7387,13 +7415,13 @@ class TestSessionAffinity: TTL, so a session whose only turn landed on the cooldown fallback must classify again once the breaker closes instead of holding that fallback's model.""" now = 100.0 - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() mock_router_instance.acompletion = AsyncMock( side_effect=[TimeoutError("classifier timed out"), _llm_response('{"tier": "REASONING"}')] ) router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **session_affinity_config, "classifier_type": "llm", @@ -7422,10 +7450,10 @@ class TestSessionAffinity: @pytest.mark.asyncio async def test_a_pinned_turn_reports_the_tier_that_serves_it(self, mock_router_instance, session_affinity_config): - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=session_affinity_config, ) request_kwargs = self._request_kwargs("session-1") @@ -7439,10 +7467,10 @@ class TestSessionAffinity: @pytest.mark.asyncio async def test_different_sessions_classify_independently(self, mock_router_instance, session_affinity_config): - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=session_affinity_config, ) reasoning = await router.async_pre_routing_hook( @@ -7461,10 +7489,10 @@ class TestSessionAffinity: ) -> None: clock: Final = MagicMock(return_value=100.0) cache: Final = DualCache(in_memory_cache=InMemoryCache(clock=clock)) - mock_router_instance.cache = cache + mock_router_instance.health.return_value.store = cache router: Final = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **basic_config, "session_affinity": True, @@ -7565,10 +7593,10 @@ class TestSessionAffinity: litellm.in_memory_llm_clients_cache.set_cache(key=client_key, value=client) try: cache: Final = DualCache(in_memory_cache=InMemoryCache(clock=clock), redis_cache=redis_cache) - mock_router_instance.cache = cache + mock_router_instance.health.return_value.store = cache router: Final = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **basic_config, "classification_mode": "user_turn", @@ -7623,10 +7651,10 @@ class TestSessionAffinity: async def test_different_api_keys_do_not_share_pin(self, mock_router_instance, session_affinity_config): """A session_id is client-supplied and unauthenticated; two different callers (API keys) reusing the same session_id must not poison each other's pin.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=session_affinity_config, ) caller_a_kwargs = {"metadata": {"session_id": "shared-session", "user_api_key_hash": "key-a"}} @@ -7647,10 +7675,10 @@ class TestSessionAffinity: @pytest.mark.asyncio async def test_no_session_id_falls_back_to_reclassify(self, mock_router_instance, session_affinity_config): cache = AsyncMock() - mock_router_instance.cache = cache + mock_router_instance.health.return_value.store = cache router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=session_affinity_config, ) result = await router.async_pre_routing_hook( @@ -7665,18 +7693,20 @@ class TestSessionAffinity: """Regression: skipping classification on a pinned turn must not break the adaptive bandit's reward-feedback loop, which only records a turn's outcome when ADAPTIVE_ROUTER_CHOSEN_MODEL_KEY is present in the request metadata.""" - mock_router_instance.cache = DualCache() - mock_router_instance.model_list = [ - { - "model_name": "cheap", - "litellm_params": {"model": "openai/gpt-4o-mini", "input_cost_per_token": 0.0}, - "model_info": {}, - }, - ] - _answer_deployments_named(mock_router_instance) + mock_router_instance.health.return_value.store = DualCache() + _answer_deployments_named( + mock_router_instance, + [ + { + "model_name": "cheap", + "litellm_params": {"model": "openai/gpt-4o-mini", "input_cost_per_token": 0.0}, + "model_info": {}, + }, + ], + ) router = ComplexityRouter( model_name="hybrid", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "adaptive": True, "session_affinity": True, @@ -7915,10 +7945,10 @@ class TestClassificationMode: return {"metadata": {"session_id": session_id}} def _router(self, mock_router_instance, config: dict) -> ComplexityRouter: - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() return ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) @@ -7936,7 +7966,7 @@ class TestClassificationMode: with pytest.raises(ValidationError): ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "classification_mode": "sometimes"}, ) @@ -8252,7 +8282,7 @@ class TestRoutingPlugins: router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": ["gpt-4o-mini", "gpt-4o-nano"]}, "plugins": [ExcludeGpt4oMini()], @@ -8280,7 +8310,7 @@ class TestRoutingPlugins: router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "gpt-4o-mini"}, "default_model": "gpt-4o-fallback", @@ -8303,7 +8333,7 @@ class TestRoutingPlugins: router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "gpt-4o-mini"}, "plugins": [BlockEverything()], @@ -8327,7 +8357,7 @@ class TestRoutingPlugins: router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "gpt-4o-mini"}, "plugins": [CaptureMetadata()], @@ -8351,7 +8381,7 @@ class TestRoutingPlugins: router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": ["gpt-4o-mini", "gpt-4o-nano"]}, "keyword_tier_rules": [{"keywords": ["hello"], "tier": "SIMPLE"}], @@ -8380,7 +8410,7 @@ class TestRoutingPlugins: router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"MEDIUM": ["gpt-4o-default", "gpt-4o-nano"]}, "default_model": "gpt-4o-default", @@ -8407,7 +8437,7 @@ class TestRoutingPlugins: PR #33251 after the plugin-bypass fix changed this priority unconditionally.""" router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"MEDIUM": ["gpt-4o-medium-tier"]}, "default_model": "gpt-4o-configured-default", @@ -8449,7 +8479,7 @@ class TestRoutingPlugins: (e.g. a budget cap crossed mid-session) was only ever enforced on a session's first turn. With plugins configured, every turn must go through _classify_and_route (and therefore the plugin pipeline) again.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() class AllowAll: async def run(self, context): @@ -8457,7 +8487,7 @@ class TestRoutingPlugins: router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": ["gpt-4o-mini"]}, "session_affinity": True, @@ -8521,7 +8551,7 @@ def _plugin_router(mock_router_instance, plugin, **config_overrides): } return ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) @@ -8686,7 +8716,7 @@ class TestClassifierPlugin: """A built-in tier the operator gave no models is a decline, not a later routing error.""" router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "gpt-4o-mini"}, "classifier_type": "custom", @@ -8826,7 +8856,7 @@ class TestEscalationKeywords: def test_escalate_tier_skips_unconfigured_intermediate(self, mock_router_instance): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={"tiers": {"SIMPLE": "gpt-4o-mini", "REASONING": "o1-preview"}}, ) assert router._escalate_tier(ComplexityTier.SIMPLE) == ComplexityTier.REASONING @@ -8834,7 +8864,7 @@ class TestEscalationKeywords: def test_tier_for_model_returns_most_severe(self, mock_router_instance): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={"tiers": {"SIMPLE": "shared", "COMPLEX": "shared", "REASONING": "top"}}, ) assert router._tier_for_model("shared") == ComplexityTier.COMPLEX @@ -8845,7 +8875,7 @@ class TestEscalationKeywords: async def test_escalation_bumps_classified_tier(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) # Baseline: this prompt classifies SIMPLE. @@ -8865,7 +8895,7 @@ class TestEscalationKeywords: async def test_lowercase_keyword_does_not_escalate(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) result = await router.async_pre_routing_hook( @@ -8879,7 +8909,7 @@ class TestEscalationKeywords: async def test_custom_escalation_keyword(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "escalation_keywords": ["MAKE IT BETTER"]}, ) # The default keyword no longer triggers once a custom list is supplied. @@ -8901,7 +8931,7 @@ class TestEscalationKeywords: async def test_empty_keyword_list_disables_escalation(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "escalation_keywords": []}, ) result = await router.async_pre_routing_hook( @@ -8915,7 +8945,7 @@ class TestEscalationKeywords: async def test_escalation_caps_at_highest_tier(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) result = await router.async_pre_routing_hook( @@ -8934,7 +8964,7 @@ class TestEscalationKeywords: async def test_escalation_bumps_keyword_tier_override(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **basic_config, "keyword_tier_rules": [{"keywords": ["billing"], "tier": "SIMPLE"}], @@ -8956,10 +8986,10 @@ class TestEscalationKeywords: async def test_escalation_overrides_session_pin_and_persists(self, mock_router_instance, basic_config): """Mid-session escalation bumps relative to the pinned model (never below it) and the bumped model persists for later turns.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "session_affinity": True}, ) request_kwargs = self._request_kwargs("session-1") @@ -9019,10 +9049,10 @@ class TestEscalationKeywords: survives across the plumbing turns after it, so reading escalation off it re-fires per turn and, with the pin persisted, walks the session to the top tier. Escalation reads the newest turn's ask. """ - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "session_affinity": True}, ) request_kwargs = self._request_kwargs("session-plumbing") @@ -9057,7 +9087,7 @@ class TestEscalationKeywords: """ router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) @@ -9096,7 +9126,7 @@ class TestEscalationKeywords: async def test_blank_escalation_keyword_does_not_escalate_everything(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "escalation_keywords": [""]}, ) assert router.escalation_keywords == () @@ -9112,7 +9142,7 @@ class TestEscalationKeywords: when that tier's pool has peers `get_model_for_tier` could randomly pick instead.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={"tiers": {"SIMPLE": "gpt-4o-mini", "REASONING": ["o1-a", "o1-b", "o1-c"]}}, ) for pinned in ("o1-a", "o1-b", "o1-c"): @@ -9121,17 +9151,17 @@ class TestEscalationKeywords: @pytest.mark.asyncio async def test_session_escalation_at_ceiling_keeps_multi_model_pin(self, mock_router_instance): - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "gpt-4o-mini", "REASONING": ["o1-a", "o1-b", "o1-c"]}, "session_affinity": True, }, ) cache_key = router._get_session_affinity_cache_key("session-top", {}) - await mock_router_instance.cache.async_set_cache(key=cache_key, value="o1-b") + await mock_router_instance.health().store.async_set_cache(key=cache_key, value="o1-b") result = await router.async_pre_routing_hook( model="test-model", request_kwargs=self._request_kwargs("session-top"), @@ -9168,7 +9198,7 @@ class TestStallEscalation: async def test_repeated_tool_calls_escalate_the_classified_tier(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "stall_escalation_enabled": True}, ) messages = [*_stalled_tool_history(), {"role": "user", "content": "Hello there!"}] @@ -9179,7 +9209,7 @@ class TestStallEscalation: async def test_varied_tool_calls_do_not_escalate(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "stall_escalation_enabled": True}, ) messages = [ @@ -9200,7 +9230,7 @@ class TestStallEscalation: async def test_disabled_by_default_ignores_repeated_tool_calls(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=basic_config, ) messages = [*_stalled_tool_history(), {"role": "user", "content": "Hello there!"}] @@ -9211,7 +9241,7 @@ class TestStallEscalation: async def test_signals_record_stall_escalation(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "stall_escalation_enabled": True}, ) messages = [*_stalled_tool_history(), {"role": "user", "content": "Hello there!"}] @@ -9222,7 +9252,7 @@ class TestStallEscalation: async def test_stall_escalation_caps_at_highest_tier(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "stall_escalation_enabled": True}, ) messages = [ @@ -9236,7 +9266,7 @@ class TestStallEscalation: async def test_stall_escalation_stacks_with_keyword_escalation(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "stall_escalation_enabled": True}, ) messages = [*_stalled_tool_history(), {"role": "user", "content": "LITELLM ESCALATE Hello there!"}] @@ -9250,7 +9280,7 @@ class TestStallEscalation: would be the one path a stall could never lift.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **basic_config, "stall_escalation_enabled": True, @@ -9276,7 +9306,7 @@ class TestStallEscalation: before it: escalation still fires on the turn carrying that follow-up.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "stall_escalation_enabled": True}, ) messages = [*_stalled_tool_history(), {"role": "user", "content": "try again"}] @@ -9403,7 +9433,7 @@ class TestRoutingDecisionContents: } router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) response = await router.async_pre_routing_hook( @@ -9437,7 +9467,7 @@ class TestRoutingDecisionContents: async def test_a_default_model_fallback_claims_no_tier(self, mock_router_instance, basic_config): router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "default_model": "gpt-4o"}, ) response = await router.async_pre_routing_hook( @@ -9452,15 +9482,15 @@ class TestRoutingDecisionContents: @pytest.mark.asyncio async def test_session_pin_decision(self, mock_router_instance, basic_config): - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "session_affinity": True}, ) request_kwargs = {"metadata": {"session_id": "session-decision"}} cache_key = router._get_session_affinity_cache_key("session-decision", request_kwargs) - await mock_router_instance.cache.async_set_cache(key=cache_key, value="gpt-4o") + await mock_router_instance.health().store.async_set_cache(key=cache_key, value="gpt-4o") response = await router.async_pre_routing_hook( model="test-complexity-router", request_kwargs=request_kwargs, @@ -9514,7 +9544,7 @@ class TestRoutingDecisionContents: """ router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "tier_labels": CUSTOM_TIER_LABELS}, ) response = await router.async_pre_routing_hook( @@ -9534,7 +9564,7 @@ class TestRoutingDecisionContents: """A partial map must not stamp a redundant label on the tiers it left alone.""" router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "tier_labels": {"REASONING": "Deep"}}, ) simple = await router.async_pre_routing_hook( @@ -9841,7 +9871,7 @@ class TestEscalationIsRecordedConsistently: async def test_scorer_path_at_ceiling_keeps_the_keyword_and_reports_no_bump(self, mock_router_instance): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **self.CEILING_CONFIG, "tier_boundaries": {"simple_medium": -99, "medium_complex": -99, "complex_reasoning": -99}, @@ -9870,15 +9900,15 @@ class TestEscalationIsRecordedConsistently: @pytest.mark.asyncio async def test_session_pin_at_ceiling_still_records_the_ask(self, mock_router_instance): - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**self.CEILING_CONFIG, "session_affinity": True}, ) request_kwargs = {"metadata": {"session_id": "session-ceiling"}} cache_key = router._get_session_affinity_cache_key("session-ceiling", request_kwargs) - await mock_router_instance.cache.async_set_cache(key=cache_key, value="o1-preview") + await mock_router_instance.health().store.async_set_cache(key=cache_key, value="o1-preview") response = await router.async_pre_routing_hook( model="test-router", @@ -9895,15 +9925,15 @@ class TestEscalationIsRecordedConsistently: @pytest.mark.asyncio async def test_session_pin_below_ceiling_reports_the_bump(self, mock_router_instance): - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**self.CEILING_CONFIG, "session_affinity": True}, ) request_kwargs = {"metadata": {"session_id": "session-below"}} cache_key = router._get_session_affinity_cache_key("session-below", request_kwargs) - await mock_router_instance.cache.async_set_cache(key=cache_key, value="gpt-4o-mini") + await mock_router_instance.health().store.async_set_cache(key=cache_key, value="gpt-4o-mini") response = await router.async_pre_routing_hook( model="test-router", @@ -10192,7 +10222,7 @@ class TestContextAwareClassifier: dependency: Final = MagicMock(acompletion=AsyncMock(return_value=_llm_response('{"tier": "COMPLEX"}'))) router: Final = ComplexityRouter( "test-complexity-router", - dependency, + RoutingContext(dependency), { **llm_classifier_config, "classifier_context_include_assistant_turns": True, @@ -10253,7 +10283,7 @@ class TestContextAwareClassifier: dependency: Final = MagicMock(acompletion=AsyncMock(return_value=_llm_response('{"tier": "SIMPLE"}'))) router: Final = ComplexityRouter( "test-complexity-router", - dependency, + RoutingContext(dependency), {**llm_classifier_config, "classifier_context_window_size": 0}, ) messages: Final = [ @@ -10317,7 +10347,7 @@ class TestContextAwareClassifier: ) router: Final = ComplexityRouter( model_name="router", - litellm_router_instance=MagicMock(acompletion=completion, cache=DualCache()), + ctx=RoutingContext(MagicMock(acompletion=completion, **{"health.return_value.store": DualCache()})), complexity_router_config={ "tiers": {"SIMPLE": "simple-model", "COMPLEX": "task-model"}, "classifier_type": "llm", @@ -10382,7 +10412,7 @@ class TestContextAwareClassifier: completion: Final = AsyncMock(return_value=_llm_response('{"tier":"COMPLEX"}')) router: Final = ComplexityRouter( model_name="router", - litellm_router_instance=MagicMock(acompletion=completion), + ctx=RoutingContext(MagicMock(acompletion=completion)), complexity_router_config={ "tiers": {"COMPLEX": "task-model"}, "default_model": "fallback-model", @@ -10450,7 +10480,7 @@ class TestContextAwareClassifier: completion: Final = AsyncMock(return_value=_llm_response('{"tier":"COMPLEX"}')) router: Final = ComplexityRouter( model_name="codex-router", - litellm_router_instance=MagicMock(acompletion=completion), + ctx=RoutingContext(MagicMock(acompletion=completion)), complexity_router_config={ "tiers": {"COMPLEX": "task-model", "REASONING": "escalated-model"}, "classifier_type": "llm", @@ -10498,7 +10528,7 @@ class TestContextAwareClassifier: completion: Final = AsyncMock(return_value=_llm_response('{"tier":"COMPLEX"}')) router: Final = ComplexityRouter( model_name="router", - litellm_router_instance=MagicMock(acompletion=completion), + ctx=RoutingContext(MagicMock(acompletion=completion)), complexity_router_config={ "tiers": {"COMPLEX": "task-model"}, "classifier_type": "llm", @@ -11031,7 +11061,7 @@ class TestContextAwareClassifier: router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=llm_classifier_config, ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "SIMPLE"}')) @@ -11058,7 +11088,7 @@ class TestContextAwareClassifier: """ router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**llm_classifier_config, "classifier_context_budget_chars": 1}, ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "SIMPLE"}')) @@ -11344,7 +11374,7 @@ class TestContextAwareClassifier: """ router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "gpt-4o-mini", "COMPLEX": "claude-sonnet-4-20250514"}, "classifier_type": "llm", @@ -11383,7 +11413,7 @@ class TestContextAwareClassifier: """ router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **llm_classifier_config, "classifier_context_include_assistant_turns": include_assistant, @@ -11425,7 +11455,7 @@ class TestContextAwareClassifier: """ router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **llm_classifier_config, "classifier_context_include_assistant_turns": include_assistant, @@ -11466,7 +11496,7 @@ class TestContextAwareClassifier: """ router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **llm_classifier_config, "classifier_context_include_assistant_turns": True, @@ -11516,7 +11546,7 @@ class TestClientHousekeepingCalls: """ router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=llm_classifier_config, ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "REASONING"}')) @@ -11542,7 +11572,7 @@ class TestClientHousekeepingCalls: """ router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=llm_classifier_config, ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "REASONING"}')) @@ -11566,7 +11596,7 @@ class TestClientHousekeepingCalls: """A caller who explicitly escalated asked for something; the cap must not silently undo it.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=llm_classifier_config, ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "SIMPLE"}')) @@ -11585,7 +11615,7 @@ class TestClientHousekeepingCalls: """keyword_tier_rules are the operator's own instruction, decided before this ever runs.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **llm_classifier_config, "keyword_tier_rules": [{"keywords": ["livelocks under contention"], "tier": "REASONING"}], @@ -11606,7 +11636,7 @@ class TestClientHousekeepingCalls: """The floor is an operator guarantee about what plan-mode turns may run on, so it wins.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**llm_classifier_config, "plan_mode_min_tier": "COMPLEX"}, ) @@ -11629,7 +11659,7 @@ class TestClientHousekeepingCalls: """An operator who wants these classified keeps the old behaviour, classifier call included.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**llm_classifier_config, "route_housekeeping_to_cheapest_tier": False}, ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "REASONING"}')) @@ -11649,7 +11679,7 @@ class TestClientHousekeepingCalls: """Client wording drifts with releases, so coverage has to be extensible without a code change.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **llm_classifier_config, "housekeeping_patterns": ["Summarize this thread for the sidebar"], @@ -11678,7 +11708,7 @@ class TestClientHousekeepingCalls: """A tier can be declared with no pool, and routing to an empty pool is a different bug.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"COMPLEX": "claude-sonnet-4-20250514", "REASONING": "o1-preview"}, "default_model": "gpt-4o-mini", @@ -11712,7 +11742,7 @@ class TestClientHousekeepingCalls: router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "gpt-4o-mini", "REASONING": "o1-preview"}, "classifier_type": "custom", @@ -11731,22 +11761,24 @@ class TestClientHousekeepingCalls: def _adaptive_router(self, tier_distance_penalty: float, plan_mode_min_tier: str | None = None) -> ComplexityRouter: adaptive_instance = MagicMock() - adaptive_instance.model_list = [ - { - "model_name": "cheap", - "litellm_params": {"model": "openai/gpt-4o-mini", "input_cost_per_token": 0.00000015}, - "model_info": {"adaptive_router_preferences": {"quality_tier": 1, "strengths": []}}, - }, - { - "model_name": "premium", - "litellm_params": {"model": "openai/gpt-4o", "input_cost_per_token": 0.000005}, - "model_info": {"adaptive_router_preferences": {"quality_tier": 3, "strengths": []}}, - }, - ] - _answer_deployments_named(adaptive_instance) + _answer_deployments_named( + adaptive_instance, + [ + { + "model_name": "cheap", + "litellm_params": {"model": "openai/gpt-4o-mini", "input_cost_per_token": 0.00000015}, + "model_info": {"adaptive_router_preferences": {"quality_tier": 1, "strengths": []}}, + }, + { + "model_name": "premium", + "litellm_params": {"model": "openai/gpt-4o", "input_cost_per_token": 0.000005}, + "model_info": {"adaptive_router_preferences": {"quality_tier": 3, "strengths": []}}, + }, + ], + ) router = ComplexityRouter( model_name="hybrid", - litellm_router_instance=adaptive_instance, + ctx=RoutingContext(adaptive_instance), complexity_router_config={ "adaptive": True, "adaptive_eligible": "all", @@ -11806,11 +11838,11 @@ class TestClientHousekeepingCalls: An agent names the conversation on its first turn, so the cheapest tier would be the pin every session starts with and the real work that follows would run there for the whole TTL. """ - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "REASONING"}')) router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": { "SIMPLE": "gpt-4o-mini", @@ -11848,7 +11880,7 @@ class TestClientHousekeepingCalls: """ router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=llm_classifier_config, ) @@ -11918,7 +11950,7 @@ class TestClassifierTrustBoundary: router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "gpt-4o-mini", "REASONING": "o1-preview"}, "classifier_type": "llm", @@ -11980,7 +12012,7 @@ class TestClassifierTrustBoundary: router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **llm_classifier_config, "classifier_context_include_assistant_turns": include_assistant, @@ -12030,7 +12062,7 @@ class TestConversationShapeDiscriminator: def _router(mock_router_instance, basic_config) -> ComplexityRouter: return ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**basic_config, "session_affinity": False}, ) @@ -12038,7 +12070,7 @@ class TestConversationShapeDiscriminator: async def test_a_single_ask_is_a_first_turn(self, mock_router_instance, basic_config): """Nothing is cached for any model yet, so the baseline would have paid the same cache write and the saving is the plain rate difference.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() result = await self._router(mock_router_instance, basic_config).async_pre_routing_hook( model="test-model", request_kwargs={"metadata": {}}, @@ -12050,7 +12082,7 @@ class TestConversationShapeDiscriminator: async def test_a_second_ask_means_the_baseline_was_already_warm(self, mock_router_instance, basic_config): """An earlier turn was served, so a single-model deployment wrote the prompt then and would only read it now; this request's write is what switching cost.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() result = await self._router(mock_router_instance, basic_config).async_pre_routing_hook( model="test-model", request_kwargs={"metadata": {}}, @@ -12066,7 +12098,7 @@ class TestConversationShapeDiscriminator: async def test_it_needs_no_session_id(self, mock_router_instance, basic_config): """The whole point of reading the conversation rather than remembering it: a caller that sends no session header is still classified correctly.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = self._router(mock_router_instance, basic_config) first = await router.async_pre_routing_hook( model="test-model", request_kwargs={}, messages=[{"role": "user", "content": "Hello!"}] @@ -12089,7 +12121,7 @@ class TestConversationShapeDiscriminator: round-trip, and with it a cache failure that would read as a first turn.""" cache = AsyncMock() cache.async_get_cache = AsyncMock(return_value=None) - mock_router_instance.cache = cache + mock_router_instance.health.return_value.store = cache result = await self._router(mock_router_instance, basic_config).async_pre_routing_hook( model="test-model", request_kwargs={"metadata": {}}, @@ -12243,7 +12275,7 @@ class TestCustomClassifierSystemPrompt: **config_patch, ) return ComplexityRouter( - model_name="test-complexity-router", litellm_router_instance=MagicMock(), complexity_router_config=config + model_name="test-complexity-router", ctx=RoutingContext(MagicMock()), complexity_router_config=config ) def test_custom_instructions_keep_the_rubric_criteria_and_examples(self): @@ -12290,7 +12322,7 @@ class TestCustomClassifierSystemPrompt: classification_prompt="Grade the request.", ) router = ComplexityRouter( - model_name="test-complexity-router", litellm_router_instance=MagicMock(), complexity_router_config=config + model_name="test-complexity-router", ctx=RoutingContext(MagicMock()), complexity_router_config=config ) prompt = router._classifier_system_prompt assert prompt is not None @@ -12364,7 +12396,7 @@ class TestCustomClassifierSystemPrompt: ) router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **llm_classifier_config, "classifier_llm_config": { @@ -12391,7 +12423,7 @@ class TestCustomClassifierSystemPrompt: rather than escaping as an exception to the caller's request.""" router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **llm_classifier_config, "classifier_llm_config": { @@ -12425,7 +12457,7 @@ class TestClassifierFallbackChoice: def default_model_fallback_router(self, mock_router_instance, llm_classifier_config): return ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ **llm_classifier_config, "classifier_fallback": "default_model", @@ -12442,7 +12474,7 @@ class TestClassifierFallbackChoice: with pytest.raises(ValueError, match="requires a default model"): ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**llm_classifier_config, "classifier_fallback": "default_model"}, ) @@ -12453,7 +12485,7 @@ class TestClassifierFallbackChoice: validator would have rejected this valid deployment.""" router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={**llm_classifier_config, "classifier_fallback": "default_model"}, default_model="gpt-4o", ) @@ -12508,7 +12540,7 @@ class TestClassifierFallbackChoice: disabled here so the next turn isolates and verifies the affinity contract.""" router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": { "SIMPLE": "gpt-4o-mini", @@ -12527,7 +12559,7 @@ class TestClassifierFallbackChoice: "session_affinity": True, }, ) - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() request_kwargs: Dict = {"metadata": {"session_id": "session-flaky"}} mock_router_instance.acompletion = AsyncMock(side_effect=TimeoutError("classifier timed out")) @@ -12556,7 +12588,7 @@ class TestClassifierFallbackChoice: turn on a default_model-fallback router must still pin exactly as it did before.""" router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "gpt-4o-mini", "REASONING": "o1-preview"}, "classifier_type": "llm", @@ -12566,7 +12598,7 @@ class TestClassifierFallbackChoice: "session_affinity": True, }, ) - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() request_kwargs: Dict = {"metadata": {"session_id": "session-steady"}} mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "REASONING"}')) @@ -12600,7 +12632,7 @@ class TestClassifierFallbackChoice: router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"MEDIUM": ["gpt-4o-default", "gpt-4o-nano"]}, "classifier_type": "llm", @@ -12640,7 +12672,7 @@ class TestClassifierFallbackChoice: router = ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"COMPLEX": ["o1-preview"]}, "classifier_type": "llm", @@ -12690,7 +12722,7 @@ class TestSavingsBaselineOnDecision: ) return ComplexityRouter( model_name="savings-router", - litellm_router_instance=parent, + ctx=RoutingContext(parent), complexity_router_config={"tiers": tiers}, **kwargs, ) @@ -12716,7 +12748,7 @@ class TestSavingsBaselineOnDecision: """The deployment id is what lets the spend writer price a baseline whose deployment carries a configured rate instead of the public one.""" router = self._router_with_tiers({"SIMPLE": "cheap", "REASONING": "top"}) - expected_id = router.litellm_router_instance.get_model_list(model_name="top")[0]["model_info"]["id"] + expected_id = router.ctx.registry().deployments(model_name="top")[0]["model_info"]["id"] decision = router._build_routing_decision(routed_model="cheap", cause="heuristic_scorer") assert decision["savings_baseline_model"] == "anthropic/claude-fable-5" assert decision["savings_baseline_deployment_id"] == expected_id @@ -12760,7 +12792,7 @@ class TestSavingsBaselinePinnedPerInstance: ) router = ComplexityRouter( model_name="savings-router", - litellm_router_instance=parent, + ctx=RoutingContext(parent), complexity_router_config={"tiers": {"SIMPLE": "cheap", "REASONING": ["cheap", "top"]}}, ) return router, parent @@ -12779,7 +12811,7 @@ class TestSavingsBaselinePinnedPerInstance: parent.model_name_to_deployment_indices.clear() rebuilt = ComplexityRouter( model_name="savings-router", - litellm_router_instance=parent, + ctx=RoutingContext(parent), complexity_router_config={"tiers": {"SIMPLE": "cheap", "REASONING": ["cheap", "top"]}}, ) assert rebuilt.savings_baseline is None @@ -13071,7 +13103,7 @@ class TestTierDefinitions: def custom_tier_router(self, mock_router_instance): return ComplexityRouter( model_name="custom-tier-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=_custom_tier_config(), ) @@ -13186,7 +13218,7 @@ class TestTierDefinitions: the injection-defense paragraph would let a caller ask for a tier and get it.""" router = ComplexityRouter( model_name="custom-tier-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=_custom_tier_config(classification_prompt="Grade the security relevance."), ) mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "SIMPLE"}')) @@ -13205,7 +13237,7 @@ class TestTierDefinitions: after the defined tiers, and still above the injection guard.""" router = ComplexityRouter( model_name="custom-tier-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=_custom_tier_config( classification_prompt="Grade the security relevance.", classification_examples='- "audit this login handler" -> SECURITY_REVIEW', @@ -13257,7 +13289,7 @@ class TestTierDefinitions: tier_definitions wins, mirroring the built-in severity tie-break.""" router = ComplexityRouter( model_name="custom-tier-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=_custom_tier_config( keyword_tier_rules=[ {"keywords": ["audit"], "tier": "SECURITY_REVIEW"}, @@ -13517,7 +13549,7 @@ class TestPlanModeTierFloor: def _router(self, mock_router_instance, config: dict) -> ComplexityRouter: return ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) @@ -13618,7 +13650,7 @@ class TestPlanModeTierFloor: auto-routes back to it instead of staying premium.""" from litellm.caching.dual_cache import DualCache - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() config = {**basic_config, "plan_mode_min_tier": "COMPLEX", "session_affinity": True} router = self._router(mock_router_instance, config) session_kwargs = {"metadata": {"session_id": "plan-session"}} @@ -13659,7 +13691,7 @@ class TestPlanModeTierFloor: the first ordinary turn classifies and pins as if plan mode had never happened.""" from litellm.caching.dual_cache import DualCache - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() config = {**basic_config, "plan_mode_min_tier": "COMPLEX", "session_affinity": True} router = self._router(mock_router_instance, config) session_kwargs = {"metadata": {"session_id": "plan-first-session"}} @@ -13683,7 +13715,7 @@ class TestPlanModeTierFloor: async def test_pinned_session_at_or_above_floor_keeps_pin_cause(self, mock_router_instance, basic_config): from litellm.caching.dual_cache import DualCache - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() config = {**basic_config, "plan_mode_min_tier": "MEDIUM", "session_affinity": True} router = self._router(mock_router_instance, config) session_kwargs = {"metadata": {"session_id": "premium-session"}} @@ -13822,22 +13854,24 @@ class TestPlanModeTierFloor: from litellm.types.router import RequestType adaptive_instance = MagicMock() - adaptive_instance.model_list = [ - { - "model_name": "cheap", - "litellm_params": {"model": "openai/gpt-4o-mini", "input_cost_per_token": 0.00000015}, - "model_info": {"adaptive_router_preferences": {"quality_tier": 1, "strengths": []}}, - }, - { - "model_name": "premium", - "litellm_params": {"model": "openai/gpt-4o", "input_cost_per_token": 0.000005}, - "model_info": {"adaptive_router_preferences": {"quality_tier": 3, "strengths": []}}, - }, - ] - _answer_deployments_named(adaptive_instance) + _answer_deployments_named( + adaptive_instance, + [ + { + "model_name": "cheap", + "litellm_params": {"model": "openai/gpt-4o-mini", "input_cost_per_token": 0.00000015}, + "model_info": {"adaptive_router_preferences": {"quality_tier": 1, "strengths": []}}, + }, + { + "model_name": "premium", + "litellm_params": {"model": "openai/gpt-4o", "input_cost_per_token": 0.000005}, + "model_info": {"adaptive_router_preferences": {"quality_tier": 3, "strengths": []}}, + }, + ], + ) router = ComplexityRouter( model_name="hybrid", - litellm_router_instance=adaptive_instance, + ctx=RoutingContext(adaptive_instance), complexity_router_config={ "adaptive": True, "tiers": {"SIMPLE": ["cheap"], "MEDIUM": ["cheap"], "COMPLEX": ["premium"]}, @@ -13864,7 +13898,7 @@ class TestPlanModeTierFloor: turn's pin would carry plan mode past its exit.""" from litellm.caching.dual_cache import DualCache - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() config = { **basic_config, "plan_mode_min_tier": "MEDIUM", @@ -14011,7 +14045,7 @@ def test_adaptive_empty_tier_pool_is_rejected(): def test_tier_model_params_are_used_by_pools_and_savings_baseline(mock_router_instance): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": { "SIMPLE": "mini", @@ -14029,7 +14063,7 @@ def test_tier_model_params_are_used_by_pools_and_savings_baseline(mock_router_in async def test_tier_model_params_reach_the_hook_response_and_override_client_values(mock_router_instance): router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": { "REASONING": { @@ -14065,13 +14099,13 @@ async def test_tier_params_mask_credentials_in_routing_decision(route, mock_rout } router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) request_kwargs = {"metadata": {"session_id": "masked-params-session"}} if route == "session": - mock_router_instance.cache = DualCache() - await mock_router_instance.cache.async_set_cache( + mock_router_instance.health.return_value.store = DualCache() + await mock_router_instance.health().store.async_set_cache( key=router._get_session_affinity_cache_key("masked-params-session", request_kwargs), value={"model": "opus", "tier": "REASONING"}, ) @@ -14094,10 +14128,10 @@ async def test_tier_params_mask_credentials_in_routing_decision(route, mock_rout @pytest.mark.asyncio async def test_session_pin_outside_tiers_does_not_inherit_medium_params(mock_router_instance): - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": { "SIMPLE": "mini", @@ -14108,7 +14142,7 @@ async def test_session_pin_outside_tiers_does_not_inherit_medium_params(mock_rou }, ) request_kwargs = {"metadata": {"session_id": "orphan-session"}} - await mock_router_instance.cache.async_set_cache( + await mock_router_instance.health().store.async_set_cache( key=router._get_session_affinity_cache_key("orphan-session", request_kwargs), value="orphan", ) @@ -14126,10 +14160,10 @@ async def test_session_pin_outside_tiers_does_not_inherit_medium_params(mock_rou @pytest.mark.asyncio async def test_session_pin_uses_recorded_tier_when_model_is_in_multiple_tiers(mock_router_instance): - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": { "SIMPLE": {"model_name": "shared", "litellm_params": {"reasoning_effort": "low"}}, @@ -14139,7 +14173,7 @@ async def test_session_pin_uses_recorded_tier_when_model_is_in_multiple_tiers(mo }, ) request_kwargs = {"metadata": {"session_id": "shared-session"}} - await mock_router_instance.cache.async_set_cache( + await mock_router_instance.health().store.async_set_cache( key=router._get_session_affinity_cache_key("shared-session", request_kwargs), value={"model": "shared", "tier": "SIMPLE"}, ) @@ -14159,10 +14193,10 @@ async def test_session_pin_uses_recorded_tier_when_model_is_in_multiple_tiers(mo @pytest.mark.asyncio async def test_session_pin_survives_json_list_round_trip(mock_router_instance): cache: Final = DualCache() - mock_router_instance.cache = cache + mock_router_instance.health.return_value.store = cache router = ComplexityRouter( model_name="test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": { "SIMPLE": {"model_name": "shared", "litellm_params": {"reasoning_effort": "low"}}, @@ -14223,7 +14257,7 @@ def _heuristic_first_router(mock_router_instance, **config_overrides): } return ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) @@ -14413,7 +14447,7 @@ def _hybrid_router(mock_router_instance, **config_overrides): } return ComplexityRouter( model_name="test-complexity-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) @@ -14645,7 +14679,7 @@ async def test_selected_v2_chain_routes_using_success_probabilities( mock_router_instance.acompletion = AsyncMock(return_value=_llm_response('{"tier": "REASONING"}')) router: Final = ComplexityRouter( model_name="v2-chain", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "classifier_type": classifier_type, "local_heuristic": "heuristic_v2", @@ -14693,7 +14727,7 @@ async def test_v2_chain_judge_failure_uses_selected_fallback( dependency.acompletion = AsyncMock(side_effect=RuntimeError("judge failed")) router: Final = ComplexityRouter( model_name="v2-chain", - litellm_router_instance=dependency, + ctx=RoutingContext(dependency), complexity_router_config={ "classifier_type": classifier_type, "local_heuristic": "heuristic_v2", @@ -14778,7 +14812,7 @@ class TestContextWindowEscalation: """ router = ComplexityRouter( model_name="test-router", - litellm_router_instance=_windowed_router(_SMALL, _BIG), + ctx=RoutingContext(_windowed_router(_SMALL, _BIG)), complexity_router_config=_tier_config(), ) @@ -14796,7 +14830,7 @@ class TestContextWindowEscalation: """The gate must be invisible for normal traffic: same model, no escalation facts.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=_windowed_router(_SMALL, _BIG), + ctx=RoutingContext(_windowed_router(_SMALL, _BIG)), complexity_router_config=_tier_config(), ) @@ -14815,7 +14849,7 @@ class TestContextWindowEscalation: that fits, which is cheaper than escalating and preserves the classifier's decision.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=_windowed_router(_SMALL, ("mid-model", "openai/gpt-4o-mini", 200000), _BIG), + ctx=RoutingContext(_windowed_router(_SMALL, ("mid-model", "openai/gpt-4o-mini", 200000), _BIG)), complexity_router_config=_tier_config(tiers={"SIMPLE": ["small-model", "mid-model"], "COMPLEX": "big-model"}), ) @@ -14834,24 +14868,26 @@ class TestContextWindowEscalation: smallest resolvable window and escalates past it.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=Router( - model_list=[ - { - "model_name": "mixed-pool", - "litellm_params": {"model": "openai/gpt-3.5-turbo", "mock_response": "ok"}, - "model_info": {"max_input_tokens": 16385}, - }, - { - "model_name": "mixed-pool", - "litellm_params": {"model": "openai/gpt-4o-mini", "mock_response": "ok"}, - "model_info": {"max_input_tokens": 200000}, - }, - { - "model_name": "big-model", - "litellm_params": {"model": "openai/gpt-4o-mini", "mock_response": "ok"}, - "model_info": {"max_input_tokens": 200000}, - }, - ] + ctx=RoutingContext( + Router( + model_list=[ + { + "model_name": "mixed-pool", + "litellm_params": {"model": "openai/gpt-3.5-turbo", "mock_response": "ok"}, + "model_info": {"max_input_tokens": 16385}, + }, + { + "model_name": "mixed-pool", + "litellm_params": {"model": "openai/gpt-4o-mini", "mock_response": "ok"}, + "model_info": {"max_input_tokens": 200000}, + }, + { + "model_name": "big-model", + "litellm_params": {"model": "openai/gpt-4o-mini", "mock_response": "ok"}, + "model_info": {"max_input_tokens": 200000}, + }, + ] + ) ), complexity_router_config=_tier_config(tiers={"SIMPLE": "mixed-pool", "COMPLEX": "big-model"}), ) @@ -14869,7 +14905,7 @@ class TestContextWindowEscalation: length, which the token count can never exceed.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=_windowed_router(_SMALL, _BIG), + ctx=RoutingContext(_windowed_router(_SMALL, _BIG)), complexity_router_config=_tier_config(), ) @@ -14904,7 +14940,7 @@ class TestContextWindowEscalation: when nothing provably fits, the classified tier stands and the client owns overflow.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=_windowed_router(*deployments), + ctx=RoutingContext(_windowed_router(*deployments)), complexity_router_config=_tier_config(tiers=tiers), ) @@ -14934,7 +14970,7 @@ class TestContextWindowEscalation: ) router: Final = ComplexityRouter( model_name="test-router", - litellm_router_instance=_windowed_router(_SMALL, _BIG), + ctx=RoutingContext(_windowed_router(_SMALL, _BIG)), complexity_router_config=config.model_dump(exclude_unset=not serialized, exclude_none=True), ) @@ -14954,7 +14990,7 @@ class TestContextWindowEscalation: dispatches a provably oversized request and the provider 400s anyway.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=_windowed_router(_SMALL, _BIG), + ctx=RoutingContext(_windowed_router(_SMALL, _BIG)), complexity_router_config=_tier_config(), ) @@ -14983,7 +15019,7 @@ class TestContextWindowEscalation: fresh instead of inheriting a pin.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=_windowed_router(_SMALL, _BIG), + ctx=RoutingContext(_windowed_router(_SMALL, _BIG)), complexity_router_config=_tier_config(session_affinity=True), ) @@ -15008,7 +15044,7 @@ class TestContextWindowEscalation: session's own model so the first turn that fits again routes exactly as pinned.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=_windowed_router(_SMALL, _BIG), + ctx=RoutingContext(_windowed_router(_SMALL, _BIG)), complexity_router_config=_tier_config(session_affinity=True), ) @@ -15039,19 +15075,21 @@ class TestContextWindowEscalation: unobserved, cold start samples only among models whose window holds the prompt.""" router = ComplexityRouter( model_name="test-router", - litellm_router_instance=Router( - model_list=[ - { - "model_name": "small-model", - "litellm_params": {"model": "openai/gpt-3.5-turbo", "mock_response": "ok"}, - "model_info": {"max_input_tokens": 16385}, - }, - { - "model_name": "mid-model", - "litellm_params": {"model": "openai/gpt-4o-mini", "mock_response": "ok"}, - "model_info": {"max_input_tokens": 200000}, - }, - ] + ctx=RoutingContext( + Router( + model_list=[ + { + "model_name": "small-model", + "litellm_params": {"model": "openai/gpt-3.5-turbo", "mock_response": "ok"}, + "model_info": {"max_input_tokens": 16385}, + }, + { + "model_name": "mid-model", + "litellm_params": {"model": "openai/gpt-4o-mini", "mock_response": "ok"}, + "model_info": {"max_input_tokens": 200000}, + }, + ] + ) ), complexity_router_config=_tier_config(adaptive=True, tiers={"SIMPLE": ["small-model", "mid-model"]}), ) @@ -15073,15 +15111,17 @@ class TestContextWindowEscalation: (tmp_path / "api-key.json").write_text(json.dumps({"token": "tid=test", "expires_at": int(time.time()) + 3600})) router = ComplexityRouter( model_name="test-router", - litellm_router_instance=Router( - model_list=[ - {"model_name": "cop-pool", "litellm_params": {"model": "github_copilot/gpt-4o"}}, - { - "model_name": "big-model", - "litellm_params": {"model": "openai/gpt-4o-mini", "mock_response": "ok"}, - "model_info": {"max_input_tokens": 200000}, - }, - ] + ctx=RoutingContext( + Router( + model_list=[ + {"model_name": "cop-pool", "litellm_params": {"model": "github_copilot/gpt-4o"}}, + { + "model_name": "big-model", + "litellm_params": {"model": "openai/gpt-4o-mini", "mock_response": "ok"}, + "model_info": {"max_input_tokens": 200000}, + }, + ] + ) ), complexity_router_config=_tier_config(tiers={"SIMPLE": "cop-pool", "COMPLEX": "big-model"}), ) @@ -15187,7 +15227,11 @@ class TestModalityRouting: def _router(mock_router_instance, config, vision_by_model): """vision_by_model: model name -> True/False (deployment model_info) or None (undeclared).""" - def get_model_list(model_name=None): + named: Final = mock_router_instance.registry.return_value.deployments.side_effect + + def deployments(model_name=None, *, source="group", **_): + if source == "named": + return DEFAULT if named is None else named(model_name, source=source) if model_name not in vision_by_model: return [] declared = vision_by_model[model_name] @@ -15199,10 +15243,10 @@ class TestModalityRouting: } ] - mock_router_instance.get_model_list = get_model_list + mock_router_instance.registry.return_value.deployments.side_effect = deployments return ComplexityRouter( model_name="modality-test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) @@ -15314,7 +15358,7 @@ class TestModalityRouting: ] elif path.startswith(("pin_kept", "pin_replacement", "pin_override")): cache: Final = DualCache() - mock_router_instance.cache = cache + mock_router_instance.health.return_value.store = cache config["session_affinity"] = True request_kwargs = {"metadata": {"session_id": "s1"}} if path == "pin_replacement_gated": @@ -15332,11 +15376,10 @@ class TestModalityRouting: config["modality_pin_override"] = path.startswith("pin_override") elif path == "adaptive_pick_rewritten": config["adaptive"] = True - mock_router_instance.model_list = [] - _answer_deployments_named(mock_router_instance) + _answer_deployments_named(mock_router_instance, []) router = self._router(mock_router_instance, config, vision) if path.startswith(("pin_kept", "pin_replacement", "pin_override")): - mock_router_instance.cache.in_memory_cache.set_cache( + mock_router_instance.health().store.in_memory_cache.set_cache( router._get_session_affinity_cache_key("s1", request_kwargs), {"model": "text-cheap", "tier": "SIMPLE"}, ) @@ -15409,7 +15452,9 @@ class TestModalityRouting: @pytest.mark.asyncio async def test_mixed_deployment_group_is_treated_text_only(self, mock_router_instance): - def get_model_list(model_name=None): + def deployments(model_name=None, *, source="group", **_): + if source != "group": + return DEFAULT declared = {"mixed-group": [True, False], "vision-big": [True]}.get(model_name) if declared is None: return [] @@ -15422,10 +15467,10 @@ class TestModalityRouting: for i, accepts in enumerate(declared) ] - mock_router_instance.get_model_list = get_model_list + mock_router_instance.registry.return_value.deployments.side_effect = deployments router = ComplexityRouter( model_name="modality-test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {"SIMPLE": "mixed-group", "COMPLEX": "vision-big"}, "modality_routing": True, @@ -15439,7 +15484,7 @@ class TestModalityRouting: async def test_continuation_turn_screenshot_escalates_past_the_held_model(self, mock_router_instance): """classification_mode user_turn replays the held model on continuation turns; a continuation carrying a screenshot must still be re-placed when that model is text-only.""" - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() config = { "tiers": dict(self.BASE_TIERS), "classification_mode": "user_turn", @@ -15508,7 +15553,7 @@ class TestModalityRouting: async def test_pin_override_serves_the_image_turn_without_repinning(self, mock_router_instance): """The override is for one request: the session keeps the model it was pinned to.""" cache: Final = DualCache() - mock_router_instance.cache = cache + mock_router_instance.health.return_value.store = cache router = self._router( mock_router_instance, { @@ -15542,7 +15587,7 @@ class TestModalityRouting: async def test_pin_override_with_no_capable_model_rejects_and_keeps_the_pin(self, mock_router_instance): """The clear 400 replaces the provider's, and a rejected turn must not cost the session its pin.""" cache: Final = DualCache() - mock_router_instance.cache = cache + mock_router_instance.health.return_value.store = cache router = self._router( mock_router_instance, { @@ -16290,7 +16335,7 @@ class TestTierHealthFailover: ): """ids_by_model: model group -> deployment ids the router knows. - The fake mirrors the real async_get_healthy_deployments contract, including how it says + The fake mirrors the real select(kind="healthy") contract, including how it says no: BadRequestError for a group with no deployment at all, RouterRateLimitError when every deployment is filtered out (cooling, admin-paused, or excluded by a request-scoped policy such as tags, team scoping or access groups), a per-model exception via raises_for (the @@ -16303,8 +16348,16 @@ class TestTierHealthFailover: probed_kwargs = [] probed_prompts = [] - async def get_healthy_deployments( - model, request_kwargs, messages=None, input=None, parent_otel_span=None, health_check_probe=False + async def select( + model, + request_kwargs, + *, + kind, + messages=None, + input=None, + specific_deployment=False, + parent_otel_span=None, + health_check_probe=False, ): probed_kwargs.append(request_kwargs) probed_prompts.append((messages, input)) @@ -16326,13 +16379,13 @@ class TestTierHealthFailover: ) return healthy - mock_router_instance.async_get_healthy_deployments = get_healthy_deployments + mock_router_instance.select = select mock_router_instance.probed_kwargs = probed_kwargs mock_router_instance.probed_prompts = probed_prompts - mock_router_instance.cache = DualCache() + mock_router_instance.health.return_value.store = DualCache() return ComplexityRouter( model_name="health-test-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) @@ -16357,7 +16410,7 @@ class TestTierHealthFailover: ) # Seed the pin onto the dead group directly so the replay path is exercised. key = router._get_session_affinity_cache_key("sess-dead", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-a", "tier": "SIMPLE"}, ttl=600 ) result = await router.async_pre_routing_hook( @@ -16422,7 +16475,7 @@ class TestTierHealthFailover: ) pinned = "only" if tiers else "dead-a" key = router._get_session_affinity_cache_key("sess-open", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": pinned, "tier": "SIMPLE"}, ttl=600 ) result = await router.async_pre_routing_hook( @@ -16452,7 +16505,7 @@ class TestTierHealthFailover: request_kwargs={"metadata": {"session_id": session_id}}, messages=self.SIMPLE_MESSAGE, ) - return await router.litellm_router_instance.cache.async_get_cache( + return await router.ctx.health().store.async_get_cache( key=router._get_session_affinity_cache_key(session_id, {}) ) @@ -16477,7 +16530,7 @@ class TestTierHealthFailover: messages=[{"role": "user", "content": TITLE_ASK}], ) assert result.routing_decision["cause"] in ("housekeeping", "health_failover") - stored = await router.litellm_router_instance.cache.async_get_cache( + stored = await router.ctx.health().store.async_get_cache( key=router._get_session_affinity_cache_key(session_id, {}) ) assert stored is None @@ -16502,7 +16555,7 @@ class TestTierHealthFailover: blocked=("id-b1",), ) key = router._get_session_affinity_cache_key("sess-paused", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-a", "tier": "SIMPLE"}, ttl=600 ) results = [ @@ -16544,7 +16597,7 @@ class TestTierHealthFailover: cooling=("id-a1",), ) key = router._get_session_affinity_cache_key("sess-adaptive", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-a", "tier": "SIMPLE"}, ttl=600 ) request_kwargs = {"metadata": {"session_id": "sess-adaptive", "adaptive_router_chosen_model": "dead-a"}} @@ -16560,7 +16613,9 @@ class TestTierHealthFailover: modality gate chose: serving a cooling vision model beats a hard 400.""" vision_by_model = {"dead-vision": True, "live-text": False} - def get_model_list(model_name=None): + def deployments(model_name=None, *, source="group", **_): + if source != "group": + return DEFAULT if model_name not in vision_by_model: return [] return [ @@ -16571,7 +16626,7 @@ class TestTierHealthFailover: } ] - mock_router_instance.get_model_list = get_model_list + mock_router_instance.registry.return_value.deployments.side_effect = deployments router = self._router( mock_router_instance, { @@ -16588,7 +16643,7 @@ class TestTierHealthFailover: cooling=("id-v1",), ) key = router._get_session_affinity_cache_key("sess-image", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-vision", "tier": "SIMPLE"}, ttl=600 ) image_message = [ @@ -16626,7 +16681,7 @@ class TestTierHealthFailover: router_instance.cache = DualCache() router = ComplexityRouter( model_name="health-window-router", - litellm_router_instance=router_instance, + ctx=RoutingContext(router_instance), complexity_router_config={ "tiers": {name: list(pool) for name in ("SIMPLE", "MEDIUM", "COMPLEX", "REASONING")}, "session_affinity": True, @@ -16634,7 +16689,7 @@ class TestTierHealthFailover: }, ) key = router._get_session_affinity_cache_key("sess-window", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-big", "tier": "SIMPLE"}, ttl=600 ) results = [ @@ -16680,7 +16735,7 @@ class TestTierHealthFailover: {"live-b": ["id-b1"]}, ) key = router._get_session_affinity_cache_key("sess-unknown", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-a", "tier": "SIMPLE"}, ttl=600 ) result = await router.async_pre_routing_hook( @@ -16709,7 +16764,7 @@ class TestTierHealthFailover: excluded=("id-b1",), ) key = router._get_session_affinity_cache_key("sess-tagged", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-a", "tier": "SIMPLE"}, ttl=600 ) results = [ @@ -16731,7 +16786,7 @@ class TestTierHealthFailover: cooling=("id-a1",), ) key = router._get_session_affinity_cache_key("sess-kwargs", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-a", "tier": "SIMPLE"}, ttl=600 ) request_kwargs = { @@ -16745,7 +16800,7 @@ class TestTierHealthFailover: assert result.model == "live-b" assert request_kwargs["_target_order"] == 1 assert request_kwargs["_excluded_deployment_ids"] == ["id-x"] - assert all(probed is not request_kwargs for probed in router.litellm_router_instance.probed_kwargs) + assert all(probed is not request_kwargs for probed in mock_router_instance.probed_kwargs) @pytest.mark.asyncio async def test_a_peer_whose_every_deployment_is_over_its_rpm_is_not_a_failover_target(self, mock_router_instance): @@ -16769,7 +16824,7 @@ class TestTierHealthFailover: raises_for={"rpm-full-b": RouterRateLimitErrorBasic(model="rpm-full-b")}, ) key = router._get_session_affinity_cache_key("sess-rpm", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-a", "tier": "SIMPLE"}, ttl=600 ) results = [ @@ -16792,7 +16847,7 @@ class TestTierHealthFailover: cooling=("id-a1",), ) key = router._get_session_affinity_cache_key("sess-input", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-a", "tier": "SIMPLE"}, ttl=600 ) result = await router.async_pre_routing_hook( @@ -16803,7 +16858,7 @@ class TestTierHealthFailover: assert result.model == "live-b" assert any( probed_input == "summarize this document for me" - for _, probed_input in router.litellm_router_instance.probed_prompts + for _, probed_input in mock_router_instance.probed_prompts ), "the eligibility probe must forward `input` to the owner" @pytest.mark.asyncio @@ -16842,7 +16897,7 @@ class TestTierHealthFailover: sessions: Final = tuple(f"sess-exhausted-{sample}" for sample in range(20)) await asyncio.gather( *( - router.litellm_router_instance.cache.async_set_cache( + router.ctx.health().store.async_set_cache( key=router._get_session_affinity_cache_key(session_id, {}), value={"model": "dead-a", "tier": "SIMPLE"}, ttl=600, @@ -16889,7 +16944,7 @@ class TestTierHealthFailover: cooling=("id-a1",), ) key = router._get_session_affinity_cache_key("sess-missing", {}) - await router.litellm_router_instance.cache.async_set_cache( + await router.ctx.health().store.async_set_cache( key=key, value={"model": "dead-a", "tier": "SIMPLE"}, ttl=600 ) results = [ @@ -16912,7 +16967,9 @@ class TestClassifierVision: @staticmethod def _router(mock_router_instance, *, vision, classifier_declares_vision=True, classifier_type="llm", **extra): - def get_model_list(model_name=None): + def deployments(model_name=None, *, source="group", **_): + if source != "group": + return DEFAULT if model_name != "clf": return [{"model_name": model_name, "litellm_params": {"model": "openai/gpt-4o"}}] declared = classifier_declares_vision @@ -16924,11 +16981,11 @@ class TestClassifierVision: } ] - mock_router_instance.get_model_list = get_model_list + mock_router_instance.registry.return_value.deployments.side_effect = deployments classifier_llm_config = {"model": "clf", "circuit_breaker_enabled": False} return ComplexityRouter( model_name="vision-classifier-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "classifier_type": classifier_type, "classifier_llm_config": ( @@ -17569,7 +17626,7 @@ class TestMaxTokensFromTierModel: async def test_a_default_model_landing_with_no_tier_still_gets_its_ceiling(self): strategy = ComplexityRouter( model_name="smart-router", - litellm_router_instance=self._router(), + ctx=RoutingContext(self._router()), complexity_router_config={"tiers": {"SIMPLE": "small"}, "default_model": "big"}, ) @@ -17783,7 +17840,7 @@ class TestNonReasoningTier: } return ComplexityRouter( model_name="test-non-reasoning-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config=config, ) @@ -17923,7 +17980,7 @@ class TestNonReasoningTier: """The four-class artifact's 1-based index must keep mapping onto SIMPLE..REASONING.""" router: Final = ComplexityRouter( model_name="v2-router", - litellm_router_instance=mock_router_instance, + ctx=RoutingContext(mock_router_instance), complexity_router_config={ "tiers": {k: v for k, v in NON_REASONING_TIERS.items() if k != "NON_REASONING"}, "classifier_type": "heuristic_v2", @@ -17946,7 +18003,7 @@ class TestNonReasoningTier: async def test_custom_classifier_infers_tiers_and_routes_fallback(verdict: str | None, expected: str) -> None: router: Final = ComplexityRouter( model_name="auto", - litellm_router_instance=litellm.Router(model_list=[]), + ctx=RoutingContext(litellm.Router(model_list=[])), default_model="backup", complexity_router_config={ "classifier_type": "custom", @@ -17966,7 +18023,7 @@ async def test_custom_classifier_infers_tiers_and_routes_fallback(verdict: str | async def test_custom_classifier_can_extend_builtin_tiers() -> None: router: Final = ComplexityRouter( model_name="auto", - litellm_router_instance=litellm.Router(model_list=[]), + ctx=RoutingContext(litellm.Router(model_list=[])), default_model="backup", complexity_router_config={ "classifier_type": "custom", @@ -18000,7 +18057,7 @@ def test_inferred_custom_tiers_reject_unusable_routes(tiers: dict[str, str | lis async def test_defined_custom_tiers_allow_default_model_fallback(explicit_fallback: str | None) -> None: router: Final = ComplexityRouter( model_name="auto", - litellm_router_instance=litellm.Router(model_list=[]), + ctx=RoutingContext(litellm.Router(model_list=[])), default_model="backup", complexity_router_config={ "classifier_type": "custom", @@ -18050,7 +18107,7 @@ async def test_custom_classifier_failure_preserves_plan_floor_and_direct_default ) router: Final = ComplexityRouter( model_name="auto", - litellm_router_instance=litellm.Router(model_list=[]), + ctx=RoutingContext(litellm.Router(model_list=[])), default_model=default_model, complexity_router_config={ "classifier_type": "custom", diff --git a/tests/unit/router_strategy/test_lar1_routing.py b/tests/unit/router_strategy/test_lar1_routing.py index 4710bbb6896..64cd84fd4ff 100644 --- a/tests/unit/router_strategy/test_lar1_routing.py +++ b/tests/unit/router_strategy/test_lar1_routing.py @@ -56,7 +56,7 @@ def _create_test_router(): @pytest.mark.asyncio async def test_low_confidence_routes_to_cloud_smart(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) result = await strategy.async_get_available_deployment( model="agent-router", @@ -68,7 +68,7 @@ async def test_low_confidence_routes_to_cloud_smart(): @pytest.mark.asyncio async def test_high_confidence_routes_to_deep(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) result = await strategy.async_get_available_deployment( model="agent-router", @@ -80,7 +80,7 @@ async def test_high_confidence_routes_to_deep(): @pytest.mark.asyncio async def test_unverified_evidence_fallback(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) result = await strategy.async_get_available_deployment( model="agent-router", @@ -97,7 +97,7 @@ async def test_unverified_evidence_fallback(): async def test_custom_thresholds(): router = _create_test_router() custom_strategy = LAR1RoutingStrategy( - router, + router._core_ctx, thresholds={"low": 0.1, "medium": 0.3, "high": 0.9}, ) @@ -111,7 +111,7 @@ async def test_custom_thresholds(): @pytest.mark.asyncio async def test_mem_time_routes_to_cloud_fast(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) result = await strategy.async_get_available_deployment( model="agent-router", @@ -127,7 +127,7 @@ async def test_mem_time_routes_to_cloud_fast(): @pytest.mark.asyncio async def test_invalid_confidence_falls_back_to_local(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) result = await strategy.async_get_available_deployment( model="agent-router", @@ -141,7 +141,7 @@ async def test_invalid_confidence_falls_back_to_local(): @pytest.mark.asyncio async def test_no_metadata_defaults_to_local(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) result = await strategy.async_get_available_deployment( model="agent-router", @@ -185,7 +185,7 @@ async def test_router_init_lar1_default_thresholds(): @pytest.mark.asyncio async def test_mid_confidence_routes_to_cloud_fast(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) result = await strategy.async_get_available_deployment( model="agent-router", @@ -205,7 +205,7 @@ async def test_no_router_returns_none(): @pytest.mark.asyncio async def test_request_kwargs_none_uses_defaults(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) result = await strategy.async_get_available_deployment( model="agent-router", @@ -217,7 +217,7 @@ async def test_request_kwargs_none_uses_defaults(): @pytest.mark.asyncio async def test_invalid_lar1_metadata_type_uses_defaults(caplog): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) with caplog.at_level("WARNING"): result = await strategy.async_get_available_deployment( @@ -232,7 +232,7 @@ async def test_invalid_lar1_metadata_type_uses_defaults(caplog): @pytest.mark.asyncio async def test_confirmed_evidence_routes_by_confidence(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) result = await strategy.async_get_available_deployment( model="agent-router", @@ -248,8 +248,8 @@ async def test_confirmed_evidence_routes_by_confidence(): @pytest.mark.asyncio async def test_empty_healthy_deployments_returns_none(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) - router.async_get_healthy_deployments = AsyncMock(return_value=[]) + strategy = LAR1RoutingStrategy(router._core_ctx) + router.select = AsyncMock(return_value=[]) result = await strategy.async_get_available_deployment( model="agent-router", @@ -265,8 +265,8 @@ async def test_specific_deployment_dict_short_circuit(): "litellm_params": {"model": "ollama/mythos"}, } router = _create_test_router() - strategy = LAR1RoutingStrategy(router) - router.async_get_healthy_deployments = AsyncMock(return_value=deployment) + strategy = LAR1RoutingStrategy(router._core_ctx) + router.select = AsyncMock(return_value=deployment) result = await strategy.async_get_available_deployment( model="agent-router", @@ -279,8 +279,8 @@ async def test_specific_deployment_dict_short_circuit(): @pytest.mark.asyncio async def test_non_dict_healthy_deployment_returns_none(): router = _create_test_router() - strategy = LAR1RoutingStrategy(router) - router.async_get_healthy_deployments = AsyncMock(return_value=[None]) + strategy = LAR1RoutingStrategy(router._core_ctx) + router.select = AsyncMock(return_value=[None]) result = await strategy.async_get_available_deployment( model="agent-router", @@ -398,7 +398,7 @@ async def test_update_settings_routing_strategy_args_relinks_lar1(): def test_apply_lar1_routing_strategy_wires_custom_selector(): router = Router(model_list=_model_list(), routing_strategy="simple-shuffle") - apply_lar1_routing_strategy(router, {"confidence_threshold_high": 0.9}) + apply_lar1_routing_strategy(router._core_ctx, {"confidence_threshold_high": 0.9}) assert router.routing_strategy == "lar1" with pytest.raises(NotImplementedError, match="async routing"): router.get_available_deployment(model="agent-router") @@ -409,7 +409,7 @@ def test_apply_lar1_invalid_thresholds_leaves_router_unchanged(): with pytest.raises(ValueError, match="LAR-1 thresholds must satisfy"): apply_lar1_routing_strategy( - router, + router._core_ctx, { "confidence_threshold_low": 0.9, "confidence_threshold_medium": 0.5, @@ -448,7 +448,7 @@ async def test_missing_target_type_falls_back_with_warning(caplog): } ] ) - strategy = LAR1RoutingStrategy(router) + strategy = LAR1RoutingStrategy(router._core_ctx) with caplog.at_level("WARNING"): result = await strategy.async_get_available_deployment( diff --git a/tests/unit/router_strategy/test_litellm_encoder.py b/tests/unit/router_strategy/test_litellm_encoder.py index 46187f52adb..d950025afdb 100644 --- a/tests/unit/router_strategy/test_litellm_encoder.py +++ b/tests/unit/router_strategy/test_litellm_encoder.py @@ -8,6 +8,7 @@ import pytest import litellm from litellm.constants import DEFAULT_AUTO_ROUTER_MAX_INPUT_CHARS +from litellm.router_api import RoutingContext if sys.version_info >= (3, 14): pytest.skip("The semantic-router extra excludes Python 3.14", allow_module_level=True) @@ -39,7 +40,7 @@ class RecordingRouter: def _encoder(router: RecordingRouter, **kwargs: Any) -> LiteLLMRouterEncoder: return LiteLLMRouterEncoder( - litellm_router_instance=router, # pyright: ignore[reportArgumentType] # test double stands in for Router + ctx=RoutingContext(router), # pyright: ignore[reportArgumentType] # test double stands in for Router model_name="text-embedding-3-small", **kwargs, ) diff --git a/tests/unit/router_strategy/test_llm_v2.py b/tests/unit/router_strategy/test_llm_v2.py index 8c1e9e48661..993da777c66 100644 --- a/tests/unit/router_strategy/test_llm_v2.py +++ b/tests/unit/router_strategy/test_llm_v2.py @@ -9,6 +9,7 @@ from pydantic import ValidationError import litellm from litellm import ModelResponse, Router from litellm.caching.dual_cache import DualCache +from litellm.router_api import RoutingContext from litellm.router_strategy.auto_router.auto_router_model_naming import strategy_router_dependencies from litellm.router_strategy.complexity_router.complexity_router import ComplexityRouter from litellm.router_strategy.complexity_router.config import ComplexityRouterConfig, ComplexityTier @@ -90,7 +91,7 @@ def _router(content: str, config: ComplexityRouterConfig | None = None) -> tuple client.acompletion = AsyncMock(return_value=_response(content)) router: Final = ComplexityRouter( model_name="v2-router", - litellm_router_instance=client, + ctx=RoutingContext(client), complexity_router_config=(config or _config()).model_dump(), derive_savings_baseline=False, ) @@ -570,7 +571,7 @@ def test_response_schema_requires_both_model_forecasts() -> None: @pytest.mark.asyncio async def test_user_turn_mode_reuses_forecast_until_a_new_user_requirement() -> None: router, client = _router(_verdict().model_dump_json(), _config(classification_mode="user_turn")) - client.cache = DualCache() + client.health.return_value.store = DualCache() initial: Final = [{"role": "user", "content": "Fix nested behavior"}] first: Final = await router.async_pre_routing_hook( model="v2-router", messages=initial, request_kwargs={"metadata": {"session_id": "v2-task"}} @@ -670,7 +671,7 @@ def test_v2_judge_is_a_declared_dependency_for_authorization() -> None: async def test_v2_forwards_inline_images_only_when_vision_is_enabled(vision_enabled: bool) -> None: config: Final = _config(classifier_llm_config={"model": "judge", "vision": {"enabled": vision_enabled}}) router, client = _router(_verdict().model_dump_json(), config) - client.get_model_list.return_value = [ + client.registry.return_value.deployments.return_value = [ {"model_name": "judge", "litellm_params": {"model": "judge"}, "model_info": {"supports_vision": True}} ] image: Final = {"type": "image_url", "image_url": {"url": "data:image/png;base64,aGk="}} diff --git a/tests/unit/router_strategy/test_quality_router.py b/tests/unit/router_strategy/test_quality_router.py index 4e87652f8b3..249e5254412 100644 --- a/tests/unit/router_strategy/test_quality_router.py +++ b/tests/unit/router_strategy/test_quality_router.py @@ -15,6 +15,7 @@ from unittest.mock import MagicMock import pytest +from litellm.router_api import RoutingContext from litellm.router_strategy.quality_router.config import ( DEFAULT_COMPLEXITY_TO_QUALITY, ) @@ -74,7 +75,7 @@ def four_tier_model_list() -> List[Dict[str, Any]]: def mock_router(four_tier_model_list): """A MagicMock router preloaded with the four-tier model list.""" router = MagicMock() - router.model_list = four_tier_model_list + router.registry.return_value.all.return_value = four_tier_model_list return router @@ -87,7 +88,7 @@ def quality_router(mock_router) -> QualityRouter: } return QualityRouter( model_name="quality-router-test", - litellm_router_instance=mock_router, + ctx=RoutingContext(mock_router), default_model="haiku", quality_router_config=config, ) @@ -109,11 +110,11 @@ class TestTierIndex: # Add a model the config doesn't list — it should be ignored. extra = _make_model_list([{"model_name": "ghost", "quality_tier": 5}]) router = MagicMock() - router.model_list = four_tier_model_list + extra + router.registry.return_value.all.return_value = four_tier_model_list + extra qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="haiku", quality_router_config={ "available_models": ["haiku", "sonnet", "opus", "opus-next"] @@ -132,14 +133,14 @@ class TestTierIndex: ] ) router = MagicMock() - router.model_list = ml + router.registry.return_value.all.return_value = ml # Construction succeeds (tier index is lazy); the error surfaces on # first use so the router entry doesn't have to appear after all of # its referenced models in config.yaml. qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="haiku", quality_router_config={"available_models": ["haiku", "sonnet"]}, ) @@ -163,11 +164,11 @@ class TestResolveModelForQualityTier: {"model_name": "opus-next", "quality_tier": 4}, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="haiku", quality_router_config={"available_models": ["haiku", "opus", "opus-next"]}, ) @@ -179,11 +180,11 @@ class TestResolveModelForQualityTier: # rounds DOWN to the closest lower tier — tier 1. spec = [{"model_name": "haiku", "quality_tier": 1}] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="emergency-default", quality_router_config={"available_models": ["haiku"]}, ) @@ -197,11 +198,11 @@ class TestResolveModelForQualityTier: {"model_name": "sonnet", "quality_tier": 2}, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="emergency-default", quality_router_config={"available_models": ["haiku", "sonnet"]}, ) @@ -215,11 +216,11 @@ class TestResolveModelForQualityTier: {"model_name": "opus", "quality_tier": 3}, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="emergency-default", quality_router_config={"available_models": ["haiku", "opus"]}, ) @@ -244,11 +245,11 @@ class TestRoutingPreferencesValidation: } ] router = MagicMock() - router.model_list = ml + router.registry.return_value.all.return_value = ml qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="haiku", quality_router_config={"available_models": ["haiku"]}, ) @@ -266,18 +267,18 @@ class TestConfigOrderingIndependence: # appears before its target deployments). The tier index must not be # built eagerly — it's deferred until first use. router = MagicMock() - router.model_list = [] # <- targets haven't been added yet + router.registry.return_value.all.return_value = [] # <- targets haven't been added yet qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="haiku", quality_router_config={"available_models": ["haiku", "sonnet", "opus"]}, ) # Now the targets come online. This mirrors the incremental add by # `Router._create_deployment`. - router.model_list = _make_model_list( + router.registry.return_value.all.return_value = _make_model_list( [ {"model_name": "haiku", "quality_tier": 1}, {"model_name": "sonnet", "quality_tier": 2}, @@ -489,10 +490,10 @@ def keyword_router(): }, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) return QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="default-haiku", quality_router_config={ "available_models": [ @@ -547,10 +548,10 @@ class TestKeywordOverride: }, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="cheap", quality_router_config={"available_models": ["expensive", "cheap"]}, ) @@ -574,10 +575,10 @@ class TestKeywordOverride: }, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="no-price", quality_router_config={"available_models": ["no-price", "with-price"]}, ) @@ -633,10 +634,10 @@ class TestKeywordOverride: }, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="ordered-tier2", quality_router_config={ "available_models": ["ordered-tier2", "implicit-tier3"] @@ -663,10 +664,10 @@ class TestKeywordOverride: }, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="default-tier3", quality_router_config={"available_models": ["preferred", "default-tier3"]}, ) @@ -691,10 +692,10 @@ class TestKeywordOverride: }, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="cheap-default", quality_router_config={ "available_models": ["expensive-but-preferred", "cheap-default"] @@ -719,10 +720,10 @@ class TestKeywordOverride: }, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="first", quality_router_config={"available_models": ["first", "second"]}, ) @@ -756,10 +757,10 @@ class TestKeywordOverride: }, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="low-tier", quality_router_config={ "available_models": [ @@ -787,10 +788,10 @@ class TestKeywordOverride: }, ] router = MagicMock() - router.model_list = _make_model_list(spec) + router.registry.return_value.all.return_value = _make_model_list(spec) qr = QualityRouter( model_name="qr", - litellm_router_instance=router, + ctx=RoutingContext(router), default_model="default-pick", quality_router_config={ "available_models": ["default-pick", "preferred-pick"] diff --git a/tests/unit/router_strategy/test_router_routing_groups.py b/tests/unit/router_strategy/test_router_routing_groups.py index 7235333f59f..6b5c052618b 100644 --- a/tests/unit/router_strategy/test_router_routing_groups.py +++ b/tests/unit/router_strategy/test_router_routing_groups.py @@ -20,6 +20,7 @@ import litellm from litellm import Router from litellm.caching.redis_cache import RedisPipelineIncrementOperation from litellm.integrations.custom_logger import CustomLogger +from litellm.router_api import RoutingContext from litellm.types.router import DeploymentTypedDict, FallbackAccessCheck, RoutingGroup, RoutingStrategy from litellm.utils import Rules, function_setup @@ -1567,7 +1568,7 @@ async def _call_and_get_cooldowns(router, model): messages=[{"role": "user", "content": "hi"}], mock_response="litellm.RateLimitError", ) - return await async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) + return await async_get_cooldown_deployments(ctx=router._core_ctx, parent_otel_span=None) @pytest.mark.asyncio @@ -2060,7 +2061,7 @@ async def test_priority_group_preserves_responses_continuity_on_a_backup() -> No def _recording_fallback_gate(allowed: frozenset[str], checked: list[str]) -> FallbackAccessCheck: - async def check(*, model: str, request_kwargs: Mapping[str, object], llm_router: Router) -> bool: + async def check(*, model: str, request_kwargs: Mapping[str, object], ctx: RoutingContext) -> bool: checked.append(model) return model in allowed diff --git a/tests/unit/router_strategy/test_router_tag_regex_routing.py b/tests/unit/router_strategy/test_router_tag_regex_routing.py index 46e79a1b8c8..4f80cc54d3f 100644 --- a/tests/unit/router_strategy/test_router_tag_regex_routing.py +++ b/tests/unit/router_strategy/test_router_tag_regex_routing.py @@ -9,9 +9,8 @@ existing tag-based routing. import pytest - -from unittest.mock import MagicMock - +from litellm import Router +from litellm.router_api import RoutingContext from litellm.router_strategy import tag_based_routing from litellm.router_strategy.tag_based_routing import get_deployments_for_tag @@ -105,20 +104,17 @@ REGULAR_DEPLOYMENT = { ALL_DEPLOYMENTS = [CLAUDE_CODE_DEPLOYMENT, REGULAR_DEPLOYMENT] -def _make_router_mock(enable_tag_filtering=True, match_any=True): - mock = MagicMock() - mock.enable_tag_filtering = enable_tag_filtering - mock.tag_filtering_match_any = match_any - mock.tag_routing_prefix = "" - return mock +def _make_routing_ctx(enable_tag_filtering=True, match_any=True) -> RoutingContext: + """The candidates come in as healthy_deployments, so the router itself configures none.""" + return Router(model_list=[], enable_tag_filtering=enable_tag_filtering, tag_filtering_match_any=match_any)._core_ctx @pytest.mark.asyncio async def test_claude_code_ua_routes_to_cc_deployment(): """claude-code/x.y.z UA → claude-code-deployment via tag_regex.""" - router = _make_router_mock() + ctx = _make_routing_ctx() result = await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="claude-sonnet", healthy_deployments=ALL_DEPLOYMENTS, request_deployments=ALL_DEPLOYMENTS, @@ -131,9 +127,9 @@ async def test_claude_code_ua_routes_to_cc_deployment(): @pytest.mark.asyncio async def test_regular_ua_routes_to_default_deployment(): """Mozilla UA → regular-deployment via default tag fallback.""" - router = _make_router_mock() + ctx = _make_routing_ctx() result = await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="claude-sonnet", healthy_deployments=ALL_DEPLOYMENTS, request_deployments=ALL_DEPLOYMENTS, @@ -146,9 +142,9 @@ async def test_regular_ua_routes_to_default_deployment(): @pytest.mark.asyncio async def test_no_ua_routes_to_default_deployment(): """No User-Agent → default deployment.""" - router = _make_router_mock() + ctx = _make_routing_ctx() result = await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="claude-sonnet", healthy_deployments=ALL_DEPLOYMENTS, request_deployments=ALL_DEPLOYMENTS, @@ -161,10 +157,10 @@ async def test_no_ua_routes_to_default_deployment(): @pytest.mark.asyncio async def test_tag_routing_metadata_written_for_regex_match(): """tag_routing metadata block is populated when regex matches.""" - router = _make_router_mock() + ctx = _make_routing_ctx() metadata: dict = {"user_agent": "claude-code/2.0.0-beta.1"} await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="claude-sonnet", healthy_deployments=ALL_DEPLOYMENTS, request_deployments=ALL_DEPLOYMENTS, @@ -180,9 +176,9 @@ async def test_tag_routing_metadata_written_for_regex_match(): @pytest.mark.asyncio async def test_tag_filtering_disabled_returns_all_deployments(): """When enable_tag_filtering is False, all deployments returned regardless of UA.""" - router = _make_router_mock(enable_tag_filtering=False) + ctx = _make_routing_ctx(enable_tag_filtering=False) result = await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="claude-sonnet", healthy_deployments=ALL_DEPLOYMENTS, request_deployments=ALL_DEPLOYMENTS, @@ -199,9 +195,9 @@ async def test_empty_healthy_deployments_with_request_tags_returns_empty_list(): Tag-based filtering runs only against non-empty healthy_deployments; an empty list is returned unchanged for the router's standard handling. """ - router = _make_router_mock() + ctx = _make_routing_ctx() result = await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="gpt-5.2", healthy_deployments=[], request_deployments=[], @@ -225,13 +221,13 @@ async def test_explicit_tag_match_takes_precedence_over_regex(): }, "model_info": {"id": "both-deployment"}, } - router = _make_router_mock() + ctx = _make_routing_ctx() metadata: dict = { "tags": ["premium"], "user_agent": "claude-code/1.0", } result = await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="claude-sonnet", healthy_deployments=[deployment_with_both], request_deployments=[deployment_with_both], @@ -269,11 +265,11 @@ async def test_user_agent_present_no_tag_regex_deployments_does_not_raise(): "model_info": {"id": "free-deployment"}, }, ] - router = _make_router_mock() + ctx = _make_routing_ctx() # The request has a User-Agent (as all proxy requests do) but NO tags and # neither deployment has tag_regex — must not raise, must return all. result = await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="gpt-4", healthy_deployments=plain_tag_only_deployments, request_deployments=plain_tag_only_deployments, @@ -307,10 +303,10 @@ async def test_tag_routing_metadata_not_overwritten_for_multiple_matches(): }, "model_info": {"id": "cc-deployment-b"}, } - router = _make_router_mock() + ctx = _make_routing_ctx() metadata: dict = {"user_agent": "claude-code/1.0"} result = await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="claude-sonnet", healthy_deployments=[deployment_a, deployment_b], request_deployments=[deployment_a, deployment_b], @@ -357,13 +353,13 @@ async def test_match_any_false_strict_tag_check_blocks_regex_fallback(): # match_any=False: req_set must be a subset of dep_set. # Request has "vip" which is NOT in ["premium"], so tag check fails. # Even though UA matches tag_regex, the deployment must NOT be selected. - router = _make_router_mock(enable_tag_filtering=True, match_any=False) + ctx = _make_routing_ctx(enable_tag_filtering=True, match_any=False) metadata: dict = { "tags": ["vip"], # "vip" not in deployment tags → strict check fails "user_agent": "claude-code/1.0", } result = await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="claude-sonnet", healthy_deployments=[deployment_strict, default_deployment], request_deployments=[deployment_strict, default_deployment], @@ -392,9 +388,9 @@ async def test_match_any_false_regex_only_deployment_still_matches(): }, "model_info": {"id": "regex-only-deployment"}, } - router = _make_router_mock(enable_tag_filtering=True, match_any=False) + ctx = _make_routing_ctx(enable_tag_filtering=True, match_any=False) result = await get_deployments_for_tag( - llm_router_instance=router, + ctx=ctx, model="claude-sonnet", healthy_deployments=[regex_only_deployment], request_deployments=[regex_only_deployment], diff --git a/tests/unit/router_strategy/test_router_tag_routing.py b/tests/unit/router_strategy/test_router_tag_routing.py index 26d04be7e25..28192704bd1 100644 --- a/tests/unit/router_strategy/test_router_tag_routing.py +++ b/tests/unit/router_strategy/test_router_tag_routing.py @@ -1168,31 +1168,29 @@ async def test_request_level_enable_tag_filtering_false_cannot_disable_global(): # --- model_info.enable_tag_filtering per-chain override --- -class _FakeRouterForChainOverride: - def __init__(self, all_deployments): - self._all_deployments = all_deployments - - def get_all_deployments(self, model_name): - return self._all_deployments +def _chain_override_router(*model_infos: dict) -> litellm.Router: + return litellm.Router( + model_list=[ + {"model_name": "gpt-4", "litellm_params": {"model": "gpt-4"}, "model_info": {"id": f"gpt-4-{i}", **info}} + for i, info in enumerate(model_infos) + ] + ) def test_chain_tag_filtering_override_reads_any_member(): from litellm.router_strategy.tag_based_routing import _chain_tag_filtering_override - deployments = [ - {"model_info": {}}, - {"model_info": {"enable_tag_filtering": False}}, - ] - router = _FakeRouterForChainOverride(deployments) - assert _chain_tag_filtering_override(router, "gpt-4", deployments) is False + router = _chain_override_router({}, {"enable_tag_filtering": False}) + deployments = router.registry().deployments("gpt-4", source="all") + assert _chain_tag_filtering_override(router._core_ctx, "gpt-4", deployments) is False def test_chain_tag_filtering_override_none_when_unset_anywhere(): from litellm.router_strategy.tag_based_routing import _chain_tag_filtering_override - deployments = [{"model_info": {}}, {}] - router = _FakeRouterForChainOverride(deployments) - assert _chain_tag_filtering_override(router, "gpt-4", deployments) is None + router = _chain_override_router({}, {}) + deployments = router.registry().deployments("gpt-4", source="all") + assert _chain_tag_filtering_override(router._core_ctx, "gpt-4", deployments) is None def test_chain_tag_filtering_override_survives_the_overriding_member_going_unhealthy(): @@ -1203,27 +1201,28 @@ def test_chain_tag_filtering_override_survives_the_overriding_member_going_unhea # the one deployment that carries the group's only explicit override. from litellm.router_strategy.tag_based_routing import _chain_tag_filtering_override - all_deployments = [ - {"model_info": {"enable_tag_filtering": True}}, - {"model_info": {}}, - ] - router = _FakeRouterForChainOverride(all_deployments) + router = _chain_override_router({"enable_tag_filtering": True}, {}) + all_deployments = router.registry().deployments("gpt-4", source="all") # The overriding deployment (index 0) is cooled down and absent from # healthy_deployments -- the override must still be found via the full-group # lookup, not silently lost. healthy_deployments = [all_deployments[1]] - assert _chain_tag_filtering_override(router, "gpt-4", healthy_deployments) is True + assert _chain_tag_filtering_override(router._core_ctx, "gpt-4", healthy_deployments) is True def test_chain_tag_filtering_override_falls_back_to_healthy_deployments_on_lookup_error(): from litellm.router_strategy.tag_based_routing import _chain_tag_filtering_override - class _BrokenRouter: - def get_all_deployments(self, model_name): + class _BrokenRegistry: + def deployments(self, model_name, *, source): raise RuntimeError("model group not found") + class _BrokenCtx: + def registry(self): + return _BrokenRegistry() + healthy_deployments = [{"model_info": {"enable_tag_filtering": False}}] - assert _chain_tag_filtering_override(_BrokenRouter(), "gpt-4", healthy_deployments) is False + assert _chain_tag_filtering_override(_BrokenCtx(), "gpt-4", healthy_deployments) is False @pytest.mark.asyncio() @@ -2754,14 +2753,14 @@ def test_tag_known_to_group_true_for_real_tag(): from litellm.router_strategy.tag_based_routing import _tag_known_to_group router = _quality_high_cost_low_router() - assert _tag_known_to_group(router, "gpt-4", ["quality:high"], frozenset()) is True + assert _tag_known_to_group(router._core_ctx, "gpt-4", ["quality:high"], frozenset()) is True def test_tag_known_to_group_false_for_foreign_tag(): from litellm.router_strategy.tag_based_routing import _tag_known_to_group router = _quality_high_cost_low_router() - assert _tag_known_to_group(router, "gpt-4", ["llm-preference-include:unrelated"], frozenset()) is False + assert _tag_known_to_group(router._core_ctx, "gpt-4", ["llm-preference-include:unrelated"], frozenset()) is False def test_inherited_constraint_sets_none_when_inherited_tags_absent(): @@ -3456,7 +3455,7 @@ async def _routed_to(router: litellm.Router, metadata: dict[str, object]) -> str async def _pool(router: litellm.Router, metadata: dict[str, object]) -> frozenset[str]: request_deployments: Final = router.get_model_list(model_name="chat") deployments: Final = await get_deployments_for_tag( - llm_router_instance=router, + ctx=router._core_ctx, model="chat", healthy_deployments=request_deployments, request_deployments=request_deployments, diff --git a/tests/unit/router_strategy/test_savings_baseline.py b/tests/unit/router_strategy/test_savings_baseline.py index 4241a541202..a6c99ba061c 100644 --- a/tests/unit/router_strategy/test_savings_baseline.py +++ b/tests/unit/router_strategy/test_savings_baseline.py @@ -1,6 +1,7 @@ import pytest from litellm.router import Router +from litellm.router_api import RoutingContext from litellm.router_strategy.savings_baseline import ( Baseline, canonical_model, @@ -11,7 +12,7 @@ from litellm.router_strategy.savings_baseline import ( @pytest.fixture -def parent() -> Router: +def parent() -> RoutingContext: return Router( model_list=[ {"model_name": "cheap", "litellm_params": {"model": "anthropic/claude-haiku-4-5"}}, @@ -19,7 +20,7 @@ def parent() -> Router: {"model_name": "pool", "litellm_params": {"model": "anthropic/claude-haiku-4-5"}}, {"model_name": "pool", "litellm_params": {"model": "anthropic/claude-opus-5"}}, ] - ) + )._core_ctx class TestCanonicalModel: @@ -107,7 +108,7 @@ class TestResolveBaseline: served; a dashboard counterfactual must not be able to take routing down.""" class Exploding: - def deployments_named(self, model_name): + def registry(self): raise RuntimeError("router is mid-reload") assert resolve_baseline(Exploding(), ["anything"]) is None @@ -128,8 +129,8 @@ class TestDeploymentsPricedByBaseModel: """ @staticmethod - def _router(*deployments: dict) -> Router: - return Router(model_list=list(deployments)) + def _router(*deployments: dict) -> RoutingContext: + return Router(model_list=list(deployments))._core_ctx def test_model_info_base_model_is_preferred_over_the_deployment_name(self): router = self._router( @@ -192,7 +193,7 @@ class TestDeploymentPricingOverrides: {"model_name": "top", "litellm_params": {"model": "anthropic/claude-opus-5"}}, ] ) - assert resolve_baseline(router, ["cheap", "top"]).model == "anthropic/claude-opus-5" + assert resolve_baseline(router._core_ctx, ["cheap", "top"]).model == "anthropic/claude-opus-5" overridden = Router( model_list=[ @@ -207,4 +208,4 @@ class TestDeploymentPricingOverrides: {"model_name": "top", "litellm_params": {"model": "anthropic/claude-opus-5"}}, ] ) - assert resolve_baseline(overridden, ["cheap", "top"]).model == "anthropic/claude-haiku-4-5" + assert resolve_baseline(overridden._core_ctx, ["cheap", "top"]).model == "anthropic/claude-haiku-4-5" diff --git a/tests/unit/router_utils/pre_call_checks/test_encrypted_content_affinity_check.py b/tests/unit/router_utils/pre_call_checks/test_encrypted_content_affinity_check.py index a3745c7b23f..d184bf84035 100644 --- a/tests/unit/router_utils/pre_call_checks/test_encrypted_content_affinity_check.py +++ b/tests/unit/router_utils/pre_call_checks/test_encrypted_content_affinity_check.py @@ -24,6 +24,7 @@ import pytest import litellm from litellm.models.credentials import CredentialItem from litellm.responses.utils import ResponsesAPIRequestUtils +from litellm.router_api import RoutingContext from litellm.types.llms.openai import ResponsesAPIResponse @@ -1016,13 +1017,13 @@ async def test_affinity_falls_back_to_same_boundary_on_alias_switch(): def test_boundary_fallback_no_router_ref_returns_empty(): """ Standalone use (no router wired in) -> the boundary lookup short-circuits - to ``[]`` instead of crashing on ``None.get_deployment``. + to ``[]`` instead of crashing on ``None.registry()``. """ from litellm.router_utils.pre_call_checks.encrypted_content_affinity_check import ( EncryptedContentAffinityCheck, ) - check = EncryptedContentAffinityCheck(router=None) + check = EncryptedContentAffinityCheck(ctx=None) healthy = [ { "model_info": {"id": "dep-1"}, @@ -1040,7 +1041,7 @@ def test_boundary_fallback_no_router_ref_returns_empty(): def test_boundary_fallback_originating_deployment_removed_returns_empty(): """ If the originating deployment has been removed from the router (e.g. via - /model/delete), ``router.get_deployment`` returns None and we return [] so + /model/delete), ``ctx.registry().deployment`` returns None and we return [] so the caller falls back to the full healthy_deployments list. """ from unittest.mock import MagicMock @@ -1049,10 +1050,10 @@ def test_boundary_fallback_originating_deployment_removed_returns_empty(): EncryptedContentAffinityCheck, ) - mock_router = MagicMock() - mock_router.get_deployment.return_value = None + mock_ctx = MagicMock() + mock_ctx.registry.return_value.deployment.return_value = None - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) healthy = [ { "model_info": {"id": "dep-1"}, @@ -1065,7 +1066,7 @@ def test_boundary_fallback_originating_deployment_removed_returns_empty(): ) assert matches == [] assert originating is None - mock_router.get_deployment.assert_called_once_with(model_id="dep-removed") + mock_ctx.registry().deployment.assert_called_once_with("dep-removed") def test_boundary_key_accepts_pydantic_litellm_params_instance(): @@ -1241,7 +1242,7 @@ def test_boundary_fallback_matches_deployments_with_same_named_credential_values ], num_retries=0, ) - check = EncryptedContentAffinityCheck(router=router) + check = EncryptedContentAffinityCheck(ctx=RoutingContext(router)) healthy_deployments = [ { "model_info": {"id": "peer-same-boundary"}, @@ -1308,19 +1309,21 @@ def _make_router_mock_with_cooldown( routed_group_model_ids: list[str] | None = None, ): """ - Build a MagicMock router whose ``cooldown_cache.async_get_active_cooldowns`` + Build a MagicMock routing context whose ``health().cooldowns.async_get_active_cooldowns`` returns ``cooldown_entries`` (defaulting to ``[]`` — no active cooldown), and - whose ``get_candidate_model_ids_for_route`` returns ``routed_group_model_ids`` + whose ``registry().names(model, kind="route_candidates")`` returns ``routed_group_model_ids`` (the deployment ids the router resolves for the routed model; defaulting to ``[]`` — origin absent from the routed group, i.e. a tier change). """ from unittest.mock import AsyncMock, MagicMock - mock_router = MagicMock() - mock_router.get_deployment.return_value = originating - mock_router.cooldown_cache.async_get_active_cooldowns = AsyncMock(return_value=list(cooldown_entries or [])) - mock_router.get_candidate_model_ids_for_route.return_value = frozenset(routed_group_model_ids or []) - return mock_router + mock_ctx = MagicMock() + mock_ctx.registry.return_value.deployment.return_value = originating + mock_ctx.health.return_value.cooldowns.async_get_active_cooldowns = AsyncMock( + return_value=list(cooldown_entries or []) + ) + mock_ctx.registry.return_value.names.return_value = frozenset(routed_group_model_ids or []) + return mock_ctx @pytest.mark.asyncio @@ -1336,7 +1339,7 @@ async def test_affinity_strips_and_dispatches_when_origin_cooled_for_non_429(): ) originating = _make_originating_mock("https://account-a.openai.azure.com/", "key-a") - mock_router = _make_router_mock_with_cooldown( + mock_ctx = _make_router_mock_with_cooldown( originating, cooldown_entries=[ ( @@ -1352,7 +1355,7 @@ async def test_affinity_strips_and_dispatches_when_origin_cooled_for_non_429(): routed_group_model_ids=["deployment-a-cooled", "deployment-b"], ) - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) encoded_id = ResponsesAPIRequestUtils._build_encrypted_item_id("deployment-a-cooled", "rs_test") healthy_only_b = [ { @@ -1402,7 +1405,7 @@ async def test_affinity_strips_and_dispatches_when_origin_cooled_for_429(): originating = _make_originating_mock("https://account-a.openai.azure.com/", "key-a") cooldown_started = time.time() - 5.0 - mock_router = _make_router_mock_with_cooldown( + mock_ctx = _make_router_mock_with_cooldown( originating, cooldown_entries=[ ( @@ -1418,7 +1421,7 @@ async def test_affinity_strips_and_dispatches_when_origin_cooled_for_429(): routed_group_model_ids=["deployment-a-cooled-429", "deployment-b"], ) - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) encoded_id = ResponsesAPIRequestUtils._build_encrypted_item_id("deployment-a-cooled-429", "rs_test") healthy_only_b = [ { @@ -1457,11 +1460,11 @@ async def test_affinity_strips_and_dispatches_when_origin_filtered_without_coold ) originating = _make_originating_mock("https://account-a.openai.azure.com/", "key-a") - mock_router = _make_router_mock_with_cooldown( + mock_ctx = _make_router_mock_with_cooldown( originating, cooldown_entries=[], routed_group_model_ids=["deployment-a-filtered", "deployment-b"] ) - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) encoded_id = ResponsesAPIRequestUtils._build_encrypted_item_id("deployment-a-filtered", "rs_test") healthy_only_b = [ { @@ -1501,10 +1504,10 @@ async def test_affinity_serves_sibling_when_candidate_origin_has_no_boundary_pee ) originating = _make_originating_mock("https://region-a.example.com/v1", "shared-key") - mock_router = _make_router_mock_with_cooldown( + mock_ctx = _make_router_mock_with_cooldown( originating, cooldown_entries=[], routed_group_model_ids=["region-a", "region-b", "region-c"] ) - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) wrapped = ResponsesAPIRequestUtils.wrap_encrypted_content_with_model_id("gAAAAA-blob", "region-a") siblings = [ { @@ -1563,10 +1566,10 @@ async def test_affinity_strips_and_dispatches_when_origin_is_unknown_or_removed( EncryptedContentAffinityCheck, ) - mock_router = MagicMock() - mock_router.get_deployment.return_value = None + mock_ctx = MagicMock() + mock_ctx.registry.return_value.deployment.return_value = None - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) wrapped = ResponsesAPIRequestUtils.wrap_encrypted_content_with_model_id("gAAAAA-blob", "deployment-removed") routed_pool = [ { @@ -1601,7 +1604,7 @@ async def test_affinity_strips_and_dispatches_when_origin_is_unknown_or_removed( assert result is routed_pool assert not any(isinstance(item, dict) and item.get("encrypted_content") for item in request_kwargs["input"]) - mock_router.get_candidate_model_ids_for_route.assert_not_called() + mock_ctx.registry().names.assert_not_called() @pytest.mark.asyncio @@ -1622,10 +1625,10 @@ async def test_affinity_does_not_raise_when_boundary_peer_available(): "api_base": "https://account-a.openai.azure.com/", "api_key": "key-a", } - mock_router = MagicMock() - mock_router.get_deployment.return_value = originating + mock_ctx = MagicMock() + mock_ctx.registry.return_value.deployment.return_value = originating - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) encoded_id = ResponsesAPIRequestUtils._build_encrypted_item_id("deployment-a", "rs_test") peer = { "model_info": {"id": "deployment-a-peer"}, @@ -1881,10 +1884,10 @@ async def test_encrypted_content_affinity_strips_bridge_reasoning_from_messages_ same way they reject a foreign one. """ originating = _make_originating_mock(None, "key-a", model_name="gpt-reasoning-tier") - mock_router = _make_router_mock_with_cooldown( + mock_ctx = _make_router_mock_with_cooldown( originating, cooldown_entries=[], routed_group_model_ids=["openai-org-b"] ) - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) routed_pool = [{"model_info": {"id": "openai-org-b"}, "litellm_params": {"model": "openai/gpt-5-nano"}}] messages = _bridge_replayed_anthropic_messages(minted_by="openai-org-a") assistant_content = messages[1]["content"] @@ -2134,7 +2137,7 @@ async def test_affinity_keeps_mixed_origins_on_the_same_encryption_boundary(): shared_api_base = "https://account-a.openai.azure.com/" shared_api_key = "shared-key" origin_d2 = _make_originating_mock(shared_api_base, shared_api_key) - mock_router = _make_router_mock_with_cooldown(origin_d2, cooldown_entries=[], routed_group_model_ids=["d1", "d2"]) + mock_ctx = _make_router_mock_with_cooldown(origin_d2, cooldown_entries=[], routed_group_model_ids=["d1", "d2"]) deployment_d1 = { "model_info": {"id": "d1"}, "litellm_params": {"api_base": shared_api_base, "api_key": shared_api_key}, @@ -2158,8 +2161,8 @@ async def test_affinity_keeps_mixed_origins_on_the_same_encryption_boundary(): d2_item.copy(), ] } - mock_router.get_deployment.side_effect = lambda model_id: origin_d2 if model_id == "d2" else None - check = EncryptedContentAffinityCheck(router=mock_router) + mock_ctx.registry.return_value.deployment.side_effect = lambda model_id: origin_d2 if model_id == "d2" else None + check = EncryptedContentAffinityCheck(ctx=mock_ctx) result = await check.async_filter_deployments( model="gpt-5.4", @@ -2180,8 +2183,11 @@ async def test_boundary_pin_strips_reasoning_from_a_different_origin(): origin_a = _make_originating_mock("https://account-a.openai.azure.com/", "key-a") origin_b = _make_originating_mock("https://account-b.openai.azure.com/", "key-b") - mock_router = _make_router_mock_with_cooldown(origin_a, cooldown_entries=[], routed_group_model_ids=["peer-a"]) - mock_router.get_deployment.side_effect = lambda model_id: {"origin-a": origin_a, "origin-b": origin_b}.get(model_id) + mock_ctx = _make_router_mock_with_cooldown(origin_a, cooldown_entries=[], routed_group_model_ids=["peer-a"]) + mock_ctx.registry.return_value.deployment.side_effect = lambda model_id: { + "origin-a": origin_a, + "origin-b": origin_b, + }.get(model_id) peer_a = { "model_info": {"id": "peer-a"}, "litellm_params": {"api_base": "https://account-a.openai.azure.com/", "api_key": "key-a"}, @@ -2204,7 +2210,7 @@ async def test_boundary_pin_strips_reasoning_from_a_different_origin(): }, ] } - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) result = await check.async_filter_deployments( model="gpt-5.4", @@ -2234,8 +2240,11 @@ async def test_affinity_keeps_only_anthropic_reasoning_from_the_pinned_origin(): origin_a = _make_originating_mock("https://account-a.openai.azure.com/", "key-a") origin_b = _make_originating_mock("https://account-b.openai.azure.com/", "key-b") - mock_router = _make_router_mock_with_cooldown(origin_b, cooldown_entries=[], routed_group_model_ids=["origin-a"]) - mock_router.get_deployment.side_effect = lambda model_id: {"origin-a": origin_a, "origin-b": origin_b}.get(model_id) + mock_ctx = _make_router_mock_with_cooldown(origin_b, cooldown_entries=[], routed_group_model_ids=["origin-a"]) + mock_ctx.registry.return_value.deployment.side_effect = lambda model_id: { + "origin-a": origin_a, + "origin-b": origin_b, + }.get(model_id) deployment_a = { "model_info": {"id": "origin-a"}, "litellm_params": {"api_base": "https://account-a.openai.azure.com/", "api_key": "key-a"}, @@ -2248,7 +2257,7 @@ async def test_affinity_keeps_only_anthropic_reasoning_from_the_pinned_origin(): foreign_messages = _bridge_replayed_anthropic_messages(minted_by="origin-b") assistant_content = messages[1]["content"] assistant_content.insert(3, foreign_messages[1]["content"][1]) - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) result = await check.async_filter_deployments( model="gpt-5.4", @@ -2288,8 +2297,8 @@ async def test_affinity_strips_unknown_origins_but_leaves_unmarked_encrypted_con EncryptedContentAffinityCheck, ) - mock_router = MagicMock() - mock_router.get_deployment.return_value = None + mock_ctx = MagicMock() + mock_ctx.registry.return_value.deployment.return_value = None deployment_a = { "model_info": {"id": "origin-a"}, "litellm_params": {"api_base": "https://account-a.openai.azure.com/", "api_key": "key-a"}, @@ -2316,7 +2325,7 @@ async def test_affinity_strips_unknown_origins_but_leaves_unmarked_encrypted_con }, ] } - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) result = await check.async_filter_deployments( model="gpt-5.4", @@ -2354,11 +2363,13 @@ def _router_without_the_origin(): ) -@pytest.mark.parametrize("router", [None, _router_without_the_origin()], ids=["no router", "origin removed"]) +@pytest.mark.parametrize( + "ctx", [None, RoutingContext(_router_without_the_origin())], ids=["no router", "origin removed"] +) @pytest.mark.parametrize( "unmarked_origin", ["origin-removed", None], ids=["failed deployment named", "failed deployment unknown"] ) -def test_hop_strip_drops_unmarked_reasoning_whose_origin_cannot_be_resolved(router, unmarked_origin): +def test_hop_strip_drops_unmarked_reasoning_whose_origin_cannot_be_resolved(ctx, unmarked_origin): from litellm.router_utils.pre_call_checks.encrypted_content_affinity_check import ( EncryptedContentAffinityCheck, ) @@ -2378,7 +2389,7 @@ def test_hop_strip_drops_unmarked_reasoning_whose_origin_cannot_be_resolved(rout } EncryptedContentAffinityCheck.strip_reasoning_the_targets_cannot_decrypt( - router, request_input, None, (target,), unmarked_origin=unmarked_origin + ctx, request_input, None, (target,), unmarked_origin=unmarked_origin ) assert request_input == [ @@ -2417,10 +2428,10 @@ async def test_affinity_strips_encrypted_reasoning_when_routed_to_another_model_ ) originating = _make_originating_mock(None, "key-a", model_name="gpt-reasoning-tier") - mock_router = _make_router_mock_with_cooldown( + mock_ctx = _make_router_mock_with_cooldown( originating, cooldown_entries=[], routed_group_model_ids=["deployment-b"] ) - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) routed_pool = [ { "model_info": {"id": "deployment-b"}, @@ -2475,10 +2486,10 @@ async def test_affinity_degrades_within_the_origins_own_group(): originating = _make_originating_mock( "https://account-a.openai.azure.com/", "key-a", model_name="gpt-reasoning-tier" ) - mock_router = _make_router_mock_with_cooldown( + mock_ctx = _make_router_mock_with_cooldown( originating, cooldown_entries=[], routed_group_model_ids=["deployment-a", "deployment-a2"] ) - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) sibling_pool = [ { "model_info": {"id": "deployment-a2"}, @@ -2517,10 +2528,10 @@ async def test_affinity_strips_when_group_is_spelled_differently_but_same_by_id( ) originating = _make_originating_mock(None, "key-a", model_name="openai/gpt-5.4-mini") - mock_router = _make_router_mock_with_cooldown( + mock_ctx = _make_router_mock_with_cooldown( originating, cooldown_entries=[], routed_group_model_ids=["deployment-mini-a", "deployment-mini-b"] ) - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) wrapped = ResponsesAPIRequestUtils.wrap_encrypted_content_with_model_id("gAAAAA-blob", "deployment-mini-a") sibling_pool = [ { @@ -2569,10 +2580,10 @@ async def test_affinity_strips_for_team_and_pattern_routes(): ) originating = _make_originating_mock(None, "key-a", model_name="model_name_teamA_uuid") - mock_router = _make_router_mock_with_cooldown( + mock_ctx = _make_router_mock_with_cooldown( originating, cooldown_entries=[], routed_group_model_ids=["deployment-team-a", "deployment-team-b"] ) - check = EncryptedContentAffinityCheck(router=mock_router) + check = EncryptedContentAffinityCheck(ctx=mock_ctx) wrapped = ResponsesAPIRequestUtils.wrap_encrypted_content_with_model_id("gAAAAA-blob", "deployment-team-a") sibling_pool = [ { @@ -2657,7 +2668,7 @@ async def test_affinity_strips_and_dispatches_when_origin_already_failed_this_re group: Final = router.model_list reasoning_input: Final = _reasoning_input_minted_by("region-a") - result: Final = await EncryptedContentAffinityCheck(router=router).async_filter_deployments( + result: Final = await EncryptedContentAffinityCheck(ctx=RoutingContext(router)).async_filter_deployments( model="gpt-5.4", healthy_deployments=group, messages=None, @@ -2681,7 +2692,9 @@ async def test_affinity_keeps_origin_and_reasoning_when_previous_response_id_bin reasoning_input: Final = _reasoning_input_minted_by("region-a") original_reasoning: Final = dict(reasoning_input[0]) - assert await EncryptedContentAffinityCheck(router=litellm.Router(model_list=list(pool))).async_filter_deployments( + assert await EncryptedContentAffinityCheck( + ctx=RoutingContext(litellm.Router(model_list=list(pool))) + ).async_filter_deployments( model="gpt-5.4", healthy_deployments=list(pool), messages=None, @@ -2706,7 +2719,7 @@ async def test_affinity_keeps_reasoning_when_every_deployment_already_refused_th reasoning_input: Final = _reasoning_input_minted_by("region-a") original_reasoning: Final = dict(reasoning_input[0]) - result: Final = await EncryptedContentAffinityCheck(router=router).async_filter_deployments( + result: Final = await EncryptedContentAffinityCheck(ctx=RoutingContext(router)).async_filter_deployments( model="gpt-5.4", healthy_deployments=router.model_list, messages=None, diff --git a/tests/unit/router_utils/test_access_windows.py b/tests/unit/router_utils/test_access_windows.py index a797a788b4e..a283b2d57c1 100644 --- a/tests/unit/router_utils/test_access_windows.py +++ b/tests/unit/router_utils/test_access_windows.py @@ -2,7 +2,7 @@ from datetime import datetime, time, timezone from typing import Final -from litellm.router_utils.access_windows import ( +from litellm.litellm_core_utils.access_windows import ( access_windows_config_error, filter_reserved_deployments, is_window_active, diff --git a/tests/unit/router_utils/test_add_retry_fallback_headers.py b/tests/unit/router_utils/test_add_retry_fallback_headers.py index 1f4ac3be6ac..0f65e0ecf48 100644 --- a/tests/unit/router_utils/test_add_retry_fallback_headers.py +++ b/tests/unit/router_utils/test_add_retry_fallback_headers.py @@ -5,7 +5,7 @@ from typing import Final, Literal import pytest from pydantic import BaseModel -from litellm.router_utils.add_retry_fallback_headers import ( +from litellm.litellm_core_utils.add_retry_fallback_headers import ( add_fallback_headers_to_response, add_retry_headers_to_response, complexity_router_decision_headers, diff --git a/tests/unit/router_utils/test_cooldown_handlers.py b/tests/unit/router_utils/test_cooldown_handlers.py index 2e1e3acaabb..7deeb255e6c 100644 --- a/tests/unit/router_utils/test_cooldown_handlers.py +++ b/tests/unit/router_utils/test_cooldown_handlers.py @@ -20,6 +20,7 @@ from litellm._internal_context import current_service_target from litellm.caching.dual_cache import DualCache from litellm.caching.in_memory_cache import InMemoryCache from litellm.litellm_core_utils.litellm_logging import mask_api_base_credentials +from litellm.router_api import RoutingContext from litellm.router_utils.cooldown_cache import CooldownCache, CooldownCacheValue from litellm.router_utils.cooldown_callbacks import router_cooldown_event_callback from litellm.router_utils.cooldown_handlers import ( @@ -57,6 +58,25 @@ from litellm.types.utils import CooldownDeploymentInfo, CredentialItem from tests._vcr_conftest_common import install_live_call_probe, record_vcr_outcome +def _ctx_double( + *, + deployment_dict: Mapping[str, object] | None = None, + cooldown_time: float = 60.0, + allowed_fails: int = 0, + store: DualCache | MagicMock | None = None, +) -> MagicMock: + """A RoutingContext double answering the registry, settings and health reads the cooldown helpers make.""" + ctx: Final = MagicMock() + ctx.registry.return_value.deployment.return_value = None + ctx.registry.return_value.deployment_dict.return_value = deployment_dict + ctx.settings.return_value.cooldown_time = cooldown_time + ctx.settings.return_value.allowed_fails = allowed_fails + ctx.settings.return_value.allowed_fails_policy = None + ctx.settings.return_value.allowed_fails_for.return_value = None + ctx.health.return_value.store = store if store is not None else DualCache(in_memory_cache=InMemoryCache()) + return ctx + + @pytest.mark.asyncio @pytest.mark.parametrize( ("exception_type", "expected_cooldown"), @@ -80,25 +100,20 @@ async def test_unsupported_endpoint_preserves_cooldown_exclusion_with_bad_reques ) exception: Final = exception_type(message="Request failed", model="claude-sonnet-5-5", llm_provider="anthropic") set_cooldown_deployments( - litellm_router_instance=router, + ctx=RoutingContext(router), original_exception=exception, exception_status=exception.status_code, deployment="deployment", time_to_cooldown=60, ) - assert await async_get_cooldown_deployments(router, parent_otel_span=None) == ( + assert await async_get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == ( ["deployment"] if expected_cooldown else [] ) class TestGetDeploymentCooldownPolicy: - def _make_router(self, deployment_id: str, model_info: dict | None = None): - router = MagicMock() - if model_info is None: - router.get_model_info.return_value = None - else: - router.get_model_info.return_value = {"model_info": model_info} - return router + def _make_router(self, deployment_id: str, model_info: dict | None = None) -> MagicMock: + return _ctx_double(deployment_dict=None if model_info is None else {"model_info": model_info}) def test_deployment_not_found_returns_none_none(self): router = self._make_router("dep-1") @@ -107,8 +122,7 @@ class TestGetDeploymentCooldownPolicy: assert allowed is None def test_no_model_info_returns_none_none(self): - router = MagicMock() - router.get_model_info.return_value = {"model_info": {}} + router = _ctx_double(deployment_dict={"model_info": {}}) policy, allowed = _get_deployment_cooldown_policy(router, "dep-1") assert policy is None assert allowed is None @@ -186,13 +200,8 @@ class TestResolveAllowedFailsFromPolicy: class TestShouldCooldownBasedOnDeploymentPolicy: - def _make_router(self, model_info: dict | None = None): - router = MagicMock() - if model_info is None: - router.get_model_info.return_value = None - else: - router.get_model_info.return_value = model_info - return router + def _make_router(self, model_info: dict | None = None) -> MagicMock: + return _ctx_double(deployment_dict=model_info) def test_policy_match_uses_exception_type_as_cache_key_suffix(self): policy = {"RateLimitErrorAllowedFails": 0} @@ -351,31 +360,25 @@ class TestShouldCooldownBasedOnDeploymentPolicy: class TestShouldCooldownBasedOnAllowedFailsPolicy: - def _make_router(self, cooldown_time: float = 60.0, cache: DualCache | None = None) -> MagicMock: - router = MagicMock() - router.cooldown_time = cooldown_time - router.allowed_fails = 0 - router.allowed_fails_policy = None - router.get_allowed_fails_from_policy.return_value = None - router.cache = cache if cache is not None else DualCache(in_memory_cache=InMemoryCache()) - return router + def _make_router(self, cooldown_time: float = 60.0, cache: DualCache | MagicMock | None = None) -> MagicMock: + return _ctx_double(cooldown_time=cooldown_time, allowed_fails=0, store=cache) def test_cooldown_time_override_zero_is_not_falsy(self): """cooldown_time_override=0 must be honored; it must not fall through to the router-level value.""" - router = self._make_router(cooldown_time=60.0) - router.cache = MagicMock() - router.cache.increment_cache.return_value = 1 + store = MagicMock() + store.increment_cache.return_value = 1 + ctx = self._make_router(cooldown_time=60.0, cache=store) exc = litellm.RateLimitError("429", "openai", "gpt-4") should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=ctx, deployment="dep-1", original_exception=exc, allowed_fails_override=5, cooldown_time_override=0.0, ) - increment_call = router.cache.increment_cache.call_args + increment_call = store.increment_cache.call_args assert increment_call is not None assert increment_call[1]["ttl"] == 0.0, ( "cooldown_time_override=0 should be used as TTL, not the router-level 60.0" @@ -389,7 +392,7 @@ class TestShouldCooldownBasedOnAllowedFailsPolicy: results = [ should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=workers[i % 2], + ctx=workers[i % 2], deployment="dep-1", original_exception=exc, allowed_fails_override=5, @@ -408,7 +411,7 @@ class TestShouldCooldownBasedOnAllowedFailsPolicy: exc = litellm.AuthenticationError("401", "openai", "gpt-4") result = should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=router, deployment="dep-1", original_exception=exc, allowed_fails_override=5, @@ -426,7 +429,7 @@ class TestShouldCooldownBasedOnAllowedFailsPolicy: results = [ should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=router, deployment="dep-1", original_exception=exc, allowed_fails_override=5, @@ -472,7 +475,7 @@ class TestRoutingGroupCooldownAlternatives: ) assert ( _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="cg-deploy-1", exception_status=429, original_exception=Exception("rate limited"), @@ -495,7 +498,7 @@ class TestRoutingGroupCooldownAlternatives: ) assert ( _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="cg-deploy-1", exception_status=429, original_exception=Exception("rate limited"), @@ -510,7 +513,7 @@ class TestRoutingGroupCooldownAlternatives: router = self._router(routing_groups=None) assert ( _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="cg-deploy-1", exception_status=429, original_exception=Exception("rate limited"), @@ -543,7 +546,7 @@ class TestTeamModelCooldownAlternatives: router = self._router(team_deployments=2) assert ( _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="team-deploy-0", exception_status=429, original_exception=Exception("rate limited"), @@ -558,7 +561,7 @@ class TestTeamModelCooldownAlternatives: router = self._router(team_deployments=1) assert ( _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="team-deploy-0", exception_status=429, original_exception=Exception("rate limited"), @@ -573,7 +576,7 @@ class TestTeamModelCooldownAlternatives: router = self._router(team_deployments=2, blocked_ids=frozenset({"team-deploy-1"})) assert ( _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="team-deploy-0", exception_status=429, original_exception=Exception("rate limited"), @@ -675,7 +678,7 @@ class TestDeploymentLevelAllowedFails: _exception = litellm.RateLimitError("Rate limit", "openai", "gpt-4") should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="primary", exception_status=429, original_exception=_exception, @@ -709,7 +712,7 @@ class TestDeploymentLevelAllowedFails: _exception = litellm.RateLimitError("Rate limit", "openai", "gpt-4") should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="secondary", exception_status=429, original_exception=_exception, @@ -731,7 +734,7 @@ def _primary_cooldown_decisions_on_repeated_503s(router: Router) -> tuple[bool, exception: Final = litellm.ServiceUnavailableError("down", "openai", "gpt-4") return tuple( _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="primary", exception_status=503, original_exception=exception, @@ -743,7 +746,9 @@ def _primary_cooldown_decisions_on_repeated_503s(router: Router) -> tuple[bool, @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") class TestRouterLevelAllowedFailsEqualToDefault: def test_allowed_fails_equal_to_the_default_cools_down_after_that_many_fails(self): - router: Final = _make_router(model_list=list(_gpt_4_group_with_a_sibling()), allowed_fails=litellm.allowed_fails) + router: Final = _make_router( + model_list=list(_gpt_4_group_with_a_sibling()), allowed_fails=litellm.allowed_fails + ) assert _primary_cooldown_decisions_on_repeated_503s(router) == (False,) * litellm.allowed_fails + (True,) @@ -785,7 +790,7 @@ class TestDeploymentLevelAllowedFailsPolicyByExceptionType: rate_limit_exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="primary", exception_status=429, original_exception=rate_limit_exc, @@ -818,7 +823,7 @@ class TestDeploymentLevelAllowedFailsPolicyByExceptionType: for _ in range(5): should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="primary", exception_status=500, original_exception=ise, @@ -826,7 +831,7 @@ class TestDeploymentLevelAllowedFailsPolicyByExceptionType: assert should_cooldown is False, "Should not cooldown within the allowed_fails threshold" should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="primary", exception_status=500, original_exception=ise, @@ -857,7 +862,7 @@ class TestExceptionTypeCountersTrackedIndependently: for _ in range(3): should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="primary", original_exception=rate_limit_exc, allowed_fails_override=5, @@ -871,7 +876,7 @@ class TestExceptionTypeCountersTrackedIndependently: assert generic_counter == 0, "generic counter must be untouched by RateLimitError increments" should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="primary", original_exception=ise, allowed_fails_override=5, @@ -994,16 +999,14 @@ class TestFallbackDeploymentCooldown: _trigger_cooldown_for_failed_deployment must call set_cooldown_deployments with the deployment ID stamped on the exception. """ - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _ctx_double(cooldown_time=60.0) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: _trigger_cooldown_for_failed_deployment( - litellm_router=mock_router, + ctx=ctx, kwargs={}, exception=exc, ) @@ -1018,11 +1021,11 @@ class TestFallbackDeploymentCooldown: _trigger_cooldown_for_failed_deployment must not raise and must skip set_cooldown_deployments when the exception has no failed_deployment_id. """ - mock_router = MagicMock() + ctx = _ctx_double() with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: _trigger_cooldown_for_failed_deployment( - litellm_router=mock_router, + ctx=ctx, kwargs={}, exception=RuntimeError("no stamped deployment id"), ) @@ -1036,9 +1039,7 @@ class TestFallbackDeploymentCooldown: set metadata must not be able to get an arbitrary deployment cooled down by forging a deployment_model_name marker. """ - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _ctx_double(cooldown_time=60.0) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") kwargs = { @@ -1050,7 +1051,7 @@ class TestFallbackDeploymentCooldown: with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: _trigger_cooldown_for_failed_deployment( - litellm_router=mock_router, + ctx=ctx, kwargs=kwargs, exception=exc, ) @@ -1063,9 +1064,7 @@ class TestFallbackDeploymentCooldown: primary path uses, or repeated fallback failures never accumulate toward the default percent-fail-rate cooldown threshold. """ - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _ctx_double(cooldown_time=60.0) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" @@ -1076,11 +1075,9 @@ class TestFallbackDeploymentCooldown: "litellm.router_utils.fallback_event_handlers.increment_deployment_failures_for_current_minute" ) as mock_increment, ): - _trigger_cooldown_for_failed_deployment(litellm_router=mock_router, kwargs={}, exception=exc) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs={}, exception=exc) - mock_increment.assert_called_once_with( - litellm_router_instance=mock_router, deployment_id="fallback-deployment" - ) + mock_increment.assert_called_once_with(ctx=ctx, deployment_id="fallback-deployment") mock_set_cooldown.assert_called_once() def test_trigger_cooldown_uses_deployment_cooldown_time_override(self): @@ -1088,16 +1085,14 @@ class TestFallbackDeploymentCooldown: When the deployment has a model_info.cooldown_time, that value must be passed as time_to_cooldown rather than the router-level cooldown_time. """ - mock_router = MagicMock() - mock_router.cooldown_time = 300.0 - mock_router.get_model_info.return_value = {"model_info": {"cooldown_time": 30.0}} + ctx = _ctx_double(cooldown_time=300.0, deployment_dict={"model_info": {"cooldown_time": 30.0}}) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: _trigger_cooldown_for_failed_deployment( - litellm_router=mock_router, + ctx=ctx, kwargs={}, exception=exc, ) @@ -1113,9 +1108,7 @@ class TestFallbackDeploymentCooldown: deployment) must not cool down the fallback deployment, matching the same guard already applied in Router.deployment_callback_on_failure. """ - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _ctx_double(cooldown_time=60.0) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" @@ -1123,7 +1116,7 @@ class TestFallbackDeploymentCooldown: with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: _trigger_cooldown_for_failed_deployment( - litellm_router=mock_router, + ctx=ctx, kwargs={}, exception=exc, ) @@ -1137,16 +1130,14 @@ class TestFallbackDeploymentCooldown: honored as a fallback when model_info doesn't set it, unlike the new allowed_fails/allowed_fails_policy fields which are model_info-only. """ - mock_router = MagicMock() - mock_router.cooldown_time = 300.0 - mock_router.get_model_info.return_value = {"litellm_params": {"cooldown_time": 30.0}} + ctx = _ctx_double(cooldown_time=300.0, deployment_dict={"litellm_params": {"cooldown_time": 30.0}}) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: _trigger_cooldown_for_failed_deployment( - litellm_router=mock_router, + ctx=ctx, kwargs={}, exception=exc, ) @@ -1157,19 +1148,20 @@ class TestFallbackDeploymentCooldown: ) def test_trigger_cooldown_prefers_model_info_cooldown_time_over_litellm_params(self): - mock_router = MagicMock() - mock_router.cooldown_time = 300.0 - mock_router.get_model_info.return_value = { - "model_info": {"cooldown_time": 15.0}, - "litellm_params": {"cooldown_time": 30.0}, - } + ctx = _ctx_double( + cooldown_time=300.0, + deployment_dict={ + "model_info": {"cooldown_time": 15.0}, + "litellm_params": {"cooldown_time": 30.0}, + }, + ) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: _trigger_cooldown_for_failed_deployment( - litellm_router=mock_router, + ctx=ctx, kwargs={}, exception=exc, ) @@ -1200,7 +1192,7 @@ class TestSingleDeploymentModelGroupProtection: exc = Exception("Internal error") for _ in range(2): should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="solo", exception_status=500, original_exception=exc, @@ -1230,7 +1222,7 @@ class TestSingleDeploymentModelGroupProtection: exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="solo", exception_status=429, original_exception=exc, @@ -1260,7 +1252,7 @@ class TestShouldCooldownBasedOnAllowedFailsPolicyFalsyZero: exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") should_cooldown = should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="primary", original_exception=exc, ) @@ -1425,8 +1417,8 @@ class TestCallerScopedOAuthAuthFailureCooldown: result: Final = self._callback(router, model_id, self._auth_exception(status)) assert result is False - assert get_deployment_failures_for_current_minute(router, model_id) == 0 - assert get_cooldown_deployments(router, parent_otel_span=None) == [] + assert get_deployment_failures_for_current_minute(RoutingContext(router), model_id) == 0 + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [] @pytest.mark.asyncio @pytest.mark.parametrize("status", (401, 403)) @@ -1456,8 +1448,8 @@ class TestCallerScopedOAuthAuthFailureCooldown: result: Final = self._callback(router, model_id, self._auth_exception(status)) assert result is False - assert get_deployment_failures_for_current_minute(router, model_id) == 0 - assert get_cooldown_deployments(router, parent_otel_span=None) == [] + assert get_deployment_failures_for_current_minute(RoutingContext(router), model_id) == 0 + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [] @pytest.mark.asyncio async def test_api_key_deployment_still_cools_down_on_401(self) -> None: @@ -1470,8 +1462,8 @@ class TestCallerScopedOAuthAuthFailureCooldown: litellm.AuthenticationError("upstream rejected the API key", "openai", "gpt-4o-mini"), ) - assert get_deployment_failures_for_current_minute(router, model_id) == 1 - assert get_cooldown_deployments(router, parent_otel_span=None) == [model_id] + assert get_deployment_failures_for_current_minute(RoutingContext(router), model_id) == 1 + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [model_id] @pytest.mark.asyncio @pytest.mark.parametrize("status", (429, 500)) @@ -1497,8 +1489,8 @@ class TestCallerScopedOAuthAuthFailureCooldown: self._callback(router, model_id, exception) - assert get_deployment_failures_for_current_minute(router, model_id) == 1 - assert get_cooldown_deployments(router, parent_otel_span=None) == [model_id] + assert get_deployment_failures_for_current_minute(RoutingContext(router), model_id) == 1 + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [model_id] @pytest.mark.parametrize("status", (401, 403)) def test_fallback_oauth_caller_auth_failure_does_not_cooldown(self, status: int) -> None: @@ -1514,10 +1506,10 @@ class TestCallerScopedOAuthAuthFailureCooldown: exception: Final = self._auth_exception(status) exception.failed_deployment_id = model_id - _trigger_cooldown_for_failed_deployment(litellm_router=router, kwargs={}, exception=exception) + _trigger_cooldown_for_failed_deployment(ctx=RoutingContext(router), kwargs={}, exception=exception) - assert get_deployment_failures_for_current_minute(router, model_id) == 0 - assert get_cooldown_deployments(router, parent_otel_span=None) == [] + assert get_deployment_failures_for_current_minute(RoutingContext(router), model_id) == 0 + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [] @pytest.mark.asyncio async def test_fallback_api_key_auth_failure_still_cools_down(self) -> None: @@ -1526,10 +1518,10 @@ class TestCallerScopedOAuthAuthFailureCooldown: exception: Final = litellm.AuthenticationError("API key rejected", "openai", "gpt-4o-mini") exception.failed_deployment_id = model_id - _trigger_cooldown_for_failed_deployment(litellm_router=router, kwargs={}, exception=exception) + _trigger_cooldown_for_failed_deployment(ctx=RoutingContext(router), kwargs={}, exception=exception) - assert get_deployment_failures_for_current_minute(router, model_id) == 1 - assert get_cooldown_deployments(router, parent_otel_span=None) == [model_id] + assert get_deployment_failures_for_current_minute(RoutingContext(router), model_id) == 1 + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [model_id] @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") @@ -1595,7 +1587,7 @@ class TestPerUserCopilotAuthFailureCooldown: ) result: Final = self._callback(router, model_id, exception) assert result is False - assert get_cooldown_deployments(router, parent_otel_span=None) == [] + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [] @pytest.mark.asyncio async def test_shared_mode_copilot_auth_failure_still_cools_down(self) -> None: @@ -1612,8 +1604,8 @@ class TestPerUserCopilotAuthFailureCooldown: model_id, litellm.AuthenticationError("upstream rejected the shared token", "github_copilot", "gpt-4o"), ) - assert get_deployment_failures_for_current_minute(router, model_id) == 1 - assert get_cooldown_deployments(router, parent_otel_span=None) == [model_id] + assert get_deployment_failures_for_current_minute(RoutingContext(router), model_id) == 1 + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [model_id] @pytest.mark.asyncio async def test_fallback_per_user_caller_auth_failure_does_not_cooldown( @@ -1640,9 +1632,9 @@ class TestPerUserCopilotAuthFailureCooldown: ) exception.failed_deployment_id = model_id - _trigger_cooldown_for_failed_deployment(litellm_router=router, kwargs={}, exception=exception) + _trigger_cooldown_for_failed_deployment(ctx=RoutingContext(router), kwargs={}, exception=exception) - assert get_cooldown_deployments(router, parent_otel_span=None) == [] + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [] @pytest.mark.asyncio async def test_fallback_shared_mode_auth_failure_still_cools_down(self) -> None: @@ -1659,9 +1651,9 @@ class TestPerUserCopilotAuthFailureCooldown: ) exception.failed_deployment_id = model_id - _trigger_cooldown_for_failed_deployment(litellm_router=router, kwargs={}, exception=exception) + _trigger_cooldown_for_failed_deployment(ctx=RoutingContext(router), kwargs={}, exception=exception) - assert get_cooldown_deployments(router, parent_otel_span=None) == [model_id] + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [model_id] @pytest.mark.asyncio async def test_fallback_rate_limit_on_per_user_deployment_does_not_cooldown( @@ -1690,9 +1682,9 @@ class TestPerUserCopilotAuthFailureCooldown: exception: Final = litellm.RateLimitError("copilot 429", "github_copilot", "gpt-4o") exception.failed_deployment_id = model_id - _trigger_cooldown_for_failed_deployment(litellm_router=router, kwargs={}, exception=exception) + _trigger_cooldown_for_failed_deployment(ctx=RoutingContext(router), kwargs={}, exception=exception) - assert get_cooldown_deployments(router, parent_otel_span=None) == [] + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [] @pytest.mark.asyncio async def test_fallback_rate_limit_on_shared_deployment_still_cools_down(self) -> None: @@ -1711,9 +1703,9 @@ class TestPerUserCopilotAuthFailureCooldown: exception: Final = litellm.RateLimitError("copilot 429", "github_copilot", "gpt-4o") exception.failed_deployment_id = model_id - _trigger_cooldown_for_failed_deployment(litellm_router=router, kwargs={}, exception=exception) + _trigger_cooldown_for_failed_deployment(ctx=RoutingContext(router), kwargs={}, exception=exception) - assert get_cooldown_deployments(router, parent_otel_span=None) == [model_id] + assert get_cooldown_deployments(RoutingContext(router), parent_otel_span=None) == [model_id] @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") @@ -1814,19 +1806,18 @@ async def test_router_cooldown_event_callback_no_deployment(): In this scenario it should do nothing """ - # Mock Router instance - mock_router = MagicMock() - mock_router.get_deployment.return_value = None + # Routing context whose registry has no such deployment + ctx = _ctx_double() await router_cooldown_event_callback( - litellm_router_instance=mock_router, + ctx=ctx, deployment_id="test-deployment", exception_status="429", cooldown_time=60.0, ) - # Assert that the router's get_deployment method was called - mock_router.get_deployment.assert_called_once_with(model_id="test-deployment") + # Assert that the registry was asked for the deployment + ctx.registry().deployment.assert_called_once_with("test-deployment") @pytest.fixture @@ -1856,15 +1847,21 @@ def testing_litellm_router(): def test_should_run_cooldown_logic(testing_litellm_router): testing_litellm_router.disable_cooldowns = True # don't run cooldown logic if disable_cooldowns is True - assert _should_run_cooldown_logic(testing_litellm_router, "test_deployment", 500, Exception("Test")) is False + assert ( + _should_run_cooldown_logic(RoutingContext(testing_litellm_router), "test_deployment", 500, Exception("Test")) + is False + ) # don't cooldown if deployment is None testing_litellm_router.disable_cooldowns = False - assert _should_run_cooldown_logic(testing_litellm_router, None, 500, Exception("Test")) is False + assert _should_run_cooldown_logic(RoutingContext(testing_litellm_router), None, 500, Exception("Test")) is False # don't cooldown if it's a provider default deployment testing_litellm_router.provider_default_deployment_ids = ["test_deployment"] - assert _should_run_cooldown_logic(testing_litellm_router, "test_deployment", 500, Exception("Test")) is False + assert ( + _should_run_cooldown_logic(RoutingContext(testing_litellm_router), "test_deployment", 500, Exception("Test")) + is False + ) @pytest.fixture @@ -1893,7 +1890,7 @@ def test_should_run_cooldown_logic_generic_bad_request_excluded_by_default( configured for that exception type. This is the pre-existing, intentional default: a client error is usually not the deployment's fault.""" exc = litellm.BadRequestError("bad request", "openai", "gpt-5-mini") - assert _should_run_cooldown_logic(single_deployment_router, "dep-1", 400, exc) is False + assert _should_run_cooldown_logic(RoutingContext(single_deployment_router), "dep-1", 400, exc) is False @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") @@ -1907,7 +1904,7 @@ def test_should_run_cooldown_logic_router_level_policy_does_not_override_bad_req see test_should_run_cooldown_logic_explicit_deployment_level_policy_overrides_content_policy_exclusion.""" exc = litellm.BadRequestError("bad request", "openai", "gpt-5-mini") single_deployment_router.allowed_fails_policy = AllowedFailsPolicy(BadRequestErrorAllowedFails=5) - assert _should_run_cooldown_logic(single_deployment_router, "dep-1", 400, exc) is False + assert _should_run_cooldown_logic(RoutingContext(single_deployment_router), "dep-1", 400, exc) is False @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") @@ -1919,14 +1916,17 @@ def test_should_run_cooldown_logic_explicit_deployment_level_policy_overrides_co exc = litellm.ContentPolicyViolationError("flagged content", "openai", "gpt-5-mini") deployment_dict = single_deployment_router.get_model_info(id="dep-1") deployment_dict["model_info"]["allowed_fails_policy"] = {"ContentPolicyViolationErrorAllowedFails": 0} - assert _should_run_cooldown_logic(single_deployment_router, "dep-1", 400, exc) is True + assert _should_run_cooldown_logic(RoutingContext(single_deployment_router), "dep-1", 400, exc) is True @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") class TestHasExplicitAllowedFailsPolicyForException: def test_no_policy_anywhere_returns_false(self, single_deployment_router): exc = litellm.BadRequestError("bad request", "openai", "gpt-5-mini") - assert _has_explicit_allowed_fails_policy_for_exception(single_deployment_router, "dep-1", exc) is False + assert ( + _has_explicit_allowed_fails_policy_for_exception(RoutingContext(single_deployment_router), "dep-1", exc) + is False + ) def test_router_level_policy_for_matching_exception_returns_false(self, single_deployment_router): """Deliberately scoped to deployment-level only: a router-level policy @@ -1934,23 +1934,35 @@ class TestHasExplicitAllowedFailsPolicyForException: opt-in for cooldown-gate purposes.""" exc = litellm.RateLimitError("rate limited", "openai", "gpt-5-mini") single_deployment_router.allowed_fails_policy = AllowedFailsPolicy(RateLimitErrorAllowedFails=3) - assert _has_explicit_allowed_fails_policy_for_exception(single_deployment_router, "dep-1", exc) is False + assert ( + _has_explicit_allowed_fails_policy_for_exception(RoutingContext(single_deployment_router), "dep-1", exc) + is False + ) def test_router_level_policy_for_different_exception_returns_false(self, single_deployment_router): exc = litellm.BadRequestError("bad request", "openai", "gpt-5-mini") single_deployment_router.allowed_fails_policy = AllowedFailsPolicy(RateLimitErrorAllowedFails=3) - assert _has_explicit_allowed_fails_policy_for_exception(single_deployment_router, "dep-1", exc) is False + assert ( + _has_explicit_allowed_fails_policy_for_exception(RoutingContext(single_deployment_router), "dep-1", exc) + is False + ) def test_deployment_level_policy_for_matching_exception_returns_true(self, single_deployment_router): exc = litellm.ContentPolicyViolationError("flagged", "openai", "gpt-5-mini") deployment_dict = single_deployment_router.get_model_info(id="dep-1") deployment_dict["model_info"]["allowed_fails_policy"] = {"ContentPolicyViolationErrorAllowedFails": 0} - assert _has_explicit_allowed_fails_policy_for_exception(single_deployment_router, "dep-1", exc) is True + assert ( + _has_explicit_allowed_fails_policy_for_exception(RoutingContext(single_deployment_router), "dep-1", exc) + is True + ) def test_none_deployment_returns_false(self, single_deployment_router): exc = litellm.RateLimitError("rate limited", "openai", "gpt-5-mini") single_deployment_router.allowed_fails_policy = AllowedFailsPolicy(RateLimitErrorAllowedFails=3) - assert _has_explicit_allowed_fails_policy_for_exception(single_deployment_router, None, exc) is False + assert ( + _has_explicit_allowed_fails_policy_for_exception(RoutingContext(single_deployment_router), None, exc) + is False + ) @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") @@ -1960,7 +1972,9 @@ def test_should_cooldown_deployment_rate_limit_error(testing_litellm_router): """ # Test 429 error (rate limit) -> always cooldown a deployment returning 429s _exception = litellm.exceptions.RateLimitError("Rate limit", "openai", "gpt-5-mini") - assert _should_cooldown_deployment(testing_litellm_router, "test_deployment", 429, _exception) is True + assert ( + _should_cooldown_deployment(RoutingContext(testing_litellm_router), "test_deployment", 429, _exception) is True + ) @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") @@ -1970,7 +1984,9 @@ def test_should_cooldown_deployment_auth_limit_error(testing_litellm_router): """ # Test 401 error (auth limit) -> always cooldown a deployment returning 401s _exception = litellm.exceptions.AuthenticationError("Unauthorized", "openai", "gpt-5-mini") - assert _should_cooldown_deployment(testing_litellm_router, "test_deployment", 401, _exception) is True + assert ( + _should_cooldown_deployment(RoutingContext(testing_litellm_router), "test_deployment", 401, _exception) is True + ) @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") @@ -1978,7 +1994,7 @@ def test_should_cooldown_deployment_auth_limit_error(testing_litellm_router): def test_is_cooldown_required_for_account_errors(testing_litellm_router, exception_status): assert ( _is_cooldown_required( - litellm_router_instance=testing_litellm_router, + ctx=RoutingContext(testing_litellm_router), model_id="test_deployment", exception_status=exception_status, ) @@ -1993,15 +2009,17 @@ def test_single_deployment_402_does_not_cooldown( ) -> None: assert ( _should_cooldown_deployment( - Router( - model_list=[ - { - "model_name": "gpt-5-mini", - "litellm_params": {"model": "gpt-5-mini"}, - "model_info": {"id": "dep-1"}, - }, - ], - allowed_fails=allowed_fails, + RoutingContext( + Router( + model_list=[ + { + "model_name": "gpt-5-mini", + "litellm_params": {"model": "gpt-5-mini"}, + "model_info": {"id": "dep-1"}, + }, + ], + allowed_fails=allowed_fails, + ) ), "dep-1", 402, @@ -2019,15 +2037,17 @@ def test_single_deployment_402_does_not_cooldown( def test_single_deployment_402_respects_router_allowed_fails_policy() -> None: assert ( _should_cooldown_deployment( - Router( - model_list=[ - { - "model_name": "gpt-5-mini", - "litellm_params": {"model": "gpt-5-mini"}, - "model_info": {"id": "dep-1"}, - }, - ], - allowed_fails_policy=AllowedFailsPolicy(BadRequestErrorAllowedFails=0), + RoutingContext( + Router( + model_list=[ + { + "model_name": "gpt-5-mini", + "litellm_params": {"model": "gpt-5-mini"}, + "model_info": {"id": "dep-1"}, + }, + ], + allowed_fails_policy=AllowedFailsPolicy(BadRequestErrorAllowedFails=0), + ) ), "dep-1", 402, @@ -2045,17 +2065,19 @@ def test_single_deployment_402_respects_router_allowed_fails_policy() -> None: def test_single_deployment_402_respects_deployment_allowed_fails_policy() -> None: assert ( _should_cooldown_deployment( - Router( - model_list=[ - { - "model_name": "gpt-5-mini", - "litellm_params": {"model": "gpt-5-mini"}, - "model_info": { - "id": "dep-1", - "allowed_fails_policy": {"BadRequestErrorAllowedFails": 0}, + RoutingContext( + Router( + model_list=[ + { + "model_name": "gpt-5-mini", + "litellm_params": {"model": "gpt-5-mini"}, + "model_info": { + "id": "dep-1", + "allowed_fails_policy": {"BadRequestErrorAllowedFails": 0}, + }, }, - }, - ], + ], + ) ), "dep-1", 402, @@ -2073,7 +2095,7 @@ def test_single_deployment_402_respects_deployment_allowed_fails_policy() -> Non def test_multi_deployment_402_cools_down(testing_litellm_router: Router) -> None: assert ( _should_cooldown_deployment( - testing_litellm_router, + RoutingContext(testing_litellm_router), "test_deployment", 402, litellm.PaymentRequiredError( @@ -2100,7 +2122,9 @@ async def test_should_cooldown_deployment(testing_litellm_router): # Test 429 error (rate limit) -> always cooldown a deployment returning 429s _exception = litellm.exceptions.RateLimitError("Rate limit", "openai", "gpt-5-mini") - assert _should_cooldown_deployment(testing_litellm_router, "test_deployment", 429, _exception) is True + assert ( + _should_cooldown_deployment(RoutingContext(testing_litellm_router), "test_deployment", 429, _exception) is True + ) available_deployment = testing_litellm_router.get_available_deployment(model="test_deployment") print("available_deployment", available_deployment) @@ -2112,7 +2136,7 @@ async def test_should_cooldown_deployment(testing_litellm_router): # set current success for deployment to 40 for _ in range(40): increment_deployment_successes_for_current_minute( - litellm_router_instance=testing_litellm_router, deployment_id=deployment_id + ctx=RoutingContext(testing_litellm_router), deployment_id=deployment_id ) # now we fail 40 requests in a row @@ -2134,7 +2158,10 @@ async def test_should_cooldown_deployment(testing_litellm_router): await asyncio.sleep(1) # expect this to fail since it's now 51% of requests are failing - assert _should_cooldown_deployment(testing_litellm_router, deployment_id, 500, Exception("Test")) is True + assert ( + _should_cooldown_deployment(RoutingContext(testing_litellm_router), deployment_id, 500, Exception("Test")) + is True + ) @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") @@ -2159,9 +2186,9 @@ async def test_should_cooldown_deployment_allowed_fails_set_on_router(): # should not cooldown when fails are below the allowed limit for _ in range(100): - assert _should_cooldown_deployment(router, "test_deployment", 500, Exception("Test")) is False + assert _should_cooldown_deployment(RoutingContext(router), "test_deployment", 500, Exception("Test")) is False - assert _should_cooldown_deployment(router, "test_deployment", 500, Exception("Test")) is True + assert _should_cooldown_deployment(RoutingContext(router), "test_deployment", 500, Exception("Test")) is True @pytest.mark.usefixtures("_vcr_outcome_gate", "setup_and_teardown") @@ -2187,11 +2214,11 @@ def test_increment_deployment_successes_for_current_minute_does_not_write_to_red # Call the function we're testing increment_deployment_successes_for_current_minute( - litellm_router_instance=testing_litellm_router, deployment_id="test_deployment" + ctx=RoutingContext(testing_litellm_router), deployment_id="test_deployment" ) increment_deployment_failures_for_current_minute( - litellm_router_instance=testing_litellm_router, deployment_id="test_deployment" + ctx=RoutingContext(testing_litellm_router), deployment_id="test_deployment" ) time.sleep(1) @@ -2239,7 +2266,7 @@ def test_should_cooldown_high_traffic_all_fails(mock_failures, mock_successes, r mock_successes.return_value = 0 should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="gpt-4--0", exception_status=500, original_exception=Exception("Test error"), @@ -2257,7 +2284,7 @@ def test_no_cooldown_low_traffic(mock_failures, mock_successes, router): mock_successes.return_value = 0 should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="gpt-4--0", exception_status=500, original_exception=Exception("Test error"), @@ -2277,7 +2304,7 @@ def test_cooldown_rate_limit(mock_failures, mock_successes, router): mock_successes.return_value = 0 should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="gpt-4--0", exception_status=429, # Rate limit error original_exception=Exception("Rate limit exceeded"), @@ -2295,7 +2322,7 @@ def test_mixed_success_failure(mock_failures, mock_successes, router): mock_successes.return_value = 7 should_cooldown = _should_cooldown_deployment( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="gpt-4--0", exception_status=500, original_exception=Exception("Test error"), @@ -2310,7 +2337,7 @@ def test_is_cooldown_required_empty_string_exception_status(testing_litellm_rout Test that _is_cooldown_required returns False when exception_status is an empty string """ result = _is_cooldown_required( - litellm_router_instance=testing_litellm_router, + ctx=RoutingContext(testing_litellm_router), model_id="test_deployment", exception_status="", ) @@ -2342,13 +2369,15 @@ def test_should_cooldown_deployment_minimum_request_threshold(testing_litellm_ro # Simulate only 1 failure (below minimum threshold) # This should NOT trigger cooldown even though 100% > 50% increment_deployment_failures_for_current_minute( - litellm_router_instance=testing_litellm_router, deployment_id=deployment_id + ctx=RoutingContext(testing_litellm_router), deployment_id=deployment_id ) _exception = litellm.exceptions.InternalServerError("Internal error", "openai", "gpt-5-mini") # With only 1 request, should NOT cooldown (below minimum threshold) - should_cooldown = _should_cooldown_deployment(testing_litellm_router, deployment_id, 500, _exception) + should_cooldown = _should_cooldown_deployment( + RoutingContext(testing_litellm_router), deployment_id, 500, _exception + ) assert should_cooldown is False, ( f"Should NOT cooldown with only 1 failed request (below minimum threshold of {DEFAULT_FAILURE_THRESHOLD_MINIMUM_REQUESTS})" ) @@ -2356,11 +2385,13 @@ def test_should_cooldown_deployment_minimum_request_threshold(testing_litellm_ro # Now add more failures to reach the minimum threshold for _ in range(DEFAULT_FAILURE_THRESHOLD_MINIMUM_REQUESTS - 1): increment_deployment_failures_for_current_minute( - litellm_router_instance=testing_litellm_router, deployment_id=deployment_id + ctx=RoutingContext(testing_litellm_router), deployment_id=deployment_id ) # Now with enough requests (all failures), it SHOULD trigger cooldown - should_cooldown = _should_cooldown_deployment(testing_litellm_router, deployment_id, 500, _exception) + should_cooldown = _should_cooldown_deployment( + RoutingContext(testing_litellm_router), deployment_id, 500, _exception + ) assert should_cooldown is True, ( f"Should cooldown when we have {DEFAULT_FAILURE_THRESHOLD_MINIMUM_REQUESTS} failed requests (100% failure rate)" ) @@ -2446,7 +2477,7 @@ async def test_cooldown_time_zero_uses_zero_not_default(): mock_add_cooldown.assert_not_called() - cooldown_list = await async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) + cooldown_list = await async_get_cooldown_deployments(ctx=RoutingContext(router), parent_otel_span=None) assert len(cooldown_list) == 0 healthy_deployments, _ = await router._async_get_healthy_deployments(model="gpt-3.5-turbo", parent_otel_span=None) @@ -2473,7 +2504,7 @@ def test_should_run_cooldown_logic_early_exit_on_zero_cooldown(): ) result = _should_run_cooldown_logic( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="test-deployment-id", exception_status=429, original_exception=litellm.RateLimitError("test error", "openai", "gpt-3.5-turbo"), @@ -2482,7 +2513,7 @@ def test_should_run_cooldown_logic_early_exit_on_zero_cooldown(): assert result is False, "Should not run cooldown logic when time_to_cooldown is 0" result = _should_run_cooldown_logic( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="test-deployment-id", exception_status=429, original_exception=litellm.RateLimitError("test error", "openai", "gpt-3.5-turbo"), @@ -2491,7 +2522,7 @@ def test_should_run_cooldown_logic_early_exit_on_zero_cooldown(): assert result is False, "Should not run cooldown logic when time_to_cooldown is effectively 0" result = _should_run_cooldown_logic( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="test-deployment-id", exception_status=429, original_exception=litellm.RateLimitError("test error", "openai", "gpt-3.5-turbo"), @@ -2500,7 +2531,7 @@ def test_should_run_cooldown_logic_early_exit_on_zero_cooldown(): assert result is True, "Should run cooldown logic when time_to_cooldown is None" result = _should_run_cooldown_logic( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="test-deployment-id", exception_status=429, original_exception=litellm.RateLimitError("test error", "openai", "gpt-3.5-turbo"), @@ -2675,7 +2706,7 @@ async def test_high_traffic_cooldowns_all_healthy_deployments(): raise e print("model_stats: ", model_stats) - cooldown_list = await async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) + cooldown_list = await async_get_cooldown_deployments(ctx=RoutingContext(router), parent_otel_span=None) assert len(cooldown_list) == 0 @@ -2769,7 +2800,7 @@ async def test_high_traffic_cooldowns_one_bad_deployment(): raise e print("model_stats: ", model_stats) - cooldown_list = await async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) + cooldown_list = await async_get_cooldown_deployments(ctx=RoutingContext(router), parent_otel_span=None) assert len(cooldown_list) == 1 @@ -2866,7 +2897,7 @@ async def test_high_traffic_cooldowns_one_rate_limited_deployment(): raise e print("model_stats: ", model_stats) - cooldown_list = await async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) + cooldown_list = await async_get_cooldown_deployments(ctx=RoutingContext(router), parent_otel_span=None) assert len(cooldown_list) == 1 @@ -2932,7 +2963,7 @@ async def test_router_fallbacks_with_cooldowns_and_dynamic_credentials(): model="gpt-3.5-turbo", messages=messages, api_key="my-bad-key-1", mock_response="litellm.RateLimitError" ) await asyncio.sleep(1) - assert await async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) == [] + assert await async_get_cooldown_deployments(ctx=RoutingContext(router), parent_otel_span=None) == [] response = await router.acompletion( model="gpt-3.5-turbo", messages=messages, api_key="my-good-key-2", mock_response="served with credential 2" @@ -2942,7 +2973,7 @@ async def test_router_fallbacks_with_cooldowns_and_dynamic_credentials(): with pytest.raises(litellm.RateLimitError): await router.acompletion(model="gpt-3.5-turbo", messages=messages, mock_response="litellm.RateLimitError") await asyncio.sleep(1) - cooled_down = await async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) + cooled_down = await async_get_cooldown_deployments(ctx=RoutingContext(router), parent_otel_span=None) assert len(cooled_down) == 1 and cooled_down[0] in {"123", "456"} @@ -2959,7 +2990,7 @@ async def test_router_fallbacks_with_cooldowns_and_dynamic_credentials(): def test_caller_credential_errors_never_cool_down_the_shared_deployment(single_deployment_router, exception, status): """A per-user credential failure is scoped to one caller's stored token; cooling down the shared deployment would punish every other user on the group.""" - assert _should_run_cooldown_logic(single_deployment_router, "dep-1", status, exception) is False + assert _should_run_cooldown_logic(RoutingContext(single_deployment_router), "dep-1", status, exception) is False @pytest.mark.asyncio @@ -3000,7 +3031,7 @@ async def test_bad_request_error_does_not_cool_down_a_deployment( ) cooldown_deployments: Final = await async_get_cooldown_deployments( - litellm_router_instance=router, + ctx=RoutingContext(router), parent_otel_span=None, ) @@ -3065,7 +3096,7 @@ async def test_fallback_deployment_stays_up_while_the_primary_is_in_cooldown( served_by: Final = [await _complete_like_the_proxy(router, "primary") for _ in range(20)] cooldown_deployments: Final = await async_get_cooldown_deployments( - litellm_router_instance=router, + ctx=RoutingContext(router), parent_otel_span=None, ) @@ -3098,7 +3129,7 @@ async def test_fallback_group_stays_up_after_a_bad_key_cools_the_primary_under_t served_by: Final = [await _complete_like_the_proxy(router, "primary") for _ in range(12)] cooldown_deployments: Final = await async_get_cooldown_deployments( - litellm_router_instance=router, + ctx=RoutingContext(router), parent_otel_span=None, ) @@ -3206,7 +3237,7 @@ def test_has_fallback_group_reads_string_targets_and_skips_unparseable_entries( router: Final = Router(model_list=[TIMED_OUT_DEPLOYMENT]) router.fallbacks = list(fallbacks) - assert _has_fallback_group(router, "test-model") is expected + assert _has_fallback_group(RoutingContext(router), "test-model") is expected async def _group_call_outcome(router: Router) -> str: @@ -3239,7 +3270,7 @@ async def test_router_allowed_fails_still_benches_a_deployment_that_has_a_siblin while len(timed_out.calls) < 2: await _group_call_outcome(router) cooldown_deployments: Final = await async_get_cooldown_deployments( - litellm_router_instance=router, parent_otel_span=None + ctx=RoutingContext(router), parent_otel_span=None ) served: Final = tuple([await _group_call_outcome(router) for _ in range(5)]) @@ -3264,7 +3295,9 @@ def test_per_user_session_upstream_errors_never_cool_down_the_shared_deployment( (litellm.InternalServerError("copilot 500", "github_copilot", "gpt-4o"), 500), ): assert ( - _should_run_cooldown_logic(single_deployment_router, "dep-1", status, exc, request_kwargs=session_kwargs) + _should_run_cooldown_logic( + RoutingContext(single_deployment_router), "dep-1", status, exc, request_kwargs=session_kwargs + ) is False ) @@ -3275,11 +3308,15 @@ def test_shared_mode_upstream_429_still_cools_down_the_deployment(single_deploym exc = litellm.RateLimitError("copilot 429", "github_copilot", "gpt-4o") assert ( _should_run_cooldown_logic( - single_deployment_router, "dep-1", 429, exc, request_kwargs={"model": "github_copilot/gpt-4o"} + RoutingContext(single_deployment_router), + "dep-1", + 429, + exc, + request_kwargs={"model": "github_copilot/gpt-4o"}, ) is True ) - assert _should_run_cooldown_logic(single_deployment_router, "dep-1", 429, exc) is True + assert _should_run_cooldown_logic(RoutingContext(single_deployment_router), "dep-1", 429, exc) is True REFUSAL_MESSAGES: Final = [{"role": "user", "content": "cooldown"}] diff --git a/tests/unit/router_utils/test_deployment_pricing.py b/tests/unit/router_utils/test_deployment_pricing.py index 45cc211a89c..96a9436fcd1 100644 --- a/tests/unit/router_utils/test_deployment_pricing.py +++ b/tests/unit/router_utils/test_deployment_pricing.py @@ -1,6 +1,6 @@ import pytest -from litellm.router_utils.deployment_pricing import deployment_pricing_models, pricing_models +from litellm.litellm_core_utils.deployment_pricing import deployment_pricing_models, pricing_models @pytest.mark.parametrize( diff --git a/tests/unit/router_utils/test_fallback_event_handlers.py b/tests/unit/router_utils/test_fallback_event_handlers.py index c5a476c450b..26dbb96c60a 100644 --- a/tests/unit/router_utils/test_fallback_event_handlers.py +++ b/tests/unit/router_utils/test_fallback_event_handlers.py @@ -20,6 +20,7 @@ from litellm.llms.anthropic.messages.native.fake_stream_iterator import FakeAnth from litellm.litellm_core_utils import get_llm_provider_logic from litellm.litellm_core_utils.litellm_logging import Logging from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper +from litellm.router_api import RouterSettings, RoutingContext from litellm.router_utils.cooldown_handlers import async_get_cooldown_deployments, mark_advisor_orchestration_failure from litellm.types.utils import Choices, Message, ModelResponse, StandardLoggingPayload, Usage from litellm.router_utils.fallback_event_handlers import ( @@ -58,24 +59,28 @@ class StreamingWrapper: self._hidden_params = {"additional_headers": {}} -class FakeRouter: +class RouterDouble: + """The router members RoutingContext forwards to during a fallback: the fallback checks, the retry log and + the fallback loop (async_function_with_fallbacks, defined by each double).""" + fallback_access_check = None fallback_budget_check = None - def log_retry(self, kwargs, e): + def settings(self) -> RouterSettings: + return RouterSettings( + fallback_access_check=self.fallback_access_check, fallback_budget_check=self.fallback_budget_check + ) + + def _core_log_retry(self, kwargs, e): return kwargs + +class FakeRouter(RouterDouble): async def async_function_with_fallbacks(self, *args, **kwargs): return StreamingWrapper() -class AlwaysFailRouter: - fallback_access_check = None - fallback_budget_check = None - - def log_retry(self, kwargs, e): - return kwargs - +class AlwaysFailRouter(RouterDouble): async def async_function_with_fallbacks(self, *args, **kwargs): raise RuntimeError("fallback model also failed") @@ -83,7 +88,7 @@ class AlwaysFailRouter: @pytest.mark.asyncio async def test_run_async_fallback_adds_errors_when_opted_in(): response = await run_async_fallback( - litellm_router=FakeRouter(), + litellm_routing_ctx=RoutingContext(FakeRouter()), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("upstream limited request"), @@ -107,7 +112,7 @@ async def test_run_async_fallback_adds_errors_when_opted_in(): @pytest.mark.asyncio async def test_run_async_fallback_omits_errors_without_opt_in(): response = await run_async_fallback( - litellm_router=FakeRouter(), + litellm_routing_ctx=RoutingContext(FakeRouter()), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("upstream limited request"), @@ -124,7 +129,7 @@ async def test_run_async_fallback_omits_errors_without_opt_in(): async def test_run_async_fallback_raises_when_all_fallbacks_fail(): with pytest.raises(RuntimeError, match="fallback model also failed"): await run_async_fallback( - litellm_router=AlwaysFailRouter(), + litellm_routing_ctx=RoutingContext(AlwaysFailRouter()), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("original request failed"), @@ -134,16 +139,10 @@ async def test_run_async_fallback_raises_when_all_fallbacks_fail(): ) -class RecordingRouter: - fallback_access_check = None - fallback_budget_check = None - +class RecordingRouter(RouterDouble): def __init__(self): self.received_kwargs = None - def log_retry(self, kwargs, e): - return kwargs - async def async_function_with_fallbacks(self, *args, **kwargs): self.received_kwargs = kwargs return StreamingWrapper() @@ -211,7 +210,7 @@ async def test_run_async_fallback_opens_the_hop_without_the_superseded_attempts_ logging_obj.record_partial_usage_for_failure(partial_usage, 0.01) await run_async_fallback( - litellm_router=HopLoggingItsOwnSuccessRouter(), + litellm_routing_ctx=RoutingContext(HopLoggingItsOwnSuccessRouter()), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("stream dropped before content"), @@ -234,7 +233,7 @@ async def test_run_async_fallback_preserves_superseded_usage_when_hop_fails_befo with pytest.raises(RuntimeError, match="fallback model also failed"): await run_async_fallback( - litellm_router=AlwaysFailRouter(), + litellm_routing_ctx=RoutingContext(AlwaysFailRouter()), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("stream dropped before content"), @@ -325,7 +324,7 @@ async def test_run_async_fallback_cools_down_a_failed_hop_once(failure_already_l with pytest.raises(_RateLimitedHop): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("stream dropped before content"), @@ -336,7 +335,7 @@ async def test_run_async_fallback_cools_down_a_failed_hop_once(failure_already_l metadata={}, ) - cooled_down: Final = await async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) + cooled_down: Final = await async_get_cooldown_deployments(ctx=RoutingContext(router), parent_otel_span=None) assert cooled_down == (["fallback-dep-1"] if failure_already_logged else []) @@ -348,7 +347,7 @@ async def test_run_async_fallback_cools_down_the_final_deployment_after_retry_fa with pytest.raises(_RateLimitedHop): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("stream dropped before content"), @@ -359,7 +358,7 @@ async def test_run_async_fallback_cools_down_the_final_deployment_after_retry_fa ) assert logging_obj.model_call_details.get("has_logged_async_failure", False) is True - cooled_down: Final = await async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) + cooled_down: Final = await async_get_cooldown_deployments(ctx=RoutingContext(router), parent_otel_span=None) assert cooled_down == ["fallback-dep-2"] @@ -369,7 +368,7 @@ async def test_run_async_fallback_forwards_include_fallback_errors_to_nested_cal flag has to reach the nested async_function_with_fallbacks call.""" router = RecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("upstream limited request"), @@ -385,7 +384,7 @@ async def test_run_async_fallback_forwards_include_fallback_errors_to_nested_cal async def test_run_async_fallback_does_not_forward_flag_without_opt_in(): router = RecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("upstream limited request"), @@ -399,7 +398,7 @@ async def test_run_async_fallback_does_not_forward_flag_without_opt_in(): @pytest.mark.asyncio async def test_run_async_fallback_skips_original_model_group(): response = await run_async_fallback( - litellm_router=FakeRouter(), + litellm_routing_ctx=RoutingContext(FakeRouter()), fallback_model_group=["primary-model", "fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("original failed"), @@ -410,17 +409,11 @@ async def test_run_async_fallback_skips_original_model_group(): assert response._hidden_params["additional_headers"]["x-litellm-attempted-fallbacks"] == 1 -class AttemptRecordingRouter: - fallback_access_check = None - fallback_budget_check = None - +class AttemptRecordingRouter(RouterDouble): def __init__(self): self.attempted_model_groups = [] self.received_kwargs = None - def log_retry(self, kwargs, e): - return kwargs - async def async_function_with_fallbacks(self, *args, **kwargs): self.attempted_model_groups.append(kwargs.get("model")) self.received_kwargs = kwargs @@ -468,7 +461,7 @@ async def test_run_async_fallback_keeps_uploaded_file_requests_in_their_model_gr with pytest.raises(RuntimeError, match="openai connection error"): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["azure-group"], original_model_group="openai-group", original_exception=owning_provider_error, @@ -488,7 +481,7 @@ async def test_run_async_fallback_keeps_fine_tuning_requests_in_their_model_grou with pytest.raises(RuntimeError, match="openai connection error"): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["azure-group"], original_model_group="openai-group", original_exception=RuntimeError("openai connection error"), @@ -509,7 +502,7 @@ async def test_run_async_fallback_allows_same_model_group_retry_for_uploaded_fil router = AttemptRecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=[{"model": "openai-group", "_target_order": 2}], original_model_group="openai-group", original_exception=RuntimeError("first deployment failed"), @@ -532,7 +525,7 @@ async def test_run_async_fallback_keeps_file_creation_in_its_model_group(): with pytest.raises(RuntimeError, match="azure connection error"): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["openai-group"], original_model_group="azure-group", original_exception=RuntimeError("azure connection error"), @@ -550,7 +543,7 @@ async def test_run_async_fallback_allows_same_model_group_retry_for_file_creatio router = AttemptRecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=[{"model": "azure-group", "_target_order": 2}], original_model_group="azure-group", original_exception=RuntimeError("first deployment failed"), @@ -568,7 +561,7 @@ async def test_run_async_fallback_still_crosses_model_groups_without_an_uploaded router = AttemptRecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["azure-group"], original_model_group="openai-group", original_exception=RuntimeError("openai connection error"), @@ -612,7 +605,7 @@ async def test_run_async_fallback_keeps_provider_scoped_ids_in_their_model_group with pytest.raises(RuntimeError, match="openai connection error"): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["azure-group"], original_model_group="openai-group", original_exception=RuntimeError("openai connection error"), @@ -635,7 +628,7 @@ async def test_run_async_fallback_ignores_stray_resource_ids_on_completion_calls router = AttemptRecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["azure-group"], original_model_group="openai-group", original_exception=RuntimeError("openai connection error"), @@ -654,7 +647,7 @@ async def test_run_async_fallback_allows_same_model_group_retry_for_batch_cancel router = AttemptRecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=[{"model": "openai-group", "_target_order": 2}], original_model_group="openai-group", original_exception=RuntimeError("first deployment failed"), @@ -675,7 +668,7 @@ async def test_run_async_fallback_handles_explicitly_none_metadata(): router = AttemptRecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["azure-group"], original_model_group="openai-group", original_exception=RuntimeError("openai connection error"), @@ -699,7 +692,7 @@ async def test_run_async_fallback_records_batch_model_group_outside_provider_met router = AttemptRecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=[{"model": "openai-group", "_target_order": 2}], original_model_group="openai-group", original_exception=RuntimeError("first deployment failed"), @@ -724,8 +717,8 @@ class AccessCheckedRouter(AttemptRecordingRouter): fallback_budget_check = None - async def fallback_access_check(self, *, model, request_kwargs, llm_router): - self.access_checks.append((model, request_kwargs["metadata"]["user_api_key"], llm_router is self)) + async def fallback_access_check(self, *, model, request_kwargs, ctx): + self.access_checks.append((model, request_kwargs["metadata"]["user_api_key"], ctx.belongs_to(self))) return model in self.allowed_models @@ -734,7 +727,7 @@ async def test_run_async_fallback_skips_targets_the_access_check_rejects(): router = AccessCheckedRouter(allowed_models=frozenset({"allowed-model"})) await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=[ {"model": "secret-model", "messages": [{"role": "user", "content": "hi"}]}, "allowed-model", @@ -754,13 +747,39 @@ async def test_run_async_fallback_skips_targets_the_access_check_rejects(): ] +class LegacyAccessCheckedRouter(AccessCheckedRouter): + async def fallback_access_check(self, *, model, request_kwargs, llm_router): + self.access_checks.append((model, request_kwargs["metadata"]["user_api_key"], llm_router is self)) + return model in self.allowed_models + + +@pytest.mark.asyncio +async def test_run_async_fallback_still_runs_a_deprecated_llm_router_access_check(): + router = LegacyAccessCheckedRouter(allowed_models=frozenset({"allowed-model"})) + + with pytest.warns(DeprecationWarning, match="llm_router"): + await run_async_fallback( + litellm_routing_ctx=RoutingContext(router), + fallback_model_group=["secret-model", "allowed-model"], + original_model_group="primary-model", + original_exception=RuntimeError("primary failed"), + max_fallbacks=3, + fallback_depth=0, + model="primary-model", + metadata={"user_api_key": "hashed"}, + ) + + assert router.attempted_model_groups == ["allowed-model"] + assert router.access_checks == [("secret-model", "hashed", True), ("allowed-model", "hashed", True)] + + @pytest.mark.asyncio async def test_run_async_fallback_raises_original_error_when_no_target_is_authorized(): router = AccessCheckedRouter(allowed_models=frozenset()) with pytest.raises(RuntimeError, match="primary failed"): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["secret-model", "other-secret-model"], original_model_group="primary-model", original_exception=RuntimeError("primary failed"), @@ -779,7 +798,7 @@ async def test_run_async_fallback_does_not_consult_access_check_for_same_model_g router = AccessCheckedRouter(allowed_models=frozenset()) await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=[{"model": "primary-model", "_target_order": 2}], original_model_group="primary-model", original_exception=RuntimeError("first order level failed"), @@ -793,16 +812,10 @@ async def test_run_async_fallback_does_not_consult_access_check_for_same_model_g assert router.access_checks == [] -class RecordingFailRouter: - fallback_access_check = None - fallback_budget_check = None - +class RecordingFailRouter(RouterDouble): def __init__(self): self.attempted_models = [] - def log_retry(self, kwargs, e): - return kwargs - async def async_function_with_fallbacks(self, *args, **kwargs): self.attempted_models.append(kwargs.get("model")) raise RuntimeError("fallback model also failed") @@ -818,7 +831,7 @@ async def test_run_async_fallback_skips_model_group_already_attempted(): with pytest.raises(RuntimeError, match="original failed"): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["already-attempted"], original_model_group="primary-model", original_exception=RuntimeError("original failed"), @@ -836,7 +849,7 @@ async def test_run_async_fallback_attempts_a_repeated_target_once(): with pytest.raises(RuntimeError, match="fallback model also failed"): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["fallback-model", "fallback-model", "other-model"], original_model_group="primary-model", original_exception=RuntimeError("original failed"), @@ -855,7 +868,7 @@ async def test_run_async_fallback_forwards_attempted_model_groups_to_nested_call router = RecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("original failed"), @@ -876,7 +889,7 @@ async def test_run_async_fallback_can_target_the_requested_group_when_a_pre_rout router = RecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["requested-model"], original_model_group="requested-model", original_exception=RuntimeError("selected tier failed"), @@ -905,7 +918,7 @@ async def test_run_async_fallback_still_retargets_the_same_group_via_dict_entry( router = RecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=[entry], original_model_group="primary-model", original_exception=RuntimeError("original failed"), @@ -926,7 +939,7 @@ async def test_run_async_fallback_skips_a_repeated_dict_target(): with pytest.raises(RuntimeError, match="original failed"): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=[{"model": "already-attempted"}], original_model_group="primary-model", original_exception=RuntimeError("original failed"), @@ -945,7 +958,7 @@ async def test_run_async_fallback_attempts_a_repeated_dict_target_once(): with pytest.raises(RuntimeError, match="fallback model also failed"): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=[entry, entry, {"model": "other-model"}], original_model_group="primary-model", original_exception=RuntimeError("original failed"), @@ -965,7 +978,7 @@ async def test_run_async_fallback_keeps_a_request_override_distinct_from_the_bar with pytest.raises(RuntimeError, match="fallback model also failed"): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=[{"model": "already-attempted", "messages": [{"role": "user", "content": "shorter"}]}], original_model_group="primary-model", original_exception=RuntimeError("original failed"), @@ -1028,17 +1041,24 @@ def test_get_fallback_model_group_does_not_mutate_fallbacks(): assert fallbacks == [{"gpt-3.5-turbo": ["claude-3-haiku"]}, "gpt-4o-mini"] +def _cooldown_ctx(*, cooldown_time: float = 60.0, deployment_dict: Mapping[str, object] | None = None) -> MagicMock: + """A RoutingContext double for the fallback cooldown trigger: no deployment, this model info, this cooldown time.""" + ctx: Final = MagicMock() + ctx.registry.return_value.deployment.return_value = None + ctx.registry.return_value.deployment_dict.return_value = deployment_dict + ctx.settings.return_value.cooldown_time = cooldown_time + return ctx + + class TestTriggerCooldownForFailedDeployment: def test_calls_set_cooldown_deployments_with_stamped_deployment_id(self): - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _cooldown_ctx(cooldown_time=60.0) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: - _trigger_cooldown_for_failed_deployment(litellm_router=mock_router, kwargs={}, exception=exc) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs={}, exception=exc) mock_set_cooldown.assert_called_once() call_kwargs = mock_set_cooldown.call_args[1] @@ -1050,9 +1070,7 @@ class TestTriggerCooldownForFailedDeployment: one without knowing this call's function_name, so a client with permission to set metadata must not be able to get an arbitrary deployment cooled down by forging a deployment_model_name marker.""" - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _cooldown_ctx(cooldown_time=60.0) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") kwargs = { @@ -1063,7 +1081,7 @@ class TestTriggerCooldownForFailedDeployment: } with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: - _trigger_cooldown_for_failed_deployment(litellm_router=mock_router, kwargs=kwargs, exception=exc) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs=kwargs, exception=exc) mock_set_cooldown.assert_not_called() @@ -1071,9 +1089,7 @@ class TestTriggerCooldownForFailedDeployment: """The fallback path must feed the same per-minute failure counter the primary path uses, or repeated fallback failures never accumulate toward the default percent-fail-rate cooldown threshold.""" - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _cooldown_ctx(cooldown_time=60.0) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" @@ -1084,47 +1100,39 @@ class TestTriggerCooldownForFailedDeployment: "litellm.router_utils.fallback_event_handlers.increment_deployment_failures_for_current_minute" ) as mock_increment, ): - _trigger_cooldown_for_failed_deployment(litellm_router=mock_router, kwargs={}, exception=exc) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs={}, exception=exc) - mock_increment.assert_called_once_with( - litellm_router_instance=mock_router, deployment_id="fallback-deployment" - ) + mock_increment.assert_called_once_with(ctx=ctx, deployment_id="fallback-deployment") mock_set_cooldown.assert_called_once() def test_no_op_when_deployment_id_missing(self): - mock_router = MagicMock() + ctx = _cooldown_ctx() with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: - _trigger_cooldown_for_failed_deployment( - litellm_router=mock_router, kwargs={}, exception=RuntimeError("no metadata") - ) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs={}, exception=RuntimeError("no metadata")) mock_set_cooldown.assert_not_called() def test_skipped_for_advisor_orchestration_failure(self): - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _cooldown_ctx(cooldown_time=60.0) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" mark_advisor_orchestration_failure(exc) with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: - _trigger_cooldown_for_failed_deployment(litellm_router=mock_router, kwargs={}, exception=exc) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs={}, exception=exc) mock_set_cooldown.assert_not_called() def test_uses_deployment_litellm_params_cooldown_time_override(self): - mock_router = MagicMock() - mock_router.cooldown_time = 300.0 - mock_router.get_model_info.return_value = {"litellm_params": {"cooldown_time": 30.0}} + ctx = _cooldown_ctx(cooldown_time=300.0, deployment_dict={"litellm_params": {"cooldown_time": 30.0}}) exc = litellm.RateLimitError("Rate limit", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: - _trigger_cooldown_for_failed_deployment(litellm_router=mock_router, kwargs={}, exception=exc) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs={}, exception=exc) call_kwargs = mock_set_cooldown.call_args[1] assert call_kwargs["time_to_cooldown"] == 30.0 @@ -1133,24 +1141,20 @@ class TestTriggerCooldownForFailedDeployment: """Precedence must match Router.deployment_callback_on_failure's primary path: deployment config, then the response's Retry-After header, then the router default.""" - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = {"litellm_params": {}} + ctx = _cooldown_ctx(cooldown_time=60.0, deployment_dict={"litellm_params": {}}) exc = RuntimeError("upstream error") exc.failed_deployment_id = "fallback-deployment" exc.litellm_response_headers = httpx.Headers({"retry-after": "45"}) with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: - _trigger_cooldown_for_failed_deployment(litellm_router=mock_router, kwargs={}, exception=exc) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs={}, exception=exc) call_kwargs = mock_set_cooldown.call_args[1] assert call_kwargs["time_to_cooldown"] == 45 def test_silently_catches_exceptions(self): - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _cooldown_ctx(cooldown_time=60.0) exc = RuntimeError("upstream error") exc.failed_deployment_id = "fallback-deployment" @@ -1159,16 +1163,14 @@ class TestTriggerCooldownForFailedDeployment: "litellm.router_utils.fallback_event_handlers.set_cooldown_deployments", side_effect=RuntimeError("cooldown error"), ): - _trigger_cooldown_for_failed_deployment(litellm_router=mock_router, kwargs={}, exception=exc) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs={}, exception=exc) def test_skips_request_scoped_404_on_generic_api_call(self): """A generic API call (files/batches/threads/rerank/...) forwards a caller-supplied resource id, so a 404 there means "that id doesn't exist", not "this deployment is unhealthy". Without this guard, a single bad id would 404 every deployment in the fallback chain and cool all of them down from one request.""" - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _cooldown_ctx(cooldown_time=60.0) exc = litellm.NotFoundError("not found", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" @@ -1180,7 +1182,7 @@ class TestTriggerCooldownForFailedDeployment: ) as mock_increment, ): _trigger_cooldown_for_failed_deployment( - litellm_router=mock_router, + ctx=ctx, kwargs={"original_generic_function": MagicMock()}, exception=exc, ) @@ -1192,15 +1194,13 @@ class TestTriggerCooldownForFailedDeployment: """The request-scoped-404 guard is scoped to generic API calls only: a 404 on a regular completion fallback (no original_generic_function in kwargs) must still cool down the deployment as before.""" - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _cooldown_ctx(cooldown_time=60.0) exc = litellm.NotFoundError("not found", "openai", "gpt-4") exc.failed_deployment_id = "fallback-deployment" with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: - _trigger_cooldown_for_failed_deployment(litellm_router=mock_router, kwargs={}, exception=exc) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs={}, exception=exc) mock_set_cooldown.assert_called_once() @@ -1213,9 +1213,7 @@ class TestTriggerCooldownForFailedDeployment: The failure logger never stamps end_time for a fallback hop (has_logged_async_failure is already set), so model_call_details still carries the previous hop's end_time, which predates this hop's api_call_start_time. The guard must not trust it.""" - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _cooldown_ctx(cooldown_time=60.0) exc = litellm.Timeout(message="timeout", model="gpt-4", llm_provider="openai") exc.failed_deployment_id = "fallback-deployment" @@ -1227,7 +1225,7 @@ class TestTriggerCooldownForFailedDeployment: ) as mock_increment, ): _trigger_cooldown_for_failed_deployment( - litellm_router=mock_router, + ctx=ctx, kwargs={"client_side_timeout": True}, exception=exc, model_call_details={ @@ -1271,7 +1269,7 @@ class TestTriggerCooldownForFailedDeployment: started = datetime.now() _trigger_cooldown_for_failed_deployment( - litellm_router=router, + ctx=RoutingContext(router), kwargs={"client_side_timeout": True}, exception=exc, model_call_details={ @@ -1282,9 +1280,7 @@ class TestTriggerCooldownForFailedDeployment: ) assert ( - get_deployment_failures_for_current_minute( - litellm_router_instance=router, deployment_id="fallback-deployment" - ) + get_deployment_failures_for_current_minute(ctx=RoutingContext(router), deployment_id="fallback-deployment") == 1 ) active = router.cooldown_cache.get_active_cooldowns(model_ids=["fallback-deployment"], parent_otel_span=None) @@ -1294,15 +1290,13 @@ class TestTriggerCooldownForFailedDeployment: """The client-side-timeout guard is scoped to caller-supplied timeouts only: a 408 that did not come from x-litellm-timeout (no client_side_timeout in kwargs) must still cool down the deployment as before.""" - mock_router = MagicMock() - mock_router.cooldown_time = 60.0 - mock_router.get_model_info.return_value = None + ctx = _cooldown_ctx(cooldown_time=60.0) exc = litellm.Timeout(message="timeout", model="gpt-4", llm_provider="openai") exc.failed_deployment_id = "fallback-deployment" with patch("litellm.router_utils.fallback_event_handlers.set_cooldown_deployments") as mock_set_cooldown: - _trigger_cooldown_for_failed_deployment(litellm_router=mock_router, kwargs={}, exception=exc) + _trigger_cooldown_for_failed_deployment(ctx=ctx, kwargs={}, exception=exc) mock_set_cooldown.assert_called_once() @@ -1368,26 +1362,14 @@ async def test_a_fallback_deployment_whose_stream_stalled_stays_out_of_cooldown( ) error.failed_deployment_id = "fallback-deployment" - _trigger_cooldown_for_failed_deployment(litellm_router=router, kwargs={}, exception=error) + _trigger_cooldown_for_failed_deployment(ctx=RoutingContext(router), kwargs={}, exception=error) active: Final = router.cooldown_cache.get_active_cooldowns(model_ids=["fallback-deployment"], parent_otel_span=None) assert tuple(entry[0] for entry in active) == cooled class TestRunAsyncFallbackTriggersCooldown: - class RouterWithLoggingKwarg: - fallback_access_check = None - fallback_budget_check = None - - def __init__(self): - self.cooldown_time = 60.0 - - def log_retry(self, kwargs, e): - return kwargs - - def get_model_info(self, id): - return None - + class RouterWithLoggingKwarg(RouterDouble): async def async_function_with_fallbacks(self, *args, **kwargs): logging_obj: Final = kwargs.get("litellm_logging_obj") if isinstance(logging_obj, Logging): @@ -1410,7 +1392,7 @@ class TestRunAsyncFallbackTriggersCooldown: ) as mock_trigger: with pytest.raises(RuntimeError, match="fallback model also failed"): await run_async_fallback( - litellm_router=self.RouterWithLoggingKwarg(), + litellm_routing_ctx=RoutingContext(self.RouterWithLoggingKwarg()), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("original request failed"), @@ -1432,7 +1414,7 @@ class TestRunAsyncFallbackTriggersCooldown: ) as mock_trigger: with pytest.raises(RuntimeError, match="fallback model also failed"): await run_async_fallback( - litellm_router=self.RouterWithLoggingKwarg(), + litellm_routing_ctx=RoutingContext(self.RouterWithLoggingKwarg()), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("original request failed"), @@ -1450,7 +1432,7 @@ class TestRunAsyncFallbackTriggersCooldown: ) as mock_trigger: with pytest.raises(RuntimeError, match="fallback model also failed"): await run_async_fallback( - litellm_router=self.RouterWithLoggingKwarg(), + litellm_routing_ctx=RoutingContext(self.RouterWithLoggingKwarg()), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("original request failed"), @@ -1472,7 +1454,7 @@ async def test_a_stored_fallback_target_cannot_carry_a_federation_field(): match="server-owned workload identity federation or OAuth token exchange parameter", ): await run_async_fallback( - litellm_router=FakeRouter(), + litellm_routing_ctx=RoutingContext(FakeRouter()), fallback_model_group=[{"model": "anthropic-backup", "anthropic_federation_workspace_id": "wrkspc_other"}], original_model_group="primary-model", original_exception=RuntimeError("upstream limited request"), @@ -1487,7 +1469,7 @@ async def test_a_stored_fallback_target_cannot_carry_an_openai_federation_field( naming a token file would pick which workload assertion is exchanged for the bearer.""" with pytest.raises(ValueError, match="openai_identity_token_file"): await run_async_fallback( - litellm_router=FakeRouter(), + litellm_routing_ctx=RoutingContext(FakeRouter()), fallback_model_group=[ {"model": "openai-backup", "openai_identity_token_file": "/var/run/secrets/tokens/other"} ], @@ -1526,7 +1508,7 @@ async def test_a_stored_fallback_target_cannot_make_the_proxy_read_an_oidc_api_k with pytest.raises(ValueError, match="oidc/"): await run_async_fallback( - litellm_router=FakeRouter(), + litellm_routing_ctx=RoutingContext(FakeRouter()), fallback_model_group=[target], original_model_group="primary-model", original_exception=RuntimeError("upstream limited request"), @@ -1541,7 +1523,7 @@ async def test_the_refusal_is_not_swallowed_as_a_fallback_error(): that target's failure and the run would quietly continue to the next one.""" with pytest.raises(ValueError, match="anthropic_issuer_signing_key_ref"): await run_async_fallback( - litellm_router=FakeRouter(), + litellm_routing_ctx=RoutingContext(FakeRouter()), fallback_model_group=[ {"model": "anthropic-backup", "anthropic_issuer_signing_key_ref": "os.environ/ADMIN_KEY"}, "a-perfectly-fine-model", @@ -1560,7 +1542,7 @@ async def test_run_async_fallback_stamps_fallback_info_into_metadata(): router = RecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["fallback-model"], original_model_group="primary-model", original_exception=RuntimeError("original failed"), @@ -1581,7 +1563,7 @@ async def test_run_async_fallback_preserves_original_model_group_on_nested_fallb router = RecordingRouter() await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), fallback_model_group=["second-fallback"], original_model_group="first-fallback", original_exception=RuntimeError("first fallback failed"), @@ -2592,7 +2574,7 @@ async def test_run_async_fallback(function_name): request_kwargs["messages"] = [{"role": "user", "content": "Hello, world!"}] result = await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), original_function=original_function, num_retries=1, fallback_model_group=fallback_model_group, @@ -2702,7 +2684,7 @@ async def test_failed_fallbacks_raise_most_recent_exception(function_name): with pytest.raises(litellm.exceptions.RateLimitError): await run_async_fallback( - litellm_router=router, + litellm_routing_ctx=RoutingContext(router), original_function=original_function, num_retries=1, fallback_model_group=fallback_model_group, @@ -2854,7 +2836,7 @@ async def test_multiple_fallbacks(function_name, respx_mock: respx.MockRouter, m request_kwargs["messages"] = [{"role": "user", "content": "Hello, world!"}] result = await run_async_fallback( - litellm_router=router_2, + litellm_routing_ctx=RoutingContext(router_2), original_function=original_function, num_retries=1, fallback_model_group=fallback_model_group, diff --git a/tests/unit/router_utils/test_get_retry_from_policy.py b/tests/unit/router_utils/test_get_retry_from_policy.py index 4ff869849dd..8847329d82c 100644 --- a/tests/unit/router_utils/test_get_retry_from_policy.py +++ b/tests/unit/router_utils/test_get_retry_from_policy.py @@ -5,7 +5,7 @@ import httpx import pytest import litellm -from litellm.router_utils.get_retry_from_policy import get_num_retries_from_retry_policy +from litellm.litellm_core_utils.get_retry_from_policy import get_num_retries_from_retry_policy from litellm.types.router import RetryPolicy _EXCEPTION_FOR_FIELD: Final = MappingProxyType( diff --git a/tests/unit/router_utils/test_handle_error.py b/tests/unit/router_utils/test_handle_error.py index 4b0690b2bd4..151fb0bfc68 100644 --- a/tests/unit/router_utils/test_handle_error.py +++ b/tests/unit/router_utils/test_handle_error.py @@ -5,6 +5,7 @@ from unittest.mock import AsyncMock, MagicMock import pytest import litellm +from litellm.router_api import RouterSettings, RoutingObservers from tests._vcr_conftest_common import install_live_call_probe, record_vcr_outcome @@ -13,9 +14,10 @@ async def test_send_llm_exception_alert_success(): """ Test that the function sends an alert when the router.slack_alerting_logger is set. """ - # Create a mock LitellmRouter instance - mock_router = MagicMock() - mock_router.slack_alerting_logger = AsyncMock() + # A routing context whose observers carry a slack_alerting_logger + slack_alerting_logger = AsyncMock() + ctx = MagicMock() + ctx.observers.return_value = RoutingObservers(slack_alerting_logger=slack_alerting_logger) # Create a mock exception mock_exception = Exception("Test exception") @@ -32,10 +34,10 @@ async def test_send_llm_exception_alert_success(): # Call the function from litellm.router_utils.handle_error import send_llm_exception_alert - await send_llm_exception_alert(mock_router, request_kwargs, error_traceback, mock_exception) + await send_llm_exception_alert(ctx, request_kwargs, error_traceback, mock_exception) # Assert that the slack_alerting_logger's send_alert method was called - mock_router.slack_alerting_logger.send_alert.assert_called_once() + slack_alerting_logger.send_alert.assert_called_once() @pytest.mark.asyncio @@ -43,9 +45,9 @@ async def test_send_llm_exception_alert_no_logger(): """ Test that the function does error out when no slack_alerting_logger is set """ - # Create a mock LitellmRouter instance without a slack_alerting_logger - mock_router = MagicMock() - mock_router.slack_alerting_logger = None + # A routing context whose observers have no slack_alerting_logger + ctx = MagicMock() + ctx.observers.return_value = RoutingObservers(slack_alerting_logger=None) # Create a mock exception mock_exception = Exception("Test exception") @@ -62,7 +64,7 @@ async def test_send_llm_exception_alert_no_logger(): # Call the function from litellm.router_utils.handle_error import send_llm_exception_alert - await send_llm_exception_alert(mock_router, request_kwargs, error_traceback, mock_exception) + await send_llm_exception_alert(ctx, request_kwargs, error_traceback, mock_exception) @pytest.mark.asyncio @@ -70,9 +72,10 @@ async def test_send_llm_exception_alert_when_proxy_server_request_in_kwargs(): """ Test that the function does not send an alert when the request kwargs contains a proxy_server_request key. """ - # Create a mock LitellmRouter instance with a slack_alerting_logger - mock_router = MagicMock() - mock_router.slack_alerting_logger = AsyncMock() + # A routing context whose observers carry a slack_alerting_logger + slack_alerting_logger = AsyncMock() + ctx = MagicMock() + ctx.observers.return_value = RoutingObservers(slack_alerting_logger=slack_alerting_logger) # Create a mock exception mock_exception = Exception("Test exception") @@ -90,11 +93,11 @@ async def test_send_llm_exception_alert_when_proxy_server_request_in_kwargs(): # Call the function from litellm.router_utils.handle_error import send_llm_exception_alert - await send_llm_exception_alert(mock_router, request_kwargs, error_traceback, mock_exception) + await send_llm_exception_alert(ctx, request_kwargs, error_traceback, mock_exception) # Assert that no exception was raised and the function completed successfully - mock_router.slack_alerting_logger.send_alert.assert_not_called() + slack_alerting_logger.send_alert.assert_not_called() @pytest.mark.asyncio @@ -108,11 +111,11 @@ async def test_async_raise_no_deployment_exception(): from litellm.router_utils.handle_error import async_raise_no_deployment_exception from litellm.types.router import RouterRateLimitError - # Create a mock LitellmRouter instance - mock_router = MagicMock() - mock_router.get_model_ids.return_value = ["deployment-1", "deployment-2"] - mock_router.cooldown_cache.get_min_cooldown.return_value = 30.0 - mock_router.enable_pre_call_checks = True + # A routing context: the group's deployment ids, their cooldown store and the router settings + ctx = MagicMock() + ctx.registry.return_value.names.return_value = ["deployment-1", "deployment-2"] + ctx.health.return_value.cooldowns.get_min_cooldown.return_value = 30.0 + ctx.settings.return_value = RouterSettings(enable_pre_call_checks=True) # Mock the _async_get_cooldown_deployments_with_debug_info function # It should return a list of tuples where each tuple contains (model_id, debug_info) @@ -128,7 +131,7 @@ async def test_async_raise_no_deployment_exception(): ): # Call the function result = await async_raise_no_deployment_exception( - litellm_router_instance=mock_router, + ctx=ctx, model="gpt-5-mini", parent_otel_span=None, ) @@ -150,8 +153,8 @@ async def test_async_raise_no_deployment_exception(): assert isinstance(item, str), f"Expected string ID, got {type(item)}: {item}" # Verify mock calls - mock_router.get_model_ids.assert_called_once_with(model_name="gpt-5-mini") - mock_router.cooldown_cache.get_min_cooldown.assert_called_once_with( + ctx.registry().names.assert_called_once_with("gpt-5-mini", kind="ids") + ctx.health().cooldowns.get_min_cooldown.assert_called_once_with( model_ids=["deployment-1", "deployment-2"], parent_otel_span=None ) @@ -166,11 +169,11 @@ async def test_async_raise_no_deployment_exception_empty_cooldown_list(): from litellm.router_utils.handle_error import async_raise_no_deployment_exception from litellm.types.router import RouterRateLimitError - # Create a mock LitellmRouter instance - mock_router = MagicMock() - mock_router.get_model_ids.return_value = ["deployment-1", "deployment-2"] - mock_router.cooldown_cache.get_min_cooldown.return_value = 15.0 - mock_router.enable_pre_call_checks = False + # A routing context: the group's deployment ids, their cooldown store and the router settings + ctx = MagicMock() + ctx.registry.return_value.names.return_value = ["deployment-1", "deployment-2"] + ctx.health.return_value.cooldowns.get_min_cooldown.return_value = 15.0 + ctx.settings.return_value = RouterSettings(enable_pre_call_checks=False) # Mock empty cooldown list mock_cooldown_list: List = [] @@ -181,7 +184,7 @@ async def test_async_raise_no_deployment_exception_empty_cooldown_list(): ): # Call the function result = await async_raise_no_deployment_exception( - litellm_router_instance=mock_router, + ctx=ctx, model="claude-3-sonnet", parent_otel_span=None, ) @@ -211,11 +214,11 @@ async def test_async_raise_no_deployment_exception_none_cooldown_list(): from litellm.router_utils.handle_error import async_raise_no_deployment_exception from litellm.types.router import RouterRateLimitError - # Create a mock LitellmRouter instance - mock_router = MagicMock() - mock_router.get_model_ids.return_value = [] - mock_router.cooldown_cache.get_min_cooldown.return_value = 45.0 - mock_router.enable_pre_call_checks = True + # A routing context: the group's deployment ids, their cooldown store and the router settings + ctx = MagicMock() + ctx.registry.return_value.names.return_value = [] + ctx.health.return_value.cooldowns.get_min_cooldown.return_value = 45.0 + ctx.settings.return_value = RouterSettings(enable_pre_call_checks=True) # Mock None cooldown list (though this shouldn't happen in practice) mock_cooldown_list = None @@ -226,7 +229,7 @@ async def test_async_raise_no_deployment_exception_none_cooldown_list(): ): # After the defensive fix, this should handle None gracefully and return empty list result = await async_raise_no_deployment_exception( - litellm_router_instance=mock_router, + ctx=ctx, model="gpt-5.5", parent_otel_span=None, ) diff --git a/tests/unit/router_utils/test_health_check_allowed_fails_integration.py b/tests/unit/router_utils/test_health_check_allowed_fails_integration.py index d200b304c4e..74b3a8825b3 100644 --- a/tests/unit/router_utils/test_health_check_allowed_fails_integration.py +++ b/tests/unit/router_utils/test_health_check_allowed_fails_integration.py @@ -6,13 +6,14 @@ should increment the same counters used by allowed_fails_policy, using the actual exception type from the health check error. """ -from unittest.mock import patch +from unittest.mock import ANY, patch import pytest import litellm from litellm.proxy.health_check import run_with_timeout from litellm.router import Router +from litellm.router_api import RoutingContext from litellm.types.router import AllowedFailsPolicy @@ -160,14 +161,14 @@ class TestHealthCheckCooldownIntegration: # First call: should not cooldown (1 <= 3) result = should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="deploy-1", original_exception=timeout_exc, ) assert result is False # Check counter was incremented - current_fails = router.cache.get_cache(key="deployment:deploy-1:allowed_fails") + current_fails = router.health().store.get_cache(key="deployment:deploy-1:allowed_fails") assert current_fails == 1 def test_health_check_failure_triggers_cooldown_at_threshold(self): @@ -186,7 +187,7 @@ class TestHealthCheckCooldownIntegration: # Fails 1 and 2: should not cooldown for _ in range(2): result = should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="deploy-1", original_exception=auth_exc, ) @@ -194,7 +195,7 @@ class TestHealthCheckCooldownIntegration: # Fail 3: should trigger cooldown (3 > 2) result = should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="deploy-1", original_exception=auth_exc, ) @@ -219,7 +220,7 @@ class TestHealthCheckCooldownIntegration: # Fail 1: should not cooldown (1 <= 1) result = should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="deploy-1", original_exception=generic_exc, ) @@ -227,7 +228,7 @@ class TestHealthCheckCooldownIntegration: # Fail 2: should trigger cooldown (2 > 1) result = should_cooldown_based_on_allowed_fails_policy( - litellm_router_instance=router, + ctx=RoutingContext(router), deployment="deploy-1", original_exception=generic_exc, ) @@ -266,11 +267,11 @@ class TestHealthCheckCooldownIntegration: timeout_exc = litellm.Timeout(message="Health check timeout", model="gpt-4", llm_provider="openai") result = set_cooldown_deployments( - litellm_router_instance=router, + ctx=RoutingContext(router), original_exception=timeout_exc, exception_status=500, deployment="deploy-1", - time_to_cooldown=router.cooldown_time, + time_to_cooldown=router.settings().cooldown_time, ) assert result is False @@ -306,12 +307,13 @@ class TestWriteHealthStateIntegration: exceptions_by_model_id={"deploy-1": timeout_exc}, ) mock_cooldown.assert_called_once_with( - litellm_router_instance=router, + ANY, original_exception=timeout_exc, exception_status=408, # Timeout has status_code 408 deployment="deploy-1", - time_to_cooldown=router.cooldown_time, + time_to_cooldown=router.settings().cooldown_time, ) + assert mock_cooldown.call_args.args[0].belongs_to(router) def test_unhealthy_endpoint_without_exception_skips_cooldown(self): """Unhealthy endpoints without an exception key should not trigger cooldown.""" @@ -364,10 +366,8 @@ class TestWriteHealthStateIntegration: unhealthy_endpoints=unhealthy_endpoints, exceptions_by_model_id={"deploy-1": rate_exc}, ) - mock_increment.assert_called_once_with( - litellm_router_instance=router, - deployment_id="deploy-1", - ) + mock_increment.assert_called_once_with(ANY, "deploy-1") + assert mock_increment.call_args.args[0].belongs_to(router) class TestHealthCheckFilterBypassWithPolicy: diff --git a/tests/unit/router_utils/test_pattern_match_deployments.py b/tests/unit/router_utils/test_pattern_match_deployments.py index 0bb33064c68..b5145ce9c71 100644 --- a/tests/unit/router_utils/test_pattern_match_deployments.py +++ b/tests/unit/router_utils/test_pattern_match_deployments.py @@ -1,4 +1,4 @@ -"""Behavior pins for ``litellm/router_utils/pattern_match_deployments.py``.""" +"""Behavior pins for ``litellm/litellm_core_utils/pattern_match_deployments.py``.""" from __future__ import annotations @@ -13,7 +13,7 @@ import litellm from litellm import Router from litellm.litellm_core_utils import get_llm_provider_logic from litellm.router import Deployment, LiteLLM_Params -from litellm.router_utils.pattern_match_deployments import PatternMatchRouter, PatternUtils +from litellm.litellm_core_utils.pattern_match_deployments import PatternMatchRouter, PatternUtils from litellm.types.router import ModelInfo import json from unittest.mock import MagicMock @@ -406,7 +406,7 @@ def test_sorted_patterns(): """ Tests that the pattern specificity is calculated correctly """ - from litellm.router_utils.pattern_match_deployments import PatternUtils + from litellm.litellm_core_utils.pattern_match_deployments import PatternUtils sorted_patterns = PatternUtils.sorted_patterns( { @@ -418,7 +418,7 @@ def test_sorted_patterns(): def test_calculate_pattern_specificity(): - from litellm.router_utils.pattern_match_deployments import PatternUtils + from litellm.litellm_core_utils.pattern_match_deployments import PatternUtils assert PatternUtils.calculate_pattern_specificity("llmengine/*") == (11, 1) assert PatternUtils.calculate_pattern_specificity("*") == (1, 1) diff --git a/tests/unit/router_utils/test_ptu_shares.py b/tests/unit/router_utils/test_ptu_shares.py index bc929f6455a..6a843f5f821 100644 --- a/tests/unit/router_utils/test_ptu_shares.py +++ b/tests/unit/router_utils/test_ptu_shares.py @@ -6,7 +6,7 @@ from typing import Final import pytest from litellm.llms.azure.ptu_capacity import AZURE_PTU_CAPACITY -from litellm.router_utils.ptu_shares import ( +from litellm.litellm_core_utils.ptu_shares import ( filter_ptu_shared_deployments, model_group_deployments, model_group_ptu_capacity, diff --git a/tests/unit/router_utils/test_reasoning_effort_capability.py b/tests/unit/router_utils/test_reasoning_effort_capability.py index ce4cb84addf..c0ff141ffab 100644 --- a/tests/unit/router_utils/test_reasoning_effort_capability.py +++ b/tests/unit/router_utils/test_reasoning_effort_capability.py @@ -7,7 +7,7 @@ import pytest import litellm from litellm._logging import JsonFormatter, verbose_logger -from litellm.router_utils.reasoning_effort_capability import ( +from litellm.litellm_core_utils.reasoning_effort_capability import ( RequestedReasoningEffort, deployment_is_catalog_mapped, intersect_supported_reasoning_efforts, diff --git a/tests/unit/router_utils/test_router_utils_common_utils.py b/tests/unit/router_utils/test_router_utils_common_utils.py index 8011ca37cfb..6ec72868b6e 100644 --- a/tests/unit/router_utils/test_router_utils_common_utils.py +++ b/tests/unit/router_utils/test_router_utils_common_utils.py @@ -10,7 +10,7 @@ from litellm import Router from litellm.constants import ROUTER_FALLBACK_ERROR_DETAIL_MAX_CHARS from litellm.litellm_core_utils.get_model_cost_map import GetModelCostMap from litellm.proxy._types import UserAPIKeyAuth -from litellm.router_utils.common_utils import ( +from litellm.litellm_core_utils.routing_common_utils import ( _deployment_supports_web_search, add_model_file_id_mappings, filter_team_based_models, diff --git a/tests/unit/rust_bridge/test_runtime.py b/tests/unit/rust_bridge/test_runtime.py index c0c416a62c9..75cdfde087b 100644 --- a/tests/unit/rust_bridge/test_runtime.py +++ b/tests/unit/rust_bridge/test_runtime.py @@ -6,8 +6,8 @@ from typing import Final, Protocol import pytest from litellm.exceptions import APIError +from litellm.litellm_core_utils.add_retry_fallback_headers import get_hidden_params_dict from litellm.llms.base_llm.ocr.transformation import OCRResponse -from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict from litellm.rust_bridge import bindings, configuration, runtime from litellm.rust_bridge._native import RustBridgeDeclined, RustUpstreamError from litellm.rust_bridge.catalog import Route, RouteContext, RouteRule diff --git a/tests/unit/test_model_prices_and_context_window.py b/tests/unit/test_model_prices_and_context_window.py index 8ca678a94ad..e4a2beb3a86 100644 --- a/tests/unit/test_model_prices_and_context_window.py +++ b/tests/unit/test_model_prices_and_context_window.py @@ -12,9 +12,9 @@ from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter import litellm from litellm.litellm_core_utils.fallback_generalizations import match_capability_generalizations +from litellm.litellm_core_utils.reasoning_effort_capability import resolve_supported_reasoning_efforts from litellm.llms.openai.chat.gpt_reasoning_transformation import is_gpt_reasoning_series_name from litellm.llms.openai_like.json_loader import JSONProviderRegistry -from litellm.router_utils.reasoning_effort_capability import resolve_supported_reasoning_efforts from litellm.types.utils import SearchFreeRequests REPO_ROOT = Path(__file__).parents[2] diff --git a/tests/unit/test_muse_spark_1_3_model_metadata.py b/tests/unit/test_muse_spark_1_3_model_metadata.py index 049fb988fd5..468294ba91c 100644 --- a/tests/unit/test_muse_spark_1_3_model_metadata.py +++ b/tests/unit/test_muse_spark_1_3_model_metadata.py @@ -6,7 +6,7 @@ import pytest import litellm from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider from litellm.litellm_core_utils.llm_cost_calc.tool_call_cost_tracking import StandardBuiltInToolCostTracking -from litellm.router_utils.reasoning_effort_capability import resolve_supported_reasoning_efforts +from litellm.litellm_core_utils.reasoning_effort_capability import resolve_supported_reasoning_efforts MUSE_SPARK_STANDARD = "meta/muse-spark-1.3" MUSE_SPARK_CONTRIBUTOR = "meta/muse-spark-1.3-contributor" diff --git a/tests/unit/test_private_usage_aliases.py b/tests/unit/test_private_usage_aliases.py index f2195512355..3c0aab8a4b4 100644 --- a/tests/unit/test_private_usage_aliases.py +++ b/tests/unit/test_private_usage_aliases.py @@ -1966,8 +1966,8 @@ ALIAS_CASES: Final = ( "get_tags_from_request_kwargs", False, ), - ("litellm.router_utils.add_retry_fallback_headers", "HiddenParamsAsyncIteratorWrapper", "_inner", "inner", True), - ("litellm.router_utils.add_retry_fallback_headers", "", "_HiddenParamsHost", "HiddenParamsHost", False), + ("litellm.litellm_core_utils.add_retry_fallback_headers", "HiddenParamsAsyncIteratorWrapper", "_inner", "inner", True), + ("litellm.litellm_core_utils.add_retry_fallback_headers", "", "_HiddenParamsHost", "HiddenParamsHost", False), ( "litellm.litellm_core_utils.batch_utils", "", @@ -1975,7 +1975,7 @@ ALIAS_CASES: Final = ( "get_router_metadata_variable_name", False, ), - ("litellm.router_utils.common_utils", "", "_is_proxy_admin_request", "is_proxy_admin_request", False), + ("litellm.litellm_core_utils.routing_common_utils", "", "_is_proxy_admin_request", "is_proxy_admin_request", False), ( "litellm.router_utils.cooldown_callbacks", "", @@ -2007,7 +2007,7 @@ ALIAS_CASES: Final = ( False, ), ( - "litellm.router_utils.pattern_match_deployments", + "litellm.litellm_core_utils.pattern_match_deployments", "PatternMatchRouter", "_pattern_to_regex", "pattern_to_regex", @@ -2102,7 +2102,7 @@ PROPERTY_CASES: Final = ( ), ("litellm.router", "Router", "_routing_groups", "routing_groups"), ("litellm.router_strategy.adaptive_router.adaptive_router", "AdaptiveRouter", "_state_loaded", "state_loaded"), - ("litellm.router_utils.add_retry_fallback_headers", "HiddenParamsAsyncIteratorWrapper", "_inner", "inner"), + ("litellm.litellm_core_utils.add_retry_fallback_headers", "HiddenParamsAsyncIteratorWrapper", "_inner", "inner"), ) CLASS_PROPERTY_CASES: Final = () diff --git a/tests/unit/test_router/test_router.py b/tests/unit/test_router/test_router.py index 96df8d3e1f0..7ac27e22a93 100644 --- a/tests/unit/test_router/test_router.py +++ b/tests/unit/test_router/test_router.py @@ -82,6 +82,7 @@ from litellm.router_utils.prompt_caching_cache import PromptCachingCache from litellm.router_utils.router_callbacks.track_deployment_metrics import get_deployment_successes_for_current_minute from litellm.scheduler import FlowItem from litellm.types.llms.openai import AllMessageValues, ChatCompletionRequest +from litellm.router_api import RoutingContext as RouterContext from litellm.types.router import ( CustomRoutingStrategyBase, Deployment, @@ -378,7 +379,7 @@ def test_router_model_group_encrypted_content_affinity_callback_registration(): ] assert len(encrypted_content_callbacks) == 1 assert encrypted_content_callbacks[0].enable_global_affinity is True - assert encrypted_content_callbacks[0].router is router + assert encrypted_content_callbacks[0].ctx is router._core_ctx finally: if router is not None: router.discard() @@ -1506,7 +1507,7 @@ def test_sync_deployment_callback_on_success_skips_batch_retrieves( assert key == expected_key assert ( - get_deployment_successes_for_current_minute(litellm_router_instance=router, deployment_id="batch-dep") + get_deployment_successes_for_current_minute(ctx=router._core_ctx, deployment_id="batch-dep") == expected_successes ) @@ -10103,7 +10104,7 @@ def test_pattern_match_router_remove_deployment(): remove_deployment must drop only the deployment with the given model id and delete patterns whose deployment list becomes empty. """ - from litellm.router_utils.pattern_match_deployments import PatternMatchRouter + from litellm.litellm_core_utils.pattern_match_deployments import PatternMatchRouter pattern_router = PatternMatchRouter() pattern_router.add_pattern( @@ -12928,7 +12929,7 @@ class TestBackgroundResponseCostPollCooldown: is False ) assert self._cooled_down_ids(router) == [] - value = get_deployment_failures_for_current_minute(litellm_router_instance=router, deployment_id="dep-1") + value = get_deployment_failures_for_current_minute(ctx=router._core_ctx, deployment_id="dep-1") assert not value @pytest.mark.asyncio @@ -13018,7 +13019,7 @@ class TestCallerTimeoutCooldown: get_deployment_failures_for_current_minute, ) - return get_deployment_failures_for_current_minute(litellm_router_instance=router, deployment_id="dep-1") + return get_deployment_failures_for_current_minute(ctx=router._core_ctx, deployment_id="dep-1") def _cooled_down_ids(self, router): active = router.cooldown_cache.get_active_cooldowns(model_ids=["dep-1"], parent_otel_span=None) @@ -17500,7 +17501,7 @@ def test_model_group_info_reasoning_efforts_are_unknown_for_an_operator_declared operator wrote, so a mode they set themselves reads back exactly like one the map supplied. Only a mode the map supplied marks the deployment as known. An off-map deployment carrying an operator mode remains unknown and must keep the whole group's level support unknown.""" - from litellm.router_utils.reasoning_effort_capability import resolve_supported_reasoning_efforts + from litellm.litellm_core_utils.reasoning_effort_capability import resolve_supported_reasoning_efforts mapped_model = "openai/gpt-5.6-sol" expected = resolve_supported_reasoning_efforts( @@ -20890,7 +20891,7 @@ class _AllowlistFallbackAccessCheck: self.allowed_models = allowed_models self.checked_models = [] - async def __call__(self, *, model, request_kwargs, llm_router): + async def __call__(self, *, model, request_kwargs, ctx): self.checked_models.append(model) return model in self.allowed_models @@ -20923,7 +20924,7 @@ def _router_with_failing_primary(fallback_access_check) -> Router: class _DenyFallbackBudgetCheck: async def __call__( - self, *, model: str, request_kwargs: Mapping[str, object], llm_router: Router + self, *, model: str, request_kwargs: Mapping[str, object], ctx: RouterContext ) -> bool: return False @@ -22020,7 +22021,7 @@ def test_router_retry_skip_stamp_feeds_deployment_ids_to_skip_on_retry( ], ) def test_router_as_retry_skipped_deployment_ids_keeps_only_a_tuple_of_strings(value, expected): - from litellm.router_utils.common_utils import as_retry_skipped_deployment_ids + from litellm.litellm_core_utils.routing_common_utils import as_retry_skipped_deployment_ids assert as_retry_skipped_deployment_ids(value) == expected @@ -22854,7 +22855,7 @@ async def test_router_max_parallel_requests_overflow_is_429_without_cooldown_or_ assert all("capped-deployment" in r.message and "max_parallel_requests=1" in r.message for r in rejected) assert route.call_count == 1 assert sibling_route.call_count == 0 - assert await _async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) == [] + assert await _async_get_cooldown_deployments(ctx=router._core_ctx, parent_otel_span=None) == [] @pytest.mark.asyncio @@ -22973,7 +22974,7 @@ async def test_router_max_parallel_requests_overflow_takes_the_ordinary_429_fall assert len(results) == 3 assert primary.call_count == 1 assert fallback.call_count == 2 - assert await _async_get_cooldown_deployments(litellm_router_instance=router, parent_otel_span=None) == [] + assert await _async_get_cooldown_deployments(ctx=router._core_ctx, parent_otel_span=None) == [] @pytest.mark.asyncio @@ -28253,11 +28254,11 @@ async def test_aaarouter_dynamic_cooldown_message_retry_time(sync_mode): if sync_mode: cooldown_deployments = get_cooldown_deployments( - litellm_router_instance=router, parent_otel_span=None + ctx=router._core_ctx, parent_otel_span=None ) else: cooldown_deployments = await async_get_cooldown_deployments( - litellm_router_instance=router, parent_otel_span=None + ctx=router._core_ctx, parent_otel_span=None ) assert len(cooldown_deployments) > 0 @@ -29904,7 +29905,7 @@ def test_router_does_not_cool_down_api_connection_errors() -> None: assert ( _is_cooldown_required( - litellm_router_instance=router, + ctx=router._core_ctx, model_id="connection-deployment", exception_status=500, exception_str="litellm.APIConnectionError: connection refused", @@ -31168,7 +31169,7 @@ def _deployment_ids(deployments: list[DeploymentTypedDict]) -> tuple[str, ...]: id="response_polling_provider_lookup", ), pytest.param( - lambda router: _models_in(router, "model-3"), + lambda router: _models_in(router._core_ctx, "model-3"), (Baseline("openai/gpt-3", "deployment-3"),), id="savings_baseline_candidates", ), @@ -31264,7 +31265,7 @@ def test_complexity_router_adaptive_pool_during_a_concurrent_delete_prices_the_l router: Final = Router(model_list=[*(_concurrent_delete_deployment(index) for index in range(3)), priced]) complexity: Final = ComplexityRouter( model_name="hybrid", - litellm_router_instance=router, + ctx=router._core_ctx, complexity_router_config={"adaptive": True, "tiers": {"SIMPLE": ["model-3"]}}, ) diff --git a/tests/unit/test_router/test_router_endpoints.py b/tests/unit/test_router/test_router_endpoints.py index 815b32b33f7..0c57fb662ac 100644 --- a/tests/unit/test_router/test_router_endpoints.py +++ b/tests/unit/test_router/test_router_endpoints.py @@ -1256,6 +1256,6 @@ def test_router_model_group_encrypted_content_affinity_callback_registration(): ] assert len(encrypted_content_callbacks) == 1 assert encrypted_content_callbacks[0].enable_global_affinity is True - assert encrypted_content_callbacks[0].router is router + assert encrypted_content_callbacks[0].ctx is router._core_ctx finally: router.discard() diff --git a/tests/unit/test_router/test_router_entry_points.py b/tests/unit/test_router/test_router_entry_points.py index 2af7db930c6..366e16a8e91 100644 --- a/tests/unit/test_router/test_router_entry_points.py +++ b/tests/unit/test_router/test_router_entry_points.py @@ -827,3 +827,77 @@ def test_attribute_errors_about_other_objects_pass_through_unchanged(router): other = AttributeError("'dict' object has no attribute 'x'", name="x", obj={}) assert _public_attribute_error(router, "_core_x", "x", other) is other + + +# Router-family helpers whose Router parameter became a RoutingContext keep the old spellings. + + +def test_renamed_router_keyword_still_works_and_warns(router): + from litellm.router_utils.router_callbacks.track_deployment_metrics import ( + get_deployment_failures_for_current_minute, + increment_deployment_failures_for_current_minute, + ) + + deployment_id = router.registry().names(kind="ids")[0] + label = ( + "litellm.router_utils.router_callbacks.track_deployment_metrics." + "increment_deployment_failures_for_current_minute" + ) + before = DEPRECATED_ROUTER_MEMBER_USES[label] + + with pytest.warns(DeprecationWarning, match=r"litellm_router_instance= is deprecated; pass ctx="): + increment_deployment_failures_for_current_minute(litellm_router_instance=router, deployment_id=deployment_id) + + assert DEPRECATED_ROUTER_MEMBER_USES[label] == before + 1 + with warnings.catch_warnings(): + warnings.simplefilter("error") + assert get_deployment_failures_for_current_minute(ctx=router._core_ctx, deployment_id=deployment_id) == 1 + + +def test_router_passed_where_the_context_goes_is_converted_with_a_warning(router): + from litellm.router_utils.cooldown_handlers import get_cooldown_deployments + + with pytest.warns(DeprecationWarning, match="passing a Router is deprecated"): + assert get_cooldown_deployments(router, None) == [] + with pytest.warns(DeprecationWarning, match="a Router as ctx= is deprecated"): + assert get_cooldown_deployments(ctx=router, parent_otel_span=None) == [] + + +def test_renamed_router_keyword_alongside_the_new_one_is_rejected(router): + from litellm.router_utils.cooldown_handlers import get_cooldown_deployments + + with pytest.raises(TypeError, match="got both litellm_router_instance= and ctx="): + get_cooldown_deployments(ctx=router._core_ctx, litellm_router_instance=router, parent_otel_span=None) + + +def test_renamed_router_param_maps_to_a_differently_named_context(router): + from litellm.router_api import RoutingContext + from litellm.router_deprecated import renamed_router_param + + @renamed_router_param("litellm_router", new="litellm_routing_ctx") + def helper(*, litellm_routing_ctx: RoutingContext) -> RoutingContext: + return litellm_routing_ctx + + with pytest.warns(DeprecationWarning, match="litellm_router= is deprecated; pass litellm_routing_ctx="): + assert helper(litellm_router=router) is router._core_ctx + with warnings.catch_warnings(): + warnings.simplefilter("error") + assert helper(litellm_routing_ctx=router._core_ctx) is router._core_ctx + + +def test_renamed_router_attribute_reads_and_writes_the_context(router): + from litellm.router_utils.pre_call_checks.encrypted_content_affinity_check import ( + EncryptedContentAffinityCheck, + ) + + check = EncryptedContentAffinityCheck(ctx=router._core_ctx) + with pytest.warns(DeprecationWarning, match=r"EncryptedContentAffinityCheck\.router: reading this attribute"): + assert check.router is router._core_ctx + + other = _router() + with pytest.warns(DeprecationWarning, match="setting this attribute is deprecated; set .ctx"): + check.router = other + assert check.ctx is other._core_ctx + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + other.retire() diff --git a/tests/unit/test_router/test_router_helper_utils.py b/tests/unit/test_router/test_router_helper_utils.py index 5f31ded626d..8929c5fd345 100644 --- a/tests/unit/test_router/test_router_helper_utils.py +++ b/tests/unit/test_router/test_router_helper_utils.py @@ -2614,7 +2614,7 @@ def test_deployments_by_pattern(model_list): def test_pattern_match_deployment_set_model_name(user_request_model, model_name, litellm_model, expected_model): from re import Match - from litellm.router_utils.pattern_match_deployments import PatternMatchRouter + from litellm.litellm_core_utils.pattern_match_deployments import PatternMatchRouter pattern_router = PatternMatchRouter() @@ -2799,7 +2799,7 @@ def test_init_auto_router_deployment_success(mock_auto_router, model_list): auto_router_config=None, default_model="gpt-5-mini", embedding_model="text-embedding-3-small", - litellm_router_instance=router, + ctx=router._core_ctx, max_input_chars=DEFAULT_AUTO_ROUTER_MAX_INPUT_CHARS, ) diff --git a/tests/unit/test_router_streaming_fallback_metadata.py b/tests/unit/test_router_streaming_fallback_metadata.py index 7e0cb30f1e3..40449d8cc66 100644 --- a/tests/unit/test_router_streaming_fallback_metadata.py +++ b/tests/unit/test_router_streaming_fallback_metadata.py @@ -5,9 +5,9 @@ from unittest.mock import MagicMock import pytest import litellm +from litellm.litellm_core_utils.add_retry_fallback_headers import get_hidden_params_dict from litellm.proxy.proxy_server import _should_include_fallback_errors from litellm.router import Router -from litellm.router_utils.add_retry_fallback_headers import get_hidden_params_dict from litellm.types.llms.base import HiddenParams