aiagent/backend/app/api/agent_chat.py

"""
Agent 独立聊天 API — 不依赖工作流 DAG，直接与 Agent Runtime 对话。

POST /api/v1/agent-chat/bare
    {"message": "你好，帮我..."}
    → {"content": "...", "iterations": 3, "tool_calls": 5}
"""
from __future__ import annotations

import logging
import json
from typing import Any, AsyncGenerator, Dict, List, Optional
from fastapi import APIRouter, Depends, HTTPException, Request, Query
from fastapi.responses import StreamingResponse
from pydantic import BaseModel, Field

from app.core.database import get_db
from sqlalchemy.orm import Session
from app.api.auth import get_current_user
from app.api.deps import get_current_workspace_id, get_workspace_membership, WorkspaceContext
from app.models.user import User
from app.models.agent import Agent
from app.models.agent_llm_log import AgentLLMLog
from app.agent_runtime import (
    AgentRuntime,
    AgentConfig,
    AgentLLMConfig,
    AgentToolConfig,
    AgentBudgetConfig,
    AgentMemoryConfig,
    AgentStep,
    AgentContext,
    AgentOrchestrator,
    OrchestratorAgentConfig,
)
from app.models.chat_message import ChatMessage
from app.core.config import settings

logger = logging.getLogger(__name__)
router = APIRouter(prefix="/api/v1/agent-chat", tags=["agent-chat"])


def _make_llm_logger(
    db: Session,
    agent_id: Optional[str] = None,
    user_id: Optional[str] = None,
    workspace_id: Optional[str] = None,
):
    """创建 LLM 调用日志回调，写入 AgentLLMLog 表。"""
    def _log(metrics: dict):
        try:
            log = AgentLLMLog(
                agent_id=agent_id,
                session_id=metrics.get("session_id"),
                user_id=user_id,
                workspace_id=workspace_id,
                model=metrics.get("model", ""),
                provider=metrics.get("provider"),
                prompt_tokens=metrics.get("prompt_tokens", 0),
                completion_tokens=metrics.get("completion_tokens", 0),
                total_tokens=metrics.get("total_tokens", 0),
                latency_ms=metrics.get("latency_ms", 0),
                iteration_number=metrics.get("iteration_number", 0),
                step_type=metrics.get("step_type"),
                tool_name=metrics.get("tool_name"),
                status=metrics.get("status", "success"),
                error_message=metrics.get("error_message"),
            )
            db.add(log)
            db.commit()
        except Exception as e:
            logger.warning("写入 AgentLLMLog 失败: %s", e)
    return _log


def _make_message_saver(
    db: Session,
    agent_id: Optional[str] = None,
    user_id: Optional[str] = None,
    workspace_id: Optional[str] = None,
):
    """创建消息持久化回调，将每条消息写入 chat_messages 表。"""
    def _save(msg: dict):
        try:
            record = ChatMessage(
                session_id=msg.get("session_id"),
                agent_id=agent_id,
                user_id=user_id,
                workspace_id=workspace_id,
                role=msg.get("role", "user"),
                content=msg.get("content"),
                tool_name=msg.get("tool_name"),
                tool_input=msg.get("tool_input"),
                tool_output=msg.get("tool_output"),
                iteration=msg.get("iteration", 0),
            )
            db.add(record)

            # 自动创建 / 更新 AgentSession 记录
            session_id = msg.get("session_id")
            if session_id and agent_id:
                from app.models.agent_session import AgentSession
                existing = db.query(AgentSession).filter(
                    AgentSession.id == session_id
                ).first()
                if not existing:
                    title = None
                    if msg.get("role") == "user" and msg.get("content"):
                        title = msg["content"][:100]
                    session = AgentSession(
                        id=session_id,
                        user_id=user_id,
                        agent_id=agent_id,
                        workspace_id=workspace_id,
                        title=title,
                    )
                    db.add(session)
                elif existing.title is None and msg.get("role") == "user" and msg.get("content"):
                    existing.title = msg["content"][:100]

            db.commit()
        except Exception as e:
            logger.warning("写入 ChatMessage 失败: %s", e)
    return _save


async def _sse_stream(gen: AsyncGenerator[dict, None]) -> AsyncGenerator[str, None]:
    """将 run_stream 生成的 dict 事件格式化为 SSE 文本流。"""
    async for event in gen:
        event_type = event.get("type", "message")
        data = {k: v for k, v in event.items() if k != "type"}
        yield f"event: {event_type}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"


class ChatRequest(BaseModel):
    message: str
    session_id: Optional[str] = None
    model: Optional[str] = None
    temperature: Optional[float] = None
    max_iterations: Optional[int] = None
    streamlined: bool = Field(default=False, description="启用工具结果流式美化")
    prompt_sections_enabled: bool = Field(default=True, description="启用系统提示词分层装配")
    system_prompt_override: Optional[str] = Field(default=None, description="覆盖 Agent 的 System Prompt")


class ChatResponse(BaseModel):
    content: str
    iterations_used: int
    tool_calls_made: int
    truncated: bool
    session_id: str
    agent_id: Optional[str] = None
    steps: List[AgentStep] = Field(default_factory=list, description="执行追踪步骤")
    streamlined_summary: Optional[str] = Field(default=None, description="流式美化摘要（streamlined 模式）")
    token_usage: Optional[Dict[str, Any]] = Field(default=None, description="Token 预算摘要")


class MessageItem(BaseModel):
    """消息历史条目"""
    id: str
    session_id: str
    agent_id: Optional[str] = None
    user_id: Optional[str] = None
    role: str
    content: Optional[str] = None
    tool_name: Optional[str] = None
    tool_input: Optional[str] = None
    tool_output: Optional[str] = None
    iteration: int = 0
    created_at: Optional[str] = None


class MessageHistoryResponse(BaseModel):
    """消息历史分页响应"""
    messages: List[MessageItem]
    has_more: bool
    total: int


class SessionItem(BaseModel):
    """会话列表条目"""
    session_id: str
    title: Optional[str] = None
    last_message: Optional[str] = None
    message_count: int = 0
    is_pinned: bool = False
    created_at: Optional[str] = None
    updated_at: Optional[str] = None


class SessionListResponse(BaseModel):
    """会话列表响应"""
    sessions: List[SessionItem]


class SearchMessageItem(BaseModel):
    """跨会话搜索消息条目"""
    id: str
    session_id: str
    agent_id: Optional[str] = None
    role: str
    content: Optional[str] = None
    session_title: Optional[str] = None
    created_at: Optional[str] = None


class SearchMessagesResponse(BaseModel):
    """消息搜索响应"""
    messages: List[SearchMessageItem]
    total: int


class OrchestrateAgentItem(BaseModel):
    """编排中单个 Agent 的定义"""
    id: str
    name: str = "Agent"
    system_prompt: str = "你是一个有用的AI助手。"
    model: str = "deepseek-v4-flash"
    provider: str = "deepseek"
    temperature: float = 0.7
    max_iterations: int = 10
    tools: List[str] = Field(default_factory=list)
    description: str = ""


class OrchestrateRequest(BaseModel):
    """多 Agent 编排请求"""
    message: str
    mode: str = "debate"
    agents: List[OrchestrateAgentItem] = Field(..., min_length=1)
    model: Optional[str] = None


class OrchestrateStepItem(BaseModel):
    """编排步骤"""
    agent_id: str
    agent_name: str
    input: str = ""
    output: str = ""
    iterations_used: int = 0
    tool_calls_made: int = 0
    error: Optional[str] = None


class OrchestrateResponse(BaseModel):
    """多 Agent 编排响应"""
    mode: str
    final_answer: str
    steps: List[OrchestrateStepItem] = Field(default_factory=list)
    agent_results: List[Dict[str, Any]] = Field(default_factory=list)


