From 6b591c34f141d4977078da2e7d67ad320d898f13 Mon Sep 17 00:00:00 2001
From: KunalG67 <kunalgarhewal13@gmail.com>
Date: Mon, 27 Apr 2026 17:15:11 +0530
Subject: [PATCH 01/20] fix(ovhcloud): migrate reasoning_content->reasoning and
 duration->seconds fields

OVHCloud is deprecating two response fields on 2026-05-11:
- reasoning_content replaced by reasoning (LLM reasoning models)
- duration replaced by seconds (Speech-to-Text models)

Adds backward-compatible support for both field names during the
transition window, preferring the new field when present and falling
back to the legacy field.

Fixes #26586
---
 .../audio_transcription/transformation.py     |  8 ++
 litellm/llms/ovhcloud/chat/transformation.py  | 14 +++-
 ...loud_audio_transcription_transformation.py | 43 +++++++++++
 .../test_ovhcloud_chat_transformation.py      | 73 +++++++++++++++++++
 4 files changed, 134 insertions(+), 4 deletions(-)

diff --git a/litellm/llms/ovhcloud/audio_transcription/transformation.py b/litellm/llms/ovhcloud/audio_transcription/transformation.py
index 7ff6dc986be..e3c8308d507 100644
--- a/litellm/llms/ovhcloud/audio_transcription/transformation.py
+++ b/litellm/llms/ovhcloud/audio_transcription/transformation.py
@@ -156,5 +156,13 @@ class OVHCloudAudioTranscriptionConfig(BaseAudioTranscriptionConfig):
         text = response_json.get("text") or response_json.get("transcript") or ""
         response = TranscriptionResponse(text=text)
 
+        # OVHCloud field migration (deadline: 2026-05-11):
+        # `duration` is replaced by `seconds` in STT responses.
+        # Prefer `seconds`, fall back to `duration`, normalize to `duration`
+        # so downstream consumers see a consistent key.
+        duration = response_json.get("seconds") or response_json.get("duration")
+        if duration is not None:
+            response_json["duration"] = duration
+
         response._hidden_params = response_json
         return response
diff --git a/litellm/llms/ovhcloud/chat/transformation.py b/litellm/llms/ovhcloud/chat/transformation.py
index ae9271ddb16..4100c548f2c 100644
--- a/litellm/llms/ovhcloud/chat/transformation.py
+++ b/litellm/llms/ovhcloud/chat/transformation.py
@@ -98,10 +98,16 @@ class OVHCloudChatCompletionStreamingHandler(BaseModelResponseIterator):
 
             new_choices = []
             for choice in chunk["choices"]:
-                if "delta" in choice and "reasoning" in choice["delta"]:
-                    choice["delta"]["reasoning_content"] = choice["delta"].get(
-                        "reasoning"
-                    )
+                if "delta" in choice:
+                    delta = choice["delta"]
+                    # OVHCloud field migration (deadline: 2026-05-11):
+                    # `reasoning_content` is replaced by `reasoning`.
+                    # Normalise to `reasoning_content` so downstream consumers
+                    # see a consistent key during the transition window.
+                    reasoning_new = delta.get("reasoning")
+                    reasoning_legacy = delta.get("reasoning_content")
+                    if reasoning_new is not None and reasoning_legacy is None:
+                        delta["reasoning_content"] = reasoning_new
                 new_choices.append(choice)
 
             return ModelResponseStream(
diff --git a/tests/test_litellm/llms/ovhcloud/test_ovhcloud_audio_transcription_transformation.py b/tests/test_litellm/llms/ovhcloud/test_ovhcloud_audio_transcription_transformation.py
index 8cc46dc98d0..e9abf50ba75 100644
--- a/tests/test_litellm/llms/ovhcloud/test_ovhcloud_audio_transcription_transformation.py
+++ b/tests/test_litellm/llms/ovhcloud/test_ovhcloud_audio_transcription_transformation.py
@@ -54,3 +54,46 @@ def test_ovhcloud_audio_transcription_config_installed():
 
     assert config is not None
     assert isinstance(config, BaseAudioTranscriptionConfig)
+
+
+
+class TestOVHCloudDurationFieldMigration:
+    """Tests for OVHCloud duration -> seconds field migration."""
+
+    def test_seconds_field_mapped_to_duration(self):
+        """New `seconds` field should be normalized to `duration`."""
+        from litellm.llms.ovhcloud.audio_transcription.transformation import (
+            OVHCloudAudioTranscriptionConfig,
+        )
+        from unittest.mock import MagicMock
+
+        config = OVHCloudAudioTranscriptionConfig()
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "text": "Hello world",
+            "seconds": 3.14,
+        }
+
+        result = config.transform_audio_transcription_response(mock_response)
+
+        assert result.text == "Hello world"
+        assert result._hidden_params["duration"] == 3.14
+
+    def test_legacy_duration_field_still_works(self):
+        """Legacy `duration` field should still be accepted."""
+        from litellm.llms.ovhcloud.audio_transcription.transformation import (
+            OVHCloudAudioTranscriptionConfig,
+        )
+        from unittest.mock import MagicMock
+
+        config = OVHCloudAudioTranscriptionConfig()
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "text": "Hello world",
+            "duration": 2.71,
+        }
+
+        result = config.transform_audio_transcription_response(mock_response)
+
+        assert result.text == "Hello world"
+        assert result._hidden_params["duration"] == 2.71
\ No newline at end of file
diff --git a/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py b/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py
index a1b3b31f786..88ce3b4c296 100644
--- a/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py
+++ b/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py
@@ -292,3 +292,76 @@ def test_ovhcloud_with_custom_base_url():
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])
+
+
+class TestOVHCloudReasoningFieldMigration:
+    """Tests for OVHCloud reasoning_content -> reasoning field migration."""
+
+    def test_streaming_new_reasoning_field(self):
+        """New `reasoning` field should be mapped to `reasoning_content`."""
+        handler = OVHCloudChatCompletionStreamingHandler(
+            streaming_response=iter([]),
+                        sync_stream=True,
+        )
+        chunk = {
+            "id": "test-id",
+            "created": 1234567890,
+            "model": "test-model",
+            "choices": [
+                {
+                    "delta": {
+                        "role": "assistant",
+                        "reasoning": "Let me think...",
+                    },
+                    "index": 0,
+                }
+            ],
+        }
+        result = handler.chunk_parser(chunk)
+        assert result.choices[0]["delta"]["reasoning_content"] == "Let me think..."
+
+    def test_streaming_legacy_reasoning_content_unchanged(self):
+        """Legacy `reasoning_content` field should pass through untouched."""
+        handler = OVHCloudChatCompletionStreamingHandler(
+            streaming_response=iter([]),
+                        sync_stream=True,
+        )
+        chunk = {
+            "id": "test-id",
+            "created": 1234567890,
+            "model": "test-model",
+            "choices": [
+                {
+                    "delta": {
+                        "role": "assistant",
+                        "reasoning_content": "Already correct field.",
+                    },
+                    "index": 0,
+                }
+            ],
+        }
+        result = handler.chunk_parser(chunk)
+        assert result.choices[0]["delta"]["reasoning_content"] == "Already correct field."
+
+    def test_streaming_both_fields_legacy_wins(self):
+        """When both fields present, existing `reasoning_content` is not overwritten."""
+        handler = OVHCloudChatCompletionStreamingHandler(
+            streaming_response=iter([]),
+                        sync_stream=True,
+        )
+        chunk = {
+            "id": "test-id",
+            "created": 1234567890,
+            "model": "test-model",
+            "choices": [
+                {
+                    "delta": {
+                        "reasoning": "new field",
+                        "reasoning_content": "legacy field",
+                    },
+                    "index": 0,
+                }
+            ],
+        }
+        result = handler.chunk_parser(chunk)
+        assert result.choices[0]["delta"]["reasoning_content"] == "legacy field"
\ No newline at end of file

From e55e73d69b0be420a7092fcfa1159db2b7bd2d0e Mon Sep 17 00:00:00 2001
From: KunalG67 <kunalgarhewal13@gmail.com>
Date: Mon, 27 Apr 2026 17:37:27 +0530
Subject: [PATCH 02/20] fix(ovhcloud): use explicit None check for seconds
 field in STT response

Replaces falsy or with explicit is not None check so that a valid
seconds=0.0 value is not silently dropped during field migration.

Addresses Greptile review feedback on #26595
---
 .../audio_transcription/transformation.py       |  6 +++++-
 ...hcloud_audio_transcription_transformation.py | 17 ++++++++++++++++-
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/litellm/llms/ovhcloud/audio_transcription/transformation.py b/litellm/llms/ovhcloud/audio_transcription/transformation.py
index e3c8308d507..f49f31d7ecd 100644
--- a/litellm/llms/ovhcloud/audio_transcription/transformation.py
+++ b/litellm/llms/ovhcloud/audio_transcription/transformation.py
@@ -160,7 +160,11 @@ class OVHCloudAudioTranscriptionConfig(BaseAudioTranscriptionConfig):
         # `duration` is replaced by `seconds` in STT responses.
         # Prefer `seconds`, fall back to `duration`, normalize to `duration`
         # so downstream consumers see a consistent key.
-        duration = response_json.get("seconds") or response_json.get("duration")
+        duration = (
+            response_json["seconds"]
+            if "seconds" in response_json and response_json["seconds"] is not None
+            else response_json.get("duration")
+        )
         if duration is not None:
             response_json["duration"] = duration
 
diff --git a/tests/test_litellm/llms/ovhcloud/test_ovhcloud_audio_transcription_transformation.py b/tests/test_litellm/llms/ovhcloud/test_ovhcloud_audio_transcription_transformation.py
index e9abf50ba75..c8751fb2d95 100644
--- a/tests/test_litellm/llms/ovhcloud/test_ovhcloud_audio_transcription_transformation.py
+++ b/tests/test_litellm/llms/ovhcloud/test_ovhcloud_audio_transcription_transformation.py
@@ -96,4 +96,19 @@ class TestOVHCloudDurationFieldMigration:
         result = config.transform_audio_transcription_response(mock_response)
 
         assert result.text == "Hello world"
-        assert result._hidden_params["duration"] == 2.71
\ No newline at end of file
+        assert result._hidden_params["duration"] == 2.71
+
+
+
+    def test_seconds_zero_mapped_to_duration(self):
+        """seconds=0.0 must not be treated as falsy and lost."""
+        from litellm.llms.ovhcloud.audio_transcription.transformation import (
+            OVHCloudAudioTranscriptionConfig,
+        )
+        from unittest.mock import MagicMock
+
+        config = OVHCloudAudioTranscriptionConfig()
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"text": "silence", "seconds": 0.0}
+        result = config.transform_audio_transcription_response(mock_response)
+        assert result._hidden_params["duration"] == 0.0        
\ No newline at end of file

From c0da139540345e1319c5936435f611a6aa307c44 Mon Sep 17 00:00:00 2001
From: Aneesh-Fiddler <aneeshfiddler@gmail.com>
Date: Mon, 27 Apr 2026 22:51:39 +0530
Subject: [PATCH 03/20] fix(otel): populate gen_ai.output.messages and
 gen_ai.system_instructions for Responses API

Fixes #25840

The OTel integration's set_attributes() method never populates
gen_ai.output.messages, gen_ai.system_instructions, or
gen_ai.response.finish_reasons for /v1/responses calls because
ResponsesAPIResponse uses 'output' instead of 'choices' and the
system prompt arrives as 'instructions' instead of 'system_instructions'.

Changes:
- Add elif branch for response_obj.get('output') to extract response
  text from Responses API output items (type='message'/output_text)
  and tool calls (type='function_call')
- Coalesce system_instructions/instructions/system kwargs so the
  system prompt is captured for Responses API, Anthropic Messages
  API, and Vertex AI Gemini paths
- Handle plain-string system prompts without unnecessary wrapping
- Extract response_obj.get('status') as finish reason for Responses API
- Add _transform_responses_api_output_to_otel() method
---
 litellm/integrations/opentelemetry.py | 111 +++++++++++++++++++++++---
 1 file changed, 101 insertions(+), 10 deletions(-)

