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
22.2 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.

"""§6 missing-test fill-in for issue 3975.

Origin labels (also recorded in 迁移方案.md §6.1.1):

- 移植: D lives in ``test_agent_manager_session_cleanup.py`` (develop
  ``e3ee2dec``). This module does not duplicate those two functions.
- 自拟: every test in this file. develop has no functions with these names.
  B is spawn→TTL evict→real resume→second input. C is two real TaskTool
  invokes with the flag off. Neither uses a live LLM.
"""

from __future__ import annotations

import asyncio
from collections.abc import AsyncIterator
from dataclasses import dataclass, field
from types import SimpleNamespace
from typing import Any
from unittest.mock import patch

import pytest

from jiuwenswarm.server.runtime.agent_adapter.interface_deep import (
    JiuWenSwarmDeepAdapter,
)
from jiuwenswarm.server.runtime.agent_adapter.subagent_stream import (
    clear_all_subagent_progress_batches,
    persist_subagent_transcript_message,
    resolve_subagent_parallel_fields,
)
from jiuwenswarm.server.runtime.session import session_history


def _make_adapter(**state: object) -> JiuWenSwarmDeepAdapter:
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    state.setdefault("_sessions_awaiting_tool_permission", set())
    # Skill allow-list stamp bookkeeping (mirrors __init__; __new__ skips it).
    state.setdefault("_skill_enabled_version", 0)
    state.setdefault("_session_skill_versions", {})
    state.setdefault("_session_skill_refresh_failures", {})
    for name, value in state.items():
        setattr(adapter, name, value)
    return adapter


class _IdleChildAdapter:
    def __init__(self) -> None:
        self.cleaned = False
        self.released: list[tuple[str, str]] = []
        self._instance = None

    @staticmethod
    def is_session_active(_session_id: str) -> bool:
        return False

    @staticmethod
    def is_deep_agent_executing_for_session(_session_id: str) -> bool:
        return False

    async def stop_interaction(self) -> None:
        return None

    async def release_subagent_runtime_for_session(
        self,
        session_id: str,
        *,
        reason: str = "",
    ) -> None:
        self.released.append((session_id, reason))

    async def cleanup(self) -> None:
        self.cleaned = True


class _FailingCleanupChildAdapter(_IdleChildAdapter):
    async def cleanup(self) -> None:
        raise RuntimeError("child cleanup failed")


@dataclass
class _MockSubagentSession:
    pre_run_calls: int = 0
    close_stream_calls: int = 0
    commit_calls: int = 0

    async def pre_run(self, **kwargs: object) -> None:
        del kwargs
        self.pre_run_calls += 1

    async def close_stream(self) -> None:
        self.close_stream_calls += 1

    async def commit(self) -> None:
        self.commit_calls += 1


@dataclass
class _MockSubagent:
    output: str = "first-turn"
    card: SimpleNamespace = field(
        default_factory=lambda: SimpleNamespace(id="sub-card", name="explore")
    )

    async def stream(
        self,
        inputs: dict[str, str],
        *,
        session: _MockSubagentSession,
    ) -> AsyncIterator[dict[str, object]]:
        del inputs, session
        yield {"type": "llm_output", "payload": {"content": self.output}}
        yield {
            "type": "answer",
            "payload": {"output": self.output, "result_type": "answer"},
        }


class _ControlParent:
    def __init__(self, output: str = "first-turn") -> None:
        self.output = output
        self.created: list[_MockSubagent] = []

    def create_subagent(
        self,
        subagent_type: str,
        subsession_id: str,
        browser_capabilities: list[str] | None = None,
    ) -> _MockSubagent:
        del subagent_type, subsession_id, browser_capabilities
        agent = _MockSubagent(output=self.output)
        self.created.append(agent)
        return agent


class _SeededCheckpointer:
    def __init__(self) -> None:
        self.ids: set[str] = set()

    def seed(self, session_id: str) -> None:
        self.ids.add(session_id)

    async def session_exists(self, session_id: str) -> bool:
        return session_id in self.ids


async def _wait_spawned(control: Any, subagent_id: str) -> Any:
    from openjiuwen.harness.subagent_runtime.models import SubagentStatusKind

    deadline = asyncio.get_running_loop().time() + 2.0
    while asyncio.get_running_loop().time() < deadline:
        instance = control._manager.find(subagent_id)
        if instance is not None and instance.agent_status().kind is SubagentStatusKind.COMPLETED:
            return instance
        await asyncio.sleep(0.01)
    raise TimeoutError(f"subagent {subagent_id} did not finish a turn")


