langchain-agentx-python 0.8.6__tar.gz → 0.9.0__tar.gz

{langchain-agentx-python-0.8.6/langchain_agentx_python.egg-info → langchain-agentx-python-0.9.0}/PKG-INFO

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

{langchain-agentx-python-0.8.6 → langchain-agentx-python-0.9.0}/langchain_agentx/__init__.py

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

{langchain-agentx-python-0.8.6 → langchain-agentx-python-0.9.0}/langchain_agentx/loop/config/loop_config.py

@@ -99,19 +99,77 @@ class SubagentLinkage:
     parent_agent_id: str | None = None
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, init=False)
 class ToolExecutionEngineConfig:
-    """工具执行引擎模式（A20）。
+    """工具执行引擎并发配置（Phase B/C：仅 max_parallelism；CC env 对齐）。
+
+    紧急全串行回滚：``max_parallelism=1``。
+    省略 ``max_parallelism``（``None``）时由 env / 默认 10 解析，见
+    ``resolve_effective_max_parallelism`` 与 ``resolved_max_parallelism()``。
 
-    mode:
-        readonly_parallel — 默认；安全批受控并发（A20 Phase 5）
-        serial_safe — 新引擎全串行（保守灰度）
-        toolnode — LangGraph ToolNode（长期回滚路径）
+    优先级（Phase C）：显式 ``max_parallelism`` > env
+    ``LANGCHAIN_AGENTX_MAX_TOOL_PARALLELISM`` >
+    ``CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY`` > 默认 10（对齐 CC）。
     """
-    mode: str = "readonly_parallel"
-    max_parallelism: int = 4
-    enable_parity_probe: bool = False
-    fallback_to_toolnode: bool = True
+    max_parallelism: int | None
+    enable_parity_probe: bool
+
+    def __post_init__(self) -> None:
+        if self.max_parallelism is None:
+            return
+        if self.max_parallelism < 1:
+            raise ValueError(
+                f"tool_execution_engine.max_parallelism={self.max_parallelism!r} is invalid; "
+                "expected an integer >= 1."
+            )
+
+    def resolved_max_parallelism(self) -> int:
+        """effective max_parallelism（含 env 与默认值）。"""
+        from .tool_execution_engine_resolver import resolve_effective_max_parallelism
+
+        return resolve_effective_max_parallelism(self)
+
+    @classmethod
+    def _reject_legacy_mode_kwarg(cls, **kwargs: object) -> None:
+        """Phase B 迁移：旧 mode= 构造须显式改为 max_parallelism。"""
+        mode = kwargs.get("mode")
+        if mode is None:
+            return
+        normalized = str(mode).strip().lower()
+        if normalized == "toolnode":
+            raise ValueError(
+                "tool_execution_engine.mode='toolnode' was removed in v0.9.0; "
+                "use ToolExecutionEngineConfig(max_parallelism=1) for all-serial execution."
+            )
+        if normalized == "serial_safe":
+            raise ValueError(
+                "tool_execution_engine.mode='serial_safe' was removed in Phase B; "
+                "use ToolExecutionEngineConfig(max_parallelism=1)."
+            )
+        if normalized == "readonly_parallel":
+            raise ValueError(
+                "tool_execution_engine.mode='readonly_parallel' was removed in Phase B; "
+                "use ToolExecutionEngineConfig(max_parallelism=10) or omit for default."
+            )
+        raise ValueError(
+            f"tool_execution_engine.mode={mode!r} is invalid; "
+            "mode was removed — use max_parallelism only."
+        )
+
+    def __init__(
+        self,
+        max_parallelism: int | None = None,
+        enable_parity_probe: bool = False,
+        **kwargs: object,
+    ) -> None:
+        self._reject_legacy_mode_kwarg(**kwargs)
+        if kwargs:
+            raise TypeError(
+                f"ToolExecutionEngineConfig() got unexpected keyword arguments: {sorted(kwargs)!r}"
+            )
+        object.__setattr__(self, "max_parallelism", max_parallelism)
+        object.__setattr__(self, "enable_parity_probe", enable_parity_probe)
+        self.__post_init__()
 
 
 # ============================================================================

langchain-agentx-python-0.9.0/langchain_agentx/loop/config/tool_execution_engine_resolver.py

@@ -0,0 +1,52 @@
+"""tool_execution_engine_resolver.py — 工具并发 max_parallelism 解析（Phase C）
+
+职责：
+    按优先级链解析 effective max_parallelism：显式 config > env > SDK 默认 10（对齐 CC）。
+
+链路位置：
+    LoopGraphBuilder._build_tool_node → resolve_effective_max_parallelism
+
+CC 对照：
+    getMaxToolUseConcurrency() · CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY（默认 10）。
+
+当前裁剪范围：
+    仅解析整数并发上限，不读取 enable_parity_probe。
+"""
+
+from __future__ import annotations
+
+from langchain_agentx.provider.env import get_env_first, parse_positive_int
+
+from .loop_config import ToolExecutionEngineConfig
+
+_DEFAULT_MAX_PARALLELISM = 10
+
+_ENV_KEYS = (
+    "LANGCHAIN_AGENTX_MAX_TOOL_PARALLELISM",
+    "CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY",
+)
+
+
+def parse_env_max_tool_parallelism() -> int | None:
+    """读取 env 并发上限；SDK env 优先于 CC env。"""
+    raw = get_env_first(*_ENV_KEYS)
+    return parse_positive_int(raw)
+
+
+def resolve_effective_max_parallelism(cfg: ToolExecutionEngineConfig) -> int:
+    """解析 effective max_parallelism（显式 config > env > 默认 10）。"""
+    if cfg.max_parallelism is not None:
+        return cfg.max_parallelism
+    env_val = parse_env_max_tool_parallelism()
+    if env_val is not None:
+        return env_val
+    return _DEFAULT_MAX_PARALLELISM
+
+
+__all__ = [
+    "DEFAULT_MAX_TOOL_PARALLELISM",
+    "parse_env_max_tool_parallelism",
+    "resolve_effective_max_parallelism",
+]
+
+DEFAULT_MAX_TOOL_PARALLELISM = _DEFAULT_MAX_PARALLELISM

{langchain-agentx-python-0.8.6 → langchain-agentx-python-0.9.0}/langchain_agentx/loop/graph/builtin_loop_control.py

@@ -22,7 +22,7 @@ from ..exit.reason_codes import (
 )
 from ..loop_abort import LoopAbortSignal
 from ..model.orphan_tool_results import synthetic_tool_messages_for_orphan_tool_calls
-from ...tool_runtime.permission_context import rotate_auto_approved_window
+from ...tool_runtime.permission_context import clear_auto_approved_window
 from ...tool_runtime.tool_message_status import apply_tool_message_status_to_result
 
 logger = logging.getLogger(__name__)
@@ -52,7 +52,7 @@ class _LoopBuiltinModelControl:
     """内部单例：捕获模型侧的 ``LoopAbortSignal``。"""
 
     def wrap_model_call(self, request: Any, handler: Any) -> Any:
-        rotate_auto_approved_window(_session_store_from_request(request))
+        clear_auto_approved_window(_session_store_from_request(request))
         try:
             return handler(request)
         except LoopAbortSignal as sig:
@@ -71,7 +71,7 @@ class _LoopBuiltinModelControl:
             )
 
     async def awrap_model_call(self, request: Any, handler: Any) -> Any:
-        rotate_auto_approved_window(_session_store_from_request(request))
+        clear_auto_approved_window(_session_store_from_request(request))
         try:
             return await handler(request)
         except LoopAbortSignal as sig:
@@ -107,6 +107,13 @@ def _model_for_agent_tool(state: Any) -> Any | None:
     except Exception as exc:
         logger.debug("failed to fetch langgraph config for loop model: %s", exc)
         config = None
+    if isinstance(config, dict):
+        configurable = config.get("configurable", {}) or {}
+        from langchain_agentx.tool_runtime.loop_runtime_context import get_model_override
+
+        override = get_model_override(configurable.get("session_store"))
+        if override:
+            return override
     loop_config = config.get("configurable", {}).get("loop_config") if config else None
     model = getattr(loop_config, "model", None)
     if isinstance(model, str):

{langchain-agentx-python-0.8.6 → langchain-agentx-python-0.9.0}/langchain_agentx/loop/graph/factory.py

@@ -40,7 +40,6 @@ from langchain_core.runnables import RunnableConfig
 from langgraph._internal._runnable import RunnableCallable
 from langgraph.constants import END, START
 from langgraph.graph.state import StateGraph
-from langgraph.prebuilt.tool_node import ToolNode
 import asyncio
 import dataclasses
 import logging
@@ -169,10 +168,14 @@ def _sanity_check_config(
     检查失败立即报错或 warning。
     """
     # headless + prompt_handler 组合
