Skip to content

Your lightweight open-source personal agent.

11.8 KB
Raw Blame
import asyncio
from pathlib import Path
from unittest.mock import AsyncMock, MagicMock

import pytest

from nanobot.agent.memory import Consolidator
from nanobot.agent.runner import AgentRunResult
from nanobot.agent.subagent import SubagentManager
from nanobot.agent.tools.cli_apps import CliAppsTool
from nanobot.agent.tools.cli_apps_config import CliAppsToolConfig
from nanobot.agent.tools.filesystem import FileToolsConfig
from nanobot.bus.queue import MessageBus
from nanobot.config.schema import ToolsConfig
from nanobot.llm_usage.context import llm_usage_source
from nanobot.providers.base import GenerationSettings, LLMProvider, LLMResponse, ToolCallRequest
from nanobot.security.workspace_access import build_workspace_scope
from nanobot.utils.llm_runtime import LLMRuntime


def _runtime(provider: LLMProvider) -> LLMRuntime:
    provider.generation = GenerationSettings()
    return LLMRuntime.capture(provider, "test", context_window_tokens=128_000)


@pytest.mark.asyncio
async def test_subagent_uses_tool_loader():
    provider = MagicMock(spec=LLMProvider)
    provider.get_default_model.return_value = "test"
    sm = SubagentManager(
        workspace=Path("/tmp"),
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=MagicMock(spec=Consolidator),
    )
    tools = sm._build_tools()
    assert tools.has("read_file")
    assert tools.has("write_file")
    assert not tools.has("message")
    assert not tools.has("spawn")
    assert not tools.has("subagent")
    assert not tools.has("send_session_message")
    assert not tools.has("read_session")
    assert not tools.has("my")


@pytest.mark.asyncio
async def test_subagent_build_tools_isolates_file_read_state(tmp_path):
    (tmp_path / "note.txt").write_text("hello\n", encoding="utf-8")
    provider = MagicMock(spec=LLMProvider)
    provider.get_default_model.return_value = "test"
    sm = SubagentManager(
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=MagicMock(spec=Consolidator),
    )

    first_read = sm._build_tools().get("read_file")
    second_read = sm._build_tools().get("read_file")

    assert first_read is not second_read
    assert (await first_read.execute(path="note.txt")).startswith("1| hello")
    second_result = await second_read.execute(path="note.txt")
    assert second_result.startswith("1| hello")
    assert "File unchanged" not in second_result


def test_subagent_respects_file_tool_toggle(tmp_path):
    provider = MagicMock(spec=LLMProvider)
    provider.get_default_model.return_value = "test"
    sm = SubagentManager(
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=MagicMock(spec=Consolidator),
        tools_config=ToolsConfig(file=FileToolsConfig(enable=False)),
    )

    tools = sm._build_tools()

    file_tools = {
        "apply_patch",
        "edit_file",
        "find_files",
        "grep",
        "list_dir",
        "read_file",
        "write_file",
    }
    assert file_tools.isdisjoint(tools.tool_names)


@pytest.mark.asyncio
@pytest.mark.parametrize("project_scoped", [False, True])
async def test_subagent_respects_disabled_cli_apps_in_model_tools(tmp_path, project_scoped, monkeypatch):
    monkeypatch.setattr("nanobot.apps.cli.service.get_runtime_subdir", lambda name: tmp_path / name)
    provider = MagicMock(spec=LLMProvider)
    provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(content="done"))
    manager = SubagentManager(
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=MagicMock(spec=Consolidator),
        tools_config=ToolsConfig(cli_apps=CliAppsToolConfig(enable=False)),
    )
    scope = build_workspace_scope(tmp_path, "restricted") if project_scoped else None

    result = await manager.run_inline(
        task="inspect the workspace",
        session_key="test:direct",
        runtime=_runtime(provider),
        workspace_scope=scope,
    )

    assert result == "done"
    definitions = provider.chat_stream_with_retry.await_args.kwargs["tools"]
    tool_names = {definition["function"]["name"] for definition in definitions}
    assert "read_file" in tool_names
    assert "run_cli_app" not in tool_names


def test_subagent_inherits_cli_app_runtime_settings(tmp_path):
    manager = SubagentManager(
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=MagicMock(spec=Consolidator),
        tools_config=ToolsConfig(cli_apps=CliAppsToolConfig(run_timeout=17)),
    )

    tool = manager._build_tools().get("run_cli_app")

    assert isinstance(tool, CliAppsTool)
    assert tool.runtime.run_timeout == 17


def test_subagent_prompt_keeps_agent_paths_for_selected_project(tmp_path):
    agent_workspace = tmp_path / "agent"
    project = tmp_path / "project"
    global_skill = agent_workspace / "skills" / "global-custom" / "SKILL.md"
    project_skill = project / "skills" / "project-custom" / "SKILL.md"
    global_skill.parent.mkdir(parents=True)
    project_skill.parent.mkdir(parents=True)
    global_skill.write_text("---\ndescription: global skill\n---\nGlobal", encoding="utf-8")
    project_skill.write_text("---\ndescription: project skill\n---\nProject", encoding="utf-8")
    manager = SubagentManager(
        workspace=agent_workspace,
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=MagicMock(spec=Consolidator),
    )

    prompt = manager._build_subagent_prompt(workspace=project)

    assert "one root and relative SKILL.md paths" in prompt
    assert "Join them when using `read_file`" in prompt
    assert str(project.resolve()) not in prompt
    assert f"Nanobot's agent workspace: {agent_workspace.resolve()}" in prompt
    assert f"History log: {agent_workspace.resolve() / 'memory' / 'history.jsonl'}" in prompt
    assert "global-custom" in prompt
    assert "project-custom" not in prompt


