Skip to content

Your lightweight open-source personal agent.

24.1 KB
Raw Blame
import asyncio
from collections import defaultdict
from datetime import datetime, timedelta
from unittest.mock import AsyncMock, MagicMock

import pytest

from nanobot.agent.autocompact import AutoCompact
from nanobot.events import NO_EVENTS, ContextCompactionEvent, EventSink
from nanobot.session.manager import Session, SessionManager


def _mock_sessions():
    sessions = MagicMock(spec=SessionManager)
    sessions.state.get = AsyncMock(side_effect=lambda key: sessions.get_or_create(key))
    sessions.state.get_header = AsyncMock(side_effect=lambda key: sessions.get_or_create(key))
    sessions.state.list_sessions = AsyncMock(side_effect=lambda: sessions.list_sessions())
    sessions.state.has_unarchived_messages = AsyncMock(return_value=True)
    return sessions


def _runtime(_session: Session | None = None):
    return MagicMock(name="runtime")


async def _resolve_runtime(session: Session):
    return _runtime(session)


def _make_session(
    key: str = "cli:test",
    messages: list | None = None,
    last_archived: int = 0,
    updated_at: datetime | None = None,
    metadata: dict | None = None,
) -> Session:
    """Create a Session with sensible defaults for testing."""
    session = Session(
        key=key,
        messages=messages or [],
        metadata=metadata or {},
    )
    session.last_archived = last_archived
    if updated_at is not None:
        session.updated_at = updated_at
    return session


def _make_autocompact(
    ttl: int = 15,
    sessions: SessionManager | None = None,
    consolidator: MagicMock | None = None,
) -> AutoCompact:
    """Create an AutoCompact with mock dependencies."""
    if sessions is None:
        sessions = _mock_sessions()
        sessions.get_or_create.return_value = Session(key="cli:test")
    if isinstance(sessions, MagicMock):
        sessions.state.get = AsyncMock(side_effect=lambda key: sessions.get_or_create(key))
    if consolidator is None:
        consolidator = MagicMock()
        consolidator.compact_idle_session = AsyncMock(return_value="Summary.")
    return AutoCompact(
        sessions=sessions,
        consolidator=consolidator,
        session_ttl_minutes=ttl,
        session_lock=defaultdict(asyncio.Lock).__getitem__,
    )


def _add_turns(session: Session, turns: int, *, prefix: str = "msg") -> None:
    """Append simple user/assistant turns to a session."""
    for i in range(turns):
        session.add_message("user", f"{prefix} user {i}")
        session.add_message("assistant", f"{prefix} assistant {i}")


async def test_default_ttl_disables_idle_compaction():
    sessions = _mock_sessions()
    sessions.list_sessions.return_value = [
        {"key": "cli:idle", "updated_at": datetime.now() - timedelta(days=365)},
    ]
    sessions.get_or_create.return_value = _make_session(
        key="cli:idle", messages=[{"role": "user", "content": "pending"}],
    )
    ac = AutoCompact(
        sessions=sessions, consolidator=MagicMock(),
        session_lock=defaultdict(asyncio.Lock).__getitem__,
    )
    schedule = MagicMock(side_effect=lambda pending: pending.close())

    await ac.check_expired(schedule, _resolve_runtime)

    assert schedule.call_count == 0


