feat: list the Opper catalog from the gateway and add it to the dashboard

get_models reads the gateway's own model list so the 600+ model catalog
tracks Opper rather than a static price table, with get_api_key and
get_api_base resolving OPPER_* instead of inheriting OpenAI's. Registering
the provider for model info is what makes that list reachable, so the simple
half of get_provider_model_info became a frozen factory map to stay under the
complexity ceiling. Opper is now selectable in the Add Model form with its own
logo and placeholder.
This commit is contained in:
Jose Sabater 2026-08-24 14:34:58 +02:00
parent 220801e140
commit c687f9ffcf
11 changed files with 344 additions and 154 deletions

View file

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

View file

@ -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

View file

@ -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

View file

@ -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

View file

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

View file

@ -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

View file

@ -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

View file

@ -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

View file

@ -0,0 +1 @@
<svg viewBox="0 0 315 315" fill="none" xmlns="http://www.w3.org/2000/svg"><g transform="translate(49.5 0)"><path d="M159.78 315C71.53 315 0 244.49 0 157.5C0 -18.9499 159.78 0.650075 159.78 0.650075C159.78 87.2201 88.36 157.4 0.2 157.5C149.8 157.64 159.78 315 159.78 315ZM160.52 217.98C160.52 217.98 156.94 161.65 105.04 157.52C120.6 157.34 160.52 151.54 160.52 96.5601C160.52 151.54 200.44 157.34 216 157.52C164.1 161.63 160.52 217.98 160.52 217.98Z" fill="#1B2E40"/></g></svg>

After

Width:  |  Height:  |  Size: 478 B

View file

@ -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");
});

View file

@ -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<string, string> = {
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<Record<Providers, string>> = {
[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<Record<Providers, string>> = {
[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",