def test_subagent_prompt_uses_relative_paths_in_agent_workspace(tmp_path):
    skill = tmp_path / "skills" / "custom" / "SKILL.md"
    skill.parent.mkdir(parents=True)
    skill.write_text("---\ndescription: custom skill\n---\nCustom", encoding="utf-8")
    manager = SubagentManager(
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=MagicMock(spec=Consolidator),
    )

    prompt = manager._build_subagent_prompt()

    assert str(tmp_path.resolve()) not in prompt
    assert "History log: memory/history.jsonl" in prompt
    assert "### Workspace skills (`skills`)" in prompt


@pytest.mark.asyncio
async def test_subagent_keeps_project_runtime_scope_with_agent_owned_tools(tmp_path):
    agent_workspace = tmp_path / "agent"
    project = tmp_path / "project"
    agent_workspace.mkdir()
    project.mkdir()
    provider = MagicMock(spec=LLMProvider)
    provider.get_default_model.return_value = "test"
    manager = SubagentManager(
        workspace=agent_workspace,
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=MagicMock(spec=Consolidator),
    )
    manager.runner.run = AsyncMock(
        return_value=AgentRunResult(final_content="ok", messages=[], stop_reason="completed")
    )
    manager._announce_result = AsyncMock()

    await manager.spawn(
        task="task",
        label="label",
        origin_channel="websocket",
        origin_chat_id="direct",
        runtime=_runtime(provider),
        workspace_scope=build_workspace_scope(project, "restricted"),
    )
    await asyncio.gather(*manager._running_tasks.values(), return_exceptions=True)

    spec = manager.runner.run.call_args.args[0]
    assert spec.workspace == project
    assert spec.tools.get("read_file")._workspace == agent_workspace.resolve()
    assert spec.tools.get("read_file")._restrict_to_workspace is True
    assert manager.tools_config.restrict_to_workspace is False


@pytest.mark.asyncio
async def test_subagent_recovers_from_tool_error_in_same_run(tmp_path):
    provider = MagicMock(spec=LLMProvider)
    provider.get_default_model.return_value = "test"
    provider.chat_stream_with_retry = AsyncMock(side_effect=[
        LLMResponse(
            content="reading",
            tool_calls=[
                ToolCallRequest(
                    id="call_1",
                    name="read_file",
                    arguments={"path": "missing.txt"},
                )
            ],
        ),
        LLMResponse(content="recovered without restarting", tool_calls=[]),
    ])
    sm = SubagentManager(
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=MagicMock(),
    )

    result = await sm.run_inline(
        task="recover after a missing file",
        session_key="test:direct",
        runtime=_runtime(provider),
    )

    assert result == "recovered without restarting"
    assert provider.chat_stream_with_retry.await_count == 2


@pytest.mark.asyncio
async def test_subagent_pressure_uses_transient_summary(tmp_path):
    provider = MagicMock(spec=LLMProvider)
    provider.get_default_model.return_value = "test"
    provider.can_resume_conversation_state.return_value = False
    provider.generation = GenerationSettings(max_tokens=100)

    def estimate(messages, _tools, _model):
        if sum(message.get("role") == "tool" for message in messages) >= 2:
            return 600, "test-counter"
        return 100, "test-counter"

    provider.estimate_prompt_tokens = MagicMock(side_effect=estimate)
    provider.chat_stream_with_retry = AsyncMock(side_effect=[
        LLMResponse(
            content="checking",
            tool_calls=[ToolCallRequest(
                id="call-1",
                name="list_dir",
                arguments={"path": "."},
            )],
        ),
        LLMResponse(
            content="checking again",
            tool_calls=[ToolCallRequest(
                id="call-2",
                name="list_dir",
                arguments={"path": "."},
            )],
        ),
        LLMResponse(content="done", tool_calls=[]),
    ])
    consolidator = MagicMock()
    consolidator.summarize_transcript = AsyncMock(return_value="Subagent checkpoint.")
    consolidator.summarize_provider_compaction = AsyncMock(return_value=None)
    manager = SubagentManager(
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=consolidator,
    )
    runtime = LLMRuntime.capture(
        provider,
        "test",
        context_window_tokens=1_624,
    )

    result = await manager.run_inline(
        task="inspect the workspace",
        session_key="test:direct",
        runtime=runtime,
    )

    assert result == "done"
    consolidator.summarize_transcript.assert_awaited_once()
    assert consolidator.summarize_transcript.await_args.kwargs["persist"] is False
    model_request = provider.chat_stream_with_retry.await_args_list[2].kwargs["messages"]
    assert "Subagent checkpoint." in model_request[0]["content"]
    assert sum(message.get("role") == "tool" for message in model_request) == 1


@pytest.mark.asyncio
async def test_spawned_subagent_inherits_llm_usage_source(tmp_path):
    provider = MagicMock(spec=LLMProvider)
    provider.get_default_model.return_value = "test"
    sm = SubagentManager(
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=16_000,
        consolidator=MagicMock(spec=Consolidator),
    )
    sm.runner.run = AsyncMock(
        return_value=AgentRunResult(final_content="ok", messages=[], stop_reason="completed")
    )
    sm._announce_result = AsyncMock()

    with llm_usage_source("cron"):
        await sm.spawn(
            "automation task",
            session_key="websocket:bound-automation",
            runtime=_runtime(provider),
        )
    tasks = list(sm._running_tasks.values())
    await asyncio.gather(*tasks)

    spec = sm.runner.run.call_args.args[0]
    assert spec.llm_usage_source == "cron"