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
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.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,
):
    """创建 LLM 调用日志回调，写入 AgentLLMLog 表。"""
    def _log(metrics: dict):
        try:
            log = AgentLLMLog(
                agent_id=agent_id,
                session_id=metrics.get("session_id"),
                user_id=user_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,
):
    """创建消息持久化回调，将每条消息写入 chat_messages 表。"""
    def _save(msg: dict):
        try:
            record = ChatMessage(
                session_id=msg.get("session_id"),
                agent_id=agent_id,
                user_id=user_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)
            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
    created_at: Optional[str] = None
    updated_at: Optional[str] = None


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


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),
    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)
    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),
    db: Session = Depends(get_db),
):
    """图编排模式：按 DAG 拓扑顺序执行 Agent 和条件节点。"""
    on_llm_call = _make_llm_logger(db, agent_id=None, user_id=current_user.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),
    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)
    on_message = _make_message_saver(db, agent_id=None, user_id=current_user.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),
    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)
    on_message = _make_message_saver(db, agent_id=None, user_id=current_user.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),
    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":
        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)
    on_message = _make_message_saver(db, agent_id=agent_id, user_id=current_user.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),
    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":
        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)
    on_message = _make_message_saver(db, agent_id=agent_id, user_id=current_user.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,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """获取 Agent 的会话列表，按最近活跃时间排序。"""
    from sqlalchemy import func as sa_func, desc

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

    rows = (
        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)
        .order_by(desc("updated_at"))
        .limit(limit)
        .all()
    )

    sessions = []
    for row in rows:
        # 取第一条 user 消息作为标题
        first_user_msg = (
            db.query(ChatMessage)
            .filter(
                ChatMessage.session_id == row.session_id,
                ChatMessage.role == "user",
            )
            .order_by(ChatMessage.created_at.asc())
            .first()
        )
        # 取最后一条消息作为预览
        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=first_user_msg.content[:100] if first_user_msg and first_user_msg.content else None,
            last_message=last_msg.content[:200] if last_msg and last_msg.content else None,
            message_count=row.message_count,
            created_at=row.created_at.isoformat() if row.created_at else None,
            updated_at=row.updated_at.isoformat() if row.updated_at else None,
        ))

    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,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """获取会话的消息历史（分页），从旧到新排序。"""
    # limit 限制
    limit = min(max(limit, 1), 200)

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

    # 游标分页：before_id 之前的老消息
    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(ChatMessage.created_at < cursor_msg.created_at)

    # 取 N+1 条，判断 has_more（按时间降序取最新 N 条，再反转）
    batch = (
        base_q
        .order_by(ChatMessage.created_at.desc())
        .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)


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,
    )