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

"""Scheme A: plain cron_* follow-up on web; interrupt resume finds session owner."""

# pylint: disable=protected-access

from __future__ import annotations

from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch

import pytest

from jiuwenswarm.common.schema.agent import AgentRequest
from jiuwenswarm.common.schema.message import ReqMethod
from jiuwenswarm.server.agent_ws_server import AgentWebSocketServer
from jiuwenswarm.server.context import AgentServerServices, RequestContext
from jiuwenswarm.server.handlers import _default
from jiuwenswarm.server.handlers import _shared
from jiuwenswarm.server.runtime import agent_manager as am
from jiuwenswarm.server.runtime.agent_manager import AgentManager
from jiuwenswarm.server.runtime.tenant_agent_pool import TenantAgentPool
from jiuwenswarm.server.transports.sink import WSSink


@pytest.fixture(autouse=True)
def _disable_flash_for_cron_routing_tests(monkeypatch):
    """Keep cron-routing tests independent of the host Flash switch."""
    monkeypatch.setattr(
        _shared,
        "get_config",
        lambda: {"flash": {"enabled": False}},
    )


def _default_ctx(server, request):
    import asyncio as _asyncio

    class _NullWs:
        async def send(self, text):  # noqa: ANN001
            return None

    _ws = _NullWs()
    return RequestContext(
        request=request,
        sink=WSSink(_ws, _asyncio.Lock()),
        connection_id=str(id(_ws)),
        services=AgentServerServices(server),
    )


def test_cron_agent_channel_helpers_cover_followup_and_resume() -> None:
    followup = SimpleNamespace(
        session_id="cron_abc",
        channel_id="web",
        params={"query": "1"},
    )
    resume = SimpleNamespace(
        session_id="cron_abc",
        channel_id="web",
        params={
            "source": "permission_interrupt",
            "answers": [{"option_id": "allow"}],
            "request_id": "perm-1",
        },
    )
    normal = SimpleNamespace(
        session_id="sess_web",
        channel_id="web",
        params={"query": "hi"},
    )

    assert am._is_cron_session_request(followup) is True
    assert am._is_cron_permission_resume(followup) is False
    assert am._is_interrupt_resume_request(followup) is False
    # Plain follow-up stays on request channel (web), not forced to __cron__.
    assert am._cron_agent_channel_for_request(followup) == "web"
    assert am._cron_permission_resume_channel(followup) == "web"

    assert am._is_interrupt_resume_request(resume) is True
    assert am._is_cron_permission_resume(resume) is True
    assert am._cron_agent_channel_for_request(resume) == "__cron__"

    assert am._is_cron_session_request(normal) is False
    assert am._cron_agent_channel_for_request(normal) == "web"


@pytest.mark.asyncio
async def test_agent_manager_plain_cron_followup_uses_request_channel() -> None:
    """Plain cron_* follow-up must get_agent(web), not reuse __cron__ owner."""
    owned = MagicMock(name="owned_cron")
    owned._jiuwenswarm_agent_channel_id = "__cron__"
    web_agent = MagicMock(name="web_agent")
    manager = AgentManager.__new__(AgentManager)
    manager.get_agent_for_session_nowait = MagicMock(return_value=owned)
    manager.find_agent_for_session_nowait = MagicMock(return_value=owned)
    manager.get_agent = AsyncMock(return_value=web_agent)
    manager._agent_lookup_from_request = MagicMock(return_value=("agent", None, None))

    request = SimpleNamespace(
        session_id="cron_job_x",
        channel_id="web",
        params={"query": "1"},
    )
    selected = await manager._get_agent_for_request(request)
    assert selected is web_agent
    manager.find_agent_for_session_nowait.assert_not_called()
    manager.get_agent.assert_awaited_once_with(
        channel_id="web",
        mode="agent",
        project_dir=None,
        sub_mode=None,
        request=None,
    )


@pytest.mark.asyncio
async def test_agent_manager_interrupt_resume_reuses_owner() -> None:
    owned = MagicMock(name="owned_cron")
    owned._jiuwenswarm_agent_channel_id = "__cron__"
    manager = AgentManager.__new__(AgentManager)
    manager.get_agent_for_session_nowait = MagicMock(return_value=None)
    manager.find_agent_for_session_nowait = MagicMock(return_value=None)
    manager.find_agent_for_interrupt_resume_nowait = MagicMock(return_value=owned)
    manager.get_agent = AsyncMock(return_value=MagicMock())
    manager._agent_lookup_from_request = MagicMock(return_value=("agent", None, None))

    request = SimpleNamespace(
        session_id="cron_job_x",
        channel_id="web",
        params={
            "source": "permission_interrupt",
            "answers": [{"option_id": "allow"}],
            "request_id": "perm-1",
        },
    )
    selected = await manager._get_agent_for_request(request)
    assert selected is owned
    manager.get_agent.assert_not_awaited()


@pytest.mark.asyncio
async def test_cron_followup_routes_to_web_channel_agent() -> None:
    """Plain cron_* follow-up uses request channel (web), not __cron__."""
    web_agent = MagicMock(name="web_agent")
    manager = MagicMock()
    manager.get_agent = AsyncMock(return_value=web_agent)
    manager.wait_for_session_prewarm = AsyncMock()
    manager.get_agent_for_session_nowait = MagicMock(return_value=MagicMock())
    manager.find_agent_for_session_nowait = MagicMock(return_value=MagicMock())
    manager.find_agent_for_interrupt_resume_nowait = MagicMock(return_value=None)

    server = AgentWebSocketServer.__new__(AgentWebSocketServer)
    server._agent_manager = manager
    request = AgentRequest(
        request_id="cron-followup",
        channel_id="web",
        session_id="cron_job1_run2",
        req_method=ReqMethod.CHAT_SEND,
        params={"query": "1"},
    )

    with patch(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        return_value={"mode": "agent", "work_mode": "work"},
    ), patch.object(
        _default,
        "_sync_chat_request_metadata",
        return_value=None,
    ):
        mode, _sub_mode, selected = await _default._prepare_code_mode_chat_turn(
            _default_ctx(server, request),
            request,
            "web",
            agent_manager=manager,
        )

    assert selected is web_agent
    assert mode == "agent"
    manager.find_agent_for_session_nowait.assert_not_called()
    manager.get_agent.assert_awaited_once_with(
        channel_id="web",
        mode="agent",
        project_dir=None,
        sub_mode=None,
    )


@pytest.mark.asyncio
async def test_cron_interrupt_resume_reuses_session_owner() -> None:
    owned = MagicMock(name="cron_owner")
    manager = MagicMock()
    manager.get_agent = AsyncMock(return_value=MagicMock())
    manager.wait_for_session_prewarm = AsyncMock()
    manager.get_agent_for_session_nowait = MagicMock(return_value=None)
    manager.find_agent_for_session_nowait = MagicMock(return_value=None)
    manager.find_agent_for_interrupt_resume_nowait = MagicMock(return_value=owned)

    server = AgentWebSocketServer.__new__(AgentWebSocketServer)
    server._agent_manager = manager
    request = AgentRequest(
        request_id="cron-resume",
        channel_id="web",
        session_id="cron_job1_run2",
        req_method=ReqMethod.CHAT_SEND,
        params={
            "source": "permission_interrupt",
            "answers": [{"option_id": "allow"}],
            "request_id": "perm-1",
        },
    )

    with patch(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        return_value={"mode": "agent", "work_mode": "work"},
    ), patch.object(
        _default,
        "_sync_chat_request_metadata",
        return_value=None,
    ):
        _mode, _sub, selected = await _default._prepare_code_mode_chat_turn(
            _default_ctx(server, request),
            request,
            "web",
            agent_manager=manager,
        )

    assert selected is owned
    manager.find_agent_for_interrupt_resume_nowait.assert_called_once_with("cron_job1_run2")
    manager.find_agent_for_session_nowait.assert_not_called()
    manager.get_agent.assert_not_awaited()


@pytest.mark.asyncio
async def test_cron_interrupt_resume_falls_back_to_get_agent_cron_channel() -> None:
    """When no live owner, cron_* interrupt resume falls back to get_agent(__cron__)."""
    agent = MagicMock(name="cron_agent")
    manager = MagicMock()
    manager.get_agent = AsyncMock(return_value=agent)
    manager.wait_for_session_prewarm = AsyncMock()
    manager.get_agent_for_session_nowait = MagicMock(return_value=None)
    manager.find_agent_for_session_nowait = MagicMock(return_value=None)
    manager.find_agent_for_interrupt_resume_nowait = MagicMock(return_value=None)

    server = AgentWebSocketServer.__new__(AgentWebSocketServer)
    server._agent_manager = manager
    request = AgentRequest(
        request_id="cron-resume-fallback",
        channel_id="web",
        session_id="cron_job1_run3",
        req_method=ReqMethod.CHAT_SEND,
        params={
            "source": "permission_interrupt",
            "answers": [{"option_id": "allow"}],
            "request_id": "perm-2",
        },
    )

    with patch(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        return_value={"mode": "agent", "work_mode": "work"},
    ), patch.object(
        _default,
        "_sync_chat_request_metadata",
        return_value=None,
    ):
        _mode, _sub, selected = await _default._prepare_code_mode_chat_turn(
            _default_ctx(server, request),
            request,
            "web",
            agent_manager=manager,
        )

    assert selected is agent
    manager.get_agent.assert_awaited_once_with(
        channel_id="__cron__",
        mode="agent",
        project_dir=None,
        sub_mode=None,
    )


