ailine/backend/app/agent/service.py

"""
AI Agent 服务类 - 支持多模型动态切换
接收外部传入的 checkpointer，不负责管理连接生命周期
"""

import json
import asyncio

# 本地模块
from ..graph.graph_builder import GraphBuilder, GraphContext
from ..graph.graph_tools import AVAILABLE_TOOLS, TOOLS_BY_NAME
from ..model_services.chat_services import get_all_chat_services, LocalVLLMChatProvider
from .rag_initializer import init_rag_tool
from .intent_classifier import get_intent_classifier
from ..logger import info, warning

class AIAgentService:
    def __init__(self, checkpointer):
        self.checkpointer = checkpointer
        self.graphs = {}
        self.tools = AVAILABLE_TOOLS.copy()
        self.tools_by_name = TOOLS_BY_NAME.copy()
        # 添加：意图分类器
        self.intent_classifier = get_intent_classifier()
        # RAG 管道（可选，需要时设置）
        self.rag_pipeline = None

    async def initialize(self):
        # 1. 初始化 RAG 工具（如果需要）
        def create_local_llm():
            provider = LocalVLLMChatProvider()
            return provider.get_service()
        rag_tool = await init_rag_tool(create_local_llm)
        if rag_tool:
            self.tools.append(rag_tool)
            self.tools_by_name[rag_tool.name] = rag_tool

        # 2. 构建各模型的 Graph
        chat_services = get_all_chat_services()
        for name, llm in chat_services.items():
            try:
                info(f"🔄 初始化模型 '{name}'...")
                builder = GraphBuilder(llm, self.tools, self.tools_by_name).build()
                graph = builder.compile(checkpointer=self.checkpointer)
                self.graphs[name] = graph
                info(f"✅ 模型 '{name}' 初始化成功")
            except Exception as e:
                warning(f"⚠️ 模型 '{name}' 初始化失败: {e}")

        if not self.graphs:
            raise RuntimeError("没有可用的模型")
        return self

    async def process_message(self, message: str, thread_id: str, model: str = "zhipu", user_id: str = "default_user") -> dict:
        """处理用户消息，返回包含回复、token统计和耗时的字典"""
        if model not in self.graphs:
            # 回退到第一个可用模型
            available = list(self.graphs.keys())
            if not available:
                raise RuntimeError("没有可用的模型")
            model = available[0]
            warning(f"模型 '{model}' 不可用，已回退到 '{model}'")

        graph = self.graphs[model]
        config = {
            "configurable": {"thread_id": thread_id},
            "metadata": {"user_id": user_id}
        }
        input_state = {"messages": [{"role": "user", "content": message}]}
        context = GraphContext(user_id=user_id)

        result = await graph.ainvoke(input_state, config=config, context=context)

        reply = result["messages"][-1].content
        token_usage = result.get("last_token_usage", {})
        elapsed_time = result.get("last_elapsed_time", 0.0)

        return {
            "reply": reply,
            "token_usage": token_usage,
            "elapsed_time": elapsed_time
        }

    def _serialize_value(self, value):
        """递归将 LangChain 对象转换为可 JSON 序列化的格式"""
        if hasattr(value, 'content'):
            msg_type = getattr(value, 'type', 'message')
            return {
                "role": msg_type,
                "content": getattr(value, 'content', ''),
                "additional_kwargs": getattr(value, 'additional_kwargs', {}),
                "tool_calls": getattr(value, 'tool_calls', [])
            }
        elif isinstance(value, dict):
            return {k: self._serialize_value(v) for k, v in value.items()}
        elif isinstance(value, (list, tuple)):
            return [self._serialize_value(item) for item in value]
        else:
            try:
                json.dumps(value)
                return value
            except (TypeError, ValueError):
                return str(value)

    async def process_message_stream(self, message: str, thread_id: str, model_name: str, user_id: str = "default_user"):
        """流式处理消息，返回异步生成器（支持混合路由）"""
        graph = self.graphs.get(model_name)
        if not graph:
            raise ValueError(f"模型 '{model_name}' 未找到或未初始化")

        config = {
            "configurable": {"thread_id": thread_id},
            "metadata": {"user_id": user_id}
        }
        input_state = {"messages": [{"role": "user", "content": message}]}
        context = GraphContext(user_id=user_id)

        # ========== 新增：混合路由 ==========
        intent_result = await self.intent_classifier.classify(message)
        info(f"🧠 意图识别: {intent_result.intent_type} (置信度: {intent_result.confidence:.2f})")
        info(f"📝 推理: {intent_result.reasoning}")

        # 发送意图分类事件
        yield {
            "type": "intent_classified",
            "intent": intent_result.intent_type.value,
            "confidence": intent_result.confidence,
            "reasoning": intent_result.reasoning
        }

        # 根据意图决定路径
        use_react_loop = True
        if intent_result.confidence >= 0.6:
            intent_str = intent_result.intent_type.value
            if intent_str in ["chitchat", "clarify"]:
                use_react_loop = False
            elif intent_str == "knowledge" and self.rag_pipeline:
                use_react_loop = False

        # 发送路径决策事件
        yield {
            "type": "path_decision",
            "path": "react_loop" if use_react_loop else "fast",
            "intent": intent_result.intent_type.value
        }
        # ====================================

        if use_react_loop:
            # ========== React 循环路径 ==========
            current_node = None
            tool_calls_in_progress = {}

            async for chunk in graph.astream(
                input_state,
                config=config,
                context=context,
                stream_mode=["messages", "updates", "custom"],
                version="v2",
                subgraphs=True
            ):
                chunk_type = chunk["type"]
                processed_event = {}

                if chunk_type == "messages":
                    message_chunk, metadata = chunk["data"]
                    node_name = metadata.get("langgraph_node", "unknown")

                    # 检测节点变化，发送节点开始事件
                    if node_name != current_node:
                        if current_node:
                            yield {
                                "type": "node_end",
                                "node": current_node
                            }
                        yield {
                            "type": "node_start",
                            "node": node_name
                        }
                        current_node = node_name

                    # 处理消息内容
                    token_content = getattr(message_chunk, 'content', str(message_chunk))
                    reasoning_token = ""
                    if hasattr(message_chunk, 'additional_kwargs'):
                        reasoning_token = message_chunk.additional_kwargs.get("reasoning_content", "")

                    # 处理思考过程
                    if reasoning_token:
                        processed_event = {
                            "type": "llm_token",
                            "node": node_name,
                            "reasoning_token": reasoning_token
                        }
                    # 处理工具调用
                    elif hasattr(message_chunk, 'tool_calls') and message_chunk.tool_calls:
                        for tool_call in message_chunk.tool_calls:
                            tool_call_id = tool_call.get("id", "")
                            tool_name = tool_call.get("name", "")
                            tool_args = tool_call.get("args", {})

                            # 记录工具调用开始
                            if tool_call_id not in tool_calls_in_progress:
                                tool_calls_in_progress[tool_call_id] = {
                                    "name": tool_name,
                                    "args": tool_args
                                }
                                yield {
                                    "type": "tool_call_start",
                                    "tool": tool_name,
                                    "args": tool_args,
                                    "id": tool_call_id
                                }
                    # 处理普通 token
                    elif token_content:
                        processed_event = {
                            "type": "llm_token",
                            "node": node_name,
                            "token": token_content,  # ✅ 改为 token
                            "reasoning_token": reasoning_token
                        }

                elif chunk_type == "updates":
                    updates_data = chunk["data"]
                    serialized_data = self._serialize_value(updates_data)

                    # 检查是否有人工审核请求
                    if "review_pending" in serialized_data and serialized_data["review_pending"]:
                        review_id = serialized_data.get("review_id", "")
                        content_to_review = serialized_data.get("content_to_review", "")
                        yield {
                            "type": "human_review_request",
                            "review_id": review_id,
                            "content": content_to_review
                        }

                    # 检查是否有工具结果
                    if "messages" in serialized_data:
                        for msg in serialized_data["messages"]:
                            # 检测工具结果消息
                            if msg.get("role") == "tool":
                                tool_call_id = msg.get("tool_call_id", "")
                                tool_name = msg.get("name", "")
                                tool_output = msg.get("content", "")

                                if tool_call_id in tool_calls_in_progress:
                                    yield {
                                        "type": "tool_call_end",
                                        "tool": tool_name,
                                        "id": tool_call_id,
                                        "result": tool_output
                                    }
                                    del tool_calls_in_progress[tool_call_id]

                    processed_event = {
                        "type": "state_update",
                        "data": serialized_data
                    }

                elif chunk_type == "custom":
                    serialized_data = self._serialize_value(chunk["data"])
                    processed_event = {
                        "type": "custom",
                        "data": serialized_data
                    }

                if processed_event:
                    yield processed_event

            # 发送结束事件
            if current_node:
                yield {
                    "type": "node_end",
                    "node": current_node
                }
            yield {
                "type": "done"
            }

        else:
            # ========== 快速路径 ==========
            intent_str = intent_result.intent_type.value

            if intent_str == "chitchat":
                # 闲聊直接回答
                reply = await self._generate_fast_reply(
                    message,
                    "你是一个友好的助手，请礼貌回应用户的问候或闲聊。"
                )
                for char in reply:
                    yield {
                        "type": "llm_token",
                        "node": "fast_path",
                        "token": char  # ✅ 改为 token
                    }
                    await asyncio.sleep(0.03)

            elif intent_str == "clarify":
                # 澄清反问
                reply = await self._generate_fast_reply(
                    message,
                    "用户的问题不够明确，请礼貌地询问更多细节，以便更好地帮助用户。"
                )
                for char in reply:
                    yield {
                        "type": "llm_token",
                        "node": "fast_path",
                        "token": char  # ✅ 改为 token
                    }
                    await asyncio.sleep(0.03)

            elif intent_str == "knowledge" and self.rag_pipeline:
                # 快速 RAG
                yield {
                    "type": "node_start",
                    "node": "fast_rag"
                }
                yield {
                    "type": "reasoning",
                    "node": "fast_rag",
                    "content": "正在查询知识库..."
                }

                # 模拟 RAG 检索
                await asyncio.sleep(0.3)

                # 使用 RAG 生成回答
                reply = await self._generate_rag_reply(message)

                yield {
                    "type": "node_end",
                    "node": "fast_rag"
                }

                for char in reply:
                    yield {
                        "type": "llm_token",
                        "node": "fast_path",
                        "token": char  # ✅ 改为 token
                    }
                    await asyncio.sleep(0.03)

            else:
                # 兜底：直接回答
                reply = await self._generate_fast_reply(
                    message,
                    "请简洁回答用户的问题。"
                )
                for char in reply:
                    yield {
                        "type": "llm_token",
                        "node": "fast_path",
                        "token": char  # ✅ 改为 token
                    }
                    await asyncio.sleep(0.03)

            yield {
                "type": "done"
            }

    async def _generate_fast_reply(self, message: str, system_prompt: str) -> str:
        """快速生成回复（不经过 React 循环）"""
        # 使用默认模型生成回复
        model_name = next(iter(self.graphs.keys()), "zhipu")
        llm = get_all_chat_services().get(model_name)

        if not llm:
            return "抱歉，服务暂时不可用。"

        prompt = f"{system_prompt}\n\n用户: {message}"
        response = await llm.ainvoke(prompt)
        return response.content if hasattr(response, 'content') else str(response)

    async def _generate_rag_reply(self, message: str) -> str:
        """使用 RAG 生成回复"""
        if not self.rag_pipeline:
            return await self._generate_fast_reply(message, "请简洁回答用户的问题。")

        # 检索文档
        docs = await self.rag_pipeline.aretrieve(message)
        context = self.rag_pipeline.format_context(docs)

        # 生成回答
        model_name = next(iter(self.graphs.keys()), "zhipu")
        llm = get_all_chat_services().get(model_name)

        if not llm:
            return "抱歉，服务暂时不可用。"

        prompt = f"""请根据以下参考文档回答用户问题。

参考文档:
{context or "（无相关文档）"}

用户问题: {message}
"""
        response = await llm.ainvoke(prompt)
        return response.content if hasattr(response, 'content') else str(response)