sycommon-python-lib 0.2.5a27__tar.gz → 0.2.5a29__tar.gz

{sycommon_python_lib-0.2.5a27 → sycommon_python_lib-0.2.5a29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.5a27
+Version: 0.2.5a29
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -9,15 +9,15 @@ Requires-Dist: aiohttp==3.13.5
 Requires-Dist: aiomysql==0.3.2
 Requires-Dist: anyio==4.13.0
 Requires-Dist: decorator==5.3.1
-Requires-Dist: deepagents==0.6.6
+Requires-Dist: deepagents==0.6.7
 Requires-Dist: elasticsearch==9.4.1
 Requires-Dist: fastapi==0.136.3
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: kafka-python==2.3.1
 Requires-Dist: langchain==1.3.2
 Requires-Dist: langchain-core==1.4.0
-Requires-Dist: langchain-openai==1.2.1
-Requires-Dist: langfuse==4.6.1
+Requires-Dist: langchain-openai==1.2.2
+Requires-Dist: langfuse==4.7.1
 Requires-Dist: langgraph==1.2.2
 Requires-Dist: langgraph-checkpoint-postgres==3.1.0
 Requires-Dist: langgraph-checkpoint-redis==0.4.1
@@ -29,12 +29,12 @@ Requires-Dist: psutil==7.2.2
 Requires-Dist: pyxxl==0.4.7
 Requires-Dist: pydantic==2.13.4
 Requires-Dist: python-dotenv==1.2.2
-Requires-Dist: python-multipart==0.0.29
+Requires-Dist: python-multipart==0.0.30
 Requires-Dist: pyyaml==6.0.3
 Requires-Dist: redis==7.4.0
-Requires-Dist: sentry-sdk[fastapi]==2.60.0
+Requires-Dist: sentry-sdk[fastapi]==2.61.1
 Requires-Dist: sqlalchemy[asyncio]==2.0.50
-Requires-Dist: starlette[full]==1.1.0
+Requires-Dist: starlette[full]==1.2.1
 Requires-Dist: tiktoken==0.13.0
 Requires-Dist: uvicorn==0.48.0
 Requires-Dist: wecom-aibot-python-sdk==1.0.2

{sycommon_python_lib-0.2.5a27 → sycommon_python_lib-0.2.5a29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.5a27"
+version = "0.2.5a29"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -10,15 +10,15 @@ dependencies = [
     "aiomysql==0.3.2",
     "anyio==4.13.0",
     "decorator==5.3.1",
-    "deepagents==0.6.6",
+    "deepagents==0.6.7",
     "elasticsearch==9.4.1",
     "fastapi==0.136.3",
     "jinja2==3.1.6",
     "kafka-python==2.3.1",
     "langchain==1.3.2",
     "langchain-core==1.4.0",
-    "langchain-openai==1.2.1",
-    "langfuse==4.6.1",
+    "langchain-openai==1.2.2",
+    "langfuse==4.7.1",
     "langgraph==1.2.2",
     "langgraph-checkpoint-postgres==3.1.0",
     "langgraph-checkpoint-redis==0.4.1",
@@ -30,12 +30,12 @@ dependencies = [
     "pyxxl==0.4.7",
     "pydantic==2.13.4",
     "python-dotenv==1.2.2",
-    "python-multipart==0.0.29",
+    "python-multipart==0.0.30",
     "pyyaml==6.0.3",
     "redis==7.4.0",
-    "sentry-sdk[fastapi]==2.60.0",
+    "sentry-sdk[fastapi]==2.61.1",
     "sqlalchemy[asyncio]==2.0.50",
-    "starlette[full]==1.1.0",
+    "starlette[full]==1.2.1",
     "tiktoken==0.13.0",
     "uvicorn==0.48.0",
     "wecom-aibot-python-sdk==1.0.2",

{sycommon_python_lib-0.2.5a27 → sycommon_python_lib-0.2.5a29}/src/sycommon/agent/deep_agent.py

@@ -37,11 +37,12 @@
 import asyncio
 import json
 import os
+from collections.abc import Awaitable, Callable
 from pathlib import Path
-from typing import Any, AsyncGenerator, Callable, Awaitable, Dict, List, Optional, Tuple, TYPE_CHECKING
+from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple, TYPE_CHECKING
 
 from pydantic import BaseModel, Field
-from langchain_core.messages import HumanMessage, BaseMessage
+from langchain_core.messages import HumanMessage, BaseMessage, AIMessageChunk, AIMessage, SystemMessage
 from langchain_core.tools import BaseTool, tool
 
 from sycommon.logging.kafka_log import SYLogger
@@ -56,6 +57,202 @@ from sycommon.agent.summarization_utils import build_summarization_middleware
 
 if TYPE_CHECKING:
     from deepagents.graph import CompiledStateGraph
+    from langchain.agents.middleware.types import AgentState, ContextT, ModelRequest, ModelResponse, ResponseT
+    from langgraph.runtime import Runtime
+
+
+def _patch_agent_streaming(agent):
+    """Monkey-patch factory.py _execute_model_async to fix stream_mode="messages".
+
+    根因: langchain factory.py (<=1.3.2) 的 _execute_model_async 有两个问题:
+      1. 调用 model_.ainvoke(messages) 不传 config → callbacks 不传播
+      2. 使用 ainvoke (非流式) 而非 astream → on_llm_new_token 不触发
+
+    修复: 替换 amodel_node 闭包中的 _execute_model_async, 改用 astream 并传入
+    从 ContextVar 读取的 config。astream 每个 token 触发 on_llm_new_token,
+    StreamMessagesHandler 拦截后推送给 stream_mode="messages" 的消费者。
+
+    为什么是最内层替换(而非 Middleware): _execute_model_async 位于所有中间件
+    (含 deepagents tail 的 MemoryMiddleware/FilesystemMiddleware 等会 modify_request
+    的 awrap_model_call)的最内层。替换它不绕过任何中间件; 用 Middleware 方案则只能
+    插在"用户中间件"层, 会绕过更内层的 MemoryMiddleware 注入。故保留 monkey-patch。
+
+    加固: 闭包结构按"自由变量名"定位 cell(不依赖固定索引), 任一不符即跳过 patch
+    并降级为非流式(功能正常, 只是不逐 token 推送), 而非打错补丁导致静默失效。
+
+    TODO: 等官方修复 (langchain >1.3.x, _execute_model_async 改用 astream) 后
+    删除此函数及调用即可。
+    """
+    # 已验证兼容的版本范围(超出仅警告, 不阻断 —— 闭包强校验是真正的安全网)
+    _VERIFIED = {"langchain": "1.3.2", "langchain_core": "1.4.0"}
+    try:
+        import langchain as _lc
+        import langchain_core as _lcc
+        _cur = {"langchain": getattr(_lc, "__version__", "?"),
+                "langchain_core": getattr(_lcc, "__version__", "?")}
+        if _cur != _VERIFIED:
+            SYLogger.warning(
+                f"[StreamingPatch] langchain 版本 {_cur} 与已验证 {_VERIFIED} 不一致; "
+                f"闭包强校验仍会兜底, 但建议复核 _execute_model_async 是否已改用 astream")
+    except Exception:
+        pass
+
+    try:
+        from langchain_core.messages import AIMessageChunk as _AIC, AIMessage as _AIM
+        from langchain_core.runnables.config import var_child_runnable_config
+
+        print(f"[StreamingPatch] agent.nodes: {list(agent.nodes.keys())}", flush=True)
+        node = agent.nodes.get("model")
+        if node is None:
+            print("[StreamingPatch] model node not found, skip", flush=True)
+            SYLogger.warning("[DeepAgent] model node not found, skip streaming patch")
+            return
+
+        inner = node.node  # RunnableSeq
+        print(f"[StreamingPatch] inner type: {type(inner).__name__}", flush=True)
+        if not hasattr(inner, 'steps') or not inner.steps:
+            print(f"[StreamingPatch] no steps, inner={inner}", flush=True)
+            SYLogger.warning("[DeepAgent] model node has no steps, skip streaming patch")
+            return
+
+        step0 = inner.steps[0]  # RunnableCallable(trace=False, afunc=amodel_node)
+        print(f"[StreamingPatch] step0 type: {type(step0).__name__}, trace={getattr(step0, 'trace', 'N/A')}", flush=True)
+        afunc = getattr(step0, "afunc", None)  # amodel_node
+        if afunc is None or afunc.__closure__ is None:
+            SYLogger.warning("[DeepAgent] amodel_node afunc/closure 缺失, skip streaming patch")
+            return
+        print(f"[StreamingPatch] afunc: {afunc.__name__}, freevars={afunc.__code__.co_freevars}", flush=True)
+
+        # ---- 按自由变量名定位 cell（不依赖固定索引）----
+        def _cell_by_name(fn, name):
+            """从闭包函数 fn 中按 co_freevars 名取出对应 cell 对象（取不到返回 None）。"""
+            names = fn.__code__.co_freevars
+            if name not in names or fn.__closure__ is None:
+                return None
+            return fn.__closure__[names.index(name)]
+
+        exec_cell = _cell_by_name(afunc, "_execute_model_async")
+        if exec_cell is None:
+            SYLogger.warning(
+                f"[DeepAgent] amodel_node 闭包未含 _execute_model_async "
+                f"(freevars={afunc.__code__.co_freevars}), skip streaming patch")
+            return
+
+        original_execute = exec_cell.cell_contents
+        # 强校验 _execute_model_async 自身的闭包含预期三个自由变量
+        _gbm_cell = _cell_by_name(original_execute, "_get_bound_model")
+        _hmo_cell = _cell_by_name(original_execute, "_handle_model_output")
+        _name_cell = _cell_by_name(original_execute, "name")
+        if _gbm_cell is None or _hmo_cell is None:
+            SYLogger.warning(
+                f"[DeepAgent] _execute_model_async 闭包结构不符 "
+                f"(freevars={getattr(original_execute, '__code__', None) and original_execute.__code__.co_freevars}), "
+                f"skip streaming patch（降级为非流式，功能正常）")
+            return
+        _get_bound_model = _gbm_cell.cell_contents
+        _handle_model_output = _hmo_cell.cell_contents
+        _name = _name_cell.cell_contents if _name_cell is not None else None
+
+        def _clamp_max_tokens_for_model(model_, messages):
+            """在 raw_model 上执行 _clamp_max_tokens 逻辑。
+
+            由于 create_deep_agent 提取了 raw_model（绕过了 LLMWithTokenTracking 包装），
+            原本在 LLMWithTokenTracking._agenerate 中自动执行的 _clamp_max_tokens 被跳过，
+            导致 max_tokens 不随 input tokens 动态调整，当 input + max_output > context_window
+            时触发 400 错误。此函数补上这一逻辑。
+
+            注意：_get_bound_model 返回的可能是 _ChatModelBinding（RunnableBindingBase 子类），
+            需要通过 .bound 取到真正的 ChatOpenAI，否则 max_tokens 只设在 wrapper 上不生效。
+            """
+            from sycommon.config.LLMConfig import LLMConfig
+            from sycommon.config.Config import Config
+            from sycommon.llm.token_utils import clamp_max_tokens
+            try:
+                # 解包 binding wrapper，取到真正的 ChatModel
+                raw_model = getattr(model_, 'bound', model_)
+                llm_config = Config().get_llm_config(getattr(raw_model, 'model', None))
+                if not llm_config:
+                    return
+                llm_cfg = LLMConfig(**llm_config)
+                max_tokens_limit = getattr(llm_cfg, 'maxTokens', None)
+                if not max_tokens_limit:
+                    return
+                max_output = getattr(raw_model, 'max_tokens', None)
+                if not max_output:
+                    return
+                dynamic_max = clamp_max_tokens(
+                    raw_model, messages,
+                    context_window=max_tokens_limit,
+                    max_output_tokens=max_output,
+                )
+                SYLogger.debug(
+                    f"[StreamingPatch] clamp max_tokens: "
+                    f"context={max_tokens_limit}, max_output={max_output} → {dynamic_max}")
+            except Exception as e:
+                SYLogger.warning(f"[StreamingPatch] clamp max_tokens failed: {e}")
+
+        async def _patched_execute_model_async(request):
+            """替代 factory._execute_model_async: 用 astream + config 实现流式回调。"""
+            from langchain.agents.middleware.types import ModelResponse
+
+            model_, effective_response_format = _get_bound_model(request)
+            messages = request.messages
+            if request.system_message:
+                messages = [request.system_message, *messages]
+
+            # 动态调整 max_tokens，防止 input + max_output 超过上下文窗口
+            _clamp_max_tokens_for_model(model_, messages)
+
+            # 从 ContextVar 读取 LangGraph 注入的 config（含 StreamMessagesHandler）
+            config = var_child_runnable_config.get()
+
+            # 用 astream 替代 ainvoke, 每个 token 触发 on_llm_new_token
+            # 注意: ChatModel.astream() 产出的是 AIMessageChunk（BaseMessageChunk），
+            # 不是 ChatGenerationChunk，因此累加结果直接就是消息本身，没有 .message 属性。
+            chunks: list = []
+            async for chunk in model_.astream(messages, config=config):
+                chunks.append(chunk)
+
+            if not chunks:
+                # astream 无产出时降级到原始 ainvoke（不走流式）
+                SYLogger.warning("[StreamingPatch] astream returned empty, fallback to ainvoke")
+                output = await model_.ainvoke(messages, config=config)
+            else:
+                generation = chunks[0]
+                for c in chunks[1:]:
+                    generation += c
+                # astream 累加结果可能是 AIMessageChunk（多数情况）或包裹了 .message 的
+                # ChatGenerationChunk（少数自定义模型）。两种都兼容。
+                ai_message = getattr(generation, "message", generation)
+                if isinstance(ai_message, _AIC):
+                    ai_message = _AIM(
+                        content=ai_message.content,
+                        additional_kwargs=ai_message.additional_kwargs,
+                        tool_calls=ai_message.tool_calls,
+                        usage_metadata=getattr(ai_message, "usage_metadata", None),
+                        response_metadata=getattr(ai_message, "response_metadata", {}),
+                        id=ai_message.id,
+                    )
+                output = ai_message
+
+            if _name:
+                output.name = _name
+
+            handled_output = _handle_model_output(output, effective_response_format)
+            return ModelResponse(
+                result=handled_output["messages"],
+                structured_response=handled_output.get("structured_response"),
+            )
+
+        # 替换闭包 cell → amodel_node 调用 patched 版本
+        exec_cell.cell_contents = _patched_execute_model_async
+        SYLogger.info(
+            f"[DeepAgent] _execute_model_async patched (astream + config) "
+            f"| langchain={_cur.get('langchain')} core={_cur.get('langchain_core')}")
+
+
+    except Exception as e:
+        SYLogger.warning(f"[DeepAgent] streaming patch failed: {e}")
 
 
 @tool
@@ -109,6 +306,10 @@ class AgentConfig(BaseModel):
     sandbox_service_name: str = "shengye-platform-sandbox"
     sandbox_timeout: int = 300
     skills_dir: Optional[str] = None
+    # 技能是否已同步到沙箱：True 时跳过 _sync_skills_to_sandbox 的 atree 检查，
+    # 但仍会基于 skills_dir 注入 /skills（即 SkillsMiddleware 照常挂载）。
+    # 注意：不要用「把 skills_dir 置 None」来跳过同步——那会连带关闭技能注入。
+    skills_already_synced: bool = False
     memory_dir: Optional[str] = None
 
     # 工具
@@ -118,7 +319,7 @@ class AgentConfig(BaseModel):
     debug: bool = False
 
     # Rubric 评分配置
-    rubric_max_iterations: int = 3  # rubric 评估最大迭代次数（0 = 不启用）
+    rubric_max_iterations: int = 0  # rubric 评估最大迭代次数（0 = 不启用，默认关闭）
 
     class Config:
         arbitrary_types_allowed = True
@@ -197,11 +398,43 @@ class DeepAgent:
             input_state = {"messages": [HumanMessage(content=message)]}
             if rubric:
                 input_state["rubric"] = rubric
+            print(f"[DeepAgent] chat() starting stream, message={repr(message[:80])}", flush=True)
             async for chunk in self._astream_with_retry(
                 input_state,
                 max_retries=3,
                 base_delay=1.0,
             ):
+                # 🔑 详细打印 chunk 内容
+                _chunk_len = len(chunk) if isinstance(chunk, tuple) else '?'
+                if isinstance(chunk, tuple) and _chunk_len == 2:
+                    # 2-tuple: either (namespace, (msg, meta)) or (msg, meta)
+                    if isinstance(chunk[1], tuple) and len(chunk[1]) == 2:
+                        _ns = repr(chunk[0])[:30]
+                        _msg = chunk[1][0]
+                        _meta = chunk[1][1]
+                    else:
+                        _ns = '()'
+                        _msg = chunk[0]
+                        _meta = chunk[1]
+                    _msg_type = type(_msg).__name__
+                    _content = repr(str(getattr(_msg, 'content', ''))[:80])
+                    _node = _meta.get('langgraph_node', '?') if isinstance(_meta, dict) else '?'
+                    _step = _meta.get('langgraph_step', '?') if isinstance(_meta, dict) else '?'
+                    print(f"[DeepAgent] 2tuple: ns={_ns} msg={_msg_type} node={_node} step={_step} content={_content}", flush=True)
+                elif isinstance(chunk, tuple) and _chunk_len == 3:
+                    namespace_p, _tag_p, payload_p = chunk
+                    if isinstance(payload_p, tuple) and len(payload_p) == 2:
+                        _msg = payload_p[0]
+                        _meta = payload_p[1]
+                        _msg_type = type(_msg).__name__
+                        _content = repr(str(getattr(_msg, 'content', ''))[:80])
+                        _node = _meta.get('langgraph_node', '?') if isinstance(_meta, dict) else '?'
+                        _step = _meta.get('langgraph_step', '?') if isinstance(_meta, dict) else '?'
+                        print(f"[DeepAgent] 3tuple: ns={repr(namespace_p)[:30]} msg={_msg_type} node={_node} step={_step} content={_content}", flush=True)
+                    else:
+                        print(f"[DeepAgent] 3tuple: payload_type={type(payload_p).__name__}", flush=True)
+                else:
+                    print(f"[DeepAgent] chunk: type={type(chunk).__name__}", flush=True)
                 # 检查取消
                 if cancel_event and cancel_event.is_set():
                     event = ChatEventBuilder.cancelled("任务已取消")
@@ -212,8 +445,17 @@ class DeepAgent:
                     return
 
                 # 解析 chunk（subgraphs=True 格式）
+                # LangGraph v1.2+ 输出 3-tuple: (namespace, "messages", (message, metadata))
+                # 兼容旧版 2-tuple: (namespace, (message, metadata)) 或 (message, metadata)
                 namespace = ()
-                if isinstance(chunk, tuple) and len(chunk) == 2:
+                if isinstance(chunk, tuple) and len(chunk) == 3:
+                    # 新格式: (namespace, "messages", (message, metadata))
+                    namespace, _tag, payload = chunk
+                    if isinstance(payload, tuple) and len(payload) == 2:
+                        msg, metadata = payload
+                    else:
+                        continue
+                elif isinstance(chunk, tuple) and len(chunk) == 2:
                     if isinstance(chunk[1], tuple) and len(chunk[1]) == 2:
                         namespace, (msg, metadata) = chunk
                     else:
@@ -223,10 +465,29 @@ class DeepAgent:
 
                 stream_step += 1
 
+                # ===== 🔑 诊断日志：详细记录每个 chunk =====
+                _chunk_type = type(chunk).__name__
+                _msg_type = getattr(msg, '__class__.__name__', '?') if msg else 'None'
+                _ns = namespace if namespace else '()'
+                _node = metadata.get("langgraph_node", "?") if metadata else "?"
+                _step = metadata.get("langgraph_step", "?") if metadata else "?"
+                _content_preview = ""
+                if isinstance(msg, BaseMessage):
+                    _c = msg.content or ""
+                    _content_preview = repr(_c[:80]) if _c else "(empty)"
+                SYLogger.info(
+                    f"[DeepAgent #{stream_step}] chunk_type={_chunk_type} msg_type={_msg_type} "
+                    f"ns={_ns} node={_node} step={_step} content={_content_preview}")
+
                 # ===== 日志（仅关键节点） =====
                 if isinstance(msg, BaseMessage):
                     msg_type = msg.__class__.__name__
 
+                    # 🔑 跳过 subgraphs=True 导致的重复 HumanMessage
+                    # （父图和子图都会发射 HumanMessage，只处理根命名空间的）
+                    if msg_type == "HumanMessage" and namespace != ():
+                        continue
+
                     # 累积 token 统计（流式 chunk 中的 usage_metadata 兜底）
                     if msg_type in ("AIMessage", "AIMessageChunk"):
                         usage_meta = getattr(msg, "usage_metadata", None)
@@ -249,8 +510,17 @@ class DeepAgent:
                                 SYLogger.debug(
                                     f"[DeepAgent #{stream_step}] tool_call | {tc_l.get('name','?')} | args={args_str}")
                         elif not (msg.content or ""):
-                            SYLogger.debug(
-                                f"[DeepAgent #{stream_step}] chunk | (empty)")
+                            # 检查是否有 reasoning_content（思考模式下内容在 reasoning_content 而非 content）
+                            _rc = (
+                                getattr(msg, "reasoning_content", None)
+                                or getattr(msg, "additional_kwargs", {}).get("reasoning_content", None)
+                            )
+                            if _rc:
+                                SYLogger.debug(
+                                    f"[DeepAgent #{stream_step}] chunk | reasoning_content={repr(str(_rc)[:80])}")
+                            else:
+                                SYLogger.debug(
+                                    f"[DeepAgent #{stream_step}] chunk | (empty)")
                     elif msg_type == "AIMessage":
                         content_log = (msg.content or "")[:100]
                         tc_names = [tc.get('name', '?')
@@ -302,13 +572,45 @@ class DeepAgent:
                         await on_event(event)
                     yield event
 
+                print(f"[DeepAgent] post-yield: msg_type={type(msg).__name__}, is_BaseMessage={isinstance(msg, BaseMessage)}", flush=True)
+
                 if not isinstance(msg, BaseMessage):
+                    print(f"[DeepAgent] SKIPPING non-BaseMessage: {type(msg).__name__}", flush=True)
                     continue
 
                 msg_type = msg.__class__.__name__
-                content = msg.content or ""
+                raw_content = msg.content
+                # 🔑 处理 content 为 list 的情况（多模态模型）
+                if isinstance(raw_content, list):
+                    content = "".join(
+                        item.get("text", "") if isinstance(item, dict) else str(item)
+                        for item in raw_content
+                    )
+                else:
+                    content = raw_content or ""
 
                 if msg_type in ("AIMessage", "AIMessageChunk"):
+                    # 🔑 提取 reasoning_content（思考/推理内容）
+                    # 模型在 thinking 模式下会将推理过程放在 reasoning_content 字段，
+                    # 而不是 content 字段。ChatOpenAI 不提取此字段，需要手动处理。
+                    reasoning_content = (
+                        getattr(msg, "reasoning_content", None)
+                        or getattr(msg, "additional_kwargs", {}).get(
+                            "reasoning_content", None
+                        )
+                    )
+                    if reasoning_content:
+                        ai_text_content += reasoning_content
+                        event = ChatEventBuilder.ai_chunk(
+                            reasoning_content,
+                            id=getattr(msg, "id", None),
+                            agent=DEFAULT_AGENT_NAME,
+                        )
+                        event.data["reasoning"] = True
+                        if on_event:
+                            await on_event(event)
+                        yield event
+
                     # 处理 tool_call_chunks（流式分片逐步到达，args 是字符串片段）
                     tool_call_chunks = getattr(msg, "tool_call_chunks", [])
                     if tool_call_chunks:
@@ -482,6 +784,8 @@ class DeepAgent:
                 SYLogger.debug(
                     f"[DeepAgent] AI chunk done | {repr(ai_chunk_buffer[:100])}...")
 
+            print(f"[DeepAgent] FOR LOOP ENDED. stream_step={stream_step}, ai_text_content={repr(ai_text_content[:100])}, tool_calls={len(current_tool_calls)}", flush=True)
+
             # 空响应检测：模型被调用但没有产出任何文本
             if not ai_text_content and not ai_chunk_buffer:
                 SYLogger.warning(
@@ -513,12 +817,16 @@ class DeepAgent:
             yield event
 
         except asyncio.CancelledError:
+            print("[DeepAgent] chat() CancelledError!", flush=True)
             event = ChatEventBuilder.cancelled("任务已取消")
             if on_event:
                 await on_event(event)
             yield event
             raise
         except Exception as e:
+            print(f"[DeepAgent] chat() Exception: {type(e).__name__}: {e}", flush=True)
+            import traceback
+            traceback.print_exc()
             SYLogger.error(f"[DeepAgent] 聊天异常: {e}")
             event = ChatEventBuilder.error(str(e))
             if on_event:
@@ -533,7 +841,13 @@ class DeepAgent:
 
     def _parse_chunk(self, chunk) -> Tuple[Optional[BaseMessage], Optional[Dict]]:
         """解析流式响应的 chunk"""
-        if isinstance(chunk, tuple) and len(chunk) == 2:
+        if isinstance(chunk, tuple) and len(chunk) == 3:
+            # LangGraph v1.2+: (namespace, "messages", (message, metadata))
+            _ns, _tag, payload = chunk
+            if isinstance(payload, tuple) and len(payload) == 2:
+                msg, metadata = payload
+                return msg, metadata
+        elif isinstance(chunk, tuple) and len(chunk) == 2:
             if isinstance(chunk[1], tuple) and len(chunk[1]) == 2:
                 _, (msg, metadata) = chunk
             else:
@@ -561,19 +875,27 @@ class DeepAgent:
         sandbox_retries = 0
         max_sandbox_retries = 3
 
-        while True:
+        try:
+          while True:
             for attempt in range(max_retries):
                 try:
+                    print(f"[DeepAgent] _astream_with_retry: attempt={attempt}, starting astream...", flush=True)
+                    chunk_count = 0
                     async for chunk in self.agent.astream(
                         input_data,
                         config=self.config,
                         stream_mode="messages",
                         subgraphs=True
                     ):
+                        chunk_count += 1
+                        print(f"[DeepAgent] _astream yielding chunk #{chunk_count}", flush=True)
                         yield chunk
+                        print(f"[DeepAgent] _astream yield returned, consumer processed chunk #{chunk_count}", flush=True)
+                    print(f"[DeepAgent] _astream_with_retry: stream ended normally, total_chunks={chunk_count}", flush=True)
                     return
                 except (APIConnectionError, APIError, APITimeoutError, ConnectionError, httpx.RemoteProtocolError) as e:
                     last_error = e
+                    print(f"[DeepAgent] _astream_with_retry: API error: {type(e).__name__}: {e}", flush=True)
                     if attempt < max_retries - 1:
                         delay = base_delay * (2 ** attempt)
                         SYLogger.warning(
@@ -609,6 +931,12 @@ class DeepAgent:
                     raise
             else:
                 break
+        except GeneratorExit:
+            print("[DeepAgent] _astream_with_retry: GeneratorExit! Consumer closed the generator!", flush=True)
+            raise
+        except Exception as e:
+            print(f"[DeepAgent] _astream_with_retry: Unexpected exception: {type(e).__name__}: {e}", flush=True)
+            raise
 
 
 async def create_deep_agent(
@@ -651,6 +979,18 @@ async def create_deep_agent(
         wrap_structured=False,
     )
 
+    # 🔑 提取底层 ChatOpenAI 原始模型
+    # LLMWithTokenTracking 重写了 _agenerate（非流式路径），
+    # 导致 ainvoke 不走 astream 路径。
+    # 本文件的 _patch_agent_streaming() 会替换模型节点的 _execute_model_async，
+    # 改用 model.astream() 触发流式回调；提取 raw_model 确保 astream / bind_tools
+    # 等方法在原始 ChatOpenAI 上工作，而不是被 LLMWithTokenTracking 的包装拦截。
+    raw_model = getattr(model, 'llm', model)
+    if raw_model is not model:
+        print(f"[DeepAgent] 提取原始模型: {type(model).__name__} → {type(raw_model).__name__}", flush=True)
+        if hasattr(raw_model, 'streaming'):
+            raw_model.streaming = True
+
     # 创建 checkpointer
     if checkpointer is None:
         from sycommon.database.pg_checkpoint_service import PgCheckpointService
@@ -664,13 +1004,15 @@ async def create_deep_agent(
     agent_config = {"configurable": {"thread_id": tid}}
 
     # 确定沙箱路径
-    # skills_dir: 本地目录路径 → 同步到沙箱 /skills（仅上传沙箱中不存在的技能目录）
+    # skills_dir: 本地目录路径 → 注入沙箱 /skills（SkillsMiddleware 据此挂载）
     # memory_dir: 非路径字符串 → 标记启用沙箱 /memory/AGENTS.md
     skills_path = "/skills" if config.skills_dir else None
     memory_path = "/memory/AGENTS.md" if config.memory_dir else None
 
     # 同步 skills 到沙箱（按目录名检查，已存在则跳过）
-    if config.skills_dir and sandbox_backend:
+    # 仅在未同步过时执行 atree 检查 + 上传；skills_already_synced=True 时跳过同步，
+    # 但 skills_path 注入不受影响，确保 SkillsMiddleware 始终能挂载。
+    if config.skills_dir and sandbox_backend and not config.skills_already_synced:
         await _sync_skills_to_sandbox(config.skills_dir, sandbox_backend)
 
     # 创建 agent
@@ -706,7 +1048,7 @@ async def create_deep_agent(
         ))
 
     agent_kwargs = {
-        "model": model,
+        "model": raw_model,
         "tools": config.tools or [get_current_date],
         "backend": sandbox_backend,
         "checkpointer": checkpointer,
@@ -719,7 +1061,36 @@ async def create_deep_agent(
     if memory_path:
         agent_kwargs["memory"] = [memory_path]
 
+    # 🔑 RunnableCallable trace=True monkey-patch
+    # 确保 LangGraph 的回调链传播到所有子 runnable，
+    # 使 var_child_runnable_config ContextVar 能被正确设置。
+    _original_rc_init = None
+    try:
+        from langgraph._internal._runnable import RunnableCallable
+
+        _original_rc_init = RunnableCallable.__init__
+
+        def _patched_rc_init(self_, *args, **kwargs):
+            kwargs['trace'] = True
+            _original_rc_init(self_, *args, **kwargs)
+
+        RunnableCallable.__init__ = _patched_rc_init
+    except Exception as _patch_err:
+        SYLogger.warning(f"[DeepAgent] RunnableCallable monkey-patch FAILED: {_patch_err}")
+
     agent = _create_deep_agent(**agent_kwargs)
+    print(f"[DeepAgent] Agent created, type={type(agent).__name__}", flush=True)
+
+    # 恢复原始 __init__
+    if _original_rc_init is not None:
+        try:
+            RunnableCallable.__init__ = _original_rc_init
+        except Exception:
+            pass
+
+    # 🔑 Patch _execute_model_async: 将 ainvoke 替换为 astream + config
+    # 修复 stream_mode="messages" 只返回 1 chunk 的问题
+    _patch_agent_streaming(agent)
 
     recovery_manager = SandboxRecoveryManager(sandbox_backend)
 

{sycommon_python_lib-0.2.5a27 → sycommon_python_lib-0.2.5a29}/src/sycommon/agent/multi_agent_team.py

@@ -271,6 +271,24 @@ class MultiAgentTeam:
                 content = msg.content or ""
 
                 if msg_type in ("AIMessage", "AIMessageChunk"):
+                    # 🔑 提取 reasoning_content（思考/推理内容）
+                    reasoning_content = (
+                        getattr(msg, "reasoning_content", None)
+                        or getattr(msg, "additional_kwargs", {}).get(
+                            "reasoning_content", None
+                        )
+                    )
+                    if reasoning_content:
+                        event = ChatEventBuilder.ai_chunk(
+                            reasoning_content,
+                            id=getattr(msg, "id", None),
+                            agent=current_agent,
+                        )
+                        event.data["reasoning"] = True
+                        if on_event:
+                            await on_event(event)
+                        yield event
+
                     tool_calls = getattr(msg, "tool_calls", [])
 
                     if tool_calls: