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
20.7 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
"""Exercise real facade entry points without model calls or persistent sessions."""

import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock

import pytest

from jiuwenswarm.common.schema.agent import AgentRequest, AgentResponse, AgentResponseChunk
from jiuwenswarm.common.schema.message import ReqMethod
from jiuwenswarm.server.handlers import _default, _shared, chat
from jiuwenswarm.server.runtime.agent_adapter import interface
from jiuwenswarm.server.runtime.agent_manager import AgentManager, _make_agent_cache_key
from jiuwenswarm.server.runtime.session.session_manager import SessionManager
from jiuwenswarm.server.runtime.session import session_metadata
from jiuwenswarm.server.runtime.tenant_agent_pool import TenantAgentPool


class RecordingAdapter:
    def __init__(self, mode):
        self.mode = mode
        self.create_instance = AsyncMock()
        self.handle_heartbeat = AsyncMock(return_value=None)
        self.interrupts = []
        self.messages = []
        self._session_adapters = {}

    async def process_interrupt(self, request):
        self.interrupts.append(request)
        return AgentResponse(
            request_id=request.request_id,
            channel_id=request.channel_id,
            ok=True,
            payload={"event_type": "chat.interrupt_result", "success": True},
        )

    async def process_message_stream_impl(self, request, inputs):
        self.messages.append((request, dict(inputs)))
        yield AgentResponseChunk(
            request_id=request.request_id,
            channel_id=request.channel_id,
            payload={"event_type": "chat.done"},
            is_complete=True,
        )

    async def process_message_impl(self, request, inputs):
        self.messages.append((request, dict(inputs)))
        return AgentResponse(
            request_id=request.request_id, channel_id=request.channel_id,
            ok=True, payload={"event_type": "chat.done"},
        )


@pytest.fixture
def facades(monkeypatch, tmp_path):
    created = []

    def create_adapter(_sdk, *, mode, **_kwargs):
        adapter = RecordingAdapter(mode)
        created.append(adapter)
        return adapter

    monkeypatch.setattr(interface, "create_adapter", create_adapter)
    monkeypatch.setattr(interface, "resolve_sdk_choice", lambda: "harness")
    monkeypatch.setattr(interface, "get_config", lambda: {})
    monkeypatch.setattr(interface, "is_auto_memory_enabled", lambda *_: False)
    monkeypatch.setattr(interface, "_schedule_symphony_session_feedback", Mock())
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.workspace.policy_reload.reload_quota_policies_from_gateway_db",
        AsyncMock(),
    )
    monkeypatch.setattr(
        "jiuwenswarm.agents.harness.team.get_team_manager",
        lambda _channel: SimpleNamespace(),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.team_helpers._team_session_has_runtime",
        AsyncMock(return_value=False),
    )

    def build():
        facade = object.__new__(interface.JiuWenSwarm)
        facade._adapter = None
        facade._adapter_mode = None
        facade._workspace_dir = str(tmp_path)
        facade._agent_id = facade._service_id = None
        facade._skill_manager = Mock()
        facade._personal_context_runtime_enabled = False
        facade._session_manager = SessionManager(telemetry=Mock())
        facade._permission_response_ledger = interface.PermissionResponseLedger()
        facade._append_history_record = Mock()
        facade._materialize_enterprise_attachments = AsyncMock()
        facade._bind_tenant_request_context = Mock(return_value=(None, None))
        facade._reset_tenant_request_context = Mock()
        facade._cancel_team_work_for_session = AsyncMock()
        facade._build_inputs = lambda req: (
            {"query": req.params.get("query", "")}, "disabled", req.params.get("query", ""),
        )
        return facade

    return build, created


def make_request(mode, *, method=ReqMethod.CHAT_SEND, session_id="compat-session", **params):
    if mode is not None:
        params["mode"] = mode
    return AgentRequest(
        request_id=f"compat-{session_id}",
        channel_id="officeclaw",
        session_id=session_id,
        req_method=method,
        params=params,
    )


