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

cowork_dash/app.py

@@ -17,7 +17,15 @@ from typing import Optional, Dict, Any, List
 from dotenv import load_dotenv
 load_dotenv()
 
-from dash import Dash, html, Input, Output, State, callback_context, no_update, ALL
+# Early pandas import to prevent circular import issues with Plotly's JSON serializer.
+# Plotly lazily imports pandas and checks `obj is pd.NaT` which fails if pandas
+# is partially initialized due to concurrent imports.
+try:
+    import pandas
+except (ImportError, AttributeError):
+    pass
+
+from dash import Dash, html, dcc, Input, Output, State, callback_context, no_update, ALL
 from dash.exceptions import PreventUpdate
 import dash_mantine_components as dmc
 from dash_iconify import DashIconify
@@ -27,7 +35,7 @@ from .canvas import export_canvas_to_markdown, load_canvas_from_markdown
 from .file_utils import build_file_tree, render_file_tree, read_file_content, get_file_download_data, load_folder_contents
 from .components import (
     format_message, format_loading, format_thinking, format_todos_inline, render_canvas_items, format_tool_calls_inline,
-    format_interrupt
+    format_interrupt, extract_display_inline_results, render_display_inline_result, extract_thinking_from_tool_calls
 )
 from .layout import create_layout as create_layout_component
 from .virtual_fs import get_session_manager
@@ -243,6 +251,7 @@ _agent_state = {
     "thinking": "",
     "todos": [],
     "tool_calls": [],  # Current turn's tool calls (reset each turn)
+    "display_inline_items": [],  # Items pushed by display_inline tool (bypasses LangGraph)
     "canvas": load_canvas_from_markdown(WORKSPACE_ROOT) if not USE_VIRTUAL_FS else [],  # Load from canvas.md if exists (physical FS only)
     "response": "",
     "error": None,
@@ -250,6 +259,7 @@ _agent_state = {
     "last_update": time.time(),
     "start_time": None,  # Track when agent started for response time calculation
     "stop_requested": False,  # Flag to request agent stop
+    "stop_event": None,  # Threading event for immediate stop signaling
 }
 _agent_state_lock = threading.Lock()
 
@@ -267,11 +277,13 @@ def _get_default_agent_state() -> Dict[str, Any]:
         "thinking": "",
         "todos": [],
         "tool_calls": [],
+        "display_inline_items": [],  # Items pushed by display_inline tool (bypasses LangGraph)
         "canvas": [],
         "response": "",
         "error": None,
         "interrupt": None,
         "last_update": time.time(),
+        "stop_event": None,  # Threading event for immediate stop signaling
         "start_time": None,
         "stop_requested": False,
     }
@@ -315,7 +327,9 @@ def _get_session_state_lock() -> threading.Lock:
 
 
 def request_agent_stop(session_id: Optional[str] = None):
-    """Request the agent to stop execution.
+    """Request the agent to stop execution immediately.
+
+    Sets the stop_requested flag and signals the stop_event for immediate interruption.
 
     Args:
         session_id: Session ID for virtual FS mode, None for physical FS mode.
@@ -325,10 +339,16 @@ def request_agent_stop(session_id: Optional[str] = None):
         with _session_agents_lock:
             state["stop_requested"] = True
             state["last_update"] = time.time()
+            # Signal the stop event for immediate interruption
+            if state.get("stop_event"):
+                state["stop_event"].set()
     else:
         with _agent_state_lock:
             _agent_state["stop_requested"] = True
             _agent_state["last_update"] = time.time()
+            # Signal the stop event for immediate interruption
+            if _agent_state.get("stop_event"):
+                _agent_state["stop_event"].set()
 
 
 def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: str = None, session_id: Optional[str] = None):
@@ -359,6 +379,12 @@ def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: st
             current_state["running"] = False
         return
 
+    # Create a stop event for immediate interruption
+    stop_event = threading.Event()
+    with state_lock:
+        current_state["stop_event"] = stop_event
+        current_state["stop_requested"] = False  # Reset stop flag
+
     # Track tool calls by their ID for updating status
     tool_call_map = {}
 
@@ -405,6 +431,17 @@ def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: st
             # Resume from interrupt
             from langgraph.types import Command
             agent_input = Command(resume=resume_data)
+
+            # Rebuild tool_call_map from existing tool calls and mark pending ones as running
+            with state_lock:
+                for tc in current_state.get("tool_calls", []):
+                    tc_id = tc.get("id")
+                    if tc_id:
+                        tool_call_map[tc_id] = tc
+                        # Mark pending tool calls back to running since we're resuming
+                        if tc.get("status") == "pending":
+                            tc["status"] = "running"
+                current_state["last_update"] = time.time()
         else:
             # Inject workspace context into the message if available
             if workspace_path:
@@ -415,14 +452,15 @@ def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: st
             agent_input = {"messages": [{"role": "user", "content": message_with_context}]}
 
         for update in current_agent.stream(agent_input, stream_mode="updates", config=stream_config):
-            # Check if stop was requested
-            with state_lock:
-                if current_state.get("stop_requested"):
-                    current_state["response"] = current_state.get("response", "") + "\n\nAgent stopped by user."
+            # Check if stop was requested (via flag or event)
+            if stop_event.is_set() or current_state.get("stop_requested"):
+                with state_lock:
+                    current_state["response"] = current_state.get("response", "") + "\n\n⏹️ Agent stopped by user."
                     current_state["running"] = False
                     current_state["stop_requested"] = False
+                    current_state["stop_event"] = None
                     current_state["last_update"] = time.time()
-                    return
+                return
 
             # Check for interrupt
             if isinstance(update, dict) and "__interrupt__" in update:
@@ -431,6 +469,10 @@ def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: st
                 with state_lock:
                     current_state["interrupt"] = interrupt_data
                     current_state["running"] = False  # Pause until user responds
+                    # Mark any "running" tool calls as "pending" since we're waiting for user approval
+                    for tc in current_state["tool_calls"]:
+                        if tc.get("status") == "running":
+                            tc["status"] = "pending"
                     current_state["last_update"] = time.time()
                 return  # Exit stream, wait for user to resume
 
@@ -444,14 +486,26 @@ def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: st
 
                             # Capture AIMessage tool_calls
                             if msg_type == 'AIMessage' and hasattr(last_msg, 'tool_calls') and last_msg.tool_calls:
-                                new_tool_calls = []
-                                for tc in last_msg.tool_calls:
-                                    serialized = _serialize_tool_call(tc)
-                                    tool_call_map[serialized["id"]] = serialized
-                                    new_tool_calls.append(serialized)
-
                                 with state_lock:
-                                    current_state["tool_calls"].extend(new_tool_calls)
+                                    # Get existing tool call IDs to avoid duplicates
+                                    existing_ids = {tc.get("id") for tc in current_state["tool_calls"]}
+
+                                    for tc in last_msg.tool_calls:
+                                        serialized = _serialize_tool_call(tc)
+                                        tc_id = serialized["id"]
+
+                                        # Only add if not already in the list (avoid duplicates on resume)
+                                        if tc_id not in existing_ids:
+                                            tool_call_map[tc_id] = serialized
+                                            current_state["tool_calls"].append(serialized)
+                                            existing_ids.add(tc_id)
+                                        else:
+                                            # Update the map to reference the existing tool call
+                                            for existing_tc in current_state["tool_calls"]:
+                                                if existing_tc.get("id") == tc_id:
+                                                    tool_call_map[tc_id] = existing_tc
+                                                    break
+
                                     current_state["last_update"] = time.time()
 
                             elif msg_type == 'ToolMessage' and hasattr(last_msg, 'name'):
