Skip to content

JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.

Python
50.5 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.

"""Tests for JiuWenSwarmDeepAdapter interrupt when stream consumer already unwound."""

from __future__ import annotations

import asyncio
import contextvars
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, call, patch

import pytest

from openjiuwen.core.single_agent.interrupt.state import INTERRUPTION_KEY
from jiuwenswarm.common.schema.agent import AgentRequest
from jiuwenswarm.common.schema.message import ReqMethod
from jiuwenswarm.server.runtime.agent_adapter import interface_deep
from jiuwenswarm.server.runtime.agent_adapter.interface_deep import JiuWenSwarmDeepAdapter
from jiuwenswarm.server.runtime.skill_turbo.permission_bridge import (
    SKILL_TURBO_RESUME_CTX_KEY,
)
from jiuwenswarm.server.runtime.agent_adapter.deep.pure_helpers import _reset_runtime_cron_context


def _build_cancel_request(session_id: str = "tui_sess_1") -> AgentRequest:
    return AgentRequest(
        request_id="req-cancel",
        channel_id="tui",
        session_id=session_id,
        req_method=ReqMethod.CHAT_CANCEL,
        params={"intent": "cancel", "mode": "agent.plan"},
    )


def _build_supplement_request(session_id: str = "tui_sess_1") -> AgentRequest:
    return AgentRequest(
        request_id="req-supplement",
        channel_id="tui",
        session_id=session_id,
        req_method=ReqMethod.CHAT_CANCEL,
        params={
            "intent": "supplement",
            "new_input": "再执行一次",
            "mode": "agent.plan",
        },
    )


def _interruption_state(*tool_names: str) -> SimpleNamespace:
    tool_calls = [
        SimpleNamespace(id=f"call-{index}", name=tool_name)
        for index, tool_name in enumerate(tool_names)
    ]
    return SimpleNamespace(
        ai_message=SimpleNamespace(tool_calls=tool_calls),
        interrupted_tools={
            f"call-{index}": SimpleNamespace(
                tool_call=tool_call,
            )
            for index, tool_call in enumerate(tool_calls)
        },
    )


def _make_adapter(**state: object) -> JiuWenSwarmDeepAdapter:
    """Create a bare adapter with internal state set via setattr."""
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    adapter._is_session_scoped_adapter = True  # pylint: disable=protected-access
    adapter._parent_session_id = None  # pylint: disable=protected-access
    # process_interrupt reads these; __init__ normally sets them.
    adapter._task_planning_rail = None  # pylint: disable=protected-access
    adapter._workspace_dir = ""  # pylint: disable=protected-access
    for name, value in state.items():
        setattr(adapter, name, value)
    return adapter