def _parent_with_child(session_id: str, child: _IdleChildAdapter) -> JiuWenSwarmDeepAdapter:
    return _make_adapter(
        _is_session_scoped_adapter=False,
        _session_adapters={session_id: child},
        _session_adapter_locks={session_id: asyncio.Lock()},
        _session_adapter_last_used={session_id: 0.0},
        _session_adapter_versions={session_id: 1},
        _session_adapter_reload_failures={},
        SESSION_ADAPTER_EVICT_BATCH_SIZE=8,
        SESSION_ADAPTER_IDLE_TTL_SEC=1.0,
    )


@pytest.mark.asyncio
async def test_subagent_resume_after_adapter_eviction_preserves_context(
    tmp_path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """Origin: 自拟 §6.B. Connected spawn → persist → TTL evict → resume → send_input.

    No live LLM. Uses CompatibleSubagentControl.spawn/close/hydrate/resume/send_input
    and dest Adapter TTL. Does not monkeypatch ``SubagentControl.resume``.
    """
    pytest.importorskip("openjiuwen.harness.subagent_runtime")
    from openjiuwen.core.session.agent import Session
    from openjiuwen.harness.subagent_runtime.config import SubagentRuntimeConfig
    from openjiuwen.harness.subagent_runtime.models import SubagentStatusKind
    from openjiuwen.harness.subagent_runtime.persistence import read_subagent_bucket
    from openjiuwen.harness.subagent_runtime.status_events import (
        build_subagent_updated_payload,
    )
    from jiuwenswarm.agents.harness.common.tools.subagent_compat import (
        CompatibleSubagentControl,
    )

    monkeypatch.setattr(session_history, "get_agent_sessions_dir", lambda: tmp_path)
    parent_session_id = "parent-evict-1"
    parent_session = Session(session_id=parent_session_id)
    parent_session.commit = lambda: None
    checkpointer = _SeededCheckpointer()
    runtime_config = SubagentRuntimeConfig(
        enable_activity_stream=False,
        enable_transcript_stream=False,
    )
    old_control = None
    new_control = None
    try:
        with patch(
            "openjiuwen.harness.subagent_runtime.session_manager.create_agent_session",
            side_effect=lambda **kwargs: _MockSubagentSession(),
        ), patch(
            "openjiuwen.harness.subagent_runtime.control.WAIT_TIMEOUT_MS_MIN",
            100,
        ), patch(
            "openjiuwen.harness.subagent_runtime.control.CheckpointerFactory.get_checkpointer",
            return_value=checkpointer,
        ):
            old_parent = _ControlParent(output="first-turn")
            old_control = CompatibleSubagentControl(
                old_parent,
                parent_session_id,
                config=runtime_config,
                parent_session=parent_session,
            )
            spawned = await old_control.spawn("explore", "first question")
            subagent_id = spawned.subagent_id
            persist_subagent_transcript_message(
                {
                    "parent_session_id": parent_session_id,
                    "subagent_id": subagent_id,
                    "content": "child context before eviction",
                    "role": "assistant",
                    "seq": 1,
                }
            )
            first = await _wait_spawned(old_control, subagent_id)
            waited = await old_control.wait([subagent_id], timeout_ms=500)
            assert waited.timed_out is False
            assert first.last_output == "first-turn"
            checkpointer.seed(subagent_id)
            await old_control.close(subagent_id, reason="manual")
            await old_control.persist()
            assert int(old_control.capacity().get("used", 0)) == 0
            assert subagent_id in read_subagent_bucket(parent_session)["records"]

            old_adapter = _IdleChildAdapter()
            old_adapter._instance = SimpleNamespace(
                _subagent_controls={parent_session_id: old_control},
            )
            parent = _parent_with_child(parent_session_id, old_adapter)
            await parent._evict_idle_session_adapters()
            assert old_adapter.cleaned is True
            assert parent._session_adapters == {}
            rows = session_history.load_history_records(
                parent_session_id,
                subagent_id=subagent_id,
            )
            assert any(
                row.get("content") == "child context before eviction" for row in rows
            )
            assert session_history.load_history_records(parent_session_id) == []

            new_parent = _ControlParent(output="second-turn")
            new_control = CompatibleSubagentControl(
                new_parent,
                parent_session_id,
                config=runtime_config,
                parent_session=parent_session,
            )
            assert new_control is not old_control
            new_control.hydrate()
            result = await new_control.resume(subagent_id)
            assert result.restored is True
            assert result.status.kind is SubagentStatusKind.COMPLETED
            payload = build_subagent_updated_payload(
                subagent_id=subagent_id,
                subagent_type="explore",
                display_name="Explorer",
                role="researcher",
                parent_session_id=parent_session_id,
                task_description="first question",
                created_at_ms=1.0,
                updated_at_ms=2.0,
                closed_at_ms=None,
                status=result.status,
                revision=1,
            )
            assert payload["status"] == "idle"
            assert payload["can_send_input"] is True
            assert payload["subagent_id"] == subagent_id

            await new_control.send_input(subagent_id, "second question")
            second = await _wait_spawned(new_control, subagent_id)
            second_wait = await new_control.wait([subagent_id], timeout_ms=500)
            assert second_wait.timed_out is False
            assert second.last_output == "second-turn"
            assert second.subagent_id == subagent_id

            new_adapter = _IdleChildAdapter()
            new_adapter._instance = SimpleNamespace(
                _subagent_controls={parent_session_id: new_control},
            )
            parent._session_adapters[parent_session_id] = new_adapter
            assert new_adapter is not old_adapter
            assert parent._session_adapters[parent_session_id] is not old_adapter
    finally:
        for control in (old_control, new_control):
            if control is None:
                continue
            for sid in list(control._manager.list_ids()):
                await control._manager.remove(sid, reason="test_cleanup")
                control._registry.release(sid)


@pytest.mark.asyncio
async def test_idle_eviction_skips_live_subagent_runtime() -> None:
    """Origin: 自拟 §6.B/L TTL. Live children must block Adapter eviction."""
    child = _IdleChildAdapter()
    child._instance = SimpleNamespace(
        _subagent_controls={
            "sess-live": SimpleNamespace(capacity=lambda: {"used": 2}),
        }
    )
    parent = _parent_with_child("sess-live", child)
    await parent._evict_idle_session_adapters()
    assert child.cleaned is False
    assert parent._session_adapters["sess-live"] is child


@pytest.mark.asyncio
async def test_flag_off_task_tool_remains_ephemeral_end_to_end(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """Origin: 自拟 §6.C. Two real TaskTool.invoke calls with the flag off.

    No model. Flag-off rail.init registers the real task_tool, two invokes
    create two ephemeral conversation ids, and no persistent control remains.
    """
    from openjiuwen.core.session.agent import Session
    from openjiuwen.harness.rails.subagent import subagent_rail as rail_mod
    from openjiuwen.harness.tools.subagent.task_tool import TaskTool
    from jiuwenswarm.agents.harness.common.rails.browser_task_prompt_rail import (
        BrowserTaskPromptRail,
    )
    from jiuwenswarm.server.runtime.agent_adapter.interface_deep import (
        JiuWenSwarmDeepAdapter as DeepAdapter,
    )

    persistent_inits: list[str] = []
    conversation_ids: list[str] = []

    class _FakeSub:
        card = SimpleNamespace(name="explore_agent", description="explore", id="explore")

        async def invoke(self, inputs: dict[str, str], session: object = None) -> dict[str, str]:
            del session
            conversation_ids.append(str(inputs.get("conversation_id") or ""))
            return {"output": f"done-{len(conversation_ids)}"}

    def _persistent_tools(**kwargs: object) -> list[object]:
        del kwargs
        persistent_inits.append("subagent_spawn")
        return [SimpleNamespace(card=SimpleNamespace(name="subagent_spawn"))]

    if hasattr(rail_mod, "build_subagent_tools"):
        monkeypatch.setattr(rail_mod, "build_subagent_tools", _persistent_tools)

    registered: list[object] = []
    parent_agent = SimpleNamespace(
        create_subagent=lambda *_args, **_kwargs: _FakeSub(),
        deep_config=SimpleNamespace(
            subagents=[
                SimpleNamespace(
                    card=SimpleNamespace(name="explore_agent", description="explore")
                )
            ]
        ),
        ability_manager=SimpleNamespace(
            add_ability=lambda card, tool: registered.append((card, tool))
        ),
        card=SimpleNamespace(id="parent-agent"),
        system_prompt_builder=SimpleNamespace(language="en"),
    )

    adapter = DeepAdapter()
    off_rail = adapter._build_subagent_rail({})
    assert isinstance(off_rail, BrowserTaskPromptRail)
    assert off_rail.enable_subagent_runtime is False
    off_rail.init(parent_agent)
    assert persistent_inits == []
    assert not hasattr(parent_agent, "_subagent_controls")
    tools = [tool for _card, tool in registered if isinstance(tool, TaskTool)]
    assert len(tools) == 1
    tool = tools[0]
    session = Session(session_id="parent-flag-off")
    first = await tool.invoke(
        {"subagent_type": "explore_agent", "task_description": "first"},
        session=session,
    )
    second = await tool.invoke(
        {"subagent_type": "explore_agent", "task_description": "second"},
        session=session,
    )
    assert first.success is True
    assert second.success is True
    assert first.data["output"] == "done-1"
    assert second.data["output"] == "done-2"
    assert len(conversation_ids) == 2
    assert conversation_ids[0] != conversation_ids[1]
    assert conversation_ids[0].startswith("parent-flag-off_sub_explore_agent_")
    assert persistent_inits == []
    assert not hasattr(parent_agent, "_subagent_controls")
    assert all(getattr(card, "name", "") == "task_tool" for card, _tool in registered)


@pytest.mark.asyncio
async def test_parent_cleanup_isolates_failing_session_adapter() -> None:
    """Origin: 自拟 §6.L. One child cleanup exception must not skip siblings."""
    failing = _FailingCleanupChildAdapter()
    sibling = _IdleChildAdapter()
    parent = _make_adapter(
        _is_session_scoped_adapter=False,
        _session_adapters={"sess-a": failing, "sess-b": sibling},
        _session_adapter_locks={},
        _session_adapter_last_used={},
        _session_adapter_versions={},
        _session_adapter_reload_failures={},
        _instance=None,
        _memory_reindex_task=None,
        _a2x_client=None,
        _retained_sys_operation_ids=[],
    )
    await parent.cleanup()
    assert sibling.cleaned is True
    assert parent._session_adapters == {}


@pytest.mark.asyncio
async def test_cancel_session_agent_tasks_gather_isolates_exceptions() -> None:
    """Origin: 自拟 §6.L. Real asyncio.gather(..., return_exceptions=True)."""
    adapter = _make_adapter(_session_agent_tasks={})

    async def _boom() -> None:
        try:
            await asyncio.sleep(60)
        except asyncio.CancelledError:
            raise RuntimeError("task cleanup boom") from None

    async def _quiet() -> None:
        try:
            await asyncio.sleep(60)
        except asyncio.CancelledError:
            return

    boom_task = asyncio.create_task(_boom())
    quiet_task = asyncio.create_task(_quiet())
    adapter._session_agent_tasks["sess-gather"] = {boom_task, quiet_task}

    cancelled = await adapter._cancel_session_agent_tasks("sess-gather")
    assert cancelled == 2
    assert boom_task.done() is True
    assert quiet_task.done() is True
    assert adapter._session_agent_tasks.get("sess-gather") in (None, set())


def test_progress_batches_isolated_across_parent_sessions() -> None:
    """Origin: 自拟 §6.L. Same child id under two parents must not share a batch."""
    clear_all_subagent_progress_batches()
    first = resolve_subagent_parallel_fields(
        parent_session_id="parent-a",
        subagent_id="sa-shared-name",
        legacy_status="starting",
    )
    second = resolve_subagent_parallel_fields(
        parent_session_id="parent-b",
        subagent_id="sa-shared-name",
        legacy_status="starting",
    )
    assert first == (0, 1, False)
    assert second == (0, 1, False)
    third = resolve_subagent_parallel_fields(
        parent_session_id="parent-a",
        subagent_id="sa-other",
        legacy_status="starting",
    )
    assert third == (1, 2, True)
    leftover_b = resolve_subagent_parallel_fields(
        parent_session_id="parent-b",
        subagent_id="sa-shared-name",
        legacy_status="starting",
    )
    assert leftover_b == (0, 1, False)


@pytest.mark.asyncio
async def test_dual_parent_real_spawn_isolates_batches_and_ttl() -> None:
    """Origin: 自拟 §6.L live. Two parents spawn two children each via gather.

    No live LLM. Real ``CompatibleSubagentControl.spawn`` + wait. Batches and
    TTL occupancy stay isolated; idle eviction must skip both live parents.
    """
    pytest.importorskip("openjiuwen.harness.subagent_runtime")
    from openjiuwen.core.session.agent import Session
    from openjiuwen.harness.subagent_runtime.config import SubagentRuntimeConfig
    from jiuwenswarm.agents.harness.common.tools.subagent_compat import (
        CompatibleSubagentControl,
    )

    clear_all_subagent_progress_batches()
    runtime_config = SubagentRuntimeConfig(
        enable_activity_stream=False,
        enable_transcript_stream=False,
    )
    controls: list[CompatibleSubagentControl] = []

    async def _spawn_parent(
        session_id: str,
        output: str,
    ) -> tuple[CompatibleSubagentControl, list[str]]:
        parent_session = Session(session_id=session_id)
        parent_session.commit = lambda: None
        control = CompatibleSubagentControl(
            _ControlParent(output=output),
            session_id,
            config=runtime_config,
            parent_session=parent_session,
        )
        controls.append(control)

        async def _one(prompt: str) -> str:
            spawned = await control.spawn("explore", prompt)
            resolve_subagent_parallel_fields(
                parent_session_id=session_id,
                subagent_id=spawned.subagent_id,
                legacy_status="starting",
            )
            await _wait_spawned(control, spawned.subagent_id)
            return spawned.subagent_id

        child_ids = await asyncio.gather(_one("q1"), _one("q2"))
        return control, list(child_ids)

    try:
        with patch(
            "openjiuwen.harness.subagent_runtime.session_manager.create_agent_session",
            side_effect=lambda **kwargs: _MockSubagentSession(),
        ), patch(
            "openjiuwen.harness.subagent_runtime.control.WAIT_TIMEOUT_MS_MIN",
            100,
        ):
            (control_a, ids_a), (control_b, ids_b) = await asyncio.gather(
                _spawn_parent("parent-l-a", "a-out"),
                _spawn_parent("parent-l-b", "b-out"),
            )
        ids = ids_a + ids_b
        assert len(set(ids)) == 4
        leftover_a = resolve_subagent_parallel_fields(
            parent_session_id="parent-l-a",
            subagent_id=ids_a[0],
            legacy_status="starting",
        )
        leftover_b = resolve_subagent_parallel_fields(
            parent_session_id="parent-l-b",
            subagent_id=ids_b[0],
            legacy_status="starting",
        )
        assert leftover_a[1] == 2
        assert leftover_b[1] == 2
        assert leftover_a[2] is True
        assert leftover_b[2] is True
        assert int(control_a.capacity().get("used", 0)) >= 1
        assert int(control_b.capacity().get("used", 0)) >= 1

        child_a = _IdleChildAdapter()
        child_a._instance = SimpleNamespace(
            _subagent_controls={"parent-l-a": control_a},
        )
        child_b = _IdleChildAdapter()
        child_b._instance = SimpleNamespace(
            _subagent_controls={"parent-l-b": control_b},
        )
        parent = _make_adapter(
            _is_session_scoped_adapter=False,
            _session_adapters={"parent-l-a": child_a, "parent-l-b": child_b},
            _session_adapter_locks={
                "parent-l-a": asyncio.Lock(),
                "parent-l-b": asyncio.Lock(),
            },
            _session_adapter_last_used={"parent-l-a": 0.0, "parent-l-b": 0.0},
            _session_adapter_versions={"parent-l-a": 1, "parent-l-b": 1},
            _session_adapter_reload_failures={},
            SESSION_ADAPTER_EVICT_BATCH_SIZE=8,
            SESSION_ADAPTER_IDLE_TTL_SEC=1.0,
        )
        await parent._evict_idle_session_adapters()
        assert child_a.cleaned is False
        assert child_b.cleaned is False
        assert parent._session_adapters["parent-l-a"] is child_a
        assert parent._session_adapters["parent-l-b"] is child_b
    finally:
        for control in controls:
            for sid in list(control._manager.list_ids()):
                await control._manager.remove(sid, reason="test_cleanup")
                control._registry.release(sid)