Skip to content

Personal AI, On Personal Devices

Python
9.6 KB
Raw Blame
"""Focused tests for canonical managed-agent tool resolution (#688)."""

from __future__ import annotations

from collections import Counter

import pytest

from openjarvis.agents import tool_resolver
from openjarvis.connectors.store import KnowledgeStore
from openjarvis.core.registry import ToolRegistry
from openjarvis.core.types import ToolResult
from openjarvis.tools import description_loader
from openjarvis.tools._stubs import BaseTool, ToolSpec


class _AlphaTool(BaseTool):
    tool_id = "alpha"

    @property
    def spec(self) -> ToolSpec:
        return ToolSpec(name="alpha", description="Alpha test tool")

    def execute(self, **params) -> ToolResult:
        return ToolResult(tool_name="alpha", content="alpha", success=True)


class _BetaTool(BaseTool):
    tool_id = "beta"

    @property
    def spec(self) -> ToolSpec:
        return ToolSpec(name="beta", description="Beta test tool")

    def execute(self, **params) -> ToolResult:
        return ToolResult(tool_name="beta", content="beta", success=True)


class _NativeSharedTool(BaseTool):
    tool_id = "shared"

    @property
    def spec(self) -> ToolSpec:
        return ToolSpec(name="shared", description="Native shared tool")

    def execute(self, **params) -> ToolResult:
        return ToolResult(tool_name="shared", content="native", success=True)


class _MCPSharedTool(BaseTool):
    tool_id = "shared"

    @property
    def spec(self) -> ToolSpec:
        return ToolSpec(name="shared", description="MCP name collision")

    def execute(self, **params) -> ToolResult:
        return ToolResult(tool_name="shared", content="mcp", success=True)


class _MCPOnlyTool(BaseTool):
    tool_id = "mcp_only"

    @property
    def spec(self) -> ToolSpec:
        return ToolSpec(name="mcp_only", description="MCP-only test tool")

    def execute(self, **params) -> ToolResult:
        return ToolResult(tool_name="mcp_only", content="mcp-only", success=True)


@pytest.fixture(autouse=True)
def _use_explicit_test_registrations(monkeypatch: pytest.MonkeyPatch) -> None:
    """Keep these unit tests independent of import-time registry population."""

    monkeypatch.setattr(tool_resolver, "ensure_registries_populated", lambda: None)


def test_deep_research_grants_are_live_deduplicated_and_use_selected_model(
    tmp_path,
) -> None:
    """Agent-type grants must beat duplicate bare configured tools."""

    db_path = tmp_path / "knowledge.db"
    with KnowledgeStore(db_path=db_path) as store:
        store.store(
            "The RESOLVER_SENTINEL decision was approved.",
            source="test",
            doc_type="note",
        )

    engine = object()
    resolved = tool_resolver.resolve_agent_tools(
        {
            "agent_type": "deep_research",
            "config": {
                # Both names are already supplied by the agent-type grant.
                "tools": ["knowledge_search", "think", "think"],
            },
        },
        engine=engine,
        model="agent-selected-model",
        knowledge_db_path=db_path,
    )

    try:
        names = [tool.spec.name for tool in resolved.instances]
        assert set(names) == {
            "knowledge_search",
            "knowledge_sql",
            "scan_chunks",
            "think",
        }
        assert all(count == 1 for count in Counter(names).values())

        search = resolved.by_name["knowledge_search"]
        result = search.execute(query="RESOLVER_SENTINEL")
        assert result.success is True
        assert "RESOLVER_SENTINEL" in result.content

        scan = resolved.by_name["scan_chunks"]
        assert scan._engine is engine
        assert scan._model == "agent-selected-model"
    finally:
        # All three knowledge tools share this store connection.
        resolved.by_name["knowledge_sql"]._store.close()


@pytest.mark.parametrize(
    "tool_config",
    [
        ["alpha", "beta", "alpha"],
        " alpha, beta, alpha ",
    ],
)
def test_configured_tools_normalize_lists_and_comma_separated_strings(
    tool_config,
) -> None:
    ToolRegistry.register_value("alpha", _AlphaTool)
    ToolRegistry.register_value("beta", _BetaTool)

    resolved = tool_resolver.resolve_agent_tools(
        {"agent_type": "simple", "config": {"tools": tool_config}},
        engine=object(),
        model="test-model",
    )

    assert [tool.spec.name for tool in resolved.instances] == ["alpha", "beta"]
    assert [spec["function"]["name"] for spec in resolved.openai_specs] == [
        "alpha",
        "beta",
    ]