diff --git a/litellm/integrations/opentelemetry.py b/litellm/integrations/opentelemetry.py
index b6d91d0b76d..b26850657d3 100644
--- a/litellm/integrations/opentelemetry.py
+++ b/litellm/integrations/opentelemetry.py
@@ -1678,17 +1678,35 @@ class OpenTelemetry(CustomLogger):
                     value=safe_dumps(transformed_messages),
                 )
 
-            if kwargs.get("system_instructions"):
-                transformed_system_instructions = (
-                    self._transform_messages_to_otel_semantic_conventions(
-                        kwargs.get("system_instructions")
+            # Coalesce the different kwarg names that carry the system
+            # prompt depending on the call path:
+            #   - "system_instructions" — Vertex AI Gemini chat-completion
+            #   - "instructions"        — OpenAI Responses API
+            #   - "system"              — Anthropic Messages API
+            system_instructions = (
+                kwargs.get("system_instructions")
+                or kwargs.get("instructions")
+                or kwargs.get("system")
+            )
+            if system_instructions:
+                if isinstance(system_instructions, str):
+                    # Plain text system prompt — no transformation needed
+                    self.safe_set_attribute(
+                        span=span,
+                        key=SpanAttributes.GEN_AI_SYSTEM_INSTRUCTIONS.value,
+                        value=system_instructions,
+                    )
+                else:
+                    transformed_system_instructions = (
+                        self._transform_messages_to_otel_semantic_conventions(
+                            system_instructions
+                        )
+                    )
+                    self.safe_set_attribute(
+                        span=span,
+                        key=SpanAttributes.GEN_AI_SYSTEM_INSTRUCTIONS.value,
+                        value=safe_dumps(transformed_system_instructions),
                     )
-                )
-                self.safe_set_attribute(
-                    span=span,
-                    key=SpanAttributes.GEN_AI_SYSTEM_INSTRUCTIONS.value,
-                    value=safe_dumps(transformed_system_instructions),
-                )
 
             self.safe_set_attribute(
                 span=span,
@@ -1747,6 +1765,32 @@ class OpenTelemetry(CustomLogger):
                                         value=value,
                                     )
 
+                elif response_obj.get("output"):
+                    # Responses API: ResponsesAPIResponse has an "output"
+                    # list instead of "choices".  Each item with
+                    # type="message" contains a "content" list of
+                    # OutputText objects (type="output_text").
+                    output_messages = (
+                        self._transform_responses_api_output_to_otel(
+                            response_obj.get("output")
+                        )
+                    )
+                    if output_messages:
+                        self.safe_set_attribute(
+                            span=span,
+                            key=SpanAttributes.GEN_AI_OUTPUT_MESSAGES.value,
+                            value=safe_dumps(output_messages),
+                        )
+
+                    # Extract finish reason from ResponsesAPIResponse.status
+                    status = response_obj.get("status")
+                    if status:
+                        self.safe_set_attribute(
+                            span=span,
+                            key=SpanAttributes.GEN_AI_RESPONSE_FINISH_REASONS.value,
+                            value=safe_dumps([status]),
+                        )
+
         except Exception as e:
             self.handle_callback_failure(
                 callback_name=self.callback_name or "opentelemetry"
@@ -1842,6 +1886,53 @@ class OpenTelemetry(CustomLogger):
             transformed.append(transformed_msg)
         return transformed
 
+    def _transform_responses_api_output_to_otel(
+        self, output: List[dict]
+    ) -> List[dict]:
+        """
+        Transform Responses API output items into OTEL GenAI 1.38 format.
+
+        The Responses API returns output as a list of items, each with a
+        ``type`` field.  Message items (``type="message"``) contain a
+        ``content`` list of ``OutputText`` objects with ``type="output_text"``
+        and ``text`` fields.
+
+        This method converts them to the same ``{"role": ..., "parts": [...]}``
+        format used by ``_transform_choices_to_otel_semantic_conventions``.
+        """
+        transformed = []
+        for item in output:
+            if not isinstance(item, dict):
+                continue
+            if item.get("type") == "message":
+                role = item.get("role", "assistant")
+                parts = []
+                for content in item.get("content", []):
+                    if not isinstance(content, dict):
+                        continue
+                    if content.get("type") == "output_text":
+                        text = content.get("text", "")
+                        if text:
+                            parts.append({"type": "text", "content": text})
+                if parts:
+                    transformed.append({"role": role, "parts": parts})
+            elif item.get("type") == "function_call":
+                # Surface tool calls from Responses API output
+                tool_call = {
+                    "role": "assistant",
+                    "parts": [
+                        {
+                            "type": "tool_call",
+                            "name": item.get("name", ""),
+                            "arguments": item.get("arguments", ""),
+                        }
+                    ],
+                }
+                if item.get("call_id"):
+                    tool_call["parts"][0]["id"] = item["call_id"]
+                transformed.append(tool_call)
+        return transformed
+
     def set_raw_request_attributes(self, span: Span, kwargs, response_obj):
         try:
             # Only set provider-specific raw payload attributes on this span.

From 4d2e13c9070b74b0945613516e09917e15421023 Mon Sep 17 00:00:00 2001
From: Aneesh-Fiddler <aneeshfiddler@gmail.com>
Date: Mon, 27 Apr 2026 23:12:34 +0530
Subject: [PATCH 04/20] test(otel): add tests for Responses API output
 messages, system instructions, and finish reasons

Add 21 tests covering the new Responses API OTel attribute handling:

TestOpenTelemetryResponsesAPI (13 tests):
- gen_ai.output.messages from output items (text, function_call, mixed, multi-part)
- gen_ai.response.finish_reasons from ResponsesAPIResponse.status
- gen_ai.system_instructions from instructions/system/system_instructions kwargs
- Precedence and absence edge cases
- Regression test for existing choices-based responses

TestTransformResponsesAPIOutput (8 tests):
- Message with output_text, function_call items, unknown types
- Edge cases: empty output, empty text, missing call_id, default role, non-dict items
---
 .../integrations/test_opentelemetry.py        | 456 ++++++++++++++++++
 1 file changed, 456 insertions(+)

diff --git a/tests/test_litellm/integrations/test_opentelemetry.py b/tests/test_litellm/integrations/test_opentelemetry.py
index f7106471894..5f294005641 100644
--- a/tests/test_litellm/integrations/test_opentelemetry.py
+++ b/tests/test_litellm/integrations/test_opentelemetry.py
@@ -2859,3 +2859,459 @@ class TestResponseIdFallback(unittest.TestCase):
         otel.set_attributes(mock_span, kwargs, response_obj)
 
         mock_span.set_attribute.assert_any_call("litellm.call_id", call_id)
+
+
+
+class TestOpenTelemetryResponsesAPI(unittest.TestCase):
+    """
+    Tests for Responses API (/v1/responses) OTel span attributes.
+
+    The Responses API uses ``output`` (list of output items) instead of
+    ``choices``, ``instructions`` instead of ``system_instructions``, and
+    ``status`` instead of per-choice ``finish_reason``.
+
+    See: https://github.com/BerriAI/litellm/issues/25840
+    """
+
+    def _base_kwargs(self, **overrides):
+        """Return minimal kwargs for set_attributes with Responses API defaults."""
+        kwargs = {
+            "model": "gpt-4o",
+            "messages": [{"role": "user", "content": "What is 2+2?"}],
+            "optional_params": {},
+            "litellm_params": {"custom_llm_provider": "openai"},
+            "standard_logging_object": {
+                "id": "resp_abc123",
+                "call_type": "responses",
+                "metadata": {},
+            },
+        }
+        kwargs.update(overrides)
+        return kwargs
+
+    def _responses_api_response_obj(self, text="The answer is 4.", status="completed"):
+        """Return a dict mimicking ResponsesAPIResponse with a message output."""
+        return {
+            "id": "resp_abc123",
+            "model": "gpt-4o",
+            "status": status,
+            "output": [
+                {
+                    "type": "message",
+                    "role": "assistant",
+                    "content": [
+                        {
+                            "type": "output_text",
+                            "text": text,
+                        }
+                    ],
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 10,
+                "completion_tokens": 20,
+                "total_tokens": 30,
+            },
+        }
+
+    def _get_attr(self, mock_span, attr_name):
+        """Extract the value set for a specific attribute name, or None."""
+        calls = [
+            call
+            for call in mock_span.set_attribute.call_args_list
+            if call[0][0] == attr_name
+        ]
+        if not calls:
+            return None
+        return calls[0][0][1]
+
+    # ------------------------------------------------------------------
+    # gen_ai.output.messages
+    # ------------------------------------------------------------------
+
+    def test_output_messages_populated_for_responses_api(self):
+        """gen_ai.output.messages must be set when response has output items."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        kwargs = self._base_kwargs()
+        response_obj = self._responses_api_response_obj(text="The answer is 4.")
+
+        otel.set_attributes(span=mock_span, kwargs=kwargs, response_obj=response_obj)
+
+        raw = self._get_attr(mock_span, "gen_ai.output.messages")
+        self.assertIsNotNone(raw, "gen_ai.output.messages should be set")
+
+        parsed = json.loads(raw)
+        self.assertIsInstance(parsed, list)
+        self.assertEqual(len(parsed), 1)
+        self.assertEqual(parsed[0]["role"], "assistant")
+        self.assertIn("parts", parsed[0])
+        self.assertEqual(parsed[0]["parts"][0]["type"], "text")
+        self.assertEqual(parsed[0]["parts"][0]["content"], "The answer is 4.")
+
+    def test_output_messages_with_multiple_content_items(self):
+        """Multiple output_text items in a single message should all appear as parts."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        response_obj = {
+            "id": "resp_multi",
+            "model": "gpt-4o",
+            "status": "completed",
+            "output": [
+                {
+                    "type": "message",
+                    "role": "assistant",
+                    "content": [
+                        {"type": "output_text", "text": "First paragraph."},
+                        {"type": "output_text", "text": "Second paragraph."},
+                    ],
+                }
+            ],
+        }
+
+        otel.set_attributes(
+            span=mock_span, kwargs=self._base_kwargs(), response_obj=response_obj
+        )
+
+        raw = self._get_attr(mock_span, "gen_ai.output.messages")
+        parsed = json.loads(raw)
+        self.assertEqual(len(parsed[0]["parts"]), 2)
+        self.assertEqual(parsed[0]["parts"][0]["content"], "First paragraph.")
+        self.assertEqual(parsed[0]["parts"][1]["content"], "Second paragraph.")
+
+    def test_output_messages_with_function_call(self):
+        """function_call output items should appear as tool_call parts."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        response_obj = {
+            "id": "resp_fc",
+            "model": "gpt-4o",
+            "status": "completed",
+            "output": [
+                {
+                    "type": "function_call",
+                    "name": "get_weather",
+                    "call_id": "call_abc",
+                    "arguments": '{"location": "SF"}',
+                }
+            ],
+        }
+
+        otel.set_attributes(
+            span=mock_span, kwargs=self._base_kwargs(), response_obj=response_obj
+        )
+
+        raw = self._get_attr(mock_span, "gen_ai.output.messages")
+        parsed = json.loads(raw)
+        self.assertEqual(len(parsed), 1)
+        self.assertEqual(parsed[0]["role"], "assistant")
+        self.assertEqual(parsed[0]["parts"][0]["type"], "tool_call")
+        self.assertEqual(parsed[0]["parts"][0]["name"], "get_weather")
+        self.assertEqual(parsed[0]["parts"][0]["arguments"], '{"location": "SF"}')
+        self.assertEqual(parsed[0]["parts"][0]["id"], "call_abc")
+
+    def test_output_messages_mixed_message_and_function_call(self):
+        """Mixed output with both message and function_call items."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        response_obj = {
+            "id": "resp_mixed",
+            "model": "gpt-4o",
+            "status": "completed",
+            "output": [
+                {
+                    "type": "message",
+                    "role": "assistant",
+                    "content": [
+                        {"type": "output_text", "text": "Let me check the weather."},
+                    ],
+                },
+                {
+                    "type": "function_call",
+                    "name": "get_weather",
+                    "call_id": "call_xyz",
+                    "arguments": "{}",
+                },
+            ],
+        }
+
+        otel.set_attributes(
+            span=mock_span, kwargs=self._base_kwargs(), response_obj=response_obj
+        )
+
+        raw = self._get_attr(mock_span, "gen_ai.output.messages")
+        parsed = json.loads(raw)
+        self.assertEqual(len(parsed), 2)
+        self.assertEqual(parsed[0]["role"], "assistant")
+        self.assertEqual(parsed[0]["parts"][0]["content"], "Let me check the weather.")
+        self.assertEqual(parsed[1]["parts"][0]["type"], "tool_call")
+
+    def test_output_messages_empty_text_skipped(self):
+        """Output items with empty text should not produce parts."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        response_obj = {
+            "id": "resp_empty",
+            "model": "gpt-4o",
+            "status": "completed",
+            "output": [
+                {
+                    "type": "message",
+                    "role": "assistant",
+                    "content": [{"type": "output_text", "text": ""}],
+                }
+            ],
+        }
+
+        otel.set_attributes(
+            span=mock_span, kwargs=self._base_kwargs(), response_obj=response_obj
+        )
+
+        # No output messages should be set since the text is empty
+        raw = self._get_attr(mock_span, "gen_ai.output.messages")
+        self.assertIsNone(raw, "Empty output text should not produce gen_ai.output.messages")
+
+    def test_choices_still_work(self):
+        """Existing choices-based responses must still work (no regression)."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        kwargs = {
+            "model": "gpt-4",
+            "messages": [{"role": "user", "content": "Hello"}],
+            "optional_params": {},
+            "litellm_params": {"custom_llm_provider": "openai"},
+            "standard_logging_object": {
+                "id": "test-id",
+                "call_type": "completion",
+                "metadata": {},
+            },
+        }
+
+        response_obj = {
+            "id": "chatcmpl-123",
+            "model": "gpt-4",
+            "choices": [
+                {
+                    "finish_reason": "stop",
+                    "message": {"role": "assistant", "content": "Hi there!"},
+                }
+            ],
+            "usage": {"prompt_tokens": 5, "completion_tokens": 10, "total_tokens": 15},
+        }
+
+        otel.set_attributes(span=mock_span, kwargs=kwargs, response_obj=response_obj)
+
+        raw = self._get_attr(mock_span, "gen_ai.output.messages")
+        parsed = json.loads(raw)
+        self.assertEqual(parsed[0]["parts"][0]["content"], "Hi there!")
+        self.assertEqual(parsed[0]["finish_reason"], "stop")
+
+    # ------------------------------------------------------------------
+    # gen_ai.response.finish_reasons
+    # ------------------------------------------------------------------
+
+    def test_finish_reasons_from_status(self):
+        """gen_ai.response.finish_reasons should use ResponsesAPIResponse.status."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        otel.set_attributes(
+            span=mock_span,
+            kwargs=self._base_kwargs(),
+            response_obj=self._responses_api_response_obj(status="completed"),
+        )
+
+        raw = self._get_attr(mock_span, "gen_ai.response.finish_reasons")
+        self.assertIsNotNone(raw)
+        parsed = json.loads(raw)
+        self.assertEqual(parsed, ["completed"])
+
+    def test_finish_reasons_incomplete_status(self):
+        """Non-completed status values should still be captured."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        otel.set_attributes(
+            span=mock_span,
+            kwargs=self._base_kwargs(),
+            response_obj=self._responses_api_response_obj(status="incomplete"),
+        )
+
+        raw = self._get_attr(mock_span, "gen_ai.response.finish_reasons")
+        parsed = json.loads(raw)
+        self.assertEqual(parsed, ["incomplete"])
+
+    # ------------------------------------------------------------------
+    # gen_ai.system_instructions
+    # ------------------------------------------------------------------
+
+    def test_system_instructions_from_instructions_kwarg(self):
+        """Responses API passes system prompt as kwargs['instructions']."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        kwargs = self._base_kwargs(instructions="You are a math tutor.")
+        response_obj = self._responses_api_response_obj()
+
+        otel.set_attributes(span=mock_span, kwargs=kwargs, response_obj=response_obj)
+
+        value = self._get_attr(mock_span, "gen_ai.system_instructions")
+        self.assertEqual(value, "You are a math tutor.")
+
+    def test_system_instructions_from_system_kwarg(self):
+        """Anthropic Messages API passes system prompt as kwargs['system']."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        kwargs = self._base_kwargs(system="You are a helpful assistant.")
+        response_obj = self._responses_api_response_obj()
+
+        otel.set_attributes(span=mock_span, kwargs=kwargs, response_obj=response_obj)
+
+        value = self._get_attr(mock_span, "gen_ai.system_instructions")
+        self.assertEqual(value, "You are a helpful assistant.")
+
+    def test_system_instructions_from_system_instructions_kwarg(self):
+        """Vertex AI Gemini path uses kwargs['system_instructions'] (existing behavior)."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        kwargs = self._base_kwargs(
+            system_instructions=[{"role": "system", "content": "Be concise."}]
+        )
+        response_obj = self._responses_api_response_obj()
+
+        otel.set_attributes(span=mock_span, kwargs=kwargs, response_obj=response_obj)
+
+        raw = self._get_attr(mock_span, "gen_ai.system_instructions")
+        self.assertIsNotNone(raw)
+        parsed = json.loads(raw)
+        self.assertEqual(parsed[0]["role"], "system")
+        self.assertIn("parts", parsed[0])
+
+    def test_system_instructions_precedence(self):
+        """system_instructions takes precedence over instructions and system."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        kwargs = self._base_kwargs(
+            system_instructions="From Gemini",
+            instructions="From Responses API",
+            system="From Anthropic",
+        )
+        response_obj = self._responses_api_response_obj()
+
+        otel.set_attributes(span=mock_span, kwargs=kwargs, response_obj=response_obj)
+
+        # system_instructions (string) should win — it's checked first
+        value = self._get_attr(mock_span, "gen_ai.system_instructions")
+        self.assertEqual(value, "From Gemini")
+
+    def test_no_system_instructions_when_absent(self):
+        """No gen_ai.system_instructions attr when none of the kwargs are set."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        kwargs = self._base_kwargs()
+        response_obj = self._responses_api_response_obj()
+
+        otel.set_attributes(span=mock_span, kwargs=kwargs, response_obj=response_obj)
+
+        value = self._get_attr(mock_span, "gen_ai.system_instructions")
+        self.assertIsNone(value)
+
+
+class TestTransformResponsesAPIOutput(unittest.TestCase):
+    """
+    Unit tests for _transform_responses_api_output_to_otel.
+    """
+
+    def test_message_with_output_text(self):
+        otel = OpenTelemetry()
+        output = [
+            {
+                "type": "message",
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": "Hello!"}],
+            }
+        ]
+        result = otel._transform_responses_api_output_to_otel(output)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]["role"], "assistant")
+        self.assertEqual(result[0]["parts"], [{"type": "text", "content": "Hello!"}])
+
+    def test_function_call_item(self):
+        otel = OpenTelemetry()
+        output = [
+            {
+                "type": "function_call",
+                "name": "search",
+                "call_id": "call_1",
+                "arguments": '{"q": "test"}',
+            }
+        ]
+        result = otel._transform_responses_api_output_to_otel(output)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]["role"], "assistant")
+        self.assertEqual(result[0]["parts"][0]["type"], "tool_call")
+        self.assertEqual(result[0]["parts"][0]["name"], "search")
+        self.assertEqual(result[0]["parts"][0]["id"], "call_1")
+
+    def test_function_call_without_call_id(self):
+        otel = OpenTelemetry()
+        output = [
+            {
+                "type": "function_call",
+                "name": "search",
+                "arguments": "{}",
+            }
+        ]
+        result = otel._transform_responses_api_output_to_otel(output)
+        self.assertNotIn("id", result[0]["parts"][0])
+
+    def test_unknown_type_ignored(self):
+        otel = OpenTelemetry()
+        output = [{"type": "reasoning", "content": "thinking..."}]
+        result = otel._transform_responses_api_output_to_otel(output)
+        self.assertEqual(result, [])
+
+    def test_non_dict_items_ignored(self):
+        otel = OpenTelemetry()
+        output = ["not a dict", 42, None]
+        result = otel._transform_responses_api_output_to_otel(output)
+        self.assertEqual(result, [])
+
+    def test_empty_output(self):
+        otel = OpenTelemetry()
+        result = otel._transform_responses_api_output_to_otel([])
+        self.assertEqual(result, [])
+
+    def test_message_with_empty_text_skipped(self):
+        otel = OpenTelemetry()
+        output = [
+            {
+                "type": "message",
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": ""}],
+            }
+        ]
+        result = otel._transform_responses_api_output_to_otel(output)
+        self.assertEqual(result, [])
+
+    def test_message_default_role(self):
+        """Messages without explicit role should default to assistant."""
+        otel = OpenTelemetry()
+        output = [
+            {
+                "type": "message",
+                "content": [{"type": "output_text", "text": "Hi"}],
+            }
+        ]
+        result = otel._transform_responses_api_output_to_otel(output)
+        self.assertEqual(result[0]["role"], "assistant")

From e70b0c97a4c8d6aef4efd7d1738172acfe4510ea Mon Sep 17 00:00:00 2001
From: Aneesh-Fiddler <aneeshfiddler@gmail.com>
Date: Tue, 28 Apr 2026 11:26:14 +0530
Subject: [PATCH 05/20] style: apply black formatting to opentelemetry.py

---
 litellm/integrations/opentelemetry.py | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/litellm/integrations/opentelemetry.py b/litellm/integrations/opentelemetry.py
index b26850657d3..664aeadc7c2 100644
--- a/litellm/integrations/opentelemetry.py
+++ b/litellm/integrations/opentelemetry.py
@@ -1770,10 +1770,8 @@ class OpenTelemetry(CustomLogger):
                     # list instead of "choices".  Each item with
                     # type="message" contains a "content" list of
                     # OutputText objects (type="output_text").
-                    output_messages = (
-                        self._transform_responses_api_output_to_otel(
-                            response_obj.get("output")
-                        )
+                    output_messages = self._transform_responses_api_output_to_otel(
+                        response_obj.get("output")
                     )
                     if output_messages:
                         self.safe_set_attribute(
@@ -1886,9 +1884,7 @@ class OpenTelemetry(CustomLogger):
             transformed.append(transformed_msg)
         return transformed
 
-    def _transform_responses_api_output_to_otel(
-        self, output: List[dict]
-    ) -> List[dict]:
+    def _transform_responses_api_output_to_otel(self, output: List[dict]) -> List[dict]:
         """
         Transform Responses API output items into OTEL GenAI 1.38 format.
 

