Initial deployment

.dockerignore

@@ -0,0 +1,57 @@
+# Environment files - DO NOT include in Docker image
+.env
+.env.local
+.env.*.local
+backend/.env
+frontend/.env.local
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+.eggs/
+*.egg
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+venv/
+.venv/
+ENV/
+
+# Node.js
+node_modules/
+frontend/node_modules/
+frontend/dist/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Git
+.git/
+.gitignore
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Notes (generated at runtime)
+backend/src/notes/
+
+# Documentation
+*.md
+!README.md
+
+# Tests
+tests/
+*_test.py
+test_*.py

.gitignore

@@ -0,0 +1,70 @@
+# Environment files - NEVER commit these
+.env
+.env.local
+.env.*.local
+backend/.env
+frontend/.env.local
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+.eggs/
+*.egg
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+venv/
+.venv/
+ENV/
+env/
+
+# Node.js
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.npm
+
+# Build outputs
+frontend/dist/
+build/
+dist/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+*.sublime-*
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Notes (generated at runtime)
+backend/src/notes/*.md
+
+# Logs
+*.log
+logs/
+
+# Coverage
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# Temporary files
+*.tmp
+*.temp
+.cache/

Dockerfile

@@ -0,0 +1,60 @@
+# ============================================
+# Stage 1: Build Frontend
+# ============================================
+FROM node:20-alpine AS frontend-builder
+
+WORKDIR /app/frontend
+
+# Copy package files
+COPY frontend/package*.json ./
+
+# Install dependencies
+RUN npm ci
+
+# Copy frontend source
+COPY frontend/ ./
+
+# Set API base URL to same origin (relative path)
+ENV VITE_API_BASE_URL=""
+
+# Build frontend
+RUN npm run build
+
+# ============================================
+# Stage 2: Python Backend + Serve Frontend
+# ============================================
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy backend requirements and install Python dependencies
+COPY backend/pyproject.toml ./
+RUN pip install --no-cache-dir .
+
+# Copy backend source code
+COPY backend/src/ ./src/
+
+# Copy built frontend to serve as static files
+COPY --from=frontend-builder /app/frontend/dist ./static
+
+# Create notes directory
+RUN mkdir -p ./src/notes
+
+# Set working directory to src for imports
+WORKDIR /app/src
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Environment variables (will be overridden by HF Secrets)
+ENV HOST=0.0.0.0
+ENV PORT=7860
+ENV CORS_ORIGINS="*"
+
+# Start the application
+CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,64 @@
 ---
 title: Deep Research Agent
-emoji: 🐠
-colorFrom: green
-colorTo: green
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
 sdk: docker
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Deep Research Agent
+
+A fully automated web research and summarization assistant powered by LangGraph.
+
+## Features
+
+- 🔍 Intelligent web search using DuckDuckGo, Tavily, or Perplexity
+- 📝 Automated research planning and execution
+- 📊 Structured research reports with sources
+- 🔄 Real-time streaming progress updates
+
+## Configuration
+
+This Space requires the following secrets to be configured in the Settings:
+
+### Required Secrets
+
+| Secret Name | Description |
+|-------------|-------------|
+| `LLM_PROVIDER` | LLM provider: `custom`, `ollama`, or `lmstudio` |
+| `LLM_MODEL_ID` | Model name (e.g., `chatgpt-4o-latest`, `gpt-4-turbo`) |
+| `LLM_API_KEY` | Your OpenAI API key |
+| `LLM_BASE_URL` | API base URL (e.g., `https://api.openai.com/v1`) |
+
+### Optional Secrets
+
+| Secret Name | Description | Default |
+|-------------|-------------|---------|
+| `SEARCH_API` | Search backend: `duckduckgo`, `tavily`, `perplexity`, `searxng` | `duckduckgo` |
+| `TAVILY_API_KEY` | Tavily API key (if using Tavily search) | - |
+| `PERPLEXITY_API_KEY` | Perplexity API key (if using Perplexity search) | - |
+| `MAX_WEB_RESEARCH_LOOPS` | Maximum research iterations | `3` |
+| `FETCH_FULL_PAGE` | Fetch full page content | `True` |
+| `LLM_TIMEOUT` | API timeout in seconds | `60` |
+
+## Usage
+
+1. Enter your research topic in the input field
+2. Click "Start Research" to begin
+3. Watch the real-time progress as the agent:
+   - Plans research tasks
+   - Searches the web
+   - Summarizes findings
+   - Generates a comprehensive report
+
+## Tech Stack
+
+- **Backend**: FastAPI + LangGraph + LangChain
+- **Frontend**: Vue.js 3 + Vite
+- **Search**: DuckDuckGo (default) / Tavily / Perplexity
+
+## License
+
+MIT License

backend/pyproject.toml

@@ -0,0 +1,65 @@
+[project]
+name = "langgraph-deep-researcher"
+version = "0.1.0"
+description = "Fully local web research and summarization assistant powered by LangGraph."
+authors = [
+    { name = "Lance Martin" }
+]
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi>=0.115.0",
+    "langgraph>=0.2.0",
+    "langchain>=0.3.0",
+    "langchain-openai>=0.2.0",
+    "langchain-community>=0.3.0",
+    "tavily-python>=0.5.0",
+    "python-dotenv==1.0.1",
+    "requests>=2.31.0",
+    "openai>=1.12.0",
+    "uvicorn[standard]>=0.32.0",
+    "ddgs>=9.6.1",
+    "loguru>=0.7.3",
+]
+
+[project.optional-dependencies]
+dev = ["mypy>=1.11.1", "ruff>=0.6.1"]
+
+[build-system]
+requires = ["setuptools>=73.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["py.typed"]
+
+[tool.ruff]
+lint.select = [
+    "E",    # pycodestyle
+    "F",    # pyflakes
+    "I",    # isort
+    "D",    # pydocstyle
+    "D401", # First line should be in imperative mood
+    "T201",
+    "UP",
+]
+lint.ignore = [
+    "UP006",
+    "UP007",
+    "UP035",
+    "D417",
+    "E501",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["D", "UP"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.12.7",
+]

backend/src/__init__.py

@@ -0,0 +1,18 @@
+"""LangGraph Deep Research - A deep research assistant powered by LangGraph."""
+
+__version__ = "0.1.0"
+
+from .agent import DeepResearchAgent
+from .config import Configuration, SearchAPI
+from .models import SummaryState, SummaryStateInput, SummaryStateOutput, TodoItem
+
+__all__ = [
+    "DeepResearchAgent",
+    "Configuration",
+    "SearchAPI",
+    "SummaryState",
+    "SummaryStateInput",
+    "SummaryStateOutput",
+    "TodoItem",
+]
+

backend/src/agent.py

@@ -0,0 +1,919 @@
+"""Orchestrator coordinating the deep research workflow using LangGraph."""
+
+from __future__ import annotations
+
+import logging
+import re
+import operator
+from pathlib import Path
+from queue import Empty, Queue
+from threading import Lock, Thread
+from typing import Any, Annotated, Iterator, TypedDict, Optional, Callable
+
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
+from langchain_core.tools import tool
+from langgraph.graph import StateGraph, END
+
+from config import Configuration
+from prompts import (
+    report_writer_instructions,
+    task_summarizer_instructions,
+    todo_planner_system_prompt,
+    todo_planner_instructions,
+    get_current_date,
+)
+from models import SummaryState, SummaryStateOutput, TodoItem
+from services.search import dispatch_search, prepare_research_context
+from utils import strip_thinking_tokens
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# State Schema
+# ============================================================================
+class ResearchState(TypedDict, total=False):
+    """State schema for the research workflow graph."""
+    research_topic: str
+    todo_items: list[TodoItem]
+    current_task_index: int
+    web_research_results: Annotated[list[str], operator.add]
+    sources_gathered: Annotated[list[str], operator.add]
+    research_loop_count: int
+    structured_report: Optional[str]
+    report_note_id: Optional[str]
+    report_note_path: Optional[str]
+    # Internal tracking
+    messages: list[Any]
+    config: Configuration
+
+
+# ============================================================================
+# Note Tool Implementation
+# ============================================================================
+class NoteTool:
+    """Simple file-based note tool for persisting task notes."""
+
+    def __init__(self, workspace: str = "./notes"):
+        self.workspace = Path(workspace)
+        self.workspace.mkdir(parents=True, exist_ok=True)
+        self._id_counter = 0
+        self._lock = Lock()
+
+    def _generate_id(self) -> str:
+        with self._lock:
+            self._id_counter += 1
+            import time
+            return f"note_{int(time.time())}_{self._id_counter}"
+
+    def run(self, params: dict[str, Any]) -> str:
+        """Execute note action: create, read, update, list."""
+        action = params.get("action", "read")
+        
+        if action == "create":
+            return self._create_note(params)
+        elif action == "read":
+            return self._read_note(params)
+        elif action == "update":
+            return self._update_note(params)
+        elif action == "list":
+            return self._list_notes(params)
+        else:
+            return f"❌ Unknown action: {action}"
+
+    def _create_note(self, params: dict[str, Any]) -> str:
+        note_id = self._generate_id()
+        title = params.get("title", "Untitled")
+        note_type = params.get("note_type", "general")
+        tags = params.get("tags", [])
+        content = params.get("content", "")
+        task_id = params.get("task_id")
+
+        note_path = self.workspace / f"{note_id}.md"
+        
+        frontmatter = f"""---
+id: {note_id}
+title: {title}
+type: {note_type}
+tags: {tags}
+task_id: {task_id}
+---
+
+"""
+        note_path.write_text(frontmatter + content, encoding="utf-8")
+        return f"✅ Note created\nID: {note_id}\nPath: {note_path}"
+
+    def _read_note(self, params: dict[str, Any]) -> str:
+        note_id = params.get("note_id")
+        if not note_id:
+            return "❌ Missing note_id parameter"
+        
+        note_path = self.workspace / f"{note_id}.md"
+        if not note_path.exists():
+            return f"❌ Note does not exist: {note_id}"
+        
+        content = note_path.read_text(encoding="utf-8")
+        return f"✅ Note content:\n{content}"
+
+    def _update_note(self, params: dict[str, Any]) -> str:
+        note_id = params.get("note_id")
+        if not note_id:
+            return "❌ Missing note_id parameter"
+        
+        note_path = self.workspace / f"{note_id}.md"
+        if not note_path.exists():
+            return f"❌ Note does not exist: {note_id}"
+        
+        # Read existing content
+        existing = note_path.read_text(encoding="utf-8")
+        
+        # Update frontmatter if provided
+        title = params.get("title")
+        content = params.get("content", "")
+        
+        # Simple append strategy
+        if content:
+            updated = existing + "\n\n---\nUpdate:\n" + content
+            note_path.write_text(updated, encoding="utf-8")
+        
+        return f"✅ Note updated\nID: {note_id}"
+
+    def _list_notes(self, params: dict[str, Any]) -> str:
+        notes = list(self.workspace.glob("*.md"))
+        if not notes:
+            return "📝 No notes yet"
+        
+        result = "📝 Note list:\n"
+        for note in notes:
+            result += f"- {note.stem}\n"
+        return result
+
+
+# ============================================================================
+# Tool Call Tracker
+# ============================================================================
+class ToolCallTracker:
+    """Collects tool call events for SSE streaming."""
+
+    def __init__(self, notes_workspace: Optional[str] = None):
+        self._notes_workspace = notes_workspace
+        self._events: list[dict[str, Any]] = []
+        self._cursor = 0
+        self._lock = Lock()
+        self._event_sink: Optional[Callable[[dict[str, Any]], None]] = None
+
+    def record(self, event: dict[str, Any]) -> None:
+        with self._lock:
+            event["id"] = len(self._events) + 1
+            self._events.append(event)
+        
+        sink = self._event_sink
+        if sink:
+            sink({"type": "tool_call", **event})
+
+    def drain(self, step: Optional[int] = None) -> list[dict[str, Any]]:
+        with self._lock:
+            if self._cursor >= len(self._events):
+                return []
+            new_events = self._events[self._cursor:]
+            self._cursor = len(self._events)
+        
+        payloads = []
+        for event in new_events:
+            payload = {"type": "tool_call", **event}
+            if step is not None:
+                payload["step"] = step
+            payloads.append(payload)
+        return payloads
+
+    def set_event_sink(self, sink: Optional[Callable[[dict[str, Any]], None]]) -> None:
+        self._event_sink = sink
+
+    def as_dicts(self) -> list[dict[str, Any]]:
+        with self._lock:
+            return list(self._events)
+
+    def reset(self) -> None:
+        with self._lock:
+            self._events.clear()
+            self._cursor = 0
+
+
+# ============================================================================
+# Deep Research Agent using LangGraph
+# ============================================================================
+class DeepResearchAgent:
+    """Coordinator orchestrating TODO-based research workflow using LangGraph."""
+
+    def __init__(self, config: Configuration | None = None) -> None:
+        """Initialize the coordinator with configuration and LangGraph components."""
+        self.config = config or Configuration.from_env()
+        self.llm = self._init_llm()
+        
+        # Note tool setup
+        self.note_tool = (
+            NoteTool(workspace=self.config.notes_workspace)
+            if self.config.enable_notes
+            else None
+        )
+        
+        # Tool call tracking
+        self._tool_tracker = ToolCallTracker(
+            self.config.notes_workspace if self.config.enable_notes else None
+        )
+        self._tool_event_sink_enabled = False
+        self._state_lock = Lock()
+        
+        # Build the graph
+        self.graph = self._build_graph()
+        self._last_search_notices: list[str] = []
+
+    def _init_llm(self) -> ChatOpenAI:
+        """Initialize ChatOpenAI with configuration preferences."""
+        llm_kwargs: dict[str, Any] = {
+            "temperature": 0.0,
+            "streaming": True,
+        }
+        
+        model_id = self.config.llm_model_id or self.config.local_llm
+        if model_id:
+            llm_kwargs["model"] = model_id
+        
+        provider = (self.config.llm_provider or "").strip()
+        
+        if provider == "ollama":
+            llm_kwargs["base_url"] = self.config.sanitized_ollama_url()
+            llm_kwargs["api_key"] = self.config.llm_api_key or "ollama"
+        elif provider == "lmstudio":
+            llm_kwargs["base_url"] = self.config.lmstudio_base_url
+            if self.config.llm_api_key:
+                llm_kwargs["api_key"] = self.config.llm_api_key
+            else:
+                llm_kwargs["api_key"] = "lm-studio"
+        else:
+            if self.config.llm_base_url:
+                llm_kwargs["base_url"] = self.config.llm_base_url
+            if self.config.llm_api_key:
+                llm_kwargs["api_key"] = self.config.llm_api_key
+        
+        return ChatOpenAI(**llm_kwargs)
+
+    def _build_graph(self) -> StateGraph:
+        """Build the LangGraph workflow."""
+        workflow = StateGraph(ResearchState)
+        
+        # Add nodes
+        workflow.add_node("plan_research", self._plan_research_node)
+        workflow.add_node("execute_tasks", self._execute_tasks_node)
+        workflow.add_node("generate_report", self._generate_report_node)
+        
+        # Define edges
+        workflow.set_entry_point("plan_research")
+        workflow.add_edge("plan_research", "execute_tasks")
+        workflow.add_edge("execute_tasks", "generate_report")
+        workflow.add_edge("generate_report", END)
+        
+        return workflow.compile()
+
+    # -------------------------------------------------------------------------
+    # Graph Nodes
+    # -------------------------------------------------------------------------
+    def _plan_research_node(self, state: ResearchState) -> dict[str, Any]:
+        """Planning node: break research topic into actionable tasks."""
+        topic = state.get("research_topic", "")
+        
+        system_prompt = todo_planner_system_prompt.strip()
+        user_prompt = todo_planner_instructions.format(
+            current_date=get_current_date(),
+            research_topic=topic,
+        )
+        
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=user_prompt),
+        ]
+        
+        response = self.llm.invoke(messages)
+        response_text = response.content
+        
+        if self.config.strip_thinking_tokens:
+            response_text = strip_thinking_tokens(response_text)
+        
+        logger.info("Planner raw output (truncated): %s", response_text[:500])
+        
+        # Parse tasks from response
+        todo_items = self._parse_todo_items(response_text, topic)
+        
+        # Create notes for each task if enabled
+        if self.note_tool:
+            for task in todo_items:
+                result = self.note_tool.run({
+                    "action": "create",
+                    "task_id": task.id,
+                    "title": f"Task {task.id}: {task.title}",
+                    "note_type": "task_state",
+                    "tags": ["deep_research", f"task_{task.id}"],
+                    "content": f"Task objective: {task.intent}\nSearch query: {task.query}",
+                })
+                # Extract note_id from result
+                note_id = self._extract_note_id(result)
+                if note_id:
+                    task.note_id = note_id
+                    task.note_path = str(Path(self.config.notes_workspace) / f"{note_id}.md")
+                
+                self._tool_tracker.record({
+                    "agent": "Research Planning Expert",
+                    "tool": "note",
+                    "parameters": {"action": "create", "task_id": task.id},
+                    "result": result,
+                    "task_id": task.id,
+                    "note_id": note_id,
+                })
+        
+        titles = [task.title for task in todo_items]
+        logger.info("Planner produced %d tasks: %s", len(todo_items), titles)
+        
+        return {
+            "todo_items": todo_items,
+            "current_task_index": 0,
+            "research_loop_count": 0,
+        }
+
+    def _execute_tasks_node(self, state: ResearchState) -> dict[str, Any]:
+        """Execute research tasks: search and summarize each task."""
+        todo_items = state.get("todo_items", [])
+        topic = state.get("research_topic", "")
+        loop_count = state.get("research_loop_count", 0)
+        
+        web_results: list[str] = []
+        sources: list[str] = []
+        
+        for task in todo_items:
+            task.status = "in_progress"
+            
+            # Execute search
+            search_result, notices, answer_text, backend = dispatch_search(
+                task.query,
+                self.config,
+                loop_count,
+            )
+            self._last_search_notices = notices
+            task.notices = notices
+            
+            if not search_result or not search_result.get("results"):
+                task.status = "skipped"
+                continue
+            
+            # Prepare context
+            sources_summary, context = prepare_research_context(
+                search_result, answer_text, self.config
+            )
+            task.sources_summary = sources_summary
+            web_results.append(context)
+            sources.append(sources_summary)
+            
+            # Summarize task
+            summary = self._summarize_task(topic, task, context)
+            task.summary = summary
+            task.status = "completed"
+            
+            # Update note if enabled
+            if self.note_tool and task.note_id:
+                result = self.note_tool.run({
+                    "action": "update",
+                    "note_id": task.note_id,
+                    "task_id": task.id,
+                    "content": f"## Task Summary\n{summary}\n\n## Sources\n{sources_summary}",
+                })
+                self._tool_tracker.record({
+                    "agent": "Task Summary Expert",
+                    "tool": "note",
+                    "parameters": {"action": "update", "note_id": task.note_id},
+                    "result": result,
+                    "task_id": task.id,
+                    "note_id": task.note_id,
+                })
+            
+            loop_count += 1
+        
+        return {
+            "todo_items": todo_items,
+            "web_research_results": web_results,
+            "sources_gathered": sources,
+            "research_loop_count": loop_count,
+        }
+
+    def _generate_report_node(self, state: ResearchState) -> dict[str, Any]:
+        """Generate the final structured report."""
+        topic = state.get("research_topic", "")
+        todo_items = state.get("todo_items", [])
+        
+        # Build task overview
+        tasks_block = []
+        for task in todo_items:
+            summary_block = task.summary or "No information available"
+            sources_block = task.sources_summary or "No sources available"
+            tasks_block.append(
+                f"### Task {task.id}: {task.title}\n"
+                f"- Objective: {task.intent}\n"
+                f"- Search query: {task.query}\n"
+                f"- Status: {task.status}\n"
+                f"- Summary:\n{summary_block}\n"
+                f"- Sources:\n{sources_block}\n"
+            )
+        
+        prompt = (
+            f"Research topic: {topic}\n"
+            f"Task overview:\n{''.join(tasks_block)}\n"
+            "Based on the above task summaries, please write a structured research report."
+        )
+        
+        messages = [
+            SystemMessage(content=report_writer_instructions.strip()),
+            HumanMessage(content=prompt),
+        ]
+        
+        response = self.llm.invoke(messages)
+        report_text = response.content
+        
+        if self.config.strip_thinking_tokens:
+            report_text = strip_thinking_tokens(report_text)
+        
+        report_text = report_text.strip() or "Report generation failed, please check input."
+        
+        # Create conclusion note if enabled
+        report_note_id = None
+        report_note_path = None
+        if self.note_tool and report_text:
+            result = self.note_tool.run({
+                "action": "create",
+                "title": f"Research Report: {topic}",
+                "note_type": "conclusion",
+                "tags": ["deep_research", "report"],
+                "content": report_text,
+            })
+            report_note_id = self._extract_note_id(result)
+            if report_note_id:
+                report_note_path = str(Path(self.config.notes_workspace) / f"{report_note_id}.md")
+            
+            self._tool_tracker.record({
+                "agent": "Report Writing Expert",
+                "tool": "note",
+                "parameters": {"action": "create", "note_type": "conclusion"},
+                "result": result,
+                "note_id": report_note_id,
+            })
+        
+        return {
+            "structured_report": report_text,
+            "report_note_id": report_note_id,
+            "report_note_path": report_note_path,
+        }
+
+    # -------------------------------------------------------------------------
+    # Helper Methods
+    # -------------------------------------------------------------------------
+    def _summarize_task(self, topic: str, task: TodoItem, context: str) -> str:
+        """Generate summary for a single task."""
+        prompt = (
+            f"Task topic: {topic}\n"
+            f"Task name: {task.title}\n"
+            f"Task objective: {task.intent}\n"
+            f"Search query: {task.query}\n"
+            f"Task context:\n{context}\n"
+            "Please generate a detailed task summary."
+        )
+        
+        messages = [
+            SystemMessage(content=task_summarizer_instructions.strip()),
+            HumanMessage(content=prompt),
+        ]
+        
+        response = self.llm.invoke(messages)
+        summary_text = response.content
+        
+        if self.config.strip_thinking_tokens:
+            summary_text = strip_thinking_tokens(summary_text)
+        
+        return summary_text.strip() or "No information available"
+
+    def _parse_todo_items(self, response: str, topic: str) -> list[TodoItem]:
+        """Parse planner output into TodoItem list."""
+        import json
+        
+        text = response.strip()
+        tasks_payload: list[dict[str, Any]] = []
+        
+        # Try to extract JSON
+        start = text.find("{")
+        end = text.rfind("}")
+        if start != -1 and end != -1 and end > start:
+            try:
+                json_obj = json.loads(text[start:end + 1])
+                if isinstance(json_obj, dict) and "tasks" in json_obj:
+                    tasks_payload = json_obj["tasks"]
+            except json.JSONDecodeError:
+                pass
+        
+        if not tasks_payload:
+            start = text.find("[")
+            end = text.rfind("]")
+            if start != -1 and end != -1 and end > start:
+                try:
+                    tasks_payload = json.loads(text[start:end + 1])
+                except json.JSONDecodeError:
+                    pass
+        
+        # Create TodoItems
+        todo_items: list[TodoItem] = []
+        for idx, item in enumerate(tasks_payload, start=1):
+            if not isinstance(item, dict):
+                continue
+            title = str(item.get("title") or f"Task{idx}").strip()
+            intent = str(item.get("intent") or "Focus on key issues of the topic").strip()
+            query = str(item.get("query") or topic).strip() or topic
+            
+            todo_items.append(TodoItem(
+                id=idx,
+                title=title,
+                intent=intent,
+                query=query,
+            ))
+        
+        # Fallback if no tasks parsed
+        if not todo_items:
+            todo_items.append(TodoItem(
+                id=1,
+                title="Basic Background Overview",
+                intent="Collect core background and latest developments on the topic",
+                query=f"{topic} latest developments" if topic else "Basic background overview",
+            ))
+        
+        return todo_items
+
+    @staticmethod
+    def _extract_note_id(response: str) -> Optional[str]:
+        """Extract note ID from tool response."""
+        if not response:
+            return None
+        match = re.search(r"ID:\s*([^\n]+)", response)
+        return match.group(1).strip() if match else None
+
+    def _set_tool_event_sink(self, sink: Callable[[dict[str, Any]], None] | None) -> None:
+        """Enable or disable immediate tool event callbacks."""
+        self._tool_event_sink_enabled = sink is not None
+        self._tool_tracker.set_event_sink(sink)
+
+    # -------------------------------------------------------------------------
+    # Public API
+    # -------------------------------------------------------------------------
+    def run(self, topic: str) -> SummaryStateOutput:
+        """Execute the research workflow and return the final report."""
+        initial_state: ResearchState = {
+            "research_topic": topic,
+            "todo_items": [],
+            "current_task_index": 0,
+            "web_research_results": [],
+            "sources_gathered": [],
+            "research_loop_count": 0,
+            "structured_report": None,
+            "report_note_id": None,
+            "report_note_path": None,
+            "messages": [],
+            "config": self.config,
+        }
+        
+        # Run the graph
+        final_state = self.graph.invoke(initial_state)
+        
+        report = final_state.get("structured_report", "")
+        todo_items = final_state.get("todo_items", [])
+        
+        return SummaryStateOutput(
+            running_summary=report,
+            report_markdown=report,
+            todo_items=todo_items,
+        )
+
+    def run_stream(self, topic: str) -> Iterator[dict[str, Any]]:
+        """Execute the workflow yielding incremental progress events."""
+        logger.debug("Starting streaming research: topic=%s", topic)
+        yield {"type": "status", "message": "Initializing research workflow"}
+        
+        # Plan phase
+        yield {"type": "status", "message": "Planning research tasks..."}
+        
+        system_prompt = todo_planner_system_prompt.strip()
+        user_prompt = todo_planner_instructions.format(
+            current_date=get_current_date(),
+            research_topic=topic,
+        )
+        
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=user_prompt),
+        ]
+        
+        response = self.llm.invoke(messages)
+        response_text = response.content
+        
+        if self.config.strip_thinking_tokens:
+            response_text = strip_thinking_tokens(response_text)
+        
+        todo_items = self._parse_todo_items(response_text, topic)
+        
+        # Create notes for tasks
+        if self.note_tool:
+            for task in todo_items:
+                result = self.note_tool.run({
+                    "action": "create",
+                    "task_id": task.id,
+                    "title": f"Task {task.id}: {task.title}",
+                    "note_type": "task_state",
+                    "tags": ["deep_research", f"task_{task.id}"],
+                    "content": f"Task objective: {task.intent}\nSearch query: {task.query}",
+                })
+                note_id = self._extract_note_id(result)
+                if note_id:
+                    task.note_id = note_id
+                    task.note_path = str(Path(self.config.notes_workspace) / f"{note_id}.md")
+        
+        # Setup channel mapping for streaming
+        channel_map: dict[int, dict[str, Any]] = {}
+        for index, task in enumerate(todo_items, start=1):
+            token = f"task_{task.id}"
+            task.stream_token = token
+            channel_map[task.id] = {"step": index, "token": token}
+        
+        yield {
+            "type": "todo_list",
+            "tasks": [self._serialize_task(t) for t in todo_items],
+            "step": 0,
+        }
+        
+        # Execute tasks with streaming
+        event_queue: Queue[dict[str, Any]] = Queue()
+        
+        def enqueue(event: dict[str, Any], task: Optional[TodoItem] = None, step_override: Optional[int] = None) -> None:
+            payload = dict(event)
+            target_task_id = payload.get("task_id")
+            if task is not None:
+                target_task_id = task.id
+                payload["task_id"] = task.id
+            
+            channel = channel_map.get(target_task_id) if target_task_id else None
+            if channel:
+                payload.setdefault("step", channel["step"])
+                payload["stream_token"] = channel["token"]
+            if step_override is not None:
+                payload["step"] = step_override
+            event_queue.put(payload)
+        
+        def tool_event_sink(event: dict[str, Any]) -> None:
+            enqueue(event)
+        
+        self._set_tool_event_sink(tool_event_sink)
+        
+        threads: list[Thread] = []
+        state = SummaryState(research_topic=topic)
+        state.todo_items = todo_items
+        
+        def worker(task: TodoItem, step: int) -> None:
+            try:
+                enqueue({
+                    "type": "task_status",
+                    "task_id": task.id,
+                    "status": "in_progress",
+                    "title": task.title,
+                    "intent": task.intent,
+                    "note_id": task.note_id,
+                    "note_path": task.note_path,
+                }, task=task)
+                
+                # Execute search
+                search_result, notices, answer_text, backend = dispatch_search(
+                    task.query, self.config, state.research_loop_count
+                )
+                task.notices = notices
+                
+                for notice in notices:
+                    if notice:
+                        enqueue({
+                            "type": "status",
+                            "message": notice,
+                            "task_id": task.id,
+                        }, task=task)
+                
+                if not search_result or not search_result.get("results"):
+                    task.status = "skipped"
+                    enqueue({
+                        "type": "task_status",
+                        "task_id": task.id,
+                        "status": "skipped",
+                        "title": task.title,
+                        "intent": task.intent,
+                        "note_id": task.note_id,
+                        "note_path": task.note_path,
+                    }, task=task)
+                    return
+                
+                # Prepare context
+                sources_summary, context = prepare_research_context(
+                    search_result, answer_text, self.config
+                )
+                task.sources_summary = sources_summary
+                
+                with self._state_lock:
+                    state.web_research_results.append(context)
+                    state.sources_gathered.append(sources_summary)
+                    state.research_loop_count += 1
+                
+                enqueue({
+                    "type": "sources",
+                    "task_id": task.id,
+                    "latest_sources": sources_summary,
+                    "raw_context": context,
+                    "backend": backend,
+                    "note_id": task.note_id,
+                    "note_path": task.note_path,
+                }, task=task)
+                
+                # Stream summarization
+                prompt = (
+                    f"Task topic: {topic}\n"
+                    f"Task name: {task.title}\n"
+                    f"Task objective: {task.intent}\n"
+                    f"Search query: {task.query}\n"
+                    f"Task context:\n{context}\n"
+                    "Please generate a detailed task summary."
+                )
+                
+                summary_messages = [
+                    SystemMessage(content=task_summarizer_instructions.strip()),
+                    HumanMessage(content=prompt),
+                ]
+                
+                summary_chunks: list[str] = []
+                for chunk in self.llm.stream(summary_messages):
+                    chunk_text = chunk.content
+                    if chunk_text:
+                        summary_chunks.append(chunk_text)
+                        # Strip thinking tokens from visible output
+                        visible_chunk = chunk_text
+                        if self.config.strip_thinking_tokens and "<think>" not in chunk_text:
+                            enqueue({
+                                "type": "task_summary_chunk",
+                                "task_id": task.id,
+                                "content": visible_chunk,
+                                "note_id": task.note_id,
+                            }, task=task)
+                
+                full_summary = "".join(summary_chunks)
+                if self.config.strip_thinking_tokens:
+                    full_summary = strip_thinking_tokens(full_summary)
+                
+                task.summary = full_summary.strip() or "No information available"
+                task.status = "completed"
+                
+                # Update note
+                if self.note_tool and task.note_id:
+                    self.note_tool.run({
+                        "action": "update",
+                        "note_id": task.note_id,
+                        "task_id": task.id,
+                        "content": f"## Task Summary\n{task.summary}\n\n## Sources\n{sources_summary}",
+                    })
+                
+                enqueue({
+                    "type": "task_status",
+                    "task_id": task.id,
+                    "status": "completed",
+                    "summary": task.summary,
+                    "sources_summary": task.sources_summary,
+                    "note_id": task.note_id,
+                    "note_path": task.note_path,
+                }, task=task)
+                
+            except Exception as exc:
+                logger.exception("Task execution failed", exc_info=exc)
+                enqueue({
+                    "type": "task_status",
+                    "task_id": task.id,
+                    "status": "failed",
+                    "detail": str(exc),
+                    "title": task.title,
+                    "intent": task.intent,
+                    "note_id": task.note_id,
+                    "note_path": task.note_path,
+                }, task=task)
+            finally:
+                enqueue({"type": "__task_done__", "task_id": task.id})
+        
+        # Start worker threads
+        for task in todo_items:
+            step = channel_map.get(task.id, {}).get("step", 0)
+            thread = Thread(target=worker, args=(task, step), daemon=True)
+            threads.append(thread)
+            thread.start()
+        
+        # Yield events from queue
+        active_workers = len(todo_items)
+        finished_workers = 0
+        
+        try:
+            while finished_workers < active_workers:
+                event = event_queue.get()
+                if event.get("type") == "__task_done__":
+                    finished_workers += 1
+                    continue
+                yield event
+            
+            # Drain remaining events
+            while True:
+                try:
+                    event = event_queue.get_nowait()
+                except Empty:
+                    break
+                if event.get("type") != "__task_done__":
+                    yield event
+        finally:
+            self._set_tool_event_sink(None)
+            for thread in threads:
+                thread.join()
+        
+        # Generate final report
+        yield {"type": "status", "message": "Generating research report..."}
+        
+        tasks_block = []
+        for task in todo_items:
+            summary_block = task.summary or "No information available"
+            sources_block = task.sources_summary or "No sources available"
+            tasks_block.append(
+                f"### Task {task.id}: {task.title}\n"
+                f"- Objective: {task.intent}\n"
+                f"- Search query: {task.query}\n"
+                f"- Status: {task.status}\n"
+                f"- Summary:\n{summary_block}\n"
+                f"- Sources:\n{sources_block}\n"
+            )
+        
+        report_prompt = (
+            f"Research topic: {topic}\n"
+            f"Task overview:\n{''.join(tasks_block)}\n"
+            "Based on the above task summaries, please write a structured research report."
+        )
+        
+        report_messages = [
+            SystemMessage(content=report_writer_instructions.strip()),
+            HumanMessage(content=report_prompt),
+        ]
+        
+        report = self.llm.invoke(report_messages).content
+        if self.config.strip_thinking_tokens:
+            report = strip_thinking_tokens(report)
+        report = report.strip() or "Report generation failed"
+        
+        # Create conclusion note
+        report_note_id = None
+        report_note_path = None
+        if self.note_tool:
+            result = self.note_tool.run({
+                "action": "create",
+                "title": f"Research Report: {topic}",
+                "note_type": "conclusion",
+                "tags": ["deep_research", "report"],
+                "content": report,
+            })
+            report_note_id = self._extract_note_id(result)
+            if report_note_id:
+                report_note_path = str(Path(self.config.notes_workspace) / f"{report_note_id}.md")
+        
+        yield {
+            "type": "final_report",
+            "report": report,
+            "note_id": report_note_id,
+            "note_path": report_note_path,
+        }
+        yield {"type": "done"}
+
+    def _serialize_task(self, task: TodoItem) -> dict[str, Any]:
+        """Convert task dataclass to serializable dict for frontend."""
+        return {
+            "id": task.id,
+            "title": task.title,
+            "intent": task.intent,
+            "query": task.query,
+            "status": task.status,
+            "summary": task.summary,
+            "sources_summary": task.sources_summary,
+            "note_id": task.note_id,
+            "note_path": task.note_path,
+            "stream_token": task.stream_token,
+        }
+
+
+def run_deep_research(topic: str, config: Configuration | None = None) -> SummaryStateOutput:
+    """Convenience function mirroring the class-based API."""
+    agent = DeepResearchAgent(config=config)
+    return agent.run(topic)

backend/src/config.py

@@ -0,0 +1,143 @@
+import os
+from enum import Enum
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+class SearchAPI(Enum):
+    PERPLEXITY = "perplexity"
+    TAVILY = "tavily"
+    DUCKDUCKGO = "duckduckgo"
+    SEARXNG = "searxng"
+    ADVANCED = "advanced"
+
+
+class Configuration(BaseModel):
+    """Configuration options for the deep research assistant."""
+
+    max_web_research_loops: int = Field(
+        default=3,
+        title="Research Depth",
+        description="Number of research iterations to perform",
+    )
+    local_llm: str = Field(
+        default="llama3.2",
+        title="Local Model Name",
+        description="Name of the locally hosted LLM (Ollama/LMStudio)",
+    )
+    llm_provider: str = Field(
+        default="ollama",
+        title="LLM Provider",
+        description="Provider identifier (ollama, lmstudio, or custom)",
+    )
+    search_api: SearchAPI = Field(
+        default=SearchAPI.DUCKDUCKGO,
+        title="Search API",
+        description="Web search API to use",
+    )
+    enable_notes: bool = Field(
+        default=True,
+        title="Enable Notes",
+        description="Whether to store task progress in NoteTool",
+    )
+    notes_workspace: str = Field(
+        default="./notes",
+        title="Notes Workspace",
+        description="Directory for NoteTool to persist task notes",
+    )
+    fetch_full_page: bool = Field(
+        default=True,
+        title="Fetch Full Page",
+        description="Include the full page content in the search results",
+    )
+    ollama_base_url: str = Field(
+        default="http://localhost:11434",
+        title="Ollama Base URL",
+        description="Base URL for Ollama API (without /v1 suffix)",
+    )
+    lmstudio_base_url: str = Field(
+        default="http://localhost:1234/v1",
+        title="LMStudio Base URL",
+        description="Base URL for LMStudio OpenAI-compatible API",
+    )
+    strip_thinking_tokens: bool = Field(
+        default=True,
+        title="Strip Thinking Tokens",
+        description="Whether to strip <think> tokens from model responses",
+    )
+    use_tool_calling: bool = Field(
+        default=False,
+        title="Use Tool Calling",
+        description="Use tool calling instead of JSON mode for structured output",
+    )
+    llm_api_key: Optional[str] = Field(
+        default=None,
+        title="LLM API Key",
+        description="Optional API key when using custom OpenAI-compatible services",
+    )
+    llm_base_url: Optional[str] = Field(
+        default=None,
+        title="LLM Base URL",
+        description="Optional base URL when using custom OpenAI-compatible services",
+    )
+    llm_model_id: Optional[str] = Field(
+        default=None,
+        title="LLM Model ID",
+        description="Optional model identifier for custom OpenAI-compatible services",
+    )
+
+    @classmethod
+    def from_env(cls, overrides: Optional[dict[str, Any]] = None) -> "Configuration":
+        """Create a configuration object using environment variables and overrides."""
+
+        raw_values: dict[str, Any] = {}
+
+        # Load values from environment variables based on field names
+        for field_name in cls.model_fields.keys():
+            env_key = field_name.upper()
+            if env_key in os.environ:
+                raw_values[field_name] = os.environ[env_key]
+
+        # Additional mappings for explicit env names
+        env_aliases = {
+            "local_llm": os.getenv("LOCAL_LLM"),
+            "llm_provider": os.getenv("LLM_PROVIDER"),
+            "llm_api_key": os.getenv("LLM_API_KEY"),
+            "llm_model_id": os.getenv("LLM_MODEL_ID"),
+            "llm_base_url": os.getenv("LLM_BASE_URL"),
+            "lmstudio_base_url": os.getenv("LMSTUDIO_BASE_URL"),
+            "ollama_base_url": os.getenv("OLLAMA_BASE_URL"),
+            "max_web_research_loops": os.getenv("MAX_WEB_RESEARCH_LOOPS"),
+            "fetch_full_page": os.getenv("FETCH_FULL_PAGE"),
+            "strip_thinking_tokens": os.getenv("STRIP_THINKING_TOKENS"),
+            "use_tool_calling": os.getenv("USE_TOOL_CALLING"),
+            "search_api": os.getenv("SEARCH_API"),
+            "enable_notes": os.getenv("ENABLE_NOTES"),
+            "notes_workspace": os.getenv("NOTES_WORKSPACE"),
+        }
+
+        for key, value in env_aliases.items():
+            if value is not None:
+                raw_values.setdefault(key, value)
+
+        if overrides:
+            for key, value in overrides.items():
+                if value is not None:
+                    raw_values[key] = value
+
+        return cls(**raw_values)
+
+    def sanitized_ollama_url(self) -> str:
+        """Ensure Ollama base URL includes the /v1 suffix required by OpenAI clients."""
+
+        base = self.ollama_base_url.rstrip("/")
+        if not base.endswith("/v1"):
+            base = f"{base}/v1"
+        return base
+
+    def resolved_model(self) -> Optional[str]:
+        """Best-effort resolution of the model identifier to use."""
+
+        return self.llm_model_id or self.local_llm
+

backend/src/main.py

@@ -0,0 +1,236 @@
+"""FastAPI entrypoint exposing the DeepResearchAgent via HTTP."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, Iterator, Optional
+
+from dotenv import load_dotenv
+
+# Load .env file before importing config
+load_dotenv()
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from loguru import logger
+from pydantic import BaseModel, Field
+
+from config import Configuration, SearchAPI
+from agent import DeepResearchAgent
+
+# Static files directory (for production deployment)
+STATIC_DIR = Path(__file__).parent.parent / "static"
+
+# Add console log handler
+logger.add(
+    sys.stderr,
+    level="INFO",
+    format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <4}</level> | <cyan>using_function:{function}</cyan> | <cyan>{file}:{line}</cyan> | <level>{message}</level>",
+    colorize=True,
+)
+
+
+# Add error log handler
+logger.add(
+    sink=sys.stderr,
+    level="ERROR",
+    format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <4}</level> | <cyan>using_function:{function}</cyan> | <cyan>{file}:{line}</cyan> | <level>{message}</level>",
+    colorize=True,
+)
+
+
+class ResearchRequest(BaseModel):
+    """Payload for triggering a research run."""
+
+    topic: str = Field(..., description="Research topic supplied by the user")
+    search_api: SearchAPI | None = Field(
+        default=None,
+        description="Override the default search backend configured via env",
+    )
+
+
+class ResearchResponse(BaseModel):
+    """HTTP response containing the generated report and structured tasks."""
+
+    report_markdown: str = Field(
+        ..., description="Markdown-formatted research report including sections"
+    )
+    todo_items: list[dict[str, Any]] = Field(
+        default_factory=list,
+        description="Structured TODO items with summaries and sources",
+    )
+
+
+def _mask_secret(value: Optional[str], visible: int = 4) -> str:
+    """Mask sensitive tokens while keeping leading and trailing characters."""
+    if not value:
+        return "unset"
+
+    if len(value) <= visible * 2:
+        return "*" * len(value)
+
+    return f"{value[:visible]}...{value[-visible:]}"
+
+
+def _build_config(payload: ResearchRequest) -> Configuration:
+    overrides: Dict[str, Any] = {}
+
+    if payload.search_api is not None:
+        overrides["search_api"] = payload.search_api
+
+    return Configuration.from_env(overrides=overrides)
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(title="LangGraph Deep Researcher")
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    @app.on_event("startup")
+    def log_startup_configuration() -> None:
+        config = Configuration.from_env()
+
+        if config.llm_provider == "ollama":
+            base_url = config.sanitized_ollama_url()
+        elif config.llm_provider == "lmstudio":
+            base_url = config.lmstudio_base_url
+        else:
+            base_url = config.llm_base_url or "unset"
+
+        logger.info(
+            "DeepResearch configuration loaded: provider=%s model=%s base_url=%s search_api=%s "
+            "max_loops=%s fetch_full_page=%s tool_calling=%s strip_thinking=%s api_key=%s",
+            config.llm_provider,
+            config.resolved_model() or "unset",
+            base_url,
+            (config.search_api.value if isinstance(config.search_api, SearchAPI) else config.search_api),
+            config.max_web_research_loops,
+            config.fetch_full_page,
+            config.use_tool_calling,
+            config.strip_thinking_tokens,
+            _mask_secret(config.llm_api_key),
+        )
+
+    @app.get("/healthz")
+    def health_check() -> Dict[str, str]:
+        return {"status": "ok"}
+
+    @app.post("/research", response_model=ResearchResponse)
+    def run_research(payload: ResearchRequest) -> ResearchResponse:
+        try:
+            config = _build_config(payload)
+            agent = DeepResearchAgent(config=config)
+            result = agent.run(payload.topic)
+        except ValueError as exc:  # Likely due to unsupported configuration
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        except Exception as exc:  # pragma: no cover - defensive guardrail
+            raise HTTPException(status_code=500, detail="Research failed") from exc
+
+        todo_payload = [
+            {
+                "id": item.id,
+                "title": item.title,
+                "intent": item.intent,
+                "query": item.query,
+                "status": item.status,
+                "summary": item.summary,
+                "sources_summary": item.sources_summary,
+                "note_id": item.note_id,
+                "note_path": item.note_path,
+            }
+            for item in result.todo_items
+        ]
+
+        return ResearchResponse(
+            report_markdown=(result.report_markdown or result.running_summary or ""),
+            todo_items=todo_payload,
+        )
+
+    @app.post("/research/stream")
+    def stream_research(payload: ResearchRequest) -> StreamingResponse:
+        try:
+            config = _build_config(payload)
+            agent = DeepResearchAgent(config=config)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        def event_iterator() -> Iterator[str]:
+            try:
+                for event in agent.run_stream(payload.topic):
+                    yield f"data: {json.dumps(event, ensure_ascii=False)}\n\n"
+            except Exception as exc:  # pragma: no cover - defensive guardrail
+                logger.exception("Streaming research failed")
+                error_payload = {"type": "error", "detail": str(exc)}
+                yield f"data: {json.dumps(error_payload, ensure_ascii=False)}\n\n"
+
+        return StreamingResponse(
+            event_iterator(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+            },
+        )
+
+    # Serve static frontend files in production (when static directory exists)
+    if STATIC_DIR.exists() and STATIC_DIR.is_dir():
+        logger.info(f"Serving static files from {STATIC_DIR}")
+
+        # Mount assets directory first (CSS, JS, images)
+        assets_dir = STATIC_DIR / "assets"
+        if assets_dir.exists():
+            app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
+
+        # Serve index.html for root path
+        @app.get("/")
+        async def serve_index() -> FileResponse:
+            """Serve the main index.html."""
+            return FileResponse(STATIC_DIR / "index.html")
+
+        # Serve favicon and other root-level static files
+        @app.get("/favicon.ico")
+        async def serve_favicon() -> FileResponse:
+            """Serve favicon."""
+            favicon_path = STATIC_DIR / "favicon.ico"
+            if favicon_path.exists():
+                return FileResponse(favicon_path)
+            raise HTTPException(status_code=404, detail="Favicon not found")
+
+        # Catch-all for SPA routing (must be last)
+        @app.get("/{full_path:path}")
+        async def serve_spa(full_path: str) -> FileResponse:
+            """Serve the SPA index.html for client-side routing."""
+            # Check if requesting a static file that exists
+            file_path = STATIC_DIR / full_path
+            if file_path.exists() and file_path.is_file():
+                return FileResponse(file_path)
+            # Otherwise serve index.html for SPA routing
+            return FileResponse(STATIC_DIR / "index.html")
+
+    return app
+
+
+app = create_app()
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )

backend/src/models.py

@@ -0,0 +1,51 @@
+"""State models used by the deep research workflow."""
+
+import operator
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from typing_extensions import Annotated
+
+
+@dataclass(kw_only=True)
+class TodoItem:
+    """A single todo task item."""
+
+    id: int
+    title: str
+    intent: str
+    query: str
+    status: str = field(default="pending")
+    summary: Optional[str] = field(default=None)
+    sources_summary: Optional[str] = field(default=None)
+    notices: list[str] = field(default_factory=list)
+    note_id: Optional[str] = field(default=None)
+    note_path: Optional[str] = field(default=None)
+    stream_token: Optional[str] = field(default=None)
+
+
+@dataclass(kw_only=True)
+class SummaryState:
+    research_topic: str = field(default=None)  # Report topic
+    search_query: str = field(default=None)  # Deprecated placeholder
+    web_research_results: Annotated[list, operator.add] = field(default_factory=list)
+    sources_gathered: Annotated[list, operator.add] = field(default_factory=list)
+    research_loop_count: int = field(default=0)  # Research loop count
+    running_summary: str = field(default=None)  # Legacy summary field
+    todo_items: Annotated[list, operator.add] = field(default_factory=list)
+    structured_report: Optional[str] = field(default=None)
+    report_note_id: Optional[str] = field(default=None)
+    report_note_path: Optional[str] = field(default=None)
+
+
+@dataclass(kw_only=True)
+class SummaryStateInput:
+    research_topic: str = field(default=None)  # Report topic
+
+
+@dataclass(kw_only=True)
+class SummaryStateOutput:
+    running_summary: str = field(default=None)  # Backward-compatible text
+    report_markdown: Optional[str] = field(default=None)
+    todo_items: List[TodoItem] = field(default_factory=list)
+

backend/src/prompts.py

@@ -0,0 +1,110 @@
+from datetime import datetime
+
+
+# Get current date in a readable format
+def get_current_date():
+    return datetime.now().strftime("%B %d, %Y")
+
+
+
+todo_planner_system_prompt = """
+You are a research planning expert. Please break down complex topics into a limited set of complementary tasks.
+- Tasks should be complementary and avoid duplication;
+- Each task should have a clear intent and actionable search direction;
+- Output must be structured, concise, and suitable for subsequent collaboration.
+
+<GOAL>
+1. Based on the research topic, identify 3-5 key research tasks;
+2. Each task needs a clear objective intent and appropriate web search queries;
+3. Tasks should avoid overlap and collectively cover the user's problem domain;
+4. When creating or updating tasks, you must call the `note` tool to sync task information (this is the only way to write to notes).
+</GOAL>
+
+<NOTE_COLLAB>
+- Call the `note` tool to create/update structured notes for each task, using JSON parameter format:
+  - Create example: `[TOOL_CALL:note:{"action":"create","task_id":1,"title":"Task 1: Background Overview","note_type":"task_state","tags":["deep_research","task_1"],"content":"Please record task overview, system prompts, source overview, task summary"}]`
+  - Update example: `[TOOL_CALL:note:{"action":"update","note_id":"<existing_ID>","task_id":1,"title":"Task 1: Background Overview","note_type":"task_state","tags":["deep_research","task_1"],"content":"...new content..."}]`
+- `tags` must include `deep_research` and `task_{task_id}` so other Agents can find them
+</NOTE_COLLAB>
+
+<TOOLS>
+You must call the note tool named `note` to record or update tasks, using JSON parameters:
+```
+[TOOL_CALL:note:{"action":"create","task_id":1,"title":"Task 1: Background Overview","note_type":"task_state","tags":["deep_research","task_1"],"content":"..."}]
+```
+</TOOLS>
+"""
+
+
+todo_planner_instructions = """
+
+<CONTEXT>
+Current date: {current_date}
+Research topic: {research_topic}
+</CONTEXT>
+
+<FORMAT>
+Please respond strictly in JSON format:
+{{
+  "tasks": [
+    {{
+      "title": "Task name (within 10 words, highlight key points)",
+      "intent": "Core problem the task aims to solve, described in 1-2 sentences",
+      "query": "Recommended search keywords"
+    }}
+  ]
+}}
+</FORMAT>
+
+If the topic information is insufficient to plan tasks, output an empty array: {{"tasks": []}}. Use the note tool to record your thought process if necessary.
+"""
+
+
+task_summarizer_instructions = """
+You are a research execution expert. Based on the given context, generate a summary for a specific task. Provide detailed and thorough summaries rather than superficial overviews. Be innovative, break conventional thinking, and expand from multiple dimensions including principles, applications, pros and cons, engineering practices, comparisons, and historical evolution.
+
+<GOAL>
+1. Identify 3-5 key findings related to the task intent;
+2. Clearly explain the meaning and value of each finding, citing factual data when available;
+</GOAL>
+
+<NOTES>
+- Task notes are created by the planning expert. The note ID will be provided at call time; please first call `[TOOL_CALL:note:{"action":"read","note_id":"<note_id>"}]` to get the latest state.
+- After updating the task summary, use `[TOOL_CALL:note:{"action":"update","note_id":"<note_id>","task_id":{task_id},"title":"Task {task_id}: ...","note_type":"task_state","tags":["deep_research","task_{task_id}"],"content":"..."}]` to write back to notes, maintaining the original structure and appending new information.
+- If no note ID is found, please create one first with `task_{task_id}` in `tags` before continuing.
+</NOTES>
+
+<FORMAT>
+- Use Markdown for output;
+- Start with section heading: "Task Summary";
+- Express key findings using ordered or unordered lists;
+- If the task has no valid results, output "No information available".
+- The final summary presented to users must NOT contain `[TOOL_CALL:...]` directives.
+</FORMAT>
+"""
+
+
+report_writer_instructions = """
+You are a professional analysis report writer. Based on the input task summaries and reference information, generate a structured research report.
+
+<REPORT_TEMPLATE>
+1. **Background Overview**: Briefly describe the importance and context of the research topic.
+2. **Core Insights**: Extract 3-5 most important conclusions, annotated with reference/task numbers.
+3. **Evidence & Data**: List supporting facts or metrics, citing key points from task summaries.
+4. **Risks & Challenges**: Analyze potential issues, limitations, or hypotheses yet to be verified.
+5. **Reference Sources**: List key source entries by task (title + link).
+</REPORT_TEMPLATE>
+
+<REQUIREMENTS>
+- Report should use Markdown;
+- Each section should be clearly separated, no additional cover page or epilogue;
+- If information is missing for a section, state "No relevant information available";
+- When citing sources, use task titles or source titles to ensure traceability.
+- Output to users must NOT contain residual `[TOOL_CALL:...]` directives.
+</REQUIREMENTS>
+
+<NOTES>
+- Before generating the report, call `[TOOL_CALL:note:{"action":"read","note_id":"<note_id>"}]` for each note_id to read task notes.
+- If you need to save results at the report level, you can create a new `conclusion` type note, for example: `[TOOL_CALL:note:{"action":"create","title":"Research Report: {research_topic}","note_type":"conclusion","tags":["deep_research","report"],"content":"...report highlights..."}]`.
+</NOTES>
+"""

backend/src/services/__init__.py

@@ -0,0 +1,2 @@
+"""Domain services for the deep researcher workflow."""
+

backend/src/services/notes.py

@@ -0,0 +1,58 @@
+"""Helpers for coordinating note tool usage instructions."""
+
+from __future__ import annotations
+
+import json
+
+from models import TodoItem
+
+
+def build_note_guidance(task: TodoItem) -> str:
+    """Generate note tool usage guidance for a specific task."""
+
+    tags_list = ["deep_research", f"task_{task.id}"]
+    tags_literal = json.dumps(tags_list, ensure_ascii=False)
+
+    if task.note_id:
+        read_payload = json.dumps({"action": "read", "note_id": task.note_id}, ensure_ascii=False)
+        update_payload = json.dumps(
+            {
+                "action": "update",
+                "note_id": task.note_id,
+                "task_id": task.id,
+                "title": f"Task {task.id}: {task.title}",
+                "note_type": "task_state",
+                "tags": tags_list,
+                "content": "Please add the new information from this round to the task overview",
+            },
+            ensure_ascii=False,
+        )
+
+        return (
+            "Note collaboration guide:\n"
+            f"- Current task note ID: {task.note_id}.\n"
+            f"- Before writing the summary, you must call: [TOOL_CALL:note:{read_payload}] to get the latest content.\n"
+            f"- After completing analysis, call: [TOOL_CALL:note:{update_payload}] to sync incremental information.\n"
+            "- When updating, maintain the original paragraph structure and add new content to the corresponding sections.\n"
+            f"- Recommended to keep tags as {tags_literal} so other Agents can quickly locate it.\n"
+            "- After successfully syncing to notes, then output the summary for the user.\n"
+        )
+
+    create_payload = json.dumps(
+        {
+            "action": "create",
+            "task_id": task.id,
+            "title": f"Task {task.id}: {task.title}",
+            "note_type": "task_state",
+            "tags": tags_list,
+            "content": "Please record task overview, sources overview",
+        },
+        ensure_ascii=False,
+    )
+
+    return (
+        "Note collaboration guide:\n"
+        f"- No note has been created for this task yet, please first call: [TOOL_CALL:note:{create_payload}].\n"
+        "- After successful creation, record the returned note_id and reuse it in all subsequent updates.\n"
+        "- After syncing notes, then output the summary for the user.\n"
+    )

backend/src/services/planner.py

@@ -0,0 +1,158 @@
+"""Service responsible for converting the research topic into actionable tasks."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from typing import Any, List, Optional
+
+from models import TodoItem
+from config import Configuration
+from prompts import get_current_date, todo_planner_instructions
+from utils import strip_thinking_tokens
+
+logger = logging.getLogger(__name__)
+
+TOOL_CALL_PATTERN = re.compile(
+    r"\[TOOL_CALL:(?P<tool>[^:]+):(?P<body>[^\]]+)\]",
+    re.IGNORECASE,
+)
+
+class PlanningService:
+    """Wraps the planner agent to produce structured TODO items."""
+
+    def __init__(self, planner_agent: ToolAwareSimpleAgent, config: Configuration) -> None:
+        self._agent = planner_agent
+        self._config = config
+
+    def plan_todo_list(self, state: SummaryState) -> List[TodoItem]:
+        """Ask the planner agent to break the topic into actionable tasks."""
+
+        prompt = todo_planner_instructions.format(
+            current_date=get_current_date(),
+            research_topic=state.research_topic,
+        )
+
+        response = self._agent.run(prompt)
+        self._agent.clear_history()
+
+        logger.info("Planner raw output (truncated): %s", response[:500])
+
+        tasks_payload = self._extract_tasks(response)
+        todo_items: List[TodoItem] = []
+
+        for idx, item in enumerate(tasks_payload, start=1):
+            title = str(item.get("title") or f"Task{idx}").strip()
+            intent = str(item.get("intent") or "Focus on key issues of the topic").strip()
+            query = str(item.get("query") or state.research_topic).strip()
+
+            if not query:
+                query = state.research_topic
+
+            task = TodoItem(
+                id=idx,
+                title=title,
+                intent=intent,
+                query=query,
+            )
+            todo_items.append(task)
+
+        state.todo_items = todo_items
+
+        titles = [task.title for task in todo_items]
+        logger.info("Planner produced %d tasks: %s", len(todo_items), titles)
+        return todo_items
+
+    @staticmethod
+    def create_fallback_task(state: SummaryState) -> TodoItem:
+        """Create a minimal fallback task when planning failed."""
+
+        return TodoItem(
+            id=1,
+            title="Basic Background Overview",
+            intent="Collect core background and latest developments on the topic",
+            query=f"{state.research_topic} latest developments" if state.research_topic else "Basic background overview",
+        )
+
+    # ------------------------------------------------------------------
+    # Parsing helpers
+    # ------------------------------------------------------------------
+    def _extract_tasks(self, raw_response: str) -> List[dict[str, Any]]:
+        """Parse planner output into a list of task dictionaries."""
+
+        text = raw_response.strip()
+        if self._config.strip_thinking_tokens:
+            text = strip_thinking_tokens(text)
+
+        json_payload = self._extract_json_payload(text)
+        tasks: List[dict[str, Any]] = []
+
+        if isinstance(json_payload, dict):
+            candidate = json_payload.get("tasks")
+            if isinstance(candidate, list):
+                for item in candidate:
+                    if isinstance(item, dict):
+                        tasks.append(item)
+        elif isinstance(json_payload, list):
+            for item in json_payload:
+                if isinstance(item, dict):
+                    tasks.append(item)
+
+        if not tasks:
+            tool_payload = self._extract_tool_payload(text)
+            if tool_payload and isinstance(tool_payload.get("tasks"), list):
+                for item in tool_payload["tasks"]:
+                    if isinstance(item, dict):
+                        tasks.append(item)
+
+        return tasks
+
+    def _extract_json_payload(self, text: str) -> Optional[dict[str, Any] | list]:
+        """Try to locate and parse a JSON object or array from the text."""
+
+        start = text.find("{")
+        end = text.rfind("}")
+        if start != -1 and end != -1 and end > start:
+            candidate = text[start : end + 1]
+            try:
+                return json.loads(candidate)
+            except json.JSONDecodeError:
+                pass
+
+        start = text.find("[")
+        end = text.rfind("]")
+        if start != -1 and end != -1 and end > start:
+            candidate = text[start : end + 1]
+            try:
+                return json.loads(candidate)
+            except json.JSONDecodeError:
+                return None
+
+        return None
+
+    def _extract_tool_payload(self, text: str) -> Optional[dict[str, Any]]:
+        """Parse the first TOOL_CALL expression in the output."""
+
+        match = TOOL_CALL_PATTERN.search(text)
+        if not match:
+            return None
+
+        body = match.group("body")
+
+        try:
+            payload = json.loads(body)
+            if isinstance(payload, dict):
+                return payload
+        except json.JSONDecodeError:
+            pass
+
+        parts = [segment.strip() for segment in body.split(",") if segment.strip()]
+        payload: dict[str, Any] = {}
+        for part in parts:
+            if "=" not in part:
+                continue
+            key, value = part.split("=", 1)
+            payload[key.strip()] = value.strip().strip('"').strip("'")
+
+        return payload or None

backend/src/services/reporter.py

@@ -0,0 +1,79 @@
+"""Service that consolidates task results into the final report."""
+
+from __future__ import annotations
+
+import json
+
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, SystemMessage
+
+from models import SummaryState
+from config import Configuration
+from utils import strip_thinking_tokens
+from services.text_processing import strip_tool_calls
+from prompts import report_writer_instructions
+
+
+def generate_report(
+    llm: ChatOpenAI,
+    state: SummaryState,
+    config: Configuration,
+) -> str:
+    """Generate a structured report based on completed tasks."""
+    
+    tasks_block = []
+    for task in state.todo_items:
+        summary_block = task.summary or "No information available"
+        sources_block = task.sources_summary or "No sources available"
+        tasks_block.append(
+            f"### Task {task.id}: {task.title}\n"
+            f"- Objective: {task.intent}\n"
+            f"- Search query: {task.query}\n"
+            f"- Status: {task.status}\n"
+            f"- Summary:\n{summary_block}\n"
+            f"- Sources:\n{sources_block}\n"
+        )
+    
+    note_references = []
+    for task in state.todo_items:
+        if task.note_id:
+            note_references.append(
+                f"- Task {task.id} '{task.title}': note_id={task.note_id}"
+            )
+    
+    notes_section = "\n".join(note_references) if note_references else "- No task notes available"
+    
+    read_template = json.dumps({"action": "read", "note_id": "<note_id>"}, ensure_ascii=False)
+    create_conclusion_template = json.dumps(
+        {
+            "action": "create",
+            "title": f"Research Report: {state.research_topic}",
+            "note_type": "conclusion",
+            "tags": ["deep_research", "report"],
+            "content": "Please summarize the final report highlights here",
+        },
+        ensure_ascii=False,
+    )
+    
+    prompt = (
+        f"Research topic: {state.research_topic}\n"
+        f"Task overview:\n{''.join(tasks_block)}\n"
+        f"Available task notes:\n{notes_section}\n"
+        f"Please use the format [TOOL_CALL:note:{read_template}] to read each task note, then compile all information to write the report.\n"
+        f"If you need to output a summary conclusion, you can call [TOOL_CALL:note:{create_conclusion_template}] to save report highlights."
+    )
+    
+    messages = [
+        SystemMessage(content=report_writer_instructions.strip()),
+        HumanMessage(content=prompt),
+    ]
+    
+    response = llm.invoke(messages)
+    report_text = response.content.strip()
+    
+    if config.strip_thinking_tokens:
+        report_text = strip_thinking_tokens(report_text)
+    
+    report_text = strip_tool_calls(report_text).strip()
+    
+    return report_text or "Report generation failed, please check input."

backend/src/services/search.py

@@ -0,0 +1,245 @@
+"""Search dispatch helpers using DuckDuckGo and Tavily."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional, Tuple
+
+from config import Configuration
+from utils import (
+    deduplicate_and_format_sources,
+    format_sources,
+    get_config_value,
+)
+
+logger = logging.getLogger(__name__)
+
+MAX_TOKENS_PER_SOURCE = 2000
+
+
+def _search_duckduckgo(query: str, max_results: int = 5) -> dict[str, Any]:
+    """Execute search using DuckDuckGo."""
+    try:
+        from ddgs import DDGS
+        
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=max_results))
+        
+        formatted_results = []
+        for r in results:
+            formatted_results.append({
+                "title": r.get("title", ""),
+                "url": r.get("href", r.get("link", "")),
+                "content": r.get("body", r.get("snippet", "")),
+            })
+        
+        return {
+            "results": formatted_results,
+            "backend": "duckduckgo",
+            "answer": None,
+            "notices": [],
+        }
+    except Exception as e:
+        logger.exception("DuckDuckGo search failed: %s", e)
+        return {
+            "results": [],
+            "backend": "duckduckgo",
+            "answer": None,
+            "notices": [f"Search failed: {str(e)}"],
+        }
+
+
+def _search_tavily(query: str, max_results: int = 5) -> dict[str, Any]:
+    """Execute search using Tavily API."""
+    try:
+        import os
+        from tavily import TavilyClient
+        
+        api_key = os.getenv("TAVILY_API_KEY")
+        if not api_key:
+            return {
+                "results": [],
+                "backend": "tavily",
+                "answer": None,
+                "notices": ["Missing TAVILY_API_KEY environment variable"],
+            }
+        
+        client = TavilyClient(api_key=api_key)
+        response = client.search(query, max_results=max_results)
+        
+        formatted_results = []
+        for r in response.get("results", []):
+            formatted_results.append({
+                "title": r.get("title", ""),
+                "url": r.get("url", ""),
+                "content": r.get("content", ""),
+                "raw_content": r.get("raw_content"),
+            })
+        
+        return {
+            "results": formatted_results,
+            "backend": "tavily",
+            "answer": response.get("answer"),
+            "notices": [],
+        }
+    except Exception as e:
+        logger.exception("Tavily search failed: %s", e)
+        return {
+            "results": [],
+            "backend": "tavily",
+            "answer": None,
+            "notices": [f"Search failed: {str(e)}"],
+        }
+
+
+def _search_perplexity(query: str, max_results: int = 5) -> dict[str, Any]:
+    """Execute search using Perplexity API."""
+    try:
+        import os
+        from openai import OpenAI
+        
+        api_key = os.getenv("PERPLEXITY_API_KEY")
+        if not api_key:
+            return {
+                "results": [],
+                "backend": "perplexity",
+                "answer": None,
+                "notices": ["Missing PERPLEXITY_API_KEY environment variable"],
+            }
+        
+        client = OpenAI(api_key=api_key, base_url="https://api.perplexity.ai")
+        
+        response = client.chat.completions.create(
+            model="llama-3.1-sonar-small-128k-online",
+            messages=[{"role": "user", "content": query}],
+        )
+        
+        answer = response.choices[0].message.content if response.choices else None
+        
+        # Perplexity returns answer text, not structured results
+        return {
+            "results": [{
+                "title": "Perplexity Answer",
+                "url": "",
+                "content": answer or "",
+            }] if answer else [],
+            "backend": "perplexity",
+            "answer": answer,
+            "notices": [],
+        }
+    except Exception as e:
+        logger.exception("Perplexity search failed: %s", e)
+        return {
+            "results": [],
+            "backend": "perplexity",
+            "answer": None,
+            "notices": [f"Search failed: {str(e)}"],
+        }
+
+
+def _search_searxng(query: str, max_results: int = 5, base_url: str = "http://localhost:8888") -> dict[str, Any]:
+    """Execute search using SearXNG instance."""
+    try:
+        import requests
+        
+        params = {
+            "q": query,
+            "format": "json",
+            "engines": "google,bing,duckduckgo",
+        }
+        
+        response = requests.get(f"{base_url}/search", params=params, timeout=30)
+        response.raise_for_status()
+        data = response.json()
+        
+        formatted_results = []
+        for r in data.get("results", [])[:max_results]:
+            formatted_results.append({
+                "title": r.get("title", ""),
+                "url": r.get("url", ""),
+                "content": r.get("content", ""),
+            })
+        
+        return {
+            "results": formatted_results,
+            "backend": "searxng",
+            "answer": None,
+            "notices": [],
+        }
+    except Exception as e:
+        logger.exception("SearXNG search failed: %s", e)
+        return {
+            "results": [],
+            "backend": "searxng",
+            "answer": None,
+            "notices": [f"Search failed: {str(e)}"],
+        }
+
+
+def dispatch_search(
+    query: str,
+    config: Configuration,
+    loop_count: int,
+) -> Tuple[dict[str, Any] | None, list[str], Optional[str], str]:
+    """Execute configured search backend and normalize response payload."""
+    
+    search_api = get_config_value(config.search_api)
+    max_results = 5
+    
+    try:
+        if search_api == "tavily":
+            payload = _search_tavily(query, max_results)
+        elif search_api == "perplexity":
+            payload = _search_perplexity(query, max_results)
+        elif search_api == "searxng":
+            payload = _search_searxng(query, max_results)
+        elif search_api == "advanced":
+            # Try Tavily first, fall back to DuckDuckGo
+            payload = _search_tavily(query, max_results)
+            if not payload.get("results"):
+                payload = _search_duckduckgo(query, max_results)
+        else:
+            # Default to DuckDuckGo
+            payload = _search_duckduckgo(query, max_results)
+    except Exception as exc:
+        logger.exception("Search backend %s failed: %s", search_api, exc)
+        raise
+    
+    notices = list(payload.get("notices") or [])
+    backend_label = str(payload.get("backend") or search_api)
+    answer_text = payload.get("answer")
+    results = payload.get("results", [])
+    
+    if notices:
+        for notice in notices:
+            logger.info("Search notice (%s): %s", backend_label, notice)
+    
+    logger.info(
+        "Search backend=%s resolved_backend=%s answer=%s results=%s",
+        search_api,
+        backend_label,
+        bool(answer_text),
+        len(results),
+    )
+    
+    return payload, notices, answer_text, backend_label
+
+
+def prepare_research_context(
+    search_result: dict[str, Any] | None,
+    answer_text: Optional[str],
+    config: Configuration,
+) -> tuple[str, str]:
+    """Build structured context and source summary for downstream agents."""
+    
+    sources_summary = format_sources(search_result)
+    context = deduplicate_and_format_sources(
+        search_result or {"results": []},
+        max_tokens_per_source=MAX_TOKENS_PER_SOURCE,
+        fetch_full_page=config.fetch_full_page,
+    )
+    
+    if answer_text:
+        context = f"AI Direct Answer:\n{answer_text}\n\n{context}"
+    
+    return sources_summary, context

backend/src/services/summarizer.py

@@ -0,0 +1,135 @@
+"""Task summarization utilities."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Tuple, Callable
+
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, SystemMessage
+
+from models import SummaryState, TodoItem
+from config import Configuration
+from utils import strip_thinking_tokens
+from services.notes import build_note_guidance
+from services.text_processing import strip_tool_calls
+from prompts import task_summarizer_instructions
+
+
+def summarize_task(
+    llm: ChatOpenAI,
+    state: SummaryState,
+    task: TodoItem,
+    context: str,
+    config: Configuration,
+) -> str:
+    """Generate a task-specific summary using the LLM."""
+    
+    prompt = _build_prompt(state, task, context)
+    
+    messages = [
+        SystemMessage(content=task_summarizer_instructions.strip()),
+        HumanMessage(content=prompt),
+    ]
+    
+    response = llm.invoke(messages)
+    summary_text = response.content.strip()
+    
+    if config.strip_thinking_tokens:
+        summary_text = strip_thinking_tokens(summary_text)
+    
+    summary_text = strip_tool_calls(summary_text).strip()
+    
+    return summary_text or "No information available"
+
+
+def stream_task_summary(
+    llm: ChatOpenAI,
+    state: SummaryState,
+    task: TodoItem,
+    context: str,
+    config: Configuration,
+) -> Tuple[Iterator[str], Callable[[], str]]:
+    """Stream the summary text for a task while collecting full output."""
+    
+    prompt = _build_prompt(state, task, context)
+    remove_thinking = config.strip_thinking_tokens
+    raw_buffer = ""
+    visible_output = ""
+    emit_index = 0
+    
+    messages = [
+        SystemMessage(content=task_summarizer_instructions.strip()),
+        HumanMessage(content=prompt),
+    ]
+    
+    def flush_visible() -> Iterator[str]:
+        nonlocal emit_index, raw_buffer
+        while True:
+            start = raw_buffer.find("<think>", emit_index)
+            if start == -1:
+                if emit_index < len(raw_buffer):
+                    segment = raw_buffer[emit_index:]
+                    emit_index = len(raw_buffer)
+                    if segment:
+                        yield segment
+                break
+            
+            if start > emit_index:
+                segment = raw_buffer[emit_index:start]
+                emit_index = start
+                if segment:
+                    yield segment
+            
+            end = raw_buffer.find("</think>", start)
+            if end == -1:
+                break
+            emit_index = end + len("</think>")
+    
+    def generator() -> Iterator[str]:
+        nonlocal raw_buffer, visible_output, emit_index
+        try:
+            for chunk in llm.stream(messages):
+                chunk_text = chunk.content
+                if not chunk_text:
+                    continue
+                raw_buffer += chunk_text
+                if remove_thinking:
+                    for segment in flush_visible():
+                        visible_output += segment
+                        if segment:
+                            yield segment
+                else:
+                    visible_output += chunk_text
+                    if chunk_text:
+                        yield chunk_text
+        finally:
+            if remove_thinking:
+                for segment in flush_visible():
+                    visible_output += segment
+                    if segment:
+                        yield segment
+    
+    def get_summary() -> str:
+        if remove_thinking:
+            cleaned = strip_thinking_tokens(visible_output)
+        else:
+            cleaned = visible_output
+        
+        return strip_tool_calls(cleaned).strip()
+    
+    return generator(), get_summary
+
+
+def _build_prompt(state: SummaryState, task: TodoItem, context: str) -> str:
+    """Construct the summarization prompt shared by both modes."""
+    
+    return (
+        f"Task topic: {state.research_topic}\n"
+        f"Task name: {task.title}\n"
+        f"Task objective: {task.intent}\n"
+        f"Search query: {task.query}\n"
+        f"Task context:\n{context}\n"
+        f"{build_note_guidance(task)}\n"
+        "Please follow the above collaboration requirements to sync notes first, then return a user-facing Markdown summary (still following the task summary template)."
+    )

backend/src/services/text_processing.py

@@ -0,0 +1,16 @@
+"""Utility helpers for normalizing agent generated text."""
+
+from __future__ import annotations
+
+import re
+
+
+def strip_tool_calls(text: str) -> str:
+    """Remove tool call markers from text."""
+
+    if not text:
+        return text
+
+    pattern = re.compile(r"\[TOOL_CALL:[^\]]+\]")
+    return pattern.sub("", text)
+

backend/src/services/tool_events.py

@@ -0,0 +1,215 @@
+"""Utility for collecting and exposing tool call events."""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from threading import Lock
+from typing import Any, Callable, Optional
+
+from models import SummaryState, TodoItem
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ToolCallEvent:
+    """Internal representation of a tool call event."""
+
+    id: int
+    agent: str
+    tool: str
+    raw_parameters: str
+    parsed_parameters: dict[str, Any]
+    result: str
+    task_id: Optional[int]
+    note_id: Optional[str]
+
+
+class ToolCallTracker:
+    """Collects tool call events and converts them to SSE payloads."""
+
+    def __init__(self, notes_workspace: Optional[str]) -> None:
+        self._notes_workspace = notes_workspace
+        self._events: list[ToolCallEvent] = []
+        self._cursor = 0
+        self._lock = Lock()
+        self._event_sink: Optional[Callable[[dict[str, Any]], None]] = None
+
+    def record(self, payload: dict[str, Any]) -> None:
+        """Record a tool call event for logging and frontend display."""
+
+        agent_name = str(payload.get("agent_name") or payload.get("agent") or "unknown")
+        tool_name = str(payload.get("tool_name") or payload.get("tool") or "unknown")
+        raw_parameters = str(payload.get("raw_parameters") or "")
+        parsed_parameters = payload.get("parsed_parameters") or payload.get("parameters") or {}
+        result_text = str(payload.get("result") or "")
+
+        if not isinstance(parsed_parameters, dict):
+            parsed_parameters = {}
+
+        task_id = self._infer_task_id(parsed_parameters)
+        note_id: Optional[str] = payload.get("note_id")
+
+        if tool_name == "note" and note_id is None:
+            note_id = parsed_parameters.get("note_id")
+            if note_id is None:
+                note_id = self._extract_note_id(result_text)
+
+        event = ToolCallEvent(
+            id=len(self._events) + 1,
+            agent=agent_name,
+            tool=tool_name,
+            raw_parameters=raw_parameters,
+            parsed_parameters=parsed_parameters,
+            result=result_text,
+            task_id=task_id,
+            note_id=note_id,
+        )
+
+        with self._lock:
+            self._events.append(event)
+
+        logger.info(
+            "Tool call recorded: agent=%s tool=%s task_id=%s note_id=%s parsed_parameters=%s",
+            agent_name,
+            tool_name,
+            task_id,
+            note_id,
+            parsed_parameters,
+        )
+
+        sink = self._event_sink
+        if sink:
+            sink(self._build_payload(event, step=None))
+
+    # ------------------------------------------------------------------
+    # Draining helpers
+    # ------------------------------------------------------------------
+    def drain(self, state: Optional[SummaryState] = None, *, step: Optional[int] = None) -> list[dict[str, Any]]:
+        """Extract unconsumed tool call events and sync task note_ids."""
+
+        with self._lock:
+            if self._cursor >= len(self._events):
+                return []
+            new_events = self._events[self._cursor :]
+            self._cursor = len(self._events)
+
+        if state and state.todo_items:
+            for event in new_events:
+                task_id = event.task_id
+                note_id = event.note_id
+                if task_id is None or not note_id:
+                    continue
+                self._attach_note_to_task(state.todo_items, task_id, note_id)
+
+        payloads: list[dict[str, Any]] = []
+        for event in new_events:
+            payload = self._build_payload(event, step=step)
+            payloads.append(payload)
+
+        return payloads
+
+    def reset(self) -> None:
+        """Clear recorded events."""
+
+        with self._lock:
+            self._events.clear()
+            self._cursor = 0
+
+    def as_dicts(self) -> list[dict[str, Any]]:
+        """Expose a snapshot of raw events for backwards compatibility."""
+
+        with self._lock:
+            return [
+                {
+                    "id": event.id,
+                    "agent": event.agent,
+                    "tool": event.tool,
+                    "raw_parameters": event.raw_parameters,
+                    "parsed_parameters": event.parsed_parameters,
+                    "result": event.result,
+                    "task_id": event.task_id,
+                    "note_id": event.note_id,
+                }
+                for event in self._events
+            ]
+
+    def set_event_sink(self, sink: Optional[Callable[[dict[str, Any]], None]]) -> None:
+        """Register a callback for immediate tool event notifications."""
+
+        self._event_sink = sink
+
+    def _build_payload(self, event: ToolCallEvent, step: Optional[int]) -> dict[str, Any]:
+        payload = {
+            "type": "tool_call",
+            "event_id": event.id,
+            "agent": event.agent,
+            "tool": event.tool,
+            "parameters": event.parsed_parameters,
+            "result": event.result,
+            "task_id": event.task_id,
+            "note_id": event.note_id,
+        }
+        if event.note_id and self._notes_workspace:
+            note_path = Path(self._notes_workspace) / f"{event.note_id}.md"
+            payload["note_path"] = str(note_path)
+        if step is not None:
+            payload["step"] = step
+        return payload
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+    def _attach_note_to_task(self, tasks: list[TodoItem], task_id: int, note_id: str) -> None:
+        """Update matching TODO item with note metadata."""
+
+        for task in tasks:
+            if task.id != task_id:
+                continue
+
+            if task.note_id != note_id:
+                task.note_id = note_id
+                if self._notes_workspace:
+                    task.note_path = str(Path(self._notes_workspace) / f"{note_id}.md")
+            elif task.note_path is None and self._notes_workspace:
+                task.note_path = str(Path(self._notes_workspace) / f"{note_id}.md")
+            break
+
+    def _infer_task_id(self, parameters: dict[str, Any]) -> Optional[int]:
+        """Attempt to infer task_id from tool parameters."""
+
+        if not parameters:
+            return None
+
+        if "task_id" in parameters:
+            try:
+                return int(parameters["task_id"])
+            except (TypeError, ValueError):
+                pass
+
+        tags = parameters.get("tags")
+        if isinstance(tags, list):
+            for tag in tags:
+                match = re.search(r"task_(\d+)", str(tag))
+                if match:
+                    return int(match.group(1))
+
+        title = parameters.get("title")
+        if isinstance(title, str):
+            match = re.search(r"Task\s*(\d+)", title)
+            if match:
+                return int(match.group(1))
+
+        return None
+
+    def _extract_note_id(self, response: str) -> Optional[str]:
+        if not response:
+            return None
+
+        match = re.search(r"ID:\s*([^\n]+)", response)
+        if match:
+            return match.group(1).strip()
+        return None

backend/src/utils.py

@@ -0,0 +1,84 @@
+"""Utility helpers shared across deep researcher services."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Union
+
+CHARS_PER_TOKEN = 4
+
+logger = logging.getLogger(__name__)
+
+
+def get_config_value(value: Any) -> str:
+    """Return configuration value as plain string."""
+
+    return value if isinstance(value, str) else value.value
+
+
+def strip_thinking_tokens(text: str) -> str:
+    """Remove ``<think>`` sections from model responses."""
+
+    while "<think>" in text and "</think>" in text:
+        start = text.find("<think>")
+        end = text.find("</think>") + len("</think>")
+        text = text[:start] + text[end:]
+    return text
+
+
+def deduplicate_and_format_sources(
+    search_response: Dict[str, Any] | List[Dict[str, Any]],
+    max_tokens_per_source: int,
+    *,
+    fetch_full_page: bool = False,
+) -> str:
+    """Format and deduplicate search results for downstream prompting."""
+
+    if isinstance(search_response, dict):
+        sources_list = search_response.get("results", [])
+    else:
+        sources_list = search_response
+
+    unique_sources: dict[str, Dict[str, Any]] = {}
+    for source in sources_list:
+        url = source.get("url")
+        if not url:
+            continue
+        if url not in unique_sources:
+            unique_sources[url] = source
+
+    formatted_parts: List[str] = []
+    for source in unique_sources.values():
+        title = source.get("title") or source.get("url", "")
+        content = source.get("content", "")
+        formatted_parts.append(f"Source: {title}\n\n")
+        formatted_parts.append(f"URL: {source.get('url', '')}\n\n")
+        formatted_parts.append(f"Content: {content}\n\n")
+
+        if fetch_full_page:
+            raw_content = source.get("raw_content")
+            if raw_content is None:
+                logger.debug("raw_content missing for %s", source.get("url", ""))
+                raw_content = ""
+            char_limit = max_tokens_per_source * CHARS_PER_TOKEN
+            if len(raw_content) > char_limit:
+                raw_content = f"{raw_content[:char_limit]}... [truncated]"
+            formatted_parts.append(
+                f"Full content limited to {max_tokens_per_source} tokens: {raw_content}\n\n"
+            )
+
+    return "".join(formatted_parts).strip()
+
+
+def format_sources(search_results: Dict[str, Any] | None) -> str:
+    """Return bullet list summarising search sources."""
+
+    if not search_results:
+        return ""
+
+    results = search_results.get("results", [])
+    return "\n".join(
+        f"* {item.get('title', item.get('url', ''))} : {item.get('url', '')}"
+        for item in results
+        if item.get("url")
+    )

frontend/.gitignore

@@ -0,0 +1,3 @@
+node_modules
+dist
+.DS_Store

frontend/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>HelloAgents Deep Research Assistant</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

frontend/package-lock.json

@@ -0,0 +1,1758 @@
+{
+  "name": "helloagents-deepresearch-frontend",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "helloagents-deepresearch-frontend",
+      "version": "0.1.0",
+      "dependencies": {
+        "axios": "^1.7.9",
+        "vue": "^3.5.13"
+      },
+      "devDependencies": {
+        "@types/node": "^22.10.5",
+        "@vitejs/plugin-vue": "^5.2.1",
+        "typescript": "^5.7.3",
+        "vite": "^6.0.7",
+        "vue-tsc": "^2.2.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.28.4",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.4.tgz",
+      "integrity": "sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.4"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.28.4",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.4.tgz",
+      "integrity": "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.11.tgz",
+      "integrity": "sha512-Xt1dOL13m8u0WE8iplx9Ibbm+hFAO0GsU2P34UNoDGvZYkY8ifSiy6Zuc1lYxfG7svWE2fzqCUmFp5HCn51gJg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.11.tgz",
+      "integrity": "sha512-uoa7dU+Dt3HYsethkJ1k6Z9YdcHjTrSb5NUy66ZfZaSV8hEYGD5ZHbEMXnqLFlbBflLsl89Zke7CAdDJ4JI+Gg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.11.tgz",
+      "integrity": "sha512-9slpyFBc4FPPz48+f6jyiXOx/Y4v34TUeDDXJpZqAWQn/08lKGeD8aDp9TMn9jDz2CiEuHwfhRmGBvpnd/PWIQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.11.tgz",
+      "integrity": "sha512-Sgiab4xBjPU1QoPEIqS3Xx+R2lezu0LKIEcYe6pftr56PqPygbB7+szVnzoShbx64MUupqoE0KyRlN7gezbl8g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.11.tgz",
+      "integrity": "sha512-VekY0PBCukppoQrycFxUqkCojnTQhdec0vevUL/EDOCnXd9LKWqD/bHwMPzigIJXPhC59Vd1WFIL57SKs2mg4w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.11.tgz",
+      "integrity": "sha512-+hfp3yfBalNEpTGp9loYgbknjR695HkqtY3d3/JjSRUyPg/xd6q+mQqIb5qdywnDxRZykIHs3axEqU6l1+oWEQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.11.tgz",
+      "integrity": "sha512-CmKjrnayyTJF2eVuO//uSjl/K3KsMIeYeyN7FyDBjsR3lnSJHaXlVoAK8DZa7lXWChbuOk7NjAc7ygAwrnPBhA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.11.tgz",
+      "integrity": "sha512-Dyq+5oscTJvMaYPvW3x3FLpi2+gSZTCE/1ffdwuM6G1ARang/mb3jvjxs0mw6n3Lsw84ocfo9CrNMqc5lTfGOw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.11.tgz",
+      "integrity": "sha512-TBMv6B4kCfrGJ8cUPo7vd6NECZH/8hPpBHHlYI3qzoYFvWu2AdTvZNuU/7hsbKWqu/COU7NIK12dHAAqBLLXgw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.11.tgz",
+      "integrity": "sha512-Qr8AzcplUhGvdyUF08A1kHU3Vr2O88xxP0Tm8GcdVOUm25XYcMPp2YqSVHbLuXzYQMf9Bh/iKx7YPqECs6ffLA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.11.tgz",
+      "integrity": "sha512-TmnJg8BMGPehs5JKrCLqyWTVAvielc615jbkOirATQvWWB1NMXY77oLMzsUjRLa0+ngecEmDGqt5jiDC6bfvOw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.11.tgz",
+      "integrity": "sha512-DIGXL2+gvDaXlaq8xruNXUJdT5tF+SBbJQKbWy/0J7OhU8gOHOzKmGIlfTTl6nHaCOoipxQbuJi7O++ldrxgMw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.11.tgz",
+      "integrity": "sha512-Osx1nALUJu4pU43o9OyjSCXokFkFbyzjXb6VhGIJZQ5JZi8ylCQ9/LFagolPsHtgw6himDSyb5ETSfmp4rpiKQ==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.11.tgz",
+      "integrity": "sha512-nbLFgsQQEsBa8XSgSTSlrnBSrpoWh7ioFDUmwo158gIm5NNP+17IYmNWzaIzWmgCxq56vfr34xGkOcZ7jX6CPw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.11.tgz",
+      "integrity": "sha512-HfyAmqZi9uBAbgKYP1yGuI7tSREXwIb438q0nqvlpxAOs3XnZ8RsisRfmVsgV486NdjD7Mw2UrFSw51lzUk1ww==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.11.tgz",
+      "integrity": "sha512-HjLqVgSSYnVXRisyfmzsH6mXqyvj0SA7pG5g+9W7ESgwA70AXYNpfKBqh1KbTxmQVaYxpzA/SvlB9oclGPbApw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.11.tgz",
+      "integrity": "sha512-HSFAT4+WYjIhrHxKBwGmOOSpphjYkcswF449j6EjsjbinTZbp8PJtjsVK1XFJStdzXdy/jaddAep2FGY+wyFAQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.11.tgz",
+      "integrity": "sha512-hr9Oxj1Fa4r04dNpWr3P8QKVVsjQhqrMSUzZzf+LZcYjZNqhA3IAfPQdEh1FLVUJSiu6sgAwp3OmwBfbFgG2Xg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.11.tgz",
+      "integrity": "sha512-u7tKA+qbzBydyj0vgpu+5h5AeudxOAGncb8N6C9Kh1N4n7wU1Xw1JDApsRjpShRpXRQlJLb9wY28ELpwdPcZ7A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.11.tgz",
+      "integrity": "sha512-Qq6YHhayieor3DxFOoYM1q0q1uMFYb7cSpLD2qzDSvK1NAvqFi8Xgivv0cFC6J+hWVw2teCYltyy9/m/14ryHg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.11.tgz",
+      "integrity": "sha512-CN+7c++kkbrckTOz5hrehxWN7uIhFFlmS/hqziSFVWpAzpWrQoAG4chH+nN3Be+Kzv/uuo7zhX716x3Sn2Jduw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.11.tgz",
+      "integrity": "sha512-rOREuNIQgaiR+9QuNkbkxubbp8MSO9rONmwP5nKncnWJ9v5jQ4JxFnLu4zDSRPf3x4u+2VN4pM4RdyIzDty/wQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.11.tgz",
+      "integrity": "sha512-nq2xdYaWxyg9DcIyXkZhcYulC6pQ2FuCgem3LI92IwMgIZ69KHeY8T4Y88pcwoLIjbed8n36CyKoYRDygNSGhA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.11.tgz",
+      "integrity": "sha512-3XxECOWJq1qMZ3MN8srCJ/QfoLpL+VaxD/WfNRm1O3B4+AZ/BnLVgFbUV3eiRYDMXetciH16dwPbbHqwe1uU0Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.11.tgz",
+      "integrity": "sha512-3ukss6gb9XZ8TlRyJlgLn17ecsK4NSQTmdIXRASVsiS2sQ6zPPZklNJT5GR5tE/MUarymmy8kCEf5xPCNCqVOA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.11.tgz",
+      "integrity": "sha512-D7Hpz6A2L4hzsRpPaCYkQnGOotdUpDzSGRIv9I+1ITdHROSFUWW95ZPZWQmGka1Fg7W3zFJowyn9WGwMJ0+KPA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.52.5.tgz",
+      "integrity": "sha512-8c1vW4ocv3UOMp9K+gToY5zL2XiiVw3k7f1ksf4yO1FlDFQ1C2u72iACFnSOceJFsWskc2WZNqeRhFRPzv+wtQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.52.5.tgz",
+      "integrity": "sha512-mQGfsIEFcu21mvqkEKKu2dYmtuSZOBMmAl5CFlPGLY94Vlcm+zWApK7F/eocsNzp8tKmbeBP8yXyAbx0XHsFNA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.52.5.tgz",
+      "integrity": "sha512-takF3CR71mCAGA+v794QUZ0b6ZSrgJkArC+gUiG6LB6TQty9T0Mqh3m2ImRBOxS2IeYBo4lKWIieSvnEk2OQWA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.52.5.tgz",
+      "integrity": "sha512-W901Pla8Ya95WpxDn//VF9K9u2JbocwV/v75TE0YIHNTbhqUTv9w4VuQ9MaWlNOkkEfFwkdNhXgcLqPSmHy0fA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.52.5.tgz",
+      "integrity": "sha512-QofO7i7JycsYOWxe0GFqhLmF6l1TqBswJMvICnRUjqCx8b47MTo46W8AoeQwiokAx3zVryVnxtBMcGcnX12LvA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.52.5.tgz",
+      "integrity": "sha512-jr21b/99ew8ujZubPo9skbrItHEIE50WdV86cdSoRkKtmWa+DDr6fu2c/xyRT0F/WazZpam6kk7IHBerSL7LDQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.52.5.tgz",
+      "integrity": "sha512-PsNAbcyv9CcecAUagQefwX8fQn9LQ4nZkpDboBOttmyffnInRy8R8dSg6hxxl2Re5QhHBf6FYIDhIj5v982ATQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.52.5.tgz",
+      "integrity": "sha512-Fw4tysRutyQc/wwkmcyoqFtJhh0u31K+Q6jYjeicsGJJ7bbEq8LwPWV/w0cnzOqR2m694/Af6hpFayLJZkG2VQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.52.5.tgz",
+      "integrity": "sha512-a+3wVnAYdQClOTlyapKmyI6BLPAFYs0JM8HRpgYZQO02rMR09ZcV9LbQB+NL6sljzG38869YqThrRnfPMCDtZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.52.5.tgz",
+      "integrity": "sha512-AvttBOMwO9Pcuuf7m9PkC1PUIKsfaAJ4AYhy944qeTJgQOqJYJ9oVl2nYgY7Rk0mkbsuOpCAYSs6wLYB2Xiw0Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.52.5.tgz",
+      "integrity": "sha512-DkDk8pmXQV2wVrF6oq5tONK6UHLz/XcEVow4JTTerdeV1uqPeHxwcg7aFsfnSm9L+OO8WJsWotKM2JJPMWrQtA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.52.5.tgz",
+      "integrity": "sha512-W/b9ZN/U9+hPQVvlGwjzi+Wy4xdoH2I8EjaCkMvzpI7wJUs8sWJ03Rq96jRnHkSrcHTpQe8h5Tg3ZzUPGauvAw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.52.5.tgz",
+      "integrity": "sha512-sjQLr9BW7R/ZiXnQiWPkErNfLMkkWIoCz7YMn27HldKsADEKa5WYdobaa1hmN6slu9oWQbB6/jFpJ+P2IkVrmw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.52.5.tgz",
+      "integrity": "sha512-hq3jU/kGyjXWTvAh2awn8oHroCbrPm8JqM7RUpKjalIRWWXE01CQOf/tUNWNHjmbMHg/hmNCwc/Pz3k1T/j/Lg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.52.5.tgz",
+      "integrity": "sha512-gn8kHOrku8D4NGHMK1Y7NA7INQTRdVOntt1OCYypZPRt6skGbddska44K8iocdpxHTMMNui5oH4elPH4QOLrFQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.52.5.tgz",
+      "integrity": "sha512-hXGLYpdhiNElzN770+H2nlx+jRog8TyynpTVzdlc6bndktjKWyZyiCsuDAlpd+j+W+WNqfcyAWz9HxxIGfZm1Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.52.5.tgz",
+      "integrity": "sha512-arCGIcuNKjBoKAXD+y7XomR9gY6Mw7HnFBv5Rw7wQRvwYLR7gBAgV7Mb2QTyjXfTveBNFAtPt46/36vV9STLNg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.52.5.tgz",
+      "integrity": "sha512-QoFqB6+/9Rly/RiPjaomPLmR/13cgkIGfA40LHly9zcH1S0bN2HVFYk3a1eAyHQyjs3ZJYlXvIGtcCs5tko9Cw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.52.5.tgz",
+      "integrity": "sha512-w0cDWVR6MlTstla1cIfOGyl8+qb93FlAVutcor14Gf5Md5ap5ySfQ7R9S/NjNaMLSFdUnKGEasmVnu3lCMqB7w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.52.5.tgz",
+      "integrity": "sha512-Aufdpzp7DpOTULJCuvzqcItSGDH73pF3ko/f+ckJhxQyHtp67rHw3HMNxoIdDMUITJESNE6a8uh4Lo4SLouOUg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.52.5.tgz",
+      "integrity": "sha512-UGBUGPFp1vkj6p8wCRraqNhqwX/4kNQPS57BCFc8wYh0g94iVIW33wJtQAx3G7vrjjNtRaxiMUylM0ktp/TRSQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.52.5.tgz",
+      "integrity": "sha512-TAcgQh2sSkykPRWLrdyy2AiceMckNf5loITqXxFI5VuQjS5tSuw3WlwdN8qv8vzjLAUTvYaH/mVjSFpbkFbpTg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "22.18.12",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.18.12.tgz",
+      "integrity": "sha512-BICHQ67iqxQGFSzfCFTT7MRQ5XcBjG5aeKh5Ok38UBbPe5fxTyE+aHFxwVrGyr8GNlqFMLKD1D3P2K/1ks8tog==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@vitejs/plugin-vue": {
+      "version": "5.2.4",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz",
+      "integrity": "sha512-7Yx/SXSOcQq5HiiV3orevHUFn+pmMB4cgbEkDYgnkUWb0WfeQ/wa2yFv6D5ICiCQOVpjA7vYDXrC7AGO8yjDHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^5.0.0 || ^6.0.0",
+        "vue": "^3.2.25"
+      }
+    },
+    "node_modules/@volar/language-core": {
+      "version": "2.4.15",
+      "resolved": "https://registry.npmjs.org/@volar/language-core/-/language-core-2.4.15.tgz",
+      "integrity": "sha512-3VHw+QZU0ZG9IuQmzT68IyN4hZNd9GchGPhbD9+pa8CVv7rnoOZwo7T8weIbrRmihqy3ATpdfXFnqRrfPVK6CA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/source-map": "2.4.15"
+      }
+    },
+    "node_modules/@volar/source-map": {
+      "version": "2.4.15",
+      "resolved": "https://registry.npmjs.org/@volar/source-map/-/source-map-2.4.15.tgz",
+      "integrity": "sha512-CPbMWlUN6hVZJYGcU/GSoHu4EnCHiLaXI9n8c9la6RaI9W5JHX+NqG+GSQcB0JdC2FIBLdZJwGsfKyBB71VlTg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@volar/typescript": {
+      "version": "2.4.15",
+      "resolved": "https://registry.npmjs.org/@volar/typescript/-/typescript-2.4.15.tgz",
+      "integrity": "sha512-2aZ8i0cqPGjXb4BhkMsPYDkkuc2ZQ6yOpqwAuNwUoncELqoy5fRgOQtLR9gB0g902iS0NAkvpIzs27geVyVdPg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/language-core": "2.4.15",
+        "path-browserify": "^1.0.1",
+        "vscode-uri": "^3.0.8"
+      }
+    },
+    "node_modules/@vue/compiler-core": {
+      "version": "3.5.22",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.22.tgz",
+      "integrity": "sha512-jQ0pFPmZwTEiRNSb+i9Ow/I/cHv2tXYqsnHKKyCQ08irI2kdF5qmYedmF8si8mA7zepUFmJ2hqzS8CQmNOWOkQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.28.4",
+        "@vue/shared": "3.5.22",
+        "entities": "^4.5.0",
+        "estree-walker": "^2.0.2",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/@vue/compiler-dom": {
+      "version": "3.5.22",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.22.tgz",
+      "integrity": "sha512-W8RknzUM1BLkypvdz10OVsGxnMAuSIZs9Wdx1vzA3mL5fNMN15rhrSCLiTm6blWeACwUwizzPVqGJgOGBEN/hA==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-core": "3.5.22",
+        "@vue/shared": "3.5.22"
+      }
+    },
+    "node_modules/@vue/compiler-sfc": {
+      "version": "3.5.22",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.22.tgz",
+      "integrity": "sha512-tbTR1zKGce4Lj+JLzFXDq36K4vcSZbJ1RBu8FxcDv1IGRz//Dh2EBqksyGVypz3kXpshIfWKGOCcqpSbyGWRJQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.28.4",
+        "@vue/compiler-core": "3.5.22",
+        "@vue/compiler-dom": "3.5.22",
+        "@vue/compiler-ssr": "3.5.22",
+        "@vue/shared": "3.5.22",
+        "estree-walker": "^2.0.2",
+        "magic-string": "^0.30.19",
+        "postcss": "^8.5.6",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/@vue/compiler-ssr": {
+      "version": "3.5.22",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.22.tgz",
+      "integrity": "sha512-GdgyLvg4R+7T8Nk2Mlighx7XGxq/fJf9jaVofc3IL0EPesTE86cP/8DD1lT3h1JeZr2ySBvyqKQJgbS54IX1Ww==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.22",
+        "@vue/shared": "3.5.22"
+      }
+    },
+    "node_modules/@vue/compiler-vue2": {
+      "version": "2.7.16",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-vue2/-/compiler-vue2-2.7.16.tgz",
+      "integrity": "sha512-qYC3Psj9S/mfu9uVi5WvNZIzq+xnXMhOwbTFKKDD7b1lhpnn71jXSFdTQ+WsIEk0ONCd7VV2IMm7ONl6tbQ86A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "de-indent": "^1.0.2",
+        "he": "^1.2.0"
+      }
+    },
+    "node_modules/@vue/language-core": {
+      "version": "2.2.12",
+      "resolved": "https://registry.npmjs.org/@vue/language-core/-/language-core-2.2.12.tgz",
+      "integrity": "sha512-IsGljWbKGU1MZpBPN+BvPAdr55YPkj2nB/TBNGNC32Vy2qLG25DYu/NBN2vNtZqdRbTRjaoYrahLrToim2NanA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/language-core": "2.4.15",
+        "@vue/compiler-dom": "^3.5.0",
+        "@vue/compiler-vue2": "^2.7.16",
+        "@vue/shared": "^3.5.0",
+        "alien-signals": "^1.0.3",
+        "minimatch": "^9.0.3",
+        "muggle-string": "^0.4.1",
+        "path-browserify": "^1.0.1"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vue/reactivity": {
+      "version": "3.5.22",
+      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.22.tgz",
+      "integrity": "sha512-f2Wux4v/Z2pqc9+4SmgZC1p73Z53fyD90NFWXiX9AKVnVBEvLFOWCEgJD3GdGnlxPZt01PSlfmLqbLYzY/Fw4A==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/shared": "3.5.22"
+      }
+    },
+    "node_modules/@vue/runtime-core": {
+      "version": "3.5.22",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.22.tgz",
+      "integrity": "sha512-EHo4W/eiYeAzRTN5PCextDUZ0dMs9I8mQ2Fy+OkzvRPUYQEyK9yAjbasrMCXbLNhF7P0OUyivLjIy0yc6VrLJQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.22",
+        "@vue/shared": "3.5.22"
+      }
+    },
+    "node_modules/@vue/runtime-dom": {
+      "version": "3.5.22",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.22.tgz",
+      "integrity": "sha512-Av60jsryAkI023PlN7LsqrfPvwfxOd2yAwtReCjeuugTJTkgrksYJJstg1e12qle0NarkfhfFu1ox2D+cQotww==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.22",
+        "@vue/runtime-core": "3.5.22",
+        "@vue/shared": "3.5.22",
+        "csstype": "^3.1.3"
+      }
+    },
+    "node_modules/@vue/server-renderer": {
+      "version": "3.5.22",
+      "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.22.tgz",
+      "integrity": "sha512-gXjo+ao0oHYTSswF+a3KRHZ1WszxIqO7u6XwNHqcqb9JfyIL/pbWrrh/xLv7jeDqla9u+LK7yfZKHih1e1RKAQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-ssr": "3.5.22",
+        "@vue/shared": "3.5.22"
+      },
+      "peerDependencies": {
+        "vue": "3.5.22"
+      }
+    },
+    "node_modules/@vue/shared": {
+      "version": "3.5.22",
+      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.22.tgz",
+      "integrity": "sha512-F4yc6palwq3TT0u+FYf0Ns4Tfl9GRFURDN2gWG7L1ecIaS/4fCIuFOjMTnCyjsu/OK6vaDKLCrGAa+KvvH+h4w==",
+      "license": "MIT"
+    },
+    "node_modules/alien-signals": {
+      "version": "1.0.13",
+      "resolved": "https://registry.npmjs.org/alien-signals/-/alien-signals-1.0.13.tgz",
+      "integrity": "sha512-OGj9yyTnJEttvzhTUWuscOvtqxq5vrhF7vL9oS0xJ2mK0ItPYP1/y+vCFebfxoEyAz0++1AIwJ5CMr+Fk3nDmg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/axios": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz",
+      "integrity": "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.4",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
+      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
+      "license": "MIT"
+    },
+    "node_modules/de-indent": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/de-indent/-/de-indent-1.0.2.tgz",
+      "integrity": "sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.11",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.11.tgz",
+      "integrity": "sha512-KohQwyzrKTQmhXDW1PjCv3Tyspn9n5GcY2RTDqeORIdIJY8yKIF7sTSopFmn/wpMPW4rdPXI0UE5LJLuq3bx0Q==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.11",
+        "@esbuild/android-arm": "0.25.11",
+        "@esbuild/android-arm64": "0.25.11",
+        "@esbuild/android-x64": "0.25.11",
+        "@esbuild/darwin-arm64": "0.25.11",
+        "@esbuild/darwin-x64": "0.25.11",
+        "@esbuild/freebsd-arm64": "0.25.11",
+        "@esbuild/freebsd-x64": "0.25.11",
+        "@esbuild/linux-arm": "0.25.11",
+        "@esbuild/linux-arm64": "0.25.11",
+        "@esbuild/linux-ia32": "0.25.11",
+        "@esbuild/linux-loong64": "0.25.11",
+        "@esbuild/linux-mips64el": "0.25.11",
+        "@esbuild/linux-ppc64": "0.25.11",
+        "@esbuild/linux-riscv64": "0.25.11",
+        "@esbuild/linux-s390x": "0.25.11",
+        "@esbuild/linux-x64": "0.25.11",
+        "@esbuild/netbsd-arm64": "0.25.11",
+        "@esbuild/netbsd-x64": "0.25.11",
+        "@esbuild/openbsd-arm64": "0.25.11",
+        "@esbuild/openbsd-x64": "0.25.11",
+        "@esbuild/openharmony-arm64": "0.25.11",
+        "@esbuild/sunos-x64": "0.25.11",
+        "@esbuild/win32-arm64": "0.25.11",
+        "@esbuild/win32-ia32": "0.25.11",
+        "@esbuild/win32-x64": "0.25.11"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "license": "MIT"
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.11",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+      "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+      "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/he": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
+      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "he": "bin/he"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.19",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.19.tgz",
+      "integrity": "sha512-2N21sPY9Ws53PZvsEpVtNuSW+ScYbQdp4b9qUaL+9QkHUrGFKo56Lg9Emg5s9V/qrtNBmiR01sYhUOwu3H+VOw==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/muggle-string": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/muggle-string/-/muggle-string-0.4.1.tgz",
+      "integrity": "sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/path-browserify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
+      "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.6",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
+    "node_modules/rollup": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.52.5.tgz",
+      "integrity": "sha512-3GuObel8h7Kqdjt0gxkEzaifHTqLVW56Y/bjN7PSQtkKr0w3V/QYSdt6QWYtd7A1xUtYQigtdUfgj1RvWVtorw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.52.5",
+        "@rollup/rollup-android-arm64": "4.52.5",
+        "@rollup/rollup-darwin-arm64": "4.52.5",
+        "@rollup/rollup-darwin-x64": "4.52.5",
+        "@rollup/rollup-freebsd-arm64": "4.52.5",
+        "@rollup/rollup-freebsd-x64": "4.52.5",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.52.5",
+        "@rollup/rollup-linux-arm-musleabihf": "4.52.5",
+        "@rollup/rollup-linux-arm64-gnu": "4.52.5",
+        "@rollup/rollup-linux-arm64-musl": "4.52.5",
+        "@rollup/rollup-linux-loong64-gnu": "4.52.5",
+        "@rollup/rollup-linux-ppc64-gnu": "4.52.5",
+        "@rollup/rollup-linux-riscv64-gnu": "4.52.5",
+        "@rollup/rollup-linux-riscv64-musl": "4.52.5",
+        "@rollup/rollup-linux-s390x-gnu": "4.52.5",
+        "@rollup/rollup-linux-x64-gnu": "4.52.5",
+        "@rollup/rollup-linux-x64-musl": "4.52.5",
+        "@rollup/rollup-openharmony-arm64": "4.52.5",
+        "@rollup/rollup-win32-arm64-msvc": "4.52.5",
+        "@rollup/rollup-win32-ia32-msvc": "4.52.5",
+        "@rollup/rollup-win32-x64-gnu": "4.52.5",
+        "@rollup/rollup-win32-x64-msvc": "4.52.5",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "devOptional": true,
+      "license": "Apache-2.0",
+      "peer": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vite": {
+      "version": "6.4.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
+      "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vscode-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz",
+      "integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vue": {
+      "version": "3.5.22",
+      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.22.tgz",
+      "integrity": "sha512-toaZjQ3a/G/mYaLSbV+QsQhIdMo9x5rrqIpYRObsJ6T/J+RyCSFwN2LHNVH9v8uIcljDNa3QzPVdv3Y6b9hAJQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.22",
+        "@vue/compiler-sfc": "3.5.22",
+        "@vue/runtime-dom": "3.5.22",
+        "@vue/server-renderer": "3.5.22",
+        "@vue/shared": "3.5.22"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vue-tsc": {
+      "version": "2.2.12",
+      "resolved": "https://registry.npmjs.org/vue-tsc/-/vue-tsc-2.2.12.tgz",
+      "integrity": "sha512-P7OP77b2h/Pmk+lZdJ0YWs+5tJ6J2+uOQPo7tlBnY44QqQSPYvS0qVT4wqDJgwrZaLe47etJLLQRFia71GYITw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/typescript": "2.4.15",
+        "@vue/language-core": "2.2.12"
+      },
+      "bin": {
+        "vue-tsc": "bin/vue-tsc.js"
+      },
+      "peerDependencies": {
+        "typescript": ">=5.0.0"
+      }
+    }
+  }
+}

frontend/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "helloagents-deepresearch-frontend",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vue-tsc --noEmit && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "axios": "^1.7.9",
+    "vue": "^3.5.13"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "@vitejs/plugin-vue": "^5.2.1",
+    "typescript": "^5.7.3",
+    "vite": "^6.0.7",
+    "vue-tsc": "^2.2.0"
+  }
+}

frontend/src/App.vue

@@ -0,0 +1,2304 @@
+<template>
+  <main class="app-shell" :class="{ expanded: isExpanded }">
+    <div class="aurora" aria-hidden="true">
+      <span></span>
+      <span></span>
+      <span></span>
+    </div>
+
+    <!-- Initial state: centered input card -->
+    <div v-if="!isExpanded" class="layout layout-centered">
+      <section class="panel panel-form panel-centered">
+        <header class="panel-head">
+          <div class="logo">
+            <svg viewBox="0 0 24 24" aria-hidden="true">
+              <path
+                d="M12 2.5c-.7 0-1.4.2-2 .6L4.6 7C3.6 7.6 3 8.7 3 9.9v4.2c0 1.2.6 2.3 1.6 2.9l5.4 3.9c1.2.8 2.8.8 4 0l5.4-3.9c1-.7 1.6-1.7 1.6-2.9V9.9c0-1.2-.6-2.3-1.6-2.9L14 3.1a3.6 3.6 0 0 0-2-.6Z"
+              />
+            </svg>
+          </div>
+          <div>
+            <h1>Deep Research Assistant</h1>
+            <p>Combining multi-round intelligent search and summarization, presenting insights and citations in real-time.</p>
+          </div>
+        </header>
+
+        <form class="form" @submit.prevent="handleSubmit">
+          <label class="field">
+            <span>Research Topic</span>
+            <textarea
+              v-model="form.topic"
+              placeholder="e.g., Explore key breakthroughs in multimodal models in 2025"
+              rows="4"
+              required
+            ></textarea>
+          </label>
+
+          <section class="options">
+            <label class="field option">
+              <span>Search Engine</span>
+              <select v-model="form.searchApi">
+                <option value="">Use backend default</option>
+                <option
+                  v-for="option in searchOptions"
+                  :key="option"
+                  :value="option"
+                >
+                  {{ option }}
+                </option>
+              </select>
+            </label>
+          </section>
+
+          <div class="form-actions">
+            <button class="submit" type="submit" :disabled="loading">
+              <span class="submit-label">
+                <svg
+                  v-if="loading"
+                  class="spinner"
+                  viewBox="0 0 24 24"
+                  aria-hidden="true"
+                >
+                  <circle cx="12" cy="12" r="9" stroke-width="3" />
+                </svg>
+                {{ loading ? "Research in progress..." : "Start Research" }}
+              </span>
+            </button>
+            <button
+              v-if="loading"
+              type="button"
+              class="secondary-btn"
+              @click="cancelResearch"
+            >
+              Cancel Research
+            </button>
+          </div>
+        </form>
+
+        <p v-if="error" class="error-chip">
+          <svg viewBox="0 0 20 20" aria-hidden="true">
+            <path
+              d="M10 3.2c-.3 0-.6.2-.8.5L3.4 15c-.4.7.1 1.6.8 1.6h11.6c.7 0 1.2-.9.8-1.6L10.8 3.7c-.2-.3-.5-.5-.8-.5Zm0 4.3c.4 0 .7.3.7.7v4c0 .4-.3.7-.7.7s-.7-.3-.7-.7V8.2c0-.4.3-.7.7-.7Zm0 6.6a1 1 0 1 1 0 2 1 1 0 0 1 0-2Z"
+            />
+          </svg>
+          {{ error }}
+        </p>
+        <p v-else-if="loading" class="hint muted">
+          Collecting clues and evidence, real-time progress shown on the right.
+        </p>
+      </section>
+    </div>
+
+    <!-- Fullscreen state: left-right split layout -->
+    <div v-else class="layout layout-fullscreen">
+      <!-- Left side: Research info -->
+      <aside class="sidebar">
+        <div class="sidebar-header">
+          <button class="back-btn" @click="goBack" :disabled="loading">
+            <svg viewBox="0 0 24 24" width="20" height="20">
+              <path d="M19 12H5M12 19l-7-7 7-7" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
+            </svg>
+            Back
+          </button>
+          <h2>🔍 Deep Research Assistant</h2>
+        </div>
+
+        <div class="research-info">
+          <div class="info-item">
+            <label>Research Topic</label>
+            <p class="topic-display">{{ form.topic }}</p>
+          </div>
+
+          <div class="info-item" v-if="form.searchApi">
+            <label>Search Engine</label>
+            <p>{{ form.searchApi }}</p>
+          </div>
+
+          <div class="info-item" v-if="totalTasks > 0">
+            <label>Research Progress</label>
+            <div class="progress-bar">
+              <div class="progress-fill" :style="{ width: `${(completedTasks / totalTasks) * 100}%` }"></div>
+            </div>
+            <p class="progress-text">{{ completedTasks }} / {{ totalTasks }} tasks completed</p>
+          </div>
+        </div>
+
+        <div class="sidebar-actions">
+          <button class="new-research-btn" @click="startNewResearch">
+            <svg viewBox="0 0 24 24" width="18" height="18">
+              <path d="M12 5v14M5 12h14" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round"/>
+            </svg>
+            Start New Research
+          </button>
+        </div>
+      </aside>
+
+      <!-- Right side: Research results -->
+      <section
+        class="panel panel-result"
+        v-if="todoTasks.length || reportMarkdown || progressLogs.length"
+      >
+        <header class="status-bar">
+          <div class="status-main">
+            <div class="status-chip" :class="{ active: loading }">
+              <span class="dot"></span>
+              {{ loading ? "Research in progress" : "Research completed" }}
+            </div>
+            <span class="status-meta">
+              Task progress: {{ completedTasks }} / {{ totalTasks || todoTasks.length || 1 }}
+              · {{ progressLogs.length }} phase records
+            </span>
+          </div>
+          <div class="status-controls">
+            <button class="secondary-btn" @click="logsCollapsed = !logsCollapsed">
+              {{ logsCollapsed ? "Expand process" : "Collapse process" }}
+            </button>
+          </div>
+        </header>
+
+        <div class="timeline-wrapper" v-show="!logsCollapsed && progressLogs.length">
+          <transition-group name="timeline" tag="ul" class="timeline">
+            <li v-for="(log, index) in progressLogs" :key="`${log}-${index}`">
+              <span class="timeline-node"></span>
+              <p>{{ log }}</p>
+            </li>
+          </transition-group>
+        </div>
+
+        <div class="tasks-section" v-if="todoTasks.length">
+          <aside class="tasks-list">
+            <h3>Task List</h3>
+            <ul>
+              <li
+                v-for="task in todoTasks"
+                :key="task.id"
+                :class="['task-item', { active: task.id === activeTaskId, completed: task.status === 'completed' }]"
+              >
+                <button
+                  type="button"
+                  class="task-button"
+                  @click="activeTaskId = task.id"
+                >
+                  <span class="task-title">{{ task.title }}</span>
+                  <span class="task-status" :class="task.status">
+                    {{ formatTaskStatus(task.status) }}
+                  </span>
+                </button>
+                <p class="task-intent">{{ task.intent }}</p>
+              </li>
+            </ul>
+          </aside>
+
+          <article class="task-detail" v-if="currentTask">
+            <header class="task-header">
+              <div>
+                <h3>{{ currentTaskTitle || "Current Task" }}</h3>
+                <p class="muted" v-if="currentTaskIntent">
+                  {{ currentTaskIntent }}
+                </p>
+              </div>
+              <div class="task-chip-group">
+                <span class="task-label">Query: {{ currentTaskQuery || "" }}</span>
+                <span
+                  v-if="currentTaskNoteId"
+                  class="task-label note-chip"
+                  :title="currentTaskNoteId"
+                >
+                  Note: {{ currentTaskNoteId }}
+                </span>
+                <span
+                  v-if="currentTaskNotePath"
+                  class="task-label note-chip path-chip"
+                  :title="currentTaskNotePath"
+                >
+                  <span class="path-label">Path:</span>
+                  <span class="path-text">{{ currentTaskNotePath }}</span>
+                  <button
+                    class="chip-action"
+                    type="button"
+                    @click="copyNotePath(currentTaskNotePath)"
+                  >
+                    Copy
+                  </button>
+                </span>
+              </div>
+            </header>
+
+            <section v-if="currentTask && currentTask.notices.length" class="task-notices">
+              <h4>System Notices</h4>
+              <ul>
+                <li v-for="(notice, idx) in currentTask.notices" :key="`${notice}-${idx}`">
+                  {{ notice }}
+                </li>
+              </ul>
+            </section>
+
+            <section
+              class="sources-block"
+              :class="{ 'block-highlight': sourcesHighlight }"
+            >
+              <h3>Latest Sources</h3>
+              <template v-if="currentTaskSources.length">
+                <ul class="sources-list">
+                  <li
+                    v-for="(item, index) in currentTaskSources"
+                    :key="`${item.title}-${index}`"
+                    class="source-item"
+                  >
+                    <a
+                      class="source-link"
+                      :href="item.url || '#'"
+                      target="_blank"
+                      rel="noopener noreferrer"
+                    >
+                      {{ item.title || item.url || `Source ${index + 1}` }}
+                    </a>
+                    <div v-if="item.snippet || item.raw" class="source-tooltip">
+                      <p v-if="item.snippet">{{ item.snippet }}</p>
+                      <p v-if="item.raw" class="muted-text">{{ item.raw }}</p>
+                    </div>
+                  </li>
+                </ul>
+              </template>
+              <p v-else class="muted">No sources available</p>
+            </section>
+
+            <section
+              class="summary-block"
+              :class="{ 'block-highlight': summaryHighlight }"
+            >
+              <h3>Task Summary</h3>
+              <pre class="block-pre">{{ currentTaskSummary || "No information available" }}</pre>
+            </section>
+
+            <section
+              class="tools-block"
+              :class="{ 'block-highlight': toolHighlight }"
+              v-if="currentTaskToolCalls.length"
+            >
+              <h3>Tool Call Records</h3>
+              <ul class="tool-list">
+                <li
+                  v-for="entry in currentTaskToolCalls"
+                  :key="`${entry.eventId}-${entry.timestamp}`"
+                  class="tool-entry"
+                >
+                  <div class="tool-entry-header">
+                    <span class="tool-entry-title">
+                      #{{ entry.eventId }} {{ entry.agent }} → {{ entry.tool }}
+                    </span>
+                    <span
+                      v-if="entry.noteId"
+                      class="tool-entry-note"
+                    >
+                      Note: {{ entry.noteId }}
+                    </span>
+                  </div>
+                  <p v-if="entry.notePath" class="tool-entry-path">
+                    Note path:
+                    <button
+                      class="link-btn"
+                      type="button"
+                      @click="copyNotePath(entry.notePath)"
+                    >
+                      Copy
+                    </button>
+                    <span class="path-text">{{ entry.notePath }}</span>
+                  </p>
+                  <p class="tool-subtitle">Parameters</p>
+                  <pre class="tool-pre">{{ formatToolParameters(entry.parameters) }}</pre>
+                  <template v-if="entry.result">
+                    <p class="tool-subtitle">Execution Result</p>
+                    <pre class="tool-pre">{{ formatToolResult(entry.result) }}</pre>
+                  </template>
+                </li>
+              </ul>
+            </section>
+          </article>
+
+          <article class="task-detail" v-else>
+            <p class="muted">Waiting for task planning or execution results.</p>
+          </article>
+        </div>
+
+        <div
+          v-if="reportMarkdown"
+          class="report-block"
+          :class="{ 'block-highlight': reportHighlight }"
+        >
+          <h3>Final Report</h3>
+          <pre class="block-pre">{{ reportMarkdown }}</pre>
+        </div>
+      </section>
+
+    </div>
+  </main>
+</template>
+
+<script lang="ts" setup>
+import { computed, onBeforeUnmount, reactive, ref } from "vue";
+
+import {
+  runResearchStream,
+  type ResearchStreamEvent
+} from "./services/api";
+
+interface SourceItem {
+  title: string;
+  url: string;
+  snippet: string;
+  raw: string;
+}
+
+interface ToolCallLog {
+  eventId: number;
+  agent: string;
+  tool: string;
+  parameters: Record<string, unknown>;
+  result: string;
+  noteId: string | null;
+  notePath: string | null;
+  timestamp: number;
+}
+
+interface TodoTaskView {
+  id: number;
+  title: string;
+  intent: string;
+  query: string;
+  status: string;
+  summary: string;
+  sourcesSummary: string;
+  sourceItems: SourceItem[];
+  notices: string[];
+  noteId: string | null;
+  notePath: string | null;
+  toolCalls: ToolCallLog[];
+}
+
+const form = reactive({
+  topic: "",
+  searchApi: ""
+});
+
+const loading = ref(false);
+const error = ref("");
+const progressLogs = ref<string[]>([]);
+const logsCollapsed = ref(false);
+const isExpanded = ref(false);
+
+const todoTasks = ref<TodoTaskView[]>([]);
+const activeTaskId = ref<number | null>(null);
+const reportMarkdown = ref("");
+
+const summaryHighlight = ref(false);
+const sourcesHighlight = ref(false);
+const reportHighlight = ref(false);
+const toolHighlight = ref(false);
+
+let currentController: AbortController | null = null;
+
+const searchOptions = [
+  "advanced",
+  "duckduckgo",
+  "tavily",
+  "perplexity",
+  "searxng"
+];
+
+const TASK_STATUS_LABEL: Record<string, string> = {
+  pending: "Pending",
+  in_progress: "In Progress",
+  completed: "Completed",
+  skipped: "Skipped"
+};
+
+function formatTaskStatus(status: string): string {
+  return TASK_STATUS_LABEL[status] ?? status;
+}
+
+const totalTasks = computed(() => todoTasks.value.length);
+const completedTasks = computed(() =>
+  todoTasks.value.filter((task) => task.status === "completed").length
+);
+
+const currentTask = computed(() => {
+  if (activeTaskId.value !== null) {
+    return todoTasks.value.find((task) => task.id === activeTaskId.value) ?? null;
+  }
+  return todoTasks.value[0] ?? null;
+});
+
+const currentTaskSources = computed(() => currentTask.value?.sourceItems ?? []);
+const currentTaskSummary = computed(() => currentTask.value?.summary ?? "");
+const currentTaskTitle = computed(() => currentTask.value?.title ?? "");
+const currentTaskIntent = computed(() => currentTask.value?.intent ?? "");
+const currentTaskQuery = computed(() => currentTask.value?.query ?? "");
+const currentTaskNoteId = computed(() => currentTask.value?.noteId ?? "");
+const currentTaskNotePath = computed(() => currentTask.value?.notePath ?? "");
+const currentTaskToolCalls = computed(
+  () => currentTask.value?.toolCalls ?? []
+);
+
+const pulse = (flag: typeof summaryHighlight) => {
+  flag.value = false;
+  requestAnimationFrame(() => {
+    flag.value = true;
+    window.setTimeout(() => {
+      flag.value = false;
+    }, 1200);
+  });
+};
+
+function parseSources(raw: string): SourceItem[] {
+  if (!raw) {
+    return [];
+  }
+
+  const items: SourceItem[] = [];
+  const lines = raw.split("\n");
+
+  let current: SourceItem | null = null;
+  const truncate = (value: string, max = 360) => {
+    const trimmed = value.trim();
+    return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+  };
+
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    const normalized: SourceItem = {
+      title: current.title?.trim() || "",
+      url: current.url?.trim() || "",
+      snippet: current.snippet ? truncate(current.snippet) : "",
+      raw: current.raw ? truncate(current.raw, 420) : ""
+    };
+
+    if (
+      normalized.title ||
+      normalized.url ||
+      normalized.snippet ||
+      normalized.raw
+    ) {
+      if (!normalized.title && normalized.url) {
+        normalized.title = normalized.url;
+      }
+      items.push(normalized);
+    }
+    current = null;
+  };
+
+  const ensureCurrent = () => {
+    if (!current) {
+      current = { title: "", url: "", snippet: "", raw: "" };
+    }
+  };
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+
+    if (/^\*/.test(trimmed) && trimmed.includes(" : ")) {
+      flush();
+      const withoutBullet = trimmed.replace(/^\*\s*/, "");
+      const [titlePart, urlPart] = withoutBullet.split(" : ");
+      current = {
+        title: titlePart?.trim() || "",
+        url: urlPart?.trim() || "",
+        snippet: "",
+        raw: ""
+      };
+      continue;
+    }
+
+    if (/^(Source|Info Source)\s*:/.test(trimmed)) {
+      flush();
+      const [, titlePart = ""] = trimmed.split(/:\s*(.+)/);
+      current = {
+        title: titlePart.trim(),
+        url: "",
+        snippet: "",
+        raw: ""
+      };
+      continue;
+    }
+
+    if (/^URL\s*:/.test(trimmed)) {
+      ensureCurrent();
+      const [, urlPart = ""] = trimmed.split(/:\s*(.+)/);
+      current!.url = urlPart.trim();
+      continue;
+    }
+
+    if (
+      /^(Most relevant content from source|Info Content)\s*:/.test(trimmed)
+    ) {
+      ensureCurrent();
+      const [, contentPart = ""] = trimmed.split(/:\s*(.+)/);
+      current!.snippet = contentPart.trim();
+      continue;
+    }
+
+    if (
+      /^(Full source content limited to|Info content limited to)\s*:/.test(trimmed)
+    ) {
+      ensureCurrent();
+      const [, rawPart = ""] = trimmed.split(/:\s*(.+)/);
+      current!.raw = rawPart.trim();
+      continue;
+    }
+
+    if (/^https?:\/\//.test(trimmed)) {
+      ensureCurrent();
+      if (!current!.url) {
+        current!.url = trimmed;
+        continue;
+      }
+    }
+
+    ensureCurrent();
+    current!.raw = current!.raw ? `${current!.raw}\n${trimmed}` : trimmed;
+  }
+
+  flush();
+  return items;
+}
+
+function extractOptionalString(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+
+function ensureRecord(value: unknown): Record<string, unknown> {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  return {};
+}
+
+function applyNoteMetadata(
+  task: TodoTaskView,
+  payload: Record<string, unknown>
+): void {
+  const noteId = extractOptionalString(payload.note_id);
+  if (noteId) {
+    task.noteId = noteId;
+  }
+  const notePath = extractOptionalString(payload.note_path);
+  if (notePath) {
+    task.notePath = notePath;
+  }
+}
+
+function formatToolParameters(parameters: Record<string, unknown>): string {
+  try {
+    return JSON.stringify(parameters, null, 2);
+  } catch (error) {
+    console.warn("Unable to format tool parameters", error, parameters);
+    return Object.entries(parameters)
+      .map(([key, value]) => `${key}: ${String(value)}`)
+      .join("\n");
+  }
+}
+
+function formatToolResult(result: string): string {
+  const trimmed = result.trim();
+  const limit = 900;
+  if (trimmed.length > limit) {
+    return `${trimmed.slice(0, limit)}…`;
+  }
+  return trimmed;
+}
+
+async function copyNotePath(path: string | null | undefined) {
+  if (!path) {
+    return;
+  }
+
+  try {
+    await navigator.clipboard.writeText(path);
+    progressLogs.value.push(`Note path copied: ${path}`);
+  } catch (error) {
+    console.warn("Unable to copy to clipboard directly", error);
+    window.prompt("Copy the following note path", path);
+    progressLogs.value.push("Please copy the note path manually");
+  }
+}
+
+function resetWorkflowState() {
+  todoTasks.value = [];
+  activeTaskId.value = null;
+  reportMarkdown.value = "";
+  progressLogs.value = [];
+  summaryHighlight.value = false;
+  sourcesHighlight.value = false;
+  reportHighlight.value = false;
+  toolHighlight.value = false;
+  logsCollapsed.value = false;
+}
+
+function findTask(taskId: unknown): TodoTaskView | undefined {
+  const numeric =
+    typeof taskId === "number"
+      ? taskId
+      : typeof taskId === "string"
+      ? Number(taskId)
+      : NaN;
+  if (Number.isNaN(numeric)) {
+    return undefined;
+  }
+  return todoTasks.value.find((task) => task.id === numeric);
+}
+
+function upsertTaskMetadata(task: TodoTaskView, payload: Record<string, unknown>) {
+  if (typeof payload.title === "string" && payload.title.trim()) {
+    task.title = payload.title.trim();
+  }
+  if (typeof payload.intent === "string" && payload.intent.trim()) {
+    task.intent = payload.intent.trim();
+  }
+  if (typeof payload.query === "string" && payload.query.trim()) {
+    task.query = payload.query.trim();
+  }
+}
+
+const handleSubmit = async () => {
+  if (!form.topic.trim()) {
+    error.value = "Please enter a research topic";
+    return;
+  }
+
+  if (currentController) {
+    currentController.abort();
+    currentController = null;
+  }
+
+  loading.value = true;
+  error.value = "";
+  isExpanded.value = true;
+  resetWorkflowState();
+
+  const controller = new AbortController();
+  currentController = controller;
+
+  const payload = {
+    topic: form.topic.trim(),
+    search_api: form.searchApi || undefined
+  };
+
+  try {
+    await runResearchStream(
+      payload,
+      (event: ResearchStreamEvent) => {
+        if (event.type === "status") {
+          const message =
+            typeof event.message === "string" && event.message.trim()
+              ? event.message
+              : "Workflow status update";
+          progressLogs.value.push(message);
+
+          const payload = event as Record<string, unknown>;
+          const task = findTask(payload.task_id);
+          if (task && message) {
+            task.notices.push(message);
+            applyNoteMetadata(task, payload);
+          }
+          return;
+        }
+
+        if (event.type === "todo_list") {
+          const tasks = Array.isArray(event.tasks)
+            ? (event.tasks as Record<string, unknown>[])
+            : [];
+
+          todoTasks.value = tasks.map((item, index) => {
+            const rawId =
+              typeof item.id === "number"
+                ? item.id
+                : typeof item.id === "string"
+                ? Number(item.id)
+                : index + 1;
+            const id = Number.isFinite(rawId) ? Number(rawId) : index + 1;
+            const noteId =
+              typeof item.note_id === "string" && item.note_id.trim()
+                ? item.note_id.trim()
+                : null;
+            const notePath =
+              typeof item.note_path === "string" && item.note_path.trim()
+                ? item.note_path.trim()
+                : null;
+
+            return {
+              id,
+              title:
+                typeof item.title === "string" && item.title.trim()
+                  ? item.title.trim()
+                  : `Task ${id}`,
+              intent:
+                typeof item.intent === "string" && item.intent.trim()
+                  ? item.intent.trim()
+                  : "Explore key information related to the topic",
+              query:
+                typeof item.query === "string" && item.query.trim()
+                  ? item.query.trim()
+                  : form.topic.trim(),
+              status:
+                typeof item.status === "string" && item.status.trim()
+                  ? item.status.trim()
+                  : "pending",
+              summary: "",
+              sourcesSummary: "",
+              sourceItems: [],
+              notices: [],
+              noteId,
+              notePath,
+              toolCalls: []
+            } as TodoTaskView;
+          });
+
+          if (todoTasks.value.length) {
+            activeTaskId.value = todoTasks.value[0].id;
+            progressLogs.value.push("Task list generated");
+          } else {
+            progressLogs.value.push("No task list generated, continuing with default task");
+          }
+          return;
+        }
+
+        if (event.type === "task_status") {
+          const payload = event as Record<string, unknown>;
+          const task = findTask(event.task_id);
+          if (!task) {
+            return;
+          }
+
+          upsertTaskMetadata(task, payload);
+          applyNoteMetadata(task, payload);
+          const status =
+            typeof event.status === "string" && event.status.trim()
+              ? event.status.trim()
+              : task.status;
+          task.status = status;
+
+          if (status === "in_progress") {
+            task.summary = "";
+            task.sourcesSummary = "";
+            task.sourceItems = [];
+            task.notices = [];
+            activeTaskId.value = task.id;
+            progressLogs.value.push(`Starting task: ${task.title}`);
+          } else if (status === "completed") {
+            if (typeof event.summary === "string" && event.summary.trim()) {
+              task.summary = event.summary.trim();
+            }
+            if (
+              typeof event.sources_summary === "string" &&
+              event.sources_summary.trim()
+            ) {
+              task.sourcesSummary = event.sources_summary.trim();
+              task.sourceItems = parseSources(task.sourcesSummary);
+            }
+            progressLogs.value.push(`Completed task: ${task.title}`);
+            if (activeTaskId.value === task.id) {
+              pulse(summaryHighlight);
+              pulse(sourcesHighlight);
+            }
+          } else if (status === "skipped") {
+            progressLogs.value.push(`Task skipped: ${task.title}`);
+          }
+          return;
+        }
+
+        if (event.type === "sources") {
+          const payload = event as Record<string, unknown>;
+          const task = findTask(event.task_id);
+          if (!task) {
+            return;
+          }
+
+          const textCandidates = [
+            payload.latest_sources,
+            payload.sources_summary,
+            payload.raw_context
+          ];
+          const latestText = textCandidates
+            .map((value) => (typeof value === "string" ? value.trim() : ""))
+            .find((value) => value);
+
+          if (latestText) {
+            task.sourcesSummary = latestText;
+            task.sourceItems = parseSources(latestText);
+            if (activeTaskId.value === task.id) {
+              pulse(sourcesHighlight);
+            }
+            progressLogs.value.push(`Updated task sources: ${task.title}`);
+          }
+
+          if (typeof payload.backend === "string") {
+            progressLogs.value.push(
+              `Current search backend: ${payload.backend}`
+            );
+          }
+
+          applyNoteMetadata(task, payload);
+
+          return;
+        }
+
+        if (event.type === "task_summary_chunk") {
+          const payload = event as Record<string, unknown>;
+          const task = findTask(event.task_id);
+          if (!task) {
+            return;
+          }
+          const chunk =
+            typeof event.content === "string" ? event.content : "";
+          task.summary += chunk;
+          applyNoteMetadata(task, payload);
+          if (activeTaskId.value === task.id) {
+            pulse(summaryHighlight);
+          }
+          return;
+        }
+
+        if (event.type === "tool_call") {
+          const payload = event as Record<string, unknown>;
+          const eventId =
+            typeof payload.event_id === "number"
+              ? payload.event_id
+              : Date.now();
+          const agent =
+            typeof payload.agent === "string" && payload.agent.trim()
+              ? payload.agent.trim()
+              : "Agent";
+          const tool =
+            typeof payload.tool === "string" && payload.tool.trim()
+              ? payload.tool.trim()
+              : "tool";
+          const parameters = ensureRecord(payload.parameters);
+          const result =
+            typeof payload.result === "string" ? payload.result : "";
+          const noteId = extractOptionalString(payload.note_id);
+          const notePath = extractOptionalString(payload.note_path);
+
+          const task = findTask(payload.task_id);
+          if (task) {
+            task.toolCalls.push({
+              eventId,
+              agent,
+              tool,
+              parameters,
+              result,
+              noteId,
+              notePath,
+              timestamp: Date.now()
+            });
+            if (noteId) {
+              task.noteId = noteId;
+            }
+            if (notePath) {
+              task.notePath = notePath;
+            }
+            const logSummary = noteId
+              ? `${agent} called ${tool} (Task ${task.id}, Note ${noteId})`
+              : `${agent} called ${tool} (Task ${task.id})`;
+            progressLogs.value.push(logSummary);
+            if (activeTaskId.value === task.id) {
+              pulse(toolHighlight);
+            }
+          } else {
+            progressLogs.value.push(`${agent} called ${tool}`);
+          }
+          return;
+        }
+
+        if (event.type === "final_report") {
+          const report =
+            typeof event.report === "string" && event.report.trim()
+              ? event.report.trim()
+              : "";
+          reportMarkdown.value = report || "Report generation failed, no valid content obtained";
+          pulse(reportHighlight);
+          progressLogs.value.push("Final report generated");
+          return;
+        }
+
+        if (event.type === "error") {
+          const detail =
+            typeof event.detail === "string" && event.detail.trim()
+              ? event.detail
+              : "An error occurred during research";
+          error.value = detail;
+          progressLogs.value.push("Research failed, workflow stopped");
+        }
+      },
+      { signal: controller.signal }
+    );
+
+    if (!reportMarkdown.value) {
+      reportMarkdown.value = "No report generated";
+    }
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "AbortError") {
+      progressLogs.value.push("Current research task cancelled");
+    } else {
+      error.value = err instanceof Error ? err.message : "Request failed";
+    }
+  } finally {
+    loading.value = false;
+    if (currentController === controller) {
+      currentController = null;
+    }
+  }
+};
+
+const cancelResearch = () => {
+  if (!loading.value || !currentController) {
+    return;
+  }
+  progressLogs.value.push("Attempting to cancel current research task...");
+  currentController.abort();
+};
+
+const goBack = () => {
+  if (loading.value) {
+    return; // Cannot go back while research is in progress
+  }
+  isExpanded.value = false;
+};
+
+const startNewResearch = () => {
+  if (loading.value) {
+    cancelResearch();
+  }
+  resetWorkflowState();
+  isExpanded.value = false;
+  form.topic = "";
+  form.searchApi = "";
+};
+
+onBeforeUnmount(() => {
+  if (currentController) {
+    currentController.abort();
+    currentController = null;
+  }
+});
+</script>
+
+
+<style scoped>
+.app-shell {
+  position: relative;
+  min-height: 100vh;
+  padding: 72px 24px;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  background: radial-gradient(circle at 20% 20%, #f8fafc, #dbeafe 60%);
+  color: #1f2937;
+  overflow: hidden;
+  box-sizing: border-box;
+  transition: padding 0.4s ease;
+}
+
+.app-shell.expanded {
+  padding: 0;
+  align-items: stretch;
+}
+
+.aurora {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  opacity: 0.55;
+}
+
+.aurora span {
+  position: absolute;
+  width: 45vw;
+  height: 45vw;
+  max-width: 520px;
+  max-height: 520px;
+  background: radial-gradient(circle, rgba(148, 197, 255, 0.35), transparent 60%);
+  filter: blur(90px);
+  animation: float 26s infinite linear;
+}
+
+.aurora span:nth-child(1) {
+  top: -20%;
+  left: -18%;
+  animation-delay: 0s;
+}
+
+.aurora span:nth-child(2) {
+  bottom: -25%;
+  right: -20%;
+  background: radial-gradient(circle, rgba(166, 139, 255, 0.28), transparent 60%);
+  animation-delay: -9s;
+}
+
+.aurora span:nth-child(3) {
+  top: 35%;
+  left: 45%;
+  background: radial-gradient(circle, rgba(164, 219, 216, 0.26), transparent 60%);
+  animation-delay: -16s;
+}
+
+.layout {
+  position: relative;
+  width: 100%;
+  display: flex;
+  gap: 24px;
+  z-index: 1;
+  transition: all 0.4s ease;
+}
+
+.layout-centered {
+  max-width: 600px;
+  justify-content: center;
+  align-items: center;
+}
+
+.layout-fullscreen {
+  height: 100vh;
+  max-width: 100%;
+  gap: 0;
+  align-items: stretch;
+}
+
+.panel {
+  position: relative;
+  flex: 1 1 360px;
+  padding: 24px;
+  border-radius: 20px;
+  background: rgba(255, 255, 255, 0.95);
+  border: 1px solid rgba(148, 163, 184, 0.18);
+  box-shadow: 0 24px 48px rgba(15, 23, 42, 0.12);
+  backdrop-filter: blur(8px);
+  overflow: hidden;
+}
+
+.panel-form {
+  max-width: 420px;
+}
+
+.panel-centered {
+  width: 100%;
+  max-width: 600px;
+  padding: 40px;
+  box-shadow: 0 32px 64px rgba(15, 23, 42, 0.15);
+  transform: scale(1);
+  transition: transform 0.3s ease, box-shadow 0.3s ease;
+}
+
+.panel-centered:hover {
+  transform: scale(1.02);
+  box-shadow: 0 40px 80px rgba(15, 23, 42, 0.2);
+}
+
+.panel-result {
+  min-width: 360px;
+  flex: 2 1 420px;
+}
+
+.panel::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background: linear-gradient(135deg, rgba(59, 130, 246, 0.12), rgba(125, 86, 255, 0.1));
+  opacity: 0;
+  transition: opacity 0.35s ease;
+  z-index: 0;
+}
+
+.panel:hover::before {
+  opacity: 1;
+}
+
+.panel > * {
+  position: relative;
+  z-index: 1;
+}
+
+.panel-form h1 {
+  margin: 0;
+  font-size: 26px;
+  letter-spacing: 0.01em;
+}
+
+.panel-form p {
+  margin: 4px 0 0;
+  color: #64748b;
+  font-size: 13px;
+}
+
+.panel-head {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  margin-bottom: 24px;
+}
+
+.logo {
+  width: 52px;
+  height: 52px;
+  display: grid;
+  place-items: center;
+  border-radius: 16px;
+  background: linear-gradient(135deg, #2563eb, #7c3aed);
+  box-shadow: 0 12px 28px rgba(59, 130, 246, 0.4);
+}
+
+.logo svg {
+  width: 28px;
+  height: 28px;
+  fill: #f8fafc;
+}
+
+.form {
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+}
+
+.field {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.field span {
+  font-weight: 600;
+  color: #475569;
+}
+
+textarea,
+input,
+select {
+  padding: 14px 16px;
+  border-radius: 16px;
+  border: 1px solid rgba(148, 163, 184, 0.35);
+  background: rgba(255, 255, 255, 0.92);
+  color: #1f2937;
+  font-size: 14px;
+  transition: border-color 0.2s, box-shadow 0.2s, background 0.2s;
+}
+
+textarea:focus,
+input:focus,
+select:focus {
+  outline: none;
+  border-color: rgba(37, 99, 235, 0.65);
+  box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.2);
+  background: #ffffff;
+}
+
+.options {
+  display: flex;
+  gap: 16px;
+  flex-wrap: wrap;
+}
+
+.option {
+  flex: 1;
+  min-width: 140px;
+}
+
+.form-actions {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.submit {
+  align-self: flex-start;
+  padding: 12px 24px;
+  border-radius: 16px;
+  border: none;
+  background: linear-gradient(135deg, #2563eb, #7c3aed);
+  color: #ffffff;
+  font-size: 15px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: transform 0.2s, box-shadow 0.2s, opacity 0.2s;
+  display: inline-flex;
+  align-items: center;
+  gap: 10px;
+  position: relative;
+}
+
+.submit-label {
+  display: inline-flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.submit .spinner {
+  width: 18px;
+  height: 18px;
+  fill: none;
+  stroke: rgba(255, 255, 255, 0.85);
+  stroke-linecap: round;
+  animation: spin 1s linear infinite;
+}
+
+.submit:disabled {
+  opacity: 0.7;
+  cursor: not-allowed;
+}
+
+.submit:not(:disabled):hover {
+  transform: translateY(-2px);
+  box-shadow: 0 12px 28px rgba(37, 99, 235, 0.28);
+}
+
+.secondary-btn {
+  padding: 10px 18px;
+  border-radius: 14px;
+  background: rgba(148, 163, 184, 0.12);
+  border: 1px solid rgba(148, 163, 184, 0.28);
+  color: #1f2937;
+  font-size: 14px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.2s ease, border-color 0.2s ease, color 0.2s ease;
+}
+
+.secondary-btn:hover {
+  background: rgba(148, 163, 184, 0.2);
+  border-color: rgba(148, 163, 184, 0.35);
+  color: #0f172a;
+}
+
+.error-chip {
+  margin-top: 16px;
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  padding: 10px 14px;
+  background: rgba(248, 113, 113, 0.12);
+  border: 1px solid rgba(248, 113, 113, 0.35);
+  border-radius: 14px;
+  color: #b91c1c;
+  font-size: 14px;
+}
+
+.error-chip svg {
+  width: 18px;
+  height: 18px;
+  fill: currentColor;
+}
+
+.panel-result {
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+}
+
+.status-bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.status-main {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.status-controls {
+  display: flex;
+  gap: 8px;
+}
+
+.status-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  background: rgba(191, 219, 254, 0.28);
+  padding: 8px 14px;
+  border-radius: 999px;
+  font-size: 13px;
+  color: #1f2937;
+  border: 1px solid rgba(59, 130, 246, 0.35);
+  transition: background 0.3s ease, color 0.3s ease;
+}
+
+.status-chip.active {
+  background: rgba(129, 140, 248, 0.2);
+  border-color: rgba(129, 140, 248, 0.4);
+  color: #1e293b;
+}
+
+.status-chip .dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 999px;
+  background: #2563eb;
+  box-shadow: 0 0 12px rgba(37, 99, 235, 0.45);
+  animation: pulse 1.8s ease-in-out infinite;
+}
+
+.status-meta {
+  color: #64748b;
+  font-size: 13px;
+}
+
+.timeline-wrapper {
+  margin-top: 12px;
+  max-height: 220px;
+  overflow-y: auto;
+  padding-right: 8px;
+  scrollbar-width: thin;
+  scrollbar-color: rgba(129, 140, 248, 0.45) rgba(226, 232, 240, 0.6);
+}
+
+.timeline-wrapper::-webkit-scrollbar {
+  width: 6px;
+}
+
+.timeline-wrapper::-webkit-scrollbar-track {
+  background: rgba(226, 232, 240, 0.6);
+  border-radius: 999px;
+}
+
+.timeline-wrapper::-webkit-scrollbar-thumb {
+  background: linear-gradient(180deg, rgba(129, 140, 248, 0.8), rgba(59, 130, 246, 0.7));
+  border-radius: 999px;
+}
+
+.timeline-wrapper::-webkit-scrollbar-thumb:hover {
+  background: linear-gradient(180deg, rgba(99, 102, 241, 0.9), rgba(37, 99, 235, 0.8));
+}
+
+.timeline {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+  position: relative;
+  padding-left: 12px;
+}
+
+.timeline::before {
+  content: "";
+  position: absolute;
+  top: 8px;
+  bottom: 8px;
+  left: 0;
+  width: 2px;
+  background: linear-gradient(180deg, rgba(59, 130, 246, 0.35), rgba(129, 140, 248, 0.15));
+}
+
+.timeline li {
+  position: relative;
+  padding-left: 24px;
+  color: #1e293b;
+  font-size: 14px;
+  line-height: 1.5;
+}
+
+.timeline-node {
+  position: absolute;
+  left: -12px;
+  top: 6px;
+  width: 10px;
+  height: 10px;
+  border-radius: 999px;
+  background: linear-gradient(135deg, #38bdf8, #7c3aed);
+  box-shadow: 0 0 0 4px rgba(59, 130, 246, 0.22);
+}
+
+.timeline-enter-active,
+.timeline-leave-active {
+  transition: all 0.35s ease, opacity 0.35s ease;
+}
+
+.timeline-enter-from,
+.timeline-leave-to {
+  opacity: 0;
+  transform: translateY(-6px);
+}
+
+.tasks-section {
+  display: grid;
+  grid-template-columns: 280px 1fr;
+  gap: 20px;
+  align-items: start;
+}
+
+@media (max-width: 960px) {
+  .tasks-section {
+    grid-template-columns: 1fr;
+  }
+}
+
+.tasks-list {
+  background: rgba(255, 255, 255, 0.92);
+  border: 1px solid rgba(148, 163, 184, 0.26);
+  border-radius: 18px;
+  padding: 18px;
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  box-shadow: inset 0 0 0 1px rgba(226, 232, 240, 0.4);
+}
+
+.tasks-list h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  color: #1f2937;
+}
+
+.tasks-list ul {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.task-item {
+  border-radius: 14px;
+  border: 1px solid transparent;
+  transition: border-color 0.2s ease, background 0.2s ease;
+}
+
+.task-item.completed {
+  border-color: rgba(56, 189, 248, 0.35);
+  background: rgba(191, 219, 254, 0.28);
+}
+
+.task-item.active {
+  border-color: rgba(129, 140, 248, 0.5);
+  background: rgba(224, 231, 255, 0.5);
+}
+
+.task-button {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 12px 14px 6px;
+  background: transparent;
+  border: none;
+  color: inherit;
+  cursor: pointer;
+  text-align: left;
+}
+
+.task-title {
+  font-weight: 600;
+  font-size: 14px;
+  color: #1e293b;
+}
+
+.task-status {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 4px 10px;
+  border-radius: 999px;
+  font-size: 12px;
+  font-weight: 500;
+  color: #1f2937;
+  background: rgba(148, 163, 184, 0.2);
+}
+
+.task-status.pending {
+  background: rgba(148, 163, 184, 0.18);
+  color: #475569;
+}
+
+.task-status.in_progress {
+  background: rgba(129, 140, 248, 0.24);
+  color: #312e81;
+}
+
+.task-status.completed {
+  background: rgba(34, 197, 94, 0.2);
+  color: #15803d;
+}
+
+.task-status.skipped {
+  background: rgba(248, 113, 113, 0.18);
+  color: #b91c1c;
+}
+
+.task-intent {
+  margin: 0;
+  padding: 0 14px 12px 14px;
+  font-size: 13px;
+  color: #64748b;
+}
+
+.task-detail {
+  background: rgba(255, 255, 255, 0.94);
+  border: 1px solid rgba(148, 163, 184, 0.26);
+  border-radius: 18px;
+  padding: 22px;
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+  box-shadow: inset 0 0 0 1px rgba(226, 232, 240, 0.5);
+}
+
+.task-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  flex-wrap: wrap;
+  gap: 12px;
+}
+
+.task-chip-group {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.task-header h3 {
+  margin: 0;
+  font-size: 18px;
+  font-weight: 600;
+  color: #1f2937;
+}
+
+.task-header .muted {
+  margin: 6px 0 0;
+}
+
+.task-label {
+  padding: 6px 12px;
+  border-radius: 999px;
+  background: rgba(191, 219, 254, 0.32);
+  border: 1px solid rgba(59, 130, 246, 0.35);
+  font-size: 12px;
+  color: #1e3a8a;
+}
+
+.task-label.note-chip {
+  background: rgba(34, 197, 94, 0.2);
+  border-color: rgba(34, 197, 94, 0.35);
+  color: #15803d;
+}
+
+.task-label.path-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  max-width: 360px;
+  background: rgba(56, 189, 248, 0.2);
+  border-color: rgba(56, 189, 248, 0.35);
+  color: #0369a1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.path-label {
+  font-weight: 500;
+}
+
+.path-text {
+  max-width: 220px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.chip-action {
+  border: none;
+  background: rgba(56, 189, 248, 0.2);
+  color: #0369a1;
+  padding: 3px 8px;
+  border-radius: 10px;
+  font-size: 11px;
+  cursor: pointer;
+  transition: background 0.2s ease, color 0.2s ease;
+}
+
+.chip-action:hover {
+  background: rgba(14, 165, 233, 0.28);
+  color: #0f172a;
+}
+
+.task-notices {
+  background: rgba(191, 219, 254, 0.28);
+  border: 1px solid rgba(96, 165, 250, 0.35);
+  border-radius: 16px;
+  padding: 14px 18px;
+  color: #1f2937;
+}
+
+.task-notices h4 {
+  margin: 0 0 8px;
+  font-size: 14px;
+  font-weight: 600;
+}
+
+.task-notices ul {
+  list-style: disc;
+  margin: 0 0 0 18px;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.task-notices li {
+  font-size: 13px;
+}
+
+.report-block {
+  background: rgba(255, 255, 255, 0.94);
+  border: 1px solid rgba(148, 163, 184, 0.26);
+  border-radius: 18px;
+  padding: 22px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.report-block h3 {
+  margin: 0;
+  font-size: 18px;
+  font-weight: 600;
+  color: #1f2937;
+}
+
+.block-pre {
+  font-family: "JetBrains Mono", "Fira Code", ui-monospace, SFMono-Regular,
+    Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  font-size: 13px;
+  line-height: 1.7;
+  white-space: pre-wrap;
+  word-break: break-word;
+  color: #1f2937;
+  background: rgba(248, 250, 252, 0.9);
+  padding: 16px;
+  border-radius: 14px;
+  border: 1px solid rgba(148, 163, 184, 0.35);
+  overflow: auto;
+  max-height: 420px;
+  scrollbar-width: thin;
+  scrollbar-color: rgba(129, 140, 248, 0.6) rgba(226, 232, 240, 0.7);
+}
+
+.block-pre::-webkit-scrollbar {
+  width: 6px;
+}
+
+.block-pre::-webkit-scrollbar-track {
+  background: rgba(226, 232, 240, 0.7);
+  border-radius: 999px;
+}
+
+.block-pre::-webkit-scrollbar-thumb {
+  background: linear-gradient(180deg, rgba(99, 102, 241, 0.75), rgba(59, 130, 246, 0.65));
+  border-radius: 999px;
+}
+
+.block-pre::-webkit-scrollbar-thumb:hover {
+  background: linear-gradient(180deg, rgba(79, 70, 229, 0.8), rgba(37, 99, 235, 0.75));
+}
+
+.summary-block .block-pre,
+.sources-block .block-pre {
+  max-height: 360px;
+}
+
+
+.tools-block {
+  position: relative;
+  margin-top: 16px;
+  padding: 20px;
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.94);
+  border: 1px solid rgba(148, 163, 184, 0.18);
+  box-shadow: inset 0 0 0 1px rgba(226, 232, 240, 0.4);
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.tools-block h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  color: #1f2937;
+  letter-spacing: 0.02em;
+}
+
+.tool-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.tool-entry {
+  background: rgba(248, 250, 252, 0.95);
+  border: 1px solid rgba(148, 163, 184, 0.24);
+  border-radius: 14px;
+  padding: 14px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.tool-entry-header {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.tool-entry-title {
+  font-weight: 600;
+  color: #1f2937;
+}
+
+.tool-entry-note {
+  font-size: 12px;
+  color: #0f766e;
+}
+
+.tool-entry-path {
+  margin: 0;
+  font-size: 12px;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  color: #2563eb;
+}
+
+.tool-subtitle {
+  margin: 0;
+  font-size: 13px;
+  color: #475569;
+  font-weight: 500;
+}
+
+.tool-pre {
+  font-family: "JetBrains Mono", "Fira Code", ui-monospace, SFMono-Regular,
+    Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  font-size: 12px;
+  line-height: 1.6;
+  white-space: pre-wrap;
+  word-break: break-word;
+  color: #1f2937;
+  background: rgba(248, 250, 252, 0.9);
+  padding: 12px;
+  border-radius: 12px;
+  border: 1px solid rgba(148, 163, 184, 0.28);
+  overflow: auto;
+  max-height: 260px;
+  scrollbar-width: thin;
+  scrollbar-color: rgba(129, 140, 248, 0.6) rgba(226, 232, 240, 0.7);
+}
+
+.tool-pre::-webkit-scrollbar {
+  width: 6px;
+}
+
+.tool-pre::-webkit-scrollbar-track {
+  background: rgba(226, 232, 240, 0.7);
+}
+
+.tool-pre::-webkit-scrollbar-thumb {
+  background: rgba(99, 102, 241, 0.7);
+  border-radius: 10px;
+}
+
+.link-btn {
+  background: none;
+  border: none;
+  color: #0369a1;
+  cursor: pointer;
+  padding: 0 4px;
+  font-size: 12px;
+  border-radius: 8px;
+  transition: color 0.2s ease, background 0.2s ease;
+}
+
+.link-btn:hover {
+  color: #0ea5e9;
+  background: rgba(14, 165, 233, 0.16);
+}
+
+
+.sources-block,
+.summary-block {
+  position: relative;
+  margin-top: 16px;
+  padding: 18px;
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.94);
+  border: 1px solid rgba(148, 163, 184, 0.18);
+  box-shadow: inset 0 0 0 1px rgba(226, 232, 240, 0.4);
+}
+
+.sources-history {
+  margin-top: 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.sources-history h4 {
+  margin: 0;
+  color: #1f2937;
+  font-size: 14px;
+  letter-spacing: 0.01em;
+}
+
+.history-list {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.history-list details {
+  background: rgba(248, 250, 252, 0.95);
+  border: 1px solid rgba(148, 163, 184, 0.24);
+  border-radius: 14px;
+  padding: 12px 16px;
+  color: #1f2937;
+  transition: border-color 0.2s ease, background 0.2s ease;
+}
+
+.history-list details[open] {
+  background: rgba(224, 231, 255, 0.55);
+  border-color: rgba(129, 140, 248, 0.4);
+}
+
+.history-list summary {
+  cursor: pointer;
+  font-weight: 600;
+  outline: none;
+  list-style: none;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.history-list summary::-webkit-details-marker {
+  display: none;
+}
+
+.history-list summary::after {
+  content: "▾";
+  margin-left: 6px;
+  font-size: 12px;
+  opacity: 0.7;
+  transition: transform 0.2s ease;
+}
+
+.history-list details[open] summary::after {
+  transform: rotate(180deg);
+}
+
+.block-highlight {
+  animation: glow 1.2s ease;
+}
+
+.sources-block h3,
+.summary-block h3 {
+  margin: 0 0 14px;
+  color: #1f2937;
+  letter-spacing: 0.02em;
+}
+
+.sources-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.source-item {
+  position: relative;
+  display: inline-flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.source-link {
+  color: #2563eb;
+  text-decoration: none;
+  font-weight: 600;
+  letter-spacing: 0.01em;
+  transition: color 0.2s ease;
+}
+
+.source-link::after {
+  content: " ↗";
+  font-size: 12px;
+  opacity: 0.6;
+}
+
+.source-link:hover {
+  color: #0f172a;
+}
+
+.source-tooltip {
+  display: none;
+  position: absolute;
+  bottom: calc(100% + 12px);
+  left: 50%;
+  transform: translateX(-50%);
+  background: rgba(255, 255, 255, 0.98);
+  color: #1f2937;
+  padding: 14px 16px;
+  border-radius: 16px;
+  box-shadow: 0 18px 32px rgba(15, 23, 42, 0.18);
+  width: min(420px, 90vw);
+  z-index: 20;
+  border: 1px solid rgba(148, 163, 184, 0.24);
+}
+
+.source-tooltip::after {
+  content: "";
+  position: absolute;
+  top: 100%;
+  left: 50%;
+  transform: translateX(-50%);
+  border-width: 10px;
+  border-style: solid;
+  border-color: rgba(255, 255, 255, 0.98) transparent transparent transparent;
+}
+
+.source-tooltip::before {
+  content: "";
+  position: absolute;
+  bottom: -12px;
+  left: 50%;
+  transform: translateX(-50%);
+  border-width: 12px 10px 0 10px;
+  border-style: solid;
+  border-color: rgba(255, 255, 255, 0.98) transparent transparent transparent;
+  filter: drop-shadow(0 -2px 4px rgba(15, 23, 42, 0.12));
+}
+
+.source-tooltip p {
+  margin: 0 0 8px;
+  font-size: 13px;
+  line-height: 1.6;
+}
+
+.source-tooltip p:last-child {
+  margin-bottom: 0;
+}
+
+.muted-text {
+  color: #64748b;
+}
+
+.source-item:hover .source-tooltip,
+.source-item:focus-within .source-tooltip {
+  display: block;
+}
+
+.hint.muted {
+  color: #64748b;
+}
+
+@keyframes float {
+  0% {
+    transform: translate3d(0, 0, 0) rotate(0deg);
+  }
+  50% {
+    transform: translate3d(10%, 6%, 0) rotate(3deg);
+  }
+  100% {
+    transform: translate3d(0, 0, 0) rotate(0deg);
+  }
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@keyframes pulse {
+  0%,
+  100% {
+    transform: scale(1);
+    opacity: 1;
+  }
+  50% {
+    transform: scale(1.3);
+    opacity: 0.5;
+  }
+}
+
+@keyframes glow {
+  0% {
+    box-shadow: 0 0 0 rgba(59, 130, 246, 0.3);
+    border-color: rgba(59, 130, 246, 0.5);
+  }
+  100% {
+    box-shadow: inset 0 0 0 1px rgba(59, 130, 246, 0.12);
+    border-color: rgba(148, 163, 184, 0.2);
+  }
+}
+
+@media (max-width: 960px) {
+  .app-shell {
+    padding: 56px 16px;
+  }
+
+  .layout {
+    flex-direction: column;
+    align-items: stretch;
+  }
+
+  .panel {
+    padding: 22px;
+  }
+
+  .panel-form,
+  .panel-result {
+    max-width: none;
+  }
+
+  .status-bar {
+    flex-direction: column;
+    align-items: flex-start;
+  }
+
+  .status-main,
+  .status-controls {
+    width: 100%;
+  }
+
+  .status-controls {
+    justify-content: flex-start;
+  }
+}
+
+@media (max-width: 600px) {
+  .options {
+    flex-direction: column;
+  }
+
+  .status-meta {
+    font-size: 12px;
+  }
+
+  .panel-head {
+    flex-direction: column;
+    align-items: flex-start;
+  }
+
+  .panel-form h1 {
+    font-size: 24px;
+  }
+}
+
+/* Sidebar styles */
+.sidebar {
+  width: 400px;
+  min-width: 400px;
+  height: 100vh;
+  background: rgba(255, 255, 255, 0.98);
+  border-right: 1px solid rgba(148, 163, 184, 0.2);
+  padding: 32px 24px;
+  display: flex;
+  flex-direction: column;
+  gap: 24px;
+  overflow-y: auto;
+  box-shadow: 4px 0 24px rgba(15, 23, 42, 0.08);
+}
+
+.sidebar-header {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.sidebar-header h2 {
+  font-size: 24px;
+  font-weight: 700;
+  margin: 0;
+  color: #1f2937;
+}
+
+.back-btn {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 10px 16px;
+  background: transparent;
+  border: 1px solid rgba(148, 163, 184, 0.3);
+  border-radius: 12px;
+  color: #64748b;
+  font-size: 14px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all 0.2s ease;
+  width: fit-content;
+}
+
+.back-btn:hover:not(:disabled) {
+  background: rgba(59, 130, 246, 0.1);
+  border-color: #3b82f6;
+  color: #3b82f6;
+}
+
+.back-btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.research-info {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.info-item {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.info-item label {
+  font-size: 12px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  color: #64748b;
+}
+
+.info-item p {
+  margin: 0;
+  font-size: 14px;
+  color: #1f2937;
+  line-height: 1.6;
+}
+
+.topic-display {
+  font-size: 16px !important;
+  font-weight: 600;
+  color: #0f172a !important;
+  padding: 12px;
+  background: rgba(59, 130, 246, 0.05);
+  border-radius: 8px;
+  border-left: 3px solid #3b82f6;
+}
+
+.progress-bar {
+  width: 100%;
+  height: 8px;
+  background: rgba(148, 163, 184, 0.2);
+  border-radius: 4px;
+  overflow: hidden;
+}
+
+.progress-fill {
+  height: 100%;
+  background: linear-gradient(90deg, #3b82f6, #8b5cf6);
+  border-radius: 4px;
+  transition: width 0.5s ease;
+}
+
+.progress-text {
+  font-size: 13px !important;
+  color: #64748b !important;
+  font-weight: 500;
+}
+
+.sidebar-actions {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding-top: 16px;
+  border-top: 1px solid rgba(148, 163, 184, 0.2);
+}
+
+.new-research-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  padding: 14px 20px;
+  background: linear-gradient(135deg, #3b82f6, #8b5cf6);
+  border: none;
+  border-radius: 12px;
+  color: white;
+  font-size: 15px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.3s ease;
+  box-shadow: 0 4px 12px rgba(59, 130, 246, 0.3);
+}
+
+.new-research-btn:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 6px 20px rgba(59, 130, 246, 0.4);
+}
+
+.new-research-btn:active {
+  transform: translateY(0);
+}
+
+/* Fullscreen result panel styles */
+.layout-fullscreen .panel-result {
+  flex: 1;
+  height: 100vh;
+  border-radius: 0;
+  border: none;
+  overflow-y: auto;
+  max-width: none;
+}
+
+@media (max-width: 1024px) {
+  .sidebar {
+    width: 320px;
+    min-width: 320px;
+  }
+}
+
+@media (max-width: 768px) {
+  .layout-fullscreen {
+    flex-direction: column;
+  }
+
+  .sidebar {
+    width: 100%;
+    min-width: 100%;
+    height: auto;
+    max-height: 40vh;
+  }
+
+  .layout-fullscreen .panel-result {
+    height: 60vh;
+  }
+}
+</style>

frontend/src/env.d.ts

@@ -0,0 +1,7 @@
+interface ImportMetaEnv {
+  readonly VITE_API_BASE_URL?: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}

frontend/src/main.ts

@@ -0,0 +1,6 @@
+import { createApp } from "vue";
+import App from "./App.vue";
+
+import "./style.css";
+
+createApp(App).mount("#app");

frontend/src/services/api.ts

@@ -0,0 +1,96 @@
+const baseURL =
+  import.meta.env.VITE_API_BASE_URL || "http://localhost:8000";
+
+export interface ResearchRequest {
+  topic: string;
+  search_api?: string;
+}
+
+export interface ResearchStreamEvent {
+  type: string;
+  [key: string]: unknown;
+}
+
+export interface StreamOptions {
+  signal?: AbortSignal;
+}
+
+export async function runResearchStream(
+  payload: ResearchRequest,
+  onEvent: (event: ResearchStreamEvent) => void,
+  options: StreamOptions = {}
+): Promise<void> {
+  const response = await fetch(`${baseURL}/research/stream`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream"
+    },
+    body: JSON.stringify(payload),
+    signal: options.signal
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "");
+    throw new Error(
+      errorText || `Research request failed, status code: ${response.status}`
+    );
+  }
+
+  const body = response.body;
+  if (!body) {
+    throw new Error("Browser does not support streaming responses, unable to get research progress");
+  }
+
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+
+  while (true) {
+    const { value, done } = await reader.read();
+    buffer += decoder.decode(value || new Uint8Array(), { stream: !done });
+
+    let boundary = buffer.indexOf("\n\n");
+    while (boundary !== -1) {
+      const rawEvent = buffer.slice(0, boundary).trim();
+      buffer = buffer.slice(boundary + 2);
+
+      if (rawEvent.startsWith("data:")) {
+        const dataPayload = rawEvent.slice(5).trim();
+        if (dataPayload) {
+          try {
+            const event = JSON.parse(dataPayload) as ResearchStreamEvent;
+            onEvent(event);
+
+            if (event.type === "error" || event.type === "done") {
+              return;
+            }
+          } catch (error) {
+            console.error("Failed to parse streaming event:", error, dataPayload);
+          }
+        }
+      }
+
+      boundary = buffer.indexOf("\n\n");
+    }
+
+    if (done) {
+      // Handle possible trailing events
+      if (buffer.trim()) {
+        const rawEvent = buffer.trim();
+        if (rawEvent.startsWith("data:")) {
+          const dataPayload = rawEvent.slice(5).trim();
+          if (dataPayload) {
+            try {
+              const event = JSON.parse(dataPayload) as ResearchStreamEvent;
+              onEvent(event);
+            } catch (error) {
+              console.error("Failed to parse streaming event:", error, dataPayload);
+            }
+          }
+        }
+      }
+      break;
+    }
+  }
+}

frontend/src/style.css

@@ -0,0 +1,18 @@
+:root {
+  color: #1a1a1a;
+  background-color: #f6f6f6;
+  font-family: "Helvetica Neue", Arial, sans-serif;
+  line-height: 1.5;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+}
+
+#app {
+  min-height: 100vh;
+}

frontend/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "strict": true,
+    "jsx": "preserve",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "lib": ["ESNext", "DOM"],
+    "skipLibCheck": true,
+    "types": ["vite/client"],
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.tsx", "src/**/*.vue"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

frontend/tsconfig.node.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}

frontend/vite.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+
+export default defineConfig({
+  plugins: [vue()],
+  server: {
+    port: 5174
+  }
+});