Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
"""Context retrieval tests"""
import asyncio
import json
from functools import partial
import pytest
import pytest_asyncio
from openviking.message import Message, TextPart
from openviking.server.identity import RequestContext
from openviking.service.core import OpenVikingService
from openviking.service.task_tracker import get_task_tracker
from openviking.session import Session
from openviking.storage.abstract_overview import body_for_preview
from openviking.storage.queuefs import QueueManager, SessionCommitMsg, get_queue_manager
from openviking_cli.utils.config import get_openviking_config
from openviking_cli.utils.config.vlm_config import VLMConfig
def _install_fake_vlm(monkeypatch):
async def _fake_get_completion(self, prompt, thinking=False, max_retries=0):
return "# Test Summary\n\nFake summary for testing.\n\n## Details\nTest content."
async def _fake_get_vision_completion(self, prompt, images, thinking=False):
return "Fake image description for testing."
monkeypatch.setattr(VLMConfig, "is_available", lambda self: True)
monkeypatch.setattr(VLMConfig, "get_completion_async", _fake_get_completion)
monkeypatch.setattr(VLMConfig, "get_vision_completion_async", _fake_get_vision_completion)
@pytest_asyncio.fixture(scope="function")
async def client(
service: OpenVikingService,
request_context: RequestContext,
monkeypatch,
working_memory_policy,
):
service.sessions.set_default_user_memory_policy(working_memory_policy)
_install_fake_vlm(monkeypatch)
monkeypatch.setattr(get_openviking_config().memory, "extraction_enabled", False)
client = partial(service.sessions.session, request_context)
queue_manager = get_queue_manager()
original_enqueue = queue_manager.enqueue
commit_tasks: list[asyncio.Task] = []
queued_commit_tasks: set[str] = set()
tracker = get_task_tracker()
original_has_work = tracker.has_work
async def has_work(task_id, **kwargs):
return task_id in queued_commit_tasks or await original_has_work(task_id, **kwargs)
monkeypatch.setattr(
tracker,
"has_work",
has_work,
)
async def enqueue_with_session_commit_fallback(queue_name, data):
if queue_name != QueueManager.SESSION_COMMIT:
return await original_enqueue(queue_name, data)
queued_commit_tasks.add(data["task_id"])
async def process_commit():
message = SessionCommitMsg(**data)
queued_session = client(session_id=message.session_id)
while True:
phase1 = await queued_session._read_phase1_meta(message.archive_uri)
if phase1.get("status") == "ready":
break
await asyncio.sleep(0)
await queued_session.load()
try:
while not await queued_session.resume_queued_commit(message):
await asyncio.sleep(0)
finally:
queued_commit_tasks.discard(message.task_id)
commit_tasks.append(asyncio.create_task(process_commit()))
return data["task_id"]
monkeypatch.setattr(queue_manager, "enqueue", enqueue_with_session_commit_fallback)
yield client
if commit_tasks:
await asyncio.gather(*commit_tasks, return_exceptions=True)
def _estimate_tokens(text: str) -> int:
return -(-len(text) // 4)
async def _wait_for_task(task_id: str, timeout: float = 30.0) -> dict:
tracker = get_task_tracker()
for _ in range(int(timeout / 0.1)):
task = await tracker.get(task_id)
if task and task.status.value in ("completed", "failed"):
return task.to_dict()
await asyncio.sleep(0.1)
raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")
async def test_oversized_legacy_assistant_only_commit_completes_without_checkpoint(
client: partial,
):
session = client(session_id="legacy_assistant_only_turn_test")
await session.ensure_exists()
for index in range(3):
session.add_message("assistant", [TextPart(str(index) * 1000)])
result = await session.commit_async(
retention_mode="turn_budget",
keep_recent_turn_count=1,
retained_message_token_budget=150,
min_raw_tail_steps=1,
)
task = await _wait_for_task(result["task_id"])
context = await session.get_session_context()
assert task["status"] == "completed"
assert context["latest_archive_overview"]
assert context["messages"] == []
archive_meta = json.loads(
await session._viking_fs.read_file(
f"{result['archive_uri']}/.meta.json",
ctx=session.ctx,
)
)
assert archive_meta["retention_plan"]["partial_turn"] is False
assert archive_meta["retention_plan"]["turn_anchor_message_id"] is None
assert archive_meta.get("checkpoints", []) == []
class TestGetContextForSearch:
"""Test get_context_for_search"""
async def test_get_context_basic(self, session_with_messages: Session):
"""Test basic context retrieval"""
context = await session_with_messages.get_context_for_search(query="testing help")
assert isinstance(context, dict)
assert "latest_archive_overview" in context
assert "current_messages" in context
async def test_get_context_with_max_messages(self, session_with_messages: Session):
"""Test limiting max messages"""
context = await session_with_messages.get_context_for_search(query="test", max_messages=2)
assert isinstance(context, dict)
assert len(context["current_messages"]) <= 2
async def test_get_context_returns_latest_completed_archive_only(self, client: partial):
"""Current context should expose only the latest completed archive overview."""
session = client(session_id="archive_context_test")
await session.ensure_exists()
session.add_message("user", [TextPart("First message")])
session.add_message("assistant", [TextPart("First response")])
result1 = await session.commit_async()
await _wait_for_task(result1["task_id"])
session.add_message("user", [TextPart("Second message")])
session.add_message("assistant", [TextPart("Second response")])
session.add_message("user", [TextPart("Third message")])
result2 = await session.commit_async()
await _wait_for_task(result2["task_id"])
latest_overview = await session._viking_fs.read_file(
f"{result2['archive_uri']}/.overview.md",
ctx=session.ctx,
)
session.add_message("user", [TextPart("Current message")])
context = await session.get_context_for_search(query="test")
assert isinstance(context, dict)
assert context["latest_archive_overview"] == body_for_preview(latest_overview)
assert len(context["current_messages"]) == 1
async def test_get_context_skips_incomplete_latest_archive(self, client: partial):
"""Incomplete archives without .done must not replace the latest completed overview."""
session = client(session_id="archive_context_incomplete_test")
await session.ensure_exists()
session.add_message("user", [TextPart("First message")])
session.add_message("assistant", [TextPart("First response")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
completed_overview = await session._viking_fs.read_file(
f"{result['archive_uri']}/.overview.md",
ctx=session.ctx,
)
await session._viking_fs.write_file(
uri=f"{session.uri}/history/archive_999/.overview.md",
content="INCOMPLETE OVERVIEW",
ctx=session.ctx,
)
context = await session.get_context_for_search(query="test")
assert context["latest_archive_overview"] == body_for_preview(completed_overview)
async def test_get_context_includes_incomplete_archive_messages(self, client: partial):
"""Pending archive messages should be merged with current live messages."""
session = client(session_id="archive_context_pending_messages_test")
await session.ensure_exists()
session.add_message("user", [TextPart("First message")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
pending_messages = [
Message(id="pending-user", role="user", parts=[TextPart("Pending user message")]),
Message(
id="pending-assistant",
role="assistant",
parts=[TextPart("Pending assistant response")],
),
]
await session._viking_fs.write_file(
uri=f"{session.uri}/history/archive_002/messages.jsonl",
content="\n".join(msg.to_jsonl() for msg in pending_messages) + "\n",
ctx=session.ctx,
)
session.add_message("user", [TextPart("Current live message")])
context = await session.get_context_for_search(query="test")
assert [m.content for m in context["current_messages"]] == [
"Pending user message",
"Pending assistant response",
"Current live message",
]
async def test_get_context_max_messages_applies_after_pending_merge(self, client: partial):
"""max_messages should trim the merged pending + live message sequence."""
session = client(session_id="archive_context_pending_max_messages_test")
await session.ensure_exists()
session.add_message("user", [TextPart("First message")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
pending_messages = [
Message(id="pending-1", role="user", parts=[TextPart("Pending 1")]),
Message(id="pending-2", role="assistant", parts=[TextPart("Pending 2")]),
]
await session._viking_fs.write_file(
uri=f"{session.uri}/history/archive_002/messages.jsonl",
content="\n".join(msg.to_jsonl() for msg in pending_messages) + "\n",
ctx=session.ctx,
)
session.add_message("user", [TextPart("Live 1")])
session.add_message("assistant", [TextPart("Live 2")])
context = await session.get_context_for_search(query="test", max_messages=3)
assert [m.content for m in context["current_messages"]] == [
"Pending 2",
"Live 1",
"Live 2",
]
async def test_get_context_empty_session(self, session: Session):
"""Test getting context from empty session"""
context = await session.get_context_for_search(query="test")
assert isinstance(context, dict)
assert context["latest_archive_overview"] == ""
assert context["current_messages"] == []
async def test_get_context_after_commit(self, client: partial):
"""Test getting context after commit"""
session = client(session_id="post_commit_context_test")
await session.ensure_exists()
session.add_message("user", [TextPart("Test message before commit")])
session.add_message("assistant", [TextPart("Response before commit")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
session.add_message("user", [TextPart("New message after commit")])
context = await session.get_context_for_search(query="test")
assert isinstance(context, dict)
assert context["latest_archive_overview"]
assert len(context["current_messages"]) == 1
async def test_get_context_tracks_multiple_rapid_commits_by_done_boundary(
self, client: partial, monkeypatch
):
"""Context should only advance latest overview when the earlier archive is .done."""
session = client(session_id="archive_context_done_boundary_test")
await session.ensure_exists()
first_gate = asyncio.Event()
second_gate = asyncio.Event()
second_started = asyncio.Event()
async def gated_summary(self, prompt, **kwargs):
del self, kwargs
if "First round" in prompt:
await first_gate.wait()
return "# First Summary\n\nFirst archive completed."
second_started.set()
await second_gate.wait()
return "# Second Summary\n\nSecond archive completed."
monkeypatch.setattr(VLMConfig, "get_completion_async", gated_summary)
session.add_message("user", [TextPart("First round user")])
session.add_message("assistant", [TextPart("First round assistant")])
result1 = await session.commit_async()
session.add_message("user", [TextPart("Second round user")])
session.add_message("assistant", [TextPart("Second round assistant")])
result2 = await session.commit_async()
context = await session.get_context_for_search(query="test")
assert context["latest_archive_overview"] == ""
assert [m.content for m in context["current_messages"]] == [
"First round user",
"First round assistant",
"Second round user",
"Second round assistant",
]
first_gate.set()
await asyncio.wait_for(second_started.wait(), timeout=5.0)
first_overview = await session._viking_fs.read_file(
f"{result1['archive_uri']}/.overview.md",
ctx=session.ctx,
)
context = await session.get_context_for_search(query="test")
assert context["latest_archive_overview"] == body_for_preview(first_overview)
assert [m.content for m in context["current_messages"]] == [
"Second round user",
"Second round assistant",
]
second_gate.set()
await _wait_for_task(result1["task_id"])
await _wait_for_task(result2["task_id"])
second_overview = await session._viking_fs.read_file(
f"{result2['archive_uri']}/.overview.md",
ctx=session.ctx,
)
context = await session.get_context_for_search(query="test")
assert context["latest_archive_overview"] == body_for_preview(second_overview)
assert context["current_messages"] == []
class TestGetSessionContext:
"""Test get_session_context"""
async def test_get_session_context_returns_latest_archive_overview_and_history(
self, client: partial, monkeypatch
):
session = client(session_id="assemble_trim_test")
await session.ensure_exists()
summaries = [
"# Session Summary\n\n" + ("A" * 80),
"# Session Summary\n\n" + ("B" * 20),
]
async def fake_generate(self, _messages, latest_archive_overview="", **kwargs):
del self, latest_archive_overview, kwargs
return summaries.pop(0)
monkeypatch.setattr(Session, "_generate_archive_summary_async", fake_generate)
session.add_message("user", [TextPart("first turn")])
session.add_message("assistant", [TextPart("first reply")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
session.add_message("user", [TextPart("second turn")])
session.add_message("assistant", [TextPart("second reply")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
session.add_message("user", [TextPart("active tail")])
newest_summary = "# Session Summary\n\n" + ("B" * 20)
active_tokens = sum(message.estimated_tokens for message in session.messages)
token_budget = active_tokens + _estimate_tokens(newest_summary)
context = await session.get_session_context(token_budget=token_budget)
assert context["latest_archive_overview"] == newest_summary
assert context["pre_archive_abstracts"] == []
assert len(context["messages"]) == 1
assert context["messages"][0]["parts"][0]["text"] == "active tail"
assert context["estimatedTokens"] == token_budget
assert context["stats"] == {
"totalArchives": 2,
"includedArchives": 0,
"droppedArchives": 2,
"failedArchives": 0,
"activeTokens": active_tokens,
"archiveTokens": _estimate_tokens(newest_summary),
}
async def test_get_session_context_counts_active_tool_parts(
self, session_with_tool_call: tuple[Session, str, str]
):
session, _message_id, tool_id = session_with_tool_call
context = await session.get_session_context()
assert len(context["messages"]) == 1
tool_parts = [part for part in context["messages"][0]["parts"] if part["type"] == "tool"]
assert tool_parts[0]["tool_id"] == tool_id
assert context["stats"]["activeTokens"] == session.messages[0].estimated_tokens
assert context["stats"]["activeTokens"] > _estimate_tokens("Executing tool...")
async def test_get_session_context_stops_at_newest_terminal_without_abstracts(
self, client: partial, monkeypatch
):
"""Newest completed supplies overview; abstracts are never read for context."""
session = client(session_id="assemble_lazy_read_test")
await session.ensure_exists()
summaries = [
"# Summary\n\n" + ("A" * 80),
"# Summary\n\n" + ("B" * 80),
"# Summary\n\n" + ("C" * 80),
]
async def fake_generate(self, _messages, latest_archive_overview="", **kwargs):
del self, latest_archive_overview, kwargs
return summaries.pop(0)
monkeypatch.setattr(Session, "_generate_archive_summary_async", fake_generate)
for word in ("first", "second", "third"):
session.add_message("user", [TextPart(f"{word} turn")])
session.add_message("assistant", [TextPart(f"{word} reply")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
session.add_message("user", [TextPart("active tail")])
newest_summary = "# Summary\n\n" + ("C" * 80)
active_tokens = sum(m.estimated_tokens for m in session.messages)
token_budget = active_tokens + _estimate_tokens(newest_summary)
original_read_file = session._viking_fs.read_file
read_uris: list[str] = []
async def tracking_read_file(*args, **kwargs):
uri = args[0] if args else kwargs.get("uri")
read_uris.append(uri)
return await original_read_file(*args, **kwargs)
monkeypatch.setattr(session._viking_fs, "read_file", tracking_read_file)
context = await session.get_session_context(token_budget=token_budget)
assert context["latest_archive_overview"] == newest_summary
assert context["pre_archive_abstracts"] == []
assert context["stats"]["includedArchives"] == 0
assert context["stats"]["totalArchives"] == 3
abstract_reads = [u for u in read_uris if u.endswith(".abstract.md")]
assert abstract_reads == [], f"Old abstracts must not be read, got: {abstract_reads}"
overview_reads = [u for u in read_uris if u.endswith(".overview.md")]
assert overview_reads, (
f"Newest terminal overview should be available, got: {overview_reads}"
)
assert any("archive_003" in u for u in overview_reads), (
f"Newest completed overview should be read, got: {overview_reads}"
)
async def test_get_session_context_does_not_touch_archives_older_than_terminal(
self, client: partial, monkeypatch
):
"""Scan cost must not grow with history length.
Archive history grows without bound, so the read path stops at the newest
terminal marker: no marker, overview, meta or messages read may reference
an older archive.
"""
session = client(session_id="assemble_terminal_stop_cost_test")
await session.ensure_exists()
summaries = [f"# Summary\n\narchive {index}" for index in range(1, 5)]
async def fake_generate(self, _messages, latest_archive_overview="", **kwargs):
del self, latest_archive_overview, kwargs
return summaries.pop(0)
monkeypatch.setattr(Session, "_generate_archive_summary_async", fake_generate)
for word in ("first", "second", "third", "fourth"):
session.add_message("user", [TextPart(f"{word} turn")])
session.add_message("assistant", [TextPart(f"{word} reply")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
session.add_message("user", [TextPart("active tail")])
touched: list[str] = []
original_read_file = session._viking_fs.read_file
original_exists = session._viking_fs.exists
async def tracking_read_file(*args, **kwargs):
touched.append(args[0] if args else kwargs.get("uri"))
return await original_read_file(*args, **kwargs)
async def tracking_exists(*args, **kwargs):
touched.append(args[0] if args else kwargs.get("uri"))
return await original_exists(*args, **kwargs)
monkeypatch.setattr(session._viking_fs, "read_file", tracking_read_file)
monkeypatch.setattr(session._viking_fs, "exists", tracking_exists)
context = await session.get_session_context()
assert context["latest_archive_overview"].endswith("archive 4")
stale = [
uri
for uri in touched
if isinstance(uri, str) and any(f"archive_{index:03d}" in uri for index in (1, 2, 3))
]
assert stale == [], f"Archives older than the terminal must not be read: {stale}"
async def test_get_session_context_pre_archive_abstracts_always_empty(
self, client: partial, monkeypatch
):
session = client(session_id="assemble_trim_oldest_abstracts_test")
await session.ensure_exists()
summaries = [
"# Summary\n\n" + ("A" * 80),
"# Summary\n\n" + ("B" * 80),
"# Summary\n\n" + ("C" * 80),
]
async def fake_generate(self, _messages, latest_archive_overview="", **kwargs):
del self, latest_archive_overview, kwargs
return summaries.pop(0)
monkeypatch.setattr(Session, "_generate_archive_summary_async", fake_generate)
for word in ("first", "second", "third"):
session.add_message("user", [TextPart(f"{word} turn")])
session.add_message("assistant", [TextPart(f"{word} reply")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
session.add_message("user", [TextPart("active tail")])
newest_summary = "# Summary\n\n" + ("C" * 80)
active_tokens = sum(m.estimated_tokens for m in session.messages)
token_budget = active_tokens + _estimate_tokens(newest_summary)
context = await session.get_session_context(token_budget=token_budget)
assert context["latest_archive_overview"] == newest_summary
assert context["pre_archive_abstracts"] == []
assert context["estimatedTokens"] == (active_tokens + _estimate_tokens(newest_summary))
assert context["stats"]["totalArchives"] == 3
assert context["stats"]["includedArchives"] == 0
assert context["stats"]["droppedArchives"] == 3
async def test_get_session_context_newest_done_unreadable_overview_does_not_fallback(
self, client: partial, monkeypatch
):
session = client(session_id="assemble_failed_archive_test")
await session.ensure_exists()
summaries = [
"# Session Summary\n\narchive one",
"# Session Summary\n\narchive two",
]
async def fake_generate(self, _messages, latest_archive_overview="", **kwargs):
del self, latest_archive_overview, kwargs
return summaries.pop(0)
monkeypatch.setattr(Session, "_generate_archive_summary_async", fake_generate)
session.add_message("user", [TextPart("turn one")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
session.add_message("user", [TextPart("turn two")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
original_read_file = session._viking_fs.read_file
async def flaky_read_file(*args, **kwargs):
uri = args[0] if args else kwargs.get("uri")
if isinstance(uri, str) and uri.endswith("archive_002/.overview.md"):
raise RuntimeError("simulated archive read failure")
return await original_read_file(*args, **kwargs)
monkeypatch.setattr(session._viking_fs, "read_file", flaky_read_file)
context = await session.get_session_context(token_budget=128_000)
# Newest terminal becomes failed/unusable for overview; no older fallback.
assert context["latest_archive_overview"] == ""
assert context["pre_archive_abstracts"] == []
assert context["stats"]["totalArchives"] == 2
assert context["stats"]["includedArchives"] == 0
assert context["stats"]["failedArchives"] == 1
async def test_get_session_context_newest_failed_skips_overview(
self, client: partial, monkeypatch
):
session = client(session_id="assemble_newest_failed_test")
await session.ensure_exists()
async def fake_generate(self, _messages, latest_archive_overview="", **kwargs):
del self, latest_archive_overview, kwargs
return "# Session Summary\n\narchive one"
monkeypatch.setattr(Session, "_generate_archive_summary_async", fake_generate)
session.add_message("user", [TextPart("turn one")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
await session._viking_fs.write_file(
uri=f"{session.uri}/history/archive_002/.failed.json",
content='{"stage":"summary","error":"boom"}',
ctx=session.ctx,
)
pending = Message(
id="pending-after-fail",
role="user",
parts=[TextPart("after failed archive")],
)
await session._viking_fs.write_file(
uri=f"{session.uri}/history/archive_003/messages.jsonl",
content=pending.to_jsonl() + "\n",
ctx=session.ctx,
)
session.add_message("user", [TextPart("live tail")])
context = await session.get_session_context(token_budget=128_000)
assert context["latest_archive_overview"] == ""
assert context["pre_archive_abstracts"] == []
assert [m["parts"][0]["text"] for m in context["messages"]] == [
"after failed archive",
"live tail",
]
assert context["stats"]["failedArchives"] == 1
async def test_get_session_context_budget_trim_drops_latest_archive_abstract(
self, client: partial, monkeypatch
):
session = client(session_id="assemble_trim_id_test")
await session.ensure_exists()
async def fake_generate(self, _messages, latest_archive_overview="", **kwargs):
del self, latest_archive_overview, kwargs
return "# Session Summary\n\n" + ("Z" * 80)
monkeypatch.setattr(Session, "_generate_archive_summary_async", fake_generate)
session.add_message("user", [TextPart("turn one")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
context = await session.get_session_context(token_budget=1)
assert context["latest_archive_overview"] == ""
assert context["pre_archive_abstracts"] == []
assert context["stats"]["includedArchives"] == 0
assert context["stats"]["droppedArchives"] == 1
async def test_get_session_context_returns_pending_messages_while_commit_running(
self, client: partial
):
"""Regression for #3129: when an archive has been written (Phase 1 done,
commit_count advanced) but its ``.done`` marker has not been written yet
(Phase 2 still running), ``get_session_context`` must still surface the
archived messages.
This test sets up the post-Phase-1 filesystem state directly — archive
directory + ``messages.jsonl`` + updated ``.meta.json``, no ``.done`` —
and then loads a fresh session from that state. It does **not** go
through ``commit_async``, so it is deterministic regardless of the
queue-worker architecture."""
session_id = "deterministic_pending_archive_test"
session = client(session_id=session_id)
await session.ensure_exists()
# Add messages to the session (in-memory only at this point).
session.add_message("user", [TextPart("Pending user message")])
session.add_message("assistant", [TextPart("Pending assistant response")])
# Build the post-Phase-1 filesystem state directly.
vfs = session._viking_fs
session_uri = session._session_uri
# Serialise current in-memory messages as JSONL for the archive.
archive_messages_jsonl = "\n".join(msg.to_jsonl() for msg in list(session.messages)) + "\n"
# Write archive directory + messages (Phase 1 done).
archive_dir = f"{session_uri}/history/archive_001"
await vfs.mkdir(archive_dir, exist_ok=True, ctx=session.ctx)
await vfs.write_file(
f"{archive_dir}/messages.jsonl",
archive_messages_jsonl,
ctx=session.ctx,
)
# Update .meta.json: bump commit_count to match the archive index.
meta = session._meta
meta.commit_count = 1
meta.message_count = 0
await vfs.write_file(
f"{session_uri}/.meta.json",
json.dumps(meta.to_dict(), ensure_ascii=False),
ctx=session.ctx,
)
# Clear live messages (Phase 1 trims these after archiving).
await vfs.write_file(f"{session_uri}/messages.jsonl", "", ctx=session.ctx)
# Crucially: do NOT write .done or .failed.json — Phase 2 is still
# running, so the archive must be treated as pending.
# Load a fresh session from the filesystem state we just wrote.
fresh_session = client(session_id=session_id)
# The pending archive's messages must be visible.
context = await fresh_session.get_session_context()
assert [m["parts"][0]["text"] for m in context["messages"]] == [
"Pending user message",
"Pending assistant response",
]
class TestGetSessionArchive:
"""Test get_session_archive"""
async def test_get_session_archive_returns_messages_and_summary(
self, client: partial, monkeypatch
):
session = client(session_id="session_archive_expand_test")
await session.ensure_exists()
summaries = [
"# Session Summary\n\narchive one",
"# Session Summary\n\narchive two",
]
async def fake_generate(self, _messages, latest_archive_overview="", **kwargs):
del self, latest_archive_overview, kwargs
return summaries.pop(0)
monkeypatch.setattr(Session, "_generate_archive_summary_async", fake_generate)
session.add_message("user", [TextPart("turn one")])
session.add_message("assistant", [TextPart("reply one")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
session.add_message("user", [TextPart("turn two")])
result = await session.commit_async()
await _wait_for_task(result["task_id"])
archive = await session.get_session_archive("archive_001")
assert archive["archive_id"] == "archive_001"
assert archive["abstract"] == "# Session Summary"
assert archive["overview"] == "# Session Summary\n\narchive one"
assert [m["parts"][0]["text"] for m in archive["messages"]] == ["turn one", "reply one"]
async def test_get_session_archive_raises_for_missing_archive(self, client: partial):
session = client(session_id="missing_session_archive_test")
await session.ensure_exists()
with pytest.raises(Exception, match="Session archive not found: archive_999"):
await session.get_session_archive("archive_999")