@pytest.mark.parametrize("custom_spec", [False, True])
@pytest.mark.parametrize("invalid_policy", [False, True])
def test_managed_file_tools_use_application_policy(
    tmp_path, monkeypatch, custom_spec, invalid_policy
):
    from openjarvis.core.config import JarvisConfig
    from openjarvis.tools.file_read import FileReadTool

    cfg = JarvisConfig()
    cfg.security.allowed_dirs = None if invalid_policy else [str(tmp_path / "allowed")]
    monkeypatch.setattr("openjarvis.core.config.load_config", lambda: JarvisConfig())
    ToolRegistry.register_value("file_read", FileReadTool)
    entry = (
        {"type": "function", "function": {"name": "file_read"}}
        if custom_spec
        else "file_read"
    )
    resolved = tool_resolver.resolve_agent_tools(
        {"config": {"tools": [entry]}}, engine=None, model="", app_config=cfg
    )
    if invalid_policy:
        assert "file_read" not in resolved.by_name
    else:
        outside = tmp_path / "outside.txt"
        outside.write_text("must stay outside")
        assert not resolved.by_name["file_read"].execute(path=str(outside)).success


def test_registered_tool_advertisement_matches_to_openai_function(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """Runtime description overrides must reach canonical advertisements."""

    ToolRegistry.register_value("alpha", _AlphaTool)
    monkeypatch.setattr(
        description_loader,
        "get_tool_description_override",
        lambda name: "Runtime alpha description" if name == "alpha" else None,
    )

    resolved = tool_resolver.resolve_agent_tools(
        {"agent_type": "simple", "config": {"tools": ["alpha"]}},
        engine=object(),
        model="test-model",
    )

    tool = resolved.by_name["alpha"]
    assert resolved.openai_specs == [tool.to_openai_function()]
    assert (
        resolved.openai_specs[0]["function"]["description"]
        == "Runtime alpha description"
    )


def test_explicit_config_schema_takes_priority_over_tool_advertisement(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    ToolRegistry.register_value("alpha", _AlphaTool)
    monkeypatch.setattr(
        description_loader,
        "get_tool_description_override",
        lambda name: "Runtime alpha description" if name == "alpha" else None,
    )
    custom_spec = {
        "type": "function",
        "function": {
            "name": "alpha",
            "description": "Agent-specific alpha description",
            "parameters": {
                "type": "object",
                "properties": {"query": {"type": "string"}},
                "required": ["query"],
            },
        },
    }

    resolved = tool_resolver.resolve_agent_tools(
        {"agent_type": "simple", "config": {"tools": [custom_spec]}},
        engine=object(),
        model="test-model",
    )

    assert resolved.openai_specs == [custom_spec]
    assert resolved.by_name["alpha"].to_openai_function() == custom_spec


def test_invalid_tool_advertisement_falls_back_to_tool_spec() -> None:
    class _InvalidAdvertisementTool(_AlphaTool):
        def to_openai_function(self) -> dict[str, object]:
            raise RuntimeError("broken advertisement")

    ToolRegistry.register_value("alpha", _InvalidAdvertisementTool)

    resolved = tool_resolver.resolve_agent_tools(
        {"agent_type": "simple", "config": {"tools": ["alpha"]}},
        engine=object(),
        model="test-model",
    )

    assert resolved.openai_specs == [
        {
            "type": "function",
            "function": {
                "name": "alpha",
                "description": "Alpha test tool",
                "parameters": {},
            },
        }
    ]


def test_mcp_tools_merge_after_native_tools_without_name_collisions() -> None:
    ToolRegistry.register_value("shared", _NativeSharedTool)
    mcp_shared = _MCPSharedTool()
    mcp_only = _MCPOnlyTool()
    client = object()

    resolved = tool_resolver.resolve_agent_tools(
        {
            "agent_type": "simple",
            "config": {"tools": ["shared", "shared"]},
        },
        engine=object(),
        model="test-model",
        mcp_tools=[mcp_shared, mcp_only, mcp_only],
        mcp_clients=[client],
    )

    assert [tool.spec.name for tool in resolved.instances] == ["shared", "mcp_only"]
    assert isinstance(resolved.by_name["shared"], _NativeSharedTool)
    assert resolved.by_name["mcp_only"] is mcp_only
    assert resolved.mcp_clients == [client]
    assert [spec["function"]["name"] for spec in resolved.openai_specs] == [
        "shared",
        "mcp_only",
    ]


def test_mcp_tools_can_be_disabled_per_agent() -> None:
    ToolRegistry.register_value("shared", _NativeSharedTool)

    class _MustNotIterate:
        def __iter__(self):
            raise AssertionError("MCP tools must not be inspected after opt-out")

    resolved = tool_resolver.resolve_agent_tools(
        {
            "agent_type": "simple",
            "config": {"tools": ["shared"], "mcp_tools": False},
        },
        engine=object(),
        model="test-model",
        mcp_tools=_MustNotIterate(),
        mcp_clients=_MustNotIterate(),
    )

    assert [tool.spec.name for tool in resolved.instances] == ["shared"]
    assert resolved.mcp_clients == []