diff --git a/litellm/constants.py b/litellm/constants.py index f2d118b59e6..cb5c29f90b0 100644 --- a/litellm/constants.py +++ b/litellm/constants.py @@ -234,6 +234,7 @@ DEFAULT_REASONING_EFFORT_MINIMAL_THINKING_BUDGET: Final = int( # Provider-specific API base URLs XAI_API_BASE: Final = "https://api.x.ai/v1" +OPPER_API_BASE: Final = "https://api.opper.ai/v3/compat" OPEN_SANDBOX_API_BASE_ENV_VAR: Final = "OPEN_SANDBOX_API_BASE" OPEN_SANDBOX_API_KEY_ENV_VAR: Final = "OPEN_SANDBOX_API_KEY" OPEN_SANDBOX_DEFAULT_TEMPLATE: Final = "opensandbox/code-interpreter:v1.1.0" diff --git a/litellm/litellm_core_utils/get_llm_provider_logic.py b/litellm/litellm_core_utils/get_llm_provider_logic.py index 4ca6bb08aa7..c54b7b100e9 100644 --- a/litellm/litellm_core_utils/get_llm_provider_logic.py +++ b/litellm/litellm_core_utils/get_llm_provider_logic.py @@ -2,7 +2,11 @@ from typing import Final, cast from urllib.parse import urlparse import litellm -from litellm.constants import PROVIDERS_THAT_AUTHENTICATE_ON_PROVIDER_INFO, REPLICATE_MODEL_NAME_WITH_ID_LENGTH +from litellm.constants import ( + OPPER_API_BASE, + PROVIDERS_THAT_AUTHENTICATE_ON_PROVIDER_INFO, + REPLICATE_MODEL_NAME_WITH_ID_LENGTH, +) from litellm.litellm_core_utils.fallback_generalizations import ( match_routing_generalization, ) @@ -699,8 +703,10 @@ def _get_openai_compatible_provider_info( dynamic_api_key = api_key or get_secret_str("TENCENT_API_KEY") elif custom_llm_provider == "opper": - api_base = api_base or get_secret("OPPER_API_BASE") or "https://api.opper.ai/v3/compat" + # rebind-ok: provider chain assigns api_base per branch + api_base = api_base or get_secret("OPPER_API_BASE") or OPPER_API_BASE + # rebind-ok: provider chain assigns dynamic_api_key per branch dynamic_api_key = api_key or get_secret_str("OPPER_API_KEY") elif custom_llm_provider == "fireworks_ai": # fireworks is openai compatible, we just need to set this to custom_openai and have the api_base be https://api.fireworks.ai/inference/v1 diff --git a/litellm/llms/opper/chat/transformation.py b/litellm/llms/opper/chat/transformation.py index 5744f8d3600..852dcf436c9 100644 --- a/litellm/llms/opper/chat/transformation.py +++ b/litellm/llms/opper/chat/transformation.py @@ -7,8 +7,11 @@ from typing import Final import httpx +import litellm from litellm._logging import verbose_logger +from litellm.constants import OPPER_API_BASE from litellm.llms.base_llm.chat.transformation import BaseLLMException, LiteLLMLoggingObj +from litellm.secret_managers.main import get_secret_str from litellm.types.llms.openai import AllMessageValues from litellm.types.utils import ModelResponse, ModelResponseStream, StreamingChoices @@ -47,7 +50,7 @@ class OpperConfig(OpenAIGPTConfig): ) -> dict: # mutable-ok: mirrors the OpenAIGPTConfig signature request: Final = super().transform_request(model, messages, optional_params, litellm_params, headers) if request.get("stream"): - stream_options: Final = dict(request.get("stream_options") or {}) + stream_options: Final = dict(request.get("stream_options") or {}) # mutable-ok: JSON request body stream_options.setdefault("include_usage", True) request["stream_options"] = stream_options return request @@ -66,7 +69,7 @@ class OpperConfig(OpenAIGPTConfig): api_key: str | None = None, json_mode: bool | None = None, ) -> ModelResponse: - model_response = super().transform_response( + transformed: Final = super().transform_response( model=model, raw_response=raw_response, model_response=model_response, @@ -85,15 +88,15 @@ class OpperConfig(OpenAIGPTConfig): if response_json.get("usage"): response_cost: Final = response_json["usage"].get("cost") if response_cost is not None: - if "additional_headers" not in model_response._hidden_params: - model_response._hidden_params["additional_headers"] = {} - model_response._hidden_params["additional_headers"]["llm_provider-x-litellm-response-cost"] = float( - response_cost + headers: Final = transformed._hidden_params.setdefault( + "additional_headers", + {}, # mutable-ok: _hidden_params carries plain dicts ) + headers["llm_provider-x-litellm-response-cost"] = float(response_cost) except (ValueError, TypeError, KeyError, AttributeError): verbose_logger.debug("Opper: could not extract usage.cost from response") - return model_response + return transformed def get_error_class( self, @@ -107,6 +110,37 @@ class OpperConfig(OpenAIGPTConfig): headers=headers, ) + @staticmethod + def get_api_key(api_key: str | None = None) -> str | None: + return api_key or get_secret_str("OPPER_API_KEY") + + @staticmethod + def get_api_base(api_base: str | None = None) -> str | None: + return api_base or get_secret_str("OPPER_API_BASE") or OPPER_API_BASE + + def get_models( + self, + api_key: str | None = None, + api_base: str | None = None, + ) -> list[str]: # mutable-ok: mirrors the BaseLLMModelInfo signature + resolved_api_base: Final = self.get_api_base(api_base) or OPPER_API_BASE + resolved_api_key: Final = self.get_api_key(api_key) + if resolved_api_key is None: + raise ValueError("Opper API key is not set. Pass api_key or set OPPER_API_KEY") + + response: Final = litellm.module_level_client.get( + url=f"{resolved_api_base.rstrip('/')}/models", + headers={"Authorization": f"Bearer {resolved_api_key}"}, # mutable-ok: httpx request headers + ) + try: + response.raise_for_status() + except httpx.HTTPStatusError as e: + raise ValueError( + f"Failed to fetch models from Opper. Status code: {response.status_code}, Response: {response.text}" + ) from e + + return [f"opper/{model['id']}" for model in response.json()["data"]] # mutable-ok: base returns list[str] + def get_model_response_iterator( self, streaming_response: Iterator[str] | AsyncIterator[str] | ModelResponse, @@ -124,5 +158,5 @@ class OpperChatCompletionStreamingHandler(OpenAIChatCompletionStreamingHandler): def chunk_parser(self, chunk: dict) -> ModelResponseStream: # mutable-ok: mirrors the base chunk_parser signature parsed: Final = super().chunk_parser(chunk) if getattr(parsed, "usage", None) is not None and not parsed.choices: - parsed.choices = [StreamingChoices()] + parsed.choices = [StreamingChoices()] # mutable-ok: ModelResponseStream.choices is a list return parsed diff --git a/litellm/main.py b/litellm/main.py index a2c29127ed7..6ad63481476 100644 --- a/litellm/main.py +++ b/litellm/main.py @@ -64,6 +64,7 @@ from litellm.constants import ( AZURE_OPENAI_AUDIO_PROVIDERS, DEFAULT_MOCK_RESPONSE_COMPLETION_TOKEN_COUNT, DEFAULT_MOCK_RESPONSE_PROMPT_TOKEN_COUNT, + OPPER_API_BASE, ) from litellm.exceptions import LiteLLMUnknownProvider from litellm.integrations.custom_logger import CustomLogger @@ -3478,9 +3479,7 @@ def _complete_opper(ctx: _CompletionDispatchContext) -> _CompletionDispatchResul stream: Final = ctx.stream timeout: Final = ctx.timeout - api_base: Final = ( - ctx.api_base or litellm.api_base or get_secret_str("OPPER_API_BASE") or "https://api.opper.ai/v3/compat" - ) + api_base: Final = ctx.api_base or litellm.api_base or get_secret_str("OPPER_API_BASE") or OPPER_API_BASE api_key: Final = ctx.api_key or litellm.api_key or get_secret_str("OPPER_API_KEY") headers: Final = ctx.headers or litellm.headers diff --git a/litellm/proxy/public_endpoints/provider_create_fields.json b/litellm/proxy/public_endpoints/provider_create_fields.json index cd781abee26..89e91ca8ab2 100644 --- a/litellm/proxy/public_endpoints/provider_create_fields.json +++ b/litellm/proxy/public_endpoints/provider_create_fields.json @@ -2505,6 +2505,34 @@ ], "default_model_placeholder": "gpt-3.5-turbo" }, + { + "provider": "Opper", + "provider_display_name": "Opper", + "litellm_provider": "opper", + "credential_fields": [ + { + "key": "api_base", + "label": "API Base", + "placeholder": "https://api.opper.ai/v3/compat", + "tooltip": null, + "required": false, + "field_type": "text", + "options": null, + "default_value": null + }, + { + "key": "api_key", + "label": "API Key", + "placeholder": null, + "tooltip": null, + "required": true, + "field_type": "password", + "options": null, + "default_value": null + } + ], + "default_model_placeholder": "opper/anthropic/claude-haiku-4-5" + }, { "provider": "Oracle", "provider_display_name": "Oracle Cloud Infrastructure (OCI)", diff --git a/litellm/utils.py b/litellm/utils.py index a772ad6d194..596189928b1 100644 --- a/litellm/utils.py +++ b/litellm/utils.py @@ -4700,11 +4700,13 @@ def get_optional_params( drop_params=bool(drop_params), ) elif custom_llm_provider == "opper": - optional_params = litellm.OpperConfig().map_openai_params( # rebind-ok: provider chain assigns optional_params per branch - non_default_params=non_default_params, - optional_params=optional_params, - model=model, - drop_params=(drop_params if drop_params is not None and isinstance(drop_params, bool) else False), + optional_params = ( + litellm.OpperConfig().map_openai_params( # rebind-ok: provider chain assigns optional_params per branch + non_default_params=non_default_params, + optional_params=optional_params, + model=model, + drop_params=(drop_params if drop_params is not None and isinstance(drop_params, bool) else False), + ) ) elif custom_llm_provider == "watsonx": optional_params = litellm.IBMWatsonXChatConfig().map_openai_params( @@ -8107,6 +8109,23 @@ class ProviderConfigManager: # This is initialized lazily on first access to avoid circular imports _PROVIDER_CONFIG_MAP: dict[LlmProviders, tuple[Callable, bool]] | None = None + # Model-info providers whose class is already exported on the litellm module. + # Providers that need a lazy import or the model name stay in get_provider_model_info. + _MODEL_INFO_FACTORIES: Mapping[LlmProviders, Callable[[], BaseLLMModelInfo]] = MappingProxyType( + { + LlmProviders.FIREWORKS_AI: lambda: litellm.FireworksAIConfig(), + LlmProviders.OPENAI: lambda: litellm.OpenAIGPTConfig(), + LlmProviders.GEMINI: lambda: litellm.GeminiModelInfo(), + LlmProviders.LITELLM_PROXY: lambda: litellm.LiteLLMProxyChatConfig(), + LlmProviders.TOPAZ: lambda: litellm.TopazModelInfo(), + LlmProviders.ANTHROPIC: lambda: litellm.AnthropicModelInfo(), + LlmProviders.XAI: lambda: litellm.XAIModelInfo(), + LlmProviders.OPPER: lambda: litellm.OpperConfig(), + LlmProviders.LEMONADE: lambda: litellm.LemonadeChatConfig(), + LlmProviders.CLARIFAI: lambda: litellm.ClarifaiConfig(), + } + ) + @staticmethod def _build_provider_config_map() -> dict[LlmProviders, tuple[Callable, bool]]: """Build the provider-to-config mapping dictionary. @@ -8888,39 +8907,24 @@ class ProviderConfigManager: model: str | None, provider: LlmProviders, ) -> BaseLLMModelInfo | None: - if LlmProviders.FIREWORKS_AI == provider: - return litellm.FireworksAIConfig() - elif LlmProviders.OPENAI == provider: - return litellm.OpenAIGPTConfig() - elif LlmProviders.GEMINI == provider: - return litellm.GeminiModelInfo() - elif LlmProviders.VERTEX_AI == provider: + factory: Final = ProviderConfigManager._MODEL_INFO_FACTORIES.get(provider) + if factory is not None: + return factory() + if LlmProviders.VERTEX_AI == provider: from litellm.llms.vertex_ai.common_utils import VertexAIModelInfo return VertexAIModelInfo() - elif LlmProviders.LITELLM_PROXY == provider: - return litellm.LiteLLMProxyChatConfig() - elif LlmProviders.TOPAZ == provider: - return litellm.TopazModelInfo() - elif LlmProviders.ANTHROPIC == provider: - return litellm.AnthropicModelInfo() - elif LlmProviders.XAI == provider: - return litellm.XAIModelInfo() - elif LlmProviders.OLLAMA == provider or LlmProviders.OLLAMA_CHAT == provider: + elif provider in (LlmProviders.OLLAMA, LlmProviders.OLLAMA_CHAT): # Dynamic model listing for Ollama server from litellm.llms.ollama.common_utils import OllamaModelInfo return OllamaModelInfo() - elif LlmProviders.VLLM == provider or LlmProviders.HOSTED_VLLM == provider: + elif provider in (LlmProviders.VLLM, LlmProviders.HOSTED_VLLM): from litellm.llms.vllm.common_utils import ( VLLMModelInfo, # experimental approach, to reduce bloat on __init__.py ) return VLLMModelInfo() - elif LlmProviders.LEMONADE == provider: - return litellm.LemonadeChatConfig() - elif LlmProviders.CLARIFAI == provider: - return litellm.ClarifaiConfig() elif LlmProviders.BEDROCK == provider: from litellm.llms.bedrock.common_utils import BedrockModelInfo diff --git a/tests/test_litellm/llms/opper/test_opper.py b/tests/test_litellm/llms/opper/test_opper.py index 9d6d5933038..f0838933923 100644 --- a/tests/test_litellm/llms/opper/test_opper.py +++ b/tests/test_litellm/llms/opper/test_opper.py @@ -1,13 +1,36 @@ import json import os -from unittest.mock import Mock, patch +from unittest.mock import patch -import httpx import pytest OPPER_API_BASE = "https://api.opper.ai/v3/compat" +@pytest.fixture(autouse=True) +def _without_ambient_opper_credentials(monkeypatch): + """A developer's own OPPER_* environment must not decide where these tests point.""" + monkeypatch.delenv("OPPER_API_KEY", raising=False) + monkeypatch.delenv("OPPER_API_BASE", raising=False) + + +def _completion_body(usage: dict) -> dict: + return { + "id": "chatcmpl-123", + "object": "chat.completion", + "created": 1677652288, + "model": "anthropic/claude-haiku-4-5", + "choices": [ + { + "index": 0, + "message": {"role": "assistant", "content": "Hello!"}, + "finish_reason": "stop", + } + ], + "usage": usage, + } + + def test_opper_provider_registered(): import litellm @@ -54,120 +77,48 @@ def test_opper_chat_config_registered(): assert isinstance(config, litellm.OpperConfig) -def test_opper_cost_tracking_non_streaming(): - """usage.cost from the response body is surfaced as the provider-reported response cost.""" +@pytest.mark.respx() +def test_opper_cost_tracking_non_streaming(respx_mock, monkeypatch): + """usage.cost from the gateway body is surfaced as the provider-reported response cost.""" import litellm - from litellm.llms.openai.chat.gpt_transformation import OpenAIGPTConfig - from litellm.types.utils import Choices, Message, ModelResponse, Usage - config = litellm.OpperConfig() + monkeypatch.setattr(litellm, "disable_aiohttp_transport", True) - mock_response = Mock(spec=httpx.Response) - mock_response.json.return_value = { - "id": "chatcmpl-123", - "model": "anthropic/claude-haiku-4-5", - "choices": [ - { - "message": {"role": "assistant", "content": "Hello!"}, - "finish_reason": "stop", - "index": 0, - } - ], - "usage": { - "prompt_tokens": 10, - "completion_tokens": 20, - "total_tokens": 30, - "cost": 3.3e-05, - }, - } - mock_response.headers = {} - - model_response = ModelResponse( - id="chatcmpl-123", - choices=[ - Choices( - finish_reason="stop", - index=0, - message=Message(content="Hello!", role="assistant"), - ) - ], - created=1234567890, - model="anthropic/claude-haiku-4-5", - object="chat.completion", - usage=Usage(prompt_tokens=10, completion_tokens=20, total_tokens=30), + respx_mock.post(f"{OPPER_API_BASE}/chat/completions").respond( + status_code=200, + json=_completion_body({"prompt_tokens": 10, "completion_tokens": 20, "total_tokens": 30, "cost": 3.3e-05}), ) - with patch.object(OpenAIGPTConfig, "transform_response", return_value=model_response): - result = config.transform_response( - model="anthropic/claude-haiku-4-5", - raw_response=mock_response, - model_response=model_response, - logging_obj=Mock(), - request_data={}, - messages=[{"role": "user", "content": "Hello"}], - optional_params={}, - litellm_params={}, - encoding=None, - ) - - assert result._hidden_params["additional_headers"]["llm_provider-x-litellm-response-cost"] == 3.3e-05 - - -def test_opper_missing_cost_does_not_fail_response(): - import litellm - from litellm.llms.openai.chat.gpt_transformation import OpenAIGPTConfig - from litellm.types.utils import Choices, Message, ModelResponse, Usage - - config = litellm.OpperConfig() - - mock_response = Mock(spec=httpx.Response) - mock_response.json.return_value = {"usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2}} - mock_response.headers = {} - - model_response = ModelResponse( - id="chatcmpl-123", - choices=[ - Choices( - finish_reason="stop", - index=0, - message=Message(content="Hello!", role="assistant"), - ) - ], - created=1234567890, - model="anthropic/claude-haiku-4-5", - object="chat.completion", - usage=Usage(prompt_tokens=1, completion_tokens=1, total_tokens=2), + response = litellm.completion( + model="opper/anthropic/claude-haiku-4-5", + messages=[{"role": "user", "content": "Hello"}], + api_key="test-key", ) - with patch.object(OpenAIGPTConfig, "transform_response", return_value=model_response): - result = config.transform_response( - model="anthropic/claude-haiku-4-5", - raw_response=mock_response, - model_response=model_response, - logging_obj=Mock(), - request_data={}, - messages=[{"role": "user", "content": "Hello"}], - optional_params={}, - litellm_params={}, - encoding=None, - ) + assert response._hidden_params["additional_headers"]["llm_provider-x-litellm-response-cost"] == 3.3e-05 - assert "llm_provider-x-litellm-response-cost" not in result._hidden_params.get("additional_headers", {}) - mock_response.json.side_effect = ValueError("malformed body") - with patch.object(OpenAIGPTConfig, "transform_response", return_value=model_response): - result = config.transform_response( - model="anthropic/claude-haiku-4-5", - raw_response=mock_response, - model_response=model_response, - logging_obj=Mock(), - request_data={}, - messages=[{"role": "user", "content": "Hello"}], - optional_params={}, - litellm_params={}, - encoding=None, - ) - assert "llm_provider-x-litellm-response-cost" not in result._hidden_params.get("additional_headers", {}) +@pytest.mark.respx() +def test_opper_missing_cost_does_not_fail_response(respx_mock, monkeypatch): + """A gateway body without usage.cost still returns content, with no cost claimed.""" + import litellm + + monkeypatch.setattr(litellm, "disable_aiohttp_transport", True) + + respx_mock.post(f"{OPPER_API_BASE}/chat/completions").respond( + status_code=200, + json=_completion_body({"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2}), + ) + + response = litellm.completion( + model="opper/anthropic/claude-haiku-4-5", + messages=[{"role": "user", "content": "Hello"}], + api_key="test-key", + ) + + assert response.choices[0].message.content == "Hello!" + additional_headers = response._hidden_params.get("additional_headers") or {} + assert "llm_provider-x-litellm-response-cost" not in additional_headers def test_opper_streaming_requests_usage_by_default(): @@ -206,11 +157,11 @@ def test_opper_streaming_requests_usage_by_default(): @pytest.mark.respx() -def test_opper_streaming_dispatch_carries_cost(respx_mock): +def test_opper_streaming_dispatch_carries_cost(respx_mock, monkeypatch): """usage.cost from the terminal usage chunk survives dispatch into stream assembly.""" import litellm - litellm.disable_aiohttp_transport = True + monkeypatch.setattr(litellm, "disable_aiohttp_transport", True) mock_chunks = [ "data: " @@ -282,11 +233,11 @@ def test_opper_streaming_dispatch_carries_cost(respx_mock): @pytest.mark.respx() -def test_opper_reasoning_effort_passes_through(respx_mock): +def test_opper_reasoning_effort_passes_through(respx_mock, monkeypatch): """reasoning_effort is not rejected client-side and reaches the request body.""" import litellm - litellm.disable_aiohttp_transport = True + monkeypatch.setattr(litellm, "disable_aiohttp_transport", True) config = litellm.OpperConfig() assert "reasoning_effort" in config.get_supported_openai_params(model="anthropic/claude-haiku-4-5") @@ -409,11 +360,11 @@ def test_opper_supported_params_dispatch(): @pytest.mark.respx() -def test_opper_unknown_model_raises_not_found(respx_mock): +def test_opper_unknown_model_raises_not_found(respx_mock, monkeypatch): """A 404 from the gateway maps to a non-retryable NotFoundError.""" import litellm - litellm.disable_aiohttp_transport = True + monkeypatch.setattr(litellm, "disable_aiohttp_transport", True) respx_mock.post(f"{OPPER_API_BASE}/chat/completions").respond( status_code=404, @@ -434,13 +385,13 @@ def test_opper_unknown_model_raises_not_found(respx_mock): @pytest.mark.respx() -def test_opper_async_completion_and_streaming(respx_mock): +def test_opper_async_completion_and_streaming(respx_mock, monkeypatch): """acompletion works non-streaming and streaming through the async dispatch path.""" import asyncio import litellm - litellm.disable_aiohttp_transport = True + monkeypatch.setattr(litellm, "disable_aiohttp_transport", True) respx_mock.post(f"{OPPER_API_BASE}/chat/completions").respond( status_code=200, @@ -517,3 +468,111 @@ def test_opper_async_completion_and_streaming(respx_mock): stream, chunks = asyncio.run(consume_stream()) assert any(c.choices and c.choices[0].delta.content == "Hi" for c in chunks) assert any(getattr(c, "usage", None) is not None and c.usage.cost == 1.1e-05 for c in stream.chunks) + + +@pytest.mark.respx() +def test_opper_get_models_prefixes_the_live_catalog(respx_mock): + """The model list is fetched from the gateway, so it tracks the catalog instead of a static table.""" + import litellm + + route = respx_mock.get(f"{OPPER_API_BASE}/models").respond( + status_code=200, + json={ + "object": "list", + "data": [ + {"id": "anthropic/claude-haiku-4-5", "object": "model"}, + {"id": "openai/gpt-5.6", "object": "model"}, + ], + }, + ) + + models = litellm.OpperConfig().get_models(api_key="test-key") + + assert models == ["opper/anthropic/claude-haiku-4-5", "opper/openai/gpt-5.6"] + assert route.calls.last.request.headers["Authorization"] == "Bearer test-key" + + +@pytest.mark.respx() +def test_opper_get_models_keeps_the_gateway_path(respx_mock): + """The catalog lives under the gateway path, not at the host root like plain OpenAI.""" + import litellm + + route = respx_mock.get("https://gw.example.com/v3/compat/models").respond( + status_code=200, + json={"object": "list", "data": [{"id": "mistral/mistral-large", "object": "model"}]}, + ) + + models = litellm.OpperConfig().get_models(api_key="test-key", api_base="https://gw.example.com/v3/compat/") + + assert models == ["opper/mistral/mistral-large"] + assert route.called + + +@pytest.mark.respx() +def test_opper_get_models_raises_on_error_status(respx_mock): + import litellm + + respx_mock.get(f"{OPPER_API_BASE}/models").respond( + status_code=401, + json={"error": "missing authorization header"}, + ) + + with pytest.raises(ValueError, match="401"): + litellm.OpperConfig().get_models(api_key="bad-key") + + +def test_opper_get_models_requires_an_api_key(): + import litellm + + with pytest.raises(ValueError, match="OPPER_API_KEY"): + litellm.OpperConfig().get_models() + + +@pytest.mark.respx() +def test_opper_valid_models_come_from_the_provider_endpoint(respx_mock): + """get_valid_models reaches the gateway catalog through the registered provider config.""" + import litellm + + api_base = "https://valid-models.example.com/v3/compat" + respx_mock.get(f"{api_base}/models").respond( + status_code=200, + json={ + "object": "list", + "data": [ + {"id": "anthropic/claude-sonnet-5", "object": "model"}, + {"id": "gemini/gemini-3-flash-preview", "object": "model"}, + ], + }, + ) + + models = litellm.get_valid_models( + check_provider_endpoint=True, + custom_llm_provider="opper", + api_key="test-key", + api_base=api_base, + ) + + assert models == ["opper/anthropic/claude-sonnet-5", "opper/gemini/gemini-3-flash-preview"] + + +def test_opper_is_selectable_in_the_add_model_form(): + from pathlib import Path + + import litellm + + path = Path(litellm.__file__).parent / "proxy" / "public_endpoints" / "provider_create_fields.json" + with open(path) as f: + entries = [e for e in json.load(f) if e["litellm_provider"] == "opper"] + + assert len(entries) == 1, "opper must appear exactly once in provider_create_fields.json" + + entry = entries[0] + assert entry["provider"] == "Opper" + assert entry["provider_display_name"] == "Opper" + assert entry["default_model_placeholder"].startswith("opper/") + + fields = {f["key"]: f for f in entry["credential_fields"]} + assert fields["api_key"]["required"] is True + assert fields["api_key"]["field_type"] == "password" + assert fields["api_base"]["required"] is False + assert fields["api_base"]["placeholder"] == OPPER_API_BASE diff --git a/tests/test_litellm/test_utils.py b/tests/test_litellm/test_utils.py index d89496a0fd0..03d0082b71d 100644 --- a/tests/test_litellm/test_utils.py +++ b/tests/test_litellm/test_utils.py @@ -6455,3 +6455,41 @@ def test_completion_finishes_response_metadata_before_handing_the_response_to_th assert snapshot["litellm_call_id"] assert snapshot["response_cost"] is not None assert snapshot["api_base"] + + +@pytest.mark.parametrize( + "provider, expected_class_name", + [ + (LlmProviders.FIREWORKS_AI, "FireworksAIConfig"), + (LlmProviders.OPENAI, "OpenAIGPTConfig"), + (LlmProviders.GEMINI, "GeminiModelInfo"), + (LlmProviders.VERTEX_AI, "VertexAIModelInfo"), + (LlmProviders.LITELLM_PROXY, "LiteLLMProxyChatConfig"), + (LlmProviders.TOPAZ, "TopazModelInfo"), + (LlmProviders.ANTHROPIC, "AnthropicModelInfo"), + (LlmProviders.XAI, "XAIModelInfo"), + (LlmProviders.OPPER, "OpperConfig"), + (LlmProviders.OLLAMA, "OllamaModelInfo"), + (LlmProviders.OLLAMA_CHAT, "OllamaModelInfo"), + (LlmProviders.VLLM, "VLLMModelInfo"), + (LlmProviders.HOSTED_VLLM, "VLLMModelInfo"), + (LlmProviders.LEMONADE, "LemonadeChatConfig"), + (LlmProviders.CLARIFAI, "ClarifaiConfig"), + (LlmProviders.BEDROCK, "BedrockModelInfo"), + (LlmProviders.AZURE_AI, "AzureFoundryModelInfo"), + ], +) +def test_get_provider_model_info_resolves_every_mapped_provider(provider, expected_class_name): + """Every provider with dynamic model info keeps resolving to its own class.""" + from litellm.utils import ProviderConfigManager + + model_info = ProviderConfigManager.get_provider_model_info(model="some-model", provider=provider) + + assert model_info is not None + assert type(model_info).__name__ == expected_class_name + + +def test_get_provider_model_info_returns_none_for_unmapped_provider(): + from litellm.utils import ProviderConfigManager + + assert ProviderConfigManager.get_provider_model_info(model="some-model", provider=LlmProviders.DEEPSEEK) is None diff --git a/ui/litellm-dashboard/public/assets/logos/opper.svg b/ui/litellm-dashboard/public/assets/logos/opper.svg new file mode 100644 index 00000000000..6980d4a90f2 --- /dev/null +++ b/ui/litellm-dashboard/public/assets/logos/opper.svg @@ -0,0 +1 @@ + diff --git a/ui/litellm-dashboard/src/components/provider_info_helpers.test.tsx b/ui/litellm-dashboard/src/components/provider_info_helpers.test.tsx index 4c68e302267..f58e80b4f3f 100644 --- a/ui/litellm-dashboard/src/components/provider_info_helpers.test.tsx +++ b/ui/litellm-dashboard/src/components/provider_info_helpers.test.tsx @@ -73,6 +73,17 @@ describe("provider_info_helpers", () => { expect(fromEnumKey.logo).toBe(providerLogoMap[Providers.SCX_AI]); }); + it("should map the opper slug and Opper enum key to the Opper display name and logo", () => { + const fromSlug = getProviderLogoAndName("opper"); + expect(fromSlug.displayName).toBe(Providers.Opper); + expect(fromSlug.logo).toBe(providerLogoMap[Providers.Opper]); + expect(fromSlug.logo).toBeTruthy(); + + const fromEnumKey = getProviderLogoAndName("Opper"); + expect(fromEnumKey.displayName).toBe(Providers.Opper); + expect(fromEnumKey.logo).toBe(providerLogoMap[Providers.Opper]); + }); + it("should map bedrock_mantle slug to Bedrock Mantle display name and logo", () => { const result = getProviderLogoAndName("bedrock_mantle"); expect(result.displayName).toBe(Providers.BedrockMantle); @@ -205,6 +216,10 @@ describe("provider_info_helpers", () => { expect(getPlaceholder(Providers.SCX_AI)).toBe("scx-ai/GLM-5.2"); }); + it("should return an opper model placeholder for Opper provider", () => { + expect(getPlaceholder(Providers.Opper)).toBe("opper/anthropic/claude-haiku-4-5"); + }); + it("should return claude-3-opus placeholder for Anthropic provider", () => { expect(getPlaceholder(Providers.Anthropic)).toBe("claude-3-opus"); }); diff --git a/ui/litellm-dashboard/src/components/provider_info_helpers.tsx b/ui/litellm-dashboard/src/components/provider_info_helpers.tsx index de83cd00790..0bab3dbfda4 100644 --- a/ui/litellm-dashboard/src/components/provider_info_helpers.tsx +++ b/ui/litellm-dashboard/src/components/provider_info_helpers.tsx @@ -43,6 +43,7 @@ import nvidiaTritonLogo from "../../public/assets/logos/nvidia_triton.png"; import ollamaLogo from "../../public/assets/logos/ollama.svg"; import openaiSmallLogo from "../../public/assets/logos/openai_small.svg"; import openrouterLogo from "../../public/assets/logos/openrouter.svg"; +import opperLogo from "../../public/assets/logos/opper.svg"; import oracleLogo from "../../public/assets/logos/oracle.svg"; import perplexityAiLogo from "../../public/assets/logos/perplexity-ai.svg"; import qwenLogo from "../../public/assets/logos/qwen.png"; @@ -145,6 +146,7 @@ export enum Providers { OpenAI_Text = "OpenAI Text Completion", OpenAI_Text_Compatible = "OpenAI-Compatible Completions (legacy /v1/completions)", Openrouter = "Openrouter", + Opper = "Opper", Oracle = "Oracle Cloud Infrastructure (OCI)", OVHCLOUD = "Ovhcloud", Perplexity = "Perplexity", @@ -260,6 +262,7 @@ export const provider_map: Record = { OpenAI_Text: "text-completion-openai", OpenAI_Text_Compatible: "text-completion-openai", Openrouter: "openrouter", + Opper: "opper", Oracle: "oci", OVHCLOUD: "ovhcloud", Perplexity: "perplexity", @@ -362,6 +365,7 @@ export const providerLogoMap: Partial> = { [Providers.OpenAI_Text_Compatible]: openaiSmallLogo.src, [Providers.OpenAI_Compatible]: openaiSmallLogo.src, [Providers.Openrouter]: openrouterLogo.src, + [Providers.Opper]: opperLogo.src, [Providers.Oracle]: oracleLogo.src, [Providers.Perplexity]: perplexityAiLogo.src, [Providers.Qwen_AI_Platform]: qwenLogo.src, @@ -436,6 +440,7 @@ const providerPlaceholderMap: Partial> = { [Providers.Google_AI_Studio]: "gemini-pro", [Providers.JinaAI]: "jina_ai/", [Providers.NVIDIA_RIVA]: "nvidia_riva/nvidia/parakeet-ctc-1_1b-asr", + [Providers.Opper]: "opper/anthropic/claude-haiku-4-5", [Providers.Oracle]: "oci/xai.grok-4", [Providers.RunwayML]: "runwayml/gen4_turbo", [Providers.SageMaker]: "sagemaker/jumpstart-dft-meta-textgeneration-llama-2-7b",