@pytest.mark.asyncio
@pytest.mark.parametrize("mode,plan_entry_source", [
    ("team", None), ("team.plan", "e2a"), ("code.team", None),
    ("agent.plan", "e2a"), ("agent.plan", None), ("agent", None),
    ("flash", None), (None, None), ("", None),
])
async def test_cold_facade_stream_preserves_routed_mode(facades, tmp_path, mode, plan_entry_source):
    build, created = facades
    params = {"query": "hello", "project_dir": str(tmp_path)}
    if plan_entry_source is not None:
        params["plan_entry_source"] = plan_entry_source
    incoming = make_request(
        mode, **params,
    )
    manager = object.__new__(AgentManager)
    manager_mode, sub_mode, project_dir = manager._agent_lookup_from_request(incoming)
    assert project_dir == str(tmp_path)
    facade = build()
    await facade.create_instance(mode=manager_mode, sub_mode=sub_mode)

    chunks = await asyncio.wait_for(
        _collect(facade.process_message_stream(incoming)), timeout=5,
    )

    assert chunks[-1].is_complete
    assert not any((chunk.payload or {}).get("event_type") == "chat.error" for chunk in chunks)
    assert created[0].messages[0][0] is incoming
    assert created[0].messages[0][1]["query"] == "hello"
    assert created[0].create_instance.await_args.kwargs["mode"] == manager_mode
    assert incoming.params.get("mode") == mode


async def _collect(stream):
    return [chunk async for chunk in stream]


@pytest.mark.asyncio
@pytest.mark.parametrize("original_mode", ["team", "agent", "code", "flash"])
async def test_parameterless_rebuild_keeps_business_mode(facades, original_mode):
    build, created = facades
    facade = build()
    await facade.create_instance(mode=original_mode)
    if original_mode == "team":
        assert facade._ensure_adapter(mode="agent") is created[0]
    await facade.create_instance()
    assert len(created) == 1
    assert [call.kwargs["mode"] for call in created[0].create_instance.await_args_list] == [
        original_mode, original_mode,
    ]


@pytest.mark.parametrize("original_mode,new_mode", [
    ("agent", "flash"), ("flash", "agent"), ("team", "flash"),
    ("code", "agent"), ("team", "code"), ("flash", "code"),
])
def test_genuine_cross_implementation_reuse_remains_rejected(facades, original_mode, new_mode):
    build, created = facades
    facade = build()
    first = facade._ensure_adapter(mode=original_mode)
    with pytest.raises(RuntimeError, match="adapter mode mismatch"):
        facade._ensure_adapter(mode=new_mode)
    assert facade._adapter is first
    assert len(created) == 1


@pytest.mark.asyncio
@pytest.mark.parametrize("bound_mode", ["flash", "code", "agent"])
@pytest.mark.parametrize("incoming_mode", ["agent.plan", None, ""])
@pytest.mark.parametrize("intent", ["pause", "resume", "supplement", "cancel"])
async def test_legacy_interrupt_reaches_bound_adapter(facades, bound_mode, incoming_mode, intent):
    build, created = facades
    facade = build()
    await facade.create_instance(mode=bound_mode)
    incoming = make_request(incoming_mode, method=ReqMethod.CHAT_CANCEL, intent=intent)

    response = await facade.process_message(incoming)

    assert response.payload["success"] is True
    assert created[0].interrupts == [incoming]
    assert len(created) == 1
    assert facade._adapter_mode == bound_mode


@pytest.mark.asyncio
@pytest.mark.parametrize("mode,expected", [("flash", "flash"), ("agent.plan", "agent"), (None, "agent")])
async def test_interrupt_without_bound_adapter_keeps_request_fallback(facades, mode, expected):
    build, created = facades
    incoming = make_request(mode, method=ReqMethod.CHAT_CANCEL, intent="pause")
    response = await build().process_message(incoming)
    assert response.payload["success"] is True
    assert len(created) == 1
    assert created[0].mode == expected
    assert created[0].interrupts == [incoming]


@pytest.mark.asyncio
@pytest.mark.parametrize("mode", ["agent.plan", None])
@pytest.mark.parametrize("intent", ["pause", "resume", "supplement", "cancel"])
async def test_tenant_interrupt_uses_actual_session_owner(facades, monkeypatch, mode, intent):
    build, created = facades
    owner, unrelated = build(), build()
    await owner.create_instance(mode="flash")
    await unrelated.create_instance(mode="agent")
    owner._adapter._session_adapters["owned-session"] = object()
    unrelated._adapter._session_adapters["other-session"] = object()
    manager = SimpleNamespace(agents={"officeclaw": {"agent::other": unrelated, "flash::owned": owner}})
    pool = SimpleNamespace(
        resolve_control_rpc_tenant=lambda req, agent_id, service_id: (agent_id, service_id),
        get_agent_manager=AsyncMock(return_value=manager),
    )
    monkeypatch.setattr(_shared, "get_config", lambda: {"flash": {"enabled": True}})
    incoming = make_request(mode, method=ReqMethod.CHAT_CANCEL, session_id="owned-session", intent=intent)
    ctx = SimpleNamespace(
        request=incoming,
        services=SimpleNamespace(tenant_pool=lambda: pool, session_stream_tasks={}),
        sink=SimpleNamespace(send_wire=AsyncMock()),
    )

    await chat.handle_chat_cancel_dispatch(ctx)

    assert created[0].interrupts == [incoming]
    assert created[1].interrupts == []
    assert len(created) == 2
    ctx.sink.send_wire.assert_awaited_once()


@pytest.fixture
def resume_routes(facades, monkeypatch, tmp_path):
    """Keep real owner scans, cache routing, metadata and facade entry points."""
    build, created = facades
    config = {"flash": {"enabled": False}}
    monkeypatch.setattr(_shared, "get_config", lambda: config)
    monkeypatch.setattr(_default, "_sessions_dir_for_request", lambda _: tmp_path)
    monkeypatch.setattr(_shared, "_sessions_dir_for_request", lambda _: tmp_path)
    monkeypatch.setattr(
        "jiuwenswarm.server.agent_ws_server.ensure_interface_deep_and_checkpointer", AsyncMock(),
    )
    monkeypatch.setattr(_default, "_ensure_code_mode_state", AsyncMock(return_value=False))
    monkeypatch.setattr(_default, "_check_post_process_plan_exit", AsyncMock())
    manager = object.__new__(AgentManager)
    manager.agents = {"officeclaw": {}}
    manager._agent_borrowers = {}
    manager._pending_tui_retirements = {}
    manager.wait_for_session_prewarm = AsyncMock()
    pool = object.__new__(TenantAgentPool)
    pool.require_officeclaw_agent = Mock(return_value=None)
    pool.iter_agent_managers_nowait = lambda: [manager]
    pool.resolve_control_rpc_tenant = lambda req, aid, sid: (aid, sid)
    pool.get_agent_manager = AsyncMock(return_value=manager)
    pool._ensure_agent_manager = AsyncMock(return_value=manager)
    pool._refresh_agent_manager_cache = AsyncMock()
    ctx = SimpleNamespace(
        services=SimpleNamespace(
            agent_manager=manager, tenant_pool=lambda: pool, session_stream_tasks={},
        ),
        sink=SimpleNamespace(send_chunk=AsyncMock(return_value=True)),
    )

    async def add(mode, sub_mode=None):
        facade = build()
        await facade.create_instance(mode=mode, sub_mode=sub_mode)
        key = _make_agent_cache_key(mode, sub_mode or "", str(tmp_path))
        manager.agents["officeclaw"][key] = facade
        return facade

    def initialize(sid, adapter_mode="agent"):
        session_metadata.init_session_metadata(
            session_id=sid, channel_id="officeclaw", mode="agent", work_mode="work",
            adapter_mode=adapter_mode, project_dir=str(tmp_path), sessions_root=tmp_path,
        )

    return SimpleNamespace(
        add=add, initialize=initialize, config=config, manager=manager,
        pool=pool, ctx=ctx, created=created,
    )


@pytest.mark.asyncio
@pytest.mark.parametrize("path", ["handler", "manager", "pool", "handler_pool"])
@pytest.mark.parametrize("source", ["permission_interrupt", "confirm_interrupt", "ask_user_interrupt"])
@pytest.mark.parametrize("bound_mode", ["agent", "flash"])
@pytest.mark.parametrize("incoming_mode", ["agent.plan", None])
async def test_resume_reaches_paused_owner_stream(
    resume_routes, tmp_path, path, source, bound_mode, incoming_mode,
):
    routes = resume_routes
    routes.initialize("paused-session")
    owner = await routes.add(bound_mode)
    other_mode = "flash" if bound_mode == "agent" else "agent"
    unrelated = await routes.add(other_mode)
    # A real paused interaction session, discoverable by the production scans.
    owner._adapter._instance = SimpleNamespace(
        _interaction_session=SimpleNamespace(session_id=lambda: "paused-session"),
    )
    owner._adapter._read_session_interrupt_state = lambda: {"tool_call_id": "tool-1"}
    routes.config["flash"]["enabled"] = bound_mode == "agent"
    request = make_request(
        incoming_mode, session_id="paused-session", source=source,
        answers=[{"option_id": "allow"}], request_id="tool-1", query="continue",
        project_dir=str(tmp_path), work_mode="work",
    )
    # The pool shortcut can receive a decision computed by an upstream handler.
    request.resolved_adapter_mode = other_mode
    request.resolved_adapter_source = "flash_enabled_default" if other_mode == "flash" else "default"
    if path == "handler":
        _, _, selected = await _default._prepare_code_mode_chat_turn(
            routes.ctx, request, "officeclaw",
        )
        assert selected is owner
        chunks = await _collect(selected.process_message_stream(request))
    elif path == "handler_pool":
        await _default._handle_stream_impl(routes.ctx, request)
        chunks = [call.args[0] for call in routes.ctx.sink.send_chunk.await_args_list]
    else:
        target = routes.manager if path == "manager" else routes.pool
        chunks = await _collect(target.process_message_stream(request))
    assert chunks[-1].is_complete
    assert not any((chunk.payload or {}).get("event_type") == "chat.error" for chunk in chunks)
    assert owner._adapter.messages[0][0] is request
    assert unrelated._adapter.messages == []
    assert request.resolved_adapter_mode == bound_mode
    assert request.resolved_adapter_source == "session_owner"
    assert len(routes.created) == 2
    if path in {"handler", "handler_pool"}:
        metadata = session_metadata.get_session_metadata(
            "paused-session", cache_bust=True, enable_writeback=False, sessions_root=tmp_path,
        )
        assert metadata["adapter_mode"] == bound_mode


@pytest.mark.asyncio
@pytest.mark.parametrize("path", ["manager", "pool"])
@pytest.mark.parametrize("bound_mode", ["agent", "flash"])
@pytest.mark.parametrize("source", ["permission_interrupt", "confirm_interrupt", "ask_user_interrupt"])
async def test_resume_reaches_paused_owner_unary(resume_routes, tmp_path, path, bound_mode, source):
    routes = resume_routes
    owner = await routes.add(bound_mode)
    owner._adapter._sessions_awaiting_tool_permission = {"paused-session"}
    request = make_request(
        "agent.plan", session_id="paused-session", source=source,
        answers=[{"option_id": "allow"}], request_id="tool-1", query="continue",
        project_dir=str(tmp_path), work_mode="work",
    )
    request.resolved_adapter_mode = "flash" if bound_mode == "agent" else "agent"
    routes.config["flash"]["enabled"] = bound_mode == "agent"
    target = routes.manager if path == "manager" else routes.pool
    response = await target.process_message(request)
    assert response.ok
    assert owner._adapter.messages[0][0] is request
    assert request.resolved_adapter_mode == bound_mode


@pytest.mark.asyncio
@pytest.mark.parametrize("stored_adapter", ["agent", "flash"])
@pytest.mark.parametrize("incoming_mode", ["agent.plan", None])
async def test_handler_pool_manager_preserves_session_flash_binding(
    resume_routes, tmp_path, stored_adapter, incoming_mode,
):
    routes = resume_routes
    routes.initialize("sticky-session", stored_adapter)
    deep = await routes.add("agent")
    flash = await routes.add("flash")
    routes.config["flash"]["enabled"] = False
    request = make_request(
        incoming_mode, session_id="sticky-session", query="hello",
        project_dir=str(tmp_path), work_mode="work",
    )
    await _default._handle_stream_impl(routes.ctx, request)
    expected, other = (flash, deep) if stored_adapter == "flash" else (deep, flash)
    assert expected._adapter.messages[0][0] is request
    assert other._adapter.messages == []
    assert request.resolved_adapter_mode == stored_adapter
    assert request.params["mode"] == stored_adapter
    if stored_adapter == "flash":
        assert request.resolved_adapter_source == "session_sticky"
    # Wait for the real metadata writer before asserting durable mode.
    await asyncio.wait_for(asyncio.to_thread(session_metadata._METADATA_QUEUE.join), timeout=5)
    metadata = session_metadata.get_session_metadata(
        "sticky-session", cache_bust=True, enable_writeback=False, sessions_root=tmp_path,
    )
    assert metadata["adapter_mode"] == stored_adapter
    assert metadata["mode"] == (stored_adapter if incoming_mode else "agent")


