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",