Skip to content

Your lightweight open-source personal agent.

69.0 KB
Raw Blame
from __future__ import annotations

import asyncio
from unittest.mock import AsyncMock, MagicMock

import pytest
import tiktoken

from agent.runner_helpers import make_run_spec
from nanobot.agent.context import TranscriptInput
from nanobot.agent.context_governance import (
    BACKFILL_CONTENT,
    ContextCompactionState,
    ContextGovernanceConfig,
    ContextGovernor,
    ContextWindowExceededError,
    ModelRequestState,
    _request_extends_measured,
)
from nanobot.agent.runner import AgentRunner, AgentRunSpec
from nanobot.config.schema import AgentDefaults, ModelPresetConfig
from nanobot.events import ContextCompactionEvent, EventSink
from nanobot.providers.base import (
    GenerationSettings,
    LLMProvider,
    LLMResponse,
    LLMUsage,
    ProviderConversationState,
    ToolCallRequest,
)
from nanobot.providers.conversation_state import ProviderConversationStateController
from nanobot.providers.fallback_provider import FallbackProvider
from nanobot.runtime_context import public_history_message
from nanobot.session.summary import SUMMARY_CONTINUATION_TEXT

_MAX_TOOL_RESULT_CHARS = AgentDefaults().max_tool_result_chars


def _build_transcript(transcript: TranscriptInput) -> list[dict]:
    system = (
        transcript.session_summary["text"]
        if transcript.session_summary is not None
        else "system"
    )
    messages = [{"role": "system", "content": system}, *transcript.history]
    if transcript.current_message is not None:
        messages.append({"role": transcript.current_role, "content": transcript.current_message})
    return messages


def _governance_config(
    provider,
    tools,
    spec: AgentRunSpec,
) -> ContextGovernanceConfig:
    return ContextGovernanceConfig(
        provider=provider,
        model=spec.runtime.model,
        tools=tools,
        workspace=spec.workspace,
        session_key=spec.session_key,
        max_tool_result_chars=spec.max_tool_result_chars,
        context_window_tokens=spec.runtime.context_window_tokens,
        max_tokens=spec.runtime.generation.max_tokens,
    )


def _compaction_state(spec: AgentRunSpec) -> ContextCompactionState:
    assert spec.initial_messages is not None
    return ContextCompactionState.from_messages(
        spec.initial_messages,
        spec.consolidate_history,
        spec.consolidate_provider_compaction,
    )


async def test_provider_can_emit_without_an_event_specific_runner_callback():
    from nanobot.events import AgentEvent

    event = AgentEvent()
    received = []

    async def observe(value):
        received.append(value)

    async def request(*, provider_context, **kwargs):
        await provider_context.events.emit(event)
        return LLMResponse(content="done")

    provider = MagicMock(spec=LLMProvider)
    provider.chat_stream_with_retry = request
    tools = MagicMock()
    tools.get_definitions.return_value = []
    await AgentRunner().run(make_run_spec(
        provider, model="test-model", tools=tools, max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        initial_messages=[{"role": "user", "content": "hello"}],
        events=EventSink(observe),
    ))
    assert received.count(event) == 1


async def test_runner_propagates_context_governance_failure():
    from nanobot.agent.runner import AgentRunner

    provider = MagicMock()
    provider.chat_stream_with_retry = AsyncMock()
    tools = MagicMock()
    tools.get_definitions.return_value = []
    initial_messages = [
        {"role": "system", "content": "system"},
        {"role": "user", "content": "hello"},
    ]

    runner = AgentRunner()
    runner.context_governor.prepare_for_model = MagicMock(  # type: ignore[method-assign]
        side_effect=RuntimeError("boom")
    )
    with pytest.raises(RuntimeError, match="boom"):
        await runner.run(make_run_spec(provider,
            initial_messages=initial_messages,
            tools=tools,
            model="test-model",
            max_iterations=1,
            max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        ))

    provider.chat_stream_with_retry.assert_not_awaited()


