diff --git a/docs/my-website/docs/contributing/adding_openai_compatible_providers.md b/docs/my-website/docs/contributing/adding_openai_compatible_providers.md index bb89eea35bf1..598d3dfe89a1 100644 --- a/docs/my-website/docs/contributing/adding_openai_compatible_providers.md +++ b/docs/my-website/docs/contributing/adding_openai_compatible_providers.md @@ -80,6 +80,36 @@ That's it! The provider is now available. } ``` +## Responses API Support + +If your provider also supports the OpenAI Responses API (`/v1/responses`), add `supported_endpoints`: + +```json +{ + "your_provider": { + "base_url": "https://api.yourprovider.com/v1", + "api_key_env": "YOUR_PROVIDER_API_KEY", + "supported_endpoints": ["/v1/chat/completions", "/v1/responses"] + } +} +``` + +This enables `litellm.responses()` with zero additional code: + +```python +import litellm + +response = litellm.responses( + model="your_provider/model-name", + input="Hello, what can you do?", +) +print(response.output) +``` + +If `supported_endpoints` is omitted, it defaults to `[]`. Chat completions is always enabled for JSON providers regardless of this field. + +The provider inherits all request/response handling from OpenAI's Responses API — streaming, tools, and all standard parameters work out of the box. + ## Usage ```python @@ -89,11 +119,17 @@ import os # Set your API key os.environ["YOUR_PROVIDER_API_KEY"] = "your-key-here" -# Use the provider +# Chat completions response = litellm.completion( model="your_provider/model-name", messages=[{"role": "user", "content": "Hello"}], ) + +# Responses API (if supported_endpoints includes "/v1/responses") +response = litellm.responses( + model="your_provider/model-name", + input="Hello", +) ``` ## When to Use Python Instead @@ -105,7 +141,9 @@ Use a Python config class if you need: - Provider-specific streaming logic - Advanced tool calling modifications -For these cases, create a config class in `litellm/llms/your_provider/chat/transformation.py` that inherits from `OpenAIGPTConfig` or `OpenAILikeChatConfig`. +For chat completions, create a config class in `litellm/llms/your_provider/chat/transformation.py` that inherits from `OpenAIGPTConfig` or `OpenAILikeChatConfig`. + +For responses API with small overrides, inherit from `OpenAIResponsesAPIConfig` and override only what's needed. See `litellm/llms/perplexity/responses/transformation.py` for a minimal example (~40 lines vs 400+). ## Testing diff --git a/litellm/llms/openai_like/README.md b/litellm/llms/openai_like/README.md index 2e7a32f65a79..e9aaafe48a1b 100644 --- a/litellm/llms/openai_like/README.md +++ b/litellm/llms/openai_like/README.md @@ -10,8 +10,9 @@ Instead of creating a full Python module for simple OpenAI-compatible providers, - `providers.json` - Configuration file for all JSON-based providers - `json_loader.py` - Loads and parses the JSON configuration -- `dynamic_config.py` - Generates Python config classes from JSON -- `chat/` - Existing OpenAI-like chat completion handlers +- `dynamic_config.py` - Generates Python config classes from JSON (chat + responses) +- `chat/` - OpenAI-like chat completion handlers +- `responses/` - OpenAI-like Responses API handlers ## Adding a New Provider @@ -96,6 +97,32 @@ response = litellm.completion( ) ``` +## Responses API Support + +Providers that support the OpenAI Responses API (`/v1/responses`) can declare it via `supported_endpoints`: + +```json +{ + "your_provider": { + "base_url": "https://api.yourprovider.com/v1", + "api_key_env": "YOUR_PROVIDER_API_KEY", + "supported_endpoints": ["/v1/chat/completions", "/v1/responses"] + } +} +``` + +This enables `litellm.responses(model="your_provider/model-name", ...)` with zero Python code. +The provider inherits all request/response handling from OpenAI's Responses API config. + +If `supported_endpoints` is omitted, it defaults to `[]` (only chat completions, which is always enabled for JSON providers). + +### How It Works + +1. `json_loader.py` checks `supported_endpoints` for `/v1/responses` +2. `dynamic_config.py` generates a responses config class (inherits from `OpenAIResponsesAPIConfig`) +3. `ProviderConfigManager.get_provider_responses_api_config()` returns the generated config +4. Request/response transformation is inherited from OpenAI — no custom code needed + ## Benefits - **Simple**: 2-5 lines of JSON vs 100+ lines of Python @@ -112,6 +139,10 @@ Use a Python config class if you need: - Provider-specific streaming logic - Advanced tool calling transformations +For providers that are *mostly* OpenAI-compatible but need small overrides (e.g. preset model handling), +you can inherit from `OpenAIResponsesAPIConfig` and override only what's needed — see +`litellm/llms/perplexity/responses/transformation.py` for a minimal example (~40 lines). + ## Implementation Details ### How It Works @@ -125,5 +156,6 @@ Use a Python config class if you need: The JSON system is integrated at: - `litellm/litellm_core_utils/get_llm_provider_logic.py` - Provider resolution -- `litellm/utils.py` - ProviderConfigManager +- `litellm/utils.py` - ProviderConfigManager (chat + responses) +- `litellm/responses/main.py` - Responses API routing - `litellm/constants.py` - openai_compatible_providers list diff --git a/litellm/llms/openai_like/dynamic_config.py b/litellm/llms/openai_like/dynamic_config.py index a2ce6b9a5318..8be749f34a3d 100644 --- a/litellm/llms/openai_like/dynamic_config.py +++ b/litellm/llms/openai_like/dynamic_config.py @@ -166,3 +166,63 @@ def custom_llm_provider(self) -> Optional[str]: return provider.slug return JSONProviderConfig + + +_responses_config_cache: dict = {} + + +def create_responses_config_class(provider: SimpleProviderConfig): + """Generate a Responses API config class dynamically from JSON configuration. + + Parallel to create_config_class() but for /v1/responses endpoints. + Classes are cached per provider slug to avoid regeneration on every request. + """ + if provider.slug in _responses_config_cache: + return _responses_config_cache[provider.slug] + + from litellm.llms.openai_like.responses.transformation import ( + OpenAILikeResponsesConfig, + ) + from litellm.types.router import GenericLiteLLMParams + + class JSONProviderResponsesConfig(OpenAILikeResponsesConfig): + @property + def custom_llm_provider(self): # type: ignore[override] + return provider.slug + + def validate_environment( + self, + headers: dict, + model: str, + litellm_params: Optional[GenericLiteLLMParams], + ) -> dict: + litellm_params = litellm_params or GenericLiteLLMParams() + api_key = ( + litellm_params.api_key + or get_secret_str(provider.api_key_env) + ) + if api_key: + headers["Authorization"] = f"Bearer {api_key}" + return headers + + def get_complete_url( + self, + api_base: Optional[str], + litellm_params: dict, + ) -> str: + if not api_base: + if provider.api_base_env: + api_base = get_secret_str(provider.api_base_env) + if not api_base: + api_base = provider.base_url + + if api_base is None: + raise ValueError( + f"api_base is required for provider {provider.slug}" + ) + + api_base = api_base.rstrip("/") + return f"{api_base}/responses" + + _responses_config_cache[provider.slug] = JSONProviderResponsesConfig + return JSONProviderResponsesConfig diff --git a/litellm/llms/openai_like/json_loader.py b/litellm/llms/openai_like/json_loader.py index f516d39662e0..8b55fe4b618f 100644 --- a/litellm/llms/openai_like/json_loader.py +++ b/litellm/llms/openai_like/json_loader.py @@ -21,6 +21,7 @@ def __init__(self, slug: str, data: dict): self.param_mappings = data.get("param_mappings", {}) self.constraints = data.get("constraints", {}) self.special_handling = data.get("special_handling", {}) + self.supported_endpoints = data.get("supported_endpoints", []) class JSONProviderRegistry: @@ -64,6 +65,14 @@ def exists(cls, slug: str) -> bool: """Check if a provider is defined via JSON""" return slug in cls._providers + @classmethod + def supports_responses_api(cls, slug: str) -> bool: + """Check if a JSON provider supports the Responses API""" + provider = cls._providers.get(slug) + if provider is None: + return False + return "/v1/responses" in provider.supported_endpoints + @classmethod def list_providers(cls) -> list: """List all registered provider slugs""" diff --git a/litellm/llms/openai_like/responses/__init__.py b/litellm/llms/openai_like/responses/__init__.py new file mode 100644 index 000000000000..e5421ec73d67 --- /dev/null +++ b/litellm/llms/openai_like/responses/__init__.py @@ -0,0 +1,5 @@ +from litellm.llms.openai_like.responses.transformation import ( + OpenAILikeResponsesConfig, +) + +__all__ = ["OpenAILikeResponsesConfig"] diff --git a/litellm/llms/openai_like/responses/transformation.py b/litellm/llms/openai_like/responses/transformation.py new file mode 100644 index 000000000000..ff4969013639 --- /dev/null +++ b/litellm/llms/openai_like/responses/transformation.py @@ -0,0 +1,51 @@ +""" +OpenAI-like Responses API transformation. + +Base class for JSON-declared providers that support the /v1/responses endpoint. +Inherits everything from OpenAIResponsesAPIConfig; subclasses only override +provider-specific resolution (slug, API key env var, base URL). +""" + +from typing import Optional, Union + +from litellm.llms.openai.responses.transformation import OpenAIResponsesAPIConfig +from litellm.secret_managers.main import get_secret_str +from litellm.types.router import GenericLiteLLMParams +from litellm.types.utils import LlmProviders + + +class OpenAILikeResponsesConfig(OpenAIResponsesAPIConfig): + """ + Responses API config for OpenAI-compatible providers declared via JSON. + + Concrete per-provider classes are generated dynamically in dynamic_config.py. + This base provides the three overridable hooks that the dynamic generator + fills in: custom_llm_provider, validate_environment, get_complete_url. + """ + + @property + def custom_llm_provider(self) -> Union[str, LlmProviders]: # type: ignore[override] + return "openai_like" + + def validate_environment( + self, + headers: dict, + model: str, + litellm_params: Optional[GenericLiteLLMParams], + ) -> dict: + litellm_params = litellm_params or GenericLiteLLMParams() + api_key = litellm_params.api_key or get_secret_str("OPENAI_LIKE_API_KEY") + if api_key: + headers["Authorization"] = f"Bearer {api_key}" + return headers + + def get_complete_url( + self, + api_base: Optional[str], + litellm_params: dict, + ) -> str: + api_base = api_base or get_secret_str("OPENAI_LIKE_API_BASE") + if not api_base: + raise ValueError("api_base is required for openai_like provider") + api_base = api_base.rstrip("/") + return f"{api_base}/responses" diff --git a/litellm/llms/perplexity/responses/transformation.py b/litellm/llms/perplexity/responses/transformation.py index b6feb4ae4989..f365ef07a615 100644 --- a/litellm/llms/perplexity/responses/transformation.py +++ b/litellm/llms/perplexity/responses/transformation.py @@ -1,54 +1,31 @@ """ -Transformation logic for Perplexity Agent API (Responses API) +Perplexity Responses API — OpenAI-compatible. -This module handles the translation between OpenAI's Responses API format -and Perplexity's Responses API format, which supports: -- Third-party model access (OpenAI, Anthropic, Google, xAI, etc.) -- Presets for optimized configurations -- Web search and URL fetching tools -- Reasoning effort control -- Instructions parameter for system-level guidance +The only provider quirks: +- cost returned as dict → handled by ResponseAPIUsage.parse_cost validator +- preset models (preset/pro-search) → handled by transform_responses_api_request +- HTTP 200 with status:"failed" → raised as exception in transform_response_api_response + +Ref: https://docs.perplexity.ai/api-reference/responses-post """ from typing import Any, Dict, List, Optional, Union import httpx -from litellm._logging import verbose_logger from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj from litellm.llms.base_llm.chat.transformation import BaseLLMException from litellm.llms.openai.responses.transformation import OpenAIResponsesAPIConfig from litellm.secret_managers.main import get_secret_str -from litellm.types.llms.openai import ( - ResponseAPIUsage, - ResponseInputParam, - ResponsesAPIOptionalRequestParams, - ResponsesAPIResponse, - ResponsesAPIStreamingResponse, -) +from litellm.types.llms.openai import ResponseInputParam, ResponsesAPIResponse from litellm.types.router import GenericLiteLLMParams from litellm.types.utils import LlmProviders class PerplexityResponsesConfig(OpenAIResponsesAPIConfig): - """ - Configuration for Perplexity Agent API (Responses API) - - - Reference: https://docs.perplexity.ai/docs/agent-api/overview - """ - - @property - def custom_llm_provider(self) -> LlmProviders: - return LlmProviders.PERPLEXITY def get_supported_openai_params(self, model: str) -> list: - """ - Perplexity Responses API supports a different set of parameters - - Ref: https://docs.perplexity.ai/api-reference/responses-post - Params aligned with response-echo fields and Open Responses spec. - """ + """Ref: https://docs.perplexity.ai/api-reference/responses-post""" return [ "max_output_tokens", "stream", @@ -56,200 +33,45 @@ def get_supported_openai_params(self, model: str) -> list: "top_p", "tools", "reasoning", - "preset", "instructions", - "models", # Model fallback support - "tool_choice", - "parallel_tool_calls", - "max_tool_calls", - "text", - "previous_response_id", - "store", - "background", - "truncation", - "metadata", - "safety_identifier", - "user", - "stream_options", - "top_logprobs", - "prompt_cache_key", - "frequency_penalty", - "presence_penalty", - "service_tier", + "models", ] + @property + def custom_llm_provider(self) -> LlmProviders: + return LlmProviders.PERPLEXITY + def validate_environment( self, headers: dict, model: str, litellm_params: Optional[GenericLiteLLMParams] ) -> dict: - """Validate environment and set up headers""" - # Get API key from environment - api_key = get_secret_str("PERPLEXITYAI_API_KEY") or get_secret_str( - "PERPLEXITY_API_KEY" + litellm_params = litellm_params or GenericLiteLLMParams() + api_key = ( + litellm_params.api_key + or get_secret_str("PERPLEXITYAI_API_KEY") + or get_secret_str("PERPLEXITY_API_KEY") ) - if api_key: headers["Authorization"] = f"Bearer {api_key}" - - headers["Content-Type"] = "application/json" - return headers - def get_complete_url( - self, - api_base: Optional[str], - litellm_params: dict, - ) -> str: - """Get the complete URL for the Perplexity Responses API""" - if api_base is None: - api_base = ( - get_secret_str("PERPLEXITY_API_BASE") or "https://api.perplexity.ai" - ) - - # Ensure api_base doesn't end with a slash - api_base = api_base.rstrip("/") - - # Add the responses endpoint - return f"{api_base}/v1/responses" - - def map_openai_params( # noqa: PLR0915 - self, - response_api_optional_params: ResponsesAPIOptionalRequestParams, - model: str, - drop_params: bool, - ) -> Dict: - """ - Map OpenAI Responses API parameters to Perplexity format - - Key differences: - - Supports 'preset' parameter for predefined configurations - - Supports 'instructions' parameter for system-level guidance - - Tools are specified differently (web_search, fetch_url) - """ - mapped_params: Dict[str, Any] = {} - - # Map standard parameters - if response_api_optional_params.get("max_output_tokens"): - mapped_params["max_output_tokens"] = response_api_optional_params[ - "max_output_tokens" - ] + def get_complete_url(self, api_base: Optional[str], litellm_params: dict) -> str: + api_base = api_base or get_secret_str("PERPLEXITY_API_BASE") or "https://api.perplexity.ai" + return f"{api_base.rstrip('/')}/v1/responses" - if response_api_optional_params.get("temperature"): - mapped_params["temperature"] = response_api_optional_params["temperature"] - - if response_api_optional_params.get("top_p"): - mapped_params["top_p"] = response_api_optional_params["top_p"] - - if response_api_optional_params.get("stream"): - mapped_params["stream"] = response_api_optional_params["stream"] - - if response_api_optional_params.get("stream_options"): - mapped_params["stream_options"] = response_api_optional_params[ - "stream_options" - ] - - # Map Perplexity-specific parameters (using .get() with Any dict access) - preset = response_api_optional_params.get("preset") # type: ignore - if preset: - mapped_params["preset"] = preset - - instructions = response_api_optional_params.get("instructions") # type: ignore - if instructions: - mapped_params["instructions"] = instructions - - if response_api_optional_params.get("reasoning"): - mapped_params["reasoning"] = response_api_optional_params["reasoning"] - - tools = response_api_optional_params.get("tools") - if tools: - # Convert tools to list of dicts for transformation - tools_list = [dict(tool) if hasattr(tool, "__dict__") else tool for tool in tools] # type: ignore - mapped_params["tools"] = self._transform_tools(tools_list) # type: ignore - - # Tool control - if response_api_optional_params.get("tool_choice"): - mapped_params["tool_choice"] = response_api_optional_params["tool_choice"] - if response_api_optional_params.get("parallel_tool_calls") is not None: - mapped_params["parallel_tool_calls"] = response_api_optional_params[ - "parallel_tool_calls" - ] - if response_api_optional_params.get("max_tool_calls"): - mapped_params["max_tool_calls"] = response_api_optional_params[ - "max_tool_calls" - ] - - # Structured outputs - text_param = response_api_optional_params.get("text") - if text_param: - mapped_params["text"] = text_param - - # Conversation continuity - if response_api_optional_params.get("previous_response_id"): - mapped_params["previous_response_id"] = response_api_optional_params[ - "previous_response_id" - ] - - # Storage and lifecycle - if response_api_optional_params.get("store") is not None: - mapped_params["store"] = response_api_optional_params["store"] - if response_api_optional_params.get("background") is not None: - mapped_params["background"] = response_api_optional_params["background"] - if response_api_optional_params.get("truncation"): - mapped_params["truncation"] = response_api_optional_params["truncation"] - - # Metadata - if response_api_optional_params.get("metadata"): - mapped_params["metadata"] = response_api_optional_params["metadata"] - if response_api_optional_params.get("safety_identifier"): - mapped_params["safety_identifier"] = response_api_optional_params[ - "safety_identifier" - ] - if response_api_optional_params.get("user"): - mapped_params["user"] = response_api_optional_params["user"] - - # Additional - if response_api_optional_params.get("top_logprobs") is not None: - mapped_params["top_logprobs"] = response_api_optional_params["top_logprobs"] - if response_api_optional_params.get("prompt_cache_key"): - mapped_params["prompt_cache_key"] = response_api_optional_params[ - "prompt_cache_key" - ] - if response_api_optional_params.get("frequency_penalty") is not None: - mapped_params["frequency_penalty"] = response_api_optional_params[ - "frequency_penalty" # type: ignore[typeddict-item] - ] - if response_api_optional_params.get("presence_penalty") is not None: - mapped_params["presence_penalty"] = response_api_optional_params[ - "presence_penalty" # type: ignore[typeddict-item] - ] - if response_api_optional_params.get("service_tier"): - mapped_params["service_tier"] = response_api_optional_params["service_tier"] - - return mapped_params - - def _transform_tools(self, tools: List[Dict[str, Any]]) -> List[Dict[str, Any]]: - """ - Transform tools to Perplexity format. - - Perplexity supports (per public OpenAPI spec): - - web_search: Performs web searches - - fetch_url: Fetches content from URLs - - function: Function Calling - """ - perplexity_tools = [] - - for tool in tools: - if isinstance(tool, dict): - tool_type = tool.get("type", "") - - # Direct Perplexity tool format - if tool_type in ["web_search", "fetch_url"]: - perplexity_tools.append(tool) - - # Function tools: Perplexity supports them natively - elif tool_type == "function": - perplexity_tools.append(tool) - - return perplexity_tools + def _ensure_message_type( + self, input: Union[str, ResponseInputParam] + ) -> Union[str, List[Dict[str, Any]]]: + """Ensure list input items have type='message' (required by Perplexity).""" + if isinstance(input, str): + return input + if isinstance(input, list): + result = [] + for item in input: + if isinstance(item, dict) and "type" not in item: + item = {**item, "type": "message"} + result.append(item) + return result + return input def transform_responses_api_request( self, @@ -259,62 +81,23 @@ def transform_responses_api_request( litellm_params: GenericLiteLLMParams, headers: dict, ) -> Dict: - """ - Transform request to Perplexity Responses API format - """ - # Check if the model is a preset (format: preset/preset-name) + """Handle preset/ model prefix: send as {"preset": name} instead of {"model": name}.""" + input = self._ensure_message_type(input) if model.startswith("preset/"): - preset_name = model.replace("preset/", "") - data = { - "preset": preset_name, - "input": self._format_input(input), - } - # Check if preset is explicitly provided in params - elif response_api_optional_request_params.get("preset"): - data = { - "preset": response_api_optional_request_params.pop("preset"), - "input": self._format_input(input), - } - else: - # Full request format for third-party models - data = { - "model": model, - "input": self._format_input(input), + input = self._validate_input_param(input) + data: Dict = { + "preset": model[len("preset/"):], + "input": input, } - - # Add all optional parameters - for key, value in response_api_optional_request_params.items(): - data[key] = value - - return data - - def _format_input( - self, input: Union[str, ResponseInputParam] - ) -> Union[str, List[Dict[str, Any]]]: - """ - Format input for Perplexity Responses API - - The API accepts either: - - A simple string for single-turn queries - - An array of message objects for multi-turn conversations - """ - if isinstance(input, str): - return input - - # Handle ResponseInputParam format - if isinstance(input, list): - formatted_messages = [] - for item in input: - if isinstance(item, dict): - formatted_message = { - "type": "message", - "role": item.get("role"), - "content": item.get("content", ""), - } - formatted_messages.append(formatted_message) - return formatted_messages - - return str(input) + data.update(response_api_optional_request_params) + return data + return super().transform_responses_api_request( + model=model, + input=input, + response_api_optional_request_params=response_api_optional_request_params, + litellm_params=litellm_params, + headers=headers, + ) def transform_response_api_response( self, @@ -322,175 +105,28 @@ def transform_response_api_response( raw_response: httpx.Response, logging_obj: LiteLLMLoggingObj, ) -> ResponsesAPIResponse: - """ - Transform Perplexity Responses API response to OpenAI Responses API format - """ + """Check for Perplexity's status:'failed' on HTTP 200 before delegating to base.""" try: raw_response_json = raw_response.json() - except Exception as e: - raise BaseLLMException( - status_code=raw_response.status_code, - message=f"Failed to parse response: {str(e)}", - ) + except Exception: + raw_response_json = None - # Check for error status - status = raw_response_json.get("status") - if status == "failed": + if ( + isinstance(raw_response_json, dict) + and raw_response_json.get("status") == "failed" + ): error = raw_response_json.get("error", {}) - error_message = error.get("message", "Unknown error") raise BaseLLMException( status_code=raw_response.status_code, - message=error_message, + message=error.get("message", "Unknown Perplexity error"), ) - # Transform usage to handle Perplexity's cost structure - usage_data = raw_response_json.get("usage", {}) - transformed_usage_dict = self._transform_usage(usage_data) - - # Convert usage dict to ResponseAPIUsage object - usage_obj = ( - ResponseAPIUsage(**transformed_usage_dict) - if transformed_usage_dict - else None + return super().transform_response_api_response( + model=model, + raw_response=raw_response, + logging_obj=logging_obj, ) - # Map Perplexity response to OpenAI Responses API format - response = ResponsesAPIResponse( - id=raw_response_json.get("id", ""), - object="response", - created_at=raw_response_json.get("created_at", 0), - status=raw_response_json.get("status", "completed"), - model=raw_response_json.get("model", model), - output=raw_response_json.get("output", []), - usage=usage_obj, - ) - - return response - - def _transform_usage(self, usage_data: Dict[str, Any]) -> Dict[str, Any]: - """ - Transform Perplexity usage data to OpenAI format - - Perplexity returns: - { - "input_tokens": 100, - "output_tokens": 200, - "total_tokens": 300, - "cost": { - "currency": "USD", - "input_cost": 0.0001, - "output_cost": 0.0002, - "total_cost": 0.0003 - } - } - - OpenAI expects: - { - "input_tokens": 100, - "output_tokens": 200, - "total_tokens": 300, - "cost": 0.0003 - } - """ - transformed = { - "input_tokens": usage_data.get("input_tokens", 0), - "output_tokens": usage_data.get("output_tokens", 0), - "total_tokens": usage_data.get("total_tokens", 0), - } - - # Transform cost from Perplexity format (dict) to OpenAI format (float) - cost_obj = usage_data.get("cost") - if isinstance(cost_obj, dict) and "total_cost" in cost_obj: - transformed["cost"] = cost_obj["total_cost"] - verbose_logger.debug( - "Transformed Perplexity cost object to float: %s -> %s", - cost_obj, - cost_obj["total_cost"], - ) - elif cost_obj is not None: - # If cost is already a float/number, use it as-is - transformed["cost"] = cost_obj - - # Add input_tokens_details if present - if "input_tokens_details" in usage_data: - transformed["input_tokens_details"] = usage_data["input_tokens_details"] - - # Add output_tokens_details if present - if "output_tokens_details" in usage_data: - transformed["output_tokens_details"] = usage_data["output_tokens_details"] - - return transformed - - def transform_streaming_response( - self, - model: str, - parsed_chunk: dict, - logging_obj: LiteLLMLoggingObj, - ) -> ResponsesAPIStreamingResponse: - """ - Transform a parsed streaming response chunk into a ResponsesAPIStreamingResponse - """ - # Get the event type from the chunk - verbose_logger.debug("Raw Perplexity Chunk=%s", parsed_chunk) - event_type = str(parsed_chunk.get("type")) - event_pydantic_model = PerplexityResponsesConfig.get_event_model_class( - event_type=event_type - ) - - # Transform Perplexity-specific fields to OpenAI format - parsed_chunk = self._transform_perplexity_chunk(parsed_chunk) - - # Defensive: Handle error.code being null (similar to OpenAI implementation) - try: - error_obj = parsed_chunk.get("error") - if isinstance(error_obj, dict) and error_obj.get("code") is None: - # Preserve other fields, but ensure `code` is a non-null string - parsed_chunk = dict(parsed_chunk) - parsed_chunk["error"] = dict(error_obj) - parsed_chunk["error"]["code"] = "unknown_error" - except Exception: - # If anything unexpected happens here, fall back to attempting - # instantiation and let higher-level handlers manage errors. - verbose_logger.debug("Failed to coalesce error.code in parsed_chunk") - - return event_pydantic_model(**parsed_chunk) - - def _transform_perplexity_chunk(self, chunk: dict) -> dict: - """ - Transform Perplexity-specific fields in a streaming chunk to OpenAI format. - - This handles: - - Converting Perplexity's cost object to a simple float - """ - # Make a copy to avoid modifying the original - chunk = dict(chunk) - - # Transform usage.cost from Perplexity format to OpenAI format - # Perplexity: {"currency": "USD", "input_cost": 0.0001, "output_cost": 0.0002, "total_cost": 0.0003} - # OpenAI: 0.0003 (just the total_cost as a float) - try: - response_obj = chunk.get("response") - if isinstance(response_obj, dict): - usage_obj = response_obj.get("usage") - if isinstance(usage_obj, dict): - cost_obj = usage_obj.get("cost") - if isinstance(cost_obj, dict) and "total_cost" in cost_obj: - # Replace the cost object with just the total_cost value - chunk = dict(chunk) - chunk["response"] = dict(response_obj) - chunk["response"]["usage"] = dict(usage_obj) - chunk["response"]["usage"]["cost"] = cost_obj["total_cost"] - verbose_logger.debug( - "Transformed Perplexity cost object to float: %s -> %s", - cost_obj, - cost_obj["total_cost"], - ) - except Exception as e: - # If transformation fails, log and continue with original chunk - verbose_logger.debug("Failed to transform Perplexity cost object: %s", e) - - return chunk - def supports_native_websocket(self) -> bool: """Perplexity does not support native WebSocket for Responses API""" return False diff --git a/litellm/responses/main.py b/litellm/responses/main.py index 9c397aaaaeb7..789d3b20af3e 100644 --- a/litellm/responses/main.py +++ b/litellm/responses/main.py @@ -686,7 +686,7 @@ def responses( BaseResponsesAPIConfig ] = ProviderConfigManager.get_provider_responses_api_config( model=model, - provider=litellm.LlmProviders(custom_llm_provider), + provider=custom_llm_provider, ) local_vars.update(kwargs) @@ -902,7 +902,7 @@ def delete_responses( BaseResponsesAPIConfig ] = ProviderConfigManager.get_provider_responses_api_config( model=None, - provider=litellm.LlmProviders(custom_llm_provider), + provider=custom_llm_provider, ) if responses_api_provider_config is None: @@ -1082,7 +1082,7 @@ def get_responses( BaseResponsesAPIConfig ] = ProviderConfigManager.get_provider_responses_api_config( model=None, - provider=litellm.LlmProviders(custom_llm_provider), + provider=custom_llm_provider, ) if responses_api_provider_config is None: @@ -1239,7 +1239,7 @@ def list_input_items( BaseResponsesAPIConfig ] = ProviderConfigManager.get_provider_responses_api_config( model=None, - provider=litellm.LlmProviders(custom_llm_provider), + provider=custom_llm_provider, ) if responses_api_provider_config is None: @@ -1397,7 +1397,7 @@ def cancel_responses( BaseResponsesAPIConfig ] = ProviderConfigManager.get_provider_responses_api_config( model=None, - provider=litellm.LlmProviders(custom_llm_provider), + provider=custom_llm_provider, ) if responses_api_provider_config is None: @@ -1584,7 +1584,7 @@ def compact_responses( BaseResponsesAPIConfig ] = ProviderConfigManager.get_provider_responses_api_config( model=model, - provider=litellm.LlmProviders(custom_llm_provider), + provider=custom_llm_provider, ) if responses_api_provider_config is None: diff --git a/litellm/types/llms/openai.py b/litellm/types/llms/openai.py index c5d610e639b8..27b9545a7637 100644 --- a/litellm/types/llms/openai.py +++ b/litellm/types/llms/openai.py @@ -1199,6 +1199,14 @@ class ResponseAPIUsage(BaseLiteLLMOpenAIResponseObject): cost: Optional[float] = None """The cost of the request.""" + @field_validator("cost", mode="before") + @classmethod + def parse_cost(cls, v: Any) -> Optional[float]: + """Normalise cost: accept either a float or a dict with a ``total_cost`` key.""" + if isinstance(v, dict): + return v.get("total_cost") + return v + model_config = {"extra": "allow"} diff --git a/litellm/utils.py b/litellm/utils.py index fca5914dbaba..585e946fe6e7 100644 --- a/litellm/utils.py +++ b/litellm/utils.py @@ -8060,17 +8060,8 @@ def get_provider_chat_config( # noqa: PLR0915 Returns the provider config for a given provider. Uses O(1) dictionary lookup for fast provider resolution. + Python classes take priority over JSON (they have custom overrides). """ - # Check JSON providers FIRST (these override standard mappings) - from litellm.llms.openai_like.dynamic_config import create_config_class - from litellm.llms.openai_like.json_loader import JSONProviderRegistry - - if JSONProviderRegistry.exists(provider.value): - provider_config = JSONProviderRegistry.get(provider.value) - if provider_config is None: - raise ValueError(f"Provider {provider.value} not found") - return create_config_class(provider_config)() - # Handle OpenAI special cases (O-series and GPT-5 models) if provider == LlmProviders.OPENAI: if litellm.openaiOSeriesConfig.is_model_o_series_model(model=model): @@ -8084,18 +8075,24 @@ def get_provider_chat_config( # noqa: PLR0915 ProviderConfigManager._build_provider_config_map() ) - # O(1) dictionary lookup + # O(1) dictionary lookup — Python classes first (custom overrides take priority) config_entry = ProviderConfigManager._PROVIDER_CONFIG_MAP.get(provider) - if config_entry is None: - return None + if config_entry is not None: + config_factory, needs_model = config_entry + if needs_model: + return config_factory(model) # type: ignore + else: + return config_factory() # type: ignore - # Unpack factory function and whether it needs model parameter - # This avoids expensive inspect.signature() calls at runtime - config_factory, needs_model = config_entry - if needs_model: - return config_factory(model) # type: ignore - else: - return config_factory() # type: ignore + # Fall back to JSON providers (generic OpenAI-compatible) + from litellm.llms.openai_like.dynamic_config import create_config_class + from litellm.llms.openai_like.json_loader import JSONProviderRegistry + + if JSONProviderRegistry.exists(provider.value): + provider_config = JSONProviderRegistry.get(provider.value) + if provider_config is None: + raise ValueError(f"Provider {provider.value} not found") + return create_config_class(provider_config)() @staticmethod def get_provider_embedding_config( @@ -8294,9 +8291,52 @@ def get_provider_audio_transcription_config( @staticmethod def get_provider_responses_api_config( - provider: LlmProviders, + provider: Union[LlmProviders, str], model: Optional[str] = None, ) -> Optional[BaseResponsesAPIConfig]: + from litellm.llms.openai_like.dynamic_config import ( + create_responses_config_class, + ) + from litellm.llms.openai_like.json_loader import JSONProviderRegistry + + # Resolve provider string for JSON lookup + provider_str = provider.value if isinstance(provider, LlmProviders) else str(provider) + + # Try to convert to enum for Python class lookup first. + # Python classes take priority over JSON (they have custom overrides). + provider_enum: Optional[LlmProviders] = None + if isinstance(provider, LlmProviders): + provider_enum = provider + else: + try: + provider_enum = LlmProviders(provider) + except ValueError: + pass + + # Check Python classes first (custom overrides take priority) + result = ProviderConfigManager._get_python_responses_api_config( + provider_enum, model + ) + if result is not None: + return result + + # Fall back to JSON providers (generic OpenAI-compatible) + if JSONProviderRegistry.exists(provider_str) and JSONProviderRegistry.supports_responses_api(provider_str): + provider_config = JSONProviderRegistry.get(provider_str) + if provider_config is not None: + return create_responses_config_class(provider_config)() + + return None + + @staticmethod + def _get_python_responses_api_config( + provider: Optional[LlmProviders], + model: Optional[str] = None, + ) -> Optional[BaseResponsesAPIConfig]: + """Check for Python-class-based responses API configs (custom overrides).""" + if provider is None: + return None + if litellm.LlmProviders.OPENAI == provider: return litellm.OpenAIResponsesAPIConfig() elif litellm.LlmProviders.AZURE == provider: diff --git a/tests/test_litellm/llms/openai_like/responses/__init__.py b/tests/test_litellm/llms/openai_like/responses/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/tests/test_litellm/llms/openai_like/responses/test_openai_like_responses.py b/tests/test_litellm/llms/openai_like/responses/test_openai_like_responses.py new file mode 100644 index 000000000000..fdb1420f8735 --- /dev/null +++ b/tests/test_litellm/llms/openai_like/responses/test_openai_like_responses.py @@ -0,0 +1,341 @@ +""" +Tests for OpenAI-like Responses API support in the JSON provider system. +""" + +import os +import sys +from unittest.mock import patch + +import pytest + +sys.path.insert( + 0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../../../../..")) +) + + +class TestSimpleProviderConfigSupportedEndpoints: + """Test the supported_endpoints field on SimpleProviderConfig.""" + + def test_default_supported_endpoints(self): + """supported_endpoints defaults to [] (chat always enabled, nothing else)""" + from litellm.llms.openai_like.json_loader import SimpleProviderConfig + + config = SimpleProviderConfig("test", {"base_url": "https://example.com", "api_key_env": "TEST_KEY"}) + assert config.supported_endpoints == [] + + def test_custom_supported_endpoints(self): + """supported_endpoints can be set explicitly""" + from litellm.llms.openai_like.json_loader import SimpleProviderConfig + + config = SimpleProviderConfig( + "test", + { + "base_url": "https://example.com", + "api_key_env": "TEST_KEY", + "supported_endpoints": ["/v1/chat/completions", "/v1/responses"], + }, + ) + assert "/v1/responses" in config.supported_endpoints + assert "/v1/chat/completions" in config.supported_endpoints + + def test_responses_only_endpoint(self): + """A provider can support only responses""" + from litellm.llms.openai_like.json_loader import SimpleProviderConfig + + config = SimpleProviderConfig( + "test", + { + "base_url": "https://example.com", + "api_key_env": "TEST_KEY", + "supported_endpoints": ["/v1/responses"], + }, + ) + assert config.supported_endpoints == ["/v1/responses"] + + +class TestJSONProviderRegistryResponsesAPI: + """Test supports_responses_api on JSONProviderRegistry.""" + + def test_existing_provider_no_responses(self): + """Existing providers without supported_endpoints don't support responses""" + from litellm.llms.openai_like.json_loader import JSONProviderRegistry + + # publicai has no supported_endpoints in JSON, defaults to [] + assert JSONProviderRegistry.supports_responses_api("publicai") is False + + def test_nonexistent_provider(self): + """Non-existent provider returns False""" + from litellm.llms.openai_like.json_loader import JSONProviderRegistry + + assert JSONProviderRegistry.supports_responses_api("nonexistent_provider_xyz") is False + + def test_provider_with_responses_endpoint(self): + """A provider with /v1/responses in supported_endpoints returns True""" + from litellm.llms.openai_like.json_loader import ( + JSONProviderRegistry, + SimpleProviderConfig, + ) + + # Temporarily inject a test provider + test_config = SimpleProviderConfig( + "test_responses_provider", + { + "base_url": "https://test.example.com", + "api_key_env": "TEST_API_KEY", + "supported_endpoints": ["/v1/chat/completions", "/v1/responses"], + }, + ) + JSONProviderRegistry._providers["test_responses_provider"] = test_config + try: + assert JSONProviderRegistry.supports_responses_api("test_responses_provider") is True + finally: + del JSONProviderRegistry._providers["test_responses_provider"] + + +class TestCreateResponsesConfigClass: + """Test dynamic responses config class generation.""" + + def _make_test_provider(self): + from litellm.llms.openai_like.json_loader import SimpleProviderConfig + + return SimpleProviderConfig( + "test_resp", + { + "base_url": "https://api.testresp.com/v1", + "api_key_env": "TEST_RESP_API_KEY", + "api_base_env": "TEST_RESP_API_BASE", + "supported_endpoints": ["/v1/responses"], + }, + ) + + def test_generated_class_custom_llm_provider(self): + """Generated class returns the provider slug""" + from litellm.llms.openai_like.dynamic_config import ( + create_responses_config_class, + ) + + provider = self._make_test_provider() + config_cls = create_responses_config_class(provider) + config = config_cls() + assert config.custom_llm_provider == "test_resp" + + def test_generated_class_get_complete_url(self): + """Generated class builds correct responses URL""" + from litellm.llms.openai_like.dynamic_config import ( + create_responses_config_class, + ) + + provider = self._make_test_provider() + config_cls = create_responses_config_class(provider) + config = config_cls() + + url = config.get_complete_url(api_base=None, litellm_params={}) + assert url == "https://api.testresp.com/v1/responses" + + def test_generated_class_get_complete_url_with_override(self): + """api_base override takes precedence""" + from litellm.llms.openai_like.dynamic_config import ( + create_responses_config_class, + ) + + provider = self._make_test_provider() + config_cls = create_responses_config_class(provider) + config = config_cls() + + url = config.get_complete_url(api_base="https://custom.api.com/v1", litellm_params={}) + assert url == "https://custom.api.com/v1/responses" + + def test_generated_class_get_complete_url_strips_trailing_slash(self): + """Trailing slashes are stripped from base URL""" + from litellm.llms.openai_like.dynamic_config import ( + create_responses_config_class, + ) + + provider = self._make_test_provider() + config_cls = create_responses_config_class(provider) + config = config_cls() + + url = config.get_complete_url(api_base="https://custom.api.com/v1/", litellm_params={}) + assert url == "https://custom.api.com/v1/responses" + + def test_generated_class_validate_environment(self): + """validate_environment sets Authorization header from env""" + from litellm.llms.openai_like.dynamic_config import ( + create_responses_config_class, + ) + + provider = self._make_test_provider() + config_cls = create_responses_config_class(provider) + config = config_cls() + + with patch( + "litellm.llms.openai_like.dynamic_config.get_secret_str", + return_value="sk-test-key-123", + ): + headers = config.validate_environment(headers={}, model="test-model", litellm_params=None) + assert headers["Authorization"] == "Bearer sk-test-key-123" + + def test_generated_class_validate_environment_litellm_params_override(self): + """api_key from litellm_params takes precedence over env""" + from litellm.llms.openai_like.dynamic_config import ( + create_responses_config_class, + ) + from litellm.types.router import GenericLiteLLMParams + + provider = self._make_test_provider() + config_cls = create_responses_config_class(provider) + config = config_cls() + + litellm_params = GenericLiteLLMParams(api_key="sk-override-key") + headers = config.validate_environment( + headers={}, model="test-model", litellm_params=litellm_params + ) + assert headers["Authorization"] == "Bearer sk-override-key" + + def test_generated_class_inherits_openai_responses_methods(self): + """Generated class inherits OpenAI Responses API transformation methods""" + from litellm.llms.openai.responses.transformation import ( + OpenAIResponsesAPIConfig, + ) + from litellm.llms.openai_like.dynamic_config import ( + create_responses_config_class, + ) + + provider = self._make_test_provider() + config_cls = create_responses_config_class(provider) + config = config_cls() + + # Should have inherited methods from OpenAIResponsesAPIConfig + assert hasattr(config, "get_supported_openai_params") + assert hasattr(config, "map_openai_params") + assert hasattr(config, "transform_responses_api_request") + assert hasattr(config, "transform_response_api_response") + assert hasattr(config, "transform_streaming_response") + + # Verify inheritance chain + assert isinstance(config, OpenAIResponsesAPIConfig) + + def test_generated_class_get_complete_url_uses_api_base_env(self): + """get_complete_url falls back to api_base_env when api_base is None""" + from litellm.llms.openai_like.dynamic_config import ( + create_responses_config_class, + ) + + provider = self._make_test_provider() + config_cls = create_responses_config_class(provider) + config = config_cls() + + with patch( + "litellm.llms.openai_like.dynamic_config.get_secret_str", + return_value="https://env-override.example.com/v1", + ): + url = config.get_complete_url(api_base=None, litellm_params={}) + assert url == "https://env-override.example.com/v1/responses" + + +class TestProviderConfigManagerResponsesAPI: + """Test that ProviderConfigManager integrates JSON responses providers.""" + + def test_json_provider_with_responses_returns_config(self): + """A JSON provider with /v1/responses returns a responses config""" + from litellm.llms.openai_like.json_loader import ( + JSONProviderRegistry, + SimpleProviderConfig, + ) + from litellm.utils import ProviderConfigManager + + test_config = SimpleProviderConfig( + "test_pcm_resp", + { + "base_url": "https://api.testpcm.com/v1", + "api_key_env": "TEST_PCM_KEY", + "supported_endpoints": ["/v1/responses"], + }, + ) + JSONProviderRegistry._providers["test_pcm_resp"] = test_config + try: + config = ProviderConfigManager.get_provider_responses_api_config( + provider="test_pcm_resp", + model="some-model", + ) + assert config is not None + assert config.custom_llm_provider == "test_pcm_resp" + finally: + del JSONProviderRegistry._providers["test_pcm_resp"] + + def test_json_provider_without_responses_returns_none(self): + """A JSON provider without /v1/responses returns None""" + from litellm.utils import ProviderConfigManager + + # publicai only supports chat completions + config = ProviderConfigManager.get_provider_responses_api_config( + provider="publicai", + model="some-model", + ) + assert config is None + + def test_unknown_provider_returns_none(self): + """A completely unknown provider returns None""" + from litellm.utils import ProviderConfigManager + + config = ProviderConfigManager.get_provider_responses_api_config( + provider="totally_unknown_provider_xyz", + model="some-model", + ) + assert config is None + + def test_standard_providers_still_work(self): + """Existing enum-based providers still resolve correctly""" + from litellm.types.utils import LlmProviders + from litellm.utils import ProviderConfigManager + + config = ProviderConfigManager.get_provider_responses_api_config( + provider=LlmProviders.OPENAI, + model="gpt-4o", + ) + assert config is not None + + def test_standard_provider_as_string_still_works(self): + """Passing 'openai' as a string also works""" + from litellm.utils import ProviderConfigManager + + config = ProviderConfigManager.get_provider_responses_api_config( + provider="openai", + model="gpt-4o", + ) + assert config is not None + + def test_python_class_takes_priority_over_json(self): + """If a provider has both a Python class and JSON config, Python wins""" + from litellm.llms.openai_like.json_loader import ( + JSONProviderRegistry, + SimpleProviderConfig, + ) + from litellm.llms.perplexity.responses.transformation import ( + PerplexityResponsesConfig, + ) + from litellm.utils import ProviderConfigManager + + # Inject perplexity into JSON registry with responses support + test_config = SimpleProviderConfig( + "perplexity", + { + "base_url": "https://api.perplexity.ai", + "api_key_env": "PERPLEXITY_API_KEY", + "supported_endpoints": ["/v1/responses"], + }, + ) + original = JSONProviderRegistry._providers.get("perplexity") + JSONProviderRegistry._providers["perplexity"] = test_config + try: + config = ProviderConfigManager.get_provider_responses_api_config( + provider="perplexity", + model="some-model", + ) + # Should be the Python class, not the JSON-generated one + assert isinstance(config, PerplexityResponsesConfig) + finally: + if original is not None: + JSONProviderRegistry._providers["perplexity"] = original + else: + del JSONProviderRegistry._providers["perplexity"] diff --git a/tests/test_litellm/llms/perplexity/responses/test_perplexity_responses_transformation.py b/tests/test_litellm/llms/perplexity/responses/test_perplexity_responses_transformation.py index cdd4ef913f97..a3ec81c569cd 100644 --- a/tests/test_litellm/llms/perplexity/responses/test_perplexity_responses_transformation.py +++ b/tests/test_litellm/llms/perplexity/responses/test_perplexity_responses_transformation.py @@ -7,11 +7,17 @@ Source: litellm/llms/perplexity/responses/transformation.py """ +import json import os import sys +import httpx +import pytest + sys.path.insert(0, os.path.abspath("../../../../..")) +from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj +from litellm.llms.base_llm.chat.transformation import BaseLLMException from litellm.llms.perplexity.responses.transformation import PerplexityResponsesConfig from litellm.types.llms.openai import ResponsesAPIOptionalRequestParams from litellm.types.utils import LlmProviders @@ -260,10 +266,12 @@ def test_metadata_safety_identifier_user(self): assert result.get("user") == "user_456" def test_all_supported_params_declared(self): - """get_supported_openai_params returns complete list""" + """get_supported_openai_params returns Perplexity-specific restricted list""" config = PerplexityResponsesConfig() supported = config.get_supported_openai_params("perplexity/openai/gpt-5.2") + # Perplexity Responses API supports a restricted set of params + # Ref: https://docs.perplexity.ai/api-reference/responses-post expected = [ "max_output_tokens", "stream", @@ -271,68 +279,46 @@ def test_all_supported_params_declared(self): "top_p", "tools", "reasoning", - "preset", "instructions", "models", - "tool_choice", - "parallel_tool_calls", - "max_tool_calls", - "text", - "previous_response_id", - "store", - "background", - "truncation", - "metadata", - "safety_identifier", - "user", - "stream_options", - "top_logprobs", - "prompt_cache_key", - "frequency_penalty", - "presence_penalty", - "service_tier", ] for param in expected: assert param in supported, f"Missing supported param: {param}" - def test_cost_transformation(self): - """Perplexity cost dict to OpenAI float""" - config = PerplexityResponsesConfig() + def test_cost_dict_to_float_via_validator(self): + """Perplexity cost dict is parsed by generic ResponseAPIUsage.parse_cost validator""" + from litellm.types.llms.openai import ResponseAPIUsage - usage_data = { - "input_tokens": 100, - "output_tokens": 200, - "total_tokens": 300, - "cost": { + usage = ResponseAPIUsage( + input_tokens=100, + output_tokens=200, + total_tokens=300, + cost={ "currency": "USD", "input_cost": 0.0001, "output_cost": 0.0002, "total_cost": 0.0003, }, - } - - result = config._transform_usage(usage_data) - - assert result["input_tokens"] == 100 - assert result["output_tokens"] == 200 - assert result["total_tokens"] == 300 - assert result["cost"] == 0.0003 + ) - def test_cost_transformation_float_passthrough(self): - """Cost already float passes through""" - config = PerplexityResponsesConfig() + assert usage.input_tokens == 100 + assert usage.output_tokens == 200 + assert usage.total_tokens == 300 + assert usage.cost == 0.0003 - usage_data = { - "input_tokens": 100, - "output_tokens": 200, - "total_tokens": 300, - "cost": 0.0005, - } + def test_cost_float_passthrough_via_validator(self): + """Cost already float passes through validator unchanged""" + from litellm.types.llms.openai import ResponseAPIUsage - result = config._transform_usage(usage_data) + usage = ResponseAPIUsage( + input_tokens=100, + output_tokens=200, + total_tokens=300, + cost=0.0005, + ) - assert result["cost"] == 0.0005 + assert usage.cost == 0.0005 def test_preset_handling(self): """Preset model names work""" @@ -350,6 +336,85 @@ def test_preset_handling(self): assert data["input"] == "What is AI?" assert "temperature" in data + def test_preset_handling_list_input(self): + """Preset with list input preserves type field""" + config = PerplexityResponsesConfig() + + list_input = [ + {"type": "message", "role": "user", "content": "What is AI?"}, + ] + + data = config.transform_responses_api_request( + model="preset/pro-search", + input=list_input, + response_api_optional_request_params={"temperature": 0.7}, + litellm_params={}, + headers={}, + ) + + assert data["preset"] == "pro-search" + assert isinstance(data["input"], list) + assert data["input"][0]["type"] == "message" + assert data["input"][0]["role"] == "user" + + def test_non_preset_list_input(self): + """Non-preset with list input preserves type field""" + config = PerplexityResponsesConfig() + + list_input = [ + {"type": "message", "role": "user", "content": "Hello"}, + ] + + data = config.transform_responses_api_request( + model="openai/gpt-5.2", + input=list_input, + response_api_optional_request_params={}, + litellm_params={}, + headers={}, + ) + + assert data["model"] == "openai/gpt-5.2" + assert isinstance(data["input"], list) + assert data["input"][0]["type"] == "message" + + def test_list_input_adds_type_message_when_missing(self): + """Input items without type get type='message' added automatically""" + config = PerplexityResponsesConfig() + + list_input = [ + {"role": "user", "content": "Hello"}, + ] + + data = config.transform_responses_api_request( + model="openai/gpt-5.2", + input=list_input, + response_api_optional_request_params={}, + litellm_params={}, + headers={}, + ) + + assert data["input"][0]["type"] == "message" + assert data["input"][0]["role"] == "user" + assert data["input"][0]["content"] == "Hello" + + def test_list_input_preserves_existing_type(self): + """Input items that already have type are not modified""" + config = PerplexityResponsesConfig() + + list_input = [ + {"type": "function_call_output", "call_id": "123", "output": "{}"}, + ] + + data = config.transform_responses_api_request( + model="openai/gpt-5.2", + input=list_input, + response_api_optional_request_params={}, + litellm_params={}, + headers={}, + ) + + assert data["input"][0]["type"] == "function_call_output" + def test_get_complete_url(self): """Correct endpoint URL""" config = PerplexityResponsesConfig() @@ -379,3 +444,149 @@ def test_perplexity_provider_config_registration(self): assert config is not None assert isinstance(config, PerplexityResponsesConfig) assert config.custom_llm_provider == LlmProviders.PERPLEXITY + + def test_failed_status_raises_exception(self): + """Perplexity HTTP 200 with status:'failed' must raise BaseLLMException""" + config = PerplexityResponsesConfig() + + failed_body = { + "status": "failed", + "error": {"message": "Model quota exceeded"}, + } + + raw_response = httpx.Response( + status_code=200, + json=failed_body, + request=httpx.Request("POST", "https://api.perplexity.ai/v1/responses"), + ) + + logging_obj = LiteLLMLoggingObj( + model="perplexity/openai/gpt-5.2", + messages=[], + stream=False, + call_type="responses", + start_time=None, + litellm_call_id="test", + function_id="test", + ) + + with pytest.raises(BaseLLMException) as exc_info: + config.transform_response_api_response( + model="perplexity/openai/gpt-5.2", + raw_response=raw_response, + logging_obj=logging_obj, + ) + + assert "Model quota exceeded" in str(exc_info.value.message) + + def test_successful_response_passes_through(self): + """Normal completed response delegates to base OpenAI handler""" + config = PerplexityResponsesConfig() + + success_body = { + "id": "resp_123", + "object": "response", + "created_at": 1700000000, + "status": "completed", + "model": "openai/gpt-5.2", + "output": [ + { + "type": "message", + "id": "msg_123", + "role": "assistant", + "status": "completed", + "content": [ + {"type": "output_text", "text": "Hello!", "annotations": []} + ], + } + ], + "usage": { + "input_tokens": 10, + "output_tokens": 5, + "total_tokens": 15, + }, + } + + raw_response = httpx.Response( + status_code=200, + json=success_body, + request=httpx.Request("POST", "https://api.perplexity.ai/v1/responses"), + ) + + logging_obj = LiteLLMLoggingObj( + model="perplexity/openai/gpt-5.2", + messages=[], + stream=False, + call_type="responses", + start_time=None, + litellm_call_id="test", + function_id="test", + ) + + response = config.transform_response_api_response( + model="perplexity/openai/gpt-5.2", + raw_response=raw_response, + logging_obj=logging_obj, + ) + + assert response.id == "resp_123" + assert response.status == "completed" + + def test_streaming_cost_dict_to_float_via_validator(self): + """Cost dict in a streaming response.completed chunk is converted to float + end-to-end through transform_streaming_response via pydantic's recursive + construction of ResponsesAPIResponse → ResponseAPIUsage.parse_cost.""" + config = PerplexityResponsesConfig() + + completed_chunk = { + "type": "response.completed", + "response": { + "id": "resp_streaming_123", + "object": "response", + "created_at": 1700000000, + "status": "completed", + "model": "openai/gpt-5.2", + "output": [ + { + "type": "message", + "id": "msg_123", + "role": "assistant", + "status": "completed", + "content": [ + {"type": "output_text", "text": "Hello!", "annotations": []} + ], + } + ], + "usage": { + "input_tokens": 100, + "output_tokens": 200, + "total_tokens": 300, + "cost": { + "currency": "USD", + "input_cost": 0.0001, + "output_cost": 0.0002, + "total_cost": 0.0003, + }, + }, + }, + } + + logging_obj = LiteLLMLoggingObj( + model="perplexity/openai/gpt-5.2", + messages=[], + stream=True, + call_type="responses", + start_time=None, + litellm_call_id="test", + function_id="test", + ) + + result = config.transform_streaming_response( + model="perplexity/openai/gpt-5.2", + parsed_chunk=completed_chunk, + logging_obj=logging_obj, + ) + + assert result.type == "response.completed" + assert result.response.usage.cost == 0.0003 + assert isinstance(result.response.usage.cost, float)