+    effective_headless = infer_session_headless(
+        headless=config.headless,
+        container_type=config.container_type,
+    )
     if config.headless and services.prompt_handler is not None:
         # 允许：headless 仍可挂 hook 链，prompt_handler 在 race 入口被跳过
         pass
-    if not config.headless and services.prompt_handler is None:
+    if not effective_headless and services.prompt_handler is None:
         # warning：非 headless 缺 UI 通道
         logger.warning(
             "headless=False but prompt_handler=None; "
@@ -772,33 +775,30 @@ class LoopGraphBuilder:
     def _build_tool_node(self) -> Any:
         self._prepare_compile_context()
         need_tool_node = bool(self._available_tools)
-        tool_node: ToolNode | None = None
+        tool_node: Any | None = None
         if need_tool_node:
-            engine_cfg = self._config.tool_execution_engine
-            if engine_cfg.mode == "toolnode":
-                tool_node = ToolNode(tools=self._available_tools)
-            else:
-                from .runtime_tools_node import RuntimeToolsNode
-                from ...tool_runtime.execution import EngineConfig
+            from .runtime_tools_node import RuntimeToolsNode
+            from ...tool_runtime.execution import EngineConfig
+            from ..config.tool_execution_engine_resolver import resolve_effective_max_parallelism
 
-                if self._loop_loader is None:
-                    raise RuntimeError(
-                        "serial_safe / readonly_parallel require loader with loop_loader"
-                    )
-                process = self._loop_loader.process
-                tool_node = RuntimeToolsNode(
-                    tools=self._available_tools,
-                    registry=self._loop_loader.registry,
-                    adapter=process.adapter,
-                    pipeline=process.pipeline,
-                    engine_config=EngineConfig(
-                        mode=engine_cfg.mode,
-                        max_parallelism=engine_cfg.max_parallelism,
-                        enable_parity_probe=engine_cfg.enable_parity_probe,
-                        fallback_to_toolnode=engine_cfg.fallback_to_toolnode,
-                    ),
-                    unknown_tool_error_template=DYNAMIC_TOOL_ERROR_TEMPLATE,
+            engine_cfg = self._config.tool_execution_engine
+            if self._loop_loader is None:
+                raise RuntimeError(
+                    "RuntimeToolsNode requires loader with loop_loader"
                 )
+            process = self._loop_loader.process
+            effective_max_parallelism = resolve_effective_max_parallelism(engine_cfg)
+            tool_node = RuntimeToolsNode(
+                tools=self._available_tools,
+                registry=self._loop_loader.registry,
+                adapter=process.adapter,
+                pipeline=process.pipeline,
+                engine_config=EngineConfig(
+                    max_parallelism=effective_max_parallelism,
+                    enable_parity_probe=engine_cfg.enable_parity_probe,
+                ),
+                unknown_tool_error_template=DYNAMIC_TOOL_ERROR_TEMPLATE,
+            )
             if self._trace_tool_callback_handler is not None:
                 tool_node = tool_node.with_config(
                     {"callbacks": [self._trace_tool_callback_handler]}
@@ -807,14 +807,17 @@ class LoopGraphBuilder:
 
     def _prepare_for_model_nodes(self, tool_node: Any) -> None:
         """在 make_model_nodes 之前设置 default_tools、模型包装与图节点所需字段。"""
-        if tool_node:
-            default_tools = list(tool_node.tools_by_name.values()) + self._built_in_tools
+        from .runtime_tools_node import resolve_runtime_tools_node
+
+        runtime_tools_node = resolve_runtime_tools_node(tool_node)
+        if runtime_tools_node:
+            default_tools = list(runtime_tools_node.tools_by_name.values()) + self._built_in_tools
         else:
             default_tools = list(self._built_in_tools)
         model = self._model
         if self._config.enable_tool_call_degradation_fix and not isinstance(model, ToolCallDegradationCorrector):
             allowed_tool_names = _build_allowed_tool_names_for_degradation_correction(
-                tool_node=tool_node,
+                tool_node=runtime_tools_node,
                 built_in_tools=self._built_in_tools,
                 structured_output_tools=self._structured_output_tools,
             )
@@ -830,8 +833,11 @@ class LoopGraphBuilder:
 
     def _build_model_nodes(self, tool_node: Any) -> ModelNode:
         """构建 model 节点，返回 ModelNode(Runnable) 实例，供 LangGraph 直接注册。"""
+        from .runtime_tools_node import resolve_runtime_tools_node
+
         self._prepare_compile_context()
         self._prepare_for_model_nodes(tool_node)
+        runtime_tools_node = resolve_runtime_tools_node(tool_node)
         return ModelNode(
             model=self._model,
             default_tools=self._default_tools,
@@ -848,7 +854,7 @@ class LoopGraphBuilder:
             structured_output_tools=self._structured_output_tools,
             tool_strategy_for_setup=self._tool_strategy_for_setup,
             retrier=self._model_retrier,
-            tool_node=tool_node,
+            tool_node=runtime_tools_node,
             dynamic_tool_error_template=DYNAMIC_TOOL_ERROR_TEMPLATE,
             fallback_model=self._config.fallback_model,
             llm_callback_handler=self._trace_callback_handler,
@@ -1036,8 +1042,13 @@ class LoopGraphBuilder:
         }
 
     def _build_provider_chain(self, tool_node: Any) -> tuple[list[QueuedCommandProvider], bool]:
+        from .runtime_tools_node import resolve_runtime_tools_node
+
         provider_chain: list[QueuedCommandProvider] = list(self._queued_command_providers)
-        has_skill_tool = bool(tool_node and SKILL_TOOL_NAME in tool_node.tools_by_name)
+        runtime_tools_node = resolve_runtime_tools_node(tool_node)
+        has_skill_tool = bool(
+            runtime_tools_node and SKILL_TOOL_NAME in runtime_tools_node.tools_by_name
+        )
         has_skill_prefetch_provider = any(
             isinstance(item, SkillPrefetchProvider) for item in provider_chain
         )

{langchain-agentx-python-0.8.6 → langchain-agentx-python-0.9.0}/langchain_agentx/loop/graph/graph_edges.py

@@ -32,8 +32,7 @@ from langchain.agents.structured_output import OutputToolBinding
 from langchain_core.messages import AIMessage, AnyMessage, HumanMessage, ToolMessage
 from langgraph._internal._runnable import RunnableCallable
 from langgraph.graph.state import StateGraph
-from langgraph.prebuilt.tool_node import ToolCallWithContext, ToolNode
-from langgraph.types import Send
+from langgraph.prebuilt.tool_node import ToolNode
 from ..hook.async_hook_runner import AsyncHookRunner
 from ..hook.hook_projection import hook_result_to_event_dict
 from ..hook.types import HookContext, HookEvent
@@ -225,7 +224,7 @@ class LoopControllerEdge:
             else DEFAULT_TOKEN_BUDGET_MAX_CONTINUATIONS
         )
 
-    def __call__(self, state: dict[str, Any]) -> str | List[Send] | None:
+    def __call__(self, state: dict[str, Any]) -> str | None:
         jump_result = self._handle_jump(state)
         if jump_result is not None:
             return jump_result
@@ -605,7 +604,7 @@ class LoopControllerEdge:
         )
         return self._model_destination
 
-    def _handle_continue(self, state: dict[str, Any]) -> str | List[Send]:
+    def _handle_continue(self, state: dict[str, Any]) -> str:
         last_ai_message, tool_messages = _fetch_last_ai_and_tool_messages(state["messages"])
         no_message_result = self._handle_missing_last_ai_message(state, last_ai_message)
         if no_message_result is not None:
@@ -654,28 +653,26 @@ class LoopControllerEdge:
         self,
         state: dict[str, Any],
         pending_tool_calls: list[dict[str, Any]],
-    ) -> str | list[Send] | None:
+    ) -> str | None:
         if not pending_tool_calls:
             return None
