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

import asyncio
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock, patch

import pytest
from openjiuwen.core.runner import Runner
from openjiuwen.core.single_agent.ability_manager import AbilityManager
from openjiuwen.core.single_agent.rail.base import ToolCallInputs

from jiuwenswarm.agents.harness.common.rails.progressive_tool_rail import (
    ProgressiveToolRail,
)
from jiuwenswarm.agents.harness.common.rails.deepresearch_execution_rail import (
    DeepResearchExecutionRail,
)
from jiuwenswarm.agents.harness.common.tools.deepresearch import execution as de
from jiuwenswarm.agents.harness.common.tools.deepresearch import tools as dt
from jiuwenswarm.agents.harness.common.tools.invoke_tool_tool import (
    InvokeToolInput,
    InvokeToolTool,
)
from jiuwenswarm.common.local_env_config import (
    clear_agent_env_ns,
    get_bound_agent_env_ns,
    get_task_env_overlay,
    replace_active_env,
)
from jiuwenswarm.common.schema.agent import AgentRequest
from jiuwenswarm.perf.context import clear_request_context, set_request_context
from jiuwenswarm.server.runtime.agent_adapter import interface_deep


class _RequestContextSession:
    def __init__(self, session_id: str):
        self.session_id = session_id
        self.state: dict[str, object] = {}

    def get_session_id(self):
        return self.session_id

    def get_state(self, key):
        return self.state.get(key)

    def update_state(self, values):
        self.state.update(values)


def _execution_rail_context(session_id: str):
    tool_call = SimpleNamespace(
        id=f"call-{session_id}",
        name="deepresearch_execute",
        arguments={"query": "q"},
    )
    return SimpleNamespace(
        session=_RequestContextSession(session_id),
        inputs=ToolCallInputs(
            tool_call=tool_call,
            tool_name="deepresearch_execute",
            tool_args=tool_call.arguments,
            tool_result=None,
        ),
        extra={},
    )


@pytest.mark.asyncio
async def test_report_type_uses_params_and_isolated_execution_contexts():
    requests = (
        AgentRequest(
            request_id="request-brief",
            channel_id="officeclaw",
            session_id="session-brief",
            params={"report_type": "brief"},
            metadata={"report_type": "professional"},
        ),
        AgentRequest(
            request_id="request-professional",
            channel_id="officeclaw",
            session_id="session-professional",
            params={"report_type": "professional"},
            metadata={"report_type": "brief"},
        ),
    )
    both_bound = asyncio.Event()
    bound_count = 0
    bound_lock = asyncio.Lock()

    async def _observe(request: AgentRequest) -> str | None:
        nonlocal bound_count
        requested_report_type = interface_deep._extract_requested_report_type(request)
        set_request_context(
            session_id=request.session_id or "",
            request_id=request.request_id or "",
            channel_id=request.channel_id or "",
            mode="agent",
            requested_report_type=requested_report_type,
        )
        async with bound_lock:
            bound_count += 1
            if bound_count == len(requests):
                both_bound.set()
        await both_bound.wait()

        rail = DeepResearchExecutionRail(model_provider=lambda: None)
        ctx = _execution_rail_context(request.session_id or "")
        await rail.before_tool_call(ctx)
        try:
            execution_context = de._execution_context.get()
            return execution_context.requested_report_type
        finally:
            await rail.after_tool_call(ctx)
            clear_request_context(
                session_id=request.session_id,
                request_id=request.request_id,
            )

    assert await asyncio.gather(*(_observe(request) for request in requests)) == [
        "brief",
        "professional",
    ]


