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

cowork_dash/app.py

@@ -35,7 +35,8 @@ 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,
+    render_ordered_content_items
 )
 from .layout import create_layout as create_layout_component
 from .virtual_fs import get_session_manager
@@ -251,6 +252,8 @@ _agent_state = {
     "thinking": "",
     "todos": [],
     "tool_calls": [],  # Current turn's tool calls (reset each turn)
+    "content_items": [],  # Ordered list of content: {"type": "text"|"thinking"|"tool_calls", "content": ...}
+    "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 +261,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 +279,14 @@ def _get_default_agent_state() -> Dict[str, Any]:
         "thinking": "",
         "todos": [],
         "tool_calls": [],
+        "content_items": [],  # Ordered list of content: {"type": "text"|"thinking"|"tool_calls", "content": ...}
+        "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 +330,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 +342,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 +382,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 +434,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 +455,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 +472,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
 
@@ -450,17 +487,59 @@ def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: st
                             last_msg = msgs[-1] if isinstance(msgs, list) else msgs
                             msg_type = last_msg.__class__.__name__ if hasattr(last_msg, '__class__') else None
 
-                            # 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)
+                            # Capture AIMessage content and tool_calls
+                            if msg_type == 'AIMessage':
+                                # First, capture any text content from the AIMessage
+                                if hasattr(last_msg, 'content') and last_msg.content:
+                                    content = last_msg.content
+                                    response_text = ""
+                                    if isinstance(content, str):
+                                        response_text = re.sub(
+                                            r"\{'id':\s*'[^']+',\s*'input':\s*\{.*?\},\s*'name':\s*'[^']+',\s*'type':\s*'tool_use'\}",
+                                            '', content, flags=re.DOTALL
+                                        ).strip()
+                                    elif isinstance(content, list):
+                                        text_parts = [
+                                            block.get("text", "") if isinstance(block, dict) and block.get("type") == "text" else ""
+                                            for block in content
+                                        ]
+                                        response_text = " ".join(filter(None, text_parts)).strip()
 
-                                with state_lock:
-                                    current_state["tool_calls"].extend(new_tool_calls)
-                                    current_state["last_update"] = time.time()
+                                    if response_text:
+                                        with state_lock:
+                                            current_state["response"] = response_text
+                                            # Add text to ordered content list
+                                            if "content_items" not in current_state:
+                                                current_state["content_items"] = []
+                                            current_state["content_items"].append({
+                                                "type": "text",
+                                                "content": response_text
+                                            })
+                                            current_state["last_update"] = time.time()
+
+                                # Then, capture any tool_calls
+                                if hasattr(last_msg, 'tool_calls') and last_msg.tool_calls:
+                                    with state_lock:
+                                        # 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'):
                                 # Update tool call status when we get the result
@@ -488,10 +567,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)
 
@@ -508,9 +593,16 @@ def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: st
                                     elif isinstance(content, dict):
                                         thinking_text = content.get('reflection', str(content))
 
-                                    # Update state immediately
+                                    # Update state immediately - add to ordered content_items
                                     with state_lock:
                                         current_state["thinking"] = thinking_text
+                                        # Add thinking to ordered content list
+                                        if "content_items" not in current_state:
+                                            current_state["content_items"] = []
+                                        current_state["content_items"].append({
+                                            "type": "thinking",
+                                            "content": thinking_text
+                                        })
                                         current_state["last_update"] = time.time()
 
                                 elif last_msg.name == 'write_todos':