-        sends: list[Send] = []
         blocked_tool_messages: list[ToolMessage] = []
+        allowed_tool_calls: list[dict[str, Any]] = []
+        patched_by_id: dict[str, dict[str, Any]] = {}
         for tool_call in pending_tool_calls:
             hook_handled = self._prepare_single_tool_dispatch(state, tool_call)
             if hook_handled["blocked_message"] is not None:
                 blocked_tool_messages.append(hook_handled["blocked_message"])
                 continue
-            sends.append(
-                Send(
-                    self._tools_destination,
-                    ToolCallWithContext(
-                        __type="tool_call_with_context",
-                        tool_call=hook_handled["tool_call"],
-                        state=state,
-                    ),
-                )
-            )
+            allowed_tool_call = hook_handled["tool_call"]
+            allowed_tool_calls.append(allowed_tool_call)
+            tool_call_id = str(allowed_tool_call.get("id") or "")
+            if tool_call_id:
+                patched_by_id[tool_call_id] = allowed_tool_call
         if blocked_tool_messages:
             state["messages"] = list(state.get("messages") or []) + blocked_tool_messages
+        if patched_by_id:
+            _patch_last_ai_tool_calls(state, patched_by_id)
         emit_loop_decision_event(
             state=state,
             decision="tool_dispatch",
@@ -683,11 +680,14 @@ class LoopControllerEdge:
             reason_code="pending_tool_calls",
             evidence={
                 "pending_count": len(pending_tool_calls),
+                "allowed_count": len(allowed_tool_calls),
                 "tool_names": [c.get("name") for c in pending_tool_calls],
                 "step": state.get("step", 0),
             },
         )
-        return sends if sends else self._end_destination
+        if not allowed_tool_calls:
+            return self._end_destination
+        return self._tools_destination
 
     def _prepare_single_tool_dispatch(
         self,
@@ -751,6 +751,28 @@ class LoopControllerEdge:
         return self._task_reconcile_destination
 
 
+def _patch_last_ai_tool_calls(
+    state: dict[str, Any],
+    patched_by_id: dict[str, dict[str, Any]],
+) -> None:
+    """将 PRE_TOOL_USE hook 改写后的 tool_call 写回最后一条 AIMessage。"""
+    messages = list(state.get("messages") or [])
+    for idx in range(len(messages) - 1, -1, -1):
+        msg = messages[idx]
+        if not isinstance(msg, AIMessage) or not msg.tool_calls:
+            continue
+        updated_tool_calls: list[Any] = []
+        for tool_call in msg.tool_calls:
+            if not isinstance(tool_call, dict):
+                updated_tool_calls.append(tool_call)
+                continue
+            tool_call_id = str(tool_call.get("id") or "")
+            updated_tool_calls.append(patched_by_id.get(tool_call_id, tool_call))
+        messages[idx] = msg.model_copy(update={"tool_calls": updated_tool_calls})
+        state["messages"] = messages
+        return
+
+
 def _make_loop_controller_edge(
     *,
     model_destination: str,
@@ -761,7 +783,7 @@ def _make_loop_controller_edge(
     task_reconcile_destination: str | None = None,
     has_pending_task_notifications: Callable[[dict[str, Any]], bool] | None = None,
     token_budget_max_continuations: int | None = None,
-) -> Callable[[dict[str, Any]], str | List[Send] | None]:
+) -> Callable[[dict[str, Any]], str | None]:
     """LangChain AgentX 的 loop_controller 条件边工厂。"""
     return LoopControllerEdge(
         model_destination=model_destination,
@@ -779,12 +801,12 @@ def _make_model_to_model_edge(
     *,
     model_destination: str,
     end_destination: str,
-) -> Callable[[dict[str, Any]], str | List[Send] | None]:
+) -> Callable[[dict[str, Any]], str | None]:
     """model → model/END 条件边，用于仅依赖结构化输出的场景。"""
 
     def model_to_model(
         state: dict[str, Any],
-    ) -> str | List[Send] | None:
+    ) -> str | None:
         # 优先遵循中间件显式 jump_to 指令。
         if jump_to := state.get("jump_to"):
             return _resolve_jump(

{langchain-agentx-python-0.8.6 → langchain-agentx-python-0.9.0}/langchain_agentx/loop/graph/runtime_tools_node.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 
 from typing import Any, MutableMapping
 
-from langchain_core.messages import AIMessage
+from langchain_core.messages import AIMessage, ToolMessage
 from langchain_core.runnables import Runnable, RunnableConfig
 from langchain_core.tools import BaseTool
 
@@ -97,7 +97,7 @@ class RuntimeToolsNode(Runnable):
             state=state,
             config=config,
         )