def test_a2a_tool_route_survives_background_task_context(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(interface_deep, "get_runtime_tool_session_id", lambda: None)
    monkeypatch.setattr(interface_deep, "get_runtime_tool_channel_id", lambda: "default")
    adapter = _make_adapter(
        _current_request_route={
            "session_id": "web-session",
            "request_id": "request-1",
            "channel_id": "web",
        },
        _runtime_cron_tool_context=SimpleNamespace(
            session_id=None,
            channel_id="default",
        ),
    )

    assert adapter._get_a2a_outbound_tool_route() == ("web-session", "web")


@pytest.mark.asyncio
@pytest.mark.parametrize("tool_name, params", [
    ("a2a_find_agents", {"query": ""}),
    ("a2a_dispatch_task", {"agent_id": "weather", "task": "weather", "mode": "sync"}),
    ("a2a_get_dispatch", {"dispatch_id": "dispatch-1"}),
])
async def test_a2a_resource_survives_preexisting_runner_task(tool_name, params):
    """A runner created before request binding must use its adapter's identity."""
    ready = asyncio.Event()
    adapters = [_make_adapter(_current_request_route={}) for _ in range(2)]

    async def invoke(adapter):
        await ready.wait()
        tools = {}

        async def call(method, payload, **route):
            return {"params": payload, **route}

        rail = adapter._build_a2a_outbound_toolkit_rail()
        rail._backend_provider = lambda: SimpleNamespace(ready=True, call=call)
        rail.init(SimpleNamespace(
            ability_manager=SimpleNamespace(add_ability=lambda card, tool: tools.update({card.name: tool})),
            system_prompt_builder=None,
        ))
        return await tools[tool_name].invoke(params)

    runners = [
        asyncio.create_task(invoke(adapter), context=contextvars.Context())
        for adapter in adapters
    ]
    for index, adapter in enumerate(adapters):
        adapter._current_request_route = {
            "session_id": f"session-{index}", "channel_id": "web",
            "resource_id": f"bot-{index}",
        }
    ready.set()
    results = await asyncio.gather(*runners)
    for index, result in enumerate(results):
        assert result["session_id"] == f"session-{index}"
        assert result["params"]["resource_id"] == f"bot-{index}"


def test_a2a_bound_identity_does_not_borrow_snapshot_resource():
    adapter = _make_adapter(_current_request_route={
        "session_id": "old-session", "resource_id": "old-bot",
    })

    def check():
        interface_deep._CRON_TOOL_SESSION_ID.set("new-session")
        interface_deep._RUNTIME_TOOL_RESOURCE_ID.set("")
        assert adapter._get_a2a_outbound_tool_resource_id() == ""
        interface_deep._RUNTIME_TOOL_RESOURCE_ID.set("new-bot")
        assert adapter._get_a2a_outbound_tool_resource_id() == "new-bot"

    contextvars.Context().run(check)


def test_a2a_snapshot_missing_resource_does_not_borrow_cron_identity():
    adapter = _make_adapter(
        _current_request_route={"session_id": "new-session"},
        _runtime_cron_tool_context=SimpleNamespace(metadata={"routing": {"bot_id": "old-bot"}}),
    )
    assert contextvars.Context().run(adapter._get_a2a_outbound_tool_resource_id) == ""


@pytest.mark.parametrize("mode", ["team", "team.plan", "code.team"])
def test_deep_team_modes_leave_a2a_rail_to_swarm_provider(mode: str) -> None:
    adapter = _make_adapter(
        _model=None,
        _config_cache={},
        _filesystem_rail=None,
        _skill_protocol_prompt_rail=None,
        _task_execution_rail=None,
    )
    adapter._filesystem_rail_enabled_for_profile = lambda: False
    adapter._skill_include_tools_for_profile = lambda: True
    adapter._task_execution_rail_enabled = lambda: False
    adapter._instantiate_rails = lambda rail_infos, _config: rail_infos

    rail_infos = adapter._build_agent_rails({}, {}, mode=mode)

    assert "_a2a_outbound_toolkit_rail" not in {
        info.attr_name for info in rail_infos
    }


def _make_message_adapter(monkeypatch: pytest.MonkeyPatch) -> JiuWenSwarmDeepAdapter:
    adapter = JiuWenSwarmDeepAdapter()
    adapter._instance = SimpleNamespace(get_context_usage=lambda **_kwargs: {})
    adapter._is_session_scoped_adapter = True
    model = SimpleNamespace(model_config=SimpleNamespace(model_name="test-model"))
    monkeypatch.setattr(adapter, "_has_valid_model_config", lambda _model_name="": True)
    monkeypatch.setattr(adapter, "_handle_slash_command", AsyncMock(return_value=None))
    monkeypatch.setattr(adapter, "_resolve_model_for_request", lambda _request: model)
    monkeypatch.setattr(adapter, "_apply_model_to_react_agent", lambda _model: None)
    return adapter


@pytest.mark.asyncio
@pytest.mark.parametrize("params_only", [False, True])
async def test_team_stream_binds_a2a_resource_context(
    monkeypatch: pytest.MonkeyPatch, params_only: bool,
) -> None:
    from jiuwenswarm.server.runtime.agent_adapter import team_helpers
    from jiuwenswarm.server.runtime import tenant_agent_pool

    adapter = _make_message_adapter(monkeypatch)
    adapter._deepresearch_rewrite_tx_uncertain = False
    adapter._config_cache = {}
    adapter._config_base_cache = {}
    adapter._runtime_prompt_rail = None
    adapter._project_dir = None
    adapter._workspace_dir = None
    monkeypatch.setattr(adapter, "_inject_extension_config_into_inputs", lambda _inputs: None)
    monkeypatch.setattr(adapter, "_deepresearch_artifact_output_dir", lambda _path: None)
    monkeypatch.setattr(
        interface_deep,
        "_prepare_multimodal_image_inputs",
        lambda _request, inputs: inputs,
    )
    monkeypatch.setattr(adapter, "_native_image_input_enabled", lambda *_args: False)
    monkeypatch.setattr(adapter, "_resolve_runtime_language", lambda: "zh")
    monkeypatch.setattr(adapter, "_resolve_prompt_channel", lambda _session: "web")
    monkeypatch.setattr(adapter, "_write_runtime_state", lambda **_kwargs: None)
    monkeypatch.setattr(interface_deep, "set_perf_summary_context", lambda *_args, **_kwargs: None)
    monkeypatch.setattr(interface_deep, "finalize_perf_summary_request", lambda *_args, **_kwargs: None)
    monkeypatch.setattr(interface_deep, "clear_perf_summary_context", lambda *_args, **_kwargs: None)
    monkeypatch.setattr(
        interface_deep,
        "resolve_tenant_sessions_dir",
        lambda _key, *, service_id=None, agent_id=None: Path("."),
    )
    monkeypatch.setattr(interface_deep, "evolution_slash_command_name", lambda _query: None)
    monkeypatch.setattr(
        tenant_agent_pool.TenantAgentPool,
        "extract_ids",
        staticmethod(lambda _request: ("agent", "service", "workspace")),
    )

    async def _team_stream(*_args, **_kwargs):
        assert interface_deep.get_runtime_tool_resource_id() == "resource-1"
        assert contextvars.Context().run(adapter._get_a2a_outbound_tool_resource_id) == "resource-1"
        yield SimpleNamespace(payload={"event_type": "chat.delta"})

    monkeypatch.setattr(team_helpers, "process_team_message_stream", _team_stream)
    request = AgentRequest(
        request_id="request-team",
        channel_id="web",
        session_id="session-team",
        is_stream=True,
        params={"query": "delegate", "mode": "team", "bot_id": "resource-1" if params_only else "untrusted"},
        metadata={} if params_only else {"routing": {"bot_id": "resource-1"}},
    )

    chunks = [
        chunk
        async for chunk in adapter.process_message_stream_impl(
            request, {"query": "delegate"}
        )
    ]

    assert len(chunks) == 1
    assert interface_deep.get_runtime_tool_resource_id() == ""


@pytest.mark.asyncio
@pytest.mark.parametrize("params_only", [False, True])
async def test_nonstream_entry_captures_a2a_resource_snapshot(monkeypatch, params_only):
    adapter = _make_message_adapter(monkeypatch)
    monkeypatch.setattr(adapter, "_deepresearch_artifact_output_dir", lambda _path: "")
    monkeypatch.setattr(adapter, "_handle_slash_command", AsyncMock(return_value={"result_type": "goal_control"}))
    request = AgentRequest(
        request_id="snapshot-request", channel_id="web", session_id="snapshot-session",
        params={"query": "test", "mode": "agent", "bot_id": "resource-1" if params_only else "untrusted"},
        metadata={} if params_only else {"routing": {"bot_id": "resource-1"}},
    )
    await adapter.process_message_impl(request, {"query": "test"})
    assert contextvars.Context().run(adapter._get_a2a_outbound_tool_resource_id) == "resource-1"


def _route_test_request(*, stream: bool = False) -> AgentRequest:
    return AgentRequest(
        request_id="req-pre-try",
        channel_id="tui",
        session_id="sess-pre-try",
        params={"query": "research", "mode": "agent"},
        is_stream=stream,
    )


@pytest.mark.asyncio
async def test_interaction_supplement_clears_pending_ask_user_state() -> None:
    """Supplement text must start a new turn, not answer the interrupted question."""
    # 用 spec 限定 MagicMock 不自动生成 card 属性:真实 Session 无公开 card,
    # 无限 mock 会造出 Mock card 让 isolated 分支被假触发(测试与生产分叉)。
    loop_session = MagicMock(spec=["get_session_id", "get_state", "update_state"])
    loop_session.get_session_id.return_value = "tui_sess_1"
    interruption_state = _interruption_state("ask_user")
    loop_session.get_state.return_value = interruption_state
    context = MagicMock()
    context.get_messages.return_value = [
        SimpleNamespace(tool_calls=[]),
        interruption_state.ai_message,
    ]
    context_engine = MagicMock()
    context_engine.get_context.return_value = context
    context_engine.save_contexts = AsyncMock()

    # 真实生产路径:instance.card 可得 → clear() 走 isolated 通道,
    # loop_session 只清 INTERRUPTION_KEY、不写 resume_ctx(键空间语义)。
    # mock create_agent_session 截获 isolated session 的创建。
    instance = MagicMock()
    instance._interaction_started = True
    instance._loop_session = loop_session
    instance.card = SimpleNamespace(id="card-supplement-1")
    instance.react_agent = SimpleNamespace(context_engine=context_engine)
    instance.cancel_round = AsyncMock(return_value=False)

    rail = MagicMock()
    rail.get_cancelled_tool_results.return_value = []
    adapter = _make_adapter(
        _active_session_ids={},
        _stream_event_rail=rail,
        _instance=instance,
    )

    isolated_session = MagicMock()
    isolated_session.pre_run = AsyncMock()
    isolated_session.post_run = AsyncMock()
    with patch(
        "openjiuwen.core.session.agent.create_agent_session",
        return_value=isolated_session,
    ):
        response = await adapter.process_interrupt(_build_supplement_request())

    # resume_ctx 清理走 isolated 通道(隔离键空间落盘)+ loop_session 内存
    # 快照同步清(防 post_run/save_contexts 全量写回复活,R1)。prime P0-P4
    # 加固后 supplement 路径额外写入 phase/todo_snapshot 等新状态——只断言
    # 两个关键调用存在,不锁全序列。
    all_calls = loop_session.update_state.call_args_list
    assert call({"__skill_turbo_resume_ctx__": None}) in all_calls
    assert call({INTERRUPTION_KEY: None}) in all_calls
    # P0-P4 后 isolated session 可能承载多个状态写入——只验证含 resume_ctx 清除
    assert call({"__skill_turbo_resume_ctx__": None}) in (
        isolated_session.update_state.call_args_list
    )
    context.pop_messages.assert_called_once_with(1, with_history=True)
    context_engine.save_contexts.assert_awaited_once_with(loop_session)
    assert response.payload["intent"] == "supplement"
    assert response.payload["new_input"] == "再执行一次"


@pytest.mark.asyncio
async def test_interaction_cancel_clears_pending_ask_user_state() -> None:
    """cancel 同样必须丢弃暂停的纯 ask_user 轮,否则下条消息被当 resume 重生成(Bug2)。

    与 supplement 同构(_process_interaction_interrupt 的 cancel 分支),覆盖
    should_drop_ask_user 的 cancel 触发:选 cancel 后残留 ask_user INTERRUPTION_KEY
    必被清,避免现有 4 个 cancel 测试因 loop_session 未匹配而在守卫处短路、漏掉
    本 PR 唯一行为变更。
    """
    loop_session = MagicMock(spec=["get_session_id", "get_state", "update_state"])
    loop_session.get_session_id.return_value = "tui_sess_1"
    interruption_state = _interruption_state("ask_user")
    loop_session.get_state.return_value = interruption_state
    context = MagicMock()
    context.get_messages.return_value = [
        SimpleNamespace(tool_calls=[]),
        interruption_state.ai_message,
    ]
    context_engine = MagicMock()
    context_engine.get_context.return_value = context
    context_engine.save_contexts = AsyncMock()

    instance = MagicMock()
    instance._interaction_started = True
    instance._loop_session = loop_session
    instance.card = SimpleNamespace(id="card-cancel-1")
    instance.react_agent = SimpleNamespace(context_engine=context_engine)
    instance.goal_manager = None  # 跳过 goal pause 分支,聚焦 drop
    instance.cancel_round = AsyncMock(return_value=False)

    rail = MagicMock()
    rail.get_cancelled_tool_results.return_value = []
    adapter = _make_adapter(
        _active_session_ids={},
        _stream_event_rail=rail,
        _instance=instance,
    )

    isolated_session = MagicMock()
    isolated_session.pre_run = AsyncMock()
    isolated_session.post_run = AsyncMock()
    with patch(
        "openjiuwen.core.session.agent.create_agent_session",
        return_value=isolated_session,
    ):
        response = await adapter.process_interrupt(_build_cancel_request("tui_sess_1"))

    # drop 的三处直接效果(与 supplement 同构):
    all_calls = loop_session.update_state.call_args_list
    assert call({INTERRUPTION_KEY: None}) in all_calls
    context.pop_messages.assert_called_once_with(1, with_history=True)
    context_engine.save_contexts.assert_awaited_once_with(loop_session)
    assert response.payload["intent"] == "cancel"
    assert response.payload["success"] is True


@pytest.mark.parametrize(
    ("session_id", "tool_names"),
    [
        ("other_session", ("ask_user",)),
        ("tui_sess_1", ("confirm",)),
        ("tui_sess_1", ("ask_user", "confirm")),
    ],
)
@pytest.mark.asyncio
async def test_supplement_keeps_unrelated_interrupt_state(
    session_id: str,
    tool_names: tuple[str, ...],
) -> None:
    """Do not clear another session or non-ask_user interaction state."""
    loop_session = MagicMock()
    loop_session.get_session_id.return_value = "tui_sess_1"
    loop_session.get_state.return_value = _interruption_state(*tool_names)
    instance = MagicMock()
    instance._loop_session = loop_session
    adapter = _make_adapter(_instance=instance)

    cleared = await getattr(
        adapter,
        "_drop_pending_pure_ask_user_round",
    )(session_id)

    assert cleared is False
    loop_session.update_state.assert_not_called()


@pytest.mark.asyncio
async def test_supplement_keeps_ask_user_state_when_context_cannot_be_rolled_back() -> None:
    """Never clear state unless the matching ask_user call is the context tail."""
    interruption_state = _interruption_state("ask_user")
    loop_session = MagicMock()
    loop_session.get_session_id.return_value = "tui_sess_1"
    loop_session.get_state.return_value = interruption_state
    context = MagicMock()
    context.get_messages.return_value = [SimpleNamespace(tool_calls=[])]
    context_engine = MagicMock()
    context_engine.get_context.return_value = context
    context_engine.save_contexts = AsyncMock()
    instance = MagicMock()
    instance._loop_session = loop_session
    instance.react_agent = SimpleNamespace(context_engine=context_engine)
    adapter = _make_adapter(_instance=instance)

    cleared = await getattr(
        adapter,
        "_drop_pending_pure_ask_user_round",
    )("tui_sess_1")

    assert cleared is False
    context.pop_messages.assert_not_called()
    loop_session.update_state.assert_not_called()
    context_engine.save_contexts.assert_not_awaited()


@pytest.mark.asyncio
async def test_cancel_runs_teardown_when_session_not_in_active_counter(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """When session is not active, per-session teardown runs but global abort is skipped.

    Global abort (instance.abort) is unsafe when the session is inactive — a
    just-starting session on the same adapter could be killed as collateral.
    Per-session teardown (rail abort, shell kill) is sufficient for the target.
    """
    rail = MagicMock()
    rail.get_cancelled_tool_results.return_value = []
    instance = MagicMock()
    instance.abort = AsyncMock()
    # Force the non-interaction interrupt path under test (rail teardown /
    # skip global abort).  A bare MagicMock makes ``_interaction_started``
    # truthy and would divert into cancel_round().
    instance._interaction_started = False
    adapter = _make_adapter(
        _active_session_ids={},
        _session_agent_tasks={},
        _stream_event_rail=rail,
        _instance=instance,
    )

    kill_mock = MagicMock(return_value=2)
    monkeypatch.setattr(
        "openjiuwen.core.sys_operation.shell_process_registry.kill_shell_processes_for_session_tree",
        kill_mock,
    )
    monkeypatch.setattr(adapter, "_cancel_pending_todos", AsyncMock(return_value=[]))
    monkeypatch.setattr(adapter, "_cancel_scheduler_running_tasks", MagicMock())

    response = await adapter.process_interrupt(_build_cancel_request())

    # Per-session teardown must still run
    rail.abort.assert_called_once_with("tui_sess_1")
    rail.collect_cancelled_tool_updates.assert_called_once_with("tui_sess_1")
    rail.reset_for_new_task.assert_called_once_with("tui_sess_1")
    kill_mock.assert_called_once_with("tui_sess_1")
    # Global abort must NOT fire — session is inactive, could kill a just-starting session
    instance.abort.assert_not_awaited()
    assert response.payload["event_type"] == "chat.interrupt_result"
    assert response.payload["intent"] == "cancel"
    assert response.payload["success"] is True


@pytest.mark.asyncio
async def test_interaction_cancel_pauses_active_goal_before_cancel_round() -> None:
    """User stop should pause ACTIVE Goal then cancel_round; payload carries goal."""
    from openjiuwen.harness.goal.schema import GoalRecord, GoalStatus

    paused_record = GoalRecord.create(session_id="sess-goal", objective="keep going")
    paused_record.status = GoalStatus.PAUSED
    active_record = GoalRecord.create(session_id="sess-goal", objective="keep going")
    active_record.status = GoalStatus.ACTIVE

    goal_manager = MagicMock()
    goal_manager.get = AsyncMock(return_value=active_record)
    goal_manager.pause = AsyncMock(return_value=paused_record)

    instance = MagicMock()
    instance._interaction_started = True
    instance.goal_manager = goal_manager
    instance.cancel_round = AsyncMock(return_value=True)

    rail = MagicMock()
    rail.get_cancelled_tool_results.return_value = []
    adapter = _make_adapter(
        _active_session_ids={"sess-goal": 1},
        _stream_event_rail=rail,
        _instance=instance,
    )
    adapter._cancel_pending_todos = AsyncMock(return_value=None)

    response = await adapter.process_interrupt(
        AgentRequest(
            request_id="req-stop",
            channel_id="web",
            session_id="sess-goal",
            req_method=ReqMethod.CHAT_CANCEL,
            params={"intent": "cancel", "mode": "agent"},
        )
    )

    goal_manager.pause.assert_awaited_once()
    instance.cancel_round.assert_awaited_once_with(reason="user_cancel")
    rail.abort.assert_called_once_with("sess-goal")
    rail.collect_cancelled_tool_updates.assert_called_once_with("sess-goal")
    rail.reset_for_new_task.assert_called_once_with("sess-goal")
    assert response.payload["event_type"] == "chat.interrupt_result"
    assert response.payload["goal"]["status"] == "paused"
    assert response.payload["goal"]["objective"] == "keep going"


@pytest.mark.asyncio
async def test_interaction_cancel_skips_pause_when_no_goal() -> None:
    goal_manager = MagicMock()
    goal_manager.get = AsyncMock(return_value=None)
    goal_manager.pause = AsyncMock()

    instance = MagicMock()
    instance._interaction_started = True
    instance.goal_manager = goal_manager
    instance.cancel_round = AsyncMock(return_value=True)

    rail = MagicMock()
    rail.get_cancelled_tool_results.return_value = []
    adapter = _make_adapter(
        _active_session_ids={"sess-x": 1},
        _stream_event_rail=rail,
        _instance=instance,
    )
    adapter._cancel_pending_todos = AsyncMock(return_value=None)

    response = await adapter.process_interrupt(_build_cancel_request("sess-x"))

    goal_manager.pause.assert_not_awaited()
    instance.cancel_round.assert_awaited_once()
    rail.abort.assert_called_once_with("sess-x")
    assert "goal" not in response.payload


@pytest.mark.asyncio
async def test_interaction_cancel_appends_cancelled_tools_to_history(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """Interaction cancel must close in_progress tools in history (no spinner on refresh)."""
    cancelled_tools = [
        {
            "tool_name": "task_tool",
            "tool_call_id": "call_1",
            "result": "cancelled by user",
            "status": "error",
        }
    ]
    rail = MagicMock()
    rail.get_cancelled_tool_results.return_value = cancelled_tools

    instance = MagicMock()
    instance._interaction_started = True
    instance.goal_manager = None
    instance.cancel_round = AsyncMock(return_value=True)

    adapter = _make_adapter(
        _active_session_ids={"sess-tools": 1},
        _stream_event_rail=rail,
        _instance=instance,
        _session_agent_tasks={},
    )
    adapter._cancel_pending_todos = AsyncMock(return_value=None)
    adapter._cancel_session_agent_tasks = AsyncMock(return_value=0)

    append_mock = MagicMock()
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.deep.pure_helpers.append_history_record",
        append_mock,
    )

    response = await adapter.process_interrupt(_build_cancel_request("sess-tools"))

    # Must not cancel stream producer tasks on interaction path
    adapter._cancel_session_agent_tasks.assert_not_awaited()
    instance.cancel_round.assert_awaited_once_with(reason="user_cancel")
    rail.abort.assert_called_once_with("sess-tools")
    assert response.payload["cancelled_tools"] == cancelled_tools
    append_mock.assert_called_once()
    assert append_mock.call_args.kwargs["event_type"] == "chat.tool_result"
    assert append_mock.call_args.kwargs["extra"]["tool_result"]["tool_call_id"] == "call_1"


@pytest.mark.asyncio
async def test_unmark_skips_rail_cleanup_when_stream_consumer_cancelled() -> None:
    rail = MagicMock()
    adapter = _make_adapter(
        _active_session_ids={"sess_a": 1},
        _stream_event_rail=rail,
    )

    getattr(adapter, "_unmark_session_active")("sess_a", cleanup_rail=False)

    rail.cleanup_session.assert_not_called()
    assert "sess_a" not in getattr(adapter, "_active_session_ids")


@pytest.mark.asyncio
async def test_unmark_cleans_rail_on_normal_completion() -> None:
    rail = MagicMock()
    adapter = _make_adapter(
        _active_session_ids={"sess_a": 1},
        _stream_event_rail=rail,
    )

    getattr(adapter, "_unmark_session_active")("sess_a")

    rail.cleanup_session.assert_called_once_with("sess_a")
    assert "sess_a" not in getattr(adapter, "_active_session_ids")


@pytest.mark.asyncio
async def test_abort_skipped_when_other_sessions_active_even_if_target_executing(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """instance.abort() is global on the shared DeepAgent — when other sessions are
    active, it must NEVER be called, even if the target session is executing.
    Per-session teardown (rail abort, task cancel, shell kill) is sufficient.
    """
    rail = MagicMock()
    rail.get_cancelled_tool_results.return_value = []
    instance = MagicMock()
    setattr(instance, "abort", AsyncMock())
    setattr(instance, "_interaction_started", False)
    setattr(instance, "_invoke_active", True)
    stream_task = MagicMock()
    stream_task.done.return_value = False
    setattr(instance, "_stream_process_task", stream_task)
    loop_session = MagicMock()
    loop_session.get_session_id.return_value = "tui_target"
    setattr(instance, "_loop_session", loop_session)
    adapter = _make_adapter(
        _active_session_ids={"tui_other": 1},
        _session_agent_tasks={},
        _stream_event_rail=rail,
        _instance=instance,
    )

    monkeypatch.setattr(
        "openjiuwen.core.sys_operation.shell_process_registry.kill_shell_processes_for_session_tree",
        MagicMock(return_value=0),
    )
    monkeypatch.setattr(adapter, "_cancel_pending_todos", AsyncMock(return_value=[]))
    monkeypatch.setattr(adapter, "_cancel_scheduler_running_tasks", MagicMock())

    await adapter.process_interrupt(_build_cancel_request(session_id="tui_target"))

    # instance.abort must NOT be called — it would kill tui_other's work too
    instance.abort.assert_not_awaited()
    # But per-session teardown must still run
    rail.abort.assert_called_once_with("tui_target")


def test_reset_runtime_cron_context_resets_shell_session(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep
    from openjiuwen.core.sys_operation.shell_process_registry import (
        reset_shell_session_id,
        set_shell_session_id,
    )

    reset_shell_mock = MagicMock()
    monkeypatch.setattr(
        "openjiuwen.core.sys_operation.shell_process_registry.reset_shell_session_id",
        reset_shell_mock,
    )
    for var_name in (
        "_CRON_TOOL_BOUND",
        "_CRON_TOOL_MODE",
        "_CRON_TOOL_METADATA",
        "_CRON_TOOL_SESSION_ID",
        "_CRON_TOOL_CHANNEL_ID",
    ):
        monkeypatch.setattr(
            f"jiuwenswarm.server.runtime.agent_adapter.interface_deep.{var_name}",
            MagicMock(),
        )

    shell_token = set_shell_session_id("sess_reset")
    adapter = _make_adapter()
    try:
        _reset_runtime_cron_context(
            interface_deep._RuntimeCronContextTokens(
                channel=MagicMock(),
                session=MagicMock(),
                metadata=MagicMock(),
                mode=MagicMock(),
                bound=MagicMock(),
                shell=shell_token,
                deepresearch=None,
                send_file=None,
            )
        )
        reset_shell_mock.assert_called_once_with(shell_token)
    finally:
        reset_shell_session_id(shell_token)


def test_bind_runtime_cron_context_fills_locked_session_project_metadata(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep

    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        lambda session_id, cache_bust=False: {
            "session_id": session_id,
            "project_id": "proj_locked",
            "project_dir": "D:\\locked-project",
            "work_mode": "code",
        },
    )

    adapter = _make_adapter()
    tokens = adapter._bind_runtime_cron_context(
        channel_id="web",
        session_id="sess_locked",
        metadata={"request_id": "req-old"},
        request_id="req-new",
        mode="agent",
        project_dir=None,
    )
    try:
        metadata = interface_deep._CRON_TOOL_METADATA.get()
        assert metadata["request_id"] == "req-new"
        assert metadata["project_id"] == "proj_locked"
        assert metadata["project_dir"] == "D:\\locked-project"
        assert metadata["work_mode"] == "code"
    finally:
        _reset_runtime_cron_context(tokens)


def test_runtime_cron_tool_context_falls_back_to_last_bound_session(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep

    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        lambda session_id, cache_bust=False: {
            "session_id": session_id,
            "project_id": "proj_runtime",
            "project_dir": "D:\\runtime-project",
            "work_mode": "work",
        },
    )

    context = interface_deep._RuntimeCronToolContext(tool_scope="runtime_test")
    adapter = _make_adapter()
    tokens = adapter._bind_runtime_cron_context(
        channel_id="web",
        session_id="sess_runtime",
        metadata={},
        request_id="req-runtime",
        mode="agent",
        project_dir=None,
    )
    try:
        context.remember_current_binding()
    finally:
        _reset_runtime_cron_context(tokens)

    assert context.session_id == "sess_runtime"
    assert context.mode == "agent"
    metadata = context.metadata
    assert metadata["request_id"] == "req-runtime"
    assert metadata["project_id"] == "proj_runtime"
    assert metadata["project_dir"] == "D:\\runtime-project"
    assert metadata["work_mode"] == "work"


def test_stream_consumer_cancellation_resets_only_deepresearch_route() -> None:
    from jiuwenswarm.agents.harness.common.tools.deepresearch.tools import _get_route
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep

    adapter = _make_adapter(
        _env_service_id="service-cancel",
        _env_agent_id="agent-cancel",
    )
    tokens = adapter._bind_runtime_cron_context(
        channel_id="tui",
        session_id="sess-cancel",
        metadata={},
        request_id="req-cancel",
        mode="agent",
    )

    adapter._reset_stream_runtime_context(
        tokens,
        stream_consumer_cancelled=True,
    )
    try:
        assert _get_route()["session_id"] == ""
        assert interface_deep._CRON_TOOL_SESSION_ID.get() == "sess-cancel"
    finally:
        _reset_runtime_cron_context(tokens)


def test_stream_normal_completion_resets_route_and_legacy_context_once(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.agents.harness.common.tools.deepresearch.tools import _get_route

    adapter = _make_adapter(
        _env_service_id="service-normal",
        _env_agent_id="agent-normal",
    )
    tokens = adapter._bind_runtime_cron_context(
        channel_id="web",
        session_id="sess-normal",
        metadata={},
        request_id="req-normal",
        mode="agent",
    )
    reset_runtime = MagicMock(wraps=_reset_runtime_cron_context)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep._reset_runtime_cron_context", reset_runtime)

    adapter._reset_stream_runtime_context(
        tokens,
        stream_consumer_cancelled=False,
    )

    reset_runtime.assert_called_once_with(tokens)
    assert _get_route()["session_id"] == ""


def test_runtime_route_binds_current_session_workspace(tmp_path: Path) -> None:
    from jiuwenswarm.agents.harness.common.tools.deepresearch import tools as dt

    session_workspace = tmp_path / "current-session-workspace"
    adapter = _make_adapter(
        _env_service_id="service-session-output",
        _env_agent_id="agent-session-output",
        _workspace_dir=str(tmp_path / "agent-workspace"),
    )
    tokens = adapter._bind_runtime_cron_context(
        channel_id="officeclaw",
        session_id="sess-session-output",
        metadata={},
        request_id="req-session-output",
        mode="agent",
        project_dir=str(session_workspace),
    )
    try:
        # Generation and rewrite tools both consume this routed output root.
        assert dt._get_effective_request_output_dir() == session_workspace.resolve()
    finally:
        _reset_runtime_cron_context(tokens)


def test_runtime_route_binds_and_resets_enterprise_a2a_identity() -> None:
    enterprise = SimpleNamespace(
        resource_id="resource-1",
        template_ref={"a2a_access_policy": ["policy-1"]},
    )
    adapter = _make_adapter(
        _enterprise_config=enterprise,
        _env_service_id="service-1",
        _env_agent_id="agent-1",
    )
    tokens = adapter._bind_runtime_cron_context(
        channel_id="web",
        session_id="session-1",
        metadata={"routing": {"bot_id": "resource-1"}},
        request_id="request-1",
        mode="agent",
    )
    try:
        assert interface_deep.get_runtime_tool_resource_id() == "resource-1"
        assert interface_deep.get_runtime_tool_a2a_policy_id() == "policy-1"
    finally:
        _reset_runtime_cron_context(tokens)

    assert interface_deep.get_runtime_tool_resource_id() == ""
    assert interface_deep.get_runtime_tool_a2a_policy_id() == ""


def test_deepresearch_tool_context_keeps_session_workspace_snapshot(
    tmp_path: Path,
) -> None:
    session_workspace = tmp_path / "current-session-workspace"
    adapter = _make_adapter(
        _current_request_route={
            "session_id": "sess-background-output",
            "request_id": "req-background-output",
            "channel_id": "officeclaw",
            "output_dir": str(session_workspace),
        },
        _runtime_cron_tool_context=SimpleNamespace(
            session_id=None,
            channel_id="default",
            metadata={},
        ),
        _env_service_id="service-background-output",
        _env_agent_id="agent-background-output",
        _workspace_dir=str(tmp_path / "agent-workspace"),
    )

    context = adapter._get_deepresearch_tool_context()

    assert Path(context["output_dir"]) == session_workspace.resolve()


def test_artifact_output_uses_session_project_when_request_omits_workspace(
    tmp_path: Path,
) -> None:
    session_workspace = tmp_path / "session-project"
    adapter = _make_adapter(
        _project_dir=str(session_workspace),
        _workspace_dir=str(tmp_path / "agent-workspace"),
    )

    assert Path(adapter._deepresearch_artifact_output_dir()) == (
        session_workspace.resolve()
    )


def test_runtime_route_binds_adapter_artifact_output_dir(tmp_path: Path) -> None:
    from jiuwenswarm.agents.harness.common.tools.deepresearch import tools as dt

    agent_workspace = tmp_path / "agent-workspace"
    adapter = _make_adapter(
        _env_service_id="service-output",
        _env_agent_id="agent-output",
        _workspace_dir=str(agent_workspace),
    )
    tokens = adapter._bind_runtime_cron_context(
        channel_id="officeclaw",
        session_id="sess-output",
        metadata={},
        request_id="req-output",
        mode="agent",
    )
    try:
        assert dt._get_effective_request_output_dir() == (
            agent_workspace / "projects"
        ).resolve()
    finally:
        _reset_runtime_cron_context(tokens)


def test_runtime_route_binds_request_workspace_as_artifact_output_dir(
    tmp_path: Path,
) -> None:
    from jiuwenswarm.agents.harness.common.tools.deepresearch import tools as dt

    agent_workspace = tmp_path / "agent-workspace"
    request_workspace = tmp_path / "session-workspace"
    adapter = _make_adapter(
        _env_service_id="service-output",
        _env_agent_id="agent-output",
        _workspace_dir=str(agent_workspace),
    )
    tokens = adapter._bind_runtime_cron_context(
        channel_id="officeclaw",
        session_id="sess-output",
        metadata={},
        request_id="req-output",
        mode="agent",
        project_dir=str(request_workspace),
    )
    try:
        assert dt._get_effective_request_output_dir() == request_workspace.resolve()
    finally:
        _reset_runtime_cron_context(tokens)


def test_progressive_deepresearch_context_keeps_request_workspace(
    tmp_path: Path,
) -> None:
    request_workspace = tmp_path / "session-workspace"
    adapter = _make_adapter(
        _env_service_id="service-output",
        _env_agent_id="agent-output",
    )
    adapter._current_request_route = {
        "session_id": "sess-output",
        "request_id": "req-output",
        "channel_id": "officeclaw",
        "output_dir": str(request_workspace),
    }

    assert adapter._get_deepresearch_tool_context()["output_dir"] == str(
        request_workspace.resolve()
    )


def test_runtime_route_keeps_artifact_leaf_lexical(tmp_path: Path) -> None:
    agent_workspace = tmp_path / "agent-workspace"
    outside = tmp_path / "outside"
    agent_workspace.mkdir()
    outside.mkdir()
    try:
        (agent_workspace / "projects").symlink_to(
            outside, target_is_directory=True
        )
    except OSError:
        # Creating symlinks needs privilege on Windows; the rejection
        # semantics are covered where symlinks are creatable.
        pytest.skip("symlink creation requires privilege on this platform")
    adapter = _make_adapter(
        _env_service_id="service-output",
        _env_agent_id="agent-output",
        _workspace_dir=str(agent_workspace),
    )

    assert adapter._deepresearch_artifact_output_dir() == str(
        agent_workspace.resolve() / "projects"
    )


@pytest.mark.parametrize("failure_type", [RuntimeError, asyncio.CancelledError])
def test_route_bind_failure_rolls_back_legacy_context(
    monkeypatch: pytest.MonkeyPatch,
    failure_type: type[BaseException],
) -> None:
    from openjiuwen.core.sys_operation.shell_process_registry import get_shell_session_id
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep

    adapter = _make_adapter(
        _env_service_id="service-bind-failure",
        _env_agent_id="agent-bind-failure",
    )
    previous_shell_session_id = get_shell_session_id()

    def fail_route_bind(**_kwargs):
        raise failure_type("route bind failed")

    monkeypatch.setattr(interface_deep, "push_deepresearch_route", fail_route_bind)

    with pytest.raises(failure_type, match="route bind failed"):
        adapter._bind_runtime_cron_context(
            channel_id="tui",
            session_id="sess-bind-failure",
            metadata={},
            request_id="req-bind-failure",
            mode="agent",
        )

    assert interface_deep._CRON_TOOL_SESSION_ID.get() is None
    assert interface_deep._CRON_TOOL_BOUND.get() is False
    assert get_shell_session_id() == previous_shell_session_id


def test_full_reset_continues_after_failure_and_is_idempotent(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep
    from jiuwenswarm.server.runtime.agent_adapter.deep import pure_helpers

    reset_shell = MagicMock()
    monkeypatch.setattr(
        "openjiuwen.core.sys_operation.shell_process_registry.reset_shell_session_id",
        reset_shell,
    )
    route_reset = MagicMock(side_effect=RuntimeError("route reset failed"))
    monkeypatch.setattr(pure_helpers, "reset_deepresearch_route", route_reset)
    context_vars = {}
    for name in (
        "_CRON_TOOL_BOUND",
        "_CRON_TOOL_MODE",
        "_CRON_TOOL_METADATA",
        "_CRON_TOOL_SESSION_ID",
        "_CRON_TOOL_CHANNEL_ID",
    ):
        context_vars[name] = MagicMock()
        monkeypatch.setattr(interface_deep, name, context_vars[name])
    tokens = interface_deep._RuntimeCronContextTokens(
        channel=MagicMock(),
        session=MagicMock(),
        metadata=MagicMock(),
        mode=MagicMock(),
        bound=MagicMock(),
        shell=MagicMock(),
        deepresearch=interface_deep._DeepResearchRouteContextToken(MagicMock()),
    )

    with pytest.raises(RuntimeError, match="route reset failed"):
        _reset_runtime_cron_context(tokens)

    reset_shell.assert_called_once()
    for context_var in context_vars.values():
        context_var.reset.assert_called_once()

    with pytest.raises(RuntimeError, match="route reset failed"):
        _reset_runtime_cron_context(tokens)
    assert route_reset.call_count == 2
    reset_shell.assert_called_once()
    for context_var in context_vars.values():
        context_var.reset.assert_called_once()


def test_cross_context_reset_retains_tokens_for_retry_in_original_context() -> None:
    from jiuwenswarm.agents.harness.common.tools.deepresearch.tools import _get_route

    adapter = _make_adapter(
        _env_service_id="service-cross-context",
        _env_agent_id="agent-cross-context",
    )
    tokens = adapter._bind_runtime_cron_context(
        channel_id="tui",
        session_id="sess-cross-context",
        metadata={},
        request_id="req-cross-context",
        mode="agent",
    )

    with pytest.raises(ValueError):
        contextvars.Context().run(_reset_runtime_cron_context, tokens)

    assert tokens.channel is not None
    assert tokens.session is not None
    assert tokens.metadata is not None
    assert tokens.mode is not None
    assert tokens.bound is not None
    assert tokens.shell is not None
    assert tokens.deepresearch is not None and tokens.deepresearch.token is not None

    _reset_runtime_cron_context(tokens)
    _reset_runtime_cron_context(tokens)
    assert _get_route()["session_id"] == ""
    assert all(
        token is None
        for token in (
            tokens.channel,
            tokens.session,
            tokens.metadata,
            tokens.mode,
            tokens.bound,
            tokens.shell,
        )
    )
    assert tokens.deepresearch is not None and tokens.deepresearch.token is None


def test_bind_rollback_preserves_cancelled_error_when_shell_reset_fails(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep

    adapter = _make_adapter(
        _env_service_id="service-bind-failure",
        _env_agent_id="agent-bind-failure",
    )

    def fail_route_bind(**_kwargs):
        raise asyncio.CancelledError("original cancellation")

    monkeypatch.setattr(interface_deep, "push_deepresearch_route", fail_route_bind)
    monkeypatch.setattr(
        "openjiuwen.core.sys_operation.shell_process_registry.reset_shell_session_id",
        MagicMock(side_effect=RuntimeError("shell cleanup failed")),
    )

    with pytest.raises(asyncio.CancelledError, match="original cancellation"):
        adapter._bind_runtime_cron_context(
            channel_id="tui",
            session_id="sess-bind-failure",
            metadata={},
            request_id="req-bind-failure",
            mode="agent",
        )

    assert interface_deep._CRON_TOOL_CHANNEL_ID.get() == "web"
    assert interface_deep._CRON_TOOL_SESSION_ID.get() is None
    assert interface_deep._CRON_TOOL_METADATA.get() is None
    assert interface_deep._CRON_TOOL_MODE.get() is None
    assert interface_deep._CRON_TOOL_BOUND.get() is False


@pytest.mark.asyncio
async def test_chat_pre_try_failure_cleans_route_and_initialized_permission_tokens(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.agents.harness.common.tools.deepresearch.tools import _get_route
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep

    adapter = _make_message_adapter(monkeypatch)
    permission_token = object()
    permission_session_token = object()
    cleanup_permission = MagicMock()
    reset_permission_session = MagicMock()
    monkeypatch.setattr(
        interface_deep,
        "setup_permission_context",
        MagicMock(return_value=permission_token),
    )
    monkeypatch.setattr(interface_deep, "cleanup_permission_context", cleanup_permission)
    monkeypatch.setattr(
        interface_deep,
        "setup_permissions_session_scope",
        MagicMock(return_value=permission_session_token),
    )
    monkeypatch.setattr(
        interface_deep,
        "reset_permissions_session_scope",
        reset_permission_session,
    )
    monkeypatch.setattr(
        adapter,
        "_resolve_model_for_request",
        MagicMock(side_effect=RuntimeError("model init failed")),
    )

    with pytest.raises(RuntimeError, match="model init failed"):
        await adapter.process_message_impl(
            _route_test_request(),
            {"query": "research"},
        )

    assert _get_route()["session_id"] == ""
    assert interface_deep._CRON_TOOL_SESSION_ID.get() is None
    cleanup_permission.assert_called_once_with(permission_token)
    reset_permission_session.assert_called_once_with(permission_session_token)


@pytest.mark.asyncio
async def test_stream_pre_try_cancellation_cleans_route_and_initialized_permission_tokens(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.agents.harness.common.tools.deepresearch.tools import _get_route
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep

    adapter = _make_message_adapter(monkeypatch)
    permission_token = object()
    permission_session_token = object()
    cleanup_permission = MagicMock()
    reset_permission_session = MagicMock()
    monkeypatch.setattr(
        interface_deep,
        "setup_permission_context",
        MagicMock(return_value=permission_token),
    )
    monkeypatch.setattr(interface_deep, "cleanup_permission_context", cleanup_permission)
    monkeypatch.setattr(
        interface_deep,
        "setup_permissions_session_scope",
        MagicMock(return_value=permission_session_token),
    )
    monkeypatch.setattr(
        interface_deep,
        "reset_permissions_session_scope",
        reset_permission_session,
    )
    monkeypatch.setattr(
        adapter,
        "_maybe_apply_pending_reload",
        AsyncMock(side_effect=asyncio.CancelledError("pre-try cancelled")),
    )

    with pytest.raises(asyncio.CancelledError, match="pre-try cancelled"):
        async for _ in adapter.process_message_stream_impl(
            _route_test_request(stream=True),
            {"query": "research"},
        ):
            pass

    assert _get_route()["session_id"] == ""
    assert interface_deep._CRON_TOOL_SESSION_ID.get() is None
    cleanup_permission.assert_called_once_with(permission_token)
    reset_permission_session.assert_called_once_with(permission_session_token)


@pytest.mark.asyncio
async def test_chat_failure_survives_permission_cleanup_error_and_reaches_route_reset(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep
    from jiuwenswarm.server.runtime.agent_adapter.deep import pure_helpers

    adapter = _make_message_adapter(monkeypatch)
    route_reset = MagicMock(wraps=pure_helpers.reset_deepresearch_route)
    monkeypatch.setattr(pure_helpers, "reset_deepresearch_route", route_reset)
    monkeypatch.setattr(
        interface_deep,
        "setup_permission_context",
        MagicMock(return_value=object()),
    )
    monkeypatch.setattr(
        interface_deep,
        "cleanup_permission_context",
        MagicMock(side_effect=RuntimeError("permission cleanup failed")),
    )
    monkeypatch.setattr(
        adapter,
        "_update_runtime_config",
        AsyncMock(side_effect=RuntimeError("chat execution failed")),
    )

    with pytest.raises(RuntimeError, match="chat execution failed"):
        await adapter.process_message_impl(
            _route_test_request(),
            {"query": "research"},
        )

    route_reset.assert_called_once()


@pytest.mark.asyncio
async def test_stream_consumer_cancellation_survives_permission_cleanup_error_and_resets_route(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep
    from jiuwenswarm.server.runtime.agent_adapter.deep import pure_helpers

    adapter = _make_message_adapter(monkeypatch)
    route_reset = MagicMock(wraps=pure_helpers.reset_deepresearch_route)
    full_reset = MagicMock(wraps=_reset_runtime_cron_context)
    monkeypatch.setattr(pure_helpers, "reset_deepresearch_route", route_reset)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep._reset_runtime_cron_context", full_reset)
    monkeypatch.setattr(
        interface_deep,
        "setup_permission_context",
        MagicMock(return_value=object()),
    )
    monkeypatch.setattr(
        interface_deep,
        "cleanup_permission_context",
        MagicMock(side_effect=RuntimeError("permission cleanup failed")),
    )
    monkeypatch.setattr(
        adapter,
        "_update_runtime_config",
        AsyncMock(side_effect=asyncio.CancelledError("consumer cancelled")),
    )

    async def consume() -> None:
        async for _ in adapter.process_message_stream_impl(
            _route_test_request(stream=True),
            {"query": "research"},
        ):
            pass

    task = asyncio.create_task(consume())
    with pytest.raises(asyncio.CancelledError, match="consumer cancelled"):
        await task

    route_reset.assert_called_once()
    full_reset.assert_not_called()