feat: add python result and error handling

.dockerignore

@@ -3,7 +3,6 @@ Dockerfile
 .dockerignore
 .git
 .gitignore
-docker/
 
 # Python
 __pycache__/
@@ -27,7 +26,6 @@ wheels/
 *.egg-info/
 .installed.cfg
 *.egg
-.venv/
 
 # Web
 node_modules
@@ -52,20 +50,3 @@ examples/
 assets/
 tests/
 *.log
-
-# Exclude directories not needed in Docker context
-# Frontend build only needs frontend/
-# Backend build only needs backend/
-scripts/
-logs/
-docker/
-skills/
-frontend/.next
-frontend/node_modules
-backend/.venv
-backend/htmlcov
-backend/.coverage
-*.md
-!README.md
-!frontend/README.md
-!backend/README.md

.env.example

@@ -1,41 +1,27 @@
-# TAVILY API Key
+# Application Settings
-TAVILY_API_KEY=your-tavily-api-key
+DEBUG=True
+APP_ENV=development
 
-# Jina API Key
+# docker build args
-JINA_API_KEY=your-jina-api-key
+NEXT_PUBLIC_API_URL="http://localhost:8000/api"
 
-# InfoQuest API Key
+# Search Engine, Supported values: tavily (recommended), duckduckgo, brave_search, arxiv
-INFOQUEST_API_KEY=your-infoquest-api-key
+SEARCH_API=tavily
-# CORS Origins (comma-separated) - e.g., http://localhost:3000,http://localhost:3001
+TAVILY_API_KEY=tvly-xxx
-# CORS_ORIGINS=http://localhost:3000
+# BRAVE_SEARCH_API_KEY=xxx # Required only if SEARCH_API is brave_search
+# JINA_API_KEY=jina_xxx # Optional, default is None
 
-# Optional:
+# Optional, volcengine TTS for generating podcast
-# FIRECRAWL_API_KEY=your-firecrawl-api-key
+VOLCENGINE_TTS_APPID=xxx
-# VOLCENGINE_API_KEY=your-volcengine-api-key
+VOLCENGINE_TTS_ACCESS_TOKEN=xxx
-# OPENAI_API_KEY=your-openai-api-key
+# VOLCENGINE_TTS_CLUSTER=volcano_tts # Optional, default is volcano_tts
-# GEMINI_API_KEY=your-gemini-api-key
+# VOLCENGINE_TTS_VOICE_TYPE=BV700_V2_streaming # Optional, default is BV700_V2_streaming
-# DEEPSEEK_API_KEY=your-deepseek-api-key
-# NOVITA_API_KEY=your-novita-api-key  # OpenAI-compatible, see https://novita.ai
-# MINIMAX_API_KEY=your-minimax-api-key  # OpenAI-compatible, see https://platform.minimax.io
-# VLLM_API_KEY=your-vllm-api-key  # OpenAI-compatible
-# FEISHU_APP_ID=your-feishu-app-id
-# FEISHU_APP_SECRET=your-feishu-app-secret
 
-# SLACK_BOT_TOKEN=your-slack-bot-token
+# Option, for langsmith tracing and monitoring
-# SLACK_APP_TOKEN=your-slack-app-token
-# TELEGRAM_BOT_TOKEN=your-telegram-bot-token
-
-# Enable LangSmith to monitor and debug your LLM calls, agent runs, and tool executions.
 # LANGSMITH_TRACING=true
-# LANGSMITH_ENDPOINT=https://api.smith.langchain.com
+# LANGSMITH_ENDPOINT="https://api.smith.langchain.com"
-# LANGSMITH_API_KEY=your-langsmith-api-key
+# LANGSMITH_API_KEY="xxx"
-# LANGSMITH_PROJECT=your-langsmith-project
+# LANGSMITH_PROJECT="xxx"
 
-# GitHub API Token
+# [!NOTE]
-# GITHUB_TOKEN=your-github-token
+# For model settings and other configurations, please refer to `docs/configuration_guide.md`
-
-# Database (only needed when config.yaml has database.backend: postgres)
-# DATABASE_URL=postgresql://deerflow:password@localhost:5432/deerflow
-#
-# WECOM_BOT_ID=your-wecom-bot-id
-# WECOM_BOT_SECRET=your-wecom-bot-secret

.gitattributes

@@ -1,43 +0,0 @@
-# Normalize line endings to LF for all text files
-* text=auto eol=lf
-
-# Shell scripts and makefiles must always use LF
-*.sh text eol=lf
-Makefile text eol=lf
-**/Makefile text eol=lf
-
-# Common config/source files
-*.yml text eol=lf
-*.yaml text eol=lf
-*.toml text eol=lf
-*.json text eol=lf
-*.md text eol=lf
-*.py text eol=lf
-*.ts text eol=lf
-*.tsx text eol=lf
-*.js text eol=lf
-*.jsx text eol=lf
-*.css text eol=lf
-*.scss text eol=lf
-*.html text eol=lf
-*.env text eol=lf
-
-# Windows scripts
-*.bat text eol=crlf
-*.cmd text eol=crlf
-
-# Binary assets
-*.png binary
-*.jpg binary
-*.jpeg binary
-*.gif binary
-*.webp binary
-*.ico binary
-*.pdf binary
-*.zip binary
-*.tar binary
-*.gz binary
-*.mp4 binary
-*.mov binary
-*.woff binary
-*.woff2 binary

.github/ISSUE_TEMPLATE/runtime-information.yml

@@ -1,128 +0,0 @@
-name: Runtime Information
-description: Report runtime/environment details to help reproduce an issue.
-title: "[runtime] "
-labels:
-  - needs-triage
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for sharing runtime details.
-        Complete this form so maintainers can quickly reproduce and diagnose the problem.
-
-  - type: input
-    id: summary
-    attributes:
-      label: Problem summary
-      description: Short summary of the issue.
-      placeholder: e.g. make dev fails to start gateway service
-    validations:
-      required: true
-
-  - type: textarea
-    id: expected
-    attributes:
-      label: Expected behavior
-      placeholder: What did you expect to happen?
-    validations:
-      required: true
-
-  - type: textarea
-    id: actual
-    attributes:
-      label: Actual behavior
-      placeholder: What happened instead? Include key error lines.
-    validations:
-      required: true
-
-  - type: dropdown
-    id: os
-    attributes:
-      label: Operating system
-      options:
-        - macOS
-        - Linux
-        - Windows
-        - Other
-    validations:
-      required: true
-
-  - type: input
-    id: platform_details
-    attributes:
-      label: Platform details
-      description: Add architecture and shell if relevant.
-      placeholder: e.g. arm64, zsh
-
-  - type: input
-    id: python_version
-    attributes:
-      label: Python version
-      placeholder: e.g. Python 3.12.9
-
-  - type: input
-    id: node_version
-    attributes:
-      label: Node.js version
-      placeholder: e.g. v23.11.0
-
-  - type: input
-    id: pnpm_version
-    attributes:
-      label: pnpm version
-      placeholder: e.g. 10.26.2
-
-  - type: input
-    id: uv_version
-    attributes:
-      label: uv version
-      placeholder: e.g. 0.7.20
-
-  - type: dropdown
-    id: run_mode
-    attributes:
-      label: How are you running DeerFlow?
-      options:
-        - Local (make dev)
-        - Docker (make docker-dev)
-        - CI
-        - Other
-    validations:
-      required: true
-
-  - type: textarea
-    id: reproduce
-    attributes:
-      label: Reproduction steps
-      description: Provide exact commands and sequence.
-      placeholder: |
-        1. make check
-        2. make install
-        3. make dev
-        4. ...
-    validations:
-      required: true
-
-  - type: textarea
-    id: logs
-    attributes:
-      label: Relevant logs
-      description: Paste key lines from logs (for example logs/gateway.log, logs/frontend.log).
-      render: shell
-    validations:
-      required: true
-
-  - type: textarea
-    id: git_info
-    attributes:
-      label: Git state
-      description: Share output of git branch and latest commit SHA.
-      placeholder: |
-        branch: feature/my-branch
-        commit: abcdef1
-
-  - type: textarea
-    id: additional
-    attributes:
-      label: Additional context
-      description: Add anything else that might help triage.

.github/copilot-instructions.md

@@ -1,213 +0,0 @@
-# Copilot Onboarding Instructions for DeerFlow
-
-Use this file as the default operating guide for this repository. Follow it first, and only search the codebase when this file is incomplete or incorrect.
-
-## 1) Repository Summary
-
-DeerFlow is a full-stack "super agent harness".
-
-- Backend: Python 3.12, LangGraph + FastAPI gateway, sandbox/tool system, memory, MCP integration.
-- Frontend: Next.js 16 + React 19 + TypeScript + pnpm.
-- Local dev entrypoint: root `Makefile` starts backend + frontend + nginx on `http://localhost:2026`.
-- Docker dev entrypoint: `make docker-*` (mode-aware provisioner startup from `config.yaml`).
-
-Current repo footprint is medium-large (backend service, frontend app, docker stack, skills library, docs).
-
-## 2) Runtime and Toolchain Requirements
-
-Validated in this repo on macOS:
-
-- Node.js `>=22` (validated with Node `23.11.0`)
-- pnpm (repo expects lockfile generated by pnpm 10; validated with pnpm `10.26.2` and `10.15.0`)
-- Python `>=3.12` (CI uses `3.12`)
-- `uv` (validated with `0.7.20`)
-- `nginx` (required for `make dev` unified local endpoint)
-
-Always run from repo root unless a command explicitly says otherwise.
-
-## 3) Build/Test/Lint/Run - Verified Command Sequences
-
-These were executed and validated in this repository.
-
-### A. Bootstrap and install
-
-1. Check prerequisites:
-
-```bash
-make check
-```
-
-Observed: passes when required tools are installed.
-
-2. Install dependencies (recommended order: backend then frontend, as implemented by `make install`):
-
-```bash
-make install
-```
-
-### B. Backend CI-equivalent validation
-
-Run from `backend/`:
-
-```bash
-make lint
-make test
-```
-
-Validated results:
-
-- `make lint`: pass (`ruff check .`)
-- `make test`: pass (`277 passed, 15 warnings in ~76.6s`)
-
-CI parity:
-
-- `.github/workflows/backend-unit-tests.yml` runs on pull requests.
-- CI executes `uv sync --group dev`, then `make lint`, then `make test` in `backend/`.
-
-### C. Frontend validation
-
-Run from `frontend/`.
-
-Recommended reliable sequence:
-
-```bash
-pnpm lint
-pnpm typecheck
-BETTER_AUTH_SECRET=local-dev-secret pnpm build
-```
-
-Observed failure modes and workarounds:
-
-- `pnpm build` fails without `BETTER_AUTH_SECRET` in production-mode env validation.
-- Workaround: set `BETTER_AUTH_SECRET` (best) or set `SKIP_ENV_VALIDATION=1`.
-- Even with `SKIP_ENV_VALIDATION=1`, Better Auth can still warn/error in logs about default secret; prefer setting a real non-default secret.
-- `pnpm check` currently fails (`next lint` invocation is incompatible here and resolves to an invalid directory). Do not rely on `pnpm check`; run `pnpm lint` and `pnpm typecheck` explicitly.
-
-### D. Run locally (all services)
-
-From root:
-
-```bash
-make dev
-```
-
-Behavior:
-
-- Stops existing local services first.
-- Starts LangGraph (`2024`), Gateway (`8001`), Frontend (`3000`), nginx (`2026`).
-- Unified app endpoint: `http://localhost:2026`.
-- Logs: `logs/langgraph.log`, `logs/gateway.log`, `logs/frontend.log`, `logs/nginx.log`.
-
-Stop services:
-
-```bash
-make stop
-```
-
-If tool sessions/timeouts interrupt `make dev`, run `make stop` again to ensure cleanup.
-
-### E. Config bootstrap
-
-From root:
-
-```bash
-make config
-```
-
-Important behavior:
-
-- This intentionally aborts if `config.yaml` (or `config.yml`/`configure.yml`) already exists.
-- Use `make config` only for first-time setup in a clean clone.
-
-## 4) Command Order That Minimizes Failures
-
-Use this exact order for local code changes:
-
-1. `make check`
-2. `make install` (if frontend fails with proxy errors, rerun frontend install with proxy vars unset)
-3. Backend checks: `cd backend && make lint && make test`
-4. Frontend checks: `cd frontend && pnpm lint && pnpm typecheck`
-5. Frontend build (if UI changes or release-sensitive changes): `BETTER_AUTH_SECRET=... pnpm build`
-
-Always run backend lint/tests before opening PRs because that is what CI enforces.
-
-## 5) Project Layout and Architecture (High-Value Paths)
-
-Root-level orchestration and config:
-
-- `Makefile` - main local/dev/docker command entrypoints
-- `config.example.yaml` - primary app config template
-- `config.yaml` - local active config (gitignored)
-- `docker/docker-compose-dev.yaml` - Docker dev topology
-- `.github/workflows/backend-unit-tests.yml` - PR validation workflow
-
-Backend core:
-
-- `backend/packages/harness/deerflow/agents/` - lead agent, middleware chain, memory
-- `backend/app/gateway/` - FastAPI gateway API
-- `backend/packages/harness/deerflow/sandbox/` - sandbox provider + tool wrappers
-- `backend/packages/harness/deerflow/subagents/` - subagent registry/execution
-- `backend/packages/harness/deerflow/mcp/` - MCP integration
-- `backend/langgraph.json` - graph entrypoint (`deerflow.agents:make_lead_agent`)
-- `backend/pyproject.toml` - Python deps and `requires-python`
-- `backend/ruff.toml` - lint/format policy
-- `backend/tests/` - backend unit and integration-like tests
-
-Frontend core:
-
-- `frontend/src/app/` - Next.js routes/pages
-- `frontend/src/components/` - UI components
-- `frontend/src/core/` - app logic (threads, tools, API, models)
-- `frontend/src/env.js` - env schema/validation (critical for build behavior)
-- `frontend/package.json` - scripts/deps
-- `frontend/eslint.config.js` - lint rules
-- `frontend/tsconfig.json` - TS config
-
-Skills and assets:
-
-- `skills/public/` - built-in skill packs loaded by agent runtime
-
-## 6) Pre-Checkin / Validation Expectations
-
-Before submitting changes, run at minimum:
-
-- Backend: `cd backend && make lint && make test`
-- Frontend (if touched): `cd frontend && pnpm lint && pnpm typecheck`
-- Frontend build when changing env/auth/routing/build-sensitive files: `BETTER_AUTH_SECRET=... pnpm build`
-
-If touching orchestration/config (`Makefile`, `docker/*`, `config*.yaml`), also run `make dev` and verify the four services start.
-
-## 7) Non-Obvious Dependencies and Gotchas
-
-- Proxy env vars can silently break frontend network operations (`pnpm install`/registry access).
-- `BETTER_AUTH_SECRET` is effectively required for reliable frontend production build validation.
-- Next.js may warn about multiple lockfiles and workspace root inference; this is currently a warning, not a build blocker.
-- `make config` is non-idempotent by design when config already exists.
-- `make dev` includes process cleanup and can emit shutdown logs/noise if interrupted; this is expected.
-
-## 8) Root Inventory (quick reference)
-
-Important root entries:
-
-- `.github/`
-- `backend/`
-- `frontend/`
-- `docker/`
-- `skills/`
-- `scripts/`
-- `docs/`
-- `README.md`
-- `CONTRIBUTING.md`
-- `Makefile`
-- `config.example.yaml`
-- `extensions_config.example.json`
-
-## 9) Instruction Priority
-
-Trust this onboarding guide first.
-
-Only do broad repo searches (`grep/find/code search`) when:
-
-- you need file-level implementation details not listed here,
-- a command here fails and you need updated replacement behavior,
-- or CI/workflow definitions have changed since this file was written.

.github/workflows/backend-unit-tests.yml

@@ -1,40 +0,0 @@
-name: Unit Tests
-
-on:
-  push:
-    branches: [ 'main' ]
-  pull_request:
-    types: [opened, synchronize, reopened, ready_for_review]
-
-concurrency:
-  group: unit-tests-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  backend-unit-tests:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Set up Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: '3.12'
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-
-      - name: Install backend dependencies
-        working-directory: backend
-        run: uv sync --group dev
-
-      - name: Run unit tests of backend
-        working-directory: backend
-        run: make test

.github/workflows/lint-check.yml

@@ -1,74 +0,0 @@
-name: Lint Check
-
-on:
-  push:
-    branches: [ 'main' ]
-  pull_request:
-    branches: [ '*' ]
-
-permissions:
-  contents: read
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Set up Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: '3.12'
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v7
-
-      - name: Install dependencies
-        working-directory: backend
-        run: |
-          uv sync --group dev
-
-      - name: Lint backend
-        working-directory: backend
-        run: make lint
-
-  lint-frontend:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-
-      - name: Enable Corepack
-        run: corepack enable
-
-      - name: Use pinned pnpm version
-        run: corepack prepare pnpm@10.26.2 --activate
-
-      - name: Install frontend dependencies
-        run: |
-          cd frontend
-          pnpm install --frozen-lockfile
-
-      - name: Check frontend formatting
-        run: |
-          cd frontend
-          pnpm format
-
-      - name: Run frontend linting
-        run: |
-          cd frontend
-          pnpm lint
-
-      - name: Check TypeScript types
-        run: |
-          cd frontend
-          pnpm typecheck
-
-      - name: Build frontend
-        run: |
-          cd frontend
-          BETTER_AUTH_SECRET=local-dev-secret pnpm build

.github/workflows/lint.yaml

@@ -0,0 +1,28 @@
+name: Lint Check
+
+on:
+  push:
+    branches: [ 'main' ]
+  pull_request:
+    branches: [ '*' ]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install the latest version of uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        version: "latest"
+
+    - name: Install dependencies
+      run: |
+        uv venv --python 3.12
+        uv pip install -e ".[dev]"
+
+    - name: Run linters
+      run: |
+        source .venv/bin/activate
+        make lint

.github/workflows/unittest.yaml

@@ -0,0 +1,29 @@
+name: Test Cases Check
+
+on:
+  push:
+    branches: [ 'main' ]
+  pull_request:
+    branches: [ '*' ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install the latest version of uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        version: "latest"
+
+    - name: Install dependencies
+      run: |
+        uv venv --python 3.12
+        uv pip install -e ".[dev]"
+        uv pip install -e ".[test]"
+
+    - name: Run test cases
+      run: |
+        source .venv/bin/activate
+        TAVILY_API_KEY=mock-key make test

.gitignore

@@ -1,59 +1,23 @@
-# DeerFlow docker image cache
+# Python-generated files
-docker/.cache/
-# oh-my-claudecode state
-.omc/
-# OS generated files
-.DS_Store
-*.local
-._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
-Thumbs.db
-
-# Python cache
 __pycache__/
-*.pyc
+*.py[oc]
-*.pyo
+build/
+dist/
+wheels/
+*.egg-info
+.coverage
+agent_history.gif
+static/browser_history/*.gif
 
 # Virtual environments
 .venv
-venv/
 
 # Environment variables
 .env
 
-# Configuration files
+# user conf
-config.yaml
+conf.yaml
-mcp_config.json
-extensions_config.json
 
-# IDE
 .idea/
-.vscode/
+.langgraph_api/
 
-# Coverage report
-coverage.xml
-coverage/
-.deer-flow/
-.claude/
-skills/custom/*
-logs/
-log/
-
-# Local git hooks (keep only on this machine, do not push)
-.githooks/
-
-# pnpm
-.pnpm-store
-sandbox_image_cache.tar
-
-# ignore the legacy `web` folder
-web/
-
-# Deployment artifacts
-backend/Dockerfile.langgraph
-config.yaml.bak
-.playwright-mcp
-.gstack/
-.worktrees

.vscode/launch.json

@@ -0,0 +1,60 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: 当前文件",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal",
+            "justMyCode": true
+        },
+        {
+            "name": "Python: main.py",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${workspaceFolder}/main.py",
+            "console": "integratedTerminal",
+            "justMyCode": false,
+            "env": {
+                "PYTHONPATH": "${workspaceFolder}"
+            },
+            "args": [
+                "--debug", "--max_plan_iterations", "1", "--max_step_num", "1"
+            ]
+        },
+        {
+            "name": "Python: llm.py",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${workspaceFolder}/src/llms/llm.py",
+            "console": "integratedTerminal",
+            "justMyCode": true,
+            "env": {
+                "PYTHONPATH": "${workspaceFolder}"
+            }
+        },
+        {
+            "name": "Python: server.py",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${workspaceFolder}/server.py",
+            "console": "integratedTerminal",
+            "justMyCode": false,
+            "env": {
+                "PYTHONPATH": "${workspaceFolder}"
+            }
+        },
+        {
+            "name": "Python: graph.py",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${workspaceFolder}/src/ppt/graph/builder.py",
+            "console": "integratedTerminal",
+            "justMyCode": false,
+            "env": {
+                "PYTHONPATH": "${workspaceFolder}"
+            }
+        },
+    ]
+}

CONTRIBUTING

@@ -0,0 +1,133 @@
+# Contributing to DeerFlow
+
+Thank you for your interest in contributing to DeerFlow! We welcome contributions of all kinds from the community.
+
+## Ways to Contribute
+
+There are many ways you can contribute to DeerFlow:
+
+- **Code Contributions**: Add new features, fix bugs, or improve performance
+- **Documentation**: Improve README, add code comments, or create examples
+- **Bug Reports**: Submit detailed bug reports through issues
+- **Feature Requests**: Suggest new features or improvements
+- **Code Reviews**: Review pull requests from other contributors
+- **Community Support**: Help others in discussions and issues
+
+## Development Setup
+
+1. Fork the repository
+2. Clone your fork:
+   ```bash
+   git clone https://github.com/bytedance/deer-flow.git
+   cd deer-flow
+   ```
+3. Set up your development environment:
+   ```bash
+   # Install dependencies, uv will take care of the python interpreter and venv creation
+   uv sync
+
+   # For development, install additional dependencies
+   uv pip install -e ".[dev]"
+   uv pip install -e ".[test]"
+   ```
+4. Configure pre-commit hooks:
+   ```bash
+   chmod +x pre-commit
+   ln -s ../../pre-commit .git/hooks/pre-commit
+   ```
+
+## Development Process
+
+1. Create a new branch:
+   ```bash
+   git checkout -b feature/amazing-feature
+   ```
+
+2. Make your changes following our coding standards:
+   - Write clear, documented code
+   - Follow PEP 8 style guidelines
+   - Add tests for new features
+   - Update documentation as needed
+
+3. Run tests and checks:
+   ```bash
+   make test      # Run tests
+   make lint      # Run linting
+   make format    # Format code
+   make coverage  # Check test coverage
+   ```
+
+4. Commit your changes:
+   ```bash
+   git commit -m 'Add some amazing feature'
+   ```
+
+5. Push to your fork:
+   ```bash
+   git push origin feature/amazing-feature
+   ```
+
+6. Open a Pull Request
+
+## Pull Request Guidelines
+
+- Fill in the pull request template completely
+- Include tests for new features
+- Update documentation as needed
+- Ensure all tests pass and there are no linting errors
+- Keep pull requests focused on a single feature or fix
+- Reference any related issues
+
+## Code Style
+
+- Follow PEP 8 guidelines
+- Use type hints where possible
+- Write descriptive docstrings
+- Keep functions and methods focused and single-purpose
+- Comment complex logic
+- Python version requirement: >= 3.12
+
+## Testing
+
+Run the test suite:
+```bash
+# Run all tests
+make test
+
+# Run specific test file
+pytest tests/integration/test_workflow.py
+
+# Run with coverage
+make coverage
+```
+
+## Code Quality
+
+```bash
+# Run linting
+make lint
+
+# Format code
+make format
+```
+
+## Community Guidelines
+
+- Be respectful and inclusive
+- Follow our code of conduct
+- Help others learn and grow
+- Give constructive feedback
+- Stay focused on improving the project
+
+## Need Help?
+
+If you need help with anything:
+- Check existing issues and discussions
+- Join our community channels
+- Ask questions in discussions
+
+## License
+
+By contributing to DeerFlow, you agree that your contributions will be licensed under the MIT License.
+
+We appreciate your contributions to making DeerFlow better!

CONTRIBUTING.md

@@ -1,323 +0,0 @@
-# Contributing to DeerFlow
-
-Thank you for your interest in contributing to DeerFlow! This guide will help you set up your development environment and understand our development workflow.
-
-## Development Environment Setup
-
-We offer two development environments. **Docker is recommended** for the most consistent and hassle-free experience.
-
-### Option 1: Docker Development (Recommended)
-
-Docker provides a consistent, isolated environment with all dependencies pre-configured. No need to install Node.js, Python, or nginx on your local machine.
-
-#### Prerequisites
-
-- Docker Desktop or Docker Engine
-- pnpm (for caching optimization)
-
-#### Setup Steps
-
-1. **Configure the application**:
-   ```bash
-   # Copy example configuration
-   cp config.example.yaml config.yaml
-
-   # Set your API keys
-   export OPENAI_API_KEY="your-key-here"
-   # or edit config.yaml directly
-   ```
-
-2. **Initialize Docker environment** (first time only):
-   ```bash
-   make docker-init
-   ```
-   This will:
-   - Build Docker images
-   - Install frontend dependencies (pnpm)
-   - Install backend dependencies (uv)
-   - Share pnpm cache with host for faster builds
-
-3. **Start development services**:
-   ```bash
-   make docker-start
-   ```
-   `make docker-start` reads `config.yaml` and starts `provisioner` only for provisioner/Kubernetes sandbox mode.
-
-   All services will start with hot-reload enabled:
-   - Frontend changes are automatically reloaded
-   - Backend changes trigger automatic restart
-   - LangGraph server supports hot-reload
-
-4. **Access the application**:
-   - Web Interface: http://localhost:2026
-   - API Gateway: http://localhost:2026/api/*
-   - LangGraph: http://localhost:2026/api/langgraph/*
-
-#### Docker Commands
-
-```bash
-# Build the custom k3s image (with pre-cached sandbox image)
-make docker-init
-# Start Docker services (mode-aware, localhost:2026)
-make docker-start
-# Stop Docker development services
-make docker-stop
-# View Docker development logs
-make docker-logs
-# View Docker frontend logs
-make docker-logs-frontend
-# View Docker gateway logs
-make docker-logs-gateway
-```
-
-If Docker builds are slow in your network, you can override the default package registries before running `make docker-init` or `make docker-start`:
-
-```bash
-export UV_INDEX_URL=https://pypi.org/simple
-export NPM_REGISTRY=https://registry.npmjs.org
-```
-
-#### Linux: Docker daemon permission denied
-
-If `make docker-init`, `make docker-start`, or `make docker-stop` fails on Linux with an error like below, your current user likely does not have permission to access the Docker daemon socket:
-
-```text
-unable to get image 'deer-flow-dev-langgraph': permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock
-```
-
-Recommended fix: add your current user to the `docker` group so Docker commands work without `sudo`.
-
-1. Confirm the `docker` group exists:
-   ```bash
-   getent group docker
-   ```
-2. Add your current user to the `docker` group:
-   ```bash
-   sudo usermod -aG docker $USER
-   ```
-3. Apply the new group membership. The most reliable option is to log out completely and then log back in. If you want to refresh the current shell session instead, run:
-   ```bash
-   newgrp docker
-   ```
-4. Verify Docker access:
-   ```bash
-   docker ps
-   ```
-5. Retry the DeerFlow command:
-   ```bash
-   make docker-stop
-   make docker-start
-   ```
-
-If `docker ps` still reports a permission error after `usermod`, fully log out and log back in before retrying.
-
-#### Docker Architecture
-
-```
-Host Machine
-  ↓
-Docker Compose (deer-flow-dev)
-  ├→ nginx (port 2026) ← Reverse proxy
-  ├→ web (port 3000) ← Frontend with hot-reload
-  ├→ api (port 8001) ← Gateway API with hot-reload
-   ├→ langgraph (port 2024) ← LangGraph server with hot-reload
-   └→ provisioner (optional, port 8002) ← Started only in provisioner/K8s sandbox mode
-```
-
-**Benefits of Docker Development**:
-- ✅ Consistent environment across different machines
-- ✅ No need to install Node.js, Python, or nginx locally
-- ✅ Isolated dependencies and services
-- ✅ Easy cleanup and reset
-- ✅ Hot-reload for all services
-- ✅ Production-like environment
-
-### Option 2: Local Development
-
-If you prefer to run services directly on your machine:
-
-#### Prerequisites
-
-Check that you have all required tools installed:
-
-```bash
-make check
-```
-
-Required tools:
-- Node.js 22+
-- pnpm
-- uv (Python package manager)
-- nginx
-
-#### Setup Steps
-
-1. **Configure the application** (same as Docker setup above)
-
-2. **Install dependencies**:
-   ```bash
-   make install
-   ```
-
-3. **Run development server** (starts all services with nginx):
-   ```bash
-   make dev
-   ```
-
-4. **Access the application**:
-   - Web Interface: http://localhost:2026
-   - All API requests are automatically proxied through nginx
-
-#### Manual Service Control
-
-If you need to start services individually:
-
-1. **Start backend services**:
-   ```bash
-   # Terminal 1: Start LangGraph Server (port 2024)
-   cd backend
-   make dev
-
-   # Terminal 2: Start Gateway API (port 8001)
-   cd backend
-   make gateway
-
-   # Terminal 3: Start Frontend (port 3000)
-   cd frontend
-   pnpm dev
-   ```
-
-2. **Start nginx**:
-   ```bash
-   make nginx
-   # or directly: nginx -c $(pwd)/docker/nginx/nginx.local.conf -g 'daemon off;'
-   ```
-
-3. **Access the application**:
-   - Web Interface: http://localhost:2026
-
-#### Nginx Configuration
-
-The nginx configuration provides:
-- Unified entry point on port 2026
-- Routes `/api/langgraph/*` to LangGraph Server (2024)
-- Routes other `/api/*` endpoints to Gateway API (8001)
-- Routes non-API requests to Frontend (3000)
-- Centralized CORS handling
-- SSE/streaming support for real-time agent responses
-- Optimized timeouts for long-running operations
-
-## Project Structure
-
-```
-deer-flow/
-├── config.example.yaml      # Configuration template
-├── extensions_config.example.json  # MCP and Skills configuration template
-├── Makefile                 # Build and development commands
-├── scripts/
-│   └── docker.sh           # Docker management script
-├── docker/
-│   ├── docker-compose-dev.yaml  # Docker Compose configuration
-│   └── nginx/
-│       ├── nginx.conf      # Nginx config for Docker
-│       └── nginx.local.conf # Nginx config for local dev
-├── backend/                 # Backend application
-│   ├── src/
-│   │   ├── gateway/        # Gateway API (port 8001)
-│   │   ├── agents/         # LangGraph agents (port 2024)
-│   │   ├── mcp/            # Model Context Protocol integration
-│   │   ├── skills/         # Skills system
-│   │   └── sandbox/        # Sandbox execution
-│   ├── docs/               # Backend documentation
-│   └── Makefile            # Backend commands
-├── frontend/               # Frontend application
-│   └── Makefile            # Frontend commands
-└── skills/                 # Agent skills
-    ├── public/             # Public skills
-    └── custom/             # Custom skills
-```
-
-## Architecture
-
-```
-Browser
-  ↓
-Nginx (port 2026) ← Unified entry point
-  ├→ Frontend (port 3000) ← / (non-API requests)
-  ├→ Gateway API (port 8001) ← /api/models, /api/mcp, /api/skills, /api/threads/*/artifacts
-  └→ LangGraph Server (port 2024) ← /api/langgraph/* (agent interactions)
-```
-
-## Development Workflow
-
-1. **Create a feature branch**:
-   ```bash
-   git checkout -b feature/your-feature-name
-   ```
-
-2. **Make your changes** with hot-reload enabled
-
-3. **Format and lint your code** (CI will reject unformatted code):
-   ```bash
-   # Backend
-   cd backend
-   make format   # ruff check --fix + ruff format
-
-   # Frontend
-   cd frontend
-   pnpm format:write   # Prettier
-   ```
-
-4. **Test your changes** thoroughly
-
-5. **Commit your changes**:
-   ```bash
-   git add .
-   git commit -m "feat: description of your changes"
-   ```
-
-6. **Push and create a Pull Request**:
-   ```bash
-   git push origin feature/your-feature-name
-   ```
-
-## Testing
-
-```bash
-# Backend tests
-cd backend
-uv run pytest
-
-# Frontend checks
-cd frontend
-pnpm check
-```
-
-### PR Regression Checks
-
-Every pull request runs the backend regression workflow at [.github/workflows/backend-unit-tests.yml](.github/workflows/backend-unit-tests.yml), including:
-
-- `tests/test_provisioner_kubeconfig.py`
-- `tests/test_docker_sandbox_mode_detection.py`
-
-## Code Style
-
-- **Backend (Python)**: We use `ruff` for linting and formatting. Run `make format` before committing.
-- **Frontend (TypeScript)**: We use ESLint and Prettier. Run `pnpm format:write` before committing.
-- CI enforces formatting — PRs with unformatted code will fail the lint check.
-
-## Documentation
-
-- [Configuration Guide](backend/docs/CONFIGURATION.md) - Setup and configuration
-- [Architecture Overview](backend/CLAUDE.md) - Technical architecture
-- [MCP Setup Guide](backend/docs/MCP_SERVER.md) - Model Context Protocol configuration
-
-## Need Help?
-
-- Check existing [Issues](https://github.com/bytedance/deer-flow/issues)
-- Read the [Documentation](backend/docs/)
-- Ask questions in [Discussions](https://github.com/bytedance/deer-flow/discussions)
-
-## License
-
-By contributing to DeerFlow, you agree that your contributions will be licensed under the [MIT License](./LICENSE).

Dockerfile

@@ -0,0 +1,17 @@
+FROM ghcr.io/astral-sh/uv:python3.12-bookworm
+
+# Install uv.
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
+
+WORKDIR /app
+
+# Copy the application into the container.
+COPY . /app
+
+# Install the application dependencies.
+RUN uv sync --frozen --no-cache
+
+EXPOSE 8000
+
+# Run the application.
+CMD ["uv", "run", "python", "server.py", "--host", "0.0.0.0", "--port", "8000"]

Install.md

@@ -1,87 +0,0 @@
-# DeerFlow Install
-
-This file is for coding agents. If the DeerFlow repository is not already cloned and open, clone `https://github.com/bytedance/deer-flow.git` first, then continue from the repository root.
-
-## Goal
-
-Bootstrap a DeerFlow local development workspace on the user's machine with the least risky path available.
-
-Default preference:
-
-1. Docker development environment
-2. Local development environment
-
-Do not assume API keys or model credentials exist. Set up everything that can be prepared safely, then stop with a concise summary of what the user still needs to provide.
-
-## Operating Rules
-
-- Be idempotent. Re-running this document should not damage an existing setup.
-- Prefer existing repo commands over ad hoc shell commands.
-- Do not use `sudo` or install system packages without explicit user approval.
-- Do not overwrite existing user config values unless the user asks.
-- If a step fails, stop, explain the blocker, and provide the smallest next action.
-- If multiple setup paths are possible, prefer Docker when Docker is already available.
-
-## Success Criteria
-
-Consider the setup successful when all of the following are true:
-
-- The DeerFlow repository is cloned and the current working directory is the repo root.
-- `config.yaml` exists.
-- For Docker setup, `make docker-init` completed successfully and Docker prerequisites are prepared, but services are not assumed to be running yet.
-- For local setup, `make check` passed or reported no missing prerequisites, and `make install` completed successfully.
-- The user receives the exact next command to launch DeerFlow.
-- The user also receives any missing model configuration or referenced environment variable names from `config.yaml`, without inspecting secret-bearing files for actual values.
-
-## Steps
-
-- If the current directory is not the DeerFlow repository root, clone `https://github.com/bytedance/deer-flow.git` if needed, then change into the repository root.
-- Confirm the current directory is the DeerFlow repository root by checking that `Makefile`, `backend/`, `frontend/`, and `config.example.yaml` exist.
-- Detect whether `config.yaml` already exists.
-- If `config.yaml` does not exist, run `make config`.
-- Detect whether Docker is available and the daemon is reachable with `docker info`.
-- If Docker is available:
-  - Run `make docker-init`.
-  - Treat this as Docker prerequisite preparation only. Do not claim that app services, compose validation, or image builds have already succeeded.
-  - Do not start long-running services unless the user explicitly asks or this setup request clearly includes launch verification.
-  - Tell the user the recommended next command is `make docker-start`.
-- If Docker is not available:
-  - Run `make check`.
-  - If `make check` reports missing system dependencies such as `node`, `pnpm`, `uv`, or `nginx`, stop and report the missing tools instead of attempting privileged installs.
-  - If prerequisites are satisfied, run `make install`.
-  - Tell the user the recommended next command is `make dev`.
-- Inspect `config.yaml` only for missing model entries or referenced environment variable placeholders. Do not read `.env`, `frontend/.env`, or other secret-bearing files.
-- If no model is configured, tell the user they must add at least one entry under `models` in `config.yaml`.
-- If `config.yaml` references variables such as `$OPENAI_API_KEY`, tell the user which variable names still need real values, but do not verify them by opening secret-bearing files.
-- If the repository already appears configured, avoid repeating expensive work unless it is necessary to verify the environment.
-
-## Verification
-
-Use the lightest verification that matches the chosen setup path.
-
-For Docker setup:
-
-- Confirm `make docker-init` completed successfully.
-- Confirm `config.yaml` exists.
-- State explicitly that Docker services were not started and `make docker-start` is still the first real launch step.
-- Do not leave background services running unless the user asked for that.
-
-For local setup:
-
-- Confirm `make install` completed successfully.
-- Confirm `config.yaml` exists.
-- Do not leave background services running unless the user asked for that.
-
-## Final Response Format
-
-Return a short status report with:
-
-1. Setup path used: Docker or local
-2. Setup level reached: Docker prerequisites prepared or local dependencies installed
-3. Files created or detected: for example `config.yaml`
-4. Remaining user action: model config, env var values, auth files, or nothing
-5. Exact next command to start DeerFlow
-
-## EXECUTE NOW
-
-Complete the steps above. When finished, stop after the setup boundary and report status instead of continuing into unrelated project work.

LICENSE

@@ -1,7 +1,6 @@
 MIT License
 
 Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
-Copyright (c) 2025-2026 DeerFlow Authors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,234 +1,22 @@
-# DeerFlow - Unified Development Environment
+.PHONY: lint format install-dev serve test coverage
 
-.PHONY: help config config-upgrade check install dev dev-pro dev-daemon dev-daemon-pro start start-pro start-daemon start-daemon-pro stop up up-pro down clean docker-init docker-start docker-start-pro docker-stop docker-logs docker-logs-frontend docker-logs-gateway
+install-dev:
+	uv pip install -e ".[dev]" && uv pip install -e ".[test]"
 
-BASH ?= bash
+format:
+	uv run black --preview .
 
-# Detect OS for Windows compatibility
+lint:
-ifeq ($(OS),Windows_NT)
+	uv run black --check .
-    SHELL := cmd.exe
-    PYTHON ?= python
-else
-    PYTHON ?= python3
-endif
 
-help:
+serve:
-	@echo "DeerFlow Development Commands:"
+	uv run server.py --reload
-	@echo "  make config          - Generate local config files (aborts if config already exists)"
-	@echo "  make config-upgrade  - Merge new fields from config.example.yaml into config.yaml"
-	@echo "  make check           - Check if all required tools are installed"
-	@echo "  make install         - Install all dependencies (frontend + backend)"
-	@echo "  make setup-sandbox   - Pre-pull sandbox container image (recommended)"
-	@echo "  make dev             - Start all services in development mode (with hot-reloading)"
-	@echo "  make dev-pro         - Start in dev + Gateway mode (experimental, no LangGraph server)"
-	@echo "  make dev-daemon      - Start dev services in background (daemon mode)"
-	@echo "  make dev-daemon-pro  - Start dev daemon + Gateway mode (experimental)"
-	@echo "  make start           - Start all services in production mode (optimized, no hot-reloading)"
-	@echo "  make start-pro       - Start in prod + Gateway mode (experimental)"
-	@echo "  make start-daemon    - Start prod services in background (daemon mode)"
-	@echo "  make start-daemon-pro - Start prod daemon + Gateway mode (experimental)"
-	@echo "  make stop            - Stop all running services"
-	@echo "  make clean           - Clean up processes and temporary files"
-	@echo ""
-	@echo "Docker Production Commands:"
-	@echo "  make up              - Build and start production Docker services (localhost:2026)"
-	@echo "  make up-pro          - Build and start production Docker in Gateway mode (experimental)"
-	@echo "  make down            - Stop and remove production Docker containers"
-	@echo ""
-	@echo "Docker Development Commands:"
-	@echo "  make docker-init     - Pull the sandbox image"
-	@echo "  make docker-start    - Start Docker services (mode-aware from config.yaml, localhost:2026)"
-	@echo "  make docker-start-pro - Start Docker in Gateway mode (experimental, no LangGraph container)"
-	@echo "  make docker-stop     - Stop Docker development services"
-	@echo "  make docker-logs     - View Docker development logs"
-	@echo "  make docker-logs-frontend - View Docker frontend logs"
-	@echo "  make docker-logs-gateway - View Docker gateway logs"
 
-config:
+test:
-	@$(PYTHON) ./scripts/configure.py
+	uv run pytest tests/
 
-config-upgrade:
+langgraph-dev:
-	@./scripts/config-upgrade.sh
+	uvx --refresh --from "langgraph-cli[inmem]" --with-editable . --python 3.12 langgraph dev --allow-blocking
 
-# Check required tools
+coverage:
-check:
+	uv run pytest --cov=src tests/ --cov-report=term-missing
-	@$(PYTHON) ./scripts/check.py
-
-# Install all dependencies
-install:
-	@echo "Installing backend dependencies..."
-	@cd backend && uv sync
-	@echo "Installing frontend dependencies..."
-	@cd frontend && pnpm install
-	@echo "✓ All dependencies installed"
-	@echo ""
-	@echo "=========================================="
-	@echo "  Optional: Pre-pull Sandbox Image"
-	@echo "=========================================="
-	@echo ""
-	@echo "If you plan to use Docker/Container-based sandbox, you can pre-pull the image:"
-	@echo "  make setup-sandbox"
-	@echo ""
-
-# Pre-pull sandbox Docker image (optional but recommended)
-setup-sandbox:
-	@echo "=========================================="
-	@echo "  Pre-pulling Sandbox Container Image"
-	@echo "=========================================="
-	@echo ""
-	@IMAGE=$$(grep -A 20 "# sandbox:" config.yaml 2>/dev/null | grep "image:" | awk '{print $$2}' | head -1); \
-	if [ -z "$$IMAGE" ]; then \
-		IMAGE="enterprise-public-cn-beijing.cr.volces.com/vefaas-public/all-in-one-sandbox:latest"; \
-		echo "Using default image: $$IMAGE"; \
-	else \
-		echo "Using configured image: $$IMAGE"; \
-	fi; \
-	echo ""; \
-	if command -v container >/dev/null 2>&1 && [ "$$(uname)" = "Darwin" ]; then \
-		echo "Detected Apple Container on macOS, pulling image..."; \
-		container pull "$$IMAGE" || echo "⚠ Apple Container pull failed, will try Docker"; \
-	fi; \
-	if command -v docker >/dev/null 2>&1; then \
-		echo "Pulling image using Docker..."; \
-		if docker pull "$$IMAGE"; then \
-			echo ""; \
-			echo "✓ Sandbox image pulled successfully"; \
-		else \
-			echo ""; \
-			echo "⚠ Failed to pull sandbox image (this is OK for local sandbox mode)"; \
-		fi; \
-	else \
-		echo "✗ Neither Docker nor Apple Container is available"; \
-		echo "  Please install Docker: https://docs.docker.com/get-docker/"; \
-		exit 1; \
-	fi
-
-# Start all services in development mode (with hot-reloading)
-dev:
-	@$(PYTHON) ./scripts/check.py
-ifeq ($(OS),Windows_NT)
-	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --dev
-else
-	@./scripts/serve.sh --dev
-endif
-
-# Start all services in dev + Gateway mode (experimental: agent runtime embedded in Gateway)
-dev-pro:
-	@$(PYTHON) ./scripts/check.py
-ifeq ($(OS),Windows_NT)
-	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --dev --gateway
-else
-	@./scripts/serve.sh --dev --gateway
-endif
-
-# Start all services in production mode (with optimizations)
-start:
-	@$(PYTHON) ./scripts/check.py
-ifeq ($(OS),Windows_NT)
-	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --prod
-else
-	@./scripts/serve.sh --prod
-endif
-
-# Start all services in prod + Gateway mode (experimental)
-start-pro:
-	@$(PYTHON) ./scripts/check.py
-ifeq ($(OS),Windows_NT)
-	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --prod --gateway
-else
-	@./scripts/serve.sh --prod --gateway
-endif
-
-# Start all services in daemon mode (background)
-dev-daemon:
-	@$(PYTHON) ./scripts/check.py
-ifeq ($(OS),Windows_NT)
-	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --dev --daemon
-else
-	@./scripts/serve.sh --dev --daemon
-endif
-
-# Start daemon + Gateway mode (experimental)
-dev-daemon-pro:
-	@$(PYTHON) ./scripts/check.py
-ifeq ($(OS),Windows_NT)
-	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --dev --gateway --daemon
-else
-	@./scripts/serve.sh --dev --gateway --daemon
-endif
-
-# Start prod services in daemon mode (background)
-start-daemon:
-	@$(PYTHON) ./scripts/check.py
-ifeq ($(OS),Windows_NT)
-	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --prod --daemon
-else
-	@./scripts/serve.sh --prod --daemon
-endif
-
-# Start prod daemon + Gateway mode (experimental)
-start-daemon-pro:
-	@$(PYTHON) ./scripts/check.py
-ifeq ($(OS),Windows_NT)
-	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --prod --gateway --daemon
-else
-	@./scripts/serve.sh --prod --gateway --daemon
-endif
-
-# Stop all services
-stop:
-	@./scripts/serve.sh --stop
-
-# Clean up
-clean: stop
-	@echo "Cleaning up..."
-	@-rm -rf backend/.deer-flow 2>/dev/null || true
-	@-rm -rf backend/.langgraph_api 2>/dev/null || true
-	@-rm -rf logs/*.log 2>/dev/null || true
-	@echo "✓ Cleanup complete"
-
-# ==========================================
-# Docker Development Commands
-# ==========================================
-
-# Initialize Docker containers and install dependencies
-docker-init:
-	@./scripts/docker.sh init
-
-# Start Docker development environment
-docker-start:
-	@./scripts/docker.sh start
-
-# Start Docker in Gateway mode (experimental)
-docker-start-pro:
-	@./scripts/docker.sh start --gateway
-
-# Stop Docker development environment
-docker-stop:
-	@./scripts/docker.sh stop
-
-# View Docker development logs
-docker-logs:
-	@./scripts/docker.sh logs
-
-# View Docker development logs
-docker-logs-frontend:
-	@./scripts/docker.sh logs --frontend
-docker-logs-gateway:
-	@./scripts/docker.sh logs --gateway
-
-# ==========================================
-# Production Docker Commands
-# ==========================================
-
-# Build and start production services
-up:
-	@./scripts/deploy.sh
-
-# Build and start production services in Gateway mode
-up-pro:
-	@./scripts/deploy.sh --gateway
-
-# Stop and remove production containers
-down:
-	@./scripts/deploy.sh down

README_de.md

@@ -0,0 +1,495 @@
+# 🦌 DeerFlow
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![DeepWiki](https://img.shields.io/badge/DeepWiki-bytedance%2Fdeer--flow-blue.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACwAAAAyCAYAAAAnWDnqAAAAAXNSR0IArs4c6QAAA05JREFUaEPtmUtyEzEQhtWTQyQLHNak2AB7ZnyXZMEjXMGeK/AIi+QuHrMnbChYY7MIh8g01fJoopFb0uhhEqqcbWTp06/uv1saEDv4O3n3dV60RfP947Mm9/SQc0ICFQgzfc4CYZoTPAswgSJCCUJUnAAoRHOAUOcATwbmVLWdGoH//PB8mnKqScAhsD0kYP3j/Yt5LPQe2KvcXmGvRHcDnpxfL2zOYJ1mFwrryWTz0advv1Ut4CJgf5uhDuDj5eUcAUoahrdY/56ebRWeraTjMt/00Sh3UDtjgHtQNHwcRGOC98BJEAEymycmYcWwOprTgcB6VZ5JK5TAJ+fXGLBm3FDAmn6oPPjR4rKCAoJCal2eAiQp2x0vxTPB3ALO2CRkwmDy5WohzBDwSEFKRwPbknEggCPB/imwrycgxX2NzoMCHhPkDwqYMr9tRcP5qNrMZHkVnOjRMWwLCcr8ohBVb1OMjxLwGCvjTikrsBOiA6fNyCrm8V1rP93iVPpwaE+gO0SsWmPiXB+jikdf6SizrT5qKasx5j8ABbHpFTx+vFXp9EnYQmLx02h1QTTrl6eDqxLnGjporxl3NL3agEvXdT0WmEost648sQOYAeJS9Q7bfUVoMGnjo4AZdUMQku50McDcMWcBPvr0SzbTAFDfvJqwLzgxwATnCgnp4wDl6Aa+Ax283gghmj+vj7feE2KBBRMW3FzOpLOADl0Isb5587h/U4gGvkt5v60Z1VLG8BhYjbzRwyQZemwAd6cCR5/XFWLYZRIMpX39AR0tjaGGiGzLVyhse5C9RKC6ai42ppWPKiBagOvaYk8lO7DajerabOZP46Lby5wKjw1HCRx7p9sVMOWGzb/vA1hwiWc6jm3MvQDTogQkiqIhJV0nBQBTU+3okKCFDy9WwferkHjtxib7t3xIUQtHxnIwtx4mpg26/HfwVNVDb4oI9RHmx5WGelRVlrtiw43zboCLaxv46AZeB3IlTkwouebTr1y2NjSpHz68WNFjHvupy3q8TFn3Hos2IAk4Ju5dCo8B3wP7VPr/FGaKiG+T+v+TQqIrOqMTL1VdWV1DdmcbO8KXBz6esmYWYKPwDL5b5FA1a0hwapHiom0r/cKaoqr+27/XcrS5UwSMbQAAAABJRU5ErkJggg==)](https://deepwiki.com/bytedance/deer-flow)
+<!-- DeepWiki badge generated by https://deepwiki.ryoppippi.com/ -->
+
+[English](./README.md) | [简体中文](./README_zh.md) | [日本語](./README_ja.md) | [Deutsch](./README_de.md)
+
+> Aus Open Source entstanden, an Open Source zurückgeben.
+
+**DeerFlow** (**D**eep **E**xploration and **E**fficient **R**esearch **Flow**) ist ein Community-getriebenes Framework für tiefgehende Recherche, das auf der großartigen Arbeit der Open-Source-Community aufbaut. Unser Ziel ist es, Sprachmodelle mit spezialisierten Werkzeugen für Aufgaben wie Websuche, Crawling und Python-Code-Ausführung zu kombinieren und gleichzeitig der Community, die dies möglich gemacht hat, etwas zurückzugeben.
+
+Besuchen Sie [unsere offizielle Website](https://deerflow.tech/) für weitere Details.
+
+## Demo
+
+### Video
+
+https://github.com/user-attachments/assets/f3786598-1f2a-4d07-919e-8b99dfa1de3e
+
+In dieser Demo zeigen wir, wie man DeerFlow nutzt, um:
+- Nahtlos mit MCP-Diensten zu integrieren
+- Den Prozess der tiefgehenden Recherche durchzuführen und einen umfassenden Bericht mit Bildern zu erstellen
+- Podcast-Audio basierend auf dem generierten Bericht zu erstellen
+
+### Wiedergaben
+
+- [Wie hoch ist der Eiffelturm im Vergleich zum höchsten Gebäude?](https://deerflow.tech/chat?replay=eiffel-tower-vs-tallest-building)
+- [Was sind die angesagtesten Repositories auf GitHub?](https://deerflow.tech/chat?replay=github-top-trending-repo)
+- [Einen Artikel über traditionelle Gerichte aus Nanjing schreiben](https://deerflow.tech/chat?replay=nanjing-traditional-dishes)
+- [Wie dekoriert man eine Mietwohnung?](https://deerflow.tech/chat?replay=rental-apartment-decoration)
+- [Besuchen Sie unsere offizielle Website, um weitere Wiedergaben zu entdecken.](https://deerflow.tech/#case-studies)
+
+---
+
+
+## 📑 Inhaltsverzeichnis
+
+- [🚀 Schnellstart](#schnellstart)
+- [🌟 Funktionen](#funktionen)
+- [🏗️ Architektur](#architektur)
+- [🛠️ Entwicklung](#entwicklung)
+- [🗣️ Text-zu-Sprache-Integration](#text-zu-sprache-integration)
+- [📚 Beispiele](#beispiele)
+- [❓ FAQ](#faq)
+- [📜 Lizenz](#lizenz)
+- [💖 Danksagungen](#danksagungen)
+- [⭐ Star-Verlauf](#star-verlauf)
+
+
+## Schnellstart
+
+DeerFlow ist in Python entwickelt und kommt mit einer in Node.js geschriebenen Web-UI. Um einen reibungslosen Einrichtungsprozess zu gewährleisten, empfehlen wir die Verwendung der folgenden Tools:
+
+### Empfohlene Tools
+- **[`uv`](https://docs.astral.sh/uv/getting-started/installation/):**
+  Vereinfacht die Verwaltung von Python-Umgebungen und Abhängigkeiten. `uv` erstellt automatisch eine virtuelle Umgebung im Stammverzeichnis und installiert alle erforderlichen Pakete für Sie—keine manuelle Installation von Python-Umgebungen notwendig.
+
+- **[`nvm`](https://github.com/nvm-sh/nvm):**
+  Verwalten Sie mühelos mehrere Versionen der Node.js-Laufzeit.
+
+- **[`pnpm`](https://pnpm.io/installation):**
+  Installieren und verwalten Sie Abhängigkeiten des Node.js-Projekts.
+
+### Umgebungsanforderungen
+Stellen Sie sicher, dass Ihr System die folgenden Mindestanforderungen erfüllt:
+- **[Python](https://www.python.org/downloads/):** Version `3.12+`
+- **[Node.js](https://nodejs.org/en/download/):** Version `22+`
+
+### Installation
+```bash
+# Repository klonen
+git clone https://github.com/bytedance/deer-flow.git
+cd deer-flow
+
+# Abhängigkeiten installieren, uv kümmert sich um den Python-Interpreter und die Erstellung der venv sowie die Installation der erforderlichen Pakete
+uv sync
+
+# Konfigurieren Sie .env mit Ihren API-Schlüsseln
+# Tavily: https://app.tavily.com/home
+# Brave_SEARCH: https://brave.com/search/api/
+# volcengine TTS: Fügen Sie Ihre TTS-Anmeldedaten hinzu, falls vorhanden
+cp .env.example .env
+
+# Siehe die Abschnitte 'Unterstützte Suchmaschinen' und 'Text-zu-Sprache-Integration' unten für alle verfügbaren Optionen
+
+# Konfigurieren Sie conf.yaml für Ihr LLM-Modell und API-Schlüssel
+# Weitere Details finden Sie unter 'docs/configuration_guide.md'
+cp conf.yaml.example conf.yaml
+
+# Installieren Sie marp für PPT-Generierung
+# https://github.com/marp-team/marp-cli?tab=readme-ov-file#use-package-manager
+brew install marp-cli
+```
+
+Optional können Sie Web-UI-Abhängigkeiten über [pnpm](https://pnpm.io/installation) installieren:
+
+```bash
+cd deer-flow/web
+pnpm install
+```
+
+### Konfigurationen
+
+Weitere Informationen finden Sie im [Konfigurationsleitfaden](docs/configuration_guide.md).
+
+> [!HINWEIS]
+> Lesen Sie den Leitfaden sorgfältig, bevor Sie das Projekt starten, und aktualisieren Sie die Konfigurationen entsprechend Ihren spezifischen Einstellungen und Anforderungen.
+
+### Konsolen-UI
+
+Der schnellste Weg, um das Projekt auszuführen, ist die Verwendung der Konsolen-UI.
+
+```bash
+# Führen Sie das Projekt in einer bash-ähnlichen Shell aus
+uv run main.py
+```
+
+### Web-UI
+
+Dieses Projekt enthält auch eine Web-UI, die ein dynamischeres und ansprechenderes interaktives Erlebnis bietet.
+> [!HINWEIS]
+> Sie müssen zuerst die Abhängigkeiten der Web-UI installieren.
+
+```bash
+# Führen Sie sowohl den Backend- als auch den Frontend-Server im Entwicklungsmodus aus
+# Unter macOS/Linux
+./bootstrap.sh -d
+
+# Unter Windows
+bootstrap.bat -d
+```
+
+Öffnen Sie Ihren Browser und besuchen Sie [`http://localhost:3000`](http://localhost:3000), um die Web-UI zu erkunden.
+
+Weitere Details finden Sie im Verzeichnis [`web`](./web/).
+
+
+## Unterstützte Suchmaschinen
+
+DeerFlow unterstützt mehrere Suchmaschinen, die in Ihrer `.env`-Datei über die Variable `SEARCH_API` konfiguriert werden können:
+
+- **Tavily** (Standard): Eine spezialisierte Such-API für KI-Anwendungen
+    - Erfordert `TAVILY_API_KEY` in Ihrer `.env`-Datei
+    - Registrieren Sie sich unter: https://app.tavily.com/home
+
+- **DuckDuckGo**: Datenschutzorientierte Suchmaschine
+    - Kein API-Schlüssel erforderlich
+
+- **Brave Search**: Datenschutzorientierte Suchmaschine mit erweiterten Funktionen
+    - Erfordert `BRAVE_SEARCH_API_KEY` in Ihrer `.env`-Datei
+    - Registrieren Sie sich unter: https://brave.com/search/api/
+
+- **Arxiv**: Wissenschaftliche Papiersuche für akademische Forschung
+    - Kein API-Schlüssel erforderlich
+    - Spezialisiert auf wissenschaftliche und akademische Papiere
+
+Um Ihre bevorzugte Suchmaschine zu konfigurieren, setzen Sie die Variable `SEARCH_API` in Ihrer `.env`-Datei:
+
+```bash
+# Wählen Sie eine: tavily, duckduckgo, brave_search, arxiv
+SEARCH_API=tavily
+```
+
+## Funktionen
+
+### Kernfähigkeiten
+
+- 🤖 **LLM-Integration**
+    - Unterstützt die Integration der meisten Modelle über [litellm](https://docs.litellm.ai/docs/providers).
+    - Unterstützung für Open-Source-Modelle wie Qwen
+    - OpenAI-kompatible API-Schnittstelle
+    - Mehrstufiges LLM-System für unterschiedliche Aufgabenkomplexitäten
+
+### Tools und MCP-Integrationen
+
+- 🔍 **Suche und Abruf**
+    - Websuche über Tavily, Brave Search und mehr
+    - Crawling mit Jina
+    - Fortgeschrittene Inhaltsextraktion
+
+- 🔗 **MCP Nahtlose Integration**
+    - Erweiterte Fähigkeiten für privaten Domänenzugriff, Wissensgraphen, Webbrowsing und mehr
+    - Erleichtert die Integration verschiedener Forschungswerkzeuge und -methoden
+
+### Menschliche Zusammenarbeit
+
+- 🧠 **Mensch-in-der-Schleife**
+    - Unterstützt interaktive Modifikation von Forschungsplänen mit natürlicher Sprache
+    - Unterstützt automatische Akzeptanz von Forschungsplänen
+
+- 📝 **Bericht-Nachbearbeitung**
+    - Unterstützt Notion-ähnliche Blockbearbeitung
+    - Ermöglicht KI-Verfeinerungen, einschließlich KI-unterstützter Polierung, Satzkürzung und -erweiterung
+    - Angetrieben von [tiptap](https://tiptap.dev/)
+
+### Inhaltserstellung
+
+- 🎙️ **Podcast- und Präsentationserstellung**
+    - KI-gestützte Podcast-Skripterstellung und Audiosynthese
+    - Automatisierte Erstellung einfacher PowerPoint-Präsentationen
+    - Anpassbare Vorlagen für maßgeschneiderte Inhalte
+
+
+## Architektur
+
+DeerFlow implementiert eine modulare Multi-Agenten-Systemarchitektur, die für automatisierte Forschung und Codeanalyse konzipiert ist. Das System basiert auf LangGraph und ermöglicht einen flexiblen zustandsbasierten Workflow, bei dem Komponenten über ein klar definiertes Nachrichtenübermittlungssystem kommunizieren.
+
+![Architekturdiagramm](./assets/architecture.png)
+> Sehen Sie es live auf [deerflow.tech](https://deerflow.tech/#multi-agent-architecture)
+
+Das System verwendet einen optimierten Workflow mit den folgenden Komponenten:
+
+1. **Koordinator**: Der Einstiegspunkt, der den Workflow-Lebenszyklus verwaltet
+   - Initiiert den Forschungsprozess basierend auf Benutzereingaben
+   - Delegiert Aufgaben bei Bedarf an den Planer
+   - Fungiert als primäre Schnittstelle zwischen dem Benutzer und dem System
+
+2. **Planer**: Strategische Komponente für Aufgabenzerlegung und -planung
+   - Analysiert Forschungsziele und erstellt strukturierte Ausführungspläne
+   - Bestimmt, ob ausreichend Kontext verfügbar ist oder ob weitere Forschung benötigt wird
+   - Verwaltet den Forschungsablauf und entscheidet, wann der endgültige Bericht erstellt wird
+
+3. **Forschungsteam**: Eine Sammlung spezialisierter Agenten, die den Plan ausführen:
+   - **Forscher**: Führt Websuchen und Informationssammlung mit Tools wie Websuchmaschinen, Crawling und sogar MCP-Diensten durch.
+   - **Codierer**: Behandelt Codeanalyse, -ausführung und technische Aufgaben mit dem Python REPL Tool.
+   Jeder Agent hat Zugriff auf spezifische Tools, die für seine Rolle optimiert sind, und operiert innerhalb des LangGraph-Frameworks
+
+4. **Reporter**: Endphasenprozessor für Forschungsergebnisse
+   - Aggregiert Erkenntnisse vom Forschungsteam
+   - Verarbeitet und strukturiert die gesammelten Informationen
+   - Erstellt umfassende Forschungsberichte
+
+## Text-zu-Sprache-Integration
+
+DeerFlow enthält jetzt eine Text-zu-Sprache (TTS)-Funktion, mit der Sie Forschungsberichte in Sprache umwandeln können. Diese Funktion verwendet die volcengine TTS API, um hochwertige Audios aus Text zu generieren. Funktionen wie Geschwindigkeit, Lautstärke und Tonhöhe können ebenfalls angepasst werden.
+
+### Verwendung der TTS API
+
+Sie können auf die TTS-Funktionalität über den Endpunkt `/api/tts` zugreifen:
+
+```bash
+# Beispiel API-Aufruf mit curl
+curl --location 'http://localhost:8000/api/tts' \
+--header 'Content-Type: application/json' \
+--data '{
+    "text": "Dies ist ein Test der Text-zu-Sprache-Funktionalität.",
+    "speed_ratio": 1.0,
+    "volume_ratio": 1.0,
+    "pitch_ratio": 1.0
+}' \
+--output speech.mp3
+```
+
+
+## Entwicklung
+
+### Testen
+
+Führen Sie die Testsuite aus:
+
+```bash
+# Alle Tests ausführen
+make test
+
+# Spezifische Testdatei ausführen
+pytest tests/integration/test_workflow.py
+
+# Mit Abdeckung ausführen
+make coverage
+```
+
+### Codequalität
+
+```bash
+# Lint ausführen
+make lint
+
+# Code formatieren
+make format
+```
+
+### Debugging mit LangGraph Studio
+
+DeerFlow verwendet LangGraph für seine Workflow-Architektur. Sie können LangGraph Studio verwenden, um den Workflow in Echtzeit zu debuggen und zu visualisieren.
+
+#### LangGraph Studio lokal ausführen
+
+DeerFlow enthält eine `langgraph.json`-Konfigurationsdatei, die die Graphstruktur und Abhängigkeiten für das LangGraph Studio definiert. Diese Datei verweist auf die im Projekt definierten Workflow-Graphen und lädt automatisch Umgebungsvariablen aus der `.env`-Datei.
+
+##### Mac
+
+```bash
+# Installieren Sie den uv-Paketmanager, wenn Sie ihn noch nicht haben
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Installieren Sie Abhängigkeiten und starten Sie den LangGraph-Server
+uvx --refresh --from "langgraph-cli[inmem]" --with-editable . --python 3.12 langgraph dev --allow-blocking
+```
+
+##### Windows / Linux
+
+```bash
+# Abhängigkeiten installieren
+pip install -e .
+pip install -U "langgraph-cli[inmem]"
+
+# LangGraph-Server starten
+langgraph dev
+```
+
+Nach dem Start des LangGraph-Servers sehen Sie mehrere URLs im Terminal:
+- API: http://127.0.0.1:2024
+- Studio UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+- API-Dokumentation: http://127.0.0.1:2024/docs
+
+Öffnen Sie den Studio UI-Link in Ihrem Browser, um auf die Debugging-Schnittstelle zuzugreifen.
+
+#### Verwendung von LangGraph Studio
+
+In der Studio UI können Sie:
+
+1. Den Workflow-Graphen visualisieren und sehen, wie Komponenten verbunden sind
+2. Die Ausführung in Echtzeit verfolgen, um zu sehen, wie Daten durch das System fließen
+3. Den Zustand in jedem Schritt des Workflows inspizieren
+4. Probleme durch Untersuchung von Ein- und Ausgaben jeder Komponente debuggen
+5. Feedback während der Planungsphase geben, um Forschungspläne zu verfeinern
+
+Wenn Sie ein Forschungsthema in der Studio UI einreichen, können Sie die gesamte Workflow-Ausführung sehen, einschließlich:
+- Die Planungsphase, in der der Forschungsplan erstellt wird
+- Die Feedback-Schleife, in der Sie den Plan ändern können
+- Die Forschungs- und Schreibphasen für jeden Abschnitt
+- Die Erstellung des endgültigen Berichts
+
+### Aktivieren von LangSmith-Tracing
+
+DeerFlow unterstützt LangSmith-Tracing, um Ihnen beim Debuggen und Überwachen Ihrer Workflows zu helfen. Um LangSmith-Tracing zu aktivieren:
+
+1. Stellen Sie sicher, dass Ihre `.env`-Datei die folgenden Konfigurationen enthält (siehe `.env.example`):
+   ```bash
+   LANGSMITH_TRACING=true
+   LANGSMITH_ENDPOINT="https://api.smith.langchain.com"
+   LANGSMITH_API_KEY="xxx"
+   LANGSMITH_PROJECT="xxx"
+   ```
+
+2. Starten Sie das Tracing mit LangSmith lokal, indem Sie folgenden Befehl ausführen:
+   ```bash
+   langgraph dev
+   ```
+
+Dies aktiviert die Trace-Visualisierung in LangGraph Studio und sendet Ihre Traces zur Überwachung und Analyse an LangSmith.
+
+## Beispiele
+
+Die folgenden Beispiele demonstrieren die Fähigkeiten von DeerFlow:
+
+### Forschungsberichte
+
+1. **OpenAI Sora Bericht** - Analyse von OpenAIs Sora KI-Tool
+   - Diskutiert Funktionen, Zugang, Prompt-Engineering, Einschränkungen und ethische Überlegungen
+   - [Vollständigen Bericht ansehen](examples/openai_sora_report.md)
+
+2. **Googles Agent-to-Agent-Protokoll Bericht** - Überblick über Googles Agent-to-Agent (A2A)-Protokoll
+   - Diskutiert seine Rolle in der KI-Agentenkommunikation und seine Beziehung zum Model Context Protocol (MCP) von Anthropic
+   - [Vollständigen Bericht ansehen](examples/what_is_agent_to_agent_protocol.md)
+
+3. **Was ist MCP?** - Eine umfassende Analyse des Begriffs "MCP" in mehreren Kontexten
+   - Untersucht Model Context Protocol in KI, Monocalciumphosphat in der Chemie und Micro-channel Plate in der Elektronik
+   - [Vollständigen Bericht ansehen](examples/what_is_mcp.md)
+
+4. **Bitcoin-Preisschwankungen** - Analyse der jüngsten Bitcoin-Preisbewegungen
+   - Untersucht Markttrends, regulatorische Einflüsse und technische Indikatoren
+   - Bietet Empfehlungen basierend auf historischen Daten
+   - [Vollständigen Bericht ansehen](examples/bitcoin_price_fluctuation.md)
+
+5. **Was ist LLM?** - Eine eingehende Erforschung großer Sprachmodelle
+   - Diskutiert Architektur, Training, Anwendungen und ethische Überlegungen
+   - [Vollständigen Bericht ansehen](examples/what_is_llm.md)
+
+6. **Wie nutzt man Claude für tiefgehende Recherche?** - Best Practices und Workflows für die Verwendung von Claude in der tiefgehenden Forschung
+   - Behandelt Prompt-Engineering, Datenanalyse und Integration mit anderen Tools
+   - [Vollständigen Bericht ansehen](examples/how_to_use_claude_deep_research.md)
+
+7. **KI-Adoption im Gesundheitswesen: Einflussfaktoren** - Analyse der Faktoren, die die KI-Adoption im Gesundheitswesen vorantreiben
+   - Diskutiert KI-Technologien, Datenqualität, ethische Überlegungen, wirtschaftliche Bewertungen, organisatorische Bereitschaft und digitale Infrastruktur
+   - [Vollständigen Bericht ansehen](examples/AI_adoption_in_healthcare.md)
+
+8. **Auswirkungen des Quantencomputing auf die Kryptographie** - Analyse der Auswirkungen des Quantencomputing auf die Kryptographie
+   - Diskutiert Schwachstellen der klassischen Kryptographie, Post-Quanten-Kryptographie und quantenresistente kryptographische Lösungen
+   - [Vollständigen Bericht ansehen](examples/Quantum_Computing_Impact_on_Cryptography.md)
+
+9. **Cristiano Ronaldos Leistungshöhepunkte** - Analyse der Leistungshöhepunkte von Cristiano Ronaldo
+   - Diskutiert seine Karriereerfolge, internationalen Tore und Leistungen in verschiedenen Spielen
+   - [Vollständigen Bericht ansehen](examples/Cristiano_Ronaldo's_Performance_Highlights.md)
+
+Um diese Beispiele auszuführen oder Ihre eigenen Forschungsberichte zu erstellen, können Sie die folgenden Befehle verwenden:
+
+```bash
+# Mit einer spezifischen Anfrage ausführen
+uv run main.py "Welche Faktoren beeinflussen die KI-Adoption im Gesundheitswesen?"
+
+# Mit benutzerdefinierten Planungsparametern ausführen
+uv run main.py --max_plan_iterations 3 "Wie wirkt sich Quantencomputing auf die Kryptographie aus?"
+
+# Im interaktiven Modus mit eingebauten Fragen ausführen
+uv run main.py --interactive
+
+# Oder mit grundlegendem interaktiven Prompt ausführen
+uv run main.py
+
+# Alle verfügbaren Optionen anzeigen
+uv run main.py --help
+```
+
+### Interaktiver Modus
+
+Die Anwendung unterstützt jetzt einen interaktiven Modus mit eingebauten Fragen in Englisch und Chinesisch:
+
+1. Starten Sie den interaktiven Modus:
+   ```bash
+   uv run main.py --interactive
+   ```
+
+2. Wählen Sie Ihre bevorzugte Sprache (English oder 中文)
+
+3. Wählen Sie aus einer Liste von eingebauten Fragen oder wählen Sie die Option, Ihre eigene Frage zu stellen
+
+4. Das System wird Ihre Frage verarbeiten und einen umfassenden Forschungsbericht generieren
+
+### Mensch-in-der-Schleife
+
+DeerFlow enthält einen Mensch-in-der-Schleife-Mechanismus, der es Ihnen ermöglicht, Forschungspläne vor ihrer Ausführung zu überprüfen, zu bearbeiten und zu genehmigen:
+
+1. **Planüberprüfung**: Wenn Mensch-in-der-Schleife aktiviert ist, präsentiert das System den generierten Forschungsplan zur Überprüfung vor der Ausführung
+
+2. **Feedback geben**: Sie können:
+   - Den Plan akzeptieren, indem Sie mit `[ACCEPTED]` antworten
+   - Den Plan bearbeiten, indem Sie Feedback geben (z.B., `[EDIT PLAN] Fügen Sie mehr Schritte zur technischen Implementierung hinzu`)
+   - Das System wird Ihr Feedback einarbeiten und einen überarbeiteten Plan generieren
+
+3. **Automatische Akzeptanz**: Sie können die automatische Akzeptanz aktivieren, um den Überprüfungsprozess zu überspringen:
+   - Über API: Setzen Sie `auto_accepted_plan: true` in Ihrer Anfrage
+
+4. **API-Integration**: Bei Verwendung der API können Sie Feedback über den Parameter `feedback` geben:
+   ```json
+   {
+     "messages": [{"role": "user", "content": "Was ist Quantencomputing?"}],
+     "thread_id": "my_thread_id",
+     "auto_accepted_plan": false,
+     "feedback": "[EDIT PLAN] Mehr über Quantenalgorithmen aufnehmen"
+   }
+   ```
+
+### Kommandozeilenargumente
+
+Die Anwendung unterstützt mehrere Kommandozeilenargumente, um ihr Verhalten anzupassen:
+
+- **query**: Die zu verarbeitende Forschungsanfrage (kann mehrere Wörter umfassen)
+- **--interactive**: Im interaktiven Modus mit eingebauten Fragen ausführen
+- **--max_plan_iterations**: Maximale Anzahl von Planungszyklen (Standard: 1)
+- **--max_step_num**: Maximale Anzahl von Schritten in einem Forschungsplan (Standard: 3)
+- **--debug**: Detaillierte Debug-Protokollierung aktivieren
+
+## FAQ
+
+Weitere Informationen finden Sie in der [FAQ.md](docs/FAQ.md).
+
+## Lizenz
+
+Dieses Projekt ist Open Source und unter der [MIT-Lizenz](./LICENSE) verfügbar.
+
+## Danksagungen
+
+DeerFlow baut auf der unglaublichen Arbeit der Open-Source-Community auf. Wir sind allen Projekten und Mitwirkenden zutiefst dankbar, deren Bemühungen DeerFlow möglich gemacht haben. Wahrhaftig stehen wir auf den Schultern von Riesen.
+
+Wir möchten unsere aufrichtige Wertschätzung den folgenden Projekten für ihre unschätzbaren Beiträge aussprechen:
+
+- **[LangChain](https://github.com/langchain-ai/langchain)**: Ihr außergewöhnliches Framework unterstützt unsere LLM-Interaktionen und -Ketten und ermöglicht nahtlose Integration und Funktionalität.
+- **[LangGraph](https://github.com/langchain-ai/langgraph)**: Ihr innovativer Ansatz zur Multi-Agenten-Orchestrierung war maßgeblich für die Ermöglichung der ausgeklügelten Workflows von DeerFlow.
+
+Diese Projekte veranschaulichen die transformative Kraft der Open-Source-Zusammenarbeit, und wir sind stolz darauf, auf ihren Grundlagen aufzubauen.
+
+### Hauptmitwirkende
+Ein herzliches Dankeschön geht an die Hauptautoren von `DeerFlow`, deren Vision, Leidenschaft und Engagement dieses Projekt zum Leben erweckt haben:
+
+- **[Daniel Walnut](https://github.com/hetaoBackend/)**
+- **[Henry Li](https://github.com/magiccube/)**
+
+Ihr unerschütterliches Engagement und Fachwissen waren die treibende Kraft hinter dem Erfolg von DeerFlow. Wir fühlen uns geehrt, Sie an der Spitze dieser Reise zu haben.
+
+## Star-Verlauf
+
+[![Star History Chart](https://api.star-history.com/svg?repos=bytedance/deer-flow&type=Date)](https://star-history.com/#bytedance/deer-flow&Date) 

README_fr.md

@@ -1,610 +0,0 @@
-# 🦌 DeerFlow - 2.0
-
-[English](./README.md) | [中文](./README_zh.md) | [日本語](./README_ja.md) | Français | [Русский](./README_ru.md)
-
-[![Python](https://img.shields.io/badge/Python-3.12%2B-3776AB?logo=python&logoColor=white)](./backend/pyproject.toml)
-[![Node.js](https://img.shields.io/badge/Node.js-22%2B-339933?logo=node.js&logoColor=white)](./Makefile)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
-
-<a href="https://trendshift.io/repositories/14699" target="_blank"><img src="https://trendshift.io/api/badge/repositories/14699" alt="bytedance%2Fdeer-flow | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
-> Le 28 février 2026, DeerFlow a décroché la 🏆 1re place sur GitHub Trending suite au lancement de la version 2. Un immense merci à notre incroyable communauté — c'est grâce à vous ! 💪🔥
-
-DeerFlow (**D**eep **E**xploration and **E**fficient **R**esearch **Flow**) est un **super agent harness** open source qui orchestre des **sub-agents**, de la **mémoire** et des **sandboxes** pour accomplir pratiquement n'importe quelle tâche — le tout propulsé par des **skills extensibles**.
-
-https://github.com/user-attachments/assets/a8bcadc4-e040-4cf2-8fda-dd768b999c18
-
-> [!NOTE]
-> **DeerFlow 2.0 est une réécriture complète.** Il ne partage aucun code avec la v1. Si vous cherchez le framework Deep Research original, il est maintenu sur la [branche `1.x`](https://github.com/bytedance/deer-flow/tree/main-1.x) — les contributions y sont toujours les bienvenues. Le développement actif a migré vers la 2.0.
-
-## Site officiel
-
-[<img width="2880" height="1600" alt="image" src="https://github.com/user-attachments/assets/a598c49f-3b2f-41ea-a052-05e21349188a" />](https://deerflow.tech)
-
-Découvrez-en plus et regardez des **démos réelles** sur notre [**site officiel**](https://deerflow.tech).
-
-## Coding Plan de ByteDance Volcengine
-
-<img width="4808" height="2400" alt="英文方舟" src="https://github.com/user-attachments/assets/2ecc7b9d-50be-4185-b1f7-5542d222fb2d" />
-
-- Nous recommandons fortement d'utiliser Doubao-Seed-2.0-Code, DeepSeek v3.2 et Kimi 2.5 pour exécuter DeerFlow
-- [En savoir plus](https://www.byteplus.com/en/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
-- [Développeurs en Chine continentale, cliquez ici](https://www.volcengine.com/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
-
-## InfoQuest
-
-DeerFlow intègre désormais le toolkit de recherche et de crawling intelligent développé par BytePlus — [InfoQuest (essai gratuit en ligne)](https://docs.byteplus.com/en/docs/InfoQuest/What_is_Info_Quest)
-
-<a href="https://docs.byteplus.com/en/docs/InfoQuest/What_is_Info_Quest" target="_blank">
-  <img
-    src="https://sf16-sg.tiktokcdn.com/obj/eden-sg/hubseh7bsbps/20251208-160108.png"   alt="InfoQuest_banner"
-  />
-</a>
-
----
-
-## Table des matières
-
-- [🦌 DeerFlow - 2.0](#-deerflow---20)
-  - [Site officiel](#site-officiel)
-  - [InfoQuest](#infoquest)
-  - [Table des matières](#table-des-matières)
-  - [Installation en une phrase pour un coding agent](#installation-en-une-phrase-pour-un-coding-agent)
-  - [Démarrage rapide](#démarrage-rapide)
-    - [Configuration](#configuration)
-    - [Lancer l'application](#lancer-lapplication)
-      - [Option 1 : Docker (recommandé)](#option-1--docker-recommandé)
-      - [Option 2 : Développement local](#option-2--développement-local)
-    - [Avancé](#avancé)
-      - [Mode Sandbox](#mode-sandbox)
-      - [Serveur MCP](#serveur-mcp)
-      - [Canaux de messagerie](#canaux-de-messagerie)
-      - [Traçage LangSmith](#traçage-langsmith)
-  - [Du Deep Research au Super Agent Harness](#du-deep-research-au-super-agent-harness)
-  - [Fonctionnalités principales](#fonctionnalités-principales)
-    - [Skills et outils](#skills-et-outils)
-      - [Intégration Claude Code](#intégration-claude-code)
-    - [Sub-Agents](#sub-agents)
-    - [Sandbox et système de fichiers](#sandbox-et-système-de-fichiers)
-    - [Context Engineering](#context-engineering)
-    - [Mémoire à long terme](#mémoire-à-long-terme)
-  - [Modèles recommandés](#modèles-recommandés)
-  - [Client Python intégré](#client-python-intégré)
-  - [Documentation](#documentation)
-  - [⚠️ Avertissement de sécurité](#️-avertissement-de-sécurité)
-  - [Contribuer](#contribuer)
-  - [Licence](#licence)
-  - [Remerciements](#remerciements)
-    - [Contributeurs principaux](#contributeurs-principaux)
-  - [Star History](#star-history)
-
-## Installation en une phrase pour un coding agent
-
-Si vous utilisez Claude Code, Codex, Cursor, Windsurf ou un autre coding agent, vous pouvez simplement lui envoyer cette phrase :
-
-```text
-Aide-moi à cloner DeerFlow si nécessaire, puis à initialiser son environnement de développement local en suivant https://raw.githubusercontent.com/bytedance/deer-flow/main/Install.md
-```
-
-Ce prompt est destiné aux coding agents. Il leur demande de cloner le dépôt si nécessaire, de privilégier Docker quand il est disponible, puis de s'arrêter avec la commande exacte pour lancer DeerFlow et la liste des configurations encore manquantes.
-
-## Démarrage rapide
-
-### Configuration
-
-1. **Cloner le dépôt DeerFlow**
-
-   ```bash
-   git clone https://github.com/bytedance/deer-flow.git
-   cd deer-flow
-   ```
-
-2. **Générer les fichiers de configuration locaux**
-
-   Depuis le répertoire racine du projet (`deer-flow/`), exécutez :
-
-   ```bash
-   make config
-   ```
-
-   Cette commande crée les fichiers de configuration locaux à partir des templates fournis.
-
-3. **Configurer le(s) modèle(s) de votre choix**
-
-   Éditez `config.yaml` et définissez au moins un modèle :
-
-   ```yaml
-   models:
-     - name: gpt-4                       # Internal identifier
-       display_name: GPT-4               # Human-readable name
-       use: langchain_openai:ChatOpenAI  # LangChain class path
-       model: gpt-4                      # Model identifier for API
-       api_key: $OPENAI_API_KEY          # API key (recommended: use env var)
-       max_tokens: 4096                  # Maximum tokens per request
-       temperature: 0.7                  # Sampling temperature
-
-     - name: openrouter-gemini-2.5-flash
-       display_name: Gemini 2.5 Flash (OpenRouter)
-       use: langchain_openai:ChatOpenAI
-       model: google/gemini-2.5-flash-preview
-       api_key: $OPENAI_API_KEY          # OpenRouter still uses the OpenAI-compatible field name here
-       base_url: https://openrouter.ai/api/v1
-
-     - name: gpt-5-responses
-       display_name: GPT-5 (Responses API)
-       use: langchain_openai:ChatOpenAI
-       model: gpt-5
-       api_key: $OPENAI_API_KEY
-       use_responses_api: true
-       output_version: responses/v1
-   ```
-
-   OpenRouter et les passerelles compatibles OpenAI similaires doivent être configurés avec `langchain_openai:ChatOpenAI` et `base_url`. Si vous préférez utiliser un nom de variable d'environnement propre au fournisseur, pointez `api_key` vers cette variable explicitement (par exemple `api_key: $OPENROUTER_API_KEY`).
-
-   Pour router les modèles OpenAI via `/v1/responses`, continuez d'utiliser `langchain_openai:ChatOpenAI` et définissez `use_responses_api: true` avec `output_version: responses/v1`.
-
-   Exemples de providers basés sur un CLI :
-
-   ```yaml
-   models:
-     - name: gpt-5.4
-       display_name: GPT-5.4 (Codex CLI)
-       use: deerflow.models.openai_codex_provider:CodexChatModel
-       model: gpt-5.4
-       supports_thinking: true
-       supports_reasoning_effort: true
-
-     - name: claude-sonnet-4.6
-       display_name: Claude Sonnet 4.6 (Claude Code OAuth)
-       use: deerflow.models.claude_provider:ClaudeChatModel
-       model: claude-sonnet-4-6
-       max_tokens: 4096
-       supports_thinking: true
-   ```
-
-   - Codex CLI lit `~/.codex/auth.json`
-   - L'endpoint Responses de Codex rejette actuellement `max_tokens` et `max_output_tokens`, donc `CodexChatModel` n'expose pas de limite de tokens par requête
-   - Claude Code accepte `CLAUDE_CODE_OAUTH_TOKEN`, `ANTHROPIC_AUTH_TOKEN`, `CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR`, `CLAUDE_CODE_CREDENTIALS_PATH`, ou en clair `~/.claude/.credentials.json`
-   - Sur macOS, DeerFlow ne sonde pas le Keychain automatiquement. Exportez l'auth Claude Code explicitement si nécessaire :
-
-   ```bash
-   eval "$(python3 scripts/export_claude_code_oauth.py --print-export)"
-   ```
-
-4. **Définir les clés API pour le(s) modèle(s) configuré(s)**
-
-   Choisissez l'une des méthodes suivantes :
-
-- Option A : Éditer le fichier `.env` à la racine du projet (recommandé)
-
-
-   ```bash
-   TAVILY_API_KEY=your-tavily-api-key
-   OPENAI_API_KEY=your-openai-api-key
-   # OpenRouter also uses OPENAI_API_KEY when your config uses langchain_openai:ChatOpenAI + base_url.
-   # Add other provider keys as needed
-   INFOQUEST_API_KEY=your-infoquest-api-key
-   ```
-
-- Option B : Exporter les variables d'environnement dans votre shell
-
-   ```bash
-   export OPENAI_API_KEY=your-openai-api-key
-   ```
-
-   Pour les providers basés sur un CLI :
-   - Codex CLI : `~/.codex/auth.json`
-   - Claude Code OAuth : handoff explicite via env/fichier ou `~/.claude/.credentials.json`
-
-- Option C : Éditer `config.yaml` directement (non recommandé en production)
-
-   ```yaml
-   models:
-     - name: gpt-4
-       api_key: your-actual-api-key-here  # Replace placeholder
-   ```
-
-### Lancer l'application
-
-#### Option 1 : Docker (recommandé)
-
-**Développement** (hot-reload, montage des sources) :
-
-```bash
-make docker-init    # Pull sandbox image (only once or when image updates)
-make docker-start   # Start services (auto-detects sandbox mode from config.yaml)
-```
-
-`make docker-start` ne lance `provisioner` que si `config.yaml` utilise le mode provisioner (`sandbox.use: deerflow.community.aio_sandbox:AioSandboxProvider` avec `provisioner_url`).
-Les processus backend récupèrent automatiquement les changements dans `config.yaml` au prochain accès à la configuration, donc les mises à jour de métadonnées des modèles ne nécessitent pas de redémarrage manuel en développement.
-
-> [!TIP]
-> Sous Linux, si les commandes Docker échouent avec `permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock`, ajoutez votre utilisateur au groupe `docker` et reconnectez-vous avant de réessayer. Voir [CONTRIBUTING.md](CONTRIBUTING.md#linux-docker-daemon-permission-denied) pour la solution complète.
-
-**Production** (build des images en local, montage de la config et des données) :
-
-```bash
-make up     # Build images and start all production services
-make down   # Stop and remove containers
-```
-
-> [!NOTE]
-> Le serveur d'agents LangGraph fonctionne actuellement via `langgraph dev` (le serveur CLI open source).
-
-Accès : http://localhost:2026
-
-Voir [CONTRIBUTING.md](CONTRIBUTING.md) pour le guide complet de développement avec Docker.
-
-#### Option 2 : Développement local
-
-Si vous préférez lancer les services en local :
-
-Prérequis : complétez d'abord les étapes de « Configuration » ci-dessus (`make config` et clés API des modèles). `make dev` nécessite un fichier de configuration valide (par défaut `config.yaml` à la racine du projet ; modifiable via `DEER_FLOW_CONFIG_PATH`).
-
-1. **Vérifier les prérequis** :
-   ```bash
-   make check  # Verifies Node.js 22+, pnpm, uv, nginx
-   ```
-
-2. **Installer les dépendances** :
-   ```bash
-   make install  # Install backend + frontend dependencies
-   ```
-
-3. **(Optionnel) Pré-télécharger l'image sandbox** :
-   ```bash
-   # Recommended if using Docker/Container-based sandbox
-   make setup-sandbox
-   ```
-
-4. **Démarrer les services** :
-   ```bash
-   make dev
-   ```
-
-5. **Accès** : http://localhost:2026
-
-### Avancé
-#### Mode Sandbox
-
-DeerFlow supporte plusieurs modes d'exécution sandbox :
-- **Exécution locale** (exécute le code sandbox directement sur la machine hôte)
-- **Exécution Docker** (exécute le code sandbox dans des conteneurs Docker isolés)
-- **Exécution Docker avec Kubernetes** (exécute le code sandbox dans des pods Kubernetes via le service provisioner)
-
-En développement Docker, le démarrage des services suit le mode sandbox défini dans `config.yaml`. En mode Local/Docker, `provisioner` n'est pas démarré.
-
-Voir le [Guide de configuration Sandbox](backend/docs/CONFIGURATION.md#sandbox) pour configurer le mode de votre choix.
-
-#### Serveur MCP
-
-DeerFlow supporte des serveurs MCP et des skills configurables pour étendre ses capacités.
-Pour les serveurs MCP HTTP/SSE, les flux de tokens OAuth sont supportés (`client_credentials`, `refresh_token`).
-Voir le [Guide MCP Server](backend/docs/MCP_SERVER.md) pour les instructions détaillées.
-
-#### Canaux de messagerie
-
-DeerFlow peut recevoir des tâches depuis des applications de messagerie. Les canaux démarrent automatiquement une fois configurés — aucune IP publique n'est requise.
-
-| Canal | Transport | Difficulté |
-|---------|-----------|------------|
-| Telegram | Bot API (long-polling) | Facile |
-| Slack | Socket Mode | Modérée |
-| Feishu / Lark | WebSocket | Modérée |
-
-**Configuration dans `config.yaml` :**
-
-```yaml
-channels:
-  # LangGraph Server URL (default: http://localhost:2024)
-  langgraph_url: http://localhost:2024
-  # Gateway API URL (default: http://localhost:8001)
-  gateway_url: http://localhost:8001
-
-  # Optional: global session defaults for all mobile channels
-  session:
-    assistant_id: lead_agent
-    config:
-      recursion_limit: 100
-    context:
-      thinking_enabled: true
-      is_plan_mode: false
-      subagent_enabled: false
-
-  feishu:
-    enabled: true
-    app_id: $FEISHU_APP_ID
-    app_secret: $FEISHU_APP_SECRET
-    # domain: https://open.feishu.cn       # China (default)
-    # domain: https://open.larksuite.com   # International
-
-  slack:
-    enabled: true
-    bot_token: $SLACK_BOT_TOKEN     # xoxb-...
-    app_token: $SLACK_APP_TOKEN     # xapp-... (Socket Mode)
-    allowed_users: []               # empty = allow all
-
-  telegram:
-    enabled: true
-    bot_token: $TELEGRAM_BOT_TOKEN
-    allowed_users: []               # empty = allow all
-
-    # Optional: per-channel / per-user session settings
-    session:
-      assistant_id: mobile_agent
-      context:
-        thinking_enabled: false
-      users:
-        "123456789":
-          assistant_id: vip_agent
-          config:
-            recursion_limit: 150
-          context:
-            thinking_enabled: true
-            subagent_enabled: true
-```
-
-Définissez les clés API correspondantes dans votre fichier `.env` :
-
-```bash
-# Telegram
-TELEGRAM_BOT_TOKEN=123456789:ABCdefGHIjklMNOpqrSTUvwxYZ
-
-# Slack
-SLACK_BOT_TOKEN=xoxb-...
-SLACK_APP_TOKEN=xapp-...
-
-# Feishu / Lark
-FEISHU_APP_ID=cli_xxxx
-FEISHU_APP_SECRET=your_app_secret
-```
-
-**Configuration Telegram**
-
-1. Ouvrez une conversation avec [@BotFather](https://t.me/BotFather), envoyez `/newbot`, et copiez le token HTTP API.
-2. Définissez `TELEGRAM_BOT_TOKEN` dans `.env` et activez le canal dans `config.yaml`.
-
-**Configuration Slack**
-
-1. Créez une Slack App sur [api.slack.com/apps](https://api.slack.com/apps) → Create New App → From scratch.
-2. Dans **OAuth & Permissions**, ajoutez les Bot Token Scopes : `app_mentions:read`, `chat:write`, `im:history`, `im:read`, `im:write`, `files:write`.
-3. Activez le **Socket Mode** → générez un App-Level Token (`xapp-…`) avec le scope `connections:write`.
-4. Dans **Event Subscriptions**, abonnez-vous aux bot events : `app_mention`, `message.im`.
-5. Définissez `SLACK_BOT_TOKEN` et `SLACK_APP_TOKEN` dans `.env` et activez le canal dans `config.yaml`.
-
-**Configuration Feishu / Lark**
-
-1. Créez une application sur [Feishu Open Platform](https://open.feishu.cn/) → activez la capacité **Bot**.
-2. Ajoutez les permissions : `im:message`, `im:message.p2p_msg:readonly`, `im:resource`.
-3. Dans **Events**, abonnez-vous à `im.message.receive_v1` et sélectionnez le mode **Long Connection**.
-4. Copiez l'App ID et l'App Secret. Définissez `FEISHU_APP_ID` et `FEISHU_APP_SECRET` dans `.env` et activez le canal dans `config.yaml`.
-
-**Commandes**
-
-Une fois un canal connecté, vous pouvez interagir avec DeerFlow directement depuis le chat :
-
-| Commande | Description |
-|---------|-------------|
-| `/new` | Démarrer une nouvelle conversation |
-| `/status` | Afficher les infos du thread en cours |
-| `/models` | Lister les modèles disponibles |
-| `/memory` | Consulter la mémoire |
-| `/help` | Afficher l'aide |
-
-> Les messages sans préfixe de commande sont traités comme du chat classique — DeerFlow crée un thread et répond de manière conversationnelle.
-
-#### Traçage LangSmith
-
-DeerFlow intègre nativement [LangSmith](https://smith.langchain.com) pour l'observabilité. Une fois activé, tous les appels LLM, les exécutions d'agents et les exécutions d'outils sont tracés et visibles dans le tableau de bord LangSmith.
-
-Ajoutez les lignes suivantes à votre fichier `.env` :
-
-```bash
-LANGSMITH_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
-LANGSMITH_API_KEY=lsv2_pt_xxxxxxxxxxxxxxxx
-LANGSMITH_PROJECT=xxx
-```
-
-Pour les déploiements Docker, le traçage est désactivé par défaut. Définissez `LANGSMITH_TRACING=true` et `LANGSMITH_API_KEY` dans votre `.env` pour l'activer.
-
-## Du Deep Research au Super Agent Harness
-
-DeerFlow a démarré comme un framework de Deep Research — et la communauté s'en est emparée. Depuis le lancement, les développeurs l'ont poussé bien au-delà de la recherche : construction de pipelines de données, génération de présentations, mise en place de dashboards, automatisation de workflows de contenu. Des usages qu'on n'avait jamais anticipés.
-
-Ça nous a révélé quelque chose d'important : DeerFlow n'était pas qu'un simple outil de recherche. C'était un **harness** — un runtime qui donne aux agents l'infrastructure nécessaire pour vraiment accomplir du travail.
-
-On l'a donc reconstruit de zéro.
-
-DeerFlow 2.0 n'est plus un framework à assembler soi-même. C'est un super agent harness — clé en main et entièrement extensible. Construit sur LangGraph et LangChain, il embarque tout ce dont un agent a besoin out of the box : un système de fichiers, de la mémoire, des skills, une exécution sandboxée, et la capacité de planifier et de lancer des sub-agents pour les tâches complexes et multi-étapes.
-
-Utilisez-le tel quel. Ou démontez-le et faites-en le vôtre.
-
-## Fonctionnalités principales
-
-### Skills et outils
-
-Les skills sont ce qui permet à DeerFlow de faire *pratiquement n'importe quoi*.
-
-Un Agent Skill standard est un module de capacité structuré — un fichier Markdown qui définit un workflow, des bonnes pratiques et des références vers des ressources associées. DeerFlow est livré avec des skills intégrés pour la recherche, la génération de rapports, la création de présentations, les pages web, la génération d'images et de vidéos, et bien plus. Mais la vraie force réside dans l'extensibilité : ajoutez vos propres skills, remplacez ceux fournis, ou combinez-les en workflows composites.
-
-Les skills sont chargés progressivement — uniquement quand la tâche le nécessite, pas tous en même temps. Ça permet de garder la fenêtre de contexte légère et de bien fonctionner même avec des modèles sensibles au nombre de tokens.
-
-Quand vous installez des archives `.skill` via le Gateway, DeerFlow accepte les métadonnées frontmatter optionnelles standard comme `version`, `author` et `compatibility`, plutôt que de rejeter des skills externes par ailleurs valides.
-
-Les outils suivent la même philosophie. DeerFlow est livré avec un ensemble d'outils de base — recherche web, fetch de pages web, opérations sur les fichiers, exécution bash — et supporte les outils custom via des serveurs MCP et des fonctions Python. Remplacez n'importe quoi. Ajoutez n'importe quoi.
-
-Les suggestions de suivi générées par le Gateway normalisent désormais aussi bien la sortie texte brut du modèle que le contenu riche au format bloc/liste avant de parser la réponse en tableau JSON, de sorte que les wrappers de contenu propres à chaque provider ne suppriment plus silencieusement les suggestions.
-
-```
-# Paths inside the sandbox container
-/mnt/skills/public
-├── research/SKILL.md
-├── report-generation/SKILL.md
-├── slide-creation/SKILL.md
-├── web-page/SKILL.md
-└── image-generation/SKILL.md
-
-/mnt/skills/custom
-└── your-custom-skill/SKILL.md      ← yours
-```
-
-#### Intégration Claude Code
-
-Le skill `claude-to-deerflow` vous permet d'interagir avec une instance DeerFlow en cours d'exécution directement depuis [Claude Code](https://docs.anthropic.com/en/docs/claude-code). Envoyez des tâches de recherche, vérifiez le statut, gérez les threads — le tout sans quitter le terminal.
-
-**Installer le skill** :
-
-```bash
-npx skills add https://github.com/bytedance/deer-flow --skill claude-to-deerflow
-```
-
-Assurez-vous ensuite que DeerFlow tourne (par défaut sur `http://localhost:2026`) et utilisez la commande `/claude-to-deerflow` dans Claude Code.
-
-**Ce que vous pouvez faire** :
-- Envoyer des messages à DeerFlow et recevoir des réponses en streaming
-- Choisir le mode d'exécution : flash (rapide), standard, pro (planification), ultra (sub-agents)
-- Vérifier la santé de DeerFlow, lister les modèles/skills/agents
-- Gérer les threads et l'historique des conversations
-- Upload des fichiers pour analyse
-
-**Variables d'environnement** (optionnel, pour des endpoints custom) :
-
-```bash
-DEERFLOW_URL=http://localhost:2026            # Unified proxy base URL
-DEERFLOW_GATEWAY_URL=http://localhost:2026    # Gateway API
-DEERFLOW_LANGGRAPH_URL=http://localhost:2026/api/langgraph  # LangGraph API
-```
-
-Voir [`skills/public/claude-to-deerflow/SKILL.md`](skills/public/claude-to-deerflow/SKILL.md) pour la référence API complète.
-
-### Sub-Agents
-
-Les tâches complexes tiennent rarement en une seule passe. DeerFlow les décompose.
-
-L'agent principal peut lancer des sub-agents à la volée — chacun avec son propre contexte délimité, ses outils et ses conditions d'arrêt. Les sub-agents s'exécutent en parallèle quand c'est possible, remontent des résultats structurés, et l'agent principal synthétise le tout en une sortie cohérente.
-
-C'est comme ça que DeerFlow gère les tâches qui prennent de quelques minutes à plusieurs heures : une tâche de recherche peut se déployer en une dizaine de sub-agents, chacun explorant un angle différent, puis converger vers un seul rapport — ou un site web — ou un jeu de slides avec des visuels générés. Un seul harness, de nombreuses mains.
-
-### Sandbox et système de fichiers
-
-DeerFlow ne se contente pas de *parler* de faire les choses. Il dispose de son propre ordinateur.
-
-Chaque tâche s'exécute dans un conteneur Docker isolé avec un système de fichiers complet — skills, workspace, uploads, outputs. L'agent lit, écrit et édite des fichiers. Il exécute des commandes bash et du code. Il visualise des images. Le tout sandboxé, le tout auditable, zéro contamination entre les sessions.
-
-C'est la différence entre un chatbot avec accès à des outils et un agent doté d'un véritable environnement d'exécution.
-
-```
-# Paths inside the sandbox container
-/mnt/user-data/
-├── uploads/          ← your files
-├── workspace/        ← agents' working directory
-└── outputs/          ← final deliverables
-```
-
-### Context Engineering
-
-**Contexte isolé des Sub-Agents** : chaque sub-agent s'exécute dans son propre contexte isolé. Il ne peut voir ni le contexte de l'agent principal, ni celui des autres sub-agents. L'objectif est de garantir que chaque sub-agent reste concentré sur sa tâche sans être parasité par des informations non pertinentes.
-
-**Résumé** : au sein d'une session, DeerFlow gère le contexte de manière agressive — en résumant les sous-tâches terminées, en déchargeant les résultats intermédiaires vers le système de fichiers, en compressant ce qui n'est plus immédiatement pertinent. Ça lui permet de rester efficace sur des tâches longues et multi-étapes sans faire exploser la fenêtre de contexte.
-
-### Mémoire à long terme
-
-La plupart des agents oublient tout dès qu'une conversation se termine. DeerFlow, lui, se souvient.
-
-D'une session à l'autre, DeerFlow construit une mémoire persistante de votre profil, de vos préférences et de vos connaissances accumulées. Plus vous l'utilisez, mieux il vous connaît — votre style d'écriture, votre stack technique, vos workflows récurrents. La mémoire est stockée localement et reste sous votre contrôle.
-
-Les mises à jour de la mémoire ignorent désormais les entrées de faits en double au moment de l'application, de sorte que les préférences et le contexte répétés ne s'accumulent plus indéfiniment entre les sessions.
-
-## Modèles recommandés
-
-DeerFlow est agnostique en termes de modèle — il fonctionne avec n'importe quel LLM implémentant l'API compatible OpenAI. Cela dit, il offre de meilleures performances avec des modèles qui supportent :
-
-- **De longues fenêtres de contexte** (100k+ tokens) pour la recherche approfondie et les tâches multi-étapes
-- **Des capacités de raisonnement** pour la planification adaptative et la décomposition de tâches complexes
-- **Des entrées multimodales** pour la compréhension d'images et de vidéos
-- **Un usage fiable des outils (tool use)** pour des appels de fonctions et des sorties structurées fiables
-
-## Client Python intégré
-
-DeerFlow peut être utilisé comme bibliothèque Python intégrée sans lancer l'ensemble des services HTTP. Le `DeerFlowClient` fournit un accès direct in-process à toutes les capacités d'agent et de Gateway, en retournant les mêmes schémas de réponse que l'API HTTP Gateway. Le HTTP Gateway expose également `DELETE /api/threads/{thread_id}` pour supprimer les données de thread locales gérées par DeerFlow après la suppression du thread LangGraph :
-
-```python
-from deerflow.client import DeerFlowClient
-
-client = DeerFlowClient()
-
-# Chat
-response = client.chat("Analyze this paper for me", thread_id="my-thread")
-
-# Streaming (LangGraph SSE protocol: values, messages-tuple, end)
-for event in client.stream("hello"):
-    if event.type == "messages-tuple" and event.data.get("type") == "ai":
-        print(event.data["content"])
-
-# Configuration & management — returns Gateway-aligned dicts
-models = client.list_models()        # {"models": [...]}
-skills = client.list_skills()        # {"skills": [...]}
-client.update_skill("web-search", enabled=True)
-client.upload_files("thread-1", ["./report.pdf"])  # {"success": True, "files": [...]}
-```
-
-Toutes les méthodes retournant des dicts sont validées en CI contre les modèles de réponse Pydantic du Gateway (`TestGatewayConformance`), garantissant que le client intégré reste synchronisé avec les schémas de l'API HTTP. Voir `backend/packages/harness/deerflow/client.py` pour la documentation API complète.
-
-## Documentation
-
-- [Guide de contribution](CONTRIBUTING.md) - Mise en place de l'environnement de développement et workflow
-- [Guide de configuration](backend/docs/CONFIGURATION.md) - Instructions d'installation et de configuration
-- [Vue d'ensemble de l'architecture](backend/CLAUDE.md) - Détails de l'architecture technique
-- [Architecture backend](backend/README.md) - Architecture backend et référence API
-
-## ⚠️ Avertissement de sécurité
-
-### Un déploiement inapproprié peut introduire des risques de sécurité
-
-DeerFlow dispose de capacités clés à hauts privilèges, notamment **l'exécution de commandes système, les opérations sur les ressources et l'invocation de logique métier**. Il est conçu par défaut pour être **déployé dans un environnement local de confiance (accessible uniquement via l'interface de loopback 127.0.0.1)**. Si vous déployez l'agent dans des environnements non fiables — tels que des réseaux LAN, des serveurs cloud publics ou d'autres environnements accessibles depuis plusieurs terminaux — sans mesures de sécurité strictes, cela peut introduire des risques, notamment :
-
-- **Invocation non autorisée** : les fonctionnalités de l'agent pourraient être découvertes par des tiers non autorisés ou des scanners malveillants, déclenchant des requêtes non autorisées en masse qui exécutent des opérations à haut risque (commandes système, lecture/écriture de fichiers), pouvant causer de graves conséquences.
-- **Risques juridiques et de conformité** : si l'agent est utilisé illégalement pour mener des cyberattaques, du vol de données ou d'autres activités illicites, cela peut entraîner des responsabilités juridiques et des risques de conformité.
-
-### Recommandations de sécurité
-
-**Note : nous recommandons fortement de déployer DeerFlow dans un environnement réseau local de confiance.** Si vous avez besoin d'un déploiement multi-appareils ou multi-réseaux, vous devez mettre en place des mesures de sécurité strictes, par exemple :
-
-- **Liste blanche d'IP** : utilisez `iptables`, ou déployez des pare-feux matériels / commutateurs avec ACL, pour **configurer des règles de liste blanche d'IP** et refuser l'accès à toutes les autres adresses IP.
-- **Passerelle d'authentification** : configurez un proxy inverse (ex. nginx) et **activez une authentification forte en amont**, bloquant tout accès non authentifié.
-- **Isolation réseau** : si possible, placez l'agent et les appareils de confiance dans le **même VLAN dédié**, isolé des autres équipements réseau.
-- **Restez informé** : continuez à suivre les mises à jour de sécurité du projet DeerFlow.
-
-## Contribuer
-
-Les contributions sont les bienvenues ! Consultez [CONTRIBUTING.md](CONTRIBUTING.md) pour la mise en place de l'environnement de développement, le workflow et les conventions.
-
-La couverture de tests de régression inclut la détection du mode sandbox Docker et les tests de gestion du kubeconfig-path du provisioner dans `backend/tests/`.
-
-## Licence
-
-Ce projet est open source et disponible sous la [Licence MIT](./LICENSE).
-
-## Remerciements
-
-DeerFlow est construit sur le travail remarquable de la communauté open source. Nous sommes profondément reconnaissants envers tous les projets et contributeurs dont les efforts ont rendu DeerFlow possible. Nous nous tenons véritablement sur les épaules de géants.
-
-Nous tenons à exprimer notre sincère gratitude aux projets suivants pour leurs contributions inestimables :
-
-- **[LangChain](https://github.com/langchain-ai/langchain)** : leur excellent framework propulse nos interactions LLM et nos chaînes, permettant une intégration et des fonctionnalités fluides.
-- **[LangGraph](https://github.com/langchain-ai/langgraph)** : leur approche innovante de l'orchestration multi-agents a été déterminante pour les workflows sophistiqués de DeerFlow.
-
-Ces projets illustrent le pouvoir transformateur de la collaboration open source, et nous sommes fiers de bâtir sur leurs fondations.
-
-### Contributeurs principaux
-
-Un grand merci aux auteurs principaux de `DeerFlow`, dont la vision, la passion et le dévouement ont donné vie à ce projet :
-
-- **[Daniel Walnut](https://github.com/hetaoBackend/)**
-- **[Henry Li](https://github.com/magiccube/)**
-
-Votre engagement sans faille et votre expertise sont le moteur du succès de DeerFlow. Nous sommes honorés de vous avoir à la barre de cette aventure.
-
-## Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=bytedance/deer-flow&type=Date)](https://star-history.com/#bytedance/deer-flow&Date)

README_ja.md

@@ -1,563 +1,553 @@
-# 🦌 DeerFlow - 2.0
+# 🦌 DeerFlow
 
-[English](./README.md) | [中文](./README_zh.md) | 日本語 | [Français](./README_fr.md) | [Русский](./README_ru.md)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-[![Python](https://img.shields.io/badge/Python-3.12%2B-3776AB?logo=python&logoColor=white)](./backend/pyproject.toml)
+[English](./README.md) | [简体中文](./README_zh.md) | [日本語](./README_ja.md) | [Deutsch](./README_de.md)
-[![Node.js](https://img.shields.io/badge/Node.js-22%2B-339933?logo=node.js&logoColor=white)](./Makefile)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
 
-<a href="https://trendshift.io/repositories/14699" target="_blank"><img src="https://trendshift.io/api/badge/repositories/14699" alt="bytedance%2Fdeer-flow | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+> オープンソースから生まれ、オープンソースに還元する。
-> 2026年2月28日、バージョン2のリリースに伴い、DeerFlowはGitHub Trendingで🏆 第1位を獲得しました。素晴らしいコミュニティの皆さん、ありがとうございます！💪🔥
 
-DeerFlow（**D**eep **E**xploration and **E**fficient **R**esearch **Flow**）は、**サブエージェント**、**メモリ**、**サンドボックス**を統合し、**拡張可能なスキル**によってあらゆるタスクを実行できるオープンソースの**スーパーエージェントハーネス**です。
+**DeerFlow**（**D**eep **E**xploration and **E**fficient **R**esearch **Flow**）は、オープンソースコミュニティの素晴らしい成果の上に構築されたコミュニティ主導の深層研究フレームワークです。私たちの目標は、言語モデルとウェブ検索、クローリング、Python コード実行などの専門ツールを組み合わせながら、これを可能にしたコミュニティに貢献することです。
 
-https://github.com/user-attachments/assets/a8bcadc4-e040-4cf2-8fda-dd768b999c18
+詳細については[DeerFlow の公式ウェブサイト](https://deerflow.tech/)をご覧ください。
 
-> [!NOTE]
+## デモ
-> **DeerFlow 2.0はゼロからの完全な書き直しです。** v1とコードを共有していません。オリジナルのDeep Researchフレームワークをお探しの場合は、[`1.x`ブランチ](https://github.com/bytedance/deer-flow/tree/main-1.x)で引き続きメンテナンスされています。現在の開発は2.0に移行しています。
 
-## 公式ウェブサイト
+### ビデオ
 
-[<img width="2880" height="1600" alt="image" src="https://github.com/user-attachments/assets/a598c49f-3b2f-41ea-a052-05e21349188a" />](https://deerflow.tech)
+https://github.com/user-attachments/assets/f3786598-1f2a-4d07-919e-8b99dfa1de3e
 
-**実際のデモ**は[**公式ウェブサイト**](https://deerflow.tech)でご覧いただけます。
+このデモでは、DeerFlow の使用方法を紹介しています：
 
-## ByteDance Volcengine のコーディングプラン
+- MCP サービスとのシームレスな統合
+- 深層研究プロセスの実施と画像を含む包括的なレポートの作成
+- 生成されたレポートに基づくポッドキャストオーディオの作成
 
-<img width="4808" height="2400" alt="英文方舟" src="https://github.com/user-attachments/assets/2ecc7b9d-50be-4185-b1f7-5542d222fb2d" />
+### リプレイ例
 
-- DeerFlowの実行には、Doubao-Seed-2.0-Code、DeepSeek v3.2、Kimi 2.5の使用を強く推奨します
+- [エッフェル塔は世界一高いビルと比べてどれくらい高い？](https://deerflow.tech/chat?replay=eiffel-tower-vs-tallest-building)
-- [詳細はこちら](https://www.byteplus.com/en/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
+- [GitHub で最も人気のあるリポジトリは？](https://deerflow.tech/chat?replay=github-top-trending-repo)
-- [中国大陸の開発者はこちらをクリック](https://www.volcengine.com/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
+- [南京の伝統料理に関する記事を書く](https://deerflow.tech/chat?replay=nanjing-traditional-dishes)
-
+- [賃貸アパートの装飾方法は？](https://deerflow.tech/chat?replay=rental-apartment-decoration)
-## InfoQuest
+- [公式ウェブサイトでより多くのリプレイ例をご覧ください。](https://deerflow.tech/#case-studies)
-
-DeerFlowは、BytePlusが独自に開発したインテリジェント検索・クローリングツールセット「[InfoQuest（無料オンライン体験対応）](https://docs.byteplus.com/en/docs/InfoQuest/What_is_Info_Quest)」を新たに統合しました。
-
-<a href="https://docs.byteplus.com/en/docs/InfoQuest/What_is_Info_Quest" target="_blank">
-  <img
-    src="https://sf16-sg.tiktokcdn.com/obj/eden-sg/hubseh7bsbps/20251208-160108.png"   alt="InfoQuest_banner"
-  />
-</a>
 
 ---
 
-## 目次
+## 📑 目次
 
-- [🦌 DeerFlow - 2.0](#-deerflow---20)
+- [🚀 クイックスタート](#クイックスタート)
-  - [公式ウェブサイト](#公式ウェブサイト)
+- [🌟 特徴](#特徴)
-  - [InfoQuest](#infoquest)
+- [🏗️ アーキテクチャ](#アーキテクチャ)
-  - [目次](#目次)
+- [🛠️ 開発](#開発)
-  - [Coding Agent に一文でセットアップを依頼](#coding-agent-に一文でセットアップを依頼)
+- [🗣️ テキスト読み上げ統合](#テキスト読み上げ統合)
-  - [クイックスタート](#クイックスタート)
+- [📚 例](#例)
-    - [設定](#設定)
+- [❓ よくある質問](#よくある質問)
-    - [アプリケーションの実行](#アプリケーションの実行)
+- [📜 ライセンス](#ライセンス)
-      - [オプション1: Docker（推奨）](#オプション1-docker推奨)
+- [💖 謝辞](#謝辞)
-      - [オプション2: ローカル開発](#オプション2-ローカル開発)
+- [⭐ スター履歴](#スター履歴)
-    - [詳細設定](#詳細設定)
-      - [サンドボックスモード](#サンドボックスモード)
-      - [MCPサーバー](#mcpサーバー)
-      - [IMチャネル](#imチャネル)
-      - [LangSmithトレーシング](#langsmithトレーシング)
-  - [Deep Researchからスーパーエージェントハーネスへ](#deep-researchからスーパーエージェントハーネスへ)
-  - [コア機能](#コア機能)
-    - [スキルとツール](#スキルとツール)
-      - [Claude Code連携](#claude-code連携)
-    - [サブエージェント](#サブエージェント)
-    - [サンドボックスとファイルシステム](#サンドボックスとファイルシステム)
-    - [コンテキストエンジニアリング](#コンテキストエンジニアリング)
-    - [長期メモリ](#長期メモリ)
-  - [推奨モデル](#推奨モデル)
-  - [組み込みPythonクライアント](#組み込みpythonクライアント)
-  - [ドキュメント](#ドキュメント)
-  - [⚠️ セキュリティに関する注意](#️-セキュリティに関する注意)
-  - [コントリビュート](#コントリビュート)
-  - [ライセンス](#ライセンス)
-  - [謝辞](#謝辞)
-    - [主要コントリビューター](#主要コントリビューター)
-  - [Star History](#star-history)
-
-## Coding Agent に一文でセットアップを依頼
-
-Claude Code、Codex、Cursor、Windsurf などの coding agent を使っているなら、次の一文をそのまま渡せます。
-
-```text
-DeerFlow がまだ clone されていなければ先に clone してから、https://raw.githubusercontent.com/bytedance/deer-flow/main/Install.md に従ってローカル開発環境を初期化してください
-```
-
-このプロンプトは coding agent 向けです。必要なら先にリポジトリを clone し、Docker が使える場合は Docker を優先して初期セットアップを行い、最後に次の起動コマンドと不足している設定項目だけを返します。
 
 ## クイックスタート
 
-### 設定
+DeerFlow は Python で開発され、Node.js で書かれた Web UI が付属しています。スムーズなセットアッププロセスを確保するために、以下のツールの使用をお勧めします：
 
-1. **DeerFlowリポジトリをクローン**
+### 推奨ツール
+
+- **[`uv`](https://docs.astral.sh/uv/getting-started/installation/):**
+  Python 環境と依存関係の管理を簡素化します。`uv`はルートディレクトリに自動的に仮想環境を作成し、必要なパッケージをすべてインストールします—Python 環境を手動でインストールする必要はありません。
+
+- **[`nvm`](https://github.com/nvm-sh/nvm):**
+  複数の Node.js ランタイムバージョンを簡単に管理します。
+
+- **[`pnpm`](https://pnpm.io/installation):**
+  Node.js プロジェクトの依存関係をインストールおよび管理します。
+
+### 環境要件
+
+システムが以下の最小要件を満たしていることを確認してください：
+
+- **[Python](https://www.python.org/downloads/):** バージョン `3.12+`
+- **[Node.js](https://nodejs.org/en/download/):** バージョン `22+`
+
+### インストール
 
 ```bash
+# リポジトリをクローン
 git clone https://github.com/bytedance/deer-flow.git
 cd deer-flow
+
+# 依存関係をインストール、uvがPythonインタープリタと仮想環境の作成、必要なパッケージのインストールを担当
+uv sync
+
+# APIキーで.envを設定
+# Tavily: https://app.tavily.com/home
+# Brave_SEARCH: https://brave.com/search/api/
+# 火山引擎TTS: TTSの資格情報がある場合は追加
+cp .env.example .env
+
+# 下記の「サポートされている検索エンジン」と「テキスト読み上げ統合」セクションですべての利用可能なオプションを確認
+
+# LLMモデルとAPIキーのconf.yamlを設定
+# 詳細は「docs/configuration_guide.md」を参照
+cp conf.yaml.example conf.yaml
+
+# PPT生成用にmarpをインストール
+# https://github.com/marp-team/marp-cli?tab=readme-ov-file#use-package-manager
+brew install marp-cli
 ```
 
-2. **ローカル設定ファイルの生成**
+オプションで、[pnpm](https://pnpm.io/installation)を使用して Web UI 依存関係をインストール：
-
-   プロジェクトルートディレクトリ（`deer-flow/`）から以下を実行します：
 
 ```bash
-   make config
+cd deer-flow/web
+pnpm install
 ```
 
-   このコマンドは、提供されたテンプレートに基づいてローカル設定ファイルを作成します。
+### 設定
 
-3. **使用するモデルの設定**
+詳細については[設定ガイド](docs/configuration_guide.md)を参照してください。
 
-   `config.yaml`を編集し、少なくとも1つのモデルを定義します：
+> [!注意]
+> プロジェクトを開始する前に、ガイドを注意深く読み、特定の設定と要件に合わせて構成を更新してください。
 
-   ```yaml
+### コンソール UI
-   models:
-     - name: gpt-4                       # 内部識別子
-       display_name: GPT-4               # 表示名
-       use: langchain_openai:ChatOpenAI  # LangChainクラスパス
-       model: gpt-4                      # API用モデル識別子
-       api_key: $OPENAI_API_KEY          # APIキー（推奨：環境変数を使用）
-       max_tokens: 4096                  # リクエストあたりの最大トークン数
-       temperature: 0.7                  # サンプリング温度
 
-     - name: openrouter-gemini-2.5-flash
+プロジェクトを実行する最も迅速な方法は、コンソール UI を使用することです。
-       display_name: Gemini 2.5 Flash (OpenRouter)
-       use: langchain_openai:ChatOpenAI
-       model: google/gemini-2.5-flash-preview
-       api_key: $OPENAI_API_KEY          # OpenRouterもここではOpenAI互換のフィールド名を使用
-       base_url: https://openrouter.ai/api/v1
-   ```
-
-   OpenRouterやOpenAI互換のゲートウェイは、`langchain_openai:ChatOpenAI`と`base_url`で設定します。プロバイダー固有の環境変数名を使用したい場合は、`api_key`でその変数を明示的に指定してください（例：`api_key: $OPENROUTER_API_KEY`）。
-
-4. **設定したモデルのAPIキーを設定**
-
-   以下のいずれかの方法を選択してください：
-
-- オプションA：プロジェクトルートの`.env`ファイルを編集（推奨）
 
 ```bash
-   TAVILY_API_KEY=your-tavily-api-key
+# bashライクなシェルでプロジェクトを実行
-   OPENAI_API_KEY=your-openai-api-key
+uv run main.py
-   # OpenRouterもlangchain_openai:ChatOpenAI + base_url使用時はOPENAI_API_KEYを使用します。
-   # 必要に応じて他のプロバイダーキーを追加
-   INFOQUEST_API_KEY=your-infoquest-api-key
 ```
 
-- オプションB：シェルで環境変数をエクスポート
+### Web UI
+
+このプロジェクトには Web UI も含まれており、より動的で魅力的なインタラクティブ体験を提供します。
+
+> [!注意]
+> 先に Web UI の依存関係をインストールする必要があります。
 
 ```bash
-   export OPENAI_API_KEY=your-openai-api-key
+# 開発モードでバックエンドとフロントエンドサーバーの両方を実行
+# macOS/Linuxの場合
+./bootstrap.sh -d
+
+# Windowsの場合
+bootstrap.bat -d
 ```
 
-- オプションC：`config.yaml`を直接編集（本番環境には非推奨）
+ブラウザを開き、[`http://localhost:3000`](http://localhost:3000)にアクセスして Web UI を探索してください。
 
-   ```yaml
+[`web`](./web/)ディレクトリで詳細を確認できます。
-   models:
-     - name: gpt-4
-       api_key: your-actual-api-key-here  # プレースホルダーを置換
-   ```
 
-### アプリケーションの実行
+## サポートされている検索エンジン
 
-#### オプション1: Docker（推奨）
+DeerFlow は複数の検索エンジンをサポートしており、`.env`ファイルの`SEARCH_API`変数で設定できます：
 
-**開発環境**（ホットリロード、ソースマウント）：
+- **Tavily**（デフォルト）：AI アプリケーション向けの専門検索 API
+
+  - `.env`ファイルに`TAVILY_API_KEY`が必要
+  - 登録先：https://app.tavily.com/home
+
+- **DuckDuckGo**：プライバシー重視の検索エンジン
+
+  - API キー不要
+
+- **Brave Search**：高度な機能を備えたプライバシー重視の検索エンジン
+
+  - `.env`ファイルに`BRAVE_SEARCH_API_KEY`が必要
+  - 登録先：https://brave.com/search/api/
+
+- **Arxiv**：学術研究用の科学論文検索
+  - API キー不要
+  - 科学・学術論文専用
+
+お好みの検索エンジンを設定するには、`.env`ファイルで`SEARCH_API`変数を設定します：
 
 ```bash
-make docker-init    # サンドボックスイメージをプル（初回またはイメージ更新時のみ）
+# 選択肢: tavily, duckduckgo, brave_search, arxiv
-make docker-start   # サービスを開始（config.yamlからサンドボックスモードを自動検出）
+SEARCH_API=tavily
 ```
 
-`make docker-start`は、`config.yaml`がプロビジョナーモード（`sandbox.use: deerflow.community.aio_sandbox:AioSandboxProvider`と`provisioner_url`）を使用している場合にのみ`provisioner`を起動します。
+## 特徴
 
-**本番環境**（ローカルでイメージをビルドし、ランタイム設定とデータをマウント）：
+### コア機能
+
+- 🤖 **LLM 統合**
+  - [litellm](https://docs.litellm.ai/docs/providers)を通じてほとんどのモデルの統合をサポート
+  - Qwen などのオープンソースモデルをサポート
+  - OpenAI 互換の API インターフェース
+  - 異なるタスクの複雑さに対応するマルチティア LLM システム
+
+### ツールと MCP 統合
+
+- 🔍 **検索と取得**
+
+  - Tavily、Brave Search などを通じた Web 検索
+  - Jina を使用したクローリング
+  - 高度なコンテンツ抽出
+
+- 🔗 **MCP シームレス統合**
+  - プライベートドメインアクセス、ナレッジグラフ、Web ブラウジングなどの機能を拡張
+  - 多様な研究ツールと方法論の統合を促進
+
+### 人間との協力
+
+- 🧠 **人間参加型ループ**
+
+  - 自然言語を使用した研究計画の対話的修正をサポート
+  - 研究計画の自動承認をサポート
+
+- 📝 **レポート後編集**
+  - Notion ライクなブロック編集をサポート
+  - AI 支援による洗練、文の短縮、拡張などの AI 改良を可能に
+  - [tiptap](https://tiptap.dev/)を活用
+
+### コンテンツ作成
+
+- 🎙️ **ポッドキャストとプレゼンテーション生成**
+  - AI 駆動のポッドキャストスクリプト生成と音声合成
+  - シンプルな PowerPoint プレゼンテーションの自動作成
+  - カスタマイズ可能なテンプレートで個別のコンテンツに対応
+
+## アーキテクチャ
+
+DeerFlow は、自動研究とコード分析のためのモジュラーなマルチエージェントシステムアーキテクチャを実装しています。システムは LangGraph 上に構築され、コンポーネントが明確に定義されたメッセージパッシングシステムを通じて通信する柔軟な状態ベースのワークフローを実現しています。
+
+![アーキテクチャ図](./assets/architecture.png)
+
+> [deerflow.tech](https://deerflow.tech/#multi-agent-architecture)でライブで確認できます
+
+システムは以下のコンポーネントを含む合理化されたワークフローを採用しています：
+
+1. **コーディネーター**：ワークフローのライフサイクルを管理するエントリーポイント
+
+   - ユーザー入力に基づいて研究プロセスを開始
+   - 適切なタイミングでプランナーにタスクを委託
+   - ユーザーとシステム間の主要なインターフェースとして機能
+
+2. **プランナー**：タスク分解と計画のための戦略的コンポーネント
+
+   - 研究目標を分析し、構造化された実行計画を作成
+   - 十分なコンテキストが利用可能か、さらなる研究が必要かを判断
+   - 研究フローを管理し、最終レポート生成のタイミングを決定
+
+3. **研究チーム**：計画を実行する専門エージェントの集合：
+
+   - **研究者**：Web 検索エンジン、クローリング、さらには MCP サービスなどのツールを使用して Web 検索と情報収集を行う。
+   - **コーダー**：Python REPL ツールを使用してコード分析、実行、技術的タスクを処理する。
+     各エージェントは自分の役割に最適化された特定のツールにアクセスでき、LangGraph フレームワーク内で動作する
+
+4. **レポーター**：研究出力の最終段階プロセッサ
+   - 研究チームの調査結果を集約
+   - 収集した情報を処理および構造化
+   - 包括的な研究レポートを生成
+
+## 開発
+
+### テスト
+
+テストスイートの実行：
 
 ```bash
-make up     # イメージをビルドして全本番サービスを開始
+# すべてのテストを実行
-make down   # コンテナを停止して削除
+make test
+
+# 特定のテストファイルを実行
+pytest tests/integration/test_workflow.py
+
+# カバレッジテストを実行
+make coverage
 ```
 
-> [!NOTE]
+### コード品質
-> LangGraphエージェントサーバーは現在`langgraph dev`（オープンソースCLIサーバー）経由で実行されます。
-
-アクセス: http://localhost:2026
-
-詳細なDocker開発ガイドは[CONTRIBUTING.md](CONTRIBUTING.md)をご覧ください。
-
-#### オプション2: ローカル開発
-
-サービスをローカルで実行する場合：
-
-前提条件：上記の「設定」手順を先に完了してください（`make config`とモデルAPIキー）。`make dev`には有効な設定ファイルが必要です（デフォルトはプロジェクトルートの`config.yaml`。`DEER_FLOW_CONFIG_PATH`で上書き可能）。
-
-1. **前提条件の確認**：
-   ```bash
-   make check  # Node.js 22+、pnpm、uv、nginxを検証
-   ```
-
-2. **依存関係のインストール**：
-   ```bash
-   make install  # バックエンド＋フロントエンドの依存関係をインストール
-   ```
-
-3. **（オプション）サンドボックスイメージの事前プル**：
-   ```bash
-   # Docker/コンテナベースのサンドボックス使用時に推奨
-   make setup-sandbox
-   ```
-
-4. **サービスの開始**：
-   ```bash
-   make dev
-   ```
-
-5. **アクセス**: http://localhost:2026
-
-### 詳細設定
-#### サンドボックスモード
-
-DeerFlowは複数のサンドボックス実行モードをサポートしています：
-- **ローカル実行**（ホストマシン上で直接サンドボックスコードを実行）
-- **Docker実行**（分離されたDockerコンテナ内でサンドボックスコードを実行）
-- **KubernetesによるDocker実行**（プロビジョナーサービス経由でKubernetesポッドでサンドボックスコードを実行）
-
-Docker開発では、サービスの起動は`config.yaml`のサンドボックスモードに従います。ローカル/Dockerモードでは`provisioner`は起動されません。
-
-お好みのモードの設定については[サンドボックス設定ガイド](backend/docs/CONFIGURATION.md#sandbox)をご覧ください。
-
-#### MCPサーバー
-
-DeerFlowは、機能を拡張するための設定可能なMCPサーバーとスキルをサポートしています。
-HTTP/SSE MCPサーバーでは、OAuthトークンフロー（`client_credentials`、`refresh_token`）がサポートされています。
-詳細な手順は[MCPサーバーガイド](backend/docs/MCP_SERVER.md)をご覧ください。
-
-#### IMチャネル
-
-DeerFlowはメッセージングアプリからのタスク受信をサポートしています。チャネルは設定時に自動的に開始されます。いずれもパブリックIPは不要です。
-
-| チャネル | トランスポート | 難易度 |
-|---------|-----------|------------|
-| Telegram | Bot API（ロングポーリング） | 簡単 |
-| Slack | Socket Mode | 中程度 |
-| Feishu / Lark | WebSocket | 中程度 |
-
-**`config.yaml`での設定：**
-
-```yaml
-channels:
-  # LangGraphサーバーURL（デフォルト: http://localhost:2024）
-  langgraph_url: http://localhost:2024
-  # Gateway API URL（デフォルト: http://localhost:8001）
-  gateway_url: http://localhost:8001
-
-  # オプション: 全モバイルチャネルのグローバルセッションデフォルト
-  session:
-    assistant_id: lead_agent
-    config:
-      recursion_limit: 100
-    context:
-      thinking_enabled: true
-      is_plan_mode: false
-      subagent_enabled: false
-
-  feishu:
-    enabled: true
-    app_id: $FEISHU_APP_ID
-    app_secret: $FEISHU_APP_SECRET
-    # domain: https://open.feishu.cn       # China (default)
-    # domain: https://open.larksuite.com   # International
-
-  slack:
-    enabled: true
-    bot_token: $SLACK_BOT_TOKEN     # xoxb-...
-    app_token: $SLACK_APP_TOKEN     # xapp-...（Socket Mode）
-    allowed_users: []               # 空 = 全員許可
-
-  telegram:
-    enabled: true
-    bot_token: $TELEGRAM_BOT_TOKEN
-    allowed_users: []               # 空 = 全員許可
-
-    # オプション: チャネル/ユーザーごとのセッション設定
-    session:
-      assistant_id: mobile_agent
-      context:
-        thinking_enabled: false
-      users:
-        "123456789":
-          assistant_id: vip_agent
-          config:
-            recursion_limit: 150
-          context:
-            thinking_enabled: true
-            subagent_enabled: true
-```
-
-対応するAPIキーを`.env`ファイルに設定します：
 
 ```bash
-# Telegram
+# コードチェックを実行
-TELEGRAM_BOT_TOKEN=123456789:ABCdefGHIjklMNOpqrSTUvwxYZ
+make lint
 
-# Slack
+# コードをフォーマット
-SLACK_BOT_TOKEN=xoxb-...
+make format
-SLACK_APP_TOKEN=xapp-...
-
-# Feishu / Lark
-FEISHU_APP_ID=cli_xxxx
-FEISHU_APP_SECRET=your_app_secret
 ```
 
-**Telegramのセットアップ**
+### LangGraph Studio によるデバッグ
 
-1. [@BotFather](https://t.me/BotFather)とチャットし、`/newbot`を送信してHTTP APIトークンをコピーします。
+DeerFlow はワークフローアーキテクチャとして LangGraph を使用しています。LangGraph Studio を使用してワークフローをリアルタイムでデバッグおよび可視化できます。
-2. `.env`に`TELEGRAM_BOT_TOKEN`を設定し、`config.yaml`でチャネルを有効にします。
 
-**Slackのセットアップ**
+#### ローカルで LangGraph Studio を実行
 
-1. [api.slack.com/apps](https://api.slack.com/apps)でSlackアプリを作成 → 新規アプリ作成 → 最初から作成。
+DeerFlow には`langgraph.json`設定ファイルが含まれており、これが LangGraph Studio のグラフ構造と依存関係を定義しています。このファイルはプロジェクトで定義されたワークフローグラフを指し、`.env`ファイルから環境変数を自動的に読み込みます。
-2. **OAuth & Permissions**で、Botトークンスコープを追加：`app_mentions:read`、`chat:write`、`im:history`、`im:read`、`im:write`、`files:write`。
-3. **Socket Mode**を有効化 → `connections:write`スコープのApp-Levelトークン（`xapp-…`）を生成。
-4. **Event Subscriptions**で、ボットイベントを購読：`app_mention`、`message.im`。
-5. `.env`に`SLACK_BOT_TOKEN`と`SLACK_APP_TOKEN`を設定し、`config.yaml`でチャネルを有効にします。
 
-**Feishu / Larkのセットアップ**
+##### Mac
 
-1. [Feishu Open Platform](https://open.feishu.cn/)でアプリを作成 → **ボット**機能を有効化。
+```bash
-2. 権限を追加：`im:message`、`im:message.p2p_msg:readonly`、`im:resource`。
+# uvパッケージマネージャがない場合はインストール
-3. **イベント**で`im.message.receive_v1`を購読し、**ロングコネクション**モードを選択。
+curl -LsSf https://astral.sh/uv/install.sh | sh
-4. App IDとApp Secretをコピー。`.env`に`FEISHU_APP_ID`と`FEISHU_APP_SECRET`を設定し、`config.yaml`でチャネルを有効にします。
 
-**コマンド**
+# 依存関係をインストールしLangGraphサーバーを開始
+uvx --refresh --from "langgraph-cli[inmem]" --with-editable . --python 3.12 langgraph dev --allow-blocking
+```
 
-チャネル接続後、チャットから直接DeerFlowと対話できます：
+##### Windows / Linux
 
-| コマンド | 説明 |
+```bash
-|---------|-------------|
+# 依存関係をインストール
-| `/new` | 新しい会話を開始 |
+pip install -e .
-| `/status` | 現在のスレッド情報を表示 |
+pip install -U "langgraph-cli[inmem]"
-| `/models` | 利用可能なモデルを一覧表示 |
-| `/memory` | メモリを表示 |
-| `/help` | ヘルプを表示 |
 
-> コマンドプレフィックスのないメッセージは通常のチャットとして扱われ、DeerFlowがスレッドを作成して会話形式で応答します。
+# LangGraphサーバーを開始
+langgraph dev
+```
 
-#### LangSmithトレーシング
+LangGraph サーバーを開始すると、端末にいくつかの URL が表示されます：
 
-DeerFlowには[LangSmith](https://smith.langchain.com)による可観測性が組み込まれています。有効にすると、すべてのLLM呼び出し、エージェント実行、ツール実行がトレースされ、LangSmithダッシュボードで確認できます。
+- API: http://127.0.0.1:2024
+- Studio UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+- API ドキュメント: http://127.0.0.1:2024/docs
 
-`.env`ファイルに以下を追加します：
+ブラウザで Studio UI リンクを開いてデバッグインターフェースにアクセスします。
 
+#### LangGraph Studio の使用
+
+Studio UI では、次のことができます：
+
+1. ワークフローグラフを可視化し、コンポーネントの接続方法を確認
+2. 実行をリアルタイムで追跡し、データがシステム内をどのように流れるかを理解
+3. ワークフローの各ステップの状態を検査
+4. 各コンポーネントの入力と出力を検査して問題をデバッグ
+5. 計画段階でフィードバックを提供して研究計画を洗練
+
+Studio UI で研究トピックを送信すると、次を含む全ワークフロー実行プロセスを見ることができます：
+
+- 研究計画を作成する計画段階
+- 計画を修正できるフィードバックループ
+- 各セクションの研究と執筆段階
+- 最終レポート生成
+
+### LangSmith トレースの有効化
+
+DeerFlow は LangSmith トレース機能をサポートしており、ワークフローのデバッグとモニタリングに役立ちます。LangSmith トレースを有効にするには：
+
+1. `.env` ファイルに次の設定があることを確認してください（`.env.example` を参照）：
    ```bash
    LANGSMITH_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
+   LANGSMITH_ENDPOINT="https://api.smith.langchain.com"
-LANGSMITH_API_KEY=lsv2_pt_xxxxxxxxxxxxxxxx
+   LANGSMITH_API_KEY="xxx"
-LANGSMITH_PROJECT=xxx
+   LANGSMITH_PROJECT="xxx"
    ```
 
-Dockerデプロイでは、トレーシングはデフォルトで無効です。`.env`で`LANGSMITH_TRACING=true`と`LANGSMITH_API_KEY`を設定して有効にします。
+2. 次のコマンドを実行して LangSmith トレースを開始します：
-
+   ```bash
-## Deep Researchからスーパーエージェントハーネスへ
+   langgraph dev
-
-DeerFlowはDeep Researchフレームワークとして始まり、コミュニティがそれを大きく発展させました。リリース以来、開発者たちはリサーチを超えて活用してきました：データパイプラインの構築、スライドデッキの生成、ダッシュボードの立ち上げ、コンテンツワークフローの自動化。私たちが予想もしなかったことです。
-
-これは重要なことを示していました：DeerFlowは単なるリサーチツールではなかったのです。それは**ハーネス**——エージェントが実際に仕事をこなすためのインフラを提供するランタイムでした。
-
-そこで、ゼロから再構築しました。
-
-DeerFlow 2.0は、もはやつなぎ合わせるフレームワークではありません。バッテリー同梱、完全に拡張可能なスーパーエージェントハーネスです。LangGraphとLangChainの上に構築され、エージェントが必要とするすべてを標準搭載しています：ファイルシステム、メモリ、スキル、サンドボックス実行、そして複雑なマルチステップタスクのためのプランニングとサブエージェントの生成機能。
-
-そのまま使うもよし。分解して自分のものにするもよし。
-
-## コア機能
-
-### スキルとツール
-
-スキルこそが、DeerFlowを*ほぼ何でもできる*ものにしています。
-
-標準的なエージェントスキルは構造化された機能モジュールです——ワークフロー、ベストプラクティス、サポートリソースへの参照を定義するMarkdownファイルです。DeerFlowにはリサーチ、レポート生成、スライド作成、Webページ、画像・動画生成などの組み込みスキルが付属しています。しかし、真の力は拡張性にあります：独自のスキルを追加し、組み込みスキルを置き換え、複合ワークフローに組み合わせることができます。
-
-スキルはプログレッシブに読み込まれます——タスクが必要とする時にのみ、一度にすべてではありません。これによりコンテキストウィンドウを軽量に保ち、トークンに敏感なモデルでもDeerFlowがうまく動作します。
-
-Gateway経由で`.skill`アーカイブをインストールする際、DeerFlowは`version`、`author`、`compatibility`などの標準的なオプショナルフロントマターメタデータを受け入れ、有効な外部スキルを拒否しません。
-
-ツールも同じ哲学に従います。DeerFlowにはコアツールセット——Web検索、Webフェッチ、ファイル操作、bash実行——が付属し、MCPサーバーやPython関数によるカスタムツールをサポートしています。何でも入れ替え可能、何でも追加可能です。
-
-Gatewayが生成するフォローアップ提案は、プレーン文字列のモデル出力とブロック/リスト形式のリッチコンテンツの両方をJSON配列レスポンスの解析前に正規化するため、プロバイダー固有のコンテンツラッパーが提案をサイレントにドロップすることはありません。
-
-```
-# サンドボックスコンテナ内のパス
-/mnt/skills/public
-├── research/SKILL.md
-├── report-generation/SKILL.md
-├── slide-creation/SKILL.md
-├── web-page/SKILL.md
-└── image-generation/SKILL.md
-
-/mnt/skills/custom
-└── your-custom-skill/SKILL.md      ← あなたのカスタムスキル
    ```
 
-#### Claude Code連携
+これにより、LangGraph Studio でトレース可視化が有効になり、トレースがモニタリングと分析のために LangSmith に送信されます。
 
-`claude-to-deerflow`スキルを使えば、[Claude Code](https://docs.anthropic.com/en/docs/claude-code)から直接、実行中のDeerFlowインスタンスと対話できます。リサーチタスクの送信、ステータスの確認、スレッドの管理——すべてターミナルから離れずに実行できます。
+## Docker
 
-**スキルのインストール**：
+このプロジェクトは Docker でも実行できます。
+
+まず、以下の[設定](#設定)セクションを読んでください。`.env`と`.conf.yaml`ファイルが準備できていることを確認してください。
+
+次に、独自の Web サーバーの Docker イメージをビルドします：
 
 ```bash
-npx skills add https://github.com/bytedance/deer-flow --skill claude-to-deerflow
+docker build -t deer-flow-api .
 ```
 
-DeerFlowが実行中であることを確認し（デフォルトは`http://localhost:2026`）、Claude Codeで`/claude-to-deerflow`コマンドを使用します。
+最後に、Web サーバーを実行する Docker コンテナを起動します：
-
-**できること**：
-- DeerFlowにメッセージを送信してストリーミングレスポンスを取得
-- 実行モードの選択：flash（高速）、standard、pro（プランニング）、ultra（サブエージェント）
-- DeerFlowのヘルスチェック、モデル/スキル/エージェントの一覧表示
-- スレッドと会話履歴の管理
-- 分析用ファイルのアップロード
-
-**環境変数**（オプション、カスタムエンドポイント用）：
 
 ```bash
-DEERFLOW_URL=http://localhost:2026            # 統合プロキシベースURL
+# deer-flow-api-appを希望のコンテナ名に置き換えてください
-DEERFLOW_GATEWAY_URL=http://localhost:2026    # Gateway API
+docker run -d -t -p 8000:8000 --env-file .env --name deer-flow-api-app deer-flow-api
-DEERFLOW_LANGGRAPH_URL=http://localhost:2026/api/langgraph  # LangGraph API
+
+# サーバーを停止
+docker stop deer-flow-api-app
 ```
 
-完全なAPIリファレンスは[`skills/public/claude-to-deerflow/SKILL.md`](skills/public/claude-to-deerflow/SKILL.md)をご覧ください。
+### Docker Compose
 
-### サブエージェント
+このプロジェクトは docker compose でも設定できます：
 
-複雑なタスクは単一のパスに収まりません。DeerFlowはそれを分解します。
+```bash
+# dockerイメージをビルド
+docker compose build
 
-リードエージェントはオンザフライでサブエージェントを生成できます——それぞれ独自のスコープ付きコンテキスト、ツール、終了条件を持ちます。サブエージェントは可能な限り並列で実行され、構造化された結果を報告し、リードエージェントがすべてを一貫した出力に統合します。
+# サーバーを起動
-
+docker compose up
-これがDeerFlowが数分から数時間かかるタスクを処理する方法です：リサーチタスクが十数のサブエージェントに展開され、それぞれが異なる角度を探索し、1つのレポート——またはWebサイト——または生成されたビジュアル付きのスライドデッキに収束します。1つのハーネス、多くの手。
-
-### サンドボックスとファイルシステム
-
-DeerFlowは物事を*語る*だけではありません。自分のコンピューターを持っています。
-
-各タスクは、完全なファイルシステムを持つ分離されたDockerコンテナ内で実行されます——スキル、ワークスペース、アップロード、出力。エージェントはファイルの読み書き・編集を行います。bashコマンドを実行し、コーディングを行います。画像を表示します。すべてサンドボックス化され、すべて監査可能で、セッション間の汚染はゼロです。
-
-これが、ツールアクセスのあるチャットボットと、実際の実行環境を持つエージェントの違いです。
-
-```
-# サンドボックスコンテナ内のパス
-/mnt/user-data/
-├── uploads/          ← あなたのファイル
-├── workspace/        ← エージェントの作業ディレクトリ
-└── outputs/          ← 最終成果物
 ```
 
-### コンテキストエンジニアリング
+## テキスト読み上げ統合
 
-**分離されたサブエージェントコンテキスト**：各サブエージェントは独自の分離されたコンテキストで実行されます。これにより、サブエージェントはメインエージェントや他のサブエージェントのコンテキストを見ることができません。これは、サブエージェントが目の前のタスクに集中し、メインエージェントや他のサブエージェントのコンテキストに気を取られないようにするために重要です。
+DeerFlow には現在、研究レポートを音声に変換できるテキスト読み上げ（TTS）機能が含まれています。この機能は火山引擎 TTS API を使用して高品質なテキストオーディオを生成します。速度、音量、ピッチなどの特性もカスタマイズ可能です。
 
-**要約化**：セッション内で、DeerFlowはコンテキストを積極的に管理します——完了したサブタスクの要約、中間結果のファイルシステムへのオフロード、もはや直接関係のないものの圧縮。これにより、コンテキストウィンドウを超えることなく、長いマルチステップタスク全体を通じてシャープさを維持します。
+### TTS API の使用
 
-### 長期メモリ
+`/api/tts`エンドポイントから TTS 機能にアクセスできます：
 
-ほとんどのエージェントは、会話が終わるとすべてを忘れます。DeerFlowは記憶します。
+```bash
-
+# curlを使用したAPI呼び出し例
-セッションをまたいで、DeerFlowはあなたのプロフィール、好み、蓄積された知識の永続的なメモリを構築します。使えば使うほど、あなたのことをよく知るようになります——あなたの文体、技術スタック、繰り返されるワークフロー。メモリはローカルに保存され、あなたの管理下にあります。
+curl --location 'http://localhost:8000/api/tts' \
-
+--header 'Content-Type: application/json' \
-メモリ更新は適用時に重複するファクトエントリをスキップするようになり、繰り返される好みやコンテキストがセッションをまたいで際限なく蓄積されることはありません。
+--data '{
-
+    "text": "これはテキスト読み上げ機能のテストです。",
-## 推奨モデル
+    "speed_ratio": 1.0,
-
+    "volume_ratio": 1.0,
-DeerFlowはモデルに依存しません——OpenAI互換APIを実装する任意のLLMで動作します。とはいえ、以下をサポートするモデルで最高のパフォーマンスを発揮します：
+    "pitch_ratio": 1.0
-
+}' \
-- **長いコンテキストウィンドウ**（10万トークン以上）：深いリサーチとマルチステップタスク向け
+--output speech.mp3
-- **推論能力**：適応的なプランニングと複雑な分解向け
-- **マルチモーダル入力**：画像理解と動画理解向け
-- **強力なツール使用**：信頼性の高いファンクションコーリングと構造化された出力向け
-
-## 組み込みPythonクライアント
-
-DeerFlowは、完全なHTTPサービスを実行せずに組み込みPythonライブラリとして使用できます。`DeerFlowClient`は、すべてのエージェントとGateway機能へのプロセス内直接アクセスを提供し、HTTP Gateway APIと同じレスポンススキーマを返します：
-
-```python
-from deerflow.client import DeerFlowClient
-
-client = DeerFlowClient()
-
-# チャット
-response = client.chat("Analyze this paper for me", thread_id="my-thread")
-
-# ストリーミング（LangGraph SSEプロトコル：values、messages-tuple、end）
-for event in client.stream("hello"):
-    if event.type == "messages-tuple" and event.data.get("type") == "ai":
-        print(event.data["content"])
-
-# 設定＆管理 — Gateway準拠のdictを返す
-models = client.list_models()        # {"models": [...]}
-skills = client.list_skills()        # {"skills": [...]}
-client.update_skill("web-search", enabled=True)
-client.upload_files("thread-1", ["./report.pdf"])  # {"success": True, "files": [...]}
 ```
 
-すべてのdict返却メソッドはCIでGateway Pydanticレスポンスモデルに対して検証されており（`TestGatewayConformance`）、組み込みクライアントがHTTP APIスキーマと同期していることを保証します。完全なAPIドキュメントは`backend/packages/harness/deerflow/client.py`をご覧ください。
+## 例
 
-## ドキュメント
+以下の例は DeerFlow の機能を示しています：
 
-- [コントリビュートガイド](CONTRIBUTING.md) - 開発環境のセットアップとワークフロー
+### 研究レポート
-- [設定ガイド](backend/docs/CONFIGURATION.md) - セットアップと設定の手順
-- [アーキテクチャ概要](backend/CLAUDE.md) - 技術的なアーキテクチャの詳細
-- [バックエンドアーキテクチャ](backend/README.md) - バックエンドアーキテクチャとAPIリファレンス
 
-## ⚠️ セキュリティに関する注意
+1. **OpenAI Sora レポート** - OpenAI の Sora AI ツールの分析
 
-### 不適切なデプロイはセキュリティリスクを引き起こす可能性があります
+   - 機能、アクセス方法、プロンプトエンジニアリング、制限、倫理的考慮について議論
+   - [完全なレポートを見る](examples/openai_sora_report.md)
 
-DeerFlowは**システムコマンドの実行、リソース操作、ビジネスロジックの呼び出し**などの重要な高権限機能を備えており、デフォルトでは**ローカルの信頼できる環境（127.0.0.1のループバックアクセスのみ）にデプロイされる設計**になっています。信頼できないLAN、公開クラウドサーバー、または複数のエンドポイントからアクセス可能なネットワーク環境にエージェントをデプロイし、厳格なセキュリティ対策を講じない場合、以下のようなセキュリティリスクが生じる可能性があります：
+2. **Google の Agent to Agent プロトコルレポート** - Google の Agent to Agent（A2A）プロトコルの概要
 
-- **不正な違法呼び出し**：エージェントの機能が権限のない第三者や悪意のあるインターネットスキャナーに発見され、システムコマンドやファイル読み書きなどの高リスク操作を実行する不正な一括リクエストが引き起こされ、重大なセキュリティ上の問題が発生する可能性があります。
+   - AI エージェント通信における役割と、Anthropic の Model Context Protocol（MCP）との関係について議論
-- **コンプライアンスおよび法的リスク**：エージェントがサイバー攻撃やデータ窃取などの違法行為に不正使用された場合、法的責任やコンプライアンス上のリスクが生じる可能性があります。
+   - [完全なレポートを見る](examples/what_is_agent_to_agent_protocol.md)
 
-### セキュリティ推奨事項
+3. **MCP とは何か？** - 複数のコンテキストにおける「MCP」という用語の包括的分析
 
-**注意：DeerFlowはローカルの信頼できるネットワーク環境にデプロイすることを強く推奨します。** クロスデバイス・クロスネットワークのデプロイが必要な場合は、以下のような厳格なセキュリティ対策を実装する必要があります：
+   - AI における Model Context Protocol、化学における Monocalcium Phosphate、電子工学における Micro-channel Plate を探る
+   - [完全なレポートを見る](examples/what_is_mcp.md)
 
-- **IPホワイトリストの設定**：`iptables`を使用するか、ハードウェアファイアウォール / ACL機能付きスイッチをデプロイして**IPホワイトリストルールを設定**し、他のすべてのIPアドレスからのアクセスを拒否します。
+4. **ビットコイン価格変動** - 最近のビットコイン価格動向の分析
-- **前置認証**：リバースプロキシ（nginxなど）を設定し、**強力な前置認証を有効化**して、認証なしのアクセスをブロックします。
-- **ネットワーク分離**：可能であれば、エージェントと信頼できるデバイスを**同一の専用VLAN**に配置し、他のネットワークデバイスから隔離します。
-- **アップデートを継続的に確認**：DeerFlowのセキュリティ機能のアップデートを継続的にフォローしてください。
 
-## コントリビュート
+   - 市場動向、規制の影響、テクニカル指標の調査
+   - 歴史的データに基づく提言
+   - [完全なレポートを見る](examples/bitcoin_price_fluctuation.md)
 
-コントリビューションを歓迎します！開発環境のセットアップ、ワークフロー、ガイドラインについては[CONTRIBUTING.md](CONTRIBUTING.md)をご覧ください。
+5. **LLM とは何か？** - 大規模言語モデルの詳細な探求
 
-回帰テストのカバレッジには、`backend/tests/`でのDockerサンドボックスモード検出とプロビジョナーkubeconfig-pathハンドリングテストが含まれます。
+   - アーキテクチャ、トレーニング、応用、倫理的考慮について議論
+   - [完全なレポートを見る](examples/what_is_llm.md)
+
+6. **Claude を使った深層研究の方法は？** - 深層研究での Claude の使用に関するベストプラクティスとワークフロー
+
+   - プロンプトエンジニアリング、データ分析、他のツールとの統合
+   - [完全なレポートを見る](examples/how_to_use_claude_deep_research.md)
+
+7. **医療における AI 採用：影響要因** - 医療における AI 採用に影響する要因の分析
+
+   - AI テクノロジー、データ品質、倫理的考慮、経済的評価、組織の準備状況、デジタルインフラについて議論
+   - [完全なレポートを見る](examples/AI_adoption_in_healthcare.md)
+
+8. **量子コンピューティングの暗号学への影響** - 量子コンピューティングの暗号学への影響の分析
+
+   - 古典的暗号の脆弱性、ポスト量子暗号学、耐量子暗号ソリューションについて議論
+   - [完全なレポートを見る](examples/Quantum_Computing_Impact_on_Cryptography.md)
+
+9. **クリスティアーノ・ロナウドのパフォーマンスハイライト** - クリスティアーノ・ロナウドのパフォーマンスハイライトの分析
+   - 彼のキャリア達成、国際ゴール、さまざまな大会でのパフォーマンスについて議論
+   - [完全なレポートを見る](examples/Cristiano_Ronaldo's_Performance_Highlights.md)
+
+これらの例を実行したり、独自の研究レポートを作成したりするには、次のコマンドを使用できます：
+
+```bash
+# 特定のクエリで実行
+uv run main.py "医療におけるAI採用に影響する要因は何か？"
+
+# カスタム計画パラメータで実行
+uv run main.py --max_plan_iterations 3 "量子コンピューティングは暗号学にどのように影響するか？"
+
+# 組み込み質問を使用したインタラクティブモードで実行
+uv run main.py --interactive
+
+# または基本的なインタラクティブプロンプトで実行
+uv run main.py
+
+# 利用可能なすべてのオプションを表示
+uv run main.py --help
+```
+
+### インタラクティブモード
+
+アプリケーションは現在、英語と中国語の組み込み質問を使用したインタラクティブモードをサポートしています：
+
+1. インタラクティブモードを開始：
+
+   ```bash
+   uv run main.py --interactive
+   ```
+
+2. 好みの言語（English または Chinese）を選択
+
+3. 組み込み質問リストから選択するか、独自の質問を提示するオプションを選択
+
+4. システムが質問を処理し、包括的な研究レポートを生成
+
+### 人間参加型ループ
+
+DeerFlow には人間参加型ループメカニズムが含まれており、研究計画を実行する前にレビュー、編集、承認することができます：
+
+1. **計画レビュー**：人間参加型ループが有効な場合、システムは実行前に生成された研究計画を表示
+
+2. **フィードバック提供**：次のことができます：
+
+   - `[ACCEPTED]`と返信して計画を承認
+   - フィードバックを提供して計画を編集（例：`[EDIT PLAN] 技術実装に関するステップをさらに追加する`）
+   - システムはフィードバックを統合し、修正された計画を生成
+
+3. **自動承認**：レビュープロセスをスキップするために自動承認を有効にできます：
+
+   - API 経由：リクエストで`auto_accepted_plan: true`を設定
+
+4. **API 統合**：API を使用する場合、`feedback`パラメータでフィードバックを提供できます：
+   ```json
+   {
+     "messages": [
+       { "role": "user", "content": "量子コンピューティングとは何ですか？" }
+     ],
+     "thread_id": "my_thread_id",
+     "auto_accepted_plan": false,
+     "feedback": "[EDIT PLAN] 量子アルゴリズムについてもっと含める"
+   }
+   ```
+
+### コマンドライン引数
+
+アプリケーションは動作をカスタマイズするための複数のコマンドライン引数をサポートしています：
+
+- **query**：処理する研究クエリ（複数の単語でも可）
+- **--interactive**：組み込み質問を使用したインタラクティブモードで実行
+- **--max_plan_iterations**：最大計画サイクル数（デフォルト：1）
+- **--max_step_num**：研究計画の最大ステップ数（デフォルト：3）
+- **--debug**：詳細なデバッグログを有効化
+
+## よくある質問
+
+詳細については[FAQ.md](docs/FAQ.md)を参照してください。
 
 ## ライセンス
 
-このプロジェクトはオープンソースであり、[MITライセンス](./LICENSE)の下で提供されています。
+このプロジェクトはオープンソースであり、[MIT ライセンス](./LICENSE)に従っています。
 
 ## 謝辞
 
-DeerFlowはオープンソースコミュニティの素晴らしい成果の上に構築されています。DeerFlowを可能にしてくれたすべてのプロジェクトとコントリビューターに深く感謝いたします。まさに、巨人の肩の上に立っています。
+DeerFlow はオープンソースコミュニティの素晴らしい成果の上に構築されています。DeerFlow を可能にしたすべてのプロジェクトと貢献者に深く感謝します。私たちは確かに巨人の肩の上に立っています。
 
-以下のプロジェクトの貴重な貢献に心からの感謝を申し上げます：
+以下のプロジェクトに心からの感謝を表します：
 
-- **[LangChain](https://github.com/langchain-ai/langchain)**：その優れたフレームワークがLLMのインタラクションとチェーンを支え、シームレスな統合と機能を実現しています。
+- **[LangChain](https://github.com/langchain-ai/langchain)**：彼らの優れたフレームワークは、シームレスな統合と機能性を実現する LLM 相互作用とチェーンに力を与えています。
-- **[LangGraph](https://github.com/langchain-ai/langgraph)**：マルチエージェントオーケストレーションへの革新的なアプローチが、DeerFlowの洗練されたワークフローの実現に大きく貢献しています。
+- **[LangGraph](https://github.com/langchain-ai/langgraph)**：マルチエージェントオーケストレーションへの革新的アプローチは、DeerFlow の複雑なワークフローの実現に不可欠でした。
 
-これらのプロジェクトはオープンソースコラボレーションの変革的な力を体現しており、その基盤の上に構築できることを誇りに思います。
+これらのプロジェクトはオープンソースコラボレーションの変革力を示しており、その基盤の上に構築できることを誇りに思います。
 
-### 主要コントリビューター
+### 主要貢献者
 
-`DeerFlow`のコア著者に心からの感謝を捧げます。そのビジョン、情熱、献身がこのプロジェクトに命を吹き込みました：
+`DeerFlow`の主要な作者に心から感謝します。彼らのビジョン、情熱、献身がこのプロジェクトを実現しました：
 
 - **[Daniel Walnut](https://github.com/hetaoBackend/)**
 - **[Henry Li](https://github.com/magiccube/)**
 
-揺るぎないコミットメントと専門知識が、DeerFlowの成功の原動力です。この旅の先頭に立ってくださっていることを光栄に思います。
+あなたの揺るぎない取り組みと専門知識が DeerFlow の成功を推進しています。この旅をリードしていただき光栄です。
 
-## Star History
+## スター履歴
 
 [![Star History Chart](https://api.star-history.com/svg?repos=bytedance/deer-flow&type=Date)](https://star-history.com/#bytedance/deer-flow&Date)

README_ru.md

@@ -1,490 +0,0 @@
-# 🦌 DeerFlow - 2.0
-
-[English](./README.md) | [中文](./README_zh.md) | [日本語](./README_ja.md) | [Français](./README_fr.md) | Русский
-
-[![Python](https://img.shields.io/badge/Python-3.12%2B-3776AB?logo=python&logoColor=white)](./backend/pyproject.toml)
-[![Node.js](https://img.shields.io/badge/Node.js-22%2B-339933?logo=node.js&logoColor=white)](./Makefile)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
-
-<a href="https://trendshift.io/repositories/14699" target="_blank"><img src="https://trendshift.io/api/badge/repositories/14699" alt="bytedance%2Fdeer-flow | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
-
-> 28 февраля 2026 года DeerFlow занял 🏆 #1 в GitHub Trending после релиза версии 2. Спасибо огромное нашему сообществу — всё благодаря вам! 💪🔥
-
-DeerFlow (**D**eep **E**xploration and **E**fficient **R**esearch **Flow**) — open-source **Super Agent Harness**, который управляет **Sub-Agents**, **Memory** и **Sandbox** для решения почти любой задачи. Всё на основе расширяемых **Skills**.
-
-https://github.com/user-attachments/assets/a8bcadc4-e040-4cf2-8fda-dd768b999c18
-
-> [!NOTE]
-> **DeerFlow 2.0 — проект переписан с нуля.** Общего кода с v1 нет. Если нужен оригинальный Deep Research фреймворк — он живёт в ветке [`1.x`](https://github.com/bytedance/deer-flow/tree/main-1.x), туда тоже принимают контрибьюты. Активная разработка идёт в 2.0.
-
-## Официальный сайт
-
-[<img width="2880" height="1600" alt="image" src="https://github.com/user-attachments/assets/a598c49f-3b2f-41ea-a052-05e21349188a" />](https://deerflow.tech)
-
-Больше информации и живые демо на [**официальном сайте**](https://deerflow.tech).
-
-## Coding Plan от ByteDance Volcengine
-
-<img width="4808" height="2400" alt="英文方舟" src="https://github.com/user-attachments/assets/2ecc7b9d-50be-4185-b1f7-5542d222fb2d" />
-
-- Рекомендуем Doubao-Seed-2.0-Code, DeepSeek v3.2 и Kimi 2.5 для запуска DeerFlow
-- [Подробнее](https://www.byteplus.com/en/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
-- [Для разработчиков из материкового Китая](https://www.volcengine.com/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
-
-## InfoQuest
-
-DeerFlow интегрирован с инструментарием для умного поиска и краулинга от BytePlus — [InfoQuest (есть бесплатный онлайн-доступ)](https://docs.byteplus.com/en/docs/InfoQuest/What_is_Info_Quest)
-
-<a href="https://docs.byteplus.com/en/docs/InfoQuest/What_is_Info_Quest" target="_blank">
-  <img
-    src="https://sf16-sg.tiktokcdn.com/obj/eden-sg/hubseh7bsbps/20251208-160108.png"
-    alt="InfoQuest_banner"
-  />
-</a>
-
----
-
-## Содержание
-
-- [🦌 DeerFlow - 2.0](#-deerflow---20)
-  - [Официальный сайт](#официальный-сайт)
-  - [InfoQuest](#infoquest)
-  - [Содержание](#содержание)
-  - [Установка одной фразой для coding agent](#установка-одной-фразой-для-coding-agent)
-  - [Быстрый старт](#быстрый-старт)
-    - [Конфигурация](#конфигурация)
-    - [Запуск](#запуск)
-      - [Вариант 1: Docker (рекомендуется)](#вариант-1-docker-рекомендуется)
-      - [Вариант 2: Локальная разработка](#вариант-2-локальная-разработка)
-    - [Дополнительно](#дополнительно)
-      - [Режим Sandbox](#режим-sandbox)
-      - [MCP-сервер](#mcp-сервер)
-      - [Мессенджеры](#мессенджеры)
-      - [Трассировка LangSmith](#трассировка-langsmith)
-  - [От Deep Research к Super Agent Harness](#от-deep-research-к-super-agent-harness)
-  - [Core Features](#core-features)
-    - [Skills & Tools](#skills--tools)
-      - [Интеграция с Claude Code](#интеграция-с-claude-code)
-    - [Sub-Agents](#sub-agents)
-    - [Sandbox & файловая система](#sandbox--файловая-система)
-    - [Context Engineering](#context-engineering)
-    - [Long-Term Memory](#long-term-memory)
-  - [Рекомендуемые модели](#рекомендуемые-модели)
-  - [Встроенный Python-клиент](#встроенный-python-клиент)
-  - [Документация](#документация)
-  - [⚠️ Безопасность](#️-безопасность)
-  - [Участие в разработке](#участие-в-разработке)
-  - [Лицензия](#лицензия)
-  - [Благодарности](#благодарности)
-    - [Ключевые контрибьюторы](#ключевые-контрибьюторы)
-  - [История звёзд](#история-звёзд)
-
-## Установка одной фразой для coding agent
-
-Если вы используете Claude Code, Codex, Cursor, Windsurf или другой coding agent, просто отправьте ему эту фразу:
-
-```text
-Если DeerFlow еще не клонирован, сначала клонируй его, а затем подготовь локальное окружение разработки по инструкции https://raw.githubusercontent.com/bytedance/deer-flow/main/Install.md
-```
-
-Этот prompt предназначен для coding agent. Он просит агента при необходимости сначала клонировать репозиторий, предпочесть Docker, если он доступен, и в конце вернуть точную команду запуска и список недостающих настроек.
-
-## Быстрый старт
-
-### Конфигурация
-
-1. **Склонировать репозиторий DeerFlow**
-
-   ```bash
-   git clone https://github.com/bytedance/deer-flow.git
-   cd deer-flow
-   ```
-
-2. **Сгенерировать локальные конфиги**
-
-   Из корня проекта (`deer-flow/`) запустите:
-
-   ```bash
-   make config
-   ```
-
-   Команда создаёт локальные конфиги на основе шаблонов.
-
-3. **Настроить модель**
-
-   Отредактируйте `config.yaml` и задайте хотя бы одну модель:
-
-   ```yaml
-   models:
-     - name: gpt-4                       # Внутренний идентификатор
-       display_name: GPT-4               # Отображаемое имя
-       use: langchain_openai:ChatOpenAI  # Путь к классу LangChain
-       model: gpt-4                      # Идентификатор модели для API
-       api_key: $OPENAI_API_KEY          # API-ключ (рекомендуется: переменная окружения)
-       max_tokens: 4096                  # Максимальное количество токенов на запрос
-       temperature: 0.7                  # Температура сэмплирования
-
-     - name: openrouter-gemini-2.5-flash
-       display_name: Gemini 2.5 Flash (OpenRouter)
-       use: langchain_openai:ChatOpenAI
-       model: google/gemini-2.5-flash-preview
-       api_key: $OPENAI_API_KEY
-       base_url: https://openrouter.ai/api/v1
-
-     - name: gpt-5-responses
-       display_name: GPT-5 (Responses API)
-       use: langchain_openai:ChatOpenAI
-       model: gpt-5
-       api_key: $OPENAI_API_KEY
-       use_responses_api: true
-       output_version: responses/v1
-   ```
-
-   OpenRouter и аналогичные OpenAI-совместимые шлюзы настраиваются через `langchain_openai:ChatOpenAI` с параметром `base_url`. Для CLI-провайдеров:
-
-   ```yaml
-   models:
-     - name: gpt-5.4
-       display_name: GPT-5.4 (Codex CLI)
-       use: deerflow.models.openai_codex_provider:CodexChatModel
-       model: gpt-5.4
-       supports_thinking: true
-       supports_reasoning_effort: true
-
-     - name: claude-sonnet-4.6
-       display_name: Claude Sonnet 4.6 (Claude Code OAuth)
-       use: deerflow.models.claude_provider:ClaudeChatModel
-       model: claude-sonnet-4-6
-       max_tokens: 4096
-       supports_thinking: true
-   ```
-
-   - Codex CLI читает `~/.codex/auth.json`
-   - Claude Code принимает `CLAUDE_CODE_OAUTH_TOKEN`, `ANTHROPIC_AUTH_TOKEN` или `~/.claude/.credentials.json`
-   - На macOS при необходимости экспортируйте аутентификацию Claude Code явно:
-
-   ```bash
-   eval "$(python3 scripts/export_claude_code_oauth.py --print-export)"
-   ```
-
-4. **Указать API-ключи**
-
-   - **Вариант А**: файл `.env` в корне проекта (рекомендуется)
-
-   ```bash
-   TAVILY_API_KEY=your-tavily-api-key
-   OPENAI_API_KEY=your-openai-api-key
-   INFOQUEST_API_KEY=your-infoquest-api-key
-   ```
-
-   - **Вариант Б**: переменные окружения в терминале
-
-   ```bash
-   export OPENAI_API_KEY=your-openai-api-key
-   ```
-
-   - **Вариант В**: напрямую в `config.yaml` (не рекомендуется для продакшена)
-
-### Запуск
-
-#### Вариант 1: Docker (рекомендуется)
-
-**Разработка** (hot-reload, монтирование исходников):
-
-```bash
-make docker-init    # Загрузить образ Sandbox (один раз или при обновлении)
-make docker-start   # Запустить сервисы
-```
-
-**Продакшен** (собирает образы локально):
-
-```bash
-make up     # Собрать образы и запустить все сервисы
-make down   # Остановить и удалить контейнеры
-```
-
-> [!TIP]
-> На Linux при ошибке `permission denied` для Docker daemon добавьте пользователя в группу `docker` и перелогиньтесь. Подробнее в [CONTRIBUTING.md](CONTRIBUTING.md#linux-docker-daemon-permission-denied).
-
-Адрес: http://localhost:2026
-
-#### Вариант 2: Локальная разработка
-
-1. **Проверить зависимости**:
-   ```bash
-   make check  # Проверяет Node.js 22+, pnpm, uv, nginx
-   ```
-
-2. **Установить зависимости**:
-   ```bash
-   make install
-   ```
-
-3. **(Опционально) Загрузить образ Sandbox заранее**:
-   ```bash
-   make setup-sandbox
-   ```
-
-4. **Запустить сервисы**:
-   ```bash
-   make dev
-   ```
-
-5. **Адрес**: http://localhost:2026
-
-### Дополнительно
-
-#### Режим Sandbox
-
-DeerFlow поддерживает несколько режимов выполнения:
-- **Локальное выполнение** — код запускается прямо на хосте
-- **Docker** — код выполняется в изолированных Docker-контейнерах
-- **Docker + Kubernetes** — выполнение в Kubernetes-подах через provisioner
-
-Подробнее в [руководстве по конфигурации Sandbox](backend/docs/CONFIGURATION.md#sandbox).
-
-#### MCP-сервер
-
-DeerFlow поддерживает настраиваемые MCP-серверы для расширения возможностей. Для HTTP/SSE MCP-серверов поддерживаются OAuth-токены (`client_credentials`, `refresh_token`). Подробнее в [руководстве по MCP-серверу](backend/docs/MCP_SERVER.md).
-
-#### Мессенджеры
-
-DeerFlow принимает задачи прямо из мессенджеров. Каналы запускаются автоматически при настройке, публичный IP не нужен.
-
-| Канал | Транспорт | Сложность |
-|-------|-----------|-----------|
-| Telegram | Bot API (long-polling) | Просто |
-| Slack | Socket Mode | Средне |
-| Feishu / Lark | WebSocket | Средне |
-
-**Конфигурация в `config.yaml`:**
-
-```yaml
-channels:
-  feishu:
-    enabled: true
-    app_id: $FEISHU_APP_ID
-    app_secret: $FEISHU_APP_SECRET
-    # domain: https://open.feishu.cn       # China (default)
-    # domain: https://open.larksuite.com   # International
-
-  slack:
-    enabled: true
-    bot_token: $SLACK_BOT_TOKEN
-    app_token: $SLACK_APP_TOKEN
-    allowed_users: []
-
-  telegram:
-    enabled: true
-    bot_token: $TELEGRAM_BOT_TOKEN
-    allowed_users: []
-```
-
-**Настройка Telegram**
-
-1. Напишите [@BotFather](https://t.me/BotFather), отправьте `/newbot` и скопируйте HTTP API-токен.
-2. Укажите `TELEGRAM_BOT_TOKEN` в `.env` и включите канал в `config.yaml`.
-
-**Доступные команды**
-
-| Команда | Описание |
-|---------|----------|
-| `/new` | Начать новый диалог |
-| `/status` | Показать информацию о текущем треде |
-| `/models` | Список доступных моделей |
-| `/memory` | Просмотреть память |
-| `/help` | Показать справку |
-
-> Сообщения без команды воспринимаются как обычный чат — DeerFlow создаёт тред и отвечает.
-
-#### Трассировка LangSmith
-
-DeerFlow имеет встроенную интеграцию с [LangSmith](https://smith.langchain.com) для наблюдаемости. При включении все вызовы LLM, запуски агентов и выполнения инструментов отслеживаются и отображаются в дашборде LangSmith.
-
-Добавьте в файл `.env` в корне проекта:
-
-```bash
-LANGSMITH_TRACING=true
-LANGSMITH_API_KEY=lsv2_pt_xxxxxxxxxxxxxxxx
-LANGSMITH_PROJECT=deer-flow
-```
-
-`LANGSMITH_ENDPOINT` по умолчанию `https://api.smith.langchain.com` и может быть переопределён при необходимости. Устаревшие переменные `LANGCHAIN_*` (`LANGCHAIN_TRACING_V2`, `LANGCHAIN_API_KEY` и т.д.) также поддерживаются для обратной совместимости; `LANGSMITH_*` имеет приоритет, когда заданы обе.
-
-В Docker-развёртываниях трассировка отключена по умолчанию. Установите `LANGSMITH_TRACING=true` и `LANGSMITH_API_KEY` в `.env` для включения.
-
-## От Deep Research к Super Agent Harness
-
-DeerFlow начинался как фреймворк для Deep Research, и сообщество вышло далеко за эти рамки. После запуска разработчики строили пайплайны, генерировали презентации, поднимали дашборды, автоматизировали контент. То, чего мы не ожидали.
-
-Стало понятно: DeerFlow не просто research-инструмент. Это **harness**: runtime, который даёт агентам необходимую инфраструктуру.
-
-Поэтому мы переписали всё с нуля.
-
-DeerFlow 2.0 — это Super Agent Harness «из коробки». Batteries included, полностью расширяемый. Построен на LangGraph и LangChain. По умолчанию есть всё, что нужно агенту: файловая система, memory, skills, sandbox-выполнение и возможность планировать и запускать sub-agents для сложных многошаговых задач.
-
-Используйте как есть. Или разберите и переделайте под себя.
-
-## Core Features
-
-### Skills & Tools
-
-Skills — это то, что позволяет DeerFlow делать почти что угодно.
-
-Agent Skill — это структурированный модуль: Markdown-файл с описанием воркфлоу, лучших практик и ссылок на ресурсы. DeerFlow поставляется со встроенными skills для ресёрча, генерации отчётов, слайдов, веб-страниц, изображений и видео. Но главное — расширяемость: добавляйте свои skills, заменяйте встроенные или собирайте из них составные воркфлоу.
-
-Skills загружаются по мере необходимости, только когда задача их требует. Это держит контекстное окно чистым.
-
-```
-# Пути внутри контейнера sandbox
-/mnt/skills/public
-├── research/SKILL.md
-├── report-generation/SKILL.md
-├── slide-creation/SKILL.md
-├── web-page/SKILL.md
-└── image-generation/SKILL.md
-
-/mnt/skills/custom
-└── your-custom-skill/SKILL.md      ← ваш skill
-```
-
-#### Интеграция с Claude Code
-
-Skill `claude-to-deerflow` позволяет работать с DeerFlow прямо из [Claude Code](https://docs.anthropic.com/en/docs/claude-code). Отправляйте задачи, проверяйте статус, управляйте тредами, не выходя из терминала.
-
-**Установка скилла**:
-
-```bash
-npx skills add https://github.com/bytedance/deer-flow --skill claude-to-deerflow
-```
-
-**Что можно делать**:
-- Отправлять сообщения в DeerFlow и получать потоковые ответы
-- Выбирать режимы выполнения: flash (быстро), standard, pro (planning), ultra (sub-agents)
-- Проверять статус DeerFlow, просматривать модели, скиллы, агентов
-- Управлять тредами и историей диалога
-- Загружать файлы для анализа
-
-Полный справочник API в [`skills/public/claude-to-deerflow/SKILL.md`](skills/public/claude-to-deerflow/SKILL.md).
-
-### Sub-Agents
-
-Сложные задачи редко решаются за один проход. DeerFlow их декомпозирует.
-
-Lead agent запускает sub-agents на лету, каждый со своим изолированным контекстом, инструментами и условиями завершения. Sub-agents работают параллельно, возвращают структурированные результаты, а lead agent собирает всё в единый итог.
-
-Вот как DeerFlow справляется с задачами на минуты и часы: research-задача разветвляется в дюжину sub-agents, каждый копает свой угол, потом всё сходится в один отчёт, или сайт, или слайддек со сгенерированными визуалами. Один harness, много рук.
-
-### Sandbox & файловая система
-
-DeerFlow не просто *говорит* о том, что умеет что-то делать. У него есть собственный компьютер.
-
-Каждая задача выполняется внутри изолированного Docker-контейнера с полной файловой системой: skills, workspace, uploads, outputs. Агент читает, пишет и редактирует файлы. Выполняет bash-команды и пишет код. Смотрит на изображения. Всё изолировано, всё прозрачно, никакого пересечения между сессиями.
-
-Это разница между чатботом с доступом к инструментам и агентом с реальной средой выполнения.
-
-```
-# Пути внутри контейнера sandbox
-/mnt/user-data/
-├── uploads/          ← ваши файлы
-├── workspace/        ← рабочая директория агентов
-└── outputs/          ← результаты
-```
-
-### Context Engineering
-
-**Изолированный контекст**: каждый sub-agent работает в своём контексте и не видит контекст главного агента или других sub-agents. Агент фокусируется на своей задаче.
-
-**Управление контекстом**: внутри сессии DeerFlow агрессивно сжимает контекст и суммирует завершённые подзадачи, выгружает промежуточные результаты в файловую систему, сжимает то, что уже не актуально. На длинных многошаговых задачах контекстное окно не переполняется.
-
-### Long-Term Memory
-
-Большинство агентов забывают всё, когда диалог заканчивается. DeerFlow помнит.
-
-DeerFlow сохраняет ваш профиль, предпочтения и накопленные знания между сессиями. Чем больше используете, тем лучше он вас знает: стиль, технологический стек, повторяющиеся воркфлоу. Всё хранится локально и остаётся под вашим контролем.
-
-## Рекомендуемые модели
-
-DeerFlow работает с любым LLM через OpenAI-совместимый API. Лучше всего — с моделями, которые поддерживают:
-
-- **Большое контекстное окно** (100k+ токенов) — для deep research и многошаговых задач
-- **Reasoning capabilities** — для адаптивного планирования и сложной декомпозиции
-- **Multimodal inputs** — для работы с изображениями и видео
-- **Strong tool-use** — для надёжного вызова функций и структурированных ответов
-
-## Встроенный Python-клиент
-
-DeerFlow можно использовать как Python-библиотеку прямо в коде — без запуска HTTP-сервисов. `DeerFlowClient` даёт доступ ко всем возможностям агента и Gateway, возвращает те же схемы ответов, что и HTTP Gateway API:
-
-```python
-from deerflow.client import DeerFlowClient
-
-client = DeerFlowClient()
-
-# Chat
-response = client.chat("Analyze this paper for me", thread_id="my-thread")
-
-# Streaming (LangGraph SSE protocol: values, messages-tuple, end)
-for event in client.stream("hello"):
-    if event.type == "messages-tuple" and event.data.get("type") == "ai":
-        print(event.data["content"])
-
-# Configuration & management — returns Gateway-aligned dicts
-models = client.list_models()        # {"models": [...]}
-skills = client.list_skills()        # {"skills": [...]}
-client.update_skill("web-search", enabled=True)
-client.upload_files("thread-1", ["./report.pdf"])  # {"success": True, "files": [...]}
-```
-
-## Документация
-
-- [Руководство по участию](CONTRIBUTING.md) — настройка среды разработки, воркфлоу и гайдлайны
-- [Руководство по конфигурации](backend/docs/CONFIGURATION.md) — инструкции по настройке
-- [Обзор архитектуры](backend/CLAUDE.md) — технические детали
-- [Архитектура бэкенда](backend/README.md) — бэкенд и справочник API
-
-## ⚠️ Безопасность
-
-### Неправильное развёртывание может привести к угрозам безопасности
-
-DeerFlow обладает ключевыми высокопривилегированными возможностями, включая **выполнение системных команд, операции с ресурсами и вызов бизнес-логики**. По умолчанию он рассчитан на **развёртывание в локальной доверенной среде (доступ только через loopback-адрес 127.0.0.1)**. Если вы разворачиваете агент в недоверенных средах — локальных сетях, публичных облачных серверах или других окружениях, доступных с нескольких устройств — без строгих мер безопасности, это может привести к следующим угрозам:
-
-- **Несанкционированные вызовы**: функциональность агента может быть обнаружена неавторизованными третьими лицами или вредоносными сканерами, что приведёт к массовым несанкционированным запросам с выполнением высокорисковых операций (системные команды, чтение/запись файлов) и серьёзным последствиям для безопасности.
-- **Юридические и compliance-риски**: если агент будет незаконно использован для кибератак, кражи данных или других противоправных действий, это может повлечь юридическую ответственность и compliance-риски.
-
-### Рекомендации по безопасности
-
-**Примечание: настоятельно рекомендуем развёртывать DeerFlow только в локальной доверенной сети.** Если вам необходимо развёртывание через несколько устройств или сетей, обязательно реализуйте строгие меры безопасности, например:
-
-- **Белый список IP-адресов**: используйте `iptables` или аппаратные межсетевые экраны / коммутаторы с ACL, чтобы **настроить правила белого списка IP** и заблокировать доступ со всех остальных адресов.
-- **Шлюз аутентификации**: настройте обратный прокси (nginx и др.) и **включите строгую предварительную аутентификацию**, запрещающую любой доступ без авторизации.
-- **Сетевая изоляция**: по возможности разместите агент и доверенные устройства в **одном выделенном VLAN**, изолированном от остальной сети.
-- **Следите за обновлениями**: регулярно отслеживайте обновления безопасности проекта DeerFlow.
-
-## Участие в разработке
-
-Приветствуем контрибьюторов! Настройка среды разработки, воркфлоу и гайдлайны — в [CONTRIBUTING.md](CONTRIBUTING.md).
-
-## Лицензия
-
-Проект распространяется под [лицензией MIT](./LICENSE).
-
-## Благодарности
-
-DeerFlow стоит на плечах open-source сообщества. Спасибо всем проектам и разработчикам, чья работа сделала его возможным.
-
-Отдельная благодарность:
-
-- **[LangChain](https://github.com/langchain-ai/langchain)** — фреймворк для взаимодействия с LLM и построения цепочек.
-- **[LangGraph](https://github.com/langchain-ai/langgraph)** — многоагентная оркестрация, на которой держатся сложные воркфлоу DeerFlow.
-
-### Ключевые контрибьюторы
-
-Авторы DeerFlow, без которых проекта бы не было:
-
-- **[Daniel Walnut](https://github.com/hetaoBackend/)**
-- **[Henry Li](https://github.com/magiccube/)**
-
-## История звёзд
-
-[![Star History Chart](https://api.star-history.com/svg?repos=bytedance/deer-flow&type=Date)](https://star-history.com/#bytedance/deer-flow&Date)

README_zh.md

@@ -1,570 +1,551 @@
-# 🦌 DeerFlow - 2.0
+# 🦌 DeerFlow
 
-[English](./README.md) | 中文 | [日本語](./README_ja.md) | [Français](./README_fr.md) | [Русский](./README_ru.md)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-[![Python](https://img.shields.io/badge/Python-3.12%2B-3776AB?logo=python&logoColor=white)](./backend/pyproject.toml)
+[English](./README.md) | [简体中文](./README_zh.md) | [日本語](./README_ja.md) | [Deutsch](./README_de.md)
-[![Node.js](https://img.shields.io/badge/Node.js-22%2B-339933?logo=node.js&logoColor=white)](./Makefile)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
 
-<a href="https://trendshift.io/repositories/14699" target="_blank"><img src="https://trendshift.io/api/badge/repositories/14699" alt="bytedance%2Fdeer-flow | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+> 源于开源，回馈开源。
-> 2026 年 2 月 28 日，DeerFlow 2 发布后登上 GitHub Trending 第 1 名。非常感谢社区的支持，这是大家一起做到的。
 
-DeerFlow（**D**eep **E**xploration and **E**fficient **R**esearch **Flow**）是一个开源的 **super agent harness**。它把 **sub-agents**、**memory** 和 **sandbox** 组织在一起，再配合可扩展的 **skills**，让 agent 可以完成几乎任何事情。
+**DeerFlow**（**D**eep **E**xploration and **E**fficient **R**esearch **Flow**）是一个社区驱动的深度研究框架，它建立在开源社区的杰出工作基础之上。我们的目标是将语言模型与专业工具（如网络搜索、爬虫和 Python 代码执行）相结合，同时回馈使这一切成为可能的社区。
 
-https://github.com/user-attachments/assets/a8bcadc4-e040-4cf2-8fda-dd768b999c18
+请访问[DeerFlow 的官方网站](https://deerflow.tech/)了解更多详情。
 
-> [!NOTE]
+## 演示
-> **DeerFlow 2.0 是一次彻底重写。** 它和 v1 没有共用代码。如果你要找的是最初的 Deep Research 框架，可以前往 [`1.x` 分支](https://github.com/bytedance/deer-flow/tree/main-1.x)。那里仍然欢迎贡献；当前的主要开发已经转向 2.0。
 
-## 官网
+### 视频
 
-[<img width="2880" height="1600" alt="image" src="https://github.com/user-attachments/assets/a598c49f-3b2f-41ea-a052-05e21349188a" />](https://deerflow.tech)
+https://github.com/user-attachments/assets/f3786598-1f2a-4d07-919e-8b99dfa1de3e
 
-想了解更多，或者直接看**真实演示**，可以访问[**官网**](https://deerflow.tech)。
+在此演示中，我们展示了如何使用 DeerFlow：
 
-## 字节跳动火山引擎方舟 Coding Plan
+- 无缝集成 MCP 服务
+- 进行深度研究过程并生成包含图像的综合报告
+- 基于生成的报告创建播客音频
 
-[<img width="4808" height="2400" alt="codingplan -banner 素材" src="https://github.com/user-attachments/assets/d30dae52-84f2-4021-b32f-6d281252b9ea" />](https://www.volcengine.com/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
+### 回放示例
 
-- 我们推荐使用 Doubao-Seed-2.0-Code、DeepSeek v3.2 和 Kimi 2.5 运行 DeerFlow
+- [埃菲尔铁塔与最高建筑相比有多高？](https://deerflow.tech/chat?replay=eiffel-tower-vs-tallest-building)
-- [现在就加入 Coding Plan](https://www.volcengine.com/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
+- [GitHub 上最热门的仓库有哪些？](https://deerflow.tech/chat?replay=github-top-trending-repo)
-- [海外地区的开发者请点击这里](https://www.byteplus.com/en/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
+- [撰写关于南京传统美食的文章](https://deerflow.tech/chat?replay=nanjing-traditional-dishes)
+- [如何装饰租赁公寓？](https://deerflow.tech/chat?replay=rental-apartment-decoration)
+- [访问我们的官方网站探索更多回放示例。](https://deerflow.tech/#case-studies)
 
-## 目录
+---
 
-- [🦌 DeerFlow - 2.0](#-deerflow---20)
+## 📑 目录
-  - [官网](#官网)
-  - [InfoQuest](#infoquest)
-  - [目录](#目录)
-  - [一句话交给 Coding Agent 安装](#一句话交给-coding-agent-安装)
-  - [快速开始](#快速开始)
-    - [配置](#配置)
-    - [运行应用](#运行应用)
-      - [方式一：Docker（推荐）](#方式一docker推荐)
-      - [方式二：本地开发](#方式二本地开发)
-    - [进阶配置](#进阶配置)
-      - [Sandbox 模式](#sandbox-模式)
-      - [MCP Server](#mcp-server)
-      - [IM 渠道](#im-渠道)
-      - [LangSmith 链路追踪](#langsmith-链路追踪)
-  - [从 Deep Research 到 Super Agent Harness](#从-deep-research-到-super-agent-harness)
-  - [核心特性](#核心特性)
-    - [Skills 与 Tools](#skills-与-tools)
-      - [Claude Code 集成](#claude-code-集成)
-    - [Sub-Agents](#sub-agents)
-    - [Sandbox 与文件系统](#sandbox-与文件系统)
-    - [Context Engineering](#context-engineering)
-    - [长期记忆](#长期记忆)
-  - [推荐模型](#推荐模型)
-  - [内嵌 Python Client](#内嵌-python-client)
-  - [文档](#文档)
-  - [⚠️ 安全使用](#️-安全使用)
-  - [参与贡献](#参与贡献)
-  - [许可证](#许可证)
-  - [致谢](#致谢)
-    - [核心贡献者](#核心贡献者)
-  - [Star History](#star-history)
 
-## 一句话交给 Coding Agent 安装
+- [🚀 快速开始](#快速开始)
-
+- [🌟 特性](#特性)
-如果你在用 Claude Code、Codex、Cursor、Windsurf 或其他 coding agent，可以直接把下面这句话发给它：
+- [🏗️ 架构](#架构)
-
+- [🛠️ 开发](#开发)
-```text
+- [🗣️ 文本转语音集成](#文本转语音集成)
-如果还没 clone DeerFlow，就先 clone，然后按照 https://raw.githubusercontent.com/bytedance/deer-flow/main/Install.md 把它的本地开发环境初始化好
+- [📚 示例](#示例)
-```
+- [❓ 常见问题](#常见问题)
-
+- [📜 许可证](#许可证)
-这条提示词是给 coding agent 用的。它会在需要时先 clone 仓库，优先选择 Docker，完成初始化，并在结束时告诉你下一条启动命令，以及还缺哪些配置需要你补充。
+- [💖 致谢](#致谢)
+- [⭐ Star History](#star-History)
 
 ## 快速开始
 
-### 配置
+DeerFlow 使用 Python 开发，并配有用 Node.js 编写的 Web UI。为确保顺利的设置过程，我们推荐使用以下工具：
 
-1. **克隆 DeerFlow 仓库**
+### 推荐工具
+
+- **[`uv`](https://docs.astral.sh/uv/getting-started/installation/):**
+  简化 Python 环境和依赖管理。`uv`会自动在根目录创建虚拟环境并为您安装所有必需的包—无需手动安装 Python 环境。
+
+- **[`nvm`](https://github.com/nvm-sh/nvm):**
+  轻松管理多个 Node.js 运行时版本。
+
+- **[`pnpm`](https://pnpm.io/installation):**
+  安装和管理 Node.js 项目的依赖。
+
+### 环境要求
+
+确保您的系统满足以下最低要求：
+
+- **[Python](https://www.python.org/downloads/):** 版本 `3.12+`
+- **[Node.js](https://nodejs.org/en/download/):** 版本 `22+`
+
+### 安装
 
 ```bash
+# 克隆仓库
 git clone https://github.com/bytedance/deer-flow.git
 cd deer-flow
+
+# 安装依赖，uv将负责Python解释器和虚拟环境的创建，并安装所需的包
+uv sync
+
+# 使用您的API密钥配置.env
+# Tavily: https://app.tavily.com/home
+# Brave_SEARCH: https://brave.com/search/api/
+# 火山引擎TTS: 如果您有TTS凭证，请添加
+cp .env.example .env
+
+# 查看下方的"支持的搜索引擎"和"文本转语音集成"部分了解所有可用选项
+
+# 为您的LLM模型和API密钥配置conf.yaml
+# 请参阅'docs/configuration_guide.md'获取更多详情
+cp conf.yaml.example conf.yaml
+
+# 安装marp用于PPT生成
+# https://github.com/marp-team/marp-cli?tab=readme-ov-file#use-package-manager
+brew install marp-cli
 ```
 
-2. **生成本地配置文件**
+可选，通过[pnpm](https://pnpm.io/installation)安装 Web UI 依赖：
-
-   在项目根目录（`deer-flow/`）执行：
 
 ```bash
-   make config
+cd deer-flow/web
+pnpm install
 ```
 
-   这个命令会基于示例模板生成本地配置文件。
+### 配置
 
-3. **配置你要使用的模型**
+请参阅[配置指南](docs/configuration_guide.md)获取更多详情。
 
-   编辑 `config.yaml`，至少定义一个模型：
+> [!注意]
+> 在启动项目之前，请仔细阅读指南，并更新配置以匹配您的特定设置和要求。
 
-   ```yaml
+### 控制台 UI
-   models:
-     - name: gpt-4                       # 内部标识
-       display_name: GPT-4               # 展示名称
-       use: langchain_openai:ChatOpenAI  # LangChain 类路径
-       model: gpt-4                      # API 使用的模型标识
-       api_key: $OPENAI_API_KEY          # API key（推荐使用环境变量）
-       max_tokens: 4096                  # 单次请求最大 tokens
-       temperature: 0.7                  # 采样温度
 
-     - name: openrouter-gemini-2.5-flash
+运行项目的最快方法是使用控制台 UI。
-       display_name: Gemini 2.5 Flash (OpenRouter)
-       use: langchain_openai:ChatOpenAI
-       model: google/gemini-2.5-flash-preview
-       api_key: $OPENAI_API_KEY          # 这里 OpenRouter 依然沿用 OpenAI 兼容字段名
-       base_url: https://openrouter.ai/api/v1
-   ```
-
-   OpenRouter 以及类似的 OpenAI 兼容网关，建议通过 `langchain_openai:ChatOpenAI` 配合 `base_url` 来配置。如果你更想用 provider 自己的环境变量名，也可以直接把 `api_key` 指向对应变量，例如 `api_key: $OPENROUTER_API_KEY`。
-
-4. **为已配置的模型设置 API key**
-
-   可任选以下一种方式：
-
-- 方式 A：编辑项目根目录下的 `.env` 文件（推荐）
 
 ```bash
-   TAVILY_API_KEY=your-tavily-api-key
+# 在类bash的shell中运行项目
-   OPENAI_API_KEY=your-openai-api-key
+uv run main.py
-   # 如果配置使用的是 langchain_openai:ChatOpenAI + base_url，OpenRouter 也会读取 OPENAI_API_KEY
-   # 其他 provider 的 key 按需补充
-   INFOQUEST_API_KEY=your-infoquest-api-key
 ```
 
-- 方式 B：在 shell 中导出环境变量
+### Web UI
+
+本项目还包括一个 Web UI，提供更加动态和引人入胜的交互体验。
+
+> [!注意]
+> 您需要先安装 Web UI 的依赖。
 
 ```bash
-   export OPENAI_API_KEY=your-openai-api-key
+# 在开发模式下同时运行后端和前端服务器
+# 在macOS/Linux上
+./bootstrap.sh -d
+
+# 在Windows上
+bootstrap.bat -d
 ```
 
-- 方式 C：直接编辑 `config.yaml`（不建议用于生产环境）
+打开浏览器并访问[`http://localhost:3000`](http://localhost:3000)探索 Web UI。
 
-   ```yaml
+在[`web`](./web/)目录中探索更多详情。
-   models:
-     - name: gpt-4
-       api_key: your-actual-api-key-here  # 替换为真实 key
-   ```
 
-### 运行应用
+## 支持的搜索引擎
 
-#### 方式一：Docker（推荐）
+DeerFlow 支持多种搜索引擎，可以在`.env`文件中通过`SEARCH_API`变量进行配置：
 
-**开发模式**（支持热更新，挂载源码）：
+- **Tavily**（默认）：专为 AI 应用设计的专业搜索 API
+
+  - 需要在`.env`文件中设置`TAVILY_API_KEY`
+  - 注册地址：https://app.tavily.com/home
+
+- **DuckDuckGo**：注重隐私的搜索引擎
+
+  - 无需 API 密钥
+
+- **Brave Search**：具有高级功能的注重隐私的搜索引擎
+
+  - 需要在`.env`文件中设置`BRAVE_SEARCH_API_KEY`
+  - 注册地址：https://brave.com/search/api/
+
+- **Arxiv**：用于学术研究的科学论文搜索
+  - 无需 API 密钥
+  - 专为科学和学术论文设计
+
+要配置您首选的搜索引擎，请在`.env`文件中设置`SEARCH_API`变量：
 
 ```bash
-make docker-init    # 拉取 sandbox 镜像（首次运行或镜像更新时执行）
+# 选择一个：tavily, duckduckgo, brave_search, arxiv
-make docker-start   # 启动服务（会根据 config.yaml 自动判断 sandbox 模式）
+SEARCH_API=tavily
 ```
 
-如果 `config.yaml` 使用的是 provisioner 模式（`sandbox.use: deerflow.community.aio_sandbox:AioSandboxProvider` 且配置了 `provisioner_url`），`make docker-start` 才会启动 `provisioner`。
+## 特性
 
-**生产模式**（本地构建镜像，并挂载运行期配置与数据）：
+### 核心能力
+
+- 🤖 **LLM 集成**
+  - 通过[litellm](https://docs.litellm.ai/docs/providers)支持集成大多数模型
+  - 支持开源模型如 Qwen
+  - 兼容 OpenAI 的 API 接口
+  - 多层 LLM 系统适用于不同复杂度的任务
+
+### 工具和 MCP 集成
+
+- 🔍 **搜索和检索**
+
+  - 通过 Tavily、Brave Search 等进行网络搜索
+  - 使用 Jina 进行爬取
+  - 高级内容提取
+
+- 🔗 **MCP 无缝集成**
+  - 扩展私有域访问、知识图谱、网页浏览等能力
+  - 促进多样化研究工具和方法的集成
+
+### 人机协作
+
+- 🧠 **人在环中**
+
+  - 支持使用自然语言交互式修改研究计划
+  - 支持自动接受研究计划
+
+- 📝 **报告后期编辑**
+  - 支持类 Notion 的块编辑
+  - 允许 AI 优化，包括 AI 辅助润色、句子缩短和扩展
+  - 由[tiptap](https://tiptap.dev/)提供支持
+
+### 内容创作
+
+- 🎙️ **播客和演示文稿生成**
+  - AI 驱动的播客脚本生成和音频合成
+  - 自动创建简单的 PowerPoint 演示文稿
+  - 可定制模板以满足个性化内容需求
+
+## 架构
+
+DeerFlow 实现了一个模块化的多智能体系统架构，专为自动化研究和代码分析而设计。该系统基于 LangGraph 构建，实现了灵活的基于状态的工作流，其中组件通过定义良好的消息传递系统进行通信。
+
+![架构图](./assets/architecture.png)
+
+> 在[deerflow.tech](https://deerflow.tech/#multi-agent-architecture)上查看实时演示
+
+系统采用了精简的工作流程，包含以下组件：
+
+1. **协调器**：管理工作流生命周期的入口点
+
+   - 根据用户输入启动研究过程
+   - 在适当时候将任务委派给规划器
+   - 作为用户和系统之间的主要接口
+
+2. **规划器**：负责任务分解和规划的战略组件
+
+   - 分析研究目标并创建结构化执行计划
+   - 确定是否有足够的上下文或是否需要更多研究
+   - 管理研究流程并决定何时生成最终报告
+
+3. **研究团队**：执行计划的专业智能体集合：
+
+   - **研究员**：使用网络搜索引擎、爬虫甚至 MCP 服务等工具进行网络搜索和信息收集。
+   - **编码员**：使用 Python REPL 工具处理代码分析、执行和技术任务。
+     每个智能体都可以访问针对其角色优化的特定工具，并在 LangGraph 框架内运行
+
+4. **报告员**：研究输出的最终阶段处理器
+   - 汇总研究团队的发现
+   - 处理和组织收集的信息
+   - 生成全面的研究报告
+
+## 开发
+
+### 测试
+
+运行测试套件：
 
 ```bash
-make up     # 构建镜像并启动全部生产服务
+# 运行所有测试
-make down   # 停止并移除容器
+make test
+
+# 运行特定测试文件
+pytest tests/integration/test_workflow.py
+
+# 运行覆盖率测试
+make coverage
 ```
 
-> [!NOTE]
+### 代码质量
-> 当前 LangGraph agent server 通过开源 CLI 服务 `langgraph dev` 运行。
-
-访问地址：http://localhost:2026
-
-更完整的 Docker 开发说明见 [CONTRIBUTING.md](CONTRIBUTING.md)。
-
-#### 方式二：本地开发
-
-如果你更希望直接在本地启动各个服务：
-
-前提：先完成上面的“配置”步骤（`make config` 和模型 API key 配置）。`make dev` 需要有效配置文件，默认读取项目根目录下的 `config.yaml`，也可以通过 `DEER_FLOW_CONFIG_PATH` 覆盖。
-在 Windows 上，请使用 Git Bash 运行本地开发流程。基于 bash 的服务脚本不支持直接在原生 `cmd.exe` 或 PowerShell 中执行，且 WSL 也不保证可用，因为部分脚本依赖 Git for Windows 的 `cygpath` 等工具。
-
-1. **检查依赖环境**：
-   ```bash
-   make check  # 校验 Node.js 22+、pnpm、uv、nginx
-   ```
-
-2. **安装依赖**：
-   ```bash
-   make install  # 安装 backend + frontend 依赖
-   ```
-
-3. **（可选）预拉取 sandbox 镜像**：
-   ```bash
-   # 如果使用 Docker / Container sandbox，建议先执行
-   make setup-sandbox
-   ```
-
-4. **启动服务**：
-   ```bash
-   make dev
-   ```
-
-5. **访问地址**：http://localhost:2026
-
-### 进阶配置
-#### Sandbox 模式
-
-DeerFlow 支持多种 sandbox 执行方式：
-- **本地执行**（直接在宿主机上运行 sandbox 代码）
-- **Docker 执行**（在隔离的 Docker 容器里运行 sandbox 代码）
-- **Docker + Kubernetes 执行**（通过 provisioner 服务在 Kubernetes Pod 中运行 sandbox 代码）
-
-Docker 开发时，服务启动行为会遵循 `config.yaml` 里的 sandbox 模式。在 Local / Docker 模式下，不会启动 `provisioner`。
-
-如果要配置你自己的模式，参见 [Sandbox 配置指南](backend/docs/CONFIGURATION.md#sandbox)。
-
-#### MCP Server
-
-DeerFlow 支持可配置的 MCP Server 和 skills，用来扩展能力。
-对于 HTTP/SSE MCP Server，还支持 OAuth token 流程（`client_credentials`、`refresh_token`）。
-详细说明见 [MCP Server 指南](backend/docs/MCP_SERVER.md)。
-
-#### IM 渠道
-
-DeerFlow 支持从即时通讯应用接收任务。只要配置完成，对应渠道会自动启动，而且都不需要公网 IP。
-
-| 渠道 | 传输方式 | 上手难度 |
-|---------|-----------|------------|
-| Telegram | Bot API（long-polling） | 简单 |
-| Slack | Socket Mode | 中等 |
-| Feishu / Lark | WebSocket | 中等 |
-| 企业微信智能机器人 | WebSocket | 中等 |
-
-**`config.yaml` 中的配置示例：**
-
-```yaml
-channels:
-  # LangGraph Server URL（默认：http://localhost:2024）
-  langgraph_url: http://localhost:2024
-  # Gateway API URL（默认：http://localhost:8001）
-  gateway_url: http://localhost:8001
-
-  # 可选：所有移动端渠道共用的全局 session 默认值
-  session:
-    assistant_id: lead_agent  # 也可以填自定义 agent 名；渠道层会自动转换为 lead_agent + agent_name
-    config:
-      recursion_limit: 100
-    context:
-      thinking_enabled: true
-      is_plan_mode: false
-      subagent_enabled: false
-
-  feishu:
-    enabled: true
-    app_id: $FEISHU_APP_ID
-    app_secret: $FEISHU_APP_SECRET
-    # domain: https://open.feishu.cn       # 国内版（默认）
-    # domain: https://open.larksuite.com   # 国际版
-
-  wecom:
-    enabled: true
-    bot_id: $WECOM_BOT_ID
-    bot_secret: $WECOM_BOT_SECRET
-
-  slack:
-    enabled: true
-    bot_token: $SLACK_BOT_TOKEN     # xoxb-...
-    app_token: $SLACK_APP_TOKEN     # xapp-...（Socket Mode）
-    allowed_users: []               # 留空表示允许所有人
-
-  telegram:
-    enabled: true
-    bot_token: $TELEGRAM_BOT_TOKEN
-    allowed_users: []               # 留空表示允许所有人
-
-    # 可选：按渠道 / 按用户单独覆盖 session 配置
-    session:
-      assistant_id: mobile-agent  # 这里同样支持自定义 agent 名
-      context:
-        thinking_enabled: false
-      users:
-        "123456789":
-          assistant_id: vip-agent
-          config:
-            recursion_limit: 150
-          context:
-            thinking_enabled: true
-            subagent_enabled: true
-```
-
-说明：
-- `assistant_id: lead_agent` 会直接调用默认的 LangGraph assistant。
-- 如果 `assistant_id` 填的是自定义 agent 名，DeerFlow 仍然会走 `lead_agent`，同时把该值注入为 `agent_name`，这样 IM 渠道也会生效对应 agent 的 SOUL 和配置。
-
-在 `.env` 里设置对应的 API key：
 
 ```bash
-# Telegram
+# 运行代码检查
-TELEGRAM_BOT_TOKEN=123456789:ABCdefGHIjklMNOpqrSTUvwxYZ
+make lint
 
-# Slack
+# 格式化代码
-SLACK_BOT_TOKEN=xoxb-...
+make format
-SLACK_APP_TOKEN=xapp-...
-
-# Feishu / Lark
-FEISHU_APP_ID=cli_xxxx
-FEISHU_APP_SECRET=your_app_secret
-
-# 企业微信智能机器人
-WECOM_BOT_ID=your_bot_id
-WECOM_BOT_SECRET=your_bot_secret
 ```
 
-**Telegram 配置**
+### 使用 LangGraph Studio 进行调试
 
-1. 打开 [@BotFather](https://t.me/BotFather)，发送 `/newbot`，复制生成的 HTTP API token。
+DeerFlow 使用 LangGraph 作为其工作流架构。您可以使用 LangGraph Studio 实时调试和可视化工作流。
-2. 在 `.env` 中设置 `TELEGRAM_BOT_TOKEN`，并在 `config.yaml` 里启用该渠道。
 
-**Slack 配置**
+#### 本地运行 LangGraph Studio
 
-1. 前往 [api.slack.com/apps](https://api.slack.com/apps) 创建 Slack App：Create New App → From scratch。
+DeerFlow 包含一个`langgraph.json`配置文件，该文件定义了 LangGraph Studio 的图结构和依赖关系。该文件指向项目中定义的工作流图，并自动从`.env`文件加载环境变量。
-2. 在 **OAuth & Permissions** 中添加 Bot Token Scopes：`app_mentions:read`、`chat:write`、`im:history`、`im:read`、`im:write`、`files:write`。
-3. 启用 **Socket Mode**，生成带 `connections:write` 权限的 App-Level Token（`xapp-...`）。
-4. 在 **Event Subscriptions** 中订阅 bot events：`app_mention`、`message.im`。
-5. 在 `.env` 中设置 `SLACK_BOT_TOKEN` 和 `SLACK_APP_TOKEN`，并在 `config.yaml` 中启用该渠道。
 
-**Feishu / Lark 配置**
+##### Mac
 
-1. 在 [飞书开放平台](https://open.feishu.cn/) 创建应用，并启用 **Bot** 能力。
+```bash
-2. 添加权限：`im:message`、`im:message.p2p_msg:readonly`、`im:resource`。
+# 如果您没有uv包管理器，请安装它
-3. 在 **事件订阅** 中订阅 `im.message.receive_v1`，连接方式选择 **长连接**。
+curl -LsSf https://astral.sh/uv/install.sh | sh
-4. 复制 App ID 和 App Secret，在 `.env` 中设置 `FEISHU_APP_ID` 和 `FEISHU_APP_SECRET`，并在 `config.yaml` 中启用该渠道。
 
-**企业微信智能机器人配置**
+# 安装依赖并启动LangGraph服务器
+uvx --refresh --from "langgraph-cli[inmem]" --with-editable . --python 3.12 langgraph dev --allow-blocking
+```
 
-1. 在企业微信智能机器人平台创建机器人，获取 `bot_id` 和 `bot_secret`。
+##### Windows / Linux
-2. 在 `config.yaml` 中启用 `channels.wecom`，并填入 `bot_id` / `bot_secret`。
-3. 在 `.env` 中设置 `WECOM_BOT_ID` 和 `WECOM_BOT_SECRET`。
-4. 安装后端依赖时确保包含 `wecom-aibot-python-sdk`，渠道会通过 WebSocket 长连接接收消息，无需公网回调地址。
-5. 当前支持文本、图片和文件入站消息；agent 生成的最终图片/文件也会回传到企业微信会话中。
 
-**命令**
+```bash
+# 安装依赖
+pip install -e .
+pip install -U "langgraph-cli[inmem]"
 
-渠道连接完成后，你可以直接在聊天窗口里和 DeerFlow 交互：
+# 启动LangGraph服务器
+langgraph dev
+```
 
-| 命令 | 说明 |
+启动 LangGraph 服务器后，您将在终端中看到几个 URL：
-|---------|-------------|
-| `/new` | 开启新对话 |
-| `/status` | 查看当前 thread 信息 |
-| `/models` | 列出可用模型 |
-| `/memory` | 查看 memory |
-| `/help` | 查看帮助 |
 
-> 没有命令前缀的消息会被当作普通聊天处理。DeerFlow 会自动创建 thread，并以对话方式回复。
+- API: http://127.0.0.1:2024
+- Studio UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+- API 文档: http://127.0.0.1:2024/docs
 
-#### LangSmith 链路追踪
+在浏览器中打开 Studio UI 链接以访问调试界面。
 
-DeerFlow 内置了 [LangSmith](https://smith.langchain.com) 集成，用于可观测性。启用后，所有 LLM 调用、agent 运行和工具执行都会被追踪，并在 LangSmith 仪表盘中展示。
+#### 使用 LangGraph Studio
 
-在 `.env` 文件中添加以下配置：
+在 Studio UI 中，您可以：
 
+1. 可视化工作流图并查看组件如何连接
+2. 实时跟踪执行情况，了解数据如何在系统中流动
+3. 检查工作流每个步骤的状态
+4. 通过检查每个组件的输入和输出来调试问题
+5. 在规划阶段提供反馈以完善研究计划
+
+当您在 Studio UI 中提交研究主题时，您将能够看到整个工作流执行过程，包括：
+
+- 创建研究计划的规划阶段
+- 可以修改计划的反馈循环
+- 每个部分的研究和写作阶段
+- 最终报告生成
+
+### 启用 LangSmith 追踪
+
+DeerFlow 支持 LangSmith 追踪功能，帮助您调试和监控工作流。要启用 LangSmith 追踪：
+
+1. 确保您的 `.env` 文件中有以下配置（参见 `.env.example`）：
    ```bash
    LANGSMITH_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
+   LANGSMITH_ENDPOINT="https://api.smith.langchain.com"
-LANGSMITH_API_KEY=lsv2_pt_xxxxxxxxxxxxxxxx
+   LANGSMITH_API_KEY="xxx"
-LANGSMITH_PROJECT=xxx
+   LANGSMITH_PROJECT="xxx"
    ```
 
-Docker 部署时，追踪默认关闭。在 `.env` 中设置 `LANGSMITH_TRACING=true` 和 `LANGSMITH_API_KEY` 即可启用。
+2. 通过运行以下命令本地启动 LangSmith 追踪：
-
+   ```bash
-## 从 Deep Research 到 Super Agent Harness
+   langgraph dev
-
-DeerFlow 最初是一个 Deep Research 框架，后来社区把它一路推到了更远的地方。上线之后，开发者拿它去做的事情早就不止研究：搭数据流水线、生成演示文稿、快速起 dashboard、自动化内容流程，很多方向一开始连我们自己都没想到。
-
-这让我们意识到一件事：DeerFlow 不只是一个研究工具。它更像一个 **harness**，一个真正让 agents 把事情做完的运行时基础设施。
-
-所以我们把它从头重做了一遍。
-
-DeerFlow 2.0 不再是一个需要你自己拼装的 framework。它是一个开箱即用、同时又足够可扩展的 super agent harness。基于 LangGraph 和 LangChain 构建，默认就带上了 agent 真正会用到的关键能力：文件系统、memory、skills、sandbox 执行环境，以及为复杂多步骤任务做规划、拉起 sub-agents 的能力。
-
-你可以直接拿来用，也可以拆开重组，改成你自己的样子。
-
-## 核心特性
-
-### Skills 与 Tools
-
-Skills 是 DeerFlow 能做“几乎任何事”的关键。
-
-标准的 Agent Skill 是一种结构化能力模块，通常就是一个 Markdown 文件，里面定义了工作流、最佳实践，以及相关的参考资源。DeerFlow 自带一批内置 skills，覆盖研究、报告生成、演示文稿制作、网页生成、图像和视频生成等场景。真正有意思的地方在于它的扩展性：你可以加自己的 skills，替换内置 skills，或者把多个 skills 组合成复合工作流。
-
-Skills 采用按需渐进加载，不会一次性把所有内容都塞进上下文。只有任务确实需要时才加载，这样能把上下文窗口控制得更干净，也更适合对 token 比较敏感的模型。
-
-通过 Gateway 安装 `.skill` 压缩包时，DeerFlow 会接受标准的可选 frontmatter 元数据，比如 `version`、`author`、`compatibility`，不会把本来合法的外部 skill 拒之门外。
-
-Tools 也是同样的思路。DeerFlow 自带一组核心工具：网页搜索、网页抓取、文件操作、bash 执行；同时也支持通过 MCP Server 和 Python 函数扩展自定义工具。你可以替换任何一项，也可以继续往里加。
-
-Gateway 生成后续建议时，现在会先把普通字符串输出和 block/list 风格的富文本内容统一归一化，再去解析 JSON 数组响应，因此不同 provider 的内容包装方式不会再悄悄把建议吞掉。
-
-```text
-# sandbox 容器内的路径
-/mnt/skills/public
-├── research/SKILL.md
-├── report-generation/SKILL.md
-├── slide-creation/SKILL.md
-├── web-page/SKILL.md
-└── image-generation/SKILL.md
-
-/mnt/skills/custom
-└── your-custom-skill/SKILL.md      ← 你的 skill
    ```
 
-#### Claude Code 集成
+这将在 LangGraph Studio 中启用追踪可视化，并将您的追踪发送到 LangSmith 进行监控和分析。
 
-借助 `claude-to-deerflow` skill，你可以直接在 [Claude Code](https://docs.anthropic.com/en/docs/claude-code) 里和正在运行的 DeerFlow 实例交互。不用离开终端，就能下发研究任务、查看状态、管理 threads。
+## Docker
 
-**安装这个 skill：**
+您也可以使用 Docker 运行此项目。
+
+首先，您需要阅读下面的[配置](#配置)部分。确保`.env`和`.conf.yaml`文件已准备就绪。
+
+其次，构建您自己的 Web 服务器 Docker 镜像：
 
 ```bash
-npx skills add https://github.com/bytedance/deer-flow --skill claude-to-deerflow
+docker build -t deer-flow-api .
 ```
 
-然后确认 DeerFlow 已经启动（默认地址是 `http://localhost:2026`），在 Claude Code 里使用 `/claude-to-deerflow` 命令即可。
+最后，启动运行 Web 服务器的 Docker 容器：
-
-**你可以做的事情包括：**
-- 给 DeerFlow 发送消息，并接收流式响应
-- 选择执行模式：flash（更快）、standard、pro（规划模式）、ultra（sub-agents 模式）
-- 检查 DeerFlow 健康状态，列出 models / skills / agents
-- 管理 threads 和会话历史
-- 上传文件做分析
-
-**环境变量**（可选，用于自定义端点）：
 
 ```bash
-DEERFLOW_URL=http://localhost:2026            # 统一代理基地址
+# 将deer-flow-api-app替换为您首选的容器名称
-DEERFLOW_GATEWAY_URL=http://localhost:2026    # Gateway API
+docker run -d -t -p 8000:8000 --env-file .env --name deer-flow-api-app deer-flow-api
-DEERFLOW_LANGGRAPH_URL=http://localhost:2026/api/langgraph  # LangGraph API
+
+# 停止服务器
+docker stop deer-flow-api-app
 ```
 
-完整 API 说明见 [`skills/public/claude-to-deerflow/SKILL.md`](skills/public/claude-to-deerflow/SKILL.md)。
+### Docker Compose
 
-### Sub-Agents
+您也可以使用 docker compose 设置此项目：
 
-复杂任务通常不可能一次完成，DeerFlow 会先拆解，再执行。
+```bash
+# 构建docker镜像
+docker compose build
 
-lead agent 可以按需动态拉起 sub-agents。每个 sub-agent 都有自己独立的上下文、工具和终止条件。只要条件允许，它们就会并行运行，返回结构化结果，最后再由 lead agent 汇总成一份完整输出。
+# 启动服务器
-
+docker compose up
-这也是 DeerFlow 能处理从几分钟到几小时任务的原因。比如一个研究任务，可以拆成十几个 sub-agents，分别探索不同方向，最后合并成一份报告，或者一个网站，或者一套带生成视觉内容的演示文稿。一个 harness，多路并行。
-
-### Sandbox 与文件系统
-
-DeerFlow 不只是“会说它能做”，它是真的有一台自己的“电脑”。
-
-每个任务都运行在隔离的 Docker 容器里，里面有完整的文件系统，包括 skills、workspace、uploads、outputs。agent 可以读写和编辑文件，可以执行 bash 命令和代码，也可以查看图片。整个过程都在 sandbox 内完成，可审计、会隔离，不会在不同 session 之间互相污染。
-
-这就是“带工具的聊天机器人”和“真正有执行环境的 agent”之间的差别。
-
-```text
-# sandbox 容器内的路径
-/mnt/user-data/
-├── uploads/          ← 你的文件
-├── workspace/        ← agents 的工作目录
-└── outputs/          ← 最终交付物
 ```
 
-### Context Engineering
+## 文本转语音集成
 
-**隔离的 Sub-Agent Context**：每个 sub-agent 都在自己独立的上下文里运行。它看不到主 agent 的上下文，也看不到其他 sub-agents 的上下文。这样做的目的很直接，就是让它只聚焦当前任务，不被无关信息干扰。
+DeerFlow 现在包含一个文本转语音(TTS)功能，允许您将研究报告转换为语音。此功能使用火山引擎 TTS API 生成高质量的文本音频。速度、音量和音调等特性也可以自定义。
 
-**摘要压缩**：在单个 session 内，DeerFlow 会比较积极地管理上下文，包括总结已完成的子任务、把中间结果转存到文件系统、压缩暂时不重要的信息。这样在长链路、多步骤任务里，它也能保持聚焦，而不会轻易把上下文窗口打爆。
+### 使用 TTS API
 
-### 长期记忆
+您可以通过`/api/tts`端点访问 TTS 功能：
 
-大多数 agents 会在对话结束后把一切都忘掉，DeerFlow 不一样。
+```bash
-
+# 使用curl的API调用示例
-跨 session 使用时，DeerFlow 会逐步积累关于你的持久 memory，包括你的个人偏好、知识背景，以及长期沉淀下来的工作习惯。你用得越多，它越了解你的写作风格、技术栈和重复出现的工作流。memory 保存在本地，控制权也始终在你手里。
+curl --location 'http://localhost:8000/api/tts' \
-
+--header 'Content-Type: application/json' \
-## 推荐模型
+--data '{
-
+    "text": "这是文本转语音功能的测试。",
-DeerFlow 对模型没有强绑定，只要实现了 OpenAI 兼容 API 的 LLM，理论上都可以接入。不过在下面这些能力上表现更强的模型，通常会更适合 DeerFlow：
+    "speed_ratio": 1.0,
-
+    "volume_ratio": 1.0,
-- **长上下文窗口**（100k+ tokens），适合深度研究和多步骤任务
+    "pitch_ratio": 1.0
-- **推理能力**，适合自适应规划和复杂拆解
+}' \
-- **多模态输入**，适合理解图片和视频
+--output speech.mp3
-- **稳定的 tool use 能力**，适合可靠的函数调用和结构化输出
-
-## 内嵌 Python Client
-
-DeerFlow 也可以作为内嵌的 Python 库使用，不必启动完整的 HTTP 服务。`DeerFlowClient` 提供了进程内的直接访问方式，覆盖所有 agent 和 Gateway 能力，返回的数据结构与 HTTP Gateway API 保持一致：
-
-```python
-from deerflow.client import DeerFlowClient
-
-client = DeerFlowClient()
-
-# Chat
-response = client.chat("Analyze this paper for me", thread_id="my-thread")
-
-# Streaming（LangGraph SSE 协议：values、messages-tuple、end）
-for event in client.stream("hello"):
-    if event.type == "messages-tuple" and event.data.get("type") == "ai":
-        print(event.data["content"])
-
-# 配置与管理：返回值与 Gateway 对齐的 dict
-models = client.list_models()        # {"models": [...]}
-skills = client.list_skills()        # {"skills": [...]}
-client.update_skill("web-search", enabled=True)
-client.upload_files("thread-1", ["./report.pdf"])  # {"success": True, "files": [...]}
 ```
 
-所有返回 dict 的方法都会在 CI 中通过 Gateway 的 Pydantic 响应模型校验（`TestGatewayConformance`），以确保内嵌 client 始终和 HTTP API schema 保持同步。完整 API 说明见 `backend/packages/harness/deerflow/client.py`。
+## 示例
 
-## 文档
+以下示例展示了 DeerFlow 的功能：
 
-- [贡献指南](CONTRIBUTING.md) - 开发环境搭建与协作流程
+### 研究报告
-- [配置指南](backend/docs/CONFIGURATION.md) - 安装与配置说明
-- [架构概览](backend/CLAUDE.md) - 技术架构说明
-- [后端架构](backend/README.md) - 后端架构与 API 参考
 
-## ⚠️ 安全使用
+1. **OpenAI Sora 报告** - OpenAI 的 Sora AI 工具分析
 
-### 不恰当的部署可能导致安全风险
+   - 讨论功能、访问方式、提示工程、限制和伦理考虑
+   - [查看完整报告](examples/openai_sora_report.md)
 
-DeerFlow 具备**系统指令执行、资源操作、业务逻辑调用**等关键高权限能力，默认设计为**部署在本地可信环境（仅本机 127.0.0.1 回环访问）**。若您将 agent 部署至不可信局域网、公网云服务器等可被多终端访问的网络环境，且未采取严格的安全防护措施，可能导致安全风险，例如：
+2. **Google 的 Agent to Agent 协议报告** - Google 的 Agent to Agent (A2A)协议概述
 
-- **未授权的非法调用**：agent 功能被未授权的第三方、公网恶意扫描程序探测到，进而发起批量非法调用请求，执行系统命令、文件读写等高危操作，可能导致安全后果。
+   - 讨论其在 AI 智能体通信中的作用及其与 Anthropic 的 Model Context Protocol (MCP)的关系
-- **合规与法律风险**：若 agent 被非法调用用于实施网络攻击、信息窃取等违法违规行为，可能产生法律责任与合规风险。
+   - [查看完整报告](examples/what_is_agent_to_agent_protocol.md)
 
-### 安全使用建议
+3. **什么是 MCP？** - 对"MCP"一词在多个上下文中的全面分析
 
-**注意：建议您将 DeerFlow 部署在本地可信的网络环境下。** 若您有跨设备、跨网络的部署需求，必须加入严格的安全措施。例如，采取如下手段：
+   - 探讨 AI 中的 Model Context Protocol、化学中的 Monocalcium Phosphate 和电子学中的 Micro-channel Plate
+   - [查看完整报告](examples/what_is_mcp.md)
 
-- **设置访问 IP 白名单**：使用 `iptables`，或部署硬件防火墙 / 带访问控制（ACL）功能的交换机等，**配置规则设置 IP 白名单**，拒绝其他所有 IP 进行访问。
+4. **比特币价格波动** - 最近比特币价格走势分析
-- **前置身份验证**：配置反向代理（nginx 等），并**开启高强度的前置身份验证功能**，禁止无任何身份验证的访问。
-- **网络隔离**：若有可能，建议将 agent 和可信设备划分到**同一个专用 VLAN**，与其他网络设备做隔离。
-- **持续关注项目更新**：请持续关注 DeerFlow 项目的安全功能更新。
 
-## 参与贡献
+   - 研究市场趋势、监管影响和技术指标
+   - 基于历史数据提供建议
+   - [查看完整报告](examples/bitcoin_price_fluctuation.md)
 
-欢迎参与贡献。开发环境、工作流和相关规范见 [CONTRIBUTING.md](CONTRIBUTING.md)。
+5. **什么是 LLM？** - 对大型语言模型的深入探索
 
-目前回归测试已经覆盖 Docker sandbox 模式识别，以及 `backend/tests/` 中 provisioner kubeconfig-path 处理相关测试。
+   - 讨论架构、训练、应用和伦理考虑
+   - [查看完整报告](examples/what_is_llm.md)
+
+6. **如何使用 Claude 进行深度研究？** - 在深度研究中使用 Claude 的最佳实践和工作流程
+
+   - 涵盖提示工程、数据分析和与其他工具的集成
+   - [查看完整报告](examples/how_to_use_claude_deep_research.md)
+
+7. **医疗保健中的 AI 采用：影响因素** - 影响医疗保健中 AI 采用的因素分析
+
+   - 讨论 AI 技术、数据质量、伦理考虑、经济评估、组织准备度和数字基础设施
+   - [查看完整报告](examples/AI_adoption_in_healthcare.md)
+
+8. **量子计算对密码学的影响** - 量子计算对密码学影响的分析
+
+   - 讨论经典密码学的漏洞、后量子密码学和抗量子密码解决方案
+   - [查看完整报告](examples/Quantum_Computing_Impact_on_Cryptography.md)
+
+9. **克里斯蒂亚诺·罗纳尔多的表现亮点** - 克里斯蒂亚诺·罗纳尔多表现亮点的分析
+   - 讨论他的职业成就、国际进球和在各种比赛中的表现
+   - [查看完整报告](examples/Cristiano_Ronaldo's_Performance_Highlights.md)
+
+要运行这些示例或创建您自己的研究报告，您可以使用以下命令：
+
+```bash
+# 使用特定查询运行
+uv run main.py "哪些因素正在影响医疗保健中的AI采用？"
+
+# 使用自定义规划参数运行
+uv run main.py --max_plan_iterations 3 "量子计算如何影响密码学？"
+
+# 在交互模式下运行，带有内置问题
+uv run main.py --interactive
+
+# 或者使用基本交互提示运行
+uv run main.py
+
+# 查看所有可用选项
+uv run main.py --help
+```
+
+### 交互模式
+
+应用程序现在支持带有英文和中文内置问题的交互模式：
+
+1. 启动交互模式：
+
+   ```bash
+   uv run main.py --interactive
+   ```
+
+2. 选择您偏好的语言（English 或中文）
+
+3. 从内置问题列表中选择或选择提出您自己问题的选项
+
+4. 系统将处理您的问题并生成全面的研究报告
+
+### 人在环中
+
+DeerFlow 包含一个人在环中机制，允许您在执行研究计划前审查、编辑和批准：
+
+1. **计划审查**：启用人在环中时，系统将在执行前向您展示生成的研究计划
+
+2. **提供反馈**：您可以：
+
+   - 通过回复`[ACCEPTED]`接受计划
+   - 通过提供反馈编辑计划（例如，`[EDIT PLAN] 添加更多关于技术实现的步骤`）
+   - 系统将整合您的反馈并生成修订后的计划
+
+3. **自动接受**：您可以启用自动接受以跳过审查过程：
+
+   - 通过 API：在请求中设置`auto_accepted_plan: true`
+
+4. **API 集成**：使用 API 时，您可以通过`feedback`参数提供反馈：
+   ```json
+   {
+     "messages": [{ "role": "user", "content": "什么是量子计算？" }],
+     "thread_id": "my_thread_id",
+     "auto_accepted_plan": false,
+     "feedback": "[EDIT PLAN] 包含更多关于量子算法的内容"
+   }
+   ```
+
+### 命令行参数
+
+应用程序支持多个命令行参数来自定义其行为：
+
+- **query**：要处理的研究查询（可以是多个词）
+- **--interactive**：以交互模式运行，带有内置问题
+- **--max_plan_iterations**：最大规划周期数（默认：1）
+- **--max_step_num**：研究计划中的最大步骤数（默认：3）
+- **--debug**：启用详细调试日志
+
+## 常见问题
+
+请参阅[FAQ.md](docs/FAQ.md)获取更多详情。
 
 ## 许可证
 
-本项目采用 [MIT License](./LICENSE) 开源发布。
+本项目是开源的，遵循[MIT 许可证](./LICENSE)。
 
 ## 致谢
 
-DeerFlow 建立在开源社区大量优秀工作的基础上。所有让 DeerFlow 成为可能的项目和贡献者，我们都心怀感谢。毫不夸张地说，我们是站在巨人的肩膀上继续往前走。
+DeerFlow 建立在开源社区的杰出工作基础之上。我们深深感谢所有使 DeerFlow 成为可能的项目和贡献者。诚然，我们站在巨人的肩膀上。
 
-特别感谢以下项目带来的关键支持：
+我们要向以下项目表达诚挚的感谢，感谢他们的宝贵贡献：
 
-- **[LangChain](https://github.com/langchain-ai/langchain)**：它们提供的优秀框架支撑了我们的 LLM 交互与 chains，让整体集成和能力编排顺畅可用。
+- **[LangChain](https://github.com/langchain-ai/langchain)**：他们卓越的框架为我们的 LLM 交互和链提供动力，实现了无缝集成和功能。
-- **[LangGraph](https://github.com/langchain-ai/langgraph)**：它们在多 agent 编排上的创新方式，是 DeerFlow 复杂工作流得以成立的重要基础。
+- **[LangGraph](https://github.com/langchain-ai/langgraph)**：他们在多智能体编排方面的创新方法对于实现 DeerFlow 复杂工作流至关重要。
 
-这些项目体现了开源协作真正的力量，我们也很高兴能继续建立在这些基础之上。
+这些项目展示了开源协作的变革力量，我们很自豪能够在他们的基础上构建。
 
 ### 核心贡献者
 
-感谢 `DeerFlow` 的核心作者，是他们的判断、投入和持续推进，才让这个项目真正落地：
+衷心感谢`DeerFlow`的核心作者，他们的愿景、热情和奉献使这个项目得以实现：
 
 - **[Daniel Walnut](https://github.com/hetaoBackend/)**
 - **[Henry Li](https://github.com/magiccube/)**
 
+您坚定不移的承诺和专业知识是 DeerFlow 成功的驱动力。我们很荣幸有您引领这一旅程。
+
 ## Star History
 
 [![Star History Chart](https://api.star-history.com/svg?repos=bytedance/deer-flow&type=Date)](https://star-history.com/#bytedance/deer-flow&Date)

SECURITY.md

@@ -1,12 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-As deer-flow doesn't provide an official release yet, please use the latest version for the security updates.
-Currently, we have two branches to maintain:
-* main branch for deer-flow 2.x
-* main-1.x branch for deer-flow 1.x 
-
-## Reporting a Vulnerability
-
-Please go to https://github.com/bytedance/deer-flow/security to report the vulnerability you find.

backend/.gitignore

@@ -1,28 +0,0 @@
-# Python-generated files
-__pycache__/
-*.py[oc]
-build/
-dist/
-wheels/
-*.egg-info
-.coverage
-.coverage.*
-.ruff_cache
-agent_history.gif
-static/browser_history/*.gif
-
-log/
-log/*
-
-# Virtual environments
-.venv
-venv/
-
-# User config file
-config.yaml
-
-# Langgraph
-.langgraph_api
-
-# Claude Code settings
-.claude/settings.local.json

backend/.vscode/extensions.json

@@ -1,3 +0,0 @@
-{
-  "recommendations": ["charliermarsh.ruff"]
-}

backend/.vscode/settings.json

@@ -1,11 +0,0 @@
-{
-  "window.title": "${activeEditorShort}${separator}${separator}deer-flow/backend",
-  "[python]": {
-    "editor.formatOnSave": true,
-    "editor.codeActionsOnSave": {
-      "source.fixAll": "explicit",
-      "source.organizeImports": "explicit"
-    },
-    "editor.defaultFormatter": "charliermarsh.ruff"
-  }
-}

backend/AGENTS.md

@@ -1,2 +0,0 @@
-For the backend architecture and design patterns:
-@./CLAUDE.md

backend/CLAUDE.md

@@ -1,555 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-DeerFlow is a LangGraph-based AI super agent system with a full-stack architecture. The backend provides a "super agent" with sandbox execution, persistent memory, subagent delegation, and extensible tool integration - all operating in per-thread isolated environments.
-
-**Architecture**:
-- **LangGraph Server** (port 2024): Agent runtime and workflow execution
-- **Gateway API** (port 8001): REST API for models, MCP, skills, memory, artifacts, uploads, and local thread cleanup
-- **Frontend** (port 3000): Next.js web interface
-- **Nginx** (port 2026): Unified reverse proxy entry point
-- **Provisioner** (port 8002, optional in Docker dev): Started only when sandbox is configured for provisioner/Kubernetes mode
-
-**Runtime Modes**:
-- **Standard mode** (`make dev`): LangGraph Server handles agent execution as a separate process. 4 processes total.
-- **Gateway mode** (`make dev-pro`, experimental): Agent runtime embedded in Gateway via `RunManager` + `run_agent()` + `StreamBridge` (`packages/harness/deerflow/runtime/`). Service manages its own concurrency via async tasks. 3 processes total, no LangGraph Server.
-
-**Project Structure**:
-```
-deer-flow/
-├── Makefile                    # Root commands (check, install, dev, stop)
-├── config.yaml                 # Main application configuration
-├── extensions_config.json      # MCP servers and skills configuration
-├── backend/                    # Backend application (this directory)
-│   ├── Makefile               # Backend-only commands (dev, gateway, lint)
-│   ├── langgraph.json         # LangGraph server configuration
-│   ├── packages/
-│   │   └── harness/           # deerflow-harness package (import: deerflow.*)
-│   │       ├── pyproject.toml
-│   │       └── deerflow/
-│   │           ├── agents/            # LangGraph agent system
-│   │           │   ├── lead_agent/    # Main agent (factory + system prompt)
-│   │           │   ├── middlewares/   # 10 middleware components
-│   │           │   ├── memory/        # Memory extraction, queue, prompts
-│   │           │   └── thread_state.py # ThreadState schema
-│   │           ├── sandbox/           # Sandbox execution system
-│   │           │   ├── local/         # Local filesystem provider
-│   │           │   ├── sandbox.py     # Abstract Sandbox interface
-│   │           │   ├── tools.py       # bash, ls, read/write/str_replace
-│   │           │   └── middleware.py  # Sandbox lifecycle management
-│   │           ├── subagents/         # Subagent delegation system
-│   │           │   ├── builtins/      # general-purpose, bash agents
-│   │           │   ├── executor.py    # Background execution engine
-│   │           │   └── registry.py    # Agent registry
-│   │           ├── tools/builtins/    # Built-in tools (present_files, ask_clarification, view_image)
-│   │           ├── mcp/               # MCP integration (tools, cache, client)
-│   │           ├── models/            # Model factory with thinking/vision support
-│   │           ├── skills/            # Skills discovery, loading, parsing
-│   │           ├── config/            # Configuration system (app, model, sandbox, tool, etc.)
-│   │           ├── community/         # Community tools (tavily, jina_ai, firecrawl, image_search, aio_sandbox)
-│   │           ├── reflection/        # Dynamic module loading (resolve_variable, resolve_class)
-│   │           ├── utils/             # Utilities (network, readability)
-│   │           └── client.py          # Embedded Python client (DeerFlowClient)
-│   ├── app/                   # Application layer (import: app.*)
-│   │   ├── gateway/           # FastAPI Gateway API
-│   │   │   ├── app.py         # FastAPI application
-│   │   │   └── routers/       # FastAPI route modules (models, mcp, memory, skills, uploads, threads, artifacts, agents, suggestions, channels)
-│   │   └── channels/          # IM platform integrations
-│   ├── tests/                 # Test suite
-│   └── docs/                  # Documentation
-├── frontend/                   # Next.js frontend application
-└── skills/                     # Agent skills directory
-    ├── public/                # Public skills (committed)
-    └── custom/                # Custom skills (gitignored)
-```
-
-## Important Development Guidelines
-
-### Documentation Update Policy
-**CRITICAL: Always update README.md and CLAUDE.md after every code change**
-
-When making code changes, you MUST update the relevant documentation:
-- Update `README.md` for user-facing changes (features, setup, usage instructions)
-- Update `CLAUDE.md` for development changes (architecture, commands, workflows, internal systems)
-- Keep documentation synchronized with the codebase at all times
-- Ensure accuracy and timeliness of all documentation
-
-## Commands
-
-**Root directory** (for full application):
-```bash
-make check      # Check system requirements
-make install    # Install all dependencies (frontend + backend)
-make dev        # Start all services (LangGraph + Gateway + Frontend + Nginx), with config.yaml preflight
-make dev-pro    # Gateway mode (experimental): skip LangGraph, agent runtime embedded in Gateway
-make start-pro  # Production + Gateway mode (experimental)
-make stop       # Stop all services
-```
-
-**Backend directory** (for backend development only):
-```bash
-make install    # Install backend dependencies
-make dev        # Run LangGraph server only (port 2024)
-make gateway    # Run Gateway API only (port 8001)
-make test       # Run all backend tests
-make lint       # Lint with ruff
-make format     # Format code with ruff
-```
-
-Regression tests related to Docker/provisioner behavior:
-- `tests/test_docker_sandbox_mode_detection.py` (mode detection from `config.yaml`)
-- `tests/test_provisioner_kubeconfig.py` (kubeconfig file/directory handling)
-
-Boundary check (harness → app import firewall):
-- `tests/test_harness_boundary.py` — ensures `packages/harness/deerflow/` never imports from `app.*`
-
-CI runs these regression tests for every pull request via [.github/workflows/backend-unit-tests.yml](../.github/workflows/backend-unit-tests.yml).
-
-## Architecture
-
-### Harness / App Split
-
-The backend is split into two layers with a strict dependency direction:
-
-- **Harness** (`packages/harness/deerflow/`): Publishable agent framework package (`deerflow-harness`). Import prefix: `deerflow.*`. Contains agent orchestration, tools, sandbox, models, MCP, skills, config — everything needed to build and run agents.
-- **App** (`app/`): Unpublished application code. Import prefix: `app.*`. Contains the FastAPI Gateway API and IM channel integrations (Feishu, Slack, Telegram).
-
-**Dependency rule**: App imports deerflow, but deerflow never imports app. This boundary is enforced by `tests/test_harness_boundary.py` which runs in CI.
-
-**Import conventions**:
-```python
-# Harness internal
-from deerflow.agents import make_lead_agent
-from deerflow.models import create_chat_model
-
-# App internal
-from app.gateway.app import app
-from app.channels.service import start_channel_service
-
-# App → Harness (allowed)
-from deerflow.config import get_app_config
-
-# Harness → App (FORBIDDEN — enforced by test_harness_boundary.py)
-# from app.gateway.routers.uploads import ...  # ← will fail CI
-```
-
-### Agent System
-
-**Lead Agent** (`packages/harness/deerflow/agents/lead_agent/agent.py`):
-- Entry point: `make_lead_agent(config: RunnableConfig)` registered in `langgraph.json`
-- Dynamic model selection via `create_chat_model()` with thinking/vision support
-- Tools loaded via `get_available_tools()` - combines sandbox, built-in, MCP, community, and subagent tools
-- System prompt generated by `apply_prompt_template()` with skills, memory, and subagent instructions
-
-**ThreadState** (`packages/harness/deerflow/agents/thread_state.py`):
-- Extends `AgentState` with: `sandbox`, `thread_data`, `title`, `artifacts`, `todos`, `uploaded_files`, `viewed_images`
-- Uses custom reducers: `merge_artifacts` (deduplicate), `merge_viewed_images` (merge/clear)
-
-**Runtime Configuration** (via `config.configurable`):
-- `thinking_enabled` - Enable model's extended thinking
-- `model_name` - Select specific LLM model
-- `is_plan_mode` - Enable TodoList middleware
-- `subagent_enabled` - Enable task delegation tool
-
-### Middleware Chain
-
-Middlewares execute in strict order in `packages/harness/deerflow/agents/lead_agent/agent.py`:
-
-1. **ThreadDataMiddleware** - Creates per-thread directories (`backend/.deer-flow/threads/{thread_id}/user-data/{workspace,uploads,outputs}`); Web UI thread deletion now follows LangGraph thread removal with Gateway cleanup of the local `.deer-flow/threads/{thread_id}` directory
-2. **UploadsMiddleware** - Tracks and injects newly uploaded files into conversation
-3. **SandboxMiddleware** - Acquires sandbox, stores `sandbox_id` in state
-4. **DanglingToolCallMiddleware** - Injects placeholder ToolMessages for AIMessage tool_calls that lack responses (e.g., due to user interruption)
-5. **GuardrailMiddleware** - Pre-tool-call authorization via pluggable `GuardrailProvider` protocol (optional, if `guardrails.enabled` in config). Evaluates each tool call and returns error ToolMessage on deny. Three provider options: built-in `AllowlistProvider` (zero deps), OAP policy providers (e.g. `aport-agent-guardrails`), or custom providers. See [docs/GUARDRAILS.md](docs/GUARDRAILS.md) for setup, usage, and how to implement a provider.
-6. **SummarizationMiddleware** - Context reduction when approaching token limits (optional, if enabled)
-7. **TodoListMiddleware** - Task tracking with `write_todos` tool (optional, if plan_mode)
-8. **TitleMiddleware** - Auto-generates thread title after first complete exchange and normalizes structured message content before prompting the title model
-9. **MemoryMiddleware** - Queues conversations for async memory update (filters to user + final AI responses)
-10. **ViewImageMiddleware** - Injects base64 image data before LLM call (conditional on vision support)
-11. **SubagentLimitMiddleware** - Truncates excess `task` tool calls from model response to enforce `MAX_CONCURRENT_SUBAGENTS` limit (optional, if subagent_enabled)
-12. **ClarificationMiddleware** - Intercepts `ask_clarification` tool calls, interrupts via `Command(goto=END)` (must be last)
-
-### Configuration System
-
-**Main Configuration** (`config.yaml`):
-
-Setup: Copy `config.example.yaml` to `config.yaml` in the **project root** directory.
-
-**Config Versioning**: `config.example.yaml` has a `config_version` field. On startup, `AppConfig.from_file()` compares user version vs example version and emits a warning if outdated. Missing `config_version` = version 0. Run `make config-upgrade` to auto-merge missing fields. When changing the config schema, bump `config_version` in `config.example.yaml`.
-
-**Config Caching**: `get_app_config()` caches the parsed config, but automatically reloads it when the resolved config path changes or the file's mtime increases. This keeps Gateway and LangGraph reads aligned with `config.yaml` edits without requiring a manual process restart.
-
-Configuration priority:
-1. Explicit `config_path` argument
-2. `DEER_FLOW_CONFIG_PATH` environment variable
-3. `config.yaml` in current directory (backend/)
-4. `config.yaml` in parent directory (project root - **recommended location**)
-
-Config values starting with `$` are resolved as environment variables (e.g., `$OPENAI_API_KEY`).
-`ModelConfig` also declares `use_responses_api` and `output_version` so OpenAI `/v1/responses` can be enabled explicitly while still using `langchain_openai:ChatOpenAI`.
-
-**Extensions Configuration** (`extensions_config.json`):
-
-MCP servers and skills are configured together in `extensions_config.json` in project root:
-
-Configuration priority:
-1. Explicit `config_path` argument
-2. `DEER_FLOW_EXTENSIONS_CONFIG_PATH` environment variable
-3. `extensions_config.json` in current directory (backend/)
-4. `extensions_config.json` in parent directory (project root - **recommended location**)
-
-### Gateway API (`app/gateway/`)
-
-FastAPI application on port 8001 with health check at `GET /health`.
-
-**Routers**:
-
-| Router | Endpoints |
-|--------|-----------|
-| **Models** (`/api/models`) | `GET /` - list models; `GET /{name}` - model details |
-| **MCP** (`/api/mcp`) | `GET /config` - get config; `PUT /config` - update config (saves to extensions_config.json) |
-| **Skills** (`/api/skills`) | `GET /` - list skills; `GET /{name}` - details; `PUT /{name}` - update enabled; `POST /install` - install from .skill archive (accepts standard optional frontmatter like `version`, `author`, `compatibility`) |
-| **Memory** (`/api/memory`) | `GET /` - memory data; `POST /reload` - force reload; `GET /config` - config; `GET /status` - config + data |
-| **Uploads** (`/api/threads/{id}/uploads`) | `POST /` - upload files (auto-converts PDF/PPT/Excel/Word); `GET /list` - list; `DELETE /{filename}` - delete |
-| **Threads** (`/api/threads/{id}`) | `DELETE /` - remove DeerFlow-managed local thread data after LangGraph thread deletion; unexpected failures are logged server-side and return a generic 500 detail |
-| **Artifacts** (`/api/threads/{id}/artifacts`) | `GET /{path}` - serve artifacts; active content types (`text/html`, `application/xhtml+xml`, `image/svg+xml`) are always forced as download attachments to reduce XSS risk; `?download=true` still forces download for other file types |
-| **Suggestions** (`/api/threads/{id}/suggestions`) | `POST /` - generate follow-up questions; rich list/block model content is normalized before JSON parsing |
-
-Proxied through nginx: `/api/langgraph/*` → LangGraph, all other `/api/*` → Gateway.
-
-### Sandbox System (`packages/harness/deerflow/sandbox/`)
-
-**Interface**: Abstract `Sandbox` with `execute_command`, `read_file`, `write_file`, `list_dir`
-**Provider Pattern**: `SandboxProvider` with `acquire`, `get`, `release` lifecycle
-**Implementations**:
-- `LocalSandboxProvider` - Singleton local filesystem execution with path mappings
-- `AioSandboxProvider` (`packages/harness/deerflow/community/`) - Docker-based isolation
-
-**Virtual Path System**:
-- Agent sees: `/mnt/user-data/{workspace,uploads,outputs}`, `/mnt/skills`
-- Physical: `backend/.deer-flow/threads/{thread_id}/user-data/...`, `deer-flow/skills/`
-- Translation: `replace_virtual_path()` / `replace_virtual_paths_in_command()`
-- Detection: `is_local_sandbox()` checks `sandbox_id == "local"`
-
-**Sandbox Tools** (in `packages/harness/deerflow/sandbox/tools.py`):
-- `bash` - Execute commands with path translation and error handling
-- `ls` - Directory listing (tree format, max 2 levels)
-- `read_file` - Read file contents with optional line range
-- `write_file` - Write/append to files, creates directories
-- `str_replace` - Substring replacement (single or all occurrences); same-path serialization is scoped to `(sandbox.id, path)` so isolated sandboxes do not contend on identical virtual paths inside one process
-
-### Subagent System (`packages/harness/deerflow/subagents/`)
-
-**Built-in Agents**: `general-purpose` (all tools except `task`) and `bash` (command specialist)
-**Execution**: Dual thread pool - `_scheduler_pool` (3 workers) + `_execution_pool` (3 workers)
-**Concurrency**: `MAX_CONCURRENT_SUBAGENTS = 3` enforced by `SubagentLimitMiddleware` (truncates excess tool calls in `after_model`), 15-minute timeout
-**Flow**: `task()` tool → `SubagentExecutor` → background thread → poll 5s → SSE events → result
-**Events**: `task_started`, `task_running`, `task_completed`/`task_failed`/`task_timed_out`
-
-### Tool System (`packages/harness/deerflow/tools/`)
-
-`get_available_tools(groups, include_mcp, model_name, subagent_enabled)` assembles:
-1. **Config-defined tools** - Resolved from `config.yaml` via `resolve_variable()`
-2. **MCP tools** - From enabled MCP servers (lazy initialized, cached with mtime invalidation)
-3. **Built-in tools**:
-   - `present_files` - Make output files visible to user (only `/mnt/user-data/outputs`)
-   - `ask_clarification` - Request clarification (intercepted by ClarificationMiddleware → interrupts)
-   - `view_image` - Read image as base64 (added only if model supports vision)
-4. **Subagent tool** (if enabled):
-   - `task` - Delegate to subagent (description, prompt, subagent_type, max_turns)
-
-**Community tools** (`packages/harness/deerflow/community/`):
-- `tavily/` - Web search (5 results default) and web fetch (4KB limit)
-- `jina_ai/` - Web fetch via Jina reader API with readability extraction
-- `firecrawl/` - Web scraping via Firecrawl API
-
-**ACP agent tools**:
-- `invoke_acp_agent` - Invokes external ACP-compatible agents from `config.yaml`
-- ACP launchers must be real ACP adapters. The standard `codex` CLI is not ACP-compatible by itself; configure a wrapper such as `npx -y @zed-industries/codex-acp` or an installed `codex-acp` binary
-- Missing ACP executables now return an actionable error message instead of a raw `[Errno 2]`
-- Each ACP agent uses a per-thread workspace at `{base_dir}/threads/{thread_id}/acp-workspace/`. The workspace is accessible to the lead agent via the virtual path `/mnt/acp-workspace/` (read-only). In docker sandbox mode, the directory is volume-mounted into the container at `/mnt/acp-workspace` (read-only); in local sandbox mode, path translation is handled by `tools.py`
-- `image_search/` - Image search via DuckDuckGo
-
-### MCP System (`packages/harness/deerflow/mcp/`)
-
-- Uses `langchain-mcp-adapters` `MultiServerMCPClient` for multi-server management
-- **Lazy initialization**: Tools loaded on first use via `get_cached_mcp_tools()`
-- **Cache invalidation**: Detects config file changes via mtime comparison
-- **Transports**: stdio (command-based), SSE, HTTP
-- **OAuth (HTTP/SSE)**: Supports token endpoint flows (`client_credentials`, `refresh_token`) with automatic token refresh + Authorization header injection
-- **Runtime updates**: Gateway API saves to extensions_config.json; LangGraph detects via mtime
-
-### Skills System (`packages/harness/deerflow/skills/`)
-
-- **Location**: `deer-flow/skills/{public,custom}/`
-- **Format**: Directory with `SKILL.md` (YAML frontmatter: name, description, license, allowed-tools)
-- **Loading**: `load_skills()` recursively scans `skills/{public,custom}` for `SKILL.md`, parses metadata, and reads enabled state from extensions_config.json
-- **Injection**: Enabled skills listed in agent system prompt with container paths
-- **Installation**: `POST /api/skills/install` extracts .skill ZIP archive to custom/ directory
-
-### Model Factory (`packages/harness/deerflow/models/factory.py`)
-
-- `create_chat_model(name, thinking_enabled)` instantiates LLM from config via reflection
-- Supports `thinking_enabled` flag with per-model `when_thinking_enabled` overrides
-- Supports vLLM-style thinking toggles via `when_thinking_enabled.extra_body.chat_template_kwargs.enable_thinking` for Qwen reasoning models, while normalizing legacy `thinking` configs for backward compatibility
-- Supports `supports_vision` flag for image understanding models
-- Config values starting with `$` resolved as environment variables
-- Missing provider modules surface actionable install hints from reflection resolvers (for example `uv add langchain-google-genai`)
-
-### vLLM Provider (`packages/harness/deerflow/models/vllm_provider.py`)
-
-- `VllmChatModel` subclasses `langchain_openai:ChatOpenAI` for vLLM 0.19.0 OpenAI-compatible endpoints
-- Preserves vLLM's non-standard assistant `reasoning` field on full responses, streaming deltas, and follow-up tool-call turns
-- Designed for configs that enable thinking through `extra_body.chat_template_kwargs.enable_thinking` on vLLM 0.19.0 Qwen reasoning models, while accepting the older `thinking` alias
-
-### IM Channels System (`app/channels/`)
-
-Bridges external messaging platforms (Feishu, Slack, Telegram) to the DeerFlow agent via the LangGraph Server.
-
-**Architecture**: Channels communicate with the LangGraph Server through `langgraph-sdk` HTTP client (same as the frontend), ensuring threads are created and managed server-side.
-
-**Components**:
-- `message_bus.py` - Async pub/sub hub (`InboundMessage` → queue → dispatcher; `OutboundMessage` → callbacks → channels)
-- `store.py` - JSON-file persistence mapping `channel_name:chat_id[:topic_id]` → `thread_id` (keys are `channel:chat` for root conversations and `channel:chat:topic` for threaded conversations)
-- `manager.py` - Core dispatcher: creates threads via `client.threads.create()`, routes commands, keeps Slack/Telegram on `client.runs.wait()`, and uses `client.runs.stream(["messages-tuple", "values"])` for Feishu incremental outbound updates
-- `base.py` - Abstract `Channel` base class (start/stop/send lifecycle)
-- `service.py` - Manages lifecycle of all configured channels from `config.yaml`
-- `slack.py` / `feishu.py` / `telegram.py` - Platform-specific implementations (`feishu.py` tracks the running card `message_id` in memory and patches the same card in place)
-
-**Message Flow**:
-1. External platform -> Channel impl -> `MessageBus.publish_inbound()`
-2. `ChannelManager._dispatch_loop()` consumes from queue
-3. For chat: look up/create thread on LangGraph Server
-4. Feishu chat: `runs.stream()` → accumulate AI text → publish multiple outbound updates (`is_final=False`) → publish final outbound (`is_final=True`)
-5. Slack/Telegram chat: `runs.wait()` → extract final response → publish outbound
-6. Feishu channel sends one running reply card up front, then patches the same card for each outbound update (card JSON sets `config.update_multi=true` for Feishu's patch API requirement)
-7. For commands (`/new`, `/status`, `/models`, `/memory`, `/help`): handle locally or query Gateway API
-8. Outbound → channel callbacks → platform reply
-
-**Configuration** (`config.yaml` -> `channels`):
-- `langgraph_url` - LangGraph Server URL (default: `http://localhost:2024`)
-- `gateway_url` - Gateway API URL for auxiliary commands (default: `http://localhost:8001`)
-- In Docker Compose, IM channels run inside the `gateway` container, so `localhost` points back to that container. Use `http://langgraph:2024` / `http://gateway:8001`, or set `DEER_FLOW_CHANNELS_LANGGRAPH_URL` / `DEER_FLOW_CHANNELS_GATEWAY_URL`.
-- Per-channel configs: `feishu` (app_id, app_secret), `slack` (bot_token, app_token), `telegram` (bot_token)
-
-### Memory System (`packages/harness/deerflow/agents/memory/`)
-
-**Components**:
-- `updater.py` - LLM-based memory updates with fact extraction, whitespace-normalized fact deduplication (trims leading/trailing whitespace before comparing), and atomic file I/O
-- `queue.py` - Debounced update queue (per-thread deduplication, configurable wait time)
-- `prompt.py` - Prompt templates for memory updates
-
-**Data Structure** (stored in `backend/.deer-flow/memory.json`):
-- **User Context**: `workContext`, `personalContext`, `topOfMind` (1-3 sentence summaries)
-- **History**: `recentMonths`, `earlierContext`, `longTermBackground`
-- **Facts**: Discrete facts with `id`, `content`, `category` (preference/knowledge/context/behavior/goal), `confidence` (0-1), `createdAt`, `source`
-
-**Workflow**:
-1. `MemoryMiddleware` filters messages (user inputs + final AI responses) and queues conversation
-2. Queue debounces (30s default), batches updates, deduplicates per-thread
-3. Background thread invokes LLM to extract context updates and facts
-4. Applies updates atomically (temp file + rename) with cache invalidation, skipping duplicate fact content before append
-5. Next interaction injects top 15 facts + context into `<memory>` tags in system prompt
-
-Focused regression coverage for the updater lives in `backend/tests/test_memory_updater.py`.
-
-**Configuration** (`config.yaml` → `memory`):
-- `enabled` / `injection_enabled` - Master switches
-- `storage_path` - Path to memory.json
-- `debounce_seconds` - Wait time before processing (default: 30)
-- `model_name` - LLM for updates (null = default model)
-- `max_facts` / `fact_confidence_threshold` - Fact storage limits (100 / 0.7)
-- `max_injection_tokens` - Token limit for prompt injection (2000)
-
-### Reflection System (`packages/harness/deerflow/reflection/`)
-
-- `resolve_variable(path)` - Import module and return variable (e.g., `module.path:variable_name`)
-- `resolve_class(path, base_class)` - Import and validate class against base class
-
-### Config Schema
-
-**`config.yaml`** key sections:
-- `models[]` - LLM configs with `use` class path, `supports_thinking`, `supports_vision`, provider-specific fields
-- vLLM reasoning models should use `deerflow.models.vllm_provider:VllmChatModel`; for Qwen-style parsers prefer `when_thinking_enabled.extra_body.chat_template_kwargs.enable_thinking`, and DeerFlow will also normalize the older `thinking` alias
-- `tools[]` - Tool configs with `use` variable path and `group`
-- `tool_groups[]` - Logical groupings for tools
-- `sandbox.use` - Sandbox provider class path
-- `skills.path` / `skills.container_path` - Host and container paths to skills directory
-- `title` - Auto-title generation (enabled, max_words, max_chars, prompt_template)
-- `summarization` - Context summarization (enabled, trigger conditions, keep policy)
-- `subagents.enabled` - Master switch for subagent delegation
-- `memory` - Memory system (enabled, storage_path, debounce_seconds, model_name, max_facts, fact_confidence_threshold, injection_enabled, max_injection_tokens)
-
-**`extensions_config.json`**:
-- `mcpServers` - Map of server name → config (enabled, type, command, args, env, url, headers, oauth, description)
-- `skills` - Map of skill name → state (enabled)
-
-Both can be modified at runtime via Gateway API endpoints or `DeerFlowClient` methods.
-
-### Embedded Client (`packages/harness/deerflow/client.py`)
-
-`DeerFlowClient` provides direct in-process access to all DeerFlow capabilities without HTTP services. All return types align with the Gateway API response schemas, so consumer code works identically in HTTP and embedded modes.
-
-**Architecture**: Imports the same `deerflow` modules that LangGraph Server and Gateway API use. Shares the same config files and data directories. No FastAPI dependency.
-
-**Agent Conversation** (replaces LangGraph Server):
-- `chat(message, thread_id)` — synchronous, returns final text
-- `stream(message, thread_id)` — yields `StreamEvent` aligned with LangGraph SSE protocol:
-  - `"values"` — full state snapshot (title, messages, artifacts)
-  - `"messages-tuple"` — per-message update (AI text, tool calls, tool results)
-  - `"end"` — stream finished
-- Agent created lazily via `create_agent()` + `_build_middlewares()`, same as `make_lead_agent`
-- Supports `checkpointer` parameter for state persistence across turns
-- `reset_agent()` forces agent recreation (e.g. after memory or skill changes)
-
-**Gateway Equivalent Methods** (replaces Gateway API):
-
-| Category | Methods | Return format |
-|----------|---------|---------------|
-| Models | `list_models()`, `get_model(name)` | `{"models": [...]}`, `{name, display_name, ...}` |
-| MCP | `get_mcp_config()`, `update_mcp_config(servers)` | `{"mcp_servers": {...}}` |
-| Skills | `list_skills()`, `get_skill(name)`, `update_skill(name, enabled)`, `install_skill(path)` | `{"skills": [...]}` |
-| Memory | `get_memory()`, `reload_memory()`, `get_memory_config()`, `get_memory_status()` | dict |
-| Uploads | `upload_files(thread_id, files)`, `list_uploads(thread_id)`, `delete_upload(thread_id, filename)` | `{"success": true, "files": [...]}`, `{"files": [...], "count": N}` |
-| Artifacts | `get_artifact(thread_id, path)` → `(bytes, mime_type)` | tuple |
-
-**Key difference from Gateway**: Upload accepts local `Path` objects instead of HTTP `UploadFile`, rejects directory paths before copying, and reuses a single worker when document conversion must run inside an active event loop. Artifact returns `(bytes, mime_type)` instead of HTTP Response. The new Gateway-only thread cleanup route deletes `.deer-flow/threads/{thread_id}` after LangGraph thread deletion; there is no matching `DeerFlowClient` method yet. `update_mcp_config()` and `update_skill()` automatically invalidate the cached agent.
-
-**Tests**: `tests/test_client.py` (77 unit tests including `TestGatewayConformance`), `tests/test_client_live.py` (live integration tests, requires config.yaml)
-
-**Gateway Conformance Tests** (`TestGatewayConformance`): Validate that every dict-returning client method conforms to the corresponding Gateway Pydantic response model. Each test parses the client output through the Gateway model — if Gateway adds a required field that the client doesn't provide, Pydantic raises `ValidationError` and CI catches the drift. Covers: `ModelsListResponse`, `ModelResponse`, `SkillsListResponse`, `SkillResponse`, `SkillInstallResponse`, `McpConfigResponse`, `UploadResponse`, `MemoryConfigResponse`, `MemoryStatusResponse`.
-
-## Development Workflow
-
-### Test-Driven Development (TDD) — MANDATORY
-
-**Every new feature or bug fix MUST be accompanied by unit tests. No exceptions.**
-
-- Write tests in `backend/tests/` following the existing naming convention `test_<feature>.py`
-- Run the full suite before and after your change: `make test`
-- Tests must pass before a feature is considered complete
-- For lightweight config/utility modules, prefer pure unit tests with no external dependencies
-- If a module causes circular import issues in tests, add a `sys.modules` mock in `tests/conftest.py` (see existing example for `deerflow.subagents.executor`)
-
-```bash
-# Run all tests
-make test
-
-# Run a specific test file
-PYTHONPATH=. uv run pytest tests/test_<feature>.py -v
-```
-
-### Running the Full Application
-
-From the **project root** directory:
-```bash
-make dev
-```
-
-This starts all services and makes the application available at `http://localhost:2026`.
-
-**All startup modes:**
-
-| | **Local Foreground** | **Local Daemon** | **Docker Dev** | **Docker Prod** |
-|---|---|---|---|---|
-| **Dev** | `./scripts/serve.sh --dev`<br/>`make dev` | `./scripts/serve.sh --dev --daemon`<br/>`make dev-daemon` | `./scripts/docker.sh start`<br/>`make docker-start` | — |
-| **Dev + Gateway** | `./scripts/serve.sh --dev --gateway`<br/>`make dev-pro` | `./scripts/serve.sh --dev --gateway --daemon`<br/>`make dev-daemon-pro` | `./scripts/docker.sh start --gateway`<br/>`make docker-start-pro` | — |
-| **Prod** | `./scripts/serve.sh --prod`<br/>`make start` | `./scripts/serve.sh --prod --daemon`<br/>`make start-daemon` | — | `./scripts/deploy.sh`<br/>`make up` |
-| **Prod + Gateway** | `./scripts/serve.sh --prod --gateway`<br/>`make start-pro` | `./scripts/serve.sh --prod --gateway --daemon`<br/>`make start-daemon-pro` | — | `./scripts/deploy.sh --gateway`<br/>`make up-pro` |
-
-| Action | Local | Docker Dev | Docker Prod |
-|---|---|---|---|
-| **Stop** | `./scripts/serve.sh --stop`<br/>`make stop` | `./scripts/docker.sh stop`<br/>`make docker-stop` | `./scripts/deploy.sh down`<br/>`make down` |
-| **Restart** | `./scripts/serve.sh --restart [flags]` | `./scripts/docker.sh restart` | — |
-
-Gateway mode embeds the agent runtime in Gateway, no LangGraph server.
-
-**Nginx routing**:
-- Standard mode: `/api/langgraph/*` → LangGraph Server (2024)
-- Gateway mode: `/api/langgraph/*` → Gateway embedded runtime (8001) (via envsubst)
-- `/api/*` (other) → Gateway API (8001)
-- `/` (non-API) → Frontend (3000)
-
-### Running Backend Services Separately
-
-From the **backend** directory:
-
-```bash
-# Terminal 1: LangGraph server
-make dev
-
-# Terminal 2: Gateway API
-make gateway
-```
-
-Direct access (without nginx):
-- LangGraph: `http://localhost:2024`
-- Gateway: `http://localhost:8001`
-
-### Frontend Configuration
-
-The frontend uses environment variables to connect to backend services:
-- `NEXT_PUBLIC_LANGGRAPH_BASE_URL` - Defaults to `/api/langgraph` (through nginx)
-- `NEXT_PUBLIC_BACKEND_BASE_URL` - Defaults to empty string (through nginx)
-
-When using `make dev` from root, the frontend automatically connects through nginx.
-
-## Key Features
-
-### File Upload
-
-Multi-file upload with automatic document conversion:
-- Endpoint: `POST /api/threads/{thread_id}/uploads`
-- Supports: PDF, PPT, Excel, Word documents (converted via `markitdown`)
-- Rejects directory inputs before copying so uploads stay all-or-nothing
-- Reuses one conversion worker per request when called from an active event loop
-- Files stored in thread-isolated directories
-- Agent receives uploaded file list via `UploadsMiddleware`
-
-See [docs/FILE_UPLOAD.md](docs/FILE_UPLOAD.md) for details.
-
-### Plan Mode
-
-TodoList middleware for complex multi-step tasks:
-- Controlled via runtime config: `config.configurable.is_plan_mode = True`
-- Provides `write_todos` tool for task tracking
-- One task in_progress at a time, real-time updates
-
-See [docs/plan_mode_usage.md](docs/plan_mode_usage.md) for details.
-
-### Context Summarization
-
-Automatic conversation summarization when approaching token limits:
-- Configured in `config.yaml` under `summarization` key
-- Trigger types: tokens, messages, or fraction of max input
-- Keeps recent messages while summarizing older ones
-
-See [docs/summarization.md](docs/summarization.md) for details.
-
-### Vision Support
-
-For models with `supports_vision: true`:
-- `ViewImageMiddleware` processes images in conversation
-- `view_image_tool` added to agent's toolset
-- Images automatically converted to base64 and injected into state
-
-## Code Style
-
-- Uses `ruff` for linting and formatting
-- Line length: 240 characters
-- Python 3.12+ with type hints
-- Double quotes, space indentation
-
-## Documentation
-
-See `docs/` directory for detailed documentation:
-- [CONFIGURATION.md](docs/CONFIGURATION.md) - Configuration options
-- [ARCHITECTURE.md](docs/ARCHITECTURE.md) - Architecture details
-- [API.md](docs/API.md) - API reference
-- [SETUP.md](docs/SETUP.md) - Setup guide
-- [FILE_UPLOAD.md](docs/FILE_UPLOAD.md) - File upload feature
-- [PATH_EXAMPLES.md](docs/PATH_EXAMPLES.md) - Path types and usage
-- [summarization.md](docs/summarization.md) - Context summarization
-- [plan_mode_usage.md](docs/plan_mode_usage.md) - Plan mode with TodoList

backend/CONTRIBUTING.md

@@ -1,426 +0,0 @@
-# Contributing to DeerFlow Backend
-
-Thank you for your interest in contributing to DeerFlow! This document provides guidelines and instructions for contributing to the backend codebase.
-
-## Table of Contents
-
-- [Getting Started](#getting-started)
-- [Development Setup](#development-setup)
-- [Project Structure](#project-structure)
-- [Code Style](#code-style)
-- [Making Changes](#making-changes)
-- [Testing](#testing)
-- [Pull Request Process](#pull-request-process)
-- [Architecture Guidelines](#architecture-guidelines)
-
-## Getting Started
-
-### Prerequisites
-
-- Python 3.12 or higher
-- [uv](https://docs.astral.sh/uv/) package manager
-- Git
-- Docker (optional, for Docker sandbox testing)
-
-### Fork and Clone
-
-1. Fork the repository on GitHub
-2. Clone your fork locally:
-   ```bash
-   git clone https://github.com/YOUR_USERNAME/deer-flow.git
-   cd deer-flow
-   ```
-
-## Development Setup
-
-### Install Dependencies
-
-```bash
-# From project root
-cp config.example.yaml config.yaml
-
-# Install backend dependencies
-cd backend
-make install
-```
-
-### Configure Environment
-
-Set up your API keys for testing:
-
-```bash
-export OPENAI_API_KEY="your-api-key"
-# Add other keys as needed
-```
-
-### Run the Development Server
-
-```bash
-# Terminal 1: LangGraph server
-make dev
-
-# Terminal 2: Gateway API
-make gateway
-```
-
-## Project Structure
-
-```
-backend/src/
-├── agents/                  # Agent system
-│   ├── lead_agent/         # Main agent implementation
-│   │   └── agent.py        # Agent factory and creation
-│   ├── middlewares/        # Agent middlewares
-│   │   ├── thread_data_middleware.py
-│   │   ├── sandbox_middleware.py
-│   │   ├── title_middleware.py
-│   │   ├── uploads_middleware.py
-│   │   ├── view_image_middleware.py
-│   │   └── clarification_middleware.py
-│   └── thread_state.py     # Thread state definition
-│
-├── gateway/                 # FastAPI Gateway
-│   ├── app.py              # FastAPI application
-│   └── routers/            # Route handlers
-│       ├── models.py       # /api/models endpoints
-│       ├── mcp.py          # /api/mcp endpoints
-│       ├── skills.py       # /api/skills endpoints
-│       ├── artifacts.py    # /api/threads/.../artifacts
-│       └── uploads.py      # /api/threads/.../uploads
-│
-├── sandbox/                 # Sandbox execution
-│   ├── __init__.py         # Sandbox interface
-│   ├── local.py            # Local sandbox provider
-│   └── tools.py            # Sandbox tools (bash, file ops)
-│
-├── tools/                   # Agent tools
-│   └── builtins/           # Built-in tools
-│       ├── present_file_tool.py
-│       ├── ask_clarification_tool.py
-│       └── view_image_tool.py
-│
-├── mcp/                     # MCP integration
-│   └── manager.py          # MCP server management
-│
-├── models/                  # Model system
-│   └── factory.py          # Model factory
-│
-├── skills/                  # Skills system
-│   └── loader.py           # Skills loader
-│
-├── config/                  # Configuration
-│   ├── app_config.py       # Main app config
-│   ├── extensions_config.py # Extensions config
-│   └── summarization_config.py
-│
-├── community/               # Community tools
-│   ├── tavily/             # Tavily web search
-│   ├── jina/               # Jina web fetch
-│   ├── firecrawl/          # Firecrawl scraping
-│   └── aio_sandbox/        # Docker sandbox
-│
-├── reflection/              # Dynamic loading
-│   └── __init__.py         # Module resolution
-│
-└── utils/                   # Utilities
-    └── __init__.py
-```
-
-## Code Style
-
-### Linting and Formatting
-
-We use `ruff` for both linting and formatting:
-
-```bash
-# Check for issues
-make lint
-
-# Auto-fix and format
-make format
-```
-
-### Style Guidelines
-
-- **Line length**: 240 characters maximum
-- **Python version**: 3.12+ features allowed
-- **Type hints**: Use type hints for function signatures
-- **Quotes**: Double quotes for strings
-- **Indentation**: 4 spaces (no tabs)
-- **Imports**: Group by standard library, third-party, local
-
-### Docstrings
-
-Use docstrings for public functions and classes:
-
-```python
-def create_chat_model(name: str, thinking_enabled: bool = False) -> BaseChatModel:
-    """Create a chat model instance from configuration.
-
-    Args:
-        name: The model name as defined in config.yaml
-        thinking_enabled: Whether to enable extended thinking
-
-    Returns:
-        A configured LangChain chat model instance
-
-    Raises:
-        ValueError: If the model name is not found in configuration
-    """
-    ...
-```
-
-## Making Changes
-
-### Branch Naming
-
-Use descriptive branch names:
-
-- `feature/add-new-tool` - New features
-- `fix/sandbox-timeout` - Bug fixes
-- `docs/update-readme` - Documentation
-- `refactor/config-system` - Code refactoring
-
-### Commit Messages
-
-Write clear, concise commit messages:
-
-```
-feat: add support for Claude 3.5 model
-
-- Add model configuration in config.yaml
-- Update model factory to handle Claude-specific settings
-- Add tests for new model
-```
-
-Prefix types:
-- `feat:` - New feature
-- `fix:` - Bug fix
-- `docs:` - Documentation
-- `refactor:` - Code refactoring
-- `test:` - Tests
-- `chore:` - Build/config changes
-
-## Testing
-
-### Running Tests
-
-```bash
-uv run pytest
-```
-
-### Writing Tests
-
-Place tests in the `tests/` directory mirroring the source structure:
-
-```
-tests/
-├── test_models/
-│   └── test_factory.py
-├── test_sandbox/
-│   └── test_local.py
-└── test_gateway/
-    └── test_models_router.py
-```
-
-Example test:
-
-```python
-import pytest
-from deerflow.models.factory import create_chat_model
-
-def test_create_chat_model_with_valid_name():
-    """Test that a valid model name creates a model instance."""
-    model = create_chat_model("gpt-4")
-    assert model is not None
-
-def test_create_chat_model_with_invalid_name():
-    """Test that an invalid model name raises ValueError."""
-    with pytest.raises(ValueError):
-        create_chat_model("nonexistent-model")
-```
-
-## Pull Request Process
-
-### Before Submitting
-
-1. **Ensure tests pass**: `uv run pytest`
-2. **Run linter**: `make lint`
-3. **Format code**: `make format`
-4. **Update documentation** if needed
-
-### PR Description
-
-Include in your PR description:
-
-- **What**: Brief description of changes
-- **Why**: Motivation for the change
-- **How**: Implementation approach
-- **Testing**: How you tested the changes
-
-### Review Process
-
-1. Submit PR with clear description
-2. Address review feedback
-3. Ensure CI passes
-4. Maintainer will merge when approved
-
-## Architecture Guidelines
-
-### Adding New Tools
-
-1. Create tool in `packages/harness/deerflow/tools/builtins/` or `packages/harness/deerflow/community/`:
-
-```python
-# packages/harness/deerflow/tools/builtins/my_tool.py
-from langchain_core.tools import tool
-
-@tool
-def my_tool(param: str) -> str:
-    """Tool description for the agent.
-
-    Args:
-        param: Description of the parameter
-
-    Returns:
-        Description of return value
-    """
-    return f"Result: {param}"
-```
-
-2. Register in `config.yaml`:
-
-```yaml
-tools:
-  - name: my_tool
-    group: my_group
-    use: deerflow.tools.builtins.my_tool:my_tool
-```
-
-### Adding New Middleware
-
-1. Create middleware in `packages/harness/deerflow/agents/middlewares/`:
-
-```python
-# packages/harness/deerflow/agents/middlewares/my_middleware.py
-from langchain.agents.middleware import BaseMiddleware
-from langchain_core.runnables import RunnableConfig
-
-class MyMiddleware(BaseMiddleware):
-    """Middleware description."""
-
-    def transform_state(self, state: dict, config: RunnableConfig) -> dict:
-        """Transform the state before agent execution."""
-        # Modify state as needed
-        return state
-```
-
-2. Register in `packages/harness/deerflow/agents/lead_agent/agent.py`:
-
-```python
-middlewares = [
-    ThreadDataMiddleware(),
-    SandboxMiddleware(),
-    MyMiddleware(),  # Add your middleware
-    TitleMiddleware(),
-    ClarificationMiddleware(),
-]
-```
-
-### Adding New API Endpoints
-
-1. Create router in `app/gateway/routers/`:
-
-```python
-# app/gateway/routers/my_router.py
-from fastapi import APIRouter
-
-router = APIRouter(prefix="/my-endpoint", tags=["my-endpoint"])
-
-@router.get("/")
-async def get_items():
-    """Get all items."""
-    return {"items": []}
-
-@router.post("/")
-async def create_item(data: dict):
-    """Create a new item."""
-    return {"created": data}
-```
-
-2. Register in `app/gateway/app.py`:
-
-```python
-from app.gateway.routers import my_router
-
-app.include_router(my_router.router)
-```
-
-### Configuration Changes
-
-When adding new configuration options:
-
-1. Update `packages/harness/deerflow/config/app_config.py` with new fields
-2. Add default values in `config.example.yaml`
-3. Document in `docs/CONFIGURATION.md`
-
-### MCP Server Integration
-
-To add support for a new MCP server:
-
-1. Add configuration in `extensions_config.json`:
-
-```json
-{
-  "mcpServers": {
-    "my-server": {
-      "enabled": true,
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@my-org/mcp-server"],
-      "description": "My MCP Server"
-    }
-  }
-}
-```
-
-2. Update `extensions_config.example.json` with the new server
-
-### Skills Development
-
-To create a new skill:
-
-1. Create directory in `skills/public/` or `skills/custom/`:
-
-```
-skills/public/my-skill/
-└── SKILL.md
-```
-
-2. Write `SKILL.md` with YAML front matter:
-
-```markdown
----
-name: My Skill
-description: What this skill does
-license: MIT
-allowed-tools:
-  - read_file
-  - write_file
-  - bash
----
-
-# My Skill
-
-Instructions for the agent when this skill is enabled...
-```
-
-## Questions?
-
-If you have questions about contributing:
-
-1. Check existing documentation in `docs/`
-2. Look for similar issues or PRs on GitHub
-3. Open a discussion or issue on GitHub
-
-Thank you for contributing to DeerFlow!

backend/Dockerfile

@@ -1,91 +0,0 @@
-# Backend Dockerfile — multi-stage build
-# Stage 1 (builder): compiles native Python extensions with build-essential
-# Stage 2 (dev):     retains toolchain for dev containers (uv sync at startup)
-# Stage 3 (runtime): clean image without compiler toolchain for production
-
-# UV source image (override for restricted networks that cannot reach ghcr.io)
-ARG UV_IMAGE=ghcr.io/astral-sh/uv:0.7.20
-FROM ${UV_IMAGE} AS uv-source
-
-# ── Stage 1: Builder ──────────────────────────────────────────────────────────
-FROM python:3.12-slim-bookworm AS builder
-
-ARG NODE_MAJOR=22
-ARG APT_MIRROR
-ARG UV_INDEX_URL
-# Optional extras to install (e.g. "postgres" for PostgreSQL support)
-# Usage: docker build --build-arg UV_EXTRAS=postgres ...
-ARG UV_EXTRAS
-
-# Optionally override apt mirror for restricted networks (e.g. APT_MIRROR=mirrors.aliyun.com)
-RUN if [ -n "${APT_MIRROR}" ]; then \
-      sed -i "s|deb.debian.org|${APT_MIRROR}|g" /etc/apt/sources.list.d/debian.sources 2>/dev/null || true; \
-      sed -i "s|deb.debian.org|${APT_MIRROR}|g" /etc/apt/sources.list 2>/dev/null || true; \
-    fi
-
-# Install build tools + Node.js (build-essential needed for native Python extensions)
-RUN apt-get update && apt-get install -y \
-    curl \
-    build-essential \
-    gnupg \
-    ca-certificates \
-    && mkdir -p /etc/apt/keyrings \
-    && curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg \
-    && echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_${NODE_MAJOR}.x nodistro main" > /etc/apt/sources.list.d/nodesource.list \
-    && apt-get update \
-    && apt-get install -y nodejs \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install uv (source image overridable via UV_IMAGE build arg)
-COPY --from=uv-source /uv /uvx /usr/local/bin/
-
-# Set working directory
-WORKDIR /app
-
-# Copy backend source code
-COPY backend ./backend
-
-# Install dependencies with cache mount
-# When UV_EXTRAS is set (e.g. "postgres"), installs optional dependencies.
-RUN --mount=type=cache,target=/root/.cache/uv \
-    sh -c "cd backend && UV_INDEX_URL=${UV_INDEX_URL:-https://pypi.org/simple} uv sync ${UV_EXTRAS:+--extra $UV_EXTRAS}"
-
-# ── Stage 2: Dev ──────────────────────────────────────────────────────────────
-# Retains compiler toolchain from builder so startup-time `uv sync` can build
-# source distributions in development containers.
-FROM builder AS dev
-
-# Install Docker CLI (for DooD: allows starting sandbox containers via host Docker socket)
-COPY --from=docker:cli /usr/local/bin/docker /usr/local/bin/docker
-
-EXPOSE 8001 2024
-
-CMD ["sh", "-c", "cd backend && PYTHONPATH=. uv run uvicorn app.gateway.app:app --host 0.0.0.0 --port 8001"]
-
-# ── Stage 3: Runtime ──────────────────────────────────────────────────────────
-# Clean image without build-essential — reduces size (~200 MB) and attack surface.
-FROM python:3.12-slim-bookworm
-
-# Copy Node.js runtime from builder (provides npx for MCP servers)
-COPY --from=builder /usr/bin/node /usr/bin/node
-COPY --from=builder /usr/lib/node_modules /usr/lib/node_modules
-RUN ln -s ../lib/node_modules/npm/bin/npm-cli.js /usr/bin/npm \
-    && ln -s ../lib/node_modules/npm/bin/npx-cli.js /usr/bin/npx
-
-# Install Docker CLI (for DooD: allows starting sandbox containers via host Docker socket)
-COPY --from=docker:cli /usr/local/bin/docker /usr/local/bin/docker
-
-# Install uv (source image overridable via UV_IMAGE build arg)
-COPY --from=uv-source /uv /uvx /usr/local/bin/
-
-# Set working directory
-WORKDIR /app
-
-# Copy backend with pre-built virtualenv from builder
-COPY --from=builder /app/backend ./backend
-
-# Expose ports (gateway: 8001, langgraph: 2024)
-EXPOSE 8001 2024
-
-# Default command (can be overridden in docker-compose)
-CMD ["sh", "-c", "cd backend && PYTHONPATH=. uv run uvicorn app.gateway.app:app --host 0.0.0.0 --port 8001"]

backend/Makefile

@@ -1,18 +0,0 @@
-install:
-	uv sync
-
-dev:
-	uv run langgraph dev --no-browser --no-reload --n-jobs-per-worker 10
-
-gateway:
-	PYTHONPATH=. uv run uvicorn app.gateway.app:app --host 0.0.0.0 --port 8001
-
-test:
-	PYTHONPATH=. uv run pytest tests/ -v
-
-lint:
-	uvx ruff check .
-	uvx ruff format --check .
-
-format:
-	uvx ruff check . --fix && uvx ruff format .

backend/README.md

@@ -1,418 +0,0 @@
-# DeerFlow Backend
-
-DeerFlow is a LangGraph-based AI super agent with sandbox execution, persistent memory, and extensible tool integration. The backend enables AI agents to execute code, browse the web, manage files, delegate tasks to subagents, and retain context across conversations - all in isolated, per-thread environments.
-
----
-
-## Architecture
-
-```
-                        ┌──────────────────────────────────────┐
-                        │          Nginx (Port 2026)           │
-                        │      Unified reverse proxy           │
-                        └───────┬──────────────────┬───────────┘
-                                │                  │
-              /api/langgraph/*  │                  │  /api/* (other)
-                                ▼                  ▼
-               ┌────────────────────┐  ┌────────────────────────┐
-               │ LangGraph Server   │  │   Gateway API (8001)   │
-               │    (Port 2024)     │  │   FastAPI REST         │
-               │                    │  │                        │
-               │ ┌────────────────┐ │  │ Models, MCP, Skills,   │
-               │ │  Lead Agent    │ │  │ Memory, Uploads,       │
-               │ │  ┌──────────┐  │ │  │ Artifacts              │
-               │ │  │Middleware│  │ │  └────────────────────────┘
-               │ │  │  Chain   │  │ │
-               │ │  └──────────┘  │ │
-               │ │  ┌──────────┐  │ │
-               │ │  │  Tools   │  │ │
-               │ │  └──────────┘  │ │
-               │ │  ┌──────────┐  │ │
-               │ │  │Subagents │  │ │
-               │ │  └──────────┘  │ │
-               │ └────────────────┘ │
-               └────────────────────┘
-```
-
-**Request Routing** (via Nginx):
-- `/api/langgraph/*` → LangGraph Server - agent interactions, threads, streaming
-- `/api/*` (other) → Gateway API - models, MCP, skills, memory, artifacts, uploads, thread-local cleanup
-- `/` (non-API) → Frontend - Next.js web interface
-
----
-
-## Core Components
-
-### Lead Agent
-
-The single LangGraph agent (`lead_agent`) is the runtime entry point, created via `make_lead_agent(config)`. It combines:
-
-- **Dynamic model selection** with thinking and vision support
-- **Middleware chain** for cross-cutting concerns (9 middlewares)
-- **Tool system** with sandbox, MCP, community, and built-in tools
-- **Subagent delegation** for parallel task execution
-- **System prompt** with skills injection, memory context, and working directory guidance
-
-### Middleware Chain
-
-Middlewares execute in strict order, each handling a specific concern:
-
-| # | Middleware | Purpose |
-|---|-----------|---------|
-| 1 | **ThreadDataMiddleware** | Creates per-thread isolated directories (workspace, uploads, outputs) |
-| 2 | **UploadsMiddleware** | Injects newly uploaded files into conversation context |
-| 3 | **SandboxMiddleware** | Acquires sandbox environment for code execution |
-| 4 | **SummarizationMiddleware** | Reduces context when approaching token limits (optional) |
-| 5 | **TodoListMiddleware** | Tracks multi-step tasks in plan mode (optional) |
-| 6 | **TitleMiddleware** | Auto-generates conversation titles after first exchange |
-| 7 | **MemoryMiddleware** | Queues conversations for async memory extraction |
-| 8 | **ViewImageMiddleware** | Injects image data for vision-capable models (conditional) |
-| 9 | **ClarificationMiddleware** | Intercepts clarification requests and interrupts execution (must be last) |
-
-### Sandbox System
-
-Per-thread isolated execution with virtual path translation:
-
-- **Abstract interface**: `execute_command`, `read_file`, `write_file`, `list_dir`
-- **Providers**: `LocalSandboxProvider` (filesystem) and `AioSandboxProvider` (Docker, in community/)
-- **Virtual paths**: `/mnt/user-data/{workspace,uploads,outputs}` → thread-specific physical directories
-- **Skills path**: `/mnt/skills` → `deer-flow/skills/` directory
-- **Skills loading**: Recursively discovers nested `SKILL.md` files under `skills/{public,custom}` and preserves nested container paths
-- **File-write safety**: `str_replace` serializes read-modify-write per `(sandbox.id, path)` so isolated sandboxes keep concurrency even when virtual paths match
-- **Tools**: `bash`, `ls`, `read_file`, `write_file`, `str_replace` (`bash` is disabled by default when using `LocalSandboxProvider`; use `AioSandboxProvider` for isolated shell access)
-
-### Subagent System
-
-Async task delegation with concurrent execution:
-
-- **Built-in agents**: `general-purpose` (full toolset) and `bash` (command specialist, exposed only when shell access is available)
-- **Concurrency**: Max 3 subagents per turn, 15-minute timeout
-- **Execution**: Background thread pools with status tracking and SSE events
-- **Flow**: Agent calls `task()` tool → executor runs subagent in background → polls for completion → returns result
-
-### Memory System
-
-LLM-powered persistent context retention across conversations:
-
-- **Automatic extraction**: Analyzes conversations for user context, facts, and preferences
-- **Structured storage**: User context (work, personal, top-of-mind), history, and confidence-scored facts
-- **Debounced updates**: Batches updates to minimize LLM calls (configurable wait time)
-- **System prompt injection**: Top facts + context injected into agent prompts
-- **Storage**: JSON file with mtime-based cache invalidation
-
-### Tool Ecosystem
-
-| Category | Tools |
-|----------|-------|
-| **Sandbox** | `bash`, `ls`, `read_file`, `write_file`, `str_replace` |
-| **Built-in** | `present_files`, `ask_clarification`, `view_image`, `task` (subagent) |
-| **Community** | Tavily (web search), Jina AI (web fetch), Firecrawl (scraping), DuckDuckGo (image search) |
-| **MCP** | Any Model Context Protocol server (stdio, SSE, HTTP transports) |
-| **Skills** | Domain-specific workflows injected via system prompt |
-
-### Gateway API
-
-FastAPI application providing REST endpoints for frontend integration:
-
-| Route | Purpose |
-|-------|---------|
-| `GET /api/models` | List available LLM models |
-| `GET/PUT /api/mcp/config` | Manage MCP server configurations |
-| `GET/PUT /api/skills` | List and manage skills |
-| `POST /api/skills/install` | Install skill from `.skill` archive |
-| `GET /api/memory` | Retrieve memory data |
-| `POST /api/memory/reload` | Force memory reload |
-| `GET /api/memory/config` | Memory configuration |
-| `GET /api/memory/status` | Combined config + data |
-| `POST /api/threads/{id}/uploads` | Upload files (auto-converts PDF/PPT/Excel/Word to Markdown, rejects directory paths) |
-| `GET /api/threads/{id}/uploads/list` | List uploaded files |
-| `DELETE /api/threads/{id}` | Delete DeerFlow-managed local thread data after LangGraph thread deletion; unexpected failures are logged server-side and return a generic 500 detail |
-| `GET /api/threads/{id}/artifacts/{path}` | Serve generated artifacts |
-
-### IM Channels
-
-The IM bridge supports Feishu, Slack, and Telegram. Slack and Telegram still use the final `runs.wait()` response path, while Feishu now streams through `runs.stream(["messages-tuple", "values"])` and updates a single in-thread card in place.
-
-For Feishu card updates, DeerFlow stores the running card's `message_id` per inbound message and patches that same card until the run finishes, preserving the existing `OK` / `DONE` reaction flow.
-
----
-
-## Quick Start
-
-### Prerequisites
-
-- Python 3.12+
-- [uv](https://docs.astral.sh/uv/) package manager
-- API keys for your chosen LLM provider
-
-### Installation
-
-```bash
-cd deer-flow
-
-# Copy configuration files
-cp config.example.yaml config.yaml
-
-# Install backend dependencies
-cd backend
-make install
-```
-
-### Configuration
-
-Edit `config.yaml` in the project root:
-
-```yaml
-models:
-  - name: gpt-4o
-    display_name: GPT-4o
-    use: langchain_openai:ChatOpenAI
-    model: gpt-4o
-    api_key: $OPENAI_API_KEY
-    supports_thinking: false
-    supports_vision: true
-
-  - name: gpt-5-responses
-    display_name: GPT-5 (Responses API)
-    use: langchain_openai:ChatOpenAI
-    model: gpt-5
-    api_key: $OPENAI_API_KEY
-    use_responses_api: true
-    output_version: responses/v1
-    supports_vision: true
-```
-
-Set your API keys:
-
-```bash
-export OPENAI_API_KEY="your-api-key-here"
-```
-
-### Running
-
-**Full Application** (from project root):
-
-```bash
-make dev  # Starts LangGraph + Gateway + Frontend + Nginx
-```
-
-Access at: http://localhost:2026
-
-**Backend Only** (from backend directory):
-
-```bash
-# Terminal 1: LangGraph server
-make dev
-
-# Terminal 2: Gateway API
-make gateway
-```
-
-Direct access: LangGraph at http://localhost:2024, Gateway at http://localhost:8001
-
----
-
-## Project Structure
-
-```
-backend/
-├── src/
-│   ├── agents/                  # Agent system
-│   │   ├── lead_agent/         # Main agent (factory, prompts)
-│   │   ├── middlewares/        # 9 middleware components
-│   │   ├── memory/             # Memory extraction & storage
-│   │   └── thread_state.py    # ThreadState schema
-│   ├── gateway/                # FastAPI Gateway API
-│   │   ├── app.py             # Application setup
-│   │   └── routers/           # 6 route modules
-│   ├── sandbox/                # Sandbox execution
-│   │   ├── local/             # Local filesystem provider
-│   │   ├── sandbox.py         # Abstract interface
-│   │   ├── tools.py           # bash, ls, read/write/str_replace
-│   │   └── middleware.py      # Sandbox lifecycle
-│   ├── subagents/              # Subagent delegation
-│   │   ├── builtins/          # general-purpose, bash agents
-│   │   ├── executor.py        # Background execution engine
-│   │   └── registry.py        # Agent registry
-│   ├── tools/builtins/         # Built-in tools
-│   ├── mcp/                    # MCP protocol integration
-│   ├── models/                 # Model factory
-│   ├── skills/                 # Skill discovery & loading
-│   ├── config/                 # Configuration system
-│   ├── community/              # Community tools & providers
-│   ├── reflection/             # Dynamic module loading
-│   └── utils/                  # Utilities
-├── docs/                       # Documentation
-├── tests/                      # Test suite
-├── langgraph.json              # LangGraph server configuration
-├── pyproject.toml              # Python dependencies
-├── Makefile                    # Development commands
-└── Dockerfile                  # Container build
-```
-
----
-
-## Configuration
-
-### Main Configuration (`config.yaml`)
-
-Place in project root. Config values starting with `$` resolve as environment variables.
-
-Key sections:
-- `models` - LLM configurations with class paths, API keys, thinking/vision flags
-- `tools` - Tool definitions with module paths and groups
-- `tool_groups` - Logical tool groupings
-- `sandbox` - Execution environment provider
-- `skills` - Skills directory paths
-- `title` - Auto-title generation settings
-- `summarization` - Context summarization settings
-- `subagents` - Subagent system (enabled/disabled)
-- `memory` - Memory system settings (enabled, storage, debounce, facts limits)
-
-Provider note:
-- `models[*].use` references provider classes by module path (for example `langchain_openai:ChatOpenAI`).
-- If a provider module is missing, DeerFlow now returns an actionable error with install guidance (for example `uv add langchain-google-genai`).
-
-### Extensions Configuration (`extensions_config.json`)
-
-MCP servers and skill states in a single file:
-
-```json
-{
-  "mcpServers": {
-    "github": {
-      "enabled": true,
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-github"],
-      "env": {"GITHUB_TOKEN": "$GITHUB_TOKEN"}
-    },
-    "secure-http": {
-      "enabled": true,
-      "type": "http",
-      "url": "https://api.example.com/mcp",
-      "oauth": {
-        "enabled": true,
-        "token_url": "https://auth.example.com/oauth/token",
-        "grant_type": "client_credentials",
-        "client_id": "$MCP_OAUTH_CLIENT_ID",
-        "client_secret": "$MCP_OAUTH_CLIENT_SECRET"
-      }
-    }
-  },
-  "skills": {
-    "pdf-processing": {"enabled": true}
-  }
-}
-```
-
-### Environment Variables
-
-- `DEER_FLOW_CONFIG_PATH` - Override config.yaml location
-- `DEER_FLOW_EXTENSIONS_CONFIG_PATH` - Override extensions_config.json location
-- Model API keys: `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `DEEPSEEK_API_KEY`, etc.
-- Tool API keys: `TAVILY_API_KEY`, `GITHUB_TOKEN`, etc.
-
-### LangSmith Tracing
-
-DeerFlow has built-in [LangSmith](https://smith.langchain.com) integration for observability. When enabled, all LLM calls, agent runs, tool executions, and middleware processing are traced and visible in the LangSmith dashboard.
-
-**Setup:**
-
-1. Sign up at [smith.langchain.com](https://smith.langchain.com) and create a project.
-2. Add the following to your `.env` file in the project root:
-
-```bash
-LANGSMITH_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
-LANGSMITH_API_KEY=lsv2_pt_xxxxxxxxxxxxxxxx
-LANGSMITH_PROJECT=xxx
-```
-
-**Legacy variables:** The `LANGCHAIN_TRACING_V2`, `LANGCHAIN_API_KEY`, `LANGCHAIN_PROJECT`, and `LANGCHAIN_ENDPOINT` variables are also supported for backward compatibility. `LANGSMITH_*` variables take precedence when both are set.
-
-### Langfuse Tracing
-
-DeerFlow also supports [Langfuse](https://langfuse.com) observability for LangChain-compatible runs.
-
-Add the following to your `.env` file:
-
-```bash
-LANGFUSE_TRACING=true
-LANGFUSE_PUBLIC_KEY=pk-lf-xxxxxxxxxxxxxxxx
-LANGFUSE_SECRET_KEY=sk-lf-xxxxxxxxxxxxxxxx
-LANGFUSE_BASE_URL=https://cloud.langfuse.com
-```
-
-If you are using a self-hosted Langfuse deployment, set `LANGFUSE_BASE_URL` to your Langfuse host.
-
-### Dual Provider Behavior
-
-If both LangSmith and Langfuse are enabled, DeerFlow initializes and attaches both callbacks so the same run data is reported to both systems.
-
-If a provider is explicitly enabled but required credentials are missing, or the provider callback cannot be initialized, DeerFlow raises an error when tracing is initialized during model creation instead of silently disabling tracing.
-
-**Docker:** In `docker-compose.yaml`, tracing is disabled by default (`LANGSMITH_TRACING=false`). Set `LANGSMITH_TRACING=true` and/or `LANGFUSE_TRACING=true` in your `.env`, together with the required credentials, to enable tracing in containerized deployments.
-
----
-
-## Development
-
-### Commands
-
-```bash
-make install    # Install dependencies
-make dev        # Run LangGraph server (port 2024)
-make gateway    # Run Gateway API (port 8001)
-make lint       # Run linter (ruff)
-make format     # Format code (ruff)
-```
-
-### Code Style
-
-- **Linter/Formatter**: `ruff`
-- **Line length**: 240 characters
-- **Python**: 3.12+ with type hints
-- **Quotes**: Double quotes
-- **Indentation**: 4 spaces
-
-### Testing
-
-```bash
-uv run pytest
-```
-
----
-
-## Technology Stack
-
-- **LangGraph** (1.0.6+) - Agent framework and multi-agent orchestration
-- **LangChain** (1.2.3+) - LLM abstractions and tool system
-- **FastAPI** (0.115.0+) - Gateway REST API
-- **langchain-mcp-adapters** - Model Context Protocol support
-- **agent-sandbox** - Sandboxed code execution
-- **markitdown** - Multi-format document conversion
-- **tavily-python** / **firecrawl-py** - Web search and scraping
-
----
-
-## Documentation
-
-- [Configuration Guide](docs/CONFIGURATION.md)
-- [Architecture Details](docs/ARCHITECTURE.md)
-- [API Reference](docs/API.md)
-- [File Upload](docs/FILE_UPLOAD.md)
-- [Path Examples](docs/PATH_EXAMPLES.md)
-- [Context Summarization](docs/summarization.md)
-- [Plan Mode](docs/plan_mode_usage.md)
-- [Setup Guide](docs/SETUP.md)
-
----
-
-## License
-
-See the [LICENSE](../LICENSE) file in the project root.
-
-## Contributing
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines.

backend/app/channels/__init__.py

@@ -1,16 +0,0 @@
-"""IM Channel integration for DeerFlow.
-
-Provides a pluggable channel system that connects external messaging platforms
-(Feishu/Lark, Slack, Telegram) to the DeerFlow agent via the ChannelManager,
-which uses ``langgraph-sdk`` to communicate with the underlying LangGraph Server.
-"""
-
-from app.channels.base import Channel
-from app.channels.message_bus import InboundMessage, MessageBus, OutboundMessage
-
-__all__ = [
-    "Channel",
-    "InboundMessage",
-    "MessageBus",
-    "OutboundMessage",
-]

backend/app/channels/base.py

@@ -1,126 +0,0 @@
-"""Abstract base class for IM channels."""
-
-from __future__ import annotations
-
-import logging
-from abc import ABC, abstractmethod
-from typing import Any
-
-from app.channels.message_bus import InboundMessage, InboundMessageType, MessageBus, OutboundMessage, ResolvedAttachment
-
-logger = logging.getLogger(__name__)
-
-
-class Channel(ABC):
-    """Base class for all IM channel implementations.
-
-    Each channel connects to an external messaging platform and:
-    1. Receives messages, wraps them as InboundMessage, publishes to the bus.
-    2. Subscribes to outbound messages and sends replies back to the platform.
-
-    Subclasses must implement ``start``, ``stop``, and ``send``.
-    """
-
-    def __init__(self, name: str, bus: MessageBus, config: dict[str, Any]) -> None:
-        self.name = name
-        self.bus = bus
-        self.config = config
-        self._running = False
-
-    @property
-    def is_running(self) -> bool:
-        return self._running
-
-    # -- lifecycle ---------------------------------------------------------
-
-    @abstractmethod
-    async def start(self) -> None:
-        """Start listening for messages from the external platform."""
-
-    @abstractmethod
-    async def stop(self) -> None:
-        """Gracefully stop the channel."""
-
-    # -- outbound ----------------------------------------------------------
-
-    @abstractmethod
-    async def send(self, msg: OutboundMessage) -> None:
-        """Send a message back to the external platform.
-
-        The implementation should use ``msg.chat_id`` and ``msg.thread_ts``
-        to route the reply to the correct conversation/thread.
-        """
-
-    async def send_file(self, msg: OutboundMessage, attachment: ResolvedAttachment) -> bool:
-        """Upload a single file attachment to the platform.
-
-        Returns True if the upload succeeded, False otherwise.
-        Default implementation returns False (no file upload support).
-        """
-        return False
-
-    # -- helpers -----------------------------------------------------------
-
-    def _make_inbound(
-        self,
-        chat_id: str,
-        user_id: str,
-        text: str,
-        *,
-        msg_type: InboundMessageType = InboundMessageType.CHAT,
-        thread_ts: str | None = None,
-        files: list[dict[str, Any]] | None = None,
-        metadata: dict[str, Any] | None = None,
-    ) -> InboundMessage:
-        """Convenience factory for creating InboundMessage instances."""
-        return InboundMessage(
-            channel_name=self.name,
-            chat_id=chat_id,
-            user_id=user_id,
-            text=text,
-            msg_type=msg_type,
-            thread_ts=thread_ts,
-            files=files or [],
-            metadata=metadata or {},
-        )
-
-    async def _on_outbound(self, msg: OutboundMessage) -> None:
-        """Outbound callback registered with the bus.
-
-        Only forwards messages targeted at this channel.
-        Sends the text message first, then uploads any file attachments.
-        File uploads are skipped entirely when the text send fails to avoid
-        partial deliveries (files without accompanying text).
-        """
-        if msg.channel_name == self.name:
-            try:
-                await self.send(msg)
-            except Exception:
-                logger.exception("Failed to send outbound message on channel %s", self.name)
-                return  # Do not attempt file uploads when the text message failed
-
-            for attachment in msg.attachments:
-                try:
-                    success = await self.send_file(msg, attachment)
-                    if not success:
-                        logger.warning("[%s] file upload skipped for %s", self.name, attachment.filename)
-                except Exception:
-                    logger.exception("[%s] failed to upload file %s", self.name, attachment.filename)
-
-    async def receive_file(self, msg: InboundMessage, thread_id: str) -> InboundMessage:
-        """
-        Optionally process and materialize inbound file attachments for this channel.
-
-        By default, this method does nothing and simply returns the original message.
-        Subclasses (e.g. FeishuChannel) may override this to download files (images, documents, etc)
-        referenced in msg.files, save them to the sandbox, and update msg.text to include
-        the sandbox file paths for downstream model consumption.
-
-        Args:
-            msg: The inbound message, possibly containing file metadata in msg.files.
-            thread_id: The resolved DeerFlow thread ID for sandbox path context.
-
-        Returns:
-            The (possibly modified) InboundMessage, with text and/or files updated as needed.
-        """
-        return msg

backend/app/channels/commands.py

@@ -1,20 +0,0 @@
-"""Shared command definitions used by all channel implementations.
-
-Keeping the authoritative command set in one place ensures that channel
-parsers (e.g. Feishu) and the ChannelManager dispatcher stay in sync
-automatically — adding or removing a command here is the single edit
-required.
-"""
-
-from __future__ import annotations
-
-KNOWN_CHANNEL_COMMANDS: frozenset[str] = frozenset(
-    {
-        "/bootstrap",
-        "/new",
-        "/status",
-        "/models",
-        "/memory",
-        "/help",
-    }
-)

backend/app/channels/feishu.py

@@ -1,692 +0,0 @@
-"""Feishu/Lark channel — connects to Feishu via WebSocket (no public IP needed)."""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import re
-import threading
-from typing import Any, Literal
-
-from app.channels.base import Channel
-from app.channels.commands import KNOWN_CHANNEL_COMMANDS
-from app.channels.message_bus import InboundMessage, InboundMessageType, MessageBus, OutboundMessage, ResolvedAttachment
-from deerflow.config.paths import VIRTUAL_PATH_PREFIX, get_paths
-from deerflow.sandbox.sandbox_provider import get_sandbox_provider
-
-logger = logging.getLogger(__name__)
-
-
-def _is_feishu_command(text: str) -> bool:
-    if not text.startswith("/"):
-        return False
-    return text.split(maxsplit=1)[0].lower() in KNOWN_CHANNEL_COMMANDS
-
-
-class FeishuChannel(Channel):
-    """Feishu/Lark IM channel using the ``lark-oapi`` WebSocket client.
-
-    Configuration keys (in ``config.yaml`` under ``channels.feishu``):
-        - ``app_id``: Feishu app ID.
-        - ``app_secret``: Feishu app secret.
-        - ``verification_token``: (optional) Event verification token.
-
-    The channel uses WebSocket long-connection mode so no public IP is required.
-
-    Message flow:
-        1. User sends a message → bot adds "OK" emoji reaction
-        2. Bot replies in thread: "Working on it......"
-        3. Agent processes the message and returns a result
-        4. Bot replies in thread with the result
-        5. Bot adds "DONE" emoji reaction to the original message
-    """
-
-    def __init__(self, bus: MessageBus, config: dict[str, Any]) -> None:
-        super().__init__(name="feishu", bus=bus, config=config)
-        self._thread: threading.Thread | None = None
-        self._main_loop: asyncio.AbstractEventLoop | None = None
-        self._api_client = None
-        self._CreateMessageReactionRequest = None
-        self._CreateMessageReactionRequestBody = None
-        self._Emoji = None
-        self._PatchMessageRequest = None
-        self._PatchMessageRequestBody = None
-        self._background_tasks: set[asyncio.Task] = set()
-        self._running_card_ids: dict[str, str] = {}
-        self._running_card_tasks: dict[str, asyncio.Task] = {}
-        self._CreateFileRequest = None
-        self._CreateFileRequestBody = None
-        self._CreateImageRequest = None
-        self._CreateImageRequestBody = None
-        self._GetMessageResourceRequest = None
-        self._thread_lock = threading.Lock()
-
-    async def start(self) -> None:
-        if self._running:
-            return
-
-        try:
-            import lark_oapi as lark
-            from lark_oapi.api.im.v1 import (
-                CreateFileRequest,
-                CreateFileRequestBody,
-                CreateImageRequest,
-                CreateImageRequestBody,
-                CreateMessageReactionRequest,
-                CreateMessageReactionRequestBody,
-                CreateMessageRequest,
-                CreateMessageRequestBody,
-                Emoji,
-                GetMessageResourceRequest,
-                PatchMessageRequest,
-                PatchMessageRequestBody,
-                ReplyMessageRequest,
-                ReplyMessageRequestBody,
-            )
-        except ImportError:
-            logger.error("lark-oapi is not installed. Install it with: uv add lark-oapi")
-            return
-
-        self._lark = lark
-        self._CreateMessageRequest = CreateMessageRequest
-        self._CreateMessageRequestBody = CreateMessageRequestBody
-        self._ReplyMessageRequest = ReplyMessageRequest
-        self._ReplyMessageRequestBody = ReplyMessageRequestBody
-        self._CreateMessageReactionRequest = CreateMessageReactionRequest
-        self._CreateMessageReactionRequestBody = CreateMessageReactionRequestBody
-        self._Emoji = Emoji
-        self._PatchMessageRequest = PatchMessageRequest
-        self._PatchMessageRequestBody = PatchMessageRequestBody
-        self._CreateFileRequest = CreateFileRequest
-        self._CreateFileRequestBody = CreateFileRequestBody
-        self._CreateImageRequest = CreateImageRequest
-        self._CreateImageRequestBody = CreateImageRequestBody
-        self._GetMessageResourceRequest = GetMessageResourceRequest
-
-        app_id = self.config.get("app_id", "")
-        app_secret = self.config.get("app_secret", "")
-        domain = self.config.get("domain", "https://open.feishu.cn")
-
-        if not app_id or not app_secret:
-            logger.error("Feishu channel requires app_id and app_secret")
-            return
-
-        self._api_client = lark.Client.builder().app_id(app_id).app_secret(app_secret).domain(domain).build()
-        logger.info("[Feishu] using domain: %s", domain)
-        self._main_loop = asyncio.get_event_loop()
-
-        self._running = True
-        self.bus.subscribe_outbound(self._on_outbound)
-
-        # Both ws.Client construction and start() must happen in a dedicated
-        # thread with its own event loop.  lark-oapi caches the running loop
-        # at construction time and later calls loop.run_until_complete(),
-        # which conflicts with an already-running uvloop.
-        self._thread = threading.Thread(
-            target=self._run_ws,
-            args=(app_id, app_secret, domain),
-            daemon=True,
-        )
-        self._thread.start()
-        logger.info("Feishu channel started")
-
-    def _run_ws(self, app_id: str, app_secret: str, domain: str) -> None:
-        """Construct and run the lark WS client in a thread with a fresh event loop.
-
-        The lark-oapi SDK captures a module-level event loop at import time
-        (``lark_oapi.ws.client.loop``).  When uvicorn uses uvloop, that
-        captured loop is the *main* thread's uvloop — which is already
-        running, so ``loop.run_until_complete()`` inside ``Client.start()``
-        raises ``RuntimeError``.
-
-        We work around this by creating a plain asyncio event loop for this
-        thread and patching the SDK's module-level reference before calling
-        ``start()``.
-        """
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        try:
-            import lark_oapi as lark
-            import lark_oapi.ws.client as _ws_client_mod
-
-            # Replace the SDK's module-level loop so Client.start() uses
-            # this thread's (non-running) event loop instead of the main
-            # thread's uvloop.
-            _ws_client_mod.loop = loop
-
-            event_handler = lark.EventDispatcherHandler.builder("", "").register_p2_im_message_receive_v1(self._on_message).build()
-            ws_client = lark.ws.Client(
-                app_id=app_id,
-                app_secret=app_secret,
-                event_handler=event_handler,
-                log_level=lark.LogLevel.INFO,
-                domain=domain,
-            )
-            ws_client.start()
-        except Exception:
-            if self._running:
-                logger.exception("Feishu WebSocket error")
-
-    async def stop(self) -> None:
-        self._running = False
-        self.bus.unsubscribe_outbound(self._on_outbound)
-        for task in list(self._background_tasks):
-            task.cancel()
-        self._background_tasks.clear()
-        for task in list(self._running_card_tasks.values()):
-            task.cancel()
-        self._running_card_tasks.clear()
-        if self._thread:
-            self._thread.join(timeout=5)
-            self._thread = None
-        logger.info("Feishu channel stopped")
-
-    async def send(self, msg: OutboundMessage, *, _max_retries: int = 3) -> None:
-        if not self._api_client:
-            logger.warning("[Feishu] send called but no api_client available")
-            return
-
-        logger.info(
-            "[Feishu] sending reply: chat_id=%s, thread_ts=%s, text_len=%d",
-            msg.chat_id,
-            msg.thread_ts,
-            len(msg.text),
-        )
-
-        last_exc: Exception | None = None
-        for attempt in range(_max_retries):
-            try:
-                await self._send_card_message(msg)
-                return  # success
-            except Exception as exc:
-                last_exc = exc
-                if attempt < _max_retries - 1:
-                    delay = 2**attempt  # 1s, 2s
-                    logger.warning(
-                        "[Feishu] send failed (attempt %d/%d), retrying in %ds: %s",
-                        attempt + 1,
-                        _max_retries,
-                        delay,
-                        exc,
-                    )
-                    await asyncio.sleep(delay)
-
-        logger.error("[Feishu] send failed after %d attempts: %s", _max_retries, last_exc)
-        if last_exc is None:
-            raise RuntimeError("Feishu send failed without an exception from any attempt")
-        raise last_exc
-
-    async def send_file(self, msg: OutboundMessage, attachment: ResolvedAttachment) -> bool:
-        if not self._api_client:
-            return False
-
-        # Check size limits (image: 10MB, file: 30MB)
-        if attachment.is_image and attachment.size > 10 * 1024 * 1024:
-            logger.warning("[Feishu] image too large (%d bytes), skipping: %s", attachment.size, attachment.filename)
-            return False
-        if not attachment.is_image and attachment.size > 30 * 1024 * 1024:
-            logger.warning("[Feishu] file too large (%d bytes), skipping: %s", attachment.size, attachment.filename)
-            return False
-
-        try:
-            if attachment.is_image:
-                file_key = await self._upload_image(attachment.actual_path)
-                msg_type = "image"
-                content = json.dumps({"image_key": file_key})
-            else:
-                file_key = await self._upload_file(attachment.actual_path, attachment.filename)
-                msg_type = "file"
-                content = json.dumps({"file_key": file_key})
-
-            if msg.thread_ts:
-                request = self._ReplyMessageRequest.builder().message_id(msg.thread_ts).request_body(self._ReplyMessageRequestBody.builder().msg_type(msg_type).content(content).reply_in_thread(True).build()).build()
-                await asyncio.to_thread(self._api_client.im.v1.message.reply, request)
-            else:
-                request = self._CreateMessageRequest.builder().receive_id_type("chat_id").request_body(self._CreateMessageRequestBody.builder().receive_id(msg.chat_id).msg_type(msg_type).content(content).build()).build()
-                await asyncio.to_thread(self._api_client.im.v1.message.create, request)
-
-            logger.info("[Feishu] file sent: %s (type=%s)", attachment.filename, msg_type)
-            return True
-        except Exception:
-            logger.exception("[Feishu] failed to upload/send file: %s", attachment.filename)
-            return False
-
-    async def _upload_image(self, path) -> str:
-        """Upload an image to Feishu and return the image_key."""
-        with open(str(path), "rb") as f:
-            request = self._CreateImageRequest.builder().request_body(self._CreateImageRequestBody.builder().image_type("message").image(f).build()).build()
-            response = await asyncio.to_thread(self._api_client.im.v1.image.create, request)
-        if not response.success():
-            raise RuntimeError(f"Feishu image upload failed: code={response.code}, msg={response.msg}")
-        return response.data.image_key
-
-    async def _upload_file(self, path, filename: str) -> str:
-        """Upload a file to Feishu and return the file_key."""
-        suffix = path.suffix.lower() if hasattr(path, "suffix") else ""
-        if suffix in (".xls", ".xlsx", ".csv"):
-            file_type = "xls"
-        elif suffix in (".ppt", ".pptx"):
-            file_type = "ppt"
-        elif suffix == ".pdf":
-            file_type = "pdf"
-        elif suffix in (".doc", ".docx"):
-            file_type = "doc"
-        else:
-            file_type = "stream"
-
-        with open(str(path), "rb") as f:
-            request = self._CreateFileRequest.builder().request_body(self._CreateFileRequestBody.builder().file_type(file_type).file_name(filename).file(f).build()).build()
-            response = await asyncio.to_thread(self._api_client.im.v1.file.create, request)
-        if not response.success():
-            raise RuntimeError(f"Feishu file upload failed: code={response.code}, msg={response.msg}")
-        return response.data.file_key
-
-    async def receive_file(self, msg: InboundMessage, thread_id: str) -> InboundMessage:
-        """Download a Feishu file into the thread uploads directory.
-
-        Returns the sandbox virtual path when the image is persisted successfully.
-        """
-        if not msg.thread_ts:
-            logger.warning("[Feishu] received file message without thread_ts, cannot associate with conversation: %s", msg)
-            return msg
-        files = msg.files
-        if not files:
-            logger.warning("[Feishu] received message with no files: %s", msg)
-            return msg
-        text = msg.text
-        for file in files:
-            if file.get("image_key"):
-                virtual_path = await self._receive_single_file(msg.thread_ts, file["image_key"], "image", thread_id)
-                text = text.replace("[image]", virtual_path, 1)
-            elif file.get("file_key"):
-                virtual_path = await self._receive_single_file(msg.thread_ts, file["file_key"], "file", thread_id)
-                text = text.replace("[file]", virtual_path, 1)
-        msg.text = text
-        return msg
-
-    async def _receive_single_file(self, message_id: str, file_key: str, type: Literal["image", "file"], thread_id: str) -> str:
-        request = self._GetMessageResourceRequest.builder().message_id(message_id).file_key(file_key).type(type).build()
-
-        def inner():
-            return self._api_client.im.v1.message_resource.get(request)
-
-        try:
-            response = await asyncio.to_thread(inner)
-        except Exception:
-            logger.exception("[Feishu] resource get request failed for resource_key=%s type=%s", file_key, type)
-            return f"Failed to obtain the [{type}]"
-
-        if not response.success():
-            logger.warning(
-                "[Feishu] resource get failed: resource_key=%s, type=%s, code=%s, msg=%s, log_id=%s ",
-                file_key,
-                type,
-                response.code,
-                response.msg,
-                response.get_log_id(),
-            )
-            return f"Failed to obtain the [{type}]"
-
-        image_stream = getattr(response, "file", None)
-        if image_stream is None:
-            logger.warning("[Feishu] resource get returned no file stream: resource_key=%s, type=%s", file_key, type)
-            return f"Failed to obtain the [{type}]"
-
-        try:
-            content: bytes = await asyncio.to_thread(image_stream.read)
-        except Exception:
-            logger.exception("[Feishu] failed to read resource stream: resource_key=%s, type=%s", file_key, type)
-            return f"Failed to obtain the [{type}]"
-
-        if not content:
-            logger.warning("[Feishu] empty resource content: resource_key=%s, type=%s", file_key, type)
-            return f"Failed to obtain the [{type}]"
-
-        paths = get_paths()
-        paths.ensure_thread_dirs(thread_id)
-        uploads_dir = paths.sandbox_uploads_dir(thread_id).resolve()
-
-        ext = "png" if type == "image" else "bin"
-        raw_filename = getattr(response, "file_name", "") or f"feishu_{file_key[-12:]}.{ext}"
-
-        # Sanitize filename: preserve extension, replace path chars in name part
-        if "." in raw_filename:
-            name_part, ext = raw_filename.rsplit(".", 1)
-            name_part = re.sub(r"[./\\]", "_", name_part)
-            filename = f"{name_part}.{ext}"
-        else:
-            filename = re.sub(r"[./\\]", "_", raw_filename)
-        resolved_target = uploads_dir / filename
-
-        def down_load():
-            # use thread_lock to avoid filename conflicts when writing
-            with self._thread_lock:
-                resolved_target.write_bytes(content)
-
-        try:
-            await asyncio.to_thread(down_load)
-        except Exception:
-            logger.exception("[Feishu] failed to persist downloaded resource: %s, type=%s", resolved_target, type)
-            return f"Failed to obtain the [{type}]"
-
-        virtual_path = f"{VIRTUAL_PATH_PREFIX}/uploads/{resolved_target.name}"
-
-        try:
-            sandbox_provider = get_sandbox_provider()
-            sandbox_id = sandbox_provider.acquire(thread_id)
-            if sandbox_id != "local":
-                sandbox = sandbox_provider.get(sandbox_id)
-                if sandbox is None:
-                    logger.warning("[Feishu] sandbox not found for thread_id=%s", thread_id)
-                    return f"Failed to obtain the [{type}]"
-                sandbox.update_file(virtual_path, content)
-        except Exception:
-            logger.exception("[Feishu] failed to sync resource into non-local sandbox: %s", virtual_path)
-            return f"Failed to obtain the [{type}]"
-
-        logger.info("[Feishu] downloaded resource mapped: file_key=%s -> %s", file_key, virtual_path)
-        return virtual_path
-
-    # -- message formatting ------------------------------------------------
-
-    @staticmethod
-    def _build_card_content(text: str) -> str:
-        """Build a Feishu interactive card with markdown content.
-
-        Feishu's interactive card format natively renders markdown, including
-        headers, bold/italic, code blocks, lists, and links.
-        """
-        card = {
-            "config": {"wide_screen_mode": True, "update_multi": True},
-            "elements": [{"tag": "markdown", "content": text}],
-        }
-        return json.dumps(card)
-
-    # -- reaction helpers --------------------------------------------------
-
-    async def _add_reaction(self, message_id: str, emoji_type: str = "THUMBSUP") -> None:
-        """Add an emoji reaction to a message."""
-        if not self._api_client or not self._CreateMessageReactionRequest:
-            return
-        try:
-            request = self._CreateMessageReactionRequest.builder().message_id(message_id).request_body(self._CreateMessageReactionRequestBody.builder().reaction_type(self._Emoji.builder().emoji_type(emoji_type).build()).build()).build()
-            await asyncio.to_thread(self._api_client.im.v1.message_reaction.create, request)
-            logger.info("[Feishu] reaction '%s' added to message %s", emoji_type, message_id)
-        except Exception:
-            logger.exception("[Feishu] failed to add reaction '%s' to message %s", emoji_type, message_id)
-
-    async def _reply_card(self, message_id: str, text: str) -> str | None:
-        """Reply with an interactive card and return the created card message ID."""
-        if not self._api_client:
-            return None
-
-        content = self._build_card_content(text)
-        request = self._ReplyMessageRequest.builder().message_id(message_id).request_body(self._ReplyMessageRequestBody.builder().msg_type("interactive").content(content).reply_in_thread(True).build()).build()
-        response = await asyncio.to_thread(self._api_client.im.v1.message.reply, request)
-        response_data = getattr(response, "data", None)
-        return getattr(response_data, "message_id", None)
-
-    async def _create_card(self, chat_id: str, text: str) -> None:
-        """Create a new card message in the target chat."""
-        if not self._api_client:
-            return
-
-        content = self._build_card_content(text)
-        request = self._CreateMessageRequest.builder().receive_id_type("chat_id").request_body(self._CreateMessageRequestBody.builder().receive_id(chat_id).msg_type("interactive").content(content).build()).build()
-        await asyncio.to_thread(self._api_client.im.v1.message.create, request)
-
-    async def _update_card(self, message_id: str, text: str) -> None:
-        """Patch an existing card message in place."""
-        if not self._api_client or not self._PatchMessageRequest:
-            return
-
-        content = self._build_card_content(text)
-        request = self._PatchMessageRequest.builder().message_id(message_id).request_body(self._PatchMessageRequestBody.builder().content(content).build()).build()
-        await asyncio.to_thread(self._api_client.im.v1.message.patch, request)
-
-    def _track_background_task(self, task: asyncio.Task, *, name: str, msg_id: str) -> None:
-        """Keep a strong reference to fire-and-forget tasks and surface errors."""
-        self._background_tasks.add(task)
-        task.add_done_callback(lambda done_task, task_name=name, mid=msg_id: self._finalize_background_task(done_task, task_name, mid))
-
-    def _finalize_background_task(self, task: asyncio.Task, name: str, msg_id: str) -> None:
-        self._background_tasks.discard(task)
-        self._log_task_error(task, name, msg_id)
-
-    async def _create_running_card(self, source_message_id: str, text: str) -> str | None:
-        """Create the running card and cache its message ID when available."""
-        running_card_id = await self._reply_card(source_message_id, text)
-        if running_card_id:
-            self._running_card_ids[source_message_id] = running_card_id
-            logger.info("[Feishu] running card created: source=%s card=%s", source_message_id, running_card_id)
-        else:
-            logger.warning("[Feishu] running card creation returned no message_id for source=%s, subsequent updates will fall back to new replies", source_message_id)
-        return running_card_id
-
-    def _ensure_running_card_started(self, source_message_id: str, text: str = "Working on it...") -> asyncio.Task | None:
-        """Start running-card creation once per source message."""
-        running_card_id = self._running_card_ids.get(source_message_id)
-        if running_card_id:
-            return None
-
-        running_card_task = self._running_card_tasks.get(source_message_id)
-        if running_card_task:
-            return running_card_task
-
-        running_card_task = asyncio.create_task(self._create_running_card(source_message_id, text))
-        self._running_card_tasks[source_message_id] = running_card_task
-        running_card_task.add_done_callback(lambda done_task, mid=source_message_id: self._finalize_running_card_task(mid, done_task))
-        return running_card_task
-
-    def _finalize_running_card_task(self, source_message_id: str, task: asyncio.Task) -> None:
-        if self._running_card_tasks.get(source_message_id) is task:
-            self._running_card_tasks.pop(source_message_id, None)
-        self._log_task_error(task, "create_running_card", source_message_id)
-
-    async def _ensure_running_card(self, source_message_id: str, text: str = "Working on it...") -> str | None:
-        """Ensure the in-thread running card exists and track its message ID."""
-        running_card_id = self._running_card_ids.get(source_message_id)
-        if running_card_id:
-            return running_card_id
-
-        running_card_task = self._ensure_running_card_started(source_message_id, text)
-        if running_card_task is None:
-            return self._running_card_ids.get(source_message_id)
-        return await running_card_task
-
-    async def _send_running_reply(self, message_id: str) -> None:
-        """Reply to a message in-thread with a running card."""
-        try:
-            await self._ensure_running_card(message_id)
-        except Exception:
-            logger.exception("[Feishu] failed to send running reply for message %s", message_id)
-
-    async def _send_card_message(self, msg: OutboundMessage) -> None:
-        """Send or update the Feishu card tied to the current request."""
-        source_message_id = msg.thread_ts
-        if source_message_id:
-            running_card_id = self._running_card_ids.get(source_message_id)
-            awaited_running_card_task = False
-
-            if not running_card_id:
-                running_card_task = self._running_card_tasks.get(source_message_id)
-                if running_card_task:
-                    awaited_running_card_task = True
-                    running_card_id = await running_card_task
-
-            if running_card_id:
-                try:
-                    await self._update_card(running_card_id, msg.text)
-                except Exception:
-                    if not msg.is_final:
-                        raise
-                    logger.exception(
-                        "[Feishu] failed to patch running card %s, falling back to final reply",
-                        running_card_id,
-                    )
-                    await self._reply_card(source_message_id, msg.text)
-                else:
-                    logger.info("[Feishu] running card updated: source=%s card=%s", source_message_id, running_card_id)
-            elif msg.is_final:
-                await self._reply_card(source_message_id, msg.text)
-            elif awaited_running_card_task:
-                logger.warning(
-                    "[Feishu] running card task finished without message_id for source=%s, skipping duplicate non-final creation",
-                    source_message_id,
-                )
-            else:
-                await self._ensure_running_card(source_message_id, msg.text)
-
-            if msg.is_final:
-                self._running_card_ids.pop(source_message_id, None)
-                await self._add_reaction(source_message_id, "DONE")
-            return
-
-        await self._create_card(msg.chat_id, msg.text)
-
-    # -- internal ----------------------------------------------------------
-
-    @staticmethod
-    def _log_future_error(fut, name: str, msg_id: str) -> None:
-        """Callback for run_coroutine_threadsafe futures to surface errors."""
-        try:
-            exc = fut.exception()
-            if exc:
-                logger.error("[Feishu] %s failed for msg_id=%s: %s", name, msg_id, exc)
-        except Exception:
-            pass
-
-    @staticmethod
-    def _log_task_error(task: asyncio.Task, name: str, msg_id: str) -> None:
-        """Callback for background asyncio tasks to surface errors."""
-        try:
-            exc = task.exception()
-            if exc:
-                logger.error("[Feishu] %s failed for msg_id=%s: %s", name, msg_id, exc)
-        except asyncio.CancelledError:
-            logger.info("[Feishu] %s cancelled for msg_id=%s", name, msg_id)
-        except Exception:
-            pass
-
-    async def _prepare_inbound(self, msg_id: str, inbound) -> None:
-        """Kick off Feishu side effects without delaying inbound dispatch."""
-        reaction_task = asyncio.create_task(self._add_reaction(msg_id, "OK"))
-        self._track_background_task(reaction_task, name="add_reaction", msg_id=msg_id)
-        self._ensure_running_card_started(msg_id)
-        await self.bus.publish_inbound(inbound)
-
-    def _on_message(self, event) -> None:
-        """Called by lark-oapi when a message is received (runs in lark thread)."""
-        try:
-            logger.info("[Feishu] raw event received: type=%s", type(event).__name__)
-            message = event.event.message
-            chat_id = message.chat_id
-            msg_id = message.message_id
-            sender_id = event.event.sender.sender_id.open_id
-
-            # root_id is set when the message is a reply within a Feishu thread.
-            # Use it as topic_id so all replies share the same DeerFlow thread.
-            root_id = getattr(message, "root_id", None) or None
-
-            # Parse message content
-            content = json.loads(message.content)
-
-            # files_list store the any-file-key in feishu messages, which can be used to download the file content later
-            # In Feishu channel, image_keys are independent of file_keys.
-            # The file_key includes files, videos, and audio, but does not include stickers.
-            files_list = []
-
-            if "text" in content:
-                # Handle plain text messages
-                text = content["text"]
-            elif "file_key" in content:
-                file_key = content.get("file_key")
-                if isinstance(file_key, str) and file_key:
-                    files_list.append({"file_key": file_key})
-                    text = "[file]"
-                else:
-                    text = ""
-            elif "image_key" in content:
-                image_key = content.get("image_key")
-                if isinstance(image_key, str) and image_key:
-                    files_list.append({"image_key": image_key})
-                    text = "[image]"
-                else:
-                    text = ""
-            elif "content" in content and isinstance(content["content"], list):
-                # Handle rich-text messages with a top-level "content" list (e.g., topic groups/posts)
-                text_paragraphs: list[str] = []
-                for paragraph in content["content"]:
-                    if isinstance(paragraph, list):
-                        paragraph_text_parts: list[str] = []
-                        for element in paragraph:
-                            if isinstance(element, dict):
-                                # Include both normal text and @ mentions
-                                if element.get("tag") in ("text", "at"):
-                                    text_value = element.get("text", "")
-                                    if text_value:
-                                        paragraph_text_parts.append(text_value)
-                                elif element.get("tag") == "img":
-                                    image_key = element.get("image_key")
-                                    if isinstance(image_key, str) and image_key:
-                                        files_list.append({"image_key": image_key})
-                                        paragraph_text_parts.append("[image]")
-                                elif element.get("tag") in ("file", "media"):
-                                    file_key = element.get("file_key")
-                                    if isinstance(file_key, str) and file_key:
-                                        files_list.append({"file_key": file_key})
-                                        paragraph_text_parts.append("[file]")
-                        if paragraph_text_parts:
-                            # Join text segments within a paragraph with spaces to avoid "helloworld"
-                            text_paragraphs.append(" ".join(paragraph_text_parts))
-
-                # Join paragraphs with blank lines to preserve paragraph boundaries
-                text = "\n\n".join(text_paragraphs)
-            else:
-                text = ""
-            text = text.strip()
-
-            logger.info(
-                "[Feishu] parsed message: chat_id=%s, msg_id=%s, root_id=%s, sender=%s, text=%r",
-                chat_id,
-                msg_id,
-                root_id,
-                sender_id,
-                text[:100] if text else "",
-            )
-
-            if not (text or files_list):
-                logger.info("[Feishu] empty text, ignoring message")
-                return
-
-            # Only treat known slash commands as commands; absolute paths and
-            # other slash-prefixed text should be handled as normal chat.
-            if _is_feishu_command(text):
-                msg_type = InboundMessageType.COMMAND
-            else:
-                msg_type = InboundMessageType.CHAT
-
-            # topic_id: use root_id for replies (same topic), msg_id for new messages (new topic)
-            topic_id = root_id or msg_id
-
-            inbound = self._make_inbound(
-                chat_id=chat_id,
-                user_id=sender_id,
-                text=text,
-                msg_type=msg_type,
-                thread_ts=msg_id,
-                files=files_list,
-                metadata={"message_id": msg_id, "root_id": root_id},
-            )
-            inbound.topic_id = topic_id
-
-            # Schedule on the async event loop
-            if self._main_loop and self._main_loop.is_running():
-                logger.info("[Feishu] publishing inbound message to bus (type=%s, msg_id=%s)", msg_type.value, msg_id)
-                fut = asyncio.run_coroutine_threadsafe(self._prepare_inbound(msg_id, inbound), self._main_loop)
-                fut.add_done_callback(lambda f, mid=msg_id: self._log_future_error(f, "prepare_inbound", mid))
-            else:
-                logger.warning("[Feishu] main loop not running, cannot publish inbound message")
-        except Exception:
-            logger.exception("[Feishu] error processing message")

backend/app/channels/manager.py

@@ -1,940 +0,0 @@
-"""ChannelManager — consumes inbound messages and dispatches them to the DeerFlow agent via LangGraph Server."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import mimetypes
-import re
-import time
-from collections.abc import Awaitable, Callable, Mapping
-from typing import Any
-
-import httpx
-from langgraph_sdk.errors import ConflictError
-
-from app.channels.commands import KNOWN_CHANNEL_COMMANDS
-from app.channels.message_bus import InboundMessage, InboundMessageType, MessageBus, OutboundMessage, ResolvedAttachment
-from app.channels.store import ChannelStore
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_LANGGRAPH_URL = "http://localhost:2024"
-DEFAULT_GATEWAY_URL = "http://localhost:8001"
-DEFAULT_ASSISTANT_ID = "lead_agent"
-CUSTOM_AGENT_NAME_PATTERN = re.compile(r"^[A-Za-z0-9-]+$")
-
-DEFAULT_RUN_CONFIG: dict[str, Any] = {"recursion_limit": 100}
-DEFAULT_RUN_CONTEXT: dict[str, Any] = {
-    "thinking_enabled": True,
-    "is_plan_mode": False,
-    "subagent_enabled": False,
-}
-STREAM_UPDATE_MIN_INTERVAL_SECONDS = 0.35
-THREAD_BUSY_MESSAGE = "This conversation is already processing another request. Please wait for it to finish and try again."
-
-CHANNEL_CAPABILITIES = {
-    "feishu": {"supports_streaming": True},
-    "slack": {"supports_streaming": False},
-    "telegram": {"supports_streaming": False},
-    "wecom": {"supports_streaming": True},
-}
-
-InboundFileReader = Callable[[dict[str, Any], httpx.AsyncClient], Awaitable[bytes | None]]
-
-
-INBOUND_FILE_READERS: dict[str, InboundFileReader] = {}
-
-
-def register_inbound_file_reader(channel_name: str, reader: InboundFileReader) -> None:
-    INBOUND_FILE_READERS[channel_name] = reader
-
-
-async def _read_http_inbound_file(file_info: dict[str, Any], client: httpx.AsyncClient) -> bytes | None:
-    url = file_info.get("url")
-    if not isinstance(url, str) or not url:
-        return None
-
-    resp = await client.get(url)
-    resp.raise_for_status()
-    return resp.content
-
-
-async def _read_wecom_inbound_file(file_info: dict[str, Any], client: httpx.AsyncClient) -> bytes | None:
-    data = await _read_http_inbound_file(file_info, client)
-    if data is None:
-        return None
-
-    aeskey = file_info.get("aeskey") if isinstance(file_info.get("aeskey"), str) else None
-    if not aeskey:
-        return data
-
-    try:
-        from aibot.crypto_utils import decrypt_file
-    except Exception:
-        logger.exception("[Manager] failed to import WeCom decrypt_file")
-        return None
-
-    return decrypt_file(data, aeskey)
-
-
-register_inbound_file_reader("wecom", _read_wecom_inbound_file)
-
-
-class InvalidChannelSessionConfigError(ValueError):
-    """Raised when IM channel session overrides contain invalid agent config."""
-
-
-def _is_thread_busy_error(exc: BaseException | None) -> bool:
-    if exc is None:
-        return False
-    if isinstance(exc, ConflictError):
-        return True
-    return "already running a task" in str(exc)
-
-
-def _as_dict(value: Any) -> dict[str, Any]:
-    return dict(value) if isinstance(value, Mapping) else {}
-
-
-def _merge_dicts(*layers: Any) -> dict[str, Any]:
-    merged: dict[str, Any] = {}
-    for layer in layers:
-        if isinstance(layer, Mapping):
-            merged.update(layer)
-    return merged
-
-
-def _normalize_custom_agent_name(raw_value: str) -> str:
-    """Normalize legacy channel assistant IDs into valid custom agent names."""
-    normalized = raw_value.strip().lower().replace("_", "-")
-    if not normalized:
-        raise InvalidChannelSessionConfigError("Channel session assistant_id is empty. Use 'lead_agent' or a valid custom agent name.")
-    if not CUSTOM_AGENT_NAME_PATTERN.fullmatch(normalized):
-        raise InvalidChannelSessionConfigError(f"Invalid channel session assistant_id {raw_value!r}. Use 'lead_agent' or a custom agent name containing only letters, digits, and hyphens.")
-    return normalized
-
-
-def _extract_response_text(result: dict | list) -> str:
-    """Extract the last AI message text from a LangGraph runs.wait result.
-
-    ``runs.wait`` returns the final state dict which contains a ``messages``
-    list.  Each message is a dict with at least ``type`` and ``content``.
-
-    Handles special cases:
-    - Regular AI text responses
-    - Clarification interrupts (``ask_clarification`` tool messages)
-    - AI messages with tool_calls but no text content
-    """
-    if isinstance(result, list):
-        messages = result
-    elif isinstance(result, dict):
-        messages = result.get("messages", [])
-    else:
-        return ""
-
-    # Walk backwards to find usable response text, but stop at the last
-    # human message to avoid returning text from a previous turn.
-    for msg in reversed(messages):
-        if not isinstance(msg, dict):
-            continue
-
-        msg_type = msg.get("type")
-
-        # Stop at the last human message — anything before it is a previous turn
-        if msg_type == "human":
-            break
-
-        # Check for tool messages from ask_clarification (interrupt case)
-        if msg_type == "tool" and msg.get("name") == "ask_clarification":
-            content = msg.get("content", "")
-            if isinstance(content, str) and content:
-                return content
-
-        # Regular AI message with text content
-        if msg_type == "ai":
-            content = msg.get("content", "")
-            if isinstance(content, str) and content:
-                return content
-            # content can be a list of content blocks
-            if isinstance(content, list):
-                parts = []
-                for block in content:
-                    if isinstance(block, dict) and block.get("type") == "text":
-                        parts.append(block.get("text", ""))
-                    elif isinstance(block, str):
-                        parts.append(block)
-                text = "".join(parts)
-                if text:
-                    return text
-    return ""
-
-
-def _extract_text_content(content: Any) -> str:
-    """Extract text from a streaming payload content field."""
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        parts: list[str] = []
-        for block in content:
-            if isinstance(block, str):
-                parts.append(block)
-            elif isinstance(block, Mapping):
-                text = block.get("text")
-                if isinstance(text, str):
-                    parts.append(text)
-                else:
-                    nested = block.get("content")
-                    if isinstance(nested, str):
-                        parts.append(nested)
-        return "".join(parts)
-    if isinstance(content, Mapping):
-        for key in ("text", "content"):
-            value = content.get(key)
-            if isinstance(value, str):
-                return value
-    return ""
-
-
-def _merge_stream_text(existing: str, chunk: str) -> str:
-    """Merge either delta text or cumulative text into a single snapshot."""
-    if not chunk:
-        return existing
-    if not existing or chunk == existing:
-        return chunk or existing
-    if chunk.startswith(existing):
-        return chunk
-    if existing.endswith(chunk):
-        return existing
-    return existing + chunk
-
-
-def _extract_stream_message_id(payload: Any, metadata: Any) -> str | None:
-    """Best-effort extraction of the streamed AI message identifier."""
-    candidates = [payload, metadata]
-    if isinstance(payload, Mapping):
-        candidates.append(payload.get("kwargs"))
-
-    for candidate in candidates:
-        if not isinstance(candidate, Mapping):
-            continue
-        for key in ("id", "message_id"):
-            value = candidate.get(key)
-            if isinstance(value, str) and value:
-                return value
-    return None
-
-
-def _accumulate_stream_text(
-    buffers: dict[str, str],
-    current_message_id: str | None,
-    event_data: Any,
-) -> tuple[str | None, str | None]:
-    """Convert a ``messages-tuple`` event into the latest displayable AI text."""
-    payload = event_data
-    metadata: Any = None
-    if isinstance(event_data, (list, tuple)):
-        if event_data:
-            payload = event_data[0]
-        if len(event_data) > 1:
-            metadata = event_data[1]
-
-    if isinstance(payload, str):
-        message_id = current_message_id or "__default__"
-        buffers[message_id] = _merge_stream_text(buffers.get(message_id, ""), payload)
-        return buffers[message_id], message_id
-
-    if not isinstance(payload, Mapping):
-        return None, current_message_id
-
-    payload_type = str(payload.get("type", "")).lower()
-    if "tool" in payload_type:
-        return None, current_message_id
-
-    text = _extract_text_content(payload.get("content"))
-    if not text and isinstance(payload.get("kwargs"), Mapping):
-        text = _extract_text_content(payload["kwargs"].get("content"))
-    if not text:
-        return None, current_message_id
-
-    message_id = _extract_stream_message_id(payload, metadata) or current_message_id or "__default__"
-    buffers[message_id] = _merge_stream_text(buffers.get(message_id, ""), text)
-    return buffers[message_id], message_id
-
-
-def _extract_artifacts(result: dict | list) -> list[str]:
-    """Extract artifact paths from the last AI response cycle only.
-
-    Instead of reading the full accumulated ``artifacts`` state (which contains
-    all artifacts ever produced in the thread), this inspects the messages after
-    the last human message and collects file paths from ``present_files`` tool
-    calls.  This ensures only newly-produced artifacts are returned.
-    """
-    if isinstance(result, list):
-        messages = result
-    elif isinstance(result, dict):
-        messages = result.get("messages", [])
-    else:
-        return []
-
-    artifacts: list[str] = []
-    for msg in reversed(messages):
-        if not isinstance(msg, dict):
-            continue
-        # Stop at the last human message — anything before it is a previous turn
-        if msg.get("type") == "human":
-            break
-        # Look for AI messages with present_files tool calls
-        if msg.get("type") == "ai":
-            for tc in msg.get("tool_calls", []):
-                if isinstance(tc, dict) and tc.get("name") == "present_files":
-                    args = tc.get("args", {})
-                    paths = args.get("filepaths", [])
-                    if isinstance(paths, list):
-                        artifacts.extend(p for p in paths if isinstance(p, str))
-    return artifacts
-
-
-def _format_artifact_text(artifacts: list[str]) -> str:
-    """Format artifact paths into a human-readable text block listing filenames."""
-    import posixpath
-
-    filenames = [posixpath.basename(p) for p in artifacts]
-    if len(filenames) == 1:
-        return f"Created File: 📎 {filenames[0]}"
-    return "Created Files: 📎 " + "、".join(filenames)
-
-
-_OUTPUTS_VIRTUAL_PREFIX = "/mnt/user-data/outputs/"
-
-
-def _resolve_attachments(thread_id: str, artifacts: list[str]) -> list[ResolvedAttachment]:
-    """Resolve virtual artifact paths to host filesystem paths with metadata.
-
-    Only paths under ``/mnt/user-data/outputs/`` are accepted; any other
-    virtual path is rejected with a warning to prevent exfiltrating uploads
-    or workspace files via IM channels.
-
-    Skips artifacts that cannot be resolved (missing files, invalid paths)
-    and logs warnings for them.
-    """
-    from deerflow.config.paths import get_paths
-
-    attachments: list[ResolvedAttachment] = []
-    paths = get_paths()
-    outputs_dir = paths.sandbox_outputs_dir(thread_id).resolve()
-    for virtual_path in artifacts:
-        # Security: only allow files from the agent outputs directory
-        if not virtual_path.startswith(_OUTPUTS_VIRTUAL_PREFIX):
-            logger.warning("[Manager] rejected non-outputs artifact path: %s", virtual_path)
-            continue
-        try:
-            actual = paths.resolve_virtual_path(thread_id, virtual_path)
-            # Verify the resolved path is actually under the outputs directory
-            # (guards against path-traversal even after prefix check)
-            try:
-                actual.resolve().relative_to(outputs_dir)
-            except ValueError:
-                logger.warning("[Manager] artifact path escapes outputs dir: %s -> %s", virtual_path, actual)
-                continue
-            if not actual.is_file():
-                logger.warning("[Manager] artifact not found on disk: %s -> %s", virtual_path, actual)
-                continue
-            mime, _ = mimetypes.guess_type(str(actual))
-            mime = mime or "application/octet-stream"
-            attachments.append(
-                ResolvedAttachment(
-                    virtual_path=virtual_path,
-                    actual_path=actual,
-                    filename=actual.name,
-                    mime_type=mime,
-                    size=actual.stat().st_size,
-                    is_image=mime.startswith("image/"),
-                )
-            )
-        except (ValueError, OSError) as exc:
-            logger.warning("[Manager] failed to resolve artifact %s: %s", virtual_path, exc)
-    return attachments
-
-
-def _prepare_artifact_delivery(
-    thread_id: str,
-    response_text: str,
-    artifacts: list[str],
-) -> tuple[str, list[ResolvedAttachment]]:
-    """Resolve attachments and append filename fallbacks to the text response."""
-    attachments: list[ResolvedAttachment] = []
-    if not artifacts:
-        return response_text, attachments
-
-    attachments = _resolve_attachments(thread_id, artifacts)
-    resolved_virtuals = {attachment.virtual_path for attachment in attachments}
-    unresolved = [path for path in artifacts if path not in resolved_virtuals]
-
-    if unresolved:
-        artifact_text = _format_artifact_text(unresolved)
-        response_text = (response_text + "\n\n" + artifact_text) if response_text else artifact_text
-
-    # Always include resolved attachment filenames as a text fallback so files
-    # remain discoverable even when the upload is skipped or fails.
-    if attachments:
-        resolved_text = _format_artifact_text([attachment.virtual_path for attachment in attachments])
-        response_text = (response_text + "\n\n" + resolved_text) if response_text else resolved_text
-
-    return response_text, attachments
-
-
-async def _ingest_inbound_files(thread_id: str, msg: InboundMessage) -> list[dict[str, Any]]:
-    if not msg.files:
-        return []
-
-    from deerflow.uploads.manager import claim_unique_filename, ensure_uploads_dir, normalize_filename
-
-    uploads_dir = ensure_uploads_dir(thread_id)
-    seen_names = {entry.name for entry in uploads_dir.iterdir() if entry.is_file()}
-
-    created: list[dict[str, Any]] = []
-    file_reader = INBOUND_FILE_READERS.get(msg.channel_name, _read_http_inbound_file)
-    async with httpx.AsyncClient(timeout=httpx.Timeout(20.0)) as client:
-        for idx, f in enumerate(msg.files):
-            if not isinstance(f, dict):
-                continue
-
-            ftype = f.get("type") if isinstance(f.get("type"), str) else "file"
-            filename = f.get("filename") if isinstance(f.get("filename"), str) else ""
-
-            try:
-                data = await file_reader(f, client)
-            except Exception:
-                logger.exception(
-                    "[Manager] failed to read inbound file: channel=%s, file=%s",
-                    msg.channel_name,
-                    f.get("url") or filename or idx,
-                )
-                continue
-
-            if data is None:
-                logger.warning(
-                    "[Manager] inbound file reader returned no data: channel=%s, file=%s",
-                    msg.channel_name,
-                    f.get("url") or filename or idx,
-                )
-                continue
-
-            if not filename:
-                ext = ".bin"
-                if ftype == "image":
-                    ext = ".png"
-                filename = f"{msg.thread_ts or 'msg'}_{idx}{ext}"
-
-            try:
-                safe_name = claim_unique_filename(normalize_filename(filename), seen_names)
-            except ValueError:
-                logger.warning(
-                    "[Manager] skipping inbound file with unsafe filename: channel=%s, file=%r",
-                    msg.channel_name,
-                    filename,
-                )
-                continue
-
-            dest = uploads_dir / safe_name
-            try:
-                dest.write_bytes(data)
-            except Exception:
-                logger.exception("[Manager] failed to write inbound file: %s", dest)
-                continue
-
-            created.append(
-                {
-                    "filename": safe_name,
-                    "size": len(data),
-                    "path": f"/mnt/user-data/uploads/{safe_name}",
-                    "is_image": ftype == "image",
-                }
-            )
-
-    return created
-
-
-def _format_uploaded_files_block(files: list[dict[str, Any]]) -> str:
-    lines = [
-        "<uploaded_files>",
-        "The following files were uploaded in this message:",
-        "",
-    ]
-    if not files:
-        lines.append("(empty)")
-    else:
-        for f in files:
-            filename = f.get("filename", "")
-            size = int(f.get("size") or 0)
-            size_kb = size / 1024 if size else 0
-            size_str = f"{size_kb:.1f} KB" if size_kb < 1024 else f"{size_kb / 1024:.1f} MB"
-            path = f.get("path", "")
-            is_image = bool(f.get("is_image"))
-            file_kind = "image" if is_image else "file"
-            lines.append(f"- {filename} ({size_str})")
-            lines.append(f"  Type: {file_kind}")
-            lines.append(f"  Path: {path}")
-            lines.append("")
-    lines.append("Use `read_file` for text-based files and documents.")
-    lines.append("Use `view_image` for image files (jpg, jpeg, png, webp) so the model can inspect the image content.")
-    lines.append("</uploaded_files>")
-    return "\n".join(lines)
-
-
-class ChannelManager:
-    """Core dispatcher that bridges IM channels to the DeerFlow agent.
-
-    It reads from the MessageBus inbound queue, creates/reuses threads on
-    the LangGraph Server, sends messages via ``runs.wait``, and publishes
-    outbound responses back through the bus.
-    """
-
-    def __init__(
-        self,
-        bus: MessageBus,
-        store: ChannelStore,
-        *,
-        max_concurrency: int = 5,
-        langgraph_url: str = DEFAULT_LANGGRAPH_URL,
-        gateway_url: str = DEFAULT_GATEWAY_URL,
-        assistant_id: str = DEFAULT_ASSISTANT_ID,
-        default_session: dict[str, Any] | None = None,
-        channel_sessions: dict[str, Any] | None = None,
-    ) -> None:
-        self.bus = bus
-        self.store = store
-        self._max_concurrency = max_concurrency
-        self._langgraph_url = langgraph_url
-        self._gateway_url = gateway_url
-        self._assistant_id = assistant_id
-        self._default_session = _as_dict(default_session)
-        self._channel_sessions = dict(channel_sessions or {})
-        self._client = None  # lazy init — langgraph_sdk async client
-        self._semaphore: asyncio.Semaphore | None = None
-        self._running = False
-        self._task: asyncio.Task | None = None
-
-    @staticmethod
-    def _channel_supports_streaming(channel_name: str) -> bool:
-        return CHANNEL_CAPABILITIES.get(channel_name, {}).get("supports_streaming", False)
-
-    def _resolve_session_layer(self, msg: InboundMessage) -> tuple[dict[str, Any], dict[str, Any]]:
-        channel_layer = _as_dict(self._channel_sessions.get(msg.channel_name))
-        users_layer = _as_dict(channel_layer.get("users"))
-        user_layer = _as_dict(users_layer.get(msg.user_id))
-        return channel_layer, user_layer
-
-    def _resolve_run_params(self, msg: InboundMessage, thread_id: str) -> tuple[str, dict[str, Any], dict[str, Any]]:
-        channel_layer, user_layer = self._resolve_session_layer(msg)
-
-        assistant_id = user_layer.get("assistant_id") or channel_layer.get("assistant_id") or self._default_session.get("assistant_id") or self._assistant_id
-        if not isinstance(assistant_id, str) or not assistant_id.strip():
-            assistant_id = self._assistant_id
-
-        run_config = _merge_dicts(
-            DEFAULT_RUN_CONFIG,
-            self._default_session.get("config"),
-            channel_layer.get("config"),
-            user_layer.get("config"),
-        )
-
-        run_context = _merge_dicts(
-            DEFAULT_RUN_CONTEXT,
-            self._default_session.get("context"),
-            channel_layer.get("context"),
-            user_layer.get("context"),
-            {"thread_id": thread_id},
-        )
-
-        # Custom agents are implemented as lead_agent + agent_name context.
-        # Keep backward compatibility for channel configs that set
-        # assistant_id: <custom-agent-name> by routing through lead_agent.
-        if assistant_id != DEFAULT_ASSISTANT_ID:
-            run_context.setdefault("agent_name", _normalize_custom_agent_name(assistant_id))
-            assistant_id = DEFAULT_ASSISTANT_ID
-
-        return assistant_id, run_config, run_context
-
-    # -- LangGraph SDK client (lazy) ----------------------------------------
-
-    def _get_client(self):
-        """Return the ``langgraph_sdk`` async client, creating it on first use."""
-        if self._client is None:
-            from langgraph_sdk import get_client
-
-            self._client = get_client(url=self._langgraph_url)
-        return self._client
-
-    # -- lifecycle ---------------------------------------------------------
-
-    async def start(self) -> None:
-        """Start the dispatch loop."""
-        if self._running:
-            return
-        self._running = True
-        self._semaphore = asyncio.Semaphore(self._max_concurrency)
-        self._task = asyncio.create_task(self._dispatch_loop())
-        logger.info("ChannelManager started (max_concurrency=%d)", self._max_concurrency)
-
-    async def stop(self) -> None:
-        """Stop the dispatch loop."""
-        self._running = False
-        if self._task:
-            self._task.cancel()
-            try:
-                await self._task
-            except asyncio.CancelledError:
-                pass
-            self._task = None
-        logger.info("ChannelManager stopped")
-
-    # -- dispatch loop -----------------------------------------------------
-
-    async def _dispatch_loop(self) -> None:
-        logger.info("[Manager] dispatch loop started, waiting for inbound messages")
-        while self._running:
-            try:
-                msg = await asyncio.wait_for(self.bus.get_inbound(), timeout=1.0)
-            except TimeoutError:
-                continue
-            except asyncio.CancelledError:
-                break
-
-            logger.info(
-                "[Manager] received inbound: channel=%s, chat_id=%s, type=%s, text=%r",
-                msg.channel_name,
-                msg.chat_id,
-                msg.msg_type.value,
-                msg.text[:100] if msg.text else "",
-            )
-            task = asyncio.create_task(self._handle_message(msg))
-            task.add_done_callback(self._log_task_error)
-
-    @staticmethod
-    def _log_task_error(task: asyncio.Task) -> None:
-        """Surface unhandled exceptions from background tasks."""
-        if task.cancelled():
-            return
-        exc = task.exception()
-        if exc:
-            logger.error("[Manager] unhandled error in message task: %s", exc, exc_info=exc)
-
-    async def _handle_message(self, msg: InboundMessage) -> None:
-        async with self._semaphore:
-            try:
-                if msg.msg_type == InboundMessageType.COMMAND:
-                    await self._handle_command(msg)
-                else:
-                    await self._handle_chat(msg)
-            except InvalidChannelSessionConfigError as exc:
-                logger.warning(
-                    "Invalid channel session config for %s (chat=%s): %s",
-                    msg.channel_name,
-                    msg.chat_id,
-                    exc,
-                )
-                await self._send_error(msg, str(exc))
-            except Exception:
-                logger.exception(
-                    "Error handling message from %s (chat=%s)",
-                    msg.channel_name,
-                    msg.chat_id,
-                )
-                await self._send_error(msg, "An internal error occurred. Please try again.")
-
-    # -- chat handling -----------------------------------------------------
-
-    async def _create_thread(self, client, msg: InboundMessage) -> str:
-        """Create a new thread on the LangGraph Server and store the mapping."""
-        thread = await client.threads.create()
-        thread_id = thread["thread_id"]
-        self.store.set_thread_id(
-            msg.channel_name,
-            msg.chat_id,
-            thread_id,
-            topic_id=msg.topic_id,
-            user_id=msg.user_id,
-        )
-        logger.info("[Manager] new thread created on LangGraph Server: thread_id=%s for chat_id=%s topic_id=%s", thread_id, msg.chat_id, msg.topic_id)
-        return thread_id
-
-    async def _handle_chat(self, msg: InboundMessage, extra_context: dict[str, Any] | None = None) -> None:
-        client = self._get_client()
-
-        # Look up existing DeerFlow thread.
-        # topic_id may be None (e.g. Telegram private chats) — the store
-        # handles this by using the "channel:chat_id" key without a topic suffix.
-        thread_id = self.store.get_thread_id(msg.channel_name, msg.chat_id, topic_id=msg.topic_id)
-        if thread_id:
-            logger.info("[Manager] reusing thread: thread_id=%s for topic_id=%s", thread_id, msg.topic_id)
-
-        # No existing thread found — create a new one
-        if thread_id is None:
-            thread_id = await self._create_thread(client, msg)
-
-        assistant_id, run_config, run_context = self._resolve_run_params(msg, thread_id)
-
-        # If the inbound message contains file attachments, let the channel
-        # materialize (download) them and update msg.text to include sandbox file paths.
-        # This enables downstream models to access user-uploaded files by path.
-        # Channels that do not support file download will simply return the original message.
-        if msg.files:
-            from .service import get_channel_service
-
-            service = get_channel_service()
-            channel = service.get_channel(msg.channel_name) if service else None
-            logger.info("[Manager] preparing receive file context for %d attachments", len(msg.files))
-            msg = await channel.receive_file(msg, thread_id) if channel else msg
-        if extra_context:
-            run_context.update(extra_context)
-
-        uploaded = await _ingest_inbound_files(thread_id, msg)
-        if uploaded:
-            msg.text = f"{_format_uploaded_files_block(uploaded)}\n\n{msg.text}".strip()
-
-        if self._channel_supports_streaming(msg.channel_name):
-            await self._handle_streaming_chat(
-                client,
-                msg,
-                thread_id,
-                assistant_id,
-                run_config,
-                run_context,
-            )
-            return
-
-        logger.info("[Manager] invoking runs.wait(thread_id=%s, text=%r)", thread_id, msg.text[:100])
-        result = await client.runs.wait(
-            thread_id,
-            assistant_id,
-            input={"messages": [{"role": "human", "content": msg.text}]},
-            config=run_config,
-            context=run_context,
-        )
-
-        response_text = _extract_response_text(result)
-        artifacts = _extract_artifacts(result)
-
-        logger.info(
-            "[Manager] agent response received: thread_id=%s, response_len=%d, artifacts=%d",
-            thread_id,
-            len(response_text) if response_text else 0,
-            len(artifacts),
-        )
-
-        response_text, attachments = _prepare_artifact_delivery(thread_id, response_text, artifacts)
-
-        if not response_text:
-            if attachments:
-                response_text = _format_artifact_text([a.virtual_path for a in attachments])
-            else:
-                response_text = "(No response from agent)"
-
-        outbound = OutboundMessage(
-            channel_name=msg.channel_name,
-            chat_id=msg.chat_id,
-            thread_id=thread_id,
-            text=response_text,
-            artifacts=artifacts,
-            attachments=attachments,
-            thread_ts=msg.thread_ts,
-        )
-        logger.info("[Manager] publishing outbound message to bus: channel=%s, chat_id=%s", msg.channel_name, msg.chat_id)
-        await self.bus.publish_outbound(outbound)
-
-    async def _handle_streaming_chat(
-        self,
-        client,
-        msg: InboundMessage,
-        thread_id: str,
-        assistant_id: str,
-        run_config: dict[str, Any],
-        run_context: dict[str, Any],
-    ) -> None:
-        logger.info("[Manager] invoking runs.stream(thread_id=%s, text=%r)", thread_id, msg.text[:100])
-
-        last_values: dict[str, Any] | list | None = None
-        streamed_buffers: dict[str, str] = {}
-        current_message_id: str | None = None
-        latest_text = ""
-        last_published_text = ""
-        last_publish_at = 0.0
-        stream_error: BaseException | None = None
-
-        try:
-            async for chunk in client.runs.stream(
-                thread_id,
-                assistant_id,
-                input={"messages": [{"role": "human", "content": msg.text}]},
-                config=run_config,
-                context=run_context,
-                stream_mode=["messages-tuple", "values"],
-                multitask_strategy="reject",
-            ):
-                event = getattr(chunk, "event", "")
-                data = getattr(chunk, "data", None)
-
-                if event == "messages-tuple":
-                    accumulated_text, current_message_id = _accumulate_stream_text(streamed_buffers, current_message_id, data)
-                    if accumulated_text:
-                        latest_text = accumulated_text
-                elif event == "values" and isinstance(data, (dict, list)):
-                    last_values = data
-                    snapshot_text = _extract_response_text(data)
-                    if snapshot_text:
-                        latest_text = snapshot_text
-
-                if not latest_text or latest_text == last_published_text:
-                    continue
-
-                now = time.monotonic()
-                if last_published_text and now - last_publish_at < STREAM_UPDATE_MIN_INTERVAL_SECONDS:
-                    continue
-
-                await self.bus.publish_outbound(
-                    OutboundMessage(
-                        channel_name=msg.channel_name,
-                        chat_id=msg.chat_id,
-                        thread_id=thread_id,
-                        text=latest_text,
-                        is_final=False,
-                        thread_ts=msg.thread_ts,
-                    )
-                )
-                last_published_text = latest_text
-                last_publish_at = now
-        except Exception as exc:
-            stream_error = exc
-            if _is_thread_busy_error(exc):
-                logger.warning("[Manager] thread busy (concurrent run rejected): thread_id=%s", thread_id)
-            else:
-                logger.exception("[Manager] streaming error: thread_id=%s", thread_id)
-        finally:
-            result = last_values if last_values is not None else {"messages": [{"type": "ai", "content": latest_text}]}
-            response_text = _extract_response_text(result)
-            artifacts = _extract_artifacts(result)
-            response_text, attachments = _prepare_artifact_delivery(thread_id, response_text, artifacts)
-
-            if not response_text:
-                if attachments:
-                    response_text = _format_artifact_text([attachment.virtual_path for attachment in attachments])
-                elif stream_error:
-                    if _is_thread_busy_error(stream_error):
-                        response_text = THREAD_BUSY_MESSAGE
-                    else:
-                        response_text = "An error occurred while processing your request. Please try again."
-                else:
-                    response_text = latest_text or "(No response from agent)"
-
-            logger.info(
-                "[Manager] streaming response completed: thread_id=%s, response_len=%d, artifacts=%d, error=%s",
-                thread_id,
-                len(response_text),
-                len(artifacts),
-                stream_error,
-            )
-            await self.bus.publish_outbound(
-                OutboundMessage(
-                    channel_name=msg.channel_name,
-                    chat_id=msg.chat_id,
-                    thread_id=thread_id,
-                    text=response_text,
-                    artifacts=artifacts,
-                    attachments=attachments,
-                    is_final=True,
-                    thread_ts=msg.thread_ts,
-                )
-            )
-
-    # -- command handling --------------------------------------------------
-
-    async def _handle_command(self, msg: InboundMessage) -> None:
-        text = msg.text.strip()
-        parts = text.split(maxsplit=1)
-        command = parts[0].lower().lstrip("/")
-
-        if command == "bootstrap":
-            from dataclasses import replace as _dc_replace
-
-            chat_text = parts[1] if len(parts) > 1 else "Initialize workspace"
-            chat_msg = _dc_replace(msg, text=chat_text, msg_type=InboundMessageType.CHAT)
-            await self._handle_chat(chat_msg, extra_context={"is_bootstrap": True})
-            return
-
-        if command == "new":
-            # Create a new thread on the LangGraph Server
-            client = self._get_client()
-            thread = await client.threads.create()
-            new_thread_id = thread["thread_id"]
-            self.store.set_thread_id(
-                msg.channel_name,
-                msg.chat_id,
-                new_thread_id,
-                topic_id=msg.topic_id,
-                user_id=msg.user_id,
-            )
-            reply = "New conversation started."
-        elif command == "status":
-            thread_id = self.store.get_thread_id(msg.channel_name, msg.chat_id, topic_id=msg.topic_id)
-            reply = f"Active thread: {thread_id}" if thread_id else "No active conversation."
-        elif command == "models":
-            reply = await self._fetch_gateway("/api/models", "models")
-        elif command == "memory":
-            reply = await self._fetch_gateway("/api/memory", "memory")
-        elif command == "help":
-            reply = (
-                "Available commands:\n"
-                "/bootstrap — Start a bootstrap session (enables agent setup)\n"
-                "/new — Start a new conversation\n"
-                "/status — Show current thread info\n"
-                "/models — List available models\n"
-                "/memory — Show memory status\n"
-                "/help — Show this help"
-            )
-        else:
-            available = " | ".join(sorted(KNOWN_CHANNEL_COMMANDS))
-            reply = f"Unknown command: /{command}. Available commands: {available}"
-
-        outbound = OutboundMessage(
-            channel_name=msg.channel_name,
-            chat_id=msg.chat_id,
-            thread_id=self.store.get_thread_id(msg.channel_name, msg.chat_id) or "",
-            text=reply,
-            thread_ts=msg.thread_ts,
-        )
-        await self.bus.publish_outbound(outbound)
-
-    async def _fetch_gateway(self, path: str, kind: str) -> str:
-        """Fetch data from the Gateway API for command responses."""
-        import httpx
-
-        try:
-            async with httpx.AsyncClient() as http:
-                resp = await http.get(f"{self._gateway_url}{path}", timeout=10)
-                resp.raise_for_status()
-                data = resp.json()
-        except Exception:
-            logger.exception("Failed to fetch %s from gateway", kind)
-            return f"Failed to fetch {kind} information."
-
-        if kind == "models":
-            names = [m["name"] for m in data.get("models", [])]
-            return ("Available models:\n" + "\n".join(f"• {n}" for n in names)) if names else "No models configured."
-        elif kind == "memory":
-            facts = data.get("facts", [])
-            return f"Memory contains {len(facts)} fact(s)."
-        return str(data)
-
-    # -- error helper ------------------------------------------------------
-
-    async def _send_error(self, msg: InboundMessage, error_text: str) -> None:
-        outbound = OutboundMessage(
-            channel_name=msg.channel_name,
-            chat_id=msg.chat_id,
-            thread_id=self.store.get_thread_id(msg.channel_name, msg.chat_id) or "",
-            text=error_text,
-            thread_ts=msg.thread_ts,
-        )
-        await self.bus.publish_outbound(outbound)

backend/app/channels/message_bus.py

@@ -1,173 +0,0 @@
-"""MessageBus — async pub/sub hub that decouples channels from the agent dispatcher."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import time
-from collections.abc import Callable, Coroutine
-from dataclasses import dataclass, field
-from enum import StrEnum
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-# ---------------------------------------------------------------------------
-# Message types
-# ---------------------------------------------------------------------------
-
-
-class InboundMessageType(StrEnum):
-    """Types of messages arriving from IM channels."""
-
-    CHAT = "chat"
-    COMMAND = "command"
-
-
-@dataclass
-class InboundMessage:
-    """A message arriving from an IM channel toward the agent dispatcher.
-
-    Attributes:
-        channel_name: Name of the source channel (e.g. "feishu", "slack").
-        chat_id: Platform-specific chat/conversation identifier.
-        user_id: Platform-specific user identifier.
-        text: The message text.
-        msg_type: Whether this is a regular chat message or a command.
-        thread_ts: Optional platform thread identifier (for threaded replies).
-        topic_id: Conversation topic identifier used to map to a DeerFlow thread.
-            Messages sharing the same ``topic_id`` within a ``chat_id`` will
-            reuse the same DeerFlow thread.  When ``None``, each message
-            creates a new thread (one-shot Q&A).
-        files: Optional list of file attachments (platform-specific dicts).
-        metadata: Arbitrary extra data from the channel.
-        created_at: Unix timestamp when the message was created.
-    """
-
-    channel_name: str
-    chat_id: str
-    user_id: str
-    text: str
-    msg_type: InboundMessageType = InboundMessageType.CHAT
-    thread_ts: str | None = None
-    topic_id: str | None = None
-    files: list[dict[str, Any]] = field(default_factory=list)
-    metadata: dict[str, Any] = field(default_factory=dict)
-    created_at: float = field(default_factory=time.time)
-
-
-@dataclass
-class ResolvedAttachment:
-    """A file attachment resolved to a host filesystem path, ready for upload.
-
-    Attributes:
-        virtual_path: Original virtual path (e.g. /mnt/user-data/outputs/report.pdf).
-        actual_path: Resolved host filesystem path.
-        filename: Basename of the file.
-        mime_type: MIME type (e.g. "application/pdf").
-        size: File size in bytes.
-        is_image: True for image/* MIME types (platforms may handle images differently).
-    """
-
-    virtual_path: str
-    actual_path: Path
-    filename: str
-    mime_type: str
-    size: int
-    is_image: bool
-
-
-@dataclass
-class OutboundMessage:
-    """A message from the agent dispatcher back to a channel.
-
-    Attributes:
-        channel_name: Target channel name (used for routing).
-        chat_id: Target chat/conversation identifier.
-        thread_id: DeerFlow thread ID that produced this response.
-        text: The response text.
-        artifacts: List of artifact paths produced by the agent.
-        is_final: Whether this is the final message in the response stream.
-        thread_ts: Optional platform thread identifier for threaded replies.
-        metadata: Arbitrary extra data.
-        created_at: Unix timestamp.
-    """
-
-    channel_name: str
-    chat_id: str
-    thread_id: str
-    text: str
-    artifacts: list[str] = field(default_factory=list)
-    attachments: list[ResolvedAttachment] = field(default_factory=list)
-    is_final: bool = True
-    thread_ts: str | None = None
-    metadata: dict[str, Any] = field(default_factory=dict)
-    created_at: float = field(default_factory=time.time)
-
-
-# ---------------------------------------------------------------------------
-# MessageBus
-# ---------------------------------------------------------------------------
-
-OutboundCallback = Callable[[OutboundMessage], Coroutine[Any, Any, None]]
-
-
-class MessageBus:
-    """Async pub/sub hub connecting channels and the agent dispatcher.
-
-    Channels publish inbound messages; the dispatcher consumes them.
-    The dispatcher publishes outbound messages; channels receive them
-    via registered callbacks.
-    """
-
-    def __init__(self) -> None:
-        self._inbound_queue: asyncio.Queue[InboundMessage] = asyncio.Queue()
-        self._outbound_listeners: list[OutboundCallback] = []
-
-    # -- inbound -----------------------------------------------------------
-
-    async def publish_inbound(self, msg: InboundMessage) -> None:
-        """Enqueue an inbound message from a channel."""
-        await self._inbound_queue.put(msg)
-        logger.info(
-            "[Bus] inbound enqueued: channel=%s, chat_id=%s, type=%s, queue_size=%d",
-            msg.channel_name,
-            msg.chat_id,
-            msg.msg_type.value,
-            self._inbound_queue.qsize(),
-        )
-
-    async def get_inbound(self) -> InboundMessage:
-        """Block until the next inbound message is available."""
-        return await self._inbound_queue.get()
-
-    @property
-    def inbound_queue(self) -> asyncio.Queue[InboundMessage]:
-        return self._inbound_queue
-
-    # -- outbound ----------------------------------------------------------
-
-    def subscribe_outbound(self, callback: OutboundCallback) -> None:
-        """Register an async callback for outbound messages."""
-        self._outbound_listeners.append(callback)
-
-    def unsubscribe_outbound(self, callback: OutboundCallback) -> None:
-        """Remove a previously registered outbound callback."""
-        self._outbound_listeners = [cb for cb in self._outbound_listeners if cb is not callback]
-
-    async def publish_outbound(self, msg: OutboundMessage) -> None:
-        """Dispatch an outbound message to all registered listeners."""
-        logger.info(
-            "[Bus] outbound dispatching: channel=%s, chat_id=%s, listeners=%d, text_len=%d",
-            msg.channel_name,
-            msg.chat_id,
-            len(self._outbound_listeners),
-            len(msg.text),
-        )
-        for callback in self._outbound_listeners:
-            try:
-                await callback(msg)
-            except Exception:
-                logger.exception("Error in outbound callback for channel=%s", msg.channel_name)

backend/app/channels/service.py

@@ -1,198 +0,0 @@
-"""ChannelService — manages the lifecycle of all IM channels."""
-
-from __future__ import annotations
-
-import logging
-import os
-from typing import Any
-
-from app.channels.base import Channel
-from app.channels.manager import DEFAULT_GATEWAY_URL, DEFAULT_LANGGRAPH_URL, ChannelManager
-from app.channels.message_bus import MessageBus
-from app.channels.store import ChannelStore
-
-logger = logging.getLogger(__name__)
-
-# Channel name → import path for lazy loading
-_CHANNEL_REGISTRY: dict[str, str] = {
-    "feishu": "app.channels.feishu:FeishuChannel",
-    "slack": "app.channels.slack:SlackChannel",
-    "telegram": "app.channels.telegram:TelegramChannel",
-    "wecom": "app.channels.wecom:WeComChannel",
-}
-
-_CHANNELS_LANGGRAPH_URL_ENV = "DEER_FLOW_CHANNELS_LANGGRAPH_URL"
-_CHANNELS_GATEWAY_URL_ENV = "DEER_FLOW_CHANNELS_GATEWAY_URL"
-
-
-def _resolve_service_url(config: dict[str, Any], config_key: str, env_key: str, default: str) -> str:
-    value = config.pop(config_key, None)
-    if isinstance(value, str) and value.strip():
-        return value
-    env_value = os.getenv(env_key, "").strip()
-    if env_value:
-        return env_value
-    return default
-
-
-class ChannelService:
-    """Manages the lifecycle of all configured IM channels.
-
-    Reads configuration from ``config.yaml`` under the ``channels`` key,
-    instantiates enabled channels, and starts the ChannelManager dispatcher.
-    """
-
-    def __init__(self, channels_config: dict[str, Any] | None = None) -> None:
-        self.bus = MessageBus()
-        self.store = ChannelStore()
-        config = dict(channels_config or {})
-        langgraph_url = _resolve_service_url(config, "langgraph_url", _CHANNELS_LANGGRAPH_URL_ENV, DEFAULT_LANGGRAPH_URL)
-        gateway_url = _resolve_service_url(config, "gateway_url", _CHANNELS_GATEWAY_URL_ENV, DEFAULT_GATEWAY_URL)
-        default_session = config.pop("session", None)
-        channel_sessions = {name: channel_config.get("session") for name, channel_config in config.items() if isinstance(channel_config, dict)}
-        self.manager = ChannelManager(
-            bus=self.bus,
-            store=self.store,
-            langgraph_url=langgraph_url,
-            gateway_url=gateway_url,
-            default_session=default_session if isinstance(default_session, dict) else None,
-            channel_sessions=channel_sessions,
-        )
-        self._channels: dict[str, Any] = {}  # name -> Channel instance
-        self._config = config
-        self._running = False
-
-    @classmethod
-    def from_app_config(cls) -> ChannelService:
-        """Create a ChannelService from the application config."""
-        from deerflow.config.app_config import get_app_config
-
-        config = get_app_config()
-        channels_config = {}
-        # extra fields are allowed by AppConfig (extra="allow")
-        extra = config.model_extra or {}
-        if "channels" in extra:
-            channels_config = extra["channels"]
-        return cls(channels_config=channels_config)
-
-    async def start(self) -> None:
-        """Start the manager and all enabled channels."""
-        if self._running:
-            return
-
-        await self.manager.start()
-
-        for name, channel_config in self._config.items():
-            if not isinstance(channel_config, dict):
-                continue
-            if not channel_config.get("enabled", False):
-                logger.info("Channel %s is disabled, skipping", name)
-                continue
-
-            await self._start_channel(name, channel_config)
-
-        self._running = True
-        logger.info("ChannelService started with channels: %s", list(self._channels.keys()))
-
-    async def stop(self) -> None:
-        """Stop all channels and the manager."""
-        for name, channel in list(self._channels.items()):
-            try:
-                await channel.stop()
-                logger.info("Channel %s stopped", name)
-            except Exception:
-                logger.exception("Error stopping channel %s", name)
-        self._channels.clear()
-
-        await self.manager.stop()
-        self._running = False
-        logger.info("ChannelService stopped")
-
-    async def restart_channel(self, name: str) -> bool:
-        """Restart a specific channel. Returns True if successful."""
-        if name in self._channels:
-            try:
-                await self._channels[name].stop()
-            except Exception:
-                logger.exception("Error stopping channel %s for restart", name)
-            del self._channels[name]
-
-        config = self._config.get(name)
-        if not config or not isinstance(config, dict):
-            logger.warning("No config for channel %s", name)
-            return False
-
-        return await self._start_channel(name, config)
-
-    async def _start_channel(self, name: str, config: dict[str, Any]) -> bool:
-        """Instantiate and start a single channel."""
-        import_path = _CHANNEL_REGISTRY.get(name)
-        if not import_path:
-            logger.warning("Unknown channel type: %s", name)
-            return False
-
-        try:
-            from deerflow.reflection import resolve_class
-
-            channel_cls = resolve_class(import_path, base_class=None)
-        except Exception:
-            logger.exception("Failed to import channel class for %s", name)
-            return False
-
-        try:
-            channel = channel_cls(bus=self.bus, config=config)
-            await channel.start()
-            self._channels[name] = channel
-            logger.info("Channel %s started", name)
-            return True
-        except Exception:
-            logger.exception("Failed to start channel %s", name)
-            return False
-
-    def get_status(self) -> dict[str, Any]:
-        """Return status information for all channels."""
-        channels_status = {}
-        for name in _CHANNEL_REGISTRY:
-            config = self._config.get(name, {})
-            enabled = isinstance(config, dict) and config.get("enabled", False)
-            running = name in self._channels and self._channels[name].is_running
-            channels_status[name] = {
-                "enabled": enabled,
-                "running": running,
-            }
-        return {
-            "service_running": self._running,
-            "channels": channels_status,
-        }
-
-    def get_channel(self, name: str) -> Channel | None:
-        """Return a running channel instance by name when available."""
-        return self._channels.get(name)
-
-
-# -- singleton access -------------------------------------------------------
-
-_channel_service: ChannelService | None = None
-
-
-def get_channel_service() -> ChannelService | None:
-    """Get the singleton ChannelService instance (if started)."""
-    return _channel_service
-
-
-async def start_channel_service() -> ChannelService:
-    """Create and start the global ChannelService from app config."""
-    global _channel_service
-    if _channel_service is not None:
-        return _channel_service
-    _channel_service = ChannelService.from_app_config()
-    await _channel_service.start()
-    return _channel_service
-
-
-async def stop_channel_service() -> None:
-    """Stop the global ChannelService."""
-    global _channel_service
-    if _channel_service is not None:
-        await _channel_service.stop()
-        _channel_service = None

backend/app/channels/slack.py

@@ -1,246 +0,0 @@
-"""Slack channel — connects via Socket Mode (no public IP needed)."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Any
-
-from markdown_to_mrkdwn import SlackMarkdownConverter
-
-from app.channels.base import Channel
-from app.channels.message_bus import InboundMessageType, MessageBus, OutboundMessage, ResolvedAttachment
-
-logger = logging.getLogger(__name__)
-
-_slack_md_converter = SlackMarkdownConverter()
-
-
-class SlackChannel(Channel):
-    """Slack IM channel using Socket Mode (WebSocket, no public IP).
-
-    Configuration keys (in ``config.yaml`` under ``channels.slack``):
-        - ``bot_token``: Slack Bot User OAuth Token (xoxb-...).
-        - ``app_token``: Slack App-Level Token (xapp-...) for Socket Mode.
-        - ``allowed_users``: (optional) List of allowed Slack user IDs. Empty = allow all.
-    """
-
-    def __init__(self, bus: MessageBus, config: dict[str, Any]) -> None:
-        super().__init__(name="slack", bus=bus, config=config)
-        self._socket_client = None
-        self._web_client = None
-        self._loop: asyncio.AbstractEventLoop | None = None
-        self._allowed_users: set[str] = {str(user_id) for user_id in config.get("allowed_users", [])}
-
-    async def start(self) -> None:
-        if self._running:
-            return
-
-        try:
-            from slack_sdk import WebClient
-            from slack_sdk.socket_mode import SocketModeClient
-            from slack_sdk.socket_mode.response import SocketModeResponse
-        except ImportError:
-            logger.error("slack-sdk is not installed. Install it with: uv add slack-sdk")
-            return
-
-        self._SocketModeResponse = SocketModeResponse
-
-        bot_token = self.config.get("bot_token", "")
-        app_token = self.config.get("app_token", "")
-
-        if not bot_token or not app_token:
-            logger.error("Slack channel requires bot_token and app_token")
-            return
-
-        self._web_client = WebClient(token=bot_token)
-        self._socket_client = SocketModeClient(
-            app_token=app_token,
-            web_client=self._web_client,
-        )
-        self._loop = asyncio.get_event_loop()
-
-        self._socket_client.socket_mode_request_listeners.append(self._on_socket_event)
-
-        self._running = True
-        self.bus.subscribe_outbound(self._on_outbound)
-
-        # Start socket mode in background thread
-        asyncio.get_event_loop().run_in_executor(None, self._socket_client.connect)
-        logger.info("Slack channel started")
-
-    async def stop(self) -> None:
-        self._running = False
-        self.bus.unsubscribe_outbound(self._on_outbound)
-        if self._socket_client:
-            self._socket_client.close()
-            self._socket_client = None
-        logger.info("Slack channel stopped")
-
-    async def send(self, msg: OutboundMessage, *, _max_retries: int = 3) -> None:
-        if not self._web_client:
-            return
-
-        kwargs: dict[str, Any] = {
-            "channel": msg.chat_id,
-            "text": _slack_md_converter.convert(msg.text),
-        }
-        if msg.thread_ts:
-            kwargs["thread_ts"] = msg.thread_ts
-
-        last_exc: Exception | None = None
-        for attempt in range(_max_retries):
-            try:
-                await asyncio.to_thread(self._web_client.chat_postMessage, **kwargs)
-                # Add a completion reaction to the thread root
-                if msg.thread_ts:
-                    await asyncio.to_thread(
-                        self._add_reaction,
-                        msg.chat_id,
-                        msg.thread_ts,
-                        "white_check_mark",
-                    )
-                return
-            except Exception as exc:
-                last_exc = exc
-                if attempt < _max_retries - 1:
-                    delay = 2**attempt  # 1s, 2s
-                    logger.warning(
-                        "[Slack] send failed (attempt %d/%d), retrying in %ds: %s",
-                        attempt + 1,
-                        _max_retries,
-                        delay,
-                        exc,
-                    )
-                    await asyncio.sleep(delay)
-
-        logger.error("[Slack] send failed after %d attempts: %s", _max_retries, last_exc)
-        # Add failure reaction on error
-        if msg.thread_ts:
-            try:
-                await asyncio.to_thread(
-                    self._add_reaction,
-                    msg.chat_id,
-                    msg.thread_ts,
-                    "x",
-                )
-            except Exception:
-                pass
-        if last_exc is None:
-            raise RuntimeError("Slack send failed without an exception from any attempt")
-        raise last_exc
-
-    async def send_file(self, msg: OutboundMessage, attachment: ResolvedAttachment) -> bool:
-        if not self._web_client:
-            return False
-
-        try:
-            kwargs: dict[str, Any] = {
-                "channel": msg.chat_id,
-                "file": str(attachment.actual_path),
-                "filename": attachment.filename,
-                "title": attachment.filename,
-            }
-            if msg.thread_ts:
-                kwargs["thread_ts"] = msg.thread_ts
-
-            await asyncio.to_thread(self._web_client.files_upload_v2, **kwargs)
-            logger.info("[Slack] file uploaded: %s to channel=%s", attachment.filename, msg.chat_id)
-            return True
-        except Exception:
-            logger.exception("[Slack] failed to upload file: %s", attachment.filename)
-            return False
-
-    # -- internal ----------------------------------------------------------
-
-    def _add_reaction(self, channel_id: str, timestamp: str, emoji: str) -> None:
-        """Add an emoji reaction to a message (best-effort, non-blocking)."""
-        if not self._web_client:
-            return
-        try:
-            self._web_client.reactions_add(
-                channel=channel_id,
-                timestamp=timestamp,
-                name=emoji,
-            )
-        except Exception as exc:
-            if "already_reacted" not in str(exc):
-                logger.warning("[Slack] failed to add reaction %s: %s", emoji, exc)
-
-    def _send_running_reply(self, channel_id: str, thread_ts: str) -> None:
-        """Send a 'Working on it......' reply in the thread (called from SDK thread)."""
-        if not self._web_client:
-            return
-        try:
-            self._web_client.chat_postMessage(
-                channel=channel_id,
-                text=":hourglass_flowing_sand: Working on it...",
-                thread_ts=thread_ts,
-            )
-            logger.info("[Slack] 'Working on it...' reply sent in channel=%s, thread_ts=%s", channel_id, thread_ts)
-        except Exception:
-            logger.exception("[Slack] failed to send running reply in channel=%s", channel_id)
-
-    def _on_socket_event(self, client, req) -> None:
-        """Called by slack-sdk for each Socket Mode event."""
-        try:
-            # Acknowledge the event
-            response = self._SocketModeResponse(envelope_id=req.envelope_id)
-            client.send_socket_mode_response(response)
-
-            event_type = req.type
-            if event_type != "events_api":
-                return
-
-            event = req.payload.get("event", {})
-            etype = event.get("type", "")
-
-            # Handle message events (DM or @mention)
-            if etype in ("message", "app_mention"):
-                self._handle_message_event(event)
-
-        except Exception:
-            logger.exception("Error processing Slack event")
-
-    def _handle_message_event(self, event: dict) -> None:
-        # Ignore bot messages
-        if event.get("bot_id") or event.get("subtype"):
-            return
-
-        user_id = event.get("user", "")
-
-        # Check allowed users
-        if self._allowed_users and user_id not in self._allowed_users:
-            logger.debug("Ignoring message from non-allowed user: %s", user_id)
-            return
-
-        text = event.get("text", "").strip()
-        if not text:
-            return
-
-        channel_id = event.get("channel", "")
-        thread_ts = event.get("thread_ts") or event.get("ts", "")
-
-        if text.startswith("/"):
-            msg_type = InboundMessageType.COMMAND
-        else:
-            msg_type = InboundMessageType.CHAT
-
-        # topic_id: use thread_ts as the topic identifier.
-        # For threaded messages, thread_ts is the root message ts (shared topic).
-        # For non-threaded messages, thread_ts is the message's own ts (new topic).
-        inbound = self._make_inbound(
-            chat_id=channel_id,
-            user_id=user_id,
-            text=text,
-            msg_type=msg_type,
-            thread_ts=thread_ts,
-        )
-        inbound.topic_id = thread_ts
-
-        if self._loop and self._loop.is_running():
-            # Acknowledge with an eyes reaction
-            self._add_reaction(channel_id, event.get("ts", thread_ts), "eyes")
-            # Send "running" reply first (fire-and-forget from SDK thread)
-            self._send_running_reply(channel_id, thread_ts)
-            asyncio.run_coroutine_threadsafe(self.bus.publish_inbound(inbound), self._loop)

backend/app/channels/store.py

@@ -1,153 +0,0 @@
-"""ChannelStore — persists IM chat-to-DeerFlow thread mappings."""
-
-from __future__ import annotations
-
-import json
-import logging
-import tempfile
-import threading
-import time
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-class ChannelStore:
-    """JSON-file-backed store that maps IM conversations to DeerFlow threads.
-
-    Data layout (on disk)::
-
-        {
-            "<channel_name>:<chat_id>": {
-                "thread_id": "<uuid>",
-                "user_id": "<platform_user>",
-                "created_at": 1700000000.0,
-                "updated_at": 1700000000.0
-            },
-            ...
-        }
-
-    The store is intentionally simple — a single JSON file that is atomically
-    rewritten on every mutation. For production workloads with high concurrency,
-    this can be swapped for a proper database backend.
-    """
-
-    def __init__(self, path: str | Path | None = None) -> None:
-        if path is None:
-            from deerflow.config.paths import get_paths
-
-            path = Path(get_paths().base_dir) / "channels" / "store.json"
-        self._path = Path(path)
-        self._path.parent.mkdir(parents=True, exist_ok=True)
-        self._data: dict[str, dict[str, Any]] = self._load()
-        self._lock = threading.Lock()
-
-    # -- persistence -------------------------------------------------------
-
-    def _load(self) -> dict[str, dict[str, Any]]:
-        if self._path.exists():
-            try:
-                return json.loads(self._path.read_text(encoding="utf-8"))
-            except (json.JSONDecodeError, OSError):
-                logger.warning("Corrupt channel store at %s, starting fresh", self._path)
-        return {}
-
-    def _save(self) -> None:
-        fd = tempfile.NamedTemporaryFile(
-            mode="w",
-            dir=self._path.parent,
-            suffix=".tmp",
-            delete=False,
-        )
-        try:
-            json.dump(self._data, fd, indent=2)
-            fd.close()
-            Path(fd.name).replace(self._path)
-        except BaseException:
-            fd.close()
-            Path(fd.name).unlink(missing_ok=True)
-            raise
-
-    # -- key helpers -------------------------------------------------------
-
-    @staticmethod
-    def _key(channel_name: str, chat_id: str, topic_id: str | None = None) -> str:
-        if topic_id:
-            return f"{channel_name}:{chat_id}:{topic_id}"
-        return f"{channel_name}:{chat_id}"
-
-    # -- public API --------------------------------------------------------
-
-    def get_thread_id(self, channel_name: str, chat_id: str, topic_id: str | None = None) -> str | None:
-        """Look up the DeerFlow thread_id for a given IM conversation/topic."""
-        entry = self._data.get(self._key(channel_name, chat_id, topic_id))
-        return entry["thread_id"] if entry else None
-
-    def set_thread_id(
-        self,
-        channel_name: str,
-        chat_id: str,
-        thread_id: str,
-        *,
-        topic_id: str | None = None,
-        user_id: str = "",
-    ) -> None:
-        """Create or update the mapping for an IM conversation/topic."""
-        with self._lock:
-            key = self._key(channel_name, chat_id, topic_id)
-            now = time.time()
-            existing = self._data.get(key)
-            self._data[key] = {
-                "thread_id": thread_id,
-                "user_id": user_id,
-                "created_at": existing["created_at"] if existing else now,
-                "updated_at": now,
-            }
-            self._save()
-
-    def remove(self, channel_name: str, chat_id: str, topic_id: str | None = None) -> bool:
-        """Remove a mapping.
-
-        If ``topic_id`` is provided, only that specific conversation/topic mapping is removed.
-        If ``topic_id`` is omitted, all mappings whose key starts with
-        ``"<channel_name>:<chat_id>"`` (including topic-specific ones) are removed.
-
-        Returns True if at least one mapping was removed.
-        """
-        with self._lock:
-            # Remove a specific conversation/topic mapping.
-            if topic_id is not None:
-                key = self._key(channel_name, chat_id, topic_id)
-                if key in self._data:
-                    del self._data[key]
-                    self._save()
-                    return True
-                return False
-
-            # Remove all mappings for this channel/chat_id (base and any topic-specific keys).
-            prefix = self._key(channel_name, chat_id)
-            keys_to_delete = [k for k in self._data if k == prefix or k.startswith(prefix + ":")]
-            if not keys_to_delete:
-                return False
-
-            for k in keys_to_delete:
-                del self._data[k]
-            self._save()
-            return True
-
-    def list_entries(self, channel_name: str | None = None) -> list[dict[str, Any]]:
-        """List all stored mappings, optionally filtered by channel."""
-        results = []
-        for key, entry in self._data.items():
-            parts = key.split(":", 2)
-            ch = parts[0]
-            chat = parts[1] if len(parts) > 1 else ""
-            topic = parts[2] if len(parts) > 2 else None
-            if channel_name and ch != channel_name:
-                continue
-            item: dict[str, Any] = {"channel_name": ch, "chat_id": chat, **entry}
-            if topic is not None:
-                item["topic_id"] = topic
-            results.append(item)
-        return results

backend/app/channels/telegram.py

@@ -1,317 +0,0 @@
-"""Telegram channel — connects via long-polling (no public IP needed)."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import threading
-from typing import Any
-
-from app.channels.base import Channel
-from app.channels.message_bus import InboundMessage, InboundMessageType, MessageBus, OutboundMessage, ResolvedAttachment
-
-logger = logging.getLogger(__name__)
-
-
-class TelegramChannel(Channel):
-    """Telegram bot channel using long-polling.
-
-    Configuration keys (in ``config.yaml`` under ``channels.telegram``):
-        - ``bot_token``: Telegram Bot API token (from @BotFather).
-        - ``allowed_users``: (optional) List of allowed Telegram user IDs. Empty = allow all.
-    """
-
-    def __init__(self, bus: MessageBus, config: dict[str, Any]) -> None:
-        super().__init__(name="telegram", bus=bus, config=config)
-        self._application = None
-        self._thread: threading.Thread | None = None
-        self._tg_loop: asyncio.AbstractEventLoop | None = None
-        self._main_loop: asyncio.AbstractEventLoop | None = None
-        self._allowed_users: set[int] = set()
-        for uid in config.get("allowed_users", []):
-            try:
-                self._allowed_users.add(int(uid))
-            except (ValueError, TypeError):
-                pass
-        # chat_id -> last sent message_id for threaded replies
-        self._last_bot_message: dict[str, int] = {}
-
-    async def start(self) -> None:
-        if self._running:
-            return
-
-        try:
-            from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, filters
-        except ImportError:
-            logger.error("python-telegram-bot is not installed. Install it with: uv add python-telegram-bot")
-            return
-
-        bot_token = self.config.get("bot_token", "")
-        if not bot_token:
-            logger.error("Telegram channel requires bot_token")
-            return
-
-        self._main_loop = asyncio.get_event_loop()
-        self._running = True
-        self.bus.subscribe_outbound(self._on_outbound)
-
-        # Build the application
-        app = ApplicationBuilder().token(bot_token).build()
-
-        # Command handlers
-        app.add_handler(CommandHandler("start", self._cmd_start))
-        app.add_handler(CommandHandler("new", self._cmd_generic))
-        app.add_handler(CommandHandler("status", self._cmd_generic))
-        app.add_handler(CommandHandler("models", self._cmd_generic))
-        app.add_handler(CommandHandler("memory", self._cmd_generic))
-        app.add_handler(CommandHandler("help", self._cmd_generic))
-
-        # General message handler
-        app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self._on_text))
-
-        self._application = app
-
-        # Run polling in a dedicated thread with its own event loop
-        self._thread = threading.Thread(target=self._run_polling, daemon=True)
-        self._thread.start()
-        logger.info("Telegram channel started")
-
-    async def stop(self) -> None:
-        self._running = False
-        self.bus.unsubscribe_outbound(self._on_outbound)
-        if self._tg_loop and self._tg_loop.is_running():
-            self._tg_loop.call_soon_threadsafe(self._tg_loop.stop)
-        if self._thread:
-            self._thread.join(timeout=10)
-            self._thread = None
-        self._application = None
-        logger.info("Telegram channel stopped")
-
-    async def send(self, msg: OutboundMessage, *, _max_retries: int = 3) -> None:
-        if not self._application:
-            return
-
-        try:
-            chat_id = int(msg.chat_id)
-        except (ValueError, TypeError):
-            logger.error("Invalid Telegram chat_id: %s", msg.chat_id)
-            return
-
-        kwargs: dict[str, Any] = {"chat_id": chat_id, "text": msg.text}
-
-        # Reply to the last bot message in this chat for threading
-        reply_to = self._last_bot_message.get(msg.chat_id)
-        if reply_to:
-            kwargs["reply_to_message_id"] = reply_to
-
-        bot = self._application.bot
-        last_exc: Exception | None = None
-        for attempt in range(_max_retries):
-            try:
-                sent = await bot.send_message(**kwargs)
-                self._last_bot_message[msg.chat_id] = sent.message_id
-                return
-            except Exception as exc:
-                last_exc = exc
-                if attempt < _max_retries - 1:
-                    delay = 2**attempt  # 1s, 2s
-                    logger.warning(
-                        "[Telegram] send failed (attempt %d/%d), retrying in %ds: %s",
-                        attempt + 1,
-                        _max_retries,
-                        delay,
-                        exc,
-                    )
-                    await asyncio.sleep(delay)
-
-        logger.error("[Telegram] send failed after %d attempts: %s", _max_retries, last_exc)
-        if last_exc is None:
-            raise RuntimeError("Telegram send failed without an exception from any attempt")
-        raise last_exc
-
-    async def send_file(self, msg: OutboundMessage, attachment: ResolvedAttachment) -> bool:
-        if not self._application:
-            return False
-
-        try:
-            chat_id = int(msg.chat_id)
-        except (ValueError, TypeError):
-            logger.error("[Telegram] Invalid chat_id: %s", msg.chat_id)
-            return False
-
-        # Telegram limits: 10MB for photos, 50MB for documents
-        if attachment.size > 50 * 1024 * 1024:
-            logger.warning("[Telegram] file too large (%d bytes), skipping: %s", attachment.size, attachment.filename)
-            return False
-
-        bot = self._application.bot
-        reply_to = self._last_bot_message.get(msg.chat_id)
-
-        try:
-            if attachment.is_image and attachment.size <= 10 * 1024 * 1024:
-                with open(attachment.actual_path, "rb") as f:
-                    kwargs: dict[str, Any] = {"chat_id": chat_id, "photo": f}
-                    if reply_to:
-                        kwargs["reply_to_message_id"] = reply_to
-                    sent = await bot.send_photo(**kwargs)
-            else:
-                from telegram import InputFile
-
-                with open(attachment.actual_path, "rb") as f:
-                    input_file = InputFile(f, filename=attachment.filename)
-                    kwargs = {"chat_id": chat_id, "document": input_file}
-                    if reply_to:
-                        kwargs["reply_to_message_id"] = reply_to
-                    sent = await bot.send_document(**kwargs)
-
-            self._last_bot_message[msg.chat_id] = sent.message_id
-            logger.info("[Telegram] file sent: %s to chat=%s", attachment.filename, msg.chat_id)
-            return True
-        except Exception:
-            logger.exception("[Telegram] failed to send file: %s", attachment.filename)
-            return False
-
-    # -- helpers -----------------------------------------------------------
-
-    async def _send_running_reply(self, chat_id: str, reply_to_message_id: int) -> None:
-        """Send a 'Working on it...' reply to the user's message."""
-        if not self._application:
-            return
-        try:
-            bot = self._application.bot
-            await bot.send_message(
-                chat_id=int(chat_id),
-                text="Working on it...",
-                reply_to_message_id=reply_to_message_id,
-            )
-            logger.info("[Telegram] 'Working on it...' reply sent in chat=%s", chat_id)
-        except Exception:
-            logger.exception("[Telegram] failed to send running reply in chat=%s", chat_id)
-
-    # -- internal ----------------------------------------------------------
-    @staticmethod
-    def _log_future_error(fut, name: str, msg_id: str):
-        try:
-            exc = fut.exception()
-            if exc:
-                logger.error("[Telegram] %s failed for msg_id=%s: %s", name, msg_id, exc)
-        except Exception:
-            logger.exception("[Telegram] Failed to inspect future for %s (msg_id=%s)", name, msg_id)
-
-    def _run_polling(self) -> None:
-        """Run telegram polling in a dedicated thread."""
-        self._tg_loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self._tg_loop)
-        try:
-            # Cannot use run_polling() because it calls add_signal_handler(),
-            # which only works in the main thread.  Instead, manually
-            # initialize the application and start the updater.
-            self._tg_loop.run_until_complete(self._application.initialize())
-            self._tg_loop.run_until_complete(self._application.start())
-            self._tg_loop.run_until_complete(self._application.updater.start_polling())
-            self._tg_loop.run_forever()
-        except Exception:
-            if self._running:
-                logger.exception("Telegram polling error")
-        finally:
-            # Graceful shutdown
-            try:
-                if self._application.updater.running:
-                    self._tg_loop.run_until_complete(self._application.updater.stop())
-                self._tg_loop.run_until_complete(self._application.stop())
-                self._tg_loop.run_until_complete(self._application.shutdown())
-            except Exception:
-                logger.exception("Error during Telegram shutdown")
-
-    def _check_user(self, user_id: int) -> bool:
-        if not self._allowed_users:
-            return True
-        return user_id in self._allowed_users
-
-    async def _cmd_start(self, update, context) -> None:
-        """Handle /start command."""
-        if not self._check_user(update.effective_user.id):
-            return
-        await update.message.reply_text("Welcome to DeerFlow! Send me a message to start a conversation.\nType /help for available commands.")
-
-    async def _process_incoming_with_reply(self, chat_id: str, msg_id: int, inbound: InboundMessage) -> None:
-        await self._send_running_reply(chat_id, msg_id)
-        await self.bus.publish_inbound(inbound)
-
-    async def _cmd_generic(self, update, context) -> None:
-        """Forward slash commands to the channel manager."""
-        if not self._check_user(update.effective_user.id):
-            return
-
-        text = update.message.text
-        chat_id = str(update.effective_chat.id)
-        user_id = str(update.effective_user.id)
-        msg_id = str(update.message.message_id)
-
-        # Use the same topic_id logic as _on_text so that commands
-        # like /new target the correct thread mapping.
-        if update.effective_chat.type == "private":
-            topic_id = None
-        else:
-            reply_to = update.message.reply_to_message
-            if reply_to:
-                topic_id = str(reply_to.message_id)
-            else:
-                topic_id = msg_id
-
-        inbound = self._make_inbound(
-            chat_id=chat_id,
-            user_id=user_id,
-            text=text,
-            msg_type=InboundMessageType.COMMAND,
-            thread_ts=msg_id,
-        )
-        inbound.topic_id = topic_id
-
-        if self._main_loop and self._main_loop.is_running():
-            fut = asyncio.run_coroutine_threadsafe(self._process_incoming_with_reply(chat_id, update.message.message_id, inbound), self._main_loop)
-            fut.add_done_callback(lambda f: self._log_future_error(f, "process_incoming_with_reply", update.message.message_id))
-        else:
-            logger.warning("[Telegram] Main loop not running. Cannot publish inbound message.")
-
-    async def _on_text(self, update, context) -> None:
-        """Handle regular text messages."""
-        if not self._check_user(update.effective_user.id):
-            return
-
-        text = update.message.text.strip()
-        if not text:
-            return
-
-        chat_id = str(update.effective_chat.id)
-        user_id = str(update.effective_user.id)
-        msg_id = str(update.message.message_id)
-
-        # topic_id determines which DeerFlow thread the message maps to.
-        # In private chats, use None so that all messages share a single
-        # thread (the store key becomes "channel:chat_id").
-        # In group chats, use the reply-to message id or the current
-        # message id to keep separate conversation threads.
-        if update.effective_chat.type == "private":
-            topic_id = None
-        else:
-            reply_to = update.message.reply_to_message
-            if reply_to:
-                topic_id = str(reply_to.message_id)
-            else:
-                topic_id = msg_id
-
-        inbound = self._make_inbound(
-            chat_id=chat_id,
-            user_id=user_id,
-            text=text,
-            msg_type=InboundMessageType.CHAT,
-            thread_ts=msg_id,
-        )
-        inbound.topic_id = topic_id
-
-        if self._main_loop and self._main_loop.is_running():
-            fut = asyncio.run_coroutine_threadsafe(self._process_incoming_with_reply(chat_id, update.message.message_id, inbound), self._main_loop)
-            fut.add_done_callback(lambda f: self._log_future_error(f, "process_incoming_with_reply", update.message.message_id))
-        else:
-            logger.warning("[Telegram] Main loop not running. Cannot publish inbound message.")

backend/app/channels/wecom.py

@@ -1,394 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import base64
-import hashlib
-import logging
-from collections.abc import Awaitable, Callable
-from typing import Any, cast
-
-from app.channels.base import Channel
-from app.channels.message_bus import (
-    InboundMessageType,
-    MessageBus,
-    OutboundMessage,
-    ResolvedAttachment,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class WeComChannel(Channel):
-    def __init__(self, bus: MessageBus, config: dict[str, Any]) -> None:
-        super().__init__(name="wecom", bus=bus, config=config)
-        self._bot_id: str | None = None
-        self._bot_secret: str | None = None
-        self._ws_client = None
-        self._ws_task: asyncio.Task | None = None
-        self._ws_frames: dict[str, dict[str, Any]] = {}
-        self._ws_stream_ids: dict[str, str] = {}
-        self._working_message = "Working on it..."
-
-    def _clear_ws_context(self, thread_ts: str | None) -> None:
-        if not thread_ts:
-            return
-        self._ws_frames.pop(thread_ts, None)
-        self._ws_stream_ids.pop(thread_ts, None)
-
-    async def _send_ws_upload_command(self, req_id: str, body: dict[str, Any], cmd: str) -> dict[str, Any]:
-        if not self._ws_client:
-            raise RuntimeError("WeCom WebSocket client is not available")
-
-        ws_manager = getattr(self._ws_client, "_ws_manager", None)
-        send_reply = getattr(ws_manager, "send_reply", None)
-        if not callable(send_reply):
-            raise RuntimeError("Installed wecom-aibot-python-sdk does not expose the WebSocket media upload API expected by DeerFlow. Use wecom-aibot-python-sdk==0.1.6 or update the adapter.")
-
-        send_reply_async = cast(Callable[[str, dict[str, Any], str], Awaitable[dict[str, Any]]], send_reply)
-        return await send_reply_async(req_id, body, cmd)
-
-    async def start(self) -> None:
-        if self._running:
-            return
-
-        bot_id = self.config.get("bot_id")
-        bot_secret = self.config.get("bot_secret")
-        working_message = self.config.get("working_message")
-
-        self._bot_id = bot_id if isinstance(bot_id, str) and bot_id else None
-        self._bot_secret = bot_secret if isinstance(bot_secret, str) and bot_secret else None
-        self._working_message = working_message if isinstance(working_message, str) and working_message else "Working on it..."
-
-        if not self._bot_id or not self._bot_secret:
-            logger.error("WeCom channel requires bot_id and bot_secret")
-            return
-
-        try:
-            from aibot import WSClient, WSClientOptions
-        except ImportError:
-            logger.error("wecom-aibot-python-sdk is not installed. Install it with: uv add wecom-aibot-python-sdk")
-            return
-        else:
-            self._ws_client = WSClient(WSClientOptions(bot_id=self._bot_id, secret=self._bot_secret, logger=logger))
-            self._ws_client.on("message.text", self._on_ws_text)
-            self._ws_client.on("message.mixed", self._on_ws_mixed)
-            self._ws_client.on("message.image", self._on_ws_image)
-            self._ws_client.on("message.file", self._on_ws_file)
-            self._ws_task = asyncio.create_task(self._ws_client.connect())
-
-            self._running = True
-            self.bus.subscribe_outbound(self._on_outbound)
-        logger.info("WeCom channel started")
-
-    async def stop(self) -> None:
-        self._running = False
-        self.bus.unsubscribe_outbound(self._on_outbound)
-        if self._ws_task:
-            try:
-                self._ws_task.cancel()
-            except Exception:
-                pass
-            self._ws_task = None
-        if self._ws_client:
-            try:
-                self._ws_client.disconnect()
-            except Exception:
-                pass
-        self._ws_client = None
-        self._ws_frames.clear()
-        self._ws_stream_ids.clear()
-        logger.info("WeCom channel stopped")
-
-    async def send(self, msg: OutboundMessage, *, _max_retries: int = 3) -> None:
-        if self._ws_client:
-            await self._send_ws(msg, _max_retries=_max_retries)
-            return
-        logger.warning("[WeCom] send called but WebSocket client is not available")
-
-    async def _on_outbound(self, msg: OutboundMessage) -> None:
-        if msg.channel_name != self.name:
-            return
-
-        try:
-            await self.send(msg)
-        except Exception:
-            logger.exception("Failed to send outbound message on channel %s", self.name)
-            if msg.is_final:
-                self._clear_ws_context(msg.thread_ts)
-            return
-
-        for attachment in msg.attachments:
-            try:
-                success = await self.send_file(msg, attachment)
-                if not success:
-                    logger.warning("[%s] file upload skipped for %s", self.name, attachment.filename)
-            except Exception:
-                logger.exception("[%s] failed to upload file %s", self.name, attachment.filename)
-
-        if msg.is_final:
-            self._clear_ws_context(msg.thread_ts)
-
-    async def send_file(self, msg: OutboundMessage, attachment: ResolvedAttachment) -> bool:
-        if not msg.is_final:
-            return True
-        if not self._ws_client:
-            return False
-        if not msg.thread_ts:
-            return False
-        frame = self._ws_frames.get(msg.thread_ts)
-        if not frame:
-            return False
-
-        media_type = "image" if attachment.is_image else "file"
-        size_limit = 2 * 1024 * 1024 if attachment.is_image else 20 * 1024 * 1024
-        if attachment.size > size_limit:
-            logger.warning(
-                "[WeCom] %s too large (%d bytes), skipping: %s",
-                media_type,
-                attachment.size,
-                attachment.filename,
-            )
-            return False
-
-        try:
-            media_id = await self._upload_media_ws(
-                media_type=media_type,
-                filename=attachment.filename,
-                path=str(attachment.actual_path),
-                size=attachment.size,
-            )
-            if not media_id:
-                return False
-
-            body = {media_type: {"media_id": media_id}, "msgtype": media_type}
-            await self._ws_client.reply(frame, body)
-            logger.debug("[WeCom] %s sent via ws: %s", media_type, attachment.filename)
-            return True
-        except Exception:
-            logger.exception("[WeCom] failed to upload/send file via ws: %s", attachment.filename)
-            return False
-
-    async def _on_ws_text(self, frame: dict[str, Any]) -> None:
-        body = frame.get("body", {}) or {}
-        text = ((body.get("text") or {}).get("content") or "").strip()
-        quote = body.get("quote", {}).get("text", {}).get("content", "").strip()
-        if not text and not quote:
-            return
-        await self._publish_ws_inbound(frame, text + (f"\nQuote message: {quote}" if quote else ""))
-
-    async def _on_ws_mixed(self, frame: dict[str, Any]) -> None:
-        body = frame.get("body", {}) or {}
-        mixed = body.get("mixed") or {}
-        items = mixed.get("msg_item") or []
-        parts: list[str] = []
-        files: list[dict[str, Any]] = []
-        for item in items:
-            item_type = (item or {}).get("msgtype")
-            if item_type == "text":
-                content = (((item or {}).get("text") or {}).get("content") or "").strip()
-                if content:
-                    parts.append(content)
-            elif item_type in ("image", "file"):
-                payload = (item or {}).get(item_type) or {}
-                url = payload.get("url")
-                aeskey = payload.get("aeskey")
-                if isinstance(url, str) and url:
-                    files.append(
-                        {
-                            "type": item_type,
-                            "url": url,
-                            "aeskey": (aeskey if isinstance(aeskey, str) and aeskey else None),
-                        }
-                    )
-        text = "\n\n".join(parts).strip()
-        if not text and not files:
-            return
-        if not text:
-            text = "（receive image/file）"
-        await self._publish_ws_inbound(frame, text, files=files)
-
-    async def _on_ws_image(self, frame: dict[str, Any]) -> None:
-        body = frame.get("body", {}) or {}
-        image = body.get("image") or {}
-        url = image.get("url")
-        aeskey = image.get("aeskey")
-        if not isinstance(url, str) or not url:
-            return
-        await self._publish_ws_inbound(
-            frame,
-            "（receive image ）",
-            files=[
-                {
-                    "type": "image",
-                    "url": url,
-                    "aeskey": aeskey if isinstance(aeskey, str) and aeskey else None,
-                }
-            ],
-        )
-
-    async def _on_ws_file(self, frame: dict[str, Any]) -> None:
-        body = frame.get("body", {}) or {}
-        file_obj = body.get("file") or {}
-        url = file_obj.get("url")
-        aeskey = file_obj.get("aeskey")
-        if not isinstance(url, str) or not url:
-            return
-        await self._publish_ws_inbound(
-            frame,
-            "（receive file）",
-            files=[
-                {
-                    "type": "file",
-                    "url": url,
-                    "aeskey": aeskey if isinstance(aeskey, str) and aeskey else None,
-                }
-            ],
-        )
-
-    async def _publish_ws_inbound(
-        self,
-        frame: dict[str, Any],
-        text: str,
-        *,
-        files: list[dict[str, Any]] | None = None,
-    ) -> None:
-        if not self._ws_client:
-            return
-        try:
-            from aibot import generate_req_id
-        except Exception:
-            return
-
-        body = frame.get("body", {}) or {}
-        msg_id = body.get("msgid")
-        if not msg_id:
-            return
-
-        user_id = (body.get("from") or {}).get("userid")
-
-        inbound_type = InboundMessageType.COMMAND if text.startswith("/") else InboundMessageType.CHAT
-        inbound = self._make_inbound(
-            chat_id=user_id,  # keep user's conversation in memory
-            user_id=user_id,
-            text=text,
-            msg_type=inbound_type,
-            thread_ts=msg_id,
-            files=files or [],
-            metadata={"aibotid": body.get("aibotid"), "chattype": body.get("chattype")},
-        )
-        inbound.topic_id = user_id  # keep the same thread
-
-        stream_id = generate_req_id("stream")
-        self._ws_frames[msg_id] = frame
-        self._ws_stream_ids[msg_id] = stream_id
-
-        try:
-            await self._ws_client.reply_stream(frame, stream_id, self._working_message, False)
-        except Exception:
-            pass
-
-        await self.bus.publish_inbound(inbound)
-
-    async def _send_ws(self, msg: OutboundMessage, *, _max_retries: int = 3) -> None:
-        if not self._ws_client:
-            return
-        try:
-            from aibot import generate_req_id
-        except Exception:
-            generate_req_id = None
-
-        if msg.thread_ts and msg.thread_ts in self._ws_frames:
-            frame = self._ws_frames[msg.thread_ts]
-            stream_id = self._ws_stream_ids.get(msg.thread_ts)
-            if not stream_id and generate_req_id:
-                stream_id = generate_req_id("stream")
-                self._ws_stream_ids[msg.thread_ts] = stream_id
-            if not stream_id:
-                return
-
-            last_exc: Exception | None = None
-            for attempt in range(_max_retries):
-                try:
-                    await self._ws_client.reply_stream(frame, stream_id, msg.text, bool(msg.is_final))
-                    return
-                except Exception as exc:
-                    last_exc = exc
-                    if attempt < _max_retries - 1:
-                        await asyncio.sleep(2**attempt)
-            if last_exc:
-                raise last_exc
-
-        body = {"msgtype": "markdown", "markdown": {"content": msg.text}}
-        last_exc = None
-        for attempt in range(_max_retries):
-            try:
-                await self._ws_client.send_message(msg.chat_id, body)
-                return
-            except Exception as exc:
-                last_exc = exc
-                if attempt < _max_retries - 1:
-                    await asyncio.sleep(2**attempt)
-        if last_exc:
-            raise last_exc
-
-    async def _upload_media_ws(
-        self,
-        *,
-        media_type: str,
-        filename: str,
-        path: str,
-        size: int,
-    ) -> str | None:
-        if not self._ws_client:
-            return None
-        try:
-            from aibot import generate_req_id
-        except Exception:
-            return None
-
-        chunk_size = 512 * 1024
-        total_chunks = (size + chunk_size - 1) // chunk_size
-        if total_chunks < 1 or total_chunks > 100:
-            logger.warning("[WeCom] invalid total_chunks=%d for %s", total_chunks, filename)
-            return None
-
-        md5_hasher = hashlib.md5()
-        with open(path, "rb") as f:
-            for chunk in iter(lambda: f.read(1024 * 1024), b""):
-                md5_hasher.update(chunk)
-        md5 = md5_hasher.hexdigest()
-
-        init_req_id = generate_req_id("aibot_upload_media_init")
-        init_body = {
-            "type": media_type,
-            "filename": filename,
-            "total_size": int(size),
-            "total_chunks": int(total_chunks),
-            "md5": md5,
-        }
-        init_ack = await self._send_ws_upload_command(init_req_id, init_body, "aibot_upload_media_init")
-        upload_id = (init_ack.get("body") or {}).get("upload_id")
-        if not upload_id:
-            logger.warning("[WeCom] upload init returned no upload_id: %s", init_ack)
-            return None
-
-        with open(path, "rb") as f:
-            for idx in range(total_chunks):
-                data = f.read(chunk_size)
-                if not data:
-                    break
-                chunk_req_id = generate_req_id("aibot_upload_media_chunk")
-                chunk_body = {
-                    "upload_id": upload_id,
-                    "chunk_index": int(idx),
-                    "base64_data": base64.b64encode(data).decode("utf-8"),
-                }
-                await self._send_ws_upload_command(chunk_req_id, chunk_body, "aibot_upload_media_chunk")
-
-        finish_req_id = generate_req_id("aibot_upload_media_finish")
-        finish_ack = await self._send_ws_upload_command(finish_req_id, {"upload_id": upload_id}, "aibot_upload_media_finish")
-        media_id = (finish_ack.get("body") or {}).get("media_id")
-        if not media_id:
-            logger.warning("[WeCom] upload finish returned no media_id: %s", finish_ack)
-            return None
-        return media_id

backend/app/gateway/__init__.py

@@ -1,4 +0,0 @@
-from .app import app, create_app
-from .config import GatewayConfig, get_gateway_config
-
-__all__ = ["app", "create_app", "GatewayConfig", "get_gateway_config"]

backend/app/gateway/app.py

@@ -1,389 +0,0 @@
-import logging
-import os
-from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager
-from datetime import UTC
-
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-
-from app.gateway.auth_middleware import AuthMiddleware
-from app.gateway.config import get_gateway_config
-from app.gateway.csrf_middleware import CSRFMiddleware
-from app.gateway.deps import langgraph_runtime
-from app.gateway.routers import (
-    agents,
-    artifacts,
-    assistants_compat,
-    auth,
-    channels,
-    feedback,
-    mcp,
-    memory,
-    models,
-    runs,
-    skills,
-    suggestions,
-    thread_runs,
-    threads,
-    uploads,
-)
-from deerflow.config.app_config import get_app_config
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-)
-
-logger = logging.getLogger(__name__)
-
-
-async def _ensure_admin_user(app: FastAPI) -> None:
-    """Auto-create the admin user on first boot if no users exist.
-
-    After admin creation, migrate orphan threads from the LangGraph
-    store (metadata.owner_id unset) to the admin account. This is the
-    "no-auth → with-auth" upgrade path: users who ran DeerFlow without
-    authentication have existing LangGraph thread data that needs an
-    owner assigned.
-
-    No SQL persistence migration is needed: the four owner_id columns
-    (threads_meta, runs, run_events, feedback) only come into existence
-    alongside the auth module via create_all, so freshly created tables
-    never contain NULL-owner rows. "Existing persistence DB + new auth"
-    is not a supported upgrade path — fresh install or wipe-and-retry.
-
-    Multi-worker safe: relies on SQLite UNIQUE constraint to resolve
-    races during admin creation. Only the worker that successfully
-    creates/updates the admin prints the password; losers silently skip.
-    """
-    import secrets
-
-    from app.gateway.deps import get_local_provider
-
-    provider = get_local_provider()
-    user_count = await provider.count_users()
-
-    admin = None
-    fresh_admin_created = False
-
-    if user_count == 0:
-        password = secrets.token_urlsafe(16)
-        try:
-            admin = await provider.create_user(email="admin@deerflow.dev", password=password, system_role="admin", needs_setup=True)
-            fresh_admin_created = True
-        except ValueError:
-            return  # Another worker already created the admin.
-    else:
-        # Admin exists but setup never completed — reset password so operator
-        # can always find it in the console without needing the CLI.
-        # Multi-worker guard: if admin was created less than 30s ago, another
-        # worker just created it and will print the password — skip reset.
-        admin = await provider.get_user_by_email("admin@deerflow.dev")
-        if admin and admin.needs_setup:
-            import time
-
-            age = time.time() - admin.created_at.replace(tzinfo=UTC).timestamp()
-            if age >= 30:
-                from app.gateway.auth.credential_file import write_initial_credentials
-                from app.gateway.auth.password import hash_password_async
-
-                password = secrets.token_urlsafe(16)
-                admin.password_hash = await hash_password_async(password)
-                admin.token_version += 1
-                await provider.update_user(admin)
-
-                cred_path = write_initial_credentials(admin.email, password, label="reset")
-                logger.info("=" * 60)
-                logger.info("  Admin account setup incomplete — password reset")
-                logger.info("  Credentials written to: %s (mode 0600)", cred_path)
-                logger.info("  Change it after login: Settings -> Account")
-                logger.info("=" * 60)
-
-    if admin is None:
-        return  # Nothing to bind orphans to.
-
-    admin_id = str(admin.id)
-
-    # LangGraph store orphan migration — non-fatal.
-    # This covers the "no-auth → with-auth" upgrade path for users
-    # whose existing LangGraph thread metadata has no owner_id set.
-    store = getattr(app.state, "store", None)
-    if store is not None:
-        try:
-            migrated = await _migrate_orphaned_threads(store, admin_id)
-            if migrated:
-                logger.info("Migrated %d orphan LangGraph thread(s) to admin", migrated)
-        except Exception:
-            logger.exception("LangGraph thread migration failed (non-fatal)")
-
-    if fresh_admin_created:
-        from app.gateway.auth.credential_file import write_initial_credentials
-
-        cred_path = write_initial_credentials(admin.email, password, label="initial")  # noqa: F821 — defined in the fresh_admin branch
-        logger.info("=" * 60)
-        logger.info("  Admin account created on first boot")
-        logger.info("  Credentials written to: %s (mode 0600)", cred_path)
-        logger.info("  Change it after login: Settings -> Account")
-        logger.info("=" * 60)
-
-
-async def _iter_store_items(store, namespace, *, page_size: int = 500):
-    """Paginated async iterator over a LangGraph store namespace.
-
-    Replaces the old hardcoded ``limit=1000`` call with a cursor-style
-    loop so that environments with more than one page of orphans do
-    not silently lose data. Terminates when a page is empty OR when a
-    short page arrives (indicating the last page).
-    """
-    offset = 0
-    while True:
-        batch = await store.asearch(namespace, limit=page_size, offset=offset)
-        if not batch:
-            return
-        for item in batch:
-            yield item
-        if len(batch) < page_size:
-            return
-        offset += page_size
-
-
-async def _migrate_orphaned_threads(store, admin_user_id: str) -> int:
-    """Migrate LangGraph store threads with no owner_id to the given admin.
-
-    Uses cursor pagination so all orphans are migrated regardless of
-    count. Returns the number of rows migrated.
-    """
-    migrated = 0
-    async for item in _iter_store_items(store, ("threads",)):
-        metadata = item.value.get("metadata", {})
-        if not metadata.get("owner_id"):
-            metadata["owner_id"] = admin_user_id
-            item.value["metadata"] = metadata
-            await store.aput(("threads",), item.key, item.value)
-            migrated += 1
-    return migrated
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
-    """Application lifespan handler."""
-
-    # Load config and check necessary environment variables at startup
-    try:
-        get_app_config()
-        logger.info("Configuration loaded successfully")
-    except Exception as e:
-        error_msg = f"Failed to load configuration during gateway startup: {e}"
-        logger.exception(error_msg)
-        raise RuntimeError(error_msg) from e
-    config = get_gateway_config()
-    logger.info(f"Starting API Gateway on {config.host}:{config.port}")
-
-    # Initialize LangGraph runtime components (StreamBridge, RunManager, checkpointer, store)
-    async with langgraph_runtime(app):
-        logger.info("LangGraph runtime initialised")
-
-        # Ensure admin user exists (auto-create on first boot)
-        # Must run AFTER langgraph_runtime so app.state.store is available for thread migration
-        await _ensure_admin_user(app)
-
-        # Start IM channel service if any channels are configured
-        try:
-            from app.channels.service import start_channel_service
-
-            channel_service = await start_channel_service()
-            logger.info("Channel service started: %s", channel_service.get_status())
-        except Exception:
-            logger.exception("No IM channels configured or channel service failed to start")
-
-        yield
-
-        # Stop channel service on shutdown
-        try:
-            from app.channels.service import stop_channel_service
-
-            await stop_channel_service()
-        except Exception:
-            logger.exception("Failed to stop channel service")
-
-    logger.info("Shutting down API Gateway")
-
-
-def create_app() -> FastAPI:
-    """Create and configure the FastAPI application.
-
-    Returns:
-        Configured FastAPI application instance.
-    """
-
-    app = FastAPI(
-        title="DeerFlow API Gateway",
-        description="""
-## DeerFlow API Gateway
-
-API Gateway for DeerFlow - A LangGraph-based AI agent backend with sandbox execution capabilities.
-
-### Features
-
-- **Models Management**: Query and retrieve available AI models
-- **MCP Configuration**: Manage Model Context Protocol (MCP) server configurations
-- **Memory Management**: Access and manage global memory data for personalized conversations
-- **Skills Management**: Query and manage skills and their enabled status
-- **Artifacts**: Access thread artifacts and generated files
-- **Health Monitoring**: System health check endpoints
-
-### Architecture
-
-LangGraph requests are handled by nginx reverse proxy.
-This gateway provides custom endpoints for models, MCP configuration, skills, and artifacts.
-        """,
-        version="0.1.0",
-        lifespan=lifespan,
-        docs_url="/docs",
-        redoc_url="/redoc",
-        openapi_url="/openapi.json",
-        openapi_tags=[
-            {
-                "name": "models",
-                "description": "Operations for querying available AI models and their configurations",
-            },
-            {
-                "name": "mcp",
-                "description": "Manage Model Context Protocol (MCP) server configurations",
-            },
-            {
-                "name": "memory",
-                "description": "Access and manage global memory data for personalized conversations",
-            },
-            {
-                "name": "skills",
-                "description": "Manage skills and their configurations",
-            },
-            {
-                "name": "artifacts",
-                "description": "Access and download thread artifacts and generated files",
-            },
-            {
-                "name": "uploads",
-                "description": "Upload and manage user files for threads",
-            },
-            {
-                "name": "threads",
-                "description": "Manage DeerFlow thread-local filesystem data",
-            },
-            {
-                "name": "agents",
-                "description": "Create and manage custom agents with per-agent config and prompts",
-            },
-            {
-                "name": "suggestions",
-                "description": "Generate follow-up question suggestions for conversations",
-            },
-            {
-                "name": "channels",
-                "description": "Manage IM channel integrations (Feishu, Slack, Telegram)",
-            },
-            {
-                "name": "assistants-compat",
-                "description": "LangGraph Platform-compatible assistants API (stub)",
-            },
-            {
-                "name": "runs",
-                "description": "LangGraph Platform-compatible runs lifecycle (create, stream, cancel)",
-            },
-            {
-                "name": "health",
-                "description": "Health check and system status endpoints",
-            },
-        ],
-    )
-
-    # Auth: reject unauthenticated requests to non-public paths (fail-closed safety net)
-    app.add_middleware(AuthMiddleware)
-
-    # CSRF: Double Submit Cookie pattern for state-changing requests
-    app.add_middleware(CSRFMiddleware)
-
-    # CORS: when GATEWAY_CORS_ORIGINS is set (dev without nginx), add CORS middleware.
-    # In production, nginx handles CORS and no middleware is needed.
-    cors_origins_env = os.environ.get("GATEWAY_CORS_ORIGINS", "")
-    if cors_origins_env:
-        cors_origins = [o.strip() for o in cors_origins_env.split(",") if o.strip()]
-        # Validate: wildcard origin with credentials is a security misconfiguration
-        for origin in cors_origins:
-            if origin == "*":
-                logger.error("GATEWAY_CORS_ORIGINS contains wildcard '*' with allow_credentials=True. This is a security misconfiguration — browsers will reject the response. Use explicit scheme://host:port origins instead.")
-                cors_origins = [o for o in cors_origins if o != "*"]
-                break
-        if cors_origins:
-            app.add_middleware(
-                CORSMiddleware,
-                allow_origins=cors_origins,
-                allow_credentials=True,
-                allow_methods=["*"],
-                allow_headers=["*"],
-            )
-
-    # Include routers
-    # Models API is mounted at /api/models
-    app.include_router(models.router)
-
-    # MCP API is mounted at /api/mcp
-    app.include_router(mcp.router)
-
-    # Memory API is mounted at /api/memory
-    app.include_router(memory.router)
-
-    # Skills API is mounted at /api/skills
-    app.include_router(skills.router)
-
-    # Artifacts API is mounted at /api/threads/{thread_id}/artifacts
-    app.include_router(artifacts.router)
-
-    # Uploads API is mounted at /api/threads/{thread_id}/uploads
-    app.include_router(uploads.router)
-
-    # Thread cleanup API is mounted at /api/threads/{thread_id}
-    app.include_router(threads.router)
-
-    # Agents API is mounted at /api/agents
-    app.include_router(agents.router)
-
-    # Suggestions API is mounted at /api/threads/{thread_id}/suggestions
-    app.include_router(suggestions.router)
-
-    # Channels API is mounted at /api/channels
-    app.include_router(channels.router)
-
-    # Assistants compatibility API (LangGraph Platform stub)
-    app.include_router(assistants_compat.router)
-
-    # Auth API is mounted at /api/v1/auth
-    app.include_router(auth.router)
-
-    # Feedback API is mounted at /api/threads/{thread_id}/runs/{run_id}/feedback
-    app.include_router(feedback.router)
-
-    # Thread Runs API (LangGraph Platform-compatible runs lifecycle)
-    app.include_router(thread_runs.router)
-
-    # Stateless Runs API (stream/wait without a pre-existing thread)
-    app.include_router(runs.router)
-
-    @app.get("/health", tags=["health"])
-    async def health_check() -> dict:
-        """Health check endpoint.
-
-        Returns:
-            Service health status information.
-        """
-        return {"status": "healthy", "service": "deer-flow-gateway"}
-
-    return app
-
-
-# Create app instance for uvicorn
-app = create_app()

backend/app/gateway/auth/__init__.py

@@ -1,42 +0,0 @@
-"""Authentication module for DeerFlow.
-
-This module provides:
-- JWT-based authentication
-- Provider Factory pattern for extensible auth methods
-- UserRepository interface for storage backends (SQLite)
-"""
-
-from app.gateway.auth.config import AuthConfig, get_auth_config, set_auth_config
-from app.gateway.auth.errors import AuthErrorCode, AuthErrorResponse, TokenError
-from app.gateway.auth.jwt import TokenPayload, create_access_token, decode_token
-from app.gateway.auth.local_provider import LocalAuthProvider
-from app.gateway.auth.models import User, UserResponse
-from app.gateway.auth.password import hash_password, verify_password
-from app.gateway.auth.providers import AuthProvider
-from app.gateway.auth.repositories.base import UserRepository
-
-__all__ = [
-    # Config
-    "AuthConfig",
-    "get_auth_config",
-    "set_auth_config",
-    # Errors
-    "AuthErrorCode",
-    "AuthErrorResponse",
-    "TokenError",
-    # JWT
-    "TokenPayload",
-    "create_access_token",
-    "decode_token",
-    # Password
-    "hash_password",
-    "verify_password",
-    # Models
-    "User",
-    "UserResponse",
-    # Providers
-    "AuthProvider",
-    "LocalAuthProvider",
-    # Repository
-    "UserRepository",
-]

backend/app/gateway/auth/config.py

@@ -1,57 +0,0 @@
-"""Authentication configuration for DeerFlow."""
-
-import logging
-import os
-import secrets
-
-from dotenv import load_dotenv
-from pydantic import BaseModel, Field
-
-load_dotenv()
-
-logger = logging.getLogger(__name__)
-
-
-class AuthConfig(BaseModel):
-    """JWT and auth-related configuration. Parsed once at startup.
-
-    Note: the ``users`` table now lives in the shared persistence
-    database managed by ``deerflow.persistence.engine``. The old
-    ``users_db_path`` config key has been removed — user storage is
-    configured through ``config.database`` like every other table.
-    """
-
-    jwt_secret: str = Field(
-        ...,
-        description="Secret key for JWT signing. MUST be set via AUTH_JWT_SECRET.",
-    )
-    token_expiry_days: int = Field(default=7, ge=1, le=30)
-    oauth_github_client_id: str | None = Field(default=None)
-    oauth_github_client_secret: str | None = Field(default=None)
-
-
-_auth_config: AuthConfig | None = None
-
-
-def get_auth_config() -> AuthConfig:
-    """Get the global AuthConfig instance. Parses from env on first call."""
-    global _auth_config
-    if _auth_config is None:
-        jwt_secret = os.environ.get("AUTH_JWT_SECRET")
-        if not jwt_secret:
-            jwt_secret = secrets.token_urlsafe(32)
-            os.environ["AUTH_JWT_SECRET"] = jwt_secret
-            logger.warning(
-                "⚠ AUTH_JWT_SECRET is not set — using an auto-generated ephemeral secret. "
-                "Sessions will be invalidated on restart. "
-                "For production, add AUTH_JWT_SECRET to your .env file: "
-                'python -c "import secrets; print(secrets.token_urlsafe(32))"'
-            )
-        _auth_config = AuthConfig(jwt_secret=jwt_secret)
-    return _auth_config
-
-
-def set_auth_config(config: AuthConfig) -> None:
-    """Set the global AuthConfig instance (for testing)."""
-    global _auth_config
-    _auth_config = config

backend/app/gateway/auth/credential_file.py

@@ -1,38 +0,0 @@
-"""Write initial admin credentials to a restricted file instead of logs.
-
-Logging secrets to stdout/stderr is a well-known CodeQL finding
-(py/clear-text-logging-sensitive-data) — in production those logs
-get collected into ELK/Splunk/etc and become a secret sprawl
-source. This helper writes the credential to a 0600 file that only
-the process user can read, and returns the path so the caller can
-log **the path** (not the password) for the operator to pick up.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-_CREDENTIAL_FILE = Path(".deer-flow") / "admin_initial_credentials.txt"
-
-
-def write_initial_credentials(email: str, password: str, *, label: str = "initial") -> Path:
-    """Write the admin email + password to ``.deer-flow/admin_initial_credentials.txt``.
-
-    Creates the parent directory if it does not exist. Sets the file
-    mode to 0600 so only the owning process user can read it.
-
-    ``label`` distinguishes "initial" (fresh creation) from "reset"
-    (password reset) in the file header, so an operator picking up
-    the file after a restart can tell which event produced it.
-
-    Returns the absolute :class:`Path` to the file.
-    """
-    _CREDENTIAL_FILE.parent.mkdir(parents=True, exist_ok=True)
-
-    content = (
-        f"# DeerFlow admin {label} credentials\n# This file is generated on first boot or password reset.\n# Change the password after login via Settings -> Account,\n# then delete this file.\n#\nemail: {email}\npassword: {password}\n"
-    )
-    _CREDENTIAL_FILE.write_text(content)
-    os.chmod(_CREDENTIAL_FILE, 0o600)
-    return _CREDENTIAL_FILE.resolve()

backend/app/gateway/auth/errors.py

@@ -1,44 +0,0 @@
-"""Typed error definitions for auth module.
-
-AuthErrorCode: exhaustive enum of all auth failure conditions.
-TokenError: exhaustive enum of JWT decode failures.
-AuthErrorResponse: structured error payload for HTTP responses.
-"""
-
-from enum import StrEnum
-
-from pydantic import BaseModel
-
-
-class AuthErrorCode(StrEnum):
-    """Exhaustive list of auth error conditions."""
-
-    INVALID_CREDENTIALS = "invalid_credentials"
-    TOKEN_EXPIRED = "token_expired"
-    TOKEN_INVALID = "token_invalid"
-    USER_NOT_FOUND = "user_not_found"
-    EMAIL_ALREADY_EXISTS = "email_already_exists"
-    PROVIDER_NOT_FOUND = "provider_not_found"
-    NOT_AUTHENTICATED = "not_authenticated"
-
-
-class TokenError(StrEnum):
-    """Exhaustive list of JWT decode failure reasons."""
-
-    EXPIRED = "expired"
-    INVALID_SIGNATURE = "invalid_signature"
-    MALFORMED = "malformed"
-
-
-class AuthErrorResponse(BaseModel):
-    """Structured error response — replaces bare `detail` strings."""
-
-    code: AuthErrorCode
-    message: str
-
-
-def token_error_to_code(err: TokenError) -> AuthErrorCode:
-    """Map TokenError to AuthErrorCode — single source of truth."""
-    if err == TokenError.EXPIRED:
-        return AuthErrorCode.TOKEN_EXPIRED
-    return AuthErrorCode.TOKEN_INVALID

backend/app/gateway/auth/jwt.py

@@ -1,55 +0,0 @@
-"""JWT token creation and verification."""
-
-from datetime import UTC, datetime, timedelta
-
-import jwt
-from pydantic import BaseModel
-
-from app.gateway.auth.config import get_auth_config
-from app.gateway.auth.errors import TokenError
-
-
-class TokenPayload(BaseModel):
-    """JWT token payload."""
-
-    sub: str  # user_id
-    exp: datetime
-    iat: datetime | None = None
-    ver: int = 0  # token_version — must match User.token_version
-
-
-def create_access_token(user_id: str, expires_delta: timedelta | None = None, token_version: int = 0) -> str:
-    """Create a JWT access token.
-
-    Args:
-        user_id: The user's UUID as string
-        expires_delta: Optional custom expiry, defaults to 7 days
-        token_version: User's current token_version for invalidation
-
-    Returns:
-        Encoded JWT string
-    """
-    config = get_auth_config()
-    expiry = expires_delta or timedelta(days=config.token_expiry_days)
-
-    now = datetime.now(UTC)
-    payload = {"sub": user_id, "exp": now + expiry, "iat": now, "ver": token_version}
-    return jwt.encode(payload, config.jwt_secret, algorithm="HS256")
-
-
-def decode_token(token: str) -> TokenPayload | TokenError:
-    """Decode and validate a JWT token.
-
-    Returns:
-        TokenPayload if valid, or a specific TokenError variant.
-    """
-    config = get_auth_config()
-    try:
-        payload = jwt.decode(token, config.jwt_secret, algorithms=["HS256"])
-        return TokenPayload(**payload)
-    except jwt.ExpiredSignatureError:
-        return TokenError.EXPIRED
-    except jwt.InvalidSignatureError:
-        return TokenError.INVALID_SIGNATURE
-    except jwt.PyJWTError:
-        return TokenError.MALFORMED

backend/app/gateway/auth/local_provider.py

@@ -1,87 +0,0 @@
-"""Local email/password authentication provider."""
-
-from app.gateway.auth.models import User
-from app.gateway.auth.password import hash_password_async, verify_password_async
-from app.gateway.auth.providers import AuthProvider
-from app.gateway.auth.repositories.base import UserRepository
-
-
-class LocalAuthProvider(AuthProvider):
-    """Email/password authentication provider using local database."""
-
-    def __init__(self, repository: UserRepository):
-        """Initialize with a UserRepository.
-
-        Args:
-            repository: UserRepository implementation (SQLite)
-        """
-        self._repo = repository
-
-    async def authenticate(self, credentials: dict) -> User | None:
-        """Authenticate with email and password.
-
-        Args:
-            credentials: dict with 'email' and 'password' keys
-
-        Returns:
-            User if authentication succeeds, None otherwise
-        """
-        email = credentials.get("email")
-        password = credentials.get("password")
-
-        if not email or not password:
-            return None
-
-        user = await self._repo.get_user_by_email(email)
-        if user is None:
-            return None
-
-        if user.password_hash is None:
-            # OAuth user without local password
-            return None
-
-        if not await verify_password_async(password, user.password_hash):
-            return None
-
-        return user
-
-    async def get_user(self, user_id: str) -> User | None:
-        """Get user by ID."""
-        return await self._repo.get_user_by_id(user_id)
-
-    async def create_user(self, email: str, password: str | None = None, system_role: str = "user", needs_setup: bool = False) -> User:
-        """Create a new local user.
-
-        Args:
-            email: User email address
-            password: Plain text password (will be hashed)
-            system_role: Role to assign ("admin" or "user")
-            needs_setup: If True, user must complete setup on first login
-
-        Returns:
-            Created User instance
-        """
-        password_hash = await hash_password_async(password) if password else None
-        user = User(
-            email=email,
-            password_hash=password_hash,
-            system_role=system_role,
-            needs_setup=needs_setup,
-        )
-        return await self._repo.create_user(user)
-
-    async def get_user_by_oauth(self, provider: str, oauth_id: str) -> User | None:
-        """Get user by OAuth provider and ID."""
-        return await self._repo.get_user_by_oauth(provider, oauth_id)
-
-    async def count_users(self) -> int:
-        """Return total number of registered users."""
-        return await self._repo.count_users()
-
-    async def update_user(self, user: User) -> User:
-        """Update an existing user."""
-        return await self._repo.update_user(user)
-
-    async def get_user_by_email(self, email: str) -> User | None:
-        """Get user by email."""
-        return await self._repo.get_user_by_email(email)

backend/app/gateway/auth/models.py

@@ -1,41 +0,0 @@
-"""User Pydantic models for authentication."""
-
-from datetime import UTC, datetime
-from typing import Literal
-from uuid import UUID, uuid4
-
-from pydantic import BaseModel, ConfigDict, EmailStr, Field
-
-
-def _utc_now() -> datetime:
-    """Return current UTC time (timezone-aware)."""
-    return datetime.now(UTC)
-
-
-class User(BaseModel):
-    """Internal user representation."""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    id: UUID = Field(default_factory=uuid4, description="Primary key")
-    email: EmailStr = Field(..., description="Unique email address")
-    password_hash: str | None = Field(None, description="bcrypt hash, nullable for OAuth users")
-    system_role: Literal["admin", "user"] = Field(default="user")
-    created_at: datetime = Field(default_factory=_utc_now)
-
-    # OAuth linkage (optional)
-    oauth_provider: str | None = Field(None, description="e.g. 'github', 'google'")
-    oauth_id: str | None = Field(None, description="User ID from OAuth provider")
-
-    # Auth lifecycle
-    needs_setup: bool = Field(default=False, description="True for auto-created admin until setup completes")
-    token_version: int = Field(default=0, description="Incremented on password change to invalidate old JWTs")
-
-
-class UserResponse(BaseModel):
-    """Response model for user info endpoint."""
-
-    id: str
-    email: str
-    system_role: Literal["admin", "user"]
-    needs_setup: bool = False

backend/app/gateway/auth/password.py

@@ -1,33 +0,0 @@
-"""Password hashing utilities using bcrypt directly."""
-
-import asyncio
-
-import bcrypt
-
-
-def hash_password(password: str) -> str:
-    """Hash a password using bcrypt."""
-    return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
-
-
-def verify_password(plain_password: str, hashed_password: str) -> bool:
-    """Verify a password against its hash."""
-    return bcrypt.checkpw(plain_password.encode("utf-8"), hashed_password.encode("utf-8"))
-
-
-async def hash_password_async(password: str) -> str:
-    """Hash a password using bcrypt (non-blocking).
-
-    Wraps the blocking bcrypt operation in a thread pool to avoid
-    blocking the event loop during password hashing.
-    """
-    return await asyncio.to_thread(hash_password, password)
-
-
-async def verify_password_async(plain_password: str, hashed_password: str) -> bool:
-    """Verify a password against its hash (non-blocking).
-
-    Wraps the blocking bcrypt operation in a thread pool to avoid
-    blocking the event loop during password verification.
-    """
-    return await asyncio.to_thread(verify_password, plain_password, hashed_password)

backend/app/gateway/auth/providers.py

@@ -1,24 +0,0 @@
-"""Auth provider abstraction."""
-
-from abc import ABC, abstractmethod
-
-
-class AuthProvider(ABC):
-    """Abstract base class for authentication providers."""
-
-    @abstractmethod
-    async def authenticate(self, credentials: dict) -> "User | None":
-        """Authenticate user with given credentials.
-
-        Returns User if authentication succeeds, None otherwise.
-        """
-        ...
-
-    @abstractmethod
-    async def get_user(self, user_id: str) -> "User | None":
-        """Retrieve user by ID."""
-        ...
-
-
-# Import User at runtime to avoid circular imports
-from app.gateway.auth.models import User  # noqa: E402

backend/app/gateway/auth/repositories/base.py

@@ -1,82 +0,0 @@
-"""User repository interface for abstracting database operations."""
-
-from abc import ABC, abstractmethod
-
-from app.gateway.auth.models import User
-
-
-class UserRepository(ABC):
-    """Abstract interface for user data storage.
-
-    Implement this interface to support different storage backends
-    (SQLite)
-    """
-
-    @abstractmethod
-    async def create_user(self, user: User) -> User:
-        """Create a new user.
-
-        Args:
-            user: User object to create
-
-        Returns:
-            Created User with ID assigned
-
-        Raises:
-            ValueError: If email already exists
-        """
-        ...
-
-    @abstractmethod
-    async def get_user_by_id(self, user_id: str) -> User | None:
-        """Get user by ID.
-
-        Args:
-            user_id: User UUID as string
-
-        Returns:
-            User if found, None otherwise
-        """
-        ...
-
-    @abstractmethod
-    async def get_user_by_email(self, email: str) -> User | None:
-        """Get user by email.
-
-        Args:
-            email: User email address
-
-        Returns:
-            User if found, None otherwise
-        """
-        ...
-
-    @abstractmethod
-    async def update_user(self, user: User) -> User:
-        """Update an existing user.
-
-        Args:
-            user: User object with updated fields
-
-        Returns:
-            Updated User
-        """
-        ...
-
-    @abstractmethod
-    async def count_users(self) -> int:
-        """Return total number of registered users."""
-        ...
-
-    @abstractmethod
-    async def get_user_by_oauth(self, provider: str, oauth_id: str) -> User | None:
-        """Get user by OAuth provider and ID.
-
-        Args:
-            provider: OAuth provider name (e.g. 'github', 'google')
-            oauth_id: User ID from the OAuth provider
-
-        Returns:
-            User if found, None otherwise
-        """
-        ...

backend/app/gateway/auth/repositories/sqlite.py

@@ -1,116 +0,0 @@
-"""SQLAlchemy-backed UserRepository implementation.
-
-Uses the shared async session factory from
-``deerflow.persistence.engine`` — the ``users`` table lives in the
-same database as ``threads_meta``, ``runs``, ``run_events``, and
-``feedback``.
-
-Constructor takes the session factory directly (same pattern as the
-other four repositories in ``deerflow.persistence.*``). Callers
-construct this after ``init_engine_from_config()`` has run.
-"""
-
-from __future__ import annotations
-
-from datetime import UTC
-from uuid import UUID
-
-from sqlalchemy import func, select
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
-
-from app.gateway.auth.models import User
-from app.gateway.auth.repositories.base import UserRepository
-from deerflow.persistence.user.model import UserRow
-
-
-class SQLiteUserRepository(UserRepository):
-    """Async user repository backed by the shared SQLAlchemy engine."""
-
-    def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
-        self._sf = session_factory
-
-    # ── Converters ────────────────────────────────────────────────────
-
-    @staticmethod
-    def _row_to_user(row: UserRow) -> User:
-        return User(
-            id=UUID(row.id),
-            email=row.email,
-            password_hash=row.password_hash,
-            system_role=row.system_role,  # type: ignore[arg-type]
-            # SQLite loses tzinfo on read; reattach UTC so downstream
-            # code can compare timestamps reliably.
-            created_at=row.created_at if row.created_at.tzinfo else row.created_at.replace(tzinfo=UTC),
-            oauth_provider=row.oauth_provider,
-            oauth_id=row.oauth_id,
-            needs_setup=row.needs_setup,
-            token_version=row.token_version,
-        )
-
-    @staticmethod
-    def _user_to_row(user: User) -> UserRow:
-        return UserRow(
-            id=str(user.id),
-            email=user.email,
-            password_hash=user.password_hash,
-            system_role=user.system_role,
-            created_at=user.created_at,
-            oauth_provider=user.oauth_provider,
-            oauth_id=user.oauth_id,
-            needs_setup=user.needs_setup,
-            token_version=user.token_version,
-        )
-
-    # ── CRUD ──────────────────────────────────────────────────────────
-
-    async def create_user(self, user: User) -> User:
-        """Insert a new user. Raises ``ValueError`` on duplicate email."""
-        row = self._user_to_row(user)
-        async with self._sf() as session:
-            session.add(row)
-            try:
-                await session.commit()
-            except IntegrityError as exc:
-                await session.rollback()
-                raise ValueError(f"Email already registered: {user.email}") from exc
-        return user
-
-    async def get_user_by_id(self, user_id: str) -> User | None:
-        async with self._sf() as session:
-            row = await session.get(UserRow, user_id)
-            return self._row_to_user(row) if row is not None else None
-
-    async def get_user_by_email(self, email: str) -> User | None:
-        stmt = select(UserRow).where(UserRow.email == email)
-        async with self._sf() as session:
-            result = await session.execute(stmt)
-            row = result.scalar_one_or_none()
-            return self._row_to_user(row) if row is not None else None
-
-    async def update_user(self, user: User) -> User:
-        async with self._sf() as session:
-            row = await session.get(UserRow, str(user.id))
-            if row is None:
-                return user
-            row.email = user.email
-            row.password_hash = user.password_hash
-            row.system_role = user.system_role
-            row.oauth_provider = user.oauth_provider
-            row.oauth_id = user.oauth_id
-            row.needs_setup = user.needs_setup
-            row.token_version = user.token_version
-            await session.commit()
-        return user
-
-    async def count_users(self) -> int:
-        stmt = select(func.count()).select_from(UserRow)
-        async with self._sf() as session:
-            return await session.scalar(stmt) or 0
-
-    async def get_user_by_oauth(self, provider: str, oauth_id: str) -> User | None:
-        stmt = select(UserRow).where(UserRow.oauth_provider == provider, UserRow.oauth_id == oauth_id)
-        async with self._sf() as session:
-            result = await session.execute(stmt)
-            row = result.scalar_one_or_none()
-            return self._row_to_user(row) if row is not None else None

backend/app/gateway/auth/reset_admin.py

@@ -1,91 +0,0 @@
-"""CLI tool to reset an admin password.
-
-Usage:
-    python -m app.gateway.auth.reset_admin
-    python -m app.gateway.auth.reset_admin --email admin@example.com
-
-Writes the new password to ``.deer-flow/admin_initial_credentials.txt``
-(mode 0600) instead of printing it, so CI / log aggregators never see
-the cleartext secret.
-"""
-
-from __future__ import annotations
-
-import argparse
-import asyncio
-import secrets
-import sys
-
-from sqlalchemy import select
-
-from app.gateway.auth.credential_file import write_initial_credentials
-from app.gateway.auth.password import hash_password
-from app.gateway.auth.repositories.sqlite import SQLiteUserRepository
-from deerflow.persistence.user.model import UserRow
-
-
-async def _run(email: str | None) -> int:
-    from deerflow.config import get_app_config
-    from deerflow.persistence.engine import (
-        close_engine,
-        get_session_factory,
-        init_engine_from_config,
-    )
-
-    config = get_app_config()
-    await init_engine_from_config(config.database)
-    try:
-        sf = get_session_factory()
-        if sf is None:
-            print("Error: persistence engine not available (check config.database).", file=sys.stderr)
-            return 1
-
-        repo = SQLiteUserRepository(sf)
-
-        if email:
-            user = await repo.get_user_by_email(email)
-        else:
-            # Find first admin via direct SELECT — repository does not
-            # expose a "first admin" helper and we do not want to add
-            # one just for this CLI.
-            async with sf() as session:
-                stmt = select(UserRow).where(UserRow.system_role == "admin").limit(1)
-                row = (await session.execute(stmt)).scalar_one_or_none()
-            if row is None:
-                user = None
-            else:
-                user = await repo.get_user_by_id(row.id)
-
-        if user is None:
-            if email:
-                print(f"Error: user '{email}' not found.", file=sys.stderr)
-            else:
-                print("Error: no admin user found.", file=sys.stderr)
-            return 1
-
-        new_password = secrets.token_urlsafe(16)
-        user.password_hash = hash_password(new_password)
-        user.token_version += 1
-        user.needs_setup = True
-        await repo.update_user(user)
-
-        cred_path = write_initial_credentials(user.email, new_password, label="reset")
-        print(f"Password reset for: {user.email}")
-        print(f"Credentials written to: {cred_path} (mode 0600)")
-        print("Next login will require setup (new email + password).")
-        return 0
-    finally:
-        await close_engine()
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Reset admin password")
-    parser.add_argument("--email", help="Admin email (default: first admin found)")
-    args = parser.parse_args()
-
-    exit_code = asyncio.run(_run(args.email))
-    sys.exit(exit_code)
-
-
-if __name__ == "__main__":
-    main()

backend/app/gateway/auth_middleware.py

@@ -1,117 +0,0 @@
-"""Global authentication middleware — fail-closed safety net.
-
-Rejects unauthenticated requests to non-public paths with 401. When a
-request passes the cookie check, resolves the JWT payload to a real
-``User`` object and stamps it into both ``request.state.user`` and the
-``deerflow.runtime.user_context`` contextvar so that repository-layer
-owner filtering works automatically via the sentinel pattern.
-
-Fine-grained permission checks remain in authz.py decorators.
-"""
-
-from collections.abc import Callable
-
-from fastapi import Request, Response
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.responses import JSONResponse
-from starlette.types import ASGIApp
-
-from app.gateway.auth.errors import AuthErrorCode
-from deerflow.runtime.user_context import reset_current_user, set_current_user
-
-# Paths that never require authentication.
-_PUBLIC_PATH_PREFIXES: tuple[str, ...] = (
-    "/health",
-    "/docs",
-    "/redoc",
-    "/openapi.json",
-)
-
-# Exact auth paths that are public (login/register/status check).
-# /api/v1/auth/me, /api/v1/auth/change-password etc. are NOT public.
-_PUBLIC_EXACT_PATHS: frozenset[str] = frozenset(
-    {
-        "/api/v1/auth/login/local",
-        "/api/v1/auth/register",
-        "/api/v1/auth/logout",
-        "/api/v1/auth/setup-status",
-    }
-)
-
-
-def _is_public(path: str) -> bool:
-    stripped = path.rstrip("/")
-    if stripped in _PUBLIC_EXACT_PATHS:
-        return True
-    return any(path.startswith(prefix) for prefix in _PUBLIC_PATH_PREFIXES)
-
-
-class AuthMiddleware(BaseHTTPMiddleware):
-    """Strict auth gate: reject requests without a valid session.
-
-    Two-stage check for non-public paths:
-
-    1. Cookie presence — return 401 NOT_AUTHENTICATED if missing
-    2. JWT validation via ``get_optional_user_from_request`` — return 401
-       TOKEN_INVALID if the token is absent, malformed, expired, or the
-       signed user does not exist / is stale
-
-    On success, stamps ``request.state.user`` and the
-    ``deerflow.runtime.user_context`` contextvar so that repository-layer
-    owner filters work downstream without every route needing a
-    ``@require_auth`` decorator. Routes that need per-resource
-    authorization (e.g. "user A cannot read user B's thread by guessing
-    the URL") should additionally use ``@require_permission(...,
-    owner_check=True)`` for explicit enforcement — but authentication
-    itself is fully handled here.
-    """
-
-    def __init__(self, app: ASGIApp) -> None:
-        super().__init__(app)
-
-    async def dispatch(self, request: Request, call_next: Callable) -> Response:
-        if _is_public(request.url.path):
-            return await call_next(request)
-
-        # Non-public path: require session cookie
-        if not request.cookies.get("access_token"):
-            return JSONResponse(
-                status_code=401,
-                content={
-                    "detail": {
-                        "code": AuthErrorCode.NOT_AUTHENTICATED,
-                        "message": "Authentication required",
-                    }
-                },
-            )
-
-        # Strict JWT validation: reject junk/expired tokens with 401
-        # right here instead of silently passing through. This closes
-        # the "junk cookie bypass" gap (AUTH_TEST_PLAN test 7.5.8):
-        # without this, non-isolation routes like /api/models would
-        # accept any cookie-shaped string as authentication.
-        #
-        # We call the *strict* resolver so that fine-grained error
-        # codes (token_expired, token_invalid, user_not_found, …)
-        # propagate from AuthErrorCode, not get flattened into one
-        # generic code. BaseHTTPMiddleware doesn't let HTTPException
-        # bubble up, so we catch and render it as JSONResponse here.
-        #
-        # On success we stamp request.state.user and the contextvar
-        # so repository-layer owner filters work downstream without
-        # every route needing a decorator.
-        from fastapi import HTTPException
-
-        from app.gateway.deps import get_current_user_from_request
-
-        try:
-            user = await get_current_user_from_request(request)
-        except HTTPException as exc:
-            return JSONResponse(status_code=exc.status_code, content={"detail": exc.detail})
-
-        request.state.user = user
-        token = set_current_user(user)
-        try:
-            return await call_next(request)
-        finally:
-            reset_current_user(token)

backend/app/gateway/authz.py

@@ -1,269 +0,0 @@
-"""Authorization decorators and context for DeerFlow.
-
-Inspired by LangGraph Auth system: https://github.com/langchain-ai/langgraph/blob/main/libs/sdk-py/langgraph_sdk/auth/__init__.py
-
-**Usage:**
-
-1. Use ``@require_auth`` on routes that need authentication
-2. Use ``@require_permission("resource", "action", filter_key=...)`` for permission checks
-3. The decorator chain processes from bottom to top
-
-**Example:**
-
-    @router.get("/{thread_id}")
-    @require_auth
-    @require_permission("threads", "read", owner_check=True)
-    async def get_thread(thread_id: str, request: Request):
-        # User is authenticated and has threads:read permission
-        ...
-
-**Permission Model:**
-
-- threads:read   - View thread
-- threads:write  - Create/update thread
-- threads:delete - Delete thread
-- runs:create   - Run agent
-- runs:read     - View run
-- runs:cancel   - Cancel run
-"""
-
-from __future__ import annotations
-
-import functools
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, ParamSpec, TypeVar
-
-from fastapi import HTTPException, Request
-
-if TYPE_CHECKING:
-    from app.gateway.auth.models import User
-
-P = ParamSpec("P")
-T = TypeVar("T")
-
-
-# Permission constants
-class Permissions:
-    """Permission constants for resource:action format."""
-
-    # Threads
-    THREADS_READ = "threads:read"
-    THREADS_WRITE = "threads:write"
-    THREADS_DELETE = "threads:delete"
-
-    # Runs
-    RUNS_CREATE = "runs:create"
-    RUNS_READ = "runs:read"
-    RUNS_CANCEL = "runs:cancel"
-
-
-class AuthContext:
-    """Authentication context for the current request.
-
-    Stored in request.state.auth after require_auth decoration.
-
-    Attributes:
-        user: The authenticated user, or None if anonymous
-        permissions: List of permission strings (e.g., "threads:read")
-    """
-
-    __slots__ = ("user", "permissions")
-
-    def __init__(self, user: User | None = None, permissions: list[str] | None = None):
-        self.user = user
-        self.permissions = permissions or []
-
-    @property
-    def is_authenticated(self) -> bool:
-        """Check if user is authenticated."""
-        return self.user is not None
-
-    def has_permission(self, resource: str, action: str) -> bool:
-        """Check if context has permission for resource:action.
-
-        Args:
-            resource: Resource name (e.g., "threads")
-            action: Action name (e.g., "read")
-
-        Returns:
-            True if user has permission
-        """
-        permission = f"{resource}:{action}"
-        return permission in self.permissions
-
-    def require_user(self) -> User:
-        """Get user or raise 401.
-
-        Raises:
-            HTTPException 401 if not authenticated
-        """
-        if not self.user:
-            raise HTTPException(status_code=401, detail="Authentication required")
-        return self.user
-
-
-def get_auth_context(request: Request) -> AuthContext | None:
-    """Get AuthContext from request state."""
-    return getattr(request.state, "auth", None)
-
-
-_ALL_PERMISSIONS: list[str] = [
-    Permissions.THREADS_READ,
-    Permissions.THREADS_WRITE,
-    Permissions.THREADS_DELETE,
-    Permissions.RUNS_CREATE,
-    Permissions.RUNS_READ,
-    Permissions.RUNS_CANCEL,
-]
-
-
-async def _authenticate(request: Request) -> AuthContext:
-    """Authenticate request and return AuthContext.
-
-    Delegates to deps.get_optional_user_from_request() for the JWT→User pipeline.
-    Returns AuthContext with user=None for anonymous requests.
-    """
-    from app.gateway.deps import get_optional_user_from_request
-
-    user = await get_optional_user_from_request(request)
-    if user is None:
-        return AuthContext(user=None, permissions=[])
-
-    # In future, permissions could be stored in user record
-    return AuthContext(user=user, permissions=_ALL_PERMISSIONS)
-
-
-def require_auth[**P, T](func: Callable[P, T]) -> Callable[P, T]:
-    """Decorator that authenticates the request and sets AuthContext.
-
-    Must be placed ABOVE other decorators (executes after them).
-
-    Usage:
-        @router.get("/{thread_id}")
-        @require_auth  # Bottom decorator (executes first after permission check)
-        @require_permission("threads", "read")
-        async def get_thread(thread_id: str, request: Request):
-            auth: AuthContext = request.state.auth
-            ...
-
-    Raises:
-        ValueError: If 'request' parameter is missing
-    """
-
-    @functools.wraps(func)
-    async def wrapper(*args: Any, **kwargs: Any) -> Any:
-        request = kwargs.get("request")
-        if request is None:
-            raise ValueError("require_auth decorator requires 'request' parameter")
-
-        # Authenticate and set context
-        auth_context = await _authenticate(request)
-        request.state.auth = auth_context
-
-        return await func(*args, **kwargs)
-
-    return wrapper
-
-
-def require_permission(
-    resource: str,
-    action: str,
-    owner_check: bool = False,
-    owner_filter_key: str = "owner_id",
-    inject_record: bool = False,
-) -> Callable[[Callable[P, T]], Callable[P, T]]:
-    """Decorator that checks permission for resource:action.
-
-    Must be used AFTER @require_auth.
-
-    Args:
-        resource: Resource name (e.g., "threads", "runs")
-        action: Action name (e.g., "read", "write", "delete")
-        owner_check: If True, validates that the current user owns the resource.
-                     Requires 'thread_id' path parameter and performs ownership check.
-        owner_filter_key: Field name for ownership filter (default: "owner_id")
-        inject_record: If True and owner_check is True, injects the thread record
-                      into kwargs['thread_record'] for use in the handler.
-
-    Usage:
-        # Simple permission check
-        @require_permission("threads", "read")
-        async def get_thread(thread_id: str, request: Request):
-            ...
-
-        # With ownership check (for /threads/{thread_id} endpoints)
-        @require_permission("threads", "delete", owner_check=True)
-        async def delete_thread(thread_id: str, request: Request):
-            ...
-
-        # With ownership check and record injection
-        @require_permission("threads", "delete", owner_check=True, inject_record=True)
-        async def delete_thread(thread_id: str, request: Request, thread_record: dict = None):
-            # thread_record is injected if found
-            ...
-
-    Raises:
-        HTTPException 401: If authentication required but user is anonymous
-        HTTPException 403: If user lacks permission
-        HTTPException 404: If owner_check=True but user doesn't own the thread
-        ValueError: If owner_check=True but 'thread_id' parameter is missing
-    """
-
-    def decorator(func: Callable[P, T]) -> Callable[P, T]:
-        @functools.wraps(func)
-        async def wrapper(*args: Any, **kwargs: Any) -> Any:
-            request = kwargs.get("request")
-            if request is None:
-                raise ValueError("require_permission decorator requires 'request' parameter")
-
-            auth: AuthContext = getattr(request.state, "auth", None)
-            if auth is None:
-                auth = await _authenticate(request)
-                request.state.auth = auth
-
-            if not auth.is_authenticated:
-                raise HTTPException(status_code=401, detail="Authentication required")
-
-            # Check permission
-            if not auth.has_permission(resource, action):
-                raise HTTPException(
-                    status_code=403,
-                    detail=f"Permission denied: {resource}:{action}",
-                )
-
-            # Owner check for thread-specific resources.
-            #
-            # 2.0-rc moved thread metadata into the SQL persistence layer
-            # (``threads_meta`` table). We verify ownership via
-            # ``ThreadMetaStore.check_access`` instead of the LangGraph
-            # store path that the original PR #1728 used. ``check_access``
-            # returns True for missing rows (untracked legacy thread) and
-            # for rows whose ``owner_id`` is NULL (shared / pre-auth data),
-            # so this is a strict-deny check rather than strict-allow:
-            # only an *existing* row with a *different* owner_id triggers
-            # 404.
-            #
-            # ``inject_record`` is no longer supported — it was a
-            # convenience for handlers that wanted the LangGraph store
-            # blob; the SQL repo would need a different shape and no
-            # caller in 2.0 needs it.
-            if owner_check:
-                thread_id = kwargs.get("thread_id")
-                if thread_id is None:
-                    raise ValueError("require_permission with owner_check=True requires 'thread_id' parameter")
-
-                from app.gateway.deps import get_thread_meta_repo
-
-                thread_meta_repo = get_thread_meta_repo(request)
-                allowed = await thread_meta_repo.check_access(thread_id, str(auth.user.id))
-                if not allowed:
-                    raise HTTPException(
-                        status_code=404,
-                        detail=f"Thread {thread_id} not found",
-                    )
-
-            return await func(*args, **kwargs)
-
-        return wrapper
-
-    return decorator

backend/app/gateway/config.py

@@ -1,27 +0,0 @@
-import os
-
-from pydantic import BaseModel, Field
-
-
-class GatewayConfig(BaseModel):
-    """Configuration for the API Gateway."""
-
-    host: str = Field(default="0.0.0.0", description="Host to bind the gateway server")
-    port: int = Field(default=8001, description="Port to bind the gateway server")
-    cors_origins: list[str] = Field(default_factory=lambda: ["http://localhost:3000"], description="Allowed CORS origins")
-
-
-_gateway_config: GatewayConfig | None = None
-
-
-def get_gateway_config() -> GatewayConfig:
-    """Get gateway config, loading from environment if available."""
-    global _gateway_config
-    if _gateway_config is None:
-        cors_origins_str = os.getenv("CORS_ORIGINS", "http://localhost:3000")
-        _gateway_config = GatewayConfig(
-            host=os.getenv("GATEWAY_HOST", "0.0.0.0"),
-            port=int(os.getenv("GATEWAY_PORT", "8001")),
-            cors_origins=cors_origins_str.split(","),
-        )
-    return _gateway_config

backend/app/gateway/csrf_middleware.py

@@ -1,112 +0,0 @@
-"""CSRF protection middleware for FastAPI.
-
-Per RFC-001:
-State-changing operations require CSRF protection.
-"""
-
-import secrets
-from collections.abc import Callable
-
-from fastapi import Request, Response
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.responses import JSONResponse
-from starlette.types import ASGIApp
-
-CSRF_COOKIE_NAME = "csrf_token"
-CSRF_HEADER_NAME = "X-CSRF-Token"
-CSRF_TOKEN_LENGTH = 64  # bytes
-
-
-def is_secure_request(request: Request) -> bool:
-    """Detect whether the original client request was made over HTTPS."""
-    return request.headers.get("x-forwarded-proto", request.url.scheme) == "https"
-
-
-def generate_csrf_token() -> str:
-    """Generate a secure random CSRF token."""
-    return secrets.token_urlsafe(CSRF_TOKEN_LENGTH)
-
-
-def should_check_csrf(request: Request) -> bool:
-    """Determine if a request needs CSRF validation.
-
-    CSRF is checked for state-changing methods (POST, PUT, DELETE, PATCH).
-    GET, HEAD, OPTIONS, and TRACE are exempt per RFC 7231.
-    """
-    if request.method not in ("POST", "PUT", "DELETE", "PATCH"):
-        return False
-
-    path = request.url.path.rstrip("/")
-    # Exempt /api/v1/auth/me endpoint
-    if path == "/api/v1/auth/me":
-        return False
-    return True
-
-
-_AUTH_EXEMPT_PATHS: frozenset[str] = frozenset(
-    {
-        "/api/v1/auth/login/local",
-        "/api/v1/auth/logout",
-        "/api/v1/auth/register",
-    }
-)
-
-
-def is_auth_endpoint(request: Request) -> bool:
-    """Check if the request is to an auth endpoint.
-
-    Auth endpoints don't need CSRF validation on first call (no token).
-    """
-    return request.url.path.rstrip("/") in _AUTH_EXEMPT_PATHS
-
-
-class CSRFMiddleware(BaseHTTPMiddleware):
-    """Middleware that implements CSRF protection using Double Submit Cookie pattern."""
-
-    def __init__(self, app: ASGIApp) -> None:
-        super().__init__(app)
-
-    async def dispatch(self, request: Request, call_next: Callable) -> Response:
-        _is_auth = is_auth_endpoint(request)
-
-        if should_check_csrf(request) and not _is_auth:
-            cookie_token = request.cookies.get(CSRF_COOKIE_NAME)
-            header_token = request.headers.get(CSRF_HEADER_NAME)
-
-            if not cookie_token or not header_token:
-                return JSONResponse(
-                    status_code=403,
-                    content={"detail": "CSRF token missing. Include X-CSRF-Token header."},
-                )
-
-            if not secrets.compare_digest(cookie_token, header_token):
-                return JSONResponse(
-                    status_code=403,
-                    content={"detail": "CSRF token mismatch."},
-                )
-
-        response = await call_next(request)
-
-        # For auth endpoints that set up session, also set CSRF cookie
-        if _is_auth and request.method == "POST":
-            # Generate a new CSRF token for the session
-            csrf_token = generate_csrf_token()
-            is_https = is_secure_request(request)
-            response.set_cookie(
-                key=CSRF_COOKIE_NAME,
-                value=csrf_token,
-                httponly=False,  # Must be JS-readable for Double Submit Cookie pattern
-                secure=is_https,
-                samesite="strict",
-            )
-
-        return response
-
-
-def get_csrf_token(request: Request) -> str | None:
-    """Get the CSRF token from the current request's cookies.
-
-    This is useful for server-side rendering where you need to embed
-    token in forms or headers.
-    """
-    return request.cookies.get(CSRF_COOKIE_NAME)

backend/app/gateway/deps.py

@@ -1,225 +0,0 @@
-"""Centralized accessors for singleton objects stored on ``app.state``.
-
-**Getters** (used by routers): raise 503 when a required dependency is
-missing, except ``get_store`` and ``get_thread_meta_repo`` which return
-``None``.
-
-Initialization is handled directly in ``app.py`` via :class:`AsyncExitStack`.
-"""
-
-from __future__ import annotations
-
-from collections.abc import AsyncGenerator
-from contextlib import AsyncExitStack, asynccontextmanager
-from typing import TYPE_CHECKING
-
-from fastapi import FastAPI, HTTPException, Request
-
-from deerflow.runtime import RunContext, RunManager
-
-if TYPE_CHECKING:
-    from app.gateway.auth.local_provider import LocalAuthProvider
-    from app.gateway.auth.repositories.sqlite import SQLiteUserRepository
-
-
-@asynccontextmanager
-async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
-    """Bootstrap and tear down all LangGraph runtime singletons.
-
-    Usage in ``app.py``::
-
-        async with langgraph_runtime(app):
-            yield
-    """
-    from deerflow.agents.checkpointer.async_provider import make_checkpointer
-    from deerflow.config import get_app_config
-    from deerflow.persistence.engine import close_engine, get_session_factory, init_engine_from_config
-    from deerflow.runtime import make_store, make_stream_bridge
-    from deerflow.runtime.events.store import make_run_event_store
-
-    async with AsyncExitStack() as stack:
-        app.state.stream_bridge = await stack.enter_async_context(make_stream_bridge())
-
-        # Initialize persistence engine BEFORE checkpointer so that
-        # auto-create-database logic runs first (postgres backend).
-        config = get_app_config()
-        await init_engine_from_config(config.database)
-
-        app.state.checkpointer = await stack.enter_async_context(make_checkpointer())
-        app.state.store = await stack.enter_async_context(make_store())
-
-        # Initialize repositories — one get_session_factory() call for all.
-        sf = get_session_factory()
-        if sf is not None:
-            from deerflow.persistence.feedback import FeedbackRepository
-            from deerflow.persistence.run import RunRepository
-            from deerflow.persistence.thread_meta import ThreadMetaRepository
-
-            app.state.run_store = RunRepository(sf)
-            app.state.feedback_repo = FeedbackRepository(sf)
-            app.state.thread_meta_repo = ThreadMetaRepository(sf)
-        else:
-            from deerflow.persistence.thread_meta import MemoryThreadMetaStore
-            from deerflow.runtime.runs.store.memory import MemoryRunStore
-
-            app.state.run_store = MemoryRunStore()
-            app.state.feedback_repo = None
-            app.state.thread_meta_repo = MemoryThreadMetaStore(app.state.store)
-
-        # Run event store (has its own factory with config-driven backend selection)
-        run_events_config = getattr(config, "run_events", None)
-        app.state.run_event_store = make_run_event_store(run_events_config)
-
-        # RunManager with store backing for persistence
-        app.state.run_manager = RunManager(store=app.state.run_store)
-
-        try:
-            yield
-        finally:
-            await close_engine()
-
-
-# ---------------------------------------------------------------------------
-# Getters -- called by routers per-request
-# ---------------------------------------------------------------------------
-
-
-def _require(attr: str, label: str):
-    """Create a FastAPI dependency that returns ``app.state.<attr>`` or 503."""
-
-    def dep(request: Request):
-        val = getattr(request.app.state, attr, None)
-        if val is None:
-            raise HTTPException(status_code=503, detail=f"{label} not available")
-        return val
-
-    dep.__name__ = dep.__qualname__ = f"get_{attr}"
-    return dep
-
-
-get_stream_bridge = _require("stream_bridge", "Stream bridge")
-get_run_manager = _require("run_manager", "Run manager")
-get_checkpointer = _require("checkpointer", "Checkpointer")
-get_run_event_store = _require("run_event_store", "Run event store")
-get_feedback_repo = _require("feedback_repo", "Feedback")
-get_run_store = _require("run_store", "Run store")
-
-
-def get_store(request: Request):
-    """Return the global store (may be ``None`` if not configured)."""
-    return getattr(request.app.state, "store", None)
-
-
-get_thread_meta_repo = _require("thread_meta_repo", "Thread metadata store")
-
-
-def get_run_context(request: Request) -> RunContext:
-    """Build a :class:`RunContext` from ``app.state`` singletons.
-
-    Returns a *base* context with infrastructure dependencies.  Callers that
-    need per-run fields (e.g. ``follow_up_to_run_id``) should use
-    ``dataclasses.replace(ctx, follow_up_to_run_id=...)`` before passing it
-    to :func:`run_agent`.
-    """
-    from deerflow.config import get_app_config
-
-    return RunContext(
-        checkpointer=get_checkpointer(request),
-        store=get_store(request),
-        event_store=get_run_event_store(request),
-        run_events_config=getattr(get_app_config(), "run_events", None),
-        thread_meta_repo=get_thread_meta_repo(request),
-    )
-
-
-# ---------------------------------------------------------------------------
-# Auth helpers (used by authz.py and auth middleware)
-# ---------------------------------------------------------------------------
-
-# Cached singletons to avoid repeated instantiation per request
-_cached_local_provider: LocalAuthProvider | None = None
-_cached_repo: SQLiteUserRepository | None = None
-
-
-def get_local_provider() -> LocalAuthProvider:
-    """Get or create the cached LocalAuthProvider singleton.
-
-    Must be called after ``init_engine_from_config()`` — the shared
-    session factory is required to construct the user repository.
-    """
-    global _cached_local_provider, _cached_repo
-    if _cached_repo is None:
-        from app.gateway.auth.repositories.sqlite import SQLiteUserRepository
-        from deerflow.persistence.engine import get_session_factory
-
-        sf = get_session_factory()
-        if sf is None:
-            raise RuntimeError("get_local_provider() called before init_engine_from_config(); cannot access users table")
-        _cached_repo = SQLiteUserRepository(sf)
-    if _cached_local_provider is None:
-        from app.gateway.auth.local_provider import LocalAuthProvider
-
-        _cached_local_provider = LocalAuthProvider(repository=_cached_repo)
-    return _cached_local_provider
-
-
-async def get_current_user_from_request(request: Request):
-    """Get the current authenticated user from the request cookie.
-
-    Raises HTTPException 401 if not authenticated.
-    """
-    from app.gateway.auth import decode_token
-    from app.gateway.auth.errors import AuthErrorCode, AuthErrorResponse, TokenError, token_error_to_code
-
-    access_token = request.cookies.get("access_token")
-    if not access_token:
-        raise HTTPException(
-            status_code=401,
-            detail=AuthErrorResponse(code=AuthErrorCode.NOT_AUTHENTICATED, message="Not authenticated").model_dump(),
-        )
-
-    payload = decode_token(access_token)
-    if isinstance(payload, TokenError):
-        raise HTTPException(
-            status_code=401,
-            detail=AuthErrorResponse(code=token_error_to_code(payload), message=f"Token error: {payload.value}").model_dump(),
-        )
-
-    provider = get_local_provider()
-    user = await provider.get_user(payload.sub)
-    if user is None:
-        raise HTTPException(
-            status_code=401,
-            detail=AuthErrorResponse(code=AuthErrorCode.USER_NOT_FOUND, message="User not found").model_dump(),
-        )
-
-    # Token version mismatch → password was changed, token is stale
-    if user.token_version != payload.ver:
-        raise HTTPException(
-            status_code=401,
-            detail=AuthErrorResponse(code=AuthErrorCode.TOKEN_INVALID, message="Token revoked (password changed)").model_dump(),
-        )
-
-    return user
-
-
-async def get_optional_user_from_request(request: Request):
-    """Get optional authenticated user from request.
-
-    Returns None if not authenticated.
-    """
-    try:
-        return await get_current_user_from_request(request)
-    except HTTPException:
-        return None
-
-
-async def get_current_user(request: Request) -> str | None:
-    """Extract user_id from request cookie, or None if not authenticated.
-
-    Thin adapter that returns the string id for callers that only need
-    identification (e.g., ``feedback.py``). Full-user callers should use
-    ``get_current_user_from_request`` or ``get_optional_user_from_request``.
-    """
-    user = await get_optional_user_from_request(request)
-    return str(user.id) if user else None

backend/app/gateway/langgraph_auth.py

@@ -1,106 +0,0 @@
-"""LangGraph Server auth handler — shares JWT logic with Gateway.
-
-Loaded by LangGraph Server via langgraph.json ``auth.path``.
-Reuses the same ``decode_token`` / ``get_auth_config`` as Gateway,
-so both modes validate tokens with the same secret and rules.
-
-Two layers:
-  1. @auth.authenticate — validates JWT cookie, extracts user_id,
-     and enforces CSRF on state-changing methods (POST/PUT/DELETE/PATCH)
-  2. @auth.on — returns metadata filter so each user only sees own threads
-"""
-
-import secrets
-
-from langgraph_sdk import Auth
-
-from app.gateway.auth.errors import TokenError
-from app.gateway.auth.jwt import decode_token
-from app.gateway.deps import get_local_provider
-
-auth = Auth()
-
-# Methods that require CSRF validation (state-changing per RFC 7231).
-_CSRF_METHODS = frozenset({"POST", "PUT", "DELETE", "PATCH"})
-
-
-def _check_csrf(request) -> None:
-    """Enforce Double Submit Cookie CSRF check for state-changing requests.
-
-    Mirrors Gateway's CSRFMiddleware logic so that LangGraph routes
-    proxied directly by nginx have the same CSRF protection.
-    """
-    method = getattr(request, "method", "") or ""
-    if method.upper() not in _CSRF_METHODS:
-        return
-
-    cookie_token = request.cookies.get("csrf_token")
-    header_token = request.headers.get("x-csrf-token")
-
-    if not cookie_token or not header_token:
-        raise Auth.exceptions.HTTPException(
-            status_code=403,
-            detail="CSRF token missing. Include X-CSRF-Token header.",
-        )
-
-    if not secrets.compare_digest(cookie_token, header_token):
-        raise Auth.exceptions.HTTPException(
-            status_code=403,
-            detail="CSRF token mismatch.",
-        )
-
-
-@auth.authenticate
-async def authenticate(request):
-    """Validate the session cookie, decode JWT, and check token_version.
-
-    Same validation chain as Gateway's get_current_user_from_request:
-      cookie → decode JWT → DB lookup → token_version match
-    Also enforces CSRF on state-changing methods.
-    """
-    # CSRF check before authentication so forged cross-site requests
-    # are rejected early, even if the cookie carries a valid JWT.
-    _check_csrf(request)
-
-    token = request.cookies.get("access_token")
-    if not token:
-        raise Auth.exceptions.HTTPException(
-            status_code=401,
-            detail="Not authenticated",
-        )
-
-    payload = decode_token(token)
-    if isinstance(payload, TokenError):
-        raise Auth.exceptions.HTTPException(
-            status_code=401,
-            detail=f"Token error: {payload.value}",
-        )
-
-    user = await get_local_provider().get_user(payload.sub)
-    if user is None:
-        raise Auth.exceptions.HTTPException(
-            status_code=401,
-            detail="User not found",
-        )
-    if user.token_version != payload.ver:
-        raise Auth.exceptions.HTTPException(
-            status_code=401,
-            detail="Token revoked (password changed)",
-        )
-
-    return payload.sub
-
-
-@auth.on
-async def add_owner_filter(ctx: Auth.types.AuthContext, value: dict):
-    """Inject owner_id metadata on writes; filter by owner_id on reads.
-
-    Gateway stores thread ownership as ``metadata.owner_id``.
-    This handler ensures LangGraph Server enforces the same isolation.
-    """
-    # On create/update: stamp owner_id into metadata
-    metadata = value.setdefault("metadata", {})
-    metadata["owner_id"] = ctx.user.identity
-
-    # Return filter dict — LangGraph applies it to search/read/delete
-    return {"owner_id": ctx.user.identity}

backend/app/gateway/path_utils.py

@@ -1,28 +0,0 @@
-"""Shared path resolution for thread virtual paths (e.g. mnt/user-data/outputs/...)."""
-
-from pathlib import Path
-
-from fastapi import HTTPException
-
-from deerflow.config.paths import get_paths
-
-
-def resolve_thread_virtual_path(thread_id: str, virtual_path: str) -> Path:
-    """Resolve a virtual path to the actual filesystem path under thread user-data.
-
-    Args:
-        thread_id: The thread ID.
-        virtual_path: The virtual path as seen inside the sandbox
-                      (e.g., /mnt/user-data/outputs/file.txt).
-
-    Returns:
-        The resolved filesystem path.
-
-    Raises:
-        HTTPException: If the path is invalid or outside allowed directories.
-    """
-    try:
-        return get_paths().resolve_virtual_path(thread_id, virtual_path)
-    except ValueError as e:
-        status = 403 if "traversal" in str(e) else 400
-        raise HTTPException(status_code=status, detail=str(e))

backend/app/gateway/routers/__init__.py

@@ -1,3 +0,0 @@
-from . import artifacts, assistants_compat, mcp, models, skills, suggestions, thread_runs, threads, uploads
-
-__all__ = ["artifacts", "assistants_compat", "mcp", "models", "skills", "suggestions", "threads", "thread_runs", "uploads"]

backend/app/gateway/routers/agents.py

@@ -1,383 +0,0 @@
-"""CRUD API for custom agents."""
-
-import logging
-import re
-import shutil
-
-import yaml
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, Field
-
-from deerflow.config.agents_config import AgentConfig, list_custom_agents, load_agent_config, load_agent_soul
-from deerflow.config.paths import get_paths
-
-logger = logging.getLogger(__name__)
-router = APIRouter(prefix="/api", tags=["agents"])
-
-AGENT_NAME_PATTERN = re.compile(r"^[A-Za-z0-9-]+$")
-
-
-class AgentResponse(BaseModel):
-    """Response model for a custom agent."""
-
-    name: str = Field(..., description="Agent name (hyphen-case)")
-    description: str = Field(default="", description="Agent description")
-    model: str | None = Field(default=None, description="Optional model override")
-    tool_groups: list[str] | None = Field(default=None, description="Optional tool group whitelist")
-    soul: str | None = Field(default=None, description="SOUL.md content")
-
-
-class AgentsListResponse(BaseModel):
-    """Response model for listing all custom agents."""
-
-    agents: list[AgentResponse]
-
-
-class AgentCreateRequest(BaseModel):
-    """Request body for creating a custom agent."""
-
-    name: str = Field(..., description="Agent name (must match ^[A-Za-z0-9-]+$, stored as lowercase)")
-    description: str = Field(default="", description="Agent description")
-    model: str | None = Field(default=None, description="Optional model override")
-    tool_groups: list[str] | None = Field(default=None, description="Optional tool group whitelist")
-    soul: str = Field(default="", description="SOUL.md content — agent personality and behavioral guardrails")
-
-
-class AgentUpdateRequest(BaseModel):
-    """Request body for updating a custom agent."""
-
-    description: str | None = Field(default=None, description="Updated description")
-    model: str | None = Field(default=None, description="Updated model override")
-    tool_groups: list[str] | None = Field(default=None, description="Updated tool group whitelist")
-    soul: str | None = Field(default=None, description="Updated SOUL.md content")
-
-
-def _validate_agent_name(name: str) -> None:
-    """Validate agent name against allowed pattern.
-
-    Args:
-        name: The agent name to validate.
-
-    Raises:
-        HTTPException: 422 if the name is invalid.
-    """
-    if not AGENT_NAME_PATTERN.match(name):
-        raise HTTPException(
-            status_code=422,
-            detail=f"Invalid agent name '{name}'. Must match ^[A-Za-z0-9-]+$ (letters, digits, and hyphens only).",
-        )
-
-
-def _normalize_agent_name(name: str) -> str:
-    """Normalize agent name to lowercase for filesystem storage."""
-    return name.lower()
-
-
-def _agent_config_to_response(agent_cfg: AgentConfig, include_soul: bool = False) -> AgentResponse:
-    """Convert AgentConfig to AgentResponse."""
-    soul: str | None = None
-    if include_soul:
-        soul = load_agent_soul(agent_cfg.name) or ""
-
-    return AgentResponse(
-        name=agent_cfg.name,
-        description=agent_cfg.description,
-        model=agent_cfg.model,
-        tool_groups=agent_cfg.tool_groups,
-        soul=soul,
-    )
-
-
-@router.get(
-    "/agents",
-    response_model=AgentsListResponse,
-    summary="List Custom Agents",
-    description="List all custom agents available in the agents directory, including their soul content.",
-)
-async def list_agents() -> AgentsListResponse:
-    """List all custom agents.
-
-    Returns:
-        List of all custom agents with their metadata and soul content.
-    """
-    try:
-        agents = list_custom_agents()
-        return AgentsListResponse(agents=[_agent_config_to_response(a, include_soul=True) for a in agents])
-    except Exception as e:
-        logger.error(f"Failed to list agents: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to list agents: {str(e)}")
-
-
-@router.get(
-    "/agents/check",
-    summary="Check Agent Name",
-    description="Validate an agent name and check if it is available (case-insensitive).",
-)
-async def check_agent_name(name: str) -> dict:
-    """Check whether an agent name is valid and not yet taken.
-
-    Args:
-        name: The agent name to check.
-
-    Returns:
-        ``{"available": true/false, "name": "<normalized>"}``
-
-    Raises:
-        HTTPException: 422 if the name is invalid.
-    """
-    _validate_agent_name(name)
-    normalized = _normalize_agent_name(name)
-    available = not get_paths().agent_dir(normalized).exists()
-    return {"available": available, "name": normalized}
-
-
-@router.get(
-    "/agents/{name}",
-    response_model=AgentResponse,
-    summary="Get Custom Agent",
-    description="Retrieve details and SOUL.md content for a specific custom agent.",
-)
-async def get_agent(name: str) -> AgentResponse:
-    """Get a specific custom agent by name.
-
-    Args:
-        name: The agent name.
-
-    Returns:
-        Agent details including SOUL.md content.
-
-    Raises:
-        HTTPException: 404 if agent not found.
-    """
-    _validate_agent_name(name)
-    name = _normalize_agent_name(name)
-
-    try:
-        agent_cfg = load_agent_config(name)
-        return _agent_config_to_response(agent_cfg, include_soul=True)
-    except FileNotFoundError:
-        raise HTTPException(status_code=404, detail=f"Agent '{name}' not found")
-    except Exception as e:
-        logger.error(f"Failed to get agent '{name}': {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to get agent: {str(e)}")
-
-
-@router.post(
-    "/agents",
-    response_model=AgentResponse,
-    status_code=201,
-    summary="Create Custom Agent",
-    description="Create a new custom agent with its config and SOUL.md.",
-)
-async def create_agent_endpoint(request: AgentCreateRequest) -> AgentResponse:
-    """Create a new custom agent.
-
-    Args:
-        request: The agent creation request.
-
-    Returns:
-        The created agent details.
-
-    Raises:
-        HTTPException: 409 if agent already exists, 422 if name is invalid.
-    """
-    _validate_agent_name(request.name)
-    normalized_name = _normalize_agent_name(request.name)
-
-    agent_dir = get_paths().agent_dir(normalized_name)
-
-    if agent_dir.exists():
-        raise HTTPException(status_code=409, detail=f"Agent '{normalized_name}' already exists")
-
-    try:
-        agent_dir.mkdir(parents=True, exist_ok=True)
-
-        # Write config.yaml
-        config_data: dict = {"name": normalized_name}
-        if request.description:
-            config_data["description"] = request.description
-        if request.model is not None:
-            config_data["model"] = request.model
-        if request.tool_groups is not None:
-            config_data["tool_groups"] = request.tool_groups
-
-        config_file = agent_dir / "config.yaml"
-        with open(config_file, "w", encoding="utf-8") as f:
-            yaml.dump(config_data, f, default_flow_style=False, allow_unicode=True)
-
-        # Write SOUL.md
-        soul_file = agent_dir / "SOUL.md"
-        soul_file.write_text(request.soul, encoding="utf-8")
-
-        logger.info(f"Created agent '{normalized_name}' at {agent_dir}")
-
-        agent_cfg = load_agent_config(normalized_name)
-        return _agent_config_to_response(agent_cfg, include_soul=True)
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        # Clean up on failure
-        if agent_dir.exists():
-            shutil.rmtree(agent_dir)
-        logger.error(f"Failed to create agent '{request.name}': {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to create agent: {str(e)}")
-
-
-@router.put(
-    "/agents/{name}",
-    response_model=AgentResponse,
-    summary="Update Custom Agent",
-    description="Update an existing custom agent's config and/or SOUL.md.",
-)
-async def update_agent(name: str, request: AgentUpdateRequest) -> AgentResponse:
-    """Update an existing custom agent.
-
-    Args:
-        name: The agent name.
-        request: The update request (all fields optional).
-
-    Returns:
-        The updated agent details.
-
-    Raises:
-        HTTPException: 404 if agent not found.
-    """
-    _validate_agent_name(name)
-    name = _normalize_agent_name(name)
-
-    try:
-        agent_cfg = load_agent_config(name)
-    except FileNotFoundError:
-        raise HTTPException(status_code=404, detail=f"Agent '{name}' not found")
-
-    agent_dir = get_paths().agent_dir(name)
-
-    try:
-        # Update config if any config fields changed
-        config_changed = any(v is not None for v in [request.description, request.model, request.tool_groups])
-
-        if config_changed:
-            updated: dict = {
-                "name": agent_cfg.name,
-                "description": request.description if request.description is not None else agent_cfg.description,
-            }
-            new_model = request.model if request.model is not None else agent_cfg.model
-            if new_model is not None:
-                updated["model"] = new_model
-
-            new_tool_groups = request.tool_groups if request.tool_groups is not None else agent_cfg.tool_groups
-            if new_tool_groups is not None:
-                updated["tool_groups"] = new_tool_groups
-
-            config_file = agent_dir / "config.yaml"
-            with open(config_file, "w", encoding="utf-8") as f:
-                yaml.dump(updated, f, default_flow_style=False, allow_unicode=True)
-
-        # Update SOUL.md if provided
-        if request.soul is not None:
-            soul_path = agent_dir / "SOUL.md"
-            soul_path.write_text(request.soul, encoding="utf-8")
-
-        logger.info(f"Updated agent '{name}'")
-
-        refreshed_cfg = load_agent_config(name)
-        return _agent_config_to_response(refreshed_cfg, include_soul=True)
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Failed to update agent '{name}': {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to update agent: {str(e)}")
-
-
-class UserProfileResponse(BaseModel):
-    """Response model for the global user profile (USER.md)."""
-
-    content: str | None = Field(default=None, description="USER.md content, or null if not yet created")
-
-
-class UserProfileUpdateRequest(BaseModel):
-    """Request body for setting the global user profile."""
-
-    content: str = Field(default="", description="USER.md content — describes the user's background and preferences")
-
-
-@router.get(
-    "/user-profile",
-    response_model=UserProfileResponse,
-    summary="Get User Profile",
-    description="Read the global USER.md file that is injected into all custom agents.",
-)
-async def get_user_profile() -> UserProfileResponse:
-    """Return the current USER.md content.
-
-    Returns:
-        UserProfileResponse with content=None if USER.md does not exist yet.
-    """
-    try:
-        user_md_path = get_paths().user_md_file
-        if not user_md_path.exists():
-            return UserProfileResponse(content=None)
-        raw = user_md_path.read_text(encoding="utf-8").strip()
-        return UserProfileResponse(content=raw or None)
-    except Exception as e:
-        logger.error(f"Failed to read user profile: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to read user profile: {str(e)}")
-
-
-@router.put(
-    "/user-profile",
-    response_model=UserProfileResponse,
-    summary="Update User Profile",
-    description="Write the global USER.md file that is injected into all custom agents.",
-)
-async def update_user_profile(request: UserProfileUpdateRequest) -> UserProfileResponse:
-    """Create or overwrite the global USER.md.
-
-    Args:
-        request: The update request with the new USER.md content.
-
-    Returns:
-        UserProfileResponse with the saved content.
-    """
-    try:
-        paths = get_paths()
-        paths.base_dir.mkdir(parents=True, exist_ok=True)
-        paths.user_md_file.write_text(request.content, encoding="utf-8")
-        logger.info(f"Updated USER.md at {paths.user_md_file}")
-        return UserProfileResponse(content=request.content or None)
-    except Exception as e:
-        logger.error(f"Failed to update user profile: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to update user profile: {str(e)}")
-
-
-@router.delete(
-    "/agents/{name}",
-    status_code=204,
-    summary="Delete Custom Agent",
-    description="Delete a custom agent and all its files (config, SOUL.md, memory).",
-)
-async def delete_agent(name: str) -> None:
-    """Delete a custom agent.
-
-    Args:
-        name: The agent name.
-
-    Raises:
-        HTTPException: 404 if agent not found.
-    """
-    _validate_agent_name(name)
-    name = _normalize_agent_name(name)
-
-    agent_dir = get_paths().agent_dir(name)
-
-    if not agent_dir.exists():
-        raise HTTPException(status_code=404, detail=f"Agent '{name}' not found")
-
-    try:
-        shutil.rmtree(agent_dir)
-        logger.info(f"Deleted agent '{name}' from {agent_dir}")
-    except Exception as e:
-        logger.error(f"Failed to delete agent '{name}': {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to delete agent: {str(e)}")

backend/app/gateway/routers/artifacts.py

@@ -1,183 +0,0 @@
-import logging
-import mimetypes
-import zipfile
-from pathlib import Path
-from urllib.parse import quote
-
-from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import FileResponse, PlainTextResponse, Response
-
-from app.gateway.authz import require_permission
-from app.gateway.path_utils import resolve_thread_virtual_path
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api", tags=["artifacts"])
-
-ACTIVE_CONTENT_MIME_TYPES = {
-    "text/html",
-    "application/xhtml+xml",
-    "image/svg+xml",
-}
-
-
-def _build_content_disposition(disposition_type: str, filename: str) -> str:
-    """Build an RFC 5987 encoded Content-Disposition header value."""
-    return f"{disposition_type}; filename*=UTF-8''{quote(filename)}"
-
-
-def _build_attachment_headers(filename: str, extra_headers: dict[str, str] | None = None) -> dict[str, str]:
-    headers = {"Content-Disposition": _build_content_disposition("attachment", filename)}
-    if extra_headers:
-        headers.update(extra_headers)
-    return headers
-
-
-def is_text_file_by_content(path: Path, sample_size: int = 8192) -> bool:
-    """Check if file is text by examining content for null bytes."""
-    try:
-        with open(path, "rb") as f:
-            chunk = f.read(sample_size)
-            # Text files shouldn't contain null bytes
-            return b"\x00" not in chunk
-    except Exception:
-        return False
-
-
-def _extract_file_from_skill_archive(zip_path: Path, internal_path: str) -> bytes | None:
-    """Extract a file from a .skill ZIP archive.
-
-    Args:
-        zip_path: Path to the .skill file (ZIP archive).
-        internal_path: Path to the file inside the archive (e.g., "SKILL.md").
-
-    Returns:
-        The file content as bytes, or None if not found.
-    """
-    if not zipfile.is_zipfile(zip_path):
-        return None
-
-    try:
-        with zipfile.ZipFile(zip_path, "r") as zip_ref:
-            # List all files in the archive
-            namelist = zip_ref.namelist()
-
-            # Try direct path first
-            if internal_path in namelist:
-                return zip_ref.read(internal_path)
-
-            # Try with any top-level directory prefix (e.g., "skill-name/SKILL.md")
-            for name in namelist:
-                if name.endswith("/" + internal_path) or name == internal_path:
-                    return zip_ref.read(name)
-
-            # Not found
-            return None
-    except (zipfile.BadZipFile, KeyError):
-        return None
-
-
-@router.get(
-    "/threads/{thread_id}/artifacts/{path:path}",
-    summary="Get Artifact File",
-    description="Retrieve an artifact file generated by the AI agent. Text and binary files can be viewed inline, while active web content is always downloaded.",
-)
-@require_permission("threads", "read", owner_check=True)
-async def get_artifact(thread_id: str, path: str, request: Request, download: bool = False) -> Response:
-    """Get an artifact file by its path.
-
-    The endpoint automatically detects file types and returns appropriate content types.
-    Use the `download` query parameter to force file download for non-active content.
-
-    Args:
-        thread_id: The thread ID.
-        path: The artifact path with virtual prefix (e.g., mnt/user-data/outputs/file.txt).
-        request: FastAPI request object (automatically injected).
-
-    Returns:
-        The file content as a FileResponse with appropriate content type:
-        - Active content (HTML/XHTML/SVG): Served as download attachment
-        - Text files: Plain text with proper MIME type
-        - Binary files: Inline display with download option
-
-    Raises:
-        HTTPException:
-            - 400 if path is invalid or not a file
-            - 403 if access denied (path traversal detected)
-            - 404 if file not found
-
-    Query Parameters:
-        download (bool): If true, forces attachment download for file types that are
-            otherwise returned inline or as plain text. Active HTML/XHTML/SVG content
-            is always downloaded regardless of this flag.
-
-    Example:
-        - Get text file inline: `/api/threads/abc123/artifacts/mnt/user-data/outputs/notes.txt`
-        - Download file: `/api/threads/abc123/artifacts/mnt/user-data/outputs/data.csv?download=true`
-        - Active web content such as `.html`, `.xhtml`, and `.svg` artifacts is always downloaded
-    """
-    # Check if this is a request for a file inside a .skill archive (e.g., xxx.skill/SKILL.md)
-    if ".skill/" in path:
-        # Split the path at ".skill/" to get the ZIP file path and internal path
-        skill_marker = ".skill/"
-        marker_pos = path.find(skill_marker)
-        skill_file_path = path[: marker_pos + len(".skill")]  # e.g., "mnt/user-data/outputs/my-skill.skill"
-        internal_path = path[marker_pos + len(skill_marker) :]  # e.g., "SKILL.md"
-
-        actual_skill_path = resolve_thread_virtual_path(thread_id, skill_file_path)
-
-        if not actual_skill_path.exists():
-            raise HTTPException(status_code=404, detail=f"Skill file not found: {skill_file_path}")
-
-        if not actual_skill_path.is_file():
-            raise HTTPException(status_code=400, detail=f"Path is not a file: {skill_file_path}")
-
-        # Extract the file from the .skill archive
-        content = _extract_file_from_skill_archive(actual_skill_path, internal_path)
-        if content is None:
-            raise HTTPException(status_code=404, detail=f"File '{internal_path}' not found in skill archive")
-
-        # Determine MIME type based on the internal file
-        mime_type, _ = mimetypes.guess_type(internal_path)
-        # Add cache headers to avoid repeated ZIP extraction (cache for 5 minutes)
-        cache_headers = {"Cache-Control": "private, max-age=300"}
-        download_name = Path(internal_path).name or actual_skill_path.stem
-        if download or mime_type in ACTIVE_CONTENT_MIME_TYPES:
-            return Response(content=content, media_type=mime_type or "application/octet-stream", headers=_build_attachment_headers(download_name, cache_headers))
-
-        if mime_type and mime_type.startswith("text/"):
-            return PlainTextResponse(content=content.decode("utf-8"), media_type=mime_type, headers=cache_headers)
-
-        # Default to plain text for unknown types that look like text
-        try:
-            return PlainTextResponse(content=content.decode("utf-8"), media_type="text/plain", headers=cache_headers)
-        except UnicodeDecodeError:
-            return Response(content=content, media_type=mime_type or "application/octet-stream", headers=cache_headers)
-
-    actual_path = resolve_thread_virtual_path(thread_id, path)
-
-    logger.info(f"Resolving artifact path: thread_id={thread_id}, requested_path={path}, actual_path={actual_path}")
-
-    if not actual_path.exists():
-        raise HTTPException(status_code=404, detail=f"Artifact not found: {path}")
-
-    if not actual_path.is_file():
-        raise HTTPException(status_code=400, detail=f"Path is not a file: {path}")
-
-    mime_type, _ = mimetypes.guess_type(actual_path)
-
-    if download:
-        return FileResponse(path=actual_path, filename=actual_path.name, media_type=mime_type, headers=_build_attachment_headers(actual_path.name))
-
-    # Always force download for active content types to prevent script execution
-    # in the application origin when users open generated artifacts.
-    if mime_type in ACTIVE_CONTENT_MIME_TYPES:
-        return FileResponse(path=actual_path, filename=actual_path.name, media_type=mime_type, headers=_build_attachment_headers(actual_path.name))
-
-    if mime_type and mime_type.startswith("text/"):
-        return PlainTextResponse(content=actual_path.read_text(encoding="utf-8"), media_type=mime_type)
-
-    if is_text_file_by_content(actual_path):
-        return PlainTextResponse(content=actual_path.read_text(encoding="utf-8"), media_type=mime_type)
-
-    return Response(content=actual_path.read_bytes(), media_type=mime_type, headers={"Content-Disposition": _build_content_disposition("inline", actual_path.name)})

backend/app/gateway/routers/assistants_compat.py

@@ -1,149 +0,0 @@
-"""Assistants compatibility endpoints.
-
-Provides LangGraph Platform-compatible assistants API backed by the
-``langgraph.json`` graph registry and ``config.yaml`` agent definitions.
-
-This is a minimal stub that satisfies the ``useStream`` React hook's
-initialization requirements (``assistants.search()`` and ``assistants.get()``).
-"""
-
-from __future__ import annotations
-
-import logging
-from datetime import UTC, datetime
-from typing import Any
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, Field
-
-logger = logging.getLogger(__name__)
-router = APIRouter(prefix="/api/assistants", tags=["assistants-compat"])
-
-
-class AssistantResponse(BaseModel):
-    assistant_id: str
-    graph_id: str
-    name: str
-    config: dict[str, Any] = Field(default_factory=dict)
-    metadata: dict[str, Any] = Field(default_factory=dict)
-    description: str | None = None
-    created_at: str = ""
-    updated_at: str = ""
-    version: int = 1
-
-
-class AssistantSearchRequest(BaseModel):
-    graph_id: str | None = None
-    name: str | None = None
-    metadata: dict[str, Any] | None = None
-    limit: int = 10
-    offset: int = 0
-
-
-def _get_default_assistant() -> AssistantResponse:
-    """Return the default lead_agent assistant."""
-    now = datetime.now(UTC).isoformat()
-    return AssistantResponse(
-        assistant_id="lead_agent",
-        graph_id="lead_agent",
-        name="lead_agent",
-        config={},
-        metadata={"created_by": "system"},
-        description="DeerFlow lead agent",
-        created_at=now,
-        updated_at=now,
-        version=1,
-    )
-
-
-def _list_assistants() -> list[AssistantResponse]:
-    """List all available assistants from config."""
-    assistants = [_get_default_assistant()]
-
-    # Also include custom agents from config.yaml agents directory
-    try:
-        from deerflow.config.agents_config import list_custom_agents
-
-        for agent_cfg in list_custom_agents():
-            now = datetime.now(UTC).isoformat()
-            assistants.append(
-                AssistantResponse(
-                    assistant_id=agent_cfg.name,
-                    graph_id="lead_agent",  # All agents use the same graph
-                    name=agent_cfg.name,
-                    config={},
-                    metadata={"created_by": "user"},
-                    description=agent_cfg.description or "",
-                    created_at=now,
-                    updated_at=now,
-                    version=1,
-                )
-            )
-    except Exception:
-        logger.debug("Could not load custom agents for assistants list")
-
-    return assistants
-
-
-@router.post("/search", response_model=list[AssistantResponse])
-async def search_assistants(body: AssistantSearchRequest | None = None) -> list[AssistantResponse]:
-    """Search assistants.
-
-    Returns all registered assistants (lead_agent + custom agents from config).
-    """
-    assistants = _list_assistants()
-
-    if body and body.graph_id:
-        assistants = [a for a in assistants if a.graph_id == body.graph_id]
-    if body and body.name:
-        assistants = [a for a in assistants if body.name.lower() in a.name.lower()]
-
-    offset = body.offset if body else 0
-    limit = body.limit if body else 10
-    return assistants[offset : offset + limit]
-
-
-@router.get("/{assistant_id}", response_model=AssistantResponse)
-async def get_assistant_compat(assistant_id: str) -> AssistantResponse:
-    """Get an assistant by ID."""
-    for a in _list_assistants():
-        if a.assistant_id == assistant_id:
-            return a
-    raise HTTPException(status_code=404, detail=f"Assistant {assistant_id} not found")
-
-
-@router.get("/{assistant_id}/graph")
-async def get_assistant_graph(assistant_id: str) -> dict:
-    """Get the graph structure for an assistant.
-
-    Returns a minimal graph description. Full graph introspection is
-    not supported in the Gateway — this stub satisfies SDK validation.
-    """
-    found = any(a.assistant_id == assistant_id for a in _list_assistants())
-    if not found:
-        raise HTTPException(status_code=404, detail=f"Assistant {assistant_id} not found")
-
-    return {
-        "graph_id": "lead_agent",
-        "nodes": [],
-        "edges": [],
-    }
-
-
-@router.get("/{assistant_id}/schemas")
-async def get_assistant_schemas(assistant_id: str) -> dict:
-    """Get JSON schemas for an assistant's input/output/state.
-
-    Returns empty schemas — full introspection not supported in Gateway.
-    """
-    found = any(a.assistant_id == assistant_id for a in _list_assistants())
-    if not found:
-        raise HTTPException(status_code=404, detail=f"Assistant {assistant_id} not found")
-
-    return {
-        "graph_id": "lead_agent",
-        "input_schema": {},
-        "output_schema": {},
-        "state_schema": {},
-        "config_schema": {},
-    }

backend/app/gateway/routers/auth.py

@@ -1,303 +0,0 @@
-"""Authentication endpoints."""
-
-import logging
-import time
-
-from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
-from fastapi.security import OAuth2PasswordRequestForm
-from pydantic import BaseModel, EmailStr, Field
-
-from app.gateway.auth import (
-    UserResponse,
-    create_access_token,
-)
-from app.gateway.auth.config import get_auth_config
-from app.gateway.auth.errors import AuthErrorCode, AuthErrorResponse
-from app.gateway.csrf_middleware import is_secure_request
-from app.gateway.deps import get_current_user_from_request, get_local_provider
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api/v1/auth", tags=["auth"])
-
-
-# ── Request/Response Models ──────────────────────────────────────────────
-
-
-class LoginResponse(BaseModel):
-    """Response model for login — token only lives in HttpOnly cookie."""
-
-    expires_in: int  # seconds
-    needs_setup: bool = False
-
-
-class RegisterRequest(BaseModel):
-    """Request model for user registration."""
-
-    email: EmailStr
-    password: str = Field(..., min_length=8)
-
-
-class ChangePasswordRequest(BaseModel):
-    """Request model for password change (also handles setup flow)."""
-
-    current_password: str
-    new_password: str = Field(..., min_length=8)
-    new_email: EmailStr | None = None
-
-
-class MessageResponse(BaseModel):
-    """Generic message response."""
-
-    message: str
-
-
-# ── Helpers ───────────────────────────────────────────────────────────────
-
-
-def _set_session_cookie(response: Response, token: str, request: Request) -> None:
-    """Set the access_token HttpOnly cookie on the response."""
-    config = get_auth_config()
-    is_https = is_secure_request(request)
-    response.set_cookie(
-        key="access_token",
-        value=token,
-        httponly=True,
-        secure=is_https,
-        samesite="lax",
-        max_age=config.token_expiry_days * 24 * 3600 if is_https else None,
-    )
-
-
-# ── Rate Limiting ────────────────────────────────────────────────────────
-# In-process dict — not shared across workers. Sufficient for single-worker deployments.
-
-_MAX_LOGIN_ATTEMPTS = 5
-_LOCKOUT_SECONDS = 300  # 5 minutes
-
-# ip → (fail_count, lock_until_timestamp)
-_login_attempts: dict[str, tuple[int, float]] = {}
-
-
-def _get_client_ip(request: Request) -> str:
-    """Extract the real client IP for rate limiting.
-
-    Uses ``X-Real-IP`` header set by nginx (``proxy_set_header X-Real-IP
-    $remote_addr``).  Nginx unconditionally overwrites any client-supplied
-    ``X-Real-IP``, so the value seen by Gateway is always the TCP peer IP
-    that nginx observed — it cannot be spoofed by the client.
-
-    ``request.client.host`` is NOT reliable because uvicorn's default
-    ``proxy_headers=True`` replaces it with the *first* entry from
-    ``X-Forwarded-For``, which IS client-spoofable.
-
-    ``X-Forwarded-For`` is intentionally NOT used for the same reason.
-    """
-    real_ip = request.headers.get("x-real-ip", "").strip()
-    if real_ip:
-        return real_ip
-
-    # Fallback: direct connection without nginx (e.g. unit tests, dev).
-    return request.client.host if request.client else "unknown"
-
-
-def _check_rate_limit(ip: str) -> None:
-    """Raise 429 if the IP is currently locked out."""
-    record = _login_attempts.get(ip)
-    if record is None:
-        return
-    fail_count, lock_until = record
-    if fail_count >= _MAX_LOGIN_ATTEMPTS:
-        if time.time() < lock_until:
-            raise HTTPException(
-                status_code=429,
-                detail="Too many login attempts. Try again later.",
-            )
-        del _login_attempts[ip]
-
-
-_MAX_TRACKED_IPS = 10000
-
-
-def _record_login_failure(ip: str) -> None:
-    """Record a failed login attempt for the given IP."""
-    # Evict expired lockouts when dict grows too large
-    if len(_login_attempts) >= _MAX_TRACKED_IPS:
-        now = time.time()
-        expired = [k for k, (c, t) in _login_attempts.items() if c >= _MAX_LOGIN_ATTEMPTS and now >= t]
-        for k in expired:
-            del _login_attempts[k]
-        # If still too large, evict cheapest-to-lose half: below-threshold
-        # IPs (lock_until=0.0) sort first, then earliest-expiring lockouts.
-        if len(_login_attempts) >= _MAX_TRACKED_IPS:
-            by_time = sorted(_login_attempts.items(), key=lambda kv: kv[1][1])
-            for k, _ in by_time[: len(by_time) // 2]:
-                del _login_attempts[k]
-
-    record = _login_attempts.get(ip)
-    if record is None:
-        _login_attempts[ip] = (1, 0.0)
-    else:
-        new_count = record[0] + 1
-        lock_until = time.time() + _LOCKOUT_SECONDS if new_count >= _MAX_LOGIN_ATTEMPTS else 0.0
-        _login_attempts[ip] = (new_count, lock_until)
-
-
-def _record_login_success(ip: str) -> None:
-    """Clear failure counter for the given IP on successful login."""
-    _login_attempts.pop(ip, None)
-
-
-# ── Endpoints ─────────────────────────────────────────────────────────────
-
-
-@router.post("/login/local", response_model=LoginResponse)
-async def login_local(
-    request: Request,
-    response: Response,
-    form_data: OAuth2PasswordRequestForm = Depends(),
-):
-    """Local email/password login."""
-    client_ip = _get_client_ip(request)
-    _check_rate_limit(client_ip)
-
-    user = await get_local_provider().authenticate({"email": form_data.username, "password": form_data.password})
-
-    if user is None:
-        _record_login_failure(client_ip)
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=AuthErrorResponse(code=AuthErrorCode.INVALID_CREDENTIALS, message="Incorrect email or password").model_dump(),
-        )
-
-    _record_login_success(client_ip)
-    token = create_access_token(str(user.id), token_version=user.token_version)
-    _set_session_cookie(response, token, request)
-
-    return LoginResponse(
-        expires_in=get_auth_config().token_expiry_days * 24 * 3600,
-        needs_setup=user.needs_setup,
-    )
-
-
-@router.post("/register", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
-async def register(request: Request, response: Response, body: RegisterRequest):
-    """Register a new user account (always 'user' role).
-
-    Admin is auto-created on first boot. This endpoint creates regular users.
-    Auto-login by setting the session cookie.
-    """
-    try:
-        user = await get_local_provider().create_user(email=body.email, password=body.password, system_role="user")
-    except ValueError:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=AuthErrorResponse(code=AuthErrorCode.EMAIL_ALREADY_EXISTS, message="Email already registered").model_dump(),
-        )
-
-    token = create_access_token(str(user.id), token_version=user.token_version)
-    _set_session_cookie(response, token, request)
-
-    return UserResponse(id=str(user.id), email=user.email, system_role=user.system_role)
-
-
-@router.post("/logout", response_model=MessageResponse)
-async def logout(request: Request, response: Response):
-    """Logout current user by clearing the cookie."""
-    response.delete_cookie(key="access_token", secure=is_secure_request(request), samesite="lax")
-    return MessageResponse(message="Successfully logged out")
-
-
-@router.post("/change-password", response_model=MessageResponse)
-async def change_password(request: Request, response: Response, body: ChangePasswordRequest):
-    """Change password for the currently authenticated user.
-
-    Also handles the first-boot setup flow:
-    - If new_email is provided, updates email (checks uniqueness)
-    - If user.needs_setup is True and new_email is given, clears needs_setup
-    - Always increments token_version to invalidate old sessions
-    - Re-issues session cookie with new token_version
-    """
-    from app.gateway.auth.password import hash_password_async, verify_password_async
-
-    user = await get_current_user_from_request(request)
-
-    if user.password_hash is None:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=AuthErrorResponse(code=AuthErrorCode.INVALID_CREDENTIALS, message="OAuth users cannot change password").model_dump())
-
-    if not await verify_password_async(body.current_password, user.password_hash):
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=AuthErrorResponse(code=AuthErrorCode.INVALID_CREDENTIALS, message="Current password is incorrect").model_dump())
-
-    provider = get_local_provider()
-
-    # Update email if provided
-    if body.new_email is not None:
-        existing = await provider.get_user_by_email(body.new_email)
-        if existing and str(existing.id) != str(user.id):
-            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=AuthErrorResponse(code=AuthErrorCode.EMAIL_ALREADY_EXISTS, message="Email already in use").model_dump())
-        user.email = body.new_email
-
-    # Update password + bump version
-    user.password_hash = await hash_password_async(body.new_password)
-    user.token_version += 1
-
-    # Clear setup flag if this is the setup flow
-    if user.needs_setup and body.new_email is not None:
-        user.needs_setup = False
-
-    await provider.update_user(user)
-
-    # Re-issue cookie with new token_version
-    token = create_access_token(str(user.id), token_version=user.token_version)
-    _set_session_cookie(response, token, request)
-
-    return MessageResponse(message="Password changed successfully")
-
-
-@router.get("/me", response_model=UserResponse)
-async def get_me(request: Request):
-    """Get current authenticated user info."""
-    user = await get_current_user_from_request(request)
-    return UserResponse(id=str(user.id), email=user.email, system_role=user.system_role, needs_setup=user.needs_setup)
-
-
-@router.get("/setup-status")
-async def setup_status():
-    """Check if admin account exists. Always False after first boot."""
-    user_count = await get_local_provider().count_users()
-    return {"needs_setup": user_count == 0}
-
-
-# ── OAuth Endpoints (Future/Placeholder) ─────────────────────────────────
-
-
-@router.get("/oauth/{provider}")
-async def oauth_login(provider: str):
-    """Initiate OAuth login flow.
-
-    Redirects to the OAuth provider's authorization URL.
-    Currently a placeholder - requires OAuth provider implementation.
-    """
-    if provider not in ["github", "google"]:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Unsupported OAuth provider: {provider}",
-        )
-
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED,
-        detail="OAuth login not yet implemented",
-    )
-
-
-@router.get("/callback/{provider}")
-async def oauth_callback(provider: str, code: str, state: str):
-    """OAuth callback endpoint.
-
-    Handles the OAuth provider's callback after user authorization.
-    Currently a placeholder.
-    """
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED,
-        detail="OAuth callback not yet implemented",
-    )

backend/app/gateway/routers/channels.py

@@ -1,52 +0,0 @@
-"""Gateway router for IM channel management."""
-
-from __future__ import annotations
-
-import logging
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api/channels", tags=["channels"])
-
-
-class ChannelStatusResponse(BaseModel):
-    service_running: bool
-    channels: dict[str, dict]
-
-
-class ChannelRestartResponse(BaseModel):
-    success: bool
-    message: str
-
-
-@router.get("/", response_model=ChannelStatusResponse)
-async def get_channels_status() -> ChannelStatusResponse:
-    """Get the status of all IM channels."""
-    from app.channels.service import get_channel_service
-
-    service = get_channel_service()
-    if service is None:
-        return ChannelStatusResponse(service_running=False, channels={})
-    status = service.get_status()
-    return ChannelStatusResponse(**status)
-
-
-@router.post("/{name}/restart", response_model=ChannelRestartResponse)
-async def restart_channel(name: str) -> ChannelRestartResponse:
-    """Restart a specific IM channel."""
-    from app.channels.service import get_channel_service
-
-    service = get_channel_service()
-    if service is None:
-        raise HTTPException(status_code=503, detail="Channel service is not running")
-
-    success = await service.restart_channel(name)
-    if success:
-        logger.info("Channel %s restarted successfully", name)
-        return ChannelRestartResponse(success=True, message=f"Channel {name} restarted successfully")
-    else:
-        logger.warning("Failed to restart channel %s", name)
-        return ChannelRestartResponse(success=False, message=f"Failed to restart channel {name}")

backend/app/gateway/routers/feedback.py

@@ -1,132 +0,0 @@
-"""Feedback endpoints — create, list, stats, delete.
-
-Allows users to submit thumbs-up/down feedback on runs,
-optionally scoped to a specific message.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel, Field
-
-from app.gateway.authz import require_permission
-from app.gateway.deps import get_current_user, get_feedback_repo, get_run_store
-
-logger = logging.getLogger(__name__)
-router = APIRouter(prefix="/api/threads", tags=["feedback"])
-
-
-# ---------------------------------------------------------------------------
-# Request / response models
-# ---------------------------------------------------------------------------
-
-
-class FeedbackCreateRequest(BaseModel):
-    rating: int = Field(..., description="Feedback rating: +1 (positive) or -1 (negative)")
-    comment: str | None = Field(default=None, description="Optional text feedback")
-    message_id: str | None = Field(default=None, description="Optional: scope feedback to a specific message")
-
-
-class FeedbackResponse(BaseModel):
-    feedback_id: str
-    run_id: str
-    thread_id: str
-    owner_id: str | None = None
-    message_id: str | None = None
-    rating: int
-    comment: str | None = None
-    created_at: str = ""
-
-
-class FeedbackStatsResponse(BaseModel):
-    run_id: str
-    total: int = 0
-    positive: int = 0
-    negative: int = 0
-
-
-# ---------------------------------------------------------------------------
-# Endpoints
-# ---------------------------------------------------------------------------
-
-
-@router.post("/{thread_id}/runs/{run_id}/feedback", response_model=FeedbackResponse)
-@require_permission("threads", "write", owner_check=True)
-async def create_feedback(
-    thread_id: str,
-    run_id: str,
-    body: FeedbackCreateRequest,
-    request: Request,
-) -> dict[str, Any]:
-    """Submit feedback (thumbs-up/down) for a run."""
-    if body.rating not in (1, -1):
-        raise HTTPException(status_code=400, detail="rating must be +1 or -1")
-
-    user_id = await get_current_user(request)
-
-    # Validate run exists and belongs to thread
-    run_store = get_run_store(request)
-    run = await run_store.get(run_id)
-    if run is None:
-        raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
-    if run.get("thread_id") != thread_id:
-        raise HTTPException(status_code=404, detail=f"Run {run_id} not found in thread {thread_id}")
-
-    feedback_repo = get_feedback_repo(request)
-    return await feedback_repo.create(
-        run_id=run_id,
-        thread_id=thread_id,
-        rating=body.rating,
-        owner_id=user_id,
-        message_id=body.message_id,
-        comment=body.comment,
-    )
-
-
-@router.get("/{thread_id}/runs/{run_id}/feedback", response_model=list[FeedbackResponse])
-@require_permission("threads", "read", owner_check=True)
-async def list_feedback(
-    thread_id: str,
-    run_id: str,
-    request: Request,
-) -> list[dict[str, Any]]:
-    """List all feedback for a run."""
-    feedback_repo = get_feedback_repo(request)
-    return await feedback_repo.list_by_run(thread_id, run_id)
-
-
-@router.get("/{thread_id}/runs/{run_id}/feedback/stats", response_model=FeedbackStatsResponse)
-@require_permission("threads", "read", owner_check=True)
-async def feedback_stats(
-    thread_id: str,
-    run_id: str,
-    request: Request,
-) -> dict[str, Any]:
-    """Get aggregated feedback stats (positive/negative counts) for a run."""
-    feedback_repo = get_feedback_repo(request)
-    return await feedback_repo.aggregate_by_run(thread_id, run_id)
-
-
-@router.delete("/{thread_id}/runs/{run_id}/feedback/{feedback_id}")
-@require_permission("threads", "delete", owner_check=True)
-async def delete_feedback(
-    thread_id: str,
-    run_id: str,
-    feedback_id: str,
-    request: Request,
-) -> dict[str, bool]:
-    """Delete a feedback record."""
-    feedback_repo = get_feedback_repo(request)
-    # Verify feedback belongs to the specified thread/run before deleting
-    existing = await feedback_repo.get(feedback_id)
-    if existing is None:
-        raise HTTPException(status_code=404, detail=f"Feedback {feedback_id} not found")
-    if existing.get("thread_id") != thread_id or existing.get("run_id") != run_id:
-        raise HTTPException(status_code=404, detail=f"Feedback {feedback_id} not found in run {run_id}")
-    deleted = await feedback_repo.delete(feedback_id)
-    if not deleted:
-        raise HTTPException(status_code=404, detail=f"Feedback {feedback_id} not found")
-    return {"success": True}

backend/app/gateway/routers/mcp.py

@@ -1,169 +0,0 @@
-import json
-import logging
-from pathlib import Path
-from typing import Literal
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, Field
-
-from deerflow.config.extensions_config import ExtensionsConfig, get_extensions_config, reload_extensions_config
-
-logger = logging.getLogger(__name__)
-router = APIRouter(prefix="/api", tags=["mcp"])
-
-
-class McpOAuthConfigResponse(BaseModel):
-    """OAuth configuration for an MCP server."""
-
-    enabled: bool = Field(default=True, description="Whether OAuth token injection is enabled")
-    token_url: str = Field(default="", description="OAuth token endpoint URL")
-    grant_type: Literal["client_credentials", "refresh_token"] = Field(default="client_credentials", description="OAuth grant type")
-    client_id: str | None = Field(default=None, description="OAuth client ID")
-    client_secret: str | None = Field(default=None, description="OAuth client secret")
-    refresh_token: str | None = Field(default=None, description="OAuth refresh token")
-    scope: str | None = Field(default=None, description="OAuth scope")
-    audience: str | None = Field(default=None, description="OAuth audience")
-    token_field: str = Field(default="access_token", description="Token response field containing access token")
-    token_type_field: str = Field(default="token_type", description="Token response field containing token type")
-    expires_in_field: str = Field(default="expires_in", description="Token response field containing expires-in seconds")
-    default_token_type: str = Field(default="Bearer", description="Default token type when response omits token_type")
-    refresh_skew_seconds: int = Field(default=60, description="Refresh this many seconds before expiry")
-    extra_token_params: dict[str, str] = Field(default_factory=dict, description="Additional form params sent to token endpoint")
-
-
-class McpServerConfigResponse(BaseModel):
-    """Response model for MCP server configuration."""
-
-    enabled: bool = Field(default=True, description="Whether this MCP server is enabled")
-    type: str = Field(default="stdio", description="Transport type: 'stdio', 'sse', or 'http'")
-    command: str | None = Field(default=None, description="Command to execute to start the MCP server (for stdio type)")
-    args: list[str] = Field(default_factory=list, description="Arguments to pass to the command (for stdio type)")
-    env: dict[str, str] = Field(default_factory=dict, description="Environment variables for the MCP server")
-    url: str | None = Field(default=None, description="URL of the MCP server (for sse or http type)")
-    headers: dict[str, str] = Field(default_factory=dict, description="HTTP headers to send (for sse or http type)")
-    oauth: McpOAuthConfigResponse | None = Field(default=None, description="OAuth configuration for MCP HTTP/SSE servers")
-    description: str = Field(default="", description="Human-readable description of what this MCP server provides")
-
-
-class McpConfigResponse(BaseModel):
-    """Response model for MCP configuration."""
-
-    mcp_servers: dict[str, McpServerConfigResponse] = Field(
-        default_factory=dict,
-        description="Map of MCP server name to configuration",
-    )
-
-
-class McpConfigUpdateRequest(BaseModel):
-    """Request model for updating MCP configuration."""
-
-    mcp_servers: dict[str, McpServerConfigResponse] = Field(
-        ...,
-        description="Map of MCP server name to configuration",
-    )
-
-
-@router.get(
-    "/mcp/config",
-    response_model=McpConfigResponse,
-    summary="Get MCP Configuration",
-    description="Retrieve the current Model Context Protocol (MCP) server configurations.",
-)
-async def get_mcp_configuration() -> McpConfigResponse:
-    """Get the current MCP configuration.
-
-    Returns:
-        The current MCP configuration with all servers.
-
-    Example:
-        ```json
-        {
-            "mcp_servers": {
-                "github": {
-                    "enabled": true,
-                    "command": "npx",
-                    "args": ["-y", "@modelcontextprotocol/server-github"],
-                    "env": {"GITHUB_TOKEN": "ghp_xxx"},
-                    "description": "GitHub MCP server for repository operations"
-                }
-            }
-        }
-        ```
-    """
-    config = get_extensions_config()
-
-    return McpConfigResponse(mcp_servers={name: McpServerConfigResponse(**server.model_dump()) for name, server in config.mcp_servers.items()})
-
-
-@router.put(
-    "/mcp/config",
-    response_model=McpConfigResponse,
-    summary="Update MCP Configuration",
-    description="Update Model Context Protocol (MCP) server configurations and save to file.",
-)
-async def update_mcp_configuration(request: McpConfigUpdateRequest) -> McpConfigResponse:
-    """Update the MCP configuration.
-
-    This will:
-    1. Save the new configuration to the mcp_config.json file
-    2. Reload the configuration cache
-    3. Reset MCP tools cache to trigger reinitialization
-
-    Args:
-        request: The new MCP configuration to save.
-
-    Returns:
-        The updated MCP configuration.
-
-    Raises:
-        HTTPException: 500 if the configuration file cannot be written.
-
-    Example Request:
-        ```json
-        {
-            "mcp_servers": {
-                "github": {
-                    "enabled": true,
-                    "command": "npx",
-                    "args": ["-y", "@modelcontextprotocol/server-github"],
-                    "env": {"GITHUB_TOKEN": "$GITHUB_TOKEN"},
-                    "description": "GitHub MCP server for repository operations"
-                }
-            }
-        }
-        ```
-    """
-    try:
-        # Get the current config path (or determine where to save it)
-        config_path = ExtensionsConfig.resolve_config_path()
-
-        # If no config file exists, create one in the parent directory (project root)
-        if config_path is None:
-            config_path = Path.cwd().parent / "extensions_config.json"
-            logger.info(f"No existing extensions config found. Creating new config at: {config_path}")
-
-        # Load current config to preserve skills configuration
-        current_config = get_extensions_config()
-
-        # Convert request to dict format for JSON serialization
-        config_data = {
-            "mcpServers": {name: server.model_dump() for name, server in request.mcp_servers.items()},
-            "skills": {name: {"enabled": skill.enabled} for name, skill in current_config.skills.items()},
-        }
-
-        # Write the configuration to file
-        with open(config_path, "w", encoding="utf-8") as f:
-            json.dump(config_data, f, indent=2)
-
-        logger.info(f"MCP configuration updated and saved to: {config_path}")
-
-        # NOTE: No need to reload/reset cache here - LangGraph Server (separate process)
-        # will detect config file changes via mtime and reinitialize MCP tools automatically
-
-        # Reload the configuration and update the global cache
-        reloaded_config = reload_extensions_config()
-        return McpConfigResponse(mcp_servers={name: McpServerConfigResponse(**server.model_dump()) for name, server in reloaded_config.mcp_servers.items()})
-
-    except Exception as e:
-        logger.error(f"Failed to update MCP configuration: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to update MCP configuration: {str(e)}")

backend/app/gateway/routers/memory.py

@@ -1,353 +0,0 @@
-"""Memory API router for retrieving and managing global memory data."""
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, Field
-
-from deerflow.agents.memory.updater import (
-    clear_memory_data,
-    create_memory_fact,
-    delete_memory_fact,
-    get_memory_data,
-    import_memory_data,
-    reload_memory_data,
-    update_memory_fact,
-)
-from deerflow.config.memory_config import get_memory_config
-
-router = APIRouter(prefix="/api", tags=["memory"])
-
-
-class ContextSection(BaseModel):
-    """Model for context sections (user and history)."""
-
-    summary: str = Field(default="", description="Summary content")
-    updatedAt: str = Field(default="", description="Last update timestamp")
-
-
-class UserContext(BaseModel):
-    """Model for user context."""
-
-    workContext: ContextSection = Field(default_factory=ContextSection)
-    personalContext: ContextSection = Field(default_factory=ContextSection)
-    topOfMind: ContextSection = Field(default_factory=ContextSection)
-
-
-class HistoryContext(BaseModel):
-    """Model for history context."""
-
-    recentMonths: ContextSection = Field(default_factory=ContextSection)
-    earlierContext: ContextSection = Field(default_factory=ContextSection)
-    longTermBackground: ContextSection = Field(default_factory=ContextSection)
-
-
-class Fact(BaseModel):
-    """Model for a memory fact."""
-
-    id: str = Field(..., description="Unique identifier for the fact")
-    content: str = Field(..., description="Fact content")
-    category: str = Field(default="context", description="Fact category")
-    confidence: float = Field(default=0.5, description="Confidence score (0-1)")
-    createdAt: str = Field(default="", description="Creation timestamp")
-    source: str = Field(default="unknown", description="Source thread ID")
-    sourceError: str | None = Field(default=None, description="Optional description of the prior mistake or wrong approach")
-
-
-class MemoryResponse(BaseModel):
-    """Response model for memory data."""
-
-    version: str = Field(default="1.0", description="Memory schema version")
-    lastUpdated: str = Field(default="", description="Last update timestamp")
-    user: UserContext = Field(default_factory=UserContext)
-    history: HistoryContext = Field(default_factory=HistoryContext)
-    facts: list[Fact] = Field(default_factory=list)
-
-
-def _map_memory_fact_value_error(exc: ValueError) -> HTTPException:
-    """Convert updater validation errors into stable API responses."""
-    if exc.args and exc.args[0] == "confidence":
-        detail = "Invalid confidence value; must be between 0 and 1."
-    else:
-        detail = "Memory fact content cannot be empty."
-    return HTTPException(status_code=400, detail=detail)
-
-
-class FactCreateRequest(BaseModel):
-    """Request model for creating a memory fact."""
-
-    content: str = Field(..., min_length=1, description="Fact content")
-    category: str = Field(default="context", description="Fact category")
-    confidence: float = Field(default=0.5, ge=0.0, le=1.0, description="Confidence score (0-1)")
-
-
-class FactPatchRequest(BaseModel):
-    """PATCH request model that preserves existing values for omitted fields."""
-
-    content: str | None = Field(default=None, min_length=1, description="Fact content")
-    category: str | None = Field(default=None, description="Fact category")
-    confidence: float | None = Field(default=None, ge=0.0, le=1.0, description="Confidence score (0-1)")
-
-
-class MemoryConfigResponse(BaseModel):
-    """Response model for memory configuration."""
-
-    enabled: bool = Field(..., description="Whether memory is enabled")
-    storage_path: str = Field(..., description="Path to memory storage file")
-    debounce_seconds: int = Field(..., description="Debounce time for memory updates")
-    max_facts: int = Field(..., description="Maximum number of facts to store")
-    fact_confidence_threshold: float = Field(..., description="Minimum confidence threshold for facts")
-    injection_enabled: bool = Field(..., description="Whether memory injection is enabled")
-    max_injection_tokens: int = Field(..., description="Maximum tokens for memory injection")
-
-
-class MemoryStatusResponse(BaseModel):
-    """Response model for memory status."""
-
-    config: MemoryConfigResponse
-    data: MemoryResponse
-
-
-@router.get(
-    "/memory",
-    response_model=MemoryResponse,
-    response_model_exclude_none=True,
-    summary="Get Memory Data",
-    description="Retrieve the current global memory data including user context, history, and facts.",
-)
-async def get_memory() -> MemoryResponse:
-    """Get the current global memory data.
-
-    Returns:
-        The current memory data with user context, history, and facts.
-
-    Example Response:
-        ```json
-        {
-            "version": "1.0",
-            "lastUpdated": "2024-01-15T10:30:00Z",
-            "user": {
-                "workContext": {"summary": "Working on DeerFlow project", "updatedAt": "..."},
-                "personalContext": {"summary": "Prefers concise responses", "updatedAt": "..."},
-                "topOfMind": {"summary": "Building memory API", "updatedAt": "..."}
-            },
-            "history": {
-                "recentMonths": {"summary": "Recent development activities", "updatedAt": "..."},
-                "earlierContext": {"summary": "", "updatedAt": ""},
-                "longTermBackground": {"summary": "", "updatedAt": ""}
-            },
-            "facts": [
-                {
-                    "id": "fact_abc123",
-                    "content": "User prefers TypeScript over JavaScript",
-                    "category": "preference",
-                    "confidence": 0.9,
-                    "createdAt": "2024-01-15T10:30:00Z",
-                    "source": "thread_xyz"
-                }
-            ]
-        }
-        ```
-    """
-    memory_data = get_memory_data()
-    return MemoryResponse(**memory_data)
-
-
-@router.post(
-    "/memory/reload",
-    response_model=MemoryResponse,
-    response_model_exclude_none=True,
-    summary="Reload Memory Data",
-    description="Reload memory data from the storage file, refreshing the in-memory cache.",
-)
-async def reload_memory() -> MemoryResponse:
-    """Reload memory data from file.
-
-    This forces a reload of the memory data from the storage file,
-    useful when the file has been modified externally.
-
-    Returns:
-        The reloaded memory data.
-    """
-    memory_data = reload_memory_data()
-    return MemoryResponse(**memory_data)
-
-
-@router.delete(
-    "/memory",
-    response_model=MemoryResponse,
-    response_model_exclude_none=True,
-    summary="Clear All Memory Data",
-    description="Delete all saved memory data and reset the memory structure to an empty state.",
-)
-async def clear_memory() -> MemoryResponse:
-    """Clear all persisted memory data."""
-    try:
-        memory_data = clear_memory_data()
-    except OSError as exc:
-        raise HTTPException(status_code=500, detail="Failed to clear memory data.") from exc
-
-    return MemoryResponse(**memory_data)
-
-
-@router.post(
-    "/memory/facts",
-    response_model=MemoryResponse,
-    response_model_exclude_none=True,
-    summary="Create Memory Fact",
-    description="Create a single saved memory fact manually.",
-)
-async def create_memory_fact_endpoint(request: FactCreateRequest) -> MemoryResponse:
-    """Create a single fact manually."""
-    try:
-        memory_data = create_memory_fact(
-            content=request.content,
-            category=request.category,
-            confidence=request.confidence,
-        )
-    except ValueError as exc:
-        raise _map_memory_fact_value_error(exc) from exc
-    except OSError as exc:
-        raise HTTPException(status_code=500, detail="Failed to create memory fact.") from exc
-
-    return MemoryResponse(**memory_data)
-
-
-@router.delete(
-    "/memory/facts/{fact_id}",
-    response_model=MemoryResponse,
-    response_model_exclude_none=True,
-    summary="Delete Memory Fact",
-    description="Delete a single saved memory fact by its fact id.",
-)
-async def delete_memory_fact_endpoint(fact_id: str) -> MemoryResponse:
-    """Delete a single fact from memory by fact id."""
-    try:
-        memory_data = delete_memory_fact(fact_id)
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=f"Memory fact '{fact_id}' not found.") from exc
-    except OSError as exc:
-        raise HTTPException(status_code=500, detail="Failed to delete memory fact.") from exc
-
-    return MemoryResponse(**memory_data)
-
-
-@router.patch(
-    "/memory/facts/{fact_id}",
-    response_model=MemoryResponse,
-    response_model_exclude_none=True,
-    summary="Patch Memory Fact",
-    description="Partially update a single saved memory fact by its fact id while preserving omitted fields.",
-)
-async def update_memory_fact_endpoint(fact_id: str, request: FactPatchRequest) -> MemoryResponse:
-    """Partially update a single fact manually."""
-    try:
-        memory_data = update_memory_fact(
-            fact_id=fact_id,
-            content=request.content,
-            category=request.category,
-            confidence=request.confidence,
-        )
-    except ValueError as exc:
-        raise _map_memory_fact_value_error(exc) from exc
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=f"Memory fact '{fact_id}' not found.") from exc
-    except OSError as exc:
-        raise HTTPException(status_code=500, detail="Failed to update memory fact.") from exc
-
-    return MemoryResponse(**memory_data)
-
-
-@router.get(
-    "/memory/export",
-    response_model=MemoryResponse,
-    response_model_exclude_none=True,
-    summary="Export Memory Data",
-    description="Export the current global memory data as JSON for backup or transfer.",
-)
-async def export_memory() -> MemoryResponse:
-    """Export the current memory data."""
-    memory_data = get_memory_data()
-    return MemoryResponse(**memory_data)
-
-
-@router.post(
-    "/memory/import",
-    response_model=MemoryResponse,
-    response_model_exclude_none=True,
-    summary="Import Memory Data",
-    description="Import and overwrite the current global memory data from a JSON payload.",
-)
-async def import_memory(request: MemoryResponse) -> MemoryResponse:
-    """Import and persist memory data."""
-    try:
-        memory_data = import_memory_data(request.model_dump())
-    except OSError as exc:
-        raise HTTPException(status_code=500, detail="Failed to import memory data.") from exc
-
-    return MemoryResponse(**memory_data)
-
-
-@router.get(
-    "/memory/config",
-    response_model=MemoryConfigResponse,
-    summary="Get Memory Configuration",
-    description="Retrieve the current memory system configuration.",
-)
-async def get_memory_config_endpoint() -> MemoryConfigResponse:
-    """Get the memory system configuration.
-
-    Returns:
-        The current memory configuration settings.
-
-    Example Response:
-        ```json
-        {
-            "enabled": true,
-            "storage_path": ".deer-flow/memory.json",
-            "debounce_seconds": 30,
-            "max_facts": 100,
-            "fact_confidence_threshold": 0.7,
-            "injection_enabled": true,
-            "max_injection_tokens": 2000
-        }
-        ```
-    """
-    config = get_memory_config()
-    return MemoryConfigResponse(
-        enabled=config.enabled,
-        storage_path=config.storage_path,
-        debounce_seconds=config.debounce_seconds,
-        max_facts=config.max_facts,
-        fact_confidence_threshold=config.fact_confidence_threshold,
-        injection_enabled=config.injection_enabled,
-        max_injection_tokens=config.max_injection_tokens,
-    )
-
-
-@router.get(
-    "/memory/status",
-    response_model=MemoryStatusResponse,
-    response_model_exclude_none=True,
-    summary="Get Memory Status",
-    description="Retrieve both memory configuration and current data in a single request.",
-)
-async def get_memory_status() -> MemoryStatusResponse:
-    """Get the memory system status including configuration and data.
-
-    Returns:
-        Combined memory configuration and current data.
-    """
-    config = get_memory_config()
-    memory_data = get_memory_data()
-
-    return MemoryStatusResponse(
-        config=MemoryConfigResponse(
-            enabled=config.enabled,
-            storage_path=config.storage_path,
-            debounce_seconds=config.debounce_seconds,
-            max_facts=config.max_facts,
-            fact_confidence_threshold=config.fact_confidence_threshold,
-            injection_enabled=config.injection_enabled,
-            max_injection_tokens=config.max_injection_tokens,
-        ),
-        data=MemoryResponse(**memory_data),
-    )

backend/app/gateway/routers/models.py

@@ -1,116 +0,0 @@
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, Field
-
-from deerflow.config import get_app_config
-
-router = APIRouter(prefix="/api", tags=["models"])
-
-
-class ModelResponse(BaseModel):
-    """Response model for model information."""
-
-    name: str = Field(..., description="Unique identifier for the model")
-    model: str = Field(..., description="Actual provider model identifier")
-    display_name: str | None = Field(None, description="Human-readable name")
-    description: str | None = Field(None, description="Model description")
-    supports_thinking: bool = Field(default=False, description="Whether model supports thinking mode")
-    supports_reasoning_effort: bool = Field(default=False, description="Whether model supports reasoning effort")
-
-
-class ModelsListResponse(BaseModel):
-    """Response model for listing all models."""
-
-    models: list[ModelResponse]
-
-
-@router.get(
-    "/models",
-    response_model=ModelsListResponse,
-    summary="List All Models",
-    description="Retrieve a list of all available AI models configured in the system.",
-)
-async def list_models() -> ModelsListResponse:
-    """List all available models from configuration.
-
-    Returns model information suitable for frontend display,
-    excluding sensitive fields like API keys and internal configuration.
-
-    Returns:
-        A list of all configured models with their metadata.
-
-    Example Response:
-        ```json
-        {
-            "models": [
-                {
-                    "name": "gpt-4",
-                    "display_name": "GPT-4",
-                    "description": "OpenAI GPT-4 model",
-                    "supports_thinking": false
-                },
-                {
-                    "name": "claude-3-opus",
-                    "display_name": "Claude 3 Opus",
-                    "description": "Anthropic Claude 3 Opus model",
-                    "supports_thinking": true
-                }
-            ]
-        }
-        ```
-    """
-    config = get_app_config()
-    models = [
-        ModelResponse(
-            name=model.name,
-            model=model.model,
-            display_name=model.display_name,
-            description=model.description,
-            supports_thinking=model.supports_thinking,
-            supports_reasoning_effort=model.supports_reasoning_effort,
-        )
-        for model in config.models
-    ]
-    return ModelsListResponse(models=models)
-
-
-@router.get(
-    "/models/{model_name}",
-    response_model=ModelResponse,
-    summary="Get Model Details",
-    description="Retrieve detailed information about a specific AI model by its name.",
-)
-async def get_model(model_name: str) -> ModelResponse:
-    """Get a specific model by name.
-
-    Args:
-        model_name: The unique name of the model to retrieve.
-
-    Returns:
-        Model information if found.
-
-    Raises:
-        HTTPException: 404 if model not found.
-
-    Example Response:
-        ```json
-        {
-            "name": "gpt-4",
-            "display_name": "GPT-4",
-            "description": "OpenAI GPT-4 model",
-            "supports_thinking": false
-        }
-        ```
-    """
-    config = get_app_config()
-    model = config.get_model_config(model_name)
-    if model is None:
-        raise HTTPException(status_code=404, detail=f"Model '{model_name}' not found")
-
-    return ModelResponse(
-        name=model.name,
-        model=model.model,
-        display_name=model.display_name,
-        description=model.description,
-        supports_thinking=model.supports_thinking,
-        supports_reasoning_effort=model.supports_reasoning_effort,
-    )

backend/app/gateway/routers/runs.py

@@ -1,87 +0,0 @@
-"""Stateless runs endpoints -- stream and wait without a pre-existing thread.
-
-These endpoints auto-create a temporary thread when no ``thread_id`` is
-supplied in the request body.  When a ``thread_id`` **is** provided, it
-is reused so that conversation history is preserved across calls.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import uuid
-
-from fastapi import APIRouter, Request
-from fastapi.responses import StreamingResponse
-
-from app.gateway.deps import get_checkpointer, get_run_manager, get_stream_bridge
-from app.gateway.routers.thread_runs import RunCreateRequest
-from app.gateway.services import sse_consumer, start_run
-from deerflow.runtime import serialize_channel_values
-
-logger = logging.getLogger(__name__)
-router = APIRouter(prefix="/api/runs", tags=["runs"])
-
-
-def _resolve_thread_id(body: RunCreateRequest) -> str:
-    """Return the thread_id from the request body, or generate a new one."""
-    thread_id = (body.config or {}).get("configurable", {}).get("thread_id")
-    if thread_id:
-        return str(thread_id)
-    return str(uuid.uuid4())
-
-
-@router.post("/stream")
-async def stateless_stream(body: RunCreateRequest, request: Request) -> StreamingResponse:
-    """Create a run and stream events via SSE.
-
-    If ``config.configurable.thread_id`` is provided, the run is created
-    on the given thread so that conversation history is preserved.
-    Otherwise a new temporary thread is created.
-    """
-    thread_id = _resolve_thread_id(body)
-    bridge = get_stream_bridge(request)
-    run_mgr = get_run_manager(request)
-    record = await start_run(body, thread_id, request)
-
-    return StreamingResponse(
-        sse_consumer(bridge, record, request, run_mgr),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-            "Content-Location": f"/api/threads/{thread_id}/runs/{record.run_id}",
-        },
-    )
-
-
-@router.post("/wait", response_model=dict)
-async def stateless_wait(body: RunCreateRequest, request: Request) -> dict:
-    """Create a run and block until completion.
-
-    If ``config.configurable.thread_id`` is provided, the run is created
-    on the given thread so that conversation history is preserved.
-    Otherwise a new temporary thread is created.
-    """
-    thread_id = _resolve_thread_id(body)
-    record = await start_run(body, thread_id, request)
-
-    if record.task is not None:
-        try:
-            await record.task
-        except asyncio.CancelledError:
-            pass
-
-    checkpointer = get_checkpointer(request)
-    config = {"configurable": {"thread_id": thread_id}}
-    try:
-        checkpoint_tuple = await checkpointer.aget_tuple(config)
-        if checkpoint_tuple is not None:
-            checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
-            channel_values = checkpoint.get("channel_values", {})
-            return serialize_channel_values(channel_values)
-    except Exception:
-        logger.exception("Failed to fetch final state for run %s", record.run_id)
-
-    return {"status": record.status.value, "error": record.error}

backend/app/gateway/routers/skills.py

@@ -1,354 +0,0 @@
-import json
-import logging
-import shutil
-from pathlib import Path
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, Field
-
-from app.gateway.path_utils import resolve_thread_virtual_path
-from deerflow.agents.lead_agent.prompt import clear_skills_system_prompt_cache
-from deerflow.config.extensions_config import ExtensionsConfig, SkillStateConfig, get_extensions_config, reload_extensions_config
-from deerflow.skills import Skill, load_skills
-from deerflow.skills.installer import SkillAlreadyExistsError, install_skill_from_archive
-from deerflow.skills.manager import (
-    append_history,
-    atomic_write,
-    custom_skill_exists,
-    ensure_custom_skill_is_editable,
-    get_custom_skill_dir,
-    get_custom_skill_file,
-    get_skill_history_file,
-    read_custom_skill_content,
-    read_history,
-    validate_skill_markdown_content,
-)
-from deerflow.skills.security_scanner import scan_skill_content
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api", tags=["skills"])
-
-
-class SkillResponse(BaseModel):
-    """Response model for skill information."""
-
-    name: str = Field(..., description="Name of the skill")
-    description: str = Field(..., description="Description of what the skill does")
-    license: str | None = Field(None, description="License information")
-    category: str = Field(..., description="Category of the skill (public or custom)")
-    enabled: bool = Field(default=True, description="Whether this skill is enabled")
-
-
-class SkillsListResponse(BaseModel):
-    """Response model for listing all skills."""
-
-    skills: list[SkillResponse]
-
-
-class SkillUpdateRequest(BaseModel):
-    """Request model for updating a skill."""
-
-    enabled: bool = Field(..., description="Whether to enable or disable the skill")
-
-
-class SkillInstallRequest(BaseModel):
-    """Request model for installing a skill from a .skill file."""
-
-    thread_id: str = Field(..., description="The thread ID where the .skill file is located")
-    path: str = Field(..., description="Virtual path to the .skill file (e.g., mnt/user-data/outputs/my-skill.skill)")
-
-
-class SkillInstallResponse(BaseModel):
-    """Response model for skill installation."""
-
-    success: bool = Field(..., description="Whether the installation was successful")
-    skill_name: str = Field(..., description="Name of the installed skill")
-    message: str = Field(..., description="Installation result message")
-
-
-class CustomSkillContentResponse(SkillResponse):
-    content: str = Field(..., description="Raw SKILL.md content")
-
-
-class CustomSkillUpdateRequest(BaseModel):
-    content: str = Field(..., description="Replacement SKILL.md content")
-
-
-class CustomSkillHistoryResponse(BaseModel):
-    history: list[dict]
-
-
-class SkillRollbackRequest(BaseModel):
-    history_index: int = Field(default=-1, description="History entry index to restore from, defaulting to the latest change.")
-
-
-def _skill_to_response(skill: Skill) -> SkillResponse:
-    """Convert a Skill object to a SkillResponse."""
-    return SkillResponse(
-        name=skill.name,
-        description=skill.description,
-        license=skill.license,
-        category=skill.category,
-        enabled=skill.enabled,
-    )
-
-
-@router.get(
-    "/skills",
-    response_model=SkillsListResponse,
-    summary="List All Skills",
-    description="Retrieve a list of all available skills from both public and custom directories.",
-)
-async def list_skills() -> SkillsListResponse:
-    try:
-        skills = load_skills(enabled_only=False)
-        return SkillsListResponse(skills=[_skill_to_response(skill) for skill in skills])
-    except Exception as e:
-        logger.error(f"Failed to load skills: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to load skills: {str(e)}")
-
-
-@router.post(
-    "/skills/install",
-    response_model=SkillInstallResponse,
-    summary="Install Skill",
-    description="Install a skill from a .skill file (ZIP archive) located in the thread's user-data directory.",
-)
-async def install_skill(request: SkillInstallRequest) -> SkillInstallResponse:
-    try:
-        skill_file_path = resolve_thread_virtual_path(request.thread_id, request.path)
-        result = install_skill_from_archive(skill_file_path)
-        return SkillInstallResponse(**result)
-    except FileNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-    except SkillAlreadyExistsError as e:
-        raise HTTPException(status_code=409, detail=str(e))
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Failed to install skill: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to install skill: {str(e)}")
-
-
-@router.get("/skills/custom", response_model=SkillsListResponse, summary="List Custom Skills")
-async def list_custom_skills() -> SkillsListResponse:
-    try:
-        skills = [skill for skill in load_skills(enabled_only=False) if skill.category == "custom"]
-        return SkillsListResponse(skills=[_skill_to_response(skill) for skill in skills])
-    except Exception as e:
-        logger.error("Failed to list custom skills: %s", e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to list custom skills: {str(e)}")
-
-
-@router.get("/skills/custom/{skill_name}", response_model=CustomSkillContentResponse, summary="Get Custom Skill Content")
-async def get_custom_skill(skill_name: str) -> CustomSkillContentResponse:
-    try:
-        skills = load_skills(enabled_only=False)
-        skill = next((s for s in skills if s.name == skill_name and s.category == "custom"), None)
-        if skill is None:
-            raise HTTPException(status_code=404, detail=f"Custom skill '{skill_name}' not found")
-        return CustomSkillContentResponse(**_skill_to_response(skill).model_dump(), content=read_custom_skill_content(skill_name))
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error("Failed to get custom skill %s: %s", skill_name, e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to get custom skill: {str(e)}")
-
-
-@router.put("/skills/custom/{skill_name}", response_model=CustomSkillContentResponse, summary="Edit Custom Skill")
-async def update_custom_skill(skill_name: str, request: CustomSkillUpdateRequest) -> CustomSkillContentResponse:
-    try:
-        ensure_custom_skill_is_editable(skill_name)
-        validate_skill_markdown_content(skill_name, request.content)
-        scan = await scan_skill_content(request.content, executable=False, location=f"{skill_name}/SKILL.md")
-        if scan.decision == "block":
-            raise HTTPException(status_code=400, detail=f"Security scan blocked the edit: {scan.reason}")
-        skill_file = get_custom_skill_dir(skill_name) / "SKILL.md"
-        prev_content = skill_file.read_text(encoding="utf-8")
-        atomic_write(skill_file, request.content)
-        append_history(
-            skill_name,
-            {
-                "action": "human_edit",
-                "author": "human",
-                "thread_id": None,
-                "file_path": "SKILL.md",
-                "prev_content": prev_content,
-                "new_content": request.content,
-                "scanner": {"decision": scan.decision, "reason": scan.reason},
-            },
-        )
-        clear_skills_system_prompt_cache()
-        return await get_custom_skill(skill_name)
-    except HTTPException:
-        raise
-    except FileNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    except Exception as e:
-        logger.error("Failed to update custom skill %s: %s", skill_name, e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to update custom skill: {str(e)}")
-
-
-@router.delete("/skills/custom/{skill_name}", summary="Delete Custom Skill")
-async def delete_custom_skill(skill_name: str) -> dict[str, bool]:
-    try:
-        ensure_custom_skill_is_editable(skill_name)
-        skill_dir = get_custom_skill_dir(skill_name)
-        prev_content = read_custom_skill_content(skill_name)
-        append_history(
-            skill_name,
-            {
-                "action": "human_delete",
-                "author": "human",
-                "thread_id": None,
-                "file_path": "SKILL.md",
-                "prev_content": prev_content,
-                "new_content": None,
-                "scanner": {"decision": "allow", "reason": "Deletion requested."},
-            },
-        )
-        shutil.rmtree(skill_dir)
-        clear_skills_system_prompt_cache()
-        return {"success": True}
-    except FileNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    except Exception as e:
-        logger.error("Failed to delete custom skill %s: %s", skill_name, e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to delete custom skill: {str(e)}")
-
-
-@router.get("/skills/custom/{skill_name}/history", response_model=CustomSkillHistoryResponse, summary="Get Custom Skill History")
-async def get_custom_skill_history(skill_name: str) -> CustomSkillHistoryResponse:
-    try:
-        if not custom_skill_exists(skill_name) and not get_skill_history_file(skill_name).exists():
-            raise HTTPException(status_code=404, detail=f"Custom skill '{skill_name}' not found")
-        return CustomSkillHistoryResponse(history=read_history(skill_name))
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error("Failed to read history for %s: %s", skill_name, e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to read history: {str(e)}")
-
-
-@router.post("/skills/custom/{skill_name}/rollback", response_model=CustomSkillContentResponse, summary="Rollback Custom Skill")
-async def rollback_custom_skill(skill_name: str, request: SkillRollbackRequest) -> CustomSkillContentResponse:
-    try:
-        if not custom_skill_exists(skill_name) and not get_skill_history_file(skill_name).exists():
-            raise HTTPException(status_code=404, detail=f"Custom skill '{skill_name}' not found")
-        history = read_history(skill_name)
-        if not history:
-            raise HTTPException(status_code=400, detail=f"Custom skill '{skill_name}' has no history")
-        record = history[request.history_index]
-        target_content = record.get("prev_content")
-        if target_content is None:
-            raise HTTPException(status_code=400, detail="Selected history entry has no previous content to roll back to")
-        validate_skill_markdown_content(skill_name, target_content)
-        scan = await scan_skill_content(target_content, executable=False, location=f"{skill_name}/SKILL.md")
-        skill_file = get_custom_skill_file(skill_name)
-        current_content = skill_file.read_text(encoding="utf-8") if skill_file.exists() else None
-        history_entry = {
-            "action": "rollback",
-            "author": "human",
-            "thread_id": None,
-            "file_path": "SKILL.md",
-            "prev_content": current_content,
-            "new_content": target_content,
-            "rollback_from_ts": record.get("ts"),
-            "scanner": {"decision": scan.decision, "reason": scan.reason},
-        }
-        if scan.decision == "block":
-            append_history(skill_name, history_entry)
-            raise HTTPException(status_code=400, detail=f"Rollback blocked by security scanner: {scan.reason}")
-        atomic_write(skill_file, target_content)
-        append_history(skill_name, history_entry)
-        clear_skills_system_prompt_cache()
-        return await get_custom_skill(skill_name)
-    except HTTPException:
-        raise
-    except IndexError:
-        raise HTTPException(status_code=400, detail="history_index is out of range")
-    except FileNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e))
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    except Exception as e:
-        logger.error("Failed to roll back custom skill %s: %s", skill_name, e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to roll back custom skill: {str(e)}")
-
-
-@router.get(
-    "/skills/{skill_name}",
-    response_model=SkillResponse,
-    summary="Get Skill Details",
-    description="Retrieve detailed information about a specific skill by its name.",
-)
-async def get_skill(skill_name: str) -> SkillResponse:
-    try:
-        skills = load_skills(enabled_only=False)
-        skill = next((s for s in skills if s.name == skill_name), None)
-
-        if skill is None:
-            raise HTTPException(status_code=404, detail=f"Skill '{skill_name}' not found")
-
-        return _skill_to_response(skill)
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Failed to get skill {skill_name}: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to get skill: {str(e)}")
-
-
-@router.put(
-    "/skills/{skill_name}",
-    response_model=SkillResponse,
-    summary="Update Skill",
-    description="Update a skill's enabled status by modifying the extensions_config.json file.",
-)
-async def update_skill(skill_name: str, request: SkillUpdateRequest) -> SkillResponse:
-    try:
-        skills = load_skills(enabled_only=False)
-        skill = next((s for s in skills if s.name == skill_name), None)
-
-        if skill is None:
-            raise HTTPException(status_code=404, detail=f"Skill '{skill_name}' not found")
-
-        config_path = ExtensionsConfig.resolve_config_path()
-        if config_path is None:
-            config_path = Path.cwd().parent / "extensions_config.json"
-            logger.info(f"No existing extensions config found. Creating new config at: {config_path}")
-
-        extensions_config = get_extensions_config()
-        extensions_config.skills[skill_name] = SkillStateConfig(enabled=request.enabled)
-
-        config_data = {
-            "mcpServers": {name: server.model_dump() for name, server in extensions_config.mcp_servers.items()},
-            "skills": {name: {"enabled": skill_config.enabled} for name, skill_config in extensions_config.skills.items()},
-        }
-
-        with open(config_path, "w", encoding="utf-8") as f:
-            json.dump(config_data, f, indent=2)
-
-        logger.info(f"Skills configuration updated and saved to: {config_path}")
-        reload_extensions_config()
-
-        skills = load_skills(enabled_only=False)
-        updated_skill = next((s for s in skills if s.name == skill_name), None)
-
-        if updated_skill is None:
-            raise HTTPException(status_code=500, detail=f"Failed to reload skill '{skill_name}' after update")
-
-        logger.info(f"Skill '{skill_name}' enabled status updated to {request.enabled}")
-        return _skill_to_response(updated_skill)
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Failed to update skill {skill_name}: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to update skill: {str(e)}")

backend/app/gateway/routers/suggestions.py

@@ -1,134 +0,0 @@
-import json
-import logging
-
-from fastapi import APIRouter, Request
-from langchain_core.messages import HumanMessage, SystemMessage
-from pydantic import BaseModel, Field
-
-from app.gateway.authz import require_permission
-from deerflow.models import create_chat_model
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api", tags=["suggestions"])
-
-
-class SuggestionMessage(BaseModel):
-    role: str = Field(..., description="Message role: user|assistant")
-    content: str = Field(..., description="Message content as plain text")
-
-
-class SuggestionsRequest(BaseModel):
-    messages: list[SuggestionMessage] = Field(..., description="Recent conversation messages")
-    n: int = Field(default=3, ge=1, le=5, description="Number of suggestions to generate")
-    model_name: str | None = Field(default=None, description="Optional model override")
-
-
-class SuggestionsResponse(BaseModel):
-    suggestions: list[str] = Field(default_factory=list, description="Suggested follow-up questions")
-
-
-def _strip_markdown_code_fence(text: str) -> str:
-    stripped = text.strip()
-    if not stripped.startswith("```"):
-        return stripped
-    lines = stripped.splitlines()
-    if len(lines) >= 3 and lines[0].startswith("```") and lines[-1].startswith("```"):
-        return "\n".join(lines[1:-1]).strip()
-    return stripped
-
-
-def _parse_json_string_list(text: str) -> list[str] | None:
-    candidate = _strip_markdown_code_fence(text)
-    start = candidate.find("[")
-    end = candidate.rfind("]")
-    if start == -1 or end == -1 or end <= start:
-        return None
-    candidate = candidate[start : end + 1]
-    try:
-        data = json.loads(candidate)
-    except Exception:
-        return None
-    if not isinstance(data, list):
-        return None
-    out: list[str] = []
-    for item in data:
-        if not isinstance(item, str):
-            continue
-        s = item.strip()
-        if not s:
-            continue
-        out.append(s)
-    return out
-
-
-def _extract_response_text(content: object) -> str:
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        parts: list[str] = []
-        for block in content:
-            if isinstance(block, str):
-                parts.append(block)
-            elif isinstance(block, dict) and block.get("type") in {"text", "output_text"}:
-                text = block.get("text")
-                if isinstance(text, str):
-                    parts.append(text)
-        return "\n".join(parts) if parts else ""
-    if content is None:
-        return ""
-    return str(content)
-
-
-def _format_conversation(messages: list[SuggestionMessage]) -> str:
-    parts: list[str] = []
-    for m in messages:
-        role = m.role.strip().lower()
-        if role in ("user", "human"):
-            parts.append(f"User: {m.content.strip()}")
-        elif role in ("assistant", "ai"):
-            parts.append(f"Assistant: {m.content.strip()}")
-        else:
-            parts.append(f"{m.role}: {m.content.strip()}")
-    return "\n".join(parts).strip()
-
-
-@router.post(
-    "/threads/{thread_id}/suggestions",
-    response_model=SuggestionsResponse,
-    summary="Generate Follow-up Questions",
-    description="Generate short follow-up questions a user might ask next, based on recent conversation context.",
-)
-@require_permission("threads", "read", owner_check=True)
-async def generate_suggestions(thread_id: str, body: SuggestionsRequest, request: Request) -> SuggestionsResponse:
-    if not body.messages:
-        return SuggestionsResponse(suggestions=[])
-
-    n = body.n
-    conversation = _format_conversation(body.messages)
-    if not conversation:
-        return SuggestionsResponse(suggestions=[])
-
-    system_instruction = (
-        "You are generating follow-up questions to help the user continue the conversation.\n"
-        f"Based on the conversation below, produce EXACTLY {n} short questions the user might ask next.\n"
-        "Requirements:\n"
-        "- Questions must be relevant to the preceding conversation.\n"
-        "- Questions must be written in the same language as the user.\n"
-        "- Keep each question concise (ideally <= 20 words / <= 40 Chinese characters).\n"
-        "- Do NOT include numbering, markdown, or any extra text.\n"
-        "- Output MUST be a JSON array of strings only.\n"
-    )
-    user_content = f"Conversation Context:\n{conversation}\n\nGenerate {n} follow-up questions"
-
-    try:
-        model = create_chat_model(name=body.model_name, thinking_enabled=False)
-        response = await model.ainvoke([SystemMessage(content=system_instruction), HumanMessage(content=user_content)])
-        raw = _extract_response_text(response.content)
-        suggestions = _parse_json_string_list(raw) or []
-        cleaned = [s.replace("\n", " ").strip() for s in suggestions if s.strip()]
-        cleaned = cleaned[:n]
-        return SuggestionsResponse(suggestions=cleaned)
-    except Exception as exc:
-        logger.exception("Failed to generate suggestions: thread_id=%s err=%s", thread_id, exc)
-        return SuggestionsResponse(suggestions=[])

backend/app/gateway/routers/thread_runs.py

@@ -1,328 +0,0 @@
-"""Runs endpoints — create, stream, wait, cancel.
-
-Implements the LangGraph Platform runs API on top of
-:class:`deerflow.agents.runs.RunManager` and
-:class:`deerflow.agents.stream_bridge.StreamBridge`.
-
-SSE format is aligned with the LangGraph Platform protocol so that
-the ``useStream`` React hook from ``@langchain/langgraph-sdk/react``
-works without modification.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Any, Literal
-
-from fastapi import APIRouter, HTTPException, Query, Request
-from fastapi.responses import Response, StreamingResponse
-from pydantic import BaseModel, Field
-
-from app.gateway.authz import require_permission
-from app.gateway.deps import get_checkpointer, get_run_event_store, get_run_manager, get_run_store, get_stream_bridge
-from app.gateway.services import sse_consumer, start_run
-from deerflow.runtime import RunRecord, serialize_channel_values
-
-logger = logging.getLogger(__name__)
-router = APIRouter(prefix="/api/threads", tags=["runs"])
-
-
-# ---------------------------------------------------------------------------
-# Request / response models
-# ---------------------------------------------------------------------------
-
-
-class RunCreateRequest(BaseModel):
-    assistant_id: str | None = Field(default=None, description="Agent / assistant to use")
-    input: dict[str, Any] | None = Field(default=None, description="Graph input (e.g. {messages: [...]})")
-    command: dict[str, Any] | None = Field(default=None, description="LangGraph Command")
-    metadata: dict[str, Any] | None = Field(default=None, description="Run metadata")
-    config: dict[str, Any] | None = Field(default=None, description="RunnableConfig overrides")
-    context: dict[str, Any] | None = Field(default=None, description="DeerFlow context overrides (model_name, thinking_enabled, etc.)")
-    webhook: str | None = Field(default=None, description="Completion callback URL")
-    checkpoint_id: str | None = Field(default=None, description="Resume from checkpoint")
-    checkpoint: dict[str, Any] | None = Field(default=None, description="Full checkpoint object")
-    interrupt_before: list[str] | Literal["*"] | None = Field(default=None, description="Nodes to interrupt before")
-    interrupt_after: list[str] | Literal["*"] | None = Field(default=None, description="Nodes to interrupt after")
-    stream_mode: list[str] | str | None = Field(default=None, description="Stream mode(s)")
-    stream_subgraphs: bool = Field(default=False, description="Include subgraph events")
-    stream_resumable: bool | None = Field(default=None, description="SSE resumable mode")
-    on_disconnect: Literal["cancel", "continue"] = Field(default="cancel", description="Behaviour on SSE disconnect")
-    on_completion: Literal["delete", "keep"] = Field(default="keep", description="Delete temp thread on completion")
-    multitask_strategy: Literal["reject", "rollback", "interrupt", "enqueue"] = Field(default="reject", description="Concurrency strategy")
-    after_seconds: float | None = Field(default=None, description="Delayed execution")
-    if_not_exists: Literal["reject", "create"] = Field(default="create", description="Thread creation policy")
-    feedback_keys: list[str] | None = Field(default=None, description="LangSmith feedback keys")
-    follow_up_to_run_id: str | None = Field(default=None, description="Run ID this message follows up on. Auto-detected from latest successful run if not provided.")
-
-
-class RunResponse(BaseModel):
-    run_id: str
-    thread_id: str
-    assistant_id: str | None = None
-    status: str
-    metadata: dict[str, Any] = Field(default_factory=dict)
-    kwargs: dict[str, Any] = Field(default_factory=dict)
-    multitask_strategy: str = "reject"
-    created_at: str = ""
-    updated_at: str = ""
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _record_to_response(record: RunRecord) -> RunResponse:
-    return RunResponse(
-        run_id=record.run_id,
-        thread_id=record.thread_id,
-        assistant_id=record.assistant_id,
-        status=record.status.value,
-        metadata=record.metadata,
-        kwargs=record.kwargs,
-        multitask_strategy=record.multitask_strategy,
-        created_at=record.created_at,
-        updated_at=record.updated_at,
-    )
-
-
-# ---------------------------------------------------------------------------
-# Endpoints
-# ---------------------------------------------------------------------------
-
-
-@router.post("/{thread_id}/runs", response_model=RunResponse)
-@require_permission("runs", "create", owner_check=True)
-async def create_run(thread_id: str, body: RunCreateRequest, request: Request) -> RunResponse:
-    """Create a background run (returns immediately)."""
-    record = await start_run(body, thread_id, request)
-    return _record_to_response(record)
-
-
-@router.post("/{thread_id}/runs/stream")
-@require_permission("runs", "create", owner_check=True)
-async def stream_run(thread_id: str, body: RunCreateRequest, request: Request) -> StreamingResponse:
-    """Create a run and stream events via SSE.
-
-    The response includes a ``Content-Location`` header with the run's
-    resource URL, matching the LangGraph Platform protocol.  The
-    ``useStream`` React hook uses this to extract run metadata.
-    """
-    bridge = get_stream_bridge(request)
-    run_mgr = get_run_manager(request)
-    record = await start_run(body, thread_id, request)
-
-    return StreamingResponse(
-        sse_consumer(bridge, record, request, run_mgr),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-            # LangGraph Platform includes run metadata in this header.
-            # The SDK uses a greedy regex to extract the run id from this path,
-            # so it must point at the canonical run resource without extra suffixes.
-            "Content-Location": f"/api/threads/{thread_id}/runs/{record.run_id}",
-        },
-    )
-
-
-@router.post("/{thread_id}/runs/wait", response_model=dict)
-@require_permission("runs", "create", owner_check=True)
-async def wait_run(thread_id: str, body: RunCreateRequest, request: Request) -> dict:
-    """Create a run and block until it completes, returning the final state."""
-    record = await start_run(body, thread_id, request)
-
-    if record.task is not None:
-        try:
-            await record.task
-        except asyncio.CancelledError:
-            pass
-
-    checkpointer = get_checkpointer(request)
-    config = {"configurable": {"thread_id": thread_id}}
-    try:
-        checkpoint_tuple = await checkpointer.aget_tuple(config)
-        if checkpoint_tuple is not None:
-            checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
-            channel_values = checkpoint.get("channel_values", {})
-            return serialize_channel_values(channel_values)
-    except Exception:
-        logger.exception("Failed to fetch final state for run %s", record.run_id)
-
-    return {"status": record.status.value, "error": record.error}
-
-
-@router.get("/{thread_id}/runs", response_model=list[RunResponse])
-@require_permission("runs", "read", owner_check=True)
-async def list_runs(thread_id: str, request: Request) -> list[RunResponse]:
-    """List all runs for a thread."""
-    run_mgr = get_run_manager(request)
-    records = await run_mgr.list_by_thread(thread_id)
-    return [_record_to_response(r) for r in records]
-
-
-@router.get("/{thread_id}/runs/{run_id}", response_model=RunResponse)
-@require_permission("runs", "read", owner_check=True)
-async def get_run(thread_id: str, run_id: str, request: Request) -> RunResponse:
-    """Get details of a specific run."""
-    run_mgr = get_run_manager(request)
-    record = run_mgr.get(run_id)
-    if record is None or record.thread_id != thread_id:
-        raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
-    return _record_to_response(record)
-
-
-@router.post("/{thread_id}/runs/{run_id}/cancel")
-@require_permission("runs", "cancel", owner_check=True)
-async def cancel_run(
-    thread_id: str,
-    run_id: str,
-    request: Request,
-    wait: bool = Query(default=False, description="Block until run completes after cancel"),
-    action: Literal["interrupt", "rollback"] = Query(default="interrupt", description="Cancel action"),
-) -> Response:
-    """Cancel a running or pending run.
-
-    - action=interrupt: Stop execution, keep current checkpoint (can be resumed)
-    - action=rollback: Stop execution, revert to pre-run checkpoint state
-    - wait=true: Block until the run fully stops, return 204
-    - wait=false: Return immediately with 202
-    """
-    run_mgr = get_run_manager(request)
-    record = run_mgr.get(run_id)
-    if record is None or record.thread_id != thread_id:
-        raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
-
-    cancelled = await run_mgr.cancel(run_id, action=action)
-    if not cancelled:
-        raise HTTPException(
-            status_code=409,
-            detail=f"Run {run_id} is not cancellable (status: {record.status.value})",
-        )
-
-    if wait and record.task is not None:
-        try:
-            await record.task
-        except asyncio.CancelledError:
-            pass
-        return Response(status_code=204)
-
-    return Response(status_code=202)
-
-
-@router.get("/{thread_id}/runs/{run_id}/join")
-@require_permission("runs", "read", owner_check=True)
-async def join_run(thread_id: str, run_id: str, request: Request) -> StreamingResponse:
-    """Join an existing run's SSE stream."""
-    bridge = get_stream_bridge(request)
-    run_mgr = get_run_manager(request)
-    record = run_mgr.get(run_id)
-    if record is None or record.thread_id != thread_id:
-        raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
-
-    return StreamingResponse(
-        sse_consumer(bridge, record, request, run_mgr),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-        },
-    )
-
-
-@router.api_route("/{thread_id}/runs/{run_id}/stream", methods=["GET", "POST"], response_model=None)
-@require_permission("runs", "read", owner_check=True)
-async def stream_existing_run(
-    thread_id: str,
-    run_id: str,
-    request: Request,
-    action: Literal["interrupt", "rollback"] | None = Query(default=None, description="Cancel action"),
-    wait: int = Query(default=0, description="Block until cancelled (1) or return immediately (0)"),
-):
-    """Join an existing run's SSE stream (GET), or cancel-then-stream (POST).
-
-    The LangGraph SDK's ``joinStream`` and ``useStream`` stop button both use
-    ``POST`` to this endpoint.  When ``action=interrupt`` or ``action=rollback``
-    is present the run is cancelled first; the response then streams any
-    remaining buffered events so the client observes a clean shutdown.
-    """
-    run_mgr = get_run_manager(request)
-    record = run_mgr.get(run_id)
-    if record is None or record.thread_id != thread_id:
-        raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
-
-    # Cancel if an action was requested (stop-button / interrupt flow)
-    if action is not None:
-        cancelled = await run_mgr.cancel(run_id, action=action)
-        if cancelled and wait and record.task is not None:
-            try:
-                await record.task
-            except (asyncio.CancelledError, Exception):
-                pass
-            return Response(status_code=204)
-
-    bridge = get_stream_bridge(request)
-    return StreamingResponse(
-        sse_consumer(bridge, record, request, run_mgr),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-        },
-    )
-
-
-# ---------------------------------------------------------------------------
-# Messages / Events / Token usage endpoints
-# ---------------------------------------------------------------------------
-
-
-@router.get("/{thread_id}/messages")
-@require_permission("runs", "read", owner_check=True)
-async def list_thread_messages(
-    thread_id: str,
-    request: Request,
-    limit: int = Query(default=50, le=200),
-    before_seq: int | None = Query(default=None),
-    after_seq: int | None = Query(default=None),
-) -> list[dict]:
-    """Return displayable messages for a thread (across all runs)."""
-    event_store = get_run_event_store(request)
-    return await event_store.list_messages(thread_id, limit=limit, before_seq=before_seq, after_seq=after_seq)
-
-
-@router.get("/{thread_id}/runs/{run_id}/messages")
-@require_permission("runs", "read", owner_check=True)
-async def list_run_messages(thread_id: str, run_id: str, request: Request) -> list[dict]:
-    """Return displayable messages for a specific run."""
-    event_store = get_run_event_store(request)
-    return await event_store.list_messages_by_run(thread_id, run_id)
-
-
-@router.get("/{thread_id}/runs/{run_id}/events")
-@require_permission("runs", "read", owner_check=True)
-async def list_run_events(
-    thread_id: str,
-    run_id: str,
-    request: Request,
-    event_types: str | None = Query(default=None),
-    limit: int = Query(default=500, le=2000),
-) -> list[dict]:
-    """Return the full event stream for a run (debug/audit)."""
-    event_store = get_run_event_store(request)
-    types = event_types.split(",") if event_types else None
-    return await event_store.list_events(thread_id, run_id, event_types=types, limit=limit)
-
-
-@router.get("/{thread_id}/token-usage")
-@require_permission("threads", "read", owner_check=True)
-async def thread_token_usage(thread_id: str, request: Request) -> dict:
-    """Thread-level token usage aggregation."""
-    run_store = get_run_store(request)
-    agg = await run_store.aggregate_tokens_by_thread(thread_id)
-    return {"thread_id": thread_id, **agg}

backend/app/gateway/routers/threads.py

@@ -1,593 +0,0 @@
-"""Thread CRUD, state, and history endpoints.
-
-Combines the existing thread-local filesystem cleanup with LangGraph
-Platform-compatible thread management backed by the checkpointer.
-
-Channel values returned in state responses are serialized through
-:func:`deerflow.runtime.serialization.serialize_channel_values` to
-ensure LangChain message objects are converted to JSON-safe dicts
-matching the LangGraph Platform wire format expected by the
-``useStream`` React hook.
-"""
-
-from __future__ import annotations
-
-import logging
-import time
-import uuid
-from typing import Any
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel, Field
-
-from app.gateway.authz import require_permission
-from app.gateway.deps import get_checkpointer
-from app.gateway.utils import sanitize_log_param
-from deerflow.config.paths import Paths, get_paths
-from deerflow.runtime import serialize_channel_values
-
-logger = logging.getLogger(__name__)
-router = APIRouter(prefix="/api/threads", tags=["threads"])
-
-
-# ---------------------------------------------------------------------------
-# Response / request models
-# ---------------------------------------------------------------------------
-
-
-class ThreadDeleteResponse(BaseModel):
-    """Response model for thread cleanup."""
-
-    success: bool
-    message: str
-
-
-class ThreadResponse(BaseModel):
-    """Response model for a single thread."""
-
-    thread_id: str = Field(description="Unique thread identifier")
-    status: str = Field(default="idle", description="Thread status: idle, busy, interrupted, error")
-    created_at: str = Field(default="", description="ISO timestamp")
-    updated_at: str = Field(default="", description="ISO timestamp")
-    metadata: dict[str, Any] = Field(default_factory=dict, description="Thread metadata")
-    values: dict[str, Any] = Field(default_factory=dict, description="Current state channel values")
-    interrupts: dict[str, Any] = Field(default_factory=dict, description="Pending interrupts")
-
-
-class ThreadCreateRequest(BaseModel):
-    """Request body for creating a thread."""
-
-    thread_id: str | None = Field(default=None, description="Optional thread ID (auto-generated if omitted)")
-    assistant_id: str | None = Field(default=None, description="Associate thread with an assistant")
-    metadata: dict[str, Any] = Field(default_factory=dict, description="Initial metadata")
-
-
-class ThreadSearchRequest(BaseModel):
-    """Request body for searching threads."""
-
-    metadata: dict[str, Any] = Field(default_factory=dict, description="Metadata filter (exact match)")
-    limit: int = Field(default=100, ge=1, le=1000, description="Maximum results")
-    offset: int = Field(default=0, ge=0, description="Pagination offset")
-    status: str | None = Field(default=None, description="Filter by thread status")
-
-
-class ThreadStateResponse(BaseModel):
-    """Response model for thread state."""
-
-    values: dict[str, Any] = Field(default_factory=dict, description="Current channel values")
-    next: list[str] = Field(default_factory=list, description="Next tasks to execute")
-    metadata: dict[str, Any] = Field(default_factory=dict, description="Checkpoint metadata")
-    checkpoint: dict[str, Any] = Field(default_factory=dict, description="Checkpoint info")
-    checkpoint_id: str | None = Field(default=None, description="Current checkpoint ID")
-    parent_checkpoint_id: str | None = Field(default=None, description="Parent checkpoint ID")
-    created_at: str | None = Field(default=None, description="Checkpoint timestamp")
-    tasks: list[dict[str, Any]] = Field(default_factory=list, description="Interrupted task details")
-
-
-class ThreadPatchRequest(BaseModel):
-    """Request body for patching thread metadata."""
-
-    metadata: dict[str, Any] = Field(default_factory=dict, description="Metadata to merge")
-
-
-class ThreadStateUpdateRequest(BaseModel):
-    """Request body for updating thread state (human-in-the-loop resume)."""
-
-    values: dict[str, Any] | None = Field(default=None, description="Channel values to merge")
-    checkpoint_id: str | None = Field(default=None, description="Checkpoint to branch from")
-    checkpoint: dict[str, Any] | None = Field(default=None, description="Full checkpoint object")
-    as_node: str | None = Field(default=None, description="Node identity for the update")
-
-
-class HistoryEntry(BaseModel):
-    """Single checkpoint history entry."""
-
-    checkpoint_id: str
-    parent_checkpoint_id: str | None = None
-    metadata: dict[str, Any] = Field(default_factory=dict)
-    values: dict[str, Any] = Field(default_factory=dict)
-    created_at: str | None = None
-    next: list[str] = Field(default_factory=list)
-
-
-class ThreadHistoryRequest(BaseModel):
-    """Request body for checkpoint history."""
-
-    limit: int = Field(default=10, ge=1, le=100, description="Maximum entries")
-    before: str | None = Field(default=None, description="Cursor for pagination")
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _delete_thread_data(thread_id: str, paths: Paths | None = None) -> ThreadDeleteResponse:
-    """Delete local persisted filesystem data for a thread."""
-    path_manager = paths or get_paths()
-    try:
-        path_manager.delete_thread_dir(thread_id)
-    except ValueError as exc:
-        raise HTTPException(status_code=422, detail=str(exc)) from exc
-    except FileNotFoundError:
-        # Not critical — thread data may not exist on disk
-        logger.debug("No local thread data to delete for %s", sanitize_log_param(thread_id))
-        return ThreadDeleteResponse(success=True, message=f"No local data for {thread_id}")
-    except Exception as exc:
-        logger.exception("Failed to delete thread data for %s", sanitize_log_param(thread_id))
-        raise HTTPException(status_code=500, detail="Failed to delete local thread data.") from exc
-
-    logger.info("Deleted local thread data for %s", sanitize_log_param(thread_id))
-    return ThreadDeleteResponse(success=True, message=f"Deleted local thread data for {thread_id}")
-
-
-def _derive_thread_status(checkpoint_tuple) -> str:
-    """Derive thread status from checkpoint metadata."""
-    if checkpoint_tuple is None:
-        return "idle"
-    pending_writes = getattr(checkpoint_tuple, "pending_writes", None) or []
-
-    # Check for error in pending writes
-    for pw in pending_writes:
-        if len(pw) >= 2 and pw[1] == "__error__":
-            return "error"
-
-    # Check for pending next tasks (indicates interrupt)
-    tasks = getattr(checkpoint_tuple, "tasks", None)
-    if tasks:
-        return "interrupted"
-
-    return "idle"
-
-
-# ---------------------------------------------------------------------------
-# Endpoints
-# ---------------------------------------------------------------------------
-
-
-@router.delete("/{thread_id}", response_model=ThreadDeleteResponse)
-@require_permission("threads", "delete", owner_check=True)
-async def delete_thread_data(thread_id: str, request: Request) -> ThreadDeleteResponse:
-    """Delete local persisted filesystem data for a thread.
-
-    Cleans DeerFlow-managed thread directories, removes checkpoint data,
-    and removes the thread_meta row from the configured ThreadMetaStore
-    (sqlite or memory).
-    """
-    from app.gateway.deps import get_thread_meta_repo
-
-    # Clean local filesystem
-    response = _delete_thread_data(thread_id)
-
-    # Remove checkpoints (best-effort)
-    checkpointer = getattr(request.app.state, "checkpointer", None)
-    if checkpointer is not None:
-        try:
-            if hasattr(checkpointer, "adelete_thread"):
-                await checkpointer.adelete_thread(thread_id)
-        except Exception:
-            logger.debug("Could not delete checkpoints for thread %s (not critical)", sanitize_log_param(thread_id))
-
-    # Remove thread_meta row (best-effort) — required for sqlite backend
-    # so the deleted thread no longer appears in /threads/search.
-    try:
-        thread_meta_repo = get_thread_meta_repo(request)
-        await thread_meta_repo.delete(thread_id)
-    except Exception:
-        logger.debug("Could not delete thread_meta for %s (not critical)", sanitize_log_param(thread_id))
-
-    return response
-
-
-@router.post("", response_model=ThreadResponse)
-async def create_thread(body: ThreadCreateRequest, request: Request) -> ThreadResponse:
-    """Create a new thread.
-
-    Writes a thread_meta record (so the thread appears in /threads/search)
-    and an empty checkpoint (so state endpoints work immediately).
-    Idempotent: returns the existing record when ``thread_id`` already exists.
-    """
-    from app.gateway.deps import get_thread_meta_repo
-
-    checkpointer = get_checkpointer(request)
-    thread_meta_repo = get_thread_meta_repo(request)
-    thread_id = body.thread_id or str(uuid.uuid4())
-    now = time.time()
-
-    # Idempotency: return existing record when already present
-    existing_record = await thread_meta_repo.get(thread_id)
-    if existing_record is not None:
-        return ThreadResponse(
-            thread_id=thread_id,
-            status=existing_record.get("status", "idle"),
-            created_at=str(existing_record.get("created_at", "")),
-            updated_at=str(existing_record.get("updated_at", "")),
-            metadata=existing_record.get("metadata", {}),
-        )
-
-    # Write thread_meta so the thread appears in /threads/search immediately
-    try:
-        await thread_meta_repo.create(
-            thread_id,
-            assistant_id=getattr(body, "assistant_id", None),
-            metadata=body.metadata,
-        )
-    except Exception:
-        logger.exception("Failed to write thread_meta for %s", sanitize_log_param(thread_id))
-        raise HTTPException(status_code=500, detail="Failed to create thread")
-
-    # Write an empty checkpoint so state endpoints work immediately
-    config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
-    try:
-        from langgraph.checkpoint.base import empty_checkpoint
-
-        ckpt_metadata = {
-            "step": -1,
-            "source": "input",
-            "writes": None,
-            "parents": {},
-            **body.metadata,
-            "created_at": now,
-        }
-        await checkpointer.aput(config, empty_checkpoint(), ckpt_metadata, {})
-    except Exception:
-        logger.exception("Failed to create checkpoint for thread %s", sanitize_log_param(thread_id))
-        raise HTTPException(status_code=500, detail="Failed to create thread")
-
-    logger.info("Thread created: %s", sanitize_log_param(thread_id))
-    return ThreadResponse(
-        thread_id=thread_id,
-        status="idle",
-        created_at=str(now),
-        updated_at=str(now),
-        metadata=body.metadata,
-    )
-
-
-@router.post("/search", response_model=list[ThreadResponse])
-async def search_threads(body: ThreadSearchRequest, request: Request) -> list[ThreadResponse]:
-    """Search and list threads.
-
-    Delegates to the configured ThreadMetaStore implementation
-    (SQL-backed for sqlite/postgres, Store-backed for memory mode).
-    """
-    from app.gateway.deps import get_thread_meta_repo
-
-    repo = get_thread_meta_repo(request)
-    rows = await repo.search(
-        metadata=body.metadata or None,
-        status=body.status,
-        limit=body.limit,
-        offset=body.offset,
-    )
-    return [
-        ThreadResponse(
-            thread_id=r["thread_id"],
-            status=r.get("status", "idle"),
-            created_at=r.get("created_at", ""),
-            updated_at=r.get("updated_at", ""),
-            metadata=r.get("metadata", {}),
-            values={"title": r["display_name"]} if r.get("display_name") else {},
-            interrupts={},
-        )
-        for r in rows
-    ]
-
-
-@router.patch("/{thread_id}", response_model=ThreadResponse)
-@require_permission("threads", "write", owner_check=True)
-async def patch_thread(thread_id: str, body: ThreadPatchRequest, request: Request) -> ThreadResponse:
-    """Merge metadata into a thread record."""
-    from app.gateway.deps import get_thread_meta_repo
-
-    thread_meta_repo = get_thread_meta_repo(request)
-    record = await thread_meta_repo.get(thread_id)
-    if record is None:
-        raise HTTPException(status_code=404, detail=f"Thread {thread_id} not found")
-
-    try:
-        await thread_meta_repo.update_metadata(thread_id, body.metadata)
-    except Exception:
-        logger.exception("Failed to patch thread %s", sanitize_log_param(thread_id))
-        raise HTTPException(status_code=500, detail="Failed to update thread")
-
-    # Re-read to get the merged metadata + refreshed updated_at
-    record = await thread_meta_repo.get(thread_id) or record
-    return ThreadResponse(
-        thread_id=thread_id,
-        status=record.get("status", "idle"),
-        created_at=str(record.get("created_at", "")),
-        updated_at=str(record.get("updated_at", "")),
-        metadata=record.get("metadata", {}),
-    )
-
-
-@router.get("/{thread_id}", response_model=ThreadResponse)
-@require_permission("threads", "read", owner_check=True)
-async def get_thread(thread_id: str, request: Request) -> ThreadResponse:
-    """Get thread info.
-
-    Reads metadata from the ThreadMetaStore and derives the accurate
-    execution status from the checkpointer.  Falls back to the checkpointer
-    alone for threads that pre-date ThreadMetaStore adoption (backward compat).
-    """
-    from app.gateway.deps import get_thread_meta_repo
-
-    thread_meta_repo = get_thread_meta_repo(request)
-    checkpointer = get_checkpointer(request)
-
-    record: dict | None = await thread_meta_repo.get(thread_id)
-
-    # Derive accurate status from the checkpointer
-    config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
-    try:
-        checkpoint_tuple = await checkpointer.aget_tuple(config)
-    except Exception:
-        logger.exception("Failed to get checkpoint for thread %s", sanitize_log_param(thread_id))
-        raise HTTPException(status_code=500, detail="Failed to get thread")
-
-    if record is None and checkpoint_tuple is None:
-        raise HTTPException(status_code=404, detail=f"Thread {thread_id} not found")
-
-    # If the thread exists in the checkpointer but not in thread_meta (e.g.
-    # legacy data created before thread_meta adoption), synthesize a minimal
-    # record from the checkpoint metadata.
-    if record is None and checkpoint_tuple is not None:
-        ckpt_meta = getattr(checkpoint_tuple, "metadata", {}) or {}
-        record = {
-            "thread_id": thread_id,
-            "status": "idle",
-            "created_at": ckpt_meta.get("created_at", ""),
-            "updated_at": ckpt_meta.get("updated_at", ckpt_meta.get("created_at", "")),
-            "metadata": {k: v for k, v in ckpt_meta.items() if k not in ("created_at", "updated_at", "step", "source", "writes", "parents")},
-        }
-
-    if record is None:
-        raise HTTPException(status_code=404, detail=f"Thread {thread_id} not found")
-
-    status = _derive_thread_status(checkpoint_tuple) if checkpoint_tuple is not None else record.get("status", "idle")
-    checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {} if checkpoint_tuple is not None else {}
-    channel_values = checkpoint.get("channel_values", {})
-
-    return ThreadResponse(
-        thread_id=thread_id,
-        status=status,
-        created_at=str(record.get("created_at", "")),
-        updated_at=str(record.get("updated_at", "")),
-        metadata=record.get("metadata", {}),
-        values=serialize_channel_values(channel_values),
-    )
-
-
-@router.get("/{thread_id}/state", response_model=ThreadStateResponse)
-@require_permission("threads", "read", owner_check=True)
-async def get_thread_state(thread_id: str, request: Request) -> ThreadStateResponse:
-    """Get the latest state snapshot for a thread.
-
-    Channel values are serialized to ensure LangChain message objects
-    are converted to JSON-safe dicts.
-    """
-    checkpointer = get_checkpointer(request)
-
-    config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
-    try:
-        checkpoint_tuple = await checkpointer.aget_tuple(config)
-    except Exception:
-        logger.exception("Failed to get state for thread %s", sanitize_log_param(thread_id))
-        raise HTTPException(status_code=500, detail="Failed to get thread state")
-
-    if checkpoint_tuple is None:
-        raise HTTPException(status_code=404, detail=f"Thread {thread_id} not found")
-
-    checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
-    metadata = getattr(checkpoint_tuple, "metadata", {}) or {}
-    checkpoint_id = None
-    ckpt_config = getattr(checkpoint_tuple, "config", {})
-    if ckpt_config:
-        checkpoint_id = ckpt_config.get("configurable", {}).get("checkpoint_id")
-
-    channel_values = checkpoint.get("channel_values", {})
-
-    parent_config = getattr(checkpoint_tuple, "parent_config", None)
-    parent_checkpoint_id = None
-    if parent_config:
-        parent_checkpoint_id = parent_config.get("configurable", {}).get("checkpoint_id")
-
-    tasks_raw = getattr(checkpoint_tuple, "tasks", []) or []
-    next_tasks = [t.name for t in tasks_raw if hasattr(t, "name")]
-    tasks = [{"id": getattr(t, "id", ""), "name": getattr(t, "name", "")} for t in tasks_raw]
-
-    return ThreadStateResponse(
-        values=serialize_channel_values(channel_values),
-        next=next_tasks,
-        metadata=metadata,
-        checkpoint={"id": checkpoint_id, "ts": str(metadata.get("created_at", ""))},
-        checkpoint_id=checkpoint_id,
-        parent_checkpoint_id=parent_checkpoint_id,
-        created_at=str(metadata.get("created_at", "")),
-        tasks=tasks,
-    )
-
-
-@router.post("/{thread_id}/state", response_model=ThreadStateResponse)
-@require_permission("threads", "write", owner_check=True)
-async def update_thread_state(thread_id: str, body: ThreadStateUpdateRequest, request: Request) -> ThreadStateResponse:
-    """Update thread state (e.g. for human-in-the-loop resume or title rename).
-
-    Writes a new checkpoint that merges *body.values* into the latest
-    channel values, then syncs any updated ``title`` field through the
-    ThreadMetaStore abstraction so that ``/threads/search`` reflects the
-    change immediately in both sqlite and memory backends.
-    """
-    from app.gateway.deps import get_thread_meta_repo
-
-    checkpointer = get_checkpointer(request)
-    thread_meta_repo = get_thread_meta_repo(request)
-
-    # checkpoint_ns must be present in the config for aput — default to ""
-    # (the root graph namespace).  checkpoint_id is optional; omitting it
-    # fetches the latest checkpoint for the thread.
-    read_config: dict[str, Any] = {
-        "configurable": {
-            "thread_id": thread_id,
-            "checkpoint_ns": "",
-        }
-    }
-    if body.checkpoint_id:
-        read_config["configurable"]["checkpoint_id"] = body.checkpoint_id
-
-    try:
-        checkpoint_tuple = await checkpointer.aget_tuple(read_config)
-    except Exception:
-        logger.exception("Failed to get state for thread %s", sanitize_log_param(thread_id))
-        raise HTTPException(status_code=500, detail="Failed to get thread state")
-
-    if checkpoint_tuple is None:
-        raise HTTPException(status_code=404, detail=f"Thread {thread_id} not found")
-
-    # Work on mutable copies so we don't accidentally mutate cached objects.
-    checkpoint: dict[str, Any] = dict(getattr(checkpoint_tuple, "checkpoint", {}) or {})
-    metadata: dict[str, Any] = dict(getattr(checkpoint_tuple, "metadata", {}) or {})
-    channel_values: dict[str, Any] = dict(checkpoint.get("channel_values", {}))
-
-    if body.values:
-        channel_values.update(body.values)
-
-    checkpoint["channel_values"] = channel_values
-    metadata["updated_at"] = time.time()
-
-    if body.as_node:
-        metadata["source"] = "update"
-        metadata["step"] = metadata.get("step", 0) + 1
-        metadata["writes"] = {body.as_node: body.values}
-
-    # aput requires checkpoint_ns in the config — use the same config used for the
-    # read (which always includes checkpoint_ns="").  Do NOT include checkpoint_id
-    # so that aput generates a fresh checkpoint ID for the new snapshot.
-    write_config: dict[str, Any] = {
-        "configurable": {
-            "thread_id": thread_id,
-            "checkpoint_ns": "",
-        }
-    }
-    try:
-        new_config = await checkpointer.aput(write_config, checkpoint, metadata, {})
-    except Exception:
-        logger.exception("Failed to update state for thread %s", sanitize_log_param(thread_id))
-        raise HTTPException(status_code=500, detail="Failed to update thread state")
-
-    new_checkpoint_id: str | None = None
-    if isinstance(new_config, dict):
-        new_checkpoint_id = new_config.get("configurable", {}).get("checkpoint_id")
-
-    # Sync title changes through the ThreadMetaStore abstraction so /threads/search
-    # reflects them immediately in both sqlite and memory backends.
-    if body.values and "title" in body.values:
-        new_title = body.values["title"]
-        if new_title:  # Skip empty strings and None
-            try:
-                await thread_meta_repo.update_display_name(thread_id, new_title)
-            except Exception:
-                logger.debug("Failed to sync title to thread_meta for %s (non-fatal)", sanitize_log_param(thread_id))
-
-    return ThreadStateResponse(
-        values=serialize_channel_values(channel_values),
-        next=[],
-        metadata=metadata,
-        checkpoint_id=new_checkpoint_id,
-        created_at=str(metadata.get("created_at", "")),
-    )
-
-
-@router.post("/{thread_id}/history", response_model=list[HistoryEntry])
-@require_permission("threads", "read", owner_check=True)
-async def get_thread_history(thread_id: str, body: ThreadHistoryRequest, request: Request) -> list[HistoryEntry]:
-    """Get checkpoint history for a thread.
-
-    Messages are read from the checkpointer's channel values (the
-    authoritative source) and serialized via
-    :func:`~deerflow.runtime.serialization.serialize_channel_values`.
-    Only the latest (first) checkpoint carries the ``messages`` key to
-    avoid duplicating them across every entry.
-    """
-    checkpointer = get_checkpointer(request)
-
-    config: dict[str, Any] = {"configurable": {"thread_id": thread_id}}
-    if body.before:
-        config["configurable"]["checkpoint_id"] = body.before
-
-    entries: list[HistoryEntry] = []
-    is_latest_checkpoint = True
-    try:
-        async for checkpoint_tuple in checkpointer.alist(config, limit=body.limit):
-            ckpt_config = getattr(checkpoint_tuple, "config", {})
-            parent_config = getattr(checkpoint_tuple, "parent_config", None)
-            metadata = getattr(checkpoint_tuple, "metadata", {}) or {}
-            checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
-
-            checkpoint_id = ckpt_config.get("configurable", {}).get("checkpoint_id", "")
-            parent_id = None
-            if parent_config:
-                parent_id = parent_config.get("configurable", {}).get("checkpoint_id")
-
-            channel_values = checkpoint.get("channel_values", {})
-
-            # Build values from checkpoint channel_values
-            values: dict[str, Any] = {}
-            if title := channel_values.get("title"):
-                values["title"] = title
-            if thread_data := channel_values.get("thread_data"):
-                values["thread_data"] = thread_data
-
-            # Attach messages from checkpointer only for the latest checkpoint
-            if is_latest_checkpoint:
-                messages = channel_values.get("messages")
-                if messages:
-                    values["messages"] = serialize_channel_values({"messages": messages}).get("messages", [])
-            is_latest_checkpoint = False
-
-            # Derive next tasks
-            tasks_raw = getattr(checkpoint_tuple, "tasks", []) or []
-            next_tasks = [t.name for t in tasks_raw if hasattr(t, "name")]
-
-            # Strip LangGraph internal keys from metadata
-            user_meta = {k: v for k, v in metadata.items() if k not in ("created_at", "updated_at", "step", "source", "writes", "parents")}
-            # Keep step for ordering context
-            if "step" in metadata:
-                user_meta["step"] = metadata["step"]
-
-            entries.append(
-                HistoryEntry(
-                    checkpoint_id=checkpoint_id,
-                    parent_checkpoint_id=parent_id,
-                    metadata=user_meta,
-                    values=values,
-                    created_at=str(metadata.get("created_at", "")),
-                    next=next_tasks,
-                )
-            )
-    except Exception:
-        logger.exception("Failed to get history for thread %s", sanitize_log_param(thread_id))
-        raise HTTPException(status_code=500, detail="Failed to get thread history")
-
-    return entries

backend/app/gateway/routers/uploads.py

@@ -1,173 +0,0 @@
-"""Upload router for handling file uploads."""
-
-import logging
-import os
-import stat
-
-from fastapi import APIRouter, File, HTTPException, Request, UploadFile
-from pydantic import BaseModel
-
-from app.gateway.authz import require_permission
-from deerflow.config.paths import get_paths
-from deerflow.sandbox.sandbox_provider import get_sandbox_provider
-from deerflow.uploads.manager import (
-    PathTraversalError,
-    delete_file_safe,
-    enrich_file_listing,
-    ensure_uploads_dir,
-    get_uploads_dir,
-    list_files_in_dir,
-    normalize_filename,
-    upload_artifact_url,
-    upload_virtual_path,
-)
-from deerflow.utils.file_conversion import CONVERTIBLE_EXTENSIONS, convert_file_to_markdown
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api/threads/{thread_id}/uploads", tags=["uploads"])
-
-
-class UploadResponse(BaseModel):
-    """Response model for file upload."""
-
-    success: bool
-    files: list[dict[str, str]]
-    message: str
-
-
-def _make_file_sandbox_writable(file_path: os.PathLike[str] | str) -> None:
-    """Ensure uploaded files remain writable when mounted into non-local sandboxes.
-
-    In AIO sandbox mode, the gateway writes the authoritative host-side file
-    first, then the sandbox runtime may rewrite the same mounted path. Granting
-    world-writable access here prevents permission mismatches between the
-    gateway user and the sandbox runtime user.
-    """
-    file_stat = os.lstat(file_path)
-    if stat.S_ISLNK(file_stat.st_mode):
-        logger.warning("Skipping sandbox chmod for symlinked upload path: %s", file_path)
-        return
-
-    writable_mode = stat.S_IMODE(file_stat.st_mode) | stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH
-    chmod_kwargs = {"follow_symlinks": False} if os.chmod in os.supports_follow_symlinks else {}
-    os.chmod(file_path, writable_mode, **chmod_kwargs)
-
-
-@router.post("", response_model=UploadResponse)
-@require_permission("threads", "write", owner_check=True)
-async def upload_files(
-    thread_id: str,
-    request: Request,
-    files: list[UploadFile] = File(...),
-) -> UploadResponse:
-    """Upload multiple files to a thread's uploads directory."""
-    if not files:
-        raise HTTPException(status_code=400, detail="No files provided")
-
-    try:
-        uploads_dir = ensure_uploads_dir(thread_id)
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    sandbox_uploads = get_paths().sandbox_uploads_dir(thread_id)
-    uploaded_files = []
-
-    sandbox_provider = get_sandbox_provider()
-    sandbox_id = sandbox_provider.acquire(thread_id)
-    sandbox = sandbox_provider.get(sandbox_id)
-
-    for file in files:
-        if not file.filename:
-            continue
-
-        try:
-            safe_filename = normalize_filename(file.filename)
-        except ValueError:
-            logger.warning(f"Skipping file with unsafe filename: {file.filename!r}")
-            continue
-
-        try:
-            content = await file.read()
-            file_path = uploads_dir / safe_filename
-            file_path.write_bytes(content)
-
-            virtual_path = upload_virtual_path(safe_filename)
-
-            if sandbox_id != "local":
-                _make_file_sandbox_writable(file_path)
-                sandbox.update_file(virtual_path, content)
-
-            file_info = {
-                "filename": safe_filename,
-                "size": str(len(content)),
-                "path": str(sandbox_uploads / safe_filename),
-                "virtual_path": virtual_path,
-                "artifact_url": upload_artifact_url(thread_id, safe_filename),
-            }
-
-            logger.info(f"Saved file: {safe_filename} ({len(content)} bytes) to {file_info['path']}")
-
-            file_ext = file_path.suffix.lower()
-            if file_ext in CONVERTIBLE_EXTENSIONS:
-                md_path = await convert_file_to_markdown(file_path)
-                if md_path:
-                    md_virtual_path = upload_virtual_path(md_path.name)
-
-                    if sandbox_id != "local":
-                        _make_file_sandbox_writable(md_path)
-                        sandbox.update_file(md_virtual_path, md_path.read_bytes())
-
-                    file_info["markdown_file"] = md_path.name
-                    file_info["markdown_path"] = str(sandbox_uploads / md_path.name)
-                    file_info["markdown_virtual_path"] = md_virtual_path
-                    file_info["markdown_artifact_url"] = upload_artifact_url(thread_id, md_path.name)
-
-            uploaded_files.append(file_info)
-
-        except Exception as e:
-            logger.error(f"Failed to upload {file.filename}: {e}")
-            raise HTTPException(status_code=500, detail=f"Failed to upload {file.filename}: {str(e)}")
-
-    return UploadResponse(
-        success=True,
-        files=uploaded_files,
-        message=f"Successfully uploaded {len(uploaded_files)} file(s)",
-    )
-
-
-@router.get("/list", response_model=dict)
-@require_permission("threads", "read", owner_check=True)
-async def list_uploaded_files(thread_id: str, request: Request) -> dict:
-    """List all files in a thread's uploads directory."""
-    try:
-        uploads_dir = get_uploads_dir(thread_id)
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    result = list_files_in_dir(uploads_dir)
-    enrich_file_listing(result, thread_id)
-
-    # Gateway additionally includes the sandbox-relative path.
-    sandbox_uploads = get_paths().sandbox_uploads_dir(thread_id)
-    for f in result["files"]:
-        f["path"] = str(sandbox_uploads / f["filename"])
-
-    return result
-
-
-@router.delete("/{filename}")
-@require_permission("threads", "delete", owner_check=True)
-async def delete_uploaded_file(thread_id: str, filename: str, request: Request) -> dict:
-    """Delete a file from a thread's uploads directory."""
-    try:
-        uploads_dir = get_uploads_dir(thread_id)
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    try:
-        return delete_file_safe(uploads_dir, filename, convertible_extensions=CONVERTIBLE_EXTENSIONS)
-    except FileNotFoundError:
-        raise HTTPException(status_code=404, detail=f"File not found: {filename}")
-    except PathTraversalError:
-        raise HTTPException(status_code=400, detail="Invalid path")
-    except Exception as e:
-        logger.error(f"Failed to delete {filename}: {e}")
-        raise HTTPException(status_code=500, detail=f"Failed to delete {filename}: {str(e)}")

backend/app/gateway/services.py

@@ -1,325 +0,0 @@
-"""Run lifecycle service layer.
-
-Centralizes the business logic for creating runs, formatting SSE
-frames, and consuming stream bridge events.  Router modules
-(``thread_runs``, ``runs``) are thin HTTP handlers that delegate here.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import dataclasses
-import json
-import logging
-import re
-from typing import Any
-
-from fastapi import HTTPException, Request
-from langchain_core.messages import HumanMessage
-
-from app.gateway.deps import get_run_context, get_run_manager, get_run_store, get_stream_bridge
-from app.gateway.utils import sanitize_log_param
-from deerflow.runtime import (
-    END_SENTINEL,
-    HEARTBEAT_SENTINEL,
-    ConflictError,
-    DisconnectMode,
-    RunManager,
-    RunRecord,
-    RunStatus,
-    StreamBridge,
-    UnsupportedStrategyError,
-    run_agent,
-)
-
-logger = logging.getLogger(__name__)
-
-
-# ---------------------------------------------------------------------------
-# SSE formatting
-# ---------------------------------------------------------------------------
-
-
-def format_sse(event: str, data: Any, *, event_id: str | None = None) -> str:
-    """Format a single SSE frame.
-
-    Field order: ``event:`` -> ``data:`` -> ``id:`` (optional) -> blank line.
-    This matches the LangGraph Platform wire format consumed by the
-    ``useStream`` React hook and the Python ``langgraph-sdk`` SSE decoder.
-    """
-    payload = json.dumps(data, default=str, ensure_ascii=False)
-    parts = [f"event: {event}", f"data: {payload}"]
-    if event_id:
-        parts.append(f"id: {event_id}")
-    parts.append("")
-    parts.append("")
-    return "\n".join(parts)
-
-
-# ---------------------------------------------------------------------------
-# Input / config helpers
-# ---------------------------------------------------------------------------
-
-
-def normalize_stream_modes(raw: list[str] | str | None) -> list[str]:
-    """Normalize the stream_mode parameter to a list.
-
-    Default matches what ``useStream`` expects: values + messages-tuple.
-    """
-    if raw is None:
-        return ["values"]
-    if isinstance(raw, str):
-        return [raw]
-    return raw if raw else ["values"]
-
-
-def normalize_input(raw_input: dict[str, Any] | None) -> dict[str, Any]:
-    """Convert LangGraph Platform input format to LangChain state dict."""
-    if raw_input is None:
-        return {}
-    messages = raw_input.get("messages")
-    if messages and isinstance(messages, list):
-        converted = []
-        for msg in messages:
-            if isinstance(msg, dict):
-                role = msg.get("role", msg.get("type", "user"))
-                content = msg.get("content", "")
-                if role in ("user", "human"):
-                    converted.append(HumanMessage(content=content))
-                else:
-                    # TODO: handle other message types (system, ai, tool)
-                    converted.append(HumanMessage(content=content))
-            else:
-                converted.append(msg)
-        return {**raw_input, "messages": converted}
-    return raw_input
-
-
-_DEFAULT_ASSISTANT_ID = "lead_agent"
-
-
-def resolve_agent_factory(assistant_id: str | None):
-    """Resolve the agent factory callable from config.
-
-    Custom agents are implemented as ``lead_agent`` + an ``agent_name``
-    injected into ``configurable`` — see :func:`build_run_config`.  All
-    ``assistant_id`` values therefore map to the same factory; the routing
-    happens inside ``make_lead_agent`` when it reads ``cfg["agent_name"]``.
-    """
-    from deerflow.agents.lead_agent.agent import make_lead_agent
-
-    return make_lead_agent
-
-
-def build_run_config(
-    thread_id: str,
-    request_config: dict[str, Any] | None,
-    metadata: dict[str, Any] | None,
-    *,
-    assistant_id: str | None = None,
-) -> dict[str, Any]:
-    """Build a RunnableConfig dict for the agent.
-
-    When *assistant_id* refers to a custom agent (anything other than
-    ``"lead_agent"`` / ``None``), the name is forwarded as
-    ``configurable["agent_name"]``.  ``make_lead_agent`` reads this key to
-    load the matching ``agents/<name>/SOUL.md`` and per-agent config —
-    without it the agent silently runs as the default lead agent.
-
-    This mirrors the channel manager's ``_resolve_run_params`` logic so that
-    the LangGraph Platform-compatible HTTP API and the IM channel path behave
-    identically.
-    """
-    config: dict[str, Any] = {"recursion_limit": 100}
-    if request_config:
-        # LangGraph >= 0.6.0 introduced ``context`` as the preferred way to
-        # pass thread-level data and rejects requests that include both
-        # ``configurable`` and ``context``.  If the caller already sends
-        # ``context``, honour it and skip our own ``configurable`` dict.
-        if "context" in request_config:
-            if "configurable" in request_config:
-                logger.warning(
-                    "build_run_config: client sent both 'context' and 'configurable'; preferring 'context' (LangGraph >= 0.6.0). thread_id=%s, caller_configurable keys=%s",
-                    thread_id,
-                    list(request_config.get("configurable", {}).keys()),
-                )
-            config["context"] = request_config["context"]
-        else:
-            configurable = {"thread_id": thread_id}
-            configurable.update(request_config.get("configurable", {}))
-            config["configurable"] = configurable
-        for k, v in request_config.items():
-            if k not in ("configurable", "context"):
-                config[k] = v
-    else:
-        config["configurable"] = {"thread_id": thread_id}
-
-    # Inject custom agent name when the caller specified a non-default assistant.
-    # Honour an explicit configurable["agent_name"] in the request if already set.
-    if assistant_id and assistant_id != _DEFAULT_ASSISTANT_ID and "configurable" in config:
-        if "agent_name" not in config["configurable"]:
-            normalized = assistant_id.strip().lower().replace("_", "-")
-            if not normalized or not re.fullmatch(r"[a-z0-9-]+", normalized):
-                raise ValueError(f"Invalid assistant_id {assistant_id!r}: must contain only letters, digits, and hyphens after normalization.")
-            config["configurable"]["agent_name"] = normalized
-    if metadata:
-        config.setdefault("metadata", {}).update(metadata)
-    return config
-
-
-# ---------------------------------------------------------------------------
-# Run lifecycle
-# ---------------------------------------------------------------------------
-
-
-async def start_run(
-    body: Any,
-    thread_id: str,
-    request: Request,
-) -> RunRecord:
-    """Create a RunRecord and launch the background agent task.
-
-    Parameters
-    ----------
-    body : RunCreateRequest
-        The validated request body (typed as Any to avoid circular import
-        with the router module that defines the Pydantic model).
-    thread_id : str
-        Target thread.
-    request : Request
-        FastAPI request — used to retrieve singletons from ``app.state``.
-    """
-    bridge = get_stream_bridge(request)
-    run_mgr = get_run_manager(request)
-    run_ctx = get_run_context(request)
-
-    disconnect = DisconnectMode.cancel if body.on_disconnect == "cancel" else DisconnectMode.continue_
-
-    # Resolve follow_up_to_run_id: explicit from request, or auto-detect from latest successful run
-    follow_up_to_run_id = getattr(body, "follow_up_to_run_id", None)
-    if follow_up_to_run_id is None:
-        run_store = get_run_store(request)
-        try:
-            recent_runs = await run_store.list_by_thread(thread_id, limit=1)
-            if recent_runs and recent_runs[0].get("status") == "success":
-                follow_up_to_run_id = recent_runs[0]["run_id"]
-        except Exception:
-            pass  # Don't block run creation
-
-    # Enrich base context with per-run field
-    if follow_up_to_run_id:
-        run_ctx = dataclasses.replace(run_ctx, follow_up_to_run_id=follow_up_to_run_id)
-
-    try:
-        record = await run_mgr.create_or_reject(
-            thread_id,
-            body.assistant_id,
-            on_disconnect=disconnect,
-            metadata=body.metadata or {},
-            kwargs={"input": body.input, "config": body.config},
-            multitask_strategy=body.multitask_strategy,
-            follow_up_to_run_id=follow_up_to_run_id,
-        )
-    except ConflictError as exc:
-        raise HTTPException(status_code=409, detail=str(exc)) from exc
-    except UnsupportedStrategyError as exc:
-        raise HTTPException(status_code=501, detail=str(exc)) from exc
-
-    # Upsert thread metadata so the thread appears in /threads/search,
-    # even for threads that were never explicitly created via POST /threads
-    # (e.g. stateless runs).
-    try:
-        existing = await run_ctx.thread_meta_repo.get(thread_id)
-        if existing is None:
-            await run_ctx.thread_meta_repo.create(
-                thread_id,
-                assistant_id=body.assistant_id,
-                metadata=body.metadata,
-            )
-        else:
-            await run_ctx.thread_meta_repo.update_status(thread_id, "running")
-    except Exception:
-        logger.warning("Failed to upsert thread_meta for %s (non-fatal)", sanitize_log_param(thread_id))
-
-    agent_factory = resolve_agent_factory(body.assistant_id)
-    graph_input = normalize_input(body.input)
-    config = build_run_config(thread_id, body.config, body.metadata, assistant_id=body.assistant_id)
-
-    # Merge DeerFlow-specific context overrides into configurable.
-    # The ``context`` field is a custom extension for the langgraph-compat layer
-    # that carries agent configuration (model_name, thinking_enabled, etc.).
-    # Only agent-relevant keys are forwarded; unknown keys (e.g. thread_id) are ignored.
-    context = getattr(body, "context", None)
-    if context:
-        _CONTEXT_CONFIGURABLE_KEYS = {
-            "model_name",
-            "mode",
-            "thinking_enabled",
-            "reasoning_effort",
-            "is_plan_mode",
-            "subagent_enabled",
-            "max_concurrent_subagents",
-        }
-        configurable = config.setdefault("configurable", {})
-        for key in _CONTEXT_CONFIGURABLE_KEYS:
-            if key in context:
-                configurable.setdefault(key, context[key])
-
-    stream_modes = normalize_stream_modes(body.stream_mode)
-
-    task = asyncio.create_task(
-        run_agent(
-            bridge,
-            run_mgr,
-            record,
-            ctx=run_ctx,
-            agent_factory=agent_factory,
-            graph_input=graph_input,
-            config=config,
-            stream_modes=stream_modes,
-            stream_subgraphs=body.stream_subgraphs,
-            interrupt_before=body.interrupt_before,
-            interrupt_after=body.interrupt_after,
-        )
-    )
-    record.task = task
-
-    # Title sync is handled by worker.py's finally block which reads the
-    # title from the checkpoint and calls thread_meta_repo.update_display_name
-    # after the run completes.
-
-    return record
-
-
-async def sse_consumer(
-    bridge: StreamBridge,
-    record: RunRecord,
-    request: Request,
-    run_mgr: RunManager,
-):
-    """Async generator that yields SSE frames from the bridge.
-
-    The ``finally`` block implements ``on_disconnect`` semantics:
-    - ``cancel``: abort the background task on client disconnect.
-    - ``continue``: let the task run; events are discarded.
-    """
-    last_event_id = request.headers.get("Last-Event-ID")
-    try:
-        async for entry in bridge.subscribe(record.run_id, last_event_id=last_event_id):
-            if await request.is_disconnected():
-                break
-
-            if entry is HEARTBEAT_SENTINEL:
-                yield ": heartbeat\n\n"
-                continue
-
-            if entry is END_SENTINEL:
-                yield format_sse("end", None, event_id=entry.id or None)
-                return
-
-            yield format_sse(entry.event, entry.data, event_id=entry.id or None)
-
-    finally:
-        if record.status in (RunStatus.pending, RunStatus.running):
-            if record.on_disconnect == DisconnectMode.cancel:
-                await run_mgr.cancel(record.run_id)

backend/app/gateway/utils.py

@@ -1,6 +0,0 @@
-"""Shared utility helpers for the Gateway layer."""
-
-
-def sanitize_log_param(value: str) -> str:
-    """Strip control characters to prevent log injection."""
-    return value.replace("\n", "").replace("\r", "").replace("\x00", "")

backend/debug.py

@@ -1,91 +0,0 @@
-#!/usr/bin/env python
-"""
-Debug script for lead_agent.
-Run this file directly in VS Code with breakpoints.
-
-Requirements:
-    Run with `uv run` from the backend/ directory so that the uv workspace
-    resolves deerflow-harness and app packages correctly:
-
-        cd backend && PYTHONPATH=. uv run python debug.py
-
-Usage:
-    1. Set breakpoints in agent.py or other files
-    2. Press F5 or use "Run and Debug" panel
-    3. Input messages in the terminal to interact with the agent
-"""
-
-import asyncio
-import logging
-
-from dotenv import load_dotenv
-from langchain_core.messages import HumanMessage
-
-from deerflow.agents import make_lead_agent
-
-load_dotenv()
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-)
-
-
-async def main():
-    # Initialize MCP tools at startup
-    try:
-        from deerflow.mcp import initialize_mcp_tools
-
-        await initialize_mcp_tools()
-    except Exception as e:
-        print(f"Warning: Failed to initialize MCP tools: {e}")
-
-    # Create agent with default config
-    config = {
-        "configurable": {
-            "thread_id": "debug-thread-001",
-            "thinking_enabled": True,
-            "is_plan_mode": True,
-            # Uncomment to use a specific model
-            "model_name": "kimi-k2.5",
-        }
-    }
-
-    agent = make_lead_agent(config)
-
-    print("=" * 50)
-    print("Lead Agent Debug Mode")
-    print("Type 'quit' or 'exit' to stop")
-    print("=" * 50)
-
-    while True:
-        try:
-            user_input = input("\nYou: ").strip()
-            if not user_input:
-                continue
-            if user_input.lower() in ("quit", "exit"):
-                print("Goodbye!")
-                break
-
-            # Invoke the agent
-            state = {"messages": [HumanMessage(content=user_input)]}
-            result = await agent.ainvoke(state, config=config, context={"thread_id": "debug-thread-001"})
-
-            # Print the response
-            if result.get("messages"):
-                last_message = result["messages"][-1]
-                print(f"\nAgent: {last_message.content}")
-
-        except KeyboardInterrupt:
-            print("\nInterrupted. Goodbye!")
-            break
-        except Exception as e:
-            print(f"\nError: {e}")
-            import traceback
-
-            traceback.print_exc()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

backend/docs/API.md

@@ -1,631 +0,0 @@
-# API Reference
-
-This document provides a complete reference for the DeerFlow backend APIs.
-
-## Overview
-
-DeerFlow backend exposes two sets of APIs:
-
-1. **LangGraph API** - Agent interactions, threads, and streaming (`/api/langgraph/*`)
-2. **Gateway API** - Models, MCP, skills, uploads, and artifacts (`/api/*`)
-
-All APIs are accessed through the Nginx reverse proxy at port 2026.
-
-## LangGraph API
-
-Base URL: `/api/langgraph`
-
-The LangGraph API is provided by the LangGraph server and follows the LangGraph SDK conventions.
-
-### Threads
-
-#### Create Thread
-
-```http
-POST /api/langgraph/threads
-Content-Type: application/json
-```
-
-**Request Body:**
-```json
-{
-  "metadata": {}
-}
-```
-
-**Response:**
-```json
-{
-  "thread_id": "abc123",
-  "created_at": "2024-01-15T10:30:00Z",
-  "metadata": {}
-}
-```
-
-#### Get Thread State
-
-```http
-GET /api/langgraph/threads/{thread_id}/state
-```
-
-**Response:**
-```json
-{
-  "values": {
-    "messages": [...],
-    "sandbox": {...},
-    "artifacts": [...],
-    "thread_data": {...},
-    "title": "Conversation Title"
-  },
-  "next": [],
-  "config": {...}
-}
-```
-
-### Runs
-
-#### Create Run
-
-Execute the agent with input.
-
-```http
-POST /api/langgraph/threads/{thread_id}/runs
-Content-Type: application/json
-```
-
-**Request Body:**
-```json
-{
-  "input": {
-    "messages": [
-      {
-        "role": "user",
-        "content": "Hello, can you help me?"
-      }
-    ]
-  },
-  "config": {
-    "configurable": {
-      "model_name": "gpt-4",
-      "thinking_enabled": false,
-      "is_plan_mode": false
-    }
-  },
-  "stream_mode": ["values", "messages-tuple", "custom"]
-}
-```
-
-**Stream Mode Compatibility:**
-- Use: `values`, `messages-tuple`, `custom`, `updates`, `events`, `debug`, `tasks`, `checkpoints`
-- Do not use: `tools` (deprecated/invalid in current `langgraph-api` and will trigger schema validation errors)
-
-**Configurable Options:**
-- `model_name` (string): Override the default model
-- `thinking_enabled` (boolean): Enable extended thinking for supported models
-- `is_plan_mode` (boolean): Enable TodoList middleware for task tracking
-
-**Response:** Server-Sent Events (SSE) stream
-
-```
-event: values
-data: {"messages": [...], "title": "..."}
-
-event: messages
-data: {"content": "Hello! I'd be happy to help.", "role": "assistant"}
-
-event: end
-data: {}
-```
-
-#### Get Run History
-
-```http
-GET /api/langgraph/threads/{thread_id}/runs
-```
-
-**Response:**
-```json
-{
-  "runs": [
-    {
-      "run_id": "run123",
-      "status": "success",
-      "created_at": "2024-01-15T10:30:00Z"
-    }
-  ]
-}
-```
-
-#### Stream Run
-
-Stream responses in real-time.
-
-```http
-POST /api/langgraph/threads/{thread_id}/runs/stream
-Content-Type: application/json
-```
-
-Same request body as Create Run. Returns SSE stream.
-
----
-
-## Gateway API
-
-Base URL: `/api`
-
-### Models
-
-#### List Models
-
-Get all available LLM models from configuration.
-
-```http
-GET /api/models
-```
-
-**Response:**
-```json
-{
-  "models": [
-    {
-      "name": "gpt-4",
-      "display_name": "GPT-4",
-      "supports_thinking": false,
-      "supports_vision": true
-    },
-    {
-      "name": "claude-3-opus",
-      "display_name": "Claude 3 Opus",
-      "supports_thinking": false,
-      "supports_vision": true
-    },
-    {
-      "name": "deepseek-v3",
-      "display_name": "DeepSeek V3",
-      "supports_thinking": true,
-      "supports_vision": false
-    }
-  ]
-}
-```
-
-#### Get Model Details
-
-```http
-GET /api/models/{model_name}
-```
-
-**Response:**
-```json
-{
-  "name": "gpt-4",
-  "display_name": "GPT-4",
-  "model": "gpt-4",
-  "max_tokens": 4096,
-  "supports_thinking": false,
-  "supports_vision": true
-}
-```
-
-### MCP Configuration
-
-#### Get MCP Config
-
-Get current MCP server configurations.
-
-```http
-GET /api/mcp/config
-```
-
-**Response:**
-```json
-{
-  "mcpServers": {
-    "github": {
-      "enabled": true,
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-github"],
-      "env": {
-        "GITHUB_TOKEN": "***"
-      },
-      "description": "GitHub operations"
-    },
-    "filesystem": {
-      "enabled": false,
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-filesystem"],
-      "description": "File system access"
-    }
-  }
-}
-```
-
-#### Update MCP Config
-
-Update MCP server configurations.
-
-```http
-PUT /api/mcp/config
-Content-Type: application/json
-```
-
-**Request Body:**
-```json
-{
-  "mcpServers": {
-    "github": {
-      "enabled": true,
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-github"],
-      "env": {
-        "GITHUB_TOKEN": "$GITHUB_TOKEN"
-      },
-      "description": "GitHub operations"
-    }
-  }
-}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "MCP configuration updated"
-}
-```
-
-### Skills
-
-#### List Skills
-
-Get all available skills.
-
-```http
-GET /api/skills
-```
-
-**Response:**
-```json
-{
-  "skills": [
-    {
-      "name": "pdf-processing",
-      "display_name": "PDF Processing",
-      "description": "Handle PDF documents efficiently",
-      "enabled": true,
-      "license": "MIT",
-      "path": "public/pdf-processing"
-    },
-    {
-      "name": "frontend-design",
-      "display_name": "Frontend Design",
-      "description": "Design and build frontend interfaces",
-      "enabled": false,
-      "license": "MIT",
-      "path": "public/frontend-design"
-    }
-  ]
-}
-```
-
-#### Get Skill Details
-
-```http
-GET /api/skills/{skill_name}
-```
-
-**Response:**
-```json
-{
-  "name": "pdf-processing",
-  "display_name": "PDF Processing",
-  "description": "Handle PDF documents efficiently",
-  "enabled": true,
-  "license": "MIT",
-  "path": "public/pdf-processing",
-  "allowed_tools": ["read_file", "write_file", "bash"],
-  "content": "# PDF Processing\n\nInstructions for the agent..."
-}
-```
-
-#### Enable Skill
-
-```http
-POST /api/skills/{skill_name}/enable
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Skill 'pdf-processing' enabled"
-}
-```
-
-#### Disable Skill
-
-```http
-POST /api/skills/{skill_name}/disable
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Skill 'pdf-processing' disabled"
-}
-```
-
-#### Install Skill
-
-Install a skill from a `.skill` file.
-
-```http
-POST /api/skills/install
-Content-Type: multipart/form-data
-```
-
-**Request Body:**
-- `file`: The `.skill` file to install
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Skill 'my-skill' installed successfully",
-  "skill": {
-    "name": "my-skill",
-    "display_name": "My Skill",
-    "path": "custom/my-skill"
-  }
-}
-```
-
-### File Uploads
-
-#### Upload Files
-
-Upload one or more files to a thread.
-
-```http
-POST /api/threads/{thread_id}/uploads
-Content-Type: multipart/form-data
-```
-
-**Request Body:**
-- `files`: One or more files to upload
-
-**Response:**
-```json
-{
-  "success": true,
-  "files": [
-    {
-      "filename": "document.pdf",
-      "size": 1234567,
-      "path": ".deer-flow/threads/abc123/user-data/uploads/document.pdf",
-      "virtual_path": "/mnt/user-data/uploads/document.pdf",
-      "artifact_url": "/api/threads/abc123/artifacts/mnt/user-data/uploads/document.pdf",
-      "markdown_file": "document.md",
-      "markdown_path": ".deer-flow/threads/abc123/user-data/uploads/document.md",
-      "markdown_virtual_path": "/mnt/user-data/uploads/document.md",
-      "markdown_artifact_url": "/api/threads/abc123/artifacts/mnt/user-data/uploads/document.md"
-    }
-  ],
-  "message": "Successfully uploaded 1 file(s)"
-}
-```
-
-**Supported Document Formats** (auto-converted to Markdown):
-- PDF (`.pdf`)
-- PowerPoint (`.ppt`, `.pptx`)
-- Excel (`.xls`, `.xlsx`)
-- Word (`.doc`, `.docx`)
-
-#### List Uploaded Files
-
-```http
-GET /api/threads/{thread_id}/uploads/list
-```
-
-**Response:**
-```json
-{
-  "files": [
-    {
-      "filename": "document.pdf",
-      "size": 1234567,
-      "path": ".deer-flow/threads/abc123/user-data/uploads/document.pdf",
-      "virtual_path": "/mnt/user-data/uploads/document.pdf",
-      "artifact_url": "/api/threads/abc123/artifacts/mnt/user-data/uploads/document.pdf",
-      "extension": ".pdf",
-      "modified": 1705997600.0
-    }
-  ],
-  "count": 1
-}
-```
-
-#### Delete File
-
-```http
-DELETE /api/threads/{thread_id}/uploads/{filename}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Deleted document.pdf"
-}
-```
-
-### Thread Cleanup
-
-Remove DeerFlow-managed local thread files under `.deer-flow/threads/{thread_id}` after the LangGraph thread itself has been deleted.
-
-```http
-DELETE /api/threads/{thread_id}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "message": "Deleted local thread data for abc123"
-}
-```
-
-**Error behavior:**
-- `422` for invalid thread IDs
-- `500` returns a generic `{"detail": "Failed to delete local thread data."}` response while full exception details stay in server logs
-
-### Artifacts
-
-#### Get Artifact
-
-Download or view an artifact generated by the agent.
-
-```http
-GET /api/threads/{thread_id}/artifacts/{path}
-```
-
-**Path Examples:**
-- `/api/threads/abc123/artifacts/mnt/user-data/outputs/result.txt`
-- `/api/threads/abc123/artifacts/mnt/user-data/uploads/document.pdf`
-
-**Query Parameters:**
-- `download` (boolean): If `true`, force download with Content-Disposition header
-
-**Response:** File content with appropriate Content-Type
-
----
-
-## Error Responses
-
-All APIs return errors in a consistent format:
-
-```json
-{
-  "detail": "Error message describing what went wrong"
-}
-```
-
-**HTTP Status Codes:**
-- `400` - Bad Request: Invalid input
-- `404` - Not Found: Resource not found
-- `422` - Validation Error: Request validation failed
-- `500` - Internal Server Error: Server-side error
-
----
-
-## Authentication
-
-Currently, DeerFlow does not implement authentication. All APIs are accessible without credentials.
-
-Note: This is about DeerFlow API authentication. MCP outbound connections can still use OAuth for configured HTTP/SSE MCP servers.
-
-For production deployments, it is recommended to:
-1. Use Nginx for basic auth or OAuth integration
-2. Deploy behind a VPN or private network
-3. Implement custom authentication middleware
-
----
-
-## Rate Limiting
-
-No rate limiting is implemented by default. For production deployments, configure rate limiting in Nginx:
-
-```nginx
-limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;
-
-location /api/ {
-    limit_req zone=api burst=20 nodelay;
-    proxy_pass http://backend;
-}
-```
-
----
-
-## WebSocket Support
-
-The LangGraph server supports WebSocket connections for real-time streaming. Connect to:
-
-```
-ws://localhost:2026/api/langgraph/threads/{thread_id}/runs/stream
-```
-
----
-
-## SDK Usage
-
-### Python (LangGraph SDK)
-
-```python
-from langgraph_sdk import get_client
-
-client = get_client(url="http://localhost:2026/api/langgraph")
-
-# Create thread
-thread = await client.threads.create()
-
-# Run agent
-async for event in client.runs.stream(
-    thread["thread_id"],
-    "lead_agent",
-    input={"messages": [{"role": "user", "content": "Hello"}]},
-    config={"configurable": {"model_name": "gpt-4"}},
-    stream_mode=["values", "messages-tuple", "custom"],
-):
-    print(event)
-```
-
-### JavaScript/TypeScript
-
-```typescript
-// Using fetch for Gateway API
-const response = await fetch('/api/models');
-const data = await response.json();
-console.log(data.models);
-
-// Using EventSource for streaming
-const eventSource = new EventSource(
-  `/api/langgraph/threads/${threadId}/runs/stream`
-);
-eventSource.onmessage = (event) => {
-  console.log(JSON.parse(event.data));
-};
-```
-
-### cURL Examples
-
-```bash
-# List models
-curl http://localhost:2026/api/models
-
-# Get MCP config
-curl http://localhost:2026/api/mcp/config
-
-# Upload file
-curl -X POST http://localhost:2026/api/threads/abc123/uploads \
-  -F "files=@document.pdf"
-
-# Enable skill
-curl -X POST http://localhost:2026/api/skills/pdf-processing/enable
-
-# Create thread and run agent
-curl -X POST http://localhost:2026/api/langgraph/threads \
-  -H "Content-Type: application/json" \
-  -d '{}'
-
-curl -X POST http://localhost:2026/api/langgraph/threads/abc123/runs \
-  -H "Content-Type: application/json" \
-  -d '{
-    "input": {"messages": [{"role": "user", "content": "Hello"}]},
-    "config": {"configurable": {"model_name": "gpt-4"}}
-  }'
-```

backend/docs/APPLE_CONTAINER.md

@@ -1,238 +0,0 @@
-# Apple Container Support
-
-DeerFlow now supports Apple Container as the preferred container runtime on macOS, with automatic fallback to Docker.
-
-## Overview
-
-Starting with this version, DeerFlow automatically detects and uses Apple Container on macOS when available, falling back to Docker when:
-- Apple Container is not installed
-- Running on non-macOS platforms
-
-This provides better performance on Apple Silicon Macs while maintaining compatibility across all platforms.
-
-## Benefits
-
-### On Apple Silicon Macs with Apple Container:
-- **Better Performance**: Native ARM64 execution without Rosetta 2 translation
-- **Lower Resource Usage**: Lighter weight than Docker Desktop
-- **Native Integration**: Uses macOS Virtualization.framework
-
-### Fallback to Docker:
-- Full backward compatibility
-- Works on all platforms (macOS, Linux, Windows)
-- No configuration changes needed
-
-## Requirements
-
-### For Apple Container (macOS only):
-- macOS 15.0 or later
-- Apple Silicon (M1/M2/M3/M4)
-- Apple Container CLI installed
-
-### Installation:
-```bash
-# Download from GitHub releases
-# https://github.com/apple/container/releases
-
-# Verify installation
-container --version
-
-# Start the service
-container system start
-```
-
-### For Docker (all platforms):
-- Docker Desktop or Docker Engine
-
-## How It Works
-
-### Automatic Detection
-
-The `AioSandboxProvider` automatically detects the available container runtime:
-
-1. On macOS: Try `container --version`
-   - Success → Use Apple Container
-   - Failure → Fall back to Docker
-
-2. On other platforms: Use Docker directly
-
-### Runtime Differences
-
-Both runtimes use nearly identical command syntax:
-
-**Container Startup:**
-```bash
-# Apple Container
-container run --rm -d -p 8080:8080 -v /host:/container -e KEY=value image
-
-# Docker
-docker run --rm -d -p 8080:8080 -v /host:/container -e KEY=value image
-```
-
-**Container Cleanup:**
-```bash
-# Apple Container (with --rm flag)
-container stop <id>  # Auto-removes due to --rm
-
-# Docker (with --rm flag)
-docker stop <id>     # Auto-removes due to --rm
-```
-
-### Implementation Details
-
-The implementation is in `backend/packages/harness/deerflow/community/aio_sandbox/aio_sandbox_provider.py`:
-
-- `_detect_container_runtime()`: Detects available runtime at startup
-- `_start_container()`: Uses detected runtime, skips Docker-specific options for Apple Container
-- `_stop_container()`: Uses appropriate stop command for the runtime
-
-## Configuration
-
-No configuration changes are needed! The system works automatically.
-
-However, you can verify the runtime in use by checking the logs:
-
-```
-INFO:deerflow.community.aio_sandbox.aio_sandbox_provider:Detected Apple Container: container version 0.1.0
-INFO:deerflow.community.aio_sandbox.aio_sandbox_provider:Starting sandbox container using container: ...
-```
-
-Or for Docker:
-```
-INFO:deerflow.community.aio_sandbox.aio_sandbox_provider:Apple Container not available, falling back to Docker
-INFO:deerflow.community.aio_sandbox.aio_sandbox_provider:Starting sandbox container using docker: ...
-```
-
-## Container Images
-
-Both runtimes use OCI-compatible images. The default image works with both:
-
-```yaml
-sandbox:
-  use: deerflow.community.aio_sandbox:AioSandboxProvider
-  image: enterprise-public-cn-beijing.cr.volces.com/vefaas-public/all-in-one-sandbox:latest  # Default image
-```
-
-Make sure your images are available for the appropriate architecture:
-- ARM64 for Apple Container on Apple Silicon
-- AMD64 for Docker on Intel Macs
-- Multi-arch images work on both
-
-### Pre-pulling Images (Recommended)
-
-**Important**: Container images are typically large (500MB+) and are pulled on first use, which can cause a long wait time without clear feedback.
-
-**Best Practice**: Pre-pull the image during setup:
-
-```bash
-# From project root
-make setup-sandbox
-```
-
-This command will:
-1. Read the configured image from `config.yaml` (or use default)
-2. Detect available runtime (Apple Container or Docker)
-3. Pull the image with progress indication
-4. Verify the image is ready for use
-
-**Manual pre-pull**:
-
-```bash
-# Using Apple Container
-container image pull enterprise-public-cn-beijing.cr.volces.com/vefaas-public/all-in-one-sandbox:latest
-
-# Using Docker
-docker pull enterprise-public-cn-beijing.cr.volces.com/vefaas-public/all-in-one-sandbox:latest
-```
-
-If you skip pre-pulling, the image will be automatically pulled on first agent execution, which may take several minutes depending on your network speed.
-
-## Cleanup Scripts
-
-The project includes a unified cleanup script that handles both runtimes:
-
-**Script:** `scripts/cleanup-containers.sh`
-
-**Usage:**
-```bash
-# Clean up all DeerFlow sandbox containers
-./scripts/cleanup-containers.sh deer-flow-sandbox
-
-# Custom prefix
-./scripts/cleanup-containers.sh my-prefix
-```
-
-**Makefile Integration:**
-
-All cleanup commands in `Makefile` automatically handle both runtimes:
-```bash
-make stop   # Stops all services and cleans up containers
-make clean  # Full cleanup including logs
-```
-
-## Testing
-
-Test the container runtime detection:
-
-```bash
-cd backend
-python test_container_runtime.py
-```
-
-This will:
-1. Detect the available runtime
-2. Optionally start a test container
-3. Verify connectivity
-4. Clean up
-
-## Troubleshooting
-
-### Apple Container not detected on macOS
-
-1. Check if installed:
-   ```bash
-   which container
-   container --version
-   ```
-
-2. Check if service is running:
-   ```bash
-   container system start
-   ```
-
-3. Check logs for detection:
-   ```bash
-   # Look for detection message in application logs
-   grep "container runtime" logs/*.log
-   ```
-
-### Containers not cleaning up
-
-1. Manually check running containers:
-   ```bash
-   # Apple Container
-   container list
-
-   # Docker
-   docker ps
-   ```
-
-2. Run cleanup script manually:
-   ```bash
-   ./scripts/cleanup-containers.sh deer-flow-sandbox
-   ```
-
-### Performance issues
-
-- Apple Container should be faster on Apple Silicon
-- If experiencing issues, you can force Docker by temporarily renaming the `container` command:
-   ```bash
-   # Temporary workaround - not recommended for permanent use
-   sudo mv /opt/homebrew/bin/container /opt/homebrew/bin/container.bak
-   ```
-
-## References
-
-- [Apple Container GitHub](https://github.com/apple/container)
-- [Apple Container Documentation](https://github.com/apple/container/blob/main/docs/)
-- [OCI Image Spec](https://github.com/opencontainers/image-spec)

backend/docs/ARCHITECTURE.md

@@ -1,484 +0,0 @@
-# Architecture Overview
-
-This document provides a comprehensive overview of the DeerFlow backend architecture.
-
-## System Architecture
-
-```
-┌──────────────────────────────────────────────────────────────────────────┐
-│                              Client (Browser)                             │
-└─────────────────────────────────┬────────────────────────────────────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│                          Nginx (Port 2026)                               │
-│                    Unified Reverse Proxy Entry Point                      │
-│  ┌────────────────────────────────────────────────────────────────────┐  │
-│  │  /api/langgraph/*  →  LangGraph Server (2024)                      │  │
-│  │  /api/*            →  Gateway API (8001)                           │  │
-│  │  /*                →  Frontend (3000)                               │  │
-│  └────────────────────────────────────────────────────────────────────┘  │
-└─────────────────────────────────┬────────────────────────────────────────┘
-                                  │
-          ┌───────────────────────┼───────────────────────┐
-          │                       │                       │
-          ▼                       ▼                       ▼
-┌─────────────────────┐ ┌─────────────────────┐ ┌─────────────────────┐
-│   LangGraph Server  │ │    Gateway API      │ │     Frontend        │
-│     (Port 2024)     │ │    (Port 8001)      │ │    (Port 3000)      │
-│                     │ │                     │ │                     │
-│  - Agent Runtime    │ │  - Models API       │ │  - Next.js App      │
-│  - Thread Mgmt      │ │  - MCP Config       │ │  - React UI         │
-│  - SSE Streaming    │ │  - Skills Mgmt      │ │  - Chat Interface   │
-│  - Checkpointing    │ │  - File Uploads     │ │                     │
-│                     │ │  - Thread Cleanup   │ │                     │
-│                     │ │  - Artifacts        │ │                     │
-└─────────────────────┘ └─────────────────────┘ └─────────────────────┘
-          │                       │
-          │     ┌─────────────────┘
-          │     │
-          ▼     ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│                         Shared Configuration                              │
-│  ┌─────────────────────────┐  ┌────────────────────────────────────────┐ │
-│  │      config.yaml        │  │      extensions_config.json            │ │
-│  │  - Models               │  │  - MCP Servers                         │ │
-│  │  - Tools                │  │  - Skills State                        │ │
-│  │  - Sandbox              │  │                                        │ │
-│  │  - Summarization        │  │                                        │ │
-│  └─────────────────────────┘  └────────────────────────────────────────┘ │
-└──────────────────────────────────────────────────────────────────────────┘
-```
-
-## Component Details
-
-### LangGraph Server
-
-The LangGraph server is the core agent runtime, built on LangGraph for robust multi-agent workflow orchestration.
-
-**Entry Point**: `packages/harness/deerflow/agents/lead_agent/agent.py:make_lead_agent`
-
-**Key Responsibilities**:
-- Agent creation and configuration
-- Thread state management
-- Middleware chain execution
-- Tool execution orchestration
-- SSE streaming for real-time responses
-
-**Configuration**: `langgraph.json`
-
-```json
-{
-  "agent": {
-    "type": "agent",
-    "path": "deerflow.agents:make_lead_agent"
-  }
-}
-```
-
-### Gateway API
-
-FastAPI application providing REST endpoints for non-agent operations.
-
-**Entry Point**: `app/gateway/app.py`
-
-**Routers**:
-- `models.py` - `/api/models` - Model listing and details
-- `mcp.py` - `/api/mcp` - MCP server configuration
-- `skills.py` - `/api/skills` - Skills management
-- `uploads.py` - `/api/threads/{id}/uploads` - File upload
-- `threads.py` - `/api/threads/{id}` - Local DeerFlow thread data cleanup after LangGraph deletion
-- `artifacts.py` - `/api/threads/{id}/artifacts` - Artifact serving
-- `suggestions.py` - `/api/threads/{id}/suggestions` - Follow-up suggestion generation
-
-The web conversation delete flow is now split across both backend surfaces: LangGraph handles `DELETE /api/langgraph/threads/{thread_id}` for thread state, then the Gateway `threads.py` router removes DeerFlow-managed filesystem data via `Paths.delete_thread_dir()`.
-
-### Agent Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                           make_lead_agent(config)                        │
-└────────────────────────────────────┬────────────────────────────────────┘
-                                     │
-                                     ▼
-┌─────────────────────────────────────────────────────────────────────────┐
-│                            Middleware Chain                              │
-│  ┌──────────────────────────────────────────────────────────────────┐   │
-│  │ 1. ThreadDataMiddleware  - Initialize workspace/uploads/outputs  │   │
-│  │ 2. UploadsMiddleware     - Process uploaded files               │   │
-│  │ 3. SandboxMiddleware     - Acquire sandbox environment          │   │
-│  │ 4. SummarizationMiddleware - Context reduction (if enabled)     │   │
-│  │ 5. TitleMiddleware       - Auto-generate titles                 │   │
-│  │ 6. TodoListMiddleware    - Task tracking (if plan_mode)         │   │
-│  │ 7. ViewImageMiddleware   - Vision model support                 │   │
-│  │ 8. ClarificationMiddleware - Handle clarifications              │   │
-│  └──────────────────────────────────────────────────────────────────┘   │
-└────────────────────────────────────┬────────────────────────────────────┘
-                                     │
-                                     ▼
-┌─────────────────────────────────────────────────────────────────────────┐
-│                              Agent Core                                  │
-│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────────┐   │
-│  │      Model       │  │      Tools       │  │    System Prompt     │   │
-│  │  (from factory)  │  │  (configured +   │  │  (with skills)       │   │
-│  │                  │  │   MCP + builtin) │  │                      │   │
-│  └──────────────────┘  └──────────────────┘  └──────────────────────┘   │
-└─────────────────────────────────────────────────────────────────────────┘
-```
-
-### Thread State
-
-The `ThreadState` extends LangGraph's `AgentState` with additional fields:
-
-```python
-class ThreadState(AgentState):
-    # Core state from AgentState
-    messages: list[BaseMessage]
-
-    # DeerFlow extensions
-    sandbox: dict             # Sandbox environment info
-    artifacts: list[str]      # Generated file paths
-    thread_data: dict         # {workspace, uploads, outputs} paths
-    title: str | None         # Auto-generated conversation title
-    todos: list[dict]         # Task tracking (plan mode)
-    viewed_images: dict       # Vision model image data
-```
-
-### Sandbox System
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                           Sandbox Architecture                           │
-└─────────────────────────────────────────────────────────────────────────┘
-
-                      ┌─────────────────────────┐
-                      │    SandboxProvider      │ (Abstract)
-                      │  - acquire()            │
-                      │  - get()                │
-                      │  - release()            │
-                      └────────────┬────────────┘
-                                   │
-              ┌────────────────────┼────────────────────┐
-              │                                         │
-              ▼                                         ▼
-┌─────────────────────────┐              ┌─────────────────────────┐
-│  LocalSandboxProvider   │              │  AioSandboxProvider     │
-│  (packages/harness/deerflow/sandbox/local.py) │              │  (packages/harness/deerflow/community/)       │
-│                         │              │                         │
-│  - Singleton instance   │              │  - Docker-based         │
-│  - Direct execution     │              │  - Isolated containers  │
-│  - Development use      │              │  - Production use       │
-└─────────────────────────┘              └─────────────────────────┘
-
-                      ┌─────────────────────────┐
-                      │        Sandbox          │ (Abstract)
-                      │  - execute_command()    │
-                      │  - read_file()          │
-                      │  - write_file()         │
-                      │  - list_dir()           │
-                      └─────────────────────────┘
-```
-
-**Virtual Path Mapping**:
-
-| Virtual Path | Physical Path |
-|-------------|---------------|
-| `/mnt/user-data/workspace` | `backend/.deer-flow/threads/{thread_id}/user-data/workspace` |
-| `/mnt/user-data/uploads` | `backend/.deer-flow/threads/{thread_id}/user-data/uploads` |
-| `/mnt/user-data/outputs` | `backend/.deer-flow/threads/{thread_id}/user-data/outputs` |
-| `/mnt/skills` | `deer-flow/skills/` |
-
-### Tool System
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                            Tool Sources                                  │
-└─────────────────────────────────────────────────────────────────────────┘
-
-┌─────────────────────┐  ┌─────────────────────┐  ┌─────────────────────┐
-│   Built-in Tools    │  │  Configured Tools   │  │     MCP Tools       │
-│  (packages/harness/deerflow/tools/)       │  │  (config.yaml)      │  │  (extensions.json)  │
-├─────────────────────┤  ├─────────────────────┤  ├─────────────────────┤
-│ - present_file      │  │ - web_search        │  │ - github            │
-│ - ask_clarification │  │ - web_fetch         │  │ - filesystem        │
-│ - view_image        │  │ - bash              │  │ - postgres          │
-│                     │  │ - read_file         │  │ - brave-search      │
-│                     │  │ - write_file        │  │ - puppeteer         │
-│                     │  │ - str_replace       │  │ - ...               │
-│                     │  │ - ls                │  │                     │
-└─────────────────────┘  └─────────────────────┘  └─────────────────────┘
-           │                       │                       │
-           └───────────────────────┴───────────────────────┘
-                                   │
-                                   ▼
-                      ┌─────────────────────────┐
-                      │   get_available_tools() │
-                      │   (packages/harness/deerflow/tools/__init__)  │
-                      └─────────────────────────┘
-```
-
-### Model Factory
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                          Model Factory                                   │
-│                     (packages/harness/deerflow/models/factory.py)                              │
-└─────────────────────────────────────────────────────────────────────────┘
-
-config.yaml:
-┌─────────────────────────────────────────────────────────────────────────┐
-│ models:                                                                  │
-│   - name: gpt-4                                                         │
-│     display_name: GPT-4                                                 │
-│     use: langchain_openai:ChatOpenAI                                    │
-│     model: gpt-4                                                        │
-│     api_key: $OPENAI_API_KEY                                            │
-│     max_tokens: 4096                                                    │
-│     supports_thinking: false                                            │
-│     supports_vision: true                                               │
-└─────────────────────────────────────────────────────────────────────────┘
-                                   │
-                                   ▼
-                      ┌─────────────────────────┐
-                      │   create_chat_model()   │
-                      │  - name: str            │
-                      │  - thinking_enabled     │
-                      └────────────┬────────────┘
-                                   │
-                                   ▼
-                      ┌─────────────────────────┐
-                      │   resolve_class()       │
-                      │  (reflection system)    │
-                      └────────────┬────────────┘
-                                   │
-                                   ▼
-                      ┌─────────────────────────┐
-                      │   BaseChatModel         │
-                      │  (LangChain instance)   │
-                      └─────────────────────────┘
-```
-
-**Supported Providers**:
-- OpenAI (`langchain_openai:ChatOpenAI`)
-- Anthropic (`langchain_anthropic:ChatAnthropic`)
-- DeepSeek (`langchain_deepseek:ChatDeepSeek`)
-- Custom via LangChain integrations
-
-### MCP Integration
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                          MCP Integration                                 │
-│                        (packages/harness/deerflow/mcp/manager.py)                              │
-└─────────────────────────────────────────────────────────────────────────┘
-
-extensions_config.json:
-┌─────────────────────────────────────────────────────────────────────────┐
-│ {                                                                        │
-│   "mcpServers": {                                                       │
-│     "github": {                                                         │
-│       "enabled": true,                                                  │
-│       "type": "stdio",                                                  │
-│       "command": "npx",                                                 │
-│       "args": ["-y", "@modelcontextprotocol/server-github"],           │
-│       "env": {"GITHUB_TOKEN": "$GITHUB_TOKEN"}                          │
-│     }                                                                   │
-│   }                                                                     │
-│ }                                                                       │
-└─────────────────────────────────────────────────────────────────────────┘
-                                   │
-                                   ▼
-                      ┌─────────────────────────┐
-                      │  MultiServerMCPClient   │
-                      │  (langchain-mcp-adapters)│
-                      └────────────┬────────────┘
-                                   │
-              ┌────────────────────┼────────────────────┐
-              │                    │                    │
-              ▼                    ▼                    ▼
-       ┌───────────┐        ┌───────────┐        ┌───────────┐
-       │  stdio    │        │   SSE     │        │   HTTP    │
-       │ transport │        │ transport │        │ transport │
-       └───────────┘        └───────────┘        └───────────┘
-```
-
-### Skills System
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                          Skills System                                   │
-│                       (packages/harness/deerflow/skills/loader.py)                             │
-└─────────────────────────────────────────────────────────────────────────┘
-
-Directory Structure:
-┌─────────────────────────────────────────────────────────────────────────┐
-│ skills/                                                                  │
-│ ├── public/                        # Public skills (committed)           │
-│ │   ├── pdf-processing/                                                 │
-│ │   │   └── SKILL.md                                                    │
-│ │   ├── frontend-design/                                                │
-│ │   │   └── SKILL.md                                                    │
-│ │   └── ...                                                             │
-│ └── custom/                        # Custom skills (gitignored)          │
-│     └── user-installed/                                                 │
-│         └── SKILL.md                                                    │
-└─────────────────────────────────────────────────────────────────────────┘
-
-SKILL.md Format:
-┌─────────────────────────────────────────────────────────────────────────┐
-│ ---                                                                      │
-│ name: PDF Processing                                                     │
-│ description: Handle PDF documents efficiently                            │
-│ license: MIT                                                            │
-│ allowed-tools:                                                          │
-│   - read_file                                                           │
-│   - write_file                                                          │
-│   - bash                                                                │
-│ ---                                                                      │
-│                                                                          │
-│ # Skill Instructions                                                     │
-│ Content injected into system prompt...                                   │
-└─────────────────────────────────────────────────────────────────────────┘
-```
-
-### Request Flow
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                         Request Flow Example                             │
-│                    User sends message to agent                           │
-└─────────────────────────────────────────────────────────────────────────┘
-
-1. Client → Nginx
-   POST /api/langgraph/threads/{thread_id}/runs
-   {"input": {"messages": [{"role": "user", "content": "Hello"}]}}
-
-2. Nginx → LangGraph Server (2024)
-   Proxied to LangGraph server
-
-3. LangGraph Server
-   a. Load/create thread state
-   b. Execute middleware chain:
-      - ThreadDataMiddleware: Set up paths
-      - UploadsMiddleware: Inject file list
-      - SandboxMiddleware: Acquire sandbox
-      - SummarizationMiddleware: Check token limits
-      - TitleMiddleware: Generate title if needed
-      - TodoListMiddleware: Load todos (if plan mode)
-      - ViewImageMiddleware: Process images
-      - ClarificationMiddleware: Check for clarifications
-
-   c. Execute agent:
-      - Model processes messages
-      - May call tools (bash, web_search, etc.)
-      - Tools execute via sandbox
-      - Results added to messages
-
-   d. Stream response via SSE
-
-4. Client receives streaming response
-```
-
-## Data Flow
-
-### File Upload Flow
-
-```
-1. Client uploads file
-   POST /api/threads/{thread_id}/uploads
-   Content-Type: multipart/form-data
-
-2. Gateway receives file
-   - Validates file
-   - Stores in .deer-flow/threads/{thread_id}/user-data/uploads/
-   - If document: converts to Markdown via markitdown
-
-3. Returns response
-   {
-     "files": [{
-       "filename": "doc.pdf",
-       "path": ".deer-flow/.../uploads/doc.pdf",
-       "virtual_path": "/mnt/user-data/uploads/doc.pdf",
-       "artifact_url": "/api/threads/.../artifacts/mnt/.../doc.pdf"
-     }]
-   }
-
-4. Next agent run
-   - UploadsMiddleware lists files
-   - Injects file list into messages
-   - Agent can access via virtual_path
-```
-
-### Thread Cleanup Flow
-
-```
-1. Client deletes conversation via LangGraph
-   DELETE /api/langgraph/threads/{thread_id}
-
-2. Web UI follows up with Gateway cleanup
-   DELETE /api/threads/{thread_id}
-
-3. Gateway removes local DeerFlow-managed files
-   - Deletes .deer-flow/threads/{thread_id}/ recursively
-   - Missing directories are treated as a no-op
-   - Invalid thread IDs are rejected before filesystem access
-```
-
-### Configuration Reload
-
-```
-1. Client updates MCP config
-   PUT /api/mcp/config
-
-2. Gateway writes extensions_config.json
-   - Updates mcpServers section
-   - File mtime changes
-
-3. MCP Manager detects change
-   - get_cached_mcp_tools() checks mtime
-   - If changed: reinitializes MCP client
-   - Loads updated server configurations
-
-4. Next agent run uses new tools
-```
-
-## Security Considerations
-
-### Sandbox Isolation
-
-- Agent code executes within sandbox boundaries
-- Local sandbox: Direct execution (development only)
-- Docker sandbox: Container isolation (production recommended)
-- Path traversal prevention in file operations
-
-### API Security
-
-- Thread isolation: Each thread has separate data directories
-- File validation: Uploads checked for path safety
-- Environment variable resolution: Secrets not stored in config
-
-### MCP Security
-
-- Each MCP server runs in its own process
-- Environment variables resolved at runtime
-- Servers can be enabled/disabled independently
-
-## Performance Considerations
-
-### Caching
-
-- MCP tools cached with file mtime invalidation
-- Configuration loaded once, reloaded on file change
-- Skills parsed once at startup, cached in memory
-
-### Streaming
-
-- SSE used for real-time response streaming
-- Reduces time to first token
-- Enables progress visibility for long operations
-
-### Context Management
-
-- Summarization middleware reduces context when limits approached
-- Configurable triggers: tokens, messages, or fraction
-- Preserves recent messages while summarizing older ones

backend/docs/AUTH_UPGRADE.md

@@ -1,129 +0,0 @@
-# Authentication Upgrade Guide
-
-DeerFlow 内置了认证模块。本文档面向从无认证版本升级的用户。
-
-## 核心概念
-
-认证模块采用**始终强制**策略：
-
-- 首次启动时自动创建 admin 账号，随机密码打印到控制台日志
-- 认证从一开始就是强制的，无竞争窗口
-- 历史对话（升级前创建的 thread）自动迁移到 admin 名下
-
-## 升级步骤
-
-### 1. 更新代码
-
-```bash
-git pull origin main
-cd backend && make install
-```
-
-### 2. 首次启动
-
-```bash
-make dev
-```
-
-控制台会输出：
-
-```
-============================================================
-  Admin account created on first boot
-  Email:    admin@deerflow.dev
-  Password: aB3xK9mN_pQ7rT2w
-  Change it after login: Settings → Account
-============================================================
-```
-
-如果未登录就重启了服务，不用担心——只要 setup 未完成，每次启动都会重置密码并重新打印到控制台。
-
-### 3. 登录
-
-访问 `http://localhost:2026/login`，使用控制台输出的邮箱和密码登录。
-
-### 4. 修改密码
-
-登录后进入 Settings → Account → Change Password。
-
-### 5. 添加用户（可选）
-
-其他用户通过 `/login` 页面注册，自动获得 **user** 角色。每个用户只能看到自己的对话。
-
-## 安全机制
-
-| 机制 | 说明 |
-|------|------|
-| JWT HttpOnly Cookie | Token 不暴露给 JavaScript，防止 XSS 窃取 |
-| CSRF Double Submit Cookie | 所有 POST/PUT/DELETE 请求需携带 `X-CSRF-Token` |
-| bcrypt 密码哈希 | 密码不以明文存储 |
-| 多租户隔离 | 用户只能访问自己的 thread |
-| HTTPS 自适应 | 检测 `x-forwarded-proto`，自动设置 `Secure` cookie 标志 |
-
-## 常见操作
-
-### 忘记密码
-
-```bash
-cd backend
-
-# 重置 admin 密码
-python -m app.gateway.auth.reset_admin
-
-# 重置指定用户密码
-python -m app.gateway.auth.reset_admin --email user@example.com
-```
-
-会输出新的随机密码。
-
-### 完全重置
-
-删除用户数据库，重启后自动创建新 admin：
-
-```bash
-rm -f backend/.deer-flow/users.db
-# 重启服务，控制台输出新密码
-```
-
-## 数据存储
-
-| 文件 | 内容 |
-|------|------|
-| `.deer-flow/users.db` | SQLite 用户数据库（密码哈希、角色） |
-| `.env` 中的 `AUTH_JWT_SECRET` | JWT 签名密钥（未设置时自动生成临时密钥，重启后 session 失效） |
-
-### 生产环境建议
-
-```bash
-# 生成持久化 JWT 密钥，避免重启后所有用户需重新登录
-python -c "import secrets; print(secrets.token_urlsafe(32))"
-# 将输出添加到 .env：
-# AUTH_JWT_SECRET=<生成的密钥>
-```
-
-## API 端点
-
-| 端点 | 方法 | 说明 |
-|------|------|------|
-| `/api/v1/auth/login/local` | POST | 邮箱密码登录（OAuth2 form） |
-| `/api/v1/auth/register` | POST | 注册新用户（user 角色） |
-| `/api/v1/auth/logout` | POST | 登出（清除 cookie） |
-| `/api/v1/auth/me` | GET | 获取当前用户信息 |
-| `/api/v1/auth/change-password` | POST | 修改密码 |
-| `/api/v1/auth/setup-status` | GET | 检查 admin 是否存在 |
-
-## 兼容性
-
-- **标准模式**（`make dev`）：完全兼容，admin 自动创建
-- **Gateway 模式**（`make dev-pro`）：完全兼容
-- **Docker 部署**：完全兼容，`.deer-flow/users.db` 需持久化卷挂载
-- **IM 渠道**（Feishu/Slack/Telegram）：通过 LangGraph SDK 通信，不经过认证层
-- **DeerFlowClient**（嵌入式）：不经过 HTTP，不受认证影响
-
-## 故障排查
-
-| 症状 | 原因 | 解决 |
-|------|------|------|
-| 启动后没看到密码 | admin 已存在（非首次启动） | 用 `reset_admin` 重置，或删 `users.db` |
-| 登录后 POST 返回 403 | CSRF token 缺失 | 确认前端已更新 |
-| 重启后需要重新登录 | `AUTH_JWT_SECRET` 未持久化 | 在 `.env` 中设置固定密钥 |

backend/docs/AUTO_TITLE_GENERATION.md

@@ -1,258 +0,0 @@
-# 自动 Thread Title 生成功能
-
-## 功能说明
-
-自动为对话线程生成标题，在用户首次提问并收到回复后自动触发。
-
-## 实现方式
-
-使用 `TitleMiddleware` 在 `after_model` 钩子中：
-1. 检测是否是首次对话（1个用户消息 + 1个助手回复）
-2. 检查 state 是否已有 title
-3. 调用 LLM 生成简洁的标题（默认最多6个词）
-4. 将 title 存储到 `ThreadState` 中（会被 checkpointer 持久化）
-
-TitleMiddleware 会先把 LangChain message content 里的结构化 block/list 内容归一化为纯文本，再拼到 title prompt 里，避免把 Python/JSON 的原始 repr 泄漏到标题生成模型。
-
-## ⚠️ 重要：存储机制
-
-### Title 存储位置
-
-Title 存储在 **`ThreadState.title`** 中，而非 thread metadata：
-
-```python
-class ThreadState(AgentState):
-    sandbox: SandboxState | None = None
-    title: str | None = None  # ✅ Title stored here
-```
-
-### 持久化说明
-
-| 部署方式 | 持久化 | 说明 |
-|---------|--------|------|
-| **LangGraph Studio (本地)** | ❌ 否 | 仅内存存储，重启后丢失 |
-| **LangGraph Platform** | ✅ 是 | 自动持久化到数据库 |
-| **自定义 + Checkpointer** | ✅ 是 | 需配置 PostgreSQL/SQLite checkpointer |
-
-### 如何启用持久化
-
-如果需要在本地开发时也持久化 title，需要配置 checkpointer：
-
-```python
-# 在 langgraph.json 同级目录创建 checkpointer.py
-from langgraph.checkpoint.postgres import PostgresSaver
-
-checkpointer = PostgresSaver.from_conn_string(
-    "postgresql://user:pass@localhost/dbname"
-)
-```
-
-然后在 `langgraph.json` 中引用：
-
-```json
-{
-  "graphs": {
-    "lead_agent": "deerflow.agents:lead_agent"
-  },
-  "checkpointer": "checkpointer:checkpointer"
-}
-```
-
-## 配置
-
-在 `config.yaml` 中添加（可选）：
-
-```yaml
-title:
-  enabled: true
-  max_words: 6
-  max_chars: 60
-  model_name: null  # 使用默认模型
-```
-
-或在代码中配置：
-
-```python
-from deerflow.config.title_config import TitleConfig, set_title_config
-
-set_title_config(TitleConfig(
-    enabled=True,
-    max_words=8,
-    max_chars=80,
-))
-```
-
-## 客户端使用
-
-### 获取 Thread Title
-
-```typescript
-// 方式1: 从 thread state 获取
-const state = await client.threads.getState(threadId);
-const title = state.values.title || "New Conversation";
-
-// 方式2: 监听 stream 事件
-for await (const chunk of client.runs.stream(threadId, assistantId, {
-  input: { messages: [{ role: "user", content: "Hello" }] }
-})) {
-  if (chunk.event === "values" && chunk.data.title) {
-    console.log("Title:", chunk.data.title);
-  }
-}
-```
-
-### 显示 Title
-
-```typescript
-// 在对话列表中显示
-function ConversationList() {
-  const [threads, setThreads] = useState([]);
-
-  useEffect(() => {
-    async function loadThreads() {
-      const allThreads = await client.threads.list();
-      
-      // 获取每个 thread 的 state 来读取 title
-      const threadsWithTitles = await Promise.all(
-        allThreads.map(async (t) => {
-          const state = await client.threads.getState(t.thread_id);
-          return {
-            id: t.thread_id,
-            title: state.values.title || "New Conversation",
-            updatedAt: t.updated_at,
-          };
-        })
-      );
-      
-      setThreads(threadsWithTitles);
-    }
-    loadThreads();
-  }, []);
-
-  return (
-    <ul>
-      {threads.map(thread => (
-        <li key={thread.id}>
-          <a href={`/chat/${thread.id}`}>{thread.title}</a>
-        </li>
-      ))}
-    </ul>
-  );
-}
-```
-
-## 工作流程
-
-```mermaid
-sequenceDiagram
-    participant User
-    participant Client
-    participant LangGraph
-    participant TitleMiddleware
-    participant LLM
-    participant Checkpointer
-
-    User->>Client: 发送首条消息
-    Client->>LangGraph: POST /threads/{id}/runs
-    LangGraph->>Agent: 处理消息
-    Agent-->>LangGraph: 返回回复
-    LangGraph->>TitleMiddleware: after_agent()
-    TitleMiddleware->>TitleMiddleware: 检查是否需要生成 title
-    TitleMiddleware->>LLM: 生成 title
-    LLM-->>TitleMiddleware: 返回 title
-    TitleMiddleware->>LangGraph: return {"title": "..."}
-    LangGraph->>Checkpointer: 保存 state (含 title)
-    LangGraph-->>Client: 返回响应
-    Client->>Client: 从 state.values.title 读取
-```
-
-## 优势
-
-✅ **可靠持久化** - 使用 LangGraph 的 state 机制，自动持久化  
-✅ **完全后端处理** - 客户端无需额外逻辑  
-✅ **自动触发** - 首次对话后自动生成  
-✅ **可配置** - 支持自定义长度、模型等  
-✅ **容错性强** - 失败时使用 fallback 策略  
-✅ **架构一致** - 与现有 SandboxMiddleware 保持一致  
-
-## 注意事项
-
-1. **读取方式不同**：Title 在 `state.values.title` 而非 `thread.metadata.title`
-2. **性能考虑**：title 生成会增加约 0.5-1 秒延迟，可通过使用更快的模型优化
-3. **并发安全**：middleware 在 agent 执行后运行，不会阻塞主流程
-4. **Fallback 策略**：如果 LLM 调用失败，会使用用户消息的前几个词作为 title
-
-## 测试
-
-```python
-# 测试 title 生成
-import pytest
-from deerflow.agents.title_middleware import TitleMiddleware
-
-def test_title_generation():
-    # TODO: 添加单元测试
-    pass
-```
-
-## 故障排查
-
-### Title 没有生成
-
-1. 检查配置是否启用：`get_title_config().enabled == True`
-2. 检查日志：查找 "Generated thread title" 或错误信息
-3. 确认是首次对话：只有 1 个用户消息和 1 个助手回复时才会触发
-
-### Title 生成但客户端看不到
-
-1. 确认读取位置：应该从 `state.values.title` 读取，而非 `thread.metadata.title`
-2. 检查 API 响应：确认 state 中包含 title 字段
-3. 尝试重新获取 state：`client.threads.getState(threadId)`
-
-### Title 重启后丢失
-
-1. 检查是否配置了 checkpointer（本地开发需要）
-2. 确认部署方式：LangGraph Platform 会自动持久化
-3. 查看数据库：确认 checkpointer 正常工作
-
-## 架构设计
-
-### 为什么使用 State 而非 Metadata？
-
-| 特性 | State | Metadata |
-|------|-------|----------|
-| **持久化** | ✅ 自动（通过 checkpointer） | ⚠️ 取决于实现 |
-| **版本控制** | ✅ 支持时间旅行 | ❌ 不支持 |
-| **类型安全** | ✅ TypedDict 定义 | ❌ 任意字典 |
-| **可追溯** | ✅ 每次更新都记录 | ⚠️ 只有最新值 |
-| **标准化** | ✅ LangGraph 核心机制 | ⚠️ 扩展功能 |
-
-### 实现细节
-
-```python
-# TitleMiddleware 核心逻辑
-@override
-def after_agent(self, state: TitleMiddlewareState, runtime: Runtime) -> dict | None:
-    """Generate and set thread title after the first agent response."""
-    if self._should_generate_title(state, runtime):
-        title = self._generate_title(runtime)
-        print(f"Generated thread title: {title}")
-        
-        # ✅ 返回 state 更新，会被 checkpointer 自动持久化
-        return {"title": title}
-    
-    return None
-```
-
-## 相关文件
-
-- [`packages/harness/deerflow/agents/thread_state.py`](../packages/harness/deerflow/agents/thread_state.py) - ThreadState 定义
-- [`packages/harness/deerflow/agents/middlewares/title_middleware.py`](../packages/harness/deerflow/agents/middlewares/title_middleware.py) - TitleMiddleware 实现
-- [`packages/harness/deerflow/config/title_config.py`](../packages/harness/deerflow/config/title_config.py) - 配置管理
-- [`config.yaml`](../../config.example.yaml) - 配置文件
-- [`packages/harness/deerflow/agents/lead_agent/agent.py`](../packages/harness/deerflow/agents/lead_agent/agent.py) - Middleware 注册
-
-## 参考资料
-
-- [LangGraph Checkpointer 文档](https://langchain-ai.github.io/langgraph/concepts/persistence/)
-- [LangGraph State 管理](https://langchain-ai.github.io/langgraph/concepts/low_level/#state)
-- [LangGraph Middleware](https://langchain-ai.github.io/langgraph/concepts/middleware/)

backend/docs/CONFIGURATION.md

@@ -1,369 +0,0 @@
-# Configuration Guide
-
-This guide explains how to configure DeerFlow for your environment.
-
-## Config Versioning
-
-`config.example.yaml` contains a `config_version` field that tracks schema changes. When the example version is higher than your local `config.yaml`, the application emits a startup warning:
-
-```
-WARNING - Your config.yaml (version 0) is outdated — the latest version is 1.
-Run `make config-upgrade` to merge new fields into your config.
-```
-
-- **Missing `config_version`** in your config is treated as version 0.
-- Run `make config-upgrade` to auto-merge missing fields (your existing values are preserved, a `.bak` backup is created).
-- When changing the config schema, bump `config_version` in `config.example.yaml`.
-
-## Configuration Sections
-
-### Models
-
-Configure the LLM models available to the agent:
-
-```yaml
-models:
-  - name: gpt-4                    # Internal identifier
-    display_name: GPT-4            # Human-readable name
-    use: langchain_openai:ChatOpenAI  # LangChain class path
-    model: gpt-4                   # Model identifier for API
-    api_key: $OPENAI_API_KEY       # API key (use env var)
-    max_tokens: 4096               # Max tokens per request
-    temperature: 0.7               # Sampling temperature
-```
-
-**Supported Providers**:
-- OpenAI (`langchain_openai:ChatOpenAI`)
-- Anthropic (`langchain_anthropic:ChatAnthropic`)
-- DeepSeek (`langchain_deepseek:ChatDeepSeek`)
-- Claude Code OAuth (`deerflow.models.claude_provider:ClaudeChatModel`)
-- Codex CLI (`deerflow.models.openai_codex_provider:CodexChatModel`)
-- Any LangChain-compatible provider
-
-CLI-backed provider examples:
-
-```yaml
-models:
-  - name: gpt-5.4
-    display_name: GPT-5.4 (Codex CLI)
-    use: deerflow.models.openai_codex_provider:CodexChatModel
-    model: gpt-5.4
-    supports_thinking: true
-    supports_reasoning_effort: true
-
-  - name: claude-sonnet-4.6
-    display_name: Claude Sonnet 4.6 (Claude Code OAuth)
-    use: deerflow.models.claude_provider:ClaudeChatModel
-    model: claude-sonnet-4-6
-    max_tokens: 4096
-    supports_thinking: true
-```
-
-**Auth behavior for CLI-backed providers**:
-- `CodexChatModel` loads Codex CLI auth from `~/.codex/auth.json`
-- The Codex Responses endpoint currently rejects `max_tokens` and `max_output_tokens`, so `CodexChatModel` does not expose a request-level token cap
-- `ClaudeChatModel` accepts `CLAUDE_CODE_OAUTH_TOKEN`, `ANTHROPIC_AUTH_TOKEN`, `CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR`, `CLAUDE_CODE_CREDENTIALS_PATH`, or plaintext `~/.claude/.credentials.json`
-- On macOS, DeerFlow does not probe Keychain automatically. Use `scripts/export_claude_code_oauth.py` to export Claude Code auth explicitly when needed
-
-To use OpenAI's `/v1/responses` endpoint with LangChain, keep using `langchain_openai:ChatOpenAI` and set:
-
-```yaml
-models:
-  - name: gpt-5-responses
-    display_name: GPT-5 (Responses API)
-    use: langchain_openai:ChatOpenAI
-    model: gpt-5
-    api_key: $OPENAI_API_KEY
-    use_responses_api: true
-    output_version: responses/v1
-```
-
-For OpenAI-compatible gateways (for example Novita or OpenRouter), keep using `langchain_openai:ChatOpenAI` and set `base_url`:
-
-```yaml
-models:
-  - name: novita-deepseek-v3.2
-    display_name: Novita DeepSeek V3.2
-    use: langchain_openai:ChatOpenAI
-    model: deepseek/deepseek-v3.2
-    api_key: $NOVITA_API_KEY
-    base_url: https://api.novita.ai/openai
-    supports_thinking: true
-    when_thinking_enabled:
-      extra_body:
-        thinking:
-          type: enabled
-
-  - name: minimax-m2.5
-    display_name: MiniMax M2.5
-    use: langchain_openai:ChatOpenAI
-    model: MiniMax-M2.5
-    api_key: $MINIMAX_API_KEY
-    base_url: https://api.minimax.io/v1
-    max_tokens: 4096
-    temperature: 1.0  # MiniMax requires temperature in (0.0, 1.0]
-    supports_vision: true
-
-  - name: minimax-m2.5-highspeed
-    display_name: MiniMax M2.5 Highspeed
-    use: langchain_openai:ChatOpenAI
-    model: MiniMax-M2.5-highspeed
-    api_key: $MINIMAX_API_KEY
-    base_url: https://api.minimax.io/v1
-    max_tokens: 4096
-    temperature: 1.0  # MiniMax requires temperature in (0.0, 1.0]
-    supports_vision: true
-  - name: openrouter-gemini-2.5-flash
-    display_name: Gemini 2.5 Flash (OpenRouter)
-    use: langchain_openai:ChatOpenAI
-    model: google/gemini-2.5-flash-preview
-    api_key: $OPENAI_API_KEY
-    base_url: https://openrouter.ai/api/v1
-```
-
-If your OpenRouter key lives in a different environment variable name, point `api_key` at that variable explicitly (for example `api_key: $OPENROUTER_API_KEY`).
-
-**Thinking Models**:
-Some models support "thinking" mode for complex reasoning:
-
-```yaml
-models:
-  - name: deepseek-v3
-    supports_thinking: true
-    when_thinking_enabled:
-      extra_body:
-        thinking:
-          type: enabled
-```
-
-**Gemini with thinking via OpenAI-compatible gateway**:
-
-When routing Gemini through an OpenAI-compatible proxy (Vertex AI OpenAI compat endpoint, AI Studio, or third-party gateways) with thinking enabled, the API attaches a `thought_signature` to each tool-call object returned in the response.  Every subsequent request that replays those assistant messages **must** echo those signatures back on the tool-call entries or the API returns:
-
-```
-HTTP 400 INVALID_ARGUMENT: function call `<tool>` in the N. content block is
-missing a `thought_signature`.
-```
-
-Standard `langchain_openai:ChatOpenAI` silently drops `thought_signature` when serialising messages.  Use `deerflow.models.patched_openai:PatchedChatOpenAI` instead — it re-injects the tool-call signatures (sourced from `AIMessage.additional_kwargs["tool_calls"]`) into every outgoing payload:
-
-```yaml
-models:
-  - name: gemini-2.5-pro-thinking
-    display_name: Gemini 2.5 Pro (Thinking)
-    use: deerflow.models.patched_openai:PatchedChatOpenAI
-    model: google/gemini-2.5-pro-preview   # model name as expected by your gateway
-    api_key: $GEMINI_API_KEY
-    base_url: https://<your-openai-compat-gateway>/v1
-    max_tokens: 16384
-    supports_thinking: true
-    supports_vision: true
-    when_thinking_enabled:
-      extra_body:
-        thinking:
-          type: enabled
-```
-
-For Gemini accessed **without** thinking (e.g. via OpenRouter where thinking is not activated), the plain `langchain_openai:ChatOpenAI` with `supports_thinking: false` is sufficient and no patch is needed.
-
-### Tool Groups
-
-Organize tools into logical groups:
-
-```yaml
-tool_groups:
-  - name: web          # Web browsing and search
-  - name: file:read    # Read-only file operations
-  - name: file:write   # Write file operations
-  - name: bash         # Shell command execution
-```
-
-### Tools
-
-Configure specific tools available to the agent:
-
-```yaml
-tools:
-  - name: web_search
-    group: web
-    use: deerflow.community.tavily.tools:web_search_tool
-    max_results: 5
-    # api_key: $TAVILY_API_KEY  # Optional
-```
-
-**Built-in Tools**:
-- `web_search` - Search the web (Tavily)
-- `web_fetch` - Fetch web pages (Jina AI)
-- `ls` - List directory contents
-- `read_file` - Read file contents
-- `write_file` - Write file contents
-- `str_replace` - String replacement in files
-- `bash` - Execute bash commands
-
-### Sandbox
-
-DeerFlow supports multiple sandbox execution modes. Configure your preferred mode in `config.yaml`:
-
-**Local Execution** (runs sandbox code directly on the host machine):
-```yaml
-sandbox:
-   use: deerflow.sandbox.local:LocalSandboxProvider # Local execution
-   allow_host_bash: false # default; host bash is disabled unless explicitly re-enabled
-```
-
-**Docker Execution** (runs sandbox code in isolated Docker containers):
-```yaml
-sandbox:
-   use: deerflow.community.aio_sandbox:AioSandboxProvider # Docker-based sandbox
-```
-
-**Docker Execution with Kubernetes** (runs sandbox code in Kubernetes pods via provisioner service):
-
-This mode runs each sandbox in an isolated Kubernetes Pod on your **host machine's cluster**. Requires Docker Desktop K8s, OrbStack, or similar local K8s setup.
-
-```yaml
-sandbox:
-   use: deerflow.community.aio_sandbox:AioSandboxProvider
-   provisioner_url: http://provisioner:8002
-```
-
-When using Docker development (`make docker-start`), DeerFlow starts the `provisioner` service only if this provisioner mode is configured. In local or plain Docker sandbox modes, `provisioner` is skipped.
-
-See [Provisioner Setup Guide](../../docker/provisioner/README.md) for detailed configuration, prerequisites, and troubleshooting.
-
-Choose between local execution or Docker-based isolation:
-
-**Option 1: Local Sandbox** (default, simpler setup):
-```yaml
-sandbox:
-  use: deerflow.sandbox.local:LocalSandboxProvider
-  allow_host_bash: false
-```
-
-`allow_host_bash` is intentionally `false` by default. DeerFlow's local sandbox is a host-side convenience mode, not a secure shell isolation boundary. If you need `bash`, prefer `AioSandboxProvider`. Only set `allow_host_bash: true` for fully trusted single-user local workflows.
-
-**Option 2: Docker Sandbox** (isolated, more secure):
-```yaml
-sandbox:
-  use: deerflow.community.aio_sandbox:AioSandboxProvider
-  port: 8080
-  auto_start: true
-  container_prefix: deer-flow-sandbox
-
-  # Optional: Additional mounts
-  mounts:
-    - host_path: /path/on/host
-      container_path: /path/in/container
-      read_only: false
-```
-
-When you configure `sandbox.mounts`, DeerFlow exposes those `container_path` values in the agent prompt so the agent can discover and operate on mounted directories directly instead of assuming everything must live under `/mnt/user-data`.
-
-### Skills
-
-Configure the skills directory for specialized workflows:
-
-```yaml
-skills:
-  # Host path (optional, default: ../skills)
-  path: /custom/path/to/skills
-
-  # Container mount path (default: /mnt/skills)
-  container_path: /mnt/skills
-```
-
-**How Skills Work**:
-- Skills are stored in `deer-flow/skills/{public,custom}/`
-- Each skill has a `SKILL.md` file with metadata
-- Skills are automatically discovered and loaded
-- Available in both local and Docker sandbox via path mapping
-
-**Per-Agent Skill Filtering**:
-Custom agents can restrict which skills they load by defining a `skills` field in their `config.yaml` (located at `workspace/agents/<agent_name>/config.yaml`):
-- **Omitted or `null`**: Loads all globally enabled skills (default fallback).
-- **`[]` (empty list)**: Disables all skills for this specific agent.
-- **`["skill-name"]`**: Loads only the explicitly specified skills.
-
-### Title Generation
-
-Automatic conversation title generation:
-
-```yaml
-title:
-  enabled: true
-  max_words: 6
-  max_chars: 60
-  model_name: null  # Use first model in list
-```
-
-### GitHub API Token (Optional for GitHub Deep Research Skill)
-
-The default GitHub API rate limits are quite restrictive. For frequent project research, we recommend configuring a personal access token (PAT) with read-only permissions.
-
-**Configuration Steps**:
-1. Uncomment the `GITHUB_TOKEN` line in the `.env` file and add your personal access token
-2. Restart the DeerFlow service to apply changes
-
-## Environment Variables
-
-DeerFlow supports environment variable substitution using the `$` prefix:
-
-```yaml
-models:
-  - api_key: $OPENAI_API_KEY  # Reads from environment
-```
-
-**Common Environment Variables**:
-- `OPENAI_API_KEY` - OpenAI API key
-- `ANTHROPIC_API_KEY` - Anthropic API key
-- `DEEPSEEK_API_KEY` - DeepSeek API key
-- `NOVITA_API_KEY` - Novita API key (OpenAI-compatible endpoint)
-- `TAVILY_API_KEY` - Tavily search API key
-- `DEER_FLOW_CONFIG_PATH` - Custom config file path
-
-## Configuration Location
-
-The configuration file should be placed in the **project root directory** (`deer-flow/config.yaml`), not in the backend directory.
-
-## Configuration Priority
-
-DeerFlow searches for configuration in this order:
-
-1. Path specified in code via `config_path` argument
-2. Path from `DEER_FLOW_CONFIG_PATH` environment variable
-3. `config.yaml` in current working directory (typically `backend/` when running)
-4. `config.yaml` in parent directory (project root: `deer-flow/`)
-
-## Best Practices
-
-1. **Place `config.yaml` in project root** - Not in `backend/` directory
-2. **Never commit `config.yaml`** - It's already in `.gitignore`
-3. **Use environment variables for secrets** - Don't hardcode API keys
-4. **Keep `config.example.yaml` updated** - Document all new options
-5. **Test configuration changes locally** - Before deploying
-6. **Use Docker sandbox for production** - Better isolation and security
-
-## Troubleshooting
-
-### "Config file not found"
-- Ensure `config.yaml` exists in the **project root** directory (`deer-flow/config.yaml`)
-- The backend searches parent directory by default, so root location is preferred
-- Alternatively, set `DEER_FLOW_CONFIG_PATH` environment variable to custom location
-
-### "Invalid API key"
-- Verify environment variables are set correctly
-- Check that `$` prefix is used for env var references
-
-### "Skills not loading"
-- Check that `deer-flow/skills/` directory exists
-- Verify skills have valid `SKILL.md` files
-- Check `skills.path` configuration if using custom path
-
-### "Docker sandbox fails to start"
-- Ensure Docker is running
-- Check port 8080 (or configured port) is available
-- Verify Docker image is accessible
-
-## Examples
-
-See `config.example.yaml` for complete examples of all configuration options.

backend/docs/FILE_UPLOAD.md

@@ -1,293 +0,0 @@
-# 文件上传功能
-
-## 概述
-
-DeerFlow 后端提供了完整的文件上传功能，支持多文件上传，并自动将 Office 文档和 PDF 转换为 Markdown 格式。
-
-## 功能特性
-
-- ✅ 支持多文件同时上传
-- ✅ 自动转换文档为 Markdown（PDF、PPT、Excel、Word）
-- ✅ 文件存储在线程隔离的目录中
-- ✅ Agent 自动感知已上传的文件
-- ✅ 支持文件列表查询和删除
-
-## API 端点
-
-### 1. 上传文件
-```
-POST /api/threads/{thread_id}/uploads
-```
-
-**请求体：** `multipart/form-data`
-- `files`: 一个或多个文件
-
-**响应：**
-```json
-{
-  "success": true,
-  "files": [
-    {
-      "filename": "document.pdf",
-      "size": 1234567,
-      "path": ".deer-flow/threads/{thread_id}/user-data/uploads/document.pdf",
-      "virtual_path": "/mnt/user-data/uploads/document.pdf",
-      "artifact_url": "/api/threads/{thread_id}/artifacts/mnt/user-data/uploads/document.pdf",
-      "markdown_file": "document.md",
-      "markdown_path": ".deer-flow/threads/{thread_id}/user-data/uploads/document.md",
-      "markdown_virtual_path": "/mnt/user-data/uploads/document.md",
-      "markdown_artifact_url": "/api/threads/{thread_id}/artifacts/mnt/user-data/uploads/document.md"
-    }
-  ],
-  "message": "Successfully uploaded 1 file(s)"
-}
-```
-
-**路径说明：**
-- `path`: 实际文件系统路径（相对于 `backend/` 目录）
-- `virtual_path`: Agent 在沙箱中使用的虚拟路径
-- `artifact_url`: 前端通过 HTTP 访问文件的 URL
-
-### 2. 列出已上传文件
-```
-GET /api/threads/{thread_id}/uploads/list
-```
-
-**响应：**
-```json
-{
-  "files": [
-    {
-      "filename": "document.pdf",
-      "size": 1234567,
-      "path": ".deer-flow/threads/{thread_id}/user-data/uploads/document.pdf",
-      "virtual_path": "/mnt/user-data/uploads/document.pdf",
-      "artifact_url": "/api/threads/{thread_id}/artifacts/mnt/user-data/uploads/document.pdf",
-      "extension": ".pdf",
-      "modified": 1705997600.0
-    }
-  ],
-  "count": 1
-}
-```
-
-### 3. 删除文件
-```
-DELETE /api/threads/{thread_id}/uploads/{filename}
-```
-
-**响应：**
-```json
-{
-  "success": true,
-  "message": "Deleted document.pdf"
-}
-```
-
-## 支持的文档格式
-
-以下格式会自动转换为 Markdown：
-- PDF (`.pdf`)
-- PowerPoint (`.ppt`, `.pptx`)
-- Excel (`.xls`, `.xlsx`)
-- Word (`.doc`, `.docx`)
-
-转换后的 Markdown 文件会保存在同一目录下，文件名为原文件名 + `.md` 扩展名。
-
-## Agent 集成
-
-### 自动文件列举
-
-Agent 在每次请求时会自动收到已上传文件的列表，格式如下：
-
-```xml
-<uploaded_files>
-The following files have been uploaded and are available for use:
-
-- document.pdf (1.2 MB)
-  Path: /mnt/user-data/uploads/document.pdf
-
-- document.md (45.3 KB)
-  Path: /mnt/user-data/uploads/document.md
-
-You can read these files using the `read_file` tool with the paths shown above.
-</uploaded_files>
-```
-
-### 使用上传的文件
-
-Agent 在沙箱中运行，使用虚拟路径访问文件。Agent 可以直接使用 `read_file` 工具读取上传的文件：
-
-```python
-# 读取原始 PDF（如果支持）
-read_file(path="/mnt/user-data/uploads/document.pdf")
-
-# 读取转换后的 Markdown（推荐）
-read_file(path="/mnt/user-data/uploads/document.md")
-```
-
-**路径映射关系：**
-- Agent 使用：`/mnt/user-data/uploads/document.pdf`（虚拟路径）
-- 实际存储：`backend/.deer-flow/threads/{thread_id}/user-data/uploads/document.pdf`
-- 前端访问：`/api/threads/{thread_id}/artifacts/mnt/user-data/uploads/document.pdf`（HTTP URL）
-
-上传流程采用“线程目录优先”策略：
-- 先写入 `backend/.deer-flow/threads/{thread_id}/user-data/uploads/` 作为权威存储
-- 本地沙箱（`sandbox_id=local`）直接使用线程目录内容
-- 非本地沙箱会额外同步到 `/mnt/user-data/uploads/*`，确保运行时可见
-
-## 测试示例
-
-### 使用 curl 测试
-
-```bash
-# 1. 上传单个文件
-curl -X POST http://localhost:2026/api/threads/test-thread/uploads \
-  -F "files=@/path/to/document.pdf"
-
-# 2. 上传多个文件
-curl -X POST http://localhost:2026/api/threads/test-thread/uploads \
-  -F "files=@/path/to/document.pdf" \
-  -F "files=@/path/to/presentation.pptx" \
-  -F "files=@/path/to/spreadsheet.xlsx"
-
-# 3. 列出已上传文件
-curl http://localhost:2026/api/threads/test-thread/uploads/list
-
-# 4. 删除文件
-curl -X DELETE http://localhost:2026/api/threads/test-thread/uploads/document.pdf
-```
-
-### 使用 Python 测试
-
-```python
-import requests
-
-thread_id = "test-thread"
-base_url = "http://localhost:2026"
-
-# 上传文件
-files = [
-    ("files", open("document.pdf", "rb")),
-    ("files", open("presentation.pptx", "rb")),
-]
-response = requests.post(
-    f"{base_url}/api/threads/{thread_id}/uploads",
-    files=files
-)
-print(response.json())
-
-# 列出文件
-response = requests.get(f"{base_url}/api/threads/{thread_id}/uploads/list")
-print(response.json())
-
-# 删除文件
-response = requests.delete(
-    f"{base_url}/api/threads/{thread_id}/uploads/document.pdf"
-)
-print(response.json())
-```
-
-## 文件存储结构
-
-```
-backend/.deer-flow/threads/
-└── {thread_id}/
-    └── user-data/
-        └── uploads/
-            ├── document.pdf          # 原始文件
-            ├── document.md           # 转换后的 Markdown
-            ├── presentation.pptx
-            ├── presentation.md
-            └── ...
-```
-
-## 限制
-
-- 最大文件大小：100MB（可在 nginx.conf 中配置 `client_max_body_size`）
-- 文件名安全性：系统会自动验证文件路径，防止目录遍历攻击
-- 线程隔离：每个线程的上传文件相互隔离，无法跨线程访问
-
-## 技术实现
-
-### 组件
-
-1. **Upload Router** (`app/gateway/routers/uploads.py`)
-   - 处理文件上传、列表、删除请求
-   - 使用 markitdown 转换文档
-
-2. **Uploads Middleware** (`packages/harness/deerflow/agents/middlewares/uploads_middleware.py`)
-   - 在每次 Agent 请求前注入文件列表
-   - 自动生成格式化的文件列表消息
-
-3. **Nginx 配置** (`nginx.conf`)
-   - 路由上传请求到 Gateway API
-   - 配置大文件上传支持
-
-### 依赖
-
-- `markitdown>=0.0.1a2` - 文档转换
-- `python-multipart>=0.0.20` - 文件上传处理
-
-## 故障排查
-
-### 文件上传失败
-
-1. 检查文件大小是否超过限制
-2. 检查 Gateway API 是否正常运行
-3. 检查磁盘空间是否充足
-4. 查看 Gateway 日志：`make gateway`
-
-### 文档转换失败
-
-1. 检查 markitdown 是否正确安装：`uv run python -c "import markitdown"`
-2. 查看日志中的具体错误信息
-3. 某些损坏或加密的文档可能无法转换，但原文件仍会保存
-
-### Agent 看不到上传的文件
-
-1. 确认 UploadsMiddleware 已在 agent.py 中注册
-2. 检查 thread_id 是否正确
-3. 确认文件确实已上传到 `backend/.deer-flow/threads/{thread_id}/user-data/uploads/`
-4. 非本地沙箱场景下，确认上传接口没有报错（需要成功完成 sandbox 同步）
-
-## 开发建议
-
-### 前端集成
-
-```typescript
-// 上传文件示例
-async function uploadFiles(threadId: string, files: File[]) {
-  const formData = new FormData();
-  files.forEach(file => {
-    formData.append('files', file);
-  });
-
-  const response = await fetch(
-    `/api/threads/${threadId}/uploads`,
-    {
-      method: 'POST',
-      body: formData,
-    }
-  );
-
-  return response.json();
-}
-
-// 列出文件
-async function listFiles(threadId: string) {
-  const response = await fetch(
-    `/api/threads/${threadId}/uploads/list`
-  );
-  return response.json();
-}
-```
-
-### 扩展功能建议
-
-1. **文件预览**：添加预览端点，支持在浏览器中直接查看文件
-2. **批量删除**：支持一次删除多个文件
-3. **文件搜索**：支持按文件名或类型搜索
-4. **版本控制**：保留文件的多个版本
-5. **压缩包支持**：自动解压 zip 文件
-6. **图片 OCR**：对上传的图片进行 OCR 识别

backend/docs/GUARDRAILS.md

@@ -1,385 +0,0 @@
-# Guardrails: Pre-Tool-Call Authorization
-
-> **Context:** [Issue #1213](https://github.com/bytedance/deer-flow/issues/1213) — DeerFlow has Docker sandboxing and human approval via `ask_clarification`, but no deterministic, policy-driven authorization layer for tool calls. An agent running autonomous multi-step tasks can execute any loaded tool with any arguments. Guardrails add a middleware that evaluates every tool call against a policy **before** execution.
-
-## Why Guardrails
-
-```
-Without guardrails:                      With guardrails:
-
-  Agent                                    Agent
-    │                                        │
-    ▼                                        ▼
-  ┌──────────┐                             ┌──────────┐
-  │ bash     │──▶ executes immediately     │ bash     │──▶ GuardrailMiddleware
-  │ rm -rf / │                             │ rm -rf / │        │
-  └──────────┘                             └──────────┘        ▼
-                                                         ┌──────────────┐
-                                                         │  Provider    │
-                                                         │  evaluates   │
-                                                         │  against     │
-                                                         │  policy      │
-                                                         └──────┬───────┘
-                                                                │
-                                                          ┌─────┴─────┐
-                                                          │           │
-                                                        ALLOW       DENY
-                                                          │           │
-                                                          ▼           ▼
-                                                      Tool runs   Agent sees:
-                                                      normally    "Guardrail denied:
-                                                                   rm -rf blocked"
-```
-
-- **Sandboxing** provides process isolation but not semantic authorization. A sandboxed `bash` can still `curl` data out.
-- **Human approval** (`ask_clarification`) requires a human in the loop for every action. Not viable for autonomous workflows.
-- **Guardrails** provide deterministic, policy-driven authorization that works without human intervention.
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│                        Middleware Chain                               │
-│                                                                      │
-│  1. ThreadDataMiddleware     ─── per-thread dirs                     │
-│  2. UploadsMiddleware        ─── file upload tracking                │
-│  3. SandboxMiddleware        ─── sandbox acquisition                 │
-│  4. DanglingToolCallMiddleware ── fix incomplete tool calls           │
-│  5. GuardrailMiddleware ◄──── EVALUATES EVERY TOOL CALL             │
-│  6. ToolErrorHandlingMiddleware ── convert exceptions to messages     │
-│  7-12. (Summarization, Title, Memory, Vision, Subagent, Clarify)    │
-│                                                                      │
-└─────────────────────────────────────────────────────────────────────┘
-                         │
-                         ▼
-           ┌──────────────────────────┐
-           │    GuardrailProvider     │  ◄── pluggable: any class
-           │    (configured in YAML)  │      with evaluate/aevaluate
-           └────────────┬─────────────┘
-                        │
-              ┌─────────┼──────────────┐
-              │         │              │
-              ▼         ▼              ▼
-         Built-in   OAP Passport    Custom
-         Allowlist  Provider        Provider
-         (zero dep) (open standard) (your code)
-                        │
-                  Any implementation
-                  (e.g. APort, or
-                   your own evaluator)
-```
-
-The `GuardrailMiddleware` implements `wrap_tool_call` / `awrap_tool_call` (the same `AgentMiddleware` pattern used by `ToolErrorHandlingMiddleware`). It:
-
-1. Builds a `GuardrailRequest` with tool name, arguments, and passport reference
-2. Calls `provider.evaluate(request)` on whatever provider is configured
-3. If **deny**: returns `ToolMessage(status="error")` with the reason -- agent sees the denial and adapts
-4. If **allow**: passes through to the actual tool handler
-5. If **provider error** and `fail_closed=true` (default): blocks the call
-6. `GraphBubbleUp` exceptions (LangGraph control signals) are always propagated, never caught
-
-## Three Provider Options
-
-### Option 1: Built-in AllowlistProvider (Zero Dependencies)
-
-The simplest option. Ships with DeerFlow. Block or allow tools by name. No external packages, no passport, no network.
-
-**config.yaml:**
-```yaml
-guardrails:
-  enabled: true
-  provider:
-    use: deerflow.guardrails.builtin:AllowlistProvider
-    config:
-      denied_tools: ["bash", "write_file"]
-```
-
-This blocks `bash` and `write_file` for all requests. All other tools pass through.
-
-You can also use an allowlist (only these tools are permitted):
-```yaml
-guardrails:
-  enabled: true
-  provider:
-    use: deerflow.guardrails.builtin:AllowlistProvider
-    config:
-      allowed_tools: ["web_search", "read_file", "ls"]
-```
-
-**Try it:**
-1. Add the config above to your `config.yaml`
-2. Start DeerFlow: `make dev`
-3. Ask the agent: "Use bash to run echo hello"
-4. The agent sees: `Guardrail denied: tool 'bash' was blocked (oap.tool_not_allowed)`
-
-### Option 2: OAP Passport Provider (Policy-Based)
-
-For policy enforcement based on the [Open Agent Passport (OAP)](https://github.com/aporthq/aport-spec) open standard. An OAP passport is a JSON document that declares an agent's identity, capabilities, and operational limits. Any provider that reads an OAP passport and returns OAP-compliant decisions works with DeerFlow.
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                    OAP Passport (JSON)                        │
-│                   (open standard, any provider)              │
-│  {                                                           │
-│    "spec_version": "oap/1.0",                                │
-│    "status": "active",                                       │
-│    "capabilities": [                                         │
-│      {"id": "system.command.execute"},                       │
-│      {"id": "data.file.read"},                               │
-│      {"id": "data.file.write"},                              │
-│      {"id": "web.fetch"},                                    │
-│      {"id": "mcp.tool.execute"}                              │
-│    ],                                                        │
-│    "limits": {                                               │
-│      "system.command.execute": {                             │
-│        "allowed_commands": ["git", "npm", "node", "ls"],     │
-│        "blocked_patterns": ["rm -rf", "sudo", "chmod 777"]   │
-│      }                                                       │
-│    }                                                         │
-│  }                                                           │
-└──────────────────────────┬──────────────────────────────────┘
-                           │
-               Any OAP-compliant provider
-          ┌────────────────┼────────────────┐
-          │                │                │
-     Your own         APort (ref.      Other future
-     evaluator        implementation)  implementations
-```
-
-**Creating a passport manually:**
-
-An OAP passport is just a JSON file. You can create one by hand following the [OAP specification](https://github.com/aporthq/aport-spec/blob/main/oap/oap-spec.md) and validate it against the [JSON schema](https://github.com/aporthq/aport-spec/blob/main/oap/passport-schema.json). See the [examples](https://github.com/aporthq/aport-spec/tree/main/oap/examples) directory for templates.
-
-**Using APort as a reference implementation:**
-
-[APort Agent Guardrails](https://github.com/aporthq/aport-agent-guardrails) is one open-source (Apache 2.0) implementation of an OAP provider. It handles passport creation, local evaluation, and optional hosted API evaluation.
-
-```bash
-pip install aport-agent-guardrails
-aport setup --framework deerflow
-```
-
-This creates:
-- `~/.aport/deerflow/config.yaml` -- evaluator config (local or API mode)
-- `~/.aport/deerflow/aport/passport.json` -- OAP passport with capabilities and limits
-
-**config.yaml (using APort as the provider):**
-```yaml
-guardrails:
-  enabled: true
-  provider:
-    use: aport_guardrails.providers.generic:OAPGuardrailProvider
-```
-
-**config.yaml (using your own OAP provider):**
-```yaml
-guardrails:
-  enabled: true
-  provider:
-    use: my_oap_provider:MyOAPProvider
-    config:
-      passport_path: ./my-passport.json
-```
-
-Any provider that accepts `framework` as a kwarg and implements `evaluate`/`aevaluate` works. The OAP standard defines the passport format and decision codes; DeerFlow doesn't care which provider reads them.
-
-**What the passport controls:**
-
-| Passport field | What it does | Example |
-|---|---|---|
-| `capabilities[].id` | Which tool categories the agent can use | `system.command.execute`, `data.file.write` |
-| `limits.*.allowed_commands` | Which commands are allowed | `["git", "npm", "node"]` or `["*"]` for all |
-| `limits.*.blocked_patterns` | Patterns always denied | `["rm -rf", "sudo", "chmod 777"]` |
-| `status` | Kill switch | `active`, `suspended`, `revoked` |
-
-**Evaluation modes (provider-dependent):**
-
-OAP providers may support different evaluation modes. For example, the APort reference implementation supports:
-
-| Mode | How it works | Network | Latency |
-|---|---|---|---|
-| **Local** | Evaluates passport locally (bash script). | None | ~300ms |
-| **API** | Sends passport + context to a hosted evaluator. Signed decisions. | Yes | ~65ms |
-
-A custom OAP provider can implement any evaluation strategy -- the DeerFlow middleware doesn't care how the provider reaches its decision.
-
-**Try it:**
-1. Install and set up as above
-2. Start DeerFlow and ask: "Create a file called test.txt with content hello"
-3. Then ask: "Now delete it using bash rm -rf"
-4. Guardrail blocks it: `oap.blocked_pattern: Command contains blocked pattern: rm -rf`
-
-### Option 3: Custom Provider (Bring Your Own)
-
-Any Python class with `evaluate(request)` and `aevaluate(request)` methods works. No base class or inheritance needed -- it's a structural protocol.
-
-```python
-# my_guardrail.py
-
-class MyGuardrailProvider:
-    name = "my-company"
-
-    def evaluate(self, request):
-        from deerflow.guardrails.provider import GuardrailDecision, GuardrailReason
-
-        # Example: block any bash command containing "delete"
-        if request.tool_name == "bash" and "delete" in str(request.tool_input):
-            return GuardrailDecision(
-                allow=False,
-                reasons=[GuardrailReason(code="custom.blocked", message="delete not allowed")],
-                policy_id="custom.v1",
-            )
-        return GuardrailDecision(allow=True, reasons=[GuardrailReason(code="oap.allowed")])
-
-    async def aevaluate(self, request):
-        return self.evaluate(request)
-```
-
-**config.yaml:**
-```yaml
-guardrails:
-  enabled: true
-  provider:
-    use: my_guardrail:MyGuardrailProvider
-```
-
-Make sure `my_guardrail.py` is on the Python path (e.g. in the backend directory or installed as a package).
-
-**Try it:**
-1. Create `my_guardrail.py` in the backend directory
-2. Add the config
-3. Start DeerFlow and ask: "Use bash to delete test.txt"
-4. Your provider blocks it
-
-## Implementing a Provider
-
-### Required Interface
-
-```
-┌──────────────────────────────────────────────────┐
-│              GuardrailProvider Protocol            │
-│                                                   │
-│  name: str                                        │
-│                                                   │
-│  evaluate(request: GuardrailRequest)              │
-│      -> GuardrailDecision                         │
-│                                                   │
-│  aevaluate(request: GuardrailRequest)   (async)   │
-│      -> GuardrailDecision                         │
-└──────────────────────────────────────────────────┘
-
-┌──────────────────────────┐    ┌──────────────────────────┐
-│     GuardrailRequest      │    │    GuardrailDecision      │
-│                           │    │                           │
-│  tool_name: str           │    │  allow: bool              │
-│  tool_input: dict         │    │  reasons: [GuardrailReason]│
-│  agent_id: str | None     │    │  policy_id: str | None    │
-│  thread_id: str | None    │    │  metadata: dict           │
-│  is_subagent: bool        │    │                           │
-│  timestamp: str           │    │  GuardrailReason:         │
-│                           │    │    code: str              │
-└──────────────────────────┘    │    message: str           │
-                                └──────────────────────────┘
-```
-
-### DeerFlow Tool Names
-
-These are the tool names your provider will see in `request.tool_name`:
-
-| Tool | What it does |
-|---|---|
-| `bash` | Shell command execution |
-| `write_file` | Create/overwrite a file |
-| `str_replace` | Edit a file (find and replace) |
-| `read_file` | Read file content |
-| `ls` | List directory |
-| `web_search` | Web search query |
-| `web_fetch` | Fetch URL content |
-| `image_search` | Image search |
-| `present_file` | Present file to user |
-| `view_image` | Display image |
-| `ask_clarification` | Ask user a question |
-| `task` | Delegate to subagent |
-| `mcp__*` | MCP tools (dynamic) |
-
-### OAP Reason Codes
-
-Standard codes used by the [OAP specification](https://github.com/aporthq/aport-spec):
-
-| Code | Meaning |
-|---|---|
-| `oap.allowed` | Tool call authorized |
-| `oap.tool_not_allowed` | Tool not in allowlist |
-| `oap.command_not_allowed` | Command not in allowed_commands |
-| `oap.blocked_pattern` | Command matches a blocked pattern |
-| `oap.limit_exceeded` | Operation exceeds a limit |
-| `oap.passport_suspended` | Passport status is suspended/revoked |
-| `oap.evaluator_error` | Provider crashed (fail-closed) |
-
-### Provider Loading
-
-DeerFlow loads providers via `resolve_variable()` -- the same mechanism used for models, tools, and sandbox providers. The `use:` field is a Python class path: `package.module:ClassName`.
-
-The provider is instantiated with `**config` kwargs if `config:` is set, plus `framework="deerflow"` is always injected. Accept `**kwargs` to stay forward-compatible:
-
-```python
-class YourProvider:
-    def __init__(self, framework: str = "generic", **kwargs):
-        # framework="deerflow" tells you which config dir to use
-        ...
-```
-
-## Configuration Reference
-
-```yaml
-guardrails:
-  # Enable/disable guardrail middleware (default: false)
-  enabled: true
-
-  # Block tool calls if provider raises an exception (default: true)
-  fail_closed: true
-
-  # Passport reference -- passed as request.agent_id to the provider.
-  # File path, hosted agent ID, or null (provider resolves from its config).
-  passport: null
-
-  # Provider: loaded by class path via resolve_variable
-  provider:
-    use: deerflow.guardrails.builtin:AllowlistProvider
-    config:  # optional kwargs passed to provider.__init__
-      denied_tools: ["bash"]
-```
-
-## Testing
-
-```bash
-cd backend
-uv run python -m pytest tests/test_guardrail_middleware.py -v
-```
-
-25 tests covering:
-- AllowlistProvider: allow, deny, both allowlist+denylist, async
-- GuardrailMiddleware: allow passthrough, deny with OAP codes, fail-closed, fail-open, passport forwarding, empty reasons fallback, empty tool name, protocol isinstance check
-- Async paths: awrap_tool_call for allow, deny, fail-closed, fail-open
-- GraphBubbleUp: LangGraph control signals propagate through (not caught)
-- Config: defaults, from_dict, singleton load/reset
-
-## Files
-
-```
-packages/harness/deerflow/guardrails/
-    __init__.py              # Public exports
-    provider.py              # GuardrailProvider protocol, GuardrailRequest, GuardrailDecision
-    middleware.py             # GuardrailMiddleware (AgentMiddleware subclass)
-    builtin.py               # AllowlistProvider (zero deps)
-
-packages/harness/deerflow/config/
-    guardrails_config.py     # GuardrailsConfig Pydantic model + singleton
-
-packages/harness/deerflow/agents/middlewares/
-    tool_error_handling_middleware.py  # Registers GuardrailMiddleware in chain
-
-config.example.yaml          # Three provider options documented
-tests/test_guardrail_middleware.py  # 25 tests
-docs/GUARDRAILS.md           # This file
-```

backend/docs/HARNESS_APP_SPLIT.md

@@ -1,343 +0,0 @@
-# DeerFlow 后端拆分设计文档：Harness + App
-
-> 状态：Draft
-> 作者：DeerFlow Team
-> 日期：2026-03-13
-
-## 1. 背景与动机
-
-DeerFlow 后端当前是一个单一 Python 包（`src.*`），包含了从底层 agent 编排到上层用户产品的所有代码。随着项目发展，这种结构带来了几个问题：
-
-- **复用困难**：其他产品（CLI 工具、Slack bot、第三方集成）想用 agent 能力，必须依赖整个后端，包括 FastAPI、IM SDK 等不需要的依赖
-- **职责模糊**：agent 编排逻辑和用户产品逻辑混在同一个 `src/` 下，边界不清晰
-- **依赖膨胀**：LangGraph Server 运行时不需要 FastAPI/uvicorn/Slack SDK，但当前必须安装全部依赖
-
-本文档提出将后端拆分为两部分：**deerflow-harness**（可发布的 agent 框架包）和 **app**（不打包的用户产品代码）。
-
-## 2. 核心概念
-
-### 2.1 Harness（线束/框架层）
-
-Harness 是 agent 的构建与编排框架，回答 **"如何构建和运行 agent"** 的问题：
-
-- Agent 工厂与生命周期管理
-- Middleware pipeline
-- 工具系统（内置工具 + MCP + 社区工具）
-- 沙箱执行环境
-- 子 agent 委派
-- 记忆系统
-- 技能加载与注入
-- 模型工厂
-- 配置系统
-
-**Harness 是一个可发布的 Python 包**（`deerflow-harness`），可以独立安装和使用。
-
-**Harness 的设计原则**：对上层应用完全无感知。它不知道也不关心谁在调用它——可以是 Web App、CLI、Slack Bot、或者一个单元测试。
-
-### 2.2 App（应用层）
-
-App 是面向用户的产品代码，回答 **"如何将 agent 呈现给用户"** 的问题：
-
-- Gateway API（FastAPI REST 接口）
-- IM Channels（飞书、Slack、Telegram 集成）
-- Custom Agent 的 CRUD 管理
-- 文件上传/下载的 HTTP 接口
-
-**App 不打包、不发布**，它是 DeerFlow 项目内部的应用代码，直接运行。
-
-**App 依赖 Harness，但 Harness 不依赖 App。**
-
-### 2.3 边界划分
-
-| 模块 | 归属 | 说明 |
-|------|------|------|
-| `config/` | Harness | 配置系统是基础设施 |
-| `reflection/` | Harness | 动态模块加载工具 |
-| `utils/` | Harness | 通用工具函数 |
-| `agents/` | Harness | Agent 工厂、middleware、state、memory |
-| `subagents/` | Harness | 子 agent 委派系统 |
-| `sandbox/` | Harness | 沙箱执行环境 |
-| `tools/` | Harness | 工具注册与发现 |
-| `mcp/` | Harness | MCP 协议集成 |
-| `skills/` | Harness | 技能加载、解析、定义 schema |
-| `models/` | Harness | LLM 模型工厂 |
-| `community/` | Harness | 社区工具（tavily、jina 等） |
-| `client.py` | Harness | 嵌入式 Python 客户端 |
-| `gateway/` | App | FastAPI REST API |
-| `channels/` | App | IM 平台集成 |
-
-**关于 Custom Agents**：agent 定义格式（`config.yaml` + `SOUL.md` schema）由 Harness 层的 `config/agents_config.py` 定义，但文件的存储、CRUD、发现机制由 App 层的 `gateway/routers/agents.py` 负责。
-
-## 3. 目标架构
-
-### 3.1 目录结构
-
-```
-backend/
-├── packages/
-│   └── harness/
-│       ├── pyproject.toml          # deerflow-harness 包定义
-│       └── deerflow/               # Python 包根（import 前缀: deerflow.*）
-│           ├── __init__.py
-│           ├── config/
-│           ├── reflection/
-│           ├── utils/
-│           ├── agents/
-│           │   ├── lead_agent/
-│           │   ├── middlewares/
-│           │   ├── memory/
-│           │   ├── checkpointer/
-│           │   └── thread_state.py
-│           ├── subagents/
-│           ├── sandbox/
-│           ├── tools/
-│           ├── mcp/
-│           ├── skills/
-│           ├── models/
-│           ├── community/
-│           └── client.py
-├── app/                            # 不打包（import 前缀: app.*）
-│   ├── __init__.py
-│   ├── gateway/
-│   │   ├── __init__.py
-│   │   ├── app.py
-│   │   ├── config.py
-│   │   ├── path_utils.py
-│   │   └── routers/
-│   └── channels/
-│       ├── __init__.py
-│       ├── base.py
-│       ├── manager.py
-│       ├── service.py
-│       ├── store.py
-│       ├── message_bus.py
-│       ├── feishu.py
-│       ├── slack.py
-│       └── telegram.py
-├── pyproject.toml                  # uv workspace root
-├── langgraph.json
-├── tests/
-├── docs/
-└── Makefile
-```
-
-### 3.2 Import 规则
-
-两个层使用不同的 import 前缀，职责边界一目了然：
-
-```python
-# ---------------------------------------------------------------
-# Harness 内部互相引用（deerflow.* 前缀）
-# ---------------------------------------------------------------
-from deerflow.agents import make_lead_agent
-from deerflow.models import create_chat_model
-from deerflow.config import get_app_config
-from deerflow.tools import get_available_tools
-
-# ---------------------------------------------------------------
-# App 内部互相引用（app.* 前缀）
-# ---------------------------------------------------------------
-from app.gateway.app import app
-from app.gateway.routers.uploads import upload_files
-from app.channels.service import start_channel_service
-
-# ---------------------------------------------------------------
-# App 调用 Harness（单向依赖，Harness 永远不 import app）
-# ---------------------------------------------------------------
-from deerflow.agents import make_lead_agent
-from deerflow.models import create_chat_model
-from deerflow.skills import load_skills
-from deerflow.config.extensions_config import get_extensions_config
-```
-
-**App 调用 Harness 示例 — Gateway 中启动 agent**：
-
-```python
-# app/gateway/routers/chat.py
-from deerflow.agents.lead_agent.agent import make_lead_agent
-from deerflow.models import create_chat_model
-from deerflow.config import get_app_config
-
-async def create_chat_session(thread_id: str, model_name: str):
-    config = get_app_config()
-    model = create_chat_model(name=model_name)
-    agent = make_lead_agent(config=...)
-    # ... 使用 agent 处理用户消息
-```
-
-**App 调用 Harness 示例 — Channel 中查询 skills**：
-
-```python
-# app/channels/manager.py
-from deerflow.skills import load_skills
-from deerflow.agents.memory.updater import get_memory_data
-
-def handle_status_command():
-    skills = load_skills(enabled_only=True)
-    memory = get_memory_data()
-    return f"Skills: {len(skills)}, Memory facts: {len(memory.get('facts', []))}"
-```
-
-**禁止方向**：Harness 代码中绝不能出现 `from app.` 或 `import app.`。
-
-### 3.3 为什么 App 不打包
-
-| 方面 | 打包（放 packages/ 下） | 不打包（放 backend/app/） |
-|------|------------------------|--------------------------|
-| 命名空间 | 需要 pkgutil `extend_path` 合并，或独立前缀 | 天然独立，`app.*` vs `deerflow.*` |
-| 发布需求 | 没有——App 是项目内部代码 | 不需要 pyproject.toml |
-| 复杂度 | 需要管理两个包的构建、版本、依赖声明 | 直接运行，零额外配置 |
-| 运行方式 | `pip install deerflow-app` | `PYTHONPATH=. uvicorn app.gateway.app:app` |
-
-App 的唯一消费者是 DeerFlow 项目自身，没有独立发布的需求。放在 `backend/app/` 下作为普通 Python 包，通过 `PYTHONPATH` 或 editable install 让 Python 找到即可。
-
-### 3.4 依赖关系
-
-```
-┌─────────────────────────────────────┐
-│  app/  (不打包，直接运行)             │
-│  ├── fastapi, uvicorn               │
-│  ├── slack-sdk, lark-oapi, ...      │
-│  └── import deerflow.*              │
-└──────────────┬──────────────────────┘
-               │
-               ▼
-┌─────────────────────────────────────┐
-│  deerflow-harness  (可发布的包)       │
-│  ├── langgraph, langchain           │
-│  ├── markitdown, pydantic, ...      │
-│  └── 零 app 依赖                     │
-└─────────────────────────────────────┘
-```
-
-**依赖分类**：
-
-| 分类 | 依赖包 |
-|------|--------|
-| Harness only | agent-sandbox, langchain*, langgraph*, markdownify, markitdown, pydantic, pyyaml, readabilipy, tavily-python, firecrawl-py, tiktoken, ddgs, duckdb, httpx, kubernetes, dotenv |
-| App only | fastapi, uvicorn, sse-starlette, python-multipart, lark-oapi, slack-sdk, python-telegram-bot, markdown-to-mrkdwn |
-| Shared | langgraph-sdk（channels 用 HTTP client）, pydantic, httpx |
-
-### 3.5 Workspace 配置
-
-`backend/pyproject.toml`（workspace root）：
-
-```toml
-[project]
-name = "deer-flow"
-version = "0.1.0"
-requires-python = ">=3.12"
-dependencies = ["deerflow-harness"]
-
-[dependency-groups]
-dev = ["pytest>=8.0.0", "ruff>=0.14.11"]
-# App 的额外依赖（fastapi 等）也声明在 workspace root，因为 app 不打包
-app = ["fastapi", "uvicorn", "sse-starlette", "python-multipart"]
-channels = ["lark-oapi", "slack-sdk", "python-telegram-bot"]
-
-[tool.uv.workspace]
-members = ["packages/harness"]
-
-[tool.uv.sources]
-deerflow-harness = { workspace = true }
-```
-
-## 4. 当前的跨层依赖问题
-
-在拆分之前，需要先解决 `client.py` 中两处从 harness 到 app 的反向依赖：
-
-### 4.1 `_validate_skill_frontmatter`
-
-```python
-# client.py — harness 导入了 app 层代码
-from src.gateway.routers.skills import _validate_skill_frontmatter
-```
-
-**解决方案**：将该函数提取到 `deerflow/skills/validation.py`。这是一个纯逻辑函数（解析 YAML frontmatter、校验字段），与 FastAPI 无关。
-
-### 4.2 `CONVERTIBLE_EXTENSIONS` + `convert_file_to_markdown`
-
-```python
-# client.py — harness 导入了 app 层代码
-from src.gateway.routers.uploads import CONVERTIBLE_EXTENSIONS, convert_file_to_markdown
-```
-
-**解决方案**：将它们提取到 `deerflow/utils/file_conversion.py`。仅依赖 `markitdown` + `pathlib`，是通用工具函数。
-
-## 5. 基础设施变更
-
-### 5.1 LangGraph Server
-
-LangGraph Server 只需要 harness 包。`langgraph.json` 更新：
-
-```json
-{
-  "dependencies": ["./packages/harness"],
-  "graphs": {
-    "lead_agent": "deerflow.agents:make_lead_agent"
-  },
-  "checkpointer": {
-    "path": "./packages/harness/deerflow/agents/checkpointer/async_provider.py:make_checkpointer"
-  }
-}
-```
-
-### 5.2 Gateway API
-
-```bash
-# serve.sh / Makefile
-# PYTHONPATH 包含 backend/ 根目录，使 app.* 和 deerflow.* 都能被找到
-PYTHONPATH=. uvicorn app.gateway.app:app --host 0.0.0.0 --port 8001
-```
-
-### 5.3 Nginx
-
-无需变更（只做 URL 路由，不涉及 Python 模块路径）。
-
-### 5.4 Docker
-
-Dockerfile 中的 module 引用从 `src.` 改为 `deerflow.` / `app.`，`COPY` 命令需覆盖 `packages/` 和 `app/` 目录。
-
-## 6. 实施计划
-
-分 3 个 PR 递进执行：
-
-### PR 1：提取共享工具函数（Low Risk）
-
-1. 创建 `src/skills/validation.py`，从 `gateway/routers/skills.py` 提取 `_validate_skill_frontmatter`
-2. 创建 `src/utils/file_conversion.py`，从 `gateway/routers/uploads.py` 提取文件转换逻辑
-3. 更新 `client.py`、`gateway/routers/skills.py`、`gateway/routers/uploads.py` 的 import
-4. 运行全部测试确认无回归
-
-### PR 2：Rename + 物理拆分（High Risk，原子操作）
-
-1. 创建 `packages/harness/` 目录，创建 `pyproject.toml`
-2. `git mv` 将 harness 相关模块从 `src/` 移入 `packages/harness/deerflow/`
-3. `git mv` 将 app 相关模块从 `src/` 移入 `app/`
-4. 全局替换 import：
-   - harness 模块：`src.*` → `deerflow.*`（所有 `.py` 文件、`langgraph.json`、测试、文档）
-   - app 模块：`src.gateway.*` → `app.gateway.*`、`src.channels.*` → `app.channels.*`
-5. 更新 workspace root `pyproject.toml`
-6. 更新 `langgraph.json`、`Makefile`、`Dockerfile`
-7. `uv sync` + 全部测试 + 手动验证服务启动
-
-### PR 3：边界检查 + 文档（Low Risk）
-
-1. 添加 lint 规则：检查 harness 不 import app 模块
-2. 更新 `CLAUDE.md`、`README.md`
-
-## 7. 风险与缓解
-
-| 风险 | 影响 | 缓解措施 |
-|------|------|----------|
-| 全局 rename 误伤 | 字符串中的 `src` 被错误替换 | 正则精确匹配 `\bsrc\.`，review diff |
-| LangGraph Server 找不到模块 | 服务启动失败 | `langgraph.json` 的 `dependencies` 指向正确的 harness 包路径 |
-| App 的 `PYTHONPATH` 缺失 | Gateway/Channel 启动 import 报错 | Makefile/Docker 统一设置 `PYTHONPATH=.` |
-| `config.yaml` 中的 `use` 字段引用旧路径 | 运行时模块解析失败 | `config.yaml` 中的 `use` 字段同步更新为 `deerflow.*` |
-| 测试中 `sys.path` 混乱 | 测试失败 | 用 editable install（`uv sync`）确保 deerflow 可导入，`conftest.py` 中添加 `app/` 到 `sys.path` |
-
-## 8. 未来演进
-
-- **独立发布**：harness 可以发布到内部 PyPI，让其他项目直接 `pip install deerflow-harness`
-- **插件化 App**：不同的 app（web、CLI、bot）可以各自独立，都依赖同一个 harness
-- **更细粒度拆分**：如果 harness 内部模块继续增长，可以进一步拆分（如 `deerflow-sandbox`、`deerflow-mcp`）

backend/docs/MCP_SERVER.md

@@ -1,65 +0,0 @@
-# MCP (Model Context Protocol) Configuration
-
-DeerFlow supports configurable MCP servers and skills to extend its capabilities, which are loaded from a dedicated `extensions_config.json` file in the project root directory.
-
-## Setup
-
-1. Copy `extensions_config.example.json` to `extensions_config.json` in the project root directory.
-   ```bash
-   # Copy example configuration
-   cp extensions_config.example.json extensions_config.json
-   ```
-   
-2. Enable the desired MCP servers or skills by setting `"enabled": true`.
-3. Configure each server’s command, arguments, and environment variables as needed.
-4. Restart the application to load and register MCP tools.
-
-## OAuth Support (HTTP/SSE MCP Servers)
-
-For `http` and `sse` MCP servers, DeerFlow supports OAuth token acquisition and automatic token refresh.
-
-- Supported grants: `client_credentials`, `refresh_token`
-- Configure per-server `oauth` block in `extensions_config.json`
-- Secrets should be provided via environment variables (for example: `$MCP_OAUTH_CLIENT_SECRET`)
-
-Example:
-
-```json
-{
-   "mcpServers": {
-      "secure-http-server": {
-         "enabled": true,
-         "type": "http",
-         "url": "https://api.example.com/mcp",
-         "oauth": {
-            "enabled": true,
-            "token_url": "https://auth.example.com/oauth/token",
-            "grant_type": "client_credentials",
-            "client_id": "$MCP_OAUTH_CLIENT_ID",
-            "client_secret": "$MCP_OAUTH_CLIENT_SECRET",
-            "scope": "mcp.read",
-            "refresh_skew_seconds": 60
-         }
-      }
-   }
-}
-```
-
-## How It Works
-
-MCP servers expose tools that are automatically discovered and integrated into DeerFlow’s agent system at runtime. Once enabled, these tools become available to agents without additional code changes.
-
-## Example Capabilities
-
-MCP servers can provide access to:
-
-- **File systems**
-- **Databases** (e.g., PostgreSQL)
-- **External APIs** (e.g., GitHub, Brave Search)
-- **Browser automation** (e.g., Puppeteer)
-- **Custom MCP server implementations**
-
-## Learn More
-
-For detailed documentation about the Model Context Protocol, visit:  
-https://modelcontextprotocol.io

backend/docs/MEMORY_IMPROVEMENTS.md

@@ -1,65 +0,0 @@
-# Memory System Improvements
-
-This document tracks memory injection behavior and roadmap status.
-
-## Status (As Of 2026-03-10)
-
-Implemented in `main`:
-- Accurate token counting via `tiktoken` in `format_memory_for_injection`.
-- Facts are injected into prompt memory context.
-- Facts are ranked by confidence (descending).
-- Injection respects `max_injection_tokens` budget.
-
-Planned / not yet merged:
-- TF-IDF similarity-based fact retrieval.
-- `current_context` input for context-aware scoring.
-- Configurable similarity/confidence weights (`similarity_weight`, `confidence_weight`).
-- Middleware/runtime wiring for context-aware retrieval before each model call.
-
-## Current Behavior
-
-Function today:
-
-```python
-def format_memory_for_injection(memory_data: dict[str, Any], max_tokens: int = 2000) -> str:
-```
-
-Current injection format:
-- `User Context` section from `user.*.summary`
-- `History` section from `history.*.summary`
-- `Facts` section from `facts[]`, sorted by confidence, appended until token budget is reached
-
-Token counting:
-- Uses `tiktoken` (`cl100k_base`) when available
-- Falls back to `len(text) // 4` if tokenizer import fails
-
-## Known Gap
-
-Previous versions of this document described TF-IDF/context-aware retrieval as if it were already shipped.
-That was not accurate for `main` and caused confusion.
-
-Issue reference: `#1059`
-
-## Roadmap (Planned)
-
-Planned scoring strategy:
-
-```text
-final_score = (similarity * 0.6) + (confidence * 0.4)
-```
-
-Planned integration shape:
-1. Extract recent conversational context from filtered user/final-assistant turns.
-2. Compute TF-IDF cosine similarity between each fact and current context.
-3. Rank by weighted score and inject under token budget.
-4. Fall back to confidence-only ranking if context is unavailable.
-
-## Validation
-
-Current regression coverage includes:
-- facts inclusion in memory injection output
-- confidence ordering
-- token-budget-limited fact inclusion
-
-Tests:
-- `backend/tests/test_memory_prompt_injection.py`