Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
from dataclasses import replace
from unittest.mock import AsyncMock, MagicMock
import pytest
from nanobot.agent.memory import (
_ARCHIVE_TOOL_RESULT,
_HISTORY_ENTRY_HARD_CAP,
Consolidator,
MemoryStore,
)
from nanobot.events import AgentEvent, ContextCompactionEvent, EventSink
from nanobot.providers.base import (
GenerationSettings,
LLMResponse,
ProviderConversationState,
ToolCallRequest,
)
from nanobot.runtime_context import (
RUNTIME_CONTEXT_HISTORY_META,
RuntimeContextBlock,
append_runtime_context,
)
from nanobot.session.keys import UNIFIED_SESSION_KEY, remember_last_channel
from nanobot.session.manager import Session
from nanobot.utils.llm_runtime import LLMRuntime
from nanobot.utils.prompt_templates import render_template
_ARCHIVE_PROMPT = render_template("agent/consolidator_archive.md", strip=True)
@pytest.fixture
def store(tmp_path):
return MemoryStore(tmp_path)
@pytest.fixture
def mock_provider():
p = MagicMock(aclose=AsyncMock())
p.chat_stream_with_retry = AsyncMock()
p.generation = GenerationSettings(max_tokens=100)
return p
@pytest.fixture
def runtime(mock_provider):
return LLMRuntime.capture(
mock_provider,
"test-model",
context_window_tokens=1000,
)
@pytest.fixture
def consolidator(store):
sessions = MagicMock()
sessions.save = MagicMock()
_session_cache: dict[str, MagicMock] = {}
sessions.get_or_create = MagicMock(side_effect=lambda key: _session_cache.get(key, MagicMock()))
sessions._session_cache = _session_cache
return Consolidator(
store=store,
sessions=sessions,
build_messages=MagicMock(return_value=[]),
get_tool_definitions=MagicMock(return_value=[]),
)
def _tool_round(call_id: str) -> list[dict]:
return [
{
"role": "assistant",
"content": None,
"tool_calls": [
{"id": call_id, "type": "function", "function": {"name": "x", "arguments": "{}"}}
],
},
{"role": "tool", "tool_call_id": call_id, "name": "x", "content": "ok"},
]
def _provider_state() -> ProviderConversationState:
return ProviderConversationState(
kind="openai_responses",
provider="openai:test",
model="test-model",
version=1,
payload={"items": []},
)
def _build_test_messages(**kwargs):
system = "system prompt"
session_summary = kwargs.get("session_summary")
if session_summary:
system += f"\n\n[Archived Context Summary]\n{session_summary['text']}"
messages = [
{"role": "system", "content": system},
*kwargs["history"],
]
if kwargs["current_message"] is not None:
messages.append({"role": "user", "content": kwargs["current_message"]})
return messages
async def _archive(
consolidator,
messages,
runtime,
*,
session_key="test:session",
previous_summary=None,
):
return await consolidator.archiver.archive(
messages,
runtime=runtime,
session_key=session_key,
history=[
{"role": "system", "content": "system prompt"},
*messages,
],
request_tools=[],
previous_summary=previous_summary,
)
class TestTurnTranscriptSummary:
@pytest.mark.parametrize("summary", ["replacement checkpoint", "(nothing)"])
async def test_uses_exact_accepted_prefix_and_existing_archiver(
self,
consolidator,
mock_provider,
runtime,
summary,
):
runtime = replace(runtime, context_window_tokens=4096)
accepted = [
{"role": "system", "content": "stable system"},
{"role": "user", "content": "accepted history"},
]
tools = [{"type": "function", "function": {"name": "inspect"}}]
mock_provider.chat_stream_with_retry.return_value = LLMResponse(
content=summary,
)
result = await consolidator.summarize_transcript(
accepted,
"previous checkpoint",
runtime=runtime,
session_key="test:turn",
tools=tools,
)
assert result == summary
call = mock_provider.chat_stream_with_retry.await_args.kwargs
assert call["messages"][:-1] == accepted
assert call["messages"][-1]["role"] == "user"
assert "SNIP" in call["messages"][-1]["content"]
assert call["tools"] == tools
async def test_nonpersistent_failure_returns_raw_checkpoint_without_journaling(
self,
consolidator,
mock_provider,
runtime,
store,
):
accepted = [
{"role": "system", "content": "stable system"},
{"role": "user", "content": "accepted history"},
]
mock_provider.chat_stream_with_retry.return_value = LLMResponse(content="")
consolidator._SAFETY_BUFFER = 0
result = await consolidator.summarize_transcript(
accepted,
None,
runtime=runtime,
session_key="test:ephemeral-turn",
tools=[],
persist=False,
)
assert result is not None
assert "[RAW]" in result
assert "accepted history" in result
assert store.read_unprocessed_history(since_cursor=0) == []
async def test_native_compaction_appends_only_archive_prompt(
self,
consolidator,
mock_provider,
runtime,
):
accepted = [
{"role": "system", "content": "stable system"},
{"role": "user", "content": "raw history must not be replayed"},
]
state = _provider_state()
mock_provider.can_resume_conversation_state.return_value = True
mock_provider.chat_stream_with_retry.return_value = LLMResponse(
content="replacement checkpoint",
)
result = await consolidator.summarize_provider_compaction(
state,
accepted,
"previous checkpoint",
runtime=runtime,
session_key="test:turn",
tools=[{"type": "function", "function": {"name": "inspect"}}],
)
assert result == "replacement checkpoint"
call = mock_provider.chat_stream_with_retry.await_args.kwargs
assert call["messages"][0] == accepted[0]
assert call["messages"][-1]["content"] == _ARCHIVE_PROMPT
assert accepted[1] not in call["messages"]
assert call["tools"] == []
provider_context = call["provider_context"]
assert provider_context.conversation_state is not None
assert provider_context.conversation_state.payload == state.payload
assert provider_context.conversation_state.pending_messages == [
call["messages"][-1],
]
async def test_native_compaction_recovers_tool_call_from_response_state(
self,
consolidator,
mock_provider,
runtime,
):
accepted = [
{"role": "system", "content": "stable system"},
{"role": "user", "content": "raw history must not be replayed"},
]
incoming_state = _provider_state()
response_state = ProviderConversationState(
kind="openai_responses",
provider="openai:test",
model="test-model",
version=1,
payload={"items": [{"type": "function_call", "call_id": "call-1"}]},
)
mock_provider.can_resume_conversation_state.return_value = True
mock_provider.chat_stream_with_retry.side_effect = [
LLMResponse(
content=None,
tool_calls=[ToolCallRequest(id="call-1", name="inspect", arguments={})],
finish_reason="tool_calls",
provider_state=response_state,
),
LLMResponse(content="replacement checkpoint", finish_reason="stop"),
]
result = await consolidator.summarize_provider_compaction(
incoming_state,
accepted,
"previous checkpoint",
runtime=runtime,
session_key="test:turn",
tools=[{"type": "function", "function": {"name": "inspect"}}],
)
assert result == "replacement checkpoint"
first_call, recovery_call = mock_provider.chat_stream_with_retry.await_args_list
assert first_call.kwargs["tools"] == recovery_call.kwargs["tools"] == []
recovery_context = recovery_call.kwargs["provider_context"]
assert recovery_context.conversation_state is not None
assert recovery_context.conversation_state.payload == response_state.payload
assert recovery_context.conversation_state.pending_messages == [{
"role": "tool",
"tool_call_id": "call-1",
"name": "inspect",
"content": _ARCHIVE_TOOL_RESULT,
}]
class TestConsolidatorSummarize:
def test_format_messages_keeps_media_only_user_turn(self):
path = "/home/user/.nanobot/media/websocket/clip.mp4"
formatted = MemoryStore._format_messages([
{
"role": "user",
"content": "",
"media": [path],
"timestamp": "2026-07-27",
}
])
assert formatted == f"[2026-07-27] USER: [image: {path}]"
async def test_archive_uses_captured_generation(
self, consolidator, mock_provider, runtime
):
admitted = replace(
runtime,
generation=GenerationSettings(
temperature=0.25,
max_tokens=321,
reasoning_effort="medium",
),
)
mock_provider.generation = GenerationSettings(
temperature=0.9,
max_tokens=999,
reasoning_effort="high",
)
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="Summary.",
finish_reason="stop",
)
await _archive(consolidator, [{"role": "user", "content": "hello"}], admitted)
call = mock_provider.chat_stream_with_retry.call_args.kwargs
assert call["model"] == admitted.model
assert call["temperature"] == 0.25
assert call["max_tokens"] == 321
assert call["reasoning_effort"] == "medium"
async def test_summarize_appends_to_history(
self, consolidator, mock_provider, store, runtime
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="User fixed a bug in the auth module."
)
messages = [
{"role": "user", "content": "fix the auth bug"},
{"role": "assistant", "content": "Done, fixed the race condition."},
]
result = await _archive(consolidator, messages, runtime)
assert result == "User fixed a bug in the auth module."
entries = store.read_unprocessed_history(since_cursor=0)
assert len(entries) == 1
async def test_summarize_appends_session_key_to_history(
self,
consolidator,
mock_provider,
store,
runtime,
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="User fixed a bug in the auth module.",
finish_reason="stop",
)
messages = [{"role": "user", "content": "fix the auth bug"}]
await _archive(
consolidator,
messages,
runtime,
session_key="telegram:chat-1",
)
entries = store.read_unprocessed_history(since_cursor=0)
assert entries[0]["session_key"] == "telegram:chat-1"
async def test_summarize_raw_dumps_on_llm_failure(
self, consolidator, mock_provider, store, runtime
):
mock_provider.chat_stream_with_retry.side_effect = Exception("API error")
messages = [{"role": "user", "content": "hello"}]
result = await _archive(consolidator, messages, runtime)
assert result is not None
assert "[RAW]" in result
assert "hello" in result
entries = store.read_unprocessed_history(since_cursor=0)
assert len(entries) == 1
assert "[RAW]" in entries[0]["content"]
async def test_raw_dump_fallback_appends_session_key(
self,
consolidator,
mock_provider,
store,
runtime,
):
mock_provider.chat_stream_with_retry.side_effect = Exception("API error")
messages = [{"role": "user", "content": "hello"}]
await _archive(
consolidator,
messages,
runtime,
session_key="slack:chat-2",
)
entries = store.read_unprocessed_history(since_cursor=0)
assert entries[0]["session_key"] == "slack:chat-2"
async def test_raw_fallback_represents_previous_checkpoint_and_new_chunk(
self,
consolidator,
mock_provider,
runtime,
):
runtime = replace(runtime, generation=GenerationSettings(max_tokens=256))
mock_provider.chat_stream_with_retry.side_effect = RuntimeError("API error")
result = await _archive(
consolidator,
[{"role": "user", "content": "NEW_MARKER " + "new " * 200}],
runtime,
previous_summary="OLD_MARKER " + "old " * 200,
)
assert result is not None
assert "[Previous archived context]" in result
assert "OLD_MARKER" in result
assert "[Newly archived raw context]" in result
assert "NEW_MARKER" in result
assert "... (truncated)" in result
async def test_summarize_skips_empty_messages(self, consolidator, runtime):
result = await _archive(consolidator, [], runtime)
assert result is None
class TestConsolidatorPromptContract:
def test_archive_prompt_requests_a_cumulative_replacement_checkpoint(self):
prompt = _ARCHIVE_PROMPT
for section in ("## Merge rules", "## What to retain", "## Output"):
assert section in prompt
assert "replacement checkpoint" in prompt
assert "[Archived Context Summary]" in prompt
assert "current conversation state" in prompt
assert "SNIP" in prompt
for mark in ("[permanent]", "[durable]", "[ephemeral]", "[correction]"):
assert mark in prompt
assert "working-state handoff" in prompt
assert "- [mark] fact" in prompt
assert "[skip]" not in prompt
assert "(nothing)" in prompt
assert "history.jsonl" not in prompt
class TestConsolidatorArchiveErrorHandling:
"""archive() must fall back when the LLM does not complete its overview.
Error responses include overloaded / quota failures from #3244; length
responses contain a partial overview that is likewise unsafe to persist.
"""
@pytest.mark.parametrize("finish_reason", ["error", "length"])
async def test_archive_falls_back_on_incomplete_finish_reason(
self,
consolidator,
mock_provider,
store,
runtime,
finish_reason: str,
):
invalid_output = f"INVALID_{finish_reason.upper()}_OUTPUT"
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content=invalid_output,
finish_reason=finish_reason,
)
messages = [
{"role": "user", "content": "fix the auth bug"},
{"role": "assistant", "content": "Done, fixed the race condition."},
]
result = await _archive(consolidator, messages, runtime)
assert result is not None
assert "[RAW]" in result
entries = store.read_unprocessed_history(since_cursor=0)
assert len(entries) == 1
assert "[RAW]" in entries[0]["content"]
assert invalid_output not in entries[0]["content"]
async def test_archive_preserves_summary_on_success(
self, consolidator, mock_provider, store, runtime
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="User fixed a bug in the auth module.",
finish_reason="stop",
)
messages = [
{"role": "user", "content": "fix the auth bug"},
{"role": "assistant", "content": "Done."},
]
result = await _archive(consolidator, messages, runtime)
assert result == "User fixed a bug in the auth module."
entries = store.read_unprocessed_history(since_cursor=0)
assert len(entries) == 1
assert "[RAW]" not in entries[0]["content"]
async def test_archive_propagates_history_write_failure(
self, consolidator, mock_provider, runtime
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="Summary.",
finish_reason="stop",
)
consolidator.store.append_history = MagicMock(side_effect=OSError("disk full"))
consolidator.store.raw_archive = MagicMock()
with pytest.raises(OSError, match="disk full"):
await _archive(
consolidator,
[{"role": "user", "content": "important"}],
runtime,
)
consolidator.store.raw_archive.assert_not_called()
async def test_archive_propagates_template_failure_without_raw_archive(
self, consolidator, mock_provider, runtime, monkeypatch
):
runtime = replace(runtime, context_window_tokens=128_000)
consolidator.store.raw_archive = MagicMock()
monkeypatch.setattr(
"nanobot.agent.memory.render_template",
MagicMock(side_effect=RuntimeError("template failed")),
)
session = Session(key="test:template")
session.add_message("user", "important")
with pytest.raises(RuntimeError, match="template failed"):
await consolidator.archive_session(
session,
archive_end=len(session.messages),
runtime=runtime,
)
mock_provider.chat_stream_with_retry.assert_not_awaited()
consolidator.store.raw_archive.assert_not_called()
class TestConsolidatorPromptEstimate:
async def test_estimate_uses_full_unarchived_tail(self, consolidator, runtime):
session = Session(key="test:full-tail")
for i in range(160):
session.add_message("user", f"msg-{i}")
captured: dict[str, list[dict]] = {}
def build_messages(**kwargs):
captured["history"] = kwargs["history"]
return kwargs["history"]
consolidator._build_messages = build_messages
consolidator.estimate_session_prompt_tokens(session, runtime=runtime)
assert len(captured["history"]) == 160
assert captured["history"][0]["content"].endswith("msg-0")
async def test_estimate_excludes_archived_replay(self, consolidator, runtime):
session = Session(key="test:archived-replay")
for i in range(10):
session.add_message("user", f"msg-{i}")
session.last_archived = len(session.messages)
captured: dict[str, list[dict]] = {}
def build_messages(**kwargs):
captured["history"] = kwargs["history"]
return kwargs["history"]
consolidator._build_messages = build_messages
consolidator.estimate_session_prompt_tokens(session, runtime=runtime)
assert captured["history"] == []
class TestCompactIdleSession:
@pytest.fixture
def runtime(self, mock_provider):
"""Exercise the structured idle-consolidation path by default."""
return LLMRuntime.capture(
mock_provider,
"test-model",
context_window_tokens=128_000,
)
@pytest.fixture
def real_consolidator(self, store, mock_provider):
"""Create a Consolidator with a real SessionManager (not a mock)."""
from nanobot.session.manager import SessionManager
sessions = SessionManager(store.workspace)
return Consolidator(
store=store,
sessions=sessions,
build_messages=MagicMock(side_effect=_build_test_messages),
get_tool_definitions=MagicMock(return_value=[]),
)
async def test_partial_raw_write_does_not_advance_checkpoint(
self, real_consolidator, store, runtime, mock_provider, monkeypatch
):
runtime = replace(runtime, context_window_tokens=1_000)
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:partial-raw")
session.add_message("user", "x " * 20_000 + "TAIL_MARKER")
expected = store._format_messages(session.messages)
sessions.save(session)
append = store._append_history_record
writes = 0
def fail_second(content, *, session_key=None):
nonlocal writes
writes += 1
if writes == 2:
raise OSError("disk full")
return append(content, session_key=session_key)
with monkeypatch.context() as patcher:
patcher.setattr(store, "_append_history_record", fail_second)
with pytest.raises(OSError, match="disk full"):
await real_consolidator.compact_idle_session(session.key, runtime=runtime)
sessions.invalidate(session.key)
unchanged = sessions.get_or_create(session.key)
assert unchanged.last_archived == 0
assert unchanged.messages == session.messages
partial_cursor = store.get_latest_cursor()
assert partial_cursor == 1
await real_consolidator.compact_idle_session(session.key, runtime=runtime)
entries = MemoryStore(store.workspace).read_unprocessed_history(partial_cursor)
assert "".join(entry["content"].split("\n", 1)[1] for entry in entries) == expected
sessions.invalidate(session.key)
assert sessions.get_or_create(session.key).last_archived == 1
mock_provider.chat_stream_with_retry.assert_not_awaited()
@pytest.mark.asyncio
async def test_archives_full_tail_preserves_messages_and_replays_checkpoint(
self, real_consolidator, mock_provider, runtime
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="Summary of old conversation.", finish_reason="stop"
)
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:test")
session.provider_state = _provider_state()
old_ts = session.updated_at
for i in range(20):
session.add_message("user", f"user msg {i}")
session.add_message("assistant", f"assistant msg {i}")
session.updated_at = old_ts
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"cli:test", runtime=runtime, max_suffix=8
)
assert result == "Summary of old conversation."
sessions.invalidate("cli:test")
reloaded = sessions.get_or_create("cli:test")
assert len(reloaded.messages) == 41
assert reloaded.messages[0]["content"] == "user msg 0"
assert reloaded.last_archived == 40
assert reloaded.provider_state is None
visible = reloaded.get_history(max_messages=40)
assert visible == []
meta = reloaded.metadata.get("_last_summary")
assert meta is not None
assert meta["text"] == "Summary of old conversation."
assert "last_active" in meta
assert reloaded.updated_at == old_ts
@pytest.mark.asyncio
async def test_emits_manual_compaction_lifecycle(
self, real_consolidator, mock_provider, runtime
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="Summary.", finish_reason="stop"
)
session = real_consolidator.sessions.get_or_create("cli:events")
session.add_message("user", "question")
session.add_message("assistant", "answer")
real_consolidator.sessions.save(session)
events: list[ContextCompactionEvent] = []
async def observe(event: AgentEvent) -> None:
if isinstance(event, ContextCompactionEvent):
events.append(event)
result = await real_consolidator.compact_idle_session(
"cli:events",
runtime=runtime,
events=EventSink(observe),
notify=True,
)
assert result == "Summary."
assert [event.phase for event in events] == ["started", "succeeded"]
assert events[0].compaction_id == events[1].compaction_id
assert all(event.notify for event in events)
@pytest.mark.asyncio
async def test_event_callback_failure_does_not_abort_compaction(
self, real_consolidator, mock_provider, runtime
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="Summary.", finish_reason="stop"
)
session = real_consolidator.sessions.get_or_create("cli:event-callback-failure")
session.add_message("user", "question")
real_consolidator.sessions.save(session)
async def fail_observer(_event: AgentEvent) -> None:
raise RuntimeError("channel unavailable")
result = await real_consolidator.compact_idle_session(
"cli:event-callback-failure",
runtime=runtime,
events=EventSink(fail_observer),
)
assert result == "Summary."
reloaded = real_consolidator.sessions.get_or_create("cli:event-callback-failure")
assert reloaded.last_archived == 1
@pytest.mark.asyncio
async def test_short_idle_session_archives_once(
self, real_consolidator, mock_provider, store, runtime
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="Short summary.", finish_reason="stop"
)
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:short")
session.add_message("user", "hello")
session.add_message("assistant", "hi")
sessions.save(session)
first = await real_consolidator.compact_idle_session("cli:short", runtime=runtime)
second = await real_consolidator.compact_idle_session("cli:short", runtime=runtime)
assert first == "Short summary."
assert second == ""
mock_provider.chat_stream_with_retry.assert_awaited_once()
assert len(store.read_unprocessed_history(since_cursor=0)) == 1
reloaded = sessions.get_or_create("cli:short")
assert reloaded.last_archived == 2
assert reloaded.get_history() == []
@pytest.mark.asyncio
async def test_idle_compaction_with_no_new_messages_is_noop(
self, real_consolidator, mock_provider, store, runtime
):
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:archived-idle")
session.provider_state = _provider_state()
session.add_message("user", "already archived")
session.add_message("assistant", "old answer")
session.last_archived = 2
sessions.save(session)
sessions.invalidate("cli:archived-idle")
result = await real_consolidator.compact_idle_session(
"cli:archived-idle",
runtime=runtime,
)
assert result == ""
mock_provider.chat_stream_with_retry.assert_not_awaited()
reloaded = sessions.get_or_create("cli:archived-idle")
assert reloaded.last_archived == 2
assert "_last_summary" not in reloaded.metadata
assert reloaded.provider_state == _provider_state()
assert store.read_unprocessed_history(since_cursor=0) == []
@pytest.mark.asyncio
async def test_next_turn_rebuilds_context_after_idle_compaction(
self, loop_factory, mock_provider,
):
mock_provider.can_resume_conversation_state.return_value = True
mock_provider.estimate_prompt_tokens.return_value = (100, "test")
mock_provider.chat_stream_with_retry.return_value = LLMResponse(
content="Archived conversation summary.", finish_reason="stop",
)
loop = loop_factory(provider=mock_provider)
try:
session = loop.sessions.get_or_create("cli:idle-resume")
for i in range(10):
session.add_message("user", f"question-{i}")
session.add_message("assistant", f"answer-{i}")
session.provider_state = _provider_state()
loop.sessions.save(session)
await loop.consolidator.compact_idle_session(
session.key, runtime=loop.llm_runtime(),
)
loop.sessions.invalidate(session.key)
mock_provider.chat_stream_with_retry.reset_mock()
mock_provider.chat_stream_with_retry.return_value = LLMResponse(
content="Next answer.", finish_reason="stop",
)
response = await loop.process_direct("Next question", session_key=session.key)
assert response is not None
assert response.content == "Next answer."
sent = mock_provider.chat_stream_with_retry.call_args.kwargs
assert sent["provider_context"].conversation_state is None
contents = [message.get("content", "") for message in sent["messages"]]
assert "Archived conversation summary." in contents[0]
assert "question-0" not in contents
assert contents[1:-1] == []
assert "Next question" in contents[-1]
finally:
await loop.aclose()
@pytest.mark.asyncio
async def test_archive_failure_preserves_provider_state(self, real_consolidator, runtime):
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:failed-archive")
session.add_message("user", "Keep this context")
session.provider_state = _provider_state()
sessions.save(session)
real_consolidator.archive_session = AsyncMock(side_effect=OSError("disk full"))
with pytest.raises(OSError, match="disk full"):
await real_consolidator.compact_idle_session(session.key, runtime=runtime)
sessions.invalidate(session.key)
reloaded = sessions.get_or_create(session.key)
assert reloaded.provider_state == _provider_state()
assert reloaded.last_archived == 0
assert "_last_summary" not in reloaded.metadata
@pytest.mark.asyncio
@pytest.mark.parametrize("summary", [None, ""])
async def test_missing_summary_preserves_replay(self, real_consolidator, runtime, summary):
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:missing-summary")
session.add_message("user", "Keep this context")
session.provider_state = _provider_state()
sessions.save(session)
real_consolidator.archive_session = AsyncMock(return_value=summary)
events = []
async def observe(event):
events.append(event)
result = await real_consolidator.compact_idle_session(
session.key, runtime=runtime, events=EventSink(observe),
)
assert result is None
assert [event.phase for event in events] == ["started", "failed"]
sessions.invalidate(session.key)
reloaded = sessions.get_or_create(session.key)
assert reloaded.provider_state == _provider_state()
assert reloaded.last_archived == 0
assert reloaded.get_history() == [{"role": "user", "content": "Keep this context"}]
@pytest.mark.asyncio
async def test_new_messages_advance_existing_archive_progress(
self, real_consolidator, mock_provider, runtime
):
mock_provider.chat_stream_with_retry.side_effect = [
MagicMock(content="First replacement checkpoint.", finish_reason="stop"),
MagicMock(content="Second replacement checkpoint.", finish_reason="stop"),
]
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:incremental")
session.add_message("user", "first user")
session.add_message("assistant", "first assistant")
sessions.save(session)
first = await real_consolidator.compact_idle_session(
"cli:incremental",
runtime=runtime,
)
current = await sessions.state.get("cli:incremental")
current.add_message("user", "second user")
current.add_message("assistant", "second assistant")
await sessions.state.finish_turn(current)
second = await real_consolidator.compact_idle_session(
"cli:incremental",
runtime=runtime,
)
assert first == "First replacement checkpoint."
assert second == "Second replacement checkpoint."
assert mock_provider.chat_stream_with_retry.await_count == 2
latest_build = real_consolidator.archiver._build_messages.call_args_list[-1].kwargs
assert latest_build["session_summary"]["text"] == "First replacement checkpoint."
latest_messages = mock_provider.chat_stream_with_retry.await_args_list[-1].kwargs["messages"]
assert [message["content"] for message in latest_messages[1:-1]] == [
"second user",
"second assistant",
]
assert latest_messages[-1]["content"] == _ARCHIVE_PROMPT
sessions.invalidate("cli:incremental")
reloaded = sessions.get_or_create("cli:incremental")
assert reloaded.last_archived == 5
assert reloaded.metadata["_last_summary"]["text"] == second
@pytest.mark.asyncio
async def test_raw_fallback_preserves_previous_checkpoint_and_new_chunk(
self,
real_consolidator,
mock_provider,
store,
runtime,
):
runtime = replace(runtime, generation=GenerationSettings(max_tokens=256))
mock_provider.chat_stream_with_retry.side_effect = [
LLMResponse(content="Earlier durable checkpoint.", finish_reason="stop"),
RuntimeError("LLM unavailable"),
]
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:cumulative-fallback")
session.add_message("user", "first user")
session.add_message("assistant", "first answer")
sessions.save(session)
await real_consolidator.compact_idle_session(
"cli:cumulative-fallback",
runtime=runtime,
)
current = await sessions.state.get("cli:cumulative-fallback")
current.add_message("user", "second user")
current.add_message("assistant", "newest working state")
await sessions.state.finish_turn(current)
fallback = await real_consolidator.compact_idle_session(
"cli:cumulative-fallback",
runtime=runtime,
)
assert fallback is not None
assert "[Previous archived context]" in fallback
assert "Earlier durable checkpoint." in fallback
assert "[Newly archived raw context]" in fallback
assert "newest working state" in fallback
entries = store.read_unprocessed_history(0)
assert entries[0]["content"] == "Earlier durable checkpoint."
assert entries[1]["content"].startswith("[RAW] 2 messages")
sessions.invalidate("cli:cumulative-fallback")
reloaded = sessions.get_or_create("cli:cumulative-fallback")
assert reloaded.metadata["_last_summary"]["text"] == fallback
@pytest.mark.asyncio
async def test_nothing_replaces_previous_checkpoint(
self,
real_consolidator,
mock_provider,
runtime,
):
mock_provider.chat_stream_with_retry.side_effect = [
LLMResponse(content="Existing checkpoint.", finish_reason="stop"),
LLMResponse(content="(nothing)", finish_reason="stop"),
]
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:nothing-after-summary")
session.add_message("user", "important first turn")
session.add_message("assistant", "important result")
sessions.save(session)
await real_consolidator.compact_idle_session(
"cli:nothing-after-summary",
runtime=runtime,
)
current = await sessions.state.get("cli:nothing-after-summary")
current.add_message("user", "thanks")
current.add_message("assistant", "you're welcome")
await sessions.state.finish_turn(current)
result = await real_consolidator.compact_idle_session(
"cli:nothing-after-summary",
runtime=runtime,
)
assert result == "(nothing)"
sessions.invalidate("cli:nothing-after-summary")
reloaded = sessions.get_or_create("cli:nothing-after-summary")
assert reloaded.last_archived == 5
assert reloaded.metadata["_last_summary"]["text"] == result
@pytest.mark.asyncio
@pytest.mark.parametrize("max_suffix", [8, 0])
async def test_concurrent_append_remains_unarchived(
self, real_consolidator, mock_provider, runtime, max_suffix
):
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:concurrent")
session.provider_state = _provider_state()
session.add_message("user", "captured user")
session.add_message("assistant", "captured assistant")
sessions.save(session)
async def append_during_archive(**_kwargs):
current = await sessions.state.get("cli:concurrent")
current.add_message("user", "late user")
current.add_message("assistant", "late assistant")
await sessions.state.finish_turn(current)
return LLMResponse(content="Summary.", finish_reason="stop")
mock_provider.chat_stream_with_retry.side_effect = append_during_archive
await real_consolidator.compact_idle_session(
"cli:concurrent", runtime=runtime, max_suffix=max_suffix,
)
sessions.invalidate("cli:concurrent")
reloaded = sessions.get_or_create("cli:concurrent")
assert len(reloaded.messages) == 5
assert reloaded.last_archived == 2
assert reloaded.provider_state is None
assert reloaded.get_history()[-1]["content"] == "late assistant"
assert [m["content"] for m in reloaded.get_history()] == [
"late user", "late assistant",
]
@pytest.mark.asyncio
async def test_summarizes_latest_correction_with_full_history(
self, real_consolidator, mock_provider, runtime
):
"""idleCompact must summarize over the full unarchived tail, including
the recent suffix it retains. Otherwise a late user correction / final
result that lands in the kept suffix is excluded from the persisted
summary, leaving a stale wrong conclusion in history. Regression for #4264."""
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="Summary.", finish_reason="stop"
)
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:correction")
for i in range(18):
session.add_message("user", f"user msg {i}")
session.add_message("assistant", f"assistant msg {i}")
session.add_message("user", "no, that's wrong, use approach B")
session.add_message("assistant", "CORRECTED_FINAL_RESULT_alpha")
sessions.save(session)
await real_consolidator.compact_idle_session(
"cli:correction", runtime=runtime, max_suffix=8
)
sent_messages = mock_provider.chat_stream_with_retry.call_args.kwargs["messages"]
assert any(
message.get("content") == "CORRECTED_FINAL_RESULT_alpha"
for message in sent_messages
)
@pytest.mark.asyncio
async def test_raw_dumps_full_archive_batch_on_llm_failure(
self, real_consolidator, mock_provider, store, runtime
):
mock_provider.chat_stream_with_retry.side_effect = RuntimeError("LLM unavailable")
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:rawdrop")
session.provider_state = _provider_state()
for i in range(18):
session.add_message("user", f"user msg {i}")
session.add_message("assistant", f"assistant msg {i}")
session.add_message("user", "final user follow-up")
session.add_message("assistant", "RETAINED_SUFFIX_marker")
sessions.save(session)
await real_consolidator.compact_idle_session(
"cli:rawdrop", runtime=runtime, max_suffix=8
)
raw = "\n".join(e["content"] for e in store.read_unprocessed_history(since_cursor=0))
assert "[RAW]" in raw
assert "user msg 0" in raw
assert "RETAINED_SUFFIX_marker" in raw
reloaded = sessions.get_or_create("cli:rawdrop")
assert len(reloaded.messages) == 39
assert reloaded.messages[-2]["content"] == "RETAINED_SUFFIX_marker"
assert reloaded.provider_state is None
@pytest.mark.asyncio
async def test_idle_compact_writes_session_key_to_history(
self,
real_consolidator,
mock_provider,
store,
runtime,
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="Summary of old conversation.", finish_reason="stop"
)
session = real_consolidator.sessions.get_or_create("cli:test")
for i in range(10):
session.add_message("user", f"user msg {i}")
session.add_message("assistant", f"assistant msg {i}")
real_consolidator.sessions.save(session)
await real_consolidator.compact_idle_session(
"cli:test", runtime=runtime, max_suffix=4
)
entries = store.read_unprocessed_history(since_cursor=0)
assert entries[0]["session_key"] == "cli:test"
@pytest.mark.asyncio
async def test_empty_session_does_not_refresh_timestamp(
self, real_consolidator, runtime
):
from datetime import datetime, timedelta
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:empty")
old_ts = datetime.now() - timedelta(hours=2)
session.updated_at = old_ts
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"cli:empty", runtime=runtime
)
assert result == ""
reloaded = sessions.get_or_create("cli:empty")
assert reloaded.updated_at == old_ts
assert reloaded.metadata == {}
@pytest.mark.asyncio
async def test_nothing_commits_checkpoint_once_without_raw_archive(
self, real_consolidator, mock_provider, runtime
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="(nothing)", finish_reason="stop"
)
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:nothing")
for i in range(10):
session.add_message("user", f"u{i}")
session.add_message("assistant", f"a{i}")
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"cli:nothing", runtime=runtime, max_suffix=4
)
second = await real_consolidator.compact_idle_session(
"cli:nothing", runtime=runtime, max_suffix=4
)
assert result == "(nothing)"
assert second == ""
reloaded = sessions.get_or_create("cli:nothing")
assert reloaded.metadata["_last_summary"]["text"] == result
assert real_consolidator.store.read_unprocessed_history(0) == []
assert reloaded.last_archived == 20
assert reloaded.get_history() == []
mock_provider.chat_stream_with_retry.assert_awaited_once()
@pytest.mark.asyncio
async def test_llm_failure_preserves_history_but_advances_replay_boundary(
self, real_consolidator, mock_provider, store, runtime
):
mock_provider.chat_stream_with_retry.side_effect = RuntimeError("LLM unavailable")
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:fail")
session.add_message("user", "/compact", _command=True)
session.add_message("assistant", "Nothing to compact.", _command=True)
for i in range(10):
session.add_message("user", f"u{i}")
session.add_message("assistant", f"a{i}")
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"cli:fail", runtime=runtime, max_suffix=4
)
assert result is not None
assert "[RAW]" in result
entries = store.read_unprocessed_history(since_cursor=0)
assert entries[0]["content"].startswith("[RAW] 20 messages")
reloaded = sessions.get_or_create("cli:fail")
assert reloaded.messages[:-1] == session.messages
assert reloaded.last_archived == 22
assert reloaded.metadata["_last_summary"]["text"] == result
assert reloaded.get_history(max_messages=20) == []
@pytest.mark.asyncio
async def test_respects_last_archived(
self, real_consolidator, mock_provider, runtime
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="Tail summary.", finish_reason="stop"
)
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:offset")
for i in range(30):
session.add_message("user", f"u{i}")
session.add_message("assistant", f"a{i}")
session.last_archived = 50
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"cli:offset", runtime=runtime, max_suffix=4
)
assert result == "Tail summary."
reloaded = sessions.get_or_create("cli:offset")
assert len(reloaded.messages) == 61
assert reloaded.last_archived == 60
archived_call = mock_provider.chat_stream_with_retry.call_args
sent_messages = archived_call.kwargs["messages"]
sent_content = [message.get("content") for message in sent_messages]
assert "u0" not in sent_content
assert "u26" in sent_content
assert sent_messages[-1]["content"] == _ARCHIVE_PROMPT
@pytest.mark.asyncio
async def test_full_archive_replaces_entire_tool_turn(
self,
real_consolidator,
mock_provider,
runtime,
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="Tail summary.", finish_reason="stop"
)
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:noncontiguous")
for i in range(15):
session.add_message("user", f"user-{i:02d}")
for i in range(10):
session.add_message("assistant", f"assistant-{i:02d}")
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"cli:noncontiguous", runtime=runtime, max_suffix=6
)
assert result == "Tail summary."
reloaded = sessions.get_or_create("cli:noncontiguous")
assert len(reloaded.messages) == 26
assert reloaded.last_archived == 25
assert reloaded.get_history(max_messages=25) == []
archived_call = mock_provider.chat_stream_with_retry.call_args
sent_content = [message.get("content") for message in archived_call.kwargs["messages"]]
assert "user-00" in sent_content
assert "assistant-09" in sent_content
assert "user-14" in sent_content
@pytest.mark.asyncio
async def test_preserves_tool_history_and_persists_only_overview(
self,
real_consolidator,
mock_provider,
store,
runtime,
):
tools = [{"type": "function", "function": {"name": "lookup"}}]
real_consolidator.archiver._get_tool_definitions.return_value = tools
mock_provider.chat_stream_with_retry.return_value = LLMResponse(
content="Overview from the temporary turn.",
finish_reason="stop",
)
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:tool-history")
session.add_message("user", "look this up")
session.messages.extend(_tool_round("call-1"))
session.add_message("assistant", "final answer")
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"cli:tool-history",
runtime=runtime,
)
assert result == "Overview from the temporary turn."
call = mock_provider.chat_stream_with_retry.call_args.kwargs
sent_messages = call["messages"]
assert [message["role"] for message in sent_messages] == [
"system",
"user",
"assistant",
"tool",
"assistant",
"user",
]
assert sent_messages[2]["tool_calls"][0]["id"] == "call-1"
assert sent_messages[-1]["content"] == _ARCHIVE_PROMPT
assert call["tools"] == tools
assert "tool_choice" not in call
reloaded = sessions.get_or_create("cli:tool-history")
assert len(reloaded.messages) == 5
assert reloaded.messages[-2]["content"] == "final answer"
assert all(
"memory overview" not in str(message.get("content", "")).lower()
for message in reloaded.messages
)
entries = store.read_unprocessed_history(since_cursor=0)
assert [entry["content"] for entry in entries] == [
"Overview from the temporary turn."
]
@pytest.mark.asyncio
async def test_tool_call_response_retries_with_disabled_tool_results(
self,
real_consolidator,
mock_provider,
store,
runtime,
):
tools = [
{"type": "function", "function": {"name": "lookup"}},
{"type": "function", "function": {"name": "read_file"}},
]
real_consolidator.archiver._get_tool_definitions.return_value = tools
mock_provider.chat_stream_with_retry.side_effect = [
LLMResponse(
content=None,
tool_calls=[
ToolCallRequest(id="call-1", name="lookup", arguments={}),
ToolCallRequest(id="call-2", name="read_file", arguments={}),
],
finish_reason="stop",
provider_state=_provider_state(),
),
LLMResponse(content="Recovered archive summary.", finish_reason="stop"),
]
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:unexpected-tool")
session.add_message("user", "remember this")
session.add_message("assistant", "important answer")
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"cli:unexpected-tool",
runtime=runtime,
)
assert result == "Recovered archive summary."
assert mock_provider.chat_stream_with_retry.await_count == 2
first_call, recovery_call = mock_provider.chat_stream_with_retry.await_args_list
assert first_call.kwargs["tools"] == recovery_call.kwargs["tools"] == tools
assert first_call.kwargs["provider_context"] is None
assert recovery_call.kwargs["provider_context"] is None
assert "tool_choice" not in first_call.kwargs
assert "tool_choice" not in recovery_call.kwargs
recovery_messages = recovery_call.kwargs["messages"]
assert [message["role"] for message in recovery_messages[-3:]] == [
"assistant",
"tool",
"tool",
]
assert [message["tool_call_id"] for message in recovery_messages[-2:]] == [
"call-1",
"call-2",
]
assert all(
"does not execute tools" in message["content"]
for message in recovery_messages[-2:]
)
entries = store.read_unprocessed_history(since_cursor=0)
assert [entry["content"] for entry in entries] == ["Recovered archive summary."]
assert sessions.get_or_create("cli:unexpected-tool").last_archived == 2
@pytest.mark.asyncio
async def test_repeated_tool_call_response_uses_raw_fallback(
self,
real_consolidator,
mock_provider,
store,
runtime,
):
tool_response = LLMResponse(
content=None,
tool_calls=[ToolCallRequest(id="call-1", name="lookup", arguments={})],
finish_reason="tool_calls",
)
mock_provider.chat_stream_with_retry.side_effect = [tool_response, tool_response]
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:repeated-tool")
session.add_message("user", "remember this")
session.add_message("assistant", "important answer")
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"cli:repeated-tool",
runtime=runtime,
)
assert result is not None
assert "[RAW]" in result
assert mock_provider.chat_stream_with_retry.await_count == 2
entries = store.read_unprocessed_history(since_cursor=0)
assert len(entries) == 1
assert "important answer" in entries[0]["content"]
assert sessions.get_or_create("cli:repeated-tool").last_archived == 2
@pytest.mark.asyncio
async def test_empty_response_uses_raw_fallback(
self,
real_consolidator,
mock_provider,
store,
runtime,
):
mock_provider.chat_stream_with_retry.return_value = LLMResponse(
content="",
finish_reason="stop",
)
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:empty-summary")
session.add_message("user", "remember this")
session.add_message("assistant", "important answer")
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"cli:empty-summary",
runtime=runtime,
)
assert result is not None
assert "[RAW]" in result
entries = store.read_unprocessed_history(since_cursor=0)
assert len(entries) == 1
assert entries[0]["content"].startswith("[RAW] ")
assert "important answer" in entries[0]["content"]
assert sessions.get_or_create("cli:empty-summary").last_archived == 2
@pytest.mark.asyncio
async def test_oversized_prefix_raw_archives_without_flattened_llm_retry(
self,
real_consolidator,
mock_provider,
store,
runtime,
):
runtime = replace(runtime, context_window_tokens=1_000)
sessions = real_consolidator.sessions
session = sessions.get_or_create("sdk:oversized")
session.add_message("user", "x" * 100_000)
sessions.save(session)
result = await real_consolidator.compact_idle_session(
"sdk:oversized",
runtime=runtime,
)
assert result is not None
assert "[RAW]" in result
mock_provider.chat_stream_with_retry.assert_not_awaited()
entries = store.read_unprocessed_history(since_cursor=0)
assert len(entries) > 1
assert all(entry["content"].startswith("[RAW] ") for entry in entries)
assert "x" * 100_000 in "".join(entry["content"].split("\n", 1)[1] for entry in entries)
assert sessions.get_or_create("sdk:oversized").last_archived == 1
@pytest.mark.asyncio
async def test_archive_context_contains_only_model_visible_messages(
self,
real_consolidator,
mock_provider,
runtime,
):
mock_provider.chat_stream_with_retry.return_value = LLMResponse(
content="Summary.",
finish_reason="stop",
)
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:commands")
session.add_message("user", "already archived user")
session.add_message("assistant", "already archived answer")
session.last_archived = 2
session.add_message("user", "/status", _command=True)
session.add_message("assistant", "status output", _command=True)
session.add_message("user", "new user")
session.add_message("assistant", "new answer")
sessions.save(session)
await real_consolidator.compact_idle_session(
"cli:commands",
runtime=runtime,
)
sent = mock_provider.chat_stream_with_retry.call_args.kwargs["messages"]
assert [message.get("content") for message in sent[1:-1]] == [
"new user",
"new answer",
]
assert sent[-1]["content"] == _ARCHIVE_PROMPT
@pytest.mark.asyncio
async def test_reuses_real_prefix_for_unified_session_workspace(
self,
loop_factory,
mock_provider,
tmp_path,
):
project = tmp_path / "project"
project.mkdir()
(tmp_path / "AGENTS.md").write_text("GLOBAL_WORKSPACE_MARKER", encoding="utf-8")
(project / "AGENTS.md").write_text("PROJECT_WORKSPACE_MARKER", encoding="utf-8")
loop = loop_factory(provider=mock_provider, unified_session=True)
runtime = loop.llm_runtime()
runtime.provider.chat_stream_with_retry.return_value = LLMResponse(
content="Summary.",
finish_reason="stop",
)
session = loop.sessions.get_or_create(UNIFIED_SESSION_KEY)
remember_last_channel(session.metadata, "websocket", "scope")
session.metadata["workspace_scope"] = {
"project_path": str(project),
"access_mode": "restricted",
}
session.add_message("user", "project question")
session.add_message("assistant", "project answer")
loop.sessions.save(session)
ordinary_messages = loop.context.build_messages(
history=session.get_history(max_messages=0),
current_message="next project question",
channel="websocket",
workspace=project,
)
await loop.consolidator.compact_idle_session(
session.key,
runtime=runtime,
)
sent_messages = runtime.provider.chat_stream_with_retry.call_args.kwargs["messages"]
assert sent_messages[:-1] == ordinary_messages[:-1]
assert sent_messages[-1]["content"] == _ARCHIVE_PROMPT
system = sent_messages[0]["content"]
assert "PROJECT_WORKSPACE_MARKER" in system
assert "GLOBAL_WORKSPACE_MARKER" not in system
@pytest.mark.asyncio
async def test_acquires_consolidation_lock(
self, real_consolidator, mock_provider, runtime
):
import asyncio
started = asyncio.Event()
release_chat = asyncio.Event()
async def slow_chat(**kwargs):
started.set()
await release_chat.wait()
return LLMResponse(content="Summary.", finish_reason="stop")
mock_provider.chat_stream_with_retry = slow_chat
sessions = real_consolidator.sessions
session = sessions.get_or_create("cli:lock")
for i in range(10):
session.add_message("user", f"u{i}")
session.add_message("assistant", f"a{i}")
sessions.save(session)
lock = real_consolidator.get_lock("cli:lock")
assert not lock.locked()
task = asyncio.ensure_future(
real_consolidator.compact_idle_session(
"cli:lock", runtime=runtime, max_suffix=4
)
)
await started.wait()
assert lock.locked()
release_chat.set()
await task
assert not lock.locked()
class TestRawArchiveChunks:
@pytest.mark.parametrize("boundary", ["A ", "\n\n", "<think>PRIVATE</think>"])
def test_raw_chunks_preserve_sanitized_boundaries(self, store, boundary):
from nanobot.utils.helpers import strip_think
message = {"role": "assistant", "content": ""}
prefix_len = len(store._format_messages([{**message, "content": "x"}])) - 1
message["content"] = "x" * (16_000 - prefix_len - 2) + boundary + "PUBLIC_TAIL"
expected = strip_think(store._format_messages([message]))
store.raw_archive([message])
entries = MemoryStore(store.workspace).read_unprocessed_history(since_cursor=0)
joined = "".join(entry["content"].split("\n", 1)[1] for entry in entries)
assert joined == expected
assert "PRIVATE" not in joined
assert "PUBLIC_TAIL" in joined
def test_raw_archive_splits_large_content_into_bounded_entries(self, store):
big = "x" * 50_000
messages = [{"role": "user", "content": big}]
store.raw_archive(messages)
entries = store.read_unprocessed_history(since_cursor=0)
assert len(entries) > 1
assert len(entries[0]["content"]) < 50_000
assert "[RAW]" in entries[0]["content"]
def test_raw_archive_preserves_small_content(self, store):
messages = [{"role": "user", "content": "hello"}]
store.raw_archive(messages)
entries = store.read_unprocessed_history(since_cursor=0)
assert len(entries) == 1
assert "hello" in entries[0]["content"]
def test_raw_archive_returns_the_sanitized_persisted_checkpoint(self, store):
messages = [
{
"role": "user",
"content": "<think>PRIVATE_REASONING</think>visible result",
}
]
checkpoint = store.raw_archive(messages, session_key="cli:test")
persisted = store.read_unprocessed_history(since_cursor=0)[0]["content"]
assert checkpoint == persisted
assert "PRIVATE_REASONING" not in checkpoint
assert "visible result" in checkpoint
def test_raw_archive_excludes_model_only_runtime_context(self, store):
content, marker = append_runtime_context(
"ship the feature",
[RuntimeContextBlock(source="goal", content="host-only goal guidance")],
)
store.raw_archive([{
"role": "user",
"content": content,
RUNTIME_CONTEXT_HISTORY_META: marker,
}])
entry = store.read_unprocessed_history(since_cursor=0)[0]["content"]
assert "ship the feature" in entry
assert "host-only goal guidance" not in entry
def test_raw_archive_preserves_session_key(self, store):
messages = [{"role": "user", "content": "hello"}]
store.raw_archive(messages, session_key="websocket:chat-1")
entries = store.read_unprocessed_history(since_cursor=0)
assert entries[0]["session_key"] == "websocket:chat-1"
def test_raw_archive_custom_max_chars(self, store):
messages = [{"role": "user", "content": "a" * 200}]
store.raw_archive(messages, max_chars=100)
entries = store.read_unprocessed_history(since_cursor=0)
assert len(entries[0]["content"]) < 200
@pytest.mark.parametrize("limit", [100, 100_000])
def test_raw_chunks_keep_tail_with_custom_limit(self, store, limit):
messages = [{"role": "user", "content": "x " * 40_000 + "TAIL_MARKER"}]
expected = store._format_messages(messages)
checkpoint = store.raw_archive(messages, max_chars=limit, session_key="cli:chunks")
entries = MemoryStore(store.workspace).read_unprocessed_history(since_cursor=0)
assert "".join(entry["content"].split("\n", 1)[1] for entry in entries) == expected
assert all(len(entry["content"]) <= _HISTORY_ENTRY_HARD_CAP for entry in entries)
assert all(entry["session_key"] == "cli:chunks" for entry in entries)
assert checkpoint == store._build_raw_checkpoint(messages, max_chars=limit)
class TestArchivePersistence:
async def test_archive_returns_the_sanitized_persisted_summary(
self, consolidator, mock_provider, store, runtime
):
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="<think>PRIVATE_REASONING</think>safe summary",
finish_reason="stop",
has_tool_calls=False,
)
summary = await _archive(
consolidator,
[{"role": "user", "content": "hi"}],
runtime,
)
persisted = store.read_unprocessed_history(since_cursor=0)[0]["content"]
assert summary is not None
assert summary == persisted == "safe summary"
async def test_oversized_summary_uses_history_emergency_cap(
self, consolidator, mock_provider, store, runtime
):
"""A pathologically large LLM summary must not land full-length in
history.jsonl — that would re-open the #3412 bloat vector from the
*success* path instead of the fallback path."""
mock_provider.chat_stream_with_retry.return_value = MagicMock(
content="S" * (_HISTORY_ENTRY_HARD_CAP * 2),
finish_reason="stop",
)
summary = await _archive(
consolidator,
[{"role": "user", "content": "hi"}],
runtime,
)
entry = store.read_unprocessed_history(since_cursor=0)[0]
assert len(entry["content"]) <= _HISTORY_ENTRY_HARD_CAP + 50
assert summary is not None
assert summary == entry["content"]