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

cowork_dash/app.py

@@ -35,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
@@ -251,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,
@@ -258,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()
 
@@ -275,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,
     }
@@ -323,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.
@@ -333,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):
@@ -367,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 = {}
 
@@ -413,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:
@@ -423,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:
@@ -439,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
 
@@ -452,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'):
@@ -488,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)
 
@@ -696,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()
 
 
@@ -899,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()
 
@@ -955,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).
 
@@ -979,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
@@ -1095,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)
@@ -1105,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
 
 
@@ -1138,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
@@ -1173,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)
@@ -1183,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))
 
@@ -1228,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)
@@ -1244,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)
@@ -1251,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)
@@ -1267,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:
@@ -1282,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)
@@ -1303,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:
@@ -1318,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)
@@ -1343,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))
 
@@ -1388,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)
@@ -1401,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)
@@ -1476,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)
@@ -1490,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))
 
@@ -1576,7 +1765,8 @@ def toggle_folder(n_clicks, header_ids, real_paths, children_ids, icon_ids, chil
                         loaded_content = render_file_tree(folder_items, colors, STYLES,
                                                           level=folder_rel_path.count("/") + folder_rel_path.count("\\") + 1,
                                                           parent_path=folder_rel_path,
-                                                          expanded_folders=expanded_folders)
+                                                          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}")
@@ -1748,7 +1938,8 @@ def enter_folder(folder_clicks, root_clicks, breadcrumb_clicks, folder_ids, fold
     # 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, []  # Reset expanded folders
@@ -2014,6 +2205,141 @@ def open_file_modal(all_n_clicks, all_ids, click_tracker, theme, session_id):
                         "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(
@@ -2087,10 +2413,12 @@ def download_from_modal(n_clicks, file_path, session_id):
      Output("html-source-tab", "style")],
     [Input("html-preview-tab", "n_clicks"),
      Input("html-source-tab", "n_clicks")],
-    [State("theme-store", "data")],
+    [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):
+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:
@@ -2099,28 +2427,18 @@ def toggle_html_view(preview_clicks, source_clicks, theme):
     colors = get_colors(theme or "light")
     triggered_id = ctx.triggered[0]["prop_id"].split(".")[0]
 
-    # Base styles
-    preview_frame_style = {
-        "width": "100%",
-        "height": "80vh",
-        "border": f"1px solid {colors['border']}",
-        "borderRadius": "4px",
-        "background": "#fff",
-    }
-    source_code_style = {
+    # 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"],
-        "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",
-    }
+    })
+
     active_btn_style = {
         "marginRight": "8px", "padding": "6px 12px", "border": "none",
         "borderRadius": "4px", "cursor": "pointer",
@@ -2144,6 +2462,85 @@ def toggle_html_view(preview_clicks, source_clicks, theme):
         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"),
@@ -2216,7 +2613,7 @@ def refresh_sidebar(n_clicks, current_workspace, theme, collapsed_ids, session_i
         current_workspace_dir = workspace_root / current_workspace if current_workspace else workspace_root
 
     # 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)
+    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
@@ -2269,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, expanded_folders=expanded_folders)
+    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
@@ -2350,7 +2747,7 @@ def create_folder(n_clicks, folder_name, current_workspace, theme, session_id, e
 
     try:
         folder_path.mkdir(parents=True, exist_ok=False)
-        return render_file_tree(build_file_tree(current_workspace_dir, current_workspace_dir), colors, STYLES, expanded_folders=expanded_folders), "", ""
+        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
 
@@ -2474,7 +2871,7 @@ def poll_file_tree_update(n_intervals, current_workspace, theme, session_id, vie
         current_workspace_dir = workspace_root / current_workspace if current_workspace else workspace_root
 
     # 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)
+    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
@@ -2760,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
 # =============================================================================