feat: REPL namespace isolation (Feature 3)

Each BaseAgent instance now owns an isolated Python execution environment:

- `self._repl_namespace`: per-instance dict passed to exec(); variables set
  in one agent's <execute> blocks are invisible to other agents
- `self._plot_capture`: per-instance PlotCapture replacing module-level
  _captured_plots; each agent captures matplotlib output independently
- `run_python_repl(command, namespace=None)`: new namespace param; falls back
  to _persistent_namespace when None for backward compatibility
- `inject_custom_functions_to_repl(fns, namespace=None)`: new namespace param;
  custom tools are injected into the per-instance namespace
- NodeExecutor.execute() passes agent._repl_namespace to run_python_repl and
  calls agent._plot_capture.apply_patches() before each Python execution
- 24 new tests in test_repl_isolation.py; updated test_add_tool.py and
  test_mcp_integration.py to reflect per-instance injection

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: BinglanLi

BaseAgent/base_agent.py

@@ -40,7 +40,7 @@
 from BaseAgent.config import default_config
 from BaseAgent.resource_manager import ResourceManager
 from BaseAgent.retriever import ToolRetriever
-from BaseAgent.tools.support_tools import run_python_repl
+from BaseAgent.tools.support_tools import PlotCapture, run_python_repl
 from BaseAgent.env_desc import data_lake_items, libraries
 from BaseAgent.utils.tool_bridge import inject_custom_functions_to_repl
 from BaseAgent.utils.formatting import pretty_print
