cowork-dash 0.1.8__py3-none-any.whl → 0.2.0__py3-none-any.whl

cowork_dash/tools.py

@@ -1,15 +1,88 @@
 from typing import Any, Dict, List, Optional
 import sys
 import io
+import os
 import traceback
 import subprocess
 import threading
-from contextlib import redirect_stdout, redirect_stderr
+import platform
+from contextlib import redirect_stdout, redirect_stderr, contextmanager
 
 from .config import WORKSPACE_ROOT, VIRTUAL_FS
 from .canvas import parse_canvas_object, generate_canvas_id
 
 
+# =============================================================================
+# DISPLAY INLINE - PUSH TO AGENT STATE
+# =============================================================================
+# Instead of returning data through LangGraph (which has serialization limitations),
+# display_inline pushes items directly to the agent state. The Dash polling callback
+# picks them up from state["display_inline_items"] and renders them directly.
+
+
+def _push_display_inline_to_state(item: Dict[str, Any]) -> None:
+    """Push a display_inline item to the agent state.
+
+    Uses the current session's state via push_display_inline_item from app.py.
+
+    Args:
+        item: The display result dict with type, display_type, data, etc.
+    """
+    # Import here to avoid circular import
+    from .app import push_display_inline_item
+
+    # Get session_id from tool context (set during agent execution)
+    session_id = get_tool_session_context()
+    push_display_inline_item(item, session_id)
+
+
+# =============================================================================
+
+
+# Memory limit for cell execution (in bytes)
+# Default: 512 MB - can be overridden via environment variable
+CELL_MEMORY_LIMIT_MB = int(os.environ.get("COWORK_CELL_MEMORY_LIMIT_MB", "512"))
+CELL_MEMORY_LIMIT_BYTES = CELL_MEMORY_LIMIT_MB * 1024 * 1024
+
+
+@contextmanager
+def memory_limit(max_bytes: int = CELL_MEMORY_LIMIT_BYTES):
+    """Context manager to set memory limits for code execution on Linux.
+
+    On Linux, uses resource.setrlimit() to set soft memory limit.
+    On other platforms (macOS, Windows), this is a no-op as they don't
+    support RLIMIT_AS in the same way or at all.
+
+    The limit applies to the virtual address space (RLIMIT_AS) which
+    will cause MemoryError when exceeded rather than OOM kill.
+
+    Args:
+        max_bytes: Maximum memory in bytes. Default from CELL_MEMORY_LIMIT_BYTES.
+    """
+    if platform.system() != "Linux":
+        # Memory limits via resource module only work reliably on Linux
+        yield
+        return
+
+    try:
+        import resource
+    except ImportError:
+        yield
+        return
+
+    # Get current limits
+    soft, hard = resource.getrlimit(resource.RLIMIT_AS)
+
+    try:
+        # Set new soft limit (don't exceed hard limit)
+        new_soft = min(max_bytes, hard) if hard != resource.RLIM_INFINITY else max_bytes
+        resource.setrlimit(resource.RLIMIT_AS, (new_soft, hard))
+        yield
+    finally:
+        # Restore original limits
+        resource.setrlimit(resource.RLIMIT_AS, (soft, hard))
+
+
 # Thread-local storage for current session context
 # This allows tools to know which session they're operating in
 _tool_context = threading.local()
@@ -383,47 +456,54 @@ except (ImportError, AttributeError):
         }
 
         try:
-            # Try IPython first for better execution handling
-            ipython = self._get_ipython()
-
-            if ipython is not None:
-                # Use IPython's run_cell for magic commands support
-                with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                    exec_result = ipython.run_cell(cell["source"], store_history=True)
-
-                result["stdout"] = stdout_capture.getvalue()
-                result["stderr"] = stderr_capture.getvalue()
-
-                if exec_result.success:
-                    if exec_result.result is not None:
-                        result["result"] = repr(exec_result.result)
+            # Apply memory limit on Linux to prevent OOM kills
+            with memory_limit():
+                # Try IPython first for better execution handling
+                ipython = self._get_ipython()
+
+                if ipython is not None:
+                    # Use IPython's run_cell for magic commands support
+                    with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+                        exec_result = ipython.run_cell(cell["source"], store_history=True)
+
+                    result["stdout"] = stdout_capture.getvalue()
+                    result["stderr"] = stderr_capture.getvalue()
+
+                    if exec_result.success:
+                        if exec_result.result is not None:
+                            result["result"] = repr(exec_result.result)
+                    else:
+                        if exec_result.error_in_exec:
+                            result["error"] = str(exec_result.error_in_exec)
+                            result["status"] = "error"
+                        elif exec_result.error_before_exec:
+                            result["error"] = str(exec_result.error_before_exec)
+                            result["status"] = "error"
                 else:
