Skip to content

Your lightweight open-source personal agent.

fix(webui): preserve cross-session provenance at display persistence (#6379)

chengyongrud5cf09d738d0
diff --git a/nanobot/session/sqlite_store.py b/nanobot/session/sqlite_store.py
index d19baacfe..1c2fb50bd 100644
--- a/nanobot/session/sqlite_store.py
+++ b/nanobot/session/sqlite_store.py
@@ -456,12 +456,12 @@ class SqliteSessionStore:
return project(HistoryReader(db, key, self.path))
def append_history(
- self, key: str, facts: list[HistoryFact], *, expected_generation: str,
+ self, key: str, facts: list[HistoryFact], *, expected_generation: str | None,
) -> None:
encoded = [(fact, fact.encode()) for fact in facts]
with self.transaction() as db:
row = db.execute("SELECT generation FROM sessions WHERE key=?", (key,)).fetchone()
- if row is None or row[0] != expected_generation:
+ if row is None or (expected_generation is not None and row[0] != expected_generation):
raise SessionConflictError("history belongs to a deleted or replaced session")
db.execute("INSERT OR IGNORE INTO history_heads (session_key) VALUES (?)", (key,))
tail = db.execute(
diff --git a/nanobot/session/state.py b/nanobot/session/state.py
index b9d9a5744..7d5c33ac0 100644
--- a/nanobot/session/state.py
+++ b/nanobot/session/state.py
@@ -715,8 +715,9 @@ class SessionState:
)
async def append_history(
- self, key: str, facts: Sequence[HistoryFact], *, expected_generation: str,
+ self, key: str, facts: Sequence[HistoryFact], *, expected_generation: str | None,
) -> None:
+ """Append to an existing session; None selects its current generation."""
records = list(facts)
await self._execute(
key,
diff --git a/nanobot/session/webui_turns.py b/nanobot/session/webui_turns.py
index 71bf04266..d1ba43698 100644
--- a/nanobot/session/webui_turns.py
+++ b/nanobot/session/webui_turns.py
@@ -678,20 +678,19 @@ class WebuiTurnCoordinator:
return
public_metadata = _session_message_public_metadata(envelope)
try:
- assert event.context.session_generation is not None
await append_session_message_input(
session_key,
sessions=self.sessions,
- expected_generation=event.context.session_generation,
content=event.content,
created_at_ms=envelope["created_at_ms"],
session_message=public_metadata,
)
- except (OSError, TypeError, ValueError):
+ except (OSError, TypeError, ValueError, SessionConflictError):
logger.opt(exception=True).warning(
"Failed to persist session input {}",
envelope["message_id"],
)
+ return
await self.bus.publish_outbound(outbound_message_for_event(
channel="websocket",
chat_id=session_key.split(":", 1)[1],
diff --git a/nanobot/webui/transcript.py b/nanobot/webui/transcript.py
index 84dc1e419..19df05a5b 100644
--- a/nanobot/webui/transcript.py
+++ b/nanobot/webui/transcript.py
@@ -486,7 +486,7 @@ def append_transcript_object(
async def append_session_message_input(
session_key: str, *, sessions: SessionManager, content: str, created_at_ms: int,
- session_message: Mapping[str, Any], expected_generation: str,
+ session_message: Mapping[str, Any],
) -> None:
chat_id = _chat_id_from_session_key(session_key)
if chat_id is None:
@@ -496,7 +496,7 @@ async def append_session_message_input(
return
event.update(created_at_ms=created_at_ms, session_message=dict(session_message))
await sessions.state.append_history(session_key, [fact_from_record(event)],
- expected_generation=expected_generation)
+ expected_generation=None)
def normalize_webui_turn_id(value: Any) -> str:
diff --git a/tests/agent/test_session_inputs.py b/tests/agent/test_session_inputs.py
index 87ae4fc17..503cf8492 100644
--- a/tests/agent/test_session_inputs.py
+++ b/tests/agent/test_session_inputs.py
@@ -6,11 +6,18 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
from nanobot.agent.loop import AgentLoop
+from nanobot.agent.tools.context import RequestContext, request_context
+from nanobot.agent.tools.session_messages import SendSessionMessageTool
from nanobot.bus.events import InboundMessage
+from nanobot.bus.outbound_events import UserInputEvent
from nanobot.bus.queue import MessageBus
+from nanobot.bus.runtime_events import UserInputAccepted
from nanobot.providers.base import LLMResponse
from nanobot.runtime_context import public_history_message
+from nanobot.session.session_handles import SessionHandleResolver
from nanobot.session.session_messages import SESSION_MESSAGE_METADATA_KEY
+from nanobot.session.webui_turns import WebuiTurnCoordinator
+from nanobot.webui.history import record_from_fact
@pytest.fixture
@@ -137,3 +144,76 @@ async def test_path_followup_reaches_running_turn(loop: AgentLoop) -> None:
release.set()
loop.stop()
await asyncio.wait_for(run, 5)
+
+
[email protected]("message_count", [1, 2], ids=["idle", "active"])
+async def test_cross_session_input_preserves_source_in_live_events_and_history(
+ loop: AgentLoop, message_count: int,
+) -> None:
+ source_key, target_key = "websocket:source", "websocket:target"
+ await loop.sessions.state.get(source_key)
+ await loop.sessions.state.get(target_key)
+ await loop.sessions.state.mutate_metadata(target_key, lambda metadata: metadata.update(webui=True))
+ handles = SessionHandleResolver(loop.sessions)
+ source = await handles.ahandle_for_session(source_key)
+ destination = await handles.ahandle_for_session(target_key)
+ assert source is not None and destination is not None
+ tool = SendSessionMessageTool(sessions=loop.sessions, bus=loop.bus)
+ coordinator = WebuiTurnCoordinator(
+ bus=loop.bus, sessions=loop.sessions,
+ schedule_background=lambda coro: coro.close(),
+ )
+ disconnect = coordinator.subscribe()
+ accepted = []
+ disconnect_accepted = loop.bus.subscribe(accepted.append, UserInputAccepted)
+ loop.bus.publish_outbound = AsyncMock()
+ started, release = asyncio.Event(), asyncio.Event()
+
+ async def respond(**kwargs):
+ started.set()
+ await release.wait()
+ return LLMResponse(content="Reviewed", tool_calls=[], usage=None)
+
+ loop.provider.chat_stream_with_retry = AsyncMock(side_effect=respond)
+ run = asyncio.create_task(loop.run())
+ try:
+ for index in range(message_count):
+ with request_context(RequestContext(
+ channel="websocket", chat_id="source", session_key=source_key,
+ )):
+ result = await tool.execute(
+ to=destination.name, content=f"Review {index}", expect_reply=False,
+ )
+ assert result == f"Sent to @{destination.name}."
+ async with asyncio.timeout(3):
+ while len(accepted) < index + 1:
+ await asyncio.sleep(0)
+ await asyncio.wait_for(started.wait(), 3)
+ release.set()
+ await asyncio.wait_for(
+ asyncio.gather(*loop._active_tasks[target_key]), 5,
+ )
+ assert len(accepted) == message_count
+ events = [
+ call.args[0].event for call in loop.bus.publish_outbound.await_args_list
+ if isinstance(call.args[0].event, UserInputEvent)
+ ]
+ assert [event.content for event in events] == [f"Review {i}" for i in range(message_count)]
+ provenance = {"id": source.id, "name": source.name}
+ assert all(event.provenance["session_message"]["session"] == provenance for event in events)
+ # Reconnect/reload must preserve provenance, not just live events.
+ records = await loop.sessions.state.project_history(
+ target_key,
+ lambda history: [record_from_fact(fact, target_key) for fact in history.all_facts()],
+ )
+ inputs = [record for record in records if record.get("event") == "user"]
+ assert [record["text"] for record in inputs] == [f"Review {i}" for i in range(message_count)]
+ assert all(record["session_message"]["session"] == provenance for record in inputs)
+ loop.provider.chat_stream_with_retry.assert_awaited()
+ finally:
+ release.set()
+ disconnect()
+ disconnect_accepted()
+ run.cancel()
+ await asyncio.gather(run, return_exceptions=True)
diff --git a/tests/session/test_display_history.py b/tests/session/test_display_history.py
index 25ff72a7c..5a226fc28 100644
--- a/tests/session/test_display_history.py
+++ b/tests/session/test_display_history.py
@@ -65,6 +65,19 @@ async def test_display_facts_survive_reopen_without_entering_model_history(tmp_p
assert next(event for event in payload["events"] if event["event"] == "stream_end")["response_sources"] == facts[3].content["response_sources"]
+async def test_unbound_display_append_targets_current_session(tmp_path):
+ sessions = _manager(tmp_path)
+ key = "websocket:current"
+ await sessions.state.get(key)
+ await sessions.state.reset(key)
+ fact = HistoryFact(HistoryKind.INPUT, {"text": "new message"})
+
+ await sessions.state.append_history(key, [fact], expected_generation=None)
+
+ assert await sessions.state.project_history(key, lambda history: list(history.all_facts())) == [fact]
+ await sessions.state.aclose()
+
+
async def test_delete_reset_reject_old_display_generation(tmp_path):
sessions = _manager(tmp_path)
key = "websocket:generation"
diff --git a/tests/utils/test_webui_turn_helpers.py b/tests/utils/test_webui_turn_helpers.py
index d56591a49..3003982b4 100644
--- a/tests/utils/test_webui_turn_helpers.py
+++ b/tests/utils/test_webui_turn_helpers.py
@@ -291,9 +291,11 @@ async def test_turn_retry_cause_survives_only_actual_exhaustion(
@pytest.mark.asyncio
[email protected]("write_succeeds", [True, False])
async def test_session_input_is_projected_by_the_webui_coordinator(
tmp_path,
monkeypatch,
+ write_succeeds,
) -> None:
bus = MessageBus()
bus.publish_outbound = AsyncMock()
@@ -310,7 +312,7 @@ async def test_session_input_is_projected_by_the_webui_coordinator(
"source_session_key": "websocket:source",
"target_session_key": "websocket:target",
}
- append_input = AsyncMock()
+ append_input = AsyncMock(side_effect=None if write_succeeds else OSError("write failed"))
monkeypatch.setattr(wth, "append_session_message_input", append_input)
coordinator = wth.WebuiTurnCoordinator(
bus=bus,
@@ -324,14 +326,15 @@ async def test_session_input_is_projected_by_the_webui_coordinator(
channel="system",
chat_id="websocket:target",
session_key="websocket:target",
- session_generation=target_session.generation,
metadata={SESSION_MESSAGE_METADATA_KEY: envelope},
),
content="Review this",
))
append_input.assert_awaited_once()
- assert append_input.await_args.kwargs["expected_generation"] == target_session.generation
+ if not write_succeeds:
+ bus.publish_outbound.assert_not_awaited()
+ return
outbound = bus.publish_outbound.await_args.args[0]
assert outbound.channel == "websocket"
assert outbound.chat_id == "target"