@@ -480,10 +534,16 @@ def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: st
                                             content_lower.startswith("traceback")):
                                             status = "error"
 
-                                    # Truncate result for display
-                                    result_display = str(content)
-                                    if len(result_display) > 1000:
-                                        result_display = result_display[:1000] + "..."
+                                    # display_inline now pushes rich content directly to queue
+                                    # and returns a simple confirmation message, so no special handling needed
+                                    if isinstance(content, str):
+                                        # Truncate result for display
+                                        result_display = content[:1000] + "..." if len(content) > 1000 else content
+                                    else:
+                                        # Convert other types to string and truncate
+                                        result_display = str(content)
+                                        if len(result_display) > 1000:
+                                            result_display = result_display[:1000] + "..."
 
                                     _update_tool_call_result(tool_call_id, result_display, status)
 
@@ -688,6 +748,7 @@ def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: st
 
         with state_lock:
             current_state["running"] = False
+            current_state["stop_event"] = None  # Clean up stop event
             current_state["last_update"] = time.time()
 
 
@@ -891,6 +952,7 @@ def resume_agent_from_interrupt(decision: str, action: str = "approve", action_r
 
         with state_lock:
             current_state["running"] = False
+            current_state["stop_event"] = None  # Clean up stop event
             current_state["response"] = f"Action rejected{tool_info}: {reject_message}"
             current_state["last_update"] = time.time()
 
@@ -947,9 +1009,34 @@ def get_agent_state(session_id: Optional[str] = None) -> Dict[str, Any]:
         state["tool_calls"] = copy.deepcopy(current_state["tool_calls"])
         state["todos"] = copy.deepcopy(current_state["todos"])
         state["canvas"] = copy.deepcopy(current_state["canvas"])
+        state["display_inline_items"] = copy.deepcopy(current_state.get("display_inline_items", []))
         return state
 
 
+def push_display_inline_item(item: Dict[str, Any], session_id: Optional[str] = None):
+    """Push a display_inline item to the agent state (thread-safe).
+
+    This is called by the display_inline tool to store rich content
+    that bypasses LangGraph serialization.
+
+    Args:
+        item: The display result dict with type, display_type, data, etc.
+        session_id: Session ID for virtual FS mode, None for physical FS mode.
+    """
+    if USE_VIRTUAL_FS and session_id:
+        current_state = _get_session_state(session_id)
+        state_lock = _session_agents_lock
+    else:
+        current_state = _agent_state
+        state_lock = _agent_state_lock
+
+    with state_lock:
+        if "display_inline_items" not in current_state:
+            current_state["display_inline_items"] = []
+        current_state["display_inline_items"].append(item)
+        current_state["last_update"] = time.time()
+
+
 def reset_agent_state(session_id: Optional[str] = None):
     """Reset agent state for a fresh session (thread-safe).
 
@@ -971,8 +1058,11 @@ def reset_agent_state(session_id: Optional[str] = None):
         current_state["thinking"] = ""
         current_state["todos"] = []
         current_state["tool_calls"] = []
+        current_state["display_inline_items"] = []
         current_state["response"] = ""
         current_state["error"] = None
+        current_state["stop_event"] = None
+        current_state["stop_requested"] = False
         current_state["interrupt"] = None
         current_state["start_time"] = None
         current_state["stop_requested"] = False
@@ -1087,8 +1177,10 @@ def display_initial_messages(history, theme, skip_render, session_initialized, s
     for msg in history:
         msg_response_time = msg.get("response_time") if msg["role"] == "assistant" else None
         messages.append(format_message(msg["role"], msg["content"], colors, STYLES, is_new=False, response_time=msg_response_time))
+        # Order: tool calls -> todos -> thinking -> display inline items
         # Render tool calls stored with this message
         if msg.get("tool_calls"):
+            # Show collapsed tool calls section first
             tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
             if tool_calls_block:
                 messages.append(tool_calls_block)
@@ -1097,6 +1189,18 @@ def display_initial_messages(history, theme, skip_render, session_initialized, s
             todos_block = format_todos_inline(msg["todos"], colors)
             if todos_block:
                 messages.append(todos_block)
+        # Extract and show thinking from tool calls
+        if msg.get("tool_calls"):
+            thinking_blocks = extract_thinking_from_tool_calls(msg["tool_calls"], colors)
+            messages.extend(thinking_blocks)
+            # Extract and show display_inline results prominently
+            inline_results = extract_display_inline_results(msg["tool_calls"], colors)
+            messages.extend(inline_results)
+        # Render display_inline items stored with this message
+        if msg.get("display_inline_items"):
+            for item in msg["display_inline_items"]:
+                rendered = render_display_inline_result(item, colors)
+                messages.append(rendered)
     return messages, False, True, new_session_id
 
 
@@ -1130,7 +1234,7 @@ def initialize_file_tree_for_session(session_initialized, session_id, current_wo
     current_workspace_dir = workspace_root.path(current_workspace) if current_workspace else workspace_root.root
 
     # Build and render file tree
-    return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES)
+    return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES, workspace_root=workspace_root)
 
 
 # Chat callbacks
@@ -1165,8 +1269,9 @@ def handle_send_immediate(n_clicks, n_submit, message, history, theme, current_w
         is_new = (i == len(history) - 1)
         msg_response_time = m.get("response_time") if m["role"] == "assistant" else None
         messages.append(format_message(m["role"], m["content"], colors, STYLES, is_new=is_new, response_time=msg_response_time))
-        # Render tool calls stored with this message
+        # Order: tool calls -> todos -> thinking -> display inline items
         if m.get("tool_calls"):
+            # Show collapsed tool calls section first
             tool_calls_block = format_tool_calls_inline(m["tool_calls"], colors)
             if tool_calls_block:
                 messages.append(tool_calls_block)
@@ -1175,6 +1280,13 @@ def handle_send_immediate(n_clicks, n_submit, message, history, theme, current_w
             todos_block = format_todos_inline(m["todos"], colors)
             if todos_block:
                 messages.append(todos_block)
+        # Extract and show thinking from tool calls
+        if m.get("tool_calls"):
+            thinking_blocks = extract_thinking_from_tool_calls(m["tool_calls"], colors)
+            messages.extend(thinking_blocks)
+            # Extract and show display_inline results prominently
+            inline_results = extract_display_inline_results(m["tool_calls"], colors)
+            messages.extend(inline_results)
 
     messages.append(format_loading(colors))
 
@@ -1220,14 +1332,18 @@ def poll_agent_updates(n_intervals, history, pending_message, theme, session_id)
     history = history or []
     colors = get_colors(theme or "light")
 
+    # Get display_inline items from agent state (bypasses LangGraph serialization)
+    display_inline_items = state.get("display_inline_items", [])
+
     def render_history_messages(history_items):
-        """Render all history items including tool calls and todos."""
+        """Render all history items including tool calls, display_inline items, and todos."""
         messages = []
         for msg in history_items:
             msg_response_time = msg.get("response_time") if msg["role"] == "assistant" else None
             messages.append(format_message(msg["role"], msg["content"], colors, STYLES, response_time=msg_response_time))
-            # Render tool calls stored with this message
+            # Order: tool calls -> todos -> thinking -> display inline items
             if msg.get("tool_calls"):
+                # Show collapsed tool calls section first
                 tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
                 if tool_calls_block:
                     messages.append(tool_calls_block)
@@ -1236,6 +1352,18 @@ def poll_agent_updates(n_intervals, history, pending_message, theme, session_id)
                 todos_block = format_todos_inline(msg["todos"], colors)
                 if todos_block:
                     messages.append(todos_block)
+            # Extract and show thinking from tool calls
+            if msg.get("tool_calls"):
+                thinking_blocks = extract_thinking_from_tool_calls(msg["tool_calls"], colors)
+                messages.extend(thinking_blocks)
+                # Extract and show display_inline results prominently
+                inline_results = extract_display_inline_results(msg["tool_calls"], colors)
+                messages.extend(inline_results)
+            # Render display_inline items stored with this message
+            if msg.get("display_inline_items"):
+                for item in msg["display_inline_items"]:
+                    rendered = render_display_inline_result(item, colors)
+                    messages.append(rendered)
         return messages
 
     # Check for interrupt (human-in-the-loop)
@@ -1243,13 +1371,9 @@ def poll_agent_updates(n_intervals, history, pending_message, theme, session_id)
         # Agent is paused waiting for user input
         messages = render_history_messages(history)
 
-        # Add current turn's thinking/tool_calls/todos before interrupt
-        if state["thinking"]:
-            thinking_block = format_thinking(state["thinking"], colors)
-            if thinking_block:
-                messages.append(thinking_block)
-
+        # Order: tool calls -> todos -> thinking -> display inline items
         if state.get("tool_calls"):
+            # Show collapsed tool calls section first
             tool_calls_block = format_tool_calls_inline(state["tool_calls"], colors)
             if tool_calls_block:
                 messages.append(tool_calls_block)
@@ -1259,6 +1383,19 @@ def poll_agent_updates(n_intervals, history, pending_message, theme, session_id)
             if todos_block:
                 messages.append(todos_block)
 
+        if state.get("tool_calls"):
+            # Extract and show thinking from tool calls
+            thinking_blocks = extract_thinking_from_tool_calls(state["tool_calls"], colors)
+            messages.extend(thinking_blocks)
+            # Extract and show display_inline results prominently
+            inline_results = extract_display_inline_results(state["tool_calls"], colors)
+            messages.extend(inline_results)
+
+        # Render any queued display_inline items (bypasses LangGraph serialization)
+        for item in display_inline_items:
+            rendered = render_display_inline_result(item, colors)
+            messages.append(rendered)
+
         # Add interrupt UI
         interrupt_block = format_interrupt(state["interrupt"], colors)
         if interrupt_block:
@@ -1274,15 +1411,20 @@ def poll_agent_updates(n_intervals, history, pending_message, theme, session_id)
         if state.get("start_time"):
             response_time = time.time() - state["start_time"]
 
-        # Agent finished - store tool calls and todos with the USER message (they appear after user msg)
+        # Agent finished - store tool calls, todos, and display_inline items with the USER message
+        # (they appear after user msg in the UI)
+        saved_display_inline_items = False
         if history:
-            # Find the last user message and attach tool calls and todos to it
+            # Find the last user message and attach tool calls, todos, and display_inline items to it
             for i in range(len(history) - 1, -1, -1):
                 if history[i]["role"] == "user":
                     if state.get("tool_calls"):
                         history[i]["tool_calls"] = state["tool_calls"]
                     if state.get("todos"):
                         history[i]["todos"] = state["todos"]
+                    if display_inline_items:
+                        history[i]["display_inline_items"] = display_inline_items
+                        saved_display_inline_items = True
                     break
 
         # Add assistant response to history (with response time)
@@ -1295,12 +1437,13 @@ def poll_agent_updates(n_intervals, history, pending_message, theme, session_id)
         history.append(assistant_msg)
 
         # Render all history (tool calls and todos are now part of history)
+        # Order: tool calls -> todos -> thinking -> display inline items
         final_messages = []
         for i, msg in enumerate(history):
             is_new = (i >= len(history) - 1)
             msg_response_time = msg.get("response_time") if msg["role"] == "assistant" else None
             final_messages.append(format_message(msg["role"], msg["content"], colors, STYLES, is_new=is_new, response_time=msg_response_time))
-            # Render tool calls stored with this message
+            # Show collapsed tool calls section first
             if msg.get("tool_calls"):
                 tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
                 if tool_calls_block:
@@ -1310,21 +1453,35 @@ def poll_agent_updates(n_intervals, history, pending_message, theme, session_id)
                 todos_block = format_todos_inline(msg["todos"], colors)
                 if todos_block:
                     final_messages.append(todos_block)
+            # Extract and show thinking from tool calls
+            if msg.get("tool_calls"):
+                thinking_blocks = extract_thinking_from_tool_calls(msg["tool_calls"], colors)
+                final_messages.extend(thinking_blocks)
+                # Extract and show display_inline results prominently
+                inline_results = extract_display_inline_results(msg["tool_calls"], colors)
+                final_messages.extend(inline_results)
+            # Render display_inline items stored with this message
+            if msg.get("display_inline_items"):
+                for item in msg["display_inline_items"]:
+                    rendered = render_display_inline_result(item, colors)
+                    final_messages.append(rendered)
+
+        # Render any NEW queued display_inline items only if not already saved to history
+        # (avoids duplicate rendering)
+        if not saved_display_inline_items:
+            for item in display_inline_items:
+                rendered = render_display_inline_result(item, colors)
+                final_messages.append(rendered)
 
         # Disable polling, set skip flag to prevent display_initial_messages from re-rendering
         return final_messages, history, True, True
     else:
-        # Agent still running - show loading with current thinking/tool_calls/todos
+        # Agent still running - show loading with current tool_calls/todos/thinking
         messages = render_history_messages(history)
 
-        # Add current thinking if available
-        if state["thinking"]:
-            thinking_block = format_thinking(state["thinking"], colors)
-            if thinking_block:
-                messages.append(thinking_block)
-
-        # Add current tool calls if available
+        # Order: tool calls -> todos -> thinking -> display inline items
         if state.get("tool_calls"):
+            # Show collapsed tool calls section first
             tool_calls_block = format_tool_calls_inline(state["tool_calls"], colors)
             if tool_calls_block:
                 messages.append(tool_calls_block)
@@ -1335,6 +1492,19 @@ def poll_agent_updates(n_intervals, history, pending_message, theme, session_id)
             if todos_block:
                 messages.append(todos_block)
 
+        if state.get("tool_calls"):
+            # Extract and show thinking from tool calls
+            thinking_blocks = extract_thinking_from_tool_calls(state["tool_calls"], colors)
+            messages.extend(thinking_blocks)
+            # Extract and show display_inline results prominently
+            inline_results = extract_display_inline_results(state["tool_calls"], colors)
+            messages.extend(inline_results)
+
+        # Render any queued display_inline items (bypasses LangGraph serialization)
+        for item in display_inline_items:
+            rendered = render_display_inline_result(item, colors)
+            messages.append(rendered)
+
         # Add loading indicator
         messages.append(format_loading(colors))
 
@@ -1380,12 +1550,14 @@ def handle_stop_button(n_clicks, history, theme, session_id):
     request_agent_stop(session_id)
 
     # Render current messages with a stopping indicator
+    # Order: tool calls -> todos -> thinking -> display inline items
     def render_history_messages(history):
         messages = []
         for i, msg in enumerate(history):
             msg_response_time = msg.get("response_time") if msg["role"] == "assistant" else None
             messages.append(format_message(msg["role"], msg["content"], colors, STYLES, is_new=False, response_time=msg_response_time))
             if msg.get("tool_calls"):
+                # Show collapsed tool calls section first
                 tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
                 if tool_calls_block:
                     messages.append(tool_calls_block)
@@ -1393,6 +1565,18 @@ def handle_stop_button(n_clicks, history, theme, session_id):
                 todos_block = format_todos_inline(msg["todos"], colors)
                 if todos_block:
                     messages.append(todos_block)
+            if msg.get("tool_calls"):
+                # Extract and show thinking from tool calls
+                thinking_blocks = extract_thinking_from_tool_calls(msg["tool_calls"], colors)
+                messages.extend(thinking_blocks)
+                # Extract and show display_inline results prominently
+                inline_results = extract_display_inline_results(msg["tool_calls"], colors)
+                messages.extend(inline_results)
+            # Render display_inline items stored with this message
+            if msg.get("display_inline_items"):
+                for item in msg["display_inline_items"]:
+                    rendered = render_display_inline_result(item, colors)
+                    messages.append(rendered)
         return messages
 
     messages = render_history_messages(history)
@@ -1468,12 +1652,13 @@ def handle_interrupt_response(approve_clicks, reject_clicks, edit_clicks, input_
     resume_agent_from_interrupt(decision, action, session_id=session_id)
 
     # Show loading state while agent resumes
+    # Order: tool calls -> todos -> thinking -> display inline items
     messages = []
     for msg in history:
         msg_response_time = msg.get("response_time") if msg["role"] == "assistant" else None
         messages.append(format_message(msg["role"], msg["content"], colors, STYLES, response_time=msg_response_time))
-        # Render tool calls stored with this message
         if msg.get("tool_calls"):
+            # Show collapsed tool calls section first
             tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
             if tool_calls_block:
                 messages.append(tool_calls_block)
@@ -1482,6 +1667,18 @@ def handle_interrupt_response(approve_clicks, reject_clicks, edit_clicks, input_
             todos_block = format_todos_inline(msg["todos"], colors)
             if todos_block:
                 messages.append(todos_block)
+        if msg.get("tool_calls"):
+            # Extract and show thinking from tool calls
+            thinking_blocks = extract_thinking_from_tool_calls(msg["tool_calls"], colors)
+            messages.extend(thinking_blocks)
+            # Extract and show display_inline results prominently
+            inline_results = extract_display_inline_results(msg["tool_calls"], colors)
+            messages.extend(inline_results)
+        # Render display_inline items stored with this message
+        if msg.get("display_inline_items"):
+            for item in msg["display_inline_items"]:
+                rendered = render_display_inline_result(item, colors)
+                messages.append(rendered)
 
     messages.append(format_loading(colors))
 
@@ -1493,7 +1690,8 @@ def handle_interrupt_response(approve_clicks, reject_clicks, edit_clicks, input_
 @app.callback(
     [Output({"type": "folder-children", "path": ALL}, "style"),
      Output({"type": "folder-icon", "path": ALL}, "style"),
-     Output({"type": "folder-children", "path": ALL}, "children")],
+     Output({"type": "folder-children", "path": ALL}, "children"),
+     Output("expanded-folders", "data")],
     Input({"type": "folder-icon", "path": ALL}, "n_clicks"),
     [State({"type": "folder-header", "path": ALL}, "id"),
      State({"type": "folder-header", "path": ALL}, "data-realpath"),
@@ -1503,16 +1701,18 @@ def handle_interrupt_response(approve_clicks, reject_clicks, edit_clicks, input_
      State({"type": "folder-icon", "path": ALL}, "style"),
      State({"type": "folder-children", "path": ALL}, "children"),
      State("theme-store", "data"),
-     State("session-id", "data")],
+     State("session-id", "data"),
+     State("expanded-folders", "data")],
     prevent_initial_call=True
 )
-def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, children_styles, icon_styles, children_content, theme, session_id):
+def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, children_styles, icon_styles, children_content, theme, session_id, expanded_folders):
     """Toggle folder expansion and lazy load contents if needed."""
     ctx = callback_context
     if not ctx.triggered or not any(n_clicks):
         raise PreventUpdate
 
     colors = get_colors(theme or "light")
+    expanded_folders = expanded_folders or []
 
     # Get workspace for this session (virtual or physical)
     workspace_root = get_workspace_for_session(session_id)
@@ -1538,6 +1738,9 @@ def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, chil
     new_icon_styles = []
     new_children_content = []
 
+    # Track whether we're expanding or collapsing the clicked folder
+    will_expand = None
+
     # Process all folder-children elements
     for i, child_id in enumerate(children_ids):
         path = child_id["path"]
@@ -1547,6 +1750,7 @@ def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, chil
         if path == clicked_path:
             # Toggle this folder
             is_expanded = current_style.get("display") != "none"
+            will_expand = not is_expanded
             new_children_styles.append({"display": "none" if is_expanded else "block"})
 
             # If expanding and content is just "Loading...", load the actual contents
@@ -1560,7 +1764,9 @@ def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, chil
                         folder_items = load_folder_contents(folder_rel_path, workspace_root)
                         loaded_content = render_file_tree(folder_items, colors, STYLES,
                                                           level=folder_rel_path.count("/") + folder_rel_path.count("\\") + 1,
-                                                          parent_path=folder_rel_path)
+                                                          parent_path=folder_rel_path,
+                                                          expanded_folders=expanded_folders,
+                                                          workspace_root=workspace_root)
                         new_children_content.append(loaded_content if loaded_content else current_content)
                     except Exception as e:
                         print(f"Error loading folder {folder_rel_path}: {e}")
@@ -1597,14 +1803,23 @@ def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, chil
         else:
             new_icon_styles.append(current_icon_style)
 
-    return new_children_styles, new_icon_styles, new_children_content
+    # Update expanded folders list
+    new_expanded_folders = list(expanded_folders)
+    if will_expand is not None:
+        if will_expand and clicked_path not in new_expanded_folders:
+            new_expanded_folders.append(clicked_path)
+        elif not will_expand and clicked_path in new_expanded_folders:
+            new_expanded_folders.remove(clicked_path)
+
+    return new_children_styles, new_icon_styles, new_children_content, new_expanded_folders
 
 
 # Enter folder callback - triggered by double-clicking folder name (changes workspace root)
 @app.callback(
     [Output("current-workspace-path", "data"),
      Output("workspace-breadcrumb", "children"),
-     Output("file-tree", "children", allow_duplicate=True)],
+     Output("file-tree", "children", allow_duplicate=True),
+     Output("expanded-folders", "data", allow_duplicate=True)],
     [Input({"type": "folder-select", "path": ALL}, "n_clicks"),
      Input("breadcrumb-root", "n_clicks"),
      Input({"type": "breadcrumb-segment", "index": ALL}, "n_clicks")],
@@ -1720,13 +1935,14 @@ def enter_folder(folder_clicks, root_clicks, breadcrumb_clicks, folder_ids, fold
     else:
         workspace_full_path = workspace_root / new_path if new_path else workspace_root
 
-    # Render new file tree
+    # Render new file tree (reset expanded folders when navigating)
     file_tree = render_file_tree(
         build_file_tree(workspace_full_path, workspace_full_path),
-        colors, STYLES
+        colors, STYLES,
+        workspace_root=workspace_root
     )
 
-    return new_path, breadcrumb_children, file_tree
+    return new_path, breadcrumb_children, file_tree, []  # Reset expanded folders
 
 
 # File click - open modal
@@ -1805,23 +2021,342 @@ def open_file_modal(all_n_clicks, all_ids, click_tracker, theme, session_id):
     colors = get_colors(theme or "light")
     content, is_text, error = read_file_content(workspace_root, file_path)
     filename = Path(file_path).name
-
-    if is_text and content:
-        modal_content = html.Pre(
-            content,
-            style={
-                "background": colors["bg_tertiary"],
-                "padding": "16px",
-                "fontSize": "12px",
-                "fontFamily": "'IBM Plex Mono', monospace",
-                "overflow": "auto",
-                "maxHeight": "60vh",
-                "whiteSpace": "pre-wrap",
-                "wordBreak": "break-word",
-                "margin": "0",
-                "color": colors["text_primary"],
-            }
-        )
+    file_ext = Path(file_path).suffix.lower()
+
+    # Define file type categories for binary previews
+    image_exts = {'.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.ico', '.bmp'}
+    pdf_exts = {'.pdf'}
+
+    # Check for binary preview types first
+    if file_ext in image_exts | pdf_exts:
+        b64, _, mime = get_file_download_data(workspace_root, file_path)
+        if b64:
+            data_url = f"data:{mime};base64,{b64}"
+
+            if file_ext in image_exts:
+                # Image preview
+                modal_content = html.Div([
+                    html.Img(
+                        src=data_url,
+                        style={
+                            "maxWidth": "100%",
+                            "maxHeight": "80vh",
+                            "display": "block",
+                            "margin": "0 auto",
+                            "borderRadius": "4px",
+                        }
+                    )
+                ], style={"textAlign": "center"})
+
+            elif file_ext in pdf_exts:
+                # PDF preview via embed
+                modal_content = html.Embed(
+                    src=data_url,
+                    type="application/pdf",
+                    style={
+                        "width": "100%",
+                        "height": "80vh",
+                        "borderRadius": "4px",
+                    }
+                )
+        else:
+            # Failed to read binary file
+            modal_content = html.Div([
+                html.P("Failed to load file preview", style={
+                    "color": colors["text_muted"],
+                    "textAlign": "center",
+                    "padding": "40px",
+                }),
+                html.P("Click Download to save the file.", style={
+                    "color": colors["text_muted"],
+                    "textAlign": "center",
+                    "fontSize": "13px",
+                })
+            ])
+
+    elif is_text and content:
+        # HTML files get rendered preview
+        if file_ext in ('.html', '.htm'):
+            modal_content = html.Div([
+                # Tab buttons for switching views
+                html.Div([
+                    html.Button("Preview", id="html-preview-tab", n_clicks=0,
+                        className="html-tab-btn html-tab-active",
+                        style={"marginRight": "8px", "padding": "6px 12px", "border": "none",
+                               "borderRadius": "4px", "cursor": "pointer",
+                               "background": colors["accent"], "color": "#fff"}),
+                    html.Button("Source", id="html-source-tab", n_clicks=0,
+                        className="html-tab-btn",
+                        style={"padding": "6px 12px", "border": f"1px solid {colors['border']}",
+                               "borderRadius": "4px", "cursor": "pointer",
+                               "background": "transparent", "color": colors["text_primary"]}),
+                ], style={"marginBottom": "12px", "display": "flex"}),
+                # Preview iframe (default visible)
+                html.Iframe(
+                    srcDoc=content,
+                    style={
+                        "width": "100%",
+                        "height": "80vh",
+                        "border": f"1px solid {colors['border']}",
+                        "borderRadius": "4px",
+                        "background": "#fff",
+                    },
+                    id="html-preview-frame"
+                ),
+                # Source code (hidden by default)
+                html.Pre(
+                    content,
+                    id="html-source-code",
+                    style={
+                        "display": "none",
+                        "background": colors["bg_tertiary"],
+                        "padding": "16px",
+                        "fontSize": "12px",
+                        "fontFamily": "'IBM Plex Mono', monospace",
+                        "overflow": "auto",
+                        "maxHeight": "80vh",
+                        "whiteSpace": "pre-wrap",
+                        "wordBreak": "break-word",
+                        "margin": "0",
+                        "color": colors["text_primary"],
+                        "border": f"1px solid {colors['border']}",
+                        "borderRadius": "4px",
+                    }
+                )
+            ])
+        elif file_ext == '.json':
+            # Try to parse as Plotly JSON figure
+            plotly_figure = None
+            try:
+                data = json.loads(content)
+                # Check if it looks like a Plotly figure (has 'data' key with list)
+                if isinstance(data, dict) and 'data' in data and isinstance(data['data'], list):
+                    plotly_figure = data
+            except (json.JSONDecodeError, KeyError):
+                pass
+
+            if plotly_figure:
+                # Render as interactive Plotly chart with source toggle
+                modal_content = html.Div([
+                    # Tab buttons for switching views
+                    html.Div([
+                        html.Button("Chart", id="html-preview-tab", n_clicks=0,
+                            className="html-tab-btn html-tab-active",
+                            style={"marginRight": "8px", "padding": "6px 12px", "border": "none",
+                                   "borderRadius": "4px", "cursor": "pointer",
+                                   "background": colors["accent"], "color": "#fff"}),
+                        html.Button("JSON", id="html-source-tab", n_clicks=0,
+                            className="html-tab-btn",
+                            style={"padding": "6px 12px", "border": f"1px solid {colors['border']}",
+                                   "borderRadius": "4px", "cursor": "pointer",
+                                   "background": "transparent", "color": colors["text_primary"]}),
+                    ], style={"marginBottom": "12px", "display": "flex"}),
+                    # Plotly chart (default visible)
+                    html.Div([
+                        dcc.Graph(
+                            figure=plotly_figure,
+                            style={"height": "75vh"},
+                            config={"displayModeBar": True, "responsive": True}
+                        )
+                    ], id="html-preview-frame", style={
+                        "border": f"1px solid {colors['border']}",
+                        "borderRadius": "4px",
+                        "background": "#fff",
+                    }),
+                    # JSON source (hidden by default)
+                    html.Pre(
+                        json.dumps(plotly_figure, indent=2),
+                        id="html-source-code",
+                        style={
+                            "display": "none",
+                            "background": colors["bg_tertiary"],
+                            "padding": "16px",
+                            "fontSize": "12px",
+                            "fontFamily": "'IBM Plex Mono', monospace",
+                            "overflow": "auto",
+                            "maxHeight": "80vh",
+                            "whiteSpace": "pre-wrap",
+                            "wordBreak": "break-word",
+                            "margin": "0",
+                            "color": colors["text_primary"],
+                            "border": f"1px solid {colors['border']}",
+                            "borderRadius": "4px",
+                        }
+                    )
+                ])
+            else:
+                # Regular JSON - show formatted
+                try:
+                    formatted = json.dumps(json.loads(content), indent=2)
+                except json.JSONDecodeError:
+                    formatted = content
+                modal_content = html.Pre(
+                    formatted,
+                    style={
+                        "background": colors["bg_tertiary"],
+                        "padding": "16px",
+                        "fontSize": "12px",
+                        "fontFamily": "'IBM Plex Mono', monospace",
+                        "overflow": "auto",
+                        "maxHeight": "80vh",
+                        "whiteSpace": "pre-wrap",
+                        "wordBreak": "break-word",
+                        "margin": "0",
+                        "color": colors["text_primary"],
+                    }
+                )
+        elif file_ext in ('.csv', '.tsv'):
+            # CSV/TSV files - render as table with raw view option
+            import io as _io
+            try:
+                import pandas as pd
+                sep = '\t' if file_ext == '.tsv' else ','
+                df = pd.read_csv(_io.StringIO(content), sep=sep)
+
+                # Pagination settings
+                rows_per_page = 50
+                total_rows = len(df)
+                total_pages = max(1, (total_rows + rows_per_page - 1) // rows_per_page)
+                current_page = 0
+
+                # Create table preview (first page)
+                start_idx = current_page * rows_per_page
+                end_idx = min(start_idx + rows_per_page, total_rows)
+                preview_df = df.iloc[start_idx:end_idx]
+
+                # Row info for display
+                if total_rows > rows_per_page:
+                    row_info = f"Rows {start_idx + 1}-{end_idx} of {total_rows}"
+                else:
+                    row_info = f"{total_rows} rows"
+
+                modal_content = html.Div([
+                    # Tab buttons for switching views
+                    html.Div([
+                        html.Button("Table", id="html-preview-tab", n_clicks=0,
+                            className="html-tab-btn html-tab-active",
+                            style={"marginRight": "8px", "padding": "6px 12px", "border": "none",
+                                   "borderRadius": "4px", "cursor": "pointer",
+                                   "background": colors["accent"], "color": "#fff"}),
+                        html.Button("Raw", id="html-source-tab", n_clicks=0,
+                            className="html-tab-btn",
+                            style={"padding": "6px 12px", "border": f"1px solid {colors['border']}",
+                                   "borderRadius": "4px", "cursor": "pointer",
+                                   "background": "transparent", "color": colors["text_primary"]}),
+                    ], style={"marginBottom": "12px", "display": "flex"}),
+                    # Row count info and pagination controls
+                    html.Div([
+                        html.Span(f"{len(df.columns)} columns, {row_info}", id="csv-row-info", style={
+                            "fontSize": "12px",
+                            "color": colors["text_muted"],
+                        }),
+                        # Pagination controls (only show if more than one page)
+                        html.Div([
+                            html.Button("◀", id="csv-prev-page", n_clicks=0,
+                                disabled=current_page == 0,
+                                style={
+                                    "padding": "4px 8px", "border": f"1px solid {colors['border']}",
+                                    "borderRadius": "4px", "cursor": "pointer",
+                                    "background": "transparent", "color": colors["text_primary"],
+                                    "marginRight": "8px", "fontSize": "12px",
+                                }),
+                            html.Span(f"Page {current_page + 1} of {total_pages}", id="csv-page-info",
+                                style={"fontSize": "12px", "color": colors["text_primary"]}),
+                            html.Button("▶", id="csv-next-page", n_clicks=0,
+                                disabled=current_page >= total_pages - 1,
+                                style={
+                                    "padding": "4px 8px", "border": f"1px solid {colors['border']}",
+                                    "borderRadius": "4px", "cursor": "pointer",
+                                    "background": "transparent", "color": colors["text_primary"],
+                                    "marginLeft": "8px", "fontSize": "12px",
+                                }),
+                        ], style={"display": "flex" if total_pages > 1 else "none", "alignItems": "center"}),
+                    ], style={"display": "flex", "justifyContent": "space-between", "alignItems": "center", "marginBottom": "8px"}),
+                    # Store CSV data for pagination
+                    dcc.Store(id="csv-data-store", data={
+                        "content": content,
+                        "sep": sep,
+                        "total_rows": total_rows,
+                        "total_pages": total_pages,
+                        "rows_per_page": rows_per_page,
+                        "current_page": current_page,
+                    }),
+                    # Table preview (default visible)
+                    html.Div([
+                        dcc.Markdown(
+                            preview_df.to_html(index=False, classes="csv-preview-table"),
+                            dangerously_allow_html=True,
+                            style={"overflow": "auto"}
+                        )
+                    ], id="html-preview-frame", className="csv-table-container", style={
+                        "border": f"1px solid {colors['border']}",
+                        "borderRadius": "4px",
+                        "background": colors["bg_secondary"],
+                        "maxHeight": "65vh",
+                        "overflow": "auto",
+                    }),
+                    # Raw CSV (hidden by default)
+                    html.Pre(
+                        content,
+                        id="html-source-code",
+                        style={
+                            "display": "none",
+                            "background": colors["bg_tertiary"],
+                            "padding": "16px",
+                            "fontSize": "12px",
+                            "fontFamily": "'IBM Plex Mono', monospace",
+                            "overflow": "auto",
+                            "maxHeight": "80vh",
+                            "whiteSpace": "pre-wrap",
+                            "wordBreak": "break-word",
+                            "margin": "0",
+                            "color": colors["text_primary"],
+                            "border": f"1px solid {colors['border']}",
+                            "borderRadius": "4px",
+                        }
+                    )
+                ])
+            except Exception as e:
+                # Fall back to raw text if parsing fails
+                modal_content = html.Div([
+                    html.Div(f"Could not parse as CSV: {e}", style={
+                        "fontSize": "12px",
+                        "color": colors["text_muted"],
+                        "marginBottom": "8px",
+                    }),
+                    html.Pre(
+                        content,
+                        style={
+                            "background": colors["bg_tertiary"],
+                            "padding": "16px",
+                            "fontSize": "12px",
+                            "fontFamily": "'IBM Plex Mono', monospace",
+                            "overflow": "auto",
+                            "maxHeight": "80vh",
+                            "whiteSpace": "pre-wrap",
+                            "wordBreak": "break-word",
+                            "margin": "0",
+                            "color": colors["text_primary"],
+                        }
+                    )
+                ])
+        else:
+            # Regular text files
+            modal_content = html.Pre(
+                content,
+                style={
+                    "background": colors["bg_tertiary"],
+                    "padding": "16px",
+                    "fontSize": "12px",
+                    "fontFamily": "'IBM Plex Mono', monospace",
+                    "overflow": "auto",
+                    "maxHeight": "80vh",
+                    "whiteSpace": "pre-wrap",
+                    "wordBreak": "break-word",
+                    "margin": "0",
+                    "color": colors["text_primary"],
+                }
+            )
     else:
         modal_content = html.Div([
             html.P(error or "Cannot display file", style={
@@ -1870,6 +2405,142 @@ def download_from_modal(n_clicks, file_path, session_id):
     return dict(content=b64, filename=filename, base64=True, type=mime)
 
 
+# HTML preview/source tab switching
+@app.callback(
+    [Output("html-preview-frame", "style"),
+     Output("html-source-code", "style"),
+     Output("html-preview-tab", "style"),
+     Output("html-source-tab", "style")],
+    [Input("html-preview-tab", "n_clicks"),
+     Input("html-source-tab", "n_clicks")],
+    [State("theme-store", "data"),
+     State("html-preview-frame", "style"),
+     State("html-source-code", "style")],
+    prevent_initial_call=True
+)
+def toggle_html_view(preview_clicks, source_clicks, theme, current_preview_style, current_source_style):
+    """Toggle between HTML preview and source code view."""
+    ctx = callback_context
+    if not ctx.triggered:
+        raise PreventUpdate
+
+    colors = get_colors(theme or "light")
+    triggered_id = ctx.triggered[0]["prop_id"].split(".")[0]
+
+    # Preserve current styles and only update display property
+    # This ensures background colors set by the modal content are preserved
+    preview_frame_style = current_preview_style.copy() if current_preview_style else {}
+    source_code_style = current_source_style.copy() if current_source_style else {}
+
+    # Update theme-sensitive properties
+    source_code_style.update({
+        "background": colors["bg_tertiary"],
+        "color": colors["text_primary"],
+        "border": f"1px solid {colors['border']}",
+    })
+
+    active_btn_style = {
+        "marginRight": "8px", "padding": "6px 12px", "border": "none",
+        "borderRadius": "4px", "cursor": "pointer",
+        "background": colors["accent"], "color": "#fff"
+    }
+    inactive_btn_style = {
+        "padding": "6px 12px", "border": f"1px solid {colors['border']}",
+        "borderRadius": "4px", "cursor": "pointer",
+        "background": "transparent", "color": colors["text_primary"]
+    }
+
+    if triggered_id == "html-source-tab":
+        # Show source, hide preview
+        preview_frame_style["display"] = "none"
+        source_code_style["display"] = "block"
+        return preview_frame_style, source_code_style, {**inactive_btn_style, "marginRight": "8px"}, active_btn_style
+    else:
+        # Show preview, hide source (default)
+        preview_frame_style["display"] = "block"
+        source_code_style["display"] = "none"
+        return preview_frame_style, source_code_style, active_btn_style, {**inactive_btn_style}
+
+
+# CSV pagination
+@app.callback(
+    [Output("html-preview-frame", "children", allow_duplicate=True),
+     Output("csv-row-info", "children"),
+     Output("csv-page-info", "children"),
+     Output("csv-prev-page", "disabled"),
+     Output("csv-next-page", "disabled"),
+     Output("csv-data-store", "data")],
+    [Input("csv-prev-page", "n_clicks"),
+     Input("csv-next-page", "n_clicks")],
+    [State("csv-data-store", "data"),
+     State("theme-store", "data")],
+    prevent_initial_call=True
+)
+def paginate_csv(prev_clicks, next_clicks, csv_data, theme):
+    """Handle CSV pagination."""
+    ctx = callback_context
+    if not ctx.triggered or not csv_data:
+        raise PreventUpdate
+
+    triggered_id = ctx.triggered[0]["prop_id"].split(".")[0]
+
+    import io as _io
+    import pandas as pd
+
+    # Get current state
+    content = csv_data.get("content", "")
+    sep = csv_data.get("sep", ",")
+    total_rows = csv_data.get("total_rows", 0)
+    total_pages = csv_data.get("total_pages", 1)
+    rows_per_page = csv_data.get("rows_per_page", 50)
+    current_page = csv_data.get("current_page", 0)
+
+    # Update page based on which button was clicked
+    if triggered_id == "csv-prev-page" and current_page > 0:
+        current_page -= 1
+    elif triggered_id == "csv-next-page" and current_page < total_pages - 1:
+        current_page += 1
+    else:
+        raise PreventUpdate
+
+    # Parse CSV and get the page slice
+    try:
+        df = pd.read_csv(_io.StringIO(content), sep=sep)
+        start_idx = current_page * rows_per_page
+        end_idx = min(start_idx + rows_per_page, total_rows)
+        preview_df = df.iloc[start_idx:end_idx]
+
+        # Generate row info
+        if total_rows > rows_per_page:
+            row_info = f"{len(df.columns)} columns, Rows {start_idx + 1}-{end_idx} of {total_rows}"
+        else:
+            row_info = f"{len(df.columns)} columns, {total_rows} rows"
+
+        # Generate table HTML
+        table_html = dcc.Markdown(
+            preview_df.to_html(index=False, classes="csv-preview-table"),
+            dangerously_allow_html=True,
+            style={"overflow": "auto"}
+        )
+
+        # Update pagination state
+        updated_csv_data = {
+            **csv_data,
+            "current_page": current_page,
+        }
+
+        return (
+            table_html,
+            row_info,
+            f"Page {current_page + 1} of {total_pages}",
+            current_page == 0,  # prev disabled
+            current_page >= total_pages - 1,  # next disabled
+            updated_csv_data
+        )
+    except Exception:
+        raise PreventUpdate
+
+
 # Open terminal
 @app.callback(
     Output("open-terminal-btn", "n_clicks"),
@@ -1922,13 +2593,15 @@ def open_terminal(n_clicks):
     [State("current-workspace-path", "data"),
      State("theme-store", "data"),
      State("collapsed-canvas-items", "data"),
-     State("session-id", "data")],
+     State("session-id", "data"),
+     State("expanded-folders", "data")],
     prevent_initial_call=True
 )
-def refresh_sidebar(n_clicks, current_workspace, theme, collapsed_ids, session_id):
+def refresh_sidebar(n_clicks, current_workspace, theme, collapsed_ids, session_id, expanded_folders):
     """Refresh both file tree and canvas content."""
     colors = get_colors(theme or "light")
     collapsed_ids = collapsed_ids or []
+    expanded_folders = expanded_folders or []
 
     # Get workspace for this session (virtual or physical)
     workspace_root = get_workspace_for_session(session_id)
@@ -1939,8 +2612,8 @@ def refresh_sidebar(n_clicks, current_workspace, theme, collapsed_ids, session_i
     else:
         current_workspace_dir = workspace_root / current_workspace if current_workspace else workspace_root
 
-    # Refresh file tree for current workspace
-    file_tree = render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES)
+    # Refresh file tree for current workspace, preserving expanded folders
+    file_tree = render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES, expanded_folders=expanded_folders, workspace_root=workspace_root)
 
     # Re-render canvas from current in-memory state (don't reload from file)
     # This preserves canvas items that may not have been exported to .canvas/canvas.md yet
@@ -1960,15 +2633,17 @@ def refresh_sidebar(n_clicks, current_workspace, theme, collapsed_ids, session_i
     [State("file-upload-sidebar", "filename"),
      State("current-workspace-path", "data"),
      State("theme-store", "data"),
-     State("session-id", "data")],
+     State("session-id", "data"),
+     State("expanded-folders", "data")],
     prevent_initial_call=True
 )
-def handle_sidebar_upload(contents, filenames, current_workspace, theme, session_id):
+def handle_sidebar_upload(contents, filenames, current_workspace, theme, session_id, expanded_folders):
     """Handle file uploads from sidebar button to current workspace."""
     if not contents:
         raise PreventUpdate
 
     colors = get_colors(theme or "light")
+    expanded_folders = expanded_folders or []
 
     # Get workspace for this session (virtual or physical)
     workspace_root = get_workspace_for_session(session_id)
@@ -1991,7 +2666,7 @@ def handle_sidebar_upload(contents, filenames, current_workspace, theme, session
         except Exception as e:
             print(f"Upload error: {e}")
 
-    return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES)
+    return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES, expanded_folders=expanded_folders, workspace_root=workspace_root)
 
 
 # Create folder modal - open
@@ -2034,15 +2709,17 @@ def toggle_create_folder_modal(open_clicks, cancel_clicks, confirm_clicks, is_op
     [State("new-folder-name", "value"),
      State("current-workspace-path", "data"),
      State("theme-store", "data"),
-     State("session-id", "data")],
+     State("session-id", "data"),
+     State("expanded-folders", "data")],
     prevent_initial_call=True
 )
-def create_folder(n_clicks, folder_name, current_workspace, theme, session_id):
+def create_folder(n_clicks, folder_name, current_workspace, theme, session_id, expanded_folders):
     """Create a new folder in the current workspace directory."""
     if not n_clicks:
         raise PreventUpdate
 
     colors = get_colors(theme or "light")
+    expanded_folders = expanded_folders or []
 
     if not folder_name or not folder_name.strip():
         return no_update, "Please enter a folder name", no_update
@@ -2070,7 +2747,7 @@ def create_folder(n_clicks, folder_name, current_workspace, theme, session_id):
 
     try:
         folder_path.mkdir(parents=True, exist_ok=False)
-        return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES), "", ""
+        return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES, expanded_folders=expanded_folders, workspace_root=workspace_root), "", ""
     except Exception as e:
         return no_update, f"Error creating folder: {e}", no_update
 
@@ -2156,15 +2833,17 @@ def update_canvas_content(n_intervals, view_value, theme, collapsed_ids, session
     [State("current-workspace-path", "data"),
      State("theme-store", "data"),
      State("session-id", "data"),
-     State("sidebar-view-toggle", "value")],
+     State("sidebar-view-toggle", "value"),
+     State("expanded-folders", "data")],
     prevent_initial_call=True
 )
-def poll_file_tree_update(n_intervals, current_workspace, theme, session_id, view_value):
+def poll_file_tree_update(n_intervals, current_workspace, theme, session_id, view_value, expanded_folders):
     """Refresh file tree during agent execution to show newly created files.
 
     This callback runs on each poll interval and refreshes the file tree
     so that files created by the agent are visible in real-time.
     Only updates when viewing files (not canvas).
+    Preserves expanded folder state across refreshes.
     """
     # Only refresh when viewing files panel
     if view_value != "files":
@@ -2180,6 +2859,7 @@ def poll_file_tree_update(n_intervals, current_workspace, theme, session_id, vie
         raise PreventUpdate
 
     colors = get_colors(theme or "light")
+    expanded_folders = expanded_folders or []
 
     # Get workspace for this session (virtual or physical)
     workspace_root = get_workspace_for_session(session_id)
@@ -2190,8 +2870,8 @@ def poll_file_tree_update(n_intervals, current_workspace, theme, session_id, vie
     else:
         current_workspace_dir = workspace_root / current_workspace if current_workspace else workspace_root
 
-    # Refresh file tree
-    return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES)
+    # Refresh file tree, preserving expanded folder state
+    return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES, expanded_folders=expanded_folders, workspace_root=workspace_root)
 
 
 # Open clear canvas confirmation modal
@@ -2477,6 +3157,133 @@ def handle_delete_confirmation(confirm_clicks, cancel_clicks, item_id, theme, co
     raise PreventUpdate
 
 
+# =============================================================================
+# ADD DISPLAY_INLINE TO CANVAS CALLBACK
+# =============================================================================
+
+@app.callback(
+    [Output("canvas-content", "children", allow_duplicate=True),
+     Output("sidebar-view-toggle", "value", allow_duplicate=True)],
+    Input({"type": "add-display-to-canvas-btn", "index": ALL}, "n_clicks"),
+    [State({"type": "display-inline-data", "index": ALL}, "data"),
+     State("theme-store", "data"),
+     State("collapsed-canvas-items", "data"),
+     State("session-id", "data")],
+    prevent_initial_call=True
+)
+def add_display_inline_to_canvas(n_clicks_list, data_list, theme, collapsed_ids, session_id):
+    """Add a display_inline item to the canvas when the button is clicked.
+
+    This allows users to save inline display items to the canvas for persistent reference.
+    """
+    from .canvas import generate_canvas_id, export_canvas_to_markdown
+    from datetime import datetime
+
+    # Check if any button was actually clicked
+    if not n_clicks_list or not any(n_clicks_list):
+        raise PreventUpdate
+
+    # Find which button was clicked
+    ctx = callback_context
+    if not ctx.triggered:
+        raise PreventUpdate
+
+    triggered = ctx.triggered[0]
+    triggered_id = triggered["prop_id"]
+
+    # Parse the pattern-matching ID to get the index
+    try:
+        # Format: {"type":"add-display-to-canvas-btn","index":"abc123"}.n_clicks
+        id_part = triggered_id.rsplit(".", 1)[0]
+        id_dict = json.loads(id_part)
+        clicked_index = id_dict.get("index")
+    except (json.JSONDecodeError, KeyError, AttributeError):
+        raise PreventUpdate
+
+    if not clicked_index:
+        raise PreventUpdate
+
+    # Find the corresponding data
+    display_data = None
+    for data in data_list:
+        if data and data.get("_item_id") == clicked_index:
+            display_data = data
+            break
+
+    if not display_data:
+        raise PreventUpdate
+
+    colors = get_colors(theme or "light")
+    collapsed_ids = collapsed_ids or []
+
+    # Get workspace for this session (virtual or physical)
+    workspace_root = get_workspace_for_session(session_id)
+
+    # Convert display_inline result to canvas item format
+    display_type = display_data.get("display_type", "text")
+    title = display_data.get("title")
+    data = display_data.get("data")
+
+    # Generate new canvas ID and timestamp
+    canvas_id = generate_canvas_id()
+    created_at = datetime.now().isoformat()
+
+    # Map display_inline types to canvas types
+    canvas_item = {
+        "id": canvas_id,
+        "created_at": created_at,
+    }
+
+    if title:
+        canvas_item["title"] = title
+
+    if display_type == "image":
+        canvas_item["type"] = "image"
+        canvas_item["data"] = data  # base64 image data
+    elif display_type == "plotly":
+        canvas_item["type"] = "plotly"
+        canvas_item["data"] = data  # Plotly JSON
+    elif display_type == "dataframe":
+        canvas_item["type"] = "dataframe"
+        canvas_item["data"] = display_data.get("csv", {}).get("data", [])
+        canvas_item["columns"] = display_data.get("csv", {}).get("columns", [])
+        canvas_item["html"] = display_data.get("csv", {}).get("html", "")
+    elif display_type == "pdf":
+        canvas_item["type"] = "pdf"
+        canvas_item["data"] = data  # base64 PDF data
+        canvas_item["mime_type"] = display_data.get("mime_type", "application/pdf")
+    elif display_type == "html":
+        canvas_item["type"] = "markdown"
+        canvas_item["data"] = data  # Store HTML as markdown (will render)
+    elif display_type == "json":
+        canvas_item["type"] = "markdown"
+        canvas_item["data"] = f"```json\n{json.dumps(data, indent=2)}\n```"
+    else:
+        # text or other
+        canvas_item["type"] = "markdown"
+        canvas_item["data"] = str(data) if data else ""
+
+    # Add item to canvas (session-specific in virtual FS mode)
+    if USE_VIRTUAL_FS and session_id:
+        current_state = _get_session_state(session_id)
+        with _session_agents_lock:
+            current_state["canvas"].append(canvas_item)
+            canvas_items = current_state["canvas"].copy()
+    else:
+        with _agent_state_lock:
+            _agent_state["canvas"].append(canvas_item)
+            canvas_items = _agent_state["canvas"].copy()
+
+    # Export updated canvas to markdown file
+    try:
+        export_canvas_to_markdown(canvas_items, workspace_root)
+    except Exception as e:
+        print(f"Failed to export canvas after adding display item: {e}")
+
+    # Render updated canvas and switch to canvas view
+    return render_canvas_items(canvas_items, colors, collapsed_ids), "canvas"
+
+
 # =============================================================================
 # THEME TOGGLE CALLBACK - Using DMC 2.4 forceColorScheme
 # =============================================================================