-                    if exec_result.error_in_exec:
-                        result["error"] = str(exec_result.error_in_exec)
-                        result["status"] = "error"
-                    elif exec_result.error_before_exec:
-                        result["error"] = str(exec_result.error_before_exec)
-                        result["status"] = "error"
-            else:
-                # Fallback to exec() if IPython is not available
-                with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                    # Compile to check for expression vs statement
-                    code = cell["source"].strip()
-
-                    # Try to evaluate as expression first (to get return value)
-                    try:
-                        # Check if it's a simple expression
-                        compiled = compile(code, "<cell>", "eval")
-                        exec_result = eval(compiled, self._namespace)
-                        if exec_result is not None:
-                            result["result"] = repr(exec_result)
-                    except SyntaxError:
-                        # It's a statement, execute it
-                        exec(code, self._namespace)
-
-                result["stdout"] = stdout_capture.getvalue()
-                result["stderr"] = stderr_capture.getvalue()
-
+                    # Fallback to exec() if IPython is not available
+                    with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+                        # Compile to check for expression vs statement
+                        code = cell["source"].strip()
+
+                        # Try to evaluate as expression first (to get return value)
+                        try:
+                            # Check if it's a simple expression
+                            compiled = compile(code, "<cell>", "eval")
+                            exec_result = eval(compiled, self._namespace)
+                            if exec_result is not None:
+                                result["result"] = repr(exec_result)
+                        except SyntaxError:
+                            # It's a statement, execute it
+                            exec(code, self._namespace)
+
+                    result["stdout"] = stdout_capture.getvalue()
+                    result["stderr"] = stderr_capture.getvalue()
+
+        except MemoryError:
+            result["error"] = f"MemoryError: Cell execution exceeded memory limit ({CELL_MEMORY_LIMIT_MB} MB). Try processing data in smaller chunks."
+            result["status"] = "error"
+            result["stdout"] = stdout_capture.getvalue()
+            result["stderr"] = stderr_capture.getvalue()
         except Exception:
             result["error"] = traceback.format_exc()
             result["status"] = "error"
@@ -732,35 +812,6 @@ def reset_notebook() -> Dict[str, Any]:
     return _notebook_state.reset()
 
 
-def get_notebook_canvas_items() -> List[Dict[str, Any]]:
-    """
-    Get all canvas items generated during notebook cell execution.
-
-    When code in cells calls add_to_canvas(), the items are collected here.
-    Use this to retrieve visualizations generated by executed code.
-
-    Returns:
-        List of canvas item dictionaries with type and data
-
-    Examples:
-        # After executing cells that created charts
-        items = get_notebook_canvas_items()
-        for item in items:
-            print(f"Type: {item['type']}")
-    """
-    return _notebook_state.get_canvas_items()
-
-
-def clear_notebook_canvas_items() -> Dict[str, Any]:
-    """
-    Clear all canvas items collected from notebook execution.
-
-    Returns:
-        Dictionary with count of cleared items
-    """
-    return _notebook_state.clear_canvas_items()
-
-
 # =============================================================================
 # CANVAS TOOLS
 # =============================================================================
@@ -888,6 +939,549 @@ def remove_canvas_item(item_id: str) -> Dict[str, Any]:
     }
 
 