@router.post("/orchestrate", response_model=OrchestrateResponse)
async def orchestrate_agents(
    req: OrchestrateRequest,
    current_user: User = Depends(get_current_user),
    workspace_id: str = Depends(get_current_workspace_id),
    db: Session = Depends(get_db),
):
    """多 Agent 编排：支持 route / sequential / debate 三种模式。"""
    agents = [
        OrchestratorAgentConfig(
            id=a.id, name=a.name,
            system_prompt=a.system_prompt,
            model=req.model or a.model,
            provider=a.provider,
            temperature=a.temperature,
            max_iterations=a.max_iterations,
            tools=a.tools,
            description=a.description,
        )
        for a in req.agents
    ]

    on_llm_call = _make_llm_logger(db, agent_id=None, user_id=current_user.id, workspace_id=workspace_id)
    orchestrator = AgentOrchestrator(
        default_llm_config=AgentLLMConfig(
            model=req.model or "deepseek-v4-flash",
            temperature=0.3,
        ),
    )
    result = await orchestrator.run(req.mode, req.message, agents, on_llm_call=on_llm_call)

    return OrchestrateResponse(
        mode=result.mode,
        final_answer=result.final_answer,
        steps=[
            OrchestrateStepItem(
                agent_id=s.agent_id,
                agent_name=s.agent_name,
                input=s.input,
                output=s.output,
                iterations_used=s.iterations_used,
                tool_calls_made=s.tool_calls_made,
                error=s.error,
            )
            for s in result.steps
        ],
        agent_results=result.agent_results,
    )


class GraphOrchestrateRequest(BaseModel):
    """图编排请求 — 以 nodes + edges 描述 DAG"""
    message: str
    nodes: List[Dict[str, Any]] = Field(..., description="编排节点列表")
    edges: List[Dict[str, Any]] = Field(default_factory=list, description="编排连线列表")
    model: Optional[str] = None


@router.post("/orchestrate/graph", response_model=OrchestrateResponse)
async def orchestrate_graph(
    req: GraphOrchestrateRequest,
    current_user: User = Depends(get_current_user),
    workspace_id: str = Depends(get_current_workspace_id),
    db: Session = Depends(get_db),
):
    """图编排模式：按 DAG 拓扑顺序执行 Agent 和条件节点。"""
    on_llm_call = _make_llm_logger(db, agent_id=None, user_id=current_user.id, workspace_id=workspace_id)
    orchestrator = AgentOrchestrator(
        default_llm_config=AgentLLMConfig(
            model=req.model or "deepseek-v4-flash",
            temperature=0.3,
        ),
    )
    result = await orchestrator._graph(
        req.message, req.nodes, req.edges, on_llm_call=on_llm_call,
    )
    return OrchestrateResponse(
        mode=result.mode,
        final_answer=result.final_answer,
        steps=[
            OrchestrateStepItem(
                agent_id=s.agent_id,
                agent_name=s.agent_name,
                input=s.input,
                output=s.output,
                iterations_used=s.iterations_used,
                tool_calls_made=s.tool_calls_made,
                error=s.error,
            )
            for s in result.steps
        ],
        agent_results=result.agent_results,
    )


@router.post("/bare", response_model=ChatResponse)
async def chat_bare(
    req: ChatRequest,
    current_user: User = Depends(get_current_user),
    workspace_id: str = Depends(get_current_workspace_id),
    db: Session = Depends(get_db),
):
    """无需 Agent 配置，使用默认设置直接对话。"""
    uid = current_user.id
    bare_scope = f"{uid}:__bare__" if uid else "__bare__"
    config = AgentConfig(
        name="bare_agent",
        system_prompt="你是一个有用的AI助手。请使用可用工具来帮助用户完成任务。",
        llm=AgentLLMConfig(
            model=req.model or (
                "gpt-4o-mini" if settings.OPENAI_API_KEY and settings.OPENAI_API_KEY != "your-openai-api-key"
                else "deepseek-v4-flash"
            ),
            temperature=req.temperature or 0.7,
            max_iterations=req.max_iterations or 10,
        ),
        user_id=uid,
        memory_scope_id=bare_scope,
        memory=AgentMemoryConfig(
            memory_dir_enabled=True,
            memory_dir_path="",
            persist_to_db=True,
            vector_memory_enabled=True,
            learning_enabled=True,
        ),
        tools=AgentToolConfig(
            permission_level="acceptEdits",
        ),
    )
    if not req.prompt_sections_enabled:
        config.prompt_sections.enabled = False
    if req.system_prompt_override:
        config.system_prompt = req.system_prompt_override
    on_llm_call = _make_llm_logger(db, agent_id=None, user_id=current_user.id, workspace_id=workspace_id)
    on_message = _make_message_saver(db, agent_id=None, user_id=current_user.id, workspace_id=workspace_id)
    context = AgentContext(session_id=req.session_id)
    runtime = AgentRuntime(config=config, context=context, on_llm_call=on_llm_call, on_message=on_message, streamlined=req.streamlined)
    result = await runtime.run(req.message)

    # 流式美化：为 steps 生成累计摘要
    streamlined_summary = None
    if req.streamlined and result.steps:
        from app.core.streamlined_output import ToolCounts, categorize_tool, get_tool_summary_text
        counts = ToolCounts()
        for s in result.steps:
            if s.type == "tool_result" and s.tool_name:
                counts.add(categorize_tool(s.tool_name))
        streamlined_summary = get_tool_summary_text(counts)

    return ChatResponse(
        content=result.content,
        iterations_used=result.iterations_used,
        tool_calls_made=result.tool_calls_made,
        truncated=result.truncated,
        session_id=runtime.context.session_id,
        steps=result.steps,
        streamlined_summary=streamlined_summary,
        token_usage=result.token_usage.model_dump() if result.token_usage else None,
    )


