Fix sandbox data access issue

- Add automatic symbolic links to project data directories
- Inject helper functions for absolute path access
- Enhance configuration display with data access information
- Ensure backward compatibility with existing relative paths

Fixes issue where sandbox mode made project data inaccessible,
causing FileNotFoundError for paths like './data/biomni_data/...'

Now provides multiple data access methods:
1. Relative paths via automatic symlinks
2. get_project_path() helper function
3. Environment variables (__original_cwd__, etc.)

All output files remain isolated in sandbox while maintaining
seamless access to project data for analysis.

Author: lxasqjc

biomni/agent/a1.py

@@ -124,10 +124,13 @@ def __init__(
                 sandbox_path = os.path.join("sandbox", session_id)
 
             self.sandbox_path = os.path.abspath(sandbox_path)
+            self.original_cwd = os.getcwd()  # Store original working directory
             os.makedirs(self.sandbox_path, exist_ok=True)
+            
             print(f"📁 Sandbox mode enabled: {self.sandbox_path}")
         else:
             self.sandbox_path = None
+            self.original_cwd = None
 
         # Display configuration in a nice, readable format
         print("\n" + "=" * 50)
@@ -167,6 +170,10 @@ def __init__(
             print(f"  Enabled: True")
             print(f"  Sandbox Path: {self.sandbox_path}")
             print(f"  Files will be created in: {self.sandbox_path}")
+            print(f"  Original Project Path: {self.original_cwd}")
+            print("  Data Access:")
+            print("    - Relative paths: ./data/... (via symlinks)")
+            print("    - Helper function: get_project_path('data/...') for absolute paths")
 
         print("=" * 50 + "\n")
 
@@ -176,6 +183,10 @@ def __init__(
             os.makedirs(path)
             print(f"Created directory: {path}")
 
+        # Setup sandbox data access after path is assigned
+        if self.sandbox_mode:
+            self._setup_sandbox_data_access()
+
         # --- Begin custom folder/file checks ---
         benchmark_dir = os.path.join(path, "biomni_data", "benchmark")
         data_lake_dir = os.path.join(path, "biomni_data", "data_lake")
@@ -1415,9 +1426,9 @@ def execute(state: AgentState) -> AgentState:
                     # Inject custom functions into the Python execution environment
                     self._inject_custom_functions_to_repl()
 
-                    # Pass sandbox path if sandbox mode is enabled
+                    # Pass sandbox path and original directory if sandbox mode is enabled
                     if self.sandbox_mode and self.sandbox_path:
-                        result = run_with_timeout(run_python_repl, [code, self.sandbox_path], timeout=timeout)
+                        result = run_with_timeout(run_python_repl, [code, self.sandbox_path, self.original_cwd], timeout=timeout)
                     else:
                         result = run_with_timeout(run_python_repl, [code], timeout=timeout)
 
@@ -1929,6 +1940,46 @@ def get_sandbox_path(self) -> str | None:
         """
         return self.sandbox_path if self.sandbox_mode else None
 
+    def _setup_sandbox_data_access(self) -> None:
+        """Setup data access for sandbox mode by creating symbolic links to important directories."""
+        if not self.sandbox_mode or not self.sandbox_path:
+            return
+        
+        # List of important directories/files to link into sandbox
+        important_paths = [
+            ("data", os.path.join(self.original_cwd, "data")),
+            ("biomni_data", os.path.join(self.original_cwd, "data", "biomni_data")),
+        ]
+        
+        # Create symbolic links for data access
+        for link_name, target_path in important_paths:
+            if os.path.exists(target_path):
+                sandbox_link = os.path.join(self.sandbox_path, link_name)
+                
+                # Remove existing link if it exists
+                if os.path.islink(sandbox_link):
+                    os.unlink(sandbox_link)
+                elif os.path.exists(sandbox_link):
+                    # Don't overwrite real directories/files
+                    continue
+                
+                try:
+                    os.symlink(target_path, sandbox_link)
+                    print(f"🔗 Linked {link_name} -> {target_path}")
+                except OSError as e:
+                    print(f"⚠️  Could not create symlink {link_name}: {e}")
+        
+        # Also try to link the main data directory directly if path is provided
+        main_data_path = os.path.join(self.original_cwd, self.path)
+        if os.path.exists(main_data_path) and main_data_path != os.path.join(self.original_cwd, "data"):
+            sandbox_data_link = os.path.join(self.sandbox_path, "main_data")
+            if not os.path.exists(sandbox_data_link):
+                try:
+                    os.symlink(main_data_path, sandbox_data_link)
+                    print(f"🔗 Linked main_data -> {main_data_path}")
+                except OSError as e:
+                    print(f"⚠️  Could not create main_data symlink: {e}")
+
     def save_conversation_history(self, filepath: str, include_images: bool = True, save_pdf: bool = True) -> None:
         """Save the complete conversation history as PDF only.
 

biomni/tool/support_tools.py

@@ -11,13 +11,14 @@
 _captured_plots = []
 
 
-def run_python_repl(command: str, working_dir: str | None = None) -> str:
+def run_python_repl(command: str, working_dir: str | None = None, original_cwd: str | None = None) -> str:
     """Executes the provided Python command in a persistent environment and returns the output.
     Variables defined in one execution will be available in subsequent executions.
     
     Args:
         command: Python command to execute
         working_dir: Optional working directory to change to before execution
+        original_cwd: Original working directory (for sandbox mode data access)
     """
 
     def execute_in_repl(command: str) -> str:
@@ -35,6 +36,21 @@ def execute_in_repl(command: str) -> str:
                 old_cwd = os.getcwd()
                 os.chdir(working_dir)
 
+            # Inject sandbox-aware helper variables for data access
+            if working_dir is not None and original_cwd is not None:
+                _persistent_namespace['__sandbox_mode__'] = True
+                _persistent_namespace['__original_cwd__'] = original_cwd
+                _persistent_namespace['__sandbox_path__'] = working_dir
+                
+                # Helper function for accessing original project data
+                def _get_project_path(relative_path):
+                    """Helper function to get absolute path to project data from sandbox."""
+                    return os.path.join(original_cwd, relative_path)
+                
+                _persistent_namespace['get_project_path'] = _get_project_path
+            else:
+                _persistent_namespace['__sandbox_mode__'] = False
+
             # Apply matplotlib monkey patches before execution
             _apply_matplotlib_patches()