@@ -113,6 +113,10 @@ def __init__(
         self._run_config: dict | None = None
         self.state = AgentState(input=[], next_step=None, pending_code=None, pending_language=None)
         self._usage_metrics = []
+        # Per-instance REPL namespace — isolates variables from other BaseAgent instances
+        self._repl_namespace: dict = {}
+        # Per-instance plot capture — isolates matplotlib output from other instances
+        self._plot_capture = PlotCapture()
         #TODO: add self-critic mode
         self.self_critic = False
 
@@ -1408,40 +1412,27 @@ def _map_langgraph_event(self, event: dict) -> "AgentEvent | None":
         return None
 
     def _clear_execution_plots(self):
-        """
-        Clear execution plots before new execution.
-
-        This function clears any previously captured plots from the execution environment
-        before starting a new execution. This prevents old plots from appearing in
-        new execution results.
-
-        Note:
-            This function calls the clear_captured_plots utility function and handles
-            any exceptions gracefully to prevent execution failures.
-        """
+        """Clear the per-instance plot capture buffer before a new execution."""
         try:
-            from BaseAgent.tools.support_tools import clear_captured_plots
-
-            clear_captured_plots()
+            self._plot_capture.clear()
         except Exception as e:
             print(f"Warning: Could not clear execution plots: {e}")
 
 
     def _inject_custom_functions_to_repl(self):
+        """Inject custom tools into the per-instance REPL namespace.
+
+        Makes custom tools added via ``add_tool()`` / ``add_mcp()`` callable
+        inside ``<execute>`` blocks.  Uses ``self._repl_namespace`` so that
+        injected functions are isolated to this agent instance.
         """
-        Inject custom functions into the Python REPL execution environment.
-        This makes custom tools from ResourceManager available during code execution.
-        """
-        # Get custom tools from ResourceManager
         custom_tools = self.resource_manager.collection.custom_tools
-        
-        # Extract callable functions from CustomTool objects
-        custom_functions = {}
-        for tool in custom_tools:
-            if tool.function is not None:
-                custom_functions[tool.name] = tool.function
-        
-        inject_custom_functions_to_repl(custom_functions)
+        custom_functions = {
+            tool.name: tool.function
+            for tool in custom_tools
+            if tool.function is not None
+        }
+        inject_custom_functions_to_repl(custom_functions, namespace=self._repl_namespace)
 
 
     def _record_usage(self, usage):

BaseAgent/nodes.py

@@ -144,10 +144,15 @@ def execute(self, state: "AgentState") -> "AgentState":
                     stripped_code = stripped_code.replace("\n", " ")
                 result = run_with_timeout(run_bash_script, [stripped_code], timeout=timeout)
             else:
-                # Python: clear previous plots and inject custom functions
-                agent._clear_execution_plots()
+                # Python: clear plots, activate per-instance patches, inject custom tools
+                agent._plot_capture.clear()
+                agent._plot_capture.apply_patches()
                 agent._inject_custom_functions_to_repl()
-                result = run_with_timeout(run_python_repl, [code], timeout=timeout)
+                result = run_with_timeout(
+                    run_python_repl,
+                    [code, agent._repl_namespace],
+                    timeout=timeout,
+                )
 
             if len(result) > 10000:
                 result = (
@@ -159,13 +164,10 @@ def execute(self, state: "AgentState") -> "AgentState":
             if not hasattr(agent, "_execution_results"):
                 agent._execution_results = []
 
-            # Get any plots that were generated during this execution
+            # Get any plots captured during this execution (per-instance buffer)
             execution_plots = []
             try:
-                from BaseAgent.tools.support_tools import get_captured_plots
-
-                current_plots = get_captured_plots()
-                execution_plots = current_plots.copy()
+                execution_plots = agent._plot_capture.get_plots()
             except Exception as e:
                 print(f"Warning: Could not capture plots from execution: {e}")
                 execution_plots = []

BaseAgent/tests/test_add_tool.py

@@ -104,45 +104,38 @@ def untyped_func(a, b, c=10):
 
 class TestREPLInjection:
     """Test REPL namespace injection."""
-    
-    def test_repl_injection(self, base_agent: BaseAgent, clear_repl_namespace):
-        """Test that custom tools are available in REPL execution."""
-        # Add a custom function
+
+    def test_repl_injection(self, base_agent: BaseAgent):
+        """Custom tools are injected into the agent's per-instance namespace."""
         def multiply(a: float, b: float) -> float:
             """Multiply two numbers."""
             return a * b
-        
+
         base_agent.add_tool(multiply)
-        
-        # Inject into REPL
         base_agent._inject_custom_functions_to_repl()
-        
-        # Check if it's in the persistent namespace
-        assert 'multiply' in _persistent_namespace
-        result = _persistent_namespace['multiply'](5, 7)
-        assert result == 35
-    
-    def test_multiple_functions_injection(self, base_agent: BaseAgent, math_functions: tuple, clear_repl_namespace):
-        """Test injecting multiple functions into REPL."""
+
+        # Injected into the per-instance namespace (not global)
+        ns = base_agent._repl_namespace
+        assert 'multiply' in ns
+        assert ns['multiply'](5, 7) == 35
+
+    def test_multiple_functions_injection(self, base_agent: BaseAgent, math_functions: tuple):
+        """Multiple custom tools are all injected into the per-instance namespace."""
         add_func, mult_func, pow_func = math_functions
-        
-        # Add all functions
+
         base_agent.add_tool(add_func)
         base_agent.add_tool(mult_func)
         base_agent.add_tool(pow_func)
-        
-        # Inject into REPL
         base_agent._inject_custom_functions_to_repl()
-        
-        # Verify all are in namespace
-        assert 'add_numbers' in _persistent_namespace
-        assert 'multiply_numbers' in _persistent_namespace
-        assert 'power' in _persistent_namespace
-        
-        # Verify they're callable
-        assert _persistent_namespace['add_numbers'](5, 3) == 8
-        assert _persistent_namespace['multiply_numbers'](5, 3) == 15
-        assert _persistent_namespace['power'](5, 2) == 25
+
+        ns = base_agent._repl_namespace
+        assert 'add_numbers' in ns
+        assert 'multiply_numbers' in ns
+        assert 'power' in ns
+
+        assert ns['add_numbers'](5, 3) == 8
+        assert ns['multiply_numbers'](5, 3) == 15
+        assert ns['power'](5, 2) == 25
 
 
 class TestPromptGeneration:

BaseAgent/tests/test_mcp_integration.py

@@ -99,25 +99,20 @@ def test_mcp_tools_selected_by_default(self, base_agent: BaseAgent, mcp_config_p
 class TestMCPREPLInjection:
     """Test MCP tool injection into REPL namespace."""
 
-    def test_mcp_repl_injection(self, base_agent: BaseAgent, mcp_config_path: Path, skip_if_no_config, clear_repl_namespace):
-        """Test that MCP tools are available in REPL."""
-        # Add MCP
+    def test_mcp_repl_injection(self, base_agent: BaseAgent, mcp_config_path: Path, skip_if_no_config):
+        """Test that MCP tools are injected into the per-instance REPL namespace."""
         base_agent.add_mcp(mcp_config_path)
-        
-        # Inject into REPL
         base_agent._inject_custom_functions_to_repl()
-        
-        # Check namespace
+
         mcp_tools = base_agent.resource_manager.collection.custom_tools
-        
         _assert_mcp_tools_loaded(mcp_tools)
-        # At least one tool should be in namespace
-        tools_in_namespace = [tool for tool in mcp_tools if tool.name in _persistent_namespace]
-        assert len(tools_in_namespace) > 0, "No MCP tools found in REPL namespace"
-        
-        # Verify callable
+
+        ns = base_agent._repl_namespace
+        tools_in_namespace = [tool for tool in mcp_tools if tool.name in ns]
+        assert len(tools_in_namespace) > 0, "No MCP tools found in per-instance REPL namespace"
+
         for tool in tools_in_namespace:
-            assert callable(_persistent_namespace[tool.name]), f"Tool {tool.name} in namespace is not callable"
+            assert callable(ns[tool.name]), f"Tool {tool.name} in namespace is not callable"
 
 
 class TestMCPPromptGeneration: