From 1557e2d4ceb72b7b53fad1efa0e4e35240755fa9 Mon Sep 17 00:00:00 2001 From: Ido Lavi Date: Wed, 19 Nov 2025 16:59:38 +0200 Subject: [PATCH 01/13] Use auth key name if there are no app id in in headers or in extra_data --- litellm/proxy/guardrails/guardrail_hooks/noma/noma.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py b/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py index c2e00b0c7c5f..24ef66c4bee4 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py +++ b/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py @@ -799,7 +799,7 @@ async def _call_noma_api( or request_data.get("metadata", {}) .get("headers", {}) .get("x-noma-application-id") - or self.application_id, + or (user_auth.key_name if user_auth.key_name else self.application_id), "ipAddress": request_data.get("metadata", {}).get( "requester_ip_address", None ), From 0fa67ac1a2364cda9c1df23da4a169844d9da1fc Mon Sep 17 00:00:00 2001 From: Ido Lavi Date: Wed, 19 Nov 2025 17:49:21 +0200 Subject: [PATCH 02/13] use key alias instead of key name --- litellm/proxy/guardrails/guardrail_hooks/noma/noma.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py b/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py index 24ef66c4bee4..b108e1c9798d 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py +++ b/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py @@ -799,7 +799,7 @@ async def _call_noma_api( or request_data.get("metadata", {}) .get("headers", {}) .get("x-noma-application-id") - or (user_auth.key_name if user_auth.key_name else self.application_id), + or (user_auth.key_alias if user_auth.key_alias else (user_auth.key_name if user_auth.key_name else self.application_id)), "ipAddress": request_data.get("metadata", {}).get( "requester_ip_address", None ), From 52cdc5f04ee10f9089cf7b8f432df5fc87588548 Mon Sep 17 00:00:00 2001 From: Ido Lavi Date: Wed, 19 Nov 2025 17:54:01 +0200 Subject: [PATCH 03/13] Fix --- litellm/proxy/guardrails/guardrail_hooks/noma/noma.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py b/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py index b108e1c9798d..36ee7aafefaf 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py +++ b/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py @@ -799,7 +799,7 @@ async def _call_noma_api( or request_data.get("metadata", {}) .get("headers", {}) .get("x-noma-application-id") - or (user_auth.key_alias if user_auth.key_alias else (user_auth.key_name if user_auth.key_name else self.application_id)), + or (user_auth.key_alias if user_auth.key_alias else self.application_id), "ipAddress": request_data.get("metadata", {}).get( "requester_ip_address", None ), From 10dfe0b32e07e76041529c2683f13c3436763bdf Mon Sep 17 00:00:00 2001 From: Ido Lavi Date: Wed, 19 Nov 2025 18:07:15 +0200 Subject: [PATCH 04/13] last priority key alias --- litellm/proxy/guardrails/guardrail_hooks/noma/noma.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py b/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py index 36ee7aafefaf..9f54c4a63f3f 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py +++ b/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py @@ -799,7 +799,8 @@ async def _call_noma_api( or request_data.get("metadata", {}) .get("headers", {}) .get("x-noma-application-id") - or (user_auth.key_alias if user_auth.key_alias else self.application_id), + or self.application_id + or user_auth.key_alias, "ipAddress": request_data.get("metadata", {}).get( "requester_ip_address", None ), From 8944b7fbb506860ebb4061740b60713e57f843df Mon Sep 17 00:00:00 2001 From: Ido Lavi Date: Wed, 19 Nov 2025 18:17:26 +0200 Subject: [PATCH 05/13] Fix --- litellm/proxy/guardrails/guardrail_hooks/noma/noma.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py b/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py index 9f54c4a63f3f..3ae2d519c45c 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py +++ b/litellm/proxy/guardrails/guardrail_hooks/noma/noma.py @@ -116,8 +116,9 @@ def __init__( "NOMA_API_BASE", NomaGuardrail._DEFAULT_API_BASE ) self.application_id = application_id or os.environ.get( - "NOMA_APPLICATION_ID", "litellm" + "NOMA_APPLICATION_ID" ) + self.default_application_id = "litellm" if monitor_mode is None: self.monitor_mode = ( @@ -800,7 +801,8 @@ async def _call_noma_api( .get("headers", {}) .get("x-noma-application-id") or self.application_id - or user_auth.key_alias, + or user_auth.key_alias + or self.default_application_id, "ipAddress": request_data.get("metadata", {}).get( "requester_ip_address", None ), From 646827aa84157bf61766203c600a4a92f3fff26e Mon Sep 17 00:00:00 2001 From: Ido Lavi Date: Wed, 19 Nov 2025 19:24:32 +0200 Subject: [PATCH 06/13] Add tests --- .../guardrails/guardrail_hooks/test_noma.py | 148 +++++++++++++++++- 1 file changed, 147 insertions(+), 1 deletion(-) diff --git a/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_noma.py b/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_noma.py index 9a6ab1b8162d..94cb831a30c4 100644 --- a/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_noma.py +++ b/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_noma.py @@ -1,5 +1,6 @@ +import copy import os -from unittest.mock import MagicMock, patch +from unittest.mock import AsyncMock, MagicMock, patch import httpx import pytest @@ -164,6 +165,151 @@ def test_initialize_guardrail_function(self): assert result.block_failures is False mock_add.assert_called_once_with(result) +class TestNomaApplicationIdResolution: + """Tests for determining which applicationId is sent to Noma.""" + + @staticmethod + def _clone_user_auth(user_auth: UserAPIKeyAuth) -> UserAPIKeyAuth: + return UserAPIKeyAuth(**user_auth.model_dump()) + + @staticmethod + def _clone_request_data(request_data: dict) -> dict: + return copy.deepcopy(request_data) + + @staticmethod + async def _get_application_id( + guardrail: NomaGuardrail, + user_auth: UserAPIKeyAuth, + request_data: dict, + extra_data: dict, + ) -> str: + mock_response = MagicMock() + mock_response.json.return_value = {"aggregatedScanResult": False, "scanResult": []} + mock_response.raise_for_status = MagicMock() + mock_post = AsyncMock(return_value=mock_response) + + with patch.object(guardrail.async_handler, "post", mock_post): + await guardrail._call_noma_api( + payload={"input": []}, + llm_request_id=None, + request_data=request_data, + user_auth=user_auth, + extra_data=extra_data, + ) + + sent_payload = mock_post.call_args.kwargs["json"] + return sent_payload["x-noma-context"]["applicationId"] + + @pytest.mark.asyncio + async def test_application_id_prefers_extra_body( + self, noma_guardrail, mock_user_api_key_dict, mock_request_data + ): + request_data = self._clone_request_data(mock_request_data) + request_data.setdefault("metadata", {}).setdefault( + "headers", {} + )["x-noma-application-id"] = "header-app" + user_auth = self._clone_user_auth(mock_user_api_key_dict) + user_auth.key_alias = "alias-app" + + application_id = await self._get_application_id( + guardrail=noma_guardrail, + user_auth=user_auth, + request_data=request_data, + extra_data={"application_id": "dynamic-app"}, + ) + + assert application_id == "dynamic-app" + + @pytest.mark.asyncio + async def test_application_id_prefers_header_over_alias( + self, noma_guardrail, mock_user_api_key_dict, mock_request_data + ): + request_data = self._clone_request_data(mock_request_data) + request_data.setdefault("metadata", {}).setdefault( + "headers", {} + )["x-noma-application-id"] = "header-app" + user_auth = self._clone_user_auth(mock_user_api_key_dict) + user_auth.key_alias = "alias-app" + original_app_id = noma_guardrail.application_id + noma_guardrail.application_id = None + + try: + application_id = await self._get_application_id( + guardrail=noma_guardrail, + user_auth=user_auth, + request_data=request_data, + extra_data={}, + ) + finally: + noma_guardrail.application_id = original_app_id + + assert application_id == "header-app" + + @pytest.mark.asyncio + async def test_application_id_uses_guardrail_config_before_alias( + self, noma_guardrail, mock_user_api_key_dict, mock_request_data + ): + request_data = self._clone_request_data(mock_request_data) + user_auth = self._clone_user_auth(mock_user_api_key_dict) + user_auth.key_alias = "alias-app" + original_app_id = noma_guardrail.application_id + noma_guardrail.application_id = "config-app" + + try: + application_id = await self._get_application_id( + guardrail=noma_guardrail, + user_auth=user_auth, + request_data=request_data, + extra_data={}, + ) + finally: + noma_guardrail.application_id = original_app_id + + assert application_id == "config-app" + + @pytest.mark.asyncio + async def test_application_id_falls_back_to_alias( + self, noma_guardrail, mock_user_api_key_dict, mock_request_data + ): + request_data = self._clone_request_data(mock_request_data) + user_auth = self._clone_user_auth(mock_user_api_key_dict) + user_auth.key_alias = "alias-app" + original_app_id = noma_guardrail.application_id + noma_guardrail.application_id = None + + try: + application_id = await self._get_application_id( + guardrail=noma_guardrail, + user_auth=user_auth, + request_data=request_data, + extra_data={}, + ) + finally: + noma_guardrail.application_id = original_app_id + + assert application_id == "alias-app" + + @pytest.mark.asyncio + async def test_application_id_defaults_to_litellm( + self, noma_guardrail, mock_user_api_key_dict, mock_request_data + ): + request_data = self._clone_request_data(mock_request_data) + user_auth = self._clone_user_auth(mock_user_api_key_dict) + user_auth.key_alias = None + original_app_id = noma_guardrail.application_id + noma_guardrail.application_id = None + + try: + application_id = await self._get_application_id( + guardrail=noma_guardrail, + user_auth=user_auth, + request_data=request_data, + extra_data={}, + ) + finally: + noma_guardrail.application_id = original_app_id + + assert application_id == "litellm" class TestNomaBlockedMessage: """Test the NomaBlockedMessage exception class""" From d21e90f6831eebde5eb8f8d42604f5b57116d05e Mon Sep 17 00:00:00 2001 From: Mateo Wang <277851410+mateo-berri@users.noreply.github.com> Date: Fri, 24 Apr 2026 14:10:42 -0700 Subject: [PATCH 07/13] [Feat] Day-0 support for GPT-5.5 and GPT-5.5 Pro (#26449) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat(openai): day-0 support for GPT-5.5 and GPT-5.5 Pro Add pricing + capability entries for the new GPT-5.5 family launched by OpenAI on 2026-04-24: - gpt-5.5 / gpt-5.5-2026-04-23 (chat): $5/$30/$0.50 per 1M input/output/cached input - gpt-5.5-pro / gpt-5.5-pro-2026-04-23 (responses-only): $60/$360/$6 per 1M input/output/cached input Other fees (long-context >272k, flex, batches, priority, cache discounts) follow the same ratios as GPT-5.4, with context window retained at 1.05M input / 128K output. No transformation / classifier code changes are required: OpenAIGPT5Config.is_model_gpt_5_4_plus_model() already matches 5.5+ via numeric version parsing, and model registration is driven from the JSON. The existing responses-API bridge for tools + reasoning_effort (litellm/main.py:970) already covers gpt-5.5-pro. Tests: - GPT5_MODELS regression list now covers gpt-5.5-pro and dated variants - New test_generic_cost_per_token_gpt55_pro cost-calc test - Updated test_generic_cost_per_token_gpt55 for long-context fields * fix(openai): mirror reasoning_effort flags onto gpt-5.5 dated variants gpt-5.5-2026-04-23 and gpt-5.5-pro-2026-04-23 were missing the supports_none_reasoning_effort, supports_xhigh_reasoning_effort, and supports_minimal_reasoning_effort flags that their non-dated counterparts define. Reasoning-effort routing in OpenAIGPT5Config is fully capability-driven from these JSON flags — since an absent flag is treated as False for opt-in levels (xhigh), users pinning to a dated snapshot would silently lose xhigh support and diverge from the base alias on logprobs + flexible temperature handling. Copy the flags onto both dated variants so every dated snapshot inherits the base model's reasoning-effort capability profile. Adds a parametrized regression test that asserts supports_{none,minimal,xhigh}_reasoning_effort parity between each dated variant and its non-dated counterpart, preventing future drift when new snapshots are added. --- ...odel_prices_and_context_window_backup.json | 148 +++++++++++++++++- model_prices_and_context_window.json | 148 +++++++++++++++++- .../llm_cost_calc/test_llm_cost_calc_utils.py | 86 +++++++++- .../llms/openai/test_is_model_gpt_5_model.py | 3 + 4 files changed, 382 insertions(+), 3 deletions(-) diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json index 1cf7c1f6c7bb..49ce5022c564 100644 --- a/litellm/model_prices_and_context_window_backup.json +++ b/litellm/model_prices_and_context_window_backup.json @@ -19275,13 +19275,24 @@ }, "gpt-5.5": { "cache_read_input_token_cost": 5e-07, + "cache_read_input_token_cost_above_272k_tokens": 1e-06, + "cache_read_input_token_cost_flex": 2.5e-07, + "cache_read_input_token_cost_priority": 1e-06, "input_cost_per_token": 5e-06, + "input_cost_per_token_above_272k_tokens": 1e-05, + "input_cost_per_token_flex": 2.5e-06, + "input_cost_per_token_batches": 2.5e-06, + "input_cost_per_token_priority": 1e-05, "litellm_provider": "openai", - "max_input_tokens": 272000, + "max_input_tokens": 1050000, "max_output_tokens": 128000, "max_tokens": 128000, "mode": "chat", "output_cost_per_token": 3e-05, + "output_cost_per_token_above_272k_tokens": 4.5e-05, + "output_cost_per_token_flex": 1.5e-05, + "output_cost_per_token_batches": 1.5e-05, + "output_cost_per_token_priority": 6e-05, "supported_endpoints": [ "/v1/chat/completions", "/v1/batch", @@ -19305,10 +19316,145 @@ "supports_tool_choice": true, "supports_service_tier": true, "supports_vision": true, + "supports_web_search": true, "supports_none_reasoning_effort": true, "supports_xhigh_reasoning_effort": true, "supports_minimal_reasoning_effort": true }, + "gpt-5.5-2026-04-23": { + "cache_read_input_token_cost": 5e-07, + "cache_read_input_token_cost_above_272k_tokens": 1e-06, + "cache_read_input_token_cost_flex": 2.5e-07, + "cache_read_input_token_cost_priority": 1e-06, + "input_cost_per_token": 5e-06, + "input_cost_per_token_above_272k_tokens": 1e-05, + "input_cost_per_token_flex": 2.5e-06, + "input_cost_per_token_batches": 2.5e-06, + "input_cost_per_token_priority": 1e-05, + "litellm_provider": "openai", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "chat", + "output_cost_per_token": 3e-05, + "output_cost_per_token_above_272k_tokens": 4.5e-05, + "output_cost_per_token_flex": 1.5e-05, + "output_cost_per_token_batches": 1.5e-05, + "output_cost_per_token_priority": 6e-05, + "supported_endpoints": [ + "/v1/chat/completions", + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": true, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_service_tier": true, + "supports_vision": true, + "supports_web_search": true, + "supports_none_reasoning_effort": true, + "supports_xhigh_reasoning_effort": true, + "supports_minimal_reasoning_effort": true + }, + "gpt-5.5-pro": { + "cache_read_input_token_cost": 6e-06, + "cache_read_input_token_cost_above_272k_tokens": 1.2e-05, + "input_cost_per_token": 6e-05, + "input_cost_per_token_above_272k_tokens": 0.00012, + "input_cost_per_token_flex": 3e-05, + "input_cost_per_token_batches": 3e-05, + "litellm_provider": "openai", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "responses", + "output_cost_per_token": 0.00036, + "output_cost_per_token_above_272k_tokens": 0.00054, + "output_cost_per_token_flex": 0.00018, + "output_cost_per_token_batches": 0.00018, + "supported_endpoints": [ + "/v1/responses", + "/v1/batch" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": false, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_service_tier": true, + "supports_vision": true, + "supports_web_search": true, + "supports_none_reasoning_effort": false, + "supports_xhigh_reasoning_effort": true, + "supports_minimal_reasoning_effort": true + }, + "gpt-5.5-pro-2026-04-23": { + "cache_read_input_token_cost": 6e-06, + "cache_read_input_token_cost_above_272k_tokens": 1.2e-05, + "input_cost_per_token": 6e-05, + "input_cost_per_token_above_272k_tokens": 0.00012, + "input_cost_per_token_flex": 3e-05, + "input_cost_per_token_batches": 3e-05, + "litellm_provider": "openai", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "responses", + "output_cost_per_token": 0.00036, + "output_cost_per_token_above_272k_tokens": 0.00054, + "output_cost_per_token_flex": 0.00018, + "output_cost_per_token_batches": 0.00018, + "supported_endpoints": [ + "/v1/responses", + "/v1/batch" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": false, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_service_tier": true, + "supports_vision": true, + "supports_web_search": true, + "supports_none_reasoning_effort": false, + "supports_xhigh_reasoning_effort": true, + "supports_minimal_reasoning_effort": true + }, "gpt-5.4": { "cache_read_input_token_cost": 2.5e-07, "cache_read_input_token_cost_above_272k_tokens": 5e-07, diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json index 8dcd52cae2dd..3733f07a30dd 100644 --- a/model_prices_and_context_window.json +++ b/model_prices_and_context_window.json @@ -19289,13 +19289,24 @@ }, "gpt-5.5": { "cache_read_input_token_cost": 5e-07, + "cache_read_input_token_cost_above_272k_tokens": 1e-06, + "cache_read_input_token_cost_flex": 2.5e-07, + "cache_read_input_token_cost_priority": 1e-06, "input_cost_per_token": 5e-06, + "input_cost_per_token_above_272k_tokens": 1e-05, + "input_cost_per_token_flex": 2.5e-06, + "input_cost_per_token_batches": 2.5e-06, + "input_cost_per_token_priority": 1e-05, "litellm_provider": "openai", - "max_input_tokens": 272000, + "max_input_tokens": 1050000, "max_output_tokens": 128000, "max_tokens": 128000, "mode": "chat", "output_cost_per_token": 3e-05, + "output_cost_per_token_above_272k_tokens": 4.5e-05, + "output_cost_per_token_flex": 1.5e-05, + "output_cost_per_token_batches": 1.5e-05, + "output_cost_per_token_priority": 6e-05, "supported_endpoints": [ "/v1/chat/completions", "/v1/batch", @@ -19319,10 +19330,145 @@ "supports_tool_choice": true, "supports_service_tier": true, "supports_vision": true, + "supports_web_search": true, "supports_none_reasoning_effort": true, "supports_xhigh_reasoning_effort": true, "supports_minimal_reasoning_effort": true }, + "gpt-5.5-2026-04-23": { + "cache_read_input_token_cost": 5e-07, + "cache_read_input_token_cost_above_272k_tokens": 1e-06, + "cache_read_input_token_cost_flex": 2.5e-07, + "cache_read_input_token_cost_priority": 1e-06, + "input_cost_per_token": 5e-06, + "input_cost_per_token_above_272k_tokens": 1e-05, + "input_cost_per_token_flex": 2.5e-06, + "input_cost_per_token_batches": 2.5e-06, + "input_cost_per_token_priority": 1e-05, + "litellm_provider": "openai", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "chat", + "output_cost_per_token": 3e-05, + "output_cost_per_token_above_272k_tokens": 4.5e-05, + "output_cost_per_token_flex": 1.5e-05, + "output_cost_per_token_batches": 1.5e-05, + "output_cost_per_token_priority": 6e-05, + "supported_endpoints": [ + "/v1/chat/completions", + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": true, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_service_tier": true, + "supports_vision": true, + "supports_web_search": true, + "supports_none_reasoning_effort": true, + "supports_xhigh_reasoning_effort": true, + "supports_minimal_reasoning_effort": true + }, + "gpt-5.5-pro": { + "cache_read_input_token_cost": 6e-06, + "cache_read_input_token_cost_above_272k_tokens": 1.2e-05, + "input_cost_per_token": 6e-05, + "input_cost_per_token_above_272k_tokens": 0.00012, + "input_cost_per_token_flex": 3e-05, + "input_cost_per_token_batches": 3e-05, + "litellm_provider": "openai", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "responses", + "output_cost_per_token": 0.00036, + "output_cost_per_token_above_272k_tokens": 0.00054, + "output_cost_per_token_flex": 0.00018, + "output_cost_per_token_batches": 0.00018, + "supported_endpoints": [ + "/v1/responses", + "/v1/batch" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": false, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_service_tier": true, + "supports_vision": true, + "supports_web_search": true, + "supports_none_reasoning_effort": false, + "supports_xhigh_reasoning_effort": true, + "supports_minimal_reasoning_effort": true + }, + "gpt-5.5-pro-2026-04-23": { + "cache_read_input_token_cost": 6e-06, + "cache_read_input_token_cost_above_272k_tokens": 1.2e-05, + "input_cost_per_token": 6e-05, + "input_cost_per_token_above_272k_tokens": 0.00012, + "input_cost_per_token_flex": 3e-05, + "input_cost_per_token_batches": 3e-05, + "litellm_provider": "openai", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "responses", + "output_cost_per_token": 0.00036, + "output_cost_per_token_above_272k_tokens": 0.00054, + "output_cost_per_token_flex": 0.00018, + "output_cost_per_token_batches": 0.00018, + "supported_endpoints": [ + "/v1/responses", + "/v1/batch" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": false, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_service_tier": true, + "supports_vision": true, + "supports_web_search": true, + "supports_none_reasoning_effort": false, + "supports_xhigh_reasoning_effort": true, + "supports_minimal_reasoning_effort": true + }, "gpt-5.4": { "cache_read_input_token_cost": 2.5e-07, "cache_read_input_token_cost_above_272k_tokens": 5e-07, diff --git a/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py b/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py index 7144279ad0cb..5e37e2a3424b 100644 --- a/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py +++ b/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py @@ -343,7 +343,10 @@ def test_generic_cost_per_token_gpt55(): assert model_cost_map["cache_read_input_token_cost"] == 5e-7 assert model_cost_map["litellm_provider"] == "openai" assert model_cost_map["mode"] == "chat" - assert model_cost_map["max_input_tokens"] == 272000 + # gpt-5.5 inherits GPT-5.4's long-context window + tiered pricing. + assert model_cost_map["max_input_tokens"] == 1050000 + assert model_cost_map["input_cost_per_token_above_272k_tokens"] == 1e-5 + assert model_cost_map["output_cost_per_token_above_272k_tokens"] == 4.5e-5 prompt_tokens = 1000 completion_tokens = 500 @@ -365,6 +368,87 @@ def test_generic_cost_per_token_gpt55(): ) +def test_generic_cost_per_token_gpt55_pro(): + """gpt-5.5-pro: responses-only model — $60/1M input, $360/1M output, $6/1M cached input.""" + model = "gpt-5.5-pro" + custom_llm_provider = "openai" + os.environ["LITELLM_LOCAL_MODEL_COST_MAP"] = "True" + litellm.model_cost = litellm.get_model_cost_map(url="") + + model_cost_map = litellm.model_cost[model] + + # Sanity-check the map values match OpenAI's published pricing. + assert model_cost_map["input_cost_per_token"] == 6e-5 + assert model_cost_map["output_cost_per_token"] == 3.6e-4 + assert model_cost_map["cache_read_input_token_cost"] == 6e-6 + assert model_cost_map["litellm_provider"] == "openai" + # gpt-5.5-pro is a responses-only model (no /v1/chat/completions endpoint). + assert model_cost_map["mode"] == "responses" + assert "/v1/chat/completions" not in model_cost_map["supported_endpoints"] + assert "/v1/responses" in model_cost_map["supported_endpoints"] + # Inherits GPT-5.4-pro's long-context window + tiered pricing (scaled 2x). + assert model_cost_map["max_input_tokens"] == 1050000 + assert model_cost_map["input_cost_per_token_above_272k_tokens"] == 1.2e-4 + assert model_cost_map["output_cost_per_token_above_272k_tokens"] == 5.4e-4 + + prompt_tokens = 1000 + completion_tokens = 500 + usage = Usage( + prompt_tokens=prompt_tokens, + completion_tokens=completion_tokens, + total_tokens=prompt_tokens + completion_tokens, + ) + prompt_cost, completion_cost = generic_cost_per_token( + model=model, + usage=usage, + custom_llm_provider=custom_llm_provider, + ) + assert round(prompt_cost, 10) == round( + model_cost_map["input_cost_per_token"] * prompt_tokens, 10 + ) + assert round(completion_cost, 10) == round( + model_cost_map["output_cost_per_token"] * completion_tokens, 10 + ) + + +@pytest.mark.parametrize( + "base_model,dated_model", + [ + ("gpt-5.5", "gpt-5.5-2026-04-23"), + ("gpt-5.5-pro", "gpt-5.5-pro-2026-04-23"), + ], +) +def test_gpt55_dated_variants_match_base_reasoning_effort_capabilities( + base_model, dated_model +): + """Dated snapshots must carry the same reasoning_effort capability flags as + their non-dated counterparts. + + Regression guard: ``supports_{none,minimal,xhigh}_reasoning_effort`` gate + downstream routing in ``OpenAIGPT5Config`` — a missing flag is treated as + ``False`` for opt-in levels (e.g. ``xhigh``), which silently diverges + behavior between ``gpt-5.5`` and ``gpt-5.5-2026-04-23``. Pinning to a + dated variant must never lose capabilities relative to the base alias. + """ + os.environ["LITELLM_LOCAL_MODEL_COST_MAP"] = "True" + litellm.model_cost = litellm.get_model_cost_map(url="") + + base = litellm.model_cost[base_model] + dated = litellm.model_cost[dated_model] + + for flag in ( + "supports_none_reasoning_effort", + "supports_minimal_reasoning_effort", + "supports_xhigh_reasoning_effort", + ): + assert dated.get(flag) == base.get(flag), ( + f"{dated_model} has {flag}={dated.get(flag)!r}, " + f"but {base_model} has {flag}={base.get(flag)!r}. " + f"Dated snapshots must inherit the base model's reasoning_effort " + f"capability profile." + ) + + def test_generic_cost_per_token_anthropic_prompt_caching(): model = "claude-sonnet-4@20250514" usage = Usage( diff --git a/tests/test_litellm/llms/openai/test_is_model_gpt_5_model.py b/tests/test_litellm/llms/openai/test_is_model_gpt_5_model.py index e611d5e6b7e7..02dd9dade0a8 100644 --- a/tests/test_litellm/llms/openai/test_is_model_gpt_5_model.py +++ b/tests/test_litellm/llms/openai/test_is_model_gpt_5_model.py @@ -47,6 +47,9 @@ "gpt-5.3", "gpt-5.4", "gpt-5.5", + "gpt-5.5-pro", + "gpt-5.5-2026-04-23", # dated variant + "gpt-5.5-pro-2026-04-23", # dated variant "gpt-5.1-chat", # versioned chat — THE KEY REGRESSION CASE "gpt-5.2-chat", # versioned chat — also a regression case "gpt-5.3-chat", # versioned chat — THE KEY REGRESSION CASE From 0beec45c138d3d92a956cc1e1dc75fa2bd2ae782 Mon Sep 17 00:00:00 2001 From: Mateo Wang <277851410+mateo-berri@users.noreply.github.com> Date: Fri, 24 Apr 2026 18:10:21 -0700 Subject: [PATCH 08/13] [Feat] Add azure/gpt-5.5 + azure/gpt-5.5-pro entries (+ dated variants) (#26361) * feat(azure): add azure/gpt-5.5 + azure/gpt-5.5-pro entries (+ dated variants) Azure variants of OpenAI's GPT-5.5 family. Microsoft has not yet shipped GPT-5.5 on Azure OpenAI (latest GA on the Foundry models page is GPT-5.4 as of 2026-04-24), but adding the entries day-0 mirrors the established precedent for azure/gpt-5.4* (which were in the cost map before the Azure rollout) so cost tracking and capability flags work the moment customers deploy. Schema follows the existing azure/gpt-5.4* shape: - Same base/long-context pricing as openai/gpt-5.5*: $5/$30 chat, $60/$360 pro per 1M, with priority tier 2x base - Azure variants drop the flex/batches keys (Azure has no flex tier) but keep priority pricing, matching gpt-5.4* precedent - mode=chat for the thinking model, mode=responses for pro reasoning_effort capability flags mirror the OpenAI variants exactly since Azure proxies the same API contract: minimal rejection on both chat and pro, low/none rejection on pro. Once #26456 (which sets supports_low_reasoning_effort + minimal=false on openai/gpt-5.5*) lands, OpenAI and Azure flag profiles align. Tests pin entry presence + pricing for all four Azure variants and verify the live-API-derived reasoning_effort flags. * test: register supports_low_reasoning_effort in cost-map JSON schema azure/gpt-5.5-pro and azure/gpt-5.5-pro-2026-04-23 added in this branch carry supports_low_reasoning_effort=false. The strict 'additionalProperties: false' schema in test_aaamodel_prices_and_context_window_json_is_valid rejected the new key. Register it alongside the other supports_*_reasoning_effort entries. Note: the runtime side of this flag (code that reads it) lands in #26456. Until that PR merges the flag is inert for both Azure and OpenAI pro entries, but having the schema accept it lets cost-map tests pass on either merge order. --- ...odel_prices_and_context_window_backup.json | 163 ++++++++++++++++++ model_prices_and_context_window.json | 163 ++++++++++++++++++ .../llm_cost_calc/test_llm_cost_calc_utils.py | 57 ++++++ tests/test_litellm/test_utils.py | 1 + 4 files changed, 384 insertions(+) diff --git a/litellm/model_prices_and_context_window_backup.json b/litellm/model_prices_and_context_window_backup.json index 49ce5022c564..e11fab90770f 100644 --- a/litellm/model_prices_and_context_window_backup.json +++ b/litellm/model_prices_and_context_window_backup.json @@ -4645,6 +4645,169 @@ "supports_vision": true, "supports_web_search": true }, + "azure/gpt-5.5": { + "cache_read_input_token_cost": 5e-07, + "cache_read_input_token_cost_above_272k_tokens": 1e-06, + "cache_read_input_token_cost_priority": 1e-06, + "cache_read_input_token_cost_above_272k_tokens_priority": 2e-06, + "input_cost_per_token": 5e-06, + "input_cost_per_token_above_272k_tokens": 1e-05, + "input_cost_per_token_priority": 1e-05, + "input_cost_per_token_above_272k_tokens_priority": 2e-05, + "litellm_provider": "azure", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "chat", + "output_cost_per_token": 3e-05, + "output_cost_per_token_above_272k_tokens": 4.5e-05, + "output_cost_per_token_priority": 6e-05, + "output_cost_per_token_above_272k_tokens_priority": 9e-05, + "supported_endpoints": [ + "/v1/chat/completions", + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": true, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_service_tier": true, + "supports_vision": true, + "supports_web_search": true, + "supports_none_reasoning_effort": true, + "supports_xhigh_reasoning_effort": true, + "supports_minimal_reasoning_effort": false + }, + "azure/gpt-5.5-2026-04-23": { + "cache_read_input_token_cost": 5e-07, + "cache_read_input_token_cost_above_272k_tokens": 1e-06, + "cache_read_input_token_cost_priority": 1e-06, + "cache_read_input_token_cost_above_272k_tokens_priority": 2e-06, + "input_cost_per_token": 5e-06, + "input_cost_per_token_above_272k_tokens": 1e-05, + "input_cost_per_token_priority": 1e-05, + "input_cost_per_token_above_272k_tokens_priority": 2e-05, + "litellm_provider": "azure", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "chat", + "output_cost_per_token": 3e-05, + "output_cost_per_token_above_272k_tokens": 4.5e-05, + "output_cost_per_token_priority": 6e-05, + "output_cost_per_token_above_272k_tokens_priority": 9e-05, + "supported_endpoints": [ + "/v1/chat/completions", + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": true, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_service_tier": true, + "supports_vision": true, + "supports_web_search": true + }, + "azure/gpt-5.5-pro": { + "cache_read_input_token_cost": 6e-06, + "cache_read_input_token_cost_above_272k_tokens": 1.2e-05, + "input_cost_per_token": 6e-05, + "input_cost_per_token_above_272k_tokens": 0.00012, + "litellm_provider": "azure", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "responses", + "output_cost_per_token": 0.00036, + "output_cost_per_token_above_272k_tokens": 0.00054, + "supported_endpoints": [ + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": false, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_vision": true, + "supports_web_search": true, + "supports_none_reasoning_effort": false, + "supports_xhigh_reasoning_effort": true, + "supports_minimal_reasoning_effort": false, + "supports_low_reasoning_effort": false + }, + "azure/gpt-5.5-pro-2026-04-23": { + "cache_read_input_token_cost": 6e-06, + "cache_read_input_token_cost_above_272k_tokens": 1.2e-05, + "input_cost_per_token": 6e-05, + "input_cost_per_token_above_272k_tokens": 0.00012, + "litellm_provider": "azure", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "responses", + "output_cost_per_token": 0.00036, + "output_cost_per_token_above_272k_tokens": 0.00054, + "supported_endpoints": [ + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": false, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_vision": true, + "supports_web_search": true + }, "azure/gpt-5.4-mini": { "cache_read_input_token_cost": 7.5e-08, "input_cost_per_token": 7.5e-07, diff --git a/model_prices_and_context_window.json b/model_prices_and_context_window.json index 3733f07a30dd..6eb6f1a9a9ec 100644 --- a/model_prices_and_context_window.json +++ b/model_prices_and_context_window.json @@ -4659,6 +4659,169 @@ "supports_vision": true, "supports_web_search": true }, + "azure/gpt-5.5": { + "cache_read_input_token_cost": 5e-07, + "cache_read_input_token_cost_above_272k_tokens": 1e-06, + "cache_read_input_token_cost_priority": 1e-06, + "cache_read_input_token_cost_above_272k_tokens_priority": 2e-06, + "input_cost_per_token": 5e-06, + "input_cost_per_token_above_272k_tokens": 1e-05, + "input_cost_per_token_priority": 1e-05, + "input_cost_per_token_above_272k_tokens_priority": 2e-05, + "litellm_provider": "azure", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "chat", + "output_cost_per_token": 3e-05, + "output_cost_per_token_above_272k_tokens": 4.5e-05, + "output_cost_per_token_priority": 6e-05, + "output_cost_per_token_above_272k_tokens_priority": 9e-05, + "supported_endpoints": [ + "/v1/chat/completions", + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": true, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_service_tier": true, + "supports_vision": true, + "supports_web_search": true, + "supports_none_reasoning_effort": true, + "supports_xhigh_reasoning_effort": true, + "supports_minimal_reasoning_effort": false + }, + "azure/gpt-5.5-2026-04-23": { + "cache_read_input_token_cost": 5e-07, + "cache_read_input_token_cost_above_272k_tokens": 1e-06, + "cache_read_input_token_cost_priority": 1e-06, + "cache_read_input_token_cost_above_272k_tokens_priority": 2e-06, + "input_cost_per_token": 5e-06, + "input_cost_per_token_above_272k_tokens": 1e-05, + "input_cost_per_token_priority": 1e-05, + "input_cost_per_token_above_272k_tokens_priority": 2e-05, + "litellm_provider": "azure", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "chat", + "output_cost_per_token": 3e-05, + "output_cost_per_token_above_272k_tokens": 4.5e-05, + "output_cost_per_token_priority": 6e-05, + "output_cost_per_token_above_272k_tokens_priority": 9e-05, + "supported_endpoints": [ + "/v1/chat/completions", + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": true, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_service_tier": true, + "supports_vision": true, + "supports_web_search": true + }, + "azure/gpt-5.5-pro": { + "cache_read_input_token_cost": 6e-06, + "cache_read_input_token_cost_above_272k_tokens": 1.2e-05, + "input_cost_per_token": 6e-05, + "input_cost_per_token_above_272k_tokens": 0.00012, + "litellm_provider": "azure", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "responses", + "output_cost_per_token": 0.00036, + "output_cost_per_token_above_272k_tokens": 0.00054, + "supported_endpoints": [ + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": false, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_vision": true, + "supports_web_search": true, + "supports_none_reasoning_effort": false, + "supports_xhigh_reasoning_effort": true, + "supports_minimal_reasoning_effort": false, + "supports_low_reasoning_effort": false + }, + "azure/gpt-5.5-pro-2026-04-23": { + "cache_read_input_token_cost": 6e-06, + "cache_read_input_token_cost_above_272k_tokens": 1.2e-05, + "input_cost_per_token": 6e-05, + "input_cost_per_token_above_272k_tokens": 0.00012, + "litellm_provider": "azure", + "max_input_tokens": 1050000, + "max_output_tokens": 128000, + "max_tokens": 128000, + "mode": "responses", + "output_cost_per_token": 0.00036, + "output_cost_per_token_above_272k_tokens": 0.00054, + "supported_endpoints": [ + "/v1/batch", + "/v1/responses" + ], + "supported_modalities": [ + "text", + "image" + ], + "supported_output_modalities": [ + "text" + ], + "supports_function_calling": true, + "supports_native_streaming": true, + "supports_parallel_function_calling": true, + "supports_pdf_input": true, + "supports_prompt_caching": true, + "supports_reasoning": true, + "supports_response_schema": false, + "supports_system_messages": true, + "supports_tool_choice": true, + "supports_vision": true, + "supports_web_search": true + }, "azure/gpt-5.4-mini": { "cache_read_input_token_cost": 7.5e-08, "input_cost_per_token": 7.5e-07, diff --git a/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py b/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py index 5e37e2a3424b..3016762043cb 100644 --- a/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py +++ b/tests/test_litellm/litellm_core_utils/llm_cost_calc/test_llm_cost_calc_utils.py @@ -449,6 +449,63 @@ def test_gpt55_dated_variants_match_base_reasoning_effort_capabilities( ) +@pytest.mark.parametrize( + "model,expected_mode,expected_input,expected_output,expected_cache_read", + [ + ("azure/gpt-5.5", "chat", 5e-6, 3e-5, 5e-7), + ("azure/gpt-5.5-2026-04-23", "chat", 5e-6, 3e-5, 5e-7), + ("azure/gpt-5.5-pro", "responses", 6e-5, 3.6e-4, 6e-6), + ("azure/gpt-5.5-pro-2026-04-23", "responses", 6e-5, 3.6e-4, 6e-6), + ], +) +def test_azure_gpt55_entries_present_with_correct_pricing( + model, expected_mode, expected_input, expected_output, expected_cache_read +): + """Day-0 Azure entries for GPT-5.5 mirror the OpenAI pricing structure. + + Pricing parity with openai/gpt-5.5* (verified against OpenAI's pricing page + on 2026-04-24): $5/$30 input/output per 1M for chat, $60/$360 for pro. + Cache discount is 10% of input. + """ + os.environ["LITELLM_LOCAL_MODEL_COST_MAP"] = "True" + litellm.model_cost = litellm.get_model_cost_map(url="") + + m = litellm.model_cost[model] + assert m["litellm_provider"] == "azure" + assert m["mode"] == expected_mode + assert m["input_cost_per_token"] == expected_input + assert m["output_cost_per_token"] == expected_output + assert m["cache_read_input_token_cost"] == expected_cache_read + # Long-context window inherited from gpt-5.4 / openai gpt-5.5. + assert m["max_input_tokens"] == 1050000 + assert m["max_output_tokens"] == 128000 + + +@pytest.mark.parametrize( + "model,expected_none,expected_minimal,expected_xhigh", + [ + # Mirror live OpenAI API contract (verified via openai/gpt-5.5* on + # 2026-04-24): chat accepts {none, low, medium, high, xhigh} but NOT + # minimal; pro accepts {medium, high, xhigh} only. + # NOTE: openai/gpt-5.5* entries currently set supports_minimal=true on + # main (pre #26456). Once that PR lands, OpenAI + Azure flags align. + ("azure/gpt-5.5", True, False, True), + ("azure/gpt-5.5-pro", False, False, True), + ], +) +def test_azure_gpt55_reasoning_effort_flags_match_live_openai_api( + model, expected_none, expected_minimal, expected_xhigh +): + """Azure entries pin reasoning_effort flags to OpenAI's actual API contract.""" + os.environ["LITELLM_LOCAL_MODEL_COST_MAP"] = "True" + litellm.model_cost = litellm.get_model_cost_map(url="") + + m = litellm.model_cost[model] + assert m.get("supports_none_reasoning_effort") is expected_none + assert m.get("supports_minimal_reasoning_effort") is expected_minimal + assert m.get("supports_xhigh_reasoning_effort") is expected_xhigh + + def test_generic_cost_per_token_anthropic_prompt_caching(): model = "claude-sonnet-4@20250514" usage = Usage( diff --git a/tests/test_litellm/test_utils.py b/tests/test_litellm/test_utils.py index 67b626961961..c6b0f49ff612 100644 --- a/tests/test_litellm/test_utils.py +++ b/tests/test_litellm/test_utils.py @@ -769,6 +769,7 @@ def test_aaamodel_prices_and_context_window_json_is_valid(): "uses_embed_content": {"type": "boolean"}, "supports_reasoning": {"type": "boolean"}, "supports_minimal_reasoning_effort": {"type": "boolean"}, + "supports_low_reasoning_effort": {"type": "boolean"}, "supports_none_reasoning_effort": {"type": "boolean"}, "supports_xhigh_reasoning_effort": {"type": "boolean"}, "supports_max_reasoning_effort": {"type": "boolean"}, From cf09c5c98f06f43c9fcd2541c902b43b399a3659 Mon Sep 17 00:00:00 2001 From: OmriShukrun_ Date: Sat, 18 Apr 2026 17:43:46 +0300 Subject: [PATCH 09/13] Use sanitize deep copy style to replace deepcopy usage --- .../guardrail_hooks/noma/noma_v2.py | 51 +++++++++++++------ 1 file changed, 36 insertions(+), 15 deletions(-) diff --git a/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py b/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py index 071613ad5f9a..cddf73bd3b6e 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py +++ b/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py @@ -7,7 +7,6 @@ import enum import json import os -from copy import deepcopy from datetime import datetime from typing import TYPE_CHECKING, Any, Literal, Optional, Type, cast from urllib.parse import urlparse @@ -131,6 +130,35 @@ def _resolve_action_from_response( raise ValueError("Noma v2 response missing valid action") + @staticmethod + def _json_safe_copy(data: Any) -> Any: + """JSON round-trip producing a deep, JSON-serializable copy of `data`. + + Fast path: `json.dumps` (C-level) with a `default=` callback that + handles Pydantic models and falls back to `str(obj)` for anything + non-serializable (e.g. uvloop.Loop, locks, other C-extension objects + whose __reduce__ raises — which is why this replaces deepcopy). + + Slow path: if `json.dumps` raises (circular refs, etc.), retry with + `safe_dumps` which walks the tree in Python with explicit cycle + detection. Finally `safe_json_loads` parses back to a Python tree. + """ + + def _default(obj: Any) -> Any: + if hasattr(obj, "model_dump"): + try: + return obj.model_dump() + except Exception: + pass + return str(obj) + + try: + json_str = json.dumps(data, default=_default) + except (ValueError, TypeError): + json_str = safe_dumps(data) + + return safe_json_loads(json_str, default={}) + def _build_scan_payload( self, inputs: GenericGuardrailAPIInputs, @@ -139,7 +167,12 @@ def _build_scan_payload( logging_obj: Optional["LiteLLMLoggingObj"], application_id: Optional[str], ) -> dict: - payload_request_data = deepcopy(request_data) + # JSON round-trip rather than deepcopy: on post_call / during_call / + # during_mcp_call, request_data contains uvloop.Loop and other C-extension + # objects whose __reduce__ raises, crashing pickle-based copy. + payload_request_data = self._json_safe_copy(request_data) + if not isinstance(payload_request_data, dict): + payload_request_data = {} if logging_obj is not None: payload_request_data["litellm_logging_obj"] = getattr( logging_obj, "model_call_details", None @@ -157,20 +190,8 @@ def _build_scan_payload( @staticmethod def _sanitize_payload_for_transport(payload: dict) -> dict: - def _default(obj: Any) -> Any: - if hasattr(obj, "model_dump"): - try: - return obj.model_dump() - except Exception: - pass - return str(obj) - - try: - json_str = json.dumps(payload, default=_default) - except (ValueError, TypeError): - json_str = safe_dumps(payload) + safe_payload = NomaV2Guardrail._json_safe_copy(payload) - safe_payload = safe_json_loads(json_str, default={}) if safe_payload == {} and payload: verbose_proxy_logger.warning( "Noma v2 guardrail: payload serialization failed, falling back to empty payload" From 44f1d5f8853a826305992d4f258f90095e770192 Mon Sep 17 00:00:00 2001 From: OmriShukrun_ Date: Sat, 18 Apr 2026 17:45:26 +0300 Subject: [PATCH 10/13] Added test checking error is not happening anymore --- .../guardrail_hooks/test_noma_v2.py | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_noma_v2.py b/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_noma_v2.py index 7a3566fecbd5..b6445a7c90d1 100644 --- a/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_noma_v2.py +++ b/tests/test_litellm/proxy/guardrails/guardrail_hooks/test_noma_v2.py @@ -160,6 +160,44 @@ def test_build_scan_payload_deep_copies_request_data(self, noma_v2_guardrail): ) assert request_data["messages"][0]["content"] == "hello" + def test_build_scan_payload_survives_unpicklable_request_data( + self, noma_v2_guardrail + ): + """Regression test for NOM-8044: post_call / during_call / during_mcp_call + used to 500 because request_data contained uvloop.Loop and similar + C-extension objects whose __reduce__ raises, which crashed deepcopy.""" + + class _FakeUvloopObject: + def __reduce__(self): + raise TypeError("no default __reduce__ due to non-trivial __cinit__") + + def __repr__(self) -> str: + return "" + + unpicklable = _FakeUvloopObject() + request_data = { + "metadata": {"headers": {"x-noma-application-id": "header-app"}}, + "messages": [{"role": "user", "content": "hello"}], + "event_loop": unpicklable, + } + + payload = noma_v2_guardrail._build_scan_payload( + inputs={"texts": ["hello"]}, + request_data=request_data, + input_type="response", + logging_obj=None, + application_id="dynamic-app", + ) + + assert isinstance(payload["request_data"], dict) + assert payload["request_data"]["event_loop"] == "" + assert payload["request_data"]["messages"] == [ + {"role": "user", "content": "hello"} + ] + + # Original request_data must not have been mutated by the copy. + assert request_data["event_loop"] is unpicklable + def test_build_scan_payload_passes_model_call_details_as_is( self, noma_v2_guardrail ): From aa48435aab28404cd202eb0e449035133dac6342 Mon Sep 17 00:00:00 2001 From: OmriShukrun_ Date: Sat, 18 Apr 2026 19:23:25 +0300 Subject: [PATCH 11/13] Added warning log when json copy failed --- litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py b/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py index cddf73bd3b6e..b74e0febaedb 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py +++ b/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py @@ -173,6 +173,10 @@ def _build_scan_payload( payload_request_data = self._json_safe_copy(request_data) if not isinstance(payload_request_data, dict): payload_request_data = {} + if not payload_request_data and request_data: + verbose_proxy_logger.warning( + "Noma v2 guardrail: request_data serialization failed in _build_scan_payload, proceeding with empty request_data" + ) if logging_obj is not None: payload_request_data["litellm_logging_obj"] = getattr( logging_obj, "model_call_details", None From 03e2cc4aca6b4ac069357efb9efc111c1e04626b Mon Sep 17 00:00:00 2001 From: OmriShukrun_ Date: Sun, 19 Apr 2026 11:06:48 +0300 Subject: [PATCH 12/13] Reduce to one change --- .../guardrail_hooks/noma/noma_v2.py | 55 +++++-------------- 1 file changed, 15 insertions(+), 40 deletions(-) diff --git a/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py b/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py index b74e0febaedb..be3fc3ac8bfa 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py +++ b/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py @@ -130,35 +130,6 @@ def _resolve_action_from_response( raise ValueError("Noma v2 response missing valid action") - @staticmethod - def _json_safe_copy(data: Any) -> Any: - """JSON round-trip producing a deep, JSON-serializable copy of `data`. - - Fast path: `json.dumps` (C-level) with a `default=` callback that - handles Pydantic models and falls back to `str(obj)` for anything - non-serializable (e.g. uvloop.Loop, locks, other C-extension objects - whose __reduce__ raises — which is why this replaces deepcopy). - - Slow path: if `json.dumps` raises (circular refs, etc.), retry with - `safe_dumps` which walks the tree in Python with explicit cycle - detection. Finally `safe_json_loads` parses back to a Python tree. - """ - - def _default(obj: Any) -> Any: - if hasattr(obj, "model_dump"): - try: - return obj.model_dump() - except Exception: - pass - return str(obj) - - try: - json_str = json.dumps(data, default=_default) - except (ValueError, TypeError): - json_str = safe_dumps(data) - - return safe_json_loads(json_str, default={}) - def _build_scan_payload( self, inputs: GenericGuardrailAPIInputs, @@ -167,16 +138,7 @@ def _build_scan_payload( logging_obj: Optional["LiteLLMLoggingObj"], application_id: Optional[str], ) -> dict: - # JSON round-trip rather than deepcopy: on post_call / during_call / - # during_mcp_call, request_data contains uvloop.Loop and other C-extension - # objects whose __reduce__ raises, crashing pickle-based copy. - payload_request_data = self._json_safe_copy(request_data) - if not isinstance(payload_request_data, dict): - payload_request_data = {} - if not payload_request_data and request_data: - verbose_proxy_logger.warning( - "Noma v2 guardrail: request_data serialization failed in _build_scan_payload, proceeding with empty request_data" - ) + payload_request_data = self._sanitize_payload_for_transport(request_data) if logging_obj is not None: payload_request_data["litellm_logging_obj"] = getattr( logging_obj, "model_call_details", None @@ -194,7 +156,20 @@ def _build_scan_payload( @staticmethod def _sanitize_payload_for_transport(payload: dict) -> dict: - safe_payload = NomaV2Guardrail._json_safe_copy(payload) + def _default(obj: Any) -> Any: + if hasattr(obj, "model_dump"): + try: + return obj.model_dump() + except Exception: + pass + return str(obj) + + try: + json_str = json.dumps(payload, default=_default) + except (ValueError, TypeError): + json_str = safe_dumps(payload) + + safe_payload = safe_json_loads(json_str, default={}) if safe_payload == {} and payload: verbose_proxy_logger.warning( From 2356ca0736616476f67ed3a67d008ef30fffafa1 Mon Sep 17 00:00:00 2001 From: OmriShukrun_ Date: Sun, 19 Apr 2026 11:07:35 +0300 Subject: [PATCH 13/13] Fix spaces --- litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py b/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py index be3fc3ac8bfa..6aeaac949a9a 100644 --- a/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py +++ b/litellm/proxy/guardrails/guardrail_hooks/noma/noma_v2.py @@ -168,9 +168,8 @@ def _default(obj: Any) -> Any: json_str = json.dumps(payload, default=_default) except (ValueError, TypeError): json_str = safe_dumps(payload) - - safe_payload = safe_json_loads(json_str, default={}) + safe_payload = safe_json_loads(json_str, default={}) if safe_payload == {} and payload: verbose_proxy_logger.warning( "Noma v2 guardrail: payload serialization failed, falling back to empty payload"