From c30d58f7e30a0568c265814d70cea2301bea51a4 Mon Sep 17 00:00:00 2001
From: Aneesh-Fiddler <aneeshfiddler@gmail.com>
Date: Tue, 28 Apr 2026 12:30:39 +0530
Subject: [PATCH 06/20] fix: resolve mypy indexed assignment error in
 function_call handling

Build the tool_call part dict separately with an explicit type
annotation so mypy can track the type, avoiding the
'Unsupported target for indexed assignment' error on
tool_call["parts"][0]["id"].
---
 litellm/integrations/opentelemetry.py | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/litellm/integrations/opentelemetry.py b/litellm/integrations/opentelemetry.py
index 664aeadc7c2..8084a9d0f22 100644
--- a/litellm/integrations/opentelemetry.py
+++ b/litellm/integrations/opentelemetry.py
@@ -1914,19 +1914,14 @@ class OpenTelemetry(CustomLogger):
                     transformed.append({"role": role, "parts": parts})
             elif item.get("type") == "function_call":
                 # Surface tool calls from Responses API output
-                tool_call = {
-                    "role": "assistant",
-                    "parts": [
-                        {
-                            "type": "tool_call",
-                            "name": item.get("name", ""),
-                            "arguments": item.get("arguments", ""),
-                        }
-                    ],
+                part: dict = {
+                    "type": "tool_call",
+                    "name": item.get("name", ""),
+                    "arguments": item.get("arguments", ""),
                 }
                 if item.get("call_id"):
-                    tool_call["parts"][0]["id"] = item["call_id"]
-                transformed.append(tool_call)
+                    part["id"] = item["call_id"]
+                transformed.append({"role": "assistant", "parts": [part]})
         return transformed
 
     def set_raw_request_attributes(self, span: Span, kwargs, response_obj):

From 466b4ddae31beb94635f72adc796d731b485930f Mon Sep 17 00:00:00 2001
From: Aneesh-Fiddler <aneeshfiddler@gmail.com>
Date: Tue, 28 Apr 2026 13:33:33 +0530
Subject: [PATCH 07/20] =?UTF-8?q?fix:=20address=20review=20comments=20?=
 =?UTF-8?q?=E2=80=94=20Pydantic=20compat,=20falsy=20fallthrough,=20per-too?=
 =?UTF-8?q?l-call=20attrs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Replace isinstance(item, dict) with hasattr(item, 'get') so Pydantic
  model instances (ResponseOutputMessage, ResponseFunctionToolCall) are
  accepted alongside plain dicts (P1)
- Use 'is not None' guards instead of or-chain for system_instructions
  coalescing to prevent falsy values (e.g. []) falling through to the
  wrong kwarg (P2)
- Emit per-tool-call span attributes (gen_ai.completion.N.function_call.*)
  for Responses API function_call items, matching the choices branch
  parity with _tool_calls_kv_pair (P2)
- Add 4 new tests: Pydantic-like objects, falsy fallthrough guard,
  per-tool-call attribute emission, multiple tool call indexing
---
 litellm/integrations/opentelemetry.py         |  62 ++++++-
 .../integrations/test_opentelemetry.py        | 171 ++++++++++++++++++
 2 files changed, 227 insertions(+), 6 deletions(-)

diff --git a/litellm/integrations/opentelemetry.py b/litellm/integrations/opentelemetry.py
index 8084a9d0f22..90e647d86bf 100644
--- a/litellm/integrations/opentelemetry.py
+++ b/litellm/integrations/opentelemetry.py
@@ -1683,10 +1683,16 @@ class OpenTelemetry(CustomLogger):
             #   - "system_instructions" — Vertex AI Gemini chat-completion
             #   - "instructions"        — OpenAI Responses API
             #   - "system"              — Anthropic Messages API
+            # Use `is not None` rather than truthiness to avoid falsy
+            # values (e.g. []) falling through to the wrong kwarg.
             system_instructions = (
                 kwargs.get("system_instructions")
-                or kwargs.get("instructions")
-                or kwargs.get("system")
+                if kwargs.get("system_instructions") is not None
+                else (
+                    kwargs.get("instructions")
+                    if kwargs.get("instructions") is not None
+                    else kwargs.get("system")
+                )
             )
             if system_instructions:
                 if isinstance(system_instructions, str):
@@ -1770,8 +1776,9 @@ class OpenTelemetry(CustomLogger):
                     # list instead of "choices".  Each item with
                     # type="message" contains a "content" list of
                     # OutputText objects (type="output_text").
+                    output_items = response_obj.get("output")
                     output_messages = self._transform_responses_api_output_to_otel(
-                        response_obj.get("output")
+                        output_items
                     )
                     if output_messages:
                         self.safe_set_attribute(
@@ -1780,6 +1787,43 @@ class OpenTelemetry(CustomLogger):
                             value=safe_dumps(output_messages),
                         )
 
+                    # Emit per-tool-call span attributes (parity with
+                    # the choices branch that calls _tool_calls_kv_pair).
+                    # Convert Responses API function_call items to the
+                    # ChatCompletionMessageToolCall format expected by
+                    # _tool_calls_kv_pair.
+                    tool_calls = []
+                    for out_item in output_items:
+                        if (
+                            hasattr(out_item, "get")
+                            and out_item.get("type") == "function_call"
+                        ):
+                            tool_calls.append(
+                                {
+                                    "function": {
+                                        "name": out_item.get("name", ""),
+                                        "arguments": out_item.get("arguments", ""),
+                                    }
+                                }
+                            )
+                    if tool_calls:
+                        kv_pairs = OpenTelemetry._tool_calls_kv_pair(tool_calls)  # type: ignore
+                        for key, value in kv_pairs.items():
+                            self.safe_set_attribute(
+                                span=span,
+                                key=key,
+                                value=value,
+                            )
+
+                    # Extract finish reason from ResponsesAPIResponse.status
+                    status = response_obj.get("status")
+                    if status:
+                        self.safe_set_attribute(
+                            span=span,
+                            key=SpanAttributes.GEN_AI_RESPONSE_FINISH_REASONS.value,
+                            value=safe_dumps([status]),
+                        )
+
                     # Extract finish reason from ResponsesAPIResponse.status
                     status = response_obj.get("status")
                     if status:
@@ -1884,7 +1928,7 @@ class OpenTelemetry(CustomLogger):
             transformed.append(transformed_msg)
         return transformed
 
-    def _transform_responses_api_output_to_otel(self, output: List[dict]) -> List[dict]:
+    def _transform_responses_api_output_to_otel(self, output: List) -> List[dict]:
         """
         Transform Responses API output items into OTEL GenAI 1.38 format.
 
@@ -1893,18 +1937,24 @@ class OpenTelemetry(CustomLogger):
         ``content`` list of ``OutputText`` objects with ``type="output_text"``
         and ``text`` fields.
 
+        Items may be plain dicts or Pydantic model instances (e.g.
+        ``ResponseOutputMessage``, ``ResponseFunctionToolCall``).  Both
+        expose a ``.get()`` method via ``BaseLiteLLMOpenAIResponseObject``,
+        so we use ``hasattr(item, "get")`` rather than ``isinstance(item,
+        dict)`` to accept either form.
+
         This method converts them to the same ``{"role": ..., "parts": [...]}``
         format used by ``_transform_choices_to_otel_semantic_conventions``.
         """
         transformed = []
         for item in output:
-            if not isinstance(item, dict):
+            if not hasattr(item, "get"):
                 continue
             if item.get("type") == "message":
                 role = item.get("role", "assistant")
                 parts = []
                 for content in item.get("content", []):
-                    if not isinstance(content, dict):
+                    if not hasattr(content, "get"):
                         continue
                     if content.get("type") == "output_text":
                         text = content.get("text", "")
diff --git a/tests/test_litellm/integrations/test_opentelemetry.py b/tests/test_litellm/integrations/test_opentelemetry.py
index 5f294005641..56aba4bc5ed 100644
--- a/tests/test_litellm/integrations/test_opentelemetry.py
+++ b/tests/test_litellm/integrations/test_opentelemetry.py
@@ -3315,3 +3315,174 @@ class TestTransformResponsesAPIOutput(unittest.TestCase):
         ]
         result = otel._transform_responses_api_output_to_otel(output)
         self.assertEqual(result[0]["role"], "assistant")
