langchain-agentx-python 2.0.0__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.0"
+__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"]