Skip to content

Your lightweight open-source personal agent.

25.9 KB
Raw Blame
import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch

import pytest

from nanobot.agent.context import TranscriptInput
from nanobot.agent.memory import Consolidator
from nanobot.agent.runner import AgentRunResult
from nanobot.agent.tools.context import RequestContext
from nanobot.agent.tools.registry import is_tool_error_result
from nanobot.config.schema import AgentDefaults
from nanobot.providers.base import GenerationSettings
from nanobot.utils.llm_runtime import LLMRuntime

_MAX_TOOL_RESULT_CHARS = AgentDefaults().max_tool_result_chars


def _runtime(provider: MagicMock, model: str = "test-model") -> LLMRuntime:
    provider.generation = GenerationSettings(temperature=0.1, max_tokens=4096)
    return LLMRuntime.capture(provider, model, context_window_tokens=128_000)


@pytest.mark.asyncio
async def test_run_inline_returns_result_without_announcement(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.bus.queue import MessageBus

    provider = MagicMock()
    manager = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    manager.runner.run = AsyncMock(return_value=AgentRunResult(
        messages=[],
        stop_reason="done",
        final_content="review result",
        error=None,
        tool_events=[],
    ))
    manager._announce_result = AsyncMock()

    result = await manager.run_inline(
        task="review this",
        session_key="test:c1",
        runtime=_runtime(provider),
    )

    assert result == "review result"
    manager._announce_result.assert_not_awaited()
    assert manager._running_tasks == {}
    assert [s.state for s in manager.statuses_for_session("test:c1").values()] == ["done"]


@pytest.mark.asyncio
async def test_run_inline_returns_structured_error(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.agent.tools.registry import is_tool_error_result
    from nanobot.bus.queue import MessageBus

    manager = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    manager.runner.run = AsyncMock(return_value=AgentRunResult(
        messages=[],
        stop_reason="error",
        final_content=None,
        error="subagent failed",
        tool_events=[],
    ))

    result = await manager.run_inline(
        task="review this",
        session_key="test:c1",
        runtime=_runtime(MagicMock()),
    )

    assert result == "subagent failed"
    assert is_tool_error_result(result)
    assert manager._running_tasks == {}
    assert [s.state for s in manager.statuses_for_session("test:c1").values()] == ["error"]


@pytest.mark.asyncio
async def test_subagent_exec_tool_receives_allowed_env_keys(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.agent.tools.shell import ExecToolConfig
    from nanobot.bus.queue import MessageBus
    from nanobot.config.schema import ToolsConfig

    bus = MessageBus()
    provider = MagicMock()
    provider.get_default_model.return_value = "test-model"
    mgr = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=bus,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        tools_config=ToolsConfig(exec=ExecToolConfig(allowed_env_keys=["GOPATH", "JAVA_HOME"])),
    )
    mgr._announce_result = AsyncMock()

    mgr.runner.run = AsyncMock(return_value=AgentRunResult(
        messages=[],
        stop_reason="done",
        final_content="done",
        error=None,
        tool_events=[],
    ))

    await mgr.spawn(
        task="do task",
        label="label",
        origin_channel="test",
        origin_chat_id="c1",
        runtime=_runtime(provider),
    )
    await asyncio.gather(*mgr._running_tasks.values(), return_exceptions=True)

    mgr.runner.run.assert_awaited_once()
    spec = mgr.runner.run.await_args.args[0]
    exec_tool = spec.tools.get("exec")
    assert exec_tool is not None
    assert exec_tool.allowed_env_keys == ["GOPATH", "JAVA_HOME"]
    assert [s.state for s in mgr.statuses_for_session("test:c1").values()] == ["done"]


@pytest.mark.asyncio
async def test_subagent_uses_configured_max_iterations(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.bus.queue import MessageBus

    bus = MessageBus()
    provider = MagicMock()
    provider.get_default_model.return_value = "test-model"
    mgr = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=bus,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        max_iterations=37,
    )
    mgr._announce_result = AsyncMock()

    mgr.runner.run = AsyncMock(return_value=AgentRunResult(
        messages=[],
        stop_reason="done",
        final_content="done",
        error=None,
        tool_events=[],
    ))

    await mgr.spawn(
        task="do task",
        label="label",
        origin_channel="test",
        origin_chat_id="c1",
        runtime=_runtime(provider),
    )
    await asyncio.gather(*mgr._running_tasks.values(), return_exceptions=True)

    mgr.runner.run.assert_awaited_once()
    spec = mgr.runner.run.await_args.args[0]
    assert spec.max_iterations == 37
    assert [s.state for s in mgr.statuses_for_session("test:c1").values()] == ["done"]


@pytest.mark.asyncio
async def test_subagent_checkpoint_updates_status_and_preserves_omitted_fields(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.bus.queue import MessageBus

    mgr = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    mgr._announce_result = AsyncMock()
    snapshots = []

    async def fake_run(spec):
        for payload in [
            {"phase": "awaiting_tools", "iteration": 2},
            {"phase": "tools_completed", "iteration": 3},
            {"iteration": 4},
            {"phase": "final_response"},
        ]:
            await spec.checkpoint_callback(payload)
            snapshots.extend(mgr.statuses_for_session("test:c1").values())
        return AgentRunResult(
            messages=[],
            stop_reason="done",
            final_content="done",
            error=None,
            tool_events=[],
        )

    mgr.runner.run = AsyncMock(side_effect=fake_run)

    await mgr.spawn(task="do task", session_key="test:c1", runtime=_runtime(MagicMock()))
    await asyncio.gather(*mgr._running_tasks.values(), return_exceptions=True)

    assert [(s.state, s.phase, s.iteration) for s in snapshots] == [
        ("running", "awaiting_tools", 2),
        ("running", "tools_completed", 3),
        ("running", "tools_completed", 4),
        ("running", "final_response", 4),
    ]
    assert [s.state for s in mgr.statuses_for_session("test:c1").values()] == ["done"]


@pytest.mark.asyncio
async def test_spawn_forwards_temperature_to_run_spec(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.bus.queue import MessageBus

    bus = MessageBus()
    provider = MagicMock()
    provider.get_default_model.return_value = "test-model"
    mgr = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=bus,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    mgr._announce_result = AsyncMock()

    parent_runtime = _runtime(provider)
    seen = {}

    async def fake_run(spec):
        seen["temperature"] = spec.runtime.generation.temperature
        seen["runtime"] = spec.runtime
        return AgentRunResult(
            messages=[],
            stop_reason="done", final_content="done", error=None, tool_events=[],
        )

    mgr.runner.run = AsyncMock(side_effect=fake_run)

    await mgr.spawn(task="do task", runtime=parent_runtime, temperature=0.9)
    await asyncio.gather(*mgr._running_tasks.values(), return_exceptions=True)

    assert seen["temperature"] == 0.9
    assert seen["runtime"] is not parent_runtime
    assert parent_runtime.generation.temperature == 0.1


@pytest.mark.asyncio
async def test_background_spawn_waits_for_concurrency_capacity(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.agent.tools.subagent import SubagentTool
    from nanobot.bus.queue import MessageBus

    bus = MessageBus()
    provider = MagicMock()
    provider.get_default_model.return_value = "test-model"
    mgr = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=bus,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        max_concurrent_subagents=1,
    )
    mgr._announce_result = AsyncMock()

    first_entered = asyncio.Event()
    second_entered = asyncio.Event()
    release_first = asyncio.Event()
    release_second = asyncio.Event()

    async def fake_run(spec):
        task = spec.initial_messages[-1]["content"]
        if task == "first task":
            first_entered.set()
            await release_first.wait()
        else:
            second_entered.set()
            await release_second.wait()
        return AgentRunResult(
            messages=[],
            stop_reason="done",
            final_content="done",
            error=None,
            tool_events=[],
        )

    mgr.runner.run = AsyncMock(side_effect=fake_run)

    from nanobot.agent.tools.context import RequestContext, request_context

    tool = SubagentTool(mgr)
    with request_context(RequestContext(
        channel="test",
        chat_id="c1",
        session_key="test:c1",
        runtime=_runtime(provider),
    )):
        first_result = await tool.execute(action="create", task="first task")
        assert "started" in first_result
        await asyncio.wait_for(first_entered.wait(), timeout=1.0)

        second_result = await tool.execute(action="create", task="second task")
        assert "started" in second_result
        tasks = list(mgr._running_tasks.values())
        await asyncio.sleep(0)
        assert not second_entered.is_set()
        phases = {status.task_description: status.phase for status in mgr.runtime_statuses().values()}
        assert phases == {"first task": "initializing", "second task": "queued"}

    release_first.set()
    await asyncio.wait_for(second_entered.wait(), timeout=1.0)
    release_second.set()
    await asyncio.gather(*tasks, return_exceptions=True)
    await asyncio.sleep(0)
    assert mgr._running_tasks == {}


@pytest.mark.asyncio
async def test_subagent_tool_waits_for_inline_result():
    from nanobot.agent.tools.context import RequestContext, request_context
    from nanobot.agent.tools.subagent import SubagentTool

    class Manager:
        max_concurrent_subagents = 1

        def __init__(self):
            self.inline = AsyncMock(return_value="review result")
            self.spawn = AsyncMock(return_value="started")

        def get_running_count(self):
            return 0

        async def run_inline(self, **kwargs):
            return await self.inline(**kwargs)

    manager = Manager()
    tool = SubagentTool(manager)
    runtime = _runtime(MagicMock())
    with request_context(RequestContext(
        channel="test",
        chat_id="c1",
        session_key="test:c1",
        runtime=runtime,
    )):
        result = await tool.execute(action="create", task="review this", wait=True)

    assert result == "review result"
    manager.inline.assert_awaited_once()
    manager.spawn.assert_not_awaited()


@pytest.mark.asyncio
async def test_inline_spawn_waits_for_concurrency_capacity(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.agent.tools.context import RequestContext, request_context
    from nanobot.agent.tools.subagent import SubagentTool
    from nanobot.bus.queue import MessageBus

    manager = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        max_concurrent_subagents=1,
    )
    first_entered = asyncio.Event()
    second_entered = asyncio.Event()
    release_first = asyncio.Event()
    release_second = asyncio.Event()

    async def fake_run(spec):
        task = spec.initial_messages[-1]["content"]
        if task == "first":
            first_entered.set()
            await release_first.wait()
        else:
            second_entered.set()
            await release_second.wait()
        return AgentRunResult(
            messages=[],
            stop_reason="done",
            final_content="done",
            error=None,
            tool_events=[],
        )

    manager.runner.run = AsyncMock(side_effect=fake_run)
    tool = SubagentTool(manager)
    with request_context(RequestContext(
        channel="test",
        chat_id="c1",
        session_key="test:c1",
        runtime=_runtime(MagicMock()),
    )):
        first = asyncio.create_task(tool.execute(action="create", task="first", wait=True))
        await asyncio.wait_for(first_entered.wait(), timeout=1.0)

        second = asyncio.create_task(tool.execute(action="create", task="second", wait=True))
        await asyncio.sleep(0)

        assert not second.done()
        assert not second_entered.is_set()
        assert manager.get_running_count() == 2
        release_first.set()
        assert await first == "done"
        await asyncio.wait_for(second_entered.wait(), timeout=1.0)
        release_second.set()
        assert await second == "done"

    assert manager.get_running_count() == 0
    assert [s.state for s in manager.statuses_for_session("test:c1").values()] == ["done", "done"]


@pytest.mark.asyncio
async def test_runner_executes_inline_spawn_batch_concurrently(tmp_path):
    from nanobot.agent.hook import AgentHook, AgentHookContext
    from nanobot.agent.subagent import SubagentManager
    from nanobot.agent.tools.context import RequestContext, request_context
    from nanobot.agent.tools.execution import execute_tool_calls
    from nanobot.agent.tools.registry import ToolRegistry
    from nanobot.agent.tools.subagent import SubagentTool
    from nanobot.bus.queue import MessageBus
    from nanobot.providers.base import ToolCallRequest

    manager = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        max_concurrent_subagents=2,
    )
    both_entered = asyncio.Event()
    release = asyncio.Event()
    entered: list[str] = []

    async def fake_run(spec):
        entered.append(spec.initial_messages[-1]["content"])
        if len(entered) == 2:
            both_entered.set()
        await release.wait()
        return AgentRunResult(
            messages=[],
            stop_reason="done",
            final_content=spec.initial_messages[-1]["content"],
            error=None,
            tool_events=[],
        )

    manager.runner.run = AsyncMock(side_effect=fake_run)
    tools = ToolRegistry()
    tools.register(SubagentTool(manager))
    runtime = _runtime(MagicMock())
    calls = [
        ToolCallRequest(
            id="create-1",
            name="subagent",
            arguments={"action": "create", "task": "first", "wait": True},
        ),
        ToolCallRequest(
            id="create-2",
            name="subagent",
            arguments={"action": "create", "task": "second", "wait": True},
        ),
    ]

    settled = []
    with request_context(RequestContext(
        channel="test",
        chat_id="c1",
        session_key="test:c1",
        runtime=runtime,
    )):
        execution = asyncio.create_task(execute_tool_calls(
            tools,
            calls,
            concurrent=True,
            external_lookup_counts={},
            workspace_violation_counts={},
            hook=AgentHook(),
            context=AgentHookContext(iteration=0, messages=[], session_key="test:c1"),
            on_settled=AsyncMock(side_effect=settled.extend),
        ))
        await asyncio.wait_for(both_entered.wait(), timeout=1.0)
        release.set()
        await execution

    assert set(entered) == {"first", "second"}
    assert [completed.result for completed in settled] == ["first", "second"]
    assert [completed.event["status"] for completed in settled] == ["ok", "ok"]
    assert manager._running_tasks == {}


@pytest.mark.asyncio
async def test_cancel_by_session_cancels_inline_subagent(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.bus.queue import MessageBus

    manager = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=MessageBus(),
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    entered = asyncio.Event()

    async def fake_run(spec):
        entered.set()
        await asyncio.Event().wait()

    manager.runner.run = AsyncMock(side_effect=fake_run)
    inline = asyncio.create_task(manager.run_inline(
        task="wait",
        session_key="test:c1",
        runtime=_runtime(MagicMock()),
    ))
    await asyncio.wait_for(entered.wait(), timeout=1.0)

    assert await manager.cancel_by_session("test:c1") == 1
    result = await inline
    assert is_tool_error_result(result)
    assert result == "Task cancelled."
    assert manager._running_tasks == {}
    assert [s.state for s in manager.statuses_for_session("test:c1").values()] == ["cancelled"]


def test_subagent_default_max_concurrent_matches_agent_defaults(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.bus.queue import MessageBus

    bus = MessageBus()
    mgr = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=bus,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )

    assert AgentDefaults().max_concurrent_subagents == 4
    assert mgr.max_concurrent_subagents == AgentDefaults().max_concurrent_subagents


def test_subagent_default_max_iterations_matches_agent_defaults(tmp_path):
    from nanobot.agent.subagent import SubagentManager
    from nanobot.bus.queue import MessageBus

    bus = MessageBus()
    mgr = SubagentManager(
        consolidator=MagicMock(spec=Consolidator),
        workspace=tmp_path,
        bus=bus,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )

    assert mgr.max_iterations == AgentDefaults().max_tool_iterations


def test_agent_loop_passes_max_iterations_to_subagents(tmp_path):
    from nanobot.agent.loop import AgentLoop
    from nanobot.bus.queue import MessageBus

    bus = MessageBus()
    provider = MagicMock()
    provider.get_default_model.return_value = "test-model"

    loop = AgentLoop(
        bus=bus,
        provider=provider,
        workspace=tmp_path,
        model="test-model",
        max_iterations=42,
    )

    assert loop.subagents.max_iterations == 42


@pytest.mark.asyncio
async def test_agent_loop_syncs_updated_max_iterations_before_run(tmp_path):
    from nanobot.agent.loop import AgentLoop
    from nanobot.bus.queue import MessageBus

    bus = MessageBus()
    provider = MagicMock()
    provider.get_default_model.return_value = "test-model"

    loop = AgentLoop(
        bus=bus,
        provider=provider,
        workspace=tmp_path,
        model="test-model",
        max_iterations=42,
    )
    loop.tools.get_definitions = MagicMock(return_value=[])

    async def fake_run(spec):
        assert spec.max_iterations == 55
        assert loop.subagents.max_iterations == 55
        return AgentRunResult(
            messages=[],
            stop_reason="done",
            final_content="done",
            error=None,
            tool_events=[],
            had_injections=False,
            tools_used=[],
        )

    loop.runner.run = AsyncMock(side_effect=fake_run)
    loop.max_iterations = 55

    await loop._run_agent_loop(
        TranscriptInput(history=[], current_message=None),
        runtime=loop.llm_runtime(),
    )

    loop.runner.run.assert_awaited_once()


@pytest.mark.asyncio
async def test_drain_pending_no_block_when_no_subagents(tmp_path):
    from nanobot.agent.loop import AgentLoop
    from nanobot.bus.queue import MessageBus

    bus = MessageBus()
    provider = MagicMock()
    provider.get_default_model.return_value = "test-model"

    loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="test-model")

    pending_queue: asyncio.Queue = asyncio.Queue()
    injection_callback = None
    terminal_injection_callback = None

    async def fake_runner_run(spec):
        nonlocal injection_callback, terminal_injection_callback
        injection_callback = spec.injection_callback
        terminal_injection_callback = spec.terminal_injection_callback
        return AgentRunResult(
            messages=[],
            stop_reason="done",
            final_content="done",
            error=None,
            tool_events=[],
            had_injections=False,
            tools_used=[],
            provider_state=None,
        )

    loop.runner.run = AsyncMock(side_effect=fake_runner_run)

    runtime = loop.llm_runtime()
    await loop._run_agent_loop(
        TranscriptInput(history=[{"role": "user", "content": "test"}], current_message=None),
        runtime=runtime,
        session=None,
        request_context=RequestContext(channel="test", chat_id="c1", runtime=runtime),
        pending_queue=pending_queue,
    )

    assert injection_callback is not None
    assert terminal_injection_callback is not None

    assert await asyncio.wait_for(injection_callback(), timeout=1.0) == []
    assert await asyncio.wait_for(terminal_injection_callback(), timeout=1.0) == []


@pytest.mark.asyncio
async def test_terminal_drain_timeout(tmp_path):
    from nanobot.agent.loop import AgentLoop
    from nanobot.bus.queue import MessageBus
    from nanobot.session.manager import Session

    bus = MessageBus()
    provider = MagicMock()
    provider.get_default_model.return_value = "test-model"

    loop = AgentLoop(bus=bus, provider=provider, workspace=tmp_path, model="test-model")

    pending_queue: asyncio.Queue = asyncio.Queue()
    session = Session(key="test:drain-timeout")
    terminal_injection_callback = None

    async def fake_runner_run(spec):
        nonlocal terminal_injection_callback
        terminal_injection_callback = spec.terminal_injection_callback
        return AgentRunResult(
            messages=[],
            stop_reason="done",
            final_content="done",
            error=None,
            tool_events=[],
            had_injections=False,
            tools_used=[],
            provider_state=None,
        )

    loop.runner.run = AsyncMock(side_effect=fake_runner_run)

    async def _hang_forever(spec):
        await asyncio.Event().wait()

    loop.subagents.runner.run = _hang_forever
    await loop.subagents.spawn("pending", runtime=loop.llm_runtime(), session_key=session.key)

    runtime = loop.llm_runtime()
    await loop._run_agent_loop(
        TranscriptInput(history=[{"role": "user", "content": "test"}], current_message=None),
        runtime=runtime,
        session=session,
        request_context=RequestContext(
            channel="test",
            chat_id="c1",
            session_key=session.key,
            runtime=runtime,
        ),
        pending_queue=pending_queue,
    )

    assert terminal_injection_callback is not None

    async def _timeout(awaitable, timeout):
        awaitable.close()
        raise asyncio.TimeoutError

    with patch("nanobot.agent.loop.asyncio.wait_for", side_effect=_timeout):
        results = await terminal_injection_callback()
        assert results == []

    await loop.subagents.close()


@pytest.mark.asyncio
async def test_terminal_drain_reuses_one_timeout_budget(tmp_path):
    from nanobot.agent.loop import AgentLoop
    from nanobot.bus.events import InboundMessage
    from nanobot.bus.queue import MessageBus
    from nanobot.session.manager import Session

    loop = AgentLoop(
        bus=MessageBus(),
        provider=MagicMock(),
        workspace=tmp_path,
        model="test-model",
    )
    pending_queue: asyncio.Queue[InboundMessage] = asyncio.Queue()
    session = Session(key="test:shared-deadline")
    terminal_injection_callback = None

    async def fake_runner_run(spec):
        nonlocal terminal_injection_callback
        terminal_injection_callback = spec.terminal_injection_callback
        return AgentRunResult(
            messages=[],
            stop_reason="done",
            final_content="done",
            error=None,
            tool_events=[],
            had_injections=False,
            tools_used=[],
            provider_state=None,
        )

    loop.runner.run = AsyncMock(side_effect=fake_runner_run)

    async def _hang_forever(spec):
        await asyncio.Event().wait()

    loop.subagents.runner.run = _hang_forever
    await loop.subagents.spawn("pending", runtime=loop.llm_runtime(), session_key=session.key)

    await loop._run_agent_loop(
        TranscriptInput(history=[{"role": "user", "content": "test"}], current_message=None),
        runtime=loop.llm_runtime(),
        session=session,
        pending_queue=pending_queue,
    )
    assert terminal_injection_callback is not None

    timeouts: list[float] = []
    clock = MagicMock(side_effect=[10.0, 110.0])

    async def _deliver(awaitable, timeout):
        awaitable.close()
        timeouts.append(timeout)
        return InboundMessage(
            sender_id="subagent",
            channel="test",
            chat_id="c1",
            content="result",
        )

    loop.tools.get_runtime_context_providers = MagicMock(return_value=[])
    fake_loop = MagicMock(wraps=asyncio.get_running_loop())
    fake_loop.time = clock
    loop_asyncio = SimpleNamespace(**vars(asyncio))
    loop_asyncio.get_running_loop = lambda: fake_loop
    loop_asyncio.wait_for = _deliver
    with patch("nanobot.agent.loop.asyncio", loop_asyncio):
        assert await terminal_injection_callback()
        assert await terminal_injection_callback()

    assert timeouts == [300.0, 200.0]

    await loop.subagents.close()