+# =============================================================================
+# DISPLAY INLINE TOOL
+# =============================================================================
+
+def display_inline(
+    content: Any,
+    title: Optional[str] = None,
+    display_type: Optional[str] = None
+) -> str:
+    """Display content to the user in a rich, interactive format inline in the chat.
+
+    This tool renders content directly in the conversation for immediate visibility.
+    Use this when you want the user to see results right away without navigating to
+    the canvas. Supports images, HTML, Plotly charts, CSV/DataFrames, and more.
+
+    **Note:** Returns a JSON string that will be parsed by the UI for rendering.
+    This is necessary because LangGraph converts non-string tool results to strings,
+    and this ensures proper JSON serialization instead of Python repr().
+
+    Args:
+        content: The content to display. Can be:
+            - str: File path (image, HTML, CSV, JSON) or raw content
+            - bytes: Binary image data (PNG, JPEG, etc.)
+            - pd.DataFrame: Rendered as an interactive table
+            - dict: If it looks like Plotly JSON, rendered as a chart
+            - matplotlib.figure.Figure: Rendered as an image
+            - plotly.graph_objects.Figure: Rendered as an interactive chart
+        title: Optional title displayed above the content
+        display_type: Optional hint for how to render the content. One of:
+            - "image": Force image rendering (PNG, JPEG, GIF, etc.)
+            - "html": Force HTML rendering with preview
+            - "plotly": Force Plotly chart rendering
+            - "csv" or "dataframe": Force table rendering
+            - "json": Force JSON rendering
+            - "text": Force plain text rendering
+            Auto-detected if not provided.
+
+    Returns:
+        Dictionary with display metadata:
+        - type: "display_inline" (identifies this as inline display)
+        - display_type: The detected/specified display type
+        - title: The title (if provided)
+        - data: The processed data for rendering
+        - status: "success" or "error"
+
+    Examples:
+        # Show an image file
+        display_inline("analysis_results.png", title="Results Chart")
+
+        # Show a DataFrame
+        import pandas as pd
+        df = pd.read_csv("data.csv")
+        display_inline(df, title="Sales Data")
+
+        # Show a Plotly figure
+        import plotly.express as px
+        fig = px.bar(df, x="category", y="value")
+        display_inline(fig, title="Category Distribution")
+
+        # Show HTML content
+        display_inline("<h1>Hello</h1><p>World</p>", display_type="html")
+
+        # Show CSV file
+        display_inline("report.csv", title="Monthly Report")
+    """
+    # Call the implementation to get the display data
+    result_dict = _display_inline_impl(content, title, display_type)
+
+    # Add unique ID for tracking
+    import uuid
+    result_dict["_item_id"] = str(uuid.uuid4())[:8]
+
+    # Push to agent state for direct Dash rendering (bypasses LangGraph serialization)
+    _push_display_inline_to_state(result_dict)
+
+    # Return a simple confirmation message (this goes through LangGraph)
+    # The actual rich content is rendered directly by Dash via state["display_inline_items"]
+    display_type_str = result_dict.get("display_type", "content")
+    title_str = f" '{title}'" if title else ""
+    if result_dict.get("status") == "error":
+        return f"Error displaying{title_str}: {result_dict.get('error', 'Unknown error')}"
+    return f"Displayed {display_type_str}{title_str} inline."
+
+
+def _display_inline_impl(
+    content: Any,
+    title: Optional[str] = None,
+    display_type: Optional[str] = None
+) -> Dict[str, Any]:
+    """Internal implementation of display_inline that returns a dict."""
+    import base64
+    import io
+    import json
+    from pathlib import PurePath
+
+    result = {
+        "type": "display_inline",
+        "display_type": None,
+        "title": title,
+        "data": None,
+        "preview": None,  # For thumbnails
+        "downloadable": False,
+        "status": "success",
+        "error": None
+    }
+
+    try:
+        # Get workspace root for file operations
+        workspace_root = _get_workspace_root_for_context()
+
+        # Detect content type and process accordingly
+        obj_type = type(content).__name__
+        obj_module = type(content).__module__
+
+        # Handle file paths (strings that look like file paths)
+        if isinstance(content, str) and not display_type:
+            # Check if it's a file path
+            if _is_file_path(content, workspace_root):
+                return _process_file_for_display(content, workspace_root, title, display_type)
+
+            # If it looks like a file path but doesn't exist, try to find it
+            from pathlib import PurePath
+            ext = PurePath(content).suffix.lower()
+            known_file_extensions = {
+                '.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico',
+                '.html', '.htm', '.csv', '.tsv', '.json', '.pdf'
+            }
+            if ext in known_file_extensions and "\n" not in content and len(content) < 500:
+                # Try to find the file - check if just filename was passed
+                found_path = _find_file_in_workspace(content, workspace_root)
+                if found_path:
+                    return _process_file_for_display(found_path, workspace_root, title, display_type)
+                else:
+                    # Return error - file not found
+                    result["status"] = "error"
+                    result["display_type"] = "error"
+                    result["error"] = f"File not found: {content}"
+                    result["data"] = f"Could not find file '{content}' in workspace. Make sure the file exists and the path is correct."
+                    return result
+
+            # Otherwise, check for explicit display types or treat as text/HTML
+            if content.strip().startswith("<") and ">" in content:
+                result["display_type"] = "html"
+                result["data"] = content
+                result["preview"] = content[:500] + "..." if len(content) > 500 else content
+                return result
+
+        # Handle explicit display_type for strings
+        if isinstance(content, str) and display_type:
+            if display_type == "html":
+                result["display_type"] = "html"
+                result["data"] = content
+                result["preview"] = content[:500] + "..." if len(content) > 500 else content
+                return result
+            elif display_type == "text":
+                result["display_type"] = "text"
+                result["data"] = content
+                return result
+            elif display_type in ("csv", "dataframe"):
+                # Parse CSV string
+                try:
+                    import pandas as pd
+                    df = pd.read_csv(io.StringIO(content))
+                    return _process_dataframe_for_display(df, title)
+                except Exception as e:
+                    result["display_type"] = "text"
+                    result["data"] = content
+                    result["error"] = f"Could not parse as CSV: {e}"
+                    return result
+            elif display_type == "json":
+                result["display_type"] = "json"
+                try:
+                    result["data"] = json.loads(content) if isinstance(content, str) else content
+                except json.JSONDecodeError:
+                    result["data"] = content
+                return result
+            elif display_type == "image":
+                # Assume it's base64 or file path
+                if _is_file_path(content, workspace_root):
+                    return _process_file_for_display(content, workspace_root, title, "image")
+                result["display_type"] = "image"
+                result["data"] = content  # Assume base64
+                return result
+            elif display_type == "plotly":
+                result["display_type"] = "plotly"
+                if isinstance(content, str):
+                    result["data"] = json.loads(content)
+                else:
+                    result["data"] = content
+                return result
+
+        # Handle bytes (binary data - likely image)
+        if isinstance(content, bytes):
+            result["display_type"] = "image"
+            result["data"] = base64.b64encode(content).decode('utf-8')
+            return result
+
+        # Handle pandas DataFrame
+        if obj_module.startswith('pandas') and obj_type == 'DataFrame':
+            return _process_dataframe_for_display(content, title)
+
+        # Handle matplotlib Figure
+        if obj_module.startswith('matplotlib') and 'Figure' in obj_type:
+            buf = io.BytesIO()
+            content.savefig(buf, format='png', bbox_inches='tight', dpi=100)
+            buf.seek(0)
+            img_data = buf.read()
+            buf.close()
+
+            result["display_type"] = "image"
+            result["data"] = base64.b64encode(img_data).decode('utf-8')
+            result["mime_type"] = "image/png"
+            return result
+
+        # Handle Plotly Figure
+        if obj_module.startswith('plotly') and 'Figure' in obj_type:
+            result["display_type"] = "plotly"
+            result["data"] = json.loads(content.to_json())
+            return result
+
+        # Handle dict (check for Plotly JSON structure or serialization artifacts)
+        if isinstance(content, dict):
+            # Check if this looks like a serialized matplotlib/plotly reference (common mistake)
+            if content.get('type') in ('matplotlib', 'plotly') and 'figure' in content:
+                result["status"] = "error"
+                result["display_type"] = "error"
+                result["error"] = (
+                    "Cannot display figure objects directly. The figure was serialized to a reference. "
+                    "To display matplotlib figures, save them to a file first:\n"
+                    "  fig.savefig('chart.png')\n"
+                    "  display_inline('chart.png')\n"
+                    "Or use add_to_canvas(fig) inside a notebook cell."
+                )
+                result["data"] = str(content)
+                return result
+            # Check for Plotly JSON structure
+            if 'data' in content and isinstance(content.get('data'), list):
+                result["display_type"] = "plotly"
+                result["data"] = content
+                return result
+            else:
+                result["display_type"] = "json"
+                result["data"] = content
+                return result
+
+        # Handle PIL Image
+        if obj_module.startswith('PIL') and 'Image' in obj_type:
+            buf = io.BytesIO()
+            content.save(buf, format='PNG')
+            buf.seek(0)
+            img_data = buf.read()
+            buf.close()
+
+            result["display_type"] = "image"
+            result["data"] = base64.b64encode(img_data).decode('utf-8')
+            result["mime_type"] = "image/png"
+            return result
+
+        # Handle list (could be data for table)
+        if isinstance(content, list) and len(content) > 0:
+            if isinstance(content[0], dict):
+                # List of dicts - render as table
+                try:
+                    import pandas as pd
+                    df = pd.DataFrame(content)
+                    return _process_dataframe_for_display(df, title)
+                except Exception:
+                    result["display_type"] = "json"
+                    result["data"] = content
+                    return result
+            else:
+                result["display_type"] = "json"
+                result["data"] = content
+                return result
+
+        # Default: convert to string
+        result["display_type"] = "text"
+        result["data"] = str(content)
+        return result
+
+    except Exception as e:
+        result["status"] = "error"
+        result["error"] = str(e)
+        result["display_type"] = "error"
+        result["data"] = f"Error processing content: {e}"
+        return result
+
+
+def _is_file_path(content: str, workspace_root: Any) -> bool:
+    """Check if a string looks like a file path that exists."""
+    if not content or len(content) > 500:  # Too long to be a path
+        return False
+    if "\n" in content:  # Contains newlines - not a path
+        return False
+
+    # Check for common file extensions
+    from pathlib import Path, PurePath
+    ext = PurePath(content).suffix.lower()
+    known_extensions = {
+        '.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico',
+        '.html', '.htm',
+        '.csv', '.tsv',
+        '.json',
+        '.pdf'
+    }
+
+    if ext in known_extensions:
+        from .file_utils import _get_path
+        from .virtual_fs import VirtualFilesystem
+
+        try:
+            # For absolute paths with physical filesystem, check the path directly
+            # This handles cases where an absolute path is passed that may be outside workspace
+            if content.startswith('/') and not isinstance(workspace_root, VirtualFilesystem):
+                abs_path = Path(content)
+                return abs_path.exists() and abs_path.is_file()
+
+            # For relative paths or VirtualFilesystem, use _get_path
+            full_path = _get_path(workspace_root, content)
+            return full_path.exists()
+        except Exception:
+            return False
+
+    return False
+
+
+def _find_file_in_workspace(filename: str, workspace_root: Any) -> Optional[str]:
+    """Try to find a file in the workspace by searching common locations.
+
+    Args:
+        filename: The filename or path to search for
+        workspace_root: The workspace root (Path or VirtualFilesystem)
+
+    Returns:
+        The relative path to the file if found, None otherwise
+    """
+    from pathlib import PurePath
+    from .file_utils import _get_path
+
+    # Extract just the filename if a path was provided
+    basename = PurePath(filename).name
+
+    # Locations to search (in order of priority)
+    search_paths = [
+        filename,  # As provided
+        basename,  # Just the filename in root
+        f".canvas/{basename}",  # In canvas folder
+        f"output/{basename}",  # Common output folder
+        f"outputs/{basename}",
+        f"results/{basename}",
+    ]
+
+    # Also try the exact path as-is first
+    for path in search_paths:
+        try:
+            full_path = _get_path(workspace_root, path)
+            if full_path.exists() and full_path.is_file():
+                return path
+        except Exception:
+            continue
+
+    # Try recursive search for the filename (limited depth)
+    try:
+        from .virtual_fs import VirtualFilesystem
+        if isinstance(workspace_root, VirtualFilesystem):
+            # For VirtualFilesystem, check all files
+            for file_path in workspace_root.glob("**/*"):
+                if file_path.name == basename and file_path.is_file():
+                    # Return relative path
+                    return str(file_path).lstrip("/")
+        else:
+            # For physical filesystem
+            import os
+            for root, dirs, files in os.walk(workspace_root):
+                # Limit depth to 3 levels
+                rel_root = os.path.relpath(root, workspace_root)
+                if rel_root.count(os.sep) > 3:
+                    continue
+                # Skip hidden directories
+                dirs[:] = [d for d in dirs if not d.startswith('.')]
+                if basename in files:
+                    return os.path.relpath(os.path.join(root, basename), workspace_root)
+    except Exception:
+        pass
+
+    return None
+
+
+def _process_file_for_display(
+    file_path: str,
+    workspace_root: Any,
+    title: Optional[str],
+    display_type: Optional[str]
+) -> Dict[str, Any]:
+    """Process a file path and return display data."""
+    import base64
+    import json
+    from pathlib import Path, PurePath
+    from .file_utils import _get_path, read_file_content, get_file_download_data
+    from .virtual_fs import VirtualFilesystem
+
+    result = {
+        "type": "display_inline",
+        "display_type": None,
+        "title": title,
+        "data": None,
+        "preview": None,
+        "filename": PurePath(file_path).name,
+        "file_path": file_path,
+        "downloadable": True,
+        "status": "success",
+        "error": None
+    }
+
+    ext = PurePath(file_path).suffix.lower()
+
+    # For absolute paths with physical filesystem, use the path directly
+    is_absolute_physical = file_path.startswith('/') and not isinstance(workspace_root, VirtualFilesystem)
+    if is_absolute_physical:
+        full_path = Path(file_path)
+    else:
+        full_path = _get_path(workspace_root, file_path)
+
+    if not full_path.exists():
+        result["status"] = "error"
+        result["error"] = f"File not found: {file_path}"
+        return result
+
+    # Image files
+    image_exts = {'.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico'}
+    if ext in image_exts or display_type == "image":
+        b64, filename, mime = get_file_download_data(workspace_root, file_path)
+        if b64:
+            result["display_type"] = "image"
+            result["data"] = b64
+            result["mime_type"] = mime
+            return result
+
+    # HTML files
+    if ext in {'.html', '.htm'} or display_type == "html":
+        content, is_text, error = read_file_content(workspace_root, file_path)
+        if content:
+            result["display_type"] = "html"
+            result["data"] = content
+            result["preview"] = content[:1000] + "..." if len(content) > 1000 else content
+            return result
+
+    # CSV files
+    if ext in {'.csv', '.tsv'} or display_type in ("csv", "dataframe"):
+        content, is_text, error = read_file_content(workspace_root, file_path)
+        if content:
+            try:
+                import pandas as pd
+                import io
+                sep = '\t' if ext == '.tsv' else ','
+                df = pd.read_csv(io.StringIO(content), sep=sep)
+                df_result = _process_dataframe_for_display(df, title)
+                df_result["filename"] = result["filename"]
+                df_result["file_path"] = file_path
+                df_result["downloadable"] = True
+                return df_result
+            except Exception as e:
+                result["display_type"] = "text"
+                result["data"] = content
+                result["error"] = f"Could not parse as CSV: {e}"
+                return result
+
+    # JSON files (check for Plotly)
+    if ext == '.json' or display_type == "json":
+        content, is_text, error = read_file_content(workspace_root, file_path)
+        if content:
+            try:
+                data = json.loads(content)
+                # Check if it's Plotly JSON
+                if isinstance(data, dict) and 'data' in data and isinstance(data.get('data'), list):
+                    result["display_type"] = "plotly"
+                    result["data"] = data
+                else:
+                    result["display_type"] = "json"
+                    result["data"] = data
+                return result
+            except json.JSONDecodeError:
+                result["display_type"] = "text"
+                result["data"] = content
+                return result
+
+    # PDF files
+    if ext == '.pdf':
+        b64, filename, mime = get_file_download_data(workspace_root, file_path)
+        if b64:
+            result["display_type"] = "pdf"
+            result["data"] = b64
+            result["mime_type"] = mime
+            return result
+
+    # Default: try to read as text
+    content, is_text, error = read_file_content(workspace_root, file_path)
+    if content:
+        result["display_type"] = "text"
+        result["data"] = content
+        return result
+
+    result["status"] = "error"
+    result["error"] = error or "Could not read file"
+    return result
+
+
+def _process_dataframe_for_display(df: Any, title: Optional[str]) -> Dict[str, Any]:
+    """Process a pandas DataFrame for display."""
+    result = {
+        "type": "display_inline",
+        "display_type": "dataframe",
+        "title": title,
+        "data": None,
+        "preview": None,
+        "downloadable": True,
+        "status": "success",
+        "error": None
+    }
+
+    # Create preview (first 10 rows)
+    preview_df = df.head(10)
+    result["preview"] = {
+        "html": preview_df.to_html(index=False, classes="dataframe-table"),
+        "rows_shown": len(preview_df),
+        "total_rows": len(df),
+        "columns": list(df.columns)
+    }
+
+    # Full data
+    result["data"] = {
+        "html": df.to_html(index=False, classes="dataframe-table"),
+        "records": df.to_dict('records'),
+        "columns": list(df.columns),
+        "shape": list(df.shape)
+    }
+
+    # CSV for download
+    result["csv"] = df.to_csv(index=False)
+
+    return result
+
+
 # =============================================================================
 # BASH TOOL
 # =============================================================================