class TestIsExpired:

    def test_ttl_zero_always_false(self):
        ac = _make_autocompact(ttl=0)
        old = datetime.now() - timedelta(days=365)
        assert ac._is_expired(old) is False

    def test_none_timestamp_returns_false(self):
        ac = _make_autocompact(ttl=15)
        assert ac._is_expired(None) is False

    def test_empty_string_timestamp_returns_false(self):
        ac = _make_autocompact(ttl=15)
        assert ac._is_expired("") is False

    def test_exactly_at_boundary_is_expired(self):
        ac = _make_autocompact(ttl=15)
        now = datetime(2026, 1, 1, 12, 0, 0)
        ts = now - timedelta(minutes=15)
        assert ac._is_expired(ts, now=now) is True

    def test_just_under_boundary_not_expired(self):
        ac = _make_autocompact(ttl=15)
        now = datetime(2026, 1, 1, 12, 0, 0)
        ts = now - timedelta(minutes=14, seconds=59)
        assert ac._is_expired(ts, now=now) is False

    def test_iso_string_parses_correctly(self):
        ac = _make_autocompact(ttl=15)
        now = datetime(2026, 1, 1, 12, 0, 0)
        ts = (now - timedelta(minutes=20)).isoformat()
        assert ac._is_expired(ts, now=now) is True

    def test_custom_now_parameter(self):
        ac = _make_autocompact(ttl=10)
        ts = datetime(2026, 1, 1, 10, 0, 0)
        now_under = datetime(2026, 1, 1, 10, 9, 0)
        assert ac._is_expired(ts, now=now_under) is False
        now_over = datetime(2026, 1, 1, 10, 10, 0)
        assert ac._is_expired(ts, now=now_over) is True

    def test_unparseable_string_timestamp_returns_false(self):
        """A persisted timestamp that no longer parses must not raise.

        list_sessions() forwards the raw persisted updated_at string, and
        SessionManager._load already tolerates a malformed value through its
        recovery path. The idle scan must mirror that tolerance instead of crashing.
        """
        ac = _make_autocompact(ttl=15)
        assert ac._is_expired("not-a-timestamp") is False

    def test_tz_aware_string_timestamp_is_compared_by_instant(self):
        ac = _make_autocompact(ttl=15)
        now = datetime(2026, 1, 1, 12, 0, 0)
        recent = (now - timedelta(minutes=10)).astimezone().isoformat()
        expired = (now - timedelta(minutes=20)).astimezone().isoformat()

        assert ac._is_expired(recent, now=now) is False
        assert ac._is_expired(expired, now=now) is True


