# web_server.py - Web服务器（修复版 - 确保text_end事件正确发送 + 停止功能）

import asyncio
import json
import os
import sys
import re
from typing import Dict, List, Optional, Callable, Any, Tuple
from flask import Flask, request, jsonify, send_from_directory, session, redirect, send_file, Response
from flask_socketio import SocketIO, emit, join_room, leave_room, disconnect
from flask_cors import CORS
from werkzeug.exceptions import RequestEntityTooLarge
from pathlib import Path
from io import BytesIO
import zipfile
import argparse
from functools import wraps
from datetime import timedelta
import time
from datetime import datetime
import threading
from collections import defaultdict, deque
from werkzeug.utils import secure_filename
from werkzeug.routing import BaseConverter

# 添加项目根目录到Python路径
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from core.web_terminal import WebTerminal
from core.sub_agent_terminal import SubAgentTerminal
from config import (
    OUTPUT_FORMATS,
    AUTO_FIX_TOOL_CALL,
    AUTO_FIX_MAX_ATTEMPTS,
    MAX_ITERATIONS_PER_TASK,
    MAX_CONSECUTIVE_SAME_TOOL,
    MAX_TOTAL_TOOL_CALLS,
    TOOL_CALL_COOLDOWN,
    MAX_UPLOAD_SIZE,
    DEFAULT_CONVERSATIONS_LIMIT,
    MAX_CONVERSATIONS_LIMIT,
    CONVERSATIONS_DIR,
    DEFAULT_RESPONSE_MAX_TOKENS,
    DEFAULT_PROJECT_PATH,
    LOGS_DIR,
    AGENT_VERSION,
    SUB_AGENT_MAX_ACTIVE,
    SUB_AGENT_DEFAULT_TIMEOUT,
    SUB_AGENT_STATE_FILE,
    DATA_DIR,
    SUB_AGENT_TASKS_BASE_DIR,
)
from modules.user_manager import UserManager, UserWorkspace
from modules.gui_file_manager import GuiFileManager

app = Flask(__name__, static_folder='static')
app.config['MAX_CONTENT_LENGTH'] = MAX_UPLOAD_SIZE
app.config['SECRET_KEY'] = 'your-secret-key-here'
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(hours=12)
CORS(app)

socketio = SocketIO(app, cors_allowed_origins="*", async_mode='threading')
SUB_AGENT_INDEX_FILE = Path(app.static_folder).resolve() / "index.html"


class ConversationIdConverter(BaseConverter):
    regex = r'(?:conv_)?\d{8}_\d{6}_\d{3}'


app.url_map.converters['conv'] = ConversationIdConverter

user_manager = UserManager()
user_terminals: Dict[str, WebTerminal] = {}
terminal_rooms: Dict[str, set] = {}
connection_users: Dict[str, str] = {}
stop_flags: Dict[str, Dict[str, Any]] = {}
terminated_tasks: set = set()

DEFAULT_PORT = 8092

# 子智能体任务管理
sub_agent_tasks: Dict[str, Dict[str, Any]] = {}
sub_agent_terminals: Dict[str, SubAgentTerminal] = {}
sub_agent_rooms: Dict[str, set] = defaultdict(set)
sub_agent_connections: Dict[str, str] = {}
SUB_AGENT_TERMINAL_STATUSES = {"completed", "failed", "timeout"}
STOPPING_GRACE_SECONDS = 30
TERMINAL_ARCHIVE_GRACE_SECONDS = 20

def format_read_file_result(result_data: Dict) -> str:
    """格式化 read_file 工具的输出，便于在Web端展示。"""
    if not isinstance(result_data, dict):
        return json.dumps(result_data, ensure_ascii=False)
    if not result_data.get("success"):
        return json.dumps(result_data, ensure_ascii=False)

    read_type = result_data.get("type", "read")
    truncated_note = "（内容已截断）" if result_data.get("truncated") else ""
    path = result_data.get("path", "未知路径")
    max_chars = result_data.get("max_chars")
    max_note = f"(max_chars={max_chars})" if max_chars else ""

    if read_type == "read":
        header = f"读取 {path} 行 {result_data.get('line_start')}~{result_data.get('line_end')} {max_note}{truncated_note}".strip()
        content = result_data.get("content", "")
        return f"{header}\n```\n{content}\n```"

    if read_type == "search":
        query = result_data.get("query", "")
        actual = result_data.get("actual_matches", 0)
        returned = result_data.get("returned_matches", 0)
        case_hint = "区分大小写" if result_data.get("case_sensitive") else "不区分大小写"
        header = (
            f"在 {path} 中搜索 \"{query}\"，返回 {returned}/{actual} 条结果（{case_hint}） "
            f"{max_note}{truncated_note}"
        ).strip()
        match_texts = []
        for idx, match in enumerate(result_data.get("matches", []), 1):
            match_note = "（片段截断）" if match.get("truncated") else ""
            hits = match.get("hits") or []
            hit_text = ", ".join(str(h) for h in hits) if hits else "无"
            label = match.get("id") or f"match_{idx}"
            snippet = match.get("snippet", "")
            match_texts.append(
                f"[{label}] 行 {match.get('line_start')}~{match.get('line_end')} 命中行: {hit_text}{match_note}\n```\n{snippet}\n```"
            )
        if not match_texts:
            match_texts.append("未找到匹配内容。")
        return "\n".join([header] + match_texts)

    if read_type == "extract":
        segments = result_data.get("segments", [])
        header = f"从 {path} 抽取 {len(segments)} 个片段 {max_note}{truncated_note}".strip()
        seg_texts = []
        for idx, segment in enumerate(segments, 1):
            seg_note = "（片段截断）" if segment.get("truncated") else ""
            label = segment.get("label") or f"segment_{idx}"
            snippet = segment.get("content", "")
            seg_texts.append(
                f"[{label}] 行 {segment.get('line_start')}~{segment.get('line_end')}{seg_note}\n```\n{snippet}\n```"
            )
        if not seg_texts:
            seg_texts.append("未提供可抽取的片段。")
        return "\n".join([header] + seg_texts)

    return json.dumps(result_data, ensure_ascii=False)


def sanitize_filename_preserve_unicode(filename: str) -> str:
    """在保留中文等字符的同时，移除危险字符和路径成分"""
    if not filename:
        return ""

    cleaned = filename.strip().replace("\x00", "")
    if not cleaned:
        return ""

    # 去除路径成分
    cleaned = cleaned.replace("\\", "/").split("/")[-1]
    # 替换不安全符号
    cleaned = re.sub(r'[<>:"\\|?*\n\r\t]', "_", cleaned)
    # 去掉前后的点避免隐藏文件/穿越
    cleaned = cleaned.strip(". ")

    if not cleaned:
        return ""

    # Windows/Unix 通用文件名长度安全上限
    return cleaned[:255]


def format_tool_result_notice(tool_name: str, tool_call_id: Optional[str], content: str) -> str:
    """将工具执行结果转为系统消息文本，方便在对话中回传。"""
    header = f"[工具结果] {tool_name}"
    if tool_call_id:
        header += f" (tool_call_id={tool_call_id})"
    body = (content or "").strip()
    if not body:
        body = "（无附加输出）"
    return f"{header}\n{body}"


def _format_relative_path(path: Optional[str], workspace: Optional[str]) -> str:
    """将绝对路径转换为相对 workspace 的表示，默认返回原始路径。"""
    if not path:
        return ""
    try:
        target = Path(path).resolve()
        if workspace:
            base = Path(workspace).resolve()
            rel = target.relative_to(base)
            rel_text = rel.as_posix()
            if not rel_text or rel_text == ".":
                return "."
            return f"./{rel_text}"
    except Exception:
        pass
    return Path(path).as_posix()


def build_sub_agent_instruction(meta: Dict[str, Any]) -> str:
    """根据任务元数据构建初始指令消息。"""
    workspace_dir = meta.get("workspace_dir")
    references_dir = meta.get("references_dir")
    deliverables_dir = meta.get("deliverables_dir")
    workspace_label = _format_relative_path(workspace_dir, workspace_dir) or "."
    references_label = _format_relative_path(references_dir, workspace_dir) or "references/"
    deliverables_label = _format_relative_path(deliverables_dir, workspace_dir) or "deliverables/"

    lines = [
        f"子智能体任务 - 代号 {meta.get('agent_id')} (task_id={meta.get('task_id')})",
        "",
        meta.get("summary", ""),
        meta.get("task", ""),
        "",
        "工作区与目录说明：",
        f"- workspace: {workspace_label}（唯一可写根目录，所有操作只能在此路径内进行）",
        f"- references: {references_label}（系统已自动创建，仅供查阅，不得修改原文件）",
        f"- deliverables: {deliverables_label}（系统已自动创建，用于存放交付文件与 result.md）",
        "",
        "交付要求：",
        "- 所有成果放入 deliverables/ 下，保持清晰的目录结构；",
        "- deliverables/ 必须包含 result.md，说明完成情况、交付列表、遗留风险和下一步建议；",
        "- references/ 只读，如需引用请复制到 workspace/ 再处理；",
        "- 子智能体无法与主智能体实时沟通，如信息不足请在 result.md 中说明。",
        "- 最后必须调用 finish_sub_agent，并在 reason 中概括完成情况；若暂未完成，也要说明阻塞原因并继续执行直至可交付。",
        "",
        "提示：references/ 与 deliverables/ 目录均已自动创建，如需额外子目录请在 workspace/ 内自行管理。",
        "",
        "请立即分析任务、规划步骤并开始执行，过程中记录关键操作，确保交付即可直接被主智能体使用。",
    ]
    return "\n".join(lines)


def build_finish_tool_reminder(meta: Dict[str, Any]) -> str:
    """构建提醒子智能体调用结束工具的提示语。"""
    workspace_dir = meta.get("workspace_dir")
    deliverables_dir = meta.get("deliverables_dir")
    deliverables_label = _format_relative_path(deliverables_dir, workspace_dir) or "deliverables"
    if deliverables_label in {"", "."}:
        result_path = "./result.md"
    else:
        normalized = deliverables_label.rstrip("/")
        result_path = f"{normalized}/result.md"
    return (
        f"⚠️ 检测到你已停止输出，但尚未调用 finish_sub_agent。请确认 {deliverables_label} 内的交付文件与 {result_path} 已准备完毕，"
        "再调用 finish_sub_agent(reason=...) 正式结束任务；如果任务仍未完成，请继续完成剩余步骤并在完成后立即调用 finish_sub_agent。"
    )


def cleanup_inactive_sub_agent_tasks(force: bool = False):
    """移除已结束或长期停止中的子智能体，避免占用名额。"""
    now = time.time()
    for task_id, task in list(sub_agent_tasks.items()):
        status = (task.get("status") or "").lower()
        if status in SUB_AGENT_TERMINAL_STATUSES:
            updated_at = task.get("updated_at") or task.get("created_at") or now
            if force or (now - updated_at) > TERMINAL_ARCHIVE_GRACE_SECONDS:
                _purge_sub_agent_task(task_id)
            continue
        if status == "stopping":
            updated_at = task.get("updated_at") or task.get("created_at") or now
            if force or (now - updated_at) > STOPPING_GRACE_SECONDS:
                _purge_sub_agent_task(task_id)


def _purge_sub_agent_task(task_id: str):
    """移除本地记录与相关连接。"""
    sub_agent_tasks.pop(task_id, None)
    terminal = sub_agent_terminals.pop(task_id, None)
    if terminal and hasattr(terminal, "close"):
        try:
            terminal.close()
        except Exception:
            pass
    room_sids = sub_agent_rooms.pop(task_id, set())
    for sid in list(room_sids):
        sub_agent_connections.pop(sid, None)
    for sid, current in list(sub_agent_connections.items()):
        if current == task_id:
            sub_agent_connections.pop(sid, None)
    for sid in list(stop_flags.keys()):
        if task_id in sid:
            stop_flags.pop(sid, None)


def get_active_sub_agent_count(conversation_id: Optional[str] = None) -> int:
    cleanup_inactive_sub_agent_tasks()
    normalized = _normalize_conversation_id(conversation_id)
    count = 0
    for task in sub_agent_tasks.values():
        if task.get("status") not in {"pending", "running"}:
            continue
        if normalized:
            if _normalize_conversation_id(task.get("parent_conversation_id")) != normalized:
                continue
        count += 1
    return count


def find_sub_agent_conversation_file(conv_id: str) -> Optional[Path]:
    """在已知目录中搜索子智能体对话文件。"""
    possible_dirs = []
    tasks_root = Path(SUB_AGENT_TASKS_BASE_DIR).expanduser().resolve()
    if tasks_root.exists():
        possible_dirs.append(tasks_root)
    data_root = Path(DATA_DIR).expanduser().resolve()
    if data_root.exists():
        possible_dirs.append(data_root)
    users_root = Path("users").resolve()
    if users_root.exists():
        possible_dirs.append(users_root)

    for base in possible_dirs:
        try:
            matches = list(base.rglob(f"{conv_id}.json"))
        except Exception:
            matches = []
        for match in matches:
            try:
                if match.name == f"{conv_id}.json":
                    return match
            except Exception:
                continue
    return None


def build_workspace_tree(root_path: str, max_depth: int = 5) -> Dict[str, Any]:
    """构建工作目录的文件树，用于子智能体只读视图。"""
    root = Path(root_path).expanduser().resolve()
    if not root.exists():
        return {
            "path": str(root),
            "tree": {},
            "folders": [],
            "files": [],
            "total_files": 0,
            "total_size": 0
        }

    structure = {
        "path": str(root),
        "tree": {},
        "folders": [],
        "files": [],
        "total_files": 0,
        "total_size": 0
    }

    def scan_directory(path: Path, tree: Dict[str, Any], depth: int = 0):
        if depth > max_depth:
            return
        try:
            entries = sorted(
                [p for p in path.iterdir() if not p.name.startswith('.')],
                key=lambda p: (not p.is_dir(), p.name.lower())
            )
        except PermissionError:
            return

        for entry in entries:
            relative_path = str(entry.relative_to(root))
            if entry.is_dir():
                structure["folders"].append({
                    "name": entry.name,
                    "path": relative_path
                })
                tree[entry.name] = {
                    "type": "folder",
                    "path": relative_path,
                    "children": {}
                }
                scan_directory(entry, tree[entry.name]["children"], depth + 1)
            else:
                try:
                    size = entry.stat().st_size
                    modified = datetime.fromtimestamp(entry.stat().st_mtime).isoformat()
                except OSError:
                    size = 0
                    modified = ""
                structure["files"].append({
                    "name": entry.name,
                    "path": relative_path,
                    "size": size,
                    "modified": modified
                })
                structure["total_files"] += 1
                structure["total_size"] += size
                tree[entry.name] = {
                    "type": "file",
                    "path": relative_path,
                    "size": size,
                    "modified": modified
                }

    scan_directory(root, structure["tree"])
    return structure


def _load_state_data() -> Dict[str, Any]:
    state_file = Path(SUB_AGENT_STATE_FILE).expanduser().resolve()
    if not state_file.exists():
        return {}
    try:
        with state_file.open('r', encoding='utf-8') as f:
            return json.load(f)
    except Exception:
        return {}


def load_persisted_task(task_id: str) -> Optional[Dict[str, Any]]:
    data = _load_state_data()
    tasks = data.get("tasks") or {}
    return tasks.get(task_id)


def iter_persisted_tasks():
    data = _load_state_data()
    tasks = data.get("tasks") or {}
    return list(tasks.values())


def get_task_record(task_id: str) -> Optional[Dict[str, Any]]:
    task = sub_agent_tasks.get(task_id)
    if task:
        return task
    return load_persisted_task(task_id)


def broadcast_sub_agent_event(task_id: str, event_type: str, payload: Optional[Dict[str, Any]] = None):
    room = f"sub_agent_{task_id}"
    data = {"task_id": task_id}
    if payload:
        data.update(payload)
    socketio.emit(event_type, data, room=room)
    socketio.emit(f"event_{event_type}", data, room=room)


def make_sub_agent_sender(task_id: str):
    def _sender(event_type: str, data: Optional[Dict]):
        if data is None:
            data = {}
        data = dict(data)
        data["task_id"] = task_id
        if event_type in {"tool_start", "tool_preparing"}:
            tool_name = data.get("tool_name") or data.get("tool")
            if tool_name:
                update_sub_agent_task(task_id, last_tool=tool_name, status="running")
        if event_type == "task_complete":
            update_sub_agent_task(task_id, last_tool=None)
        if event_type == "error":
            mark_task_failed(task_id, data.get("message") or "子智能体执行失败")
        broadcast_sub_agent_event(task_id, event_type, data)
    return _sender


def _normalize_conversation_id(value: Optional[str]) -> Optional[str]:
    if not value:
        return None
    value = value.strip()
    if not value:
        return None
    return value if value.startswith("conv_") else f"conv_{value}"


def _extract_parent_conversation(info: Optional[Dict[str, Any]]) -> Optional[str]:
    """尝试从任务记录中提取父对话ID。"""
    if not info:
        return None
    service_payload = info.get("service_payload") or {}
    candidates = [
        info.get("parent_conversation_id"),
        info.get("conversation_id"),
        service_payload.get("parent_conversation_id"),
    ]
    for candidate in candidates:
        normalized = _normalize_conversation_id(candidate)
        if normalized:
            return normalized
    return None


def _inject_sub_agent_script(html: str, task_id: str, parent_conv: Optional[str], sub_conv: Optional[str]) -> str:
    script = (
        "<script>"
        "window.APP_VARIANT='sub_agent';"
        f"window.SUB_AGENT_TASK_ID={json.dumps(task_id)};"
        f"window.SUB_AGENT_CONVERSATION_ID={json.dumps(sub_conv or parent_conv or '')};"
        "</script>"
    )
    return html.replace("</head>", f"{script}</head>", 1)


def _render_sub_agent_index(task_id: str, parent_conv: Optional[str], sub_conv: Optional[str]):
    if not SUB_AGENT_INDEX_FILE.exists():
        return send_from_directory(app.static_folder, 'index.html')
    html = SUB_AGENT_INDEX_FILE.read_text(encoding="utf-8")
    patched = _inject_sub_agent_script(html, task_id, parent_conv, sub_conv)
    return Response(patched, mimetype="text/html")