@pytest.mark.asyncio
async def test_deepresearch_followup_flows_to_execution_context():
    """metadata.deepresearch_followup 经提取→请求上下文→rail 绑定到执行上下文。

    结构不合法时按未携带处理(告警降级,不拒绝请求)。
    """
    valid_request = AgentRequest(
        request_id="request-followup",
        channel_id="officeclaw",
        session_id="session-followup",
        params={},
        metadata={
            "deepresearch_followup": {
                "v": 1,
                "action": "upgrade_latest_brief",
                "source_report_id": "brief-conv-1",
            }
        },
    )
    invalid_request = AgentRequest(
        request_id="request-invalid",
        channel_id="officeclaw",
        session_id="session-invalid",
        params={},
        metadata={"deepresearch_followup": {"v": 2, "action": "unknown"}},
    )
    plain_request = AgentRequest(
        request_id="request-plain",
        channel_id="officeclaw",
        session_id="session-plain",
    )

    followup = interface_deep._extract_deepresearch_followup(valid_request)
    assert followup == {
        "v": 1,
        "action": "upgrade_latest_brief",
        "source_report_id": "brief-conv-1",
    }
    assert interface_deep._extract_deepresearch_followup(invalid_request) is None
    assert interface_deep._extract_deepresearch_followup(plain_request) is None

    set_request_context(
        session_id="session-followup",
        request_id="request-followup",
        channel_id="officeclaw",
        mode="agent",
        deepresearch_followup=followup,
    )
    try:
        rail = DeepResearchExecutionRail(model_provider=lambda: None)
        ctx = _execution_rail_context("session-followup")
        await rail.before_tool_call(ctx)
        try:
            execution_context = de._execution_context.get()
            assert execution_context.deepresearch_followup == followup
        finally:
            await rail.after_tool_call(ctx)
    finally:
        clear_request_context(
            session_id="session-followup",
            request_id="request-followup",
        )


@pytest.mark.asyncio
async def test_deferred_deepresearch_rebinds_trusted_adapter_context():
    service_id = "progressive-test-service"
    agent_id = "office"
    shared_root = "/trusted/office-claw-skills"
    output_dir = "/trusted/agent-workspace/projects"
    replace_active_env(
        {"JIUWENSWARM_SHARED_SKILLS_DIRS": shared_root},
        service_id=service_id,
        agent_id=agent_id,
    )
    target = AsyncMock()

    async def _invoke(_arguments, **_kwargs):
        assert get_task_env_overlay() == {
            "JIUWENSWARM_SHARED_SKILLS_DIRS": shared_root
        }
        assert dt._get_route() == {
            "request_id": "request",
            "channel_id": "officeclaw",
            "session_id": "session",
            "service_id": service_id,
            "agent_id": agent_id,
        }
        assert dt._get_effective_request_output_dir() == Path(output_dir).resolve()
        return "ok"

    target.invoke.side_effect = _invoke
    card = SimpleNamespace(name="deepresearch_stream", id="deepresearch-tool-id")
    rail = ProgressiveToolRail(
        eager_tools=["tools_search", "invoke_tool"],
        deepresearch_context_provider=lambda: {
            "request_id": "request",
            "channel_id": "officeclaw",
            "session_id": "session",
            "service_id": service_id,
            "agent_id": agent_id,
            "output_dir": output_dir,
        },
    )
    rail._cached_deferred_tool_infos = [card]

    try:
        with patch.object(Runner.resource_mgr, "get_tool", return_value=target):
            result = await rail._invoke_target_tool(
                None,
                InvokeToolInput(
                    tool_name="deepresearch_stream",
                    arguments={"action": "start", "query": "q"},
                ),
            )
        assert result == {
            "success": True,
            "tool_name": "deepresearch_stream",
            "result": "ok",
        }
        assert get_task_env_overlay() is None
        assert dt._get_route() == {
            "request_id": "",
            "channel_id": "",
            "session_id": "",
            "service_id": "default",
            "agent_id": "default",
        }
    finally:
        clear_agent_env_ns(service_id, agent_id)


@pytest.mark.asyncio
async def test_skill_activated_deepresearch_entry_rebinds_trusted_adapter_context():
    service_id = "progressive-eager-service"
    agent_id = "office"
    shared_root = "/trusted/office-claw-skills"
    replace_active_env(
        {"JIUWENSWARM_SHARED_SKILLS_DIRS": shared_root},
        service_id=service_id,
        agent_id=agent_id,
    )
    agent = SimpleNamespace(
        ability_manager=SimpleNamespace(list=lambda: [de.deepresearch_execute.card]),
    )
    rail = ProgressiveToolRail(
        eager_tools=["tools_search", "invoke_tool"],
        active_skill_provider=lambda: "deepresearch",
        deepresearch_context_provider=lambda: {
            "request_id": "request",
            "channel_id": "officeclaw",
            "session_id": "session",
            "service_id": service_id,
            "agent_id": agent_id,
            "output_dir": "/trusted/projects",
        },
    )
    tool_call = SimpleNamespace(
        id="call-1", name="deepresearch_execute", arguments={"query": "q"}
    )
    ctx = SimpleNamespace(
        agent=agent,
        inputs=ToolCallInputs(
            tool_call=tool_call,
            tool_name="deepresearch_execute",
            tool_args=tool_call.arguments,
        ),
        extra={},
    )

    try:
        await rail.before_tool_call(ctx)
        assert get_task_env_overlay() == {
            "JIUWENSWARM_SHARED_SKILLS_DIRS": shared_root
        }
        assert dt._get_route()["service_id"] == service_id
        assert dt._get_route()["agent_id"] == agent_id
        await rail.after_tool_call(ctx)
        assert get_task_env_overlay() is None
        assert dt._get_route()["service_id"] == "default"
    finally:
        clear_agent_env_ns(service_id, agent_id)


def test_unregistered_deepresearch_prefix_does_not_receive_tenant_context():
    provider = Mock(
        return_value={
            "request_id": "request",
            "channel_id": "officeclaw",
            "session_id": "session",
            "service_id": "default",
            "agent_id": "default",
        }
    )
    rail = ProgressiveToolRail(
        eager_tools=["tools_search", "invoke_tool"],
        deepresearch_context_provider=provider,
    )

    with rail._bind_deepresearch_context("deepresearch_probe"):
        assert get_task_env_overlay() is None

    provider.assert_not_called()


def test_deepresearch_context_binding_rolls_back_partial_setup():
    before = get_bound_agent_env_ns()
    rail = ProgressiveToolRail(
        eager_tools=["tools_search", "invoke_tool"],
        deepresearch_context_provider=lambda: {
            "service_id": "progressive-test-service",
            "agent_id": "office",
        },
    )

    with patch(
        "jiuwenswarm.common.local_env_config.build_effective_env_overlay",
        side_effect=RuntimeError("overlay failed"),
    ):
        with pytest.raises(RuntimeError, match="overlay failed"):
            with rail._bind_deepresearch_context("deepresearch_stream"):
                pass

    assert get_bound_agent_env_ns() == before


def test_invoke_tool_defers_outer_timeout_to_target_policy():
    tool = InvokeToolTool(AsyncMock())
    assert tool.card.properties["resilience"]["timeout_s"] is None


@pytest.mark.asyncio
async def test_deferred_target_keeps_its_own_timeout_policy():
    async def _slow_invoke(_arguments, **_kwargs):
        await asyncio.sleep(0.05)
        return "late"

    target = SimpleNamespace(invoke=_slow_invoke)
    card = SimpleNamespace(
        name="ordinary_deferred",
        id="ordinary-tool-id",
        properties={"resilience": {"timeout_s": 0.01}},
    )
    rail = ProgressiveToolRail(eager_tools=["tools_search", "invoke_tool"])
    rail._cached_deferred_tool_infos = [card]

    with patch.object(Runner.resource_mgr, "get_tool", return_value=target):
        result = await rail._invoke_target_tool(
            None,
            InvokeToolInput(tool_name="ordinary_deferred", arguments={}),
        )

    assert result == {
        "success": False,
        "error": "Tool 'ordinary_deferred' timed out after 0.01s",
        "tool_name": "ordinary_deferred",
    }


@pytest.mark.asyncio
async def test_deferred_target_preserves_its_own_timeout_error():
    async def _invoke_with_internal_timeout(_arguments, **_kwargs):
        raise TimeoutError("backend request timed out")

    target = SimpleNamespace(invoke=_invoke_with_internal_timeout)
    card = SimpleNamespace(
        name="ordinary_deferred",
        id="ordinary-tool-id",
        properties={"resilience": {"timeout_s": None}},
    )
    rail = ProgressiveToolRail(eager_tools=["tools_search", "invoke_tool"])
    rail._cached_deferred_tool_infos = [card]

    with patch.object(Runner.resource_mgr, "get_tool", return_value=target):
        result = await rail._invoke_target_tool(
            None,
            InvokeToolInput(tool_name="ordinary_deferred", arguments={}),
        )

    assert result == {
        "success": False,
        "error": "backend request timed out",
        "tool_name": "ordinary_deferred",
    }


@pytest.mark.asyncio
async def test_deferred_tool_lookup_keeps_default_timeout_boundary():
    async def _slow_list_tool_info():
        await asyncio.sleep(0.05)

    ability_manager = SimpleNamespace(
        list=lambda: [],
        list_tool_info=_slow_list_tool_info,
    )
    rail = ProgressiveToolRail(eager_tools=["tools_search", "invoke_tool"])
    rail._runtime_agent = SimpleNamespace(ability_manager=ability_manager)

    with patch.object(AbilityManager, "_resolve_call_timeout", return_value=0.01):
        result = await rail._invoke_target_tool(
            None,
            InvokeToolInput(tool_name="missing_deferred", arguments={}),
        )

    assert result == {
        "success": False,
        "error": "Tool lookup for 'missing_deferred' timed out after 0.01s",
        "tool_name": "missing_deferred",
    }

@pytest.mark.asyncio
@pytest.mark.parametrize('permission,allowed', [('ask', False), ('deny', False), ('allow', True)])
async def test_material_paths_require_explicit_read_permission(permission, allowed):
    from uuid import uuid4
    from agent_shield.tool_permission import get_permission_manager
    key = f"test:material:{uuid4()}"
    manager = get_permission_manager()
    manager.update_config(
        {'enabled': True, 'tools': {'read_file': permission}}, key,
    )
    adapter = SimpleNamespace(_current_request_route={'materials_context': {
        'files': [{'path': '/uploaded/a.txt', 'name': 'a.txt'}], 'scope': 's', 'original_query': '参考附件'}},
        _resolve_permission_config_for_agent=Mock(return_value={'enabled': True}),
        _permission_rail=SimpleNamespace(permission_key=key),
    )
    try:
        context = await interface_deep.JiuWenSwarmDeepAdapter._get_deepresearch_material_context(adapter)
    finally:
        manager.remove_config(key)
    assert context['files'][0]['read_allowed'] is allowed
    assert 'read_allowed' not in adapter._current_request_route['materials_context']['files'][0]


@pytest.mark.asyncio
async def test_disabled_permissions_prepare_current_request_material(tmp_path):
    import json
    from jiuwenswarm.agents.harness.common.tools.deepresearch.materials import prepare_materials

    root = tmp_path.resolve()
    attachment = root / 'material.txt'
    attachment.write_text('fictional regression material: queue 42 to 17 seconds', encoding='utf-8')
    resolve_config = Mock(return_value={'enabled': False})
    adapter = SimpleNamespace(
        _current_request_route={'session_id': 'material-session', 'materials_context': {
            'files': [{'path': str(attachment), 'name': attachment.name}],
            'scope': 'material-session', 'output_dir': str(root),
            'original_query': '必须使用附件为核心材料,允许联网',
        }},
        _permission_rail=None,
        _resolve_permission_config_for_agent=resolve_config,
    )
    context = await interface_deep.JiuWenSwarmDeepAdapter._get_deepresearch_material_context(adapter)
    reference = await prepare_materials(context, 'e7c43dd6-2d6e-4093-8c97-4d894fd0fef1')
    payload = json.loads(Path(reference['path']).read_text())
    assert payload['materials'][0]['content'] == attachment.read_text()
    assert reference['results'][0]['status'] == 'ready'
    resolve_config.assert_called_once_with(session_id='material-session')
    assert 'read_allowed' not in adapter._current_request_route['materials_context']['files'][0]


@pytest.mark.asyncio
@pytest.mark.parametrize('config', [
    {'enabled': True}, {}, {'enabled': None}, {'enabled': 'false'}, {'enabled': 0}, None, [],
])
async def test_missing_material_permission_engine_stays_closed(config):
    adapter = SimpleNamespace(
        _current_request_route={'materials_context': {'files': [{'path': '/uploaded/a.txt'}]}},
        _permission_rail=None,
        _resolve_permission_config_for_agent=Mock(return_value=config),
    )
    context = await interface_deep.JiuWenSwarmDeepAdapter._get_deepresearch_material_context(adapter)
    assert context['files'][0]['read_allowed'] is False


@pytest.mark.asyncio
async def test_material_permission_config_failure_stays_closed(monkeypatch):
    """配置解析失败必须短路 fail-closed:即使 Manager 会放行也不得查询。"""
    from uuid import uuid4

    from agent_shield.tool_permission import get_permission_manager

    key = f"test:material:{uuid4()}"
    manager = get_permission_manager()
    manager.update_config({"enabled": True, "tools": {"read_file": "allow"}}, key)

    async def _must_not_consult(*args, **kwargs):
        raise AssertionError("config failure must short-circuit before the manager")

    monkeypatch.setattr(manager, "check_permission", _must_not_consult)
    adapter = SimpleNamespace(
        _current_request_route={'materials_context': {'files': [{'path': '/uploaded/a.txt'}]}},
        _permission_rail=SimpleNamespace(permission_key=key),
        _resolve_permission_config_for_agent=Mock(side_effect=RuntimeError('configuration unavailable')),
    )
    try:
        context = await interface_deep.JiuWenSwarmDeepAdapter._get_deepresearch_material_context(adapter)
        assert context['files'][0]['read_allowed'] is False
    finally:
        manager.remove_config(key)