重构：简化流式架构，将 ReAct 循环移入 agent 节点

主要变更：
- 简化 agent_service：移除复杂双协程，只用 stream_mode=["updates"]
- stream_context：提供更清晰的 API (set_stream_queue/get_stream_queue)
- main_graph_builder：简化图结构，移除 tools 节点和条件边
- agent 节点：包含完整 ReAct 循环 + 流式 Tool Calling 拼接
- 前端：适配新的事件格式
- 添加测试文件：test_full_react_streaming.py, test_stream.py

backend/app/main_graph/main_graph_builder.py

@@ -1,12 +1,12 @@
 """
-极简 Agent 主图 - 自己的节点结构，更好控制流式
+极简 Agent 主图 - 简化版本！
+因为完整的 ReAct 循环已经在 agent.py 里了！
 """
 
 from langgraph.graph import StateGraph, START, END
-from langgraph.prebuilt import ToolNode
-from ..state import AgentState
-from ..nodes.memory_trigger import memory_trigger_node, set_mem0_client
-from ..nodes.agent import create_agent_node
+from backend.app.main_graph.state import AgentState
+from backend.app.main_graph.nodes.memory_trigger import memory_trigger_node, set_mem0_client
+from backend.app.main_graph.nodes.agent import create_agent_node
 from backend.app.logger import info, warning
 from backend.app.tools import ALL_TOOLS
 
@@ -17,7 +17,7 @@ def build_agent_graph(
     max_steps: int = 10
 ):
     """
-    构建包含记忆节点的 Agent 图
+    构建简化的 Agent 图（ReAct 循环在 agent 节点内）
 
     Args:
         chat_services: 模型服务字典
@@ -51,28 +51,16 @@ def build_agent_graph(
         except Exception as e:
             info(f"[Graph Builder] 记忆节点初始化失败: {e}")
 
-    # ========== 3. 核心节点 ==========
+    # ========== 3. Agent 节点（包含完整 ReAct 循环） ==========
     llm_with_tools = primary_model.bind_tools(ALL_TOOLS)
     agent_node_fn = create_agent_node(llm_with_tools, primary_model)
-    tool_node_fn = ToolNode(ALL_TOOLS)
 
-    # ========== 4. 条件边判断函数 ==========
-    def should_continue(state: AgentState):
-        """判断是继续调用工具还是结束"""
-        messages = state.messages
-        last_message = messages[-1] if messages else None
-
-        if last_message and hasattr(last_message, 'tool_calls') and last_message.tool_calls:
-            return "tools"
-
-        return "finalize"
-
-    # ========== 5. 完成节点 ==========
+    # ========== 4. 完成节点 ==========
     async def finalize_node_simple(state: AgentState):
         info("[Finalize] 进入完成节点")
         return {}
 
-    # ========== 6. 构建图 ==========
+    # ========== 5. 构建图 ==========
     graph = StateGraph(AgentState)
 
     graph.add_node("init_state", init_state_node)
@@ -80,10 +68,9 @@ def build_agent_graph(
         graph.add_node("retrieve_memory", retrieve_memory_node)
     graph.add_node("memory_trigger", memory_trigger_node)
     graph.add_node("agent", agent_node_fn)
-    graph.add_node("tools", tool_node_fn)
     graph.add_node("finalize", finalize_node_simple)
 
-    # ========== 7. 边的连接 ==========
+    # ========== 6. 边的连接 ==========
     graph.add_edge(START, "init_state")
 
     if retrieve_memory_node:
@@ -93,18 +80,8 @@ def build_agent_graph(
         graph.add_edge("init_state", "memory_trigger")
 
     graph.add_edge("memory_trigger", "agent")
-
-    graph.add_conditional_edges(
-        "agent",
-        should_continue,
-        {
-            "tools": "tools",
-            "finalize": "finalize"
-        }
-    )
-
-    graph.add_edge("tools", "agent")
+    graph.add_edge("agent", "finalize")
     graph.add_edge("finalize", END)
 
-    info("✅ [Graph Builder] 极简 Agent 图构建完成")
+    info("✅ [Graph Builder] 简化 Agent 图构建完成（ReAct 在节点内）")
     return graph

backend/app/main_graph/nodes/agent.py

@@ -1,11 +1,15 @@
-"""Agent 节点：核心推理与工具调用"""
+"""
+Agent 节点：完整的 ReAct 循环 + 流式 Tool Calling 拼接
+完全参考指南实现！
+"""
 
-from typing import Dict, Any, Optional
-from langchain_core.messages import SystemMessage, AIMessage, AIMessageChunk
+from typing import Dict, Any, Optional, List
+from langchain_core.messages import SystemMessage, AIMessage, AIMessageChunk, ToolMessage
 from langchain_core.runnables.config import RunnableConfig
-from ..state import AgentState
+from backend.app.main_graph.state import AgentState
 from backend.app.logger import info, warning, error
-from .stream_context import token_queue_var
+from backend.app.agent.stream_context import get_stream_queue
+from backend.app.tools import ALL_TOOLS
 
 
 # 系统提示词（从 main_graph_builder.py 搬过来）
@@ -54,11 +58,12 @@ SYSTEM_PROMPT = """你是一个智能助手，可以使用多种工具完成复
 
 
 def create_agent_node(llm_with_tools, llm):
-    """创建 Agent 节点函数"""
+    """创建 Agent 节点函数，完整 ReAct 循环"""
 
     async def agent_node(state: AgentState, config: Optional[RunnableConfig] = None) -> Dict[str, Any]:
         """
-        Agent 节点：调用带工具的 LLM，处理步数限制
+        Agent 节点：完整的 ReAct 循环，带流式 token 和工具调用事件
+        兼容流式和非流式两种情况！
 
         Args:
             state: 当前状态
@@ -67,114 +72,214 @@ def create_agent_node(llm_with_tools, llm):
         Returns:
             状态更新字典
         """
-        current_step = state.get("current_step", 0)
-        info(f"[Agent] 第 {current_step} 步推理")
+        # 获取队列
+        queue = get_stream_queue()
+        is_streaming = queue is not None
+
+        # 获取当前步数
+        current_step = getattr(state, "current_step", 0)
+        max_steps = getattr(state, "max_steps", 10)
+        info(f"[Agent] 从第 {current_step} 步开始，最大步数: {max_steps}，流式: {is_streaming}")
+
+        # 组装完整消息
+        messages = [SystemMessage(content=SYSTEM_PROMPT)] + list(state.messages)
+        turn = current_step  # 轮次从当前步数开始
 
         try:
-            # 组装完整消息：系统提示 + 历史消息
-            full_messages = [SystemMessage(content=SYSTEM_PROMPT)] + state.messages
-            
-            info(f"[Agent] 消息数量: {len(full_messages)}, 最后一条: {type(full_messages[-1]).__name__}")
+            while turn < max_steps:
+                turn += 1
+                info(f"[Agent] 第 {turn} 轮思考")
 
-            # 判断是否达到步数上限
-            if current_step >= state.get("max_steps", 10):
-                info(f"[Agent] 达到步数上限 {state.get('max_steps', 10)}，强制结束，不绑定工具")
-                current_llm = llm.bind_tools([])
-            else:
-                current_llm = llm_with_tools
+                # 告诉前端：新的一轮开始（如果流式）
+                if is_streaming:
+                    await queue.put({
+                        "type": "turn_start",
+                        "turn": turn,
+                    })
 
-            info(f"[Agent] 调用带工具的 LLM...")
+                # 选择 LLM
+                if turn >= max_steps:
+                    info(f"[Agent] 达到步数上限，用不带工具的 LLM")
+                    current_llm = llm.bind_tools([])
+                else:
+                    current_llm = llm_with_tools
 
-            # 获取 token 队列
-            token_queue = token_queue_var.get()
-            if token_queue is None:
-                error("[Agent] ❌ token_queue 为 None！")
-                raise RuntimeError("token_queue 上下文变量未设置")
+                # 初始化变量
+                full_content = ""
+                full_reasoning_content = ""
+                pending_tool_calls = {}  # key: index, value: {id, name, args_str}
+                final_tool_calls = []
 
-            # 完整消息
-            full_content = ""
-            full_reasoning_content = ""
-            full_tool_calls = []
-
-            # 流式调用 LLM
-            async for chunk in current_llm.astream(full_messages):
-                if isinstance(chunk, AIMessageChunk):
-                    # 处理 content
-                    if chunk.content:
-                        full_content += chunk.content
-                        await token_queue.put({
-                            "type": "llm_token",
-                            "node": "agent",
-                            "token": chunk.content,
-                            "reasoning_token": "",
-                            "turn": current_step,
-                            "phase": "answering" if not full_tool_calls else "thinking"
-                        })
-
-                    # 处理 reasoning_content
-                    if hasattr(chunk, 'additional_kwargs') and chunk.additional_kwargs:
-                        reasoning_content = chunk.additional_kwargs.get("reasoning_content", "")
-                        if reasoning_content:
-                            full_reasoning_content += reasoning_content
-                            await token_queue.put({
-                                "type": "llm_token",
-                                "node": "agent",
-                                "token": "",
-                                "reasoning_token": reasoning_content,
-                                "turn": current_step,
-                                "phase": "thinking"
-                            })
-
-                    # 处理 tool_calls
-                    if hasattr(chunk, 'tool_calls') and chunk.tool_calls:
-                        # 合并 tool_calls
-                        for tc in chunk.tool_calls:
-                            # 查找是否已经有这个 id 的 tool_call
-                            found = False
-                            for existing_tc in full_tool_calls:
-                                if existing_tc.get("id") == tc.get("id"):
-                                    # 合并 args
-                                    existing_tc["args"] = {**existing_tc.get("args", {}), **tc.get("args", {})}
-                                    found = True
-                                    break
-                            if not found:
-                                full_tool_calls.append(tc)
-                                # 发送工具调用开始事件
-                                await token_queue.put({
-                                    "type": "tool_call_start",
-                                    "tool": tc.get("name"),
-                                    "args": tc.get("args"),
-                                    "id": tc.get("id", ""),
-                                    "turn": current_step
+                # 只有流式的时候用 astream，非流式直接用 ainvoke 更快！
+                if is_streaming:
+                    async for chunk in current_llm.astream(messages):
+                        if isinstance(chunk, AIMessageChunk):
+                            # 1. 处理文本 token
+                            if chunk.content:
+                                full_content += chunk.content
+                                await queue.put({
+                                    "type": "llm_token",
+                                    "turn": turn,
+                                    "phase": "answering",
+                                    "token": chunk.content,
+                                    "reasoning_token": ""
                                 })
 
-            # 构建完整的 AIMessage
-            response = AIMessage(
-                content=full_content,
-                tool_calls=full_tool_calls if full_tool_calls else None
-            )
+                            # 2. 处理 reasoning token
+                            if hasattr(chunk, 'additional_kwargs') and chunk.additional_kwargs:
+                                reasoning_content = chunk.additional_kwargs.get("reasoning_content", "")
+                                if reasoning_content:
+                                    full_reasoning_content += reasoning_content
+                                    await queue.put({
+                                        "type": "llm_token",
+                                        "turn": turn,
+                                        "phase": "reasoning",
+                                        "token": "",
+                                        "reasoning_token": reasoning_content
+                                    })
+
+                            # 3. 流式 Tool Calling 拼接逻辑（核心！用 tool_call_chunks！）
+                            if hasattr(chunk, 'tool_call_chunks') and chunk.tool_call_chunks:
+                                for tc_chunk in chunk.tool_call_chunks:
+                                    idx = tc_chunk.get("index", 0)
+                                    if idx not in pending_tool_calls:
+                                        pending_tool_calls[idx] = {
+                                            "id": "",
+                                            "name": "",
+                                            "args": ""  # 初始化为字符串
+                                        }
+
+                                    if tc_chunk.get("id"):
+                                        pending_tool_calls[idx]["id"] += tc_chunk["id"]
+                                    if tc_chunk.get("name"):
+                                        pending_tool_calls[idx]["name"] += tc_chunk["name"]
+                                    if tc_chunk.get("args"):
+                                        args_val = tc_chunk["args"]
+                                        if isinstance(args_val, str):
+                                            pending_tool_calls[idx]["args"] += args_val
+                                        else:
+                                            import json
+                                            pending_tool_calls[idx]["args"] += json.dumps(args_val)
+                else:
+                    # 非流式，直接 ainvoke
+                    result = await current_llm.ainvoke(messages)
+                    full_content = result.content if result.content else ""
+                    if hasattr(result, 'tool_calls') and result.tool_calls:
+                        final_tool_calls = result.tool_calls
+                    if hasattr(result, 'additional_kwargs') and result.additional_kwargs:
+                        full_reasoning_content = result.additional_kwargs.get("reasoning_content", "")
+
+                # 流式调用结束后，整理最终的 tool_calls（只在流式时处理 pending！）
+                if is_streaming:
+                    for idx in sorted(pending_tool_calls.keys()):
+                        tc_data = pending_tool_calls[idx]
+                        if tc_data["name"]:  # 只有有名字的才是有效工具调用
+                            # 解析参数字符串
+                            args = {}
+                            if tc_data["args"]:
+                                try:
+                                    import json
+                                    args = json.loads(tc_data["args"])
+                                except Exception as e:
+                                    info(f"[Agent] Failed to parse args JSON: {e}, raw: {tc_data['args']}")
+                            final_tool_calls.append({
+                                "id": tc_data["id"],
+                                "name": tc_data["name"],
+                                "args": args
+                            })
+
+                # 判断是否有工具调用
+                if final_tool_calls:
+                    info(f"[Agent] 第 {turn} 轮：调用 {len(final_tool_calls)} 个工具")
+
+                    # 执行工具调用
+                    new_messages = []
+                    for tc in final_tool_calls:
+                        tool_name = tc["name"]
+                        tool_args = tc["args"]
+                        tool_id = tc["id"]
+
+                        # 发送工具开始事件（如果流式）
+                        if is_streaming:
+                            await queue.put({
+                                "type": "tool_start",
+                                "turn": turn,
+                                "tool": tool_name,
+                                "args": tool_args,
+                                "id": tool_id
+                            })
+
+                        # 找到并执行对应工具
+                        tool_result = ""
+                        tool_found = False
+                        for tool in ALL_TOOLS:
+                            if tool.name == tool_name:
+                                tool_found = True
+                                try:
+                                    tool_result = await tool.ainvoke(tool_args)
+                                except Exception as e:
+                                    tool_result = f"工具调用出错: {str(e)}"
+                                    error(f"[Agent] 工具 {tool_name} 调用出错: {e}")
+                                break
+
+                        if not tool_found:
+                            tool_result = f"未找到工具: {tool_name}"
+
+                        # 发送工具结束事件（如果流式）
+                        if is_streaming:
+                            await queue.put({
+                                "type": "tool_end",
+                                "turn": turn,
+                                "tool": tool_name,
+                                "id": tool_id,
+                                "result": str(tool_result)
+                            })
+
+                        # 构造 ToolMessage
+                        tool_msg = ToolMessage(
+                            content=str(tool_result),
+                            tool_call_id=tool_id,
+                            name=tool_name
+                        )
+                        new_messages.append(tool_msg)
+
+                    # 添加到 messages，继续下一轮
+                    messages.extend(new_messages)
+                    continue
+
+                else:
+                    # 没有工具调用，最终输出
+                    info(f"[Agent] 第 {turn} 轮：完成，无工具调用")
+                    if is_streaming:
+                        await queue.put({
+                            "type": "final_answer",
+                            "turn": turn,
+                            "content": full_content
+                        })
+                    break
+
+            # 构建完整的 AIMessage 用于状态更新
+            response_kwargs = {"content": full_content}
+            if final_tool_calls:
+                response_kwargs["tool_calls"] = final_tool_calls
+            response = AIMessage(**response_kwargs)
             if full_reasoning_content:
                 response.additional_kwargs["reasoning_content"] = full_reasoning_content
 
-            info(f"[Agent] LLM 调用成功！响应类型: {type(response).__name__}")
-            if hasattr(response, 'tool_calls') and response.tool_calls:
-                info(f"[Agent] 检测到工具调用: {[tc['name'] for tc in response.tool_calls]}")
-
             # 返回状态更新
             return {
                 "messages": [response],
-                "current_step": current_step + 1,
-                "llm_calls": state.get("llm_calls", 0) + 1
+                "current_step": turn,
+                "llm_calls": getattr(state, "llm_calls", 0) + 1
             }
 
         except Exception as e:
-            error(f"[Agent] ❌ 第 {current_step} 步推理出错: {e}")
+            error(f"[Agent] ❌ 第 {turn} 轮出错: {e}")
             import traceback
             error(f"[Agent] 堆栈: {traceback.format_exc()}")
-            # 发送错误事件
-            token_queue = token_queue_var.get()
-            if token_queue:
-                await token_queue.put({
+            # 发送错误事件（如果流式）
+            if is_streaming:
+                await queue.put({
                     "type": "error",
                     "message": str(e)
                 })