diff --git a/.github/workflows/test-unit.yml b/.github/workflows/test-unit.yml index b4b7afb9a09..9fbdbdf9e2e 100644 --- a/.github/workflows/test-unit.yml +++ b/.github/workflows/test-unit.yml @@ -276,6 +276,7 @@ jobs: tests/unit/llms/google_pse tests/unit/llms/github_copilot tests/unit/llms/gradient_ai + tests/unit/llms/greenpt tests/unit/llms/groq tests/unit/llms/heroku tests/unit/llms/hosted_vllm diff --git a/litellm/llms/greenpt/__init__.py b/litellm/llms/greenpt/__init__.py new file mode 100644 index 00000000000..8b137891791 --- /dev/null +++ b/litellm/llms/greenpt/__init__.py @@ -0,0 +1 @@ + diff --git a/litellm/llms/greenpt/rerank/__init__.py b/litellm/llms/greenpt/rerank/__init__.py new file mode 100644 index 00000000000..8b137891791 --- /dev/null +++ b/litellm/llms/greenpt/rerank/__init__.py @@ -0,0 +1 @@ + diff --git a/litellm/llms/greenpt/rerank/transformation.py b/litellm/llms/greenpt/rerank/transformation.py new file mode 100644 index 00000000000..01b97bb300c --- /dev/null +++ b/litellm/llms/greenpt/rerank/transformation.py @@ -0,0 +1,64 @@ +from collections.abc import Mapping, Sized +from typing import Final + +from litellm.llms.hosted_vllm.rerank.transformation import HostedVLLMRerankConfig +from litellm.secret_managers.main import get_secret_str +from litellm.types.rerank import RerankBilledUnits +from litellm.types.utils import ModelInfo + + +class GreenPTRerankConfig(HostedVLLMRerankConfig): + def get_supported_cohere_rerank_params(self, model: str) -> list[str]: # mutable-ok: mirrors override contract + return ["query", "documents", "top_n", "return_documents"] + + def validate_environment( + self, + headers: dict[str, str], # mutable-ok: mirrors override contract + model: str, + api_key: str | None = None, + optional_params: dict[str, object] | None = None, # mutable-ok: mirrors override contract + litellm_params: Mapping[str, object] | None = None, + ) -> dict[str, str]: # mutable-ok: mirrors override contract + resolved_api_key: Final = api_key or get_secret_str("GREENPT_API_KEY") + if resolved_api_key is None: + raise ValueError("GreenPT API key is required. Set GREENPT_API_KEY.") + return { + "Authorization": f"Bearer {resolved_api_key}", + "accept": "application/json", + "content-type": "application/json", + **headers, + } + + def transform_rerank_request( + self, + model: str, + optional_rerank_params: dict[str, object], # mutable-ok: mirrors override contract + headers: dict[str, str], # mutable-ok: mirrors override contract + litellm_params: dict[str, object] | None = None, # mutable-ok: mirrors override contract + ) -> dict[str, object]: # mutable-ok: mirrors override contract + request: Final[Mapping[str, object]] = super().transform_rerank_request( # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType] # HostedVLLMRerankConfig returns an untyped dict + model=model, + optional_rerank_params=optional_rerank_params, + headers=headers, + litellm_params=litellm_params, + ) + documents: Final = optional_rerank_params["documents"] + top_n_default: Final = len(documents) if isinstance(documents, Sized) else None + return {"top_n": top_n_default, **request} if top_n_default is not None else {**request} + + def calculate_rerank_cost( + self, + model: str, + custom_llm_provider: str | None = None, + billed_units: RerankBilledUnits | None = None, + model_info: ModelInfo | None = None, + ) -> tuple[float, float]: + if model_info is None or billed_units is None: + return 0.0, 0.0 + input_cost_per_token: Final = model_info.get("input_cost_per_token") + if input_cost_per_token is None: + return 0.0, 0.0 + total_tokens: Final = billed_units.get("total_tokens") + if total_tokens is None: + return 0.0, 0.0 + return input_cost_per_token * total_tokens, 0.0 diff --git a/litellm/llms/openai_like/json_loader.py b/litellm/llms/openai_like/json_loader.py index 23b63177137..794d56fdb5f 100644 --- a/litellm/llms/openai_like/json_loader.py +++ b/litellm/llms/openai_like/json_loader.py @@ -79,12 +79,20 @@ class JSONProviderRegistry: return next((provider for provider in cls._providers.values() if provider.base_url == base_url), None) @classmethod - def supports_responses_api(cls, slug: str) -> bool: - """Check if a JSON provider supports the Responses API""" + def _supports_endpoint(cls, slug: str, endpoint: str) -> bool: provider: Final = cls._providers.get(slug) if provider is None: return False - return "/v1/responses" in provider.supported_endpoints + return endpoint in provider.supported_endpoints + + @classmethod + def supports_responses_api(cls, slug: str) -> bool: + """Check if a JSON provider supports the Responses API""" + return cls._supports_endpoint(slug, "/v1/responses") + + @classmethod + def supports_embeddings_api(cls, slug: str) -> bool: + return cls._supports_endpoint(slug, "/v1/embeddings") @classmethod def list_providers(cls) -> list: diff --git a/litellm/llms/openai_like/providers.json b/litellm/llms/openai_like/providers.json index 115d914d3ac..470d0295b31 100644 --- a/litellm/llms/openai_like/providers.json +++ b/litellm/llms/openai_like/providers.json @@ -168,6 +168,15 @@ }, "supported_endpoints": ["/v1/chat/completions", "/v1/responses"] }, + "greenpt": { + "base_url": "https://api.greenpt.ai/v1", + "api_key_env": "GREENPT_API_KEY", + "api_base_env": "GREENPT_API_BASE", + "param_mappings": { + "max_completion_tokens": "max_tokens" + }, + "supported_endpoints": ["/v1/chat/completions", "/v1/embeddings"] + }, "meta": { "base_url": "https://api.meta.ai/v1", "api_key_env": "META_API_KEY", diff --git a/litellm/main.py b/litellm/main.py index 9f412e1f24b..54e81886893 100644 --- a/litellm/main.py +++ b/litellm/main.py @@ -6961,6 +6961,7 @@ def embedding( custom_llm_provider == "openai_like" or custom_llm_provider == "llamafile" or custom_llm_provider == "lm_studio" + or JSONProviderRegistry.supports_embeddings_api(custom_llm_provider) ): api_base = api_base or litellm.api_base or get_secret_str("OPENAI_LIKE_API_BASE") diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json index 5774e699ad7..c670e19cfb7 100644 --- a/litellm/model_prices_and_context_window_backup.json +++ b/litellm/model_prices_and_context_window_backup.json @@ -61437,6 +61437,148 @@ ], "supports_audio_output": true }, + "greenpt/glm-5.2": { + "input_cost_per_token": 1.501764e-06, + "litellm_provider": "greenpt", + "max_input_tokens": 1000000, + "max_output_tokens": 131072, + "max_tokens": 131072, + "mode": "chat", + "output_cost_per_token": 5.256174e-06, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "greenpt/green-embedding": { + "input_cost_per_token": 2.2754e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 32768, + "max_output_tokens": 2560, + "max_tokens": 2560, + "mode": "embedding", + "output_cost_per_token": 0, + "source": "https://docs.greenpt.ai/pricing" + }, + "greenpt/green-rerank": { + "input_cost_per_token": 1.36524e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 32768, + "max_tokens": 32768, + "mode": "rerank", + "source": "https://docs.greenpt.ai/pricing" + }, + "greenpt/green-l": { + "input_cost_per_token": 2.84425e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 128000, + "max_output_tokens": 32000, + "max_tokens": 32000, + "mode": "chat", + "output_cost_per_token": 9.1016e-07, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_tool_choice": true, + "supports_vision": true + }, + "greenpt/green-l-raw": { + "input_cost_per_token": 2.84425e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 128000, + "max_output_tokens": 32000, + "max_tokens": 32000, + "mode": "chat", + "output_cost_per_token": 9.1016e-07, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_tool_choice": true, + "supports_vision": true + }, + "greenpt/green-r": { + "input_cost_per_token": 3.98195e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 131072, + "max_output_tokens": 32768, + "max_tokens": 32768, + "mode": "chat", + "output_cost_per_token": 1.080815e-06, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true, + "supports_vision": true + }, + "greenpt/green-r-raw": { + "input_cost_per_token": 3.98195e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 131072, + "max_output_tokens": 32768, + "max_tokens": 32768, + "mode": "chat", + "output_cost_per_token": 1.080815e-06, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true, + "supports_vision": true + }, + "greenpt/kimi-k2.6": { + "input_cost_per_token": 8.30521e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 262144, + "max_output_tokens": 262144, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 4.380145e-06, + "source": "https://docs.greenpt.ai/pricing", + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true, + "supports_vision": true + }, + "greenpt/kimi-k2.7-code": { + "input_cost_per_token": 9.44291e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 262144, + "max_output_tokens": 262144, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 4.380145e-06, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "greenpt/minimax-m2.5": { + "input_cost_per_token": 1.93409e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 200000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "chat", + "output_cost_per_token": 1.126323e-06, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "greenpt/qwen3-embedding-8b": { + "input_cost_per_token": 2.84425e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 32768, + "max_output_tokens": 4096, + "max_tokens": 4096, + "mode": "embedding", + "output_cost_per_token": 0, + "source": "https://docs.greenpt.ai/pricing" + }, "fallback_generalizations": { "rules": [ { diff --git a/litellm/rerank_api/main.py b/litellm/rerank_api/main.py index 65d9b89cf79..b374d67d674 100644 --- a/litellm/rerank_api/main.py +++ b/litellm/rerank_api/main.py @@ -33,7 +33,7 @@ async def arerank( query: str, documents: list[str | dict[str, object]], custom_llm_provider: ( - Literal["cohere", "together_ai", "deepinfra", "fireworks_ai", "voyage", "watsonx"] | None + Literal["cohere", "together_ai", "deepinfra", "fireworks_ai", "voyage", "watsonx", "greenpt"] | None ) = None, top_n: int | None = None, rank_fields: list[str] | None = None, @@ -106,6 +106,7 @@ def rerank( "fireworks_ai", "voyage", "watsonx", + "greenpt", ] | None ) = None, diff --git a/litellm/types/utils.py b/litellm/types/utils.py index 2869f9b2577..c445f3e2d3c 100644 --- a/litellm/types/utils.py +++ b/litellm/types/utils.py @@ -4532,6 +4532,7 @@ class LlmProviders(str, Enum): TOPAZ = "topaz" SAP_GENERATIVE_AI_HUB = "sap" ASSEMBLYAI = "assemblyai" + GREENPT = "greenpt" AZURE_SPEECH = "azure_speech" CHARITY_ENGINE = "charity_engine" GITHUB_COPILOT = "github_copilot" diff --git a/litellm/utils.py b/litellm/utils.py index 1e095966a43..f649cd2e5aa 100644 --- a/litellm/utils.py +++ b/litellm/utils.py @@ -9583,7 +9583,12 @@ class ProviderConfigManager: ) return get_dashscope_family_rerank_config(provider.value) - return litellm.CohereRerankConfig() + from litellm.llms.greenpt.rerank.transformation import GreenPTRerankConfig + + config_class: Final = { + litellm.LlmProviders.GREENPT: GreenPTRerankConfig, + }.get(provider, litellm.CohereRerankConfig) + return config_class() @staticmethod @lru_cache(maxsize=1) diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json index 5774e699ad7..c670e19cfb7 100644 --- a/model_prices_and_context_window.json +++ b/model_prices_and_context_window.json @@ -61437,6 +61437,148 @@ ], "supports_audio_output": true }, + "greenpt/glm-5.2": { + "input_cost_per_token": 1.501764e-06, + "litellm_provider": "greenpt", + "max_input_tokens": 1000000, + "max_output_tokens": 131072, + "max_tokens": 131072, + "mode": "chat", + "output_cost_per_token": 5.256174e-06, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "greenpt/green-embedding": { + "input_cost_per_token": 2.2754e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 32768, + "max_output_tokens": 2560, + "max_tokens": 2560, + "mode": "embedding", + "output_cost_per_token": 0, + "source": "https://docs.greenpt.ai/pricing" + }, + "greenpt/green-rerank": { + "input_cost_per_token": 1.36524e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 32768, + "max_tokens": 32768, + "mode": "rerank", + "source": "https://docs.greenpt.ai/pricing" + }, + "greenpt/green-l": { + "input_cost_per_token": 2.84425e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 128000, + "max_output_tokens": 32000, + "max_tokens": 32000, + "mode": "chat", + "output_cost_per_token": 9.1016e-07, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_tool_choice": true, + "supports_vision": true + }, + "greenpt/green-l-raw": { + "input_cost_per_token": 2.84425e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 128000, + "max_output_tokens": 32000, + "max_tokens": 32000, + "mode": "chat", + "output_cost_per_token": 9.1016e-07, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_tool_choice": true, + "supports_vision": true + }, + "greenpt/green-r": { + "input_cost_per_token": 3.98195e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 131072, + "max_output_tokens": 32768, + "max_tokens": 32768, + "mode": "chat", + "output_cost_per_token": 1.080815e-06, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true, + "supports_vision": true + }, + "greenpt/green-r-raw": { + "input_cost_per_token": 3.98195e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 131072, + "max_output_tokens": 32768, + "max_tokens": 32768, + "mode": "chat", + "output_cost_per_token": 1.080815e-06, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true, + "supports_vision": true + }, + "greenpt/kimi-k2.6": { + "input_cost_per_token": 8.30521e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 262144, + "max_output_tokens": 262144, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 4.380145e-06, + "source": "https://docs.greenpt.ai/pricing", + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true, + "supports_vision": true + }, + "greenpt/kimi-k2.7-code": { + "input_cost_per_token": 9.44291e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 262144, + "max_output_tokens": 262144, + "max_tokens": 262144, + "mode": "chat", + "output_cost_per_token": 4.380145e-06, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "greenpt/minimax-m2.5": { + "input_cost_per_token": 1.93409e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 200000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "chat", + "output_cost_per_token": 1.126323e-06, + "source": "https://docs.greenpt.ai/pricing", + "supports_function_calling": true, + "supports_reasoning": true, + "supports_tool_choice": true + }, + "greenpt/qwen3-embedding-8b": { + "input_cost_per_token": 2.84425e-07, + "litellm_provider": "greenpt", + "max_input_tokens": 32768, + "max_output_tokens": 4096, + "max_tokens": 4096, + "mode": "embedding", + "output_cost_per_token": 0, + "source": "https://docs.greenpt.ai/pricing" + }, "fallback_generalizations": { "rules": [ { diff --git a/provider_endpoints_support.json b/provider_endpoints_support.json index 9ba6ed342ea..aaadd20d575 100644 --- a/provider_endpoints_support.json +++ b/provider_endpoints_support.json @@ -5248,6 +5248,24 @@ "a2a": false, "generateContent": false } + }, + "greenpt": { + "display_name": "GreenPT (`greenpt`)", + "url": "https://docs.greenpt.ai", + "endpoints": { + "chat_completions": true, + "messages": false, + "responses": false, + "embeddings": true, + "image_generations": false, + "audio_transcriptions": false, + "audio_speech": false, + "moderations": false, + "batches": false, + "rerank": true, + "a2a": false, + "interactions": false + } } }, "endpoints": { diff --git a/tests/unit/llms/greenpt/__init__.py b/tests/unit/llms/greenpt/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/unit/llms/greenpt/rerank/__init__.py b/tests/unit/llms/greenpt/rerank/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/unit/llms/greenpt/rerank/test_greenpt_rerank_transformation.py b/tests/unit/llms/greenpt/rerank/test_greenpt_rerank_transformation.py new file mode 100644 index 00000000000..4ab67945198 --- /dev/null +++ b/tests/unit/llms/greenpt/rerank/test_greenpt_rerank_transformation.py @@ -0,0 +1,133 @@ +import json +from unittest.mock import Mock, patch + +import pytest + +import litellm +from litellm.cost_calculator import rerank_cost +from litellm.llms.custom_httpx.http_handler import HTTPHandler +from litellm.llms.greenpt.rerank.transformation import GreenPTRerankConfig + + +def test_greenpt_supported_params(): + assert GreenPTRerankConfig().get_supported_cohere_rerank_params("green-rerank") == [ + "query", + "documents", + "top_n", + "return_documents", + ] + + +def test_validate_environment_with_api_key(): + headers = GreenPTRerankConfig().validate_environment( + headers={}, + model="green-rerank", + api_key="test-key", + ) + assert headers == { + "Authorization": "Bearer test-key", + "accept": "application/json", + "content-type": "application/json", + } + + +def test_validate_environment_requires_api_key(monkeypatch): + monkeypatch.delenv("GREENPT_API_KEY", raising=False) + with pytest.raises(ValueError, match="GreenPT API key is required"): + GreenPTRerankConfig().validate_environment( + headers={}, + model="green-rerank", + ) + + +def test_transform_rerank_request_defaults_top_n(): + request = GreenPTRerankConfig().transform_rerank_request( + model="green-rerank", + optional_rerank_params={ + "query": "low-carbon inference", + "documents": ["GreenPT", "Other provider"], + "return_documents": False, + }, + headers={}, + ) + assert request == { + "model": "green-rerank", + "query": "low-carbon inference", + "documents": ["GreenPT", "Other provider"], + "top_n": 2, + "return_documents": False, + } + + +def test_transform_rerank_request_preserves_top_n(): + request = GreenPTRerankConfig().transform_rerank_request( + model="green-rerank", + optional_rerank_params={ + "query": "low-carbon inference", + "documents": ["GreenPT", "Other provider"], + "top_n": 1, + }, + headers={}, + ) + assert request["top_n"] == 1 + + +def test_calculate_rerank_cost(): + prompt_cost, completion_cost = GreenPTRerankConfig().calculate_rerank_cost( + model="green-rerank", + billed_units={"total_tokens": 1000}, + model_info={"input_cost_per_token": 1.36524e-07}, + ) + assert prompt_cost == pytest.approx(0.000136524) + assert completion_cost == 0.0 + + +def test_public_rerank_cost_uses_token_pricing(): + prompt_cost, completion_cost = rerank_cost( + model="greenpt/green-rerank", + custom_llm_provider=None, + billed_units={"total_tokens": 1000}, + ) + assert prompt_cost == pytest.approx(0.000136524) + assert completion_cost == 0.0 + + +@pytest.mark.parametrize( + ("billed_units", "model_info"), + [ + (None, None), + ({}, {"input_cost_per_token": 1.36524e-07}), + ({"total_tokens": 1000}, {}), + ], +) +def test_calculate_rerank_cost_missing_usage_or_pricing(billed_units, model_info): + assert GreenPTRerankConfig().calculate_rerank_cost( + model="green-rerank", + billed_units=billed_units, + model_info=model_info, + ) == (0.0, 0.0) + + +def test_public_rerank_call_sends_request_and_costs_tokens(): + response = Mock() + response.raise_for_status = Mock() + response.json.return_value = { + "id": "rerank-1", + "results": [{"index": 0, "relevance_score": 0.9}], + "usage": {"total_tokens": 1000}, + } + + with patch.object(HTTPHandler, "post", return_value=response) as mock_post: + result = litellm.rerank( + model="greenpt/green-rerank", + query="low-carbon inference", + documents=["GreenPT", "Other provider"], + api_key="test-key", + client=HTTPHandler(), + ) + + assert mock_post.call_args.kwargs["url"] == "https://api.greenpt.ai/v1/rerank" + assert mock_post.call_args.kwargs["headers"]["Authorization"] == "Bearer test-key" + assert json.loads(mock_post.call_args.kwargs["data"])["top_n"] == 2 + assert result.results[0]["index"] == 0 + assert result._hidden_params["response_cost"] == pytest.approx(0.000136524) diff --git a/tests/unit/llms/openai_like/test_greenpt_provider.py b/tests/unit/llms/openai_like/test_greenpt_provider.py new file mode 100644 index 00000000000..dd8595c98f1 --- /dev/null +++ b/tests/unit/llms/openai_like/test_greenpt_provider.py @@ -0,0 +1,110 @@ +import json +from unittest.mock import Mock, patch + +import litellm +from litellm.llms.custom_httpx.http_handler import HTTPHandler +from litellm.llms.openai_like.dynamic_config import create_config_class +from litellm.llms.openai_like.json_loader import JSONProviderRegistry +from litellm.types.utils import LlmProviders +from litellm.utils import ProviderConfigManager + +GREENPT_BASE_URL = "https://api.greenpt.ai/v1" + + +def _get_config(): + provider = JSONProviderRegistry.get("greenpt") + assert provider is not None + config_class = create_config_class(provider) + return config_class() + + +def test_greenpt_provider_registered(): + provider = JSONProviderRegistry.get("greenpt") + assert provider is not None + assert provider.base_url == GREENPT_BASE_URL + assert provider.api_key_env == "GREENPT_API_KEY" + assert provider.api_base_env == "GREENPT_API_BASE" + + +def test_greenpt_resolves_env_api_key(monkeypatch): + config = _get_config() + monkeypatch.setenv("GREENPT_API_KEY", "test-key") + api_base, api_key = config._get_openai_compatible_provider_info(None, None) + assert api_base == GREENPT_BASE_URL + assert api_key == "test-key" + + +def test_greenpt_maps_max_completion_tokens(): + config = _get_config() + params = config.map_openai_params( + non_default_params={"max_completion_tokens": 256}, + optional_params={}, + model="greenpt/glm-5.2", + drop_params=False, + ) + assert params == {"max_tokens": 256} + + +def test_greenpt_complete_url_appends_endpoint(): + config = _get_config() + url = config.get_complete_url( + api_base=GREENPT_BASE_URL, + api_key="test-key", + model="greenpt/glm-5.2", + optional_params={}, + litellm_params={}, + stream=False, + ) + assert url == f"{GREENPT_BASE_URL}/chat/completions" + + +def test_greenpt_provider_resolution(): + from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider + + model, provider, _, api_base = get_llm_provider( + model="greenpt/glm-5.2", + custom_llm_provider=None, + api_base=None, + api_key=None, + ) + + assert model == "glm-5.2" + assert provider == "greenpt" + assert api_base == GREENPT_BASE_URL + + +def test_greenpt_embedding_dispatches(): + response = Mock() + response.raise_for_status = Mock() + response.json.return_value = { + "object": "list", + "data": [{"object": "embedding", "embedding": [0.1, 0.2], "index": 0}], + "model": "green-embedding", + "usage": {"prompt_tokens": 2, "total_tokens": 2}, + } + client = HTTPHandler() + + with patch.object(HTTPHandler, "post", return_value=response) as mock_post: + result = litellm.embedding( + model="greenpt/green-embedding", + input=["renewable inference"], + api_key="test-key", + client=client, + ) + + assert result.data[0]["embedding"] == [0.1, 0.2] + assert mock_post.call_args.args[0] == f"{GREENPT_BASE_URL}/embeddings" + assert json.loads(mock_post.call_args.kwargs["data"]) == { + "model": "green-embedding", + "input": ["renewable inference"], + } + + +def test_greenpt_rerank_config(): + config = ProviderConfigManager.get_provider_rerank_config( + model="green-rerank", + provider=LlmProviders.GREENPT, + api_base=GREENPT_BASE_URL, + present_version_params=[], + ) + assert config.get_complete_url(GREENPT_BASE_URL, "green-rerank") == (f"{GREENPT_BASE_URL}/rerank")