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): persist user messages for refresh
chengyongru710d00a17932
diff --git a/nanobot/channels/websocket.py b/nanobot/channels/websocket.pyindex 2a8fc2e7c..d0de15787 100644--- a/nanobot/channels/websocket.py+++ b/nanobot/channels/websocket.py@@ -48,7 +48,7 @@ from nanobot.webui.http_utils import (query_first as _query_first,)from nanobot.webui.mcp_presets_api import normalize_mcp_preset_mentions-from nanobot.webui.transcript import append_transcript_object+from nanobot.webui.transcript import append_transcript_object, build_user_transcript_eventfrom nanobot.webui.websocket_logging import websockets_server_logger@@ -768,6 +768,14 @@ class WebSocketChannel(BaseChannel):"enabled": True,"aspect_ratio": aspect_ratio if isinstance(aspect_ratio, str) else None,}+ if envelope.get("webui") is True and self.is_allowed(client_id):+ self._try_append_webui_user_transcript(+ cid,+ content,+ media_paths=media_paths,+ cli_apps=cli_apps,+ mcp_presets=mcp_presets,+ )await self._handle_message(sender_id=client_id,chat_id=cid,@@ -833,9 +841,31 @@ class WebSocketChannel(BaseChannel):try:dup = json.loads(json.dumps(wire, ensure_ascii=False))append_transcript_object(sk, dup)- except (ValueError, TypeError) as e:+ except (OSError, ValueError, TypeError) as e:self.logger.warning("webui transcript append failed: {}", e)+ def _try_append_webui_user_transcript(+ self,+ chat_id: str,+ content: str,+ *,+ media_paths: list[str],+ cli_apps: list[dict[str, Any]],+ mcp_presets: list[dict[str, Any]],+ ) -> None:+ if content.strip() == "/stop" and not media_paths:+ return+ payload = build_user_transcript_event(+ chat_id,+ content,+ media_paths=media_paths,+ cli_apps=cli_apps,+ mcp_presets=mcp_presets,+ )+ if payload is None:+ return+ self._try_append_webui_transcript(chat_id, payload)+async def send(self, msg: OutboundMessage) -> None:if msg.metadata.get("_runtime_model_updated"):await self.send_runtime_model_updated(diff --git a/nanobot/webui/transcript.py b/nanobot/webui/transcript.pyindex 9d7125bca..f0a073618 100644--- a/nanobot/webui/transcript.py+++ b/nanobot/webui/transcript.py@@ -40,6 +40,15 @@ _FILE_EDIT_TOOL_NAMES: frozenset[str] = frozenset({"edit_file","apply_patch",})+_TURN_DISPLAY_EVENTS: frozenset[str] = frozenset({+ "reasoning_delta",+ "reasoning_end",+ "delta",+ "stream_end",+ "message",+ "file_edit",+ "turn_end",+})def rewrite_local_markdown_images(@@ -155,6 +164,165 @@ def delete_webui_transcript(session_key: str) -> bool:return False+def build_user_transcript_event(+ chat_id: str,+ text: str,+ *,+ media_paths: list[Any] | None = None,+ cli_apps: list[Any] | None = None,+ mcp_presets: list[Any] | None = None,+) -> dict[str, Any] | None:+ paths = [str(path) for path in (media_paths or []) if path]+ if not text and not paths:+ return None+ event: dict[str, Any] = {+ "event": "user",+ "chat_id": chat_id,+ "text": text,+ }+ if paths:+ event["media_paths"] = paths+ apps = [dict(app) for app in (cli_apps or []) if isinstance(app, Mapping)]+ if apps:+ event["cli_apps"] = apps+ presets = [dict(preset) for preset in (mcp_presets or []) if isinstance(preset, Mapping)]+ if presets:+ event["mcp_presets"] = presets+ return event+++def _session_user_event(+ session_key: str,+ message: dict[str, Any],+) -> dict[str, Any] | None:+ if message.get("role") != "user":+ return None+ content = message.get("content")+ text = content if isinstance(content, str) else ""+ media = message.get("media")+ cli_apps = message.get("cli_apps")+ mcp_presets = message.get("mcp_presets")+ chat_id = session_key.split(":", 1)[1] if ":" in session_key else session_key+ return build_user_transcript_event(+ chat_id,+ text,+ media_paths=media if isinstance(media, list) else None,+ cli_apps=cli_apps if isinstance(cli_apps, list) else None,+ mcp_presets=mcp_presets if isinstance(mcp_presets, list) else None,+ )+++def _assistant_text_signature(value: Any) -> str:+ return value.strip() if isinstance(value, str) else ""+++def _session_backfill_turns(+ session_key: str,+ session_messages: list[dict[str, Any]],+) -> list[tuple[dict[str, Any], tuple[str, ...]]]:+ turns: list[tuple[dict[str, Any], tuple[str, ...]]] = []+ current_user: dict[str, Any] | None = None+ assistant_texts: list[str] = []++ def flush() -> None:+ if current_user is None:+ return+ signature = tuple(text for text in assistant_texts if text)+ if signature:+ turns.append((current_user, signature))++ for message in session_messages:+ role = message.get("role")+ if role == "user":+ flush()+ current_user = _session_user_event(session_key, message)+ assistant_texts = []+ continue+ if role == "assistant" and current_user is not None:+ text = _assistant_text_signature(message.get("content"))+ if text:+ assistant_texts.append(text)+ flush()+ return turns+++def _split_transcript_turns(lines: list[dict[str, Any]]) -> list[list[dict[str, Any]]]:+ turns: list[list[dict[str, Any]]] = []+ current: list[dict[str, Any]] = []+ for rec in lines:+ current.append(rec)+ if rec.get("event") == "turn_end":+ turns.append(current)+ current = []+ if current:+ turns.append(current)+ return turns+++def _transcript_turn_signature(records: list[dict[str, Any]]) -> tuple[str, ...]:+ texts: list[str] = []+ for message in replay_transcript_to_ui_messages(records):+ if message.get("role") != "assistant" or message.get("kind") == "trace":+ continue+ text = _assistant_text_signature(message.get("content"))+ if text:+ texts.append(text)+ return tuple(texts)+++def _find_unique_session_turn(+ session_turns: list[tuple[dict[str, Any], tuple[str, ...]]],+ signature: tuple[str, ...],+ start: int,+) -> int | None:+ if not signature:+ return None+ found: int | None = None+ for index in range(start, len(session_turns)):+ if session_turns[index][1] != signature:+ continue+ if found is not None:+ return None+ found = index+ return found+++def _with_backfilled_user(+ records: list[dict[str, Any]],+ user_event: dict[str, Any],+) -> list[dict[str, Any]]:+ for index, rec in enumerate(records):+ if rec.get("event") in _TURN_DISPLAY_EVENTS:+ return [*records[:index], dict(user_event), *records[index:]]+ return records+++def inject_missing_user_events_from_session(+ session_key: str,+ lines: list[dict[str, Any]],+ session_messages: list[dict[str, Any]] | None,+) -> list[dict[str, Any]]:+ """Backfill user rows for legacy WebUI transcripts that only stored assistant streams."""+ if not lines or not session_messages:+ return lines+ session_turns = _session_backfill_turns(session_key, session_messages)+ if not session_turns:+ return lines++ out: list[dict[str, Any]] = []+ session_cursor = 0+ for turn in _split_transcript_turns(lines):+ has_user = any(rec.get("event") == "user" for rec in turn)+ signature = _transcript_turn_signature(turn)+ match_index = _find_unique_session_turn(session_turns, signature, session_cursor)+ if match_index is None:+ out.extend(turn)+ continue+ out.extend(turn if has_user else _with_backfilled_user(turn, session_turns[match_index][0]))+ session_cursor = match_index + 1+ return out++def _format_tool_call_trace(call: Any) -> str | None:if not call or not isinstance(call, dict):return None@@ -904,11 +1072,13 @@ def build_webui_thread_response(augment_user_media: Callable[[list[str]], list[dict[str, Any]]] | None = None,augment_assistant_media: Callable[[list[str]], list[dict[str, Any]]] | None = None,augment_assistant_text: Callable[[str], str] | None = None,+ session_messages: list[dict[str, Any]] | None = None,) -> dict[str, Any] | None:"""Return a payload compatible with ``WebuiThreadPersistedPayload``."""lines = read_transcript_lines(session_key)if not lines:return None+ lines = inject_missing_user_events_from_session(session_key, lines, session_messages)msgs = replay_transcript_to_ui_messages(lines,augment_user_media=augment_user_media,diff --git a/nanobot/webui/ws_http.py b/nanobot/webui/ws_http.pyindex 89f5e7b12..2b60bfca8 100644--- a/nanobot/webui/ws_http.py+++ b/nanobot/webui/ws_http.py@@ -348,6 +348,12 @@ class GatewayHTTPHandler:if not _is_websocket_channel_session_key(decoded_key):return _http_error(404, "session not found")scope = self.workspaces.scope_for_session_key(decoded_key)+ session_messages: list[dict[str, Any]] | None = None+ if self.session_manager is not None:+ session_data = self.session_manager.read_session_file(decoded_key)+ raw_messages = session_data.get("messages") if isinstance(session_data, dict) else None+ if isinstance(raw_messages, list):+ session_messages = [m for m in raw_messages if isinstance(m, dict)]data = build_webui_thread_response(decoded_key,augment_user_media=self.media.augment_transcript_media,@@ -356,6 +362,7 @@ class GatewayHTTPHandler:text,workspace_path=scope.project_path,),+ session_messages=session_messages,)if data is None:return _http_error(404, "webui thread not found")diff --git a/tests/channels/test_websocket_channel.py b/tests/channels/test_websocket_channel.pyindex 6cdfd8835..a441547bd 100644--- a/tests/channels/test_websocket_channel.py+++ b/tests/channels/test_websocket_channel.py@@ -294,6 +294,87 @@ async def test_webui_message_envelope_marks_inbound_metadata(bus: MagicMock) ->assert msg.metadata["_wants_stream"] is True+async def test_webui_message_envelope_persists_user_transcript_for_refresh(+ bus: MagicMock,+ tmp_path,+ monkeypatch,+) -> None:+ from nanobot.webui.transcript import build_webui_thread_response, read_transcript_lines++ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ channel = _ch(bus)+ conn = AsyncMock()+ conn.remote_address = ("127.0.0.1", 50123)++ async def answer_during_publish(_msg: Any) -> None:+ await channel.send(OutboundMessage(channel="websocket", chat_id="chat-1", content="hi back"))++ bus.publish_inbound.side_effect = answer_during_publish++ await channel._dispatch_envelope(+ conn,+ "webui-client",+ {"type": "message", "chat_id": "chat-1", "content": "hello", "webui": True},+ )++ lines = read_transcript_lines("websocket:chat-1")+ assert [line["event"] for line in lines] == ["user", "message"]++ body = build_webui_thread_response("websocket:chat-1")+ assert body is not None+ assert [message["role"] for message in body["messages"]] == ["user", "assistant"]+ assert [message["content"] for message in body["messages"]] == ["hello", "hi back"]+++async def test_webui_stop_control_message_is_not_persisted_as_user_bubble(+ bus: MagicMock,+ tmp_path,+ monkeypatch,+) -> None:+ from nanobot.webui.transcript import read_transcript_lines++ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ channel = _ch(bus)+ conn = AsyncMock()+ conn.remote_address = ("127.0.0.1", 50123)++ await channel._dispatch_envelope(+ conn,+ "webui-client",+ {"type": "message", "chat_id": "chat-1", "content": "/stop", "webui": True},+ )++ msg = bus.publish_inbound.await_args.args[0]+ assert msg.content == "/stop"+ assert read_transcript_lines("websocket:chat-1") == []+++async def test_webui_user_transcript_append_failure_does_not_block_inbound(+ bus: MagicMock,+ monkeypatch,+) -> None:+ def fail_append(_session_key: str, _obj: dict[str, Any]) -> None:+ raise OSError("disk full")++ monkeypatch.setattr("nanobot.channels.websocket.append_transcript_object", fail_append)+ channel = _ch(bus)+ conn = AsyncMock()+ conn.remote_address = ("127.0.0.1", 50123)++ await channel._dispatch_envelope(+ conn,+ "webui-client",+ {"type": "message", "chat_id": "chat-1", "content": "hello", "webui": True},+ )++ msg = bus.publish_inbound.await_args.args[0]+ assert msg.chat_id == "chat-1"+ assert msg.content == "hello"++@pytest.mark.asyncioasync def test_plain_websocket_message_does_not_mark_webui(bus: MagicMock) -> None:channel = _ch(bus)@@ -2411,3 +2492,47 @@ def test_handle_webui_thread_get_returns_json(tmp_path, monkeypatch) -> None:assert len(body["messages"]) == 1assert body["messages"][0]["role"] == "user"assert body["messages"][0]["content"] == "hi"+++def test_handle_webui_thread_get_backfills_legacy_missing_user_rows(+ tmp_path,+ monkeypatch,+) -> None:+ from urllib.parse import quote++ from websockets.datastructures import Headers+ from websockets.http11 import Request++ from nanobot.webui.transcript import append_transcript_object++ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ workspace = tmp_path / "workspace"+ sessions = SessionManager(workspace)+ key = "websocket:c-legacy"+ session = sessions.get_or_create(key)+ session.add_message("user", "legacy question")+ session.add_message("assistant", "legacy answer")+ sessions.save(session)+ append_transcript_object(+ key,+ {"event": "message", "chat_id": "c-legacy", "text": "legacy answer"},+ )++ bus = MagicMock()+ channel = WebSocketChannel(+ {"enabled": True, "allowFrom": ["*"]},+ bus,+ gateway=_basic_handler(bus, session_manager=sessions, workspace_path=workspace),+ )+ channel.gateway.tokens.api_tokens["tok"] = time.monotonic() + 300.0+ enc = quote(key, safe="")+ req = Request(f"/api/sessions/{enc}/webui-thread", Headers([("Authorization", "Bearer tok")]))+ resp = channel.gateway.http._handle_webui_thread_get(req, enc)++ assert resp.status_code == 200+ body = json.loads(resp.body.decode())+ assert [message["role"] for message in body["messages"]] == ["user", "assistant"]+ assert [message["content"] for message in body["messages"]] == [+ "legacy question",+ "legacy answer",+ ]diff --git a/tests/utils/test_webui_transcript.py b/tests/utils/test_webui_transcript.pyindex 167b6b4d9..1c7372902 100644--- a/tests/utils/test_webui_transcript.py+++ b/tests/utils/test_webui_transcript.py@@ -5,6 +5,7 @@ from __future__ import annotationsfrom nanobot.webui.transcript import (WEBUI_TRANSCRIPT_SCHEMA_VERSION,append_transcript_object,+ build_webui_thread_response,read_transcript_lines,replay_transcript_to_ui_messages,)@@ -66,6 +67,98 @@ def test_replay_uses_stream_end_final_text() -> None:assert msgs[1]["content"] == ""+def test_build_response_backfills_legacy_sse_only_transcripts(tmp_path, monkeypatch) -> None:+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ key = "websocket:t-legacy"+ for ev in (+ {"event": "delta", "chat_id": "t-legacy", "text": "first answer"},+ {"event": "stream_end", "chat_id": "t-legacy"},+ {"event": "turn_end", "chat_id": "t-legacy"},+ {"event": "message", "chat_id": "t-legacy", "text": "second answer"},+ {"event": "turn_end", "chat_id": "t-legacy"},+ ):+ append_transcript_object(key, ev)++ out = build_webui_thread_response(+ key,+ session_messages=[+ {"role": "user", "content": "first question"},+ {"role": "assistant", "content": "first answer"},+ {"role": "user", "content": "second question"},+ {"role": "assistant", "content": "second answer"},+ ],+ )++ assert out is not None+ assert [message["role"] for message in out["messages"]] == [+ "user",+ "assistant",+ "user",+ "assistant",+ ]+ assert [message["content"] for message in out["messages"]] == [+ "first question",+ "first answer",+ "second question",+ "second answer",+ ]+++def test_backfill_does_not_duplicate_existing_user_transcript(tmp_path, monkeypatch) -> None:+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ key = "websocket:t-current"+ for ev in (+ {"event": "user", "chat_id": "t-current", "text": "already stored"},+ {"event": "message", "chat_id": "t-current", "text": "answer"},+ {"event": "turn_end", "chat_id": "t-current"},+ ):+ append_transcript_object(key, ev)++ out = build_webui_thread_response(+ key,+ session_messages=[{"role": "user", "content": "already stored"}],+ )++ assert out is not None+ assert [message["role"] for message in out["messages"]] == ["user", "assistant"]+ assert out["messages"][0]["content"] == "already stored"+++def test_backfill_does_not_misalign_when_session_only_has_transcript_tail(+ tmp_path,+ monkeypatch,+) -> None:+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ key = "websocket:t-tail"+ for ev in (+ {"event": "message", "chat_id": "t-tail", "text": "old answer"},+ {"event": "turn_end", "chat_id": "t-tail"},+ {"event": "message", "chat_id": "t-tail", "text": "tail answer"},+ {"event": "turn_end", "chat_id": "t-tail"},+ ):+ append_transcript_object(key, ev)++ out = build_webui_thread_response(+ key,+ session_messages=[+ {"role": "user", "content": "tail question"},+ {"role": "assistant", "content": "tail answer"},+ ],+ )++ assert out is not None+ assert [message["role"] for message in out["messages"]] == [+ "assistant",+ "user",+ "assistant",+ ]+ assert [message["content"] for message in out["messages"]] == [+ "old answer",+ "tail question",+ "tail answer",+ ]++def test_replay_infers_video_media_from_attachment_name() -> None:msgs = replay_transcript_to_ui_messages([