@pytest.mark.asyncio
async def test_tenant_pool_plain_cron_followup_does_not_cross_tenant_reuse() -> None:
    owned = MagicMock()
    owned.process_message_stream = MagicMock(
        return_value=_async_chunks(
            [
                SimpleNamespace(
                    request_id="r1",
                    channel_id="web",
                    payload={"event_type": "chat.delta", "content": "ok"},
                    is_complete=True,
                )
            ]
        )
    )
    pool = TenantAgentPool.__new__(TenantAgentPool)
    pool.require_officeclaw_agent = MagicMock(return_value=None)
    pool.find_agent_for_session_nowait = MagicMock(return_value=owned)
    pool._cron_resume_session_allowed = AsyncMock(return_value=True)
    manager = MagicMock()
    manager.process_message_stream = MagicMock(
        return_value=_async_chunks(
            [
                SimpleNamespace(
                    request_id="r1",
                    channel_id="web",
                    payload={"event_type": "chat.delta", "content": "web-ok"},
                    is_complete=True,
                )
            ]
        )
    )
    pool._ensure_agent_manager = AsyncMock(return_value=manager)
    pool._refresh_agent_manager_cache = AsyncMock()
    pool.extract_ids = MagicMock(return_value=("a", "s", "w"))
    pool.resolve_control_rpc_tenant = MagicMock(return_value=("a", "s"))
    pool._build_cache_key = MagicMock(return_value="cache")

    request = AgentRequest(
        request_id="r1",
        channel_id="web",
        session_id="cron_tenant_1",
        req_method=ReqMethod.CHAT_SEND,
        params={"query": "1"},
    )
    chunks = [
        chunk async for chunk in TenantAgentPool.process_message_stream(pool, request)
    ]
    assert len(chunks) == 1
    assert chunks[0].payload["content"] == "web-ok"
    pool.find_agent_for_session_nowait.assert_not_called()
    owned.process_message_stream.assert_not_called()
    pool._ensure_agent_manager.assert_awaited()


@pytest.mark.asyncio
async def test_tenant_pool_reuses_owner_for_interrupt_resume_stream() -> None:
    owned = MagicMock()
    owned.process_message_stream = MagicMock(
        return_value=_async_chunks(
            [
                SimpleNamespace(
                    request_id="r1",
                    channel_id="web",
                    payload={"event_type": "chat.delta", "content": "ok"},
                    is_complete=True,
                )
            ]
        )
    )
    pool = TenantAgentPool.__new__(TenantAgentPool)
    pool.require_officeclaw_agent = MagicMock(return_value=None)
    pool.find_agent_for_session_nowait = MagicMock(return_value=owned)
    pool.find_agent_for_interrupt_resume_nowait = MagicMock(return_value=owned)
    pool._cron_resume_session_allowed = AsyncMock(return_value=True)
    pool._ensure_agent_manager = AsyncMock()

    request = AgentRequest(
        request_id="r1",
        channel_id="web",
        session_id="cron_tenant_1",
        req_method=ReqMethod.CHAT_SEND,
        params={
            "source": "permission_interrupt",
            "answers": [{"option_id": "allow"}],
            "request_id": "perm-1",
        },
    )
    chunks = [
        chunk async for chunk in TenantAgentPool.process_message_stream(pool, request)
    ]
    assert len(chunks) == 1
    pool._ensure_agent_manager.assert_not_awaited()
    owned.process_message_stream.assert_called_once_with(request)


def _agent_holding(session_id: str, *, live: bool, awaiting: bool, last_used: float):
    adapter = MagicMock()
    adapter._is_session_scoped_adapter = False
    adapter._sessions_awaiting_tool_permission = {session_id} if awaiting or live else set()
    adapter._session_adapter_last_used = {session_id: last_used}
    adapter._session_adapters = {}
    adapter._instance = SimpleNamespace(
        _interaction_session=SimpleNamespace(session_id=session_id),
        _loop_session=None,
    )
    adapter._read_session_interrupt_state = MagicMock(
        return_value={"paused": True} if live else None
    )
    agent = MagicMock()
    agent._adapter = adapter
    return agent


def test_interrupt_resume_prefers_live_web_pause_over_stale_cron_owner() -> None:
    """Follow-up approval must hit the agent that still has the paused tool."""
    cron_agent = _agent_holding("cron_job", live=False, awaiting=True, last_used=1.0)
    web_agent = _agent_holding("cron_job", live=True, awaiting=True, last_used=10.0)
    manager = AgentManager.__new__(AgentManager)
    manager.agents = {
        "__cron__": {"cron": cron_agent},
        "web": {"web": web_agent},
    }
    selected = manager.find_agent_for_interrupt_resume_nowait("cron_job")
    assert selected is web_agent


def test_interrupt_resume_keeps_live_cron_pause() -> None:
    """First-run cron approval still returns to __cron__ when that pause is live."""
    cron_agent = _agent_holding("cron_job", live=True, awaiting=True, last_used=1.0)
    web_agent = _agent_holding("cron_job", live=False, awaiting=False, last_used=9.0)
    manager = AgentManager.__new__(AgentManager)
    manager.agents = {
        "__cron__": {"cron": cron_agent},
        "web": {"web": web_agent},
    }
    selected = manager.find_agent_for_interrupt_resume_nowait("cron_job")
    assert selected is cron_agent


async def _async_chunks(items):
    for item in items:
        yield item