langchain-agentx-python 1.2.2__tar.gz → 1.2.3__tar.gz

{langchain-agentx-python-1.2.2/langchain_agentx_python.egg-info → langchain-agentx-python-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 1.2.2
+Version: 1.2.3
 Summary: LangChain/LangGraph-based agent utilities for CodeBaseX.
 Author-email: GoodMood2008 <GoodMood2008@users.noreply.github.com>
 License:                                  Apache License

{langchain-agentx-python-1.2.2 → langchain-agentx-python-1.2.3}/langchain_agentx/__init__.py

@@ -11,7 +11,7 @@ from langchain_agentx import create_loop_agent
 ```
 """
 
-__version__ = "1.2.2"
+__version__ = "1.2.3"
 
 from .loop import (  # noqa: F401
     create_loop_agent,

{langchain-agentx-python-1.2.2 → langchain-agentx-python-1.2.3}/langchain_agentx/loop/config/loop_config.py

@@ -43,11 +43,13 @@ class PromptConfig:
         - QueryParams.systemPrompt → system
         - options.customSystemPrompt → override_system
         - options.appendSystemPrompt → append_system
+        - options.thinkingConfig → thinking_enabled
     """
     system: str | SystemMessage | None = None
     override_system: str | None = None
     append_system: str | None = None
     dynamic_sections: tuple[SystemPromptSection, ...] = ()
+    thinking_enabled: bool = True  # 是否启用 thinking（对齐 CC thinkingConfig）
 
 
 @dataclass(frozen=True)

langchain-agentx-python-1.2.3/langchain_agentx/loop/config/thinking_config.py

@@ -0,0 +1,105 @@
+"""loop/config/thinking_config.py — Thinking 生成配置
+
+职责：
+    定义 ThinkingConfig 数据类，根据 subagent mode (plain/fork/coordinate)
+    决定是否启用 thinking 功能。
+
+链路位置：
+    SubagentOrchestrator → ThinkingConfig.from_subagent_mode() →
+    SubagentContext.thinking_enabled → AgentLoopConfig
+
+当前裁剪范围：
+    v1 基础实现：mode 驱动启用/禁用；预留父配置覆盖路径。
+
+CC 对齐：
+    - runAgent.ts:682-683: plain mode 默认 { type: 'disabled' }
+    - fork mode 继承父配置或默认启用
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal
+
+
+@dataclass(frozen=True)
+class ThinkingConfig:
+    """Thinking 生成配置（对齐 CC thinkingConfig）。
+
+    Attributes:
+        enabled: 是否启用 thinking
+        type: Thinking 类型（预留，对齐 CC { type: 'enabled' | 'disabled' }）
+        budget_tokens: Thinking token 预算（预留）
+    """
+    enabled: bool = True
+    type: Literal["enabled", "disabled", "auto"] = "auto"
+    budget_tokens: int | None = None
+
+    @classmethod
+    def disabled(cls) -> "ThinkingConfig":
+        """返回禁用配置（对齐 CC { type: 'disabled' }）。"""
+        return cls(enabled=False, type="disabled")
+
+    @classmethod
+    def enabled_config(cls) -> "ThinkingConfig":
+        """返回启用配置（对齐 CC { type: 'enabled' }）。"""
+        return cls(enabled=True, type="enabled")
+
+    @classmethod
+    def from_subagent_mode(
+        cls,
+        mode: str,
+        parent_thinking_config: Any | None = None,
+        *,
+        parent_thinking_enabled: bool | None = None,
+    ) -> "ThinkingConfig":
+        """根据 subagent mode 决定是否启用 thinking。
+
+        CC 对齐规则：
+        - plain mode: 禁用 thinking（除非父配置显式启用）
+        - fork mode: 继承父 thinking_enabled / thinkingConfig（对齐 runAgent useExactTools）
+        - coordinate mode: 同 fork，继承父配置
+
+        Args:
+            mode: Subagent 模式 ("plain" | "fork" | "coordinate")
+            parent_thinking_config: 父 ThinkingConfig 或 dict（优先于 mode 规则）
+            parent_thinking_enabled: 父 ToolExecutionContext.thinking_enabled（fork/coordinate 继承）
+
+        Returns:
+            ThinkingConfig 实例
+        """
+        # 优先级 1：父显式 thinkingConfig
+        if parent_thinking_config is not None:
+            if isinstance(parent_thinking_config, dict):
+                parent_enabled = parent_thinking_config.get("enabled", True)
+                parent_type = parent_thinking_config.get("type", "auto")
+                return cls(
+                    enabled=parent_enabled,
+                    type=parent_type if parent_type in ("enabled", "disabled", "auto") else "auto",
+                )
+            elif isinstance(parent_thinking_config, ThinkingConfig):
+                return parent_thinking_config
+
+        # 优先级 2：mode 规则
+        if mode == "plain":
+            return cls.disabled()
+
+        # fork / coordinate：继承父 loop thinking_enabled（CC fork inherit）
+        if parent_thinking_enabled is not None:
+            enabled = bool(parent_thinking_enabled)
+            return cls(
+                enabled=enabled,
+                type="enabled" if enabled else "disabled",
+            )
+
+        return cls.enabled_config()
+
+    def to_dict(self) -> dict[str, Any]:
+        """转换为字典（传递给 Provider）。"""
+        return {
+            "enabled": self.enabled,
+            "type": self.type,
+        }
+
+
+__all__ = ["ThinkingConfig"]

langchain-agentx-python-1.2.3/langchain_agentx/loop/config/ui_display_context.py

@@ -0,0 +1,58 @@
+"""loop/config/ui_display_context.py — UI 展示意图（CLI → SDK seam）
+
+职责：
+    定义宿主（CLI）注入的 transcript / verbose / thinking 展示意图；
+    供 ToolExecutionContext 与 SubagentOrchestrator 读取。
+
+链路位置：
+    RunnableConfig.configurable["ui_display_context"] → LangChainAdapter → ToolExecutionContext
+
+当前裁剪范围：
+    仅数据契约与解析；不做 TUI 渲染（langchain_agentx_cli 职责）。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+@dataclass(frozen=True)
+class UiDisplayContext:
+    """宿主 UI 展示意图（对齐 CC verbose + isTranscriptMode）。"""
+
+    is_transcript_mode: bool = False
+    verbose: bool = False
+    thinking_enabled: bool | None = None
+
+    @classmethod
+    def from_mapping(cls, raw: Mapping[str, Any] | None) -> UiDisplayContext | None:
+        if not raw or not isinstance(raw, Mapping):
+            return None
+        is_transcript = bool(raw.get("is_transcript_mode", False))
+        verbose = bool(raw.get("verbose", False))
+        thinking_raw = raw.get("thinking_enabled")
+        thinking_enabled = None if thinking_raw is None else bool(thinking_raw)
+        return cls(
+            is_transcript_mode=is_transcript,
+            verbose=verbose,
+            thinking_enabled=thinking_enabled,
+        )
+
+    @classmethod
+    def from_configurable(cls, configurable: Mapping[str, Any] | None) -> UiDisplayContext | None:
+        if not configurable:
+            return None
+        raw = configurable.get("ui_display_context")
+        if isinstance(raw, UiDisplayContext):
+            return raw
+        if isinstance(raw, Mapping):
+            return cls.from_mapping(raw)
+        return None
+
+    def should_show_thinking_full(self) -> bool:
+        """对齐 CC Message.tsx：verbose || isTranscriptMode 时展示完整 thinking。"""
+        return self.verbose or self.is_transcript_mode
+
+
+__all__ = ["UiDisplayContext"]

{langchain-agentx-python-1.2.2 → langchain-agentx-python-1.2.3}/langchain_agentx/loop/graph/factory.py

@@ -302,6 +302,7 @@ def _flatten_config_for_runtime(config: AgentLoopConfig) -> _FlatLoopConfig:
         model_profile_registry=config.model_profile_registry,
         compact_buffer_tokens=config.compact_buffer_tokens,
         max_output_tokens_reserved=config.max_output_tokens_reserved,
+        thinking_enabled=config.prompt.thinking_enabled,
     )
 
 

{langchain-agentx-python-1.2.2 → langchain-agentx-python-1.2.3}/langchain_agentx/loop/model/model_node.py

@@ -447,6 +447,38 @@ class ModelNode(Runnable):
         store = (config.get("configurable", {}) or {}).get("session_store")
         return get_effort_override(store)
 
+    @staticmethod
+    def _get_thinking_enabled_from_config(config: RunnableConfig | None) -> bool | None:
+        """从 runtime config 读取 thinking_enabled intent（bool，非 vendor kwargs）。"""
+        if not isinstance(config, dict):
+            return None
+        configurable = config.get("configurable", {}) or {}
+        loop_config = configurable.get("loop_config")
+        if loop_config is not None and hasattr(loop_config, "get"):
+            return bool(loop_config.get("thinking_enabled", True))
+        return None
+
+    @staticmethod
+    def _thinking_invoke_kwargs(model: Any, config: RunnableConfig | None) -> dict[str, Any]:
+        """按 provider family 决定是否在 invoke 时传入 Claude thinking kwargs。
+
+        对实际 invoke 目标做 unwrap（Corrector / RunnableBinding），避免外层 wrapper
+        导致 family 误判从而跳过 thinking。
+        """
+        thinking_enabled = ModelNode._get_thinking_enabled_from_config(config)
+        if thinking_enabled is None:
+            return {}
+        from langchain_agentx.provider.semantics.profile import (
+            get_default_profile_resolver,
+            unwrap_chat_model_for_profile,
+        )
+
+        chat_model = unwrap_chat_model_for_profile(model)
+        profile = get_default_profile_resolver().resolve_from_model_instance(chat_model)
+        if profile.family != "anthropic":
+            return {}
+        return {"thinking": {"type": "enabled" if thinking_enabled else "disabled"}}
+
     # ===== 模型调用 =====
 
     def _invoke_bound(self, req: Any, *, config: RunnableConfig | None = None) -> Any:
@@ -465,7 +497,8 @@ class ModelNode(Runnable):
         )
         model_ = self._bind_llm_callback_handler(model_, config)
         messages = _messages_for_model_invoke(req)
-        output = model_.invoke(messages, config=config)
+        thinking_kwargs = self._thinking_invoke_kwargs(model_, config)
+        output = model_.invoke(messages, config=config, **thinking_kwargs)
         if self._name:
             output.name = self._name
         handled_output = handle_model_output(
@@ -496,7 +529,8 @@ class ModelNode(Runnable):
         )
         model_ = self._bind_llm_callback_handler(model_, config)
         messages = _messages_for_model_invoke(req)
-        output = await model_.ainvoke(messages, config=config)
+        thinking_kwargs = self._thinking_invoke_kwargs(model_, config)
+        output = await model_.ainvoke(messages, config=config, **thinking_kwargs)
         if self._name:
             output.name = self._name
         handled_output = handle_model_output(

{langchain-agentx-python-1.2.2 → langchain-agentx-python-1.2.3}/langchain_agentx/loop/subagent/context.py

@@ -27,7 +27,7 @@ import shutil
 import uuid
 from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import Any
+from typing import Any, Literal
 
 from langchain_agentx.loop.context.query_source import LoopCompilationContext, QuerySource
 from langchain_agentx.loop.runtime.subagent_execution_paths import (
@@ -97,6 +97,10 @@ class SubagentContext:
     can_use_tool: Callable[[str, dict[str, Any]], bool] | None = None
     register_transcript: bool = True
 
+    # Thinking 与显示控制字段（对齐 CC thinkingConfig + isTranscriptMode）
+    thinking_enabled: bool = True  # 是否启用 thinking（默认启用，plain mode 会被禁用）
+    display_mode: Literal["default", "transcript"] = "default"  # 显示模式（transcript 显示详细内容）
+
 
 @dataclass
 class SubagentResult:
@@ -137,6 +141,8 @@ def create_subagent_context(
     fork_worktree_parent_cwd: str | None = None,
     fork_worktree_path: str | None = None,
     available_tools: list[Any] | None = None,
+    thinking_enabled: bool = True,
+    display_mode: Literal["default", "transcript"] = "default",
 ) -> SubagentContext:
     """工厂函数：从父上下文创建子 Agent 上下文
 
@@ -158,6 +164,8 @@ def create_subagent_context(
             在最终任务 user 消息前插入 CC 等价 worktree 提示（父 cwd 由 ``fork_worktree_parent_cwd`` 提供）。
         fork_worktree_parent_cwd: 父 Agent 工作目录（须在 ``run_with_cwd_override`` 子 cwd 生效前由编排层捕获）。
         fork_worktree_path: 子 Agent 的 worktree 根路径（通常即 ``path_prep.worktree_dir``）。
+        thinking_enabled: 是否启用 thinking（由 SubagentOrchestrator 根据 mode 决定）
+        display_mode: 显示模式（"default" | "transcript"）
 
     Returns:
         SubagentContext 实例
@@ -291,6 +299,8 @@ def create_subagent_context(
         capabilities=getattr(parent_ctx, "capabilities", None),
         runnable_config=getattr(parent_ctx, "runnable_config", None),
         available_tools=list(available_tools or []),
+        thinking_enabled=thinking_enabled,
+        display_mode=display_mode,
     )
 
 

langchain-agentx-python-1.2.3/langchain_agentx/loop/subagent/display_projector.py

@@ -0,0 +1,45 @@
+"""loop/subagent/display_projector.py — Subagent execution_trace → UI 投影
+
+职责：
+    将 SubagentExecutionTrace 投影为 present_for_display 的 tool_calls 列表；
+    default 摘要 / transcript 全量由 display_mode 决定（trace 对象内仍全量）。
+
+链路位置：
+    AgentRuntimeTool.present_for_display → SubagentDisplayProjector
+
+当前裁剪范围：
+    仅 dict 投影；不渲染 TUI。
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from langchain_agentx.loop.subagent.progress import SubagentExecutionTrace
+
+
+class SubagentDisplayProjector:
+    """execution_trace → present_for_display 字段投影。"""
+
+    @staticmethod
+    def project_tool_calls(
+        trace: SubagentExecutionTrace,
+        *,
+        display_mode: Literal["default", "transcript"] | None = None,
+    ) -> list[dict[str, Any]]:
+        mode = display_mode if display_mode is not None else trace.display_mode
+        return trace.to_dict_list(display_mode=mode)
+
+    @staticmethod
+    def resolve_display_mode(
+        trace: SubagentExecutionTrace | None,
+        ctx_display_mode: Literal["default", "transcript"] | None = None,
+    ) -> Literal["default", "transcript"]:
+        if ctx_display_mode in ("default", "transcript"):
+            return ctx_display_mode
+        if trace is not None:
+            return trace.display_mode
+        return "default"
+
+
+__all__ = ["SubagentDisplayProjector"]

{langchain-agentx-python-1.2.2 → langchain-agentx-python-1.2.3}/langchain_agentx/loop/subagent/graph.py

@@ -65,7 +65,10 @@ def create_subagent_graph(
     # Phase 3: config-first 模式
     config = AgentLoopConfig(
         session_id=session_id,
-        prompt=PromptConfig(system=ctx.system_prompt or None),
+        prompt=PromptConfig(
+            system=ctx.system_prompt or None,
+            thinking_enabled=ctx.thinking_enabled,
+        ),
         workspace=AgentStateConfig(
             workspace_root=ctx.workspace_root or None,
             agent_home_segment=ctx.agent_home_segment,

{langchain-agentx-python-1.2.2 → langchain-agentx-python-1.2.3}/langchain_agentx/loop/subagent/orchestrator.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 import logging
 import os
 import uuid
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 from langchain_agentx.loop.runtime import RuntimeContextFactory, SubagentContextOverrides
 from langchain_agentx.loop.runtime.subagent_execution_paths import (
@@ -41,6 +41,7 @@ from langchain_agentx.loop.subagent.runner import (
 from langchain_agentx.loop.subagent.async_runner import register_background_agent
 from langchain_agentx.observability.logging import ObservabilityLoggerAdapter, build_log_context
 from langchain_agentx.workspace import resolve_agent_state_config
+from langchain_agentx.loop.config.thinking_config import ThinkingConfig
 
 if TYPE_CHECKING:
     from langchain_agentx.loop.runtime import AgentLoopConfig
@@ -71,6 +72,39 @@ class SubagentOrchestrator:
         self._mode = mode
         self._background_output_dir = background_output_dir
 
+    def _resolve_thinking_enabled(
+        self,
+        parent_ctx: "ToolExecutionContext",
+    ) -> bool:
+        """解析 subagent 的 thinking 启用状态（对齐 CC thinkingConfig）。
+
+        CC 对齐规则：
+        - plain mode: 禁用 thinking（{ type: 'disabled' }）
+        - fork mode: 继承父配置或默认启用
+        - coordinate mode: 继承父配置或默认启用
+        """
+        # 从父上下文获取 thinking 配置（如果有）
+        parent_thinking_config = getattr(parent_ctx, "thinking_config", None)
+        parent_thinking_enabled = getattr(parent_ctx, "thinking_enabled", None)
+        config = ThinkingConfig.from_subagent_mode(
+            self._mode,
+            parent_thinking_config,
+            parent_thinking_enabled=parent_thinking_enabled,
+        )
+        return config.enabled
+
+    def _resolve_display_mode(
+        self,
+        parent_ctx: "ToolExecutionContext",
+    ) -> Literal["default", "transcript"]:
+        """解析显示模式（对齐 CC isTranscriptMode）。
+
+        从父上下文读取 transcript 模式标志；默认为 default。
+        """
+        if getattr(parent_ctx, "is_transcript_mode", False):
+            return "transcript"
+        return "default"
+
     def invoke_subagent(
         self,
         inp: "AgentToolInput",
@@ -166,6 +200,11 @@ class SubagentOrchestrator:
         inject_fork_wt = self._mode == "fork" and prepared.worktree_dir is not None
         with run_with_cwd_override(effective_cwd):
             output_dir = self._resolve_background_output_dir(runtime_ctx)
+
+            # 解析 thinking_enabled 和 display_mode
+            thinking_enabled = self._resolve_thinking_enabled(ctx)
+            display_mode = self._resolve_display_mode(ctx)
+
             subagent_ctx = create_subagent_context(
                 parent_ctx=ctx,
                 task=subagent_task,
@@ -183,6 +222,8 @@ class SubagentOrchestrator:
                 fork_worktree_parent_cwd=parent_notice_cwd,
                 fork_worktree_path=prepared.worktree_dir,
                 available_tools=runtime_tools,
+                thinking_enabled=thinking_enabled,
+                display_mode=display_mode,
             )
             scope = propagate_subagent_tool_scope(
                 parent_ctx=ctx,
@@ -359,6 +400,11 @@ class SubagentOrchestrator:
         inject_fork_wt = self._mode == "fork" and prepared.worktree_dir is not None
         with run_with_cwd_override(effective_cwd):
             output_dir = self._resolve_background_output_dir(runtime_ctx)
+
+            # 解析 thinking_enabled 和 display_mode
+            thinking_enabled = self._resolve_thinking_enabled(ctx)
+            display_mode = self._resolve_display_mode(ctx)
+
             subagent_ctx = create_subagent_context(
                 parent_ctx=ctx,
                 task=subagent_task,
@@ -376,6 +422,8 @@ class SubagentOrchestrator:
                 fork_worktree_parent_cwd=parent_notice_cwd,
                 fork_worktree_path=prepared.worktree_dir,
                 available_tools=runtime_tools,
+                thinking_enabled=thinking_enabled,
+                display_mode=display_mode,
             )
             scope = propagate_subagent_tool_scope(
                 parent_ctx=ctx,

{langchain-agentx-python-1.2.2 → langchain-agentx-python-1.2.3}/langchain_agentx/loop/subagent/progress.py

@@ -21,6 +21,9 @@ class SubagentToolCall:
     error_message: str | None = None
     payload: str | None = None
     meta: dict[str, Any] = field(default_factory=dict)
+    # Phase 8: thinking 内容（对齐 CC reasoning_content）
+    thinking_content: str | None = None
+    display_mode: Literal["default", "transcript"] = "default"
 
 
 @dataclass
@@ -33,11 +36,47 @@ class SubagentExecutionTrace:
     tool_calls: list[SubagentToolCall] = field(default_factory=list)
     total_steps: int = 0
     terminal_reason: str | None = None
+    display_mode: Literal["default", "transcript"] = "default"  # Phase 8: 显示模式
+    _pending_thinking_content: str | None = field(default=None, repr=False)
 
     def add_tool_call(self, call: SubagentToolCall) -> None:
         """添加工具调用记录。"""
         self.tool_calls.append(call)
         self.total_steps = max(self.total_steps, call.step)
+        self.apply_pending_thinking(step=call.step)
+
+    def stage_thinking_content(self, thinking_content: str) -> None:
+        """暂存 model 步 reasoning，待下一 tool_call 或 flush 时写入。"""
+        if not thinking_content:
+            return
+        self._pending_thinking_content = thinking_content
+
+    def apply_pending_thinking(self, *, step: int) -> None:
+        """将暂存 reasoning 写入指定 step 的 tool_call。"""
+        if not self._pending_thinking_content:
+            return
+        self.add_thinking_content(step=step, thinking_content=self._pending_thinking_content)
+        self._pending_thinking_content = None
+
+    def attach_thinking_to_last_call(self, thinking_content: str) -> None:
+        """将 reasoning 挂到最后一个 tool_call（无后续 tool 的最终 model 步）。"""
+        if not thinking_content or not self.tool_calls:
+            return
+        last = self.tool_calls[-1]
+        last.thinking_content = thinking_content
+
+    def add_thinking_content(self, step: int, thinking_content: str) -> None:
+        """添加 thinking 内容到最近的工具调用（Phase 8）。
+
+        用于记录模型的 reasoning_content，在 transcript 模式下展示。
+        """
+        if not thinking_content:
+            return
+        # 查找对应的工具调用
+        for call in self.tool_calls:
+            if call.step == step:
+                call.thinking_content = thinking_content
+                break
 
     def update_last_status(
         self,
@@ -57,17 +96,37 @@ class SubagentExecutionTrace:
             if error_message:
                 last.error_message = error_message
 
-    def to_dict_list(self) -> list[dict[str, Any]]:
-        """转换为字典列表，用于 JSON 序列化。"""
+    def to_dict_list(self, *, display_mode: Literal["default", "transcript"] | None = None) -> list[dict[str, Any]]:
+        """转换为字典列表，用于 JSON 序列化。
+
+        Args:
+            display_mode: 显示模式
+                - None: 使用 trace.display_mode（默认）
+                - "default": 仅返回摘要（step, tool_name, summary, status）
+                - "transcript": 返回完整信息（含 tool_input, payload, thinking_content）
+        """
+        effective_mode = display_mode if display_mode is not None else self.display_mode
+        if effective_mode == "transcript":
+            return [
+                {
+                    "step": c.step,
+                    "tool_name": c.tool_name,
+                    "tool_input": c.tool_input,
+                    "summary": c.summary,
+                    "status": c.status,
+                    "error_message": c.error_message,
+                    "payload": c.payload,
+                    "thinking_content": c.thinking_content,
+                }
+                for c in self.tool_calls
+            ]
+        # default 模式：仅返回摘要
         return [
             {
                 "step": c.step,
                 "tool_name": c.tool_name,
-                "tool_input": c.tool_input,
                 "summary": c.summary,
                 "status": c.status,
-                "error_message": c.error_message,
-                "payload": c.payload,
             }
             for c in self.tool_calls
         ]

langchain-agentx-python-1.2.3/langchain_agentx/loop/subagent/reasoning_extractor.py

@@ -0,0 +1,42 @@
+"""loop/subagent/reasoning_extractor.py — 子 Agent 模型响应 reasoning 抽取
+
+职责：
+    从 AIMessage 按 provider family 抽取 reasoning_text（Claude thinking / OpenAI reasoning_content）。
+
+链路位置：
+    runner._handle_chat_model_end_event → SubagentReasoningExtractor → execution_trace
+
+当前裁剪范围：
+    仅 subagent runner 使用；不做 UI 渲染或 trace 持久化。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from langchain_agentx.provider.semantics.runtime import (
+    create_runtime_from_messages,
+    create_runtime_from_model,
+)
+
+
+class SubagentReasoningExtractor:
+    """从 model 响应抽取 reasoning 文本（委托 ProviderSemanticsRuntime）。"""
+
+    def __init__(self, model: Any | None = None) -> None:
+        self._model = model
+
+    def extract(self, message: Any) -> str:
+        if message is None:
+            return ""
+        if self._model is not None and not isinstance(self._model, str):
+            runtime = create_runtime_from_model(self._model)
+        else:
+            runtime = create_runtime_from_messages([message])
+        turn = runtime.normalize_model_end(message)
+        if turn is None or not turn.reasoning_text:
+            return ""
+        return str(turn.reasoning_text).strip()
+
+
+__all__ = ["SubagentReasoningExtractor"]

{langchain-agentx-python-1.2.2 → langchain-agentx-python-1.2.3}/langchain_agentx/loop/subagent/runner.py

@@ -382,10 +382,26 @@ async def _handle_chat_model_end_event(
     data: dict[str, Any],
     collected_assistant_messages: list[Any],
     total_steps: int,
+    trace: SubagentExecutionTrace | None = None,
+    model: Any | None = None,
 ) -> int:
     output = data.get("output")
     if output is not None:
         collected_assistant_messages.append(output)
+        if trace is not None:
+            from langchain_agentx.loop.subagent.reasoning_extractor import (
+                SubagentReasoningExtractor,
+            )
+
+            reasoning = SubagentReasoningExtractor(model=model).extract(output)
+            if reasoning:
+                has_tool_calls = bool(getattr(output, "tool_calls", None))
+                if has_tool_calls:
+                    trace.stage_thinking_content(reasoning)
+                elif trace.tool_calls:
+                    trace.attach_thinking_to_last_call(reasoning)
+                else:
+                    trace.stage_thinking_content(reasoning)
     has_tool_calls = bool(output is not None and getattr(output, "tool_calls", None))
     if not has_tool_calls:
         total_steps += 1
@@ -491,6 +507,8 @@ async def _collect_subagent_events(
                     data=data,
                     collected_assistant_messages=collected_assistant_messages,
                     total_steps=total_steps,
+                    trace=trace,
+                    model=getattr(ctx, "model", None),
                 )
             elif event_name == "on_chain_end" and event.get("name") == "LangGraph":
                 terminal_reason, child_run_id, loop_snapshot = _handle_langgraph_end_event(
@@ -621,7 +639,8 @@ async def run_subagent(
         )
     else:
         transcript = NoOpTranscriptManager()
-    trace = SubagentExecutionTrace()
+    # Phase 8: 使用 ctx.display_mode 设置 trace 的显示模式
+    trace = SubagentExecutionTrace(display_mode=ctx.display_mode)
 
     try:
         graph = create_subagent_graph(ctx=ctx, loader=loader, model=resolved_model)

{langchain-agentx-python-1.2.2 → langchain-agentx-python-1.2.3}/langchain_agentx/provider/compatible_chat_openai.py

@@ -58,8 +58,11 @@ class CompatibleChatOpenAI(ChatOpenAI):
         **kwargs: Any,
     ) -> dict[str, Any]:
         """与基类一致，并为 chat/completions 的 assistant 历史补上 ``reasoning_content``。"""
+        kwargs.pop("thinking_enabled", None)
+        kwargs.pop("thinking", None)
         lc_messages = self._convert_input(input_).to_messages()
         payload = super()._get_request_payload(input_, stop=stop, **kwargs)
+        payload.pop("thinking", None)
         serialized = payload.get("messages")
         if not isinstance(serialized, list) or len(serialized) != len(lc_messages):
             return payload