@router.post("/bare/stream")
async def chat_bare_stream(
    req: ChatRequest,
    current_user: User = Depends(get_current_user),
    workspace_id: str = Depends(get_current_workspace_id),
    db: Session = Depends(get_db),
):
    """无需 Agent 配置，使用默认设置直接对话（流式 SSE）。"""
    uid = current_user.id
    bare_scope = f"{uid}:__bare__" if uid else "__bare__"
    config = AgentConfig(
        name="bare_agent",
        system_prompt="你是一个有用的AI助手。请使用可用工具来帮助用户完成任务。",
        llm=AgentLLMConfig(
            model=req.model or (
                "gpt-4o-mini" if settings.OPENAI_API_KEY and settings.OPENAI_API_KEY != "your-openai-api-key"
                else "deepseek-v4-flash"
            ),
            temperature=req.temperature or 0.7,
            max_iterations=req.max_iterations or 10,
        ),
        user_id=uid,
        memory_scope_id=bare_scope,
        memory=AgentMemoryConfig(
            memory_dir_enabled=True,
            memory_dir_path="",
            persist_to_db=True,
            vector_memory_enabled=True,
            learning_enabled=True,
        ),
        tools=AgentToolConfig(
            permission_level="acceptEdits",
        ),
    )
    if not req.prompt_sections_enabled:
        config.prompt_sections.enabled = False
    if req.system_prompt_override:
        config.system_prompt = req.system_prompt_override
    on_llm_call = _make_llm_logger(db, agent_id=None, user_id=current_user.id, workspace_id=workspace_id)
    on_message = _make_message_saver(db, agent_id=None, user_id=current_user.id, workspace_id=workspace_id)
    context = AgentContext(session_id=req.session_id)
    runtime = AgentRuntime(config=config, context=context, on_llm_call=on_llm_call, on_message=on_message, streamlined=req.streamlined)
    return StreamingResponse(
        _sse_stream(runtime.run_stream(req.message)),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "Connection": "keep-alive",
            "X-Accel-Buffering": "no",
        },
    )


@router.post("/{agent_id}", response_model=ChatResponse)
async def chat_with_agent(
    agent_id: str,
    req: ChatRequest,
    current_user: User = Depends(get_current_user),
    workspace_id: str = Depends(get_current_workspace_id),
    db: Session = Depends(get_db),
):
    """与指定的 Agent 对话。Agent 的工作流配置会用于构建 Runtime。"""
    agent = db.query(Agent).filter(Agent.id == agent_id).first()
    if not agent:
        raise HTTPException(status_code=404, detail="Agent 不存在")
    if agent.user_id and agent.user_id != current_user.id and current_user.role != "admin" and not agent.is_public:
        raise HTTPException(status_code=403, detail="无权访问该 Agent")

    # 从 Agent 配置构建 Runtime
    wc = agent.workflow_config or {}
    nodes = wc.get("nodes", [])
    # 查找 agent 节点的配置（或第一个 llm 节点的配置）
    agent_node_cfg = _find_agent_node_config(nodes)

    # 构建 system prompt，并自动注入智能体名称
    system_prompt = agent_node_cfg.get("system_prompt") or agent.description or "你是一个有用的AI助手。"
    if agent.name:
        name_prefix = f"你的名字是{agent.name}"
        if name_prefix not in system_prompt:
            system_prompt = f"{name_prefix}。\n\n{system_prompt}"

    # 合并执行预算：Agent.budget_config 覆盖默认值
    budget = AgentBudgetConfig()
    if agent.budget_config and isinstance(agent.budget_config, dict):
        bc = agent.budget_config
        if "max_llm_invocations" in bc and bc["max_llm_invocations"] is not None:
            budget.max_llm_invocations = max(1, int(bc["max_llm_invocations"]))
        if "max_tool_calls" in bc and bc["max_tool_calls"] is not None:
            budget.max_tool_calls = max(1, int(bc["max_tool_calls"]))

    uid = current_user.id
    mem_scope = f"{uid}:{agent_id}" if uid else str(agent_id)
    memory_cfg = _build_memory_config_from_node(agent_node_cfg)
    if getattr(agent, "parent_agent_id", None):
        memory_cfg.parent_agent_id = agent.parent_agent_id
    config = AgentConfig(
        name=agent.name,
        system_prompt=system_prompt,
        llm=AgentLLMConfig(
            provider=agent_node_cfg.get("provider", "openai"),
            model=req.model or agent_node_cfg.get("model", "gpt-4o-mini"),
            temperature=req.temperature or float(agent_node_cfg.get("temperature", 0.7)),
            max_iterations=req.max_iterations or int(agent_node_cfg.get("max_iterations", 10)),
            # 计划模式 (P2)
            plan_mode_enabled=bool(agent_node_cfg.get("plan_mode_enabled", False)),
            plan_approval_required=bool(agent_node_cfg.get("plan_approval_required", True)),
        ),
        tools=AgentToolConfig(
            include_tools=agent_node_cfg.get("tools", []),
            exclude_tools=agent_node_cfg.get("exclude_tools", []),
            # 工具安全分级 (P3)
            permission_level=str(agent_node_cfg.get("permission_level", "default")),
            deny_tools=agent_node_cfg.get("deny_tools", []),
            auto_approve_rules=agent_node_cfg.get("auto_approve_rules", []),
        ),
        memory=memory_cfg,
        budget=budget,
        user_id=uid,
        memory_scope_id=mem_scope,
    )
    if not req.prompt_sections_enabled:
        config.prompt_sections.enabled = False
    if req.system_prompt_override:
        config.system_prompt = req.system_prompt_override

    on_llm_call = _make_llm_logger(db, agent_id=agent_id, user_id=current_user.id, workspace_id=workspace_id)
    on_message = _make_message_saver(db, agent_id=agent_id, user_id=current_user.id, workspace_id=workspace_id)
    context = AgentContext(session_id=req.session_id)
    runtime = AgentRuntime(config=config, context=context, on_llm_call=on_llm_call, on_message=on_message, streamlined=req.streamlined)
    result = await runtime.run(req.message)

    # 流式美化：为 steps 生成累计摘要
    streamlined_summary = None
    if req.streamlined and result.steps:
        from app.core.streamlined_output import ToolCounts, categorize_tool, get_tool_summary_text
        counts = ToolCounts()
        for s in result.steps:
            if s.type == "tool_result" and s.tool_name:
                counts.add(categorize_tool(s.tool_name))
        streamlined_summary = get_tool_summary_text(counts)

    return ChatResponse(
        content=result.content,
        iterations_used=result.iterations_used,
        tool_calls_made=result.tool_calls_made,
        truncated=result.truncated,
        session_id=runtime.context.session_id,
        agent_id=agent_id,
        steps=result.steps,
        streamlined_summary=streamlined_summary,
        token_usage=result.token_usage.model_dump() if result.token_usage else None,
    )


@router.post("/{agent_id}/stream")
async def chat_with_agent_stream(
    agent_id: str,
    req: ChatRequest,
    current_user: User = Depends(get_current_user),
    workspace_id: str = Depends(get_current_workspace_id),
    db: Session = Depends(get_db),
):
    """与指定的 Agent 对话（流式 SSE）。"""
    agent = db.query(Agent).filter(Agent.id == agent_id).first()
    if not agent:
        raise HTTPException(status_code=404, detail="Agent 不存在")
    if agent.user_id and agent.user_id != current_user.id and current_user.role != "admin" and not agent.is_public:
        raise HTTPException(status_code=403, detail="无权访问该 Agent")

    wc = agent.workflow_config or {}
    nodes = wc.get("nodes", [])
    agent_node_cfg = _find_agent_node_config(nodes)

    system_prompt = agent_node_cfg.get("system_prompt") or agent.description or "你是一个有用的AI助手。"
    if agent.name:
        name_prefix = f"你的名字是{agent.name}"
        if name_prefix not in system_prompt:
            system_prompt = f"{name_prefix}。\n\n{system_prompt}"

    budget = AgentBudgetConfig()
    if agent.budget_config and isinstance(agent.budget_config, dict):
        bc = agent.budget_config
        if "max_llm_invocations" in bc and bc["max_llm_invocations"] is not None:
            budget.max_llm_invocations = max(1, int(bc["max_llm_invocations"]))
        if "max_tool_calls" in bc and bc["max_tool_calls"] is not None:
            budget.max_tool_calls = max(1, int(bc["max_tool_calls"]))

    uid = current_user.id
    mem_scope = f"{uid}:{agent_id}" if uid else str(agent_id)
    memory_cfg = _build_memory_config_from_node(agent_node_cfg)
    if getattr(agent, "parent_agent_id", None):
        memory_cfg.parent_agent_id = agent.parent_agent_id
    config = AgentConfig(
        name=agent.name,
        system_prompt=system_prompt,
        llm=AgentLLMConfig(
            provider=agent_node_cfg.get("provider", "openai"),
            model=req.model or agent_node_cfg.get("model", "gpt-4o-mini"),
            temperature=req.temperature or float(agent_node_cfg.get("temperature", 0.7)),
            max_iterations=req.max_iterations or int(agent_node_cfg.get("max_iterations", 10)),
            # 计划模式 (P2)
            plan_mode_enabled=bool(agent_node_cfg.get("plan_mode_enabled", False)),
            plan_approval_required=bool(agent_node_cfg.get("plan_approval_required", True)),
        ),
        tools=AgentToolConfig(
            include_tools=agent_node_cfg.get("tools", []),
            exclude_tools=agent_node_cfg.get("exclude_tools", []),
            # 工具安全分级 (P3)
            permission_level=str(agent_node_cfg.get("permission_level", "default")),
            deny_tools=agent_node_cfg.get("deny_tools", []),
            auto_approve_rules=agent_node_cfg.get("auto_approve_rules", []),
        ),
        memory=memory_cfg,
        budget=budget,
        user_id=uid,
        memory_scope_id=mem_scope,
    )
    if not req.prompt_sections_enabled:
        config.prompt_sections.enabled = False
    if req.system_prompt_override:
        config.system_prompt = req.system_prompt_override

    on_llm_call = _make_llm_logger(db, agent_id=agent_id, user_id=current_user.id, workspace_id=workspace_id)
    on_message = _make_message_saver(db, agent_id=agent_id, user_id=current_user.id, workspace_id=workspace_id)
    context = AgentContext(session_id=req.session_id)
    runtime = AgentRuntime(config=config, context=context, on_llm_call=on_llm_call, on_message=on_message, streamlined=req.streamlined)
    return StreamingResponse(
        _sse_stream(runtime.run_stream(req.message)),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "Connection": "keep-alive",
            "X-Accel-Buffering": "no",
        },
    )