+
+
+    def test_pydantic_like_objects_accepted(self):
+        """Items with .get() but not isinstance(dict) should be accepted."""
+
+        class FakeOutputItem:
+            """Mimics BaseLiteLLMOpenAIResponseObject duck-typing."""
+
+            def __init__(self, data):
+                self._data = data
+
+            def get(self, key, default=None):
+                return self._data.get(key, default)
+
+        class FakeContent:
+            def __init__(self, data):
+                self._data = data
+
+            def get(self, key, default=None):
+                return self._data.get(key, default)
+
+        otel = OpenTelemetry()
+        output = [
+            FakeOutputItem(
+                {
+                    "type": "message",
+                    "role": "assistant",
+                    "content": [
+                        FakeContent({"type": "output_text", "text": "Pydantic works!"}),
+                    ],
+                }
+            )
+        ]
+        result = otel._transform_responses_api_output_to_otel(output)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]["parts"][0]["content"], "Pydantic works!")
+
+
+class TestSystemInstructionsPrecedence(unittest.TestCase):
+    """Tests for the is-not-None precedence in system_instructions coalescing."""
+
+    def _get_attr(self, mock_span, attr_name):
+        calls = [
+            call
+            for call in mock_span.set_attribute.call_args_list
+            if call[0][0] == attr_name
+        ]
+        if not calls:
+            return None
+        return calls[0][0][1]
+
+    def _base_kwargs(self, **overrides):
+        kwargs = {
+            "model": "gpt-4o",
+            "messages": [{"role": "user", "content": "Hi"}],
+            "optional_params": {},
+            "litellm_params": {"custom_llm_provider": "openai"},
+            "standard_logging_object": {
+                "id": "test-id",
+                "call_type": "responses",
+                "metadata": {},
+            },
+        }
+        kwargs.update(overrides)
+        return kwargs
+
+    def test_empty_list_system_instructions_does_not_fallthrough(self):
+        """An empty list for system_instructions should NOT fall through to instructions."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        kwargs = self._base_kwargs(
+            system_instructions=[],
+            instructions="Should not be used",
+        )
+        response_obj = {"id": "r1", "model": "gpt-4o"}
+
+        otel.set_attributes(span=mock_span, kwargs=kwargs, response_obj=response_obj)
+
+        # system_instructions is [] (falsy but not None), so it wins.
+        # Since it's an empty list, no attribute should be set (nothing to transform).
+        value = self._get_attr(mock_span, "gen_ai.system_instructions")
+        # The empty list is truthy for `is not None` but produces empty
+        # transformed output — the attribute should NOT contain "Should not be used".
+        if value is not None:
+            self.assertNotIn("Should not be used", str(value))
+
+
+class TestResponsesAPIToolCallSpanAttributes(unittest.TestCase):
+    """Tests for per-tool-call span attributes on Responses API function_call items."""
+
+    def _base_kwargs(self):
+        return {
+            "model": "gpt-4o",
+            "messages": [{"role": "user", "content": "What is the weather?"}],
+            "optional_params": {},
+            "litellm_params": {"custom_llm_provider": "openai"},
+            "standard_logging_object": {
+                "id": "resp_tc",
+                "call_type": "responses",
+                "metadata": {},
+            },
+        }
+
+    def test_per_tool_call_attributes_emitted(self):
+        """function_call output items should produce per-tool-call span attributes."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        response_obj = {
+            "id": "resp_tc",
+            "model": "gpt-4o",
+            "status": "completed",
+            "output": [
+                {
+                    "type": "function_call",
+                    "name": "get_weather",
+                    "call_id": "call_abc",
+                    "arguments": '{"location": "SF"}',
+                }
+            ],
+        }
+
+        otel.set_attributes(span=mock_span, kwargs=self._base_kwargs(), response_obj=response_obj)
+
+        # Verify per-tool-call attributes were set (same format as choices branch)
+        attr_names = [call[0][0] for call in mock_span.set_attribute.call_args_list]
+        tool_call_attrs = [a for a in attr_names if "function_call" in a]
+        self.assertTrue(len(tool_call_attrs) > 0, "Per-tool-call span attributes should be emitted")
+
+        # Verify the name attribute specifically
+        mock_span.set_attribute.assert_any_call(
+            "gen_ai.completion.0.function_call.name", "get_weather"
+        )
+        mock_span.set_attribute.assert_any_call(
+            "gen_ai.completion.0.function_call.arguments", '{"location": "SF"}'
+        )
+
+    def test_multiple_tool_calls_indexed(self):
+        """Multiple function_call items should be indexed correctly."""
+        otel = OpenTelemetry()
+        mock_span = MagicMock()
+
+        response_obj = {
+            "id": "resp_tc2",
+            "model": "gpt-4o",
+            "status": "completed",
+            "output": [
+                {
+                    "type": "function_call",
+                    "name": "get_weather",
+                    "call_id": "call_1",
+                    "arguments": "{}",
+                },
+                {
+                    "type": "function_call",
+                    "name": "get_time",
+                    "call_id": "call_2",
+                    "arguments": "{}",
+                },
+            ],
+        }
+
+        otel.set_attributes(span=mock_span, kwargs=self._base_kwargs(), response_obj=response_obj)
+
+        mock_span.set_attribute.assert_any_call(
+            "gen_ai.completion.0.function_call.name", "get_weather"
+        )
+        mock_span.set_attribute.assert_any_call(
+            "gen_ai.completion.1.function_call.name", "get_time"
+        )