def _resolve_task_by_conv(conv_slug: Optional[str], task_label: str):
    normalized_conv = _normalize_conversation_id(conv_slug)
    agent_id = None
    if task_label.lower().startswith("sub_agent"):
        suffix = task_label[len("sub_agent"):]
        if suffix.isdigit():
            agent_id = int(suffix)
    state_data = _load_state_data()
    stored_tasks = state_data.get("tasks") or {}
    conv_map = state_data.get("conversation_agents") or {}

    def _matches(info: Optional[Dict[str, Any]]) -> bool:
        if not info:
            return False
        parent_conv = _extract_parent_conversation(info)
        if normalized_conv and parent_conv != normalized_conv:
            return False
        if agent_id is not None and info.get("agent_id") != agent_id:
            return False
        if not normalized_conv and agent_id is None and info.get("task_id") != task_label:
            return False
        return True

    record = sub_agent_tasks.get(task_label) or stored_tasks.get(task_label)

    if not record:
        record = next((info for info in sub_agent_tasks.values() if _matches(info)), None)

    if not record:
        record = next((info for info in stored_tasks.values() if _matches(info)), None)

    if not record and normalized_conv and agent_id is not None:
        agent_list = conv_map.get(normalized_conv, [])
        if agent_list and agent_id in agent_list:
            for info in stored_tasks.values():
                if info.get("agent_id") == agent_id and _extract_parent_conversation(info) == normalized_conv:
                    record = info
                    break

    actual_task_id = record.get("task_id") if record else task_label
    parent_conv = _extract_parent_conversation(record) or normalized_conv
    sub_conv = record.get("sub_conversation_id") if record else None
    return actual_task_id, parent_conv, sub_conv

# 创建调试日志文件
DEBUG_LOG_FILE = Path(LOGS_DIR).expanduser().resolve() / "debug_stream.log"
UPLOAD_FOLDER_NAME = "user_upload"


def is_logged_in() -> bool:
    return session.get('username') is not None


def login_required(view_func):
    @wraps(view_func)
    def wrapped(*args, **kwargs):
        if not is_logged_in():
            return redirect('/login')
        return view_func(*args, **kwargs)

    return wrapped


def api_login_required(view_func):
    @wraps(view_func)
    def wrapped(*args, **kwargs):
        if not is_logged_in():
            return jsonify({"error": "Unauthorized"}), 401
        return view_func(*args, **kwargs)

    return wrapped


def get_current_username() -> Optional[str]:
    return session.get('username')


def make_terminal_callback(username: str):
    """生成面向指定用户的广播函数"""
    def _callback(event_type, data):
        try:
            socketio.emit(event_type, data, room=f"user_{username}")
        except Exception as exc:
            debug_log(f"广播事件失败 ({username}): {event_type} - {exc}")
    return _callback


def attach_user_broadcast(terminal: WebTerminal, username: str):
    """确保终端的广播函数指向当前用户的房间"""
    callback = make_terminal_callback(username)
    terminal.message_callback = callback
    if terminal.terminal_manager:
        terminal.terminal_manager.broadcast = callback


def get_user_resources(username: Optional[str] = None) -> Tuple[Optional[WebTerminal], Optional[UserWorkspace]]:
    username = (username or get_current_username())
    if not username:
        return None, None
    workspace = user_manager.ensure_user_workspace(username)
    terminal = user_terminals.get(username)
    if not terminal:
        thinking_mode = session.get('thinking_mode', False)
        terminal = WebTerminal(
            project_path=str(workspace.project_path),
            thinking_mode=thinking_mode,
            message_callback=make_terminal_callback(username),
            data_dir=str(workspace.data_dir)
        )
        if terminal.terminal_manager:
            terminal.terminal_manager.broadcast = terminal.message_callback
        user_terminals[username] = terminal
    else:
        attach_user_broadcast(terminal, username)
    return terminal, workspace


