langchain-agentx-python 1.9.4__tar.gz → 1.9.5__tar.gz

{langchain-agentx-python-1.9.4/langchain_agentx_python.egg-info → langchain-agentx-python-1.9.5}/PKG-INFO

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

{langchain-agentx-python-1.9.4 → langchain-agentx-python-1.9.5}/langchain_agentx/__init__.py

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

{langchain-agentx-python-1.9.4 → langchain-agentx-python-1.9.5}/langchain_agentx/loop/config/loop_config.py

@@ -97,10 +97,16 @@ class ModelRetrySettings:
         - query_source → CC QuerySource（决定 background overload 是否重试，Phase 3）
         - emit_progress_events → yield api_error / api_retry 进度
         - persistent_retry → CLAUDE_CODE_UNATTENDED_RETRY（Phase 5；默认 False，仅 unattended/CI）
+        - nonstreaming_fallback_enabled → CC executeNonStreamingRequest 主路径（默认 True；
+          LANGCHAIN_AGENTX_DISABLE_NONSTREAMING_FALLBACK=1 可关）
     """
     query_source: str | None = None
     emit_progress_events: bool | None = None
     persistent_retry: bool | None = None
+    nonstreaming_fallback_enabled: bool | None = None
+    nonstreaming_fallback_max_retries: int | None = None
+    stream_idle_watchdog_enabled: bool | None = None
+    stream_idle_timeout_ms: int | None = None
 
 
 @dataclass(frozen=True)

{langchain-agentx-python-1.9.4 → langchain-agentx-python-1.9.5}/langchain_agentx/loop/config/model_retry_config.py

@@ -9,12 +9,15 @@ model_retry_config.py — 从 AgentLoopConfig 装配 ModelRetryConfig。
 from __future__ import annotations
 
 import os
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 from langchain_agentx.loop.exit.query_source import QuerySource
 
 from ..model.retrier import ModelRetryConfig
 
+_DEFAULT_NONSTREAMING_FALLBACK_MAX_RETRIES = 2
+
 if TYPE_CHECKING:
     from .loop_config import AgentLoopConfig, ModelRetrySettings
 
@@ -121,6 +124,80 @@ def resolve_emit_progress_events(
     return True
 
 
+@dataclass(frozen=True, slots=True)
+class NonstreamingFallbackSettings:
+    enabled: bool = True
+    max_retries: int = _DEFAULT_NONSTREAMING_FALLBACK_MAX_RETRIES
+
+
+def resolve_nonstreaming_fallback_settings(
+    settings: ModelRetrySettings | None = None,
+) -> NonstreamingFallbackSettings:
+    from ..model.streaming_fallback import is_nonstreaming_fallback_disabled_by_env
+
+    if is_nonstreaming_fallback_disabled_by_env():
+        return NonstreamingFallbackSettings(enabled=False)
+    enabled = True
+    if settings is not None and settings.nonstreaming_fallback_enabled is not None:
+        enabled = settings.nonstreaming_fallback_enabled
+    max_retries = _DEFAULT_NONSTREAMING_FALLBACK_MAX_RETRIES
+    if settings is not None and settings.nonstreaming_fallback_max_retries is not None:
+        max_retries = settings.nonstreaming_fallback_max_retries
+    return NonstreamingFallbackSettings(enabled=enabled, max_retries=max_retries)
+
+
+def resolve_stream_idle_watchdog_settings(
+    settings: ModelRetrySettings | None = None,
+):
+    from langchain_agentx.provider.stream_idle_watchdog import (
+        StreamIdleWatchdogSettings,
+        env_stream_idle_watchdog_enabled,
+        resolve_stream_idle_timeout_ms,
+    )
+
+    enabled = False
+    if settings is not None and settings.stream_idle_watchdog_enabled is not None:
+        enabled = settings.stream_idle_watchdog_enabled
+    elif env_stream_idle_watchdog_enabled():
+        enabled = True
+    timeout_ms = resolve_stream_idle_timeout_ms(
+        settings_timeout_ms=(
+            settings.stream_idle_timeout_ms if settings is not None else None
+        ),
+    )
+    return StreamIdleWatchdogSettings(enabled=enabled, timeout_ms=timeout_ms)
+
+
+def build_nonstreaming_retry_config(
+    config: AgentLoopConfig,
+    *,
+    fallback_model: Any | None = None,
+) -> ModelRetryConfig:
+    """非流式兜底专用 retrier 配置（max_retries 低于主流式 retrier）。"""
+    base = build_model_retry_config(config, fallback_model=fallback_model)
+    ns_settings = resolve_nonstreaming_fallback_settings(config.model_retry)
+    return ModelRetryConfig(
+        max_retries=ns_settings.max_retries,
+        initial_delay=base.initial_delay,
+        backoff_factor=base.backoff_factor,
+        max_delay=base.max_delay,
+        jitter=base.jitter,
+        heartbeat_threshold_seconds=base.heartbeat_threshold_seconds,
+        heartbeat_interval_seconds=base.heartbeat_interval_seconds,
+        retry_on=base.retry_on,
+        allow_background_529_retry=base.allow_background_529_retry,
+        auth_recovery_handler=base.auth_recovery_handler,
+        max_consecutive_rate_limit=base.max_consecutive_rate_limit,
+        fallback_model=base.fallback_model,
+        query_source=base.query_source,
+        emit_progress_events=base.emit_progress_events,
+        emit_progress_custom_events=base.emit_progress_custom_events,
+        persistent_retry=False,
+        persistent_max_delay=base.persistent_max_delay,
+        persistent_reset_cap_seconds=base.persistent_reset_cap_seconds,
+    )
+
+
 def build_model_retry_config(
     config: AgentLoopConfig,
     *,
@@ -152,9 +229,13 @@ def build_model_retry_config(
 
 
 __all__ = [
+    "NonstreamingFallbackSettings",
     "build_model_retry_config",
+    "build_nonstreaming_retry_config",
     "resolve_emit_progress_events",
     "resolve_model_retry_query_source",
+    "resolve_nonstreaming_fallback_settings",
     "resolve_persistent_retry",
+    "resolve_stream_idle_watchdog_settings",
     "should_retry_overload_for_source",
 ]

{langchain-agentx-python-1.9.4 → langchain-agentx-python-1.9.5}/langchain_agentx/loop/graph/factory.py

@@ -52,7 +52,12 @@ from ..exit.exit_logic import (
 )
 from ..exit.reason_codes import TERMINAL_REASON_GRAPH_RUNTIME_ERROR
 from ..exit.terminal import read_terminal_reason
-from .graph_edges import _make_model_to_model_edge, _make_tools_to_model_edge, _make_loop_controller_edge
+from .graph_edges import (
+    _make_model_to_model_edge,
+    _make_tools_to_model_edge,
+    _make_loop_controller_node,
+    _select_loop_controller_destination,
+)
 from .reactive_compact_node import ReactiveCompactNode
 from ..model.schema_and_format import (
     STRUCTURED_OUTPUT_ERROR_TEMPLATE,
@@ -564,9 +569,7 @@ class LoopGraphBuilder:
         self._tool_strategy_for_setup = tool_strategy_for_setup
         self._structured_output_tools = structured_output_tools
         self._is_subagent = self._config.subagent.is_subagent
-        self._task_runtime = self._services.task_runtime
-        if self._task_runtime is None and self._services.capabilities is not None:
-            self._task_runtime = self._services.capabilities.task_runtime
+        self._task_runtime = self._resolve_task_runtime()
         self._queued_command_providers = list(self._services.queued_command_providers)
         self._override_system_prompt = self._config.prompt.override_system
         self._append_system_prompt = append_system_prompt
@@ -1216,6 +1219,17 @@ class LoopGraphBuilder:
         else:
             default_tools = list(self._built_in_tools)
         model = self._model
+        from ...provider.semantics.profile import get_default_profile_resolver
+        from ...provider.stream_idle_watchdog import apply_stream_idle_watchdog
+        from ..config.model_retry_config import resolve_stream_idle_watchdog_settings
+
+        profile = get_default_profile_resolver().resolve_from_model_instance(model)
+        watchdog_settings = resolve_stream_idle_watchdog_settings(self._config.model_retry)
+        model = apply_stream_idle_watchdog(
+            model,
+            family=profile.family,
+            settings=watchdog_settings,
+        )
         if self._config.enable_tool_call_degradation_fix and not isinstance(model, ToolCallDegradationCorrector):
             allowed_tool_names = _build_allowed_tool_names_for_degradation_correction(
                 enabled_tool_names=set(self._enabled_tool_names),
@@ -1229,11 +1243,20 @@ class LoopGraphBuilder:
             )
         self._default_tools = default_tools
         self._model = model
-        from ..config.model_retry_config import build_model_retry_config
-
-        _retrier = ModelCallRetrier(build_model_retry_config(self._config))
+        from ..config.model_retry_config import (
+            build_model_retry_config,
+            build_nonstreaming_retry_config,
+            resolve_nonstreaming_fallback_settings,
+        )
+        from ..model.streaming_fallback import clone_model_nonstreaming
 
-        self._model_retrier = _retrier
+        self._model_retrier = ModelCallRetrier(build_model_retry_config(self._config))
+        self._nonstreaming_model = clone_model_nonstreaming(model)
+        self._nonstreaming_fallback_model = clone_model_nonstreaming(self._config.fallback_model)
+        self._nonstreaming_retry_config = build_nonstreaming_retry_config(self._config)
+        self._nonstreaming_fallback_settings = resolve_nonstreaming_fallback_settings(
+            self._config.model_retry
+        )
 
     def _build_model_nodes(self, tool_node: Any) -> ModelNode:
         """构建 model 节点，返回 ModelNode(Runnable) 实例，供 LangGraph 直接注册。"""
@@ -1262,6 +1285,10 @@ class LoopGraphBuilder:
             dynamic_tool_error_template=DYNAMIC_TOOL_ERROR_TEMPLATE,
             fallback_model=self._config.fallback_model,
             llm_callback_handler=self._trace_callback_handler,
+            nonstreaming_model=self._nonstreaming_model,
+            nonstreaming_fallback_model=self._nonstreaming_fallback_model,
+            nonstreaming_retry_config=self._nonstreaming_retry_config,
+            nonstreaming_fallback_settings=self._nonstreaming_fallback_settings,
             dynamic_sections=self._dynamic_sections if self._has_dynamic_prompt else None,
             base_prompt=self._base_prompt,
             override_prompt=self._override_system_prompt,
@@ -1510,7 +1537,6 @@ class LoopGraphBuilder:
             entry_node=entry_node,
         )
         graph_inner.add_edge("hook_before_model", "model")
-        graph_inner.add_node("loop_controller", lambda state: state)
         return {
             "entry_node": entry_node,
             "loop_entry_node": loop_entry_node,
@@ -1521,6 +1547,25 @@ class LoopGraphBuilder:
             "wire_task_event_nodes": wire_task_event_nodes,
         }
 
+    def _resolve_task_runtime(self) -> Any | None:
+        """从 services / capabilities 解析 TaskRuntime；忽略 unittest.mock 等伪对象。"""
+        if self._services.task_runtime is not None:
+            return self._services.task_runtime
+        capabilities = self._services.capabilities
+        if capabilities is None:
+            return None
+        candidate = getattr(capabilities, "task_runtime", None)
+        if candidate is None:
+            return None
+        if type(candidate).__name__ in {"MagicMock", "Mock", "AsyncMock", "NonCallableMagicMock"}:
+            logger.warning(
+                "Ignoring capabilities.task_runtime type=%s (mock or invalid); "
+                "task notification wiring disabled",
+                type(candidate).__name__,
+            )
+            return None
+        return candidate
+
     def _build_provider_chain(self, tool_node: Any) -> tuple[list[QueuedCommandProvider], bool]:
         from .runtime_tools_node import resolve_runtime_tools_node
 
@@ -1909,11 +1954,18 @@ class LoopGraphBuilder:
                 graph_inner=graph_inner,
                 loop_entry_node=loop_entry_node,
                 loop_exit_node=loop_exit_node,
+                exit_node=exit_node,
+                provider_chain=provider_chain,
+                wire_task_event_nodes=wire_task_event_nodes,
             )
             return
         self._wire_main_edges_without_tools(
             graph_inner=graph_inner,
+            loop_entry_node=loop_entry_node,
             loop_exit_node=loop_exit_node,
+            exit_node=exit_node,
+            provider_chain=provider_chain,
+            wire_task_event_nodes=wire_task_event_nodes,
         )
 
     def _wire_main_edges_with_tools(
@@ -1951,9 +2003,50 @@ class LoopGraphBuilder:
             graph_inner.add_edge("prune_and_compress", loop_entry_node)
         graph_inner.add_edge(loop_exit_node, "hook_after_model")
         graph_inner.add_edge("hook_after_model", "hook_stop")
+        self._wire_loop_controller(
+            graph_inner=graph_inner,
+            loop_entry_node=loop_entry_node,
+            exit_node=exit_node,
+            provider_chain=provider_chain,
+            wire_task_event_nodes=wire_task_event_nodes,
+            tools_destination="tools",
+        )
+
+    def _wire_loop_controller(
+        self,
+        *,
+        graph_inner: Any,
+        loop_entry_node: str,
+        exit_node: str,
+        provider_chain: list[QueuedCommandProvider],
+        wire_task_event_nodes: bool,
+        tools_destination: str | None = None,
+    ) -> None:
+        graph_inner.add_node(
+            "loop_controller",
+            RunnableCallable(
+                _make_loop_controller_node(
+                    model_destination=loop_entry_node,
+                    tools_destination=tools_destination or loop_entry_node,
+                    structured_output_tools=self._structured_output_tools,
+                    end_destination=exit_node,
+                    max_output_tokens_cap=self._model_context_resolver.resolve_max_output_tokens(
+                        self._config
+                    ),
+                    token_budget_max_continuations=self._config.token_budget_max_continuations,
+                    task_reconcile_destination=(
+                        "task_event_commit_ack" if provider_chain else None
+                    ),
+                    has_pending_task_notifications=self._build_pending_task_notifications_checker(
+                        provider_chain
+                    ),
+                ),
+                None,
+                trace=False,
+            ),
+        )
         graph_inner.add_edge("hook_stop", "loop_controller")
 
-        # 添加 reactive_compact 节点（上下文窗口溢出恢复专用节点）
         def _reactive_compact_node(state, runtime):
             node = ReactiveCompactNode(
                 compaction_service=default_loop_context_compaction(),
@@ -1966,37 +2059,20 @@ class LoopGraphBuilder:
             "reactive_compact",
             RunnableCallable(_reactive_compact_node, None, trace=False),
         )
-        # reactive_compact 成功路径 → loop_entry_node
         graph_inner.add_conditional_edges(
             "reactive_compact",
             lambda state: state.get("destination", loop_entry_node),
             [loop_entry_node, exit_node],
         )
 
-        loop_controller_destinations = ["tools", loop_entry_node, exit_node, "reactive_compact"]
+        loop_controller_destinations = [loop_entry_node, exit_node, "reactive_compact"]
+        if tools_destination is not None:
+            loop_controller_destinations.insert(0, tools_destination)
         if wire_task_event_nodes and "task_event_commit_ack" not in loop_controller_destinations:
             loop_controller_destinations.append("task_event_commit_ack")
         graph_inner.add_conditional_edges(
             "loop_controller",
-            RunnableCallable(
-                _make_loop_controller_edge(
-                    model_destination=loop_entry_node,
-                    tools_destination="tools",
-                    structured_output_tools=self._structured_output_tools,
-                    end_destination=exit_node,
-                    max_output_tokens_cap=self._model_context_resolver.resolve_max_output_tokens(
-                        self._config
-                    ),
-                    token_budget_max_continuations=self._config.token_budget_max_continuations,
-                    task_reconcile_destination=(
-                        "task_event_commit_ack" if provider_chain else None
-                    ),
-                    has_pending_task_notifications=self._build_pending_task_notifications_checker(
-                        provider_chain
-                    ),
-                ),
-                trace=False,
-            ),
+            RunnableCallable(_select_loop_controller_destination, None, trace=False),
             loop_controller_destinations,
         )
 
@@ -2006,6 +2082,9 @@ class LoopGraphBuilder:
         graph_inner: Any,
         loop_entry_node: str,
         loop_exit_node: str,
+        exit_node: str,
+        provider_chain: list[QueuedCommandProvider],
+        wire_task_event_nodes: bool,
     ) -> None:
         graph_inner.add_edge(loop_exit_node, "hook_after_model")
         graph_inner.add_conditional_edges(
@@ -2019,17 +2098,35 @@ class LoopGraphBuilder:
             ),
             [loop_entry_node, "hook_stop"],
         )
-        graph_inner.add_edge("hook_stop", "hook_loop_end")
+        self._wire_loop_controller(
+            graph_inner=graph_inner,
+            loop_entry_node=loop_entry_node,
+            exit_node=exit_node,
+            provider_chain=provider_chain,
+            wire_task_event_nodes=wire_task_event_nodes,
+            tools_destination=None,
+        )
 
     def _wire_main_edges_without_tools(
         self,
         *,
         graph_inner: Any,
+        loop_entry_node: str,
         loop_exit_node: str,
+        exit_node: str,
+        provider_chain: list[QueuedCommandProvider],
+        wire_task_event_nodes: bool,
     ) -> None:
         graph_inner.add_edge(loop_exit_node, "hook_after_model")
         graph_inner.add_edge("hook_after_model", "hook_stop")
-        graph_inner.add_edge("hook_stop", "hook_loop_end")
+        self._wire_loop_controller(
+            graph_inner=graph_inner,
+            loop_entry_node=loop_entry_node,
+            exit_node=exit_node,
+            provider_chain=provider_chain,
+            wire_task_event_nodes=wire_task_event_nodes,
+            tools_destination=None,
+        )
 
     def _build_pending_task_notifications_checker(
         self,

{langchain-agentx-python-1.9.4 → langchain-agentx-python-1.9.5}/langchain_agentx/loop/graph/graph_edges.py

@@ -39,6 +39,10 @@ from ..hook.types import HookContext, HookEvent
 # 导入事件发射器（CLI Phase 1A 骨架）
 from ...observability.trace.event_emitter import emit_loop_decision_event
 
+import logging
+
+logger = logging.getLogger(__name__)
+
 from ..exit.exit_logic import (
     ESCALATED_MAX_OUTPUT_TOKENS,
     MAX_OUTPUT_TOKENS_RECOVERY_LIMIT,
@@ -1001,6 +1005,54 @@ def _patch_last_ai_tool_calls(
         return
 
 
+def _build_loop_controller_edge(
+    *,
+    model_destination: str,
+    tools_destination: str,
+    structured_output_tools: dict[str, OutputToolBinding[Any]],
+    end_destination: str,
+    max_output_tokens_cap: int | None = None,
+    task_reconcile_destination: str | None = None,
+    has_pending_task_notifications: Callable[[dict[str, Any]], bool] | None = None,
+    token_budget_max_continuations: int | None = None,
+) -> LoopControllerEdge:
+    return LoopControllerEdge(
+        model_destination=model_destination,
+        tools_destination=tools_destination,
+        structured_output_tools=structured_output_tools,
+        end_destination=end_destination,
+        max_output_tokens_cap=max_output_tokens_cap,
+        task_reconcile_destination=task_reconcile_destination,
+        has_pending_task_notifications=has_pending_task_notifications,
+        token_budget_max_continuations=token_budget_max_continuations,
+    )
+
+
+_LOOP_CONTROLLER_PATCH_KEYS: tuple[str, ...] = (
+    "terminal",
+    "terminal_reason",
+    "transition",
+    "resolution",
+    "__hook_result__",
+    "messages",
+    "withheld_error",
+    "max_output_tokens_override",
+    "max_output_tokens_recovery_count",
+    "collapse_retry_available",
+    "has_attempted_reactive_compact",
+    "force_text_exit",
+    "token_budget_continue_requested",
+    "token_budget_continuation_count",
+    "abort_terminal_reason",
+    "turn_count",
+    "_hook_ui_events",
+)
+
+
+def _extract_loop_controller_patch(state: dict[str, Any]) -> dict[str, Any]:
+    return {key: state[key] for key in _LOOP_CONTROLLER_PATCH_KEYS if key in state}
+
+
 def _make_loop_controller_edge(
     *,
     model_destination: str,
@@ -1012,8 +1064,32 @@ def _make_loop_controller_edge(
     has_pending_task_notifications: Callable[[dict[str, Any]], bool] | None = None,
     token_budget_max_continuations: int | None = None,
 ) -> Callable[[dict[str, Any]], str | None]:
-    """LangChain AgentX 的 loop_controller 条件边工厂。"""
-    return LoopControllerEdge(
+    """LangChain AgentX 的 loop_controller 条件边工厂（单测 / 手工投影用）。"""
+    return _build_loop_controller_edge(
+        model_destination=model_destination,
+        tools_destination=tools_destination,
+        structured_output_tools=structured_output_tools,
+        end_destination=end_destination,
+        max_output_tokens_cap=max_output_tokens_cap,
+        task_reconcile_destination=task_reconcile_destination,
+        has_pending_task_notifications=has_pending_task_notifications,
+        token_budget_max_continuations=token_budget_max_continuations,
+    )
+
+
+def _make_loop_controller_node(
+    *,
+    model_destination: str,
+    tools_destination: str,
+    structured_output_tools: dict[str, OutputToolBinding[Any]],
+    end_destination: str,
+    max_output_tokens_cap: int | None = None,
+    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]], dict[str, Any]]:
+    """loop_controller 图节点：执行路由逻辑并将 state patch 持久化到 LangGraph。"""
+    edge = _build_loop_controller_edge(
         model_destination=model_destination,
         tools_destination=tools_destination,
         structured_output_tools=structured_output_tools,
@@ -1024,6 +1100,55 @@ def _make_loop_controller_edge(
         token_budget_max_continuations=token_budget_max_continuations,
     )
 
+    def loop_controller_node(state: dict[str, Any]) -> dict[str, Any]:
+        destination = edge(state)
+        patch = _extract_loop_controller_patch(state)
+        if destination is not None:
+            patch["_loop_controller_destination"] = destination
+        terminal_patch = patch.get("terminal")
+        if isinstance(terminal_patch, dict) and terminal_patch.get("error_kind") == "api_error":
+            logger.info(
+                "loop_controller applied api_error terminal projection: step=%s destination=%s transition=%s",
+                state.get("step"),
+                destination,
+                (state.get("transition") or {}).get("reason"),
+            )
+        if (
+            task_reconcile_destination
+            and destination == task_reconcile_destination
+        ):
+            step = state.get("step", 0)
+            logger.info(
+                "loop_controller routing to task reconcile %s: step=%s transition=%s terminal_reason=%s",
+                destination,
+                step,
+                (state.get("transition") or {}).get("reason"),
+                read_terminal_reason(state.get("terminal")),
+            )
+            if isinstance(step, int) and step >= 20:
+                logger.warning(
+                    "loop_controller task reconcile at high step=%s; "
+                    "check has_pending strict bool and task_runtime wiring",
+                    step,
+                )
+        return patch
+
+    return loop_controller_node
+
+
+def _select_loop_controller_destination(state: dict[str, Any]) -> str:
+    destination = state.get("_loop_controller_destination")
+    if not isinstance(destination, str) or not destination:
+        logger.error(
+            "loop_controller missing _loop_controller_destination after node run: "
+            "step=%s transition=%s resolution=%s",
+            state.get("step"),
+            (state.get("transition") or {}).get("reason"),
+            (state.get("resolution") or {}).get("kind"),
+        )
+        raise ValueError("loop_controller node must set _loop_controller_destination")
+    return destination
+
 
 def _make_model_to_model_edge(
     *,
@@ -1107,5 +1232,7 @@ __all__ = [
     "_make_model_to_model_edge",
     "_make_tools_to_model_edge",
     "_make_loop_controller_edge",
+    "_make_loop_controller_node",
+    "_select_loop_controller_destination",
 ]