@@ -898,7 +1492,8 @@ def bash(command: str, timeout: int = 60) -> Dict[str, Any]:
     Runs the command in the workspace directory. Use this for file operations,
     git commands, installing packages, or any shell operations.
 
-    Note: This tool is disabled in virtual filesystem mode for security reasons.
+    In virtual filesystem mode (Linux only), commands run in a bubblewrap sandbox
+    with network disabled for security.
 
     Args:
         command: The bash command to execute
@@ -924,15 +1519,9 @@ def bash(command: str, timeout: int = 60) -> Dict[str, Any]:
         # Run a script
         bash("python script.py")
     """
-    # Disable bash in virtual filesystem mode for security
+    # In virtual filesystem mode, use sandboxed execution
     if VIRTUAL_FS:
-        return {
-            "stdout": "",
-            "stderr": "Bash commands are disabled in virtual filesystem mode for security reasons. "
-                      "Use the built-in file tools (read_file, write_file, list_directory) instead.",
-            "return_code": 1,
-            "status": "error"
-        }
+        return _bash_sandboxed(command, timeout)
 
     try:
         result = subprocess.run(
@@ -965,3 +1554,69 @@ def bash(command: str, timeout: int = 60) -> Dict[str, Any]:
             "return_code": -1,
             "status": "error"
         }
+
+
+def _bash_sandboxed(command: str, timeout: int = 60) -> Dict[str, Any]:
+    """Execute bash command in sandboxed environment for virtual FS mode.
+
+    Uses bubblewrap (Linux) for sandboxing with:
+    - No network access
+    - Isolated PID namespace
+    - Read-only system directories
+    - Writable workspace directory synced with VirtualFilesystem
+    """
+    from .sandbox import get_executor_for_session, get_available_sandbox
+    from .virtual_fs import get_session_manager
+
+    # Get current session context
+    session_id = get_tool_session_context()
+    if not session_id:
+        return {
+            "stdout": "",
+            "stderr": "No session context available for sandboxed execution",
+            "return_code": 1,
+            "status": "error"
+        }
+
+    # Check if sandbox is available
+    sandbox = get_available_sandbox()
+    if sandbox is None:
+        return {
+            "stdout": "",
+            "stderr": "Bash commands require bubblewrap (bwrap) or Docker in virtual filesystem mode. "
+                      "Install bubblewrap: apt-get install bubblewrap",
+            "return_code": 1,
+            "status": "error"
+        }
+
+    # Get the virtual filesystem for this session
+    fs = get_session_manager().get_filesystem(session_id)
+    if fs is None:
+        return {
+            "stdout": "",
+            "stderr": "Session filesystem not found",
+            "return_code": 1,
+            "status": "error"
+        }
+
+    # Get or create executor for this session
+    executor = get_executor_for_session(session_id, fs)
+
+    # Execute command in sandbox
+    return executor.execute(command, timeout=timeout)
+
+
+# Add a think tool
+def think_tool(reflection: str) -> str:
+    """A tool to reflect on your actions and reasoning.
+
+    This tool allows you to pause and think about your next steps,
+    evaluate your current state, or reconsider your approach. Use 
+    this tool to generate internal reflections that the user can see.
+
+    Args:
+        reflection: The reflection text
+    Returns:
+        str: The recorded reflection
+    """
+    return reflection