langchain-agentx-python 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

langchain_agentx/__init__.py

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

langchain_agentx/loop/graph/graph_edges.py

@@ -70,7 +70,6 @@ from ..exit.reason_codes import (
     TRANSITION_MAX_OUTPUT_TOKENS_ESCALATE,
     TRANSITION_MAX_OUTPUT_TOKENS_RECOVERY,
     TRANSITION_MAX_OUTPUT_TOKENS_RECOVERY_EXHAUSTED,
-    TRANSITION_REACTIVE_COMPACT_RETRY,
     TRANSITION_STOP_HOOK_BLOCKING,
     TRANSITION_STOP_HOOK_PREVENTED,
     TRANSITION_TASK_NOTIFICATION_ARRIVED,
@@ -452,6 +451,8 @@ class LoopControllerEdge:
             step=state.get("step", 0),
             turn_count=int(state.get("turn_count", 0) or 0),
             provider_finish_reason=state.get("finish_reason"),
+            error_kind="context_window",
+            recovery_exhausted=True,
         )
         state["transition"] = {
             "reason": TRANSITION_CONTEXT_WINDOW_RECOVERY_EXHAUSTED,
@@ -585,23 +586,6 @@ class LoopControllerEdge:
                 state,
                 destination=self._model_destination,
             )
-        if not state.get("has_attempted_reactive_compact", False):
-            state["has_attempted_reactive_compact"] = True
-            state["transition"] = {
-                "reason": TRANSITION_REACTIVE_COMPACT_RETRY,
-                "error_reason": withheld_error.get("reason"),
-            }
-            emit_loop_decision_event(
-                state=state,
-                decision="continue",
-                selected_edge=self._model_destination,
-                reason_code="reactive_compact_retry",
-                evidence={"withheld_error": withheld_error, "step": state.get("step", 0)},
-            )
-            return self._set_continue_resolution(
-                state,
-                destination=self._model_destination,
-            )
         state["transition"] = {
             "reason": TRANSITION_WITHHOLD_RECOVERY_RETRY,
             "error_reason": withheld_error.get("reason"),

langchain_agentx/loop/graph/reactive_compact_node.py

@@ -171,6 +171,7 @@ class ReactiveCompactNode:
         terminal = build_loop_terminal(
             reason=TERMINAL_REASON_MAX_TOKENS,
             error_kind="context_window",
+            recovery_exhausted=True,
         )
         patch = {
             STATE_HAS_ATTEMPTED_REACTIVE_COMPACT: True,

langchain_agentx/loop/model/model_node.py

@@ -1248,6 +1248,29 @@ class ModelNode(Runnable):
             and max_output_tokens_override is not None
             and max_output_tokens_recovery_count < MAX_OUTPUT_TOKENS_RECOVERY_LIMIT
         )
+        if (
+            should_end
+            and terminal_reason in RECOVERABLE_TERMINAL_REASONS
+            and overflow_kind == "context_window"
+        ):
+            withheld_error = build_withheld_error(
+                terminal_reason=terminal_reason,
+                finish_reason=finish_reason,
+                last_ai_message=last_ai_message,
+            )
+            return {
+                "should_end": False,
+                "terminal_reason": None,
+                "withheld_error": withheld_error,
+                "withhold_retry_count": withhold_retry_count,
+                "max_output_tokens_override": max_output_tokens_override,
+                "max_output_tokens_recovery_count": max_output_tokens_recovery_count,
+                "transition": {
+                    "reason": TRANSITION_WITHHOLD_RECOVERY_RETRY,
+                    "error_reason": withheld_error["reason"],
+                    "attempt": withhold_retry_count,
+                },
+            }
         if should_end and terminal_reason in RECOVERABLE_TERMINAL_REASONS and (
             can_default_withhold_retry or can_max_tokens_recovery_retry
         ):

langchain_agentx/loop/stream/loop_driver.py

@@ -10,6 +10,7 @@ loop_driver.py — Loop-aware shared stream driver.
 当前裁剪范围：
     root closeout 捕获、synthetic error/finish、orphan tool_result repair（stream surface）。
     正常结束但缺 root on_chain_end(LangGraph) 时打 anomaly WARNING（不伪造 synthetic finish）。
+    R1 反应恢复：单次 drain 内 budgeted continue 重入（S2，对齐 CC queryLoop continue）。
 """
 
 from __future__ import annotations
@@ -23,6 +24,7 @@ from langgraph.errors import GraphRecursionError
 from ..exit.reason_codes import (
     TERMINAL_REASON_GRAPH_RUNTIME_ERROR,
     TERMINAL_REASON_RUNTIME_BUDGET_EXHAUSTED,
+    TRANSITION_REACTIVE_COMPACT_RETRY,
 )
 from ..exit.terminal import apply_terminal_reason_projection, build_loop_terminal, read_terminal_reason
 from langchain_agentx.observability.events.tool_call_id_resolver import ToolCallIdResolver
@@ -57,6 +59,7 @@ class LoopStreamDriver:
         *,
         config: dict[str, Any] | None = None,
         version: str = "v2",
+        max_reactive_continue_per_drain: int = 0,
     ) -> AsyncIterator[dict[str, Any]]:
         self._graph_input = dict(graph_input)
         self._assistant_turn_count = 0
@@ -66,83 +69,173 @@ class LoopStreamDriver:
         self.result.last_raw_event = None
         self.result.saw_chat_model_end_last_turn = False
         self.result.saw_partial_superseded = False
+        self.result.reactive_continue_drains = 0
+        current_input = dict(graph_input)
+        reactive_continues = 0
         try:
-            try:
-                async for event in graph.astream_events(
-                    graph_input,
+            while True:
+                async for event in self._stream_single_drain(
+                    graph,
+                    current_input,
                     config=config,
                     version=version,
                 ):
-                    self._observe_event(event)
                     yield event
-                self.result.graph_completed = True
-                self._log_missing_root_chain_end_anomaly()
-            except asyncio.CancelledError as exc:
-                self.result.final_error = exc
-                for repair in self._orphan_tool_result_repairs(closeout_kind="cancelled"):
-                    yield repair
-                raise
-            except GraphRecursionError as exc:
-                self.result.final_error = exc
-                self._log_catch_error(exc)
-                for repair in self._orphan_tool_result_repairs(closeout_kind="interrupted"):
-                    yield repair
-                if not self.result.saw_error_visible_surface:
-                    self.result.saw_error_visible_surface = True
-                    yield build_synthetic_error_visible_event(
-                        message="Runtime budget exhausted (recursion limit reached)",
-                        error_kind="graph_recursion_error",
-                    )
-                if not self.result.saw_finish_surface:
-                    terminal = build_loop_terminal(
-                        reason=TERMINAL_REASON_RUNTIME_BUDGET_EXHAUSTED,
-                        error_kind="graph_recursion_error",
-                        step=(self.result.last_loop_snapshot or {}).get("step"),
-                        turn_count=(self.result.last_loop_snapshot or {}).get("turn_count"),
-                        provider_finish_reason=(self.result.last_loop_snapshot or {}).get("finish_reason"),
-                        errors=[str(exc)],
-                        metadata={
-                            "langgraph_error_type": "GraphRecursionError",
-                        },
-                    )
-                    self.result.terminal = terminal
-                    synthetic_output = self._build_synthetic_graph_output(terminal)
-                    self.result.graph_output = synthetic_output
-                    self.result.saw_finish_surface = True
-                    yield build_synthetic_root_chain_end(graph_output=synthetic_output)
-                self._log_catch_error_diagnostic(exc)
-                raise
-            except Exception as exc:
-                self.result.final_error = exc
-                # CC catch 协议 §5.3.3：先记录日志 / 观测，再补 stream surface，最后 re-raise
-                self._log_catch_error(exc)
-                for repair in self._orphan_tool_result_repairs(closeout_kind="interrupted"):
-                    yield repair
-                if not self.result.saw_error_visible_surface:
-                    self.result.saw_error_visible_surface = True
-                    yield build_synthetic_error_visible_event(
-                        message=str(exc),
-                        error_kind="graph_runtime_error",
-                    )
-                if not self.result.saw_finish_surface:
-                    terminal = build_loop_terminal(
-                        reason=TERMINAL_REASON_GRAPH_RUNTIME_ERROR,
-                        error_kind="graph_runtime_error",
-                        step=(self.result.last_loop_snapshot or {}).get("step"),
-                        turn_count=(self.result.last_loop_snapshot or {}).get("turn_count"),
-                        provider_finish_reason=(self.result.last_loop_snapshot or {}).get("finish_reason"),
-                        errors=[str(exc)],
-                    )
-                    self.result.terminal = terminal
-                    synthetic_output = self._build_synthetic_graph_output(terminal)
-                    self.result.graph_output = synthetic_output
-                    self.result.saw_finish_surface = True
-                    yield build_synthetic_root_chain_end(graph_output=synthetic_output)
-                self._log_catch_error_diagnostic(exc)
-                raise
+                if not self._should_reactive_continue_drain(
+                    continues_used=reactive_continues,
+                    max_continues=max_reactive_continue_per_drain,
+                ):
+                    break
+                reactive_continues += 1
+                self.result.reactive_continue_drains = reactive_continues
+                current_input = self._build_continue_graph_input(
+                    current_input,
+                    self.result.graph_output or {},
+                )
+                self._graph_input = dict(current_input)
+                self._reset_for_continue_drain()
+                logger.info(
+                    "LoopStreamDriver R1 continue: drain %s/%s transition=%s",
+                    reactive_continues,
+                    max_reactive_continue_per_drain,
+                    (self.result.graph_output or {}).get("transition", {}).get("reason"),
+                )
         finally:
             self._log_stream_closeout_summary()
 
+    async def _stream_single_drain(
+        self,
+        graph: Any,
+        graph_input: dict[str, Any],
+        *,
+        config: dict[str, Any] | None = None,
+        version: str = "v2",
+    ) -> AsyncIterator[dict[str, Any]]:
+        try:
+            async for event in graph.astream_events(
+                graph_input,
+                config=config,
+                version=version,
+            ):
+                self._observe_event(event)
+                yield event
+            self.result.graph_completed = True
+            self._log_missing_root_chain_end_anomaly()
+        except asyncio.CancelledError as exc:
+            self.result.final_error = exc
+            for repair in self._orphan_tool_result_repairs(closeout_kind="cancelled"):
+                yield repair
+            raise
+        except GraphRecursionError as exc:
+            self.result.final_error = exc
+            self._log_catch_error(exc)
+            for repair in self._orphan_tool_result_repairs(closeout_kind="interrupted"):
+                yield repair
+            if not self.result.saw_error_visible_surface:
+                self.result.saw_error_visible_surface = True
+                yield build_synthetic_error_visible_event(
+                    message="Runtime budget exhausted (recursion limit reached)",
+                    error_kind="graph_recursion_error",
+                )
+            if not self.result.saw_finish_surface:
+                terminal = build_loop_terminal(
+                    reason=TERMINAL_REASON_RUNTIME_BUDGET_EXHAUSTED,
+                    error_kind="graph_recursion_error",
+                    step=(self.result.last_loop_snapshot or {}).get("step"),
+                    turn_count=(self.result.last_loop_snapshot or {}).get("turn_count"),
+                    provider_finish_reason=(self.result.last_loop_snapshot or {}).get("finish_reason"),
+                    errors=[str(exc)],
+                    metadata={
+                        "langgraph_error_type": "GraphRecursionError",
+                    },
+                )
+                self.result.terminal = terminal
+                synthetic_output = self._build_synthetic_graph_output(terminal)
+                self.result.graph_output = synthetic_output
+                self.result.saw_finish_surface = True
+                yield build_synthetic_root_chain_end(graph_output=synthetic_output)
+            self._log_catch_error_diagnostic(exc)
+            raise
+        except Exception as exc:
+            self.result.final_error = exc
+            # CC catch 协议 §5.3.3：先记录日志 / 观测，再补 stream surface，最后 re-raise
+            self._log_catch_error(exc)
+            for repair in self._orphan_tool_result_repairs(closeout_kind="interrupted"):
+                yield repair
+            if not self.result.saw_error_visible_surface:
+                self.result.saw_error_visible_surface = True
+                yield build_synthetic_error_visible_event(
+                    message=str(exc),
+                    error_kind="graph_runtime_error",
+                )
+            if not self.result.saw_finish_surface:
+                terminal = build_loop_terminal(
+                    reason=TERMINAL_REASON_GRAPH_RUNTIME_ERROR,
+                    error_kind="graph_runtime_error",
+                    step=(self.result.last_loop_snapshot or {}).get("step"),
+                    turn_count=(self.result.last_loop_snapshot or {}).get("turn_count"),
+                    provider_finish_reason=(self.result.last_loop_snapshot or {}).get("finish_reason"),
+                    errors=[str(exc)],
+                )
+                self.result.terminal = terminal
+                synthetic_output = self._build_synthetic_graph_output(terminal)
+                self.result.graph_output = synthetic_output
+                self.result.saw_finish_surface = True
+                yield build_synthetic_root_chain_end(graph_output=synthetic_output)
+            self._log_catch_error_diagnostic(exc)
+            raise
+
+    def _should_reactive_continue_drain(
+        self,
+        *,
+        continues_used: int,
+        max_continues: int,
+    ) -> bool:
+        if max_continues <= 0 or continues_used >= max_continues:
+            return False
+        if self.result.final_error is not None:
+            return False
+        if not self.result.saw_root_chain_end or not self.result.graph_completed:
+            return False
+        output = self.result.graph_output
+        if not isinstance(output, dict):
+            return False
+        resolution = output.get("resolution")
+        if not isinstance(resolution, dict) or resolution.get("kind") != "continue":
+            return False
+        transition = resolution.get("transition")
+        if not isinstance(transition, dict):
+            transition = output.get("transition")
+        if not isinstance(transition, dict):
+            return False
+        return transition.get("reason") == TRANSITION_REACTIVE_COMPACT_RETRY
+
+    def _build_continue_graph_input(
+        self,
+        prior_input: dict[str, Any],
+        graph_output: dict[str, Any],
+    ) -> dict[str, Any]:
+        continued = dict(prior_input)
+        messages = graph_output.get("messages")
+        if isinstance(messages, list):
+            continued["messages"] = list(messages)
+        for key in (
+            "has_attempted_reactive_compact",
+            "_session_id",
+            "_run_id",
+            "_trace_collector",
+        ):
+            if key in graph_output:
+                continued[key] = graph_output[key]
+        return continued
+
+    def _reset_for_continue_drain(self) -> None:
+        self._pending_tool_calls.clear()
+        self.result.saw_root_chain_end = False
+        self.result.saw_finish_surface = False
+        self.result.graph_completed = False
+        self.result.final_error = None
+
     def _observe_event(self, event: dict[str, Any]) -> None:
         event_name = str(event.get("event") or "")
         name = str(event.get("name") or "")

langchain_agentx/loop/stream/result.py

@@ -31,6 +31,7 @@ class StreamDriverResult:
     last_raw_event: str | None = None
     saw_chat_model_end_last_turn: bool = False
     saw_partial_superseded: bool = False
+    reactive_continue_drains: int = 0
 
 
 __all__ = ["StreamDriverResult"]

langchain_agentx/loop/subagent/context.py

@@ -29,6 +29,12 @@ from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import Any, Literal
 
+from langchain_agentx.observability.events.finish_outcome import (
+    RecoveryPolicy,
+    RecoveryPolicyMode,
+    coerce_recovery_policy,
+)
+
 from langchain_agentx.loop.context.query_source import LoopCompilationContext
 from langchain_agentx.loop.exit.query_source import QuerySource
 from langchain_agentx.loop.runtime.subagent_execution_paths import (
@@ -107,6 +113,9 @@ class SubagentContext:
     # Thinking 控制字段（request-side 生成意图，与 UI 展示意图分离）
     thinking_generation_enabled: bool = True  # 子代理 request-side thinking 生成开关
 
+    # R1 恢复策略（S4→S2；None 在 runner 层按 interactive 解析）
+    recovery: RecoveryPolicy | None = None
+
 
 @dataclass
 class SubagentResult:
@@ -150,6 +159,7 @@ def create_subagent_context(
     thinking_generation_enabled: bool = True,
     query_source: str | None = None,
     is_builtin_subagent: bool = False,
+    recovery: RecoveryPolicy | RecoveryPolicyMode | None = None,
 ) -> SubagentContext:
     """工厂函数：从父上下文创建子 Agent 上下文
 
@@ -285,6 +295,14 @@ def create_subagent_context(
         effective_cwd=effective_cwd,
     )
 
+    resolved_recovery: RecoveryPolicy | None = None
+    if recovery is not None:
+        resolved_recovery = coerce_recovery_policy(recovery)
+    else:
+        parent_recovery = getattr(parent_ctx, "recovery", None)
+        if isinstance(parent_recovery, (RecoveryPolicy, str)):
+            resolved_recovery = coerce_recovery_policy(parent_recovery)
+
     return SubagentContext(
         agent_id=agent_id,
         initial_messages=initial_messages,
@@ -317,6 +335,7 @@ def create_subagent_context(
         available_tools=list(available_tools or []),
         thinking_generation_enabled=thinking_generation_enabled,
         query_source=resolved_query_source,
+        recovery=resolved_recovery,
     )
 
 

langchain_agentx/loop/subagent/runner.py

@@ -55,6 +55,11 @@ from langchain_agentx.loop.message_contract import (
     is_synthetic_transcript_tool_id,
     to_record,
 )
+from langchain_agentx.observability.events.finish_outcome import (
+    RecoveryPolicy,
+    RecoveryPolicyMode,
+    coerce_recovery_policy,
+)
 from langchain_agentx.observability.events.tool_call_id_resolver import ToolCallIdResolver
 from langchain_agentx.observability.events.tool_outcome_resolver import (
     error_message_for_outcome,
@@ -504,6 +509,7 @@ async def _collect_subagent_events(
     run_tags: list[str],
     transcript: SubagentTranscriptManager,
     trace: SubagentExecutionTrace,
+    recovery: RecoveryPolicy | RecoveryPolicyMode | None = None,
 ) -> _EventCollectionResult:
     collected_assistant_messages: list[Any] = []
     terminal_reason = "completed"
@@ -533,12 +539,16 @@ async def _collect_subagent_events(
                     config["configurable"] = dict(configurable)
 
     try:
+        recovery_policy = coerce_recovery_policy(
+            recovery if recovery is not None else ctx.recovery
+        )
         driver = LoopStreamDriver()
         async for event in driver.run(
             graph,
             graph_input,
             config=config,
             version="v2",
+            max_reactive_continue_per_drain=recovery_policy.reactive_continue_budget(),
         ):
             event_name = event.get("event", "")
             data = event.get("data") or {}
@@ -667,6 +677,7 @@ async def run_subagent(
     loader: Any,
     model: Any | None = None,
     allowed_tool_names: set[str] | None = None,
+    recovery: RecoveryPolicy | RecoveryPolicyMode | None = None,
 ) -> SubagentResult:
     """运行子 Agent（plain/fork 同步路径）。
 
@@ -715,6 +726,7 @@ async def run_subagent(
             run_tags=run_tags,
             transcript=transcript,
             trace=trace,
+            recovery=recovery,
         )
         return await _build_subagent_result(
             ctx=ctx,

langchain_agentx/observability/__init__.py

@@ -12,7 +12,9 @@ from .events import (
     LangGraphToLangchainAgentEventAdapter,
     RecoveryAction,
     RecoveryActionResolver,
+    RecoveryPolicy,
     RecoveryPolicyMode,
+    coerce_recovery_policy,
     create_langgraph_event_adapter,
     enrich_run_result,
 )
@@ -69,7 +71,9 @@ __all__ = [
     "create_langgraph_event_adapter",
     "RecoveryAction",
     "RecoveryActionResolver",
+    "RecoveryPolicy",
     "RecoveryPolicyMode",
+    "coerce_recovery_policy",
     "enrich_run_result",
     "REASON_CODES",
     "export_call_chain",

langchain_agentx/observability/events/__init__.py

@@ -13,7 +13,9 @@ from .finish_outcome import (
     FinishOutcomeParser,
     RecoveryAction,
     RecoveryActionResolver,
+    RecoveryPolicy,
     RecoveryPolicyMode,
+    coerce_recovery_policy,
     enrich_run_result,
 )
 from .factory import (
@@ -32,7 +34,9 @@ __all__ = [
     "FinishOutcomeParser",
     "RecoveryAction",
     "RecoveryActionResolver",
+    "RecoveryPolicy",
     "RecoveryPolicyMode",
+    "coerce_recovery_policy",
     "enrich_run_result",
     "ILangGraphEventAdapter",
     "create_langgraph_event_adapter",

langchain_agentx/observability/events/finish_outcome.py

@@ -54,6 +54,34 @@ FINISH_OUTCOME_KEYS = frozenset(
 RecoveryPolicyMode = Literal["interactive", "auto"]
 
 
+@dataclass(frozen=True)
+class RecoveryPolicy:
+    """Stream 恢复策略配置面（S4 消费方 → S2 LoopStreamDriver 注入）。
+
+    非 Session 编排 API：仅控制 R1 reactive continue 预算与 finish 消费模式。
+    """
+
+    mode: RecoveryPolicyMode = "interactive"
+    max_reactive_continue_per_drain: int = 1
+
+    def reactive_continue_budget(self) -> int:
+        """返回 LoopStreamDriver R1 continue 预算（interactive 禁用自动 continue）。"""
+        if self.mode == "interactive":
+            return 0
+        return self.max_reactive_continue_per_drain
+
+
+def coerce_recovery_policy(
+    recovery: RecoveryPolicy | RecoveryPolicyMode | None = None,
+) -> RecoveryPolicy:
+    """将消费方传入的 recovery 规范化为 RecoveryPolicy。"""
+    if recovery is None:
+        return RecoveryPolicy()
+    if isinstance(recovery, str):
+        return RecoveryPolicy(mode=recovery)
+    return recovery
+
+
 class RecoveryAction(str, Enum):
     """消费方建议动作（不含具体 UI 文案）。"""
 
@@ -248,6 +276,8 @@ __all__ = [
     "FinishOutcomeParser",
     "RecoveryAction",
     "RecoveryActionResolver",
+    "RecoveryPolicy",
     "RecoveryPolicyMode",
+    "coerce_recovery_policy",
     "enrich_run_result",
 ]

langchain_agentx/session/__init__.py

@@ -20,10 +20,8 @@ from .plan_mode import (
 )
 from .protocol import LoopContainer
 from .recovery import (
-    SessionRecoveryRunResult,
     finish_outcome_from_graph_output,
-    parse_result_finish_outcome,
-    run_with_recovery_loop,
+    finish_outcome_from_stream_driver_result,
 )
 
 __all__ = [
@@ -35,15 +33,13 @@ __all__ = [
     "DEFAULT_CLEANUP_ACTION_TIMEOUT",
     "ConversationSession",
     "LoopContainer",
-    "SessionRecoveryRunResult",
     "create_agent_session",
     "create_conversation_session",
     "build_plan_mode_transition_event",
     "enter_plan_mode",
     "exit_plan_mode",
     "finish_outcome_from_graph_output",
+    "finish_outcome_from_stream_driver_result",
     "load_session_messages",
-    "parse_result_finish_outcome",
     "PlanModeTransition",
-    "run_with_recovery_loop",
 ]

langchain_agentx/session/agent_session.py

@@ -38,13 +38,16 @@ from ..command.builtin import (
     make_memory_command,
     make_reload_plugins_command,
 )
-from ..observability.events.finish_outcome import RecoveryPolicyMode, enrich_run_result
+from ..observability.events.finish_outcome import (
+    RecoveryPolicy,
+    RecoveryPolicyMode,
+    coerce_recovery_policy,
+    enrich_run_result,
+)
 from ..loop.config import merge_run_config
 from .recovery import (
-    SessionRecoveryRunResult,
     finish_outcome_from_graph_output,
     finish_outcome_from_stream_driver_result,
-    run_with_recovery_loop,
 )
 from ..loop.config.loop_runtime_overlay import LoopRuntimeOverlay
 from ..loop.context.compaction_service import default_loop_context_compaction
@@ -226,37 +229,6 @@ class AgentSession:
         finally:
             reset_command_tool_scope(store)
 
-    async def resume_after_compact(self) -> dict[str, Any]:
-        """compact 后重跑当前轮：不再 append 新的 HumanMessage。
-
-        适用于 CLI `/compact` 或 headless auto 恢复的第二跳；与 ``run_loop(same_query)``
-        不同，不会把同一用户问题重复写入 messages / transcript。
-        """
-        return await self._run_loop_turn(user_input=None)
-
-    async def run_with_recovery(
-        self,
-        user_input: str,
-        *,
-        mode: RecoveryPolicyMode = "auto",
-        max_outer_retries: int = 1,
-        progress_callback: Any = None,
-    ) -> SessionRecoveryRunResult:
-        """B1 外层自动恢复：recoverable 时 compact + resume，受 ``max_outer_retries`` 约束。
-
-        - ``mode="auto"``：可恢复且未 exhausted 时自动 compact 并 resume。
-        - ``mode="interactive"``：只跑一轮，把 ``RecoveryAction`` 留给 CLI 决策。
-        """
-        return await run_with_recovery_loop(
-            user_input=user_input,
-            mode=mode,
-            max_outer_retries=max_outer_retries,
-            run_new_turn=lambda inp: self._run_loop_turn(user_input=inp),
-            resume_current_turn=lambda: self._run_loop_turn(user_input=None),
-            compact=self.compact_context,
-            progress_callback=progress_callback,
-        )
-
     async def _run_loop_turn(self, *, user_input: str | None) -> dict[str, Any]:
         if self._graph is None:
             raise RuntimeError("AgentSession graph is not initialized")
@@ -302,6 +274,7 @@ class AgentSession:
         user_input: str,
         *,
         config: dict[str, Any] | None = None,
+        recovery: RecoveryPolicy | RecoveryPolicyMode | None = None,
     ) -> AsyncIterator[dict[str, Any]]:
         """
         流式执行一轮 loop，复用 AgentSession 的消息上下文。
@@ -322,6 +295,7 @@ class AgentSession:
         output_messages: list[Any] | None = None
         graph_output: dict[str, Any] | None = None
         run_config = merge_run_config(self._graph, config)
+        recovery_policy = coerce_recovery_policy(recovery)
         driver = LoopStreamDriver()
         try:
             try:
@@ -333,6 +307,7 @@ class AgentSession:
                     },
                     config=run_config,
                     version="v2",
+                    max_reactive_continue_per_drain=recovery_policy.reactive_continue_budget(),
                 ):
                     if event.get("event") == "on_chain_end" and event.get("name") == "LangGraph":
                         data = event.get("data", {}) or {}
@@ -594,4 +569,4 @@ class AgentSession:
         self._runtime_command_registry.register(make_reload_plugins_command())
 
 
-__all__ = ["AgentSession", "SessionRecoveryRunResult"]
+__all__ = ["AgentSession"]

langchain_agentx/session/conversation_session.py

@@ -40,6 +40,11 @@ from ..loop.context.compaction_service import default_loop_context_compaction
 from ..loop.context.message_utils import total_estimated_tokens_for_messages
 from ..loop.hook.types import HookContext, HookEvent
 from ..loop.stream.loop_driver import LoopStreamDriver
+from ..observability.events.finish_outcome import (
+    RecoveryPolicy,
+    RecoveryPolicyMode,
+    coerce_recovery_policy,
+)
 from ..memory.memdir.extractor import drain_pending_extraction
 from ..plugin.loader import PluginLoader
 from ..plugin.registries import AgentRegistry, CommandRegistry as PluginCommandRegistry, SkillRegistry
@@ -264,6 +269,7 @@ class ConversationSession:
         user_input: str,
         *,
         config: dict[str, Any] | None = None,
+        recovery: RecoveryPolicy | RecoveryPolicyMode | None = None,
     ):
         """流式执行单轮对话，graph 每次新建。"""
         from ..session.recovery import (
@@ -282,6 +288,7 @@ class ConversationSession:
         output_messages: list[Any] | None = None
         graph_output: dict[str, Any] | None = None
         run_config = merge_run_config(graph, config)
+        recovery_policy = coerce_recovery_policy(recovery)
         driver = LoopStreamDriver()
         try:
             async for event in driver.run(
@@ -292,6 +299,7 @@ class ConversationSession:
                 },
                 config=run_config,
                 version="v2",
+                max_reactive_continue_per_drain=recovery_policy.reactive_continue_budget(),
             ):
                 if event.get("event") == "on_chain_end" and event.get("name") == "LangGraph":
                     data = event.get("data", {}) or {}

langchain_agentx/session/recovery.py

@@ -1,55 +1,21 @@
 """
-session/recovery.py — AgentSession 外层恢复编排（B1 auto / interactive 分流）
+session/recovery.py — Stream closeout helpers for AgentSession.
 
 职责：
-    在 run_loop + compact_context 之上封装「compact 后继续同一问题」与 auto 模式重试预算，
-    避免消费方重复 append 同一条 HumanMessage。
+    从 graph output / LoopStreamDriver.result 构建 finish_outcome 字典。
 
 链路位置：
-    AgentSession.run_with_recovery / resume_after_compact → 本模块
+    AgentSession.stream_loop_events closeout → 本模块
 
 当前裁剪范围：
-    - 不做图内 reactive_compact 拓扑修复（见 release 文档缺口 2）
-    - 不做 B2 透明自恢复（单次 invoke 内无感知恢复）
+    仅 stream closeout helper；R1 反应恢复归 LoopStreamDriver（见 error-flow 设计 2026-07-11）。
 """
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, Awaitable, Callable, Protocol
+from typing import Any
 
-from langchain_agentx.observability.events.finish_outcome import (
-    FinishOutcome,
-    FinishOutcomeParser,
-    RecoveryAction,
-    RecoveryActionResolver,
-    RecoveryPolicyMode,
-)
-
-
-class _CompactCallable(Protocol):
-    async def __call__(self, *, progress_callback: Any = None) -> tuple[int, int]: ...
-
-
-class _RunOnceCallable(Protocol):
-    async def __call__(self) -> dict[str, Any]: ...
-
-
-@dataclass(frozen=True)
-class SessionRecoveryRunResult:
-    """run_with_recovery 返回：最后一轮 graph 结果 + 终态语义 + 外层 compact 次数。"""
-
-    result: dict[str, Any]
-    outcome: FinishOutcome
-    action: RecoveryAction
-    outer_recovery_attempts: int
-
-
-def parse_result_finish_outcome(result: dict[str, Any]) -> FinishOutcome:
-    raw = result.get("finish_outcome")
-    if isinstance(raw, dict):
-        return FinishOutcomeParser().parse_finish_data(raw)
-    return FinishOutcomeParser().from_loop_state(result)
+from langchain_agentx.observability.events.finish_outcome import FinishOutcomeParser
 
 
 def finish_outcome_from_graph_output(output: dict[str, Any] | None) -> dict[str, Any]:
@@ -78,53 +44,7 @@ def finish_outcome_from_stream_driver_result(result: Any) -> dict[str, Any] | No
     return finish_outcome_from_graph_output(output)
 
 
-async def run_with_recovery_loop(
-    *,
-    user_input: str,
-    mode: RecoveryPolicyMode,
-    max_outer_retries: int,
-    run_new_turn: Callable[[str], Awaitable[dict[str, Any]]],
-    resume_current_turn: Callable[[], Awaitable[dict[str, Any]]],
-    compact: _CompactCallable,
-    progress_callback: Any = None,
-) -> SessionRecoveryRunResult:
-    """B1 外层编排：首轮 run_new_turn；recoverable 时 compact + resume（不重复 append）。"""
-    if max_outer_retries < 0:
-        raise ValueError("max_outer_retries must be >= 0")
-
-    result = await run_new_turn(user_input)
-    outcome = parse_result_finish_outcome(result)
-    action = RecoveryActionResolver.resolve(outcome, mode=mode)
-    attempts = 0
-
-    while attempts < max_outer_retries:
-        if outcome.succeeded:
-            break
-        if RecoveryActionResolver.blocks_auto_compact(outcome):
-            break
-        if mode == "interactive":
-            break
-        resolved = RecoveryActionResolver.resolve(outcome, mode="auto")
-        if resolved != RecoveryAction.AUTO_COMPACT:
-            break
-        await compact(progress_callback=progress_callback)
-        attempts += 1
-        result = await resume_current_turn()
-        outcome = parse_result_finish_outcome(result)
-        action = RecoveryActionResolver.resolve(outcome, mode=mode)
-
-    return SessionRecoveryRunResult(
-        result=result,
-        outcome=outcome,
-        action=action,
-        outer_recovery_attempts=attempts,
-    )
-
-
 __all__ = [
-    "SessionRecoveryRunResult",
     "finish_outcome_from_graph_output",
     "finish_outcome_from_stream_driver_result",
-    "parse_result_finish_outcome",
-    "run_with_recovery_loop",
 ]

langchain_agentx/tools/glob/tool.py

@@ -33,6 +33,10 @@ from langchain_agentx.tool_runtime.models import (
 )
 from langchain_agentx.tool_runtime.state_bridge import ToolStateBridge
 from langchain_agentx.tools.grep.backend import GrepExecutionError, RipgrepBackend
+from langchain_agentx.tools.search_path_resolver import (
+    policy_read_roots_from_engine,
+    resolve_search_root_for_prefixed_pattern,
+)
 from langchain_agentx.tools.ripgrep_plugin_exclusions import PluginCacheGlobExclusions
 from langchain_agentx.utils.path import expand_path
 from langchain_agentx.utils.path_user_input import UserPathInputNormalizer
@@ -129,12 +133,19 @@ class GlobRuntimeTool(RuntimeTool):
             data["pattern"] = pattern.strip()
 
         path = data.get("path")
+        default_root = resolve_tool_cwd(ctx)
+        pattern = str(data.get("pattern") or "").strip()
         if isinstance(path, str) and path.strip():
             data["path"] = self._path_normalizer.normalize_and_expand(
-                path, base_dir=resolve_tool_cwd(ctx)
+                path, base_dir=default_root
             )
         else:
-            data["path"] = resolve_tool_cwd(ctx)
+            data["path"] = resolve_search_root_for_prefixed_pattern(
+                pattern,
+                default_root,
+                ctx,
+                policy_read_roots=policy_read_roots_from_engine(self._policy),
+            )
         return data
 
     def validate_input(

langchain_agentx/tools/grep/tool.py

@@ -27,6 +27,10 @@ from langchain_agentx.tool_runtime.models import (
 )
 
 from langchain_agentx.tools.ripgrep_plugin_exclusions import PluginCacheGlobExclusions
+from langchain_agentx.tools.search_path_resolver import (
+    policy_read_roots_from_engine,
+    resolve_search_root_for_prefixed_pattern,
+)
 from langchain_agentx.utils.rg_executable import default_rg_executable
 from langchain_agentx.utils.unc_path import is_unc_path_skip_local_stat
 from langchain_agentx.workspace.tool_boundary import (
@@ -110,13 +114,28 @@ class GrepRuntimeTool(RuntimeTool):
         self, raw: dict[str, Any], ctx: ToolExecutionContext
     ) -> dict[str, Any]:
         data = dict(raw)
+        default_root = resolve_tool_cwd(ctx)
         path = data.get("path")
         if isinstance(path, str) and path.strip():
             data["path"] = self._path_normalizer.normalize_and_expand(
-                path, base_dir=resolve_tool_cwd(ctx)
+                path, base_dir=default_root
             )
         else:
-            data["path"] = resolve_tool_cwd(ctx)
+            glob_val = data.get("glob")
+            probe = (
+                str(glob_val).strip()
+                if isinstance(glob_val, str) and glob_val.strip()
+                else ""
+            )
+            if probe:
+                data["path"] = resolve_search_root_for_prefixed_pattern(
+                    probe,
+                    default_root,
+                    ctx,
+                    policy_read_roots=policy_read_roots_from_engine(self._policy),
+                )
+            else:
+                data["path"] = default_root
         pat = data.get("pattern")
         if isinstance(pat, str):
             data["pattern"] = pat.strip()
@@ -391,6 +410,7 @@ class GrepRuntimeTool(RuntimeTool):
             "mode": r.mode.value,
             "duration_ms": round(r.duration_ms, 2),
             "pattern": r.pattern,
+            "search_root": r.search_root,
         }
 
         if r.mode == GrepOutputMode.files_with_matches:

langchain_agentx/tools/search_path_resolver.py

@@ -0,0 +1,132 @@
+"""
+tools/search_path_resolver.py — repo 锚定 pattern 的 search_root 自动修正
+
+职责：
+    相对 glob pattern 含静态目录前缀、且该前缀在默认 search_root 下不存在时，
+    在 read_roots 上探测前缀目录并将 path 提升到匹配的 root（normalize 层）。
+
+链路位置：
+    GlobRuntimeTool.normalize_input（path 缺省且 pattern 含静态前缀）
+    GrepRuntimeTool.normalize_input（path 缺省且 glob 含静态前缀）
+
+裁剪：
+    仅处理相对 pattern；绝对 pattern 仍由 invoke 内 extract_glob_base_directory 处理。
+    前缀在 default_search_root 下已存在时不改写（避免误抬升 cwd 内局部搜索）。
+    有 boundary_view 时仅探测 effective_read_roots，不合并 policy 超集（对齐 L1）。
+
+已知限制（P3 · 方案 A — 文档化，暂不改代码）：
+    多 read_root 同时满足 ``{root}/{prefix}`` 为目录时，取路径字符串最短的 root；
+    长度并列时按探测顺序。典型单 repo / monorepo 父根部署无歧义；
+    并列双 repo 同构目录树时需显式传 ``path``。见 docs/bug/glob-search-root-cwd-mismatch-2026-07-11.md §已知限制。
+"""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any
+
+from langchain_agentx.tools.glob.rg_pattern import extract_glob_base_directory
+from langchain_agentx.workspace.tool_boundary import get_boundary_view
+
+if TYPE_CHECKING:
+    from langchain_agentx.tool_runtime.models import ToolExecutionContext
+
+
+def _join_root_and_prefix(root: str, base_dir: str) -> str:
+    parts = [p for p in base_dir.replace("\\", "/").split("/") if p and p != "."]
+    return os.path.join(root, *parts) if parts else root
+
+
+def _prefix_dir_exists(root: str, base_dir: str) -> bool:
+    candidate = _join_root_and_prefix(root, base_dir)
+    return os.path.isdir(candidate)
+
+
+def _collect_probe_read_roots(
+    ctx: ToolExecutionContext,
+    *,
+    policy_read_roots: list[str] | None,
+    default_search_root: str,
+) -> list[str]:
+    ordered: list[str] = []
+    seen: set[str] = set()
+
+    def add(root: str) -> None:
+        if not root:
+            return
+        real = os.path.realpath(root)
+        if real in seen:
+            return
+        seen.add(real)
+        ordered.append(real)
+
+    view = get_boundary_view(ctx)
+    if view is not None:
+        for root in view.effective_read_roots():
+            add(str(root))
+    else:
+        for root in policy_read_roots or []:
+            add(root)
+
+    add(default_search_root)
+    return ordered
+
+
+def policy_read_roots_from_engine(policy: Any | None) -> list[str]:
+    """从 DefaultPolicyEngine（或兼容对象）读取 read_roots，供 normalize 探测。"""
+    if policy is None:
+        return []
+    roots = getattr(policy, "_read_roots", None)
+    if roots:
+        return [str(r) for r in roots]
+    config = getattr(policy, "_config", None)
+    if config is not None:
+        cfg_roots = getattr(config, "read_roots", None) or []
+        return [str(r) for r in cfg_roots]
+    return []
+
+
+def resolve_search_root_for_prefixed_pattern(
+    pattern: str,
+    default_search_root: str,
+    ctx: ToolExecutionContext,
+    *,
+    policy_read_roots: list[str] | None = None,
+) -> str:
+    """
+    当相对 pattern 的静态前缀在 default_search_root 下不存在时，
+    在 read_roots 中查找使 ``{root}/{prefix}`` 为目录的最浅 root 并返回。
+
+    多 root 同匹配时的 tie-break：当前取 ``len(root)`` 最小者（路径并列时按
+    ``_collect_probe_read_roots`` 顺序）。见模块头「已知限制（P3）」。
+    """
+    pat = pattern.strip()
+    if not pat or os.path.isabs(pat):
+        return default_search_root
+
+    base_dir, _ = extract_glob_base_directory(pat)
+    if not base_dir or base_dir in (".", "/"):
+        return default_search_root
+
+    default_real = os.path.realpath(default_search_root)
+    if _prefix_dir_exists(default_real, base_dir):
+        return default_search_root
+
+    best: str | None = None
+    for root in _collect_probe_read_roots(
+        ctx,
+        policy_read_roots=policy_read_roots,
+        default_search_root=default_search_root,
+    ):
+        if not _prefix_dir_exists(root, base_dir):
+            continue
+        if best is None or len(root) < len(best):
+            best = root
+
+    return best if best is not None else default_search_root
+
+
+__all__ = [
+    "policy_read_roots_from_engine",
+    "resolve_search_root_for_prefixed_pattern",
+]

langchain_agentx/workflow/execution.py

@@ -27,6 +27,11 @@ from typing import Any, ClassVar
 from ..loop.config.agent_config import merge_run_config
 from ..loop.run_context import get_run_context, register_spawned_task
 from ..loop.stream.loop_driver import LoopStreamDriver
+from ..observability.events.finish_outcome import (
+    RecoveryPolicy,
+    RecoveryPolicyMode,
+    coerce_recovery_policy,
+)
 from .runtime import WorkflowAgentRuntime, WorkflowGraphFactory
 
 
@@ -238,6 +243,7 @@ class LoopInvocation:
     session_id: str
     parent_conversation_session_id: str | None = None
     is_subagent: bool = False
+    recovery: RecoveryPolicy | None = None
 
     @classmethod
     def from_context(
@@ -247,6 +253,7 @@ class LoopInvocation:
         messages: list[Any],
         graph: Any,
         caller_config: dict[str, Any] | None = None,
+        recovery: RecoveryPolicy | RecoveryPolicyMode | None = None,
     ) -> "LoopInvocation":
         session_id = WorkflowSessionIdPolicy.build_session_id(context)
         return cls(
@@ -259,6 +266,7 @@ class LoopInvocation:
             session_id=session_id,
             parent_conversation_session_id=context.parent_session_id,
             is_subagent=WorkflowSessionIdPolicy.is_subagent(context),
+            recovery=coerce_recovery_policy(recovery),
         )
 
 
@@ -295,6 +303,7 @@ class WorkflowAgentLoopExecutor:
         context: WorkflowNodeContext,
         messages: list[Any],
         caller_config: dict[str, Any] | None = None,
+        recovery: RecoveryPolicy | RecoveryPolicyMode | None = None,
     ) -> LoopInvocation:
         graph_factory = self._require_graph_factory()
         runtime = WorkflowAgentRuntime(
@@ -308,6 +317,7 @@ class WorkflowAgentLoopExecutor:
             messages=messages,
             graph=graph,
             caller_config=caller_config,
+            recovery=recovery,
         )
 
     async def ainvoke(
@@ -316,11 +326,13 @@ class WorkflowAgentLoopExecutor:
         context: WorkflowNodeContext,
         messages: list[Any],
         caller_config: dict[str, Any] | None = None,
+        recovery: RecoveryPolicy | RecoveryPolicyMode | None = None,
     ) -> dict[str, Any]:
         invocation = self.build_invocation(
             context=context,
             messages=messages,
             caller_config=caller_config,
+            recovery=recovery,
         )
         return await self.run_invocation(
             invocation=invocation,
@@ -458,6 +470,7 @@ class WorkflowAgentLoopExecutor:
         version: str = "v2",
     ) -> AsyncIterator[dict[str, Any]]:
         del context
