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
fix(webui): preserve cross-session provenance at display persistence (#6379)
chengyongrud5cf09d738d0
diff --git a/nanobot/session/sqlite_store.py b/nanobot/session/sqlite_store.pyindex 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.pyindex 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.pyindex 71bf04266..d1ba43698 100644--- a/nanobot/session/webui_turns.py+++ b/nanobot/session/webui_turns.py@@ -678,20 +678,19 @@ class WebuiTurnCoordinator:returnpublic_metadata = _session_message_public_metadata(envelope)try:- assert event.context.session_generation is not Noneawait 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"],)+ returnawait 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.pyindex 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(returnevent.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.pyindex 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, MagicMockimport pytestfrom nanobot.agent.loop import AgentLoop+from nanobot.agent.tools.context import RequestContext, request_context+from nanobot.agent.tools.session_messages import SendSessionMessageToolfrom nanobot.bus.events import InboundMessage+from nanobot.bus.outbound_events import UserInputEventfrom nanobot.bus.queue import MessageBus+from nanobot.bus.runtime_events import UserInputAcceptedfrom nanobot.providers.base import LLMResponsefrom nanobot.runtime_context import public_history_message+from nanobot.session.session_handles import SessionHandleResolverfrom 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.pyindex 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_passert 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.pyindex 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()+ returnoutbound = bus.publish_outbound.await_args.args[0]assert outbound.channel == "websocket"assert outbound.chat_id == "target"