bugfix: 修复codeexecute 执行和tool冲突的问题

- 如果执行codeexecute, 再次执行 tool,会导致tool的数据丢失

Author: raychen911

tests/code_executors/container/test_container_code_executor.py

@@ -321,11 +321,12 @@ async def test_exec_run_exception_propagates(self, mock_cc_cls, mock_ctx):
 class TestCodeBlockDelimiter:
 
     @patch("trpc_agent_sdk.code_executors.container._container_code_executor.ContainerClient")
-    def test_returns_correct_delimiter(self, mock_cc_cls):
+    def test_returns_default_delimiters(self, mock_cc_cls):
         mock_cc_cls.return_value = Mock()
         executor = ContainerCodeExecutor(image="img")
-        delim = executor.code_block_delimiter()
+        delims = executor.code_block_delimiters
 
-        assert isinstance(delim, CodeBlockDelimiter)
-        assert delim.start == "```tool_code\n"
-        assert delim.end == "\n```"
+        assert isinstance(delims, list)
+        assert all(isinstance(d, CodeBlockDelimiter) for d in delims)
+        assert delims[0].start == "```tool_code\n"
+        assert delims[0].end == "\n```"

tests/code_executors/local/test_unsafe_local_code_executor.py

@@ -62,27 +62,22 @@ def test_custom_clean_temp_files(self):
         executor = UnsafeLocalCodeExecutor(clean_temp_files=False)
         assert executor.clean_temp_files is False
 
-    def test_custom_delimiter(self):
-        delim = CodeBlockDelimiter(start="<<<", end=">>>")
-        executor = UnsafeLocalCodeExecutor(delimiter=delim)
-        assert executor.delimiter.start == "<<<"
-        assert executor.delimiter.end == ">>>"
-
 
 class TestCodeBlockDelimiter:
-    """Tests for code_block_delimiter method."""
+    """Tests for code block delimiter configuration."""
 
-    def test_returns_default_delimiter(self):
+    def test_returns_default_delimiters(self):
         executor = UnsafeLocalCodeExecutor()
-        delimiter = executor.code_block_delimiter()
-        assert isinstance(delimiter, CodeBlockDelimiter)
-        assert delimiter.start == "```"
-        assert delimiter.end == "```"
+        delimiters = executor.code_block_delimiters
+        assert isinstance(delimiters, list)
+        assert all(isinstance(d, CodeBlockDelimiter) for d in delimiters)
+        assert delimiters[0].start == "```tool_code\n"
+        assert delimiters[0].end == "\n```"
 
-    def test_returns_custom_delimiter(self):
+    def test_returns_custom_delimiters(self):
         custom = CodeBlockDelimiter(start="---", end="---")
-        executor = UnsafeLocalCodeExecutor(delimiter=custom)
-        assert executor.code_block_delimiter() == custom
+        executor = UnsafeLocalCodeExecutor(code_block_delimiters=[custom])
+        assert executor.code_block_delimiters == [custom]
 
 
 class TestPrepareWorkDir:

tests/code_executors/test_container_container_code_executor.py

@@ -193,16 +193,17 @@ async def test_execute_code_exception_handling(self, mock_container_client_class
             await executor.execute_code(self.mock_ctx, code_input)
 
     @patch('trpc_agent_sdk.code_executors.container._container_code_executor.ContainerClient')
-    def test_code_block_delimiter(self, mock_container_client_class):
-        """Test code_block_delimiter method."""
+    def test_code_block_delimiters(self, mock_container_client_class):
+        """Test default code_block_delimiters value."""
         mock_container_client = Mock()
         mock_container_client_class.return_value = mock_container_client
 
         executor = ContainerCodeExecutor(image="python:3-slim")
-        delimiter = executor.code_block_delimiter()
+        delimiters = executor.code_block_delimiters
 
-        assert delimiter.start == "```tool_code\n"
-        assert delimiter.end == "\n```"
+        assert isinstance(delimiters, list)
+        assert delimiters[0].start == "```tool_code\n"
+        assert delimiters[0].end == "\n```"
 
     @patch('trpc_agent_sdk.code_executors.container._container_code_executor.ContainerClient')
     async def test_execute_code_empty_language_defaults_to_python(self, mock_container_client_class):

tests/code_executors/test_local_unsafe_local_code_executor.py

@@ -59,12 +59,13 @@ def test_init_with_custom_values(self):
         assert executor.timeout == 30.0
         assert executor.clean_temp_files is False
 
-    def test_code_block_delimiter(self):
-        """Test code_block_delimiter method."""
+    def test_code_block_delimiters(self):
+        """Test default code_block_delimiters value."""
         executor = UnsafeLocalCodeExecutor()
-        delimiter = executor.code_block_delimiter()
+        delimiters = executor.code_block_delimiters
 
-        assert isinstance(delimiter, CodeBlockDelimiter)
+        assert isinstance(delimiters, list)
+        assert all(isinstance(delimiter, CodeBlockDelimiter) for delimiter in delimiters)
 
     @patch('trpc_agent_sdk.code_executors.local._unsafe_local_code_executor.async_execute_command')
     async def test_execute_code_python(self, mock_async_execute):

trpc_agent_sdk/agents/core/_code_execution_processor.py

@@ -248,19 +248,16 @@ async def _run_post_processor(
     if not llm_response or not llm_response.content:
         return
 
-    # For container and unsafe local executors, we handle execution in post-processing
-    if isinstance(code_executor, (ContainerCodeExecutor, UnsafeLocalCodeExecutor)):
-        # Continue with post-processing for these executors
-        pass
-
     code_executor_context = CodeExecutorContext(invocation_context.session.state)
     # Skip if the error count exceeds the max retry attempts.
     if code_executor_context.get_error_count(invocation_context.invocation_id) >= code_executor.error_retry_attempts:
         return
 
-    # [Step 1] Extract code from the model predict response and truncate the
-    # content to the part with the first code block.
-    response_content = llm_response.content
+    # [Step 1] Extract code from a cloned response content.
+    # IMPORTANT: extract_code_and_truncate_content mutates the input Content in place.
+    # Clone first to avoid mutating shared references that are later used by
+    # telemetry tracing and session persistence.
+    response_content = copy.deepcopy(llm_response.content)
     code_blocks = CodeExecutionUtils.extract_code_and_truncate_content(response_content,
                                                                        code_executor.code_block_delimiters,
                                                                        code_executor.ignore_codes)
@@ -302,9 +299,20 @@ async def _run_post_processor(
                                                              code_execution_result)
     yield result_event
 
-    # [Step 3] Skip processing the original model response
-    # to continue code generation loop.
-    llm_response.content = None
+    # [Step 3] Skip processing original textual/code response to continue the
+    # code generation loop, but preserve function_call parts for downstream
+    # session consistency (pairing function_call with function_response).
+    function_call_parts = []
+    if llm_response.content and llm_response.content.parts:
+        function_call_parts = [part for part in llm_response.content.parts if part.function_call]
+
+    if function_call_parts:
+        llm_response.content = Content(
+            role=llm_response.content.role if llm_response.content else "model",
+            parts=function_call_parts,
+        )
+    else:
+        llm_response.content = None
 
 
 def _extract_and_replace_inline_files(

trpc_agent_sdk/code_executors/_base_code_executor.py

@@ -100,10 +100,10 @@ async def execute_code(
             The code execution result.
         """
 
-    @abc.abstractmethod
-    def code_block_delimiter(self) -> CodeBlockDelimiter:
+    def code_block_delimiter(self) -> list[CodeBlockDelimiter]:
         """Return the code block delimiter used by this executor.
 
         Returns:
             CodeBlockDelimiter instance
         """
+        return self.code_block_delimiters

trpc_agent_sdk/code_executors/container/_container_code_executor.py

@@ -149,12 +149,3 @@ async def execute_code(
         output = "".join(all_output)
         err_str = "".join(all_errors)
         return create_code_execution_result(stdout=output, stderr=err_str)
-
-    @override
-    def code_block_delimiter(self) -> CodeBlockDelimiter:
-        """Return the code block delimiter used by this executor.
-
-        Returns:
-            CodeBlockDelimiter instance
-        """
-        return CodeBlockDelimiter(start="```tool_code\n", end="\n```")

trpc_agent_sdk/code_executors/local/_unsafe_local_code_executor.py

@@ -48,9 +48,6 @@ class UnsafeLocalCodeExecutor(BaseCodeExecutor):
     clean_temp_files: bool = Field(default=True,
                                    description="Whether to clean temporary files after the code execution.")
 
-    delimiter: CodeBlockDelimiter = Field(default_factory=CodeBlockDelimiter,
-                                          description="The delimiter for the code execution.")
-
     def __init__(self, **data):
         """Initialize the UnsafeLocalCodeExecutor."""
         if "stateful" in data and data["stateful"]:
@@ -97,11 +94,6 @@ async def execute_code(self, invocation_context: InvocationContext,
         return create_code_execution_result(stdout="\n".join(output_parts) if output_parts else "",
                                             stderr="\n".join(error_parts) if error_parts else "")
 
-    @override
-    def code_block_delimiter(self) -> CodeBlockDelimiter:
-        """Return the code block delimiter used by this executor."""
-        return self.delimiter
-
     def _prepare_work_dir(self, execution_id: str) -> tuple[Path, bool]:
         """Prepare working directory for execution.