async def test_runner_summarizes_history_and_preserves_current_input(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    provider.can_resume_conversation_state.return_value = True
    prior_state = ProviderConversationState(
        kind="openai_responses",
        provider="openai:test",
        model="test-model",
        version=1,
        payload={"items": [{"type": "message", "role": "assistant"}]},
    )
    candidate_state = ProviderConversationState(
        kind="openai_responses",
        provider="openai:test",
        model="test-model",
        version=1,
        payload={"items": [{"type": "message", "role": "assistant", "fresh": True}]},
    )
    requests: list[tuple[list[dict], object]] = []

    async def request(*, messages, provider_context, **_kwargs):
        requests.append((messages, provider_context))
        return LLMResponse(content="done", provider_state=candidate_state)

    provider.chat_stream_with_retry = request
    tools = MagicMock()
    tools.get_definitions.return_value = []
    old_answer = "old answer " * 2_000
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        lambda _provider, _model, messages, _tools: (
            (600, "test-counter")
            if any(message.get("content") == old_answer for message in messages)
            else (100, "test-counter")
        ),
    )
    consolidate = AsyncMock(return_value="fresh checkpoint")
    previous = {"text": "existing checkpoint", "last_active": "2026-08-30T00:00:00"}

    result = await AgentRunner().run(make_run_spec(
        provider,
        initial_messages=None,
        transcript_input=TranscriptInput(
            history=[
                {"role": "user", "content": "old question"},
                {"role": "assistant", "content": old_answer},
            ],
            current_message="continue the current task",
            session_summary=previous,
        ),
        transcript_builder=_build_transcript,
        consolidate_history=consolidate,
        provider_state=prior_state,
        tools=tools,
        model="test-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    ))

    consolidate.assert_awaited_once_with(
        [
            {"role": "system", "content": "existing checkpoint"},
            {"role": "user", "content": "old question"},
            {"role": "assistant", "content": old_answer},
        ],
        "existing checkpoint",
    )
    assert requests[0][0] == [
        {"role": "system", "content": "fresh checkpoint"},
        {"role": "user", "content": "continue the current task"},
    ]
    assert requests[0][1].conversation_state is None
    assert result.provider_state == candidate_state
    assert result.summary_checkpoint is not None
    assert result.summary_checkpoint.summary == "fresh checkpoint"
    assert result.summary_checkpoint.transcript_boundary == 3
    assert any(message.get("content") == old_answer for message in result.messages)


async def test_runner_rejects_oversized_delta_without_summarizable_history(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    provider.chat_stream_with_retry = AsyncMock()
    tools = MagicMock()
    tools.get_definitions.return_value = []
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        lambda *_args, **_kwargs: (600, "test-counter"),
    )
    consolidate = AsyncMock(return_value=None)

    with pytest.raises(ContextWindowExceededError):
        await AgentRunner().run(make_run_spec(
            provider,
            initial_messages=None,
            transcript_input=TranscriptInput(
                history=[],
                current_message="current input is the entire oversized delta",
            ),
            transcript_builder=_build_transcript,
            consolidate_history=consolidate,
            tools=tools,
            model="test-model",
            context_window_tokens=1_624,
            max_tokens=100,
            max_iterations=1,
            max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        ))

    consolidate.assert_awaited_once_with(
        [{"role": "system", "content": "system"}],
        None,
    )
    provider.chat_stream_with_retry.assert_not_awaited()


async def test_runner_governs_history_before_summarizing_it(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    provider.can_resume_conversation_state.return_value = False
    provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(content="done"))
    tools = MagicMock()
    tools.get_definitions.return_value = []
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        lambda _provider, _model, messages, _tools: (
            (100, "test-counter")
            if messages[0].get("content") == "fresh checkpoint"
            else (600, "test-counter")
        ),
    )
    consolidate = AsyncMock(return_value="fresh checkpoint")

    await AgentRunner().run(make_run_spec(
        provider,
        initial_messages=None,
        transcript_input=TranscriptInput(
            history=[
                {"role": "user", "content": "inspect"},
                {
                    "role": "assistant",
                    "content": "",
                    "tool_calls": [{
                        "id": "call-missing",
                        "type": "function",
                        "function": {"name": "inspect", "arguments": "{}"},
                    }],
                },
            ],
            current_message="continue",
        ),
        transcript_builder=_build_transcript,
        consolidate_history=consolidate,
        tools=tools,
        model="test-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    ))

    summarized = consolidate.await_args.args[0]
    assert [message["role"] for message in summarized] == [
        "system", "user", "assistant", "tool",
    ]
    assert summarized[-1]["tool_call_id"] == "call-missing"
    assert summarized[-1]["content"] == BACKFILL_CONTENT


@pytest.mark.parametrize(
    ("scope", "expected_contents", "expected_boundary"),
    [
        ("prior_context", ["system", "accepted question", "accepted answer"], 3),
        (
            "current_request",
            ["system", "accepted question", "accepted answer", "inspect the project"],
            4,
        ),
    ],
)
async def test_native_compaction_uses_provider_request_boundary(
    monkeypatch,
    scope,
    expected_contents,
    expected_boundary,
):
    provider = MagicMock(spec=LLMProvider)
    provider.can_resume_conversation_state.return_value = False
    compacted_state = ProviderConversationState(
        kind="openai_responses",
        provider="openai:test",
        model="test-model",
        version=1,
        payload={"items": [{"type": "compaction", "encrypted_content": "opaque"}]},
    )
    provider.chat_stream_with_retry = AsyncMock(side_effect=[
        LLMResponse(
            content=None,
            tool_calls=[ToolCallRequest(id="call-1", name="inspect", arguments={})],
            provider_compaction_applied=True,
            provider_compaction_state=compacted_state,
            provider_compaction_scope=scope,
            provider_compaction_event_id="native-already-reported" if scope == "prior_context" else None,
        ),
        LLMResponse(content="done"),
    ])
    tools = MagicMock()
    tools.get_definitions.return_value = []
    tools.execute = AsyncMock(return_value="complete tool result")
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        lambda *_args: (100, "test-counter"),
    )
    consolidate = AsyncMock(return_value="portable checkpoint")
    consolidate_native = AsyncMock(
        return_value="portable checkpoint"
    )
    compaction_events: list[ContextCompactionEvent] = []

    async def observe_compaction(event: ContextCompactionEvent) -> None:
        if isinstance(event, ContextCompactionEvent):
            compaction_events.append(event)

    result = await AgentRunner().run(make_run_spec(
        provider,
        initial_messages=None,
        transcript_input=TranscriptInput(
            history=[
                {"role": "user", "content": "accepted question"},
                {"role": "assistant", "content": "accepted answer"},
            ],
            current_message="inspect the project",
        ),
        transcript_builder=_build_transcript,
        consolidate_history=consolidate,
        consolidate_provider_compaction=consolidate_native,
        tools=tools,
        model="test-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=2,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        events=EventSink(observe_compaction),
    ))

    consolidate.assert_not_awaited()
    consolidate_native.assert_awaited_once()
    assert consolidate_native.await_args.args[0] == compacted_state
    assert [
        message["content"] for message in consolidate_native.await_args.args[1]
    ] == expected_contents
    assert consolidate_native.await_args.args[2] is None
    assert result.summary_checkpoint is not None
    assert result.summary_checkpoint.transcript_boundary == expected_boundary
    assert result.provider_compaction_applied is True
    assert any(message.get("content") == "inspect the project" for message in result.messages)
    assert any(message.get("content") == "complete tool result" for message in result.messages)
    assert [event.phase for event in compaction_events] == ([] if scope == "prior_context" else ["succeeded"])
    assert all(event.reason == "provider_native" for event in compaction_events)


@pytest.mark.parametrize("error", [RuntimeError("checkpoint failed"), asyncio.CancelledError()])
async def test_native_checkpoint_failure_does_not_relabel_completed_compaction(monkeypatch, error):
    provider = MagicMock(spec=LLMProvider)
    provider.can_resume_conversation_state.return_value = False
    compacted = ProviderConversationState(
        kind="openai_responses", provider="openai:test", model="test-model", version=1,
        payload={"items": [{"type": "compaction", "encrypted_content": "opaque"}]},
    )
    provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(
        content="done", provider_compaction_applied=True,
        provider_compaction_state=compacted, provider_compaction_scope="current_request",
    ))
    tools = MagicMock()
    tools.get_definitions.return_value = []
    monkeypatch.setattr("nanobot.agent.context_governance.estimate_prompt_tokens_chain", lambda *_args: (100, "test-counter"))
    notices: list[ContextCompactionEvent] = []

    async def observe(event) -> None:
        if isinstance(event, ContextCompactionEvent):
            notices.append(event)

    async def consolidate(*_args):
        assert [notice.phase for notice in notices] == ["succeeded"]
        raise error

    with pytest.raises(type(error)):
        await AgentRunner().run(make_run_spec(
            provider, initial_messages=None,
            transcript_input=TranscriptInput(history=[], current_message="question"),
            transcript_builder=_build_transcript, consolidate_provider_compaction=consolidate,
            tools=tools, model="test-model", context_window_tokens=1_624,
            max_tokens=100, max_iterations=1, max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
            events=EventSink(observe),
        ))
    assert [notice.phase for notice in notices] == ["succeeded"]
    assert all(notice.reason == "provider_native" for notice in notices)


async def test_runner_keeps_current_tool_exchange_outside_summary(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    provider.can_resume_conversation_state.return_value = False
    responses = [
        LLMResponse(
            content=None,
            tool_calls=[ToolCallRequest(id="call-1", name="inspect", arguments={})],
        ),
        LLMResponse(content="done"),
    ]
    requests: list[list[dict]] = []

    async def request(*, messages, **_kwargs):
        requests.append(messages)
        return responses.pop(0)

    provider.chat_stream_with_retry = request
    tools = MagicMock()
    tools.get_definitions.return_value = []
    full_result = "tool-result:" + ("x" * 4_000)
    tools.execute = AsyncMock(return_value=full_result)

    def estimate(_provider, _model, messages, _tools):
        has_tool_result = any(message.get("role") == "tool" for message in messages)
        has_old_system = any(
            message.get("role") == "system" and message.get("content") == "system"
            for message in messages
        )
        return (600 if has_tool_result and has_old_system else 100, "test-counter")

    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        estimate,
    )
    consolidate = AsyncMock(return_value="fresh checkpoint")

    result = await AgentRunner().run(make_run_spec(
        provider,
        initial_messages=None,
        transcript_input=TranscriptInput(history=[], current_message="inspect the project"),
        transcript_builder=_build_transcript,
        consolidate_history=consolidate,
        tools=tools,
        model="test-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=2,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    ))

    consolidate.assert_awaited_once_with(
        [
            {"role": "system", "content": "system"},
            {"role": "user", "content": "inspect the project"},
        ],
        None,
    )
    assert [message["role"] for message in requests[1]] == [
        "system", "user", "assistant", "tool",
    ]
    assert requests[1][1]["content"] == SUMMARY_CONTINUATION_TEXT
    assert requests[1][-1]["content"] == full_result
    assert result.summary_checkpoint is not None
    assert result.summary_checkpoint.transcript_boundary == 2
    assert any(message.get("content") == full_result for message in result.messages)


async def test_repeated_pressure_advances_summary_boundary(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    provider.can_resume_conversation_state.return_value = False
    provider.chat_stream_with_retry = AsyncMock(side_effect=[
        LLMResponse(
            content=None,
            tool_calls=[ToolCallRequest(id="call-1", name="inspect", arguments={})],
        ),
        LLMResponse(
            content=None,
            tool_calls=[ToolCallRequest(id="call-2", name="inspect", arguments={})],
        ),
        LLMResponse(content="done"),
    ])
    tools = MagicMock()
    tools.get_definitions.return_value = []
    tools.execute = AsyncMock(side_effect=["result-1", "result-2"])

    def estimate(_provider, _model, messages, _tools):
        system = messages[0].get("content")
        contents = {message.get("content") for message in messages}
        if "result-2" in contents:
            return (100 if system == "checkpoint-2" else 600, "test-counter")
        if "result-1" in contents:
            return (100 if system == "checkpoint-1" else 600, "test-counter")
        return 100, "test-counter"

    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        estimate,
    )
    consolidate = AsyncMock(side_effect=[
        "checkpoint-1",
        "checkpoint-2",
    ])
    compaction_events: list[ContextCompactionEvent] = []

    async def observe_compaction(event: ContextCompactionEvent) -> None:
        if isinstance(event, ContextCompactionEvent):
            compaction_events.append(event)

    result = await AgentRunner().run(make_run_spec(
        provider,
        initial_messages=None,
        transcript_input=TranscriptInput(history=[], current_message="inspect"),
        transcript_builder=_build_transcript,
        consolidate_history=consolidate,
        tools=tools,
        model="test-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=3,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        events=EventSink(observe_compaction),
    ))

    assert consolidate.await_count == 2
    assert consolidate.await_args_list[0].args[1] is None
    assert consolidate.await_args_list[1].args[1] == "checkpoint-1"
    second_prefix = consolidate.await_args_list[1].args[0]
    assert second_prefix[0]["content"] == "checkpoint-1"
    assert any(message.get("content") == "result-1" for message in second_prefix)
    assert result.final_content == "done"
    assert result.summary_checkpoint is not None
    assert result.summary_checkpoint.summary == "checkpoint-2"
    assert result.summary_checkpoint.transcript_boundary == 4
    assert [event.phase for event in compaction_events] == [
        "started", "succeeded", "started", "succeeded",
    ]
    assert all(event.reason == "context_pressure" for event in compaction_events)
    first_id, second_id = compaction_events[0].compaction_id, compaction_events[2].compaction_id
    assert first_id == compaction_events[1].compaction_id
    assert second_id == compaction_events[3].compaction_id
    assert first_id != second_id


async def test_runner_refuses_checkpoint_that_cannot_fit_with_delta(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(content="unexpected"))
    tools = MagicMock()
    tools.get_definitions.return_value = []
    old_answer = "old answer"
    current_input = "current input must remain intact"

    def estimate(_provider, _model, messages, _tools):
        contents = {message.get("content") for message in messages}
        if old_answer in contents or current_input in contents:
            return 600, "test-counter"
        return 100, "test-counter"

    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        estimate,
    )
    consolidate = AsyncMock(return_value="small checkpoint")

    with pytest.raises(ContextWindowExceededError):
        await AgentRunner().run(make_run_spec(
            provider,
            initial_messages=None,
            transcript_input=TranscriptInput(
                history=[{"role": "assistant", "content": old_answer}],
                current_message=current_input,
            ),
            transcript_builder=_build_transcript,
            consolidate_history=consolidate,
            tools=tools,
            model="test-model",
            context_window_tokens=1_624,
            max_tokens=100,
            max_iterations=1,
            max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        ))

    summarized = consolidate.await_args.args[0]
    assert all(message.get("content") != current_input for message in summarized)
    provider.chat_stream_with_retry.assert_not_awaited()


@pytest.mark.parametrize("context_window, omitted_count, fallback", [
    (200_000, 1, True), (100_000, 2, True), (40_000, 2, False),
])
async def test_runner_recovers_oversized_file_read_delta(
    tmp_path, monkeypatch, context_window, omitted_count, fallback,
):
    from nanobot.agent.tools.filesystem import ReadFileTool
    from nanobot.agent.tools.registry import ToolRegistry

    # A cold/offline tokenizer must exercise the same conservative count as #5879.
    if fallback:
        monkeypatch.setattr(
            "nanobot.utils.helpers._get_token_encoding",
            MagicMock(side_effect=RuntimeError("tokenizer unavailable")),
        )
    else:
        encoding = tiktoken.get_encoding("cl100k_base")
        monkeypatch.setattr("nanobot.utils.helpers._get_token_encoding", lambda: encoding)
    paths = [tmp_path / f"result-{index}.json" for index in range(3)]
    for path in paths:
        path.write_text("record, " * 10_000, encoding="utf-8")
    tools = ToolRegistry()
    tools.register(ReadFileTool(workspace=tmp_path, allowed_dir=tmp_path))
    provider = MagicMock(spec=LLMProvider)
    provider.can_resume_conversation_state.return_value = True
    provider_state = ProviderConversationState(
        kind="openai_responses", provider="openai:test", model="test-model",
        version=1, payload={"items": []},
    )
    calls = [
        ToolCallRequest(id=f"read-{index}", name="read_file", arguments={
            "path": str(path), "limit": 20,
        })
        for index, path in enumerate(paths)
    ]
    provider.chat_stream_with_retry = AsyncMock(side_effect=[
        LLMResponse(content=None, tool_calls=calls, provider_state=provider_state),
        LLMResponse(content=None, tool_calls=[ToolCallRequest(
            id="reread", name="read_file", arguments=calls[0].arguments,
        )], provider_state=provider_state),
        LLMResponse(content="done"),
    ])
    consolidate = AsyncMock(return_value="small checkpoint")
    phases = []

    async def observe(event):
        if isinstance(event, ContextCompactionEvent):
            phases.append(event.phase)

    result = await AgentRunner().run(make_run_spec(
        provider, tools=tools, model="test-model", workspace=tmp_path,
        initial_messages=None,
        transcript_input=TranscriptInput(history=[], current_message="inspect the files"),
        transcript_builder=_build_transcript,
        consolidate_history=consolidate,
        context_window_tokens=context_window, max_tokens=8192, max_iterations=3,
        max_tool_result_chars=16_000, concurrent_tools=True,
        events=EventSink(observe),
    ))

    assert result.final_content == "done"
    requests = provider.chat_stream_with_retry.await_args_list
    delivered = [m for m in requests[1].kwargs["messages"] if m["role"] == "tool"]
    assert all("read_file result was not sent" in m["content"] for m in delivered[:omitted_count])
    assert "offset" in delivered[0]["content"] and "JSON" in delivered[0]["content"]
    assert all("record, " * 10_000 in m["content"] for m in delivered[omitted_count:])
    assert all(r.kwargs["provider_context"].conversation_state is None for r in requests[1:])
    assert "record, " * 10_000 in requests[2].kwargs["messages"][-1]["content"]
    saved_results = [m for m in result.messages if m["role"] == "tool"]
    assert [m["content"] for m in saved_results[:3]] == [m["content"] for m in delivered]
    assert "record, " * 10_000 in saved_results[3]["content"]
    assert phases == ["started", "succeeded", "started", "succeeded"]
    assert consolidate.await_count == 2
    assert not any(m["role"] == "tool" for m in consolidate.await_args_list[0].args[0])
    assert all(path.read_text(encoding="utf-8") == "record, " * 10_000 for path in paths)
    assert not (tmp_path / ".nanobot" / "tool-results").exists()


@pytest.mark.parametrize("fallback, same_round, context_window", [
    (False, True, 200_000),
    (False, False, 40_000),
    (True, False, 200_000),
])
async def test_file_reads_that_fit_each_round_are_not_omitted(
    tmp_path, monkeypatch, fallback, same_round, context_window,
):
    from nanobot.agent.tools.filesystem import ReadFileTool
    from nanobot.agent.tools.registry import ToolRegistry

    encoding = None if fallback else tiktoken.get_encoding("cl100k_base")
    monkeypatch.setattr("nanobot.utils.helpers._get_token_encoding", lambda: encoding)
    paths = [tmp_path / f"result-{index}.json" for index in range(3)]
    for path in paths:
        path.write_text("record, " * 10_000, encoding="utf-8")
    tools = ToolRegistry()
    tools.register(ReadFileTool(workspace=tmp_path, allowed_dir=tmp_path))
    calls = [
        ToolCallRequest(id=f"read-{index}", name="read_file", arguments={"path": str(path)})
        for index, path in enumerate(paths)
    ]
    provider = MagicMock(spec=LLMProvider)
    provider.chat_stream_with_retry = AsyncMock(side_effect=[
        *(LLMResponse(content=None, tool_calls=batch)
          for batch in ([calls] if same_round else [[call] for call in calls])),
        LLMResponse(content="done"),
    ])
    result = await AgentRunner().run(make_run_spec(
        provider, tools=tools, model="test-model", workspace=tmp_path,
        initial_messages=None,
        transcript_input=TranscriptInput(history=[], current_message="inspect the files"),
        transcript_builder=_build_transcript,
        consolidate_history=AsyncMock(return_value="small checkpoint"),
        context_window_tokens=context_window, max_tokens=8192, max_iterations=4,
        max_tool_result_chars=16_000,
    ))
    assert result.final_content == "done"
    delivered = [
        message
        for request in provider.chat_stream_with_retry.await_args_list
        for message in request.kwargs["messages"]
        if message["role"] == "tool"
    ]
    assert {message["tool_call_id"] for message in delivered} == {call.id for call in calls}
    assert all("record, " * 10_000 in message["content"] for message in delivered)
    assert all("record, " * 10_000 in m["content"] for m in result.messages if m["role"] == "tool")
    assert all(request.kwargs["tools"] == tools.get_definitions()
               for request in provider.chat_stream_with_retry.await_args_list)


@pytest.mark.parametrize("structured_transcript", [True, False])
async def test_recovered_file_read_results_survive_session_replay(
    tmp_path, monkeypatch, structured_transcript,
):
    from nanobot.agent.loop import AgentLoop
    from nanobot.agent.tools.filesystem import ReadFileTool
    from nanobot.agent.tools.registry import ToolRegistry
    from nanobot.session.manager import SessionManager

    monkeypatch.setattr(
        "nanobot.utils.helpers._get_token_encoding",
        MagicMock(side_effect=RuntimeError("tokenizer unavailable")),
    )
    workspace = tmp_path / "workspace"
    workspace.mkdir()
    paths = [workspace / f"result-{index}.json" for index in range(3)]
    for path in paths:
        path.write_text("record, " * 10_000, encoding="utf-8")
    tools = ToolRegistry()
    tools.register(ReadFileTool(workspace=workspace, allowed_dir=workspace))
    provider = MagicMock(spec=LLMProvider)
    provider.chat_stream_with_retry = AsyncMock(side_effect=[
        LLMResponse(content=None, tool_calls=[
            ToolCallRequest(id=f"read-{index}", name="read_file", arguments={
                "path": str(path), "limit": 20,
            })
            for index, path in enumerate(paths)
        ]),
        LLMResponse(content="Please select one file to inspect first."),
    ])
    consolidate = AsyncMock(return_value="small checkpoint")
    transcript = TranscriptInput(history=[], current_message="inspect the files")
    result = await AgentRunner().run(make_run_spec(
        provider, tools=tools, model="test-model", workspace=workspace,
        initial_messages=None if structured_transcript else _build_transcript(transcript),
        transcript_input=transcript if structured_transcript else None,
        transcript_builder=_build_transcript if structured_transcript else None,
        consolidate_history=consolidate,
        context_window_tokens=200_000, max_tokens=8192, max_iterations=2,
        max_tool_result_chars=16_000, concurrent_tools=True,
    ))
    assert result.final_content == "Please select one file to inspect first."
    assert consolidate.await_count == 1
    delivered = [
        message for message in provider.chat_stream_with_retry.await_args.kwargs["messages"]
        if message["role"] == "tool"
    ]
    assert "read_file result was not sent" in delivered[0]["content"]

    manager = SessionManager(workspace, sessions_root=tmp_path / "sessions")
    session = manager.get_or_create("test:file-replay")
    AgentLoop.__new__(AgentLoop)._save_turn(
        session, result.messages, skip=1, summary_checkpoint=result.summary_checkpoint,
    )
    manager.save(session)
    reopened = SessionManager(workspace, sessions_root=tmp_path / "sessions").get_existing(session.key)
    assert reopened is not None
    replayed = [message for message in reopened.get_history() if message["role"] == "tool"]
    assert replayed == delivered
    provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(content="ready"))
    consolidate.reset_mock()
    followup = await AgentRunner().run(make_run_spec(
        provider, tools=tools, model="test-model", workspace=workspace,
        initial_messages=None,
        transcript_input=TranscriptInput(
            history=reopened.get_history(), current_message="which files are still pending?",
            session_summary=reopened.metadata["_last_summary"],
        ),
        transcript_builder=_build_transcript,
        consolidate_history=consolidate,
        context_window_tokens=200_000, max_tokens=8192, max_iterations=1,
        max_tool_result_chars=16_000,
    ))
    assert followup.final_content == "ready"
    consolidate.assert_not_awaited()
    request = provider.chat_stream_with_retry.await_args.kwargs
    assert [m for m in request["messages"] if m["role"] == "tool"] == delivered
    assert request["tools"] == tools.get_definitions()
    assert all(path.read_text(encoding="utf-8") == "record, " * 10_000 for path in paths)


@pytest.mark.asyncio
async def test_runner_governs_messages_added_by_before_iteration_hook(monkeypatch):
    from nanobot.agent.hook import AgentHook, AgentHookContext
    from nanobot.agent.runner import AgentRunner

    provider = MagicMock(spec=LLMProvider)
    provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(content="unexpected"))
    tools = MagicMock()
    tools.get_definitions.return_value = []
    oversized = "hook-added-oversized-message"

    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        lambda _provider, _model, messages, _tools: (
            (2_000, "test-counter")
            if any(oversized in str(message.get("content")) for message in messages)
            else (100, "test-counter")
        ),
    )

    class MutatingHook(AgentHook):
        async def before_iteration(self, context: AgentHookContext) -> None:
            context.messages.append({"role": "user", "content": oversized})

    with pytest.raises(ContextWindowExceededError):
        await AgentRunner().run(make_run_spec(
            provider,
            initial_messages=[{"role": "user", "content": "hello"}],
            tools=tools,
            model="local-model",
            context_window_tokens=1_624,
            max_tokens=100,
            max_iterations=1,
            max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
            hook=MutatingHook(),
        ))

    provider.chat_stream_with_retry.assert_not_awaited()


@pytest.mark.parametrize(
    ("input_tokens", "expected_pressure"),
    [(500, True), (100, False)],
)
async def test_matching_reported_provider_usage_avoids_local_estimate(
    monkeypatch,
    input_tokens,
    expected_pressure,
):
    provider = MagicMock(spec=LLMProvider)
    tools = MagicMock()
    tools.get_definitions.return_value = []
    spec = make_run_spec(
        provider,
        initial_messages=[{"role": "user", "content": "hello"}],
        tools=tools,
        model="local-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        lambda *_args, **_kwargs: (_ for _ in ()).throw(
            AssertionError("matching provider usage must be authoritative")
        ),
    )

    governor = ContextGovernor()
    state = ModelRequestState(
        config=_governance_config(provider, tools, spec),
        conversation=ProviderConversationStateController(
            provider=provider, model=spec.runtime.model, messages=spec.initial_messages,
        ),
        compaction=_compaction_state(spec),
        usage=LLMUsage.reported(input_tokens=input_tokens, output_tokens=10),
        messages=spec.initial_messages,
        tool_definitions=[],
    )
    if expected_pressure:
        with pytest.raises(ContextWindowExceededError):
            await governor.prepare_request(
                state,
                spec.initial_messages,
                tool_definitions=tools.get_definitions(),
            )
    else:
        messages, _context = await governor.prepare_request(
            state,
            spec.initial_messages,
            tool_definitions=tools.get_definitions(),
        )
        assert messages == spec.initial_messages


async def test_changed_messages_use_local_estimate_after_reported_usage(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    tools = MagicMock()
    tools.get_definitions.return_value = []
    spec = make_run_spec(
        provider,
        initial_messages=[{"role": "user", "content": "new tool output"}],
        tools=tools,
        model="local-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    estimate = MagicMock(return_value=(600, "test-counter"))
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        estimate,
    )

    governor = ContextGovernor()
    state = ModelRequestState(
        config=_governance_config(provider, tools, spec),
        conversation=ProviderConversationStateController(
            provider=provider, model=spec.runtime.model, messages=spec.initial_messages,
        ),
        compaction=_compaction_state(spec),
        usage=LLMUsage.reported(input_tokens=900, output_tokens=10),
        messages=[{"role": "user", "content": "previous request"}],
        tool_definitions=[],
    )
    with pytest.raises(ContextWindowExceededError):
        await governor.prepare_request(
            state,
            spec.initial_messages,
            tool_definitions=tools.get_definitions(),
        )
    estimate.assert_called_once()


async def test_reported_usage_floor_triggers_pressure_despite_low_estimate(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    tools = MagicMock()
    tools.get_definitions.return_value = []
    spec = make_run_spec(
        provider,
        initial_messages=[{"role": "user", "content": "previous request"}],
        tools=tools,
        model="local-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    estimate = MagicMock(return_value=(100, "test-counter"))
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        estimate,
    )

    governor = ContextGovernor()
    state = ModelRequestState(
        config=_governance_config(provider, tools, spec),
        conversation=ProviderConversationStateController(
            provider=provider, model=spec.runtime.model, messages=spec.initial_messages,
        ),
        compaction=_compaction_state(spec),
        usage=LLMUsage.reported(input_tokens=900, output_tokens=10),
        messages=spec.initial_messages,
        tool_definitions=[],
    )
    with pytest.raises(ContextWindowExceededError) as exc_info:
        await governor.prepare_request(
            state,
            [
                *spec.initial_messages,
                {"role": "assistant", "content": "appended response"},
            ],
            tool_definitions=tools.get_definitions(),
        )
    estimate.assert_called_once()
    assert exc_info.value.estimated_tokens == 900
    assert exc_info.value.source == "prior provider usage plus pending messages"


async def test_runner_does_not_compact_primary_request_from_fallback_usage(monkeypatch):
    primary = MagicMock(spec=LLMProvider)
    primary.provider_name = "primary"
    primary.generation = GenerationSettings(max_tokens=100)
    primary.supports_native_compaction.return_value = False
    primary.chat_stream_with_retry = AsyncMock(side_effect=[
        LLMResponse(content="unavailable", finish_reason="error", error_status_code=503),
        LLMResponse(content="done", usage=LLMUsage.reported(input_tokens=100, output_tokens=10)),
    ])
    fallback = MagicMock(spec=LLMProvider)
    fallback.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(
        content=None,
        tool_calls=[ToolCallRequest(id="call-1", name="inspect", arguments={})],
        finish_reason="tool_calls",
        usage=LLMUsage.reported(input_tokens=600, output_tokens=10),
    ))
    provider = FallbackProvider(
        primary=primary,
        fallback_presets=[ModelPresetConfig(model="backup", max_tokens=100)],
        provider_factory=lambda _preset: fallback,
    )
    tools = MagicMock()
    tools.get_definitions.return_value = [{
        "type": "function",
        "function": {
            "name": "inspect",
            "description": "Inspect the project.",
            "parameters": {"type": "object", "properties": {}},
        },
    }]
    tools.execute = AsyncMock(return_value="inspection complete")
    consolidate = AsyncMock(return_value=None)
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        lambda *_args, **_kwargs: (100, "test-counter"),
    )

    result = await AgentRunner().run(make_run_spec(
        provider,
        initial_messages=[{"role": "user", "content": "inspect the project"}],
        tools=tools,
        model="primary",
        context_window_tokens=1_624,
        max_iterations=2,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        consolidate_history=consolidate,
    ))

    assert result.final_content == "done"
    assert result.tools_used == ["inspect"]
    consolidate.assert_not_awaited()
    assert [usage.input_tokens for usage in result.round_usages] == [600, 100]
    assert result.usage is not None
    assert result.usage.input_tokens == 700


async def test_reported_usage_floor_stays_idle_below_budget(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    tools = MagicMock()
    tools.get_definitions.return_value = []
    spec = make_run_spec(
        provider,
        initial_messages=[{"role": "user", "content": "previous request"}],
        tools=tools,
        model="local-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    estimate = MagicMock(return_value=(100, "test-counter"))
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        estimate,
    )

    governor = ContextGovernor()
    state = ModelRequestState(
        config=_governance_config(provider, tools, spec),
        conversation=ProviderConversationStateController(
            provider=provider, model=spec.runtime.model, messages=spec.initial_messages,
        ),
        compaction=_compaction_state(spec),
        usage=LLMUsage.reported(input_tokens=200, output_tokens=10),
        messages=spec.initial_messages,
        tool_definitions=[],
    )
    messages, _context = await governor.prepare_request(
        state,
        [
            *spec.initial_messages,
            {"role": "assistant", "content": "appended response"},
        ],
        tool_definitions=tools.get_definitions(),
    )
    estimate.assert_called_once()
    assert messages == [
        {"role": "user", "content": "previous request"},
        {"role": "assistant", "content": "appended response"},
    ]


async def test_estimated_usage_does_not_apply_reported_floor(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    tools = MagicMock()
    tools.get_definitions.return_value = []
    spec = make_run_spec(
        provider,
        initial_messages=[{"role": "user", "content": "previous request"}],
        tools=tools,
        model="local-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    estimate = MagicMock(return_value=(100, "test-counter"))
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        estimate,
    )
    consolidate = AsyncMock(return_value="checkpoint")

    governor = ContextGovernor()
    state = ModelRequestState(
        config=_governance_config(provider, tools, spec),
        conversation=ProviderConversationStateController(
            provider=provider, model=spec.runtime.model, messages=spec.initial_messages,
        ),
        compaction=ContextCompactionState.from_messages(
            spec.initial_messages, consolidate, None,
        ),
        usage=LLMUsage.estimated(input_tokens=900, output_tokens=10),
        messages=spec.initial_messages,
        tool_definitions=[],
    )
    messages, _context = await governor.prepare_request(
        state,
        [
            *spec.initial_messages,
            {"role": "assistant", "content": "appended response"},
        ],
        tool_definitions=tools.get_definitions(),
    )
    estimate.assert_called_once()
    consolidate.assert_not_awaited()
    assert messages == [
        {"role": "user", "content": "previous request"},
        {"role": "assistant", "content": "appended response"},
    ]


@pytest.mark.parametrize(
    ("measured", "current", "expected"),
    [
        (
            [{"role": "user", "content": "question"}],
            [{"role": "user", "content": "question"}],
            True,
        ),
        (
            [
                {"role": "user", "content": "question"},
                {"role": "assistant", "content": "answer"},
            ],
            [{"role": "user", "content": "question"}],
            False,
        ),
        (
            [{"role": "user", "content": "question"}],
            [
                {"role": "user", "content": "question"},
                {"role": "assistant", "content": "answer"},
            ],
            True,
        ),
        (
            [
                {"role": "user", "content": "question"},
                {"role": "assistant", "content": "answer"},
            ],
            [
                {"role": "user", "content": "question"},
                {"role": "assistant", "content": "rewritten answer"},
            ],
            False,
        ),
    ],
)
def test_request_extends_measured_prefix_cases(measured, current, expected):
    assert _request_extends_measured(measured, current) is expected


@pytest.mark.parametrize(
    ("estimated_tokens", "expected_pressure"),
    [(100, None), (900, (900, "test-counter"))],
)
def test_missing_usage_falls_back_to_pure_estimate(monkeypatch, estimated_tokens, expected_pressure):
    provider = MagicMock(spec=LLMProvider)
    tools = MagicMock()
    tools.get_definitions.return_value = []
    spec = make_run_spec(
        provider,
        initial_messages=[{"role": "user", "content": "hello"}],
        tools=tools,
        model="local-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    estimate = MagicMock(return_value=(estimated_tokens, "test-counter"))
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        estimate,
    )

    pressure = ContextGovernor().request_pressure(
        _governance_config(provider, tools, spec),
        spec.initial_messages,
        None,
        usage_matches_messages=False,
        usage_prefixes_messages=True,
        tool_definitions=tools.get_definitions(),
    )

    assert pressure == expected_pressure
    estimate.assert_called_once()


async def test_rewritten_request_does_not_inherit_reported_usage_floor(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    tools = MagicMock()
    tools.get_definitions.return_value = []
    spec = make_run_spec(
        provider,
        initial_messages=[{"role": "user", "content": "rewritten request"}],
        tools=tools,
        model="local-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    estimate = MagicMock(return_value=(100, "test-counter"))
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        estimate,
    )

    governor = ContextGovernor()
    state = ModelRequestState(
        config=_governance_config(provider, tools, spec),
        conversation=ProviderConversationStateController(
            provider=provider, model=spec.runtime.model, messages=spec.initial_messages,
        ),
        compaction=_compaction_state(spec),
        usage=LLMUsage.reported(input_tokens=900, output_tokens=10),
        messages=[{"role": "user", "content": "previous request"}],
        tool_definitions=[],
    )
    messages, _context = await governor.prepare_request(
        state,
        spec.initial_messages,
        tool_definitions=tools.get_definitions(),
    )
    estimate.assert_called_once()
    assert messages == [{"role": "user", "content": "rewritten request"}]


async def test_provider_compaction_invalidates_cached_usage():
    provider = MagicMock(spec=LLMProvider)
    tools = MagicMock()
    tools.get_definitions.return_value = []

    for applied, expected_usage in ((True, None), (False, 900)):
        spec = make_run_spec(
            provider,
            initial_messages=[{"role": "user", "content": "previous request"}],
            tools=tools,
            model="local-model",
            max_iterations=1,
            max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        )
        state = ModelRequestState(
            config=_governance_config(provider, tools, spec),
            conversation=ProviderConversationStateController(
                provider=provider, model=spec.runtime.model, messages=spec.initial_messages,
            ),
            compaction=_compaction_state(spec),
            messages=spec.initial_messages,
            tool_definitions=[],
        )
        usage = await AgentRunner()._record_request_usage(
            spec,
            state,
            LLMResponse(
                content="done",
                usage=LLMUsage.reported(input_tokens=900, output_tokens=10),
                provider_compaction_applied=applied,
            ),
        )
        assert usage.input_tokens == 900
        if expected_usage is None:
            assert state.usage is None
        else:
            assert state.usage is not None
            assert state.usage.input_tokens == expected_usage


def test_resumed_provider_context_avoids_full_transcript_estimate(monkeypatch):
    provider = MagicMock(spec=LLMProvider)
    tools = MagicMock()
    tools.get_definitions.return_value = []
    spec = make_run_spec(
        provider,
        initial_messages=[{"role": "user", "content": "pending delta"}],
        tools=tools,
        model="local-model",
        context_window_tokens=1_624,
        max_tokens=100,
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    )
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        lambda *_args, **_kwargs: (_ for _ in ()).throw(
            AssertionError("resumed provider context must be authoritative")
        ),
    )

    pressure = ContextGovernor().request_pressure(
        _governance_config(provider, tools, spec),
        spec.initial_messages,
        LLMUsage.reported(input_tokens=900, output_tokens=10),
        usage_matches_messages=False,
        usage_prefixes_messages=False,
        tool_definitions=tools.get_definitions(),
        request_context_tokens=100,
    )

    assert pressure is None


@pytest.mark.asyncio
async def test_runner_refuses_oversized_resumed_state_without_compactor(monkeypatch):
    from nanobot.agent.runner import AgentRunner

    provider = MagicMock(spec=LLMProvider)
    provider.can_resume_conversation_state.return_value = True
    captured_contexts = []

    async def chat_stream_with_retry(*, provider_context=None, **_kwargs):
        captured_contexts.append(provider_context)
        return LLMResponse(
            content="done",
            usage=LLMUsage.reported(input_tokens=100, output_tokens=10),
        )

    provider.chat_stream_with_retry = chat_stream_with_retry
    tools = MagicMock()
    tools.get_definitions.return_value = []
    current_message = {"role": "user", "content": "new delta"}
    saved_state = ProviderConversationState(
        kind="openai_responses",
        provider="openai:test",
        model="local-model",
        version=1,
        payload={
            "items": [{"type": "reasoning", "encrypted_content": "opaque"}],
            "context_tokens": 450,
        },
        pending_messages=[current_message],
    )
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        lambda *_args, **_kwargs: (100, "test-counter"),
    )
    monkeypatch.setattr(
        "nanobot.providers.conversation_state.estimate_prompt_tokens_chain",
        lambda *_args, **_kwargs: (100, "test-counter"),
    )

    with pytest.raises(ContextWindowExceededError) as exc_info:
        await AgentRunner().run(make_run_spec(
            provider,
            initial_messages=[current_message],
            tools=tools,
            model="local-model",
            context_window_tokens=1_624,
            max_tokens=100,
            max_iterations=1,
            max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
            provider_state=saved_state,
        ))

    assert exc_info.value.estimated_tokens == 550
    assert exc_info.value.source == "resumed provider state plus pending messages"
    assert captured_contexts == []


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("context_window_tokens", "expected_budget"),
    [(1_624, 500), (1_000, 0)],
)
async def test_runner_refuses_oversized_request_without_compactor(
    monkeypatch,
    context_window_tokens,
    expected_budget,
):
    from nanobot.agent.runner import AgentRunner

    provider = MagicMock(spec=LLMProvider)
    provider.chat_stream_with_retry = AsyncMock(return_value=LLMResponse(content="unexpected"))
    tools = MagicMock()
    tools.get_definitions.return_value = []
    monkeypatch.setattr(
        "nanobot.agent.context_governance.estimate_prompt_tokens_chain",
        lambda *_args, **_kwargs: (2_000, "test-counter"),
    )

    with pytest.raises(ContextWindowExceededError) as exc_info:
        await AgentRunner().run(make_run_spec(
            provider,
            initial_messages=[
                {"role": "system", "content": "oversized system"},
                {"role": "user", "content": "oversized user"},
            ],
            tools=tools,
            model="local-model",
            context_window_tokens=context_window_tokens,
            max_tokens=100,
            max_iterations=1,
            max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
        ))

    assert exc_info.value.estimated_tokens == 2_000
    assert exc_info.value.input_budget == expected_budget
    provider.chat_stream_with_retry.assert_not_awaited()


async def test_backfill_missing_tool_results_inserts_error():

    messages = [
        {"role": "user", "content": "hi"},
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {"id": "call_a", "type": "function", "function": {"name": "exec", "arguments": "{}"}},
                {"id": "call_b", "type": "function", "function": {"name": "read_file", "arguments": "{}"}},
            ],
        },
        {"role": "tool", "tool_call_id": "call_a", "name": "exec", "content": "ok"},
    ]
    result = ContextGovernor.backfill_missing_tool_results(messages)
    tool_msgs = [m for m in result if m.get("role") == "tool"]
    assert len(tool_msgs) == 2
    backfilled = [m for m in tool_msgs if m.get("tool_call_id") == "call_b"]
    assert len(backfilled) == 1
    assert backfilled[0]["content"] == BACKFILL_CONTENT
    assert backfilled[0]["name"] == "read_file"


def test_drop_orphan_tool_results_removes_unmatched_tool_messages():
    messages = [
        {"role": "system", "content": "system"},
        {"role": "user", "content": "old user"},
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {"id": "call_ok", "type": "function", "function": {"name": "read_file", "arguments": "{}"}},
            ],
        },
        {"role": "tool", "tool_call_id": "call_ok", "name": "read_file", "content": "ok"},
        {"role": "tool", "tool_call_id": "call_orphan", "name": "exec", "content": "stale"},
        {"role": "assistant", "content": "after tool"},
    ]

    cleaned = ContextGovernor.drop_orphan_tool_results(messages)

    assert cleaned == [
        {"role": "system", "content": "system"},
        {"role": "user", "content": "old user"},
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {"id": "call_ok", "type": "function", "function": {"name": "read_file", "arguments": "{}"}},
            ],
        },
        {"role": "tool", "tool_call_id": "call_ok", "name": "read_file", "content": "ok"},
        {"role": "assistant", "content": "after tool"},
    ]


@pytest.mark.asyncio
async def test_backfill_noop_when_complete():
    messages = [
        {"role": "user", "content": "hi"},
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {"id": "call_x", "type": "function", "function": {"name": "exec", "arguments": "{}"}},
            ],
        },
        {"role": "tool", "tool_call_id": "call_x", "name": "exec", "content": "done"},
        {"role": "assistant", "content": "all good"},
    ]
    result = ContextGovernor.backfill_missing_tool_results(messages)
    assert result is messages


@pytest.mark.asyncio
async def test_runner_drops_orphan_tool_results_before_model_request():
    from nanobot.agent.runner import AgentRunner

    provider = MagicMock()
    captured_messages: list[dict] = []

    async def chat_stream_with_retry(*, messages, **kwargs):
        captured_messages[:] = messages
        return LLMResponse(content="done", tool_calls=[], usage=None)

    provider.chat_stream_with_retry = chat_stream_with_retry
    tools = MagicMock()
    tools.get_definitions.return_value = []

    runner = AgentRunner()
    result = await runner.run(make_run_spec(provider,
        initial_messages=[
            {"role": "system", "content": "system"},
            {"role": "user", "content": "old user"},
            {"role": "tool", "tool_call_id": "call_orphan", "name": "exec", "content": "stale"},
            {"role": "assistant", "content": "after orphan"},
            {"role": "user", "content": "new prompt"},
        ],
        tools=tools,
        model="test-model",
        max_iterations=1,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    ))

    assert all(
        message.get("tool_call_id") != "call_orphan"
        for message in captured_messages
        if message.get("role") == "tool"
    )
    assert result.messages[2]["tool_call_id"] == "call_orphan"
    assert result.final_content == "done"


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

    provider = MagicMock()
    provider.get_default_model.return_value = "test-model"
    response = LLMResponse(content="new answer", tool_calls=[], usage=None)
    provider.chat_stream_with_retry = AsyncMock(return_value=response)

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

    session = loop.sessions.get_or_create("cli:test")
    session.messages = [
        {"role": "user", "content": "old user", "timestamp": "2026-01-01T00:00:00"},
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {
                    "id": "call_missing",
                    "type": "function",
                    "function": {"name": "read_file", "arguments": "{}"},
                }
            ],
            "timestamp": "2026-01-01T00:00:01",
        },
        {"role": "assistant", "content": "old tail", "timestamp": "2026-01-01T00:00:02"},
    ]
    loop.sessions.save(session)

    result = await loop._process_message(
        InboundMessage(channel="cli", sender_id="user", chat_id="test", content="new prompt")
    )

    assert result is not None
    assert result.content == "new answer"

    request_messages = provider.chat_stream_with_retry.await_args.kwargs["messages"]
    synthetic = [
        message
        for message in request_messages
        if message.get("role") == "tool" and message.get("tool_call_id") == "call_missing"
    ]
    assert len(synthetic) == 1
    assert synthetic[0]["content"] == BACKFILL_CONTENT

    session_after = loop.sessions.get_or_create("cli:test")
    assert [
        {
            key: value
            for key, value in message.items()
            if key in {"role", "content", "tool_call_id", "name", "tool_calls"}
        }
        for message in map(public_history_message, session_after.messages)
    ] == [
        {"role": "user", "content": "old user"},
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {
                    "id": "call_missing",
                    "type": "function",
                    "function": {"name": "read_file", "arguments": "{}"},
                }
            ],
        },
        {"role": "assistant", "content": "old tail"},
        {"role": "user", "content": "new prompt"},
        {"role": "assistant", "content": "new answer"},
    ]


@pytest.mark.asyncio
async def test_runner_backfill_only_mutates_model_context_not_returned_messages():
    from nanobot.agent.runner import AgentRunner

    provider = MagicMock()
    captured_messages: list[dict] = []

    async def chat_stream_with_retry(*, messages, **kwargs):
        captured_messages[:] = messages
        return LLMResponse(content="done", tool_calls=[], usage=None)

    provider.chat_stream_with_retry = chat_stream_with_retry
    tools = MagicMock()
    tools.get_definitions.return_value = []

    initial_messages = [
        {"role": "system", "content": "system"},
        {"role": "user", "content": "old user"},
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {
                    "id": "call_missing",
                    "type": "function",
                    "function": {"name": "read_file", "arguments": "{}"},
                }
            ],
        },
        {"role": "assistant", "content": "old tail"},
        {"role": "user", "content": "new prompt"},
    ]

    runner = AgentRunner()
    result = await runner.run(make_run_spec(provider,
        initial_messages=initial_messages,
        tools=tools,
        model="test-model",
        max_iterations=3,
        max_tool_result_chars=_MAX_TOOL_RESULT_CHARS,
    ))

    synthetic = [
        message
        for message in captured_messages
        if message.get("role") == "tool" and message.get("tool_call_id") == "call_missing"
    ]
    assert len(synthetic) == 1
    assert synthetic[0]["content"] == BACKFILL_CONTENT

    assert [
        {
            key: value
            for key, value in message.items()
            if key in {"role", "content", "tool_call_id", "name", "tool_calls"}
        }
        for message in result.messages
    ] == [
        {"role": "system", "content": "system"},
        {"role": "user", "content": "old user"},
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {
                    "id": "call_missing",
                    "type": "function",
                    "function": {"name": "read_file", "arguments": "{}"},
                }
            ],
        },
        {"role": "assistant", "content": "old tail"},
        {"role": "user", "content": "new prompt"},
        {"role": "assistant", "content": "done"},
    ]


# Malformed tool_call name guard (missing/non-string name wedges the session
# upstream: messages.content.N.tool_use.name: Input should be a valid string)


def test_drop_malformed_tool_calls_trims_response():
    from nanobot.agent.runner import AgentRunner

    candidate_state = ProviderConversationState(
        kind="openai_responses",
        provider="openai:test",
        model="gpt-5.6",
        version=1,
        payload={"items": [{"type": "function_call", "name": None}]},
    )
    response = LLMResponse(
        content=None,
        tool_calls=[
            ToolCallRequest(id="1", name=None, arguments={}),
            ToolCallRequest(id="2", name="", arguments={}),
            ToolCallRequest(id="3", name={"unexpected": "object"}, arguments={}),
            ToolCallRequest(id="4", name="read_file", arguments={}),
        ],
        finish_reason="tool_calls",
        provider_state=candidate_state,
    )
    dropped, all_dropped, orig = AgentRunner._drop_malformed_tool_calls(response)
    assert [tc.name for tc in response.tool_calls] == ["read_file"]
    assert response.provider_state is None
    assert response.finish_reason == "tool_calls"
    assert response.should_execute_tools is True
    assert dropped == 3
    assert all_dropped is False
    assert orig == "tool_calls"


def test_drop_malformed_tool_calls_all_bad_disables_execution():
    from nanobot.agent.runner import AgentRunner

    response = LLMResponse(
        content="some text",
        tool_calls=[ToolCallRequest(id="1", name=None, arguments={})],
        finish_reason="tool_calls",
    )
    dropped, all_dropped, orig = AgentRunner._drop_malformed_tool_calls(response)
    assert response.tool_calls == []
    assert response.finish_reason == "stop"
    assert response.should_execute_tools is False
    assert dropped == 1
    assert all_dropped is True
    assert orig == "tool_calls"


def test_drop_malformed_returns_tuple_no_calls():
    from nanobot.agent.runner import AgentRunner

    response = LLMResponse(content="hi", finish_reason="stop")
    dropped, all_dropped, orig = AgentRunner._drop_malformed_tool_calls(response)
    assert dropped == 0
    assert all_dropped is False
    assert orig == "stop"


def test_strip_malformed_tool_calls_keeps_valid_calls_in_history():
    messages = [
        {"role": "user", "content": "hi"},
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {"id": "bad", "type": "function", "function": {"name": None, "arguments": "{}"}},
                {"id": "ok", "type": "function", "function": {"name": "exec", "arguments": "{}"}},
            ],
        },
        {"role": "tool", "tool_call_id": "ok", "name": "exec", "content": "done"},
    ]
    result = ContextGovernor.strip_malformed_tool_calls(messages)
    assert result is not messages
    assert len(messages[1]["tool_calls"]) == 2
    kept = result[1]["tool_calls"]
    assert [tc["function"]["name"] for tc in kept] == ["exec"]


def test_strip_malformed_tool_calls_drops_empty_assistant_turn():
    """An assistant turn that is only a malformed call is removed entirely;
    the existing orphan-result cleanup then drops its dangling tool result,
    so a polluted session self-heals."""
    messages = [
        {"role": "user", "content": "hi"},
        {
            "role": "assistant",
            "content": None,
            "tool_calls": [
                {"id": "bad", "type": "function", "function": {"name": None, "arguments": "{}"}},
            ],
        },
        {"role": "tool", "tool_call_id": "bad", "name": "", "content": "r"},
    ]
    stripped = ContextGovernor.strip_malformed_tool_calls(messages)
    assert [m["role"] for m in stripped] == ["user", "tool"]
    healed = ContextGovernor.drop_orphan_tool_results(stripped)
    assert [m["role"] for m in healed] == ["user"]


def test_strip_malformed_tool_calls_noop_when_clean():
    messages = [
        {"role": "user", "content": "hi"},
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {"id": "ok", "type": "function", "function": {"name": "exec", "arguments": "{}"}},
            ],
        },
        {"role": "tool", "tool_call_id": "ok", "name": "exec", "content": "done"},
    ]
    assert ContextGovernor.strip_malformed_tool_calls(messages) is messages


def test_strip_placeholder_assistant_messages_removes_omitted():
    messages = [
        {"role": "user", "content": "hi"},
        {"role": "assistant", "content": "real response"},
        {"role": "user", "content": "ok"},
        {"role": "assistant", "content": "[Previous assistant message omitted.]"},
        {"role": "user", "content": "?"},
        {"role": "assistant", "content": "[Previous assistant message omitted.]"},
        {"role": "user", "content": "hello"},
    ]
    result = ContextGovernor.strip_placeholder_assistant_messages(messages)
    assert [m["role"] for m in result] == [
        "user", "assistant", "user", "user", "user",
    ]
    assert result[1]["content"] == "real response"


def test_strip_placeholder_noop_when_clean():
    messages = [
        {"role": "user", "content": "hi"},
        {"role": "assistant", "content": "hello back"},
    ]
    assert ContextGovernor.strip_placeholder_assistant_messages(messages) is messages


def test_strip_placeholder_keeps_assistant_with_tool_calls():
    messages = [
        {"role": "user", "content": "hi"},
        {
            "role": "assistant",
            "content": "[Previous assistant message omitted.]",
            "tool_calls": [
                {"id": "1", "type": "function", "function": {"name": "exec", "arguments": "{}"}},
            ],
        },
        {"role": "tool", "tool_call_id": "1", "name": "exec", "content": "done"},
    ]
    result = ContextGovernor.strip_placeholder_assistant_messages(messages)
    assert result is messages