@pytest.mark.parametrize("mode,expected,sub_mode", [
    ("agent.code.normal", "code", "normal"), ("team", "team", None),
    ("agent.plan", "agent", "plan"), ("team.work.plan", "team", "plan"),
])
def test_prepared_flash_binding_cannot_override_code_team_or_plan(mode, expected, sub_mode, monkeypatch):
    monkeypatch.setattr(_shared, "get_config", lambda: {"flash": {"enabled": True}})
    request = make_request(mode, plan_entry_source="e2a", work_mode="work")
    request.resolved_adapter_mode = "flash"
    request.resolved_adapter_source = "session_sticky"
    manager = object.__new__(AgentManager)
    actual_mode, actual_sub, _ = manager._agent_lookup_from_request(request)
    assert (actual_mode, actual_sub) == (expected, sub_mode)
    assert request.resolved_adapter_mode == ("code" if expected == "code" else "agent")


@pytest.fixture
def standalone_yaml_configuration(monkeypatch, tmp_path):
    from jiuwenswarm.common import config as config_module

    path = tmp_path / "config.yaml"
    monkeypatch.setattr(config_module, "get_config_file", lambda: path)
    config_module.clear_config_cache()
    yield config_module, path
    config_module.clear_config_cache()


@pytest.mark.asyncio
@pytest.mark.parametrize("env_value,config_enabled,expected", [
    ("true", False, "flash"), ("false", True, "agent"),
])
async def test_standalone_flash_environment_reaches_stream_and_keeps_session_binding(
    resume_routes, standalone_yaml_configuration, monkeypatch, tmp_path, env_value, config_enabled, expected,
):
    routes = resume_routes
    session_metadata.init_session_metadata(
        session_id="standalone-env", channel_id="web", mode="agent", work_mode="work",
        adapter_mode="agent", project_dir=str(tmp_path), sessions_root=tmp_path,
    )
    deep = await routes.add("agent")
    flash = await routes.add("flash")
    routes.manager.agents["web"] = routes.manager.agents.pop("officeclaw")
    config_module, config_file = standalone_yaml_configuration
    config_file.write_text(f"flash:\n  enabled: {str(config_enabled).lower()}\n", encoding="utf-8")
    monkeypatch.setattr(_shared, "get_config", config_module.get_config)
    monkeypatch.setenv("JIUWENSWARM_FLASH_ENABLED", env_value)

    async def send(request_id):
        config_module.clear_config_cache()
        incoming = make_request(
            "agent.work.normal", session_id="standalone-env", query="hello",
            work_mode="work", project_dir=str(tmp_path),
        )
        incoming.request_id = request_id
        incoming.channel_id = "web"
        _, _, prepared = await _default._prepare_code_mode_chat_turn(routes.ctx, incoming, "web")
        chunks = await _collect(routes.manager.process_message_stream(incoming))
        assert chunks[-1].is_complete
        assert not any((c.payload or {}).get("event_type") == "chat.error" for c in chunks)
        assert prepared is (flash if expected == "flash" else deep)
        assert incoming.resolved_adapter_mode == expected
        metadata = session_metadata.get_session_metadata(
            "standalone-env", cache_bust=True, enable_writeback=False, sessions_root=tmp_path,
        )
        assert metadata["adapter_mode"] == expected
        return incoming

    first = await send("env-first")
    selected, other = (flash, deep) if expected == "flash" else (deep, flash)
    assert selected._adapter.messages[0][0] is first
    assert other._adapter.messages == []
    if expected == "flash":
        monkeypatch.setenv("JIUWENSWARM_FLASH_ENABLED", "false")
        second = await send("env-continue")
        assert second.resolved_adapter_source == "session_sticky"
        assert selected._adapter.messages[1][0] is second
    assert len(routes.created) == 2