-        tool_messages = self._message_adapter.records_to_tool_messages(records)
+        tool_messages = self._message_adapter.records_to_graph_messages(records)
         return {"messages": tool_messages}
 
     async def _arun(
@@ -114,7 +114,7 @@ class RuntimeToolsNode(Runnable):
             state=state,
             config=config,
         )
-        tool_messages = self._message_adapter.records_to_tool_messages(records)
+        tool_messages = self._message_adapter.records_to_graph_messages(records)
         return {"messages": tool_messages}
 
 
@@ -122,11 +122,32 @@ def _extract_tool_calls(
     state: MutableMapping[str, Any],
 ) -> tuple[AIMessage | None, list[dict[str, Any]]]:
     messages = list(state.get("messages") or [])
+    answered_ids = {
+        str(getattr(msg, "tool_call_id", ""))
+        for msg in messages
+        if isinstance(msg, ToolMessage) and getattr(msg, "tool_call_id", None)
+    }
     for msg in reversed(messages):
         if isinstance(msg, AIMessage) and msg.tool_calls:
-            calls = [tc for tc in msg.tool_calls if isinstance(tc, dict)]
+            calls = [
+                tc
+                for tc in msg.tool_calls
+                if isinstance(tc, dict) and str(tc.get("id") or "") not in answered_ids
+            ]
             return msg, calls
     return None, []
 
 
