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
7.1 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
"""Installation HITL and Flash's use of the authoritative session grant store."""

import asyncio
from dataclasses import replace
from types import SimpleNamespace
from unittest.mock import AsyncMock

import pytest
import test_file_skill_grant_store as grants
import test_flash_permission_actions as actions
from flash_sdk import sdk_tools

permission_adapter = actions.permission_adapter
tool_context = actions.tool_context
stores = grants.stores
manifest = grants.manifest
activate = grants.activate


@pytest.fixture
def skill_tool(monkeypatch):
    from jiuwenswarm.agents.harness.common.tools.skill_toolkits import SkillToolkit
    from jiuwenswarm.agents.harness.flash.tools.slim_skill_toolkit import (
        SlimSkillToolkit,
    )

    toolkit = object.__new__(SlimSkillToolkit)
    search = AsyncMock(
        return_value={
            "success": True,
            "items": [
                {
                    "identifier": "fixture-skill",
                    "source": "builtin",
                    "name": "fixture",
                    "installed": False,
                }
            ],
        }
    )
    monkeypatch.setattr(SkillToolkit, "search_skill", search)
    toolkit.install_skill = AsyncMock(return_value={"success": True})
    return toolkit.get_tools()[0], search, toolkit.install_skill


@pytest.mark.asyncio
@pytest.mark.parametrize("approved", [True, False])
async def test_install_asks_after_search_before_download(
    permission_adapter, skill_tool, approved
):
    from openjiuwen.harness.security.models import PermissionConfirmResponse

    tool, search, install = skill_tool
    _, rail = permission_adapter({"search_skill": "allow", "install_skill": "ask"})
    entered, answer = asyncio.Event(), asyncio.Event()

    async def confirm(request):
        assert request.tool_call.name == "install_skill"
        assert request.tool_call.id == "call-1"
        search.assert_awaited_once()
        install.assert_not_awaited()
        entered.set()
        await answer.wait()
        return PermissionConfirmResponse(approved=approved)

    rail._host.request_permission_confirmation = confirm
    ctx = tool_context("search_skill", {"query": "fixture"})
    async with sdk_tools(rail, ctx.session, [tool]) as (manager, native_ctx):
        task = asyncio.create_task(
            manager.execute(native_ctx, ctx.inputs.tool_call, ctx.session)
        )
        await asyncio.wait_for(entered.wait(), 5)
        install.assert_not_awaited()
        answer.set()
        result = await task
        assert install.await_count == int(approved), str(result)
        assert "fixture-skill" in str(result)
        search.assert_awaited_once()
        # Replay of the same SDK call cannot download twice.
        await manager.execute(native_ctx, ctx.inputs.tool_call, ctx.session)
        assert install.await_count == int(approved)


@pytest.mark.asyncio
@pytest.mark.parametrize("install_flag,items", [(False, True), (True, False)])
async def test_pure_or_empty_search_needs_no_install_approval(
    permission_adapter, skill_tool, install_flag, items
):
    tool, search, install = skill_tool
    if not items:
        search.return_value = {"success": True, "items": []}
    _, rail = permission_adapter({"search_skill": "allow", "install_skill": "ask"})
    confirm = AsyncMock(side_effect=AssertionError("unexpected installation approval"))
    rail._host.request_permission_confirmation = confirm
    ctx = tool_context("search_skill", {"query": "fixture", "install": install_flag})
    async with sdk_tools(rail, ctx.session, [tool]) as (manager, native_ctx):
        await manager.execute(native_ctx, ctx.inputs.tool_call, ctx.session)
        search.assert_awaited_once()
        confirm.assert_not_awaited()
        install.assert_not_awaited()


@pytest.mark.asyncio
async def test_native_install_resume_reuses_search_and_rejects_stale_approval(
    permission_adapter, skill_tool, monkeypatch
):
    from openjiuwen.core.runner import Runner
    from openjiuwen.harness.rails.interrupt.interrupt_base import (
        ApproveResult,
        InterruptResult,
        RejectResult,
    )

    tool, search, install = skill_tool
    monkeypatch.setattr(Runner.resource_mgr, "get_tool", lambda **_: tool)
    _, rail = permission_adapter({"search_skill": "allow", "install_skill": "ask"})
    ctx = tool_context("search_skill", {"query": "fixture"})
    ctx.agent.ability_manager = SimpleNamespace(get=lambda _: tool.card)
    assert isinstance(
        await rail.resolve_interrupt(ctx, ctx.inputs.tool_call, None), InterruptResult
    )
    assert isinstance(
        await rail.resolve_interrupt(ctx, ctx.inputs.tool_call, {"approved": True}),
        ApproveResult,
    )
    await tool.invoke(
        {"query": "fixture"}, session=ctx.session, tool_call_id="call-1"
    )
    search.assert_awaited_once()
    install.assert_awaited_once()
    changed = ctx.inputs.tool_call.model_copy(
        update={"arguments": '{"query":"different"}'}
    )
    assert isinstance(
        await rail.resolve_interrupt(ctx, changed, {"approved": True}), RejectResult
    )
    install.assert_awaited_once()


@pytest.mark.asyncio
async def test_flash_file_grants_reopen_revoke_and_never_cross_session(
    permission_adapter, stores, manifest, monkeypatch
):
    from openjiuwen.harness.security import skill_authorization
    from openjiuwen.harness.security.models import PermissionLevel

    from jiuwenswarm.agents.harness.common.rails.skill_authorization_rail import (
        SkillAuthorizationRail,
    )

    first, reopened = stores
    manifest = replace(manifest, overlay={"tools": {"web_search": "allow"}})
    activate(first, manifest)
    skill_authorization.set_skill_grant_store(reopened)
    monkeypatch.setattr(
        skill_authorization, "get_skill_authorization_context", lambda: None
    )
    _, rail = permission_adapter(
        {"web_flash": "allow", "web_search": "ask"},
        skill_authorization={"enabled": True},
    )
    gate = SkillAuthorizationRail(
        permission_key=rail.permission_key, grant_store=reopened
    )
    rail.set_skill_scope_resolver(gate.resolve_scope)
    # An ACTIVE grant must be evaluated against a published session overlay;
    # otherwise the gate fails closed instead of silently dropping the grant.
    rail.update_session_config("session", rail._static_config)
    for session_id, expected in [
        ("session", PermissionLevel.ALLOW),
        ("other", PermissionLevel.ASK),
    ]:
        ctx = tool_context(
            "web_flash", {"search": {"query": "fixture"}}, session_id=session_id
        )
        result = await rail._check_tool_permission(
            "web_flash", {"search": {"query": "fixture"}}, ctx
        )
        assert result.permission == expected
    first.revoke_grants("session", "main")
    ctx = tool_context(
        "web_flash", {"search": {"query": "fixture"}}, session_id="session"
    )
    assert (
        await rail._check_tool_permission(
            "web_flash", {"search": {"query": "fixture"}}, ctx
        )
    ).permission == PermissionLevel.ASK
    rail._published_scopes.remove_session("session")