From 982fed46321041c4bc46d02312aa731d6662bd88 Mon Sep 17 00:00:00 2001
From: KunalG67 <kunalgarhewal13@gmail.com>
Date: Tue, 28 Apr 2026 18:09:12 +0530
Subject: [PATCH 08/20] fix(ovhcloud): handle reasoning field migration in
 non-streaming responses

Adds transform_response to OVHCloudChatConfig to normalise the new

easoning field to 
easoning_content in non-streaming responses,
matching the existing streaming fix in chunk_parser.

Addresses maintainer feedback on #26595
---
 litellm/llms/ovhcloud/chat/transformation.py  | 50 ++++++++++++++++--
 .../test_ovhcloud_chat_transformation.py      | 52 ++++++++++++++++++-
 2 files changed, 97 insertions(+), 5 deletions(-)

diff --git a/litellm/llms/ovhcloud/chat/transformation.py b/litellm/llms/ovhcloud/chat/transformation.py
index 4100c548f2c..77d3683566c 100644
--- a/litellm/llms/ovhcloud/chat/transformation.py
+++ b/litellm/llms/ovhcloud/chat/transformation.py
@@ -5,17 +5,17 @@ Our unified API follows the OpenAI standard.
 More information on our website: https://endpoints.ai.cloud.ovh.net
 """
 
-from typing import Optional, Union, List
+from typing import Any, Optional, Union, List
 
 import httpx
-from litellm.utils import ModelResponseStream
+from litellm.utils import ModelResponse, ModelResponseStream
 from litellm.llms.openai.chat.gpt_transformation import OpenAIGPTConfig
 from litellm.llms.ovhcloud.utils import OVHCloudException
 from litellm.llms.base_llm.base_model_iterator import BaseModelResponseIterator
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
+from litellm.llms.base_llm.chat.transformation import LiteLLMLoggingObj
 from litellm.types.llms.openai import AllMessageValues
 
-
 class OVHCloudChatConfig(OpenAIGPTConfig):
     @property
     def custom_llm_provider(self) -> Optional[str]:
@@ -75,6 +75,50 @@ class OVHCloudChatConfig(OpenAIGPTConfig):
         return response
 
 
+    def transform_response(
+        self,
+        model: str,
+        raw_response: httpx.Response,
+        model_response: ModelResponse,
+        logging_obj: LiteLLMLoggingObj,
+        request_data: dict,
+        messages: List[AllMessageValues],
+        optional_params: dict,
+        litellm_params: dict,
+        encoding: Any,
+        api_key: Optional[str] = None,
+        json_mode: Optional[bool] = None,
+    ) -> ModelResponse:
+        # Call parent to do standard OpenAI response parsing
+        model_response = super().transform_response(
+            model=model,
+            raw_response=raw_response,
+            model_response=model_response,
+            logging_obj=logging_obj,
+            request_data=request_data,
+            messages=messages,
+            optional_params=optional_params,
+            litellm_params=litellm_params,
+            encoding=encoding,
+            api_key=api_key,
+            json_mode=json_mode,
+        )
+
+        # OVHCloud field migration (deadline: 2026-05-11):
+        # `reasoning_content` is replaced by `reasoning` in non-streaming responses.
+        # Normalise to `reasoning_content` so downstream consumers
+        # see a consistent key during the transition window.
+        for choice in model_response.choices:
+            message = getattr(choice, "message", None)
+            if message is not None:
+                reasoning_new = getattr(message, "reasoning", None)
+                reasoning_legacy = getattr(message, "reasoning_content", None)
+                if reasoning_new is not None and reasoning_legacy is None:
+                    message.reasoning_content = reasoning_new
+
+        return model_response        
+
+
 class OVHCloudChatCompletionStreamingHandler(BaseModelResponseIterator):
     """
     Handler for OVHCloud AI Endpoints streaming chat completion responses
diff --git a/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py b/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py
index 88ce3b4c296..b112f6d87f1 100644
--- a/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py
+++ b/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py
@@ -4,7 +4,7 @@ Unit tests for OVHCloud AI Endpoints chat integration.
 
 import os
 import sys
-
+import litellm
 import pytest
 
 from litellm.llms.ovhcloud.utils import OVHCloudException
@@ -364,4 +364,52 @@ class TestOVHCloudReasoningFieldMigration:
             ],
         }
         result = handler.chunk_parser(chunk)
-        assert result.choices[0]["delta"]["reasoning_content"] == "legacy field"
\ No newline at end of file
+        assert result.choices[0]["delta"]["reasoning_content"] == "legacy field"
+
+
+    def test_non_streaming_new_reasoning_field(self):
+            """Non-streaming: new `reasoning` field should be mapped to `reasoning_content`."""
+            from unittest.mock import MagicMock, patch
+            import json
+
+            config = OVHCloudChatConfig()
+
+            raw_response = MagicMock()
+            raw_response.status_code = 200
+            raw_response.headers = {"Content-Type": "application/json"}
+            raw_response.text = json.dumps({
+                "id": "test-id",
+                "object": "chat.completion",
+                "created": 1234567890,
+                "model": "test-model",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": "Hello!",
+                            "reasoning": "Let me think...",
+                        },
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
+            })
+            raw_response.json.return_value = json.loads(raw_response.text)
+
+            model_response = litellm.ModelResponse()
+
+            result = config.transform_response(
+                model="ovhcloud/test-model",
+                raw_response=raw_response,
+                model_response=model_response,
+                logging_obj=MagicMock(),
+                request_data={},
+                messages=[],
+                optional_params={},
+                litellm_params={},
+                encoding=None,
+                api_key="test-key",
+            )
+
+            assert result.choices[0].message.reasoning_content == "Let me think..."        
\ No newline at end of file

From 8f48d880da974e349deb63a47363a12c618a5301 Mon Sep 17 00:00:00 2001
From: KunalG67 <kunalgarhewal13@gmail.com>
Date: Tue, 28 Apr 2026 18:25:11 +0530
Subject: [PATCH 09/20] style: apply black formatting to ovhcloud chat
 transformation

---
 litellm/llms/ovhcloud/chat/transformation.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/litellm/llms/ovhcloud/chat/transformation.py b/litellm/llms/ovhcloud/chat/transformation.py
index 77d3683566c..b5752d16309 100644
--- a/litellm/llms/ovhcloud/chat/transformation.py
+++ b/litellm/llms/ovhcloud/chat/transformation.py
@@ -16,6 +16,7 @@ from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.base_llm.chat.transformation import LiteLLMLoggingObj
 from litellm.types.llms.openai import AllMessageValues
 
+
 class OVHCloudChatConfig(OpenAIGPTConfig):
     @property
     def custom_llm_provider(self) -> Optional[str]:
@@ -74,7 +75,6 @@ class OVHCloudChatConfig(OpenAIGPTConfig):
         response.update(extra_body)
         return response
 
-
     def transform_response(
         self,
         model: str,
@@ -116,7 +116,7 @@ class OVHCloudChatConfig(OpenAIGPTConfig):
                 if reasoning_new is not None and reasoning_legacy is None:
                     message.reasoning_content = reasoning_new
 
-        return model_response        
+        return model_response
 
 
 class OVHCloudChatCompletionStreamingHandler(BaseModelResponseIterator):

From 9928618788389e623aa0c57b9249d084bfe72482 Mon Sep 17 00:00:00 2001
From: Aneesh-Fiddler <aneeshfiddler@gmail.com>
Date: Tue, 28 Apr 2026 19:58:58 +0530
Subject: [PATCH 10/20] fix: remove duplicate gen_ai.response.finish_reasons
 block

---
 litellm/integrations/opentelemetry.py | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/litellm/integrations/opentelemetry.py b/litellm/integrations/opentelemetry.py
index 90e647d86bf..d116fc44658 100644
--- a/litellm/integrations/opentelemetry.py
+++ b/litellm/integrations/opentelemetry.py
@@ -1824,15 +1824,6 @@ class OpenTelemetry(CustomLogger):
                             value=safe_dumps([status]),
                         )
 