@router.get("/{agent_id}/sessions", response_model=SessionListResponse)
async def list_agent_sessions(
    agent_id: str,
    limit: int = 50,
    search: Optional[str] = None,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """获取 Agent 的会话列表，置顶优先，再按最近活跃时间排序。支持 search 参数按标题/内容搜索。"""
    from sqlalchemy import func as sa_func, desc, or_
    from app.models.agent_session import AgentSession

    # 验证 agent 存在或有权限
    agent = db.query(Agent).filter(Agent.id == agent_id).first()
    if not agent:
        raise HTTPException(status_code=404, detail="Agent 不存在")

    rows_query = (
        db.query(
            ChatMessage.session_id,
            sa_func.min(ChatMessage.created_at).label("created_at"),
            sa_func.max(ChatMessage.created_at).label("updated_at"),
            sa_func.count(ChatMessage.id).label("message_count"),
        )
        .filter(ChatMessage.agent_id == agent_id)
        .group_by(ChatMessage.session_id)
    )

    # 搜索过滤：按会话标题（AgentSession.title）或消息内容
    if search and search.strip():
        pattern = f"%{search.strip()}%"
        # 子查询：在标题或消息内容中匹配的 session_id
        matching_session_ids = set()

        # 匹配 AgentSession.title
        title_matches = db.query(AgentSession.id).filter(
            AgentSession.title.like(pattern)
        ).all()
        matching_session_ids.update(r[0] for r in title_matches)

        # 匹配消息内容
        content_matches = db.query(ChatMessage.session_id).filter(
            ChatMessage.agent_id == agent_id,
            ChatMessage.content.like(pattern),
        ).distinct().all()
        matching_session_ids.update(r[0] for r in content_matches)

        if matching_session_ids:
            rows_query = rows_query.filter(
                ChatMessage.session_id.in_(list(matching_session_ids))
            )
        else:
            # 无匹配，返回空
            return SessionListResponse(sessions=[])

    rows = rows_query.order_by(desc("updated_at")).limit(limit).all()

    # 批量查询 AgentSession 记录
    session_ids = [row.session_id for row in rows]
    agent_sessions_map = {}
    if session_ids:
        records = db.query(AgentSession).filter(
            AgentSession.id.in_(session_ids)
        ).all()
        agent_sessions_map = {s.id: s for s in records}

    sessions = []
    for row in rows:
        asession = agent_sessions_map.get(row.session_id)

        # 标题优先级: AgentSession.title > 第一条 user 消息
        title = asession.title if asession and asession.title else None
        if not title:
            first_user_msg = (
                db.query(ChatMessage)
                .filter(
                    ChatMessage.session_id == row.session_id,
                    ChatMessage.role == "user",
                )
                .order_by(ChatMessage.created_at.asc())
                .first()
            )
            if first_user_msg and first_user_msg.content:
                title = first_user_msg.content[:100]

        # 取最后一条消息作为预览
        last_msg = (
            db.query(ChatMessage)
            .filter(ChatMessage.session_id == row.session_id)
            .order_by(ChatMessage.created_at.desc())
            .first()
        )
        sessions.append(SessionItem(
            session_id=row.session_id,
            title=title,
            last_message=last_msg.content[:200] if last_msg and last_msg.content else None,
            message_count=row.message_count,
            is_pinned=asession.is_pinned if asession else False,
            created_at=row.created_at.isoformat() if row.created_at else None,
            updated_at=row.updated_at.isoformat() if row.updated_at else None,
        ))

    # 排序：置顶优先，再按更新时间降序
    pinned = [s for s in sessions if s.is_pinned]
    unpinned = [s for s in sessions if not s.is_pinned]
    pinned.sort(key=lambda s: s.updated_at or "", reverse=True)
    unpinned.sort(key=lambda s: s.updated_at or "", reverse=True)
    sessions = pinned + unpinned

    return SessionListResponse(sessions=sessions)


@router.get("/{agent_id}/sessions/{session_id}/messages", response_model=MessageHistoryResponse)
async def get_session_messages(
    agent_id: str,
    session_id: str,
    before_id: Optional[str] = None,
    limit: int = 50,
    search: Optional[str] = None,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """获取会话的消息历史（分页），从旧到新排序。支持 search 参数按内容搜索。"""
    from sqlalchemy import or_

    # limit 限制
    limit = min(max(limit, 1), 200)

    base_q = db.query(ChatMessage).filter(
        ChatMessage.agent_id == agent_id,
        ChatMessage.session_id == session_id,
    )

    # 消息内容搜索
    if search and search.strip():
        pattern = f"%{search.strip()}%"
        base_q = base_q.filter(ChatMessage.content.like(pattern))

    # 游标分页：before_id 之前的老消息（使用复合键避免 created_at 相同导致遗漏）
    if before_id:
        cursor_msg = db.query(ChatMessage).filter(ChatMessage.id == before_id).first()
        if cursor_msg and cursor_msg.created_at:
            base_q = base_q.filter(
                or_(
                    ChatMessage.created_at < cursor_msg.created_at,
                    (ChatMessage.created_at == cursor_msg.created_at) & (ChatMessage.id < cursor_msg.id),
                )
            )

    # 取 N+1 条，判断 has_more（按时间降序取最新 N 条，再反转）
    # 二级排序 iteration + id 避免同一秒内多条消息顺序不确定
    batch = (
        base_q
        .order_by(ChatMessage.created_at.desc(), ChatMessage.iteration.asc(), ChatMessage.id.asc())
        .limit(limit + 1)
        .all()
    )

    has_more = len(batch) > limit
    if has_more:
        batch = batch[:limit]

    # 反转为从旧到新
    batch.reverse()

    total = base_q.count()

    messages = [
        MessageItem(
            id=m.id,
            session_id=m.session_id,
            agent_id=m.agent_id,
            user_id=m.user_id,
            role=m.role,
            content=m.content,
            tool_name=m.tool_name,
            tool_input=m.tool_input,
            tool_output=m.tool_output,
            iteration=m.iteration or 0,
            created_at=m.created_at.isoformat() if m.created_at else None,
        )
        for m in batch
    ]

    return MessageHistoryResponse(messages=messages, has_more=has_more, total=total)


@router.get("/{agent_id}/search-messages", response_model=SearchMessagesResponse)
async def search_messages(
    agent_id: str,
    q: str = Query(..., min_length=1, description="搜索关键词"),
    limit: int = Query(50, ge=1, le=100),
    skip: int = Query(0, ge=0),
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """跨会话搜索消息内容，返回匹配的消息及所属会话信息。"""
    from app.models.agent_session import AgentSession

    # 验证 agent 存在
    agent = db.query(Agent).filter(Agent.id == agent_id).first()
    if not agent:
        raise HTTPException(status_code=404, detail="Agent 不存在")

    pattern = f"%{q.strip()}%"

    # 搜索匹配的消息
    total = (
        db.query(ChatMessage)
        .filter(
            ChatMessage.agent_id == agent_id,
            ChatMessage.content.like(pattern),
        )
        .count()
    )

    messages = (
        db.query(ChatMessage)
        .filter(
            ChatMessage.agent_id == agent_id,
            ChatMessage.content.like(pattern),
        )
        .order_by(ChatMessage.created_at.desc())
        .offset(skip)
        .limit(limit)
        .all()
    )

    # 批量获取会话标题
    session_ids = list(set(m.session_id for m in messages))
    session_titles = {}
    if session_ids:
        records = db.query(AgentSession).filter(
            AgentSession.id.in_(session_ids)
        ).all()
        session_titles = {s.id: s.title for s in records if s.title}

    result = [
        SearchMessageItem(
            id=m.id,
            session_id=m.session_id,
            agent_id=m.agent_id,
            role=m.role,
            content=m.content,
            session_title=session_titles.get(m.session_id),
            created_at=m.created_at.isoformat() if m.created_at else None,
        )
        for m in messages
    ]

    return SearchMessagesResponse(messages=result, total=total)


def _find_agent_node_config(nodes: list) -> Dict[str, Any]:
    """从工作流节点列表中查找第一个 agent 类型或 llm 类型的节点配置。"""
    if not nodes:
        return {}
    for node in nodes:
        typ = node.get("type", "")
        if typ in ("agent", "llm", "template"):
            return node.get("data") or {}
    return {}


def _build_memory_config_from_node(agent_node_cfg: dict) -> AgentMemoryConfig:
    """从 Agent 工作流节点配置中提取记忆配置。"""
    from app.core.compaction_config import CompactionConfig

    # 压缩配置
    compaction_raw = agent_node_cfg.get("compaction")
    if isinstance(compaction_raw, dict):
        compaction = CompactionConfig(**compaction_raw)
    else:
        compaction = CompactionConfig()  # 默认配置

    return AgentMemoryConfig(
        max_history_messages=int(agent_node_cfg.get("memory_max_history", 20)),
        vector_memory_top_k=int(agent_node_cfg.get("memory_vector_top_k", 5)),
        persist_to_db=bool(agent_node_cfg.get("memory_persist", True)),
        vector_memory_enabled=bool(agent_node_cfg.get("memory_vector_enabled", True)),
        learning_enabled=bool(agent_node_cfg.get("memory_learning", True)),
        # 文件式记忆 (MEMORY.md)
        memory_dir_enabled=bool(agent_node_cfg.get("memory_dir_enabled", False)),
        memory_dir_path=str(agent_node_cfg.get("memory_dir_path", "")),
        # 对话压缩
        compaction=compaction,
    )