From cec0fc3e8e0b4ab2ef510ecce3a80f2ef08ba1d0 Mon Sep 17 00:00:00 2001 From: agustin18 Date: Thu, 24 Sep 2026 02:52:52 +0000 Subject: [PATCH 1/5] fix(responses): normalize overlong tool call IDs in chat-to-responses bridge --- .../transformation.py | 39 ++++- ...responses_transformation_transformation.py | 139 ++++++++++++++++++ 2 files changed, 172 insertions(+), 6 deletions(-) diff --git a/litellm/completion_extras/litellm_responses_transformation/transformation.py b/litellm/completion_extras/litellm_responses_transformation/transformation.py index 31af5a144eb..05c0b796633 100644 --- a/litellm/completion_extras/litellm_responses_transformation/transformation.py +++ b/litellm/completion_extras/litellm_responses_transformation/transformation.py @@ -2,6 +2,7 @@ Handler for transforming /chat/completions api requests to litellm.responses requests """ +import hashlib import json import os from collections.abc import AsyncIterator, Callable, Iterable, Iterator, Mapping, Sequence @@ -357,19 +358,42 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): # Unknown or unsupported type return None, index + @staticmethod + def _normalize_tool_call_id(tool_call_id: object) -> str | None: + """Normalize tool call ID to ensure it does not exceed 64 characters. + + Responses API downstream providers (e.g. OpenAI Responses API, AWS Bedrock) + enforce a 64-character limit on ``call_id``. IDs within the limit are preserved + verbatim. Overlong IDs are deterministically mapped to the first 31 characters + of the ID followed by '_' and a 32-character SHA-256 digest of the full ID + (31 + 1 + 32 = 64 characters), preserving readability and guaranteeing collision resistance. + """ + if tool_call_id is None: + return None + tool_call_id_str: Final = str(tool_call_id) + if len(tool_call_id_str) <= 64: + return tool_call_id_str + prefix: Final = tool_call_id_str[:31] + digest: Final = hashlib.sha256(tool_call_id_str.encode("utf-8")).hexdigest()[:32] + return f"{prefix}_{digest}" + def convert_chat_completion_messages_to_responses_api( self, messages: list["AllMessageValues"] ) -> tuple[list[object], str | None]: input_items: Final[list[object]] = [] instructions: str | None = None custom_tool_call_ids: Final = frozenset( - tool_call["id"] + ident for msg in messages if msg.get("role") == "assistant" and isinstance(msg.get("tool_calls"), list) for tool_call in msg.get("tool_calls") or () if isinstance(tool_call, dict) and not tool_call.get("function") and isinstance(tool_call.get("custom"), dict) + for raw_id in (tool_call.get("id"),) + if raw_id is not None + for ident in (raw_id, self._normalize_tool_call_id(raw_id)) + if ident is not None ) leading_system_count: Final = next( @@ -421,11 +445,12 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): else: # Fallback: convert unexpected types to input_text tool_output = [{"type": "input_text", "text": str(content)}] - if tool_call_id in custom_tool_call_ids: + normalized_tool_call_id: Final = self._normalize_tool_call_id(tool_call_id) + if tool_call_id in custom_tool_call_ids or normalized_tool_call_id in custom_tool_call_ids: input_items.append( ResponseCustomToolCallOutputParam( type="custom_tool_call_output", - call_id=tool_call_id, + call_id=normalized_tool_call_id or "", output=content if isinstance(content, str) else tool_output, ) ) @@ -433,7 +458,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): input_items.append( FunctionCallOutput( type="function_call_output", - call_id=tool_call_id, + call_id=normalized_tool_call_id, output=tool_output, ) ) @@ -450,10 +475,12 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): for tool_call in tool_calls: function = tool_call.get("function") custom = tool_call.get("custom") + raw_id: Final = tool_call.get("id") + normalized_call_id: Final = self._normalize_tool_call_id(raw_id) if function: input_tool_call: dict[str, object] = { "type": "function_call", - "call_id": tool_call["id"], + "call_id": normalized_call_id, } if "name" in function: input_tool_call["name"] = function["name"] @@ -464,7 +491,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): input_items.append( ResponseCustomToolCallParam( type="custom_tool_call", - call_id=tool_call["id"], + call_id=normalized_call_id or "", name=custom.get("name", ""), input=custom.get("input", ""), ) diff --git a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py index d0f9bad795d..4f428340926 100644 --- a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py +++ b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py @@ -4352,3 +4352,142 @@ def test_map_optional_params_verbosity_merges_into_text(): verbosity_only_request, ) assert verbosity_only_request["text"] == {"verbosity": "low"} + + +@pytest.mark.parametrize( + "tool_call_id,is_custom", + [ + # Short tool call ID: stays unchanged + ("call_short_123", False), + # Exactly 64 characters: boundary case, stays unchanged + ("call_" + "a" * 59, False), + # Overlong tool call ID (65 characters): normalized to <= 64 chars + ("call_" + "a" * 60, False), + # Overlong tool call ID from issue #42765 (85 characters): normalized to 64 chars + ( + "call_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + False, + ), + # Custom tool call with overlong ID: normalized to <= 64 chars + ( + "custom_tool_call_id_exceeding_the_standard_responses_api_sixty_four_character_length_limit", + True, + ), + ], +) +def test_convert_chat_completion_messages_to_responses_api_normalizes_overlong_tool_call_ids( + tool_call_id: str, + is_custom: bool, +): + """ + Overlong tool call IDs (> 64 chars) must be deterministically normalized to <= 64 characters + consistently across assistant tool_calls and matching tool result messages, + while IDs <= 64 chars must be preserved unchanged. + """ + import hashlib + from litellm.completion_extras.litellm_responses_transformation.transformation import ( + LiteLLMResponsesTransformationHandler, + ) + + expected_id: Final = ( + tool_call_id + if len(tool_call_id) <= 64 + else f"{tool_call_id[:31]}_{hashlib.sha256(tool_call_id.encode('utf-8')).hexdigest()[:32]}" + ) + + handler: Final = LiteLLMResponsesTransformationHandler() + assistant_tool_call: Final[dict[str, object]] = ( + { + "id": tool_call_id, + "type": "custom", + "custom": {"name": "example_custom_tool", "input": "{}"}, + } + if is_custom + else { + "id": tool_call_id, + "type": "function", + "function": {"name": "example_tool", "arguments": "{}"}, + } + ) + + messages: Final[list[dict[str, object]]] = [ + {"role": "user", "content": "Run tool"}, + { + "role": "assistant", + "tool_calls": [assistant_tool_call], + }, + { + "role": "tool", + "tool_call_id": tool_call_id, + "content": "tool execution result", + }, + ] + + input_items, _ = handler.convert_chat_completion_messages_to_responses_api(messages) + + # Validate tool call item + if is_custom: + tool_call_item: Final = next( + item for item in input_items if isinstance(item, dict) and item.get("type") == "custom_tool_call" + ) + call_id: Final = tool_call_item.get("call_id") + else: + func_tool_call_item: Final = next( + item for item in input_items if isinstance(item, dict) and item.get("type") == "function_call" + ) + call_id = func_tool_call_item.get("call_id") + + assert call_id == expected_id + assert len(str(call_id)) <= 64 + + # Validate matching tool output item + if is_custom: + custom_output_item: Final = next( + item for item in input_items if isinstance(item, dict) and item.get("type") == "custom_tool_call_output" + ) + output_call_id: Final = custom_output_item.get("call_id") + else: + func_output_item: Final = next( + item for item in input_items if isinstance(item, dict) and item.get("type") == "function_call_output" + ) + output_call_id = func_output_item.get("call_id") + + assert output_call_id == expected_id + assert output_call_id == call_id + + +def test_convert_chat_completion_messages_to_responses_api_overlong_collision_resistance(): + """Two distinct overlong IDs with the same prefix must not produce collision.""" + from litellm.completion_extras.litellm_responses_transformation.transformation import ( + LiteLLMResponsesTransformationHandler, + ) + + handler: Final = LiteLLMResponsesTransformationHandler() + id_1: Final = "call_" + "x" * 60 + "_1" + id_2: Final = "call_" + "x" * 60 + "_2" + + messages: Final[list[dict[str, object]]] = [ + { + "role": "assistant", + "tool_calls": [ + {"id": id_1, "type": "function", "function": {"name": "f1", "arguments": "{}"}}, + {"id": id_2, "type": "function", "function": {"name": "f2", "arguments": "{}"}}, + ], + }, + {"role": "tool", "tool_call_id": id_1, "content": "res1"}, + {"role": "tool", "tool_call_id": id_2, "content": "res2"}, + ] + + input_items, _ = handler.convert_chat_completion_messages_to_responses_api(messages) + calls: Final = [item for item in input_items if isinstance(item, dict) and item.get("type") == "function_call"] + outputs: Final = [ + item for item in input_items if isinstance(item, dict) and item.get("type") == "function_call_output" + ] + + assert len(calls) == 2 + assert len(outputs) == 2 + assert calls[0]["call_id"] != calls[1]["call_id"] + assert calls[0]["call_id"] == outputs[0].get("call_id") + assert calls[1]["call_id"] == outputs[1].get("call_id") + assert len(str(calls[0]["call_id"])) <= 64 + assert len(str(calls[1]["call_id"])) <= 64 From 0f6d0b62bfd8876c4681037839c6f77984f60545 Mon Sep 17 00:00:00 2001 From: agustin18 Date: Thu, 24 Sep 2026 03:14:14 +0000 Subject: [PATCH 2/5] fix(responses): prevent custom/function output type collision and strip disallowed comments --- .../transformation.py | 17 +----- ...responses_transformation_transformation.py | 58 +++++++++++++++---- 2 files changed, 49 insertions(+), 26 deletions(-) diff --git a/litellm/completion_extras/litellm_responses_transformation/transformation.py b/litellm/completion_extras/litellm_responses_transformation/transformation.py index 05c0b796633..9be66f088e6 100644 --- a/litellm/completion_extras/litellm_responses_transformation/transformation.py +++ b/litellm/completion_extras/litellm_responses_transformation/transformation.py @@ -360,14 +360,6 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): @staticmethod def _normalize_tool_call_id(tool_call_id: object) -> str | None: - """Normalize tool call ID to ensure it does not exceed 64 characters. - - Responses API downstream providers (e.g. OpenAI Responses API, AWS Bedrock) - enforce a 64-character limit on ``call_id``. IDs within the limit are preserved - verbatim. Overlong IDs are deterministically mapped to the first 31 characters - of the ID followed by '_' and a 32-character SHA-256 digest of the full ID - (31 + 1 + 32 = 64 characters), preserving readability and guaranteeing collision resistance. - """ if tool_call_id is None: return None tool_call_id_str: Final = str(tool_call_id) @@ -383,17 +375,14 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): input_items: Final[list[object]] = [] instructions: str | None = None custom_tool_call_ids: Final = frozenset( - ident + tool_call["id"] for msg in messages if msg.get("role") == "assistant" and isinstance(msg.get("tool_calls"), list) for tool_call in msg.get("tool_calls") or () if isinstance(tool_call, dict) and not tool_call.get("function") and isinstance(tool_call.get("custom"), dict) - for raw_id in (tool_call.get("id"),) - if raw_id is not None - for ident in (raw_id, self._normalize_tool_call_id(raw_id)) - if ident is not None + and "id" in tool_call ) leading_system_count: Final = next( @@ -446,7 +435,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): # Fallback: convert unexpected types to input_text tool_output = [{"type": "input_text", "text": str(content)}] normalized_tool_call_id: Final = self._normalize_tool_call_id(tool_call_id) - if tool_call_id in custom_tool_call_ids or normalized_tool_call_id in custom_tool_call_ids: + if tool_call_id in custom_tool_call_ids: input_items.append( ResponseCustomToolCallOutputParam( type="custom_tool_call_output", diff --git a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py index 4f428340926..a8ea05f9704 100644 --- a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py +++ b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py @@ -4357,18 +4357,13 @@ def test_map_optional_params_verbosity_merges_into_text(): @pytest.mark.parametrize( "tool_call_id,is_custom", [ - # Short tool call ID: stays unchanged ("call_short_123", False), - # Exactly 64 characters: boundary case, stays unchanged ("call_" + "a" * 59, False), - # Overlong tool call ID (65 characters): normalized to <= 64 chars ("call_" + "a" * 60, False), - # Overlong tool call ID from issue #42765 (85 characters): normalized to 64 chars ( "call_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", False, ), - # Custom tool call with overlong ID: normalized to <= 64 chars ( "custom_tool_call_id_exceeding_the_standard_responses_api_sixty_four_character_length_limit", True, @@ -4379,11 +4374,7 @@ def test_convert_chat_completion_messages_to_responses_api_normalizes_overlong_t tool_call_id: str, is_custom: bool, ): - """ - Overlong tool call IDs (> 64 chars) must be deterministically normalized to <= 64 characters - consistently across assistant tool_calls and matching tool result messages, - while IDs <= 64 chars must be preserved unchanged. - """ + """Overlong tool call IDs (> 64 chars) must be deterministically normalized to <= 64 characters.""" import hashlib from litellm.completion_extras.litellm_responses_transformation.transformation import ( LiteLLMResponsesTransformationHandler, @@ -4425,7 +4416,6 @@ def test_convert_chat_completion_messages_to_responses_api_normalizes_overlong_t input_items, _ = handler.convert_chat_completion_messages_to_responses_api(messages) - # Validate tool call item if is_custom: tool_call_item: Final = next( item for item in input_items if isinstance(item, dict) and item.get("type") == "custom_tool_call" @@ -4440,7 +4430,6 @@ def test_convert_chat_completion_messages_to_responses_api_normalizes_overlong_t assert call_id == expected_id assert len(str(call_id)) <= 64 - # Validate matching tool output item if is_custom: custom_output_item: Final = next( item for item in input_items if isinstance(item, dict) and item.get("type") == "custom_tool_call_output" @@ -4491,3 +4480,48 @@ def test_convert_chat_completion_messages_to_responses_api_overlong_collision_re assert calls[1]["call_id"] == outputs[1].get("call_id") assert len(str(calls[0]["call_id"])) <= 64 assert len(str(calls[1]["call_id"])) <= 64 + + +def test_convert_chat_completion_messages_to_responses_api_mixed_custom_and_function_output_types(): + """Mixed custom and function tool call outputs must maintain respective types without collision.""" + import hashlib + from litellm.completion_extras.litellm_responses_transformation.transformation import ( + LiteLLMResponsesTransformationHandler, + ) + + handler: Final = LiteLLMResponsesTransformationHandler() + custom_raw_id: Final = "custom_call_" + "y" * 60 + function_raw_id: Final = f"{custom_raw_id[:31]}_{hashlib.sha256(custom_raw_id.encode('utf-8')).hexdigest()[:32]}" + + messages: Final[list[dict[str, object]]] = [ + { + "role": "assistant", + "tool_calls": [ + { + "id": custom_raw_id, + "type": "custom", + "custom": {"name": "c_tool", "input": "{}"}, + }, + { + "id": function_raw_id, + "type": "function", + "function": {"name": "f_tool", "arguments": "{}"}, + }, + ], + }, + {"role": "tool", "tool_call_id": custom_raw_id, "content": "custom_res"}, + {"role": "tool", "tool_call_id": function_raw_id, "content": "func_res"}, + ] + + input_items, _ = handler.convert_chat_completion_messages_to_responses_api(messages) + custom_outputs: Final = [ + item for item in input_items if isinstance(item, dict) and item.get("type") == "custom_tool_call_output" + ] + function_outputs: Final = [ + item for item in input_items if isinstance(item, dict) and item.get("type") == "function_call_output" + ] + + assert len(custom_outputs) == 1 + assert len(function_outputs) == 1 + assert custom_outputs[0].get("call_id") == function_raw_id + assert function_outputs[0].get("call_id") == function_raw_id From dfcb5517e52d07eb239b09fd745ef2f72d2a6453 Mon Sep 17 00:00:00 2001 From: agustin18 Date: Thu, 24 Sep 2026 03:39:11 +0000 Subject: [PATCH 3/5] fix(responses): fix basedpyright loop typing and achieve 100% test coverage --- .../transformation.py | 6 +++--- ...llm_responses_transformation_transformation.py | 15 +++++++++------ 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/litellm/completion_extras/litellm_responses_transformation/transformation.py b/litellm/completion_extras/litellm_responses_transformation/transformation.py index 9be66f088e6..a3422881539 100644 --- a/litellm/completion_extras/litellm_responses_transformation/transformation.py +++ b/litellm/completion_extras/litellm_responses_transformation/transformation.py @@ -434,7 +434,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): else: # Fallback: convert unexpected types to input_text tool_output = [{"type": "input_text", "text": str(content)}] - normalized_tool_call_id: Final = self._normalize_tool_call_id(tool_call_id) + normalized_tool_call_id = self._normalize_tool_call_id(tool_call_id) if tool_call_id in custom_tool_call_ids: input_items.append( ResponseCustomToolCallOutputParam( @@ -464,8 +464,8 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): for tool_call in tool_calls: function = tool_call.get("function") custom = tool_call.get("custom") - raw_id: Final = tool_call.get("id") - normalized_call_id: Final = self._normalize_tool_call_id(raw_id) + raw_id = tool_call.get("id") + normalized_call_id = self._normalize_tool_call_id(raw_id) if function: input_tool_call: dict[str, object] = { "type": "function_call", diff --git a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py index a8ea05f9704..a232a4ebcfc 100644 --- a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py +++ b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py @@ -4357,6 +4357,7 @@ def test_map_optional_params_verbosity_merges_into_text(): @pytest.mark.parametrize( "tool_call_id,is_custom", [ + (None, False), ("call_short_123", False), ("call_" + "a" * 59, False), ("call_" + "a" * 60, False), @@ -4371,17 +4372,19 @@ def test_map_optional_params_verbosity_merges_into_text(): ], ) def test_convert_chat_completion_messages_to_responses_api_normalizes_overlong_tool_call_ids( - tool_call_id: str, + tool_call_id: str | None, is_custom: bool, ): - """Overlong tool call IDs (> 64 chars) must be deterministically normalized to <= 64 characters.""" import hashlib + from litellm.completion_extras.litellm_responses_transformation.transformation import ( LiteLLMResponsesTransformationHandler, ) expected_id: Final = ( - tool_call_id + None + if tool_call_id is None + else tool_call_id if len(tool_call_id) <= 64 else f"{tool_call_id[:31]}_{hashlib.sha256(tool_call_id.encode('utf-8')).hexdigest()[:32]}" ) @@ -4428,7 +4431,8 @@ def test_convert_chat_completion_messages_to_responses_api_normalizes_overlong_t call_id = func_tool_call_item.get("call_id") assert call_id == expected_id - assert len(str(call_id)) <= 64 + if call_id is not None: + assert len(str(call_id)) <= 64 if is_custom: custom_output_item: Final = next( @@ -4446,7 +4450,6 @@ def test_convert_chat_completion_messages_to_responses_api_normalizes_overlong_t def test_convert_chat_completion_messages_to_responses_api_overlong_collision_resistance(): - """Two distinct overlong IDs with the same prefix must not produce collision.""" from litellm.completion_extras.litellm_responses_transformation.transformation import ( LiteLLMResponsesTransformationHandler, ) @@ -4483,8 +4486,8 @@ def test_convert_chat_completion_messages_to_responses_api_overlong_collision_re def test_convert_chat_completion_messages_to_responses_api_mixed_custom_and_function_output_types(): - """Mixed custom and function tool call outputs must maintain respective types without collision.""" import hashlib + from litellm.completion_extras.litellm_responses_transformation.transformation import ( LiteLLMResponsesTransformationHandler, ) From 8f391e3b8734c58b43d49b31569b19415ae06542 Mon Sep 17 00:00:00 2001 From: agustin18 Date: Thu, 24 Sep 2026 03:52:44 +0000 Subject: [PATCH 4/5] refactor(responses): inline tool call normalization to eliminate loop locals --- .../transformation.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/litellm/completion_extras/litellm_responses_transformation/transformation.py b/litellm/completion_extras/litellm_responses_transformation/transformation.py index a3422881539..54a8f974eef 100644 --- a/litellm/completion_extras/litellm_responses_transformation/transformation.py +++ b/litellm/completion_extras/litellm_responses_transformation/transformation.py @@ -434,12 +434,11 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): else: # Fallback: convert unexpected types to input_text tool_output = [{"type": "input_text", "text": str(content)}] - normalized_tool_call_id = self._normalize_tool_call_id(tool_call_id) if tool_call_id in custom_tool_call_ids: input_items.append( ResponseCustomToolCallOutputParam( type="custom_tool_call_output", - call_id=normalized_tool_call_id or "", + call_id=self._normalize_tool_call_id(tool_call_id) or "", output=content if isinstance(content, str) else tool_output, ) ) @@ -447,7 +446,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): input_items.append( FunctionCallOutput( type="function_call_output", - call_id=normalized_tool_call_id, + call_id=self._normalize_tool_call_id(tool_call_id), output=tool_output, ) ) @@ -464,12 +463,10 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): for tool_call in tool_calls: function = tool_call.get("function") custom = tool_call.get("custom") - raw_id = tool_call.get("id") - normalized_call_id = self._normalize_tool_call_id(raw_id) if function: input_tool_call: dict[str, object] = { "type": "function_call", - "call_id": normalized_call_id, + "call_id": self._normalize_tool_call_id(tool_call.get("id")), } if "name" in function: input_tool_call["name"] = function["name"] @@ -480,7 +477,7 @@ class LiteLLMResponsesTransformationHandler(CompletionTransformationBridge): input_items.append( ResponseCustomToolCallParam( type="custom_tool_call", - call_id=normalized_call_id or "", + call_id=self._normalize_tool_call_id(tool_call.get("id")) or "", name=custom.get("name", ""), input=custom.get("input", ""), ) From d777169d3dd82c99287313dc6e57ef21efc00b3b Mon Sep 17 00:00:00 2001 From: agustin18 Date: Wed, 30 Sep 2026 04:11:20 +0000 Subject: [PATCH 5/5] test(responses): remove leftover conflict marker in responses transformation test --- ...ion_extras_litellm_responses_transformation_transformation.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py index c7803363e34..698a40aedd3 100644 --- a/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py +++ b/tests/unit/completion_extras/litellm_responses_transformation/test_completion_extras_litellm_responses_transformation_transformation.py @@ -4354,7 +4354,6 @@ def test_map_optional_params_verbosity_merges_into_text(): assert verbosity_only_request["text"] == {"verbosity": "low"} -<<<<<<< HEAD @pytest.mark.parametrize( "tool_call_id,is_custom", [