-                    # Extract finish reason from ResponsesAPIResponse.status
-                    status = response_obj.get("status")
-                    if status:
-                        self.safe_set_attribute(
-                            span=span,
-                            key=SpanAttributes.GEN_AI_RESPONSE_FINISH_REASONS.value,
-                            value=safe_dumps([status]),
-                        )
-
         except Exception as e:
             self.handle_callback_failure(
                 callback_name=self.callback_name or "opentelemetry"

From 90bcd232c37389397cdcb763737f150899f1f722 Mon Sep 17 00:00:00 2001
From: KunalG67 <kunalgarhewal13@gmail.com>
Date: Tue, 28 Apr 2026 23:09:17 +0530
Subject: [PATCH 11/20] fix(ovhcloud): remove dead transform_response override

The parent OpenAIGPTConfig already handles reasoning->reasoning_content
for non-streaming via _extract_reasoning_content. The override was dead
code giving false confidence. Streaming fix in chunk_parser is the only
change needed for chat completions.

Addresses Agent Shin review feedback on #26595
---
 litellm/llms/ovhcloud/chat/transformation.py  | 47 ++----------------
 .../test_ovhcloud_chat_transformation.py      | 48 +------------------
 2 files changed, 4 insertions(+), 91 deletions(-)

diff --git a/litellm/llms/ovhcloud/chat/transformation.py b/litellm/llms/ovhcloud/chat/transformation.py
index b5752d16309..140cb855323 100644
--- a/litellm/llms/ovhcloud/chat/transformation.py
+++ b/litellm/llms/ovhcloud/chat/transformation.py
@@ -5,15 +5,15 @@ Our unified API follows the OpenAI standard.
 More information on our website: https://endpoints.ai.cloud.ovh.net
 """
 
-from typing import Any, Optional, Union, List
+from typing import Optional, Union, List
 
 import httpx
-from litellm.utils import ModelResponse, ModelResponseStream
+from litellm.utils import ModelResponseStream
 from litellm.llms.openai.chat.gpt_transformation import OpenAIGPTConfig
 from litellm.llms.ovhcloud.utils import OVHCloudException
 from litellm.llms.base_llm.base_model_iterator import BaseModelResponseIterator
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
-from litellm.llms.base_llm.chat.transformation import LiteLLMLoggingObj
+
 from litellm.types.llms.openai import AllMessageValues
 
 
@@ -75,48 +75,7 @@ class OVHCloudChatConfig(OpenAIGPTConfig):
         response.update(extra_body)
         return response
 
-    def transform_response(
-        self,
-        model: str,
-        raw_response: httpx.Response,
-        model_response: ModelResponse,
-        logging_obj: LiteLLMLoggingObj,
-        request_data: dict,
-        messages: List[AllMessageValues],
-        optional_params: dict,
-        litellm_params: dict,
-        encoding: Any,
-        api_key: Optional[str] = None,
-        json_mode: Optional[bool] = None,
-    ) -> ModelResponse:
-        # Call parent to do standard OpenAI response parsing
-        model_response = super().transform_response(
-            model=model,
-            raw_response=raw_response,
-            model_response=model_response,
-            logging_obj=logging_obj,
-            request_data=request_data,
-            messages=messages,
-            optional_params=optional_params,
-            litellm_params=litellm_params,
-            encoding=encoding,
-            api_key=api_key,
-            json_mode=json_mode,
-        )
 
-        # OVHCloud field migration (deadline: 2026-05-11):
-        # `reasoning_content` is replaced by `reasoning` in non-streaming responses.
-        # Normalise to `reasoning_content` so downstream consumers
-        # see a consistent key during the transition window.
-        for choice in model_response.choices:
-            message = getattr(choice, "message", None)
-            if message is not None:
-                reasoning_new = getattr(message, "reasoning", None)
-                reasoning_legacy = getattr(message, "reasoning_content", None)
-                if reasoning_new is not None and reasoning_legacy is None:
-                    message.reasoning_content = reasoning_new
-
-        return model_response
 
 
 class OVHCloudChatCompletionStreamingHandler(BaseModelResponseIterator):
diff --git a/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py b/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py
index b112f6d87f1..40d57c76d02 100644
--- a/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py
+++ b/tests/test_litellm/llms/ovhcloud/test_ovhcloud_chat_transformation.py
@@ -4,7 +4,7 @@ Unit tests for OVHCloud AI Endpoints chat integration.
 
 import os
 import sys
-import litellm
+
 import pytest
 
 from litellm.llms.ovhcloud.utils import OVHCloudException
@@ -367,49 +367,3 @@ class TestOVHCloudReasoningFieldMigration:
         assert result.choices[0]["delta"]["reasoning_content"] == "legacy field"
 
 
-    def test_non_streaming_new_reasoning_field(self):
-            """Non-streaming: new `reasoning` field should be mapped to `reasoning_content`."""
-            from unittest.mock import MagicMock, patch
-            import json
-
-            config = OVHCloudChatConfig()
-
-            raw_response = MagicMock()
-            raw_response.status_code = 200
-            raw_response.headers = {"Content-Type": "application/json"}
-            raw_response.text = json.dumps({
-                "id": "test-id",
-                "object": "chat.completion",
-                "created": 1234567890,
-                "model": "test-model",
-                "choices": [
-                    {
-                        "index": 0,
-                        "message": {
-                            "role": "assistant",
-                            "content": "Hello!",
-                            "reasoning": "Let me think...",
-                        },
-                        "finish_reason": "stop",
-                    }
-                ],
-                "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
-            })
-            raw_response.json.return_value = json.loads(raw_response.text)
-
-            model_response = litellm.ModelResponse()
-
-            result = config.transform_response(
-                model="ovhcloud/test-model",
-                raw_response=raw_response,
-                model_response=model_response,
-                logging_obj=MagicMock(),
-                request_data={},
-                messages=[],
-                optional_params={},
-                litellm_params={},
-                encoding=None,
-                api_key="test-key",
-            )
-
-            assert result.choices[0].message.reasoning_content == "Let me think..."        
\ No newline at end of file

From d73e24c1f93664dc147ce8ef2c5a2ffcef6f9eb7 Mon Sep 17 00:00:00 2001
From: KunalG67 <kunalgarhewal13@gmail.com>
Date: Tue, 28 Apr 2026 23:19:13 +0530
Subject: [PATCH 12/20] fix(ovhcloud): remove dead transform_response override,
 parent already handles non-streaming via _extract_reasoning_content

---
 litellm/llms/ovhcloud/chat/transformation.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/litellm/llms/ovhcloud/chat/transformation.py b/litellm/llms/ovhcloud/chat/transformation.py
index 140cb855323..62f51f1e9da 100644
--- a/litellm/llms/ovhcloud/chat/transformation.py
+++ b/litellm/llms/ovhcloud/chat/transformation.py
@@ -76,8 +76,6 @@ class OVHCloudChatConfig(OpenAIGPTConfig):
         return response
 
 
-
-
 class OVHCloudChatCompletionStreamingHandler(BaseModelResponseIterator):
     """
     Handler for OVHCloud AI Endpoints streaming chat completion responses

From 53102529ca6e817cd398f23bcc0bd63501c9f169 Mon Sep 17 00:00:00 2001
From: Aneesh-Fiddler <aneeshfiddler@gmail.com>
Date: Wed, 29 Apr 2026 19:00:43 +0530
Subject: [PATCH 13/20] ci: retrigger checks after retargeting to
 litellm_oss_staging_04_27_2026


From c319a19c25d746dbcfd27ab3c69984f5d66eb358 Mon Sep 17 00:00:00 2001
From: Aneesh-Fiddler <aneeshfiddler@gmail.com>
Date: Thu, 30 Apr 2026 11:04:08 +0530
Subject: [PATCH 14/20] fix: handle raw Pydantic v2 models from openai SDK in
 output transformation

The openai SDK returns ResponseOutputMessage and ResponseOutputText as
raw Pydantic v2 models that lack .get() (unlike LiteLLM's own wrapper
objects). Add a _to_dict() helper that normalizes plain dicts,
BaseLiteLLMOpenAIResponseObject (has .get()), and raw Pydantic models
(has .model_dump()) into a consistent dict interface.
---
 litellm/integrations/opentelemetry.py | 54 +++++++++++++++++++--------
 1 file changed, 39 insertions(+), 15 deletions(-)

diff --git a/litellm/integrations/opentelemetry.py b/litellm/integrations/opentelemetry.py
index d116fc44658..a12d67de4b4 100644
--- a/litellm/integrations/opentelemetry.py
+++ b/litellm/integrations/opentelemetry.py
@@ -1794,15 +1794,13 @@ class OpenTelemetry(CustomLogger):
                     # _tool_calls_kv_pair.
                     tool_calls = []
                     for out_item in output_items:
-                        if (
-                            hasattr(out_item, "get")
-                            and out_item.get("type") == "function_call"
-                        ):
+                        item_d = self._to_dict(out_item)
+                        if item_d and item_d.get("type") == "function_call":
                             tool_calls.append(
                                 {
                                     "function": {
-                                        "name": out_item.get("name", ""),
-                                        "arguments": out_item.get("arguments", ""),
+                                        "name": item_d.get("name", ""),
+                                        "arguments": item_d.get("arguments", ""),
                                     }
                                 }
                             )
@@ -1919,6 +1917,31 @@ class OpenTelemetry(CustomLogger):
             transformed.append(transformed_msg)
         return transformed
 
+    @staticmethod
+    def _to_dict(obj) -> Optional[dict]:
+        """Normalize an object to a plain dict.
+
+        Handles three forms that appear in practice:
+
+        1. Plain ``dict`` — returned as-is.
+        2. LiteLLM's ``BaseLiteLLMOpenAIResponseObject`` — exposes a
+           ``.get()`` method that delegates to ``__dict__``.
+        3. Raw Pydantic v2 models from the ``openai`` SDK (e.g.
+           ``ResponseOutputMessage``, ``ResponseOutputText``) — these do
+           **not** have ``.get()`` but do have ``.model_dump()``.
+
+        Returns ``None`` for anything else so callers can skip it.
+        """
+        if isinstance(obj, dict):
+            return obj
+        if hasattr(obj, "get"):
+            # BaseLiteLLMOpenAIResponseObject duck-type
+            return obj  # type: ignore[return-value]
+        if hasattr(obj, "model_dump"):
+            # Raw Pydantic v2 model (e.g. openai SDK types)
+            return obj.model_dump()  # type: ignore[union-attr]
+        return None
+
     def _transform_responses_api_output_to_otel(self, output: List) -> List[dict]:
         """
         Transform Responses API output items into OTEL GenAI 1.38 format.
@@ -1928,24 +1951,25 @@ class OpenTelemetry(CustomLogger):
         ``content`` list of ``OutputText`` objects with ``type="output_text"``
         and ``text`` fields.
 
-        Items may be plain dicts or Pydantic model instances (e.g.
-        ``ResponseOutputMessage``, ``ResponseFunctionToolCall``).  Both
-        expose a ``.get()`` method via ``BaseLiteLLMOpenAIResponseObject``,
-        so we use ``hasattr(item, "get")`` rather than ``isinstance(item,
-        dict)`` to accept either form.
+        Items may be plain dicts, LiteLLM wrapper objects (with ``.get()``),
+        or raw Pydantic v2 models from the ``openai`` SDK (with
+        ``.model_dump()``).  We normalize each item to a dict via
+        ``_to_dict`` before processing.
 
         This method converts them to the same ``{"role": ..., "parts": [...]}``
         format used by ``_transform_choices_to_otel_semantic_conventions``.
         """
         transformed = []
-        for item in output:
-            if not hasattr(item, "get"):
+        for raw_item in output:
+            item = self._to_dict(raw_item)
+            if item is None:
                 continue
             if item.get("type") == "message":
                 role = item.get("role", "assistant")
                 parts = []
-                for content in item.get("content", []):
-                    if not hasattr(content, "get"):
+                for raw_content in item.get("content", []):
+                    content = self._to_dict(raw_content)
+                    if content is None:
                         continue
                     if content.get("type") == "output_text":
                         text = content.get("text", "")

From 209bd0b9061f7b602d148f8d6da6ffddc2014c87 Mon Sep 17 00:00:00 2001
From: pnookala-godaddy <pnookala@godaddy.com>
Date: Tue, 5 May 2026 12:18:44 -0700
Subject: [PATCH 15/20] fix(proxy): sort spend updates to prevent DB deadlocks

Iterate user/key/team/team_member/org/end_user/tag spend dicts in sorted
order inside each Prisma transaction so concurrent pods acquire row locks
in the same order, avoiding PostgreSQL deadlocks under load.
---
 litellm/proxy/db/db_spend_update_writer.py    |  48 +++---
 litellm/proxy/utils.py                        |   8 +-
 .../proxy/db/test_db_spend_update_writer.py   | 143 ++++++++++++++++++
 3 files changed, 174 insertions(+), 25 deletions(-)

diff --git a/litellm/proxy/db/db_spend_update_writer.py b/litellm/proxy/db/db_spend_update_writer.py
index c06e1850d9f..418fc2d2f02 100644
--- a/litellm/proxy/db/db_spend_update_writer.py
+++ b/litellm/proxy/db/db_spend_update_writer.py
@@ -1133,10 +1133,12 @@ class DBSpendUpdateWriter:
                         timeout=timedelta(seconds=60)
                     ) as transaction:
                         async with transaction.batch_() as batcher:
-                            for (
-                                user_id,
-                                response_cost,
-                            ) in user_list_transactions.items():
+                            # Sort by ID for consistent lock ordering across pods to prevent deadlocks.
+                            # batch_() issues statements sequentially within the tx, so iteration
+                            # order = lock acquisition order.
+                            for user_id, response_cost in sorted(
+                                user_list_transactions.items()
+                            ):
                                 batcher.litellm_usertable.update_many(
                                     where={"user_id": user_id},
                                     data={"spend": {"increment": response_cost}},
@@ -1188,10 +1190,10 @@ class DBSpendUpdateWriter:
                         timeout=timedelta(seconds=60)
                     ) as transaction:
                         async with transaction.batch_() as batcher:
-                            for (
-                                token,
-                                response_cost,
-                            ) in key_list_transactions.items():
+                            # Sort by token for consistent lock ordering across pods to prevent deadlocks.
+                            for token, response_cost in sorted(
+                                key_list_transactions.items()
+                            ):
                                 batcher.litellm_verificationtoken.update_many(  # 'update_many' prevents error from being raised if no row exists
                                     where={"token": token},
                                     data={
@@ -1232,10 +1234,10 @@ class DBSpendUpdateWriter:
                         timeout=timedelta(seconds=60)
                     ) as transaction:
                         async with transaction.batch_() as batcher:
-                            for (
-                                team_id,
-                                response_cost,
-                            ) in team_list_transactions.items():
+                            # Sort by team_id for consistent lock ordering across pods to prevent deadlocks.
+                            for team_id, response_cost in sorted(
+                                team_list_transactions.items()
+                            ):
                                 verbose_proxy_logger.debug(
                                     "Updating spend for team id={} by {}".format(
                                         team_id, response_cost
@@ -1290,10 +1292,11 @@ class DBSpendUpdateWriter:
                         timeout=timedelta(seconds=60)
                     ) as transaction:
                         async with transaction.batch_() as batcher:
-                            for (
-                                key,
-                                response_cost,
-                            ) in team_member_list_transactions.items():
+                            # Sort by composite key for consistent lock ordering across pods to prevent deadlocks.
+                            # Key format "team_id::<v>::user_id::<v>" makes the string sort equivalent to sorting by (team_id, user_id).
+                            for key, response_cost in sorted(
+                                team_member_list_transactions.items()
+                            ):
                                 # key is "team_id::<value>::user_id::<value>"
                                 team_id = key.split("::")[1]
                                 user_id = key.split("::")[3]
@@ -1350,10 +1353,10 @@ class DBSpendUpdateWriter:
                         timeout=timedelta(seconds=60)
                     ) as transaction:
                         async with transaction.batch_() as batcher:
-                            for (
-                                org_id,
-                                response_cost,
-                            ) in org_list_transactions.items():
+                            # Sort by org_id for consistent lock ordering across pods to prevent deadlocks.
+                            for org_id, response_cost in sorted(
+                                org_list_transactions.items()
+                            ):
                                 batcher.litellm_organizationtable.update_many(  # 'update_many' prevents error from being raised if no row exists
                                     where={"organization_id": org_id},
                                     data={"spend": {"increment": response_cost}},
@@ -1441,7 +1444,10 @@ class DBSpendUpdateWriter:
                         timeout=timedelta(seconds=60)
                     ) as transaction:
                         async with transaction.batch_() as batcher:
-                            for entity_id, response_cost in transactions.items():
+                            # Sort by entity_id for consistent lock ordering across pods to prevent deadlocks.
+                            for entity_id, response_cost in sorted(
+                                transactions.items()
+                            ):
                                 verbose_proxy_logger.debug(
                                     f"Updating spend for {entity_name} {where_field}={entity_id} by {response_cost}"
                                 )
diff --git a/litellm/proxy/utils.py b/litellm/proxy/utils.py
index d2dfa177515..800a4be37a8 100644
--- a/litellm/proxy/utils.py
+++ b/litellm/proxy/utils.py
@@ -4874,10 +4874,10 @@ class ProxyUpdateSpend:
                     timeout=timedelta(seconds=60)
                 ) as transaction:
                     async with transaction.batch_() as batcher:
-                        for (
-                            end_user_id,
-                            response_cost,
-                        ) in end_user_list_transactions.items():
+                        # Sort by end_user_id for consistent lock ordering across pods to prevent deadlocks.
+                        for end_user_id, response_cost in sorted(
+                            end_user_list_transactions.items()
+                        ):
                             if litellm.max_end_user_budget is not None:
                                 pass
                             batcher.litellm_endusertable.upsert(
diff --git a/tests/test_litellm/proxy/db/test_db_spend_update_writer.py b/tests/test_litellm/proxy/db/test_db_spend_update_writer.py
index 4d584349342..9d4d3c4a560 100644
--- a/tests/test_litellm/proxy/db/test_db_spend_update_writer.py
+++ b/tests/test_litellm/proxy/db/test_db_spend_update_writer.py
@@ -1508,3 +1508,146 @@ async def test_commit_spend_updates_uses_pipeline():
     mock_redis_update_buffer.get_all_daily_end_user_spend_update_transactions_from_redis_buffer.assert_not_called()
     mock_redis_update_buffer.get_all_daily_agent_spend_update_transactions_from_redis_buffer.assert_not_called()
     mock_redis_update_buffer.get_all_daily_tag_spend_update_transactions_from_redis_buffer.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    "bucket_name,input_dict,table_attr,method_name,where_key,expected_order",
+    [
+        pytest.param(
+            "user_list_transactions",
+            {"user_c": 0.1, "user_a": 0.2, "user_b": 0.3},
+            "litellm_usertable",
+            "update_many",
+            "user_id",
+            ["user_a", "user_b", "user_c"],
+            id="user",
+        ),
+        pytest.param(
+            "key_list_transactions",
+            {"tok_c": 0.1, "tok_a": 0.2, "tok_b": 0.3},
+            "litellm_verificationtoken",
+            "update_many",
+            "token",
+            ["tok_a", "tok_b", "tok_c"],
+            id="key",
+        ),
+        pytest.param(
+            "team_list_transactions",
+            {"team_c": 0.1, "team_a": 0.2, "team_b": 0.3},
+            "litellm_teamtable",
+            "update_many",
+            "team_id",
+            ["team_a", "team_b", "team_c"],
+            id="team",
+        ),
+        pytest.param(
+            "team_member_list_transactions",
+            {
+                "team_id::team_c::user_id::user_x": 0.1,
+                "team_id::team_a::user_id::user_x": 0.2,
+                "team_id::team_b::user_id::user_x": 0.3,
+            },
+            "litellm_teammembership",
+            "update_many",
+            "team_id",
+            ["team_a", "team_b", "team_c"],
+            id="team_member",
+        ),
+        pytest.param(
+            "org_list_transactions",
+            {"org_c": 0.1, "org_a": 0.2, "org_b": 0.3},
+            "litellm_organizationtable",
+            "update_many",
+            "organization_id",
+            ["org_a", "org_b", "org_c"],
+            id="org",
+        ),
+        pytest.param(
+            "end_user_list_transactions",
+            {"eu_c": 0.1, "eu_a": 0.2, "eu_b": 0.3},
+            "litellm_endusertable",
+            "upsert",
+            "user_id",
+            ["eu_a", "eu_b", "eu_c"],
+            id="end_user",
+        ),
+        pytest.param(
+            "tag_list_transactions",
+            {"prod": 0.1, "customer-x": 0.2, "test": 0.3},
+            "litellm_tagtable",
+            "update_many",
+            "tag_name",
+            ["customer-x", "prod", "test"],
+            id="tag",
+        ),
+        pytest.param(
+            "agent_list_transactions",
+            {"agent_c": 0.1, "agent_a": 0.2, "agent_b": 0.3},
+            "litellm_agentstable",
+            "update_many",
+            "agent_id",
+            ["agent_a", "agent_b", "agent_c"],
+            id="agent",
+        ),
+    ],
+)
+@pytest.mark.asyncio
+async def test_commit_spend_updates_iterates_in_sorted_order(
+    bucket_name, input_dict, table_attr, method_name, where_key, expected_order
+):
+    """
+    Every spend-bucket code path in _commit_spend_updates_to_db must iterate
+    in sorted order so concurrent pods acquire row locks in the same order
+    and avoid PostgreSQL deadlocks. Covers the 5 direct loops (user/key/team/
+    team_member/org), the end_user path in ProxyUpdateSpend.update_end_user_spend,
+    and the shared _update_entity_spend_in_db helper (tag, agent).
+    """
+    db_writer = DBSpendUpdateWriter()
+
+    captured_where_values = []
+
+    def capture(*, where, data):
+        captured_where_values.append(where[where_key])
+
+    mock_batcher = MagicMock()
+    table_mock = MagicMock()
+    setattr(table_mock, method_name, MagicMock(side_effect=capture))
+    setattr(mock_batcher, table_attr, table_mock)
+
+    mock_transaction = AsyncMock()
+    mock_transaction.__aenter__ = AsyncMock(return_value=mock_transaction)
+    mock_transaction.__aexit__ = AsyncMock(return_value=False)
+    mock_transaction.batch_ = MagicMock(
+        return_value=AsyncMock(
+            __aenter__=AsyncMock(return_value=mock_batcher),
+            __aexit__=AsyncMock(return_value=False),
+        )
+    )
+
+    mock_prisma_client = MagicMock()
+    mock_prisma_client.db = MagicMock()
+    mock_prisma_client.db.tx = MagicMock(return_value=mock_transaction)
+
+    mock_proxy_logging = MagicMock()
+    mock_proxy_logging.call_details = {}
+
+    buckets = {
+        "user_list_transactions": {},
+        "end_user_list_transactions": {},
+        "key_list_transactions": {},
+        "team_list_transactions": {},
+        "team_member_list_transactions": {},
+        "org_list_transactions": {},
+        "tag_list_transactions": {},
+        "agent_list_transactions": {},
+    }
+    buckets[bucket_name] = input_dict
+
+    await db_writer._commit_spend_updates_to_db(
+        prisma_client=mock_prisma_client,
+        n_retry_times=3,
+        proxy_logging_obj=mock_proxy_logging,
+        db_spend_update_transactions=buckets,
+    )
+
+    assert captured_where_values == expected_order