class TestCheckExpired:

    async def test_empty_sessions_list(self):
        ac = _make_autocompact(ttl=15)
        mock_sm = _mock_sessions()
        mock_sm.list_sessions.return_value = []
        ac.sessions = mock_sm
        scheduler = MagicMock()
        await ac.check_expired(scheduler, _resolve_runtime)
        scheduler.assert_not_called()

    async def test_expired_session_schedules_background(self):
        ac = _make_autocompact(ttl=15)
        mock_sm = _mock_sessions()
        old_dt = datetime.now() - timedelta(minutes=20)
        session = _make_session("cli:old", updated_at=old_dt)
        _add_turns(session, 5)
        mock_sm.list_sessions.return_value = [{"key": "cli:old", "updated_at": old_dt.isoformat()}]
        mock_sm.get_or_create.return_value = session
        ac.sessions = mock_sm

        scheduled = []

        def scheduler(coro):
            scheduled.append(coro)
            coro.close()

        await ac.check_expired(scheduler, _resolve_runtime)
        assert len(scheduled) == 1
        assert "cli:old" in ac._archiving

    async def test_unparseable_updated_at_does_not_stop_scan(self):
        """A malformed timestamp is skipped without hiding later sessions.

        The idle scan runs from the agent loop's inbound-timeout branch, so a
        raised exception here would tear down the loop. list_sessions() forwards
        the raw string, so check_expired must tolerate it like SessionManager
        does when loading.
        """
        ac = _make_autocompact(ttl=15)
        mock_sm = _mock_sessions()
        old_dt = datetime.now() - timedelta(minutes=20)
        session = _make_session("cli:old", updated_at=old_dt)
        _add_turns(session, 5)
        mock_sm.list_sessions.return_value = [
            {"key": "cli:corrupt", "updated_at": "not-a-timestamp"},
            {"key": "cli:old", "updated_at": old_dt.isoformat()},
        ]
        mock_sm.get_or_create.return_value = session
        ac.sessions = mock_sm
        scheduled = []

        def scheduler(coro):
            scheduled.append(coro)
            coro.close()

        await ac.check_expired(scheduler, _resolve_runtime)

        assert len(scheduled) == 1
        assert ac._archiving == {"cli:old"}

    @pytest.mark.asyncio
    async def test_runtime_is_captured_before_background_starts(self):
        ac = _make_autocompact(ttl=15)
        old_dt = datetime.now() - timedelta(minutes=20)
        session = _make_session("cli:old", updated_at=old_dt)
        _add_turns(session, 5)
        session.updated_at = old_dt
        ac.sessions.list_sessions.return_value = [
            {"key": "cli:old", "updated_at": old_dt.isoformat()}
        ]
        ac.sessions.get_or_create.return_value = session
        admitted = _runtime()
        replacement = _runtime()
        resolve_runtime = AsyncMock(return_value=admitted)
        scheduled = []

        await ac.check_expired(scheduled.append, resolve_runtime)
        resolve_runtime.return_value = replacement
        await scheduled[0]

        resolve_runtime.assert_called_once_with(session)
        ac.consolidator.compact_idle_session.assert_awaited_once_with(
            "cli:old",
            runtime=admitted,
            events=NO_EVENTS,
            reason="idle",
        )

    @pytest.mark.parametrize("resolution_error", [KeyError, ValueError])
    async def test_invalid_preset_is_isolated_to_one_session(self, resolution_error):
        ac = _make_autocompact(ttl=15)
        old_dt = datetime.now() - timedelta(minutes=20)
        sessions = {
            key: _make_session(key, updated_at=old_dt)
            for key in ("cli:removed", "cli:healthy")
        }
        for session in sessions.values():
            _add_turns(session, 5)
        ac.sessions.list_sessions.return_value = [
            {"key": key, "updated_at": old_dt.isoformat()}
            for key in sessions
        ]
        ac.sessions.get_or_create.side_effect = sessions.__getitem__
        healthy_runtime = _runtime()

        async def resolve_runtime(session: Session):
            if session.key == "cli:removed":
                raise resolution_error("model preset cannot be resolved")
            return healthy_runtime

        scheduled = []

        def scheduler(coro):
            scheduled.append(coro)
            coro.close()

        await ac.check_expired(scheduler, resolve_runtime)

        assert len(scheduled) == 1
        assert ac._archiving == {"cli:healthy"}

    async def test_unexpected_runtime_resolution_failure_propagates(self):
        ac = _make_autocompact(ttl=15)
        old_dt = datetime.now() - timedelta(minutes=20)
        session = _make_session("cli:old", updated_at=old_dt)
        _add_turns(session, 5)
        ac.sessions.list_sessions.return_value = [
            {"key": session.key, "updated_at": old_dt.isoformat()}
        ]
        ac.sessions.get_or_create.return_value = session

        async def fail(_session: Session):
            raise RuntimeError("unexpected resolver failure")

        with pytest.raises(RuntimeError, match="unexpected resolver failure"):
            await ac.check_expired(MagicMock(), fail)

    async def test_active_session_key_skips(self):
        ac = _make_autocompact(ttl=15)
        mock_sm = _mock_sessions()
        old_ts = (datetime.now() - timedelta(minutes=20)).isoformat()
        mock_sm.list_sessions.return_value = [{"key": "cli:busy", "updated_at": old_ts}]
        ac.sessions = mock_sm
        scheduler = MagicMock()
        await ac.check_expired(scheduler, _resolve_runtime, active_session_keys={"cli:busy"})
        scheduler.assert_not_called()

    async def test_session_already_in_archiving_skips(self):
        ac = _make_autocompact(ttl=15)
        mock_sm = _mock_sessions()
        old_ts = (datetime.now() - timedelta(minutes=20)).isoformat()
        mock_sm.list_sessions.return_value = [{"key": "cli:dup", "updated_at": old_ts}]
        ac.sessions = mock_sm
        ac._archiving.add("cli:dup")
        scheduler = MagicMock()
        await ac.check_expired(scheduler, _resolve_runtime)
        scheduler.assert_not_called()

    async def test_dream_session_skips(self):
        ac = _make_autocompact(ttl=15)
        mock_sm = _mock_sessions()
        old_ts = (datetime.now() - timedelta(minutes=20)).isoformat()
        mock_sm.list_sessions.return_value = [
            {"key": "dream:20260602-155256", "updated_at": old_ts},
        ]
        ac.sessions = mock_sm
        scheduler = MagicMock()

        await ac.check_expired(scheduler, _resolve_runtime)

        scheduler.assert_not_called()
        assert "dream:20260602-155256" not in ac._archiving

    async def test_short_unarchived_session_schedules(self):
        ac = _make_autocompact(ttl=15)
        mock_sm = _mock_sessions()
        last_active = datetime(2026, 1, 1, 10, 0, 0)
        session = _make_session("cli:short", updated_at=last_active)
        _add_turns(session, 2)
        mock_sm.list_sessions.return_value = [
            {"key": "cli:short", "updated_at": last_active.isoformat()},
        ]
        mock_sm.get_or_create.return_value = session
        ac.sessions = mock_sm

        scheduled = []

        def scheduler(coro):
            scheduled.append(coro)
            coro.close()

        await ac.check_expired(scheduler, _resolve_runtime)

        assert len(scheduled) == 1
        assert ac._archiving == {"cli:short"}

    async def test_fully_archived_session_skips(self):
        ac = _make_autocompact(ttl=15)
        mock_sm = _mock_sessions()
        last_active = datetime(2026, 1, 1, 10, 0, 0)
        session = _make_session("cli:done", updated_at=last_active)
        _add_turns(session, 2)
        session.last_archived = len(session.messages)
        mock_sm.list_sessions.return_value = [
            {"key": "cli:done", "updated_at": last_active.isoformat()},
        ]
        mock_sm.get_or_create.return_value = session
        mock_sm.state.has_unarchived_messages.return_value = False
        ac.sessions = mock_sm

        scheduler = MagicMock()
        await ac.check_expired(scheduler, _resolve_runtime)

        scheduler.assert_not_called()
        mock_sm.state.get.assert_not_awaited()


class TestArchiveDelegates:

    @pytest.mark.asyncio
    async def test_calls_compact_idle_session(self):
        ac = _make_autocompact()
        mock_sm = _mock_sessions()
        mock_sm.get_or_create.return_value = _make_session(updated_at=datetime.now() - timedelta(minutes=20))
        ac.sessions = mock_sm
        ac.consolidator.compact_idle_session = AsyncMock(return_value="Summary.")

        runtime = _runtime()
        await ac._archive("cli:test", runtime=runtime)

        ac.consolidator.compact_idle_session.assert_awaited_once_with(
            "cli:test",
            runtime=runtime,
            events=NO_EVENTS,
            reason="idle",
        )

    @pytest.mark.asyncio
    async def test_forwards_timeout_compaction_events_with_session_key(self):
        sessions = _mock_sessions()
        sessions.get_or_create.return_value = _make_session(updated_at=datetime.now() - timedelta(minutes=20))
        consolidator = MagicMock()
        observed: list[tuple[str, ContextCompactionEvent]] = []

        def bind(key: str):
            async def publish(event: ContextCompactionEvent) -> None:
                observed.append((key, event))
            return EventSink(publish)

        async def compact(key: str, **kwargs):
            event = ContextCompactionEvent(compaction_id="compact-1", phase="started")
            await kwargs["events"].emit(event)
            return "Summary."

        consolidator.compact_idle_session = AsyncMock(side_effect=compact)
        ac = AutoCompact(
            sessions=sessions,
            consolidator=consolidator,
            session_ttl_minutes=15,
            bind_events=bind,
            session_lock=defaultdict(asyncio.Lock).__getitem__,
        )

        await ac._archive("cli:test", runtime=_runtime())

        assert len(observed) == 1
        assert observed[0][0] == "cli:test"
        assert observed[0][1].phase == "started"

    @pytest.mark.asyncio
    async def test_dream_session_is_ignored(self):
        ac = _make_autocompact()
        ac.consolidator.compact_idle_session = AsyncMock(return_value="Summary.")
        ac._archiving.add("dream:20260602-155256")

        await ac._archive("dream:20260602-155256", runtime=_runtime())

        ac.consolidator.compact_idle_session.assert_not_awaited()
        assert "dream:20260602-155256" not in ac._archiving

    @pytest.mark.asyncio
    async def test_populates_summaries_from_metadata(self):
        ac = _make_autocompact()
        mock_sm = _mock_sessions()
        session = _make_session(
            updated_at=datetime.now() - timedelta(minutes=20),
            metadata={"_last_summary": {"text": "Hello.", "last_active": "2026-05-13T10:00:00"}}
        )
        mock_sm.get_or_create.return_value = session
        ac.sessions = mock_sm
        ac.consolidator.compact_idle_session = AsyncMock(return_value="Hello.")

        await ac._archive("cli:test", runtime=_runtime())

        entry = ac._summaries.get("cli:test")
        assert entry is not None
        assert entry["text"] == "Hello."

    @pytest.mark.asyncio
    async def test_no_summary_when_compact_returns_empty(self):
        mock_sm = _mock_sessions()
        mock_sm.get_or_create.return_value = _make_session(updated_at=datetime.now() - timedelta(minutes=20), metadata={
            "_last_summary": {"text": "Previous checkpoint.", "last_active": "2026-05-13T10:00:00"},
        })
        ac = _make_autocompact(sessions=mock_sm)
        ac.consolidator.compact_idle_session = AsyncMock(return_value="")

        await ac._archive("cli:test", runtime=_runtime())

        ac.consolidator.compact_idle_session.assert_awaited_once()
        assert "cli:test" not in ac._summaries

    @pytest.mark.asyncio
    async def test_exception_still_removes_from_archiving(self):
        ac = _make_autocompact()
        mock_sm = _mock_sessions()
        mock_sm.get_or_create.return_value = _make_session(
            updated_at=datetime.now() - timedelta(minutes=20),
        )
        ac.sessions = mock_sm
        ac.consolidator.compact_idle_session = AsyncMock(side_effect=RuntimeError("fail"))

        ac._archiving.add("cli:test")
        await ac._archive("cli:test", runtime=_runtime())

        ac.consolidator.compact_idle_session.assert_awaited_once()
        assert "cli:test" not in ac._archiving


class TestPrepareSession:

    @pytest.mark.parametrize("archiving", [False, True])
    async def test_preparing_idle_session_preserves_turn_metadata(self, archiving):
        ac = _make_autocompact(ttl=15)
        session = _make_session(
            updated_at=datetime.now() - timedelta(minutes=20),
            metadata={"last_channel": "discord:new"},
        )
        if archiving:
            ac._archiving.add(session.key)

        prepared, _ = await ac.prepare_session(session, session.key)

        assert prepared.metadata["last_channel"] == "discord:new"

    async def test_hot_path_summary_from_summaries(self):
        ac = _make_autocompact()
        session = _make_session()
        last_active = datetime(2026, 5, 13, 14, 0, 0)
        ac._summaries["cli:test"] = {
            "text": "Hot summary.",
            "last_active": last_active.isoformat(),
        }

        result_session, summary = await ac.prepare_session(session, "cli:test")

        assert result_session is session
        assert summary is not None
        assert summary == {
            "text": "Hot summary.",
            "last_active": last_active.isoformat(),
        }

    async def test_hot_path_pops_summary_one_shot(self):
        ac = _make_autocompact()
        session = _make_session()
        last_active = datetime(2026, 1, 1)
        ac._summaries["cli:test"] = {
            "text": "One-shot.",
            "last_active": last_active.isoformat(),
        }

        _, summary1 = await ac.prepare_session(session, "cli:test")
        assert summary1 is not None
        _, summary2 = await ac.prepare_session(session, "cli:test")
        assert summary2 is None

    async def test_cold_path_summary_from_metadata(self):
        ac = _make_autocompact()
        last_active = datetime(2026, 5, 13, 14, 0, 0)
        session = _make_session(metadata={
            "_last_summary": {
                "text": "Cold summary.",
                "last_active": last_active.isoformat(),
            },
        })

        result_session, summary = await ac.prepare_session(session, "cli:test")

        assert result_session is session
        assert summary is not None
        assert summary["text"] == "Cold summary."

    async def test_cold_path_tolerates_malformed_last_active(self):
        """A malformed persisted last_active must not raise on the turn path.

        prepare_session runs from _compact_session on every turn. Persisted
        _last_summary can be hand-edited or written by another version, so a bad
        last_active should degrade gracefully (mirror estimate_session_prompt_tokens
        and _archive) instead of crashing the turn.
        """
        ac = _make_autocompact(ttl=0)
        fallback = datetime(2026, 1, 2, 3, 4, 5)
        session = _make_session(
            metadata={
                "_last_summary": {"text": "Cold summary.", "last_active": "not-a-date"},
            },
            updated_at=fallback,
        )

        result_session, summary = await ac.prepare_session(session, "cli:test")

        assert result_session is session
        assert summary is not None
        assert summary == {
            "text": "Cold summary.",
            "last_active": fallback.isoformat(),
        }

    async def test_cold_path_tolerates_missing_last_active(self):
        ac = _make_autocompact(ttl=0)
        fallback = datetime(2026, 1, 2, 3, 4, 5)
        session = _make_session(
            metadata={"_last_summary": {"text": "Cold summary."}},
            updated_at=fallback,
        )

        result_session, summary = await ac.prepare_session(session, "cli:test")

        assert result_session is session
        assert summary is not None
        assert summary == {
            "text": "Cold summary.",
            "last_active": fallback.isoformat(),
        }

    async def test_cold_path_missing_text_returns_none(self):
        ac = _make_autocompact()
        session = _make_session(metadata={
            "_last_summary": {"last_active": datetime(2026, 1, 1).isoformat()},
        })

        result_session, summary = await ac.prepare_session(session, "cli:test")

        assert result_session is session
        assert summary is None

    async def test_no_summary_available_returns_none(self):
        ac = _make_autocompact()
        session = _make_session()

        result_session, summary = await ac.prepare_session(session, "cli:test")

        assert result_session is session
        assert summary is None

    async def test_dream_session_skips_reload_and_summaries(self):
        ac = _make_autocompact(ttl=15)
        mock_sm = _mock_sessions()
        ac.sessions = mock_sm
        key = "dream:20260602-155256"
        ac._archiving.add(key)
        ac._summaries[key] = {
            "text": "Hot summary.",
            "last_active": "2026-06-02T15:52:56",
        }
        session = _make_session(
            key=key,
            updated_at=datetime.now() - timedelta(minutes=20),
            metadata={
                "_last_summary": {
                    "text": "Cold summary.",
                    "last_active": "2026-06-02T15:52:56",
                },
            },
        )

        result_session, summary = await ac.prepare_session(session, key)

        mock_sm.get_or_create.assert_not_called()
        assert result_session is session
        assert summary is None
        assert key not in ac._archiving
        assert key not in ac._summaries

    async def test_cold_path_metadata_not_dict_returns_none(self):
        ac = _make_autocompact()
        session = _make_session(metadata={"_last_summary": "not a dict"})

        result_session, summary = await ac.prepare_session(session, "cli:test")

        assert result_session is session
        assert summary is None

    async def test_hot_path_takes_priority_over_metadata(self):
        ac = _make_autocompact()
        session = _make_session(metadata={
            "_last_summary": {
                "text": "Cold summary.",
                "last_active": datetime(2026, 1, 1).isoformat(),
            },
        })
        last_active = datetime(2026, 5, 13, 14, 0, 0)
        ac._summaries["cli:test"] = {
            "text": "Hot summary.",
            "last_active": last_active.isoformat(),
        }

        _, summary = await ac.prepare_session(session, "cli:test")
        assert summary is not None
        assert summary["text"] == "Hot summary."