diff --git a/litellm/__init__.py b/litellm/__init__.py index ccfbf80369f..076d1776024 100644 --- a/litellm/__init__.py +++ b/litellm/__init__.py @@ -1561,6 +1561,7 @@ if TYPE_CHECKING: from .llms.openrouter.chat.transformation import ( OpenrouterConfig as OpenrouterConfig, ) + from .llms.opper.chat.transformation import OpperConfig as OpperConfig from .llms.datarobot.chat.transformation import DataRobotConfig as DataRobotConfig from .llms.anthropic.chat.transformation import AnthropicConfig as AnthropicConfig from .llms.bedrock.claude_platform.transformation import ( diff --git a/litellm/_lazy_imports_registry.py b/litellm/_lazy_imports_registry.py index dc323c8cc15..9a4fa7f1cff 100644 --- a/litellm/_lazy_imports_registry.py +++ b/litellm/_lazy_imports_registry.py @@ -131,6 +131,7 @@ LLM_CONFIG_NAMES: Final = ( "OobaboogaConfig", "MaritalkConfig", "OpenrouterConfig", + "OpperConfig", "DataRobotConfig", "AnthropicConfig", "BedrockClaudePlatformConfig", @@ -624,6 +625,7 @@ _LLM_CONFIGS_IMPORT_MAP: Final = { "OobaboogaConfig": (".llms.oobabooga.chat.transformation", "OobaboogaConfig"), "MaritalkConfig": (".llms.maritalk", "MaritalkConfig"), "OpenrouterConfig": (".llms.openrouter.chat.transformation", "OpenrouterConfig"), + "OpperConfig": (".llms.opper.chat.transformation", "OpperConfig"), "DataRobotConfig": (".llms.datarobot.chat.transformation", "DataRobotConfig"), "AnthropicConfig": (".llms.anthropic.chat.transformation", "AnthropicConfig"), "BedrockClaudePlatformConfig": ( diff --git a/litellm/constants.py b/litellm/constants.py index 5f8fa203b37..f2d118b59e6 100644 --- a/litellm/constants.py +++ b/litellm/constants.py @@ -641,6 +641,7 @@ LITELLM_CHAT_PROVIDERS: Final = [ "datarobot", "helicone", "openrouter", + "opper", "cometapi", "vertex_ai", "vertex_ai_beta", diff --git a/litellm/exceptions.py b/litellm/exceptions.py index 3f22a4b2dcd..3d4a25dff57 100644 --- a/litellm/exceptions.py +++ b/litellm/exceptions.py @@ -860,7 +860,7 @@ class APIConnectionError(openai.APIConnectionError): self.model = model self.status_code = 500 self.litellm_debug_info = litellm_debug_info - self.request = httpx.Request(method="POST", url="https://api.openai.com/v1") + self.request = request if request is not None else httpx.Request(method="POST", url="https://api.openai.com/v1") self.max_retries = max_retries self.num_retries = num_retries super().__init__(message=self.message, request=self.request) diff --git a/litellm/litellm_core_utils/exception_mapping_utils.py b/litellm/litellm_core_utils/exception_mapping_utils.py index 82708d412c9..9ae30bf4dde 100644 --- a/litellm/litellm_core_utils/exception_mapping_utils.py +++ b/litellm/litellm_core_utils/exception_mapping_utils.py @@ -2195,12 +2195,15 @@ def _map_openrouter_exception( ) else: # if no status code then it is an APIConnectionError: https://github.com/openai/openai-python#handling-errors + fallback_api_base: Final = ( + "https://api.opper.ai/v3/compat" if custom_llm_provider == "opper" else "https://api.openai.com/v1/" + ) raise APIConnectionError( message=f"APIConnectionError: {exception_provider} - {error_str}", llm_provider=custom_llm_provider, model=model, litellm_debug_info=extra_information, - request=httpx.Request(method="POST", url="https://api.openai.com/v1/"), + request=httpx.Request(method="POST", url=fallback_api_base), ) @@ -2609,7 +2612,7 @@ def exception_type( exception_provider=exception_provider, extra_information=extra_information, ) - if custom_llm_provider == "openrouter": + if custom_llm_provider in ("openrouter", "opper"): _map_openrouter_exception( model=model, original_exception=mappable_exception, diff --git a/litellm/litellm_core_utils/get_llm_provider_logic.py b/litellm/litellm_core_utils/get_llm_provider_logic.py index 02681d8b499..4ca6bb08aa7 100644 --- a/litellm/litellm_core_utils/get_llm_provider_logic.py +++ b/litellm/litellm_core_utils/get_llm_provider_logic.py @@ -204,6 +204,12 @@ def get_llm_provider( return remainder, custom_llm_provider, dynamic_api_key, api_base return model, custom_llm_provider, dynamic_api_key, api_base + if custom_llm_provider == "opper" and model.startswith("opper/"): + opper_remainder: Final = model[len("opper/") :] + if "/" in opper_remainder: + return opper_remainder, custom_llm_provider, dynamic_api_key, api_base + return model, custom_llm_provider, dynamic_api_key, api_base + # Check JSON-configured providers FIRST (before enum-based provider_list) provider_prefix: Final = model.split("/", 1)[0] if len(model.split("/")) > 1 and JSONProviderRegistry.exists(provider_prefix): @@ -692,6 +698,10 @@ def _get_openai_compatible_provider_info( api_base = api_base or get_secret("TENCENT_API_BASE") or "https://tokenhub-intl.tencentcloudmaas.com/v1" 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" + + 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/litellm_core_utils/get_supported_openai_params.py b/litellm/litellm_core_utils/get_supported_openai_params.py index 915a03025d9..b9e310fb71a 100644 --- a/litellm/litellm_core_utils/get_supported_openai_params.py +++ b/litellm/litellm_core_utils/get_supported_openai_params.py @@ -142,6 +142,8 @@ def get_supported_openai_params( return litellm.AzureOpenAIConfig().get_supported_openai_params(model=_azure_detection_model) elif custom_llm_provider == "openrouter": return litellm.OpenrouterConfig().get_supported_openai_params(model=model) + elif custom_llm_provider == "opper": + return litellm.OpperConfig().get_supported_openai_params(model=model) elif custom_llm_provider == "vercel_ai_gateway": return litellm.VercelAIGatewayConfig().get_supported_openai_params(model=model) elif custom_llm_provider == "mistral" or custom_llm_provider == "codestral": diff --git a/litellm/llms/opper/__init__.py b/litellm/llms/opper/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/litellm/llms/opper/chat/__init__.py b/litellm/llms/opper/chat/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/litellm/llms/opper/chat/transformation.py b/litellm/llms/opper/chat/transformation.py new file mode 100644 index 00000000000..5744f8d3600 --- /dev/null +++ b/litellm/llms/opper/chat/transformation.py @@ -0,0 +1,128 @@ +""" +Translate from OpenAI's `/v1/chat/completions` to the Opper AI gateway's `/v3/compat/chat/completions` +""" + +from collections.abc import AsyncIterator, Iterator +from typing import Final + +import httpx + +from litellm._logging import verbose_logger +from litellm.llms.base_llm.chat.transformation import BaseLLMException, LiteLLMLoggingObj +from litellm.types.llms.openai import AllMessageValues +from litellm.types.utils import ModelResponse, ModelResponseStream, StreamingChoices + +from ...openai.chat.gpt_transformation import ( + OpenAIChatCompletionStreamingHandler, + OpenAIGPTConfig, +) +from ..common_utils import OpperException + + +class OpperConfig(OpenAIGPTConfig): + @property + def custom_llm_provider(self) -> str | None: + return "opper" + + def get_supported_openai_params(self, model: str) -> list: # mutable-ok: mirrors the OpenAIGPTConfig signature + supported_params: Final = super().get_supported_openai_params(model=model) + if "reasoning_effort" not in supported_params: + supported_params.append("reasoning_effort") + return supported_params + + def _should_preserve_cache_control_for_endpoint( + self, + custom_llm_provider: str | None, + api_base: str | None, + ) -> bool: + return True + + def transform_request( + self, + model: str, + messages: list[AllMessageValues], # mutable-ok: mirrors the OpenAIGPTConfig signature + optional_params: dict, # mutable-ok: mirrors the OpenAIGPTConfig signature + litellm_params: dict, # mutable-ok: mirrors the OpenAIGPTConfig signature + headers: dict, # mutable-ok: mirrors the OpenAIGPTConfig signature + ) -> 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.setdefault("include_usage", True) + request["stream_options"] = stream_options + return request + + def transform_response( + self, + model: str, + raw_response: httpx.Response, + model_response: ModelResponse, + logging_obj: LiteLLMLoggingObj, + request_data: dict, # mutable-ok: mirrors the OpenAIGPTConfig signature + messages: list[AllMessageValues], # mutable-ok: mirrors the OpenAIGPTConfig signature + optional_params: dict, # mutable-ok: mirrors the OpenAIGPTConfig signature + litellm_params: dict, # mutable-ok: mirrors the OpenAIGPTConfig signature + encoding: object, + api_key: str | None = None, + json_mode: bool | None = None, + ) -> ModelResponse: + model_response = super().transform_response( + model=model, + raw_response=raw_response, + model_response=model_response, + logging_obj=logging_obj, + request_data=request_data, + messages=messages, + optional_params=optional_params, + litellm_params=litellm_params, + encoding=encoding, + api_key=api_key, + json_mode=json_mode, + ) + + try: + response_json: Final = raw_response.json() + 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 + ) + except (ValueError, TypeError, KeyError, AttributeError): + verbose_logger.debug("Opper: could not extract usage.cost from response") + + return model_response + + def get_error_class( + self, + error_message: str, + status_code: int, + headers: dict | httpx.Headers, # mutable-ok: mirrors the BaseConfig signature + ) -> BaseLLMException: + return OpperException( + message=error_message, + status_code=status_code, + headers=headers, + ) + + def get_model_response_iterator( + self, + streaming_response: Iterator[str] | AsyncIterator[str] | ModelResponse, + sync_stream: bool, + json_mode: bool | None = False, + ) -> "OpperChatCompletionStreamingHandler": + return OpperChatCompletionStreamingHandler( + streaming_response=streaming_response, + sync_stream=sync_stream, + json_mode=json_mode, + ) + + +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()] + return parsed diff --git a/litellm/llms/opper/common_utils.py b/litellm/llms/opper/common_utils.py new file mode 100644 index 00000000000..3e50fc715cc --- /dev/null +++ b/litellm/llms/opper/common_utils.py @@ -0,0 +1,5 @@ +from litellm.llms.base_llm.chat.transformation import BaseLLMException + + +class OpperException(BaseLLMException): + pass diff --git a/litellm/main.py b/litellm/main.py index 17edafcdfca..a2c29127ed7 100644 --- a/litellm/main.py +++ b/litellm/main.py @@ -3465,6 +3465,54 @@ def _complete_openrouter(ctx: _CompletionDispatchContext) -> _CompletionDispatch return response +def _complete_opper(ctx: _CompletionDispatchContext) -> _CompletionDispatchResult: + acompletion: Final = ctx.acompletion + client: Final = ctx.client + litellm_params: Final = ctx.litellm_params + logging: Final = ctx.logging + messages: Final = ctx.messages + model: Final = ctx.model + model_response: Final = ctx.model_response + optional_params: Final = ctx.optional_params + shared_session: Final = ctx.shared_session + 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_key: Final = ctx.api_key or litellm.api_key or get_secret_str("OPPER_API_KEY") + headers: Final = ctx.headers or litellm.headers + + config: Final = litellm.OpperConfig.get_config() + for k, v in config.items(): + if k not in optional_params: + optional_params[k] = v + + response: Final = base_llm_http_handler.completion( + model=model, + stream=stream, + messages=messages, + acompletion=acompletion, + api_base=api_base, + model_response=model_response, + optional_params=optional_params, + litellm_params=litellm_params, + shared_session=shared_session, + custom_llm_provider="opper", + timeout=timeout, + headers=headers, + encoding=_get_encoding(), + api_key=api_key, + logging_obj=logging, + client=client, + ) + ## LOGGING + logging.post_call(input=messages, api_key=api_key, original_response=response) + + return response + + def _complete_vercel_ai_gateway( ctx: _CompletionDispatchContext, ) -> _CompletionDispatchResult: @@ -5810,6 +5858,8 @@ def completion( response = _complete_datarobot(_dispatch_ctx) elif custom_llm_provider == "openrouter": response = _complete_openrouter(_dispatch_ctx) + elif custom_llm_provider == "opper": + response = _complete_opper(_dispatch_ctx) # rebind-ok: dispatch chain assigns response per provider branch elif custom_llm_provider == "vercel_ai_gateway": response = _complete_vercel_ai_gateway(_dispatch_ctx) elif custom_llm_provider == "palm": diff --git a/litellm/types/utils.py b/litellm/types/utils.py index 00c55b35182..2a06be0009f 100644 --- a/litellm/types/utils.py +++ b/litellm/types/utils.py @@ -3918,6 +3918,7 @@ class LlmProviders(str, Enum): HUGGINGFACE = "huggingface" TOGETHER_AI = "together_ai" OPENROUTER = "openrouter" + OPPER = "opper" DATAROBOT = "datarobot" VERTEX_AI = "vertex_ai" VERTEX_AI_BETA = "vertex_ai_beta" diff --git a/litellm/utils.py b/litellm/utils.py index 7732cd88cb5..a772ad6d194 100644 --- a/litellm/utils.py +++ b/litellm/utils.py @@ -4699,6 +4699,13 @@ def get_optional_params( model=model, 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), + ) elif custom_llm_provider == "watsonx": optional_params = litellm.IBMWatsonXChatConfig().map_openai_params( non_default_params=non_default_params, @@ -6441,6 +6448,11 @@ def validate_environment( keys_in_environment = True else: missing_keys.append("OPENROUTER_API_KEY") + elif custom_llm_provider == "opper": + if "OPPER_API_KEY" in os.environ: + keys_in_environment = True # rebind-ok: provider chain rebinds the shared result flag + else: + missing_keys.append("OPPER_API_KEY") elif custom_llm_provider == "vercel_ai_gateway": if "VERCEL_AI_GATEWAY_API_KEY" in os.environ: keys_in_environment = True @@ -8184,6 +8196,7 @@ class ProviderConfigManager: LlmProviders.HUGGINGFACE: (lambda: litellm.HuggingFaceChatConfig(), False), LlmProviders.TOGETHER_AI: (lambda: litellm.TogetherAIChatConfig(), False), LlmProviders.OPENROUTER: (lambda: litellm.OpenrouterConfig(), False), + LlmProviders.OPPER: (lambda: litellm.OpperConfig(), False), LlmProviders.VERCEL_AI_GATEWAY: ( lambda: litellm.VercelAIGatewayConfig(), False, diff --git a/provider_endpoints_support.json b/provider_endpoints_support.json index c71f4a82a4a..c541f352d2f 100644 --- a/provider_endpoints_support.json +++ b/provider_endpoints_support.json @@ -1950,6 +1950,23 @@ "interactions": true } }, + "opper": { + "display_name": "Opper (`opper`)", + "url": "https://docs.litellm.ai/docs/providers/opper", + "endpoints": { + "chat_completions": true, + "messages": false, + "responses": false, + "embeddings": false, + "image_generations": false, + "audio_transcriptions": false, + "audio_speech": false, + "moderations": false, + "batches": false, + "rerank": false, + "a2a": false + } + }, "ovhcloud": { "display_name": "OVHCloud AI Endpoints (`ovhcloud`)", "url": "https://docs.litellm.ai/docs/providers/ovhcloud", diff --git a/tests/test_litellm/llms/opper/test_opper.py b/tests/test_litellm/llms/opper/test_opper.py new file mode 100644 index 00000000000..9d6d5933038 --- /dev/null +++ b/tests/test_litellm/llms/opper/test_opper.py @@ -0,0 +1,519 @@ +import json +import os +from unittest.mock import Mock, patch + +import httpx +import pytest + +OPPER_API_BASE = "https://api.opper.ai/v3/compat" + + +def test_opper_provider_registered(): + import litellm + + assert litellm.LlmProviders.OPPER.value == "opper" + assert litellm.LlmProviders("opper") == litellm.LlmProviders.OPPER + + +def test_opper_provider_detection_by_prefix(): + """The provider/model remainder after the opper/ prefix is preserved intact.""" + from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider + + model, provider, _, api_base = get_llm_provider("opper/anthropic/claude-haiku-4-5") + + assert model == "anthropic/claude-haiku-4-5" + assert provider == "opper" + assert api_base == OPPER_API_BASE + + +def test_opper_env_var_resolution(): + from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider + + with patch.dict( + os.environ, + { + "OPPER_API_KEY": "test-key", + "OPPER_API_BASE": "https://gw.example.com/v3/compat", + }, + ): + model, provider, api_key, api_base = get_llm_provider("opper/anthropic/claude-haiku-4-5") + + assert provider == "opper" + assert api_key == "test-key" + assert api_base == "https://gw.example.com/v3/compat" + + +def test_opper_chat_config_registered(): + import litellm + from litellm.types.utils import LlmProviders + from litellm.utils import ProviderConfigManager + + config = ProviderConfigManager.get_provider_chat_config( + model="anthropic/claude-haiku-4-5", provider=LlmProviders.OPPER + ) + 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.""" + 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 = { + "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), + ) + + 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), + ) + + 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", {}) + + 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", {}) + + +def test_opper_streaming_requests_usage_by_default(): + """Streaming requests ask for the usage chunk by default; explicit opt-out wins.""" + import litellm + + config = litellm.OpperConfig() + messages = [{"role": "user", "content": "Hello"}] + + streaming_request = config.transform_request( + model="anthropic/claude-haiku-4-5", + messages=messages, + optional_params={"stream": True}, + litellm_params={}, + headers={}, + ) + assert streaming_request["stream_options"] == {"include_usage": True} + + opted_out_request = config.transform_request( + model="anthropic/claude-haiku-4-5", + messages=messages, + optional_params={"stream": True, "stream_options": {"include_usage": False}}, + litellm_params={}, + headers={}, + ) + assert opted_out_request["stream_options"] == {"include_usage": False} + + non_streaming_request = config.transform_request( + model="anthropic/claude-haiku-4-5", + messages=messages, + optional_params={}, + litellm_params={}, + headers={}, + ) + assert "stream_options" not in non_streaming_request + + +@pytest.mark.respx() +def test_opper_streaming_dispatch_carries_cost(respx_mock): + """usage.cost from the terminal usage chunk survives dispatch into stream assembly.""" + import litellm + + litellm.disable_aiohttp_transport = True + + mock_chunks = [ + "data: " + + json.dumps( + { + "id": "chatcmpl-123", + "object": "chat.completion.chunk", + "created": 1677652288, + "model": "anthropic/claude-haiku-4-5", + "choices": [{"index": 0, "delta": {"content": "Hello"}, "finish_reason": None}], + } + ) + + "\n\n", + "data: " + + json.dumps( + { + "id": "chatcmpl-123", + "object": "chat.completion.chunk", + "created": 1677652288, + "model": "anthropic/claude-haiku-4-5", + "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}], + } + ) + + "\n\n", + "data: " + + json.dumps( + { + "id": "chatcmpl-123", + "object": "chat.completion.chunk", + "created": 1677652288, + "model": "anthropic/claude-haiku-4-5", + "choices": [], + "usage": { + "prompt_tokens": 10, + "completion_tokens": 20, + "total_tokens": 30, + "cost": 3.3e-05, + }, + } + ) + + "\n\n", + "data: [DONE]\n\n", + ] + + respx_mock.post(f"{OPPER_API_BASE}/chat/completions").respond( + status_code=200, + headers={"content-type": "text/event-stream"}, + content="".join(mock_chunks), + ) + + response = litellm.completion( + model="opper/anthropic/claude-haiku-4-5", + messages=[{"role": "user", "content": "Hello"}], + api_key="test-key", + stream=True, + ) + yielded_chunks = list(response) + + request_body = json.loads(respx_mock.calls[0].request.content) + assert request_body["stream_options"] == {"include_usage": True} + + assert [c.choices[0].delta.content for c in yielded_chunks] == ["Hello", None] + assert all(getattr(c, "usage", None) is None for c in yielded_chunks) + + collected_usages = [getattr(c, "usage", None) for c in response.chunks] + assert any(u is not None and u.cost == 3.3e-05 for u in collected_usages) + complete_response = litellm.stream_chunk_builder(response.chunks, messages=[{"role": "user", "content": "Hello"}]) + assert complete_response.usage.cost == 3.3e-05 + + +@pytest.mark.respx() +def test_opper_reasoning_effort_passes_through(respx_mock): + """reasoning_effort is not rejected client-side and reaches the request body.""" + import litellm + + litellm.disable_aiohttp_transport = True + + config = litellm.OpperConfig() + assert "reasoning_effort" in config.get_supported_openai_params(model="anthropic/claude-haiku-4-5") + + respx_mock.post(f"{OPPER_API_BASE}/chat/completions").respond( + status_code=200, + json={ + "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": {"prompt_tokens": 10, "completion_tokens": 20, "total_tokens": 30}, + }, + ) + + litellm.completion( + model="opper/anthropic/claude-haiku-4-5", + messages=[{"role": "user", "content": "Hello"}], + api_key="test-key", + reasoning_effort="high", + ) + + request_body = json.loads(respx_mock.calls[0].request.content) + assert request_body["reasoning_effort"] == "high" + + +def test_opper_preserves_cache_control_in_content(): + """Per-content cache_control markers are not stripped from the request.""" + import litellm + + config = litellm.OpperConfig() + + transformed_request = config.transform_request( + model="anthropic/claude-haiku-4-5", + messages=[ + { + "role": "user", + "content": [ + { + "type": "text", + "text": "Long cached context", + "cache_control": {"type": "ephemeral"}, + }, + {"type": "text", "text": "Question"}, + ], + } + ], + optional_params={}, + litellm_params={}, + headers={}, + ) + + content = transformed_request["messages"][0]["content"] + assert content[0]["cache_control"] == {"type": "ephemeral"} + assert "cache_control" not in content[1] + + +def test_opper_connection_error_reports_opper_endpoint(): + """Status-less failures carry Opper request metadata, not the OpenAI default.""" + import litellm + from litellm.litellm_core_utils.exception_mapping_utils import exception_type + + with pytest.raises(litellm.APIConnectionError) as excinfo: + exception_type( + model="anthropic/claude-haiku-4-5", + original_exception=Exception("connection reset"), + custom_llm_provider="opper", + ) + + assert "api.opper.ai" in str(excinfo.value.request.url) + + +def test_opper_get_llm_provider_with_explicit_provider(): + """With custom_llm_provider preset, the opper/ routing prefix is stripped from provider/model IDs.""" + from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider + + model, provider, _, _ = get_llm_provider("opper/anthropic/claude-haiku-4-5", custom_llm_provider="opper") + assert model == "anthropic/claude-haiku-4-5" + assert provider == "opper" + + model, provider, _, _ = get_llm_provider("opper/auto", custom_llm_provider="opper") + assert model == "opper/auto" + assert provider == "opper" + + +def test_opper_validate_environment(): + """validate_environment reports OPPER_API_KEY as the required credential.""" + import litellm + + with patch.dict(os.environ, {"OPPER_API_KEY": "test-key"}, clear=False): + present = litellm.validate_environment("opper/anthropic/claude-haiku-4-5") + assert present["keys_in_environment"] is True + assert present["missing_keys"] == [] + + env_without_key = {k: v for k, v in os.environ.items() if k != "OPPER_API_KEY"} + with patch.dict(os.environ, env_without_key, clear=True): + missing = litellm.validate_environment("opper/anthropic/claude-haiku-4-5") + assert missing["keys_in_environment"] is False + assert "OPPER_API_KEY" in missing["missing_keys"] + + +def test_opper_supported_params_dispatch(): + """The get_supported_openai_params dispatch resolves the Opper config.""" + import litellm + from litellm.litellm_core_utils.get_supported_openai_params import ( + get_supported_openai_params, + ) + + assert litellm.OpperConfig().custom_llm_provider == "opper" + params = get_supported_openai_params(model="anthropic/claude-haiku-4-5", custom_llm_provider="opper") + assert params is not None + assert "reasoning_effort" in params + + +@pytest.mark.respx() +def test_opper_unknown_model_raises_not_found(respx_mock): + """A 404 from the gateway maps to a non-retryable NotFoundError.""" + import litellm + + litellm.disable_aiohttp_transport = True + + respx_mock.post(f"{OPPER_API_BASE}/chat/completions").respond( + status_code=404, + json={ + "error": { + "message": "model nonexistent/model not found", + "type": "model_not_found", + } + }, + ) + + with pytest.raises(litellm.NotFoundError): + litellm.completion( + model="opper/nonexistent/model", + messages=[{"role": "user", "content": "Hello"}], + api_key="test-key", + ) + + +@pytest.mark.respx() +def test_opper_async_completion_and_streaming(respx_mock): + """acompletion works non-streaming and streaming through the async dispatch path.""" + import asyncio + + import litellm + + litellm.disable_aiohttp_transport = True + + respx_mock.post(f"{OPPER_API_BASE}/chat/completions").respond( + status_code=200, + json={ + "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": {"prompt_tokens": 10, "completion_tokens": 20, "total_tokens": 30, "cost": 3.3e-05}, + }, + ) + + response = asyncio.run( + litellm.acompletion( + model="opper/anthropic/claude-haiku-4-5", + messages=[{"role": "user", "content": "Hello"}], + api_key="test-key", + ) + ) + assert response.choices[0].message.content == "Hello!" + assert response._hidden_params["additional_headers"]["llm_provider-x-litellm-response-cost"] == 3.3e-05 + + stream_chunks = [ + "data: " + + json.dumps( + { + "id": "chatcmpl-124", + "object": "chat.completion.chunk", + "created": 1677652288, + "model": "anthropic/claude-haiku-4-5", + "choices": [{"index": 0, "delta": {"content": "Hi"}, "finish_reason": "stop"}], + } + ) + + "\n\n", + "data: " + + json.dumps( + { + "id": "chatcmpl-124", + "object": "chat.completion.chunk", + "created": 1677652288, + "model": "anthropic/claude-haiku-4-5", + "choices": [], + "usage": {"prompt_tokens": 5, "completion_tokens": 2, "total_tokens": 7, "cost": 1.1e-05}, + } + ) + + "\n\n", + "data: [DONE]\n\n", + ] + respx_mock.post(f"{OPPER_API_BASE}/chat/completions").respond( + status_code=200, + headers={"content-type": "text/event-stream"}, + content="".join(stream_chunks), + ) + + async def consume_stream(): + stream = await litellm.acompletion( + model="opper/anthropic/claude-haiku-4-5", + messages=[{"role": "user", "content": "Hello"}], + api_key="test-key", + stream=True, + ) + collected = [] + async for chunk in stream: + collected.append(chunk) + return stream, collected + + 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)