From 2993e45ad18e7508d7f4a262608006bc787082c5 Mon Sep 17 00:00:00 2001
From: Michael Riad Zaky <michaelr@Mac.localdomain>
Date: Tue, 5 May 2026 11:37:12 -0700
Subject: [PATCH 16/20] allow non-admin roles on /compliance/* read routes

---
 litellm/proxy/_types.py                       | 10 +++++-
 .../proxy/auth/test_route_checks.py           | 33 +++++++++++++++++++
 2 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/litellm/proxy/_types.py b/litellm/proxy/_types.py
index c6653a722d6..7a049dcc5de 100644
--- a/litellm/proxy/_types.py
+++ b/litellm/proxy/_types.py
@@ -656,6 +656,13 @@ class LiteLLMRoutes(enum.Enum):
         "/health/services",
     ] + info_routes
 
+    # Stateless validators on caller-supplied log data; source logs are
+    # already accessible via spend_tracking_routes, so no scope expansion.
+    compliance_check_routes = [
+        "/compliance/eu-ai-act",
+        "/compliance/gdpr",
+    ]
+
     # Routes in `global_spend_tracking_routes` return proxy-wide spend across
     # every team, customer, and api_key. They are intentionally NOT included
     # here — non-admin roles must not see other tenants' spend. Admin roles go
@@ -675,9 +682,10 @@ class LiteLLMRoutes(enum.Enum):
         ]
         + spend_tracking_routes
         + key_management_routes
+        + compliance_check_routes
     )
 
-    internal_user_view_only_routes = spend_tracking_routes
+    internal_user_view_only_routes = spend_tracking_routes + compliance_check_routes
 
     self_managed_routes = [
         "/team/member_add",
diff --git a/tests/test_litellm/proxy/auth/test_route_checks.py b/tests/test_litellm/proxy/auth/test_route_checks.py
index cf6feabf85f..3e0b1b739ec 100644
--- a/tests/test_litellm/proxy/auth/test_route_checks.py
+++ b/tests/test_litellm/proxy/auth/test_route_checks.py
@@ -53,6 +53,39 @@ def test_non_admin_config_update_route_rejected():
     assert "Your role=internal_user" in str(exc_info.value)
 
 
+@pytest.mark.parametrize(
+    "role",
+    [
+        LitellmUserRoles.INTERNAL_USER.value,
+        LitellmUserRoles.INTERNAL_USER_VIEW_ONLY.value,
+    ],
+)
+@pytest.mark.parametrize(
+    "route",
+    ["/compliance/eu-ai-act", "/compliance/gdpr"],
+)
+def test_compliance_routes_open_to_non_admin_roles(role, route):
+    """Compliance routes are stateless validators on caller-supplied log data
+    — both non-admin internal_user roles can call them."""
+    user_obj = LiteLLM_UserTable(
+        user_id="test_user",
+        user_email="test@example.com",
+        user_role=role,
+    )
+    valid_token = UserAPIKeyAuth(user_id="test_user", user_role=role)
+    request = MagicMock(spec=Request)
+    request.query_params = {}
+
+    RouteChecks.non_proxy_admin_allowed_routes_check(
+        user_obj=user_obj,
+        _user_role=role,
+        route=route,
+        request=request,
+        valid_token=valid_token,
+        request_data={},
+    )
+
+
 def test_proxy_admin_viewer_config_update_route_rejected():
     """Test that proxy admin viewer users are rejected when trying to call /config/update"""
 

From 85d4d96c1bf1d823b1c66d5464768d568302b3f0 Mon Sep 17 00:00:00 2001
From: michelligabriele <gabriele.michelli@icloud.com>
Date: Wed, 6 May 2026 00:28:42 +0200
Subject: [PATCH 17/20] fix(proxy): preserve HTTP operations when injecting
 WebSocket stubs into OpenAPI schema

---
 litellm/proxy/proxy_server.py                 |  88 ++++++++------
 .../proxy/test_openapi_schema_validation.py   | 107 ++++++++++++++++++
 2 files changed, 158 insertions(+), 37 deletions(-)

diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py
index a5905765c6e..b136464fd2d 100644
--- a/litellm/proxy/proxy_server.py
+++ b/litellm/proxy/proxy_server.py
@@ -1057,6 +1057,52 @@ vertex_live_passthrough_vertex_base = VertexBase()
 from fastapi.routing import APIWebSocketRoute
 
 
+def _inject_websocket_stubs_into_openapi_schema(
+    openapi_schema: dict, websocket_routes: list
+) -> dict:
+    """
+    Add a synthetic GET stub for each WebSocket route so it appears in Swagger UI.
+
+    Merges into any existing path entry rather than replacing it — a WebSocket route
+    that shares its path with an HTTP route must not erase the HTTP operation. If
+    a "get" operation is already documented on the path, the WebSocket stub is
+    skipped to preserve the real GET.
+    """
+    for route in websocket_routes:
+        base_path = route.path.split("{")[0].rstrip("?")
+
+        parameters = []
+        try:
+            if hasattr(route, "dependant") and route.dependant is not None:
+                # Handle both FastAPI <0.120 and >=0.120
+                query_params = getattr(route.dependant, "query_params", [])
+                if query_params:
+                    for param in query_params:
+                        parameters.append(
+                            {
+                                "name": param.name,
+                                "in": "query",
+                                "required": param.required,
+                                "schema": {"type": "string"},
+                            }
+                        )
+        except (AttributeError, TypeError):
+            pass
+
+        path_entry = openapi_schema["paths"].setdefault(base_path, {})
+        if "get" not in path_entry:
+            path_entry["get"] = {
+                "summary": f"WebSocket: {route.name or base_path}",
+                "description": "WebSocket connection endpoint",
+                "operationId": f"websocket_{route.name or base_path.replace('/', '_')}",
+                "parameters": parameters,
+                "responses": {"101": {"description": "WebSocket Protocol Switched"}},
+                "tags": ["WebSocket"],
+            }
+
+    return openapi_schema
+
+
 def get_openapi_schema():
     if app.openapi_schema:
         return app.openapi_schema
@@ -1079,43 +1125,11 @@ def get_openapi_schema():
         route for route in app.routes if isinstance(route, APIWebSocketRoute)
     ]
 
-    # Add each WebSocket route to the schema
-    for route in websocket_routes:
-        # Get the base path without query parameters
-        base_path = route.path.split("{")[0].rstrip("?")
-
-        # Extract parameters from the route
-        parameters = []
-        try:
-            if hasattr(route, "dependant") and route.dependant is not None:
-                # Handle both FastAPI <0.120 and >=0.120
-                query_params = getattr(route.dependant, "query_params", [])
-                if query_params:
-                    for param in query_params:
-                        parameters.append(
-                            {
-                                "name": param.name,
-                                "in": "query",
-                                "required": param.required,
-                                "schema": {
-                                    "type": "string"
-                                },  # You can make this more specific if needed
-                            }
-                        )
-        except (AttributeError, TypeError):
-            # If we can't access query_params, continue without them
-            pass
-
-        openapi_schema["paths"][base_path] = {
-            "get": {
-                "summary": f"WebSocket: {route.name or base_path}",
-                "description": "WebSocket connection endpoint",
-                "operationId": f"websocket_{route.name or base_path.replace('/', '_')}",
-                "parameters": parameters,
-                "responses": {"101": {"description": "WebSocket Protocol Switched"}},
-                "tags": ["WebSocket"],
-            }
-        }
+    # Add a synthetic GET stub for each so they render in Swagger UI,
+    # without clobbering existing HTTP operations on the same path.
+    openapi_schema = _inject_websocket_stubs_into_openapi_schema(
+        openapi_schema, websocket_routes
+    )
 
     # Add LLM API request schema bodies for documentation
     from litellm.proxy.common_utils.custom_openapi_spec import CustomOpenAPISpec
diff --git a/tests/test_litellm/proxy/test_openapi_schema_validation.py b/tests/test_litellm/proxy/test_openapi_schema_validation.py
index 68d537b2593..b44edc8a3bc 100644
--- a/tests/test_litellm/proxy/test_openapi_schema_validation.py
+++ b/tests/test_litellm/proxy/test_openapi_schema_validation.py
@@ -140,3 +140,110 @@ class TestCredentialEndpointsOpenAPISchema:
         assert (
             "credential_name" in sig.parameters
         ), "get_credential_by_name must have a credential_name parameter"
+
+
+class TestWebSocketStubInjection:
+    """
+    Regression test for the v1.82.3 bug where adding a WebSocket route on a path
+    that already had an HTTP route silently dropped the HTTP operation from the
+    OpenAPI schema.
+
+    Related case: 2026-05-05-madhu-swagger-responses-missing
+    """
+
+    def _make_fake_ws_route(self, path: str, name: str = "fake_ws"):
+        """Minimal stand-in for fastapi.routing.APIWebSocketRoute for the helper's purposes."""
+        from types import SimpleNamespace
+
+        return SimpleNamespace(path=path, name=name, dependant=None)
+
+    def test_websocket_stub_does_not_clobber_existing_post(self):
+        """
+        When a WebSocket route shares its path with an existing POST operation,
+        the POST must survive — the WebSocket stub is added alongside, not on top.
+        """
+        from litellm.proxy.proxy_server import (
+            _inject_websocket_stubs_into_openapi_schema,
+        )
+
+        schema = {
+            "paths": {
+                "/v1/responses": {
+                    "post": {"summary": "responses_api", "operationId": "responses_api"}
+                }
+            }
+        }
+        ws_routes = [self._make_fake_ws_route("/v1/responses", name="responses_ws")]
+
+        result = _inject_websocket_stubs_into_openapi_schema(schema, ws_routes)
+
+        assert (
+            "post" in result["paths"]["/v1/responses"]
+        ), "POST operation must be preserved when a WebSocket route shares the path"
+        assert (
+            result["paths"]["/v1/responses"]["post"]["operationId"] == "responses_api"
+        )
+        assert (
+            "get" in result["paths"]["/v1/responses"]
+        ), "WebSocket stub should also be added under 'get'"
+        assert result["paths"]["/v1/responses"]["get"]["tags"] == ["WebSocket"]
+
+    def test_websocket_stub_added_when_path_is_new(self):
+        """
+        When a WebSocket route's path is not already in the schema, the stub
+        creates a fresh entry — preserving the original behavior for WebSocket-only
+        paths.
+        """
+        from litellm.proxy.proxy_server import (
+            _inject_websocket_stubs_into_openapi_schema,
+        )
+
+        schema = {"paths": {}}
+        ws_routes = [self._make_fake_ws_route("/ws_only", name="ws_only")]
+
+        result = _inject_websocket_stubs_into_openapi_schema(schema, ws_routes)
+
+        assert "/ws_only" in result["paths"]
+        assert "get" in result["paths"]["/ws_only"]
+        assert result["paths"]["/ws_only"]["get"]["tags"] == ["WebSocket"]
+
+    def test_websocket_stub_skipped_when_existing_get(self):
+        """
+        If a real GET is already documented on the path, the WebSocket stub is
+        skipped — a real operation always wins over the synthetic stub. This
+        closes the same trap for future GET-vs-WebSocket collisions.
+        """
+        from litellm.proxy.proxy_server import (
+            _inject_websocket_stubs_into_openapi_schema,
+        )
+
+        schema = {
+            "paths": {
+                "/health": {
+                    "get": {"summary": "health_check", "operationId": "real_get"}
+                }
+            }
+        }
+        ws_routes = [self._make_fake_ws_route("/health", name="health_ws")]
+
+        result = _inject_websocket_stubs_into_openapi_schema(schema, ws_routes)
+
+        assert (
+            result["paths"]["/health"]["get"]["operationId"] == "real_get"
+        ), "Real GET must take precedence over WebSocket stub"
+
+    def test_responses_post_routes_registered_on_router(self):
+        """
+        Sanity check: the three POST routes for the responses API are still wired
+        on the responses router. Guards against accidental removal at the source.
+        """
+        from litellm.proxy.response_api_endpoints.endpoints import router
+
+        post_paths = {
+            route.path
+            for route in router.routes
+            if hasattr(route, "methods")
+            and "POST" in (route.methods or set())
+            and route.path in {"/v1/responses", "/responses", "/openai/v1/responses"}
+        }
+        assert post_paths == {"/v1/responses", "/responses", "/openai/v1/responses"}

From 062b5b31fb0d7e9f7cce989d22bf0c0561c83ea9 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Wed, 6 May 2026 00:26:17 +0000
Subject: [PATCH 18/20] Add main module header comment

Co-authored-by: ishaan-berri <ishaan-berri@users.noreply.github.com>
---
 .evidence/main_header_repro.png               | Bin 0 -> 61972 bytes
 litellm/main.py                               |   2 ++
 tests/test_litellm/test_main_module_header.py |  13 +++++++++++++
 3 files changed, 15 insertions(+)
 create mode 100644 .evidence/main_header_repro.png
 create mode 100644 tests/test_litellm/test_main_module_header.py

diff --git a/.evidence/main_header_repro.png b/.evidence/main_header_repro.png
new file mode 100644
index 0000000000000000000000000000000000000000..d71ab04d02a56b3ad8f2e8015bf53ca13f8cd8d3
GIT binary patch
literal 61972
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

literal 0
HcmV?d00001

diff --git a/litellm/main.py b/litellm/main.py
index 0553cf9d422..66d69e9fb52 100644
--- a/litellm/main.py
+++ b/litellm/main.py
@@ -1,3 +1,5 @@
+# LiteLLM main module: public completion, embedding, streaming, and moderation entrypoints.
+#
 # +-----------------------------------------------+
 # |                                               |
 # |           Give Feedback / Get Help            |
diff --git a/tests/test_litellm/test_main_module_header.py b/tests/test_litellm/test_main_module_header.py
new file mode 100644
index 00000000000..a16e14e8c32
--- /dev/null
+++ b/tests/test_litellm/test_main_module_header.py
@@ -0,0 +1,13 @@
+from pathlib import Path
+
+
+def test_main_py_starts_with_brief_file_description():
+    repo_root = Path(__file__).resolve().parents[2]
+    main_py = repo_root / "litellm" / "main.py"
+
+    first_two_lines = main_py.read_text(encoding="utf-8").splitlines()[:2]
+
+    assert any(
+        "LiteLLM main module" in line and "entrypoints" in line
+        for line in first_two_lines
+    )

From b631863b13abe81c8de78a0787f3520d52427215 Mon Sep 17 00:00:00 2001
From: oss-agent-shin <279349115+oss-agent-shin@users.noreply.github.com>
Date: Wed, 6 May 2026 00:42:49 +0000
Subject: [PATCH 19/20] Add utils module docstring

Co-authored-by: ishaan-berri <ishaan-berri@users.noreply.github.com>
---
 litellm/utils.py                                  |  2 ++
 tests/test_litellm/test_utils_module_docstring.py | 11 +++++++++++
 2 files changed, 13 insertions(+)
 create mode 100644 tests/test_litellm/test_utils_module_docstring.py

diff --git a/litellm/utils.py b/litellm/utils.py
index 019fbc2add8..5589852ce41 100644
--- a/litellm/utils.py
+++ b/litellm/utils.py
@@ -1,3 +1,5 @@
+"""Utility helpers for LiteLLM core request handling and provider support."""
+
 # from __future__ import annotations must be the first non-comment statement
 from __future__ import annotations
 
diff --git a/tests/test_litellm/test_utils_module_docstring.py b/tests/test_litellm/test_utils_module_docstring.py
new file mode 100644
index 00000000000..ac99fb63fd4
--- /dev/null
+++ b/tests/test_litellm/test_utils_module_docstring.py
@@ -0,0 +1,11 @@
+import ast
+from pathlib import Path
+
+
+def test_utils_module_has_docstring():
+    utils_path = Path(__file__).parents[2] / "litellm" / "utils.py"
+    module = ast.parse(utils_path.read_text())
+
+    assert ast.get_docstring(module) == (
+        "Utility helpers for LiteLLM core request handling and provider support."
+    )

From 99218c6fa0326deb0ff7c1a8ee84f00cd693c7c0 Mon Sep 17 00:00:00 2001
From: Sameer Kankute <sameer@berri.ai>
Date: Mon, 11 May 2026 09:49:47 +0530
Subject: [PATCH 20/20] Fix deprecated model test

---
 tests/llm_translation/test_openrouter.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/llm_translation/test_openrouter.py b/tests/llm_translation/test_openrouter.py
index 631b0770e3d..8fbb8803d11 100644
--- a/tests/llm_translation/test_openrouter.py
+++ b/tests/llm_translation/test_openrouter.py
@@ -11,7 +11,7 @@ import litellm
 def test_completion_openrouter_reasoning_content():
     litellm._turn_on_debug()
     resp = litellm.completion(
-        model="openrouter/anthropic/claude-3.7-sonnet",
+        model="openrouter/anthropic/claude-sonnet-4",
         messages=[{"role": "user", "content": "Hello world"}],
         reasoning={"effort": "high"},
     )