-__all__ = ["RuntimeToolsNode"]
+def resolve_runtime_tools_node(tool_node: Any) -> RuntimeToolsNode | None:
+    """从 with_config() 产生的 RunnableBinding 中解析 RuntimeToolsNode。"""
+    if tool_node is None:
+        return None
+    bound = getattr(tool_node, "bound", None)
+    if bound is not None and hasattr(bound, "tools_by_name"):
+        return bound
+    if hasattr(tool_node, "tools_by_name"):
+        return tool_node
+    return None
+
+
+__all__ = ["RuntimeToolsNode", "resolve_runtime_tools_node"]

{langchain-agentx-python-0.8.6 → langchain-agentx-python-0.9.0}/langchain_agentx/loop/model/model_node.py

@@ -308,7 +308,7 @@ class ModelNode(Runnable):
     def _run(self, state: dict, config: RunnableConfig) -> dict:
         """核心同步执行逻辑。"""
         runtime = config.get("configurable", {}).get("__pregel_runtime")
-        request = self._build_request(state, runtime)
+        request = self._build_request(state, runtime, config=config)
 
         synth = _model_response_if_context_token_blocked(
             state_messages=state.get("messages", []),
@@ -331,7 +331,7 @@ class ModelNode(Runnable):
     async def _arun(self, state: dict, config: RunnableConfig) -> dict:
         """核心异步执行逻辑。"""
         runtime = config.get("configurable", {}).get("__pregel_runtime")
-        request = self._build_request(state, runtime)
+        request = self._build_request(state, runtime, config=config)
 
         synth = _model_response_if_context_token_blocked(
             state_messages=state.get("messages", []),
@@ -353,11 +353,20 @@ class ModelNode(Runnable):
 
     # ===== 请求构建 =====
 
-    def _build_request(self, state: dict, runtime: Any) -> Any:
+    def _build_request(
+        self,
+        state: dict,
+        runtime: Any,
+        *,
+        config: RunnableConfig | None = None,
+    ) -> Any:
         """从 state 构建 _ModelRequest。"""
         from langchain.agents.middleware.types import ModelRequest as _ModelRequest
 
         model_settings: Dict[str, Any] = {}
+        effort_override = self._effort_override_from_config(config)
+        if effort_override is not None:
+            model_settings["effort"] = effort_override
         if state.get("max_output_tokens_override") is not None:
             requested_override = int(state["max_output_tokens_override"])
             cap = self._max_output_tokens_cap
@@ -385,7 +394,7 @@ class ModelNode(Runnable):
         tools = [] if state.get("force_text_exit") else self._default_tools
 
         return _ModelRequest(
-            model=self._model,
+            model=self._resolve_effective_model(config),
             tools=tools,
             system_message=system_message,
             response_format=self._initial_response_format,
@@ -396,6 +405,34 @@ class ModelNode(Runnable):
             model_settings=model_settings,
         )
 
+    def _resolve_effective_model(self, config: RunnableConfig | None) -> Any:
+        """读取 session skill model override（对齐 CC mainLoopModel）。"""
+        from langchain_agentx.tool_runtime.loop_runtime_context import get_model_override
+
+        store = None
+        if isinstance(config, dict):
+            configurable = config.get("configurable", {}) or {}
+            store = configurable.get("session_store")
+        override = get_model_override(store)
+        if not override:
+            return self._model
+        try:
+            from langchain.chat_models import init_chat_model
+
+            return init_chat_model(override)
+        except Exception as exc:
+            logger.warning("skill model override init failed (%s); using base model", exc)
+            return self._model
+
+    @staticmethod
+    def _effort_override_from_config(config: RunnableConfig | None) -> str | None:
+        from langchain_agentx.tool_runtime.loop_runtime_context import get_effort_override
+
+        if not isinstance(config, dict):
+            return None
+        store = (config.get("configurable", {}) or {}).get("session_store")
+        return get_effort_override(store)
+
     # ===== 模型调用 =====
 
     def _invoke_bound(self, req: Any, *, config: RunnableConfig | None = None) -> Any: