重构：简化流式架构，将 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/agent/agent_service.py

@@ -1,6 +1,6 @@
 """
-AI Agent 服务类 - 优化版本：双协程 + 结束哨兵 + 完整的取消和异常处理
-接收外部传入的 checkpointer，不负责管理连接生命周期
+AI Agent 服务类 - 完全简化版本！
+按照指南实现，不用 stream_mode="messages" 避免重复 token！
 """
 
 import json
@@ -11,11 +11,11 @@ from typing import AsyncGenerator, Dict, Any, Optional, Tuple
 from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
 
 # 本地模块
-from ..model_services import get_cached_chat_services
-from ..main_graph.main_graph_builder import build_agent_graph
+from backend.app.model_services import get_cached_chat_services
+from backend.app.main_graph.main_graph_builder import build_agent_graph
 from backend.app.logger import debug, info, warning, error
-from ..main_graph.state import AgentState
-from .stream_context import token_queue_var
+from backend.app.main_graph.state import AgentState
+from .stream_context import set_stream_queue
 
 
 class AIAgentService:
@@ -120,125 +120,10 @@ class AIAgentService:
             "model_used": resolved_model
         }
 
-    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 _handle_message_chunk(
-        self, chunk: Dict[str, Any], current_node: Optional[str], tool_calls_in_progress: Dict[str, Any]
-    ) -> AsyncGenerator[Dict[str, Any], None]:
-        """处理 messages 类型的 chunk"""
-        message_chunk, metadata = chunk["data"]
-        node_name = metadata.get("langgraph_node", "unknown")
-        new_current_node = current_node
-
-        # 检测节点变化，发送节点开始事件
-        if node_name != current_node:
-            if current_node:
-                yield {"type": "node_end", "node": current_node}
-            yield {"type": "node_start", "node": node_name}
-            new_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:
-            yield {
-                "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 and 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:
-            yield {
-                "type": "llm_token",
-                "node": node_name,
-                "token": token_content,
-                "reasoning_token": reasoning_token
-            }
-
-        # 返回更新后的 current_node
-        yield {"type": "_update_state", "current_node": new_current_node}
-
-    async def _handle_updates_chunk(
-        self, chunk: Dict[str, Any], tool_calls_in_progress: Dict[str, Any], actual_model_used: str
-    ) -> AsyncGenerator[Dict[str, Any], None]:
-        """处理 updates 类型的 chunk"""
-        updates_data = chunk["data"]
-        new_actual_model = actual_model_used
-        
-        serialized_data = self._serialize_value(updates_data)
-        
-        # 检查是否有工具结果
-        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_result = msg.get("content", "")
-                    
-                    if tool_call_id and tool_call_id in tool_calls_in_progress:
-                        yield {
-                            "type": "tool_call_end",
-                            "tool": tool_name,
-                            "id": tool_call_id,
-                            "result": tool_result
-                        }
-                        del tool_calls_in_progress[tool_call_id]
-        
-        yield {
-            "type": "state_update",
-            "data": serialized_data
-        }
-        
-        # 返回更新后的模型
-        yield {"type": "_update_state", "actual_model_used": new_actual_model}
-
     async def process_message_stream(
         self, message: str, thread_id: str, model: str = "", user_id: str = "default_user"
     ) -> AsyncGenerator[Dict[str, Any], None]:
-        """流式处理消息 - 双协程 + 结束哨兵 + 完整取消和异常处理"""
+        """流式处理消息 - 完全简化！"""
         # 解析模型名称
         resolved_model = self._resolve_model(model)
         
@@ -246,144 +131,64 @@ class AIAgentService:
         config, input_state = self._build_invocation(message, thread_id, resolved_model, user_id)
 
         info(f"🚀 开始执行 Agent 图，指定模型: {resolved_model}")
-        current_node = None
-        tool_calls_in_progress: Dict[str, Any] = {}
         actual_model_used = resolved_model
-        full_message_content = ""
 
         # 创建 token 队列
-        token_queue = asyncio.Queue()
-        # 结束哨兵
-        SENTINEL = object()
+        queue = asyncio.Queue()
+        set_stream_queue(queue)  # 设置上下文变量
 
-        # 设置上下文变量
-        token_queue_var.set(token_queue)
-
-        # 事件和错误跟踪
-        graph_error = None
-        graph_done = asyncio.Event()
-
-        async def run_graph_task():
-            """后台任务：运行 graph.astream()"""
-            nonlocal current_node, actual_model_used, full_message_content, graph_error
+        async def run_graph():
+            """后台任务：运行 graph，只获取 updates，不要用 stream_mode="messages" 避免重复 token！"""
             try:
                 info(f"📡 开始调用 graph.astream()...")
                 
-                event_count = 0
-                
+                # 注意：只用 stream_mode=["updates"]，不要 "messages"！避免重复 token！
                 async for chunk in self.graph.astream(
                     input_state,
                     config=config,
-                    stream_mode=["messages", "updates"],
+                    stream_mode=["updates"],
                     version="v2",
                     subgraphs=True
                 ):
-                    chunk_count = 0
-                    chunk_count += 1
-                    chunk_type = chunk["type"]
-                    
-                    # 记录原始 chunk 信息（前 10 个和后 10 个）
-                    if chunk_count <= 10 or chunk_count % 50 == 0:
-                        info(f"  [{chunk_count}] chunk_type={chunk_type}, data={type(chunk.get('data'))}")
-
-                    if chunk_type == "messages":
-                        async for event in self._handle_message_chunk(
-                            chunk, current_node, tool_calls_in_progress
-                        ):
-                            if event.get("type") == "_update_state":
-                                current_node = event.get("current_node", current_node)
-                            else:
-                                event_count += 1
-                                # 记录前 10 个事件
-                                if event_count <= 10:
-                                    info(f"    → yield event #{event_count}: {event.get('type')}")
-                                
-                                # 如果是 agent 节点的 token，收集完整消息
-                                if (
-                                    event.get("type") == "llm_token"
-                                    and event.get("node") == "agent"
-                                    and "token" in event
-                                ):
-                                    full_message_content += event["token"]
-                                await token_queue.put(event)
-
-                    elif chunk_type == "updates":
-                        async for event in self._handle_updates_chunk(
-                            chunk, tool_calls_in_progress, actual_model_used
-                        ):
-                            if event.get("type") == "_update_state":
-                                actual_model_used = event.get("actual_model_used", actual_model_used)
-                            else:
-                                event_count += 1
-                                if event_count <= 10:
-                                    info(f"    → yield event #{event_count}: {event.get('type')}")
-                                await token_queue.put(event)
-
-                # 完整消息集合完成后，一次性打印
-                info(f"✅ graph.astream() 完成，共 {event_count} 个 events")
-                if full_message_content:
-                    info(f"📄 完整消息内容: {repr(full_message_content)}")
-
+                    # 可以处理一些状态更新事件，如 final_result 等
+                    await queue.put({
+                        "type": "graph_update",
+                        "data": chunk,
+                    })
             except Exception as e:
                 error(f"❌ 执行图时出错: {e}")
                 import traceback
                 error(f"📋 堆栈: {traceback.format_exc()}")
-                graph_error = e
-                await token_queue.put({
-                    "type": "error",
-                    "message": str(e)
-                })
+                await queue.put({"type": "error", "message": str(e)})
             finally:
-                # 发送结束哨兵
-                await token_queue.put(SENTINEL)
-                graph_done.set()
+                await queue.put(None)  # 结束哨兵
 
         # 启动后台任务
-        graph_task = asyncio.create_task(run_graph_task())
+        bg_task = asyncio.create_task(run_graph())
 
         try:
-            # 主协程：从队列里取事件并 yield
             while True:
-                try:
-                    # 等待队列中的事件，带超时检查任务是否完成
-                    event = await asyncio.wait_for(token_queue.get(), timeout=0.5)
-                    
-                    # 检查是否是结束哨兵
-                    if event is SENTINEL:
-                        break
-                    
-                    yield event
-                
-                except asyncio.TimeoutError:
-                    # 超时检查任务是否完成
-                    if graph_task.done():
-                        # 检查任务是否抛出异常
-                        if graph_task.exception():
-                            exc = graph_task.exception()
-                            error(f"❌ 后台任务异常: {exc}")
-                        break
-        
-        except asyncio.CancelledError:
-            info("⚠️ 流式生成被取消")
+                event = await queue.get()
+                if event is None:
+                    break
+                yield event
+
+        except GeneratorExit:
+            # 客户端断开连接，取消后台任务
+            info("⚠️ GeneratorExit，取消后台任务")
+            bg_task.cancel()
             raise
-        
         finally:
-            # 无论成功或失败，都清理资源
-            # 取消后台任务
-            if not graph_task.done():
-                info("⏹️ 取消后台任务")
-                graph_task.cancel()
+            # 保证任务被清理
+            if not bg_task.done():
+                info("⏹️ 清理后台任务")
+                bg_task.cancel()
                 try:
-                    await graph_task
+                    await bg_task
                 except asyncio.CancelledError:
                     info("✅ 后台任务已取消")
             
             # 发送结束事件，保证前端平稳关闭
-            if current_node:
-                yield {
-                    "type": "node_end",
-                    "node": current_node
-                }
             yield {
                 "type": "done",
                 "model_used": actual_model_used