@@ -664,26 +756,6 @@ def _run_agent_stream(message: str, resume_data: Dict = None, workspace_path: st
                                                 except Exception as e:
                                                     print(f"Failed to export canvas: {e}")
 
-                            elif hasattr(last_msg, 'content'):
-                                content = last_msg.content
-                                response_text = ""
-                                if isinstance(content, str):
-                                    response_text = re.sub(
-                                        r"\{'id':\s*'[^']+',\s*'input':\s*\{.*?\},\s*'name':\s*'[^']+',\s*'type':\s*'tool_use'\}",
-                                        '', content, flags=re.DOTALL
-                                    ).strip()
-                                elif isinstance(content, list):
-                                    text_parts = [
-                                        block.get("text", "") if isinstance(block, dict) else str(block)
-                                        for block in content
-                                    ]
-                                    response_text = " ".join(text_parts).strip()
-
-                                if response_text:
-                                    with state_lock:
-                                        current_state["response"] = response_text
-                                        current_state["last_update"] = time.time()
-
     except Exception as e:
         with state_lock:
             current_state["error"] = str(e)
@@ -696,6 +768,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()
 
 
@@ -822,6 +895,7 @@ def call_agent(message: str, resume_data: Dict = None, workspace_path: str = Non
             "thinking": "",
             "todos": [],
             "tool_calls": [],  # Reset tool calls for this turn
+            "content_items": [],  # Ordered list of content items
             "canvas": existing_canvas,  # Preserve existing canvas
             "response": "",
             "error": None,
@@ -899,6 +973,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 +1030,42 @@ 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["content_items"] = copy.deepcopy(current_state.get("content_items", []))
+        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)
+        # Also add to ordered content_items for proper interleaving
+        if "content_items" not in current_state:
+            current_state["content_items"] = []
+        current_state["content_items"].append({
+            "type": "display_inline",
+            "content": item  # Store the full item dict
+        })
+        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 +1087,12 @@ def reset_agent_state(session_id: Optional[str] = None):
         current_state["thinking"] = ""
         current_state["todos"] = []
         current_state["tool_calls"] = []
+        current_state["content_items"] = []
+        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
@@ -1094,17 +1206,49 @@ def display_initial_messages(history, theme, skip_render, session_initialized, s
     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, is_new=False, response_time=msg_response_time))
-        # Render tool calls stored with this message
-        if msg.get("tool_calls"):
-            tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
-            if tool_calls_block:
-                messages.append(tool_calls_block)
-        # Render todos stored with this message
-        if msg.get("todos"):
-            todos_block = format_todos_inline(msg["todos"], colors)
-            if todos_block:
-                messages.append(todos_block)
+
+        # For user messages, render normally
+        if msg["role"] == "user":
+            messages.append(format_message(msg["role"], msg["content"], colors, STYLES, is_new=False, response_time=msg_response_time))
+
+            # Show collapsed tool calls section
+            if msg.get("tool_calls"):
+                tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
+                if tool_calls_block:
+                    messages.append(tool_calls_block)
+
+            # Render todos
+            if msg.get("todos"):
+                todos_block = format_todos_inline(msg["todos"], colors)
+                if todos_block:
+                    messages.append(todos_block)
+
+            # Render ordered content items (thinking + text + display_inline in order)
+            if msg.get("content_items"):
+                content_blocks = render_ordered_content_items(msg["content_items"], colors, STYLES)
+                messages.extend(content_blocks)
+            else:
+                # Fallback: extract thinking from tool calls (old format)
+                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 from tool calls (old format)
+                if msg.get("tool_calls"):
+                    inline_results = extract_display_inline_results(msg["tool_calls"], colors)
+                    messages.extend(inline_results)
+
+                # Render display_inline items stored with this message (old format)
+                if msg.get("display_inline_items"):
+                    for item in msg["display_inline_items"]:
+                        rendered = render_display_inline_result(item, colors)
+                        messages.append(rendered)
+        else:
+            # For assistant messages, check if content_items was used (text already rendered above)
+            # In the new model, assistant content may be empty if content_items is in the user message
+            if msg["content"]:
+                messages.append(format_message(msg["role"], msg["content"], colors, STYLES, is_new=False, response_time=msg_response_time))
+
     return messages, False, True, new_session_id
 
 
