a9a5c70ee9
Gate r1 (2c + 2ab, Low): the cap check monkeypatched resolved_max_export_messages, so dropping the _session_profile_runtime_scope around the stored-session read in session.save stayed green. The cap now comes from a real config.yaml, and a tui-profile row launches the process from an uncapped HERMES_HOME: only the session profile's config refuses with 4131. Removing the scope line turns that row red.
152 lines
7.1 KiB
Python
152 lines
7.1 KiB
Python
"""/save md (CLI and gateway) carries the display history; /save json (CLI, gateway, TUI/Desktop) every kept row."""
|
|
import asyncio
|
|
import contextlib
|
|
import io
|
|
from datetime import datetime
|
|
from types import SimpleNamespace
|
|
from unittest.mock import AsyncMock, MagicMock
|
|
|
|
import pytest
|
|
|
|
|
|
def _compacted_store(path):
|
|
from hermes_state import SessionDB
|
|
|
|
db = SessionDB(db_path=path)
|
|
db.create_session("s1", "telegram")
|
|
for i in range(1, 7):
|
|
db.append_message("s1", "user", f"question {i}")
|
|
db.append_message("s1", "assistant", f"answer {i}")
|
|
tail = [{"role": "user", "content": "question 6"}, {"role": "assistant", "content": "answer 6"}]
|
|
db.archive_and_compact(
|
|
"s1", [{"role": "user", "content": "[CONTEXT COMPACTION] summary"}, *tail],
|
|
watermark=db.get_active_message_watermark("s1"), tail_count=len(tail),
|
|
)
|
|
return db
|
|
|
|
|
|
def _cli_save(db, fmt, out):
|
|
import cli
|
|
|
|
stub = SimpleNamespace(_session_db=db, session_id="s1", conversation_history=[], model="m",
|
|
session_start=datetime(2026, 1, 1))
|
|
printed = io.StringIO()
|
|
with contextlib.redirect_stdout(printed):
|
|
cli.HermesCLI.save_conversation(stub, f"/save {fmt} {out}")
|
|
return out.read_text(encoding="utf-8") if out.exists() else printed.getvalue()
|
|
|
|
|
|
def _gateway_save(db, fmt, out):
|
|
from gateway.config import Platform
|
|
from gateway.platforms.event import MessageEvent
|
|
from gateway.run import GatewayRunner
|
|
from gateway.session import SessionEntry, SessionSource, build_session_key
|
|
from hermes_state import AsyncSessionDB
|
|
|
|
source = SessionSource(platform=Platform.TELEGRAM, user_id="u1", chat_id="c1", user_name="t", chat_type="dm")
|
|
runner = object.__new__(GatewayRunner)
|
|
delivered = {}
|
|
adapter = MagicMock()
|
|
adapter.send_document = AsyncMock(side_effect=lambda **kw: delivered.update(
|
|
text=open(kw["file_path"], encoding="utf-8").read()))
|
|
runner.adapters, runner._profile_adapters = {Platform.TELEGRAM: adapter}, {}
|
|
runner.session_store = MagicMock()
|
|
runner.session_store.get_or_create_session.return_value = SessionEntry(
|
|
session_key=build_session_key(source), session_id="s1", created_at=datetime.now(),
|
|
updated_at=datetime.now(), platform=Platform.TELEGRAM, chat_type="dm")
|
|
runner._session_db = AsyncSessionDB(db)
|
|
event = MessageEvent(text=f"/save {fmt} {out.name}", source=source, message_id="m1")
|
|
reply = asyncio.run(runner._handle_save_command(event))
|
|
return delivered["text"] if reply == "Export complete." else reply
|
|
|
|
|
|
def _tui_save(db, fmt, out, *, host=False, profile=False):
|
|
"""TUI/Desktop ``session.save`` (JSON only); ``host`` forwards it as a control frame to a turn-isolated compute
|
|
host, whose own session runs the handler in-process; ``profile`` launches the process from another (uncapped)
|
|
home, so the session's profile config must be the one read."""
|
|
import json
|
|
import os
|
|
import threading
|
|
from unittest import mock
|
|
|
|
from tui_gateway import server
|
|
from tui_gateway.compute_host import ComputeHost
|
|
|
|
assert fmt == "json"
|
|
|
|
def session():
|
|
return {"agent": SimpleNamespace(model="m", session_id="s1"), "session_key": "s1", "history": [],
|
|
"profile_home": str(out.parent), "history_lock": threading.Lock()}
|
|
|
|
parent, child = session(), session()
|
|
|
|
def control(sid, **frame): # the host's own control handler, answered over its stdout wire
|
|
wire = io.StringIO()
|
|
with mock.patch.dict(server._sessions, {sid: child}):
|
|
ComputeHost(stdout=wire, heartbeat_secs=0)._handle_control({"sid": sid, **frame})
|
|
return json.loads(wire.getvalue())
|
|
|
|
launch = {"HERMES_HOME": str(out.parent / "launch")} if profile else {}
|
|
with mock.patch.dict(server._sessions, {"tui-save": parent}), mock.patch.dict(os.environ, launch), \
|
|
mock.patch.object(server, "_session_uses_compute_host", lambda s: host and s is parent), \
|
|
mock.patch.object(server, "_send_compute_host_control", control):
|
|
resp = server._methods["session.save"]("1", {"session_id": "tui-save"})
|
|
if "error" in resp:
|
|
assert resp["error"]["code"] == 4131 # the export-cap refusal, through the host too
|
|
return resp["error"]["message"]
|
|
return open(resp["result"]["file"], encoding="utf-8").read()
|
|
|
|
|
|
@pytest.mark.parametrize("save", [_cli_save, _gateway_save], ids=["cli", "gateway"])
|
|
def test_save_transcript_holds_display_history(tmp_path, monkeypatch, save):
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
|
|
db = _compacted_store(tmp_path / "state.db")
|
|
try:
|
|
text = save(db, "md", tmp_path / "saved.md")
|
|
finally:
|
|
db.close()
|
|
assert [f"answer {i}" in text for i in range(1, 7)] == [True] * 6
|
|
|
|
|
|
@pytest.mark.parametrize("save", [_cli_save, _gateway_save, _tui_save, lambda *a: _tui_save(*a, host=True),
|
|
lambda *a: _tui_save(*a, profile=True)],
|
|
ids=["cli", "gateway", "tui", "tui-compute-host", "tui-profile"])
|
|
def test_save_json_restores_compacted_history_as_archived(tmp_path, monkeypatch, save):
|
|
"""/save json is the snapshot the dashboard import restores: the turns compaction archived come back
|
|
in the display history, and stay out of the live context."""
|
|
import json
|
|
|
|
from hermes_state import SessionDB
|
|
|
|
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
|
|
db = _compacted_store(tmp_path / "state.db")
|
|
# A model-only live row (a micro-compaction merge) is context, not display history: only the transfer
|
|
# projection carries it, so the snapshot's ids pin that projection, not the display read.
|
|
db.append_message("s1", "user", "merged", display_metadata={"model_only": True})
|
|
db.append_message("s1", "user", "undone secret")
|
|
db.rewind_to_message("s1", db.get_messages("s1")[-1]["id"])
|
|
|
|
def shape(store, **flags):
|
|
return [(m["role"], m["content"]) for m in store.get_messages("s1", **flags)]
|
|
|
|
try:
|
|
shown, live = shape(db, include_compacted=True), shape(db)
|
|
snapshot = json.loads(save(db, "json", tmp_path / "saved.json"))
|
|
kept = [m["id"] for m in db.get_messages("s1", include_inactive=True) if m["active"] or m["compacted"]]
|
|
assert [m["id"] for m in snapshot["messages"]] == kept # every kept row, not the deduped display read
|
|
assert sum(snapshot["timings"]["role_counts"].values()) == len(kept) # timings name no undone row
|
|
assert {i[k] for i in snapshot["timings"]["intervals"] for k in ("from_message_id", "to_message_id")} <= set(kept)
|
|
# Like `hermes sessions export`, the in-memory backup is capped per session (the session profile's
|
|
# sessions.max_export_messages).
|
|
(tmp_path / "config.yaml").write_text("sessions:\n max_export_messages: 5\n", encoding="utf-8")
|
|
assert "max_export_messages" in save(db, "json", tmp_path / "capped.json")
|
|
finally:
|
|
db.close()
|
|
restored = SessionDB(db_path=tmp_path / "restored.db")
|
|
try:
|
|
assert restored.import_sessions([snapshot])["ok"]
|
|
assert shape(restored, include_compacted=True) == shown
|
|
assert shape(restored) == live
|
|
finally:
|
|
restored.close()
|