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

from __future__ import annotations

import os
from pathlib import Path
from unittest.mock import AsyncMock, MagicMock, patch

import pytest

from openjiuwen.core.foundation.llm import (
    AssistantMessage,
    Model,
    ModelClientConfig,
    ModelRequestConfig,
    ToolCall,
    UsageMetadata,
)
from openjiuwen.core.foundation.llm.schema.message_chunk import AssistantMessageChunk
from openjiuwen.core.runner import Runner
from openjiuwen.core.single_agent.rail.base import (
    AgentCallbackContext,
    AgentRail,
    ToolCallInputs,
)
from jiuwenswarm.server.runtime.agent_adapter import interface_deep as deep_interface_module
from jiuwenswarm.server.runtime.agent_adapter.interface_deep import JiuWenSwarmDeepAdapter
from jiuwenswarm.common.schema.agent import AgentRequest


class MockLLMModel:
    def __init__(self) -> None:
        self.responses: list[AssistantMessage] = []
        self.call_count = 0

    def set_responses(self, responses: list[AssistantMessage]) -> None:
        self.responses = responses
        self.call_count = 0

    def _next_response(self) -> AssistantMessage:
        if self.call_count < len(self.responses):
            response = self.responses[self.call_count]
            self.call_count += 1
            return response
        return AssistantMessage(content="Default mock response")

    async def invoke(self, messages, **kwargs):
        del messages, kwargs
        return self._next_response()

    async def stream(self, messages, **kwargs):
        del messages, kwargs
        result = self._next_response()
        yield AssistantMessageChunk(
            content=result.content,
            tool_calls=result.tool_calls,
            usage_metadata=result.usage_metadata,
        )


class ToolTraceRail(AgentRail):
    def __init__(self) -> None:
        super().__init__()
        self.tool_calls: list[str] = []

    async def before_tool_call(self, ctx: AgentCallbackContext) -> None:
        if isinstance(ctx.inputs, ToolCallInputs) and ctx.inputs.tool_name:
            self.tool_calls.append(ctx.inputs.tool_name)


class _TestableJiuWenSwarmDeepAdapter(JiuWenSwarmDeepAdapter):
    def set_workspace_dir(self, workspace_dir: str) -> None:
        self._workspace_dir = workspace_dir

    def build_configured_subagents(
        self,
        model: Model,
        config: dict,
        config_base: dict | None = None,
    ):
        return self._build_configured_subagents(model, config, config_base)


def create_text_response(content: str) -> AssistantMessage:
    return AssistantMessage(
        content=content,
        usage_metadata=UsageMetadata(model_name="mock-model", finish_reason="stop"),
    )


def create_tool_call_response(
    tool_name: str,
    arguments: str,
    *,
    tool_call_id: str,
) -> AssistantMessage:
    return AssistantMessage(
        content="",
        tool_calls=[
            ToolCall(
                id=tool_call_id,
                type="function",
                name=tool_name,
                arguments=arguments,
            )
        ],
        usage_metadata=UsageMetadata(model_name="mock-model", finish_reason="tool_calls"),
    )


def _build_model() -> Model:
    return Model(
        model_client_config=ModelClientConfig(
            client_provider="OpenAI",
            api_key="test-key",
            api_base="https://example.invalid/v1",
            verify_ssl=False,
        ),
        model_config=ModelRequestConfig(model_name="mock-model"),
    )


def _make_fake_runtime() -> MagicMock:
    runtime = MagicMock()
    runtime.ensure_started = AsyncMock()
    runtime.service = MagicMock()
    runtime.service.run_task = AsyncMock()
    runtime.controller = MagicMock()
    runtime.controller.bind_runtime = MagicMock()
    runtime.controller.bind_code_executor = MagicMock()
    runtime.controller.run_action = AsyncMock()
    runtime.code_executor = None
    return runtime


# ─── DeepAdapter (agent mode): only research_agent + browser_agent ──────

def test_deep_adapter_subagents_defaults_to_statusline_when_unconfigured(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    adapter = _TestableJiuWenSwarmDeepAdapter()
    model = _build_model()
    monkeypatch.setattr(
        JiuWenSwarmDeepAdapter,
        "_browser_runtime_enabled",
        staticmethod(lambda: False),
    )
    # DeepAdapter: no subagents configured, no browser → statusline still default-on
    subagents, _ = adapter.build_configured_subagents(
        model,
        {"max_iterations": 8},
        {},
    )

    assert subagents is not None
    assert [spec.agent_card.name for spec in subagents] == ["statusline-setup"]


def test_browser_runtime_environment_tracks_mode_and_chrome_path(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    adapter = _TestableJiuWenSwarmDeepAdapter()
    monkeypatch.setenv("BROWSER_MANAGED_BINARY", "C:\\stale\\chrome.exe")
    monkeypatch.setenv(
        "PLAYWRIGHT_MCP_ARGS",
        "-y @playwright/mcp@latest --headless",
    )

    adapter._sync_browser_runtime_environment(
        {
            "browser": {
                "chrome_path": "C:\\custom\\chrome.exe",
                "headless": False,
            }
        }
    )

    assert os.environ["BROWSER_MANAGED_BINARY"] == "C:\\custom\\chrome.exe"
    assert "BROWSER_MANAGED_ARGS" not in os.environ
    assert "--headless" not in os.environ["PLAYWRIGHT_MCP_ARGS"].split()

    adapter._sync_browser_runtime_environment(
        {"browser": {"chrome_path": "", "headless": True}}
    )

    assert "BROWSER_MANAGED_BINARY" not in os.environ
    assert os.environ["BROWSER_MANAGED_ARGS"] == "--headless=new"
    assert os.environ["PLAYWRIGHT_MCP_ARGS"].split().count("--headless") == 1


def test_deep_adapter_subagents_includes_browser_by_default_when_runtime_enabled(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    adapter = _TestableJiuWenSwarmDeepAdapter()
    adapter.set_workspace_dir("/tmp/test-workspace")
    model = _build_model()

    monkeypatch.setattr(
        deep_interface_module,
        "build_browser_agent_config",
        lambda *args, **kwargs: {"name": "browser_agent", "kwargs": kwargs},
    )
    monkeypatch.setattr(
        JiuWenSwarmDeepAdapter,
        "_browser_runtime_enabled",
        staticmethod(lambda: True),
    )
    monkeypatch.setenv("BROWSER_DRIVER", "managed")

    subagents, _ = adapter.build_configured_subagents(
        model,
        {
            "max_iterations": 8,
            "subagents": {"statusline-setup": {"enabled": False}},
        },
        {},
    )

    assert subagents is not None
    assert [item["name"] for item in subagents] == ["browser_agent"]
    assert subagents[-1]["kwargs"]["max_iterations"] == 100


def test_deep_adapter_subagents_only_includes_explicitly_enabled_agents(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    adapter = _TestableJiuWenSwarmDeepAdapter()
    adapter.set_workspace_dir("/tmp/test-workspace")
    model = _build_model()

    monkeypatch.setattr(
        deep_interface_module,
        "build_research_agent_config",
        lambda *args, **kwargs: {"name": "research_agent", "kwargs": kwargs},
    )
    monkeypatch.setattr(
        deep_interface_module,
        "build_browser_agent_config",
        lambda *args, **kwargs: {"name": "browser_agent", "kwargs": kwargs},
    )
    monkeypatch.setattr(
        JiuWenSwarmDeepAdapter,
        "_browser_runtime_enabled",
        staticmethod(lambda: True),
    )
    monkeypatch.setenv("BROWSER_DRIVER", "managed")

    subagents, _ = adapter.build_configured_subagents(
        model,
        {
            "max_iterations": 8,
            "subagents": {
                "research_agent": {"enabled": True, "max_iterations": 5},
                "browser_agent": {"max_iterations": 7},
                "statusline-setup": {"enabled": False},
            },
        },
        {},
    )

    assert subagents is not None
    assert [item["name"] for item in subagents] == ["research_agent", "browser_agent"]
    assert subagents[0]["kwargs"]["max_iterations"] == 5
    assert subagents[1]["kwargs"]["max_iterations"] == 7


def test_deep_adapter_subagents_skips_browser_without_runtime(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    adapter = _TestableJiuWenSwarmDeepAdapter()
    model = _build_model()

    monkeypatch.setattr(
        JiuWenSwarmDeepAdapter,
        "_browser_runtime_enabled",
        staticmethod(lambda: False),
    )
    browser_builder = MagicMock()
    monkeypatch.setattr(deep_interface_module, "build_browser_agent_config", browser_builder)

    # When browser runtime is disabled and no other subagents are configured,
    # the result should be None
    subagents, _ = adapter.build_configured_subagents(
        model,
        {
            "subagents": {
                "browser_agent": {"max_iterations": 7},
                "statusline-setup": {"enabled": False},
            },
        },
        {},
    )

    assert subagents is None
    browser_builder.assert_not_called()


@pytest.mark.asyncio
@pytest.mark.skip(reason="Browser subagent integration test is flaky")
async def test_interface_deep_browser_subagent_task_tool_chain(
    temp_workspace: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setenv("PLAYWRIGHT_RUNTIME_MCP_ENABLED", "1")
    monkeypatch.setenv("BROWSER_RUNTIME_MCP_ENABLED", "1")
    monkeypatch.setenv("API_KEY", "test-key")
    monkeypatch.setenv("API_BASE", "https://example.invalid/v1")
    monkeypatch.setenv("MODEL_NAME", "mock-model")
    monkeypatch.setenv("MODEL_PROVIDER", "OpenAI")

    config_base = {
        "preferred_language": "en",
        "react": {
            "agent_name": "main_agent",
            "enable_task_loop": False,
            "max_iterations": 8,
        },
    }
    monkeypatch.setattr(deep_interface_module, "get_config", lambda: config_base)

    mock_llm = MockLLMModel()
    mock_llm.set_responses([
        create_tool_call_response(
            "task_tool",
            (
                '{"subagent_type": "browser_agent", '
                '"task_description": "Open https://example.com and summarize the page"}'
            ),
            tool_call_id="main_task_tool_call",
        ),
        create_tool_call_response(
            "browser_run_task",
            (
                '{"task": "Open https://example.com and summarize the page", '
                '"session_id": "browser-sub-session"}'
            ),
            tool_call_id="browser_run_task_call",
        ),
        create_text_response("Browser subagent finished: page title is Example Domain."),
        create_text_response("Main agent received browser result successfully."),
    ])
    model = _build_model()
    runtime = _make_fake_runtime()
    runtime.service.run_task.return_value = {
        "ok": True,
        "session_id": "browser-sub-session",
        "final": "page title is Example Domain.",
        "page": {"url": "https://example.com", "title": "Example Domain"},
        "screenshot": None,
        "error": None,
    }
    tool_trace = ToolTraceRail()
    adapter = _TestableJiuWenSwarmDeepAdapter()
    adapter.set_workspace_dir(str(temp_workspace / "workspace" / "agent"))

    with (
        patch.object(JiuWenSwarmDeepAdapter, "set_checkpoint", AsyncMock()),
        patch.object(JiuWenSwarmDeepAdapter, "_create_model", return_value=model),
        patch.object(JiuWenSwarmDeepAdapter, "_get_tool_cards", AsyncMock(return_value=[])),
        patch.object(JiuWenSwarmDeepAdapter, "_build_agent_rails", return_value=[tool_trace]),
        patch.object(JiuWenSwarmDeepAdapter, "_create_sys_operation", return_value=MagicMock()),
        patch.object(JiuWenSwarmDeepAdapter, "_proc_context_compaction", AsyncMock()),
        patch.object(JiuWenSwarmDeepAdapter, "_register_runtime_tools", AsyncMock()),
        patch.object(JiuWenSwarmDeepAdapter, "_refresh_multimodal_configs", return_value=None),
        patch(
            "openjiuwen.harness.subagents.browser_agent.BrowserAgentRuntime",
            return_value=runtime,
        ),
        patch("openjiuwen.core.foundation.llm.model.Model.invoke", side_effect=mock_llm.invoke),
        patch("openjiuwen.core.foundation.llm.model.Model.stream", side_effect=mock_llm.stream),
    ):
        await Runner.start()
        try:
            await adapter.create_instance()
            request = AgentRequest(
                request_id="req-browser-1",
                channel_id="web",
                session_id="sess-browser-1",
                params={
                    "query": "Use the browser agent to inspect https://example.com.",
                    "mode": "agent.fast",
                },
            )
            response = await adapter.process_message_impl(
                request,
                {
                    "query": request.params["query"],
                    "conversation_id": request.session_id,
                    "request_id": request.request_id,
                },
            )
        finally:
            await Runner.stop()

    assert response.ok is True
    payload = response.payload["content"]
    assert payload["result_type"] == "answer"
    assert "browser result" in payload["output"].lower()
    assert "task_tool" in tool_trace.tool_calls
    assert runtime.ensure_started.await_count >= 1
    runtime.service.run_task.assert_awaited_once()
    run_task_kwargs = runtime.service.run_task.await_args.kwargs
    assert run_task_kwargs["task"] == "Open https://example.com and summarize the page"