@@ -1138,7 +1282,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
@@ -1172,17 +1316,41 @@ def handle_send_immediate(n_clicks, n_submit, message, history, theme, current_w
     for i, m in enumerate(history):
         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
-        if m.get("tool_calls"):
-            tool_calls_block = format_tool_calls_inline(m["tool_calls"], colors)
-            if tool_calls_block:
-                messages.append(tool_calls_block)
-        # Render todos stored with this message
-        if m.get("todos"):
-            todos_block = format_todos_inline(m["todos"], colors)
-            if todos_block:
-                messages.append(todos_block)
+
+        # For user messages, render normally
+        if m["role"] == "user":
+            messages.append(format_message(m["role"], m["content"], colors, STYLES, is_new=is_new, response_time=msg_response_time))
+
+            # Show collapsed tool calls section
+            if m.get("tool_calls"):
+                tool_calls_block = format_tool_calls_inline(m["tool_calls"], colors)
+                if tool_calls_block:
+                    messages.append(tool_calls_block)
+
+            # Render todos
+            if m.get("todos"):
+                todos_block = format_todos_inline(m["todos"], colors)
+                if todos_block:
+                    messages.append(todos_block)
+
+            # Render ordered content items (thinking + text + display_inline in order)
+            if m.get("content_items"):
+                content_blocks = render_ordered_content_items(m["content_items"], colors, STYLES)
+                messages.extend(content_blocks)
+            else:
+                # Fallback: extract thinking from tool calls (old format)
+                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 from tool calls (old format)
+                if m.get("tool_calls"):
+                    inline_results = extract_display_inline_results(m["tool_calls"], colors)
+                    messages.extend(inline_results)
+        else:
+            # For assistant messages, check if content_items was used
+            if m["content"]:
+                messages.append(format_message(m["role"], m["content"], colors, STYLES, is_new=is_new, response_time=msg_response_time))
 
     messages.append(format_loading(colors))
 
@@ -1228,22 +1396,57 @@ 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
-            if msg.get("tool_calls"):
-                tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
-                if tool_calls_block:
-                    messages.append(tool_calls_block)
-            # Render todos stored with this message
-            if msg.get("todos"):
-                todos_block = format_todos_inline(msg["todos"], colors)
-                if todos_block:
-                    messages.append(todos_block)
+
+            # For user messages, render normally
+            if msg["role"] == "user":
+                messages.append(format_message(msg["role"], msg["content"], colors, STYLES, response_time=msg_response_time))
+
+                # Show collapsed tool calls section
+                if msg.get("tool_calls"):
+                    tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
+                    if tool_calls_block:
+                        messages.append(tool_calls_block)
+
+                # Render todos
+                if msg.get("todos"):
+                    todos_block = format_todos_inline(msg["todos"], colors)
+                    if todos_block:
+                        messages.append(todos_block)
+
+                # Render ordered content items (thinking + text + display_inline in order)
+                if msg.get("content_items"):
+                    content_blocks = render_ordered_content_items(msg["content_items"], colors, STYLES)
+                    messages.extend(content_blocks)
+                else:
+                    # Fallback: extract thinking from tool calls (old format)
+                    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 from tool calls (old format)
+                    if msg.get("tool_calls"):
+                        inline_results = extract_display_inline_results(msg["tool_calls"], colors)
+                        messages.extend(inline_results)
+
+                    # Render display_inline items stored with this message (old format)
+                    if msg.get("display_inline_items"):
+                        for item in msg["display_inline_items"]:
+                            rendered = render_display_inline_result(item, colors)
+                            messages.append(rendered)
+            else:
+                # For assistant messages, check if content_items was used (text already rendered above)
+                # In the new model, assistant content may be empty if content_items is in the user message
+                if msg["content"]:
+                    messages.append(format_message(msg["role"], msg["content"], colors, STYLES, response_time=msg_response_time))
+
         return messages
 
     # Check for interrupt (human-in-the-loop)
@@ -1251,22 +1454,38 @@ 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)
-
+        # Show collapsed tool calls section
         if state.get("tool_calls"):
             tool_calls_block = format_tool_calls_inline(state["tool_calls"], colors)
             if tool_calls_block:
                 messages.append(tool_calls_block)
 
+        # Render todos
         if state["todos"]:
             todos_block = format_todos_inline(state["todos"], colors)
             if todos_block:
                 messages.append(todos_block)
 
+        # Render ordered content items (thinking + text + display_inline in order)
+        if state.get("content_items"):
+            content_blocks = render_ordered_content_items(state["content_items"], colors, STYLES)
+            messages.extend(content_blocks)
+        else:
+            # Fallback: extract thinking from tool calls
+            if state.get("tool_calls"):
+                thinking_blocks = extract_thinking_from_tool_calls(state["tool_calls"], colors)
+                messages.extend(thinking_blocks)
+
+            # Extract and show display_inline results from tool calls (old format)
+            if state.get("tool_calls"):
+                inline_results = extract_display_inline_results(state["tool_calls"], colors)
+                messages.extend(inline_results)
+
+            # Render any queued display_inline items (old format)
+            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,67 +1501,82 @@ 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, content_items, 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, content_items, 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 state.get("content_items"):
+                        history[i]["content_items"] = state["content_items"]
+                    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)
+        # Note: In the new model, content may be empty if content_items is used
         assistant_msg = {
             "role": "assistant",
-            "content": state["response"] if state["response"] else f"Error: {state['error']}",
+            "content": "" if state.get("content_items") else (state["response"] if state["response"] else f"Error: {state['error']}"),
             "response_time": response_time,
         }
 
         history.append(assistant_msg)
 
-        # Render all history (tool calls and todos are now part of history)
-        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
-            if msg.get("tool_calls"):
-                tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
-                if tool_calls_block:
-                    final_messages.append(tool_calls_block)
-            # Render todos stored with this message
-            if msg.get("todos"):
-                todos_block = format_todos_inline(msg["todos"], colors)
-                if todos_block:
-                    final_messages.append(todos_block)
+        # Render all history using render_history_messages (which handles content_items)
+        final_messages = render_history_messages(history)
+
+        # 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/content_items
         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
+        # Show collapsed tool calls section
         if state.get("tool_calls"):
             tool_calls_block = format_tool_calls_inline(state["tool_calls"], colors)
             if tool_calls_block:
                 messages.append(tool_calls_block)
 
-        # Add current todos if available
+        # Render todos
         if state["todos"]:
             todos_block = format_todos_inline(state["todos"], colors)
             if todos_block:
                 messages.append(todos_block)
 
+        # Render ordered content items (thinking + text + display_inline in order)
+        if state.get("content_items"):
+            content_blocks = render_ordered_content_items(state["content_items"], colors, STYLES)
+            messages.extend(content_blocks)
+        else:
+            # Fallback: extract thinking from tool calls
+            if state.get("tool_calls"):
+                thinking_blocks = extract_thinking_from_tool_calls(state["tool_calls"], colors)
+                messages.extend(thinking_blocks)
+
+            # Extract and show display_inline results from tool calls (old format)
+            if state.get("tool_calls"):
+                inline_results = extract_display_inline_results(state["tool_calls"], colors)
+                messages.extend(inline_results)
+
+            # Render any queued display_inline items (old format)
+            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,22 +1622,55 @@ def handle_stop_button(n_clicks, history, theme, session_id):
     request_agent_stop(session_id)
 
     # Render current messages with a stopping indicator
-    def render_history_messages(history):
+    def render_history_messages_local(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"):
-                tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
-                if tool_calls_block:
-                    messages.append(tool_calls_block)
-            if msg.get("todos"):
-                todos_block = format_todos_inline(msg["todos"], colors)
-                if todos_block:
-                    messages.append(todos_block)
+
+            # For user messages, render normally
+            if msg["role"] == "user":
+                messages.append(format_message(msg["role"], msg["content"], colors, STYLES, is_new=False, response_time=msg_response_time))
+
+                # Show collapsed tool calls section
+                if msg.get("tool_calls"):
+                    tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
+                    if tool_calls_block:
+                        messages.append(tool_calls_block)
+
+                # Render todos
+                if msg.get("todos"):
+                    todos_block = format_todos_inline(msg["todos"], colors)
+                    if todos_block:
+                        messages.append(todos_block)
+
+                # Render ordered content items (thinking + text + display_inline in order)
+                if msg.get("content_items"):
+                    content_blocks = render_ordered_content_items(msg["content_items"], colors, STYLES)
+                    messages.extend(content_blocks)
+                else:
+                    # Fallback: extract 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 from tool calls (old format)
+                    if msg.get("tool_calls"):
+                        inline_results = extract_display_inline_results(msg["tool_calls"], colors)
+                        messages.extend(inline_results)
+
+                    # Render display_inline items stored with this message (old format)
+                    if msg.get("display_inline_items"):
+                        for item in msg["display_inline_items"]:
+                            rendered = render_display_inline_result(item, colors)
+                            messages.append(rendered)
+            else:
+                # For assistant messages, check if content_items was used
+                if msg["content"]:
+                    messages.append(format_message(msg["role"], msg["content"], colors, STYLES, is_new=False, response_time=msg_response_time))
+
         return messages
 
-    messages = render_history_messages(history)
+    messages = render_history_messages_local(history)
 
     # Add stopping message
     messages.append(html.Div([
@@ -1479,17 +1746,47 @@ def handle_interrupt_response(approve_clicks, reject_clicks, edit_clicks, input_
     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"):
-            tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
-            if tool_calls_block:
-                messages.append(tool_calls_block)
-        # Render todos stored with this message
-        if msg.get("todos"):
-            todos_block = format_todos_inline(msg["todos"], colors)
-            if todos_block:
-                messages.append(todos_block)
+
+        # For user messages, render normally
+        if msg["role"] == "user":
+            messages.append(format_message(msg["role"], msg["content"], colors, STYLES, response_time=msg_response_time))
+
+            # Show collapsed tool calls section
+            if msg.get("tool_calls"):
+                tool_calls_block = format_tool_calls_inline(msg["tool_calls"], colors)
+                if tool_calls_block:
+                    messages.append(tool_calls_block)
+
+            # Render todos
+            if msg.get("todos"):
+                todos_block = format_todos_inline(msg["todos"], colors)
+                if todos_block:
+                    messages.append(todos_block)
+
+            # Render ordered content items (thinking + text + display_inline in order)
+            if msg.get("content_items"):
+                content_blocks = render_ordered_content_items(msg["content_items"], colors, STYLES)
+                messages.extend(content_blocks)
+            else:
+                # Fallback: extract 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 from tool calls (old format)
+                if msg.get("tool_calls"):
+                    inline_results = extract_display_inline_results(msg["tool_calls"], colors)
+                    messages.extend(inline_results)
+
+                # Render display_inline items stored with this message (old format)
+                if msg.get("display_inline_items"):
+                    for item in msg["display_inline_items"]:
+                        rendered = render_display_inline_result(item, colors)
+                        messages.append(rendered)
+        else:
+            # For assistant messages, check if content_items was used
+            if msg["content"]:
+                messages.append(format_message(msg["role"], msg["content"], colors, STYLES, response_time=msg_response_time))
 
     messages.append(format_loading(colors))
 
@@ -1576,7 +1873,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 +2046,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 +2313,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 +2521,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 +2535,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 +2570,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 +2721,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 +2774,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 +2855,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
 
@@ -2408,6 +2913,70 @@ def toggle_view(view_value):
         )
 
 
+# Sidebar collapse/expand toggle
+@app.callback(
+    [Output("sidebar-panel", "style"),
+     Output("sidebar-expand-btn", "style"),
+     Output("resize-handle", "style"),
+     Output("sidebar-collapsed", "data")],
+    [Input("collapse-sidebar-btn", "n_clicks"),
+     Input("expand-sidebar-btn", "n_clicks")],
+    [State("sidebar-collapsed", "data")],
+    prevent_initial_call=True
+)
+def toggle_sidebar_collapse(collapse_clicks, expand_clicks, is_collapsed):
+    """Toggle sidebar between collapsed and expanded states."""
+    ctx = callback_context
+    if not ctx.triggered:
+        raise PreventUpdate
+
+    triggered_id = ctx.triggered[0]["prop_id"].split(".")[0]
+
+    # Determine new state based on which button was clicked
+    if triggered_id == "collapse-sidebar-btn":
+        new_collapsed = True
+    elif triggered_id == "expand-sidebar-btn":
+        new_collapsed = False
+    else:
+        raise PreventUpdate
+
+    if new_collapsed:
+        # Collapsed state - hide sidebar, show expand button
+        return (
+            {"display": "none"},  # Hide sidebar panel
+            {  # Show expand button
+                "display": "flex",
+                "alignItems": "flex-start",
+                "paddingTop": "10px",
+                "borderLeft": "1px solid var(--mantine-color-default-border)",
+                "background": "var(--mantine-color-body)",
+            },
+            {"display": "none"},  # Hide resize handle
+            True,  # Store collapsed state
+        )
+    else:
+        # Expanded state - show sidebar, hide expand button
+        return (
+            {  # Show sidebar panel
+                "flex": "1",
+                "minWidth": "0",
+                "minHeight": "0",
+                "display": "flex",
+                "flexDirection": "column",
+                "background": "var(--mantine-color-body)",
+                "borderLeft": "1px solid var(--mantine-color-default-border)",
+            },
+            {"display": "none"},  # Hide expand button
+            {  # Show resize handle
+                "width": "3px",
+                "cursor": "col-resize",
+                "background": "transparent",
+                "flexShrink": "0",
+            },
+            False,  # Store expanded state
+        )
+
+
 # Canvas content update
 @app.callback(
     Output("canvas-content", "children"),
@@ -2474,7 +3043,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 +3329,333 @@ 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"
+
+
+# =============================================================================
+# DOWNLOAD DISPLAY INLINE CALLBACK - Download display inline content
+# =============================================================================
+
+@app.callback(
+    Output("file-download", "data", allow_duplicate=True),
+    Input({"type": "download-display-btn", "index": ALL}, "n_clicks"),
+    State({"type": "display-inline-data", "index": ALL}, "data"),
+    prevent_initial_call=True
+)
+def download_display_inline_content(n_clicks_list, data_list):
+    """Download a display_inline item when the download button is clicked."""
+    import base64
+
+    ctx = callback_context
+    # Check if any button was actually clicked
+    if not n_clicks_list or not any(n_clicks_list):
+        raise PreventUpdate
+
+    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":"download-display-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
+
+    display_type = display_data.get("display_type", "text")
+    data = display_data.get("data")
+    title = display_data.get("title", "download")
+    filename = display_data.get("filename")
+
+    # Generate appropriate filename and content based on type
+    if display_type == "image":
+        mime_type = display_data.get("mime_type", "image/png")
+        ext = mime_type.split("/")[-1]
+        if ext == "jpeg":
+            ext = "jpg"
+        download_filename = filename or f"{title}.{ext}"
+        return dict(
+            content=data,
+            filename=download_filename,
+            base64=True
+        )
+
+    elif display_type == "pdf":
+        download_filename = filename or f"{title}.pdf"
+        return dict(
+            content=data,
+            filename=download_filename,
+            base64=True
+        )
+
+    elif display_type == "html":
+        download_filename = filename or f"{title}.html"
+        return dict(
+            content=data,
+            filename=download_filename
+        )
+
+    elif display_type == "dataframe":
+        # Download as CSV
+        csv_data = display_data.get("csv", {})
+        columns = csv_data.get("columns", [])
+        rows = csv_data.get("data", [])
+
+        # Build CSV content
+        import csv
+        import io
+        output = io.StringIO()
+        writer = csv.writer(output)
+        writer.writerow(columns)
+        for row in rows:
+            writer.writerow([row.get(col, "") for col in columns])
+        csv_content = output.getvalue()
+
+        download_filename = filename or f"{title}.csv"
+        return dict(
+            content=csv_content,
+            filename=download_filename
+        )
+
+    elif display_type == "json":
+        json_content = json.dumps(data, indent=2) if isinstance(data, (dict, list)) else str(data)
+        download_filename = filename or f"{title}.json"
+        return dict(
+            content=json_content,
+            filename=download_filename
+        )
+
+    elif display_type == "plotly":
+        # Download Plotly chart as JSON
+        json_content = json.dumps(data, indent=2) if isinstance(data, dict) else str(data)
+        download_filename = filename or f"{title}.json"
+        return dict(
+            content=json_content,
+            filename=download_filename
+        )
+
+    else:
+        # Text or unknown - download as .txt
+        text_content = str(data) if data else ""
+        download_filename = filename or f"{title}.txt"
+        return dict(
+            content=text_content,
+            filename=download_filename
+        )
+
+
+# =============================================================================
+# FULLSCREEN PREVIEW CALLBACK - Open HTML/PDF in fullscreen modal
+# =============================================================================
+
+@app.callback(
+    [Output("fullscreen-preview-modal", "opened"),
+     Output("fullscreen-preview-modal", "title"),
+     Output("fullscreen-preview-content", "children")],
+    Input({"type": "fullscreen-btn", "index": ALL}, "n_clicks"),
+    State({"type": "fullscreen-data", "index": ALL}, "data"),
+    prevent_initial_call=True
+)
+def open_fullscreen_preview(n_clicks_list, data_list):
+    """Open fullscreen modal for HTML/PDF preview."""
+    ctx = callback_context
+    if not n_clicks_list or not any(n_clicks_list):
+        raise PreventUpdate
+
+    # Find which button was clicked
+    triggered = ctx.triggered[0]
+    triggered_id = triggered["prop_id"]
+
+    try:
+        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
+
+    # Find the corresponding data
+    fullscreen_data = None
+    for i, data in enumerate(data_list):
+        if data and n_clicks_list[i]:
+            # Match by checking trigger
+            btn_ids = ctx.inputs_list[0]
+            if i < len(btn_ids) and btn_ids[i].get("id", {}).get("index") == clicked_index:
+                fullscreen_data = data
+                break
+
+    if not fullscreen_data:
+        raise PreventUpdate
+
+    content_type = fullscreen_data.get("type")
+    content = fullscreen_data.get("content")
+    title = fullscreen_data.get("title", "Preview")
+
+    if content_type == "html":
+        preview_content = html.Iframe(
+            srcDoc=content,
+            style={
+                "width": "100%",
+                "height": "100%",
+                "border": "none",
+                "backgroundColor": "white",
+            }
+        )
+    elif content_type == "pdf":
+        preview_content = html.Iframe(
+            src=content,
+            style={
+                "width": "100%",
+                "height": "100%",
+                "border": "none",
+            }
+        )
+    else:
+        preview_content = html.Div("Unsupported content type")
+
+    return True, title, preview_content
+
+
 # =============================================================================
 # THEME TOGGLE CALLBACK - Using DMC 2.4 forceColorScheme
 # =============================================================================