update

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY pyproject.toml .
+RUN pip install --no-cache-dir .
+
+# Copy application code
+COPY backend/ backend/
+COPY frontend/ frontend/
+
+# HF Spaces uses port 7860
+EXPOSE 7860
+
+# Run the server
+# --no-browser since we're in a container
+# --workspace-dir /app/workspace for session storage
+CMD ["python", "-m", "backend.main", "--port", "7860", "--no-browser", "--workspace-dir", "/app/workspace"]

backend/code.py

@@ -2,11 +2,14 @@
 Code notebook backend - handles code execution with E2B
 """
 import json
+import logging
 import os
 import re
 from typing import List, Dict, Optional
 from e2b_code_interpreter import Sandbox
 
+logger = logging.getLogger(__name__)
+
 
 TOOLS = [
     {
@@ -268,7 +271,7 @@ def download_files_from_sandbox(sbx: Sandbox, files: List[Dict], files_root: str
     return "\n".join(results)
 
 
-def stream_code_execution(client, model: str, messages: List[Dict], sbx: Sandbox, files_root: str = None):
+def stream_code_execution(client, model: str, messages: List[Dict], sbx: Sandbox, files_root: str = None, extra_params: Optional[Dict] = None):
     """
     Stream code execution results
 
@@ -281,6 +284,7 @@ def stream_code_execution(client, model: str, messages: List[Dict], sbx: Sandbox
         messages: Conversation messages
         sbx: E2B sandbox instance
         files_root: Root directory for file uploads (optional)
+        extra_params: Extra parameters for API calls (optional)
     """
     turns = 0
     done = False
@@ -297,12 +301,16 @@ def stream_code_execution(client, model: str, messages: List[Dict], sbx: Sandbox
         for attempt in range(MAX_RETRIES):
             try:
                 # Call LLM with tools
-                response = client.chat.completions.create(
-                    messages=messages,
-                    model=model,
-                    tools=TOOLS,
-                    tool_choice="auto",
-                )
+                call_params = {
+                    "messages": messages,
+                    "model": model,
+                    "tools": TOOLS,
+                    "tool_choice": "auto",
+                }
+                # Apply any extra params via extra_body (for OpenAI SDK compatibility)
+                if extra_params:
+                    call_params["extra_body"] = extra_params
+                response = client.chat.completions.create(**call_params)
                 break  # Success, exit retry loop
             except Exception as e:
                 last_error = e
@@ -340,7 +348,7 @@ def stream_code_execution(client, model: str, messages: List[Dict], sbx: Sandbox
         thinking_content = content
 
         if result_match:
-            print("RESULT:", content)
+            logger.debug(f"Result found: {content[:200]}...")
             result_content = result_match.group(1).strip()
             # Remove result tags from thinking display
             thinking_content = re.sub(r'<result>.*?</result>', '', content, flags=re.DOTALL | re.IGNORECASE).strip()
@@ -363,7 +371,7 @@ def stream_code_execution(client, model: str, messages: List[Dict], sbx: Sandbox
                         code = args["code"]
                     except json.JSONDecodeError as e:
                         error_msg = f"JSON parse error: {e}. Raw arguments: {tool_call.function.arguments[:500]}"
-                        print(f"[code.py] {error_msg}")
+                        logger.error(error_msg)
                         # Treat as tool error so LLM can recover
                         output = f"Error parsing code arguments: {e}"
                         messages.append({
@@ -387,7 +395,7 @@ def stream_code_execution(client, model: str, messages: List[Dict], sbx: Sandbox
                         continue
                     except KeyError as e:
                         error_msg = f"Missing required key {e} in arguments: {tool_call.function.arguments[:500]}"
-                        print(f"[code.py] {error_msg}")
+                        logger.error(error_msg)
                         output = f"Error: Missing required 'code' parameter"
                         messages.append({
                             "role": "assistant",
@@ -418,16 +426,6 @@ def stream_code_execution(client, model: str, messages: List[Dict], sbx: Sandbox
                         output = parse_execution_result(execution)
                         has_error = execution.error is not None
 
-                        # Debug logging for E2B execution results
-                        print(f"[E2B DEBUG] Number of results: {len(execution.results)}")
-                        for i, result in enumerate(execution.results):
-                            print(f"[E2B DEBUG] Result {i}:")
-                            print(f"  - text: {result.text[:100] if result.text else None}...")
-                            print(f"  - png: {len(result.png) if result.png else None} bytes")
-                            print(f"  - jpeg: {len(result.jpeg) if result.jpeg else None} bytes")
-                            print(f"  - svg: {len(result.svg) if result.svg else None} bytes")
-                            print(f"  - all attrs: {[a for a in dir(result) if not a.startswith('_')]}")
-
                         # Extract images and assign figure names
                         images = []
                         figure_names = []
@@ -494,7 +492,7 @@ def stream_code_execution(client, model: str, messages: List[Dict], sbx: Sandbox
                         paths = args["paths"]
                     except (json.JSONDecodeError, KeyError) as e:
                         error_msg = f"Failed to parse upload_files arguments: {e}. Raw: {tool_call.function.arguments[:500]}"
-                        print(f"[code.py] {error_msg}")
+                        logger.error(error_msg)
                         output = f"Error parsing upload_files arguments: {e}"
                         messages.append({
                             "role": "assistant",
@@ -553,7 +551,7 @@ def stream_code_execution(client, model: str, messages: List[Dict], sbx: Sandbox
                         files = args["files"]
                     except (json.JSONDecodeError, KeyError) as e:
                         error_msg = f"Failed to parse download_files arguments: {e}. Raw: {tool_call.function.arguments[:500]}"
-                        print(f"[code.py] {error_msg}")
+                        logger.error(error_msg)
                         output = f"Error parsing download_files arguments: {e}"
                         messages.append({
                             "role": "assistant",

backend/command.py

@@ -2,10 +2,13 @@
 Command center backend - handles tool-based notebook launching
 """
 import json
+import logging
 import os
 import re
 from typing import List, Dict
 
+logger = logging.getLogger(__name__)
+
 # Tool definitions for launching notebooks
 TOOLS = [
     {
@@ -101,7 +104,8 @@ RETRY_DELAYS = [2, 5, 10]  # Delay in seconds for each retry attempt
 
 # Set FORCE_RETRY=1 to test retry logic with any error
 FORCE_RETRY_FOR_TESTING = os.environ.get("FORCE_RETRY", "0") == "1"
-print(f"[command.py] FORCE_RETRY_FOR_TESTING = {FORCE_RETRY_FOR_TESTING}")
+if FORCE_RETRY_FOR_TESTING:
+    logger.debug("FORCE_RETRY_FOR_TESTING enabled")
 
 
 def parse_llm_error(error: Exception) -> dict:
@@ -135,7 +139,7 @@ def parse_llm_error(error: Exception) -> dict:
     }
 
 
-def stream_command_center(client, model: str, messages: List[Dict]):
+def stream_command_center(client, model: str, messages: List[Dict], extra_params: dict = None):
     """
     Stream command center responses with notebook launching capabilities
 
@@ -159,12 +163,15 @@ def stream_command_center(client, model: str, messages: List[Dict]):
                     raise Exception("Error code: 429 - {'message': \"We're experiencing high traffic right now! Please try again soon.\", 'type': 'too_many_requests_error', 'param': 'queue', 'code': 'queue_exceeded'}")
 
                 # Call LLM with tools
-                response = client.chat.completions.create(
-                    messages=messages,
-                    model=model,
-                    tools=TOOLS,
-                    tool_choice="auto",
-                )
+                call_params = {
+                    "messages": messages,
+                    "model": model,
+                    "tools": TOOLS,
+                    "tool_choice": "auto",
+                }
+                if extra_params:
+                    call_params["extra_body"] = extra_params
+                response = client.chat.completions.create(**call_params)
                 break  # Success, exit retry loop
             except Exception as e:
                 last_error = e

backend/defaultnames.py

@@ -0,0 +1,124 @@
+# Auto-generated isotope data for session names
+# Structure: element name -> list of mass numbers
+# Two-stage sampling: 1) pick random element, 2) pick random isotope
+
+ISOTOPES = {
+    "hydrogen": [1, 2, 3, 4, 5, 6],
+    "helium": [3, 4, 5, 6, 7, 8, 9, 10],
+    "lithium": [4, 5, 6, 7, 8, 9, 10, 11, 12],
+    "beryllium": [5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
+    "boron": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
+    "carbon": [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22],
+    "nitrogen": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24],
+    "oxygen": [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],
+    "fluorine": [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
+    "neon": [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32],
+    "sodium": [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35],
+    "magnesium": [20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37],
+    "aluminum": [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
+    "silicon": [22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42],
+    "phosphorus": [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46],
+    "sulfur": [26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
+    "chlorine": [28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51],
+    "argon": [30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53],
+    "potassium": [32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55],
+    "calcium": [34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57],
+    "scandium": [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
+    "titanium": [38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61],
+    "vanadium": [40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63],
+    "chromium": [42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65],
+    "manganese": [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67],
+    "iron": [45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
+    "cobalt": [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72],
+    "nickel": [50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78],
+    "copper": [52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80],
+    "zinc": [54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82],
+    "gallium": [56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84],
+    "germanium": [58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86],
+    "arsenic": [60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
+    "selenium": [65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92],
+    "bromine": [67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94],
+    "krypton": [69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97],
+    "rubidium": [71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102],
+    "strontium": [73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104],
+    "yttrium": [77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106],
+    "zirconium": [79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108],
+    "niobium": [81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110],
+    "molybdenum": [83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113],
+    "technetium": [85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115],
+    "ruthenium": [87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118],
+    "rhodium": [89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121],
+    "palladium": [91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123],
+    "silver": [94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127],
+    "cadmium": [96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130],
+    "indium": [98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134],
+    "tin": [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137],
+    "antimony": [103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139],
+    "tellurium": [106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142],
+    "iodine": [108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144],
+    "xenon": [110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147],
+    "cesium": [112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151],
+    "barium": [114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153],
+    "lanthanum": [117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155],
+    "cerium": [119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157],
+    "praseodymium": [121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159],
+    "neodymium": [126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161],
+    "promethium": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163],
+    "samarium": [130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165],
+    "europium": [132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167],
+    "gadolinium": [136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169],
+    "terbium": [138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171],
+    "dysprosium": [140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173],
+    "holmium": [142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175],
+    "erbium": [144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177],
+    "thulium": [146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179],
+    "ytterbium": [148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181],
+    "lutetium": [150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184],
+    "hafnium": [154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186],
+    "tantalum": [156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188],
+    "tungsten": [158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190],
+    "rhenium": [160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192],
+    "osmium": [162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196],
+    "iridium": [165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199],
+    "platinum": [168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202],
+    "gold": [171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205],
+    "mercury": [175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208],
+    "thallium": [177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210],
+    "lead": [181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214],
+    "bismuth": [185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216],
+    "polonium": [190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218],
+    "astatine": [193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223],
+    "radon": [196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228],
+    "francium": [200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232],
+    "radium": [203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234],
+    "actinium": [207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236],
+    "thorium": [210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238],
+    "protactinium": [213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240],
+    "uranium": [218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242],
+    "neptunium": [225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244],
+    "plutonium": [228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247],
+    "americium": [231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249],
+    "curium": [233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252],
+    "berkelium": [235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254],
+    "californium": [237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256],
+    "einsteinium": [240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257],
+    "fermium": [242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259],
+    "mendelevium": [245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260],
+    "nobelium": [249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262],
+    "lawrencium": [251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263],
+    "rutherfordium": [253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264],
+    "dubnium": [255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265],
+    "seaborgium": [258, 259, 260, 261, 262, 263, 264, 265, 266],
+    "bohrium": [260, 261, 262, 263, 264, 265, 266, 267],
+    "hassium": [263, 264, 265, 266, 267, 268, 269, 277],
+    "meitnerium": [265, 266, 267, 268, 269, 270, 271],
+    "darmstadtium": [267, 268, 269, 270, 271, 272, 273, 281],
+    "roentgenium": [272],
+    "copernicium": [285],
+    "nihonium": [286],
+    "flerovium": [289],
+    "moscovium": [289],
+    "livermorium": [293],
+    "tennessine": [294],
+    "oganesson": [294],
+}

backend/main.py

@@ -7,10 +7,31 @@ from typing import List, Optional, Dict
 import json
 import httpx
 import os
+import logging
 from datetime import datetime
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
 app = FastAPI(title="Productive API")
 
+
+# ============================================
+# Environment Variable Fallbacks
+# ============================================
+# These allow API keys to be set via environment variables as fallback
+# when not configured in settings. Useful for HF Spaces deployment.
+
+def get_env_fallback(value: Optional[str], env_var: str) -> Optional[str]:
+    """Return value if set, otherwise check environment variable."""
+    if value:
+        return value
+    return os.environ.get(env_var)
+
 # Get the project root directory (parent of backend/)
 PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
@@ -22,22 +43,15 @@ try:
     E2B_AVAILABLE = True
 except ImportError:
     E2B_AVAILABLE = False
-    print("Warning: E2B not available. Code execution will be disabled.")
+    logger.warning("E2B not available. Code execution will be disabled.")
 
-# For research - supports two backends: "original" (default) or "tulu"
-# Set RESEARCH_BACKEND=tulu to use DR-TULU model-driven research
-RESEARCH_BACKEND = os.environ.get("RESEARCH_BACKEND", "original").lower()
+# For research
 try:
-    if RESEARCH_BACKEND == "tulu":
-        from research_tulu import stream_research
-        print(f"Research backend: DR-TULU (model-driven)")
-    else:
-        from research import stream_research
-        print(f"Research backend: Original (orchestrator-driven)")
+    from research import stream_research
     RESEARCH_AVAILABLE = True
 except ImportError as e:
     RESEARCH_AVAILABLE = False
-    print(f"Warning: Research dependencies not available ({e}). Install with: pip install trafilatura requests")
+    logger.warning(f"Research dependencies not available ({e}). Install with: pip install trafilatura requests")
 
 # For command center with tool-based launching
 try:
@@ -45,7 +59,7 @@ try:
     COMMAND_AVAILABLE = True
 except ImportError:
     COMMAND_AVAILABLE = False
-    print("Warning: Command center tool handling not available.")
+    logger.warning("Command center tool handling not available.")
 
 # Session management for sandboxes
 SANDBOXES: Dict[str, any] = {}
@@ -273,11 +287,13 @@ class ChatRequest(BaseModel):
     endpoint: str  # User's configured LLM endpoint
     token: Optional[str] = None  # Optional auth token
     model: Optional[str] = "gpt-4"  # Model name
+    extra_params: Optional[Dict] = None  # Extra parameters for API calls (e.g., enable_thinking)
     e2b_key: Optional[str] = None  # E2B API key for code execution
     serper_key: Optional[str] = None  # Serper API key for research
     research_sub_agent_model: Optional[str] = None  # Model for research sub-tasks
     research_sub_agent_endpoint: Optional[str] = None  # Endpoint for research sub-agent (may differ from main)
     research_sub_agent_token: Optional[str] = None  # Token for research sub-agent endpoint
+    research_sub_agent_extra_params: Optional[Dict] = None  # Extra params for research sub-agent
     research_parallel_workers: Optional[int] = None  # Number of parallel workers for research
     research_max_websites: Optional[int] = None  # Max websites to analyze per research session
     notebook_id: Optional[str] = None  # Unique notebook/tab ID for session management
@@ -308,7 +324,8 @@ async def stream_code_notebook(
     e2b_key: str,
     session_id: str,
     tab_id: str = "default",
-    frontend_context: Optional[Dict] = None
+    frontend_context: Optional[Dict] = None,
+    extra_params: Optional[Dict] = None
 ):
     """Handle code notebook with execution capabilities"""
 
@@ -341,14 +358,14 @@ async def stream_code_notebook(
         record_api_call(tab_id, full_messages)
 
         # Stream code execution
-        for update in stream_code_execution(client, model, full_messages, sbx, files_root=FILES_ROOT):
+        for update in stream_code_execution(client, model, full_messages, sbx, files_root=FILES_ROOT, extra_params=extra_params):
             # Forward updates to frontend
             yield f"data: {json.dumps(update)}\n\n"
 
     except Exception as e:
         import traceback
         error_message = f"Code execution error: {str(e)}\n{traceback.format_exc()}"
-        print(error_message)
+        logger.error(error_message)
 
         # Check if this is a sandbox timeout error (502)
         error_str = str(e)
@@ -373,7 +390,7 @@ async def stream_code_notebook(
                 yield f"data: {json.dumps({'type': 'info', 'content': 'New sandbox created. Retrying execution...'})}\n\n"
 
                 # Retry code execution with new sandbox
-                for update in stream_code_execution(client, model, full_messages, sbx, files_root=FILES_ROOT):
+                for update in stream_code_execution(client, model, full_messages, sbx, files_root=FILES_ROOT, extra_params=extra_params):
                     yield f"data: {json.dumps(update)}\n\n"
 
             except Exception as retry_error:
@@ -393,7 +410,9 @@ async def stream_research_notebook(
     max_websites: Optional[int] = None,
     tab_id: str = "default",
     sub_agent_endpoint: Optional[str] = None,
-    sub_agent_token: Optional[str] = None
+    sub_agent_token: Optional[str] = None,
+    extra_params: Optional[Dict] = None,
+    sub_agent_extra_params: Optional[Dict] = None
 ):
     """Handle research notebook with web search"""
 
@@ -438,13 +457,13 @@ async def stream_research_notebook(
         max_sites = max_websites if max_websites else 50
 
         # Stream research
-        for update in stream_research(client, model, question, serper_key, max_websites=max_sites, system_prompt=system_prompt, sub_agent_model=analysis_model, parallel_workers=workers, sub_agent_client=sub_agent_client):
+        for update in stream_research(client, model, question, serper_key, max_websites=max_sites, system_prompt=system_prompt, sub_agent_model=analysis_model, parallel_workers=workers, sub_agent_client=sub_agent_client, extra_params=extra_params, sub_agent_extra_params=sub_agent_extra_params):
             yield f"data: {json.dumps(update)}\n\n"
 
     except Exception as e:
         import traceback
         error_message = f"Research error: {str(e)}\n{traceback.format_exc()}"
-        print(error_message)
+        logger.error(error_message)
         yield f"data: {json.dumps({'type': 'error', 'content': error_message})}\n\n"
 
 
@@ -453,13 +472,14 @@ async def stream_command_center_notebook(
     endpoint: str,
     token: Optional[str],
     model: str,
-    tab_id: str = "0"
+    tab_id: str = "0",
+    extra_params: Optional[Dict] = None
 ):
     """Handle command center with tool-based notebook launching"""
 
     if not COMMAND_AVAILABLE:
         # Fallback to regular chat if command tools not available
-        async for chunk in stream_chat_response(messages, endpoint, token, model, "command", tab_id):
+        async for chunk in stream_chat_response(messages, endpoint, token, model, "command", tab_id, extra_params):
             yield chunk
         return
 
@@ -477,26 +497,26 @@ async def stream_command_center_notebook(
         system_prompt = get_system_prompt("command")
 
         # Build full messages: system + stored history + new messages
-        print(f"DEBUG: tab_id={tab_id}, incoming messages={messages}")
-        print(f"DEBUG: stored history length={len(CONVERSATION_HISTORY[tab_id])}")
+        logger.debug(f"tab_id={tab_id}, incoming messages={messages}")
+        logger.debug(f"stored history length={len(CONVERSATION_HISTORY[tab_id])}")
 
         # On first call, history is empty, so just use incoming messages
         # On subsequent calls, append only new messages
         if not CONVERSATION_HISTORY[tab_id]:
             # First message - use all incoming messages
             full_messages = [{"role": "system", "content": system_prompt}] + messages
-            print(f"DEBUG: First call, full_messages length={len(full_messages)}")
+            logger.debug(f"First call, full_messages length={len(full_messages)}")
         else:
             # Subsequent messages - use stored history + incoming messages
             # The incoming messages should only be the new user message
             full_messages = [{"role": "system", "content": system_prompt}] + CONVERSATION_HISTORY[tab_id] + messages
-            print(f"DEBUG: Subsequent call, full_messages length={len(full_messages)}")
+            logger.debug(f"Subsequent call, full_messages length={len(full_messages)}")
 
         # Store for debugging
         record_api_call(tab_id, full_messages)
 
         # Stream command center execution
-        for update in stream_command_center(client, model, full_messages):
+        for update in stream_command_center(client, model, full_messages, extra_params=extra_params):
             # Forward updates to frontend
             yield f"data: {json.dumps(update)}\n\n"
 
@@ -511,7 +531,7 @@ async def stream_command_center_notebook(
     except Exception as e:
         import traceback
         error_message = f"Command center error: {str(e)}\n{traceback.format_exc()}"
-        print(error_message)
+        logger.error(error_message)
         yield f"data: {json.dumps({'type': 'error', 'content': error_message})}\n\n"
 
 
@@ -521,16 +541,13 @@ async def stream_chat_response(
     token: Optional[str],
     model: str,
     notebook_type: str,
-    tab_id: str = "default"
+    tab_id: str = "default",
+    extra_params: Optional[Dict] = None
 ):
     """Proxy stream from user's configured LLM endpoint"""
 
     try:
-        print(f"=== Stream Request ===")
-        print(f"Endpoint: {endpoint}")
-        print(f"Model: {model}")
-        print(f"Messages: {len(messages)} messages")
-        print(f"Token provided: {bool(token)}")
+        logger.info(f"Stream request: endpoint={endpoint}, model={model}, messages={len(messages)}, token={'yes' if token else 'no'}")
 
         # Prepare messages with appropriate system prompt based on notebook type (with file tree)
         system_prompt = get_system_prompt(notebook_type)
@@ -545,9 +562,9 @@ async def stream_chat_response(
         if not token and "huggingface.co" in endpoint:
             token = os.getenv("HF_TOKEN")
             if token:
-                print(f"Using HF_TOKEN from environment for Hugging Face endpoint")
+                logger.debug("Using HF_TOKEN from environment for Hugging Face endpoint")
             else:
-                print(f"WARNING: No token provided and HF_TOKEN not found in environment!")
+                logger.warning("No token provided and HF_TOKEN not found in environment!")
 
         # Prepare headers
         headers = {
@@ -563,8 +580,11 @@ async def stream_chat_response(
             "stream": True,
             "temperature": 0.7
         }
+        # Apply any extra params (e.g., enable_thinking)
+        if extra_params:
+            request_body.update(extra_params)
 
-        print(f"Sending request to: {endpoint}/chat/completions")
+        logger.debug(f"Sending request to: {endpoint}/chat/completions")
 
         # Make streaming request to user's endpoint
         async with httpx.AsyncClient(timeout=60.0) as client:
@@ -578,7 +598,7 @@ async def stream_chat_response(
                     error_text = await response.aread()
                     error_detail = error_text.decode() if error_text else f"Status {response.status_code}"
                     error_message = f"LLM API error ({response.status_code}): {error_detail}"
-                    print(f"Error from LLM API: {error_message}")
+                    logger.error(f"LLM API error: {error_message}")
                     yield f"data: {json.dumps({'type': 'error', 'content': error_message})}\n\n"
                     return
 
@@ -610,13 +630,12 @@ async def stream_chat_response(
 
     except httpx.RequestError as e:
         error_message = f"Connection error to LLM endpoint: {str(e)}"
-        print(f"HTTP Request Error: {e}")
+        logger.error(f"HTTP Request Error: {e}")
         yield f"data: {json.dumps({'type': 'error', 'content': error_message})}\n\n"
     except Exception as e:
         import traceback
         error_message = f"Error: {str(e) or 'Unknown error occurred'}"
-        print(f"Exception in stream_chat_response: {e}")
-        print(traceback.format_exc())
+        logger.error(f"Exception in stream_chat_response: {e}\n{traceback.format_exc()}")
         yield f"data: {json.dumps({'type': 'error', 'content': error_message})}\n\n"
 
 
@@ -683,7 +702,7 @@ async def generate_title(request: TitleRequest):
 async def chat_stream(request: ChatRequest):
     """Proxy streaming chat to user's configured LLM endpoint"""
 
-    print("REQUEST", request.json)
+    logger.debug(f"Chat stream request: notebook_type={request.notebook_type}")
 
     if not request.messages:
         raise HTTPException(status_code=400, detail="Messages are required")
@@ -700,6 +719,11 @@ async def chat_stream(request: ChatRequest):
     # Convert frontend_context to dict if provided
     frontend_context = request.frontend_context.model_dump() if request.frontend_context else None
 
+    # Apply environment variable fallbacks for API keys
+    e2b_key = get_env_fallback(request.e2b_key, "E2B_API_KEY")
+    serper_key = get_env_fallback(request.serper_key, "SERPER_API_KEY")
+    token = get_env_fallback(request.token, "LLM_API_KEY")
+
     # Route to code execution handler for code notebooks
     if request.notebook_type == "code":
         # Use notebook_id as session key, fallback to "default" if not provided
@@ -709,12 +733,13 @@ async def chat_stream(request: ChatRequest):
             stream_code_notebook(
                 messages,
                 request.endpoint,
-                request.token,
+                token,
                 request.model or "gpt-4",
-                request.e2b_key or "",
+                e2b_key or "",
                 session_id,
                 tab_id,
-                frontend_context
+                frontend_context,
+                request.extra_params
             ),
             media_type="text/event-stream",
             headers={
@@ -728,21 +753,23 @@ async def chat_stream(request: ChatRequest):
     if request.notebook_type == "research":
         # Use sub-agent endpoint/token if provided, otherwise fall back to main
         sub_agent_endpoint = request.research_sub_agent_endpoint or request.endpoint
-        sub_agent_token = request.research_sub_agent_token if request.research_sub_agent_endpoint else request.token
+        sub_agent_token = request.research_sub_agent_token if request.research_sub_agent_endpoint else token
 
         return StreamingResponse(
             stream_research_notebook(
                 messages,
                 request.endpoint,
-                request.token,
+                token,
                 request.model or "gpt-4",
-                request.serper_key or "",
+                serper_key or "",
                 request.research_sub_agent_model,
                 request.research_parallel_workers,
                 None,
                 tab_id,
                 sub_agent_endpoint,
-                sub_agent_token
+                sub_agent_token,
+                request.extra_params,
+                request.research_sub_agent_extra_params
             ),
             media_type="text/event-stream",
             headers={
@@ -758,9 +785,10 @@ async def chat_stream(request: ChatRequest):
             stream_command_center_notebook(
                 messages,
                 request.endpoint,
-                request.token,
+                token,
                 request.model or "gpt-4",
-                tab_id
+                tab_id,
+                request.extra_params
             ),
             media_type="text/event-stream",
             headers={
@@ -775,10 +803,11 @@ async def chat_stream(request: ChatRequest):
         stream_chat_response(
             messages,
             request.endpoint,
-            request.token,
+            token,
             request.model or "gpt-4",
             request.notebook_type,
-            tab_id
+            tab_id,
+            request.extra_params
         ),
         media_type="text/event-stream",
         headers={
@@ -901,7 +930,9 @@ os.makedirs(CONFIG_DIR, exist_ok=True)
 
 SETTINGS_FILE = os.path.join(CONFIG_DIR, "settings.json")
 FILES_ROOT = os.getcwd()  # Root directory for file tree (current working directory)
-WORKSPACE_FILE = os.path.join(FILES_ROOT, "workspace.json")  # Workspace is per-project
+SESSIONS_ROOT = os.path.join(FILES_ROOT, "sessions")  # Sessions are stored in sessions/ subfolder
+CURRENT_SESSION = None  # Name of the current session (None = no session selected)
+WORKSPACE_FILE = None  # Set when session is selected
 
 # Directories/patterns to exclude from file tree
 FILES_EXCLUDE = {
@@ -964,6 +995,188 @@ async def save_settings(settings: dict):
         raise HTTPException(status_code=500, detail=f"Failed to save settings: {str(e)}")
 
 
+# ============================================
+# Session Management
+# ============================================
+
+def get_session_path(session_name: str) -> str:
+    """Get the full path for a session folder"""
+    return os.path.join(SESSIONS_ROOT, session_name)
+
+
+def list_sessions() -> list:
+    """List all available sessions"""
+    sessions = []
+    if os.path.exists(SESSIONS_ROOT):
+        for name in os.listdir(SESSIONS_ROOT):
+            session_path = os.path.join(SESSIONS_ROOT, name)
+            workspace_file = os.path.join(session_path, "workspace.json")
+            if os.path.isdir(session_path) and os.path.exists(workspace_file):
+                # Get modification time
+                mtime = os.path.getmtime(workspace_file)
+                sessions.append({
+                    "name": name,
+                    "modified": mtime
+                })
+    # Sort by modification time (most recent first)
+    sessions.sort(key=lambda x: x["modified"], reverse=True)
+    return sessions
+
+
+def select_session(session_name: str) -> bool:
+    """Select a session and update global paths"""
+    global CURRENT_SESSION, WORKSPACE_FILE, FILES_ROOT, CONVERSATION_HISTORY, MESSAGE_HISTORY
+
+    session_path = get_session_path(session_name)
+    workspace_file = os.path.join(session_path, "workspace.json")
+
+    if not os.path.exists(session_path):
+        return False
+
+    CURRENT_SESSION = session_name
+    WORKSPACE_FILE = workspace_file
+    # FILES_ROOT stays at the original working directory (not session-specific)
+
+    # Clear backend state when switching sessions
+    CONVERSATION_HISTORY.clear()
+    MESSAGE_HISTORY.clear()
+
+    return True
+
+
+def create_session(session_name: str) -> bool:
+    """Create a new session folder with default workspace"""
+    session_path = get_session_path(session_name)
+
+    if os.path.exists(session_path):
+        return False  # Session already exists
+
+    os.makedirs(session_path, exist_ok=True)
+
+    # Create default workspace.json
+    workspace_file = os.path.join(session_path, "workspace.json")
+    with open(workspace_file, "w") as f:
+        json.dump(get_default_workspace(), f, indent=2)
+
+    return True
+
+
+@app.get("/api/sessions/random-name")
+async def api_random_session_name():
+    """Get a random isotope name for session naming.
+    Uses two-stage sampling: 1) pick random element, 2) pick random isotope.
+    This gives equal weight to all elements regardless of isotope count.
+    """
+    import random
+    from defaultnames import ISOTOPES
+    # Two-stage sampling: first pick element, then pick isotope
+    element = random.choice(list(ISOTOPES.keys()))
+    mass_number = random.choice(ISOTOPES[element])
+    return {"name": f"{element}-{mass_number}"}
+
+
+@app.get("/api/sessions")
+async def api_list_sessions():
+    """List all available sessions"""
+    return {
+        "sessions": list_sessions(),
+        "current": CURRENT_SESSION,
+        "sessionsRoot": SESSIONS_ROOT
+    }
+
+
+@app.post("/api/sessions")
+async def api_create_session(data: dict):
+    """Create a new session"""
+    name = data.get("name", "").strip()
+    if not name:
+        raise HTTPException(status_code=400, detail="Session name is required")
+
+    # Sanitize name for filesystem
+    safe_name = "".join(c for c in name if c.isalnum() or c in "- _").strip()
+    if not safe_name:
+        raise HTTPException(status_code=400, detail="Invalid session name")
+
+    if not create_session(safe_name):
+        raise HTTPException(status_code=409, detail="Session already exists")
+
+    # Auto-select the new session
+    select_session(safe_name)
+
+    return {"success": True, "name": safe_name}
+
+
+@app.post("/api/sessions/select")
+async def api_select_session(data: dict):
+    """Select an existing session"""
+    name = data.get("name", "").strip()
+    if not name:
+        raise HTTPException(status_code=400, detail="Session name is required")
+
+    if not select_session(name):
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    return {"success": True, "name": name}
+
+
+@app.post("/api/sessions/rename")
+async def api_rename_session(data: dict):
+    """Rename a session"""
+    old_name = data.get("oldName", "").strip()
+    new_name = data.get("newName", "").strip()
+
+    if not old_name or not new_name:
+        raise HTTPException(status_code=400, detail="Both oldName and newName are required")
+
+    # Sanitize new name
+    safe_new_name = "".join(c for c in new_name if c.isalnum() or c in "- _").strip()
+    if not safe_new_name:
+        raise HTTPException(status_code=400, detail="Invalid new session name")
+
+    old_path = get_session_path(old_name)
+    new_path = get_session_path(safe_new_name)
+
+    if not os.path.exists(old_path):
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    if os.path.exists(new_path):
+        raise HTTPException(status_code=409, detail="A session with that name already exists")
+
+    os.rename(old_path, new_path)
+
+    # Update current session if it was renamed
+    global CURRENT_SESSION, WORKSPACE_FILE
+    if CURRENT_SESSION == old_name:
+        CURRENT_SESSION = safe_new_name
+        WORKSPACE_FILE = os.path.join(new_path, "workspace.json")
+
+    return {"success": True, "name": safe_new_name}
+
+
+@app.delete("/api/sessions/{session_name}")
+async def api_delete_session(session_name: str):
+    """Delete a session"""
+    import shutil
+
+    if not session_name:
+        raise HTTPException(status_code=400, detail="Session name is required")
+
+    session_path = get_session_path(session_name)
+
+    if not os.path.exists(session_path):
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    # Don't allow deleting the current session
+    global CURRENT_SESSION
+    if CURRENT_SESSION == session_name:
+        raise HTTPException(status_code=400, detail="Cannot delete the currently active session")
+
+    # Delete the session folder
+    shutil.rmtree(session_path)
+
+    return {"success": True}
+
+
 # ============================================
 # Workspace State Persistence
 # ============================================
@@ -994,6 +1207,8 @@ def get_default_workspace():
 @app.get("/api/workspace")
 async def get_workspace():
     """Load workspace state from workspace.json file"""
+    if WORKSPACE_FILE is None:
+        raise HTTPException(status_code=400, detail="No session selected")
     try:
         if os.path.exists(WORKSPACE_FILE):
             with open(WORKSPACE_FILE, "r") as f:
@@ -1009,6 +1224,8 @@ async def get_workspace():
 @app.post("/api/workspace")
 async def save_workspace(workspace: dict):
     """Save workspace state to workspace.json file"""
+    if WORKSPACE_FILE is None:
+        raise HTTPException(status_code=400, detail="No session selected")
     try:
         with open(WORKSPACE_FILE, "w") as f:
             json.dump(workspace, f, indent=2)
@@ -1020,6 +1237,8 @@ async def save_workspace(workspace: dict):
 @app.post("/api/workspace/clear")
 async def clear_workspace():
     """Clear workspace and start fresh"""
+    if WORKSPACE_FILE is None:
+        raise HTTPException(status_code=400, detail="No session selected")
     try:
         default_workspace = get_default_workspace()
         with open(WORKSPACE_FILE, "w") as f:
@@ -1190,28 +1409,22 @@ def start():
     # Set custom config directory if provided
     if args.config_dir:
         set_config_dir(args.config_dir)
-        print(f"Using config directory: {args.config_dir}")
+        logger.info(f"Using config directory: {args.config_dir}")
 
     # Set custom workspace directory if provided
     if args.workspace_dir:
-        global FILES_ROOT, WORKSPACE_FILE
+        global FILES_ROOT, SESSIONS_ROOT
         FILES_ROOT = os.path.abspath(args.workspace_dir)
-        os.makedirs(FILES_ROOT, exist_ok=True)
-        WORKSPACE_FILE = os.path.join(FILES_ROOT, "workspace.json")
+        SESSIONS_ROOT = os.path.join(FILES_ROOT, "sessions")
 
-    # Clear workspace if --clean flag is provided
-    if args.clean:
-        print("Clearing workspace...")
-        default_workspace = get_default_workspace()
-        with open(WORKSPACE_FILE, "w") as f:
-            json.dump(default_workspace, f, indent=2)
-        print("Workspace cleared.")
+    # Ensure sessions directory exists
+    os.makedirs(SESSIONS_ROOT, exist_ok=True)
 
     url = f"http://localhost:{args.port}"
-    print(f"Starting Productive server...")
-    print(f"Config directory: {CONFIG_DIR}")
-    print(f"Working directory: {FILES_ROOT}")
-    print(f"Opening {url} in your browser...")
+    logger.info(f"Starting Productive server...")
+    logger.info(f"Config directory: {CONFIG_DIR}")
+    logger.info(f"Sessions directory: {SESSIONS_ROOT}")
+    logger.info(f"Opening {url} in your browser...")
 
     # Open browser after a short delay to let the server start
     if not args.no_browser:

backend/research.py

@@ -1,12 +1,20 @@
 """
-Research notebook backend - handles deep research with web search
+Research notebook backend using DR-TULU model - model-driven deep research
+
+DR-TULU drives the research loop - it decides when to search, what to search for,
+and when it has enough information to answer.
 """
 import json
+import logging
 import os
-from typing import List, Dict, Optional
+import re
+import uuid
+from typing import List, Dict, Optional, Tuple
 import requests
 import trafilatura
 
+logger = logging.getLogger(__name__)
+
 
 def search_web(query: str, api_key: str, num_results: int = 10) -> List[Dict[str, str]]:
     """Search the web using Serper API"""
@@ -33,7 +41,7 @@ def search_web(query: str, api_key: str, num_results: int = 10) -> List[Dict[str
             })
         return results
     except Exception as e:
-        print(f"Search error: {e}")
+        logger.error(f"Search error: {e}")
         return []
 
 
@@ -51,148 +59,167 @@ def extract_content(url: str) -> Optional[str]:
         )
         return text
     except Exception as e:
-        print(f"Content extraction error for {url}: {e}")
+        logger.error(f"Content extraction error for {url}: {e}")
         return None
 
 
-def generate_queries(client, model: str, user_question: str, existing_knowledge: str = "") -> List[str]:
-    """Generate search queries using LLM"""
-    prompt = f"""Given this research question: "{user_question}"
-
-{f"Current knowledge gathered: {existing_knowledge}" if existing_knowledge else ""}
+def generate_snippet_id() -> str:
+    """Generate unique snippet ID"""
+    return f"S_{uuid.uuid4().hex[:8]}"
 
-Generate 3-5 specific, targeted search queries that would help answer this question.
-Focus on aspects not yet covered or that need more depth.
 
-Return ONLY a JSON array of query strings, nothing else.
-Example: ["query 1", "query 2", "query 3"]"""
-
-    messages = [{"role": "user", "content": prompt}]
-
-    try:
-        response = client.chat.completions.create(
-            model=model,
-            messages=messages,
-            max_tokens=500,
-            temperature=0.7,
-        )
+def generate_webpage_id() -> str:
+    """Generate unique webpage ID"""
+    return f"W_{uuid.uuid4().hex[:8]}"
 
-        content = response.choices[0].message.content
 
-        # Extract JSON array
-        start = content.find('[')
-        end = content.rfind(']') + 1
-        if start != -1 and end > start:
-            json_str = content[start:end]
-            queries = json.loads(json_str)
-            return queries[:5]
-    except Exception as e:
-        print(f"Query generation error: {e}")
+def parse_tool_calls(text: str) -> List[Dict]:
+    """
+    Parse <call_tool name="...">query</call_tool> from model output.
+    Returns list of {"name": str, "query": str, "params": dict}
+    """
+    pattern = r'<call_tool\s+name="([^"]+)"([^>]*)>([^<]+)</call_tool>'
+    matches = re.findall(pattern, text)
 
-    return [user_question]
+    tool_calls = []
+    for name, params_str, query in matches:
+        # Parse optional params like limit="8" year="2021-2025"
+        params = {}
+        param_pattern = r'(\w+)="([^"]+)"'
+        for param_name, param_value in re.findall(param_pattern, params_str):
+            params[param_name] = param_value
 
+        tool_calls.append({
+            "name": name.strip(),
+            "query": query.strip(),
+            "params": params
+        })
 
-def analyze_content(client, model: str, user_question: str, content: str, source_url: str) -> str:
-    """Analyze content for relevance to research question"""
-    prompt = f"""Research Question: "{user_question}"
+    return tool_calls
 
-Source: {source_url}
 
-Content:
-{content[:4000]}
+def parse_think_blocks(text: str) -> List[str]:
+    """Extract <think>...</think> content"""
+    pattern = r'<think>(.*?)</think>'
+    return re.findall(pattern, text, re.DOTALL)
 
-Extract ONLY the information relevant to answering the research question.
-Be concise and factual. Include specific claims, data, or insights.
-If nothing is relevant, return "No relevant information found."
 
-Your analysis:"""
+def parse_answer(text: str) -> Optional[str]:
+    """Extract <answer>...</answer> content"""
+    pattern = r'<answer>(.*?)</answer>'
+    match = re.search(pattern, text, re.DOTALL)
+    return match.group(1).strip() if match else None
 
-    messages = [{"role": "user", "content": prompt}]
 
-    try:
-        response = client.chat.completions.create(
-            model=model,
-            messages=messages,
-            max_tokens=800,
-            temperature=0.5,
+def format_search_results(results: List[Dict], query: str) -> str:
+    """
+    Format search results as DR-TULU tool output.
+    """
+    if not results:
+        return "<tool_output>No results found.</tool_output>"
+
+    snippets = []
+    for r in results:
+        snippet_id = generate_snippet_id()
+        # Escape XML special chars in content
+        title = r.get("title", "").replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        snippet_text = r.get("snippet", "").replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        url = r.get("url", "")
+
+        snippets.append(
+            f'<snippet id="{snippet_id}" url="{url}" title="{title}">\n'
+            f'{snippet_text}\n'
+            f'</snippet>'
         )
-        return response.choices[0].message.content
-    except Exception as e:
-        print(f"Analysis error: {e}")
-        return "Error analyzing content"
-
 
-def assess_completeness(client, model: str, user_question: str, findings: List[Dict]) -> Dict:
-    """Assess if we have enough information"""
-    findings_text = "\n\n".join([f"Source: {f['source']}\n{f['analysis']}" for f in findings])
+    return f"<tool_output>\n" + "\n".join(snippets) + "\n</tool_output>"
 
-    prompt = f"""Research Question: "{user_question}"
 
-Information gathered so far:
-{findings_text}
-
-Evaluate:
-1. Do we have sufficient information to answer the question? (yes/no)
-2. What key aspects are still missing or need more depth?
-3. Provide a brief reasoning (1-2 sentences) about whether to continue or finish.
-
-Return ONLY a JSON object with this structure:
-{{"sufficient": true/false, "missing_aspects": ["aspect 1", "aspect 2"], "reasoning": "brief explanation"}}"""
-
-    messages = [{"role": "user", "content": prompt}]
-
-    try:
-        response = client.chat.completions.create(
-            model=model,
-            messages=messages,
-            max_tokens=500,
-            temperature=0.3,
-        )
-
-        content = response.choices[0].message.content
-
-        # Extract JSON
-        start = content.find('{')
-        end = content.rfind('}') + 1
-        if start != -1 and end > start:
-            json_str = content[start:end]
-            return json.loads(json_str)
-    except Exception as e:
-        print(f"Assessment error: {e}")
+def format_webpage_content(url: str, title: str, content: str) -> str:
+    """
+    Format extracted webpage as DR-TULU tool output.
+    """
+    if not content:
+        return f"<tool_output>Could not extract content from {url}</tool_output>"
+
+    webpage_id = generate_webpage_id()
+    # Truncate very long content
+    if len(content) > 8000:
+        content = content[:8000] + "\n[Content truncated...]"
+
+    # Escape XML special chars
+    content = content.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+    title = title.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+    return (
+        f"<tool_output>\n"
+        f'<webpage id="{webpage_id}" url="{url}" title="{title}">\n'
+        f'{content}\n'
+        f'</webpage>\n'
+        f"</tool_output>"
+    )
+
+
+def execute_tool(
+    tool_name: str,
+    query: str,
+    params: dict,
+    serper_key: str
+) -> Tuple[str, List[Dict]]:
+    """
+    Execute a tool and return (formatted_output, raw_results).
+    """
+    if tool_name == "google_search":
+        num_results = int(params.get("limit", 10))
+        results = search_web(query, serper_key, num_results=num_results)
+        formatted = format_search_results(results, query)
+        return formatted, results
+
+    elif tool_name == "browse_webpage":
+        # query is the URL for browse_webpage
+        url = query
+        content = extract_content(url)
+        title = url  # Could extract from content if needed
+        formatted = format_webpage_content(url, title, content or "")
+        return formatted, [{"url": url, "content": content, "title": title}]
 
-    return {"sufficient": len(findings) >= 5, "missing_aspects": [], "reasoning": "Default assessment based on findings count."}
+    else:
+        return f"<tool_output>Unknown tool: {tool_name}</tool_output>", []
 
 
-def generate_final_report(client, model: str, user_question: str, findings: List[Dict], system_prompt: str = "") -> str:
-    """Generate final research report"""
-    findings_text = "\n\n".join([
-        f"Source {i+1}: {f['source']}\n{f['analysis']}"
-        for i, f in enumerate(findings)
-    ])
+def get_dr_tulu_system_prompt() -> str:
+    """Return the DR-TULU system prompt"""
+    return '''You are a research assistant who answers questions through iterative reasoning and research.
 
-    prompt = f"""Research Question: "{user_question}"
+## Process
+- Use <think></think> tags to show your reasoning at any point.
+- Use <call_tool name="...">query</call_tool> when you need information (see tools below).
+- You can alternate between thinking and searching multiple times.
+- Only provide <answer></answer> tags when you have enough information for a complete response.
+- Support every non-trivial claim with retrieved evidence. Wrap the exact claim span in <cite id="ID1,ID2">...</cite>, where id are snippet IDs from searched results.
 
-All information gathered from {len(findings)} sources:
+## Calling Tools (<call_tool name="...">query</call_tool>)
 
-{findings_text}
+1. google_search
+- Purpose: general web search.
+- Input via: <call_tool name="google_search">your query</call_tool>
+- Output: web search snippets.
 
-Write a concise, well-structured report following the guidelines in your system instructions. Remember to use tables where appropriate and wrap your final report in <result> tags."""
+2. browse_webpage
+- Purpose: open a specific URL and extract readable page text.
+- Input via: <call_tool name="browse_webpage">https://example.com/article</call_tool>
+- Output: webpage content.
 
-    messages = [{"role": "user", "content": prompt}]
-    if system_prompt:
-        messages.insert(0, {"role": "system", "content": system_prompt})
+## Tool Output
+- After you issue a tool call, we will execute it and return results wrapped in <tool_output> tags.
+- For web search: <tool_output><snippet id=UNIQUE_ID url="..." title="...">content</snippet>...</tool_output>
+- For web browsing: <tool_output><webpage id=UNIQUE_ID url="..." title="...">content</webpage></tool_output>
 
-    try:
-        response = client.chat.completions.create(
-            model=model,
-            messages=messages,
-            max_tokens=3000,
-            temperature=0.7,
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        print(f"Report generation error: {e}")
-        return "Error generating report"
+## Answer and Citation Format
+- Once you collect all necessary information, generate the final answer with <answer></answer> tags.
+- In your answer, wrap supported text in <cite id="SNIPPET_ID">...</cite> using exact IDs from returned snippets.
+- Write comprehensive, well-structured answers with clear sections when appropriate.
+'''
 
 
 def stream_research(
@@ -205,260 +232,245 @@ def stream_research(
     system_prompt: str = "",
     sub_agent_model: Optional[str] = None,
     parallel_workers: int = 8,
-    sub_agent_client=None  # Optional separate client for sub-agent
+    max_tool_calls: int = 20,
+    **kwargs
 ):
     """
-    Stream deep research results with progress updates
+    Stream deep research results using DR-TULU.
 
-    Args:
-        sub_agent_model: Smaller/faster model for analyzing individual web pages. If None, uses main model.
-        parallel_workers: Number of parallel workers for extract+analyze operations
-        sub_agent_client: Optional separate OpenAI client for sub-agent (if using different endpoint)
+    The model drives the research loop - it decides when to search,
+    what to search for, and when it has enough information to answer.
 
-    Yields:
-        dict: Updates with type 'progress', 'source', 'query_stats', 'report', 'result', 'result_preview', 'done', or 'error'
+    Yields same event types as the original research.py for API compatibility.
     """
-    import concurrent.futures
-    import re
-    from collections import defaultdict
 
-    findings = []
-    websites_visited = 0
-    iteration = 0
+    # Build system prompt
+    dr_tulu_system = get_dr_tulu_system_prompt()
+    if system_prompt:
+        dr_tulu_system += f"\n\n{system_prompt}"
 
-    # Use sub-agent model/client for analysis if provided, otherwise use main
-    analysis_model = sub_agent_model if sub_agent_model else model
-    analysis_client = sub_agent_client if sub_agent_client else client
+    messages = [
+        {"role": "system", "content": dr_tulu_system},
+        {"role": "user", "content": question}
+    ]
 
-    yield {
-        "type": "status",
-        "message": f"Starting research: {question}"
-    }
+    yield {"type": "status", "message": f"Starting DR-TULU research: {question}"}
 
-    while iteration < max_iterations and websites_visited < max_websites:
+    tool_call_count = 0
+    findings = []  # Track sources for compatibility
+    all_queries = []  # Track queries for compatibility
+    iteration = 0
+    max_iterations_without_progress = 3
+    iterations_without_tool_calls = 0
+
+    while tool_call_count < max_tool_calls:
         iteration += 1
 
-        # Generate queries
-        yield {
-            "type": "status",
-            "message": "Generating search queries..."
-        }
-
-        existing_knowledge = "\n".join([f['analysis'] for f in findings[-3:]])
-        queries = generate_queries(client, model, question, existing_knowledge)
-
-        yield {
-            "type": "queries",
-            "queries": queries,
-            "iteration": iteration
-        }
-
-        # Collect all search results for all queries in parallel
-        query_results = {}  # query_index -> list of results
-        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
-            future_to_query_idx = {
-                executor.submit(search_web, query, serper_key, num_results=5): idx
-                for idx, query in enumerate(queries)
+        # Call DR-TULU
+        yield {"type": "status", "message": "Thinking..."}
+
+        try:
+            response = client.chat.completions.create(
+                model=model,
+                messages=messages,
+                max_tokens=4096,
+                temperature=0.7,
+            )
+            assistant_message = response.choices[0].message.content
+        except Exception as e:
+            yield {"type": "error", "content": f"Model error: {str(e)}"}
+            yield {"type": "done"}
+            return
+
+        # Parse thinking blocks and yield as status
+        think_blocks = parse_think_blocks(assistant_message)
+        for thought in think_blocks:
+            # Truncate long thoughts for status display
+            thought_preview = thought[:300].strip()
+            if len(thought) > 300:
+                thought_preview += "..."
+            yield {"type": "status", "message": f"Reasoning: {thought_preview}"}
+
+        # Check for final answer
+        answer = parse_answer(assistant_message)
+        if answer:
+            yield {"type": "status", "message": "Research complete! Generating report..."}
+
+            # Wrap in <result> tags for compatibility with command center
+            result_content = answer
+            if "<result>" not in answer:
+                result_content = f"<result>\n{answer}\n</result>"
+
+            yield {"type": "result_preview", "content": answer, "figures": {}}
+            yield {"type": "result", "content": answer, "figures": {}}
+            yield {"type": "done"}
+            return
+
+        # Parse and execute tool calls
+        tool_calls = parse_tool_calls(assistant_message)
+
+        if not tool_calls:
+            # No tool calls and no answer - model might be stuck
+            iterations_without_tool_calls += 1
+
+            if iterations_without_tool_calls >= max_iterations_without_progress:
+                # Force final answer
+                yield {"type": "status", "message": "No more searches needed, generating final answer..."}
+                messages.append({"role": "assistant", "content": assistant_message})
+                messages.append({"role": "user", "content": "Please provide your final answer now using <answer></answer> tags."})
+                continue
+
+            # Append message and continue to prompt for more
+            messages.append({"role": "assistant", "content": assistant_message})
+            messages.append({"role": "user", "content": "Please continue your research or provide your answer using <answer></answer> tags."})
+            continue
+
+        # Reset counter since we have tool calls
+        iterations_without_tool_calls = 0
+
+        # Track queries for compatibility - build map of query -> global index
+        new_queries = [tc["query"] for tc in tool_calls if tc["name"] == "google_search"]
+        query_start_idx = len(all_queries)  # Starting global index for this batch
+
+        if new_queries:
+            all_queries.extend(new_queries)
+            yield {
+                "type": "queries",
+                "queries": new_queries,
+                "iteration": iteration
             }
 
-            for future in concurrent.futures.as_completed(future_to_query_idx):
-                query_idx = future_to_query_idx[future]
-                try:
-                    results = future.result()
-                    query_results[query_idx] = results
-                except Exception as e:
-                    print(f"Search failed for query {query_idx}: {e}")
-                    query_results[query_idx] = []
-
-        # Interleave results from all queries
-        interleaved_urls = []
-        max_results = max((len(results) for results in query_results.values()), default=0)
-
-        for result_idx in range(max_results):
-            for query_idx in range(len(queries)):
-                if query_idx in query_results and result_idx < len(query_results[query_idx]):
-                    result = query_results[query_idx][result_idx]
-                    interleaved_urls.append({
-                        'query_index': query_idx,
-                        'query_text': queries[query_idx],
-                        'url': result['url'],
-                        'title': result['title']
-                    })
+        # Track stats per query for this batch
+        query_stats = {}  # local index -> {relevant, irrelevant, error}
 
-        # Track stats per query
-        query_stats = defaultdict(lambda: {'relevant': 0, 'irrelevant': 0, 'error': 0})
-
-        # Process URLs in parallel with interleaved order
-        def process_url(url_data):
-            """Extract content and analyze for a single URL"""
-            query_idx = url_data['query_index']
-            query_text = url_data['query_text']
-            url = url_data['url']
-            title = url_data['title']
-
-            try:
-                # Extract content
-                content = extract_content(url)
-
-                if not content or len(content) < 100:
-                    return {
-                        'query_index': query_idx,
-                        'query_text': query_text,
-                        'title': title,
-                        'url': url,
-                        'analysis': "Could not extract content from this page.",
-                        'is_relevant': False,
-                        'is_error': True,
-                        'error_message': "Content extraction failed"
-                    }
+        # Execute tools and collect results
+        tool_outputs = []
+        search_idx = 0  # Track which search query we're on within this batch
 
-                # Analyze content using sub-agent client if available
-                analysis = analyze_content(analysis_client, analysis_model, question, content, url)
+        for i, tc in enumerate(tool_calls):
+            tool_call_count += 1
 
-                is_relevant = "no relevant information" not in analysis.lower()
+            if tc["name"] == "google_search":
+                # Calculate global query index
+                global_query_idx = query_start_idx + search_idx
 
-                return {
-                    'query_index': query_idx,
-                    'query_text': query_text,
-                    'title': title,
-                    'url': url,
-                    'analysis': analysis,
-                    'is_relevant': is_relevant,
-                    'is_error': False,
-                    'error_message': ""
+                yield {
+                    "type": "status",
+                    "message": f"Searching: {tc['query'][:50]}..."
                 }
-            except Exception as e:
-                return {
-                    'query_index': query_idx,
-                    'query_text': query_text,
-                    'title': title,
-                    'url': url,
-                    'analysis': f"Error: {str(e)}",
-                    'is_relevant': False,
-                    'is_error': True,
-                    'error_message': str(e)
+
+                # Initialize stats for this query
+                if global_query_idx not in query_stats:
+                    query_stats[global_query_idx] = {"relevant": 0, "irrelevant": 0, "error": 0}
+            else:
+                global_query_idx = None  # browse_webpage doesn't have a query index
+                yield {
+                    "type": "status",
+                    "message": f"Browsing: {tc['query'][:50]}..."
                 }
 
-        # Process all URLs in parallel with progress updates
-        with concurrent.futures.ThreadPoolExecutor(max_workers=parallel_workers) as executor:
-            futures = {executor.submit(process_url, url_data): url_data for url_data in interleaved_urls[:max_websites - websites_visited]}
-
-            for future in concurrent.futures.as_completed(futures):
-                if websites_visited >= max_websites:
-                    break
-
-                try:
-                    result = future.result()
-                    websites_visited += 1
-
-                    # Update stats
-                    if result['is_error']:
-                        query_stats[result['query_index']]['error'] += 1
-                    elif result['is_relevant']:
-                        query_stats[result['query_index']]['relevant'] += 1
-                        # Add to findings
-                        findings.append({
-                            'source': result['url'],
-                            'title': result['title'],
-                            'analysis': result['analysis']
-                        })
-                    else:
-                        query_stats[result['query_index']]['irrelevant'] += 1
-
-                    # Send source event
+            formatted_output, raw_results = execute_tool(
+                tc["name"],
+                tc["query"],
+                tc["params"],
+                serper_key
+            )
+            tool_outputs.append(formatted_output)
+
+            # Yield source events for compatibility
+            if tc["name"] == "google_search":
+                for j, result in enumerate(raw_results):
+                    findings.append({
+                        "source": result.get("url", ""),
+                        "title": result.get("title", ""),
+                        "analysis": result.get("snippet", "")
+                    })
+
+                    # All search results are considered relevant (DR-TULU decides what to use)
+                    query_stats[global_query_idx]["relevant"] += 1
+
                     yield {
                         "type": "source",
-                        "query_index": result['query_index'],
-                        "query_text": result['query_text'],
-                        "title": result['title'],
-                        "url": result['url'],
-                        "analysis": result['analysis'],
+                        "query_index": global_query_idx,
+                        "query_text": tc["query"],
+                        "title": result.get("title", ""),
+                        "url": result.get("url", ""),
+                        "analysis": result.get("snippet", ""),
                         "finding_count": len(findings),
-                        "is_relevant": result['is_relevant'],
-                        "is_error": result['is_error'],
-                        "error_message": result['error_message']
+                        "is_relevant": True,  # DR-TULU decides relevance
+                        "is_error": False,
+                        "error_message": ""
                     }
 
-                    # Send updated stats for this query
-                    stats = query_stats[result['query_index']]
+                # Emit query_stats after processing all results for this query
+                yield {
+                    "type": "query_stats",
+                    "query_index": global_query_idx,
+                    "relevant_count": query_stats[global_query_idx]["relevant"],
+                    "irrelevant_count": query_stats[global_query_idx]["irrelevant"],
+                    "error_count": query_stats[global_query_idx]["error"]
+                }
+
+                search_idx += 1  # Move to next search query
+
+            elif tc["name"] == "browse_webpage":
+                # browse_webpage results don't belong to a search query
+                # We can associate them with the last search query or skip
+                for result in raw_results:
+                    content = result.get("content", "")
+                    is_error = not content
+                    findings.append({
+                        "source": tc["query"],
+                        "title": result.get("title", tc["query"]),
+                        "analysis": content[:500] if content else "Failed to extract"
+                    })
+
+                    # For browse_webpage, use a pseudo-index or skip query association
+                    # Since it's browsing a specific URL, we'll emit it without query grouping
                     yield {
-                        "type": "query_stats",
-                        "query_index": result['query_index'],
-                        "relevant_count": stats['relevant'],
-                        "irrelevant_count": stats['irrelevant'],
-                        "error_count": stats['error']
+                        "type": "source",
+                        "query_index": -1,  # Special index for browse results
+                        "query_text": f"Browse: {tc['query'][:50]}",
+                        "title": result.get("title", tc["query"]),
+                        "url": tc["query"],
+                        "analysis": content[:500] if content else "Failed to extract content",
+                        "finding_count": len(findings),
+                        "is_relevant": not is_error,
+                        "is_error": is_error,
+                        "error_message": "Content extraction failed" if is_error else ""
                     }
 
-                except Exception as e:
-                    print(f"Error processing URL: {e}")
+            if tool_call_count >= max_tool_calls:
+                break
 
-        # Assess completeness
-        if len(findings) >= 3:  # Only assess if we have some findings
-            yield {
-                "type": "status",
-                "message": "Evaluating information gathered..."
-            }
+        # Append assistant message and tool results to conversation
+        messages.append({"role": "assistant", "content": assistant_message})
 
-            assessment = assess_completeness(client, model, question, findings)
+        # Combine all tool outputs into one user message
+        combined_output = "\n\n".join(tool_outputs)
+        messages.append({"role": "user", "content": combined_output})
 
-            yield {
-                "type": "assessment",
-                "sufficient": assessment.get('sufficient', False),
-                "missing_aspects": assessment.get('missing_aspects', []),
-                "findings_count": len(findings),
-                "reasoning": assessment.get('reasoning', '')
-            }
+    # Max tool calls reached - ask for final answer
+    yield {"type": "status", "message": "Maximum searches reached, generating final answer..."}
 
-            if assessment.get('sufficient', False):
-                yield {
-                    "type": "status",
-                    "message": "Research complete! Generating final report..."
-                }
-                break
+    messages.append({
+        "role": "user",
+        "content": "You have reached the maximum number of tool calls. Please provide your final answer now using <answer></answer> tags based on the information gathered."
+    })
 
-    # Generate final report
-    if findings:
-        report = generate_final_report(client, model, question, findings, system_prompt)
-
-        print("\n" + "="*80)
-        print("RAW REPORT TEXT:")
-        print("="*80)
-        print(report)
-        print("="*80 + "\n")
-
-        # Parse result tags from report
-        result_match = re.search(r'<result>(.*?)</result>', report, re.DOTALL)
-
-        result_content = None
-        if result_match:
-            result_content = result_match.group(1).strip()
-            print("\n" + "="*80)
-            print("EXTRACTED RESULT CONTENT:")
-            print("="*80)
-            print(result_content)
-            print("="*80 + "\n")
-        else:
-            # If no result tags, use the full report
-            result_content = report
-            print(f"Warning: No <result> tags found in report, using full content")
-
-        # Send result preview to research notebook
-        yield {
-            "type": "result_preview",
-            "content": result_content,
-            "figures": {}  # Research doesn't generate figures
-        }
-
-        # Send result to command center
-        yield {
-            "type": "result",
-            "content": result_content,
-            "figures": {}
-        }
-    else:
-        yield {
-            "type": "error",
-            "content": "No relevant information found. Please try a different question."
-        }
+    try:
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=4096,
+            temperature=0.7,
+        )
+        final_message = response.choices[0].message.content
+        answer = parse_answer(final_message) or final_message
+
+        yield {"type": "result_preview", "content": answer, "figures": {}}
+        yield {"type": "result", "content": answer, "figures": {}}
+    except Exception as e:
+        yield {"type": "error", "content": f"Failed to generate final answer: {str(e)}"}
 
     yield {"type": "done"}

backend/research_tulu.py

@@ -1,473 +0,0 @@
-"""
-Research notebook backend using DR-TULU model - model-driven deep research
-
-DR-TULU drives the research loop - it decides when to search, what to search for,
-and when it has enough information to answer.
-"""
-import json
-import os
-import re
-import uuid
-from typing import List, Dict, Optional, Tuple
-import requests
-import trafilatura
-
-
-def search_web(query: str, api_key: str, num_results: int = 10) -> List[Dict[str, str]]:
-    """Search the web using Serper API"""
-    url = "https://google.serper.dev/search"
-    payload = json.dumps({"q": query, "num": num_results})
-    headers = {
-        'X-API-KEY': api_key,
-        'Content-Type': 'application/json'
-    }
-
-    try:
-        response = requests.post(url, headers=headers, data=payload, timeout=10)
-
-        if response.status_code != 200:
-            return []
-
-        data = response.json()
-        results = []
-        for item in data.get('organic', []):
-            results.append({
-                'title': item.get('title', ''),
-                'url': item.get('link', ''),
-                'snippet': item.get('snippet', '')
-            })
-        return results
-    except Exception as e:
-        print(f"Search error: {e}")
-        return []
-
-
-def extract_content(url: str) -> Optional[str]:
-    """Extract main content from a URL"""
-    try:
-        downloaded = trafilatura.fetch_url(url)
-        if downloaded is None:
-            return None
-        text = trafilatura.extract(
-            downloaded,
-            include_comments=False,
-            include_tables=False,
-            no_fallback=False
-        )
-        return text
-    except Exception as e:
-        print(f"Content extraction error for {url}: {e}")
-        return None
-
-
-def generate_snippet_id() -> str:
-    """Generate unique snippet ID"""
-    return f"S_{uuid.uuid4().hex[:8]}"
-
-
-def generate_webpage_id() -> str:
-    """Generate unique webpage ID"""
-    return f"W_{uuid.uuid4().hex[:8]}"
-
-
-def parse_tool_calls(text: str) -> List[Dict]:
-    """
-    Parse <call_tool name="...">query</call_tool> from model output.
-    Returns list of {"name": str, "query": str, "params": dict}
-    """
-    pattern = r'<call_tool\s+name="([^"]+)"([^>]*)>([^<]+)</call_tool>'
-    matches = re.findall(pattern, text)
-
-    tool_calls = []
-    for name, params_str, query in matches:
-        # Parse optional params like limit="8" year="2021-2025"
-        params = {}
-        param_pattern = r'(\w+)="([^"]+)"'
-        for param_name, param_value in re.findall(param_pattern, params_str):
-            params[param_name] = param_value
-
-        tool_calls.append({
-            "name": name.strip(),
-            "query": query.strip(),
-            "params": params
-        })
-
-    return tool_calls
-
-
-def parse_think_blocks(text: str) -> List[str]:
-    """Extract <think>...</think> content"""
-    pattern = r'<think>(.*?)</think>'
-    return re.findall(pattern, text, re.DOTALL)
-
-
-def parse_answer(text: str) -> Optional[str]:
-    """Extract <answer>...</answer> content"""
-    pattern = r'<answer>(.*?)</answer>'
-    match = re.search(pattern, text, re.DOTALL)
-    return match.group(1).strip() if match else None
-
-
-def format_search_results(results: List[Dict], query: str) -> str:
-    """
-    Format search results as DR-TULU tool output.
-    """
-    if not results:
-        return "<tool_output>No results found.</tool_output>"
-
-    snippets = []
-    for r in results:
-        snippet_id = generate_snippet_id()
-        # Escape XML special chars in content
-        title = r.get("title", "").replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-        snippet_text = r.get("snippet", "").replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-        url = r.get("url", "")
-
-        snippets.append(
-            f'<snippet id="{snippet_id}" url="{url}" title="{title}">\n'
-            f'{snippet_text}\n'
-            f'</snippet>'
-        )
-
-    return f"<tool_output>\n" + "\n".join(snippets) + "\n</tool_output>"
-
-
-def format_webpage_content(url: str, title: str, content: str) -> str:
-    """
-    Format extracted webpage as DR-TULU tool output.
-    """
-    if not content:
-        return f"<tool_output>Could not extract content from {url}</tool_output>"
-
-    webpage_id = generate_webpage_id()
-    # Truncate very long content
-    if len(content) > 8000:
-        content = content[:8000] + "\n[Content truncated...]"
-
-    # Escape XML special chars
-    content = content.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-    title = title.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-
-    return (
-        f"<tool_output>\n"
-        f'<webpage id="{webpage_id}" url="{url}" title="{title}">\n'
-        f'{content}\n'
-        f'</webpage>\n'
-        f"</tool_output>"
-    )
-
-
-def execute_tool(
-    tool_name: str,
-    query: str,
-    params: dict,
-    serper_key: str
-) -> Tuple[str, List[Dict]]:
-    """
-    Execute a tool and return (formatted_output, raw_results).
-    """
-    if tool_name == "google_search":
-        num_results = int(params.get("limit", 10))
-        results = search_web(query, serper_key, num_results=num_results)
-        formatted = format_search_results(results, query)
-        return formatted, results
-
-    elif tool_name == "browse_webpage":
-        # query is the URL for browse_webpage
-        url = query
-        content = extract_content(url)
-        title = url  # Could extract from content if needed
-        formatted = format_webpage_content(url, title, content or "")
-        return formatted, [{"url": url, "content": content, "title": title}]
-
-    else:
-        return f"<tool_output>Unknown tool: {tool_name}</tool_output>", []
-
-
-def get_dr_tulu_system_prompt() -> str:
-    """Return the DR-TULU system prompt"""
-    return '''You are a research assistant who answers questions through iterative reasoning and research.
-
-## Process
-- Use <think></think> tags to show your reasoning at any point.
-- Use <call_tool name="...">query</call_tool> when you need information (see tools below).
-- You can alternate between thinking and searching multiple times.
-- Only provide <answer></answer> tags when you have enough information for a complete response.
-- Support every non-trivial claim with retrieved evidence. Wrap the exact claim span in <cite id="ID1,ID2">...</cite>, where id are snippet IDs from searched results.
-
-## Calling Tools (<call_tool name="...">query</call_tool>)
-
-1. google_search
-- Purpose: general web search.
-- Input via: <call_tool name="google_search">your query</call_tool>
-- Output: web search snippets.
-
-2. browse_webpage
-- Purpose: open a specific URL and extract readable page text.
-- Input via: <call_tool name="browse_webpage">https://example.com/article</call_tool>
-- Output: webpage content.
-
-## Tool Output
-- After you issue a tool call, we will execute it and return results wrapped in <tool_output> tags.
-- For web search: <tool_output><snippet id=UNIQUE_ID url="..." title="...">content</snippet>...</tool_output>
-- For web browsing: <tool_output><webpage id=UNIQUE_ID url="..." title="...">content</webpage></tool_output>
-
-## Answer and Citation Format
-- Once you collect all necessary information, generate the final answer with <answer></answer> tags.
-- In your answer, wrap supported text in <cite id="SNIPPET_ID">...</cite> using exact IDs from returned snippets.
-- Write comprehensive, well-structured answers with clear sections when appropriate.
-'''
-
-
-def stream_research(
-    client,
-    model: str,
-    question: str,
-    serper_key: str,
-    max_iterations: int = 5,
-    max_websites: int = 50,
-    system_prompt: str = "",
-    sub_agent_model: Optional[str] = None,
-    parallel_workers: int = 8,
-    max_tool_calls: int = 20,
-    **kwargs
-):
-    """
-    Stream deep research results using DR-TULU.
-
-    The model drives the research loop - it decides when to search,
-    what to search for, and when it has enough information to answer.
-
-    Yields same event types as the original research.py for API compatibility.
-    """
-
-    # Build system prompt
-    dr_tulu_system = get_dr_tulu_system_prompt()
-    if system_prompt:
-        dr_tulu_system += f"\n\n{system_prompt}"
-
-    messages = [
-        {"role": "system", "content": dr_tulu_system},
-        {"role": "user", "content": question}
-    ]
-
-    yield {"type": "status", "message": f"Starting DR-TULU research: {question}"}
-
-    tool_call_count = 0
-    findings = []  # Track sources for compatibility
-    all_queries = []  # Track queries for compatibility
-    iteration = 0
-    max_iterations_without_progress = 3
-    iterations_without_tool_calls = 0
-
-    while tool_call_count < max_tool_calls:
-        iteration += 1
-
-        # Call DR-TULU
-        yield {"type": "status", "message": "Thinking..."}
-
-        try:
-            response = client.chat.completions.create(
-                model=model,
-                messages=messages,
-                max_tokens=4096,
-                temperature=0.7,
-            )
-            assistant_message = response.choices[0].message.content
-        except Exception as e:
-            yield {"type": "error", "content": f"Model error: {str(e)}"}
-            yield {"type": "done"}
-            return
-
-        # Parse thinking blocks and yield as status
-        think_blocks = parse_think_blocks(assistant_message)
-        for thought in think_blocks:
-            # Truncate long thoughts for status display
-            thought_preview = thought[:300].strip()
-            if len(thought) > 300:
-                thought_preview += "..."
-            yield {"type": "status", "message": f"Reasoning: {thought_preview}"}
-
-        # Check for final answer
-        answer = parse_answer(assistant_message)
-        if answer:
-            yield {"type": "status", "message": "Research complete! Generating report..."}
-
-            # Wrap in <result> tags for compatibility with command center
-            result_content = answer
-            if "<result>" not in answer:
-                result_content = f"<result>\n{answer}\n</result>"
-
-            yield {"type": "result_preview", "content": answer, "figures": {}}
-            yield {"type": "result", "content": answer, "figures": {}}
-            yield {"type": "done"}
-            return
-
-        # Parse and execute tool calls
-        tool_calls = parse_tool_calls(assistant_message)
-
-        if not tool_calls:
-            # No tool calls and no answer - model might be stuck
-            iterations_without_tool_calls += 1
-
-            if iterations_without_tool_calls >= max_iterations_without_progress:
-                # Force final answer
-                yield {"type": "status", "message": "No more searches needed, generating final answer..."}
-                messages.append({"role": "assistant", "content": assistant_message})
-                messages.append({"role": "user", "content": "Please provide your final answer now using <answer></answer> tags."})
-                continue
-
-            # Append message and continue to prompt for more
-            messages.append({"role": "assistant", "content": assistant_message})
-            messages.append({"role": "user", "content": "Please continue your research or provide your answer using <answer></answer> tags."})
-            continue
-
-        # Reset counter since we have tool calls
-        iterations_without_tool_calls = 0
-
-        # Track queries for compatibility - build map of query -> global index
-        new_queries = [tc["query"] for tc in tool_calls if tc["name"] == "google_search"]
-        query_start_idx = len(all_queries)  # Starting global index for this batch
-
-        if new_queries:
-            all_queries.extend(new_queries)
-            yield {
-                "type": "queries",
-                "queries": new_queries,
-                "iteration": iteration
-            }
-
-        # Track stats per query for this batch
-        query_stats = {}  # local index -> {relevant, irrelevant, error}
-
-        # Execute tools and collect results
-        tool_outputs = []
-        search_idx = 0  # Track which search query we're on within this batch
-
-        for i, tc in enumerate(tool_calls):
-            tool_call_count += 1
-
-            if tc["name"] == "google_search":
-                # Calculate global query index
-                global_query_idx = query_start_idx + search_idx
-
-                yield {
-                    "type": "status",
-                    "message": f"Searching: {tc['query'][:50]}..."
-                }
-
-                # Initialize stats for this query
-                if global_query_idx not in query_stats:
-                    query_stats[global_query_idx] = {"relevant": 0, "irrelevant": 0, "error": 0}
-            else:
-                global_query_idx = None  # browse_webpage doesn't have a query index
-                yield {
-                    "type": "status",
-                    "message": f"Browsing: {tc['query'][:50]}..."
-                }
-
-            formatted_output, raw_results = execute_tool(
-                tc["name"],
-                tc["query"],
-                tc["params"],
-                serper_key
-            )
-            tool_outputs.append(formatted_output)
-
-            # Yield source events for compatibility
-            if tc["name"] == "google_search":
-                for j, result in enumerate(raw_results):
-                    findings.append({
-                        "source": result.get("url", ""),
-                        "title": result.get("title", ""),
-                        "analysis": result.get("snippet", "")
-                    })
-
-                    # All search results are considered relevant (DR-TULU decides what to use)
-                    query_stats[global_query_idx]["relevant"] += 1
-
-                    yield {
-                        "type": "source",
-                        "query_index": global_query_idx,
-                        "query_text": tc["query"],
-                        "title": result.get("title", ""),
-                        "url": result.get("url", ""),
-                        "analysis": result.get("snippet", ""),
-                        "finding_count": len(findings),
-                        "is_relevant": True,  # DR-TULU decides relevance
-                        "is_error": False,
-                        "error_message": ""
-                    }
-
-                # Emit query_stats after processing all results for this query
-                yield {
-                    "type": "query_stats",
-                    "query_index": global_query_idx,
-                    "relevant_count": query_stats[global_query_idx]["relevant"],
-                    "irrelevant_count": query_stats[global_query_idx]["irrelevant"],
-                    "error_count": query_stats[global_query_idx]["error"]
-                }
-
-                search_idx += 1  # Move to next search query
-
-            elif tc["name"] == "browse_webpage":
-                # browse_webpage results don't belong to a search query
-                # We can associate them with the last search query or skip
-                for result in raw_results:
-                    content = result.get("content", "")
-                    is_error = not content
-                    findings.append({
-                        "source": tc["query"],
-                        "title": result.get("title", tc["query"]),
-                        "analysis": content[:500] if content else "Failed to extract"
-                    })
-
-                    # For browse_webpage, use a pseudo-index or skip query association
-                    # Since it's browsing a specific URL, we'll emit it without query grouping
-                    yield {
-                        "type": "source",
-                        "query_index": -1,  # Special index for browse results
-                        "query_text": f"Browse: {tc['query'][:50]}",
-                        "title": result.get("title", tc["query"]),
-                        "url": tc["query"],
-                        "analysis": content[:500] if content else "Failed to extract content",
-                        "finding_count": len(findings),
-                        "is_relevant": not is_error,
-                        "is_error": is_error,
-                        "error_message": "Content extraction failed" if is_error else ""
-                    }
-
-            if tool_call_count >= max_tool_calls:
-                break
-
-        # Append assistant message and tool results to conversation
-        messages.append({"role": "assistant", "content": assistant_message})
-
-        # Combine all tool outputs into one user message
-        combined_output = "\n\n".join(tool_outputs)
-        messages.append({"role": "user", "content": combined_output})
-
-    # Max tool calls reached - ask for final answer
-    yield {"type": "status", "message": "Maximum searches reached, generating final answer..."}
-
-    messages.append({
-        "role": "user",
-        "content": "You have reached the maximum number of tool calls. Please provide your final answer now using <answer></answer> tags based on the information gathered."
-    })
-
-    try:
-        response = client.chat.completions.create(
-            model=model,
-            messages=messages,
-            max_tokens=4096,
-            temperature=0.7,
-        )
-        final_message = response.choices[0].message.content
-        answer = parse_answer(final_message) or final_message
-
-        yield {"type": "result_preview", "content": answer, "figures": {}}
-        yield {"type": "result", "content": answer, "figures": {}}
-    except Exception as e:
-        yield {"type": "error", "content": f"Failed to generate final answer: {str(e)}"}
-
-    yield {"type": "done"}

backend/utils.py

@@ -1,3 +1,6 @@
+import json
+import logging
+
 import nbformat
 from nbformat.v4 import new_notebook, new_markdown_cell, new_code_cell
 from nbconvert import HTMLExporter
@@ -6,7 +9,8 @@ from e2b_code_interpreter import Sandbox
 from transformers import AutoTokenizer
 from traitlets.config import Config
 from jupyter_handler import JupyterNotebook
-import json
+
+logger = logging.getLogger(__name__)
 
 
 TOOLS = [
@@ -33,7 +37,7 @@ MAX_TURNS = 40
 
 
 def execute_code(sbx, code):
-    execution = sbx.run_code(code, on_stdout=lambda data: print('stdout:', data))
+    execution = sbx.run_code(code, on_stdout=lambda data: logger.debug('stdout: %s', data))
     output = ""
     if len(execution.logs.stdout) > 0:
         output += "\n".join(execution.logs.stdout)

frontend/index.html

@@ -7,7 +7,7 @@
     <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;700&display=swap" rel="stylesheet">
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism.min.css">
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.min.css">
-    <link rel="stylesheet" href="style.css?v=17">
+    <link rel="stylesheet" href="style.css?v=35">
 </head>
 <body>
     <div class="app-container">
@@ -26,6 +26,7 @@
                 </div>
             </div>
             <div class="tab-bar-spacer"></div>
+            <button class="sessions-btn" id="sessionsBtn">SESSIONS</button>
             <button class="files-btn" id="filesBtn">FILES</button>
             <button class="debug-btn" id="debugBtn">DEBUG</button>
             <button class="settings-btn" id="settingsBtn">SETTINGS</button>
@@ -52,74 +53,99 @@
 
                     <div class="notebook-body">
                         <div class="chat-container" id="messages-command">
-                            <div class="welcome-message">
+                            <div class="welcome-message" id="welcomeMessage">
                                 <p>Welcome to Productive — an AI interface with specialized notebooks.</p>
-                                <p>The assistant can automatically open specialized notebooks for different tasks:</p>
-                                <ul>
-                                    <li><strong style="color: var(--theme-accent)">BASE</strong> — Basic tasks with search</li>
-                                    <li><strong style="color: var(--theme-accent)">CODE</strong> — Programming and data analysis</li>
-                                    <li><strong style="color: var(--theme-accent)">RESEARCH</strong> — Deep research and information gathering</li>
-                                    <li><strong style="color: var(--theme-accent)">COMPUTER</strong> <em>(coming soon)</em> — Computer control and automation</li>
-                                    <li><strong style="color: var(--theme-accent)">IMAGE</strong> <em>(coming soon)</em> — Image generation and editing</li>
-                                </ul>
-                                <div class="workflow-diagram">
-                                    <svg class="diagram-svg" viewBox="0 0 500 180" preserveAspectRatio="xMidYMid meet">
-                                        <defs>
-                                            <marker id="arrowhead" markerWidth="8" markerHeight="6" refX="7" refY="3" orient="auto">
-                                                <polygon points="0 0, 8 3, 0 6" fill="var(--theme-accent)" />
-                                            </marker>
-                                        </defs>
-
-                                        <!-- Task Center Box -->
-                                        <rect x="20" y="10" width="180" height="160" rx="4" fill="#fafafa" stroke="#e0e0e0" stroke-width="1"/>
-                                        <text x="110" y="28" text-anchor="middle" font-size="11" font-weight="600" fill="var(--theme-accent)">TASK CENTER</text>
-
-                                        <!-- User Message -->
-                                        <rect x="35" y="40" width="150" height="24" rx="3" fill="white" stroke="var(--theme-accent)" stroke-width="1"/>
-                                        <text x="110" y="56" text-anchor="middle" font-size="9" fill="#333">User input</text>
-
-                                        <!-- Task Widget (combined task + report) -->
-                                        <rect x="35" y="74" width="150" height="86" rx="3" fill="white" stroke="#ccc" stroke-width="1"/>
-                                        <rect x="35" y="74" width="150" height="20" rx="3" fill="var(--theme-accent)"/>
-                                        <text x="110" y="88" text-anchor="middle" font-size="9" font-weight="500" fill="white">TASK</text>
-                                        <text x="110" y="115" text-anchor="middle" font-size="9" fill="#666">processing...</text>
-                                        <line x1="45" y1="130" x2="175" y2="130" stroke="#eee" stroke-width="1"/>
-                                        <text x="110" y="150" text-anchor="middle" font-size="9" fill="#333">Report summary</text>
-
-                                        <!-- Notebook Box -->
-                                        <rect x="300" y="10" width="180" height="160" rx="4" fill="#fafafa" stroke="#e0e0e0" stroke-width="1"/>
-                                        <text x="390" y="28" text-anchor="middle" font-size="11" font-weight="600" fill="var(--theme-accent)">NOTEBOOK</text>
-
-                                        <!-- Query (top of notebook) -->
-                                        <rect x="315" y="40" width="150" height="24" rx="3" fill="white" stroke="var(--theme-accent)" stroke-width="1"/>
-                                        <text x="390" y="56" text-anchor="middle" font-size="9" fill="#333">Query</text>
-
-                                        <!-- Intermediate steps (faded) -->
-                                        <rect x="315" y="72" width="150" height="14" rx="2" fill="#f5f5f5" stroke="#e8e8e8" stroke-width="1"/>
-                                        <text x="390" y="82" text-anchor="middle" font-size="8" fill="#aaa">step 1</text>
-                                        <rect x="315" y="90" width="150" height="14" rx="2" fill="#f8f8f8" stroke="#eee" stroke-width="1"/>
-                                        <text x="390" y="100" text-anchor="middle" font-size="8" fill="#bbb">step 2</text>
-                                        <rect x="315" y="108" width="150" height="14" rx="2" fill="#fbfbfb" stroke="#f0f0f0" stroke-width="1"/>
-                                        <text x="390" y="118" text-anchor="middle" font-size="8" fill="#ccc">...</text>
-
-                                        <!-- Report (bottom of notebook) - aligned with Task report area at y=145 -->
-                                        <rect x="315" y="130" width="150" height="30" rx="3" fill="white" stroke="var(--theme-accent)" stroke-width="1"/>
-                                        <text x="390" y="150" text-anchor="middle" font-size="9" fill="#333">Report</text>
-
-                                        <!-- Arrows (drawn last to be on top) -->
-                                        <!-- Arrow from Task to Query (straight with corners) -->
-                                        <polyline points="185,84 250,84 250,52 307,52" fill="none" stroke="var(--theme-accent)" stroke-width="1.5" marker-end="url(#arrowhead)" stroke-dasharray="4,2"/>
-
-                                        <!-- Arrow from Report back to Task (straight horizontal) -->
-                                        <line x1="315" y1="150" x2="193" y2="150" stroke="var(--theme-accent)" stroke-width="1.5" marker-end="url(#arrowhead)"/>
-                                    </svg>
+
+                                <div class="session-selector" id="sessionSelector">
+                                    <div class="session-selector-form">
+                                        <div class="session-new">
+                                            <label>New session:</label>
+                                            <div class="session-new-input">
+                                                <div class="session-input-wrapper">
+                                                    <input type="text" id="newSessionName" placeholder="Session name..." />
+                                                    <button type="button" class="session-regenerate-btn" id="regenerateNameBtn" title="Generate new name">↻</button>
+                                                </div>
+                                                <button id="createSessionBtn">START</button>
+                                            </div>
+                                        </div>
+
+                                        <div class="session-existing">
+                                            <label>Or continue:</label>
+                                            <select id="existingSessionSelect">
+                                                <option value="">-- Select session --</option>
+                                            </select>
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <div class="welcome-explanation">
+                                    <p>The assistant can automatically open specialized notebooks for different tasks:</p>
+                                    <ul>
+                                        <li><strong style="color: var(--theme-accent)">BASE</strong> — Basic tasks with search</li>
+                                        <li><strong style="color: var(--theme-accent)">CODE</strong> — Programming and data analysis</li>
+                                        <li><strong style="color: var(--theme-accent)">RESEARCH</strong> — Deep research and information gathering</li>
+                                        <li><strong style="color: var(--theme-accent)">COMPUTER</strong> <em>(coming soon)</em> — Computer control and automation</li>
+                                        <li><strong style="color: var(--theme-accent)">IMAGE</strong> <em>(coming soon)</em> — Image generation and editing</li>
+                                    </ul>
+                                    <div class="workflow-diagram">
+                                        <svg class="diagram-svg" viewBox="0 0 500 180" preserveAspectRatio="xMidYMid meet">
+                                            <defs>
+                                                <marker id="arrowhead" markerWidth="8" markerHeight="6" refX="7" refY="3" orient="auto">
+                                                    <polygon points="0 0, 8 3, 0 6" fill="var(--theme-accent)" />
+                                                </marker>
+                                            </defs>
+
+                                            <!-- Task Center Box -->
+                                            <rect x="20" y="10" width="180" height="160" rx="4" fill="#fafafa" stroke="#e0e0e0" stroke-width="1"/>
+                                            <text x="110" y="28" text-anchor="middle" font-size="11" font-weight="600" fill="var(--theme-accent)">TASK CENTER</text>
+
+                                            <!-- User Message -->
+                                            <rect x="35" y="40" width="150" height="24" rx="3" fill="white" stroke="var(--theme-accent)" stroke-width="1"/>
+                                            <text x="110" y="56" text-anchor="middle" font-size="9" fill="#333">User input</text>
+
+                                            <!-- Task Widget (combined task + report) -->
+                                            <rect x="35" y="74" width="150" height="86" rx="3" fill="white" stroke="#ccc" stroke-width="1"/>
+                                            <rect x="35" y="74" width="150" height="20" rx="3" fill="var(--theme-accent)"/>
+                                            <text x="110" y="88" text-anchor="middle" font-size="9" font-weight="500" fill="white">TASK</text>
+                                            <text x="110" y="115" text-anchor="middle" font-size="9" fill="#666">processing...</text>
+                                            <line x1="45" y1="130" x2="175" y2="130" stroke="#eee" stroke-width="1"/>
+                                            <text x="110" y="150" text-anchor="middle" font-size="9" fill="#333">Report summary</text>
+
+                                            <!-- Notebook Box -->
+                                            <rect x="300" y="10" width="180" height="160" rx="4" fill="#fafafa" stroke="#e0e0e0" stroke-width="1"/>
+                                            <text x="390" y="28" text-anchor="middle" font-size="11" font-weight="600" fill="var(--theme-accent)">NOTEBOOK</text>
+
+                                            <!-- Query (top of notebook) -->
+                                            <rect x="315" y="40" width="150" height="24" rx="3" fill="white" stroke="var(--theme-accent)" stroke-width="1"/>
+                                            <text x="390" y="56" text-anchor="middle" font-size="9" fill="#333">Query</text>
+
+                                            <!-- Intermediate steps (faded) -->
+                                            <rect x="315" y="72" width="150" height="14" rx="2" fill="#f5f5f5" stroke="#e8e8e8" stroke-width="1"/>
+                                            <text x="390" y="82" text-anchor="middle" font-size="8" fill="#aaa">step 1</text>
+                                            <rect x="315" y="90" width="150" height="14" rx="2" fill="#f8f8f8" stroke="#eee" stroke-width="1"/>
+                                            <text x="390" y="100" text-anchor="middle" font-size="8" fill="#bbb">step 2</text>
+                                            <rect x="315" y="108" width="150" height="14" rx="2" fill="#fbfbfb" stroke="#f0f0f0" stroke-width="1"/>
+                                            <text x="390" y="118" text-anchor="middle" font-size="8" fill="#ccc">...</text>
+
+                                            <!-- Report (bottom of notebook) - aligned with Task report area at y=145 -->
+                                            <rect x="315" y="130" width="150" height="30" rx="3" fill="white" stroke="var(--theme-accent)" stroke-width="1"/>
+                                            <text x="390" y="150" text-anchor="middle" font-size="9" fill="#333">Report</text>
+
+                                            <!-- Arrows (drawn last to be on top) -->
+                                            <!-- Arrow from Task to Query (straight with corners) -->
+                                            <polyline points="185,84 250,84 250,52 307,52" fill="none" stroke="var(--theme-accent)" stroke-width="1.5" marker-end="url(#arrowhead)" stroke-dasharray="4,2"/>
+
+                                            <!-- Arrow from Report back to Task (straight horizontal) -->
+                                            <line x1="315" y1="150" x2="193" y2="150" stroke="var(--theme-accent)" stroke-width="1.5" marker-end="url(#arrowhead)"/>
+                                        </svg>
+                                    </div>
+                                    <p>When a notebook is opened, you'll see a widget you can click to jump to it. A pulsing dot on the tab indicates active generation.</p>
                                 </div>
-                                <p>When a notebook is opened, you'll see a widget you can click to jump to it. A pulsing dot on the tab indicates active generation.</p>
                             </div>
                         </div>
                     </div>
 
-                    <div class="input-area">
+                    <div class="input-area" id="commandInputArea" style="display: none;">
                         <div class="input-container">
                             <textarea placeholder="Enter message..." id="input-command" rows="1"></textarea>
                             <button id="sendCommand">SEND</button>
@@ -305,6 +331,50 @@
         </div>
     </div>
 
+    <!-- Sessions Panel -->
+    <div class="sessions-panel" id="sessionsPanel">
+        <div class="sessions-panel-header">
+            <h3>SESSIONS</h3>
+            <button class="sessions-panel-close" id="sessionsPanelClose">×</button>
+        </div>
+        <div class="sessions-panel-body">
+            <div class="sessions-current">
+                <label>Current session:</label>
+                <div class="sessions-current-name">
+                    <input type="text" id="currentSessionRename" placeholder="Session name" />
+                    <button id="renameSessionBtn" title="Rename">✓</button>
+                </div>
+            </div>
+
+            <div class="sessions-divider"></div>
+
+            <div class="sessions-new">
+                <label>New session:</label>
+                <div class="sessions-new-input">
+                    <div class="session-input-wrapper">
+                        <input type="text" id="panelNewSessionName" placeholder="Name..." />
+                        <button type="button" class="session-regenerate-btn" id="panelRegenerateNameBtn" title="Generate new name">↻</button>
+                    </div>
+                    <button id="panelCreateSessionBtn">CREATE</button>
+                </div>
+            </div>
+
+            <div class="sessions-divider"></div>
+
+            <div class="sessions-list-section">
+                <label>Switch to:</label>
+                <div class="sessions-list" id="sessionsList">
+                    <div class="sessions-loading">Loading...</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Session Indicator (top left) -->
+    <div class="session-indicator" id="sessionIndicator" style="display: none;">
+        session: <a id="currentSessionName" onclick="openSessionsPanel()"></a>
+    </div>
+
     <!-- Provider Dialog -->
     <div class="settings-dialog-overlay" id="provider-dialog">
         <div class="settings-dialog">
@@ -356,6 +426,11 @@
                     <input type="text" id="model-model-id" class="settings-input" placeholder="e.g., gpt-4o, claude-3-5-sonnet-20241022">
                     <span class="dialog-hint">The exact model identifier used in API calls</span>
                 </div>
+                <div class="dialog-field">
+                    <label class="dialog-label">EXTRA PARAMETERS</label>
+                    <textarea id="model-extra-params" class="settings-textarea" placeholder='{"enable_thinking": false}' rows="3"></textarea>
+                    <span class="dialog-hint">Optional JSON object with extra parameters for API calls (e.g., enable_thinking, temperature)</span>
+                </div>
             </div>
             <div class="settings-dialog-actions">
                 <button class="settings-save-btn" onclick="saveModelFromDialog()">SAVE</button>
@@ -368,7 +443,7 @@
     <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-python.min.js"></script>
     <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
     <script src="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.min.js"></script>
-    <script src="research-ui.js?v=17"></script>
-    <script src="script.js?v=17"></script>
+    <script src="research-ui.js?v=23"></script>
+    <script src="script.js?v=32"></script>
 </body>
 </html>

frontend/research-ui.js

@@ -86,7 +86,7 @@ function createQueriesMessage(chatContainer, queries, iteration) {
         html += `
             <div class="query-tree ${isLast ? 'last' : ''}" id="query-group-${idx}">
                 <div class="query-node">
-                    <span class="query-text">${escapeHtml(query)}</span>
+                    <span class="query-text">${parseMarkdown(query)}</span>
                     <span class="query-stats" id="query-stats-${idx}">${stats.relevant} relevant / ${stats.irrelevant} not relevant / ${stats.error} failed</span>
                 </div>
                 <div class="query-sources-tree" id="query-sources-${idx}"></div>
@@ -162,7 +162,7 @@ function renderFullQueryTree(treeContainer) {
         html += `
             <div class="query-tree ${isLast ? 'last' : ''}" id="query-group-${idx}">
                 <div class="query-node">
-                    <span class="query-text">${escapeHtml(query)}</span>
+                    <span class="query-text">${parseMarkdown(query)}</span>
                     <span class="query-stats" id="query-stats-${idx}">${stats.relevant} relevant / ${stats.irrelevant} not relevant / ${stats.error} failed</span>
                 </div>
                 <div class="query-sources-tree" id="query-sources-${idx}"></div>
@@ -305,7 +305,7 @@ function createAssessmentMessage(chatContainer, sufficient, missingAspects, find
         reasoningText = `Continuing research - ${findingsCount} relevant sources found. Missing: ${missingAspects.join(', ')}`;
     }
 
-    reasoningSection.innerHTML = `<div class="research-reasoning">${escapeHtml(reasoningText)}</div>`;
+    reasoningSection.innerHTML = `<div class="research-reasoning">${parseMarkdown(reasoningText)}</div>`;
 }
 
 function createReportMessage(chatContainer, content, sourcesCount, websitesVisited) {

frontend/script.js

@@ -1,6 +1,20 @@
 // State management
 let tabCounter = 1;
 let activeTabId = 0;
+let currentSession = null;  // Name of the current session
+
+// Fetch random isotope name from backend
+async function generateSessionName() {
+    try {
+        const response = await fetch('/api/sessions/random-name');
+        const data = await response.json();
+        return data.name;
+    } catch (error) {
+        // Fallback to timestamp if API fails
+        return `session-${Date.now()}`;
+    }
+}
+
 let settings = {
     // New provider/model structure
     providers: {},  // providerId -> {name, endpoint, token}
@@ -57,8 +71,19 @@ let saveWorkspaceTimer = null;
 document.addEventListener('DOMContentLoaded', async () => {
     await loadSettings();
     applyTheme(settings.themeColor || 'forest');
-    await loadWorkspace();
     initializeEventListeners();
+    initializeSessionListeners();
+
+    // Check if we have a session selected
+    const sessionsData = await fetchSessions();
+    if (sessionsData.current) {
+        // Session already selected (from backend state)
+        currentSession = sessionsData.current;
+        await onSessionSelected(currentSession);
+    } else {
+        // Show session selector
+        showSessionSelector(sessionsData.sessions);
+    }
 });
 
 function initializeEventListeners() {
@@ -182,6 +207,364 @@ function initializeEventListeners() {
     }
 }
 
+// ============================================
+// Session Management
+// ============================================
+
+async function fetchSessions() {
+    try {
+        const response = await fetch('/api/sessions');
+        if (response.ok) {
+            return await response.json();
+        }
+    } catch (e) {
+        console.error('Failed to fetch sessions:', e);
+    }
+    return { sessions: [], current: null };
+}
+
+function showSessionSelector(sessions) {
+    const selector = document.getElementById('sessionSelector');
+    const welcome = document.getElementById('welcomeMessage');
+    const sessionIndicator = document.getElementById('sessionIndicator');
+    const inputArea = document.getElementById('commandInputArea');
+
+    // Show welcome message and session selector
+    if (welcome) welcome.style.display = 'block';
+    if (selector) selector.style.display = 'block';
+    if (sessionIndicator) sessionIndicator.style.display = 'none';
+    if (inputArea) inputArea.style.display = 'none';
+
+    // Populate existing sessions dropdown
+    const select = document.getElementById('existingSessionSelect');
+    if (select) {
+        select.innerHTML = '<option value="">-- Select session --</option>';
+        sessions.forEach(session => {
+            const option = document.createElement('option');
+            option.value = session.name;
+            option.textContent = `${session.name} (${formatDate(session.modified)})`;
+            select.appendChild(option);
+        });
+    }
+}
+
+function hideSessionSelector() {
+    const selector = document.getElementById('sessionSelector');
+    const welcome = document.getElementById('welcomeMessage');
+    const sessionIndicator = document.getElementById('sessionIndicator');
+    const inputArea = document.getElementById('commandInputArea');
+
+    // Hide session selector, keep welcome visible, show session indicator and input
+    if (selector) selector.style.display = 'none';
+    if (welcome) welcome.style.display = 'block';
+    if (sessionIndicator) sessionIndicator.style.display = 'block';
+    if (inputArea) inputArea.style.display = 'block';
+}
+
+async function onSessionSelected(sessionName) {
+    currentSession = sessionName;
+    hideSessionSelector();
+
+    // Update session name display
+    const nameEl = document.getElementById('currentSessionName');
+    if (nameEl) nameEl.textContent = sessionName;
+
+    const renameInput = document.getElementById('currentSessionRename');
+    if (renameInput) renameInput.value = sessionName;
+
+    // Load workspace for this session
+    await loadWorkspace();
+
+    // Refresh sessions panel list
+    await refreshSessionsList();
+}
+
+async function createSession(name) {
+    try {
+        const response = await fetch('/api/sessions', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name })
+        });
+        if (response.ok) {
+            const data = await response.json();
+            await onSessionSelected(data.name);
+            return true;
+        } else {
+            const error = await response.json();
+            alert(error.detail || 'Failed to create session');
+        }
+    } catch (e) {
+        console.error('Failed to create session:', e);
+        alert('Failed to create session');
+    }
+    return false;
+}
+
+async function selectSession(name) {
+    try {
+        const response = await fetch('/api/sessions/select', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name })
+        });
+        if (response.ok) {
+            // Reload the page to reset all state
+            window.location.reload();
+            return true;
+        } else {
+            const error = await response.json();
+            alert(error.detail || 'Failed to select session');
+        }
+    } catch (e) {
+        console.error('Failed to select session:', e);
+        alert('Failed to select session');
+    }
+    return false;
+}
+
+async function renameSession(oldName, newName) {
+    try {
+        const response = await fetch('/api/sessions/rename', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ oldName, newName })
+        });
+        if (response.ok) {
+            const data = await response.json();
+            currentSession = data.name;
+
+            // Update displays
+            const nameEl = document.getElementById('currentSessionName');
+            if (nameEl) nameEl.textContent = data.name;
+
+            await refreshSessionsList();
+            return true;
+        } else {
+            const error = await response.json();
+            alert(error.detail || 'Failed to rename session');
+        }
+    } catch (e) {
+        console.error('Failed to rename session:', e);
+        alert('Failed to rename session');
+    }
+    return false;
+}
+
+function openSessionsPanel() {
+    const sessionsBtn = document.getElementById('sessionsBtn');
+    if (sessionsBtn) {
+        sessionsBtn.click();
+    }
+}
+
+async function refreshSessionsList() {
+    const sessionsData = await fetchSessions();
+    const listEl = document.getElementById('sessionsList');
+
+    // Update the current session rename input
+    const renameInput = document.getElementById('currentSessionRename');
+    if (renameInput && currentSession) {
+        renameInput.value = currentSession;
+    }
+
+    if (!listEl) return;
+
+    if (sessionsData.sessions.length === 0) {
+        listEl.innerHTML = '<div class="sessions-loading">No other sessions</div>';
+        return;
+    }
+
+    listEl.innerHTML = '';
+    sessionsData.sessions.forEach(session => {
+        const item = document.createElement('div');
+        item.className = 'sessions-list-item' + (session.name === currentSession ? ' current' : '');
+
+        const isCurrent = session.name === currentSession;
+        item.innerHTML = `
+            <span class="sessions-list-item-name">${escapeHtml(session.name)}</span>
+            <span class="sessions-list-item-date">${formatDate(session.modified)}</span>
+            ${!isCurrent ? `<button class="sessions-delete-btn" title="Delete session">×</button>` : ''}
+        `;
+
+        if (!isCurrent) {
+            // Click on name/date to select
+            item.querySelector('.sessions-list-item-name').addEventListener('click', () => selectSession(session.name));
+            item.querySelector('.sessions-list-item-date').addEventListener('click', () => selectSession(session.name));
+
+            // Click on delete button to delete
+            const deleteBtn = item.querySelector('.sessions-delete-btn');
+            if (deleteBtn) {
+                deleteBtn.addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    deleteSession(session.name);
+                });
+            }
+        }
+
+        listEl.appendChild(item);
+    });
+}
+
+async function deleteSession(sessionName) {
+    if (!confirm(`Delete session "${sessionName}"? This cannot be undone.`)) {
+        return;
+    }
+
+    try {
+        const response = await fetch(`/api/sessions/${encodeURIComponent(sessionName)}`, {
+            method: 'DELETE'
+        });
+
+        if (!response.ok) {
+            try {
+                const error = await response.json();
+                alert(error.detail || 'Failed to delete session');
+            } catch {
+                alert('Failed to delete session');
+            }
+            return;
+        }
+
+        // Refresh the sessions list in the panel
+        refreshSessionsList();
+
+        // Also refresh the welcome page dropdown
+        const sessionsData = await fetchSessions();
+        const select = document.getElementById('existingSessionSelect');
+        if (select) {
+            select.innerHTML = '<option value="">-- Select session --</option>';
+            sessionsData.sessions.forEach(session => {
+                const option = document.createElement('option');
+                option.value = session.name;
+                option.textContent = `${session.name} (${formatDate(session.modified)})`;
+                select.appendChild(option);
+            });
+        }
+    } catch (error) {
+        console.error('Error deleting session:', error);
+        alert('Failed to delete session');
+    }
+}
+
+function formatDate(timestamp) {
+    const date = new Date(timestamp * 1000);
+    const now = new Date();
+    const diff = now - date;
+
+    if (diff < 60000) return 'just now';
+    if (diff < 3600000) return Math.floor(diff / 60000) + 'm ago';
+    if (diff < 86400000) return Math.floor(diff / 3600000) + 'h ago';
+    if (diff < 604800000) return Math.floor(diff / 86400000) + 'd ago';
+
+    return date.toLocaleDateString();
+}
+
+function initializeSessionListeners() {
+    // Welcome page session selector
+    const createBtn = document.getElementById('createSessionBtn');
+    const newNameInput = document.getElementById('newSessionName');
+    const existingSelect = document.getElementById('existingSessionSelect');
+
+    // Pre-populate with a cool random name
+    if (newNameInput) {
+        generateSessionName().then(name => newNameInput.value = name);
+    }
+
+    // Regenerate button
+    const regenerateBtn = document.getElementById('regenerateNameBtn');
+    if (regenerateBtn && newNameInput) {
+        regenerateBtn.addEventListener('click', async () => {
+            newNameInput.value = await generateSessionName();
+        });
+    }
+
+    if (createBtn) {
+        createBtn.addEventListener('click', async () => {
+            const name = newNameInput?.value.trim();
+            if (name) {
+                createSession(name);
+            } else {
+                // Auto-generate name
+                createSession(await generateSessionName());
+            }
+        });
+    }
+
+    if (newNameInput) {
+        newNameInput.addEventListener('keydown', (e) => {
+            if (e.key === 'Enter') {
+                createBtn?.click();
+            }
+        });
+    }
+
+    if (existingSelect) {
+        existingSelect.addEventListener('change', () => {
+            const name = existingSelect.value;
+            if (name) {
+                selectSession(name);
+            }
+        });
+    }
+
+    // Sessions panel handlers are set up at the end of the file with other panels
+
+    // Panel rename button
+    const renameBtn = document.getElementById('renameSessionBtn');
+    const renameInput = document.getElementById('currentSessionRename');
+
+    if (renameBtn && renameInput) {
+        renameBtn.addEventListener('click', () => {
+            const newName = renameInput.value.trim();
+            if (newName && newName !== currentSession) {
+                renameSession(currentSession, newName);
+            }
+        });
+    }
+
+    // Panel create new session
+    const panelCreateBtn = document.getElementById('panelCreateSessionBtn');
+    const panelNewNameInput = document.getElementById('panelNewSessionName');
+    const panelRegenerateBtn = document.getElementById('panelRegenerateNameBtn');
+
+    // Pre-populate panel input with cool name too
+    if (panelNewNameInput) {
+        generateSessionName().then(name => panelNewNameInput.value = name);
+    }
+
+    // Panel regenerate button
+    if (panelRegenerateBtn && panelNewNameInput) {
+        panelRegenerateBtn.addEventListener('click', async () => {
+            panelNewNameInput.value = await generateSessionName();
+        });
+    }
+
+    if (panelCreateBtn) {
+        panelCreateBtn.addEventListener('click', async () => {
+            const name = panelNewNameInput?.value.trim();
+            if (name) {
+                // Create and switch to new session
+                try {
+                    const response = await fetch('/api/sessions', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ name })
+                    });
+                    if (response.ok) {
+                        window.location.reload();
+                    } else {
+                        const error = await response.json();
+                        alert(error.detail || 'Failed to create session');
+                    }
+                } catch (e) {
+                    alert('Failed to create session');
+                }
+            }
+        });
+    }
+}
+
 function createNotebookTab(type, initialMessage = null, autoSwitch = true, taskId = null) {
     const tabId = tabCounter++;
 
@@ -380,6 +763,40 @@ function closeTab(tabId) {
     }
 }
 
+function showProgressWidget(chatContainer) {
+    // Remove any existing progress widget
+    hideProgressWidget(chatContainer);
+
+    const widget = document.createElement('div');
+    widget.className = 'progress-widget';
+    widget.innerHTML = `
+        <div class="progress-spinner">
+            <span></span>
+            <span></span>
+            <span></span>
+        </div>
+        <span class="progress-text">Generating...</span>
+    `;
+    chatContainer.appendChild(widget);
+    scrollChatToBottom(chatContainer);
+    return widget;
+}
+
+function hideProgressWidget(chatContainer) {
+    const widget = chatContainer.querySelector('.progress-widget');
+    if (widget) {
+        widget.remove();
+    }
+}
+
+function scrollChatToBottom(chatContainer) {
+    // The actual scrolling container is .notebook-body, not .chat-container
+    const notebookBody = chatContainer.closest('.notebook-body');
+    if (notebookBody) {
+        notebookBody.scrollTop = notebookBody.scrollHeight;
+    }
+}
+
 async function sendMessage(tabId) {
     const content = document.querySelector(`[data-content-id="${tabId}"]`);
     if (!content) return;
@@ -406,6 +823,15 @@ async function sendMessage(tabId) {
     userMsg.innerHTML = `<div class="message-content">${parseMarkdown(message.trim())}</div>`;
     chatContainer.appendChild(userMsg);
 
+    // Scroll the notebook body (the actual scrolling container) to bottom
+    const notebookBody = chatContainer.closest('.notebook-body');
+    if (notebookBody) {
+        notebookBody.scrollTop = notebookBody.scrollHeight;
+    }
+
+    // Show progress widget while waiting for response
+    showProgressWidget(chatContainer);
+
     // Generate a title for the notebook if this is the first message and not command center
     if (isFirstMessage && tabId !== 0) {
         generateNotebookTitle(tabId, message);
@@ -599,11 +1025,13 @@ async function streamChatResponse(messages, chatContainer, notebookType, tabId)
                 endpoint: modelConfig.endpoint,
                 token: modelConfig.token || null,
                 model: modelConfig.model,
+                extra_params: modelConfig.extraParams || null,
                 e2b_key: currentSettings.e2bKey || null,
                 serper_key: currentSettings.serperKey || null,
                 research_sub_agent_model: researchSubAgentConfig?.model || null,
                 research_sub_agent_endpoint: researchSubAgentConfig?.endpoint || null,
                 research_sub_agent_token: researchSubAgentConfig?.token || null,
+                research_sub_agent_extra_params: researchSubAgentConfig?.extraParams || null,
                 research_parallel_workers: currentSettings.researchParallelWorkers || null,
                 research_max_websites: currentSettings.researchMaxWebsites || null,
                 notebook_id: tabId.toString(),  // Send unique tab ID for sandbox sessions
@@ -620,6 +1048,7 @@ async function streamChatResponse(messages, chatContainer, notebookType, tabId)
         let buffer = '';
         let fullResponse = '';
         let currentMessageEl = null;
+        let progressHidden = false;
 
         while (true) {
             const { done, value } = await reader.read();
@@ -633,6 +1062,12 @@ async function streamChatResponse(messages, chatContainer, notebookType, tabId)
                 if (line.startsWith('data: ')) {
                     const data = JSON.parse(line.slice(6));
 
+                    // Hide progress widget on first meaningful response
+                    if (!progressHidden && data.type !== 'generating' && data.type !== 'retry') {
+                        hideProgressWidget(chatContainer);
+                        progressHidden = true;
+                    }
+
                     // Handle different message types from backend
                     if (data.type === 'thinking') {
                         // Assistant thinking - create message if not exists
@@ -640,31 +1075,31 @@ async function streamChatResponse(messages, chatContainer, notebookType, tabId)
                             currentMessageEl = createAssistantMessage(chatContainer);
                         }
                         appendToMessage(currentMessageEl, parseMarkdown(data.content));
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'code') {
                         // Code execution result - update the last code cell
                         updateLastCodeCell(chatContainer, data.output, data.error, data.images);
                         currentMessageEl = null;  // Reset for next thinking
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'code_start') {
                         // Code cell starting execution - show with spinner
                         createCodeCell(chatContainer, data.code, null, false, true);
                         currentMessageEl = null;
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'upload') {
                         // File upload notification
                         createUploadMessage(chatContainer, data.paths, data.output);
                         currentMessageEl = null;
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'download') {
                         // File download notification
                         createDownloadMessage(chatContainer, data.paths, data.output);
                         currentMessageEl = null;
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'generating') {
                         // Still generating - no action needed
@@ -720,27 +1155,27 @@ async function streamChatResponse(messages, chatContainer, notebookType, tabId)
                             <div class="report-content">${html}</div>
                         `;
                         chatContainer.appendChild(resultDiv);
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'status') {
                         // Research status update
                         createStatusMessage(chatContainer, data.message, data.iteration, data.total_iterations);
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'queries') {
                         // Research queries generated
                         createQueriesMessage(chatContainer, data.queries, data.iteration);
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'progress') {
                         // Research progress
                         updateProgress(chatContainer, data.message, data.websites_visited, data.max_websites);
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'source') {
                         // Research source found - now includes query grouping
                         createSourceMessage(chatContainer, data);
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'query_stats') {
                         // Update query statistics
@@ -753,12 +1188,12 @@ async function streamChatResponse(messages, chatContainer, notebookType, tabId)
                     } else if (data.type === 'assessment') {
                         // Research completeness assessment
                         createAssessmentMessage(chatContainer, data.sufficient, data.missing_aspects, data.findings_count, data.reasoning);
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'report') {
                         // Final research report
                         createReportMessage(chatContainer, data.content, data.sources_count, data.websites_visited);
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'content') {
                         // Regular streaming content (non-code notebooks)
@@ -767,7 +1202,7 @@ async function streamChatResponse(messages, chatContainer, notebookType, tabId)
                         }
                         fullResponse += data.content;
                         appendToMessage(currentMessageEl, parseMarkdown(fullResponse));
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'launch') {
                         // Tool-based notebook launch from command center
@@ -829,7 +1264,7 @@ async function streamChatResponse(messages, chatContainer, notebookType, tabId)
                         infoDiv.innerHTML = `<em>${escapeHtml(data.content)}</em>`;
                         infoDiv.style.color = 'var(--theme-accent)';
                         chatContainer.appendChild(infoDiv);
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
 
                     } else if (data.type === 'retry') {
                         // Show retry indicator
@@ -842,12 +1277,13 @@ async function streamChatResponse(messages, chatContainer, notebookType, tabId)
                         errorDiv.className = 'message assistant';
                         errorDiv.innerHTML = `<div class="message-content" style="color: #c62828;">Error: ${escapeHtml(data.content)}</div>`;
                         chatContainer.appendChild(errorDiv);
-                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        scrollChatToBottom(chatContainer);
                     }
                 }
             }
         }
     } catch (error) {
+        hideProgressWidget(chatContainer);
         const errorDiv = document.createElement('div');
         errorDiv.className = 'message assistant';
         errorDiv.innerHTML = `<div class="message-content" style="color: #c62828;">Connection error: ${escapeHtml(error.message)}</div>`;
@@ -1023,7 +1459,7 @@ function showActionWidget(chatContainer, action, message, targetTabId, taskId =
         </div>
         <div class="action-widget-body">
             <div class="section-label">QUERY</div>
-            <div class="section-content">${escapeHtml(message)}</div>
+            <div class="section-content">${parseMarkdown(message)}</div>
         </div>
     `;
 
@@ -1037,7 +1473,7 @@ function showActionWidget(chatContainer, action, message, targetTabId, taskId =
     clickableArea.addEventListener('click', clickHandler);
 
     chatContainer.appendChild(widget);
-    chatContainer.scrollTop = chatContainer.scrollHeight;
+    scrollChatToBottom(chatContainer);
 
     // Store widget for later updates
     actionWidgets[targetTabId] = widget;
@@ -1209,7 +1645,7 @@ function showRetryIndicator(chatContainer, data) {
         </div>
     `;
     chatContainer.appendChild(retryDiv);
-    chatContainer.scrollTop = chatContainer.scrollHeight;
+    scrollChatToBottom(chatContainer);
 
     // Start countdown
     let remaining = data.delay;
@@ -1524,7 +1960,7 @@ function renderActionWidget(data) {
 
     let bodyHtml = `
         <div class="section-label">QUERY</div>
-        <div class="section-content">${escapeHtml(data.query || '')}</div>
+        <div class="section-content">${parseMarkdown(data.query || '')}</div>
     `;
 
     // Add result section if present
@@ -2170,17 +2606,19 @@ function deleteProvider(providerId) {
 // Show add/edit model dialog
 function showModelDialog(modelId = null) {
     const isEdit = !!modelId;
-    const model = isEdit ? settings.models[modelId] : { name: '', providerId: '', modelId: '' };
+    const model = isEdit ? settings.models[modelId] : { name: '', providerId: '', modelId: '', extraParams: null };
 
     const dialog = document.getElementById('model-dialog');
     const title = document.getElementById('model-dialog-title');
     const nameInput = document.getElementById('model-name');
     const providerSelect = document.getElementById('model-provider');
     const modelIdInput = document.getElementById('model-model-id');
+    const extraParamsInput = document.getElementById('model-extra-params');
 
     title.textContent = isEdit ? 'Edit Model' : 'Add Model';
     nameInput.value = model.name;
     modelIdInput.value = model.modelId;
+    extraParamsInput.value = model.extraParams ? JSON.stringify(model.extraParams, null, 2) : '';
 
     // Populate provider dropdown
     providerSelect.innerHTML = '<option value="">-- Select Provider --</option>';
@@ -2209,13 +2647,25 @@ function saveModelFromDialog() {
     const name = document.getElementById('model-name').value.trim();
     const providerId = document.getElementById('model-provider').value;
     const apiModelId = document.getElementById('model-model-id').value.trim();
+    const extraParamsStr = document.getElementById('model-extra-params').value.trim();
 
     if (!name || !providerId || !apiModelId) {
-        alert('All fields are required');
+        alert('Name, provider, and model ID are required');
         return;
     }
 
-    settings.models[modelId] = { name, providerId, modelId: apiModelId };
+    // Parse extra params if provided
+    let extraParams = null;
+    if (extraParamsStr) {
+        try {
+            extraParams = JSON.parse(extraParamsStr);
+        } catch (e) {
+            alert('Invalid JSON in extra parameters: ' + e.message);
+            return;
+        }
+    }
+
+    settings.models[modelId] = { name, providerId, modelId: apiModelId, extraParams };
     hideModelDialog();
     renderModelsList();
     populateModelDropdowns();
@@ -2439,7 +2889,7 @@ function getSettings() {
 }
 
 // Resolve model configuration for a notebook type
-// Returns { endpoint, token, model } or null if not configured
+// Returns { endpoint, token, model, extraParams } or null if not configured
 function resolveModelConfig(notebookType) {
     const modelId = settings.notebooks?.[notebookType];
     if (!modelId) return null;
@@ -2453,7 +2903,8 @@ function resolveModelConfig(notebookType) {
     return {
         endpoint: provider.endpoint,
         token: provider.token,
-        model: model.modelId
+        model: model.modelId,
+        extraParams: model.extraParams || null
     };
 }
 
@@ -2470,7 +2921,8 @@ function getDefaultModelConfig() {
     return {
         endpoint: provider.endpoint,
         token: provider.token,
-        model: model.modelId
+        model: model.modelId,
+        extraParams: model.extraParams || null
     };
 }
 
@@ -2647,6 +3099,11 @@ if (debugBtn) {
         if (filesPanel) filesPanel.classList.remove('active');
         if (filesBtn) filesBtn.classList.remove('active');
         appContainer.classList.remove('files-panel-open');
+        const sessionsPanel = document.getElementById('sessionsPanel');
+        const sessionsBtn = document.getElementById('sessionsBtn');
+        if (sessionsPanel) sessionsPanel.classList.remove('active');
+        if (sessionsBtn) sessionsBtn.classList.remove('active');
+        appContainer.classList.remove('sessions-panel-open');
 
         // Toggle debug panel
         debugPanel.classList.toggle('active');
@@ -2743,6 +3200,11 @@ if (settingsBtn) {
         if (filesPanel) filesPanel.classList.remove('active');
         if (filesBtn) filesBtn.classList.remove('active');
         appContainer.classList.remove('files-panel-open');
+        const sessionsPanel = document.getElementById('sessionsPanel');
+        const sessionsBtn = document.getElementById('sessionsBtn');
+        if (sessionsPanel) sessionsPanel.classList.remove('active');
+        if (sessionsBtn) sessionsBtn.classList.remove('active');
+        appContainer.classList.remove('sessions-panel-open');
 
         openSettings(); // Populate form fields with current values
         settingsPanel.classList.add('active');
@@ -2934,6 +3396,11 @@ if (filesBtn) {
         debugPanel.classList.remove('active');
         debugBtn.classList.remove('active');
         appContainer.classList.remove('panel-open');
+        const sessionsPanel = document.getElementById('sessionsPanel');
+        const sessionsBtn = document.getElementById('sessionsBtn');
+        if (sessionsPanel) sessionsPanel.classList.remove('active');
+        if (sessionsBtn) sessionsBtn.classList.remove('active');
+        appContainer.classList.remove('sessions-panel-open');
 
         // Toggle files panel
         filesPanel.classList.toggle('active');
@@ -2972,3 +3439,44 @@ if (showHiddenFiles) {
     });
 }
 
+// Sessions panel (same pattern as Files/Settings/Debug panels)
+const sessionsPanel = document.getElementById('sessionsPanel');
+const sessionsPanelClose = document.getElementById('sessionsPanelClose');
+const sessionsBtn = document.getElementById('sessionsBtn');
+
+if (sessionsBtn && sessionsPanel) {
+    sessionsBtn.addEventListener('click', () => {
+        const isOpening = !sessionsPanel.classList.contains('active');
+
+        // Close other panels first
+        settingsPanel.classList.remove('active');
+        settingsBtn.classList.remove('active');
+        debugPanel.classList.remove('active');
+        debugBtn.classList.remove('active');
+        filesPanel.classList.remove('active');
+        if (filesBtn) filesBtn.classList.remove('active');
+        appContainer.classList.remove('panel-open');
+        appContainer.classList.remove('files-panel-open');
+
+        // Toggle sessions panel
+        sessionsPanel.classList.toggle('active');
+        sessionsBtn.classList.toggle('active');
+
+        // Shift content when opening, unshift when closing
+        if (isOpening) {
+            appContainer.classList.add('sessions-panel-open');
+            refreshSessionsList();
+        } else {
+            appContainer.classList.remove('sessions-panel-open');
+        }
+    });
+}
+
+if (sessionsPanelClose) {
+    sessionsPanelClose.addEventListener('click', () => {
+        sessionsPanel.classList.remove('active');
+        sessionsBtn.classList.remove('active');
+        appContainer.classList.remove('sessions-panel-open');
+    });
+}
+

frontend/style.css

@@ -34,10 +34,9 @@ body {
     background: #f5f5f5;
     padding: 0;
     gap: 0;
-    overflow-x: auto;
-    overflow-y: visible;
+    overflow: hidden;
     border-bottom: 1px solid #ccc;
-    min-height: fit-content;
+    height: 29px;
     position: relative;
     z-index: 10;
 }
@@ -54,8 +53,8 @@ body {
 .tab {
     display: flex;
     align-items: center;
-    gap: 8px;
-    padding: 8px 16px;
+    gap: 6px;
+    padding: 4px 10px;
     background: #f5f5f5;
     color: #666;
     cursor: pointer;
@@ -63,7 +62,7 @@ body {
     white-space: nowrap;
     transition: all 0.2s;
     border-right: 1px solid #ccc;
-    font-size: 12px;
+    font-size: 11px;
     font-weight: 500;
     letter-spacing: 1px;
     position: relative;
@@ -136,13 +135,14 @@ body {
 
 .settings-btn,
 .files-btn,
-.debug-btn {
+.debug-btn,
+.sessions-btn {
     background: #f5f5f5;
     color: #666;
     border: none;
     border-left: 1px solid #ccc;
-    padding: 8px 16px;
-    font-size: 12px;
+    padding: 4px 10px;
+    font-size: 11px;
     font-weight: 500;
     letter-spacing: 1px;
     cursor: pointer;
@@ -152,14 +152,16 @@ body {
 
 .settings-btn:hover,
 .files-btn:hover,
-.debug-btn:hover {
+.debug-btn:hover,
+.sessions-btn:hover {
     background: #eee;
     color: #1a1a1a;
 }
 
 .settings-btn.active,
 .files-btn.active,
-.debug-btn.active {
+.debug-btn.active,
+.sessions-btn.active {
     background: var(--theme-accent);
     color: white;
 }
@@ -339,14 +341,14 @@ body {
 .welcome-message {
     color: #999;
     font-size: 13px;
-    line-height: 1.8;
+    line-height: 1.6;
     max-width: 700px;
     margin: 0 auto;
-    padding: 40px 20px;
+    padding: 20px 20px;
 }
 
 .welcome-message p {
-    margin-bottom: 16px;
+    margin-bottom: 10px;
 }
 
 .welcome-message ul {
@@ -728,8 +730,52 @@ body {
     transform: translate(-50%, -50%) rotate(240deg) translateY(-4.5px);
 }
 
+/* Progress widget - shown while waiting for model response */
+.progress-widget {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 20px;
+    font-size: 12px;
+    color: #888;
+}
+
+.progress-widget .progress-spinner {
+    width: 14px;
+    height: 14px;
+    position: relative;
+    animation: orbit-rotate 1.2s linear infinite;
+}
+
+.progress-widget .progress-spinner span {
+    position: absolute;
+    width: 3px;
+    height: 3px;
+    border-radius: 50%;
+    background: var(--theme-accent);
+    top: 50%;
+    left: 50%;
+}
+
+.progress-widget .progress-spinner span:nth-child(1) {
+    transform: translate(-50%, -50%) translateY(-5px);
+}
+
+.progress-widget .progress-spinner span:nth-child(2) {
+    transform: translate(-50%, -50%) rotate(120deg) translateY(-5px);
+}
+
+.progress-widget .progress-spinner span:nth-child(3) {
+    transform: translate(-50%, -50%) rotate(240deg) translateY(-5px);
+}
+
+.progress-widget .progress-text {
+    font-family: 'JetBrains Mono', monospace;
+    letter-spacing: 0.5px;
+}
+
 .input-area {
-    padding: 15px 20px;
+    padding: 10px 20px;
     background: white;
     border-top: 1px solid #ccc;
 }
@@ -744,9 +790,9 @@ body {
 
 .input-container textarea {
     flex: 1;
-    padding: 12px 15px;
+    padding: 10px 12px;
     border: 1px solid #ccc;
-    min-height: 44px;
+    min-height: 38px;
     max-height: 200px;
     resize: none;
     overflow-y: auto;
@@ -769,7 +815,7 @@ body {
 }
 
 .input-container button {
-    padding: 12px 24px;
+    padding: 10px 20px;
     background: #f5f5f5;
     border: 1px solid #ccc;
     color: #1a1a1a;
@@ -884,6 +930,32 @@ body {
     color: #999;
 }
 
+.settings-textarea {
+    width: 100%;
+    padding: 12px 15px;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 12px;
+    background: #f9f9f9;
+    color: #1a1a1a;
+    outline: none;
+    transition: border-color 0.2s ease;
+    resize: vertical;
+    min-height: 60px;
+    box-sizing: border-box;
+}
+
+.settings-textarea:focus {
+    border-color: var(--theme-accent);
+    box-shadow: 0 0 0 1px var(--theme-accent);
+    background: white;
+}
+
+.settings-textarea::placeholder {
+    color: #999;
+}
+
 /* Theme Color Picker */
 .theme-color-picker {
     display: grid;
@@ -1972,10 +2044,10 @@ body {
 /* Debug Panel */
 .debug-panel {
     position: fixed;
-    top: 37px;
+    top: 29px;
     right: -600px;
     width: 600px;
-    height: calc(100vh - 37px);
+    height: calc(100vh - 28px);
     background: white;
     border-left: 2px solid var(--theme-accent);
     z-index: 1000;
@@ -2122,10 +2194,10 @@ body {
 /* Settings Panel (side panel like debug) */
 .settings-panel {
     position: fixed;
-    top: 37px;
+    top: 29px;
     right: -600px;
     width: 600px;
-    height: calc(100vh - 37px);
+    height: calc(100vh - 28px);
     background: white;
     border-left: 2px solid var(--theme-accent);
     z-index: 1000;
@@ -2297,21 +2369,30 @@ body {
 /* Settings Select (dropdowns) */
 .settings-select {
     width: 100%;
-    padding: 10px 12px;
-    border: 1px solid #ccc;
+    padding: 10px 32px 10px 12px;
+    border: 1px solid #ddd;
     border-radius: 4px;
     font-family: inherit;
     font-size: 12px;
-    background: #f5f5f5;
+    background: white;
     color: #1a1a1a;
     outline: none;
     cursor: pointer;
     transition: border-color 0.2s ease;
+    -webkit-appearance: none;
+    -moz-appearance: none;
+    appearance: none;
+    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%23999' d='M6 8L2 4h8z'/%3E%3C/svg%3E");
+    background-repeat: no-repeat;
+    background-position: right 10px center;
+}
+
+.settings-select:hover {
+    border-color: #bbb;
 }
 
 .settings-select:focus {
     border-color: var(--theme-accent);
-    background: white;
 }
 
 /* Notebook models grid */
@@ -2437,10 +2518,10 @@ body {
 /* Files Panel (right side panel, like settings/debug) */
 .files-panel {
     position: fixed;
-    top: 37px;
+    top: 29px;
     right: -320px;
     width: 320px;
-    height: calc(100vh - 37px);
+    height: calc(100vh - 28px);
     background: white;
     border-left: 2px solid var(--theme-accent);
     z-index: 1000;
@@ -2726,3 +2807,354 @@ body {
     color: #f57c00;
     font-weight: 500;
 }
+
+/* Session Selector (inside welcome message) */
+.session-selector {
+    margin-top: 16px;
+    padding-top: 16px;
+    border-top: 1px solid #e0e0e0;
+}
+
+/* Welcome explanation section (below session selector) */
+.welcome-explanation {
+    margin-top: 20px;
+    padding-top: 16px;
+    border-top: 1px solid #e0e0e0;
+    color: #666;
+}
+
+.session-indicator {
+    position: fixed;
+    bottom: 6px;
+    right: 12px;
+    font-size: 13px;
+    color: #999;
+    z-index: 100;
+}
+
+.session-indicator a {
+    color: var(--theme-accent);
+    text-decoration: none;
+    cursor: pointer;
+}
+
+.session-indicator a:hover {
+    text-decoration: underline;
+}
+
+.session-selector-form {
+    display: flex;
+    gap: 20px;
+    align-items: flex-end;
+}
+
+.session-new {
+    flex: 1;
+}
+
+.session-existing {
+    flex: 1;
+}
+
+.session-new label,
+.session-existing label {
+    display: block;
+    font-size: 10px;
+    font-weight: 600;
+    color: #666;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: 6px;
+}
+
+.session-new-input {
+    display: flex;
+    gap: 6px;
+}
+
+.session-input-wrapper {
+    flex: 1;
+    position: relative;
+    display: flex;
+}
+
+.session-input-wrapper input {
+    flex: 1;
+    padding: 7px 28px 7px 10px;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+    font-size: 12px;
+    font-family: inherit;
+    height: 32px;
+    box-sizing: border-box;
+}
+
+.session-input-wrapper input:focus {
+    outline: none;
+    border-color: var(--theme-accent);
+}
+
+.session-regenerate-btn {
+    position: absolute;
+    right: 6px;
+    top: 50%;
+    transform: translateY(-50%);
+    background: transparent;
+    border: none;
+    color: #bbb;
+    font-size: 13px;
+    cursor: pointer;
+    padding: 0;
+    line-height: 1;
+    transition: color 0.2s;
+}
+
+.session-regenerate-btn:hover {
+    color: var(--theme-accent);
+}
+
+.session-new-input button:not(.session-regenerate-btn) {
+    padding: 7px 14px;
+    background: #f5f5f5;
+    color: #1a1a1a;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+    font-size: 11px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.2s;
+    letter-spacing: 0.5px;
+}
+
+.session-new-input button:not(.session-regenerate-btn):hover {
+    background: var(--theme-accent);
+    color: #ffffff;
+    border-color: var(--theme-accent);
+}
+
+.session-existing select {
+    width: 100%;
+    padding: 7px 32px 7px 10px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 12px;
+    font-family: inherit;
+    background: white;
+    color: #1a1a1a;
+    cursor: pointer;
+    height: 32px;
+    box-sizing: border-box;
+    -webkit-appearance: none;
+    -moz-appearance: none;
+    appearance: none;
+    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%23999' d='M6 8L2 4h8z'/%3E%3C/svg%3E");
+    background-repeat: no-repeat;
+    background-position: right 10px center;
+    transition: border-color 0.2s ease;
+}
+
+.session-existing select:hover {
+    border-color: #bbb;
+}
+
+.session-existing select:focus {
+    outline: none;
+    border-color: var(--theme-accent);
+}
+
+/* Sessions Panel (right side) */
+.sessions-panel {
+    position: fixed;
+    top: 29px;
+    right: -320px;
+    width: 320px;
+    height: calc(100vh - 28px);
+    background: white;
+    border-left: 2px solid var(--theme-accent);
+    z-index: 1000;
+    display: flex;
+    flex-direction: column;
+    transition: right 0.3s ease;
+}
+
+.sessions-panel.active {
+    right: 0;
+}
+
+.sessions-panel-open .content-area {
+    margin-right: 320px;
+}
+
+.sessions-panel-header {
+    padding: 8px 12px;
+    border-bottom: 1px solid #e0e0e0;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: var(--theme-accent);
+}
+
+.sessions-panel-header h3 {
+    margin: 0;
+    font-size: 12px;
+    font-weight: 600;
+    color: white;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.sessions-panel-close {
+    background: none;
+    border: none;
+    font-size: 20px;
+    color: white;
+    cursor: pointer;
+    padding: 0;
+    width: 24px;
+    height: 24px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 4px;
+    transition: background 0.2s;
+}
+
+.sessions-panel-close:hover {
+    background: rgba(255, 255, 255, 0.2);
+}
+
+.sessions-panel-body {
+    flex: 1;
+    padding: 16px;
+    overflow-y: auto;
+}
+
+.sessions-panel-body label {
+    display: block;
+    font-size: 10px;
+    font-weight: 600;
+    color: #666;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: 8px;
+}
+
+.sessions-current-name,
+.sessions-new-input {
+    display: flex;
+    gap: 8px;
+}
+
+.sessions-current-name input,
+.sessions-new-input input {
+    flex: 1;
+    padding: 8px 28px 8px 10px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 13px;
+    font-family: inherit;
+}
+
+.sessions-new-input .session-input-wrapper {
+    width: 180px;
+    position: relative;
+    display: flex;
+}
+
+.sessions-new-input .session-input-wrapper input {
+    width: 100%;
+    flex: none;
+}
+
+.sessions-current-name input:focus,
+.sessions-new-input input:focus {
+    outline: none;
+    border-color: var(--theme-accent);
+}
+
+.sessions-current-name button,
+.sessions-new-input button:not(.session-regenerate-btn) {
+    padding: 8px 12px;
+    background: var(--theme-accent);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    font-size: 11px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: opacity 0.2s;
+    flex-shrink: 0;
+}
+
+.sessions-current-name button:hover,
+.sessions-new-input button:not(.session-regenerate-btn):hover {
+    opacity: 0.9;
+}
+
+.sessions-divider {
+    height: 1px;
+    background: #e0e0e0;
+    margin: 16px 0;
+}
+
+.sessions-list {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+}
+
+.sessions-list-item {
+    padding: 10px 12px;
+    background: #f5f5f5;
+    border-radius: 4px;
+    cursor: pointer;
+    transition: background 0.2s;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.sessions-list-item:hover {
+    background: #e8e8e8;
+}
+
+.sessions-list-item.current {
+    background: var(--theme-accent-bg);
+    border: 1px solid var(--theme-accent);
+}
+
+.sessions-list-item-name {
+    font-size: 13px;
+    font-weight: 500;
+    color: #333;
+}
+
+.sessions-list-item-date {
+    font-size: 10px;
+    color: #999;
+    flex: 1;
+    text-align: right;
+    margin-right: 8px;
+}
+
+.sessions-delete-btn {
+    background: none;
+    border: none;
+    color: #999;
+    font-size: 16px;
+    cursor: pointer;
+    padding: 0 4px;
+    line-height: 1;
+    transition: color 0.2s;
+}
+
+.sessions-delete-btn:hover {
+    color: #e53935;
+}
+
+.sessions-loading {
+    text-align: center;
+    color: #666;
+    padding: 20px;
+}
+