def with_terminal(func):
    """注入用户专属终端和工作区"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        username = get_current_username()
        terminal, workspace = get_user_resources(username)
        if not terminal or not workspace:
            return jsonify({"error": "System not initialized"}), 503
        kwargs.update({
            'terminal': terminal,
            'workspace': workspace,
            'username': username
        })
        return func(*args, **kwargs)
    return wrapper


def get_terminal_for_sid(sid: str) -> Tuple[Optional[str], Optional[WebTerminal], Optional[UserWorkspace]]:
    username = connection_users.get(sid)
    if not username:
        return None, None, None
    terminal, workspace = get_user_resources(username)
    return username, terminal, workspace


def get_gui_manager(workspace: UserWorkspace) -> GuiFileManager:
    """构建 GUI 文件管理器"""
    return GuiFileManager(str(workspace.project_path))


def ensure_conversation_loaded(terminal: WebTerminal, conversation_id: Optional[str], thinking_mode: bool) -> Tuple[str, bool]:
    """确保终端加载指定对话，若无则创建新的"""
    created_new = False
    if not conversation_id:
        result = terminal.create_new_conversation(thinking_mode=thinking_mode)
        if not result.get("success"):
            raise RuntimeError(result.get("message", "创建对话失败"))
        conversation_id = result["conversation_id"]
        created_new = True
    else:
        conversation_id = conversation_id if conversation_id.startswith('conv_') else f"conv_{conversation_id}"
        current_id = terminal.context_manager.current_conversation_id
        if current_id != conversation_id:
            load_result = terminal.load_conversation(conversation_id)
            if not load_result.get("success"):
                raise RuntimeError(load_result.get("message", "对话加载失败"))
    return conversation_id, created_new

def reset_system_state(terminal: Optional[WebTerminal]):
    """完整重置系统状态，确保停止后能正常开始新任务"""
    if not terminal:
        return
    
    try:
        # 1. 重置API客户端状态
        if hasattr(terminal, 'api_client') and terminal.api_client:
            debug_log("重置API客户端状态")
            terminal.api_client.start_new_task()  # 重置思考模式状态
        
        # 2. 重置主终端会话状态
        if hasattr(terminal, 'current_session_id'):
            terminal.current_session_id += 1  # 开始新会话
            debug_log(f"重置会话ID为: {terminal.current_session_id}")
        
        # 3. 清理读取文件跟踪器
            debug_log("清理文件读取跟踪器")
        
        # 4. 重置Web特有的状态属性
        web_attrs = ['streamingMessage', 'currentMessageIndex', 'preparingTools', 'activeTools']
        for attr in web_attrs:
            if hasattr(terminal, attr):
                if attr in ['streamingMessage']:
                    setattr(terminal, attr, False)
                elif attr in ['currentMessageIndex']:
                    setattr(terminal, attr, -1)
                elif attr in ['preparingTools', 'activeTools'] and hasattr(getattr(terminal, attr), 'clear'):
                    getattr(terminal, attr).clear()
        
        debug_log("系统状态重置完成")
        
    except Exception as e:
        debug_log(f"状态重置过程中出现错误: {e}")
        import traceback
        debug_log(f"错误详情: {traceback.format_exc()}")


def debug_log(message):
    """写入调试日志"""
    DEBUG_LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
    with DEBUG_LOG_FILE.open('a', encoding='utf-8') as f:
        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
        f.write(f"[{timestamp}] {message}\n")

# 终端广播回调函数
def terminal_broadcast(event_type, data):
    """广播终端事件到所有订阅者"""
    try:
        # 对于全局事件，发送给所有连接的客户端
        if event_type in ('todo_updated',):
            socketio.emit(event_type, data)  # 全局广播，不限制房间
            debug_log(f"全局广播{event_type}: {data}")
        else:
            # 其他终端事件发送到终端订阅者房间
            socketio.emit(event_type, data, room='terminal_subscribers')
            
            # 如果是特定会话的事件，也发送到该会话的专属房间
            if 'session' in data:
                session_room = f"terminal_{data['session']}"
                socketio.emit(event_type, data, room=session_room)
        
        debug_log(f"终端广播: {event_type} - {data}")
    except Exception as e:
        debug_log(f"终端广播错误: {e}")

@app.route('/login', methods=['GET', 'POST'])
def login():
    """登录页面与认证"""
    if request.method == 'GET':
        if is_logged_in():
            return redirect('/new')
        return app.send_static_file('login.html')

    data = request.get_json() or {}
    email = (data.get('email') or '').strip()
    password = data.get('password') or ''

    record = user_manager.authenticate(email, password)
    if not record:
        return jsonify({"success": False, "error": "账号或密码错误"}), 401

    session['logged_in'] = True
    session['username'] = record.username
    session['thinking_mode'] = app.config.get('DEFAULT_THINKING_MODE', False)
    session.permanent = True
    user_manager.ensure_user_workspace(record.username)
    return jsonify({"success": True})


@app.route('/register', methods=['GET', 'POST'])
def register():
    """注册新用户（需要邀请码）"""
    if request.method == 'GET':
        if is_logged_in():
            return redirect('/new')
        return app.send_static_file('register.html')
    
    data = request.get_json() or {}
    username = (data.get('username') or '').strip()
    email = (data.get('email') or '').strip()
    password = data.get('password') or ''
    invite_code = (data.get('invite_code') or '').strip()
    
    try:
        user_manager.register_user(username, email, password, invite_code)
        return jsonify({"success": True})
    except ValueError as exc:
        return jsonify({"success": False, "error": str(exc)}), 400
    except Exception as exc:
        return jsonify({"success": False, "error": str(exc)}), 500


@app.route('/logout', methods=['POST'])
def logout():
    """退出登录"""
    username = session.get('username')
    session.clear()
    if username and username in user_terminals:
        user_terminals.pop(username, None)
    return jsonify({"success": True})


@app.route('/')
@login_required
def index():
    """主页 -> 重定向到 /new"""
    return redirect('/new')


@app.route('/new')
@login_required
def new_page():
    return app.send_static_file('index.html')


@app.route('/<conv:conversation_id>')
@login_required
def conversation_page(conversation_id):
    return app.send_static_file('index.html')


@app.route('/terminal')
@login_required
def terminal_page():
    """终端监控页面"""
    return app.send_static_file('terminal.html')


@app.route('/file-manager')
@login_required
def gui_file_manager_page():
    """桌面式文件管理器页面"""
    return send_from_directory(Path(app.static_folder) / 'file_manager', 'index.html')


@app.route('/file-manager/editor')
@login_required
def gui_file_editor_page():
    """GUI 文件编辑器页面"""
    return send_from_directory(Path(app.static_folder) / 'file_manager', 'editor.html')


@app.route('/file-preview/<path:relative_path>')
@login_required
@with_terminal
def gui_file_preview(relative_path: str, terminal: WebTerminal, workspace: UserWorkspace, username: str):
    manager = get_gui_manager(workspace)
    try:
        target = manager.prepare_download(relative_path)
        if not target.is_file():
            return "预览仅支持文件", 400
        return send_from_directory(
            directory=target.parent,
            path=target.name,
            mimetype='text/html'
        )
    except Exception as exc:
        return f"无法预览文件: {exc}", 400

@app.route('/static/<path:filename>')
def static_files(filename):
    """提供静态文件"""
    return send_from_directory('static', filename)

@app.route('/api/status')
@api_login_required
@with_terminal
def get_status(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """获取系统状态（增强版：包含对话信息）"""
    status = terminal.get_status()
    
    # 添加终端状态信息
    if terminal.terminal_manager:
        terminal_status = terminal.terminal_manager.list_terminals()
        status['terminals'] = terminal_status
    
    # 【新增】添加当前对话的详细信息
    try:
        current_conv = terminal.context_manager.current_conversation_id
        status['conversation'] = status.get('conversation', {})
        status['conversation']['current_id'] = current_conv
        if current_conv and not current_conv.startswith('temp_'):
            current_conv_data = terminal.context_manager.conversation_manager.load_conversation(current_conv)
            if current_conv_data:
                status['conversation']['title'] = current_conv_data.get('title', '未知对话')
                status['conversation']['created_at'] = current_conv_data.get('created_at')
                status['conversation']['updated_at'] = current_conv_data.get('updated_at')
    except Exception as e:
        print(f"[Status] 获取当前对话信息失败: {e}")
    
    status['project_path'] = str(workspace.project_path)
    status['version'] = AGENT_VERSION
    return jsonify(status)

@app.route('/api/files')
@api_login_required
@with_terminal
def get_files(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """获取文件树"""
    structure = terminal.context_manager.get_project_structure()
    return jsonify(structure)


# ==========================================
# 新版 GUI 文件管理器 API
# ==========================================


def _format_entry(entry) -> Dict[str, Any]:
    return {
        "name": entry.name,
        "path": entry.path,
        "type": entry.type,
        "size": entry.size,
        "modified_at": entry.modified_at,
        "extension": entry.extension,
        "is_editable": entry.is_editable,
    }


@app.route('/api/gui/files/entries', methods=['GET'])
@api_login_required
@with_terminal
def gui_list_entries(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """列出指定目录内容"""
    relative_path = request.args.get('path') or ""
    manager = get_gui_manager(workspace)
    try:
        resolved_path, entries = manager.list_directory(relative_path)
        breadcrumb = manager.breadcrumb(resolved_path)
        return jsonify({
            "success": True,
            "data": {
                "path": resolved_path,
                "breadcrumb": breadcrumb,
                "items": [_format_entry(entry) for entry in entries]
            }
        })
    except Exception as exc:
        return jsonify({
            "success": False,
            "error": str(exc)
        }), 400


@app.route('/api/gui/files/create', methods=['POST'])
@api_login_required
@with_terminal
def gui_create_entry(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    payload = request.get_json() or {}
    parent = payload.get('path') or ""
    name = payload.get('name') or ""
    entry_type = payload.get('type') or "file"
    manager = get_gui_manager(workspace)
    try:
        new_path = manager.create_entry(parent, name, entry_type)
        return jsonify({
            "success": True,
            "path": new_path
        })
    except Exception as exc:
        return jsonify({
            "success": False,
            "error": str(exc)
        }), 400


@app.route('/api/gui/files/delete', methods=['POST'])
@api_login_required
@with_terminal
def gui_delete_entries(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    payload = request.get_json() or {}
    paths = payload.get('paths') or []
    manager = get_gui_manager(workspace)
    try:
        result = manager.delete_entries(paths)
        return jsonify({
            "success": True,
            "result": result
        })
    except Exception as exc:
        return jsonify({
            "success": False,
            "error": str(exc)
        }), 400


@app.route('/api/gui/files/rename', methods=['POST'])
@api_login_required
@with_terminal
def gui_rename_entry(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    payload = request.get_json() or {}
    path = payload.get('path')
    new_name = payload.get('new_name')
    if not path or not new_name:
        return jsonify({"success": False, "error": "缺少 path 或 new_name"}), 400
    manager = get_gui_manager(workspace)
    try:
        new_path = manager.rename_entry(path, new_name)
        return jsonify({
            "success": True,
            "path": new_path
        })
    except Exception as exc:
        return jsonify({
            "success": False,
            "error": str(exc)
        }), 400


@app.route('/api/gui/files/copy', methods=['POST'])
@api_login_required
@with_terminal
def gui_copy_entries(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    payload = request.get_json() or {}
    paths = payload.get('paths') or []
    target_dir = payload.get('target_dir') or ""
    manager = get_gui_manager(workspace)
    try:
        result = manager.copy_entries(paths, target_dir)
        return jsonify({
            "success": True,
            "result": result
        })
    except Exception as exc:
        return jsonify({
            "success": False,
            "error": str(exc)
        }), 400


@app.route('/api/gui/files/move', methods=['POST'])
@api_login_required
@with_terminal
def gui_move_entries(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    payload = request.get_json() or {}
    paths = payload.get('paths') or []
    target_dir = payload.get('target_dir') or ""
    manager = get_gui_manager(workspace)
    try:
        result = manager.move_entries(paths, target_dir)
        return jsonify({
            "success": True,
            "result": result
        })
    except Exception as exc:
        return jsonify({
            "success": False,
            "error": str(exc)
        }), 400


@app.route('/api/gui/files/upload', methods=['POST'])
@api_login_required
@with_terminal
def gui_upload_entry(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    if 'file' not in request.files:
        return jsonify({"success": False, "error": "未找到文件"}), 400
    file_obj = request.files['file']
    if not file_obj or not file_obj.filename:
        return jsonify({"success": False, "error": "文件名为空"}), 400
    current_dir = request.form.get('path') or ""
    raw_name = request.form.get('filename') or file_obj.filename
    filename = sanitize_filename_preserve_unicode(raw_name) or secure_filename(raw_name)
    if not filename:
        return jsonify({"success": False, "error": "非法文件名"}), 400
    manager = get_gui_manager(workspace)
    try:
        target_path = manager.prepare_upload(current_dir, filename)
    except Exception as exc:
        return jsonify({"success": False, "error": str(exc)}), 400

    try:
        file_obj.save(target_path)
    except Exception as exc:
        return jsonify({"success": False, "error": f'保存文件失败: {exc}'}), 500

    return jsonify({
        "success": True,
        "path": manager._to_relative(target_path)
    })


@app.route('/api/gui/files/download', methods=['GET'])
@api_login_required
@with_terminal
def gui_download_entry(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    path = request.args.get('path')
    if not path:
        return jsonify({"success": False, "error": "缺少 path"}), 400
    manager = get_gui_manager(workspace)
    try:
        target = manager.prepare_download(path)
        if target.is_dir():
            memory_file = BytesIO()
            with zipfile.ZipFile(memory_file, mode='w', compression=zipfile.ZIP_DEFLATED) as zf:
                for root, dirs, files in os.walk(target):
                    for file in files:
                        full_path = Path(root) / file
                        arcname = manager._to_relative(full_path)
                        zf.write(full_path, arcname=arcname)
            memory_file.seek(0)
            download_name = f"{target.name}.zip"
            return send_file(memory_file, as_attachment=True, download_name=download_name, mimetype='application/zip')
        return send_file(target, as_attachment=True, download_name=target.name)
    except Exception as exc:
        return jsonify({"success": False, "error": str(exc)}), 400


@app.route('/api/gui/files/download/batch', methods=['POST'])
@api_login_required
@with_terminal
def gui_download_batch(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    payload = request.get_json() or {}
    paths = payload.get('paths') or []
    if not paths:
        return jsonify({"success": False, "error": "缺少待下载的路径"}), 400
    manager = get_gui_manager(workspace)
    try:
        memory_file = BytesIO()
        with zipfile.ZipFile(memory_file, mode='w', compression=zipfile.ZIP_DEFLATED) as zf:
            for rel in paths:
                target = manager.prepare_download(rel)
                arc_base = rel.strip('/') or target.name
                if target.is_dir():
                    for root, _, files in os.walk(target):
                        for file in files:
                            full_path = Path(root) / file
                            relative_sub = full_path.relative_to(target)
                            arcname = Path(arc_base) / relative_sub
                            zf.write(full_path, arcname=str(arcname))
                else:
                    zf.write(target, arcname=arc_base)
        memory_file.seek(0)
        download_name = f"selected_{len(paths)}.zip"
        return send_file(memory_file, as_attachment=True, download_name=download_name, mimetype='application/zip')
    except Exception as exc:
        return jsonify({"success": False, "error": str(exc)}), 400


@app.route('/api/gui/files/text', methods=['GET', 'POST'])
@api_login_required
@with_terminal
def gui_text_entry(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    manager = get_gui_manager(workspace)
    if request.method == 'GET':
        path = request.args.get('path')
        if not path:
            return jsonify({"success": False, "error": "缺少 path"}), 400
        try:
            content, modified = manager.read_text(path)
            return jsonify({
                "success": True,
                "path": path,
                "content": content,
                "modified_at": modified
            })
        except Exception as exc:
            return jsonify({"success": False, "error": str(exc)}), 400

    payload = request.get_json() or {}
    path = payload.get('path')
    content = payload.get('content')
    if path is None or content is None:
        return jsonify({"success": False, "error": "缺少 path 或 content"}), 400
    try:
        result = manager.write_text(path, content)
        return jsonify({"success": True, "data": result})
    except Exception as exc:
        return jsonify({"success": False, "error": str(exc)}), 400

@app.route('/api/focused')
@api_login_required
@with_terminal
def get_focused_files(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """获取聚焦文件"""
    focused = {}
    for path, content in terminal.focused_files.items():
        focused[path] = {
            "content": content,
            "size": len(content),
            "lines": content.count('\n') + 1
        }
    return jsonify(focused)

@app.route('/api/todo-list')
@api_login_required
@with_terminal
def get_todo_list(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """获取当前待办列表"""
    todo_snapshot = terminal.context_manager.get_todo_snapshot()
    return jsonify({
        "success": True,
        "data": todo_snapshot
    })

@app.route('/api/upload', methods=['POST'])
@api_login_required
@with_terminal
def upload_file(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """处理前端文件上传请求"""
    if 'file' not in request.files:
        return jsonify({
            "success": False,
            "error": "未找到文件",
            "message": "请求中缺少文件字段"
        }), 400

    uploaded_file = request.files['file']
    original_name = (request.form.get('filename') or '').strip()

    if not uploaded_file or not uploaded_file.filename or uploaded_file.filename.strip() == '':
        return jsonify({
            "success": False,
            "error": "文件名为空",
            "message": "请选择要上传的文件"
        }), 400

    raw_name = original_name or uploaded_file.filename
    filename = sanitize_filename_preserve_unicode(raw_name)
    if not filename:
        filename = secure_filename(raw_name)
    if not filename:
        return jsonify({
            "success": False,
            "error": "非法文件名",
            "message": "文件名包含不支持的字符"
        }), 400

    file_manager = getattr(terminal, 'file_manager', None)
    if file_manager is None:
        return jsonify({
            "success": False,
            "error": "文件管理器未初始化"
        }), 500

    target_folder_relative = UPLOAD_FOLDER_NAME
    valid_folder, folder_error, folder_path = file_manager._validate_path(target_folder_relative)
    if not valid_folder:
        return jsonify({
            "success": False,
            "error": folder_error
        }), 400

    try:
        folder_path.mkdir(parents=True, exist_ok=True)
    except Exception as exc:
        return jsonify({
            "success": False,
            "error": f"创建上传目录失败: {exc}"
        }), 500

    target_relative = str(Path(target_folder_relative) / filename)
    valid_file, file_error, target_full_path = file_manager._validate_path(target_relative)
    if not valid_file:
        return jsonify({
            "success": False,
            "error": file_error
        }), 400

    final_path = target_full_path
    if final_path.exists():
        stem = final_path.stem
        suffix = final_path.suffix
        counter = 1

        while final_path.exists():
            candidate_name = f"{stem}_{counter}{suffix}"
            target_relative = str(Path(target_folder_relative) / candidate_name)
            valid_file, file_error, candidate_path = file_manager._validate_path(target_relative)
            if not valid_file:
                return jsonify({
                    "success": False,
                    "error": file_error
                }), 400
            final_path = candidate_path
            counter += 1

    try:
        uploaded_file.save(final_path)
    except Exception as exc:
        return jsonify({
            "success": False,
            "error": f"保存文件失败: {exc}"
        }), 500

    relative_path = str(final_path.relative_to(workspace.project_path))
    print(f"{OUTPUT_FORMATS['file']} 上传文件: {relative_path}")

    return jsonify({
        "success": True,
        "path": relative_path,
        "filename": final_path.name,
        "folder": target_folder_relative
    })


@app.errorhandler(RequestEntityTooLarge)
def handle_file_too_large(error):
    """全局捕获上传超大小"""
    size_mb = MAX_UPLOAD_SIZE / (1024 * 1024)
    return jsonify({
        "success": False,
        "error": "文件过大",
        "message": f"单个文件大小不可超过 {size_mb:.1f} MB"
    }), 413


@app.route('/api/download/file')
@api_login_required
@with_terminal
def download_file_api(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """下载单个文件"""
    path = (request.args.get('path') or '').strip()
    if not path:
        return jsonify({"success": False, "error": "缺少路径参数"}), 400

    valid, error, full_path = terminal.file_manager._validate_path(path)
    if not valid or full_path is None:
        return jsonify({"success": False, "error": error or "路径校验失败"}), 400
    if not full_path.exists() or not full_path.is_file():
        return jsonify({"success": False, "error": "文件不存在"}), 404

    return send_file(
        full_path,
        as_attachment=True,
        download_name=full_path.name
    )


@app.route('/api/download/folder')
@api_login_required
@with_terminal
def download_folder_api(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """打包并下载文件夹"""
    path = (request.args.get('path') or '').strip()
    if not path:
        return jsonify({"success": False, "error": "缺少路径参数"}), 400

    valid, error, full_path = terminal.file_manager._validate_path(path)
    if not valid or full_path is None:
        return jsonify({"success": False, "error": error or "路径校验失败"}), 400
    if not full_path.exists() or not full_path.is_dir():
        return jsonify({"success": False, "error": "文件夹不存在"}), 404

    buffer = BytesIO()
    folder_name = Path(path).name or full_path.name or "archive"

    with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED) as zip_buffer:
        # 确保目录本身被包含
        zip_buffer.write(full_path, arcname=folder_name + '/')

        for item in full_path.rglob('*'):
            relative_name = Path(folder_name) / item.relative_to(full_path)
            if item.is_dir():
                zip_buffer.write(item, arcname=str(relative_name) + '/')
            else:
                zip_buffer.write(item, arcname=str(relative_name))

    buffer.seek(0)
    return send_file(
        buffer,
        mimetype='application/zip',
        as_attachment=True,
        download_name=f"{folder_name}.zip"
    )

@app.route('/api/tool-settings', methods=['GET', 'POST'])
@api_login_required
@with_terminal
def tool_settings(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """获取或更新工具启用状态"""
    if request.method == 'GET':
        snapshot = terminal.get_tool_settings_snapshot()
        return jsonify({
            "success": True,
            "categories": snapshot
        })

    data = request.get_json() or {}
    category = data.get('category')
    if category is None:
        return jsonify({
            "success": False,
            "error": "缺少类别参数",
            "message": "请求体需要提供 category 字段"
        }), 400

    if 'enabled' not in data:
        return jsonify({
            "success": False,
            "error": "缺少启用状态",
            "message": "请求体需要提供 enabled 字段"
        }), 400

    try:
        enabled = bool(data['enabled'])
        terminal.set_tool_category_enabled(category, enabled)
        snapshot = terminal.get_tool_settings_snapshot()
        socketio.emit('tool_settings_updated', {
            'categories': snapshot
        }, room=f"user_{username}")
        return jsonify({
            "success": True,
            "categories": snapshot
        })
    except ValueError as exc:
        return jsonify({
            "success": False,
            "error": str(exc)
        }), 400

@app.route('/api/terminals')
@api_login_required
@with_terminal
def get_terminals(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """获取终端会话列表"""
    if terminal.terminal_manager:
        result = terminal.terminal_manager.list_terminals()
        return jsonify(result)
    else:
        return jsonify({"sessions": [], "active": None, "total": 0})

@socketio.on('connect')
def handle_connect():
    """客户端连接"""
    print(f"[WebSocket] 客户端连接: {request.sid}")
    username = get_current_username()
    if not username:
        connection_users[request.sid] = None
        emit('connected', {'status': 'guest'})
        return

    emit('connected', {'status': 'Connected to server'})
    connection_users[request.sid] = username
    
    # 清理可能存在的停止标志和状态
    stop_flags.pop(request.sid, None)
    
    join_room(f"user_{username}")
    join_room(f"user_{username}_terminal")
    if request.sid not in terminal_rooms:
        terminal_rooms[request.sid] = set()
    terminal_rooms[request.sid].update({f"user_{username}", f"user_{username}_terminal"})
    
    terminal, workspace = get_user_resources(username)
    if terminal:
        reset_system_state(terminal)
        emit('system_ready', {
            'project_path': str(workspace.project_path),
            'thinking_mode': terminal.get_thinking_mode_status(),
            'version': AGENT_VERSION
        }, room=request.sid)
        
        if terminal.terminal_manager:
            terminals = terminal.terminal_manager.get_terminal_list()
            emit('terminal_list_update', {
                'terminals': terminals,
                'active': terminal.terminal_manager.active_terminal
            }, room=request.sid)
            
            if terminal.terminal_manager.active_terminal:
                for name, term in terminal.terminal_manager.terminals.items():
                    emit('terminal_started', {
                        'session': name,
                        'working_dir': str(term.working_dir),
                        'shell': term.shell_command,
                        'time': term.start_time.isoformat() if term.start_time else None
                    }, room=request.sid)

@socketio.on('disconnect')
def handle_disconnect():
    """客户端断开"""
    print(f"[WebSocket] 客户端断开: {request.sid}")
    username = connection_users.pop(request.sid, None)
    
    # 清理停止标志
    stop_flags.pop(request.sid, None)
    
    # 从所有房间移除
    for room in list(terminal_rooms.get(request.sid, [])):
        leave_room(room)
    if request.sid in terminal_rooms:
        del terminal_rooms[request.sid]
    
    if username:
        leave_room(f"user_{username}")
        leave_room(f"user_{username}_terminal")

    task_id = sub_agent_connections.pop(request.sid, None)
    if task_id:
        room = f"sub_agent_{task_id}"
        leave_room(room)
        if request.sid in sub_agent_rooms.get(task_id, set()):
            sub_agent_rooms[task_id].remove(request.sid)

@socketio.on('stop_task')
def handle_stop_task():
    """处理停止任务请求"""
    print(f"[停止] 收到停止请求: {request.sid}")
    
    # 检查是否有正在运行的任务
    if request.sid in stop_flags and isinstance(stop_flags[request.sid], dict):
        # 获取任务引用并取消
        task_info = stop_flags[request.sid]
        if 'task' in task_info and not task_info['task'].done():
            debug_log(f"正在取消任务: {request.sid}")
            task_info['task'].cancel()
        
        # 设置停止标志
        task_info['stop'] = True
        if task_info.get('terminal'):
            reset_system_state(task_info['terminal'])
    else:
        # 如果没有任务引用，使用旧的布尔标志
        stop_flags[request.sid] = True
    
    emit('stop_requested', {
        'message': '停止请求已接收，正在取消任务...'
    })

@socketio.on('terminal_subscribe')
def handle_terminal_subscribe(data):
    """订阅终端事件"""
    session_name = data.get('session')
    subscribe_all = data.get('all', False)

    username, terminal, _ = get_terminal_for_sid(request.sid)
    if not username or not terminal or not terminal.terminal_manager:
        emit('error', {'message': 'Terminal system not initialized'})
        return
    
    if request.sid not in terminal_rooms:
        terminal_rooms[request.sid] = set()
    
    if subscribe_all:
        # 订阅所有终端事件
        room_name = f"user_{username}_terminal"
        join_room(room_name)
        terminal_rooms[request.sid].add(room_name)
        print(f"[Terminal] {request.sid} 订阅所有终端事件")
        
        # 发送当前终端状态
        emit('terminal_subscribed', {
            'type': 'all',
            'terminals': terminal.terminal_manager.get_terminal_list()
        })
    elif session_name:
        # 订阅特定终端会话
        room_name = f'user_{username}_terminal_{session_name}'
        join_room(room_name)
        terminal_rooms[request.sid].add(room_name)
        print(f"[Terminal] {request.sid} 订阅终端: {session_name}")
        
        # 发送该终端的当前输出
        output_result = terminal.terminal_manager.get_terminal_output(session_name, 100)
        if output_result['success']:
            emit('terminal_history', {
                'session': session_name,
                'output': output_result['output']
            })

@socketio.on('terminal_unsubscribe')
def handle_terminal_unsubscribe(data):
    """取消订阅终端事件"""
    session_name = data.get('session')
    username = connection_users.get(request.sid)
    
    if session_name:
        room_name = f'user_{username}_terminal_{session_name}' if username else f'terminal_{session_name}'
        leave_room(room_name)
        if request.sid in terminal_rooms:
            terminal_rooms[request.sid].discard(room_name)
        print(f"[Terminal] {request.sid} 取消订阅终端: {session_name}")

@socketio.on('get_terminal_output')
def handle_get_terminal_output(data):
    """获取终端输出历史"""
    session_name = data.get('session')
    lines = data.get('lines', 50)
    
    username, terminal, _ = get_terminal_for_sid(request.sid)
    if not terminal or not terminal.terminal_manager:
        emit('error', {'message': 'Terminal system not initialized'})
        return
    
    result = terminal.terminal_manager.get_terminal_output(session_name, lines)
    
    if result['success']:
        emit('terminal_output_history', {
            'session': session_name,
            'output': result['output'],
            'is_interactive': result.get('is_interactive', False),
            'last_command': result.get('last_command', '')
        })
    else:
        emit('error', {'message': result['error']})

@socketio.on('send_message')
def handle_message(data):
    """处理用户消息"""
    username, terminal, workspace = get_terminal_for_sid(request.sid)
    if not terminal:
        emit('error', {'message': 'System not initialized'})
        return
    
    message = (data.get('message') or '').strip()
    if not message:
        emit('error', {'message': '消息不能为空'})
        return
    
    print(f"[WebSocket] 收到消息: {message}")
    debug_log(f"\n{'='*80}\n新任务开始: {message}\n{'='*80}")
    
    requested_conversation_id = data.get('conversation_id')
    try:
        conversation_id, created_new = ensure_conversation_loaded(terminal, requested_conversation_id, terminal.thinking_mode)
    except RuntimeError as exc:
        emit('error', {'message': str(exc)})
        return
    try:
        conv_data = terminal.context_manager.conversation_manager.load_conversation(conversation_id) or {}
    except Exception:
        conv_data = {}
    title = conv_data.get('title', '新对话')

    socketio.emit('conversation_resolved', {
        'conversation_id': conversation_id,
        'title': title,
        'created': created_new
    }, room=request.sid)

    if created_new:
        socketio.emit('conversation_list_update', {
            'action': 'created',
            'conversation_id': conversation_id
        }, room=f"user_{username}")
        socketio.emit('conversation_changed', {
            'conversation_id': conversation_id,
            'title': title
        }, room=request.sid)
    
    client_sid = request.sid

    def send_to_client(event_type, data):
        """发送消息到客户端"""
        socketio.emit(event_type, data, room=client_sid)

    # 传递客户端ID
    socketio.start_background_task(process_message_task, terminal, message, send_to_client, client_sid)


@socketio.on('sub_agent_join')
def handle_sub_agent_join(data):
    task_id = (data or {}).get("task_id")
    task = sub_agent_tasks.get(task_id)
    if not task:
        emit('sub_agent_status', {"task_id": task_id, "status": "unknown", "message": "任务不存在"})
        return
    room = f"sub_agent_{task_id}"
    join_room(room)
    sub_agent_connections[request.sid] = task_id
    sub_agent_rooms[task_id].add(request.sid)
    emit('sub_agent_status', {
        "task_id": task_id,
        "status": task.get("status"),
        "summary": task.get("summary"),
        "last_tool": task.get("last_tool"),
        "deliverables_dir": task.get("deliverables_dir"),
    })


@socketio.on('sub_agent_leave')
def handle_sub_agent_leave():
    task_id = sub_agent_connections.pop(request.sid, None)
    if not task_id:
        return
    room = f"sub_agent_{task_id}"
    leave_room(room)
    if request.sid in sub_agent_rooms.get(task_id, set()):
        sub_agent_rooms[task_id].remove(request.sid)


@socketio.on('sub_agent_message')
def handle_sub_agent_message(data):
    task_id = (data or {}).get("task_id")
    message = (data or {}).get("message", "").strip()
    if not task_id or not message:
        emit('sub_agent_status', {
            "task_id": task_id,
            "status": "error",
            "message": "缺少任务ID或消息内容"
        })
        return
    result = send_message_to_sub_agent(task_id, message)
    if not result.get("success"):
        emit('sub_agent_status', {
            "task_id": task_id,
            "status": "error",
            "message": result.get("error")
        })

# 在 web_server.py 中添加以下对话管理API接口
# 添加在现有路由之后，@socketio 事件处理之前

# ==========================================
# 对话管理API接口
# ==========================================

@app.route('/api/conversations', methods=['GET'])
@api_login_required
@with_terminal
def get_conversations(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """获取对话列表"""
    try:
        # 获取查询参数
        limit = request.args.get('limit', 20, type=int)
        offset = request.args.get('offset', 0, type=int)
        
        # 限制参数范围
        limit = max(1, min(limit, 100))  # 限制在1-100之间
        offset = max(0, offset)
        
        result = terminal.get_conversations_list(limit=limit, offset=offset)
        
        if result["success"]:
            return jsonify({
                "success": True,
                "data": result["data"]
            })
        else:
            return jsonify({
                "success": False,
                "error": result.get("error", "Unknown error"),
                "message": result.get("message", "获取对话列表失败")
            }), 500
            
    except Exception as e:
        print(f"[API] 获取对话列表错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e),
            "message": "获取对话列表时发生异常"
        }), 500

@app.route('/api/conversations', methods=['POST'])
@api_login_required
@with_terminal
def create_conversation(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """创建新对话"""
    try:
        data = request.get_json() or {}
        thinking_mode = data.get('thinking_mode', terminal.thinking_mode)
        
        result = terminal.create_new_conversation(thinking_mode=thinking_mode)
        
        if result["success"]:
            # 广播对话列表更新事件
            socketio.emit('conversation_list_update', {
                'action': 'created',
                'conversation_id': result["conversation_id"]
            }, room=f"user_{username}")
            
            # 广播当前对话切换事件
            socketio.emit('conversation_changed', {
                'conversation_id': result["conversation_id"],
                'title': "新对话"
            }, room=f"user_{username}")
            
            return jsonify(result), 201
        else:
            return jsonify(result), 500
            
    except Exception as e:
        print(f"[API] 创建对话错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e),
            "message": "创建对话时发生异常"
        }), 500

@app.route('/api/conversations/<conversation_id>', methods=['GET'])
@api_login_required
@with_terminal
def get_conversation_info(terminal: WebTerminal, workspace: UserWorkspace, username: str, conversation_id):
    """获取特定对话信息"""
    try:
        # 通过ConversationManager直接获取对话数据
        conversation_data = terminal.context_manager.conversation_manager.load_conversation(conversation_id)
        
        if conversation_data:
            # 提取关键信息，不返回完整消息内容（避免数据量过大）
            info = {
                "id": conversation_data["id"],
                "title": conversation_data["title"],
                "created_at": conversation_data["created_at"],
                "updated_at": conversation_data["updated_at"],
                "metadata": conversation_data["metadata"],
                "messages_count": len(conversation_data.get("messages", []))
            }
            
            return jsonify({
                "success": True,
                "data": info
            })
        else:
            return jsonify({
                "success": False,
                "error": "Conversation not found",
                "message": f"对话 {conversation_id} 不存在"
            }), 404
            
    except Exception as e:
        print(f"[API] 获取对话信息错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e),
            "message": "获取对话信息时发生异常"
        }), 500

@app.route('/api/conversations/<conversation_id>/load', methods=['PUT'])
@api_login_required
@with_terminal
def load_conversation(conversation_id, terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """加载特定对话"""
    try:
        result = terminal.load_conversation(conversation_id)
        
        if result["success"]:
            # 广播对话切换事件
            socketio.emit('conversation_changed', {
                'conversation_id': conversation_id,
                'title': result.get("title", "未知对话"),
                'messages_count': result.get("messages_count", 0)
            }, room=f"user_{username}")
            
            # 广播系统状态更新（因为当前对话改变了）
            status = terminal.get_status()
            socketio.emit('status_update', status, room=f"user_{username}")
            
            # 清理和重置相关UI状态
            socketio.emit('conversation_loaded', {
                'conversation_id': conversation_id,
                'clear_ui': True  # 提示前端清理当前UI状态
            }, room=f"user_{username}")
            
            return jsonify(result)
        else:
            return jsonify(result), 404 if "不存在" in result.get("message", "") else 500
            
    except Exception as e:
        print(f"[API] 加载对话错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e),
            "message": "加载对话时发生异常"
        }), 500

@app.route('/api/conversations/<conversation_id>', methods=['DELETE'])
@api_login_required
@with_terminal
def delete_conversation(conversation_id, terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """删除特定对话"""
    try:
        # 检查是否是当前对话
        is_current = (terminal.context_manager.current_conversation_id == conversation_id)
        
        result = terminal.delete_conversation(conversation_id)
        
        if result["success"]:
            # 广播对话列表更新事件
            socketio.emit('conversation_list_update', {
                'action': 'deleted',
                'conversation_id': conversation_id
            }, room=f"user_{username}")
            
            # 如果删除的是当前对话，广播对话清空事件
            if is_current:
                socketio.emit('conversation_changed', {
                    'conversation_id': None,
                    'title': None,
                    'cleared': True
                }, room=f"user_{username}")
                
                # 更新系统状态
                status = terminal.get_status()
                socketio.emit('status_update', status, room=f"user_{username}")
            
            return jsonify(result)
        else:
            return jsonify(result), 404 if "不存在" in result.get("message", "") else 500
            
    except Exception as e:
        print(f"[API] 删除对话错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e),
            "message": "删除对话时发生异常"
        }), 500

@app.route('/api/conversations/search', methods=['GET'])
@api_login_required
@with_terminal
def search_conversations(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """搜索对话"""
    try:
        query = request.args.get('q', '').strip()
        limit = request.args.get('limit', 20, type=int)
        
        if not query:
            return jsonify({
                "success": False,
                "error": "Missing query parameter",
                "message": "请提供搜索关键词"
            }), 400
        
        # 限制参数范围
        limit = max(1, min(limit, 50))
        
        result = terminal.search_conversations(query, limit)
        
        return jsonify({
            "success": True,
            "data": {
                "results": result["results"],
                "count": result["count"],
                "query": query
            }
        })
            
    except Exception as e:
        print(f"[API] 搜索对话错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e),
            "message": "搜索对话时发生异常"
        }), 500

@app.route('/api/conversations/<conversation_id>/messages', methods=['GET'])
@api_login_required
@with_terminal
def get_conversation_messages(conversation_id, terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """获取对话的消息历史（可选功能，用于调试或详细查看）"""
    try:
        # 获取完整对话数据
        conversation_data = terminal.context_manager.conversation_manager.load_conversation(conversation_id)
        
        if conversation_data:
            messages = conversation_data.get("messages", [])
            
            # 可选：限制消息数量，避免返回过多数据
            limit = request.args.get('limit', type=int)
            if limit:
                messages = messages[-limit:]  # 获取最后N条消息
            
            return jsonify({
                "success": True,
                "data": {
                    "conversation_id": conversation_id,
                    "messages": messages,
                    "total_count": len(conversation_data.get("messages", []))
                }
            })
        else:
            return jsonify({
                "success": False,
                "error": "Conversation not found",
                "message": f"对话 {conversation_id} 不存在"
            }), 404
            
    except Exception as e:
        print(f"[API] 获取对话消息错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e),
            "message": "获取对话消息时发生异常"
        }), 500


@app.route('/api/conversations/<conversation_id>/compress', methods=['POST'])
@api_login_required
@with_terminal
def compress_conversation(conversation_id, terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """压缩指定对话的大体积消息，生成压缩版新对话"""
    try:
        result = terminal.context_manager.compress_conversation(conversation_id)

        if not result.get("success"):
            status_code = 404 if "不存在" in result.get("error", "") else 400
            return jsonify(result), status_code

        new_conversation_id = result["compressed_conversation_id"]

        load_result = terminal.load_conversation(new_conversation_id)

        if load_result.get("success"):
            socketio.emit('conversation_list_update', {
                'action': 'compressed',
                'conversation_id': new_conversation_id
            }, room=f"user_{username}")
            socketio.emit('conversation_changed', {
                'conversation_id': new_conversation_id,
                'title': load_result.get('title', '压缩后的对话'),
                'messages_count': load_result.get('messages_count', 0)
            }, room=f"user_{username}")
            socketio.emit('conversation_loaded', {
                'conversation_id': new_conversation_id,
                'clear_ui': True
            }, room=f"user_{username}")

        response_payload = {
            "success": True,
            "compressed_conversation_id": new_conversation_id,
            "compressed_types": result.get("compressed_types", []),
            "system_message": result.get("system_message"),
            "load_result": load_result
        }

        return jsonify(response_payload)

    except Exception as e:
        print(f"[API] 压缩对话错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e),
            "message": "压缩对话时发生异常"
        }), 500


# ==========================================
# 子智能体任务调度核心
# ==========================================

def create_sub_agent_task(payload: Dict[str, Any]) -> Dict[str, Any]:
    required_fields = [
        "task_id",
        "agent_id",
        "summary",
        "task",
        "workspace_dir",
        "references_dir",
        "deliverables_dir",
        "target_project_dir",
        "conversation_storage_dir",
    ]
    for field in required_fields:
        if not payload.get(field):
            return {"success": False, "error": f"缺少必要参数: {field}"}

    cleanup_inactive_sub_agent_tasks()
    task_id = payload["task_id"]
    if task_id in sub_agent_tasks:
        return {"success": False, "error": f"任务 {task_id} 已存在"}

    parent_conv = payload.get("parent_conversation_id")
    if get_active_sub_agent_count(parent_conv) >= SUB_AGENT_MAX_ACTIVE:
        limit_note = f"同一对话最多可同时运行 {SUB_AGENT_MAX_ACTIVE} 个子智能体"
        return {"success": False, "error": f"已存在 {SUB_AGENT_MAX_ACTIVE} 个运行中的子智能体，请稍后再试（{limit_note}）。"}

    workspace_dir = Path(payload["workspace_dir"]).resolve()
    references_dir = Path(payload["references_dir"]).resolve()
    deliverables_dir = Path(payload["deliverables_dir"]).resolve()
    conversation_storage_root = Path(payload["conversation_storage_dir"]).expanduser().resolve()
    conversation_storage_root.mkdir(parents=True, exist_ok=True)
    conversation_data_dir = (conversation_storage_root / f"conv_{task_id}").resolve()
    conversation_data_dir.mkdir(parents=True, exist_ok=True)

    metadata = {
        "task_id": task_id,
        "agent_id": payload["agent_id"],
        "summary": payload.get("summary", ""),
        "task": payload.get("task", ""),
        "workspace_dir": str(workspace_dir),
        "references_dir": str(references_dir),
        "deliverables_dir": str(deliverables_dir),
        "target_project_dir": payload.get("target_project_dir"),
    }

    terminal = SubAgentTerminal(
        workspace_dir=str(workspace_dir),
        data_dir=str(conversation_data_dir),
        metadata=metadata,
        message_callback=None,
    )
    terminal.task_id = task_id

    def _finish_hook(result: Dict[str, Any]):
        reason = result.get("reason", "")
        mark_task_completed(task_id, reason)

    terminal.set_finish_callback(_finish_hook)
    terminal._ensure_conversation()
    sub_conversation_id = terminal.context_manager.current_conversation_id

    sub_agent_terminals[task_id] = terminal
    sub_agent_tasks[task_id] = {
        **metadata,
        "status": "running",
        "created_at": time.time(),
        "updated_at": time.time(),
        "timeout_seconds": payload.get("timeout_seconds") or SUB_AGENT_DEFAULT_TIMEOUT,
        "parent_conversation_id": payload.get("parent_conversation_id"),
        "reference_manifest": payload.get("reference_manifest", []),
        "conversation_data_dir": str(conversation_data_dir),
        "sub_conversation_id": sub_conversation_id,
        "last_client_sid": None,
    }

    initial_message = build_sub_agent_instruction(metadata)

    sender = make_sub_agent_sender(task_id)
    terminal.context_manager._web_terminal_callback = sender
    client_sid = f"sub_agent::{task_id}::{int(time.time()*1000)}"
    update_sub_agent_task(task_id, last_client_sid=client_sid)
    socketio.start_background_task(process_message_task, terminal, initial_message, sender, client_sid)

    return {
        "success": True,
        "status": "running",
        "task_id": task_id,
        "message": "子智能体任务已启动",
        "deliverables_dir": str(deliverables_dir),
        "sub_conversation_id": sub_conversation_id,
    }


def send_message_to_sub_agent(task_id: str, message: str) -> Dict[str, Any]:
    terminal = sub_agent_terminals.get(task_id)
    if not terminal:
        return {"success": False, "error": "未找到该子智能体"}
    if sub_agent_tasks.get(task_id, {}).get("status") in {"completed", "failed", "timeout"}:
        return {"success": False, "error": "任务已结束，无法继续发送消息"}

    sender = make_sub_agent_sender(task_id)
    client_sid = f"sub_agent::{task_id}::{int(time.time()*1000)}"
    update_sub_agent_task(task_id, last_client_sid=client_sid)
    socketio.start_background_task(process_message_task, terminal, message, sender, client_sid)
    return {"success": True, "message": "消息已发送"}


def stop_sub_agent_task(task_id: str) -> Dict[str, Any]:
    task = sub_agent_tasks.get(task_id)
    if not task:
        return {"success": False, "error": "未找到任务"}
    client_sid = task.get("last_client_sid")
    if not client_sid or client_sid not in stop_flags:
        return {"success": False, "error": "当前没有可停止的执行"}
    stop_flags[client_sid]["stop"] = True
    update_sub_agent_task(task_id, status="stopping")
    return {"success": True, "message": "已发送停止指令"}


def force_terminate_sub_agent(task_id: str) -> Dict[str, Any]:
    cleanup_inactive_sub_agent_tasks()
    task = sub_agent_tasks.get(task_id)
    if not task:
        return {"success": False, "error": "任务不存在"}

    client_sid = task.get("last_client_sid")
    if client_sid and client_sid in stop_flags:
        stop_flags[client_sid]["stop"] = True

    terminated_tasks.add(task_id)
    terminal = sub_agent_terminals.get(task_id)
    if terminal:
        try:
            reset_system_state(terminal)
        except Exception:
            pass

    update_sub_agent_task(task_id, status="terminated")
    broadcast_sub_agent_event(task_id, "sub_agent_status", {
        "status": "terminated",
        "message": "子智能体已被手动关闭"
    })
    _purge_sub_agent_task(task_id)
    return {
        "success": True,
        "status": "terminated",
        "message": "子智能体已被手动关闭",
        "system_message": "🛑 子智能体已被手动关闭。"
    }


# ==========================================
# 子智能体任务API（主智能体调用，免登录）
# ==========================================

@app.route('/tasks', methods=['POST'])
def api_create_sub_agent_task():
    data = request.get_json(silent=True) or {}
    result = create_sub_agent_task(data)
    status_code = 200 if result.get("success") else 400
    return jsonify(result), status_code


@app.route('/tasks/<task_id>', methods=['GET'])
def api_get_sub_agent_task(task_id: str):
    task = get_task_record(task_id)
    from_store = task_id not in sub_agent_tasks
    if not task:
        return jsonify({"success": False, "status": "unknown", "message": "任务不存在"}), 404
    payload = {
        "success": True,
        "task_id": task_id,
        "status": task.get("status") or (task.get("final_result") or {}).get("status") or "unknown",
        "message": task.get("error") or task.get("completion_reason") or (task.get("final_result") or {}).get("message") or "",
        "deliverables_dir": task.get("deliverables_dir"),
        "workspace_dir": task.get("workspace_dir"),
        "references_dir": task.get("references_dir"),
        "target_project_dir": task.get("target_project_dir"),
        "summary": task.get("summary"),
        "last_tool": task.get("last_tool"),
        "updated_at": task.get("updated_at"),
        "sub_conversation_id": task.get("sub_conversation_id"),
    }
    if task.get("status") == "completed":
        payload["message"] = task.get("completion_reason") or "子智能体已完成任务"
    if from_store:
        payload["archived"] = True
    return jsonify(payload)


@app.route('/tasks/<task_id>/messages', methods=['POST'])
def api_send_message_to_sub_agent(task_id: str):
    data = request.get_json(silent=True) or {}
    message = (data.get("message") or "").strip()
    if not message:
        return jsonify({"success": False, "error": "消息内容不能为空"}), 400
    result = send_message_to_sub_agent(task_id, message)
    status_code = 200 if result.get("success") else 400
    return jsonify(result), status_code


@app.route('/tasks/<task_id>/stop', methods=['POST'])
def api_stop_sub_agent(task_id: str):
    result = stop_sub_agent_task(task_id)
    status_code = 200 if result.get("success") else 400
    return jsonify(result), status_code


@app.route('/tasks/<task_id>/terminate', methods=['POST'])
def api_terminate_sub_agent(task_id: str):
    result = force_terminate_sub_agent(task_id)
    status_code = 200 if result.get("success") else 400
    return jsonify(result), status_code


@app.route('/tasks/<task_id>/conversation', methods=['GET'])
def api_get_sub_agent_conversation(task_id: str):
    info = get_task_record(task_id)
    from_store = task_id not in sub_agent_tasks
    if not info:
        return jsonify({"success": False, "error": "任务不存在"}), 404
    conv_id = info.get("sub_conversation_id") or info.get("conversation_id")
    if not conv_id:
        return jsonify({"success": True, "conversation_id": None, "messages": []})
    conv_file = None
    if not from_store:
        data_dir = Path(info.get("conversation_data_dir") or "").expanduser()
        candidate = data_dir / "conversations" / f"{conv_id}.json"
        if candidate.exists():
            conv_file = candidate
    if conv_file is None:
        conv_file = find_sub_agent_conversation_file(conv_id)
        if conv_file is None:
            return jsonify({"success": True, "conversation_id": conv_id, "messages": []})
    try:
        content = json.loads(conv_file.read_text(encoding="utf-8"))
    except Exception as exc:
        return jsonify({"success": False, "error": f"读取对话失败: {exc}"}), 500
    messages = content.get("messages", []) if isinstance(content, dict) else []
    return jsonify({
        "success": True,
        "conversation_id": conv_id,
        "messages": messages
    })


@app.route('/sub_agent/conversations/<conv_id>', methods=['GET'])
def api_get_archived_sub_agent_conversation(conv_id: str):
    """按conversation_id直接读取历史子智能体对话文件。"""
    normalized = _normalize_conversation_id(conv_id)
    file_path = find_sub_agent_conversation_file(normalized)
    if not file_path or not file_path.exists():
        return jsonify({"success": False, "error": "对话不存在"}), 404
    try:
        content = json.loads(file_path.read_text(encoding="utf-8"))
    except Exception as exc:
        return jsonify({"success": False, "error": f"读取对话失败: {exc}"}), 500
    messages = content.get("messages", []) if isinstance(content, dict) else []
    return jsonify({
        "success": True,
        "conversation_id": normalized,
        "messages": messages
    })


@app.route('/tasks/<task_id>/files', methods=['GET'])
def api_get_sub_agent_files(task_id: str):
    """返回子智能体工作目录的文件树，只读展示使用。"""
    task = get_task_record(task_id)
    if not task:
        return jsonify({"success": False, "error": "任务不存在"}), 404
    workspace_dir = task.get("workspace_dir")
    if not workspace_dir:
        return jsonify({"success": False, "error": "任务未设置工作目录"}), 400
    try:
        tree = build_workspace_tree(workspace_dir)
        return jsonify({"success": True, "data": tree})
    except Exception as exc:
        return jsonify({"success": False, "error": f'构建文件树失败: {exc}'}), 500


@app.route('/sub_agent/<task_id>')
def serve_sub_agent_page(task_id: str):
    """子智能体监控页面（仅任务ID）。"""
    actual_id, parent_conv, sub_conv = _resolve_task_by_conv(None, task_id)
    return _render_sub_agent_index(actual_id, parent_conv, sub_conv)


@app.route('/<conv_slug>/sub_agent_<task_label>')
def serve_sub_agent_with_conv(conv_slug: str, task_label: str):
    """带对话ID的子智能体页面 /conv_slug/sub_agent_<label>"""
    task_id, parent_conv, sub_conv = _resolve_task_by_conv(conv_slug, f"sub_agent_{task_label}" if not task_label.startswith("sub_agent") else task_label)
    return _render_sub_agent_index(task_id, parent_conv, sub_conv)


@app.route('/<conv_slug>+<task_label>')
def serve_sub_agent_plus(conv_slug: str, task_label: str):
    """带 + 分隔的子智能体页面 /conv_slug+sub_agent1"""
    task_id, parent_conv, sub_conv = _resolve_task_by_conv(conv_slug, task_label)
    return _render_sub_agent_index(task_id, parent_conv, sub_conv)


@app.route('/api/conversations/<conversation_id>/duplicate', methods=['POST'])
@api_login_required
@with_terminal
def duplicate_conversation(conversation_id, terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """复制指定对话，生成新的对话副本"""

    try:
        result = terminal.context_manager.duplicate_conversation(conversation_id)

        if not result.get("success"):
            status_code = 404 if "不存在" in result.get("error", "") else 400
            return jsonify(result), status_code

        new_conversation_id = result["duplicate_conversation_id"]
        load_result = terminal.load_conversation(new_conversation_id)

        if load_result.get("success"):
            socketio.emit('conversation_list_update', {
                'action': 'duplicated',
                'conversation_id': new_conversation_id
            }, room=f"user_{username}")
            socketio.emit('conversation_changed', {
                'conversation_id': new_conversation_id,
                'title': load_result.get('title', '复制的对话'),
                'messages_count': load_result.get('messages_count', 0)
            }, room=f"user_{username}")
            socketio.emit('conversation_loaded', {
                'conversation_id': new_conversation_id,
                'clear_ui': True
            }, room=f"user_{username}")

        response_payload = {
            "success": True,
            "duplicate_conversation_id": new_conversation_id,
            "load_result": load_result
        }

        return jsonify(response_payload)

    except Exception as e:
        print(f"[API] 复制对话错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e),
            "message": "复制对话时发生异常"
        }), 500

@app.route('/api/conversations/statistics', methods=['GET'])
@api_login_required
@with_terminal
def get_conversations_statistics(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """获取对话统计信息"""
    try:
        stats = terminal.context_manager.get_conversation_statistics()
        
        return jsonify({
            "success": True,
            "data": stats
        })
            
    except Exception as e:
        print(f"[API] 获取对话统计错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e),
            "message": "获取对话统计时发生异常"
        }), 500

@app.route('/api/conversations/current', methods=['GET'])
@api_login_required
@with_terminal
def get_current_conversation(terminal: WebTerminal, workspace: UserWorkspace, username: str):
    """获取当前对话信息"""
    current_id = terminal.context_manager.current_conversation_id
    
    # 如果是临时ID，返回空的对话信息
    if not current_id or current_id.startswith('temp_'):
        return jsonify({
            "success": True,
            "data": {
                "id": current_id,
                "title": "新对话",
                "messages_count": 0,
                "is_temporary": True
            }
        })
    
    # 如果是真实的对话ID，查找对话数据
    try:
        conversation_data = terminal.context_manager.conversation_manager.load_conversation(current_id)
        if conversation_data:
            return jsonify({
                "success": True,
                "data": {
                    "id": current_id,
                    "title": conversation_data.get("title", "未知对话"),
                    "messages_count": len(conversation_data.get("messages", [])),
                    "is_temporary": False
                }
            })
        else:
            return jsonify({
                "success": False,
                "error": "对话不存在"
            }), 404
            
    except Exception as e:
        print(f"[API] 获取当前对话错误: {e}")
        return jsonify({
            "success": False,
            "error": str(e)
        }), 500
    
def process_message_task(terminal: WebTerminal, message: str, sender, client_sid):
    """在后台处理消息任务"""
    try:
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
        
        # 创建可取消的任务
        task = loop.create_task(handle_task_with_sender(terminal, message, sender, client_sid))
        
        # 存储任务引用，以便取消
        if client_sid not in stop_flags:
            stop_flags[client_sid] = {'stop': False, 'task': task, 'terminal': terminal}
        else:
            stop_flags[client_sid]['task'] = task
            stop_flags[client_sid]['terminal'] = terminal
        
        task_id = getattr(terminal, "task_id", None)
        try:
            loop.run_until_complete(task)
        except asyncio.CancelledError:
            debug_log(f"任务 {client_sid} 被成功取消")
            sender('task_stopped', {
                'message': '任务已停止',
                'reason': 'user_requested'
            })
            reset_system_state(terminal)
        finally:
            if task_id:
                terminated_tasks.discard(task_id)
        
        loop.close()
    except Exception as e:
        # 【新增】错误时确保对话状态不丢失
        try:
            if terminal and terminal.context_manager:
                # 尝试保存当前对话状态
                terminal.context_manager.auto_save_conversation()
                debug_log("错误恢复：对话状态已保存")
        except Exception as save_error:
            debug_log(f"错误恢复：保存对话状态失败: {save_error}")
        
        # 原有的错误处理逻辑
        print(f"[Task] 错误: {e}")
        debug_log(f"任务处理错误: {e}")
        import traceback
        traceback.print_exc()
        sender('error', {'message': str(e)})
        sender('task_complete', {
            'total_iterations': 0,
            'total_tool_calls': 0,
            'auto_fix_attempts': 0,
            'error': str(e)
        })

    finally:
        # 清理任务引用
        if client_sid in stop_flags and isinstance(stop_flags[client_sid], dict):
            stop_flags.pop(client_sid, None)

def detect_malformed_tool_call(text):
    """检测文本中是否包含格式错误的工具调用"""
    # 检测多种可能的工具调用格式
    patterns = [
        r'执行工具[:：]\s*\w+<.*?tool.*?sep.*?>',  # 执行工具: xxx<｜tool▼sep｜>
        r'<\|?tool[_▼]?call[_▼]?start\|?>',  # <｜tool_call_start｜>
        r'```tool[_\s]?call',  # ```tool_call 或 ```tool call
        r'{\s*"tool":\s*"[^"]+",\s*"arguments"',  # JSON格式的工具调用
        r'function_calls?:\s*\[?\s*{',  # function_call: [{
    ]
    
    for pattern in patterns:
        if re.search(pattern, text, re.IGNORECASE):
            return True
    
    # 检测特定的工具名称后跟JSON
    tool_names = ['create_file', 'read_file', 'modify_file', 'delete_file', 
                  'append_to_file', 'terminal_session', 'terminal_input', 'web_search', 
                  'extract_webpage', 'save_webpage',
                  'run_python', 'run_command', 'focus_file', 'unfocus_file', 'sleep']
    for tool in tool_names:
        if tool in text and '{' in text:
            # 可能是工具调用但格式错误
            return True
            
    return False

async def handle_task_with_sender(terminal: WebTerminal, message, sender, client_sid):
    """处理任务并发送消息（子智能体Web终端）"""
    web_terminal = terminal
    finish_called = False
    finish_prompt_sent = False
    
    # 如果是思考模式，重置状态
    if web_terminal.thinking_mode:
        web_terminal.api_client.start_new_task()
    
    # 添加到对话历史
    web_terminal.context_manager.add_conversation("user", message)
    
    # === 子智能体版本：跳过额外统计 ===
    
    # 构建上下文和消息（用于API调用）
    context = web_terminal.build_context()
    messages = web_terminal.build_messages(context, message)
    tools = web_terminal.define_tools()
    
    # 开始新的AI消息
    sender('ai_message_start', {})
    
    # 增量保存相关变量
    has_saved_thinking = False  # 是否已保存思考内容
    accumulated_response = ""   # 累积的响应内容
    is_first_iteration = True   # 是否是第一次迭代
    
    # 统计和限制变量
    total_iterations = 0
    total_tool_calls = 0
    consecutive_same_tool = defaultdict(int)
    last_tool_name = ""
    auto_fix_attempts = 0
    last_tool_call_time = 0
    
    # 设置最大迭代次数
    max_iterations = MAX_ITERATIONS_PER_TASK
    
    pending_append = None  # {"path": str, "tool_call_id": str, "buffer": str, ...}
    append_probe_buffer = ""
    pending_modify = None  # {"path": str, "tool_call_id": str, "buffer": str, ...}
    modify_probe_buffer = ""
    
    async def finalize_pending_append(response_text: str, stream_completed: bool, finish_reason: str = None) -> Dict:
        """在流式输出结束后处理追加写入"""
        nonlocal pending_append, append_probe_buffer
        
        result = {
            "handled": False,
            "success": False,
            "summary": None,
            "summary_message": None,
            "tool_content": None,
            "tool_call_id": None,
            "path": None,
            "forced": False,
            "error": None,
            "assistant_content": response_text,
            "lines": 0,
            "bytes": 0,
            "finish_reason": finish_reason,
            "appended_content": "",
            "assistant_metadata": None
        }
        
        if not pending_append:
            return result
        
        state = pending_append
        path = state.get("path")
        tool_call_id = state.get("tool_call_id")
        buffer = state.get("buffer", "")
        start_marker = state.get("start_marker")
        end_marker = state.get("end_marker")
        start_idx = state.get("content_start")
        end_idx = state.get("end_index")
        
        display_id = state.get("display_id")
        
        result.update({
            "handled": True,
            "path": path,
            "tool_call_id": tool_call_id,
            "display_id": display_id
        })
        
        if path is None or tool_call_id is None:
            error_msg = "append_to_file 状态不完整，缺少路径或ID。"
            debug_log(error_msg)
            result["error"] = error_msg
            result["summary_message"] = error_msg
            result["tool_content"] = json.dumps({
                "success": False,
                "error": error_msg
            }, ensure_ascii=False)
            if display_id:
                sender('update_action', {
                    'id': display_id,
                    'status': 'failed',
                    'preparing_id': tool_call_id,
                    'message': error_msg
                })
            pending_append = None
            return result
        
        if start_idx is None:
            error_msg = f"未检测到格式正确的开始标识 {start_marker}。"
            debug_log(error_msg)
            result["error"] = error_msg
            result["summary_message"] = error_msg
            result["tool_content"] = json.dumps({
                "success": False,
                "path": path,
                "error": error_msg
            }, ensure_ascii=False)
            if display_id:
                sender('update_action', {
                    'id': display_id,
                    'status': 'failed',
                    'preparing_id': tool_call_id,
                    'message': error_msg
                })
            pending_append = None
            return result
        
        forced = False
        if end_idx is None:
            forced = True
            # 查找下一个<<<，否则使用整个缓冲结尾
            remaining = buffer[start_idx:]
            next_marker = remaining.find("<<<", len(end_marker))
            if next_marker != -1:
                end_idx = start_idx + next_marker
            else:
                end_idx = len(buffer)
        
        content = buffer[start_idx:end_idx]
        if content.startswith('\n'):
            content = content[1:]
        
        if not content:
            error_msg = "未检测到需要追加的内容，请严格按照<<<APPEND:path>>>...<<<END_APPEND>>>格式输出。"
            debug_log(error_msg)
            result["error"] = error_msg
            result["forced"] = forced
            result["tool_content"] = json.dumps({
                "success": False,
                "path": path,
                "error": error_msg
            }, ensure_ascii=False)
            if display_id:
                sender('update_action', {
                    'id': display_id,
                    'status': 'failed',
                    'preparing_id': tool_call_id,
                    'message': error_msg
                })
            pending_append = None
            return result
        
        assistant_message_lines = []
        if start_marker:
            assistant_message_lines.append(start_marker)
        assistant_message_lines.append(content)
        if not forced and end_marker:
            assistant_message_lines.append(end_marker)
        assistant_message_text = "\n".join(assistant_message_lines)
        result["assistant_content"] = assistant_message_text
        assistant_metadata = {
            "append_payload": {
                "path": path,
                "tool_call_id": tool_call_id,
                "forced": forced,
                "has_end_marker": not forced
            }
        }
        result["assistant_metadata"] = assistant_metadata
        
        write_result = web_terminal.file_manager.append_file(path, content)
        if write_result.get("success"):
            bytes_written = len(content.encode('utf-8'))
            line_count = content.count('\n')
            if content and not content.endswith('\n'):
                line_count += 1
            
            summary = f"已向 {path} 追加 {line_count} 行（{bytes_written} 字节）"
            if forced:
                summary += "。未检测到 <<<END_APPEND>>> 标记，系统已在流结束处完成写入。如内容未完成，请重新调用 append_to_file 并按标准格式补充；如已完成，可继续后续步骤。"
            
            result.update({
                "success": True,
                "summary": summary,
                "summary_message": summary,
                "forced": forced,
                "lines": line_count,
                "bytes": bytes_written,
                "appended_content": content,
                "tool_content": json.dumps({
                    "success": True,
                    "path": path,
                    "lines": line_count,
                    "bytes": bytes_written,
                    "forced": forced,
                    "message": summary,
                    "finish_reason": finish_reason
                }, ensure_ascii=False)
            })
            
            assistant_meta_payload = result["assistant_metadata"]["append_payload"]
            assistant_meta_payload["lines"] = line_count
            assistant_meta_payload["bytes"] = bytes_written
            assistant_meta_payload["success"] = True
            
            summary_payload = {
                "success": True,
                "path": path,
                "lines": line_count,
                "bytes": bytes_written,
                "forced": forced,
                "message": summary
            }
            
            if display_id:
                sender('update_action', {
                    'id': display_id,
                    'status': 'completed',
                    'result': summary_payload,
                    'preparing_id': tool_call_id,
                    'message': summary
                })
            
            # 更新聚焦文件内容
            if path in web_terminal.focused_files:
                refreshed = web_terminal.file_manager.read_file(path)
                if refreshed.get("success"):
                    web_terminal.focused_files[path] = refreshed["content"]
                    debug_log(f"聚焦文件已刷新: {path}")
            
            debug_log(f"追加写入完成: {summary}")
        else:
            error_msg = write_result.get("error", "追加写入失败")
            result.update({
                "error": error_msg,
                "summary_message": error_msg,
                "forced": forced,
                "appended_content": content,
                "tool_content": json.dumps({
                    "success": False,
                    "path": path,
                    "error": error_msg,
                    "finish_reason": finish_reason
                }, ensure_ascii=False)
            })
            debug_log(f"追加写入失败: {error_msg}")
            
            if result["assistant_metadata"]:
                assistant_meta_payload = result["assistant_metadata"]["append_payload"]
                assistant_meta_payload["lines"] = content.count('\n') + (0 if content.endswith('\n') or not content else 1)
                assistant_meta_payload["bytes"] = len(content.encode('utf-8'))
                assistant_meta_payload["success"] = False
            
            failure_payload = {
                "success": False,
                "path": path,
                "error": error_msg,
                "forced": forced
            }
            
            if display_id:
                sender('update_action', {
                    'id': display_id,
                    'status': 'completed',
                    'result': failure_payload,
                    'preparing_id': tool_call_id,
                    'message': error_msg
                })
        
        pending_append = None
        append_probe_buffer = ""
        if hasattr(web_terminal, "pending_append_request"):
            web_terminal.pending_append_request = None
        return result
    
    async def finalize_pending_modify(response_text: str, stream_completed: bool, finish_reason: str = None) -> Dict:
        """在流式输出结束后处理修改写入"""
        nonlocal pending_modify, modify_probe_buffer
        
        result = {
            "handled": False,
            "success": False,
            "path": None,
            "tool_call_id": None,
            "display_id": None,
            "total_blocks": 0,
            "completed_blocks": [],
            "failed_blocks": [],
            "forced": False,
            "details": [],
            "error": None,
            "assistant_content": response_text,
            "assistant_metadata": None,
            "tool_content": None,
            "summary_message": None,
            "finish_reason": finish_reason
        }
        
        if not pending_modify:
            return result
        
        state = pending_modify
        path = state.get("path")
        tool_call_id = state.get("tool_call_id")
        display_id = state.get("display_id")
        start_marker = state.get("start_marker")
        end_marker = state.get("end_marker")
        buffer = state.get("buffer", "")
        raw_buffer = state.get("raw_buffer", "")
        end_index = state.get("end_index")
        
        result.update({
            "handled": True,
            "path": path,
            "tool_call_id": tool_call_id,
            "display_id": display_id
        })
        
        if not state.get("start_seen"):
            error_msg = "未检测到格式正确的 <<<MODIFY:path>>> 标记。"
            debug_log(error_msg)
            result["error"] = error_msg
            result["summary_message"] = error_msg
            result["tool_content"] = json.dumps({
                "success": False,
                "path": path,
                "error": error_msg,
                "finish_reason": finish_reason
            }, ensure_ascii=False)
            if display_id:
                sender('update_action', {
                    'id': display_id,
                    'status': 'failed',
                    'preparing_id': tool_call_id,
                    'message': error_msg
                })
            if hasattr(web_terminal, "pending_modify_request"):
                web_terminal.pending_modify_request = None
            pending_modify = None
            modify_probe_buffer = ""
            return result
        
        forced = end_index is None
        apply_text = buffer if forced else buffer[:end_index]
        raw_content = raw_buffer if forced else raw_buffer[:len(start_marker) + end_index + len(end_marker)]
        if raw_content:
            result["assistant_content"] = raw_content
        
        blocks_info = []
        block_reports = {}
        detected_indices = set()
        block_pattern = re.compile(r"\[replace:(\d+)\](.*?)\[/replace\]", re.DOTALL)
        structure_warnings: List[str] = []
        structure_detail_entries: List[Dict] = []

        def record_structure_warning(message: str, hint: Optional[str] = None):
            """记录结构性缺陷，便于给出更具体的反馈。"""
            if message in structure_warnings:
                return
            structure_warnings.append(message)
            structure_detail_entries.append({
                "index": 0,
                "status": "failed",
                "reason": message,
                "removed_lines": 0,
                "added_lines": 0,
                "hint": hint or "请严格按照模板输出：[replace:n] + <<OLD>>/<<NEW>> + [/replace]，并使用 <<<END_MODIFY>>> 收尾。"
            })
        
        def extract_segment(body: str, tag: str):
            marker = f"<<{tag}>>"
            end_tag = "<<END>>"
            start_pos = body.find(marker)
            if start_pos == -1:
                return None, f"缺少 {marker}"
            start_pos += len(marker)
            if body[start_pos:start_pos+2] == "\r\n":
                start_pos += 2
            elif body[start_pos:start_pos+1] == "\n":
                start_pos += 1
            end_pos = body.find(end_tag, start_pos)
            if end_pos == -1:
                return None, f"缺少 {end_tag}"
            segment = body[start_pos:end_pos]
            return segment, None
        
        for match in block_pattern.finditer(apply_text):
            try:
                index = int(match.group(1))
            except ValueError:
                continue
            body = match.group(2)
            if index in detected_indices:
                continue
            detected_indices.add(index)
            block_reports[index] = {
                "index": index,
                "status": "pending",
                "reason": None,
                "removed_lines": 0,
                "added_lines": 0,
                "hint": None
            }
            old_content, old_error = extract_segment(body, "OLD")
            new_content, new_error = extract_segment(body, "NEW")
            if old_error or new_error:
                reason = old_error or new_error
                block_reports[index]["status"] = "failed"
                block_reports[index]["reason"] = reason
            blocks_info.append({
                "index": index,
                "old": old_content,
                "new": new_content,
                "error": old_error or new_error
            })
        
        if not blocks_info:
            has_replace_start = bool(re.search(r"\[replace:\s*\d+\]", apply_text))
            has_replace_end = "[/replace]" in apply_text
            has_old_tag = "<<OLD>>" in apply_text
            has_new_tag = "<<NEW>>" in apply_text

            if has_replace_start and not has_replace_end:
                record_structure_warning("检测到 [replace:n] 标记但缺少对应的 [/replace] 结束标记。")
            if has_replace_end and not has_replace_start:
                record_structure_warning("检测到 [/replace] 结束标记但缺少对应的 [replace:n] 起始标记。")

            old_tags = len(re.findall(r"<<OLD>>", apply_text))
            completed_old_tags = len(re.findall(r"<<OLD>>[\s\S]*?<<END>>", apply_text))
            if old_tags and completed_old_tags < old_tags:
                record_structure_warning("检测到 <<OLD>> 段落但未看到对应的 <<END>> 结束标记。")

            new_tags = len(re.findall(r"<<NEW>>", apply_text))
            completed_new_tags = len(re.findall(r"<<NEW>>[\s\S]*?<<END>>", apply_text))
            if new_tags and completed_new_tags < new_tags:
                record_structure_warning("检测到 <<NEW>> 段落但未看到对应的 <<END>> 结束标记。")

            if (has_replace_start or has_replace_end or has_old_tag or has_new_tag) and not structure_warnings:
                record_structure_warning("检测到部分补丁标记，但整体结构不完整，请严格按照模板填写所有标记。")

        total_blocks = len(blocks_info)
        result["total_blocks"] = total_blocks
        if forced:
            debug_log("未检测到 <<<END_MODIFY>>>，将在流结束处执行已识别的修改块。")
            result["forced"] = True
        
        blocks_to_apply = [
            {"index": block["index"], "old": block["old"], "new": block["new"]}
            for block in blocks_info
            if block["error"] is None and block["old"] is not None and block["new"] is not None
        ]
        
        # 记录格式残缺的块
        for block in blocks_info:
            if block["error"]:
                idx = block["index"]
                block_reports[idx]["status"] = "failed"
                block_reports[idx]["reason"] = block["error"]
                block_reports[idx]["hint"] = "请检查补丁块的 OLD/NEW 标记是否完整，必要时复用 terminal_snapshot 或终端命令重新调整。"
        
        apply_result = {}
        if blocks_to_apply:
            apply_result = web_terminal.file_manager.apply_modify_blocks(path, blocks_to_apply)
        else:
            apply_result = {"success": False, "completed": [], "failed": [], "results": [], "write_performed": False, "error": None}
        
        block_result_map = {item["index"]: item for item in apply_result.get("results", [])}
        
        for block in blocks_info:
            idx = block["index"]
            report = block_reports.get(idx)
            if report is None:
                continue
            if report["status"] == "failed":
                continue
            block_apply = block_result_map.get(idx)
            if not block_apply:
                report["status"] = "failed"
                report["reason"] = "未执行，可能未找到匹配原文"
                report["hint"] = report.get("hint") or "请确认 OLD 文本与文件内容完全一致；若多次失败，可改用终端命令/Python 进行精准替换。"
                continue
            status = block_apply.get("status")
            report["removed_lines"] = block_apply.get("removed_lines", 0)
            report["added_lines"] = block_apply.get("added_lines", 0)
            if block_apply.get("hint"):
                report["hint"] = block_apply.get("hint")
            if status == "success":
                report["status"] = "completed"
            elif status == "not_found":
                report["status"] = "failed"
                report["reason"] = block_apply.get("reason") or "未找到匹配的原文"
                if not report.get("hint"):
                    report["hint"] = "请使用 terminal_snapshot/grep -n 校验原文，或在说明后改用 run_command/python 精确替换。"
            else:
                report["status"] = "failed"
                report["reason"] = block_apply.get("reason") or "替换失败"
                if not report.get("hint"):
                    report["hint"] = block_apply.get("hint") or "若多次尝试仍失败，可考虑利用终端命令或 Python 小脚本完成此次修改。"
        
        completed_blocks = sorted([idx for idx, rep in block_reports.items() if rep["status"] == "completed"])
        failed_blocks = sorted([idx for idx, rep in block_reports.items() if rep["status"] != "completed"])
        
        result["completed_blocks"] = completed_blocks
        result["failed_blocks"] = failed_blocks
        details = sorted(block_reports.values(), key=lambda x: x["index"])
        if structure_detail_entries:
            details = structure_detail_entries + details
        result["details"] = details
        
        summary_parts = []
        if total_blocks == 0:
            summary_parts.append("未检测到有效的修改块，未执行任何修改。")
            summary_parts.extend(structure_warnings)
        else:
            if not completed_blocks and failed_blocks:
                summary_parts.append(f"共检测到 {total_blocks} 个修改块，全部未执行。")
            elif completed_blocks and not failed_blocks:
                summary_parts.append(f"共 {total_blocks} 个修改块全部完成。")
            else:
                summary_parts.append(
                    f"共检测到 {total_blocks} 个修改块，其中成功 {len(completed_blocks)} 个，失败 {len(failed_blocks)} 个。"
                )
        if forced:
            summary_parts.append("未检测到 <<<END_MODIFY>>> 标记，系统已在流结束处执行补丁。")
        if apply_result.get("error"):
            summary_parts.append(apply_result["error"])
        
        matching_note = "提示：补丁匹配基于完整文本，包含注释和空白符，请确保 <<<OLD>>> 段落与文件内容逐字一致。如果修改成功，请忽略，如果失败，请明确原文后再次尝试。"
        summary_parts.append(matching_note)
        summary_message = " ".join(summary_parts).strip()
        result["summary_message"] = summary_message
        result["success"] = bool(completed_blocks) and not failed_blocks and apply_result.get("error") is None
        
        tool_payload = {
            "success": result["success"],
            "path": path,
            "total_blocks": total_blocks,
            "completed": completed_blocks,
            "failed": [
                {
                    "index": rep["index"],
                    "reason": rep.get("reason"),
                    "hint": rep.get("hint")
                }
                for rep in result["details"] if rep["status"] != "completed"
            ],
            "forced": forced,
            "message": summary_message,
            "finish_reason": finish_reason,
            "details": result["details"]
        }
        if apply_result.get("error"):
            tool_payload["error"] = apply_result["error"]
        
        result["tool_content"] = json.dumps(tool_payload, ensure_ascii=False)
        result["assistant_metadata"] = {
            "modify_payload": {
                "path": path,
                "total_blocks": total_blocks,
                "completed": completed_blocks,
                "failed": failed_blocks,
                "forced": forced,
                "details": result["details"]
            }
        }
        
        if display_id:
            sender('update_action', {
                'id': display_id,
                'status': 'completed' if result["success"] else 'failed',
                'result': tool_payload,
                'preparing_id': tool_call_id,
                'message': summary_message
            })
        
        if path in web_terminal.focused_files and tool_payload.get("success"):
            refreshed = web_terminal.file_manager.read_file(path)
            if refreshed.get("success"):
                web_terminal.focused_files[path] = refreshed["content"]
                debug_log(f"聚焦文件已刷新: {path}")
        
        pending_modify = None
        modify_probe_buffer = ""
        if hasattr(web_terminal, "pending_modify_request"):
            web_terminal.pending_modify_request = None
        return result

    async def process_sub_agent_updates(
        messages: List[Dict],
        inline: bool = False,
        after_tool_call_id: Optional[str] = None
    ):
        """轮询子智能体任务并通知前端，并把结果插入当前对话上下文。"""
        manager = getattr(web_terminal, "sub_agent_manager", None)
        if not manager:
            return
        try:
            updates = manager.poll_updates()
            debug_log(f"[SubAgent] poll inline={inline} updates={len(updates)}")
        except Exception as exc:
            debug_log(f"子智能体状态检查失败: {exc}")
            return
        for update in updates:
            message = update.get("system_message")
            if not message:
                continue
            task_id = update.get("task_id")
            debug_log(f"[SubAgent] update task={task_id} inline={inline} msg={message}")
            web_terminal._record_sub_agent_message(message, task_id, inline=inline)
            debug_log(f"[SubAgent] recorded task={task_id}, 计算插入位置")

            insert_index = len(messages)
            if after_tool_call_id:
                for idx, msg in enumerate(messages):
                    if msg.get("role") == "tool" and msg.get("tool_call_id") == after_tool_call_id:
                        insert_index = idx + 1
                        break

            messages.insert(insert_index, {
                "role": "system",
                "content": message,
                "metadata": {"sub_agent_notice": True, "inline": inline, "task_id": task_id}
            })
            debug_log(f"[SubAgent] 插入系统消息位置: {insert_index}")
            sender('system_message', {
                'content': message,
                'inline': inline
            })
    
    for iteration in range(max_iterations):
        total_iterations += 1
        debug_log(f"\n--- 迭代 {iteration + 1}/{max_iterations} 开始 ---")
        task_id = getattr(web_terminal, "task_id", None)
        if task_id and task_id in terminated_tasks:
            sender('system_message', {'content': '🛑 子智能体已被手动关闭。'})
            break
        
        # 检查是否超过总工具调用限制
        if total_tool_calls >= MAX_TOTAL_TOOL_CALLS:
            debug_log(f"已达到最大工具调用次数限制 ({MAX_TOTAL_TOOL_CALLS})")
            sender('system_message', {
                'content': f'⚠️ 已达到最大工具调用次数限制 ({MAX_TOTAL_TOOL_CALLS})，任务结束。'
            })
            break
        
        full_response = ""
        tool_calls = []
        current_thinking = ""
        detected_tools = {}
        
        # 状态标志
        in_thinking = False
        thinking_started = False
        thinking_ended = False
        text_started = False
        text_has_content = False
        TEXT_BUFFER_MAX_CHARS = 1
        TEXT_BUFFER_MAX_INTERVAL = 0.0
        TEXT_BUFFER_FLUSH_CHARS = 1
        text_chunk_buffer: deque[str] = deque()
        text_chunk_buffer_size = 0
        last_text_flush_time = time.time()
        TEXT_BUFFER_CHAR_DELAY = 0.02

        def _drain_text_buffer(force: bool = False) -> bool:
            nonlocal text_chunk_buffer, text_chunk_buffer_size, last_text_flush_time
            if not text_chunk_buffer:
                return False

            drain_all = force or TEXT_BUFFER_MAX_INTERVAL == 0.0
            sent = False
            while text_chunk_buffer:
                now = time.time()
                should_flush = (
                    force
                    or text_chunk_buffer_size >= TEXT_BUFFER_MAX_CHARS
                    or TEXT_BUFFER_MAX_INTERVAL == 0.0
                    or (TEXT_BUFFER_MAX_INTERVAL > 0 and (now - last_text_flush_time) >= TEXT_BUFFER_MAX_INTERVAL)
                )
                if not should_flush:
                    break

                batch_size = text_chunk_buffer_size if drain_all else max(1, min(text_chunk_buffer_size, TEXT_BUFFER_FLUSH_CHARS or 1))
                pieces: List[str] = []
                remaining = batch_size

                while text_chunk_buffer and remaining > 0:
                    chunk = text_chunk_buffer.popleft()
                    chunk_len = len(chunk)
                    if chunk_len <= remaining:
                        pieces.append(chunk)
                        remaining -= chunk_len
                    else:
                        pieces.append(chunk[:remaining])
                        text_chunk_buffer.appendleft(chunk[remaining:])
                        chunk_len = remaining
                        remaining = 0
                    text_chunk_buffer_size -= chunk_len

                if not pieces:
                    break

                sender('text_chunk', {'content': "".join(pieces)})
                last_text_flush_time = now
                sent = True

                if not drain_all:
                    break
            return sent

        async def flush_text_buffer(force: bool = False):
            sent = _drain_text_buffer(force)
            if sent and not force and TEXT_BUFFER_CHAR_DELAY > 0:
                await asyncio.sleep(TEXT_BUFFER_CHAR_DELAY)
        text_streaming = False
        
        # 计数器
        chunk_count = 0
        reasoning_chunks = 0
        content_chunks = 0
        tool_chunks = 0
        append_break_triggered = False
        append_result = {"handled": False}
        modify_break_triggered = False
        modify_result = {"handled": False}
        last_finish_reason = None
        
        # 获取是否显示思考
        should_show_thinking = web_terminal.api_client.get_current_thinking_mode()
        debug_log(f"思考模式: {should_show_thinking}")
        
        print(f"[API] 第{iteration + 1}次调用 (总工具调用: {total_tool_calls}/{MAX_TOTAL_TOOL_CALLS})")
        
        # 收集流式响应
        async for chunk in web_terminal.api_client.chat(messages, tools, stream=True):
            chunk_count += 1
            
            # 检查停止标志
            client_stop_info = stop_flags.get(client_sid)
            if client_stop_info:
                stop_requested = client_stop_info.get('stop', False) if isinstance(client_stop_info, dict) else client_stop_info
                if stop_requested:
                    debug_log(f"检测到停止请求，中断流处理")
                    if pending_append:
                        append_result = await finalize_pending_append(full_response, False, finish_reason="user_stop")
                        break
                    if pending_modify:
                        modify_result = await finalize_pending_modify(full_response, False, finish_reason="user_stop")
                        break
            
            if "choices" not in chunk:
                debug_log(f"Chunk {chunk_count}: 无choices字段")
                continue
                
            choice = chunk["choices"][0]
            delta = choice.get("delta", {})
            finish_reason = choice.get("finish_reason")
            if finish_reason:
                last_finish_reason = finish_reason
            
            # 处理思考内容
            if "reasoning_content" in delta:
                reasoning_content = delta["reasoning_content"]
                if reasoning_content:
                    reasoning_chunks += 1
                    debug_log(f"  思考内容 #{reasoning_chunks}: {len(reasoning_content)} 字符")
                    
                    if should_show_thinking:
                        if not thinking_started:
                            in_thinking = True
                            thinking_started = True
                            sender('thinking_start', {})
                            await asyncio.sleep(0.05)
                        
                        current_thinking += reasoning_content
                        sender('thinking_chunk', {'content': reasoning_content})
            
            # 处理正常内容
            if "content" in delta:
                content = delta["content"]
                if content:
                    content_chunks += 1
                    debug_log(f"  正式内容 #{content_chunks}: {repr(content[:100] if content else 'None')}")
                    
                    # 通过文本内容提前检测工具调用意图
                    if not detected_tools:
                        # 检测常见的工具调用模式
                        tool_patterns = [
                            (r'(创建|新建|生成).*(文件|file)', 'create_file'),
                            (r'(读取|查看|打开).*(文件|file)', 'read_file'),
                            (r'(修改|编辑|更新).*(文件|file)', 'modify_file'),
                            (r'(删除|移除).*(文件|file)', 'delete_file'),
                            (r'(搜索|查找|search)', 'web_search'),
                            (r'(执行|运行).*(Python|python|代码)', 'run_python'),
                            (r'(执行|运行).*(命令|command)', 'run_command'),
                            (r'(等待|sleep|延迟)', 'sleep'),
                            (r'(聚焦|focus).*(文件|file)', 'focus_file'),
                            (r'(终端|terminal|会话|session)', 'terminal_session'),
                        ]
                        
                        for pattern, tool_name in tool_patterns:
                            if re.search(pattern, content, re.IGNORECASE):
                                early_tool_id = f"early_{tool_name}_{time.time()}"
                                if early_tool_id not in detected_tools:
                                    sender('tool_hint', {
                                        'id': early_tool_id,
                                        'name': tool_name,
                                        'message': f'检测到可能需要调用 {tool_name}...',
                                        'confidence': 'low'
                                    })
                                    detected_tools[early_tool_id] = tool_name
                                    debug_log(f"    ⚡ 提前检测到工具意图: {tool_name}")
                                    break
                    
                    if in_thinking and not thinking_ended:
                        in_thinking = False
                        thinking_ended = True
                        sender('thinking_end', {'full_content': current_thinking})
                        await asyncio.sleep(0.1)
                        
                        # ===== 增量保存：保存思考内容 =====
                        if current_thinking and not has_saved_thinking and is_first_iteration:
                            thinking_content = f"<think>\n{current_thinking}\n</think>"
                            web_terminal.context_manager.add_conversation("assistant", thinking_content)
                            has_saved_thinking = True
                            debug_log(f"💾 增量保存：思考内容 ({len(current_thinking)} 字符)")
                    
                    expecting_modify = bool(pending_modify) or bool(getattr(web_terminal, "pending_modify_request", None))
                    expecting_append = bool(pending_append) or bool(getattr(web_terminal, "pending_append_request", None))

                    if pending_modify:
                        if not pending_modify.get("start_seen"):
                            probe_buffer = pending_modify.get("probe_buffer", "") + content
                            if len(probe_buffer) > 10000:
                                probe_buffer = probe_buffer[-10000:]
                            marker = pending_modify.get("start_marker")
                            marker_index = probe_buffer.find(marker)
                            if marker_index == -1:
                                pending_modify["probe_buffer"] = probe_buffer
                                continue
                            after_marker = marker_index + len(marker)
                            remainder = probe_buffer[after_marker:]
                            pending_modify["buffer"] = remainder
                            pending_modify["raw_buffer"] = marker + remainder
                            pending_modify["start_seen"] = True
                            pending_modify["detected_blocks"] = set()
                            pending_modify["probe_buffer"] = ""
                            if pending_modify.get("display_id"):
                                sender('update_action', {
                                    'id': pending_modify["display_id"],
                                    'status': 'running',
                                    'preparing_id': pending_modify.get("tool_call_id"),
                                    'message': f"正在修改 {pending_modify['path']}..."
                                })
                        else:
                            pending_modify["buffer"] += content
                            pending_modify["raw_buffer"] += content
                        
                        if pending_modify.get("start_seen"):
                            block_text = pending_modify["buffer"]
                            for match in re.finditer(r"\[replace:(\d+)\]", block_text):
                                try:
                                    block_index = int(match.group(1))
                                except ValueError:
                                    continue
                                detected_blocks = pending_modify.setdefault("detected_blocks", set())
                                if block_index not in detected_blocks:
                                    detected_blocks.add(block_index)
                                    if pending_modify.get("display_id"):
                                        sender('update_action', {
                                            'id': pending_modify["display_id"],
                                            'status': 'running',
                                            'preparing_id': pending_modify.get("tool_call_id"),
                                            'message': f"正在对 {pending_modify['path']} 进行第 {block_index} 处修改..."
                                        })
                        
                        if pending_modify.get("start_seen"):
                            end_pos = pending_modify["buffer"].find(pending_modify["end_marker"])
                            if end_pos != -1:
                                pending_modify["end_index"] = end_pos
                                modify_break_triggered = True
                                debug_log("检测到<<<END_MODIFY>>>，即将终止流式输出并应用修改")
                                break
                        continue
                    elif expecting_modify:
                        modify_probe_buffer += content
                        if len(modify_probe_buffer) > 10000:
                            modify_probe_buffer = modify_probe_buffer[-10000:]
                        
                        marker_match = re.search(r"<<<MODIFY:\s*([\s\S]*?)>>>", modify_probe_buffer)
                        if marker_match:
                            detected_raw_path = marker_match.group(1)
                            detected_path = detected_raw_path.strip()
                            marker_full = marker_match.group(0)
                            after_marker_index = modify_probe_buffer.find(marker_full) + len(marker_full)
                            remainder = modify_probe_buffer[after_marker_index:]
                            modify_probe_buffer = ""
                            
                            if not detected_path:
                                debug_log("检测到 MODIFY 起始标记但路径为空，忽略。")
                                continue
                            
                            pending_modify = {
                                "path": detected_path,
                                "tool_call_id": None,
                                "buffer": remainder,
                                "raw_buffer": marker_full + remainder,
                                "start_marker": marker_full,
                                "end_marker": "<<<END_MODIFY>>>",
                                "start_seen": True,
                                "end_index": None,
                                "display_id": None,
                                "detected_blocks": set()
                            }
                            if hasattr(web_terminal, "pending_modify_request"):
                                web_terminal.pending_modify_request = {"path": detected_path}
                            debug_log(f"直接检测到modify起始标记，构建修改缓冲: {detected_path}")
                            
                            end_pos = pending_modify["buffer"].find(pending_modify["end_marker"])
                            if end_pos != -1:
                                pending_modify["end_index"] = end_pos
                                modify_break_triggered = True
                                debug_log("检测到<<<END_MODIFY>>>，即将终止流式输出并应用修改")
                                break
                        continue
                    
                    if pending_append:
                        pending_append["buffer"] += content
                        
                        if pending_append.get("content_start") is None:
                            marker_index = pending_append["buffer"].find(pending_append["start_marker"])
                            if marker_index != -1:
                                pending_append["content_start"] = marker_index + len(pending_append["start_marker"])
                                debug_log(f"检测到追加起始标识: {pending_append['start_marker']}")
                        
                        if pending_append.get("content_start") is not None:
                            end_index = pending_append["buffer"].find(
                                pending_append["end_marker"],
                                pending_append["content_start"]
                            )
                            if end_index != -1:
                                pending_append["end_index"] = end_index
                                append_break_triggered = True
                                debug_log("检测到<<<END_APPEND>>>，即将终止流式输出并写入文件")
                                break
                        
                        # 继续累积追加内容
                        continue
                    elif expecting_append:
                        append_probe_buffer += content
                        # 限制缓冲区大小防止过长
                        if len(append_probe_buffer) > 10000:
                            append_probe_buffer = append_probe_buffer[-10000:]

                        marker_match = re.search(r"<<<APPEND:\s*([\s\S]*?)>>>", append_probe_buffer)
                        if marker_match:
                            detected_raw_path = marker_match.group(1)
                            detected_path = detected_raw_path.strip()
                            if not detected_path:
                                append_probe_buffer = append_probe_buffer[marker_match.end():]
                                continue
                            marker_full = marker_match.group(0)
                            after_marker_index = append_probe_buffer.find(marker_full) + len(marker_full)
                            remainder = append_probe_buffer[after_marker_index:]
                            append_probe_buffer = ""
                            pending_append = {
                                "path": detected_path,
                                "tool_call_id": None,
                                "buffer": remainder,
                                "start_marker": marker_full,
                                "end_marker": "<<<END_APPEND>>>",
                                "content_start": 0,
                                "end_index": None,
                                "display_id": None
                            }
                            if hasattr(web_terminal, "pending_append_request"):
                                web_terminal.pending_append_request = {"path": detected_path}
                            debug_log(f"直接检测到append起始标记，构建追加缓冲: {detected_path}")
                            # 检查是否立即包含结束标记
                            if pending_append["buffer"]:
                                end_index = pending_append["buffer"].find(pending_append["end_marker"], pending_append["content_start"])
                                if end_index != -1:
                                    pending_append["end_index"] = end_index
                                    append_break_triggered = True
                                    debug_log("检测到<<<END_APPEND>>>，即将终止流式输出并写入文件")
                                    break
                            continue
                    
                    if not text_started:
                        text_started = True
                        text_streaming = True
                        sender('text_start', {})
                        await asyncio.sleep(0.05)
                    
                    if not pending_append:
                        full_response += content
                        accumulated_response += content
                        text_has_content = True
                        for ch in content:
                            text_chunk_buffer.append(ch)
                            text_chunk_buffer_size += 1
                            await flush_text_buffer()
            
            # 收集工具调用 - 实时发送准备状态
            if "tool_calls" in delta:
                tool_chunks += 1
                for tc in delta["tool_calls"]:
                    found = False
                    for existing in tool_calls:
                        if existing.get("index") == tc.get("index"):
                            if "function" in tc and "arguments" in tc["function"]:
                                existing["function"]["arguments"] += tc["function"]["arguments"]
                            found = True
                            break
                    
                    if not found and tc.get("id"):
                        tool_id = tc["id"]
                        tool_name = tc.get("function", {}).get("name", "")
                        
                        # 新工具检测到，立即发送准备事件
                        if tool_id not in detected_tools and tool_name:
                            detected_tools[tool_id] = tool_name
                            
                            # 立即发送工具准备中事件
                            sender('tool_preparing', {
                                'id': tool_id,
                                'name': tool_name,
                                'message': f'准备调用 {tool_name}...'
                            })
                            debug_log(f"    发送工具准备事件: {tool_name}")
                            await asyncio.sleep(0.1)
                        
                        tool_calls.append({
                            "id": tool_id,
                            "index": tc.get("index"),
                            "type": "function",
                            "function": {
                                "name": tool_name,
                                "arguments": tc.get("function", {}).get("arguments", "")
                            }
                        })
                        debug_log(f"    新工具: {tool_name}")
        
        # 检查是否被停止
        client_stop_info = stop_flags.get(client_sid)
        if client_stop_info:
            stop_requested = client_stop_info.get('stop', False) if isinstance(client_stop_info, dict) else client_stop_info
            if stop_requested:
                debug_log("任务在流处理完成后检测到停止状态")
                return
        
        # 流结束后的处理
        await flush_text_buffer(force=True)
        debug_log(f"\n流结束统计:")
        debug_log(f"  总chunks: {chunk_count}")
        debug_log(f"  思考chunks: {reasoning_chunks}")
        debug_log(f"  内容chunks: {content_chunks}")
        debug_log(f"  工具chunks: {tool_chunks}")
        debug_log(f"  收集到的思考: {len(current_thinking)} 字符")
        debug_log(f"  收集到的正文: {len(full_response)} 字符")
        debug_log(f"  收集到的工具: {len(tool_calls)} 个")
        
        if not append_result["handled"] and pending_append:
            append_result = await finalize_pending_append(full_response, True, finish_reason=last_finish_reason)
        if not modify_result["handled"] and pending_modify:
            modify_result = await finalize_pending_modify(full_response, True, finish_reason=last_finish_reason)
        
        # 结束未完成的流
        if in_thinking and not thinking_ended:
            sender('thinking_end', {'full_content': current_thinking})
            await asyncio.sleep(0.1)
            
            # 保存思考内容
            if current_thinking and not has_saved_thinking and is_first_iteration:
                thinking_content = f"<think>\n{current_thinking}\n</think>"
                web_terminal.context_manager.add_conversation("assistant", thinking_content)
                has_saved_thinking = True
                debug_log(f"💾 增量保存：延迟思考内容 ({len(current_thinking)} 字符)")
        
        # 确保text_end事件被发送
        if text_started and text_has_content and not append_result["handled"] and not modify_result["handled"]:
            await flush_text_buffer(force=True)
            debug_log(f"发送text_end事件，完整内容长度: {len(full_response)}")
            sender('text_end', {'full_content': full_response})
            await asyncio.sleep(0.1)
            text_streaming = False
            
            # ===== 增量保存：保存当前轮次的文本内容 =====
            if full_response.strip():
                web_terminal.context_manager.add_conversation("assistant", full_response)
                debug_log(f"💾 增量保存：文本内容 ({len(full_response)} 字符)")
        
        if append_result["handled"]:
            append_metadata = append_result.get("assistant_metadata")
            append_content_text = append_result.get("assistant_content")
            if append_content_text:
                web_terminal.context_manager.add_conversation(
                    "assistant",
                    append_content_text,
                    metadata=append_metadata
                )
                debug_log("💾 增量保存：追加正文快照")
                
                payload_info = append_metadata.get("append_payload") if append_metadata else {}
                sender('append_payload', {
                    'path': payload_info.get("path") or append_result.get("path"),
                    'forced': payload_info.get("forced", False),
                    'lines': payload_info.get("lines"),
                    'bytes': payload_info.get("bytes"),
                    'tool_call_id': payload_info.get("tool_call_id") or append_result.get("tool_call_id"),
                    'success': payload_info.get("success", append_result.get("success", False))
                })
            
            if append_result["tool_content"]:
                tool_call_id = append_result.get("tool_call_id") or f"append_{int(time.time() * 1000)}"
                system_notice = format_tool_result_notice("append_to_file", tool_call_id, append_result["tool_content"])
                web_terminal.context_manager.add_conversation("system", system_notice)
                append_result["tool_call_id"] = tool_call_id
                debug_log("💾 增量保存：append_to_file 工具结果（system 通知）")
            
            finish_reason = append_result.get("finish_reason")
            path_for_prompt = append_result.get("path")
            need_follow_prompt = (
                finish_reason == "length" or
                append_result.get("forced") or
                not append_result.get("success")
            )

            if need_follow_prompt and path_for_prompt:
                prompt_lines = [
                    f"append_to_file 在处理 {path_for_prompt} 时未完成，需要重新发起写入。"
                ]
                if finish_reason == "length":
                    prompt_lines.append(
                        "上一次输出达到系统单次输出上限，已写入的内容已保存。"
                    )
                if append_result.get("forced"):
                    prompt_lines.append(
                        "收到的内容缺少 <<<END_APPEND>>> 标记，系统依据流式结束位置落盘。"
                    )
                if not append_result.get("success"):
                    prompt_lines.append("系统未能识别有效的追加标记。")
                prompt_lines.append(
                    "请再次调用 append_to_file 工具获取新的写入窗口，并在工具调用的输出中遵循以下格式："
                )
                prompt_lines.append(f"<<<APPEND:{path_for_prompt}>>>")
                prompt_lines.append("...填写剩余正文，如内容已完成可留空...")
                prompt_lines.append("<<<END_APPEND>>>")
                prompt_lines.append("不要在普通回复中粘贴上述标记，必须通过 append_to_file 工具发送。")
                follow_prompt = "\n".join(prompt_lines)
                messages.append({
                    "role": "system",
                    "content": follow_prompt
                })
                web_terminal.context_manager.add_conversation("system", follow_prompt)
                debug_log("已注入追加任务提示")

        if append_result["handled"] and not append_result.get("success"):
            sender('system_message', {
                'content': f'⚠️ 追加写入失败：{append_result.get("error")}'
            })
        
        # 重置文本流状态，避免后续错误处理
        text_streaming = False
        text_started = False
        text_has_content = False
        full_response = ""
        
        if modify_result["handled"]:
            modify_metadata = modify_result.get("assistant_metadata")
            modify_content_text = modify_result.get("assistant_content")
            if modify_content_text:
                web_terminal.context_manager.add_conversation(
                    "assistant",
                    modify_content_text,
                    metadata=modify_metadata
                )
                debug_log("💾 增量保存：修改正文快照")
                
                payload_info = modify_metadata.get("modify_payload") if modify_metadata else {}
                sender('modify_payload', {
                    'path': payload_info.get("path") or modify_result.get("path"),
                    'total': payload_info.get("total_blocks") or modify_result.get("total_blocks"),
                    'completed': payload_info.get("completed") or modify_result.get("completed_blocks"),
                    'failed': payload_info.get("failed") or modify_result.get("failed_blocks"),
                    'forced': payload_info.get("forced", modify_result.get("forced", False)),
                    'success': modify_result.get("success", False)
                })
            
            if modify_result["tool_content"]:
                tool_call_id = modify_result.get("tool_call_id") or f"modify_{int(time.time() * 1000)}"
                system_notice = format_tool_result_notice("modify_file", tool_call_id, modify_result["tool_content"])
                web_terminal.context_manager.add_conversation("system", system_notice)
                modify_result["tool_call_id"] = tool_call_id
                debug_log("💾 增量保存：modify_file 工具结果（system 通知）")
            
            path_for_prompt = modify_result.get("path")
            failed_blocks = modify_result.get("failed_blocks") or []
            need_follow_prompt = modify_result.get("forced") or bool(failed_blocks)
            
            if need_follow_prompt and path_for_prompt:
                prompt_lines = [
                    f"modify_file 在处理 {path_for_prompt} 时未完成，需要重新发起补丁。"
                ]
                if modify_result.get("forced"):
                    prompt_lines.append(
                        "刚才的内容缺少 <<<END_MODIFY>>> 标记，系统仅应用了已识别的部分。"
                    )
                if failed_blocks:
                    failed_text = "、".join(str(idx) for idx in failed_blocks)
                    prompt_lines.append(f"以下补丁未成功：第 {failed_text} 处。")
                prompt_lines.append(
                    "请再次调用 modify_file 工具，并在新的工具调用中按以下模板提供完整补丁："
                )
                prompt_lines.append(f"<<<MODIFY:{path_for_prompt}>>>")
                prompt_lines.append("[replace:序号]")
                prompt_lines.append("<<OLD>>")
                prompt_lines.append("...原文（必须逐字匹配，包含全部缩进、空格和换行）...")
                prompt_lines.append("<<END>>")
                prompt_lines.append("<<NEW>>")
                prompt_lines.append("...新内容，可留空表示清空，注意保持结构完整...")
                prompt_lines.append("<<END>>")
                prompt_lines.append("[/replace]")
                prompt_lines.append("<<<END_MODIFY>>>")
                prompt_lines.append("请勿在普通回复中直接粘贴补丁，必须通过 modify_file 工具发送。")
                follow_prompt = "\n".join(prompt_lines)
                messages.append({
                    "role": "system",
                    "content": follow_prompt
                })
                web_terminal.context_manager.add_conversation("system", follow_prompt)
                debug_log("已注入修改任务提示")

            if modify_result["handled"] and not modify_result.get("success"):
                error_message = modify_result.get("summary_message") or modify_result.get("error") or "修改操作未成功，请根据提示重新执行。"
                sender('system_message', {
                    'content': f'⚠️ 修改操作存在未完成的内容：{error_message}'
                })
            
            text_streaming = False
            text_started = False
            text_has_content = False
            full_response = ""
            
        
        # 保存思考内容（如果这是第一次迭代且有思考）
        if web_terminal.thinking_mode and web_terminal.api_client.current_task_first_call and current_thinking:
            web_terminal.api_client.current_task_thinking = current_thinking
            web_terminal.api_client.current_task_first_call = False
        
        # 检测是否有格式错误的工具调用
        if not tool_calls and full_response and AUTO_FIX_TOOL_CALL and not append_result["handled"] and not modify_result["handled"]:
            if detect_malformed_tool_call(full_response):
                auto_fix_attempts += 1
                
                if auto_fix_attempts <= AUTO_FIX_MAX_ATTEMPTS:
                    debug_log(f"检测到格式错误的工具调用，尝试自动修复 (尝试 {auto_fix_attempts}/{AUTO_FIX_MAX_ATTEMPTS})")
                    
                    fix_message = "你使用了错误的格式输出工具调用。请使用正确的工具调用格式而不是直接输出JSON。根据当前进度继续执行任务。"
                    
                    sender('system_message', {
                        'content': f'⚠️ 自动修复: {fix_message}'
                    })
                    
                    messages.append({
                        "role": "user",
                        "content": fix_message
                    })
                    
                    await asyncio.sleep(1)
                    continue
                else:
                    debug_log(f"自动修复尝试已达上限 ({AUTO_FIX_MAX_ATTEMPTS})")
                    sender('system_message', {
                        'content': f'⌘ 工具调用格式错误，自动修复失败。请手动检查并重试。'
                    })
                    break
        
        # 构建助手消息（用于API继续对话）
        assistant_content_parts = []
        
        if current_thinking:
            assistant_content_parts.append(f"<think>\n{current_thinking}\n</think>")
        
        if full_response:
            assistant_content_parts.append(full_response)
        elif append_result["handled"] and append_result["assistant_content"]:
            assistant_content_parts.append(append_result["assistant_content"])
        elif modify_result["handled"] and modify_result.get("assistant_content"):
            assistant_content_parts.append(modify_result["assistant_content"])
        
        assistant_content = "\n".join(assistant_content_parts) if assistant_content_parts else ""
        
        # 添加到消息历史（用于API继续对话，不保存到文件）
        assistant_message = {
            "role": "assistant",
            "content": assistant_content,
            "tool_calls": tool_calls
        }
        
        messages.append(assistant_message)
        
        if append_result["handled"] and append_result.get("tool_content"):
            tool_call_id = append_result.get("tool_call_id") or f"append_{int(time.time() * 1000)}"
            system_notice = format_tool_result_notice("append_to_file", tool_call_id, append_result["tool_content"])
            messages.append({
                "role": "system",
                "content": system_notice
            })
            append_result["tool_call_id"] = tool_call_id
            debug_log("已将 append_to_file 工具结果以 system 形式追加到对话上下文")
        if modify_result["handled"] and modify_result.get("tool_content"):
            tool_call_id = modify_result.get("tool_call_id") or f"modify_{int(time.time() * 1000)}"
            system_notice = format_tool_result_notice("modify_file", tool_call_id, modify_result["tool_content"])
            messages.append({
                "role": "system",
                "content": system_notice
            })
            modify_result["tool_call_id"] = tool_call_id
            debug_log("已将 modify_file 工具结果以 system 形式追加到对话上下文")
        
        force_continue = append_result["handled"] or modify_result["handled"]
        if force_continue:
            if append_result["handled"]:
                debug_log("append_to_file 已处理，继续下一轮以让模型返回确认回复")
            elif modify_result["handled"]:
                debug_log("modify_file 已处理，继续下一轮以让模型返回确认回复")
            else:
                debug_log("补丁处理完成，继续下一轮以获取模型回复")
            continue

        if not tool_calls:
            debug_log("没有工具调用，结束迭代")
            if not finish_called and not finish_prompt_sent:
                reminder = build_finish_tool_reminder(getattr(web_terminal, "sub_agent_meta", {}))
                web_terminal.context_manager.add_conversation("user", reminder)
                messages.append({
                    "role": "user",
                    "content": reminder
                })
                sender('system_message', {
                    'content': reminder
                })
                finish_prompt_sent = True
                await asyncio.sleep(1)
                continue
            break
        
        # 检查连续相同工具调用
        for tc in tool_calls:
            tool_name = tc["function"]["name"]
            
            if tool_name == last_tool_name:
                consecutive_same_tool[tool_name] += 1
                
                if consecutive_same_tool[tool_name] >= MAX_CONSECUTIVE_SAME_TOOL:
                    debug_log(f"警告: 连续调用相同工具 {tool_name} 已达 {MAX_CONSECUTIVE_SAME_TOOL} 次")
                    sender('system_message', {
                        'content': f'⚠️ 检测到重复调用 {tool_name} 工具 {MAX_CONSECUTIVE_SAME_TOOL} 次，可能存在循环。'
                    })
                    
                    if consecutive_same_tool[tool_name] >= MAX_CONSECUTIVE_SAME_TOOL + 2:
                        debug_log(f"终止: 工具 {tool_name} 调用次数过多")
                        sender('system_message', {
                            'content': f'⌘ 工具 {tool_name} 重复调用过多，任务终止。'
                        })
                        break
            else:
                consecutive_same_tool.clear()
                consecutive_same_tool[tool_name] = 1
            
            last_tool_name = tool_name
        
        # 更新统计
        total_tool_calls += len(tool_calls)
        
        # 执行每个工具
        for tool_call in tool_calls:
            # 检查停止标志
            client_stop_info = stop_flags.get(client_sid)
            if client_stop_info:
                stop_requested = client_stop_info.get('stop', False) if isinstance(client_stop_info, dict) else client_stop_info
                if stop_requested:
                    debug_log("在工具调用过程中检测到停止状态") 
                    return
            
            # 工具调用间隔控制
            current_time = time.time()
            if last_tool_call_time > 0:
                elapsed = current_time - last_tool_call_time
                if elapsed < TOOL_CALL_COOLDOWN:
                    await asyncio.sleep(TOOL_CALL_COOLDOWN - elapsed)
            last_tool_call_time = time.time()
            
            function_name = tool_call["function"]["name"]
            if function_name == "finish_sub_agent":
                finish_called = True
            arguments_str = tool_call["function"]["arguments"]
            tool_call_id = tool_call["id"]
            

            debug_log(f"准备解析JSON，工具: {function_name}, 参数长度: {len(arguments_str)}")
            debug_log(f"JSON参数前200字符: {arguments_str[:200]}")
            debug_log(f"JSON参数后200字符: {arguments_str[-200:]}")
            
            # 使用改进的参数解析方法
            if hasattr(web_terminal, 'api_client') and hasattr(web_terminal.api_client, '_safe_tool_arguments_parse'):
                success, arguments, error_msg = web_terminal.api_client._safe_tool_arguments_parse(arguments_str, function_name)
                if not success:
                    debug_log(f"安全解析失败: {error_msg}")
                    sender('error', {'message': f'工具参数解析失败: {error_msg}'})
                    continue
                debug_log(f"使用安全解析成功，参数键: {list(arguments.keys())}")
            else:
                # 回退到带有基本修复逻辑的解析
                try:
                    arguments = json.loads(arguments_str) if arguments_str.strip() else {}
                    debug_log(f"直接JSON解析成功，参数键: {list(arguments.keys())}")
                except json.JSONDecodeError as e:
                    debug_log(f"原始JSON解析失败: {e}")
                    # 尝试基本的JSON修复
                    repaired_str = arguments_str.strip()
                    repair_attempts = []
                    
                    # 修复1: 未闭合字符串
                    if repaired_str.count('"') % 2 == 1:
                        repaired_str += '"'
                        repair_attempts.append("添加闭合引号")
                    
                    # 修复2: 未闭合JSON对象
                    if repaired_str.startswith('{') and not repaired_str.rstrip().endswith('}'):
                        repaired_str = repaired_str.rstrip() + '}'
                        repair_attempts.append("添加闭合括号")
                    
                    # 修复3: 截断的JSON（移除不完整的最后一个键值对）
                    if not repair_attempts:  # 如果前面的修复都没用上
                        last_comma = repaired_str.rfind(',')
                        if last_comma > 0:
                            repaired_str = repaired_str[:last_comma] + '}'
                            repair_attempts.append("移除不完整的键值对")
                    
                    # 尝试解析修复后的JSON
                    try:
                        arguments = json.loads(repaired_str)
                        debug_log(f"JSON修复成功: {', '.join(repair_attempts)}")
                        debug_log(f"修复后参数键: {list(arguments.keys())}")
                    except json.JSONDecodeError as repair_error:
                        debug_log(f"JSON修复也失败: {repair_error}")
                        debug_log(f"修复尝试: {repair_attempts}")
                        debug_log(f"修复后内容前100字符: {repaired_str[:100]}")
                        sender('error', {'message': f'工具参数解析失败: {e}'})
                        continue            
            
            debug_log(f"执行工具: {function_name} (ID: {tool_call_id})")
            
            # 发送工具开始事件
            tool_display_id = f"tool_{iteration}_{function_name}_{time.time()}"
            
            sender('tool_start', {
                'id': tool_display_id,
                'name': function_name,
                'arguments': arguments,
                'preparing_id': tool_call_id
            })
            
            await asyncio.sleep(0.3)
            start_time = time.time()
            
            # 执行工具
            tool_result = await web_terminal.handle_tool_call(function_name, arguments)
            debug_log(f"工具结果: {tool_result[:200]}...")
            
            execution_time = time.time() - start_time
            if execution_time < 1.5:
                await asyncio.sleep(1.5 - execution_time)
            
            # 更新工具状态
            result_data = {}
            try:
                result_data = json.loads(tool_result)
            except:
                result_data = {'output': tool_result}
            
            action_status = 'completed'
            action_message = None
            awaiting_flag = False
            
            if function_name == "append_to_file":
                if result_data.get("success") and result_data.get("awaiting_content"):
                    append_path = result_data.get("path") or arguments.get("path")
                    pending_append = {
                        "path": append_path,
                        "tool_call_id": tool_call_id,
                        "buffer": "",
                        "start_marker": f"<<<APPEND:{append_path}>>>",
                        "end_marker": "<<<END_APPEND>>>",
                        "content_start": None,
                        "end_index": None,
                        "display_id": tool_display_id
                    }
                    append_probe_buffer = ""
                    awaiting_flag = True
                    action_status = 'running'
                    action_message = f"正在向 {append_path} 追加内容..."
                    text_started = False
                    text_streaming = False
                    text_has_content = False
                    debug_log(f"append_to_file 等待输出: {append_path}")
                else:
                    debug_log("append_to_file 返回完成状态")
            elif function_name == "modify_file":
                if result_data.get("success") and result_data.get("awaiting_content"):
                    modify_path = result_data.get("path") or arguments.get("path")
                    pending_modify = {
                        "path": modify_path,
                        "tool_call_id": tool_call_id,
                        "buffer": "",
                        "raw_buffer": "",
                        "start_marker": f"<<<MODIFY:{modify_path}>>>",
                        "end_marker": "<<<END_MODIFY>>>",
                        "start_seen": False,
                        "end_index": None,
                        "display_id": tool_display_id,
                        "detected_blocks": set(),
                        "probe_buffer": ""
                    }
                    modify_probe_buffer = ""
                    if hasattr(web_terminal, "pending_modify_request"):
                        web_terminal.pending_modify_request = {"path": modify_path}
                    awaiting_flag = True
                    action_status = 'running'
                    action_message = f"正在修改 {modify_path}..."
                    text_started = False
                    text_streaming = False
                    text_has_content = False
                    debug_log(f"modify_file 等待输出: {modify_path}")
                else:
                    debug_log("modify_file 返回完成状态")
            
            if function_name == "wait_sub_agent":
                system_msg = result_data.get("system_message")
                if system_msg:
                    messages.append({
                        "role": "system",
                        "content": system_msg
                    })
                    sender('system_message', {
                        'content': system_msg,
                        'inline': False
                    })
            
            update_payload = {
                'id': tool_display_id,
                'status': action_status,
                'result': result_data,
                'preparing_id': tool_call_id
            }
            if action_message:
                update_payload['message'] = action_message
            if awaiting_flag:
                update_payload['awaiting_content'] = True
            
            sender('update_action', update_payload)
            
            # 更新UI状态
            if function_name in ['focus_file', 'unfocus_file', 'modify_file']:
                sender('focused_files_update', web_terminal.get_focused_files_info())
            
            if function_name in ['create_file', 'delete_file', 'rename_file', 'create_folder']:
                structure = web_terminal.context_manager.get_project_structure()
                sender('file_tree_update', structure)
            
            # ===== 增量保存：立即保存工具结果 =====
            try:
                result_data = json.loads(tool_result)
                if function_name == "read_file":
                    tool_result_content = format_read_file_result(result_data)
                else:
                    tool_result_content = tool_result
            except:
                tool_result_content = tool_result
            
            # 立即保存工具结果
            web_terminal.context_manager.add_conversation(
                "tool",
                tool_result_content,
                tool_call_id=tool_call_id,
                name=function_name
            )
            debug_log(f"💾 增量保存：工具结果 {function_name}")
            system_message = result_data.get("system_message") if isinstance(result_data, dict) else None
            if system_message:
                web_terminal._record_sub_agent_message(system_message, result_data.get("task_id"), inline=False)
            todo_note = result_data.get("system_note") if isinstance(result_data, dict) else None
            if todo_note:
                web_terminal.context_manager.add_conversation("system", todo_note)
            
            # 添加到消息历史（用于API继续对话）
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call_id,
                "name": function_name,
                "content": tool_result_content
            })

            if function_name not in ['append_to_file', 'modify_file']:
                await process_sub_agent_updates(messages, inline=True, after_tool_call_id=tool_call_id)
            
            await asyncio.sleep(0.2)
        
        # 标记不再是第一次迭代
        is_first_iteration = False
    
    # 最终统计
    debug_log(f"\n{'='*40}")
    debug_log(f"任务完成统计:")
    debug_log(f"  总迭代次数: {total_iterations}")
    debug_log(f"  总工具调用: {total_tool_calls}")
    debug_log(f"  自动修复尝试: {auto_fix_attempts}")
    debug_log(f"  累积响应: {len(accumulated_response)} 字符")
    debug_log(f"{'='*40}\n")
    
    # 发送完成事件
    sender('task_complete', {
        'total_iterations': total_iterations,
        'total_tool_calls': total_tool_calls,
        'auto_fix_attempts': auto_fix_attempts
    })
    
@socketio.on('send_command')
def handle_command(data):
    """处理系统命令"""
    command = data.get('command', '')
    
    username, terminal, _ = get_terminal_for_sid(request.sid)
    if not terminal:
        emit('error', {'message': 'System not initialized'})
        return
    
    if command.startswith('/'):
        command = command[1:]
    
    parts = command.split(maxsplit=1)
    cmd = parts[0].lower()
    
    if cmd == "clear":
        terminal.context_manager.conversation_history.clear()
        if terminal.thinking_mode:
            terminal.api_client.start_new_task()
        emit('command_result', {
            'command': cmd,
            'success': True,
            'message': '对话已清除'
        })
    elif cmd == "status":
        status = terminal.get_status()
        # 添加终端状态
        if terminal.terminal_manager:
            terminal_status = terminal.terminal_manager.list_terminals()
            status['terminals'] = terminal_status
        emit('command_result', {
            'command': cmd,
            'success': True,
            'data': status
        })
    elif cmd == "terminals":
        # 列出终端会话
        if terminal.terminal_manager:
            result = terminal.terminal_manager.list_terminals()
            emit('command_result', {
                'command': cmd,
                'success': True,
                'data': result
            })
        else:
            emit('command_result', {
                'command': cmd,
                'success': False,
                'message': '终端系统未初始化'
            })
    else:
        emit('command_result', {
            'command': cmd,
            'success': False,
            'message': f'未知命令: {cmd}'
        })

def initialize_system(path: str, thinking_mode: bool = False):
    """初始化系统（多用户版本仅负责写日志和配置）"""
    # 清空或创建调试日志
    DEBUG_LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
    with DEBUG_LOG_FILE.open('w', encoding='utf-8') as f:
        f.write(f"调试日志开始 - {datetime.now()}\n")
        f.write(f"项目路径: {path}\n")
        f.write(f"思考模式: {'思考模式' if thinking_mode else '快速模式'}\n")
        f.write(f"自动修复: {'开启' if AUTO_FIX_TOOL_CALL else '关闭'}\n")
        f.write(f"最大迭代: {MAX_ITERATIONS_PER_TASK}\n")
        f.write(f"最大工具调用: {MAX_TOTAL_TOOL_CALLS}\n")
        f.write("="*80 + "\n")
    
    print(f"[Init] 初始化Web系统...")
    print(f"[Init] 项目路径: {path}")
    print(f"[Init] 运行模式: {'思考模式（首次思考，后续快速）' if thinking_mode else '快速模式（无思考）'}")
    print(f"[Init] 自动修复: {'开启' if AUTO_FIX_TOOL_CALL else '关闭'}")
    print(f"[Init] 调试日志: {DEBUG_LOG_FILE}")
    
    app.config['DEFAULT_THINKING_MODE'] = thinking_mode
    print(f"{OUTPUT_FORMATS['success']} Web系统初始化完成（多用户模式）")

def update_sub_agent_task(task_id: str, **changes):
    task = sub_agent_tasks.get(task_id)
    if not task:
        return
    task.update(changes)
    task["updated_at"] = time.time()


def mark_task_completed(task_id: str, reason: Optional[str] = None):
    update_sub_agent_task(task_id, status="completed", completion_reason=reason or "")
    broadcast_sub_agent_event(task_id, "sub_agent_status", {
        "status": "completed",
        "reason": reason or ""
    })
    cleanup_inactive_sub_agent_tasks()


def mark_task_failed(task_id: str, message: str):
    update_sub_agent_task(task_id, status="failed", error=message)
    broadcast_sub_agent_event(task_id, "sub_agent_status", {
        "status": "failed",
        "message": message
    })
    cleanup_inactive_sub_agent_tasks()


def mark_task_timeout(task_id: str):
    task = sub_agent_tasks.get(task_id)
    if not task or task.get("status") in {"completed", "failed", "timeout"}:
        return
    update_sub_agent_task(task_id, status="timeout")
    broadcast_sub_agent_event(task_id, "sub_agent_status", {
        "status": "timeout",
        "message": "任务已超时"
    })
    cleanup_inactive_sub_agent_tasks()


def start_sub_agent_monitor():
    def _loop():
        while True:
            now = time.time()
            for task_id, task in list(sub_agent_tasks.items()):
                status = task.get("status")
                if status in {"completed", "failed", "timeout"}:
                    continue
                timeout = task.get("timeout_seconds") or SUB_AGENT_DEFAULT_TIMEOUT
                if now - task.get("created_at", now) > timeout:
                    mark_task_timeout(task_id)
            time.sleep(1.5)
    threading.Thread(target=_loop, daemon=True).start()


def run_server(path: str, thinking_mode: bool = False, port: int = DEFAULT_PORT, debug: bool = False):
    """运行Web服务器"""
    initialize_system(path, thinking_mode)
    start_sub_agent_monitor()
    socketio.run(
        app,
        host='0.0.0.0',
        port=port,
        debug=debug,
        use_reloader=debug,
        allow_unsafe_werkzeug=True
    )


def parse_arguments():
    parser = argparse.ArgumentParser(description="AI Agent Web Server")
    parser.add_argument(
        "--path",
        default=str(Path(DEFAULT_PROJECT_PATH).resolve()),
        help="项目工作目录（默认使用 config.DEFAULT_PROJECT_PATH）"
    )
    parser.add_argument(
        "--port",
        type=int,
        default=DEFAULT_PORT,
        help=f"监听端口（默认 {DEFAULT_PORT}）"
    )
    parser.add_argument(
        "--debug",
        action="store_true",
        help="开发模式，启用 Flask/Socket.IO 热重载"
    )
    parser.add_argument(
        "--thinking-mode",
        action="store_true",
        help="启用思考模式（首次请求使用 reasoning）"
    )
    return parser.parse_args()


if __name__ == "__main__":
    args = parse_arguments()
    run_server(
        path=args.path,
        thinking_mode=args.thinking_mode,
        port=args.port,
        debug=args.debug
    )