+        recovery_policy = coerce_recovery_policy(invocation.recovery)
 
         async def _run() -> AsyncIterator[dict[str, Any]]:
             async for event in driver.run(
@@ -465,6 +478,7 @@ class WorkflowAgentLoopExecutor:
                 invocation.graph_input,
                 config=invocation.run_config,
                 version=version,
+                max_reactive_continue_per_drain=recovery_policy.reactive_continue_budget(),
             ):
                 yield event
 

{langchain_agentx_python-2.0.1.dist-info → langchain_agentx_python-2.1.0.dist-info}/METADATA

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

{langchain_agentx_python-2.0.1.dist-info → langchain_agentx_python-2.1.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-langchain_agentx/__init__.py,sha256=mIitE_209ZGQxVtUqOUCj_SxLxyx1fxbhZz6VZhlo_c,1678
+langchain_agentx/__init__.py,sha256=CgHyU18uWVbXjHg_5d0L50y28LboDeAoFspC7YP5mk0,1678
 langchain_agentx/command/__init__.py,sha256=Ej260S5uFQcmEtGZQG_NH7BYjHoStrpBLtGUsBTxyZk,631
 langchain_agentx/command/allowed_tools.py,sha256=TVA0VM8rm98H-QbLK_GRiX5RhEAZFxKawliMi4kk96A,3359
 langchain_agentx/command/context.py,sha256=DIGOGPBw5UGDBm0WNNJlKx1h_9rCRmcdROv4DT61Qug,731
@@ -69,8 +69,8 @@ langchain_agentx/loop/exit/withheld_error.py,sha256=LfX3j7Rgd9VoMzlz7GOs9TPuRe7R
 langchain_agentx/loop/graph/__init__.py,sha256=9pUUqn7G87n3lV45iYIU24j0wcTHyCD--SSdtv3urh4,136
 langchain_agentx/loop/graph/builtin_loop_control.py,sha256=jagBvSo8fj6Yjl95rkp5A0W8RgyVf4P-EXMmGweURl8,7184
 langchain_agentx/loop/graph/factory.py,sha256=vo98tu_tbWI0s5q_fcCJgoN1yVQ5E2l0OG8LTJP9BZo,103009
-langchain_agentx/loop/graph/graph_edges.py,sha256=6mvLTRzTC9nArkrd5q5zGzRD_vKknZeInczJuBf9z-k,47994
-langchain_agentx/loop/graph/reactive_compact_node.py,sha256=AN31reohf25zRiqdPTmFCIQ1N6VwKn1oIkRkRuGAp4k,8725
+langchain_agentx/loop/graph/graph_edges.py,sha256=W4n8xzXIz_G2n5nyMmHsMW2vMoGHLgeEtZNxNWwgiHg,47276
+langchain_agentx/loop/graph/reactive_compact_node.py,sha256=633b5hTnR3BK8GBEKWhzOwGB0BQrVRKozNxDomWFjLo,8762
 langchain_agentx/loop/graph/runtime_tools_node.py,sha256=5iBPvHl2hOdfnRZrwtnoD4J_SzEuQKC6VQUJyPuthgA,5089
 langchain_agentx/loop/hook/__init__.py,sha256=rOjc1cqWBxrcp651w_SQX50dWY7o28L2c-r8iVs-SWU,2167
 langchain_agentx/loop/hook/async_hook_runner.py,sha256=SNyuYnQoowZzBTBHQb6o5L9wTG2Rl7qryeMtqFyEsxI,3195
@@ -98,7 +98,7 @@ langchain_agentx/loop/messages/transcript_codec.py,sha256=ib4Hybdu0Al-QSA7Ae5z4z
 langchain_agentx/loop/messages/types.py,sha256=h95GW0BSMf7P49AZKYDuT_lcdz2AgNKiBrabH6O30pI,3225
 langchain_agentx/loop/messages/validate.py,sha256=5OV7_DIlzHSz5gnhcnnYpAE6XiUYc67jtQJ1HmxlfAA,3844
 langchain_agentx/loop/model/__init__.py,sha256=8wOiwa2Yvh7QdR6ilhk4faI7_iwNT6QSEFgewJNhhOw,57
-langchain_agentx/loop/model/model_node.py,sha256=EWyWyHbKim39pqVZ40EB5on7Lv7jY65xNaUaLon06PQ,52229
+langchain_agentx/loop/model/model_node.py,sha256=FY2_3Menv3ijfZvVt9sSrybN3QMWNRN2m0DX87wmNG8,53215
 langchain_agentx/loop/model/model_nodes.py,sha256=SqcPXJu4krh6IkrR1PHOMtaZPPZ0F09PY3_dtYtBhIk,29493
 langchain_agentx/loop/model/orphan_tool_results.py,sha256=TK8zDO63NYj0f0wDlREYN0qN8lpqnWRv9TMGDMQ3Z1Y,2493
 langchain_agentx/loop/model/retrier.py,sha256=S80QYWN-SfzyDx3gmhUcunFrMx4Khwi7K9wzynyTDQs,20877
@@ -132,8 +132,8 @@ langchain_agentx/loop/runtime/context_factory.py,sha256=w6VyDH5eQjMY_abZ4VDQpf_L
 langchain_agentx/loop/runtime/subagent_execution_paths.py,sha256=Bgyiom48uta1FZcnIE7fIxyrD-VFCRsw7s8IxIxmLb4,4033
 langchain_agentx/loop/stream/graph_driver.py,sha256=qMZHEw3wJ19Tfbz31-VPLy8Mt6e90xKougIjAoaEFCE,3935
 langchain_agentx/loop/stream/helpers.py,sha256=b2sqtwrAa5ic5B5AzNqItU8pmDHw13iGs3hBiShSIZk,1390
-langchain_agentx/loop/stream/loop_driver.py,sha256=wEYksr245wJtRMk8lnsVZPH-AAPdkGwQqjNJCcuZAdM,18405
-langchain_agentx/loop/stream/result.py,sha256=r_ht7xqTcYy-uv1ge_Ske-slyNs39JraBu-hSecdiqE,1093
+langchain_agentx/loop/stream/loop_driver.py,sha256=_AMnczeTVDgCuQvZDE06ueWdos3-OPKHioz9XTOeZSE,21696
+langchain_agentx/loop/stream/result.py,sha256=xQb9r1cxGCQpoAZ0gNo71CjhSE3eYOiYp5KnoOBzBF8,1131
 langchain_agentx/loop/stream/synthetic_events.py,sha256=Z3JT3iTuB9UQOoQXUprAYvaFV0vXEAuf5iqXYH9YSyI,2175
 langchain_agentx/loop/stream/transcript_gate.py,sha256=4AH3O0l8OrY_GQdqf-TOKOVS3selPLUC0jYLWQUTfkg,4690
 langchain_agentx/loop/subagent/__init__.py,sha256=MWa1IWt7eSdJhTnPCoIpvk5NMsPN6hknghqhX5kqwnY,2477
@@ -141,7 +141,7 @@ langchain_agentx/loop/subagent/active_run_registry.py,sha256=KurhAMDTBnRkdxNidaM
 langchain_agentx/loop/subagent/async_runner.py,sha256=y8Ke8nMi2XwdsrTKHCdOtIdr9hc-B1iGTAgMoVceapk,8692
 langchain_agentx/loop/subagent/boundary_snapshot.py,sha256=9cQuqN29nJDRnHnx9c8b09KRmODE2zv15Z06QyjVJps,10008
 langchain_agentx/loop/subagent/cache_safe_params.py,sha256=-qcgdazEYRy6s4ILQuttpxraE3gsxq17Ro7LYBnuv3E,4460
-langchain_agentx/loop/subagent/context.py,sha256=D4jl5u52jDMsPFb5IKaOgO742mR_Cxx7Z1bTciUrHzM,21572
+langchain_agentx/loop/subagent/context.py,sha256=3ho_iZwHu3Ydz-4ZXJWCUeEuLe53VXAk8goBfdv0uiY,22290
 langchain_agentx/loop/subagent/display_projector.py,sha256=AKsGWS1c9reH0kuD5u4oQ24KsBgyt7X10iZM3ere6Fs,3504
 langchain_agentx/loop/subagent/fork_boilerplate.py,sha256=2Uh3cwegL7V-DvtLIxjX7ik5uW5mXfY2NBzP-biREso,5005
 langchain_agentx/loop/subagent/fork_ports.py,sha256=hZATCvlYOxNVZtR3PoOVbI1GkA0KhHEyux6lUIjG5_4,1323
@@ -153,7 +153,7 @@ langchain_agentx/loop/subagent/progress.py,sha256=_4YCDnVDH8sBiwXhCQVB8OHaUQwsCO
 langchain_agentx/loop/subagent/progress_dispatcher.py,sha256=e1Kd16WRUOAJSeAjupukrlxHoyCR_JO84SHqntMCzdQ,3831
 langchain_agentx/loop/subagent/prompt.py,sha256=p7RgzibNfEJdfX8nBnZGEwQLa3_EgOn4E56T9MBRIEc,1722
 langchain_agentx/loop/subagent/reasoning_extractor.py,sha256=KrCQtBdKzsjAEfA7H5COuXzBhuGGonT2Su8IEKYlUpA,1334
-langchain_agentx/loop/subagent/runner.py,sha256=_gFw8ULiLVoji0G1R-_fSdg6c-sVhJmB_ci8skiJ2Kk,28810
+langchain_agentx/loop/subagent/runner.py,sha256=rjWtFKf2NgtLQax8nhlKQhlFVQuJeP8JvtuuhkJLbyM,29323
 langchain_agentx/loop/subagent/subagent_termination_classifier.py,sha256=ULArQeAibgy6ETSf4vRR0L6X1rsDM7-ZuLzRWQ_pmeY,3158
 langchain_agentx/loop/subagent/transcript.py,sha256=-S0VjZcvqlJQGkVGu8VDMTYwTwOePdjDHfjYi3uu7BY,7187
 langchain_agentx/loop/subagent/transcript_message_builder.py,sha256=gcDdbVOospJ9f0b-eM_0Y1uc4yTstaraWZdejokDyDQ,2081
@@ -201,7 +201,7 @@ langchain_agentx/memory/session/extractor.py,sha256=UUprKKtcMqn0pVhEWSnwCcc2tlB6
 langchain_agentx/memory/session/prompts.py,sha256=MA6UaNQsn9jrV78YuPbTTSKTmzvex_HY7kAaM9gVhUA,7690
 langchain_agentx/memory/session/session_memory.py,sha256=DdHkX-3rGOkyuxc3byq1hWNkHgucyo-n1jwUEWjxuP8,16642
 langchain_agentx/memory/session/tool_scope.py,sha256=DDhhzy_BEdZZe9SsisqZ9GOgMyt-aWUnCX-NH3QSPng,1684
-langchain_agentx/observability/__init__.py,sha256=IYPyGcf9WBN3qVUdxL7CNLf2sDN2FjlDzsWffnXmQ7I,2077
+langchain_agentx/observability/__init__.py,sha256=UTV3th78Bw_b-Mo14EkxT7zpO_UoviHcZv17P5nCnY8,2177
 langchain_agentx/observability/evaluation/__init__.py,sha256=yqkw8noWqD-7p6xnhlF-M4F2FwYukS2XDpEYoXFNYZ4,430
 langchain_agentx/observability/evaluation/retention_scheduler.py,sha256=8iKw9G8jImIaKfmGhO9Xtm3GhvSICuGwEZp7GGczDNo,2250
 langchain_agentx/observability/evaluation/service.py,sha256=E0MZIBY67aVDooOYuri3_vTM_uguXJxCxNqQ5rJxFOg,3660
@@ -214,14 +214,14 @@ langchain_agentx/observability/evaluation/checkers/degradation.py,sha256=80-oENY
 langchain_agentx/observability/evaluation/checkers/exit_quality.py,sha256=kcV2VYLeavinm5-hysCVhNfIjv2Gj_m4Xt65B403FoY,1274
 langchain_agentx/observability/evaluation/checkers/session_memory.py,sha256=jYDdIDUAhYktggsymkBADBunrSbxdC66veM-tZt3a3s,1579
 langchain_agentx/observability/evaluation/checkers/tool_behavior.py,sha256=o1nH8SeE9145H7ej4naahRcmgw_9st21dY1W3IQa2sg,2097
-langchain_agentx/observability/events/__init__.py,sha256=owI053qtlKN9N6dTr8e9DlM4pIuZkFjzE1RU6v1URZ4,951
+langchain_agentx/observability/events/__init__.py,sha256=9IfY3IcALgQjxdsircWrwTCFuSwr8MTKBDstC8CXPHY,1051
 langchain_agentx/observability/events/accumulated_text_scope.py,sha256=M4OvuQTgReF8SFrOmr-M5vyOJpzfvxj_DKD5bVpGb70,3169
 langchain_agentx/observability/events/agent_defaults.py,sha256=gmX0P__lux5xbCb8dtAlVCb3wZ7avaqFleoW4Q5anw4,1187
 langchain_agentx/observability/events/agent_event_projector.py,sha256=RN1bS9-A-XI_AZYguraVtfcQ4OvEvDxnAWhn0NKySIU,60600
 langchain_agentx/observability/events/api_retry_projection.py,sha256=XGb09sNOi6k1ZGW4YqMLBE8GDxNwNMprk62jV9TS9dQ,2433
 langchain_agentx/observability/events/factory.py,sha256=gqMATIK9tBQzaPWSPhCCSPuCq-WF562ZDTnFUaMm9Qc,1570
 langchain_agentx/observability/events/finish_event_payload_composer.py,sha256=W4jLFy6868GX122qljjeLJowsG7g26o4eKVbHEa7DJc,11481
-langchain_agentx/observability/events/finish_outcome.py,sha256=qyrwYquIw-yHeBKuQr9NBTRKENfZMKTROiOV_IdbZx4,7942
+langchain_agentx/observability/events/finish_outcome.py,sha256=I1-1RKQYMRXA5Kw0wDPXFpjdrGS421RM2fIL3gAY2kA,8926
 langchain_agentx/observability/events/langchain_agentx_event_adapter.py,sha256=plPZpoqYwDFR_XgdjH5NMQnl_oO6-rixBNl4sGJ0XRw,7519
 langchain_agentx/observability/events/model_end_text_backfill.py,sha256=7RBnxWLi1Oe-Bw9WTYqN-B6IdytFlY-Jso1STtQr6rE,5157
 langchain_agentx/observability/events/subagent_event_mapper.py,sha256=9M9cKzMz7_OXOod0JKtLb-FtUhAKiAVikKGRF6h6Ttk,6860
@@ -291,17 +291,17 @@ langchain_agentx/provider/semantics/families/openai_codec.py,sha256=RmzLq_LR1n3o
 langchain_agentx/provider/semantics/families/openai_finish_reason.py,sha256=t5ebGN2JMxUYPm8Jw8uebOgdAPc20GPgUiKJVja5r7U,1993
 langchain_agentx/provider/semantics/families/openai_interpreter.py,sha256=zT7EFfHJ5fmYZ_F59vDfyrYdEwcMJANxkoW1Pt3iocI,1915
 langchain_agentx/provider/semantics/families/openai_normalizer.py,sha256=oaf2Riz8EY6VQpc6SNKtsb-naMELw3gYV3IsnZoRBYU,2155
-langchain_agentx/session/__init__.py,sha256=7xrIOLhvbUynhKrkP5iEkJuRIyr2mAsph-o2WvUZFrg,1328
-langchain_agentx/session/agent_session.py,sha256=KW6wy1x5dwHvjCb7Khbq-XZ1_ResIMdTKkCYfnbF9Lg,24905
+langchain_agentx/session/__init__.py,sha256=uXxjBzhW1FtvSfDTTaGZPbyeSFRzRQb2MfxDumKViug,1234
+langchain_agentx/session/agent_session.py,sha256=bxjtuWDsWB3AK6Ij4jjnrCp6AtWn1NcS-2H5HieEWB0,23771
 langchain_agentx/session/cleanup_registry.py,sha256=aaPUn9psCwgZ27fB1qW7lzc1TeKaBvQAxhcHDiNs2Rs,4137
 langchain_agentx/session/conversation_factory.py,sha256=zsGBx9OwAOW21sqFsjK4d9mYLRRyxC5Bp1R9OCijxzI,5911
 langchain_agentx/session/conversation_recovery.py,sha256=OXzaxywRmqRwNA2Q1UNOpUvMlIjBzgdbsNPxPGHwoaA,5803
-langchain_agentx/session/conversation_session.py,sha256=_OjXq5FYA9HZCs0jrUszcxjyno8I-L7X8RMpPHsqiD8,16779
+langchain_agentx/session/conversation_session.py,sha256=xHbZfor4ZR9l0ANCgkZ2FUnzpY3cE6afHxZn6ZeKqQg,17125
 langchain_agentx/session/factory.py,sha256=qzZF8EkELFKPzQ-fRI2C72Usnqk_hASWB1GM8_mYjZ8,6172
 langchain_agentx/session/plan_mode.py,sha256=GjPLBG6eVrTB7M-CeMwLqkHCQDdD93cCgwIAvOF0wRM,4710
 langchain_agentx/session/plan_mode_attachments.py,sha256=byIJC2F3RTJ9BTWVhpbE1e1rRwahAH5anPKsMXFvUE8,13861
 langchain_agentx/session/protocol.py,sha256=uNkNiQ2MD9ReJgPaYe5bF0x6JzVqv2TL-hAG8ME1Obs,622
-langchain_agentx/session/recovery.py,sha256=rcebj9uVBcUWwUOL9SS4nD_t0Mce9WlEQAgjATt-UEE,4476
+langchain_agentx/session/recovery.py,sha256=vbBP7FAkp9Pcc15WzlxlApGH7ksQcwos2nVvOJD1Qn4,1802
 langchain_agentx/task_runtime/__init__.py,sha256=nwuVBYO0HDEvKMnjXbsyWlh1AC8fYBe79Y5nGgXWYbc,3972
 langchain_agentx/task_runtime/core/__init__.py,sha256=D5Y5TDp4oh7ml4O-sVdm8r-3-kEDJ7SJmPK7M6vy8_Y,1094
 langchain_agentx/task_runtime/core/ids.py,sha256=g19BWz6IK6YYyiuW3AU0HaaQGFjBzDue_ZCT8n_lip0,876
@@ -487,6 +487,7 @@ langchain_agentx/tool_runtime/resolvers/workflow.py,sha256=yahIZSShfF-eHUWAEfyxp
 langchain_agentx/tools/__init__.py,sha256=YUe8gX7o98qjgm0uURtjT9XqW_i0RCzhbjaKrkp1mj8,956
 langchain_agentx/tools/registry_names.py,sha256=kpQIPkP4eLX0sn7XpnVRdGS68AV6lu6c_4f930Rwr50,7231
 langchain_agentx/tools/ripgrep_plugin_exclusions.py,sha256=PoCJ26D--63gflqvwUZ_tI35xL1KMqzCbq5YjEtxJUM,5026
+langchain_agentx/tools/search_path_resolver.py,sha256=DF3wZrUZT6t4ZmnBOsjldG740Cszqr9mtx-QkTng4F0,4484
 langchain_agentx/tools/agent/__init__.py,sha256=doBZ0Bym-CvcwIU8i-bC3jie4MBquFyFZUuoiSYFOCc,209
 langchain_agentx/tools/agent/backend.py,sha256=YKK2ttAaAxgN1rpeVe7V5h0eqSYG7kfm0x9Cr1lZL-c,3168
 langchain_agentx/tools/agent/builtin_subagent_loader.py,sha256=pIc-FcUrrnxjPmJT8lGy_xdgcMa-s6Tb39qpCQPaytw,3665
@@ -570,13 +571,13 @@ langchain_agentx/tools/glob/pagination.py,sha256=qn3HjCpvcARgXXRqhsQQ5huibPIu9Kc
 langchain_agentx/tools/glob/prompt.py,sha256=oPEXucn9P2z01ghXEtDpGGKR3KpOp6wH8PDDYaoiN6U,686
 langchain_agentx/tools/glob/rg_list_backend.py,sha256=gTyFQE0eYHl-7LkSdah76S8bQnLCgi-6ka6jixeSI4s,5006
 langchain_agentx/tools/glob/rg_pattern.py,sha256=YOV-1gdxC52vzdAwgz27l7mzPJvVuHqpqeWhiEnWQJs,1377
-langchain_agentx/tools/glob/tool.py,sha256=fNOUrt-YUnXXOODiHVAtS0xz9qxidFPuJ9DGRh-R1cY,14445
+langchain_agentx/tools/glob/tool.py,sha256=m746Vl_aI9eFmrXYECkg16zMln9YPVxqjtijPlc5ALA,14868
 langchain_agentx/tools/grep/__init__.py,sha256=AA9qa42Ap9tw6lPQkNgKzYmr4hu44eP93qVdyP-eFNU,162
 langchain_agentx/tools/grep/backend.py,sha256=DSKetuS6Wcta5wrDBVFYSVDLsou0VDXXZyvdFvN1nls,13885
 langchain_agentx/tools/grep/models.py,sha256=6fTSux0COK06weQ7PWYqCGBQx60OaNtqC5q7xKtf5i0,3860
 langchain_agentx/tools/grep/prompt.py,sha256=Euo1NErphk5WHxaKXwJH-1v7joblfwEFWHIYNthKkzo,1336
 langchain_agentx/tools/grep/rg_subprocess_controller.py,sha256=ijMJnKPo7iEDFBz-_YipTiPusrL6OO2XbWxHUuwpMfA,4056
-langchain_agentx/tools/grep/tool.py,sha256=ngfLGdCrku_XfV_YfpoI3TyXiEqHcJ8wxcLz81mDMok,19795
+langchain_agentx/tools/grep/tool.py,sha256=S_nGFqFgGHx9UhnXJdNvkdoHCJxLRZBDoPDd-Pxms0g,20513
 langchain_agentx/tools/plan_mode/__init__.py,sha256=wO5FX24xEB0Dx9h6bysBt1ql3wn0rjPYsg70mbl4S_0,402
 langchain_agentx/tools/plan_mode/constants.py,sha256=vBjcx9JTSOhU9jfCJ4RKnCxVQPn0HzHapouKxRf2Zns,293
 langchain_agentx/tools/plan_mode/models.py,sha256=kRHPJetlB9X5nAq7-bWm1WcC68YsAj17UxY7fR6TpZ4,1204
@@ -692,7 +693,7 @@ langchain_agentx/workflow/catalog_registry.py,sha256=tYUny5FkHwQU-RRUxOdxaJhiRV_
 langchain_agentx/workflow/dag.py,sha256=Y1IR1IwnM79Xuev6HZnOvAE3Q23MRnA9lu4vg2Cie48,4469
 langchain_agentx/workflow/display_enricher.py,sha256=2HJ4xJI8H4hwBoWHAi6D_LwE-dcbZD_pafnS7DMDYZ4,6147
 langchain_agentx/workflow/display_resolver.py,sha256=hEaljqprjubG82zeqLOEeQ32AMAxaZwvwaLq3v-yt3c,10119
-langchain_agentx/workflow/execution.py,sha256=drOyyBooNcGDPfGAqHIMOTkwOGB4oNlvagVV2Co7mrg,18299
+langchain_agentx/workflow/execution.py,sha256=iCEkPgLkaoEM4cB6o7KAqIaBpFuY5HtGGISMNm0tr4A,18954
 langchain_agentx/workflow/loop_factory.py,sha256=hCShf_gDnesW2A9JspaUY3upp3NCIguII_wRiXnSIUM,3954
 langchain_agentx/workflow/memory_drain_registry.py,sha256=Xm_ytbB-BbRIu3-h-KhptsCsmmueOiNZePUuG1hk8zk,1681
 langchain_agentx/workflow/memory_session_policy.py,sha256=2FI0ZbAA6MnxJexnLYLadQpiqipPQwVnUrTWgl55A74,3333
@@ -751,8 +752,8 @@ langchain_agentx/workspace/root_grant_manager.py,sha256=W3gy8HTevbERbXqIgRcjzOXO
 langchain_agentx/workspace/tool_boundary.py,sha256=UDwX6swpSLsx9HNkYuuRRiV5o7ZZG_Bru2Yn0c5kNX8,5724
 langchain_agentx/workspace/validators.py,sha256=tQt-6TOcL8Fw7Ig5ebA9S7vGWh1rby920eFW6x8Tk9E,1439
 langchain_agentx/workspace/view.py,sha256=PGasqTaqhlD03SXXazHuw4RHfV681AIdlsYqL70pEjc,4774
-langchain_agentx_python-2.0.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-langchain_agentx_python-2.0.1.dist-info/METADATA,sha256=Md4WdCIDe34uD_fT4C8MrwhHW_yXKLNfIsgKvFU9Bv0,24844
-langchain_agentx_python-2.0.1.dist-info/WHEEL,sha256=51RkbunBAw4BWsgaQWTpPhg4Diwp3c9P5iaLk67Hdtg,92
-langchain_agentx_python-2.0.1.dist-info/top_level.txt,sha256=Ge284pniNt8xea0OLk2o9o32GqVpDhOYk20fwE-0xxA,17
-langchain_agentx_python-2.0.1.dist-info/RECORD,,
+langchain_agentx_python-2.1.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+langchain_agentx_python-2.1.0.dist-info/METADATA,sha256=TdLyMypNyg3psJwPdU3votemXhPzWi1HQkEH7qm03Ww,24844
+langchain_agentx_python-2.1.0.dist-info/WHEEL,sha256=51RkbunBAw4BWsgaQWTpPhg4Diwp3c9P5iaLk67Hdtg,92
+langchain_agentx_python-2.1.0.dist-info/top_level.txt,sha256=Ge284pniNt8xea0OLk2o9o32GqVpDhOYk20fwE-0xxA,17
+langchain_agentx_python-2.1.0.dist-info/RECORD,,