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): reconcile threads after browser resume
chengyongruae089aa3ae90
diff --git a/nanobot/channels/websocket/runtime.py b/nanobot/channels/websocket/runtime.pyindex cdd8e4f89..5dd1bcfb5 100644--- a/nanobot/channels/websocket/runtime.py+++ b/nanobot/channels/websocket/runtime.py@@ -32,6 +32,7 @@ from nanobot.bus.outbound_events import ()from nanobot.bus.queue import MessageBusfrom nanobot.channels.base import BaseChannel+from nanobot.command.builtin import builtin_command_starts_agent_turnfrom nanobot.config.schema import Basefrom nanobot.runtime_context import (RUNTIME_CONTEXT_INPUT_META,@@ -43,7 +44,14 @@ from nanobot.security.workspace_access import (WorkspaceScopeError,)from nanobot.session.goal_state import goal_state_ws_blob-from nanobot.session.webui_turns import websocket_turn_wall_started_at+from nanobot.session.webui_turns import (+ clear_websocket_turn_if_current,+ mark_websocket_turn_transcript_persistence_failed,+ register_queued_websocket_turn_if_idle,+ websocket_turn_id,+ websocket_turn_transcript_persistence_failed,+ websocket_turn_wall_started_at,+)from nanobot.webui.cli_apps_api import normalize_cli_app_mentionsfrom nanobot.webui.forking import handle_webui_fork_chatfrom nanobot.webui.gateway_services import GatewayServices@@ -57,6 +65,11 @@ 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.metadata import (+ WEBSOCKET_TURN_OWNER_METADATA_KEY,+ WEBUI_TURN_METADATA_KEY,+)+from nanobot.webui.transcript import WEBUI_TRANSCRIPT_INCOMPLETE_KEYfrom nanobot.webui.transcription_ws import webui_transcription_eventfrom nanobot.webui.websocket_logging import websockets_server_logger@@ -317,7 +330,12 @@ class WebSocketChannel(BaseChannel):t0 = websocket_turn_wall_started_at(chat_id)if t0 is None:return- await self.send_goal_status(chat_id, "running", started_at=t0)+ await self.send_goal_status(+ chat_id,+ "running",+ started_at=t0,+ turn_id=websocket_turn_id(chat_id),+ )async def _hydrate_after_subscribe(self, chat_id: str) -> None:"""Replay persisted or actively running per-chat state after subscribe."""@@ -633,17 +651,40 @@ class WebSocketChannel(BaseChannel):if not _is_valid_chat_id(cid):await self._send_event(connection, "error", detail="invalid chat_id")return+ raw_turn_id = envelope.get("turn_id")+ turn_id = raw_turn_id if isinstance(raw_turn_id, str) and raw_turn_id else None+ rejection_fields = {+ "chat_id": cid,+ **({"turn_id": turn_id} if turn_id else {}),+ }+ # The allowlist can change while an authenticated websocket stays+ # open. Reject the exact application turn before hydration,+ # transcript persistence, or an acceptance ACK; BaseChannel's+ # silent authorization return must not look like successful ingress.+ if not self.is_allowed(client_id):+ await self._send_event(+ connection,+ "error",+ detail="access_denied",+ **rejection_fields,+ )+ returnif not isinstance(content, str):- await self._send_event(connection, "error", detail="missing content")+ await self._send_event(+ connection,+ "error",+ detail="missing content",+ **rejection_fields,+ )returnmessage_rejection = self._ingress.validate_text(content)if message_rejection is not None:await self._send_event(connection,"error",- chat_id=cid,detail="message_rejected",reason=message_rejection,+ **rejection_fields,)return@@ -656,6 +697,7 @@ class WebSocketChannel(BaseChannel):"error",detail="attachment_rejected",reason="malformed",+ **rejection_fields,)returnmedia_paths, reason = self._media.store_inbound_attachments(raw_media)@@ -665,12 +707,18 @@ class WebSocketChannel(BaseChannel):"error",detail="attachment_rejected",reason=reason,+ **rejection_fields,)return# Allow media-only turns (content may be empty when attachments are present).if not content.strip() and not media_paths:- await self._send_event(connection, "error", detail="missing content")+ await self._send_event(+ connection,+ "error",+ detail="missing content",+ **rejection_fields,+ )return# Auto-attach on first use so clients can one-shot without a separate attach.self._attach(connection, cid)@@ -686,10 +734,23 @@ class WebSocketChannel(BaseChannel):controls_available=self._workspace_controls_available(connection),),chat_id=cid,+ turn_id=turn_id,)if scope is None:return+ # Hydration and scope resolution can yield. Re-check immediately+ # before transcript/bus mutation so a mid-flight revocation cannot+ # fall through BaseChannel's silent deny and still receive an ACK.+ if not self.is_allowed(client_id):+ await self._send_event(+ connection,+ "error",+ detail="access_denied",+ **rejection_fields,+ )+ return+metadata: dict[str, Any] = {"remote": getattr(connection, "remote_address", None)}if envelope.get("webui") is True:metadata["webui"] = True@@ -702,29 +763,48 @@ class WebSocketChannel(BaseChannel):metadata["mcp_presets"] = mcp_presetsmetadata[WORKSPACE_SCOPE_METADATA_KEY] = scope.metadata()self._workspaces.persist_scope(cid, scope)- if metadata.get("webui") is True and self.is_allowed(client_id):- self._transcripts.append_user_message(- cid,- content,+ is_webui = metadata.get("webui") is True+ queued_owner = None+ if is_webui and builtin_command_starts_agent_turn(content):+ queued_owner = register_queued_websocket_turn_if_idle(cid, turn_id)+ if queued_owner is not None:+ metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY] = queued_owner+ accepted = False+ try:+ if is_webui:+ self._transcripts.append_user_message(+ cid,+ content,+ metadata=metadata,+ media_paths=media_paths or None,+ cli_apps=cli_apps or None,+ mcp_presets=mcp_presets or None,+ )+ if is_webui and connection in self._webui_connections:+ quote = webui_quote_runtime_context({+ WEBUI_QUOTE_METADATA: envelope.get("quoted_context"),+ })+ if quote is not None:+ metadata[RUNTIME_CONTEXT_INPUT_META] = [quote]+ await self._handle_message(+ sender_id=client_id,+ chat_id=cid,+ content=content,+ media=media_paths or None,metadata=metadata,- media_paths=media_paths or None,- cli_apps=cli_apps or None,- mcp_presets=mcp_presets or None,+ is_dm=False,+ )+ accepted = True+ finally:+ if not accepted and queued_owner is not None:+ clear_websocket_turn_if_current(cid, queued_owner)+ if is_webui and turn_id:+ await self._send_event(+ connection,+ "message_accepted",+ chat_id=cid,+ turn_id=turn_id,)- if metadata.get("webui") is True and connection in self._webui_connections:- quote = webui_quote_runtime_context({- WEBUI_QUOTE_METADATA: envelope.get("quoted_context"),- })- if quote is not None:- metadata[RUNTIME_CONTEXT_INPUT_META] = [quote]- await self._handle_message(- sender_id=client_id,- chat_id=cid,- content=content,- media=media_paths or None,- metadata=metadata,- is_dm=False,- )returnawait self._send_event(connection, "error", detail=f"unknown type: {t!r}")@@ -734,6 +814,7 @@ class WebSocketChannel(BaseChannel):resolver: Callable[[], Any],*,chat_id: str | None = None,+ turn_id: str | None = None,) -> Any | None:try:return resolver()@@ -744,6 +825,7 @@ class WebSocketChannel(BaseChannel):detail="workspace_scope_rejected",reason=exc.message,**({"chat_id": chat_id} if chat_id else {}),+ **({"turn_id": turn_id} if turn_id else {}),)return None@@ -782,6 +864,37 @@ class WebSocketChannel(BaseChannel):self.logger.exception("send failed{}", label)raise+ def _persist_turn_transcript_event(+ self,+ chat_id: str,+ event: dict[str, Any],+ *,+ metadata: dict[str, Any] | None,+ phase: str,+ include_source: bool = False,+ transcript_overrides: dict[str, Any] | None = None,+ ) -> bool:+ """Persist one canonical turn event and retain unsafe owners on failure."""+ persisted = self._transcripts.prepare_and_append(+ chat_id,+ event,+ metadata=metadata,+ phase=phase,+ include_source=include_source,+ transcript_overrides=transcript_overrides,+ )+ if (+ not persisted+ and phase in {"answer", "complete"}+ and (metadata or {}).get("webui") is True+ ):+ owner = (metadata or {}).get(WEBSOCKET_TURN_OWNER_METADATA_KEY)+ mark_websocket_turn_transcript_persistence_failed(+ chat_id,+ owner if isinstance(owner, str) else None,+ )+ return persisted+async def send(self, msg: OutboundMessage) -> None:event = outbound_event_from_message(msg)progress_event = event if isinstance(event, ProgressEvent) else None@@ -818,21 +931,38 @@ class WebSocketChannel(BaseChannel):await self.send_goal_state(msg.chat_id, event.goal_state or {"active": False})returnif isinstance(event, GoalStatusEvent):- if conns:- if event.status in ("running", "idle"):+ turn_id = (msg.metadata or {}).get(WEBUI_TURN_METADATA_KEY)+ current_turn_id = turn_id if isinstance(turn_id, str) else None+ turn_owner = (msg.metadata or {}).get(WEBSOCKET_TURN_OWNER_METADATA_KEY)+ current_turn_owner = turn_owner if isinstance(turn_owner, str) else None+ try:+ if conns and event.status in ("running", "idle"):await self.send_goal_status(msg.chat_id,event.status,started_at=event.started_at,+ turn_id=current_turn_id,+ )+ finally:+ if event.status == "idle":+ # Cancellation/direct runs may have no turn_end, so idle is+ # still terminal. A failed canonical completion write is+ # the one case that must remain pending for safe resume.+ clear_websocket_turn_if_current(+ msg.chat_id,+ current_turn_owner,+ preserve_persistence_failure=True,)return# Signal that the agent has fully finished processing the current turn.if isinstance(event, TurnEndEvent):+ turn_owner = (msg.metadata or {}).get(WEBSOCKET_TURN_OWNER_METADATA_KEY)await self.send_turn_end(msg.chat_id,latency_ms=event.latency_ms,goal_state=event.goal_state,metadata=msg.metadata,+ turn_owner=turn_owner if isinstance(turn_owner, str) else None,)await self.send_session_updated(msg.chat_id, scope="thread")return@@ -884,7 +1014,7 @@ class WebSocketChannel(BaseChannel):elif progress_event:payload["kind"] = "progress"phase = "activity" if payload.get("kind") in ("tool_hint", "progress") else "answer"- self._transcripts.prepare_and_append(+ self._persist_turn_transcript_event(msg.chat_id,payload,metadata=msg.metadata,@@ -922,7 +1052,7 @@ class WebSocketChannel(BaseChannel):}if stream_id is not None:body["stream_id"] = stream_id- self._transcripts.prepare_and_append(+ self._persist_turn_transcript_event(chat_id,body,metadata=meta,@@ -950,7 +1080,7 @@ class WebSocketChannel(BaseChannel):}if stream_id is not None:body["stream_id"] = stream_id- self._transcripts.prepare_and_append(+ self._persist_turn_transcript_event(chat_id,body,metadata=meta,@@ -974,7 +1104,7 @@ class WebSocketChannel(BaseChannel):"chat_id": chat_id,"edits": edits,}- self._transcripts.prepare_and_append(+ self._persist_turn_transcript_event(chat_id,payload,metadata=metadata,@@ -1026,7 +1156,7 @@ class WebSocketChannel(BaseChannel):body["resuming"] = Trueif stream_end and merge_next:body["merge_next"] = True- self._transcripts.prepare_and_append(+ self._persist_turn_transcript_event(chat_id,body,metadata=meta,@@ -1045,6 +1175,7 @@ class WebSocketChannel(BaseChannel):*,goal_state: dict[str, Any] | None = None,metadata: dict[str, Any] | None = None,+ turn_owner: str | None = None,) -> None:"""Signal that the agent has fully finished processing the current turn."""conns = list(self._subs.get(chat_id, ()))@@ -1053,12 +1184,27 @@ class WebSocketChannel(BaseChannel):body["latency_ms"] = int(latency_ms)if goal_state is not None:body["goal_state"] = goal_state- self._transcripts.prepare_and_append(+ canonical_webui_turn = (metadata or {}).get("webui") is True+ prior_persistence_failure = (+ canonical_webui_turn+ and websocket_turn_transcript_persistence_failed(chat_id, turn_owner)+ )+ persisted = self._persist_turn_transcript_event(chat_id,body,metadata=metadata,phase="complete",+ transcript_overrides=(+ {WEBUI_TRANSCRIPT_INCOMPLETE_KEY: True}+ if prior_persistence_failure+ else None+ ),)+ if persisted:+ # A successful completion either has a complete transcript or now+ # carries a durable incomplete marker. The HTTP replay path can+ # recover the latter from session history after a gateway restart.+ clear_websocket_turn_if_current(chat_id, turn_owner)raw = json.dumps(body, ensure_ascii=False)if not conns:return@@ -1081,6 +1227,7 @@ class WebSocketChannel(BaseChannel):status: str,*,started_at: float | None = None,+ turn_id: str | None = None,) -> None:"""Notify subscribed clients that a turn started or finished (wall-clock hint)."""conns = list(self._subs.get(chat_id, ()))@@ -1093,6 +1240,8 @@ class WebSocketChannel(BaseChannel):}if status == "running" and started_at is not None:body["started_at"] = started_at+ if turn_id:+ body["turn_id"] = turn_idraw = json.dumps(body, ensure_ascii=False)for connection in conns:await self._safe_send_to(connection, raw, label=" goal_status ")diff --git a/nanobot/channels/websocket/tests/test_websocket_channel.py b/nanobot/channels/websocket/tests/test_websocket_channel.pyindex 92eb84bb7..a9f543eff 100644--- a/nanobot/channels/websocket/tests/test_websocket_channel.py+++ b/nanobot/channels/websocket/tests/test_websocket_channel.py@@ -49,8 +49,13 @@ from nanobot.webui.http_utils import (from nanobot.webui.http_utils import (parse_request_path as _parse_request_path,)+from nanobot.webui.metadata import WEBSOCKET_TURN_OWNER_METADATA_KEYfrom nanobot.webui.settings_api import settings_payload, update_provider_settings-from nanobot.webui.transcript import append_transcript_object, read_transcript_lines+from nanobot.webui.transcript import (+ append_transcript_object,+ build_webui_thread_response,+ read_transcript_lines,+)from .ws_test_client import http_get as _http_get@@ -164,11 +169,20 @@ async def test_start_extends_http_open_timeout_for_slow_settings_routes(@pytest.fixture(autouse=True)def isolate_webui_workspace_state(tmp_path, monkeypatch) -> None:+ wth._WEBSOCKET_ACTIVE_TURNS.clear()+ wth._WEBSOCKET_TURN_WALL_STARTED_AT.clear()+ wth._WEBSOCKET_TURN_IDS.clear()+ wth._WEBSOCKET_TURN_OWNERS.clear()monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir",lambda: tmp_path / "webui",)+ yield+ wth._WEBSOCKET_ACTIVE_TURNS.clear()+ wth._WEBSOCKET_TURN_WALL_STARTED_AT.clear()+ wth._WEBSOCKET_TURN_IDS.clear()+ wth._WEBSOCKET_TURN_OWNERS.clear()@pytest.mark.asyncio@@ -743,6 +757,7 @@ async def test_webui_scope_rejects_running_scope_change(bus: MagicMock, tmp_path"chat_id": "chat-running","content": "hello","webui": True,+ "turn_id": "turn-scope-rejected","workspace_scope": {"project_path": str(other),"access_mode": "full",@@ -757,6 +772,7 @@ async def test_webui_scope_rejects_running_scope_change(bus: MagicMock, tmp_pathassert payload["detail"] == "workspace_scope_rejected"assert payload["reason"] == "chat_running"assert payload["chat_id"] == "chat-running"+ assert payload["turn_id"] == "turn-scope-rejected"bus.publish_inbound.assert_not_awaited()@@ -1602,6 +1618,434 @@ async def test_send_turn_end_emits_turn_end_event() -> None:]+ ("active_owner", "event_owner", "expected_cleared"),+ [+ ("owner-current", "owner-current", True),+ ("owner-new", "owner-old", False),+ ],+)+async def test_turn_end_persists_and_conditionally_clears_when_fanout_fails(+ active_owner: str,+ event_owner: str,+ expected_cleared: bool,+) -> None:+ bus = MagicMock()+ channel = WebSocketChannel(+ {"enabled": True, "allowFrom": ["*"]},+ bus,+ gateway=_basic_handler(bus),+ )+ mock_ws = AsyncMock()+ mock_ws.send.side_effect = RuntimeError("fanout failed")+ chat_id = f"turn-end-failure-{expected_cleared}"+ channel._attach(mock_ws, chat_id)+ wth._WEBSOCKET_TURN_WALL_STARTED_AT[chat_id] = 1234.5+ wth._WEBSOCKET_TURN_OWNERS[chat_id] = active_owner++ try:+ with pytest.raises(RuntimeError, match="fanout failed"):+ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="",+ metadata={WEBSOCKET_TURN_OWNER_METADATA_KEY: event_owner},+ event=TurnEndEvent(),+ ))++ assert read_transcript_lines(f"websocket:{chat_id}")[-1]["event"] == "turn_end"+ assert (wth.websocket_turn_wall_started_at(chat_id) is None) is expected_cleared+ if not expected_cleared:+ assert wth._WEBSOCKET_TURN_OWNERS[chat_id] == active_owner+ finally:+ wth._WEBSOCKET_TURN_WALL_STARTED_AT.pop(chat_id, None)+ wth._WEBSOCKET_TURN_IDS.pop(chat_id, None)+ wth._WEBSOCKET_TURN_OWNERS.pop(chat_id, None)+++async def test_turn_end_keeps_registry_when_transcript_persistence_fails(+ monkeypatch,+) -> None:+ from nanobot.bus.events import InboundMessage++ bus = MagicMock()+ bus.publish_outbound = AsyncMock()+ channel = WebSocketChannel(+ {"enabled": True, "allowFrom": ["*"]},+ bus,+ gateway=_basic_handler(bus),+ )+ chat_id = "turn-end-persistence-failure"+ owner = "owner-persist"+ turn_id = "turn-persist"+ inbound = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id=chat_id,+ content="hi",+ metadata={+ WEBSOCKET_TURN_OWNER_METADATA_KEY: owner,+ "webui_turn_id": turn_id,+ "webui": True,+ },+ )+ await wth.publish_turn_run_status(bus, inbound, "running", started_at=1234.5)+ append = MagicMock(side_effect=OSError("disk full"))+ monkeypatch.setattr("nanobot.webui.transcript.append_transcript_object", append)++ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="",+ metadata={+ WEBSOCKET_TURN_OWNER_METADATA_KEY: owner,+ "webui_turn_id": turn_id,+ "webui": True,+ },+ event=TurnEndEvent(),+ ))++ append.assert_called_once()+ assert wth.websocket_turn_wall_started_at(chat_id) == 1234.5+ assert wth.websocket_turn_id(chat_id) == turn_id+ assert wth._WEBSOCKET_TURN_OWNERS[chat_id] == owner++ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="",+ metadata=dict(inbound.metadata),+ event=GoalStatusEvent(status="idle"),+ ))++ # The normal WebUI idle event follows turn_end. It must not convert a+ # failed canonical completion write into an apparently settled HTTP+ # snapshot.+ assert wth.websocket_turn_wall_started_at(chat_id) == 1234.5+ assert wth.websocket_turn_id(chat_id) == turn_id+ assert wth._WEBSOCKET_TURN_OWNERS[chat_id] == owner+++async def test_durable_incomplete_marker_stays_pending_without_safe_session_recovery(+ monkeypatch,+) -> None:+ from nanobot.bus.events import InboundMessage+ from nanobot.webui.transcript import build_webui_thread_response++ bus = MagicMock()+ bus.publish_outbound = AsyncMock()+ channel = WebSocketChannel(+ {"enabled": True, "allowFrom": ["*"]},+ bus,+ gateway=_basic_handler(bus),+ )+ chat_id = "answer-persistence-failure"+ key = f"websocket:{chat_id}"+ owner = "owner-answer"+ turn_id = "turn-answer"+ append_transcript_object(+ key,+ {"event": "user", "chat_id": chat_id, "text": "question", "turn_id": turn_id},+ )+ inbound = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id=chat_id,+ content="question",+ metadata={+ WEBSOCKET_TURN_OWNER_METADATA_KEY: owner,+ "webui_turn_id": turn_id,+ "webui": True,+ },+ )+ await wth.publish_turn_run_status(bus, inbound, "running", started_at=1234.5)++ original_append = append_transcript_object++ def fail_answer(session_key: str, event: dict[str, Any]) -> None:+ if event.get("event") == "message":+ raise OSError("transient disk failure")+ original_append(session_key, event)++ monkeypatch.setattr("nanobot.webui.transcript.append_transcript_object", fail_answer)++ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="answer",+ metadata=dict(inbound.metadata),+ ))+ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="",+ metadata=dict(inbound.metadata),+ event=TurnEndEvent(),+ ))+ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="",+ metadata=dict(inbound.metadata),+ event=GoalStatusEvent(status="idle"),+ ))++ # Simulate a gateway restart: no process-local owner survives, so the+ # persisted marker must be sufficient to reject canonical completion.+ wth._WEBSOCKET_ACTIVE_TURNS.clear()+ wth._WEBSOCKET_TURN_WALL_STARTED_AT.clear()+ wth._WEBSOCKET_TURN_IDS.clear()+ wth._WEBSOCKET_TURN_OWNERS.clear()+ body = build_webui_thread_response(+ key,+ active_turn_started_at=wth.websocket_turn_wall_started_at(chat_id),+ active_turn_id=wth.websocket_turn_id(chat_id),+ active_turn_transcript_persistence_failed=(+ wth.websocket_turn_transcript_persistence_failed(chat_id)+ ),+ )+ assert body is not None+ assert read_transcript_lines(key)[-1]["transcript_incomplete"] is True+ assert body["completed_turn_ids"] == []+ assert [(message["role"], message["content"]) for message in body["messages"]] == [+ ("user", "question"),+ ]+ assert body["has_pending_tool_calls"] is True+ assert chat_id not in wth._WEBSOCKET_TURN_OWNERS+++async def test_http_replay_recovers_marked_answer_from_session_after_gateway_restart(+ tmp_path,+ monkeypatch,+) -> None:+ from urllib.parse import quote++ from websockets.datastructures import Headers+ from websockets.http11 import Request++ from nanobot.bus.events import InboundMessage++ chat_id = "answer-recovery-after-restart"+ key = f"websocket:{chat_id}"+ owner = "owner-answer-recovery"+ turn_id = "turn-answer-recovery"+ sessions_path = tmp_path / "sessions"+ sessions = SessionManager(sessions_path)+ session = sessions.get_or_create(key)+ session.add_message("user", "question")+ session.add_message("assistant", "durable answer")+ sessions.save(session)+ append_transcript_object(+ key,+ {+ "event": "user",+ "chat_id": chat_id,+ "text": "question",+ "turn_id": turn_id,+ },+ )++ bus = MagicMock()+ bus.publish_outbound = AsyncMock()+ channel = WebSocketChannel(+ {"enabled": True, "allowFrom": ["*"]},+ bus,+ gateway=_basic_handler(bus, session_manager=sessions),+ )+ inbound = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id=chat_id,+ content="question",+ metadata={+ WEBSOCKET_TURN_OWNER_METADATA_KEY: owner,+ "webui_turn_id": turn_id,+ "webui": True,+ },+ )+ await wth.publish_turn_run_status(bus, inbound, "running", started_at=1234.5)++ original_append = append_transcript_object++ def fail_answer(session_key: str, event: dict[str, Any]) -> None:+ if event.get("event") == "message":+ raise OSError("transient disk failure")+ original_append(session_key, event)++ monkeypatch.setattr("nanobot.webui.transcript.append_transcript_object", fail_answer)+ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="durable answer",+ metadata=dict(inbound.metadata),+ ))+ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="",+ metadata=dict(inbound.metadata),+ event=TurnEndEvent(),+ ))++ persisted_lines = read_transcript_lines(key)+ assert persisted_lines[-1]["event"] == "turn_end"+ assert persisted_lines[-1]["transcript_incomplete"] is True++ # Drop all process-local state and construct a fresh HTTP/session layer.+ wth._WEBSOCKET_ACTIVE_TURNS.clear()+ wth._WEBSOCKET_TURN_WALL_STARTED_AT.clear()+ wth._WEBSOCKET_TURN_IDS.clear()+ wth._WEBSOCKET_TURN_OWNERS.clear()+ restarted_channel = WebSocketChannel(+ {"enabled": True, "allowFrom": ["*"]},+ bus,+ gateway=_basic_handler(+ bus,+ session_manager=SessionManager(sessions_path),+ ),+ )+ restarted_channel.gateway.tokens.api_tokens["tok"] = time.monotonic() + 300.0+ encoded_key = quote(key, safe="")+ request = Request(+ f"/api/sessions/{encoded_key}/webui-thread",+ Headers([("Authorization", "Bearer tok")]),+ )++ response = restarted_channel.gateway.http._handle_webui_thread_get(+ request,+ encoded_key,+ )++ assert response.status_code == 200+ body = json.loads(response.body.decode())+ assert [(message["role"], message["content"]) for message in body["messages"]] == [+ ("user", "question"),+ ("assistant", "durable answer"),+ ]+ assert body["completed_turn_ids"] == [turn_id]+ assert body["has_pending_tool_calls"] is False+ assert body["active_turn_id"] is None+++async def test_webui_idle_clears_owner_when_no_completion_write_failed() -> None:+ from nanobot.bus.events import InboundMessage++ bus = MagicMock()+ bus.publish_outbound = AsyncMock()+ channel = WebSocketChannel(+ {"enabled": True, "allowFrom": ["*"]},+ bus,+ gateway=_basic_handler(bus),+ )+ chat_id = "cancelled-webui-turn"+ owner = "owner-cancelled"+ inbound = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id=chat_id,+ content="hi",+ metadata={+ WEBSOCKET_TURN_OWNER_METADATA_KEY: owner,+ "webui_turn_id": "turn-cancelled",+ "webui": True,+ },+ )+ await wth.publish_turn_run_status(bus, inbound, "running", started_at=1234.5)++ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="",+ metadata=dict(inbound.metadata),+ event=GoalStatusEvent(status="idle"),+ ))++ assert wth.websocket_turn_wall_started_at(chat_id) is None+ assert wth.websocket_turn_id(chat_id) is None+ assert chat_id not in wth._WEBSOCKET_ACTIVE_TURNS+++async def test_non_webui_transcript_failure_does_not_block_idle_cleanup(+ monkeypatch,+) -> None:+ from nanobot.bus.events import InboundMessage++ bus = MagicMock()+ bus.publish_outbound = AsyncMock()+ channel = WebSocketChannel(+ {"enabled": True, "allowFrom": ["*"]},+ bus,+ gateway=_basic_handler(bus),+ )+ chat_id = "direct-non-webui-failure"+ owner = "owner-direct"+ inbound = InboundMessage(+ channel="websocket",+ sender_id="runtime",+ chat_id=chat_id,+ content="direct",+ metadata={WEBSOCKET_TURN_OWNER_METADATA_KEY: owner},+ )+ await wth.publish_turn_run_status(bus, inbound, "running", started_at=1234.5)+ monkeypatch.setattr(+ "nanobot.webui.transcript.append_transcript_object",+ MagicMock(side_effect=OSError("disk full")),+ )++ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="direct answer",+ metadata=dict(inbound.metadata),+ ))++ assert wth.websocket_turn_transcript_persistence_failed(chat_id, owner) is False+ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="",+ metadata=dict(inbound.metadata),+ event=GoalStatusEvent(status="idle"),+ ))+ assert wth.websocket_turn_wall_started_at(chat_id) is None+ assert chat_id not in wth._WEBSOCKET_ACTIVE_TURNS+++async def test_idle_clears_matching_owner_when_fanout_fails() -> None:+ bus = MagicMock()+ channel = WebSocketChannel(+ {"enabled": True, "allowFrom": ["*"]},+ bus,+ gateway=_basic_handler(bus),+ )+ mock_ws = AsyncMock()+ mock_ws.send.side_effect = RuntimeError("fanout failed")+ chat_id = "idle-failure"+ owner = "owner-idle"+ channel._attach(mock_ws, chat_id)+ wth._WEBSOCKET_TURN_WALL_STARTED_AT[chat_id] = 1234.5+ wth._WEBSOCKET_TURN_OWNERS[chat_id] = owner++ with pytest.raises(RuntimeError, match="fanout failed"):+ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id=chat_id,+ content="",+ metadata={WEBSOCKET_TURN_OWNER_METADATA_KEY: owner},+ event=GoalStatusEvent(status="idle"),+ ))++ assert wth.websocket_turn_wall_started_at(chat_id) is None+ assert chat_id not in wth._WEBSOCKET_TURN_OWNERS++@pytest.mark.asyncioasync def test_send_turn_end_includes_latency_ms_when_present() -> None:bus = MagicMock()@@ -1654,6 +2098,7 @@ async def test_send_goal_status_running_emits_event_with_started_at() -> None:channel="websocket",chat_id="chat-1",content="",+ metadata={"webui_turn_id": "turn-running"},event=GoalStatusEvent(status="running", started_at=1_700_000_000.5),))@@ -1664,6 +2109,7 @@ async def test_send_goal_status_running_emits_event_with_started_at() -> None:"chat_id": "chat-1","status": "running","started_at": 1_700_000_000.5,+ "turn_id": "turn-running",}@@ -1678,12 +2124,18 @@ async def test_send_goal_status_idle_omits_started_at() -> None:channel="websocket",chat_id="chat-1",content="",+ metadata={"webui_turn_id": "turn-idle"},event=GoalStatusEvent(status="idle", started_at=99.0),))mock_ws.send.assert_awaited_once()body = json.loads(mock_ws.send.await_args.args[0])- assert body == {"event": "goal_status", "chat_id": "chat-1", "status": "idle"}+ assert body == {+ "event": "goal_status",+ "chat_id": "chat-1",+ "status": "idle",+ "turn_id": "turn-idle",+ }@pytest.mark.asyncio@@ -2725,6 +3177,147 @@ async def test_allow_from_rejects_unauthorized_client_id(bus: MagicMock) -> Noneawait server_task+async def test_open_connection_rejects_revoked_webui_turn_without_acceptance_ack(+ bus: MagicMock,+) -> None:+ channel = _ch(bus, allowFrom=["alice"])+ conn = AsyncMock()+ conn.remote_address = ("127.0.0.1", 50123)++ await channel._dispatch_envelope(+ conn,+ "revoked-client",+ {+ "type": "message",+ "chat_id": "chat-revoked",+ "content": "must not enter the bus",+ "webui": True,+ "turn_id": "turn-revoked",+ },+ )++ payloads = [json.loads(call.args[0]) for call in conn.send.await_args_list]+ assert payloads == [+ {+ "event": "error",+ "detail": "access_denied",+ "chat_id": "chat-revoked",+ "turn_id": "turn-revoked",+ }+ ]+ bus.publish_inbound.assert_not_awaited()+++async def test_midflight_allowlist_revocation_rejects_turn_without_ack(+ bus: MagicMock,+) -> None:+ channel = _ch(bus)+ channel.is_allowed = MagicMock(side_effect=[True, False])+ conn = AsyncMock()+ conn.remote_address = ("127.0.0.1", 50123)++ await channel._dispatch_envelope(+ conn,+ "webui-client",+ {+ "type": "message",+ "chat_id": "chat-midflight-revoked",+ "content": "must not be acknowledged",+ "webui": True,+ "turn_id": "turn-midflight-revoked",+ },+ )++ payloads = [json.loads(call.args[0]) for call in conn.send.await_args_list]+ assert payloads[-1] == {+ "event": "error",+ "detail": "access_denied",+ "chat_id": "chat-midflight-revoked",+ "turn_id": "turn-midflight-revoked",+ }+ assert all(payload["event"] != "message_accepted" for payload in payloads)+ bus.publish_inbound.assert_not_awaited()+++async def test_authorized_webui_turn_is_acked_after_bus_acceptance(+ bus: MagicMock,+) -> None:+ 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-accepted",+ "content": "accepted",+ "webui": True,+ "turn_id": "turn-accepted",+ },+ )++ bus.publish_inbound.assert_awaited_once()+ inbound = bus.publish_inbound.await_args.args[0]+ owner = inbound.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]+ assert wth.websocket_turn_id("chat-accepted") == "turn-accepted"+ assert wth.websocket_turn_wall_started_at("chat-accepted") is not None+ assert wth.websocket_turn_owner_is_registered(+ "chat-accepted",+ owner,+ "turn-accepted",+ )+ thread = build_webui_thread_response(+ "websocket:chat-accepted",+ active_turn_started_at=wth.websocket_turn_wall_started_at("chat-accepted"),+ active_turn_id=wth.websocket_turn_id("chat-accepted"),+ )+ assert thread is not None+ assert thread["active_turn_id"] == "turn-accepted"+ assert thread["has_pending_tool_calls"] is True+ payloads = [json.loads(call.args[0]) for call in conn.send.await_args_list]+ assert payloads[-1] == {+ "event": "message_accepted",+ "chat_id": "chat-accepted",+ "turn_id": "turn-accepted",+ }+++async def test_side_channel_command_does_not_register_queued_turn(+ bus: MagicMock,+) -> None:+ 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-status",+ "content": "/status",+ "webui": True,+ "turn_id": "turn-status",+ },+ )++ inbound = bus.publish_inbound.await_args.args[0]+ assert WEBSOCKET_TURN_OWNER_METADATA_KEY not in inbound.metadata+ assert wth.websocket_turn_wall_started_at("chat-status") is None+ payloads = [json.loads(call.args[0]) for call in conn.send.await_args_list]+ assert payloads[-1] == {+ "event": "message_accepted",+ "chat_id": "chat-status",+ "turn_id": "turn-status",+ }++@pytest.mark.asyncioasync def test_client_id_truncation(bus: MagicMock) -> None:port = 29883@@ -3238,6 +3831,255 @@ 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"+ assert body["has_pending_tool_calls"] is False+++def test_handle_webui_thread_get_reports_registered_turn_as_pending(+ 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)+ monkeypatch.setattr(+ "nanobot.session.webui_turns.websocket_turn_wall_started_at",+ lambda chat_id: 1_700_000_000.0 if chat_id == "running" else None,+ )+ monkeypatch.setattr(+ "nanobot.session.webui_turns.websocket_turn_id",+ lambda chat_id: "turn-running" if chat_id == "running" else None,+ )+ key = "websocket:running"+ append_transcript_object(+ key,+ {+ "event": "user",+ "chat_id": "running",+ "text": "hi",+ "turn_id": "turn-running",+ },+ )+ bus = MagicMock()+ channel = _ch(bus)+ 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 body["messages"][0]["content"] == "hi"+ assert body["has_pending_tool_calls"] is True+++async def test_idle_registry_stays_pending_until_turn_end_is_persisted(+ tmp_path,+ monkeypatch,+) -> None:+ from urllib.parse import quote++ from websockets.datastructures import Headers+ from websockets.http11 import Request++ from nanobot.bus.events import InboundMessage+ from nanobot.session import webui_turns as wth+ from nanobot.webui.transcript import append_transcript_object++ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ key = "websocket:idle-order"+ turn_id = "turn-idle-order"+ append_transcript_object(+ key,+ {+ "event": "user",+ "chat_id": "idle-order",+ "text": "hi",+ "turn_id": turn_id,+ },+ )+ bus = MagicMock()+ bus.publish_outbound = AsyncMock()+ inbound = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id="idle-order",+ content="hi",+ metadata={"webui_turn_id": turn_id},+ )+ channel = _ch(bus)+ channel.gateway.tokens.api_tokens["tok"] = time.monotonic() + 300.0+ enc = quote(key, safe="")+ request = Request(+ f"/api/sessions/{enc}/webui-thread",+ Headers([("Authorization", "Bearer tok")]),+ )++ try:+ await wth.publish_turn_run_status(bus, inbound, "running")+ await wth.publish_turn_run_status(bus, inbound, "idle")++ before_delivery = channel.gateway.http._handle_webui_thread_get(request, enc)+ assert json.loads(before_delivery.body.decode())["has_pending_tool_calls"] is True++ await channel.send(OutboundMessage(+ channel="websocket",+ chat_id="idle-order",+ content="",+ metadata=dict(inbound.metadata),+ event=TurnEndEvent(),+ ))++ after_delivery = channel.gateway.http._handle_webui_thread_get(request, enc)+ assert json.loads(after_delivery.body.decode())["has_pending_tool_calls"] is False+ assert wth.websocket_turn_wall_started_at("idle-order") is None+ assert wth.websocket_turn_id("idle-order") is None+ finally:+ wth._WEBSOCKET_TURN_WALL_STARTED_AT.pop("idle-order", None)+ wth._WEBSOCKET_TURN_IDS.pop("idle-order", None)+ wth._WEBSOCKET_TURN_OWNERS.pop("idle-order", None)+++async def test_webui_thread_api_restores_older_owner_after_latest_completes() -> None:+ from urllib.parse import quote++ from websockets.datastructures import Headers+ from websockets.http11 import Request++ from nanobot.bus.events import InboundMessage++ chat_id = "concurrent-projection"+ key = f"websocket:{chat_id}"+ append_transcript_object(+ key,+ {+ "event": "user",+ "chat_id": chat_id,+ "text": "first",+ "turn_id": "turn-first",+ },+ )+ bus = MagicMock()+ bus.publish_outbound = AsyncMock()+ first = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id=chat_id,+ content="first",+ metadata={+ WEBSOCKET_TURN_OWNER_METADATA_KEY: "owner-first",+ "webui_turn_id": "turn-first",+ },+ session_key_override="websocket:session-first",+ )+ second = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id=chat_id,+ content="second",+ metadata={+ WEBSOCKET_TURN_OWNER_METADATA_KEY: "owner-second",+ "webui_turn_id": "turn-second",+ },+ session_key_override="websocket:session-second",+ )+ await wth.publish_turn_run_status(bus, first, "running", started_at=100.0)+ await wth.publish_turn_run_status(bus, second, "running", started_at=200.0)+ assert wth.clear_websocket_turn_if_current(chat_id, "owner-second") is True++ channel = _ch(bus)+ channel.gateway.tokens.api_tokens["tok"] = time.monotonic() + 300.0+ enc = quote(key, safe="")+ request = Request(+ f"/api/sessions/{enc}/webui-thread",+ Headers([("Authorization", "Bearer tok")]),+ )+ response = channel.gateway.http._handle_webui_thread_get(request, enc)++ assert response.status_code == 200+ payload = json.loads(response.body.decode())+ assert payload["has_pending_tool_calls"] is True+ assert wth.websocket_turn_wall_started_at(chat_id) == 100.0+ assert wth.websocket_turn_id(chat_id) == "turn-first"+ assert wth._WEBSOCKET_TURN_OWNERS[chat_id] == "owner-first"+++ ("active_turn_id", "expected_pending"),+ [+ ("turn-complete", False),+ ("turn-next", True),+ ],+)+def test_handle_webui_thread_get_reconciles_registered_turn_with_turn_end(+ tmp_path,+ monkeypatch,+ active_turn_id: str,+ expected_pending: bool,+) -> 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)+ monkeypatch.setattr(+ "nanobot.session.webui_turns.websocket_turn_wall_started_at",+ lambda chat_id: 1_700_000_000.0 if chat_id == "running" else None,+ )+ monkeypatch.setattr(+ "nanobot.session.webui_turns.websocket_turn_id",+ lambda chat_id: active_turn_id if chat_id == "running" else None,+ )+ key = "websocket:running"+ append_transcript_object(+ key,+ {+ "event": "user",+ "chat_id": "running",+ "text": "hi",+ "turn_id": "turn-complete",+ },+ )+ append_transcript_object(+ key,+ {+ "event": "message",+ "chat_id": "running",+ "text": "done",+ "turn_id": "turn-complete",+ },+ )+ append_transcript_object(+ key,+ {+ "event": "turn_end",+ "chat_id": "running",+ "turn_id": "turn-complete",+ },+ )+ bus = MagicMock()+ channel = _ch(bus)+ 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 body["messages"][-1]["content"] == "done"+ assert body["has_pending_tool_calls"] is expected_pending+ assert body["active_turn_id"] == active_turn_iddef test_handle_webui_thread_get_accepts_pagination_query(tmp_path, monkeypatch) -> None:diff --git a/nanobot/channels/websocket/tests/test_websocket_envelope_media.py b/nanobot/channels/websocket/tests/test_websocket_envelope_media.pyindex 94dd25119..85a24e8db 100644--- a/nanobot/channels/websocket/tests/test_websocket_envelope_media.py+++ b/nanobot/channels/websocket/tests/test_websocket_envelope_media.py@@ -19,6 +19,7 @@ from nanobot.channels.websocket.runtime import (WebSocketChannel,WebSocketConfig,)+from nanobot.session import webui_turns as wthfrom nanobot.webui.gateway_services import build_gateway_services@@ -59,6 +60,19 @@ def _make_channel() -> WebSocketChannel:return channel[email protected](autouse=True)+def isolate_websocket_turn_state() -> None:+ wth._WEBSOCKET_ACTIVE_TURNS.clear()+ wth._WEBSOCKET_TURN_WALL_STARTED_AT.clear()+ wth._WEBSOCKET_TURN_IDS.clear()+ wth._WEBSOCKET_TURN_OWNERS.clear()+ yield+ wth._WEBSOCKET_ACTIVE_TURNS.clear()+ wth._WEBSOCKET_TURN_WALL_STARTED_AT.clear()+ wth._WEBSOCKET_TURN_IDS.clear()+ wth._WEBSOCKET_TURN_OWNERS.clear()++# -- max_message_bytes bump ----------------------------------------------------@@ -94,6 +108,28 @@ async def test_message_without_media_backward_compatible() -> None:assert call.kwargs["media"] is None+async def test_webui_message_acceptance_echoes_turn_id() -> None:+ channel = _make_channel()+ mock_conn = AsyncMock()+ envelope = {+ "type": "message",+ "chat_id": "abc123",+ "content": "hello",+ "webui": True,+ "turn_id": "turn-accepted",+ }++ await channel._dispatch_envelope(mock_conn, "client-1", envelope)++ channel._handle_message.assert_awaited_once()+ assert json.loads(mock_conn.send.await_args.args[0]) == {+ "event": "message_accepted",+ "chat_id": "abc123",+ "turn_id": "turn-accepted",+ }++@pytest.mark.asyncioasync def test_message_text_policy_is_independent_from_transport_limit() -> None:channel = _make_channel()@@ -102,6 +138,7 @@ async def test_message_text_policy_is_independent_from_transport_limit() -> None"type": "message","chat_id": "abc123","content": "你" * 22_000,+ "turn_id": "turn-text-policy",}await channel._dispatch_envelope(mock_conn, "client-1", envelope)@@ -113,6 +150,7 @@ async def test_message_text_policy_is_independent_from_transport_limit() -> None"chat_id": "abc123","detail": "message_rejected","reason": "text_too_large",+ "turn_id": "turn-text-policy",}@@ -235,6 +273,7 @@ async def test_message_rejected_when_more_than_four_images(tmp_path) -> None:"chat_id": "abc123","content": "hi","media": [{"data_url": _tiny_png_data_url()}] * 5,+ "turn_id": "turn-attachments",}with patch(@@ -246,8 +285,10 @@ async def test_message_rejected_when_more_than_four_images(tmp_path) -> None:mock_conn.send.assert_awaited_once()err = json.loads(mock_conn.send.call_args[0][0])assert err["event"] == "error"+ assert err["chat_id"] == "abc123"assert err["detail"] == "attachment_rejected"assert err["reason"] == "too_many_images"+ assert err["turn_id"] == "turn-attachments"@pytest.mark.asynciodiff --git a/nanobot/channels/websocket/tests/test_websocket_reconnect_idle.py b/nanobot/channels/websocket/tests/test_websocket_reconnect_idle.pyindex eddd2bea6..951b7d7cd 100644--- a/nanobot/channels/websocket/tests/test_websocket_reconnect_idle.py+++ b/nanobot/channels/websocket/tests/test_websocket_reconnect_idle.py@@ -53,9 +53,19 @@ async def test_hydrate_after_subscribe_pushes_running_when_turn_active():channel.send_goal_state = mock_send_goal_statechannel.send_goal_status = mock_send_goal_status- with patch("nanobot.channels.websocket.runtime.websocket_turn_wall_started_at", return_value=1234567890.0):+ with (+ patch(+ "nanobot.channels.websocket.runtime.websocket_turn_wall_started_at",+ return_value=1234567890.0,+ ),+ patch(+ "nanobot.channels.websocket.runtime.websocket_turn_id",+ return_value="turn-active",+ ),+ ):await channel._hydrate_after_subscribe("test-chat")running_events = [e for e in sent_events if e[0] == "goal_status" and e[2] == "running"]assert len(running_events) == 1assert running_events[0][3]["started_at"] == 1234567890.0+ assert running_events[0][3]["turn_id"] == "turn-active"diff --git a/nanobot/command/builtin.py b/nanobot/command/builtin.pyindex 3ba687830..4da0b01de 100644--- a/nanobot/command/builtin.py+++ b/nanobot/command/builtin.py@@ -14,7 +14,7 @@ from typing import Literalfrom nanobot import __version__from nanobot.agent.goal_permission import goal_mutation_permissionfrom nanobot.bus.events import OutboundMessage-from nanobot.command.router import CommandContext, CommandRouter+from nanobot.command.router import CommandContext, CommandRouter, normalize_command_textfrom nanobot.utils.helpers import build_status_contentfrom nanobot.utils.restart import set_restart_notice_to_envfrom nanobot.utils.workspace_prompts import initialize_workspace_prompt@@ -180,6 +180,21 @@ def builtin_command_palette() -> list[dict[str, str | bool]]:return [spec.as_dict() for spec in BUILTIN_COMMAND_SPECS]+def builtin_command_starts_agent_turn(text: str) -> bool:+ """Return whether WebUI ingress should expect a normal agent lifecycle."""+ normalized = normalize_command_text(text)+ command, separator, args = normalized.partition(" ")+ spec = next(+ (item for item in BUILTIN_COMMAND_SPECS if item.command == command.lower()),+ None,+ )+ if spec is None or (separator and not spec.accepts_args):+ return True+ if spec.lifecycle == "agent_turn":+ return True+ return spec.lifecycle == "agent_turn_with_args" and bool(args.strip())++async def cmd_stop(ctx: CommandContext) -> OutboundMessage:"""Cancel all active tasks and subagents for the session."""loop = ctx.loopdiff --git a/nanobot/session/webui_turns.py b/nanobot/session/webui_turns.pyindex 38967ccce..37bfc731e 100644--- a/nanobot/session/webui_turns.py+++ b/nanobot/session/webui_turns.py@@ -42,7 +42,10 @@ from nanobot.session.history_visibility import is_hidden_history_messagefrom nanobot.session.manager import Session, SessionManagerfrom nanobot.utils.helpers import strip_think, truncate_textfrom nanobot.utils.llm_runtime import LLMRuntime-from nanobot.webui.metadata import WEBUI_TURN_METADATA_KEY+from nanobot.webui.metadata import (+ WEBSOCKET_TURN_OWNER_METADATA_KEY,+ WEBUI_TURN_METADATA_KEY,+)WEBUI_SESSION_METADATA_KEY = "webui"WEBUI_TITLE_METADATA_KEY = "title"@@ -51,9 +54,42 @@ TITLE_MAX_CHARS = 60TITLE_GENERATION_MAX_TOKENS = 96TITLE_GENERATION_REASONING_EFFORT = "none"-# Wall-clock turn start per ``chat_id`` (websocket only). Survives browser refresh while the-# gateway process stays up; cleared on idle/stop and implicitly dropped on restart.+# Latest active turn projection per ``chat_id`` (websocket only). It survives browser refresh+# while the gateway process stays up and is implicitly dropped on restart._WEBSOCKET_TURN_WALL_STARTED_AT: dict[str, float] = {}+_WEBSOCKET_TURN_IDS: dict[str, str] = {}+_WEBSOCKET_TURN_OWNERS: dict[str, str] = {}+++@dataclass(frozen=True)+class _WebsocketTurn:+ started_at: float+ turn_id: str | None+ transcript_persistence_failed: bool = False+++# All in-flight lifecycle owners per chat, in admission order. The three maps+# above remain the latest-owner projection consumed by the HTTP API.+_WEBSOCKET_ACTIVE_TURNS: dict[str, dict[str, _WebsocketTurn]] = {}+++def _sync_websocket_turn_projection(chat_id: str) -> None:+ turns = _WEBSOCKET_ACTIVE_TURNS.get(chat_id)+ if not turns:+ _WEBSOCKET_ACTIVE_TURNS.pop(chat_id, None)+ _WEBSOCKET_TURN_WALL_STARTED_AT.pop(chat_id, None)+ _WEBSOCKET_TURN_IDS.pop(chat_id, None)+ _WEBSOCKET_TURN_OWNERS.pop(chat_id, None)+ return++ owner = next(reversed(turns))+ turn = turns[owner]+ _WEBSOCKET_TURN_WALL_STARTED_AT[chat_id] = turn.started_at+ _WEBSOCKET_TURN_OWNERS[chat_id] = owner+ if turn.turn_id is None:+ _WEBSOCKET_TURN_IDS.pop(chat_id, None)+ else:+ _WEBSOCKET_TURN_IDS[chat_id] = turn.turn_iddef mark_webui_session(session: Session, metadata: dict[str, Any]) -> bool:@@ -203,6 +239,96 @@ def websocket_turn_wall_started_at(chat_id: str) -> float | None:return _WEBSOCKET_TURN_WALL_STARTED_AT.get(chat_id)+def websocket_turn_id(chat_id: str) -> str | None:+ """Return the WebUI identity of the active turn, when one was provided."""+ return _WEBSOCKET_TURN_IDS.get(chat_id)+++def register_queued_websocket_turn_if_idle(+ chat_id: str,+ turn_id: str | None,+) -> str | None:+ """Track an accepted WebUI turn while it waits for AgentLoop admission."""+ if websocket_turn_wall_started_at(chat_id) is not None:+ return None+ owner = uuid4().hex+ _WEBSOCKET_ACTIVE_TURNS.setdefault(chat_id, {})[owner] = _WebsocketTurn(+ started_at=time.time(),+ turn_id=turn_id,+ )+ _sync_websocket_turn_projection(chat_id)+ return owner+++def websocket_turn_owner_is_registered(+ chat_id: str,+ owner: str,+ turn_id: str | None,+) -> bool:+ """Return whether websocket ingress registered this owner for the turn."""+ turn = _WEBSOCKET_ACTIVE_TURNS.get(chat_id, {}).get(owner)+ return turn is not None and turn.turn_id == turn_id+++def websocket_turn_transcript_persistence_failed(+ chat_id: str,+ owner: str | None = None,+) -> bool:+ """Return whether one active owner has an incomplete canonical transcript."""+ turns = _WEBSOCKET_ACTIVE_TURNS.get(chat_id)+ if not turns:+ return False+ selected_owner = owner or next(reversed(turns))+ turn = turns.get(selected_owner)+ return turn.transcript_persistence_failed if turn is not None else False+++def mark_websocket_turn_transcript_persistence_failed(+ chat_id: str,+ owner: str | None,+) -> bool:+ """Keep a turn active when any canonical display event could not be written."""+ if not owner:+ return False+ turns = _WEBSOCKET_ACTIVE_TURNS.get(chat_id)+ if turns is None or owner not in turns:+ return False+ turns[owner] = replace(turns[owner], transcript_persistence_failed=True)+ return True+++def clear_websocket_turn_if_current(+ chat_id: str,+ owner: str | None,+ *,+ preserve_persistence_failure: bool = False,+) -> bool:+ """Clear one lifecycle owner without disturbing concurrent turns for the chat."""+ if not owner:+ return False+ turns = _WEBSOCKET_ACTIVE_TURNS.get(chat_id)+ if turns is not None:+ if owner not in turns:+ return False+ if preserve_persistence_failure and turns[owner].transcript_persistence_failed:+ return False+ turns.pop(owner)+ _sync_websocket_turn_projection(chat_id)+ return True++ # Compatibility for callers/tests that populated the legacy projection+ # directly before the multi-owner registry existed.+ if (+ chat_id in _WEBSOCKET_TURN_WALL_STARTED_AT+ and _WEBSOCKET_TURN_OWNERS.get(chat_id) == owner+ ):+ _WEBSOCKET_TURN_WALL_STARTED_AT.pop(chat_id, None)+ _WEBSOCKET_TURN_IDS.pop(chat_id, None)+ _WEBSOCKET_TURN_OWNERS.pop(chat_id, None)+ return True+ return False++def build_bus_progress_callback(bus: MessageBus,msg: InboundMessage,@@ -229,9 +355,17 @@ async def publish_turn_run_status(else:t0 = time.time()started_at_event = t0- _WEBSOCKET_TURN_WALL_STARTED_AT[cid] = t0- else:- _WEBSOCKET_TURN_WALL_STARTED_AT.pop(cid, None)+ owner = msg.metadata.get(WEBSOCKET_TURN_OWNER_METADATA_KEY)+ if not isinstance(owner, str) or not owner:+ owner = uuid4().hex+ msg.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY] = owner+ turn_id = msg.metadata.get(WEBUI_TURN_METADATA_KEY)+ current_turn_id = turn_id if isinstance(turn_id, str) and turn_id else None+ turns = _WEBSOCKET_ACTIVE_TURNS.setdefault(cid, {})+ # Re-registration makes this owner the latest projection.+ turns.pop(owner, None)+ turns[owner] = _WebsocketTurn(started_at=t0, turn_id=current_turn_id)+ _sync_websocket_turn_projection(cid)await bus.publish_outbound(outbound_message_for_event(channel=msg.channel,@@ -254,25 +388,50 @@ class WebuiTurnRoutePolicy:route: TurnRoute,) -> TurnRoute:"""Make an independently dispatched late subagent result visible in WebUI."""+ routed = routeif (- msg.channel != "system"- or msg.sender_id != "subagent"- or msg.metadata.get("injected_event") != "subagent_result"- or route.channel != "websocket"+ msg.channel == "system"+ and msg.sender_id == "subagent"+ and msg.metadata.get("injected_event") == "subagent_result"+ and route.channel == "websocket"):- return route-- session = self.sessions.get_or_create(session_key)- if session.metadata.get(WEBUI_SESSION_METADATA_KEY) is not True:- return route-- metadata = dict(route.metadata)- metadata.update({- WEBUI_SESSION_METADATA_KEY: True,- "_wants_stream": True,- WEBUI_TURN_METADATA_KEY: f"subagent:{uuid4().hex}",- })- return replace(route, metadata=metadata, publish_lifecycle=True)+ session = self.sessions.get_or_create(session_key)+ if session.metadata.get(WEBUI_SESSION_METADATA_KEY) is True:+ metadata = dict(route.metadata)+ metadata.update({+ WEBUI_SESSION_METADATA_KEY: True,+ "_wants_stream": True,+ WEBUI_TURN_METADATA_KEY: f"subagent:{uuid4().hex}",+ })+ routed = replace(route, metadata=metadata, publish_lifecycle=True)++ if routed.channel == "websocket" and routed.publish_lifecycle:+ metadata = dict(routed.metadata)+ turn_id = metadata.get(WEBUI_TURN_METADATA_KEY)+ current_turn_id = turn_id if isinstance(turn_id, str) and turn_id else None+ queued_owner = metadata.get(WEBSOCKET_TURN_OWNER_METADATA_KEY)+ owner = (+ queued_owner+ if (+ msg.channel == "websocket"+ and isinstance(queued_owner, str)+ and websocket_turn_owner_is_registered(+ str(msg.chat_id),+ queued_owner,+ current_turn_id,+ )+ )+ else uuid4().hex+ )+ metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY] = owner+ routed = replace(routed, metadata=metadata)+ # Direct websocket turns publish their final idle transition from+ # the original input message. Carry the same server-owned identity+ # there, overwriting any untrusted client-supplied value.+ if msg.channel == "websocket":+ msg.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY] = owner++ return routeddef build_webui_fallback_model_observer(bus: MessageBus) -> FallbackModelObserver:diff --git a/nanobot/webui/metadata.py b/nanobot/webui/metadata.pyindex 03d426bfd..c00613b36 100644--- a/nanobot/webui/metadata.py+++ b/nanobot/webui/metadata.py@@ -1,4 +1,5 @@"""Shared WebUI metadata keys."""WEBUI_TURN_METADATA_KEY = "webui_turn_id"+WEBSOCKET_TURN_OWNER_METADATA_KEY = "_websocket_turn_owner"WEBUI_MESSAGE_SOURCE_METADATA_KEY = "_webui_message_source"diff --git a/nanobot/webui/transcript.py b/nanobot/webui/transcript.pyindex 2c8a73290..54c79d71e 100644--- a/nanobot/webui/transcript.py+++ b/nanobot/webui/transcript.py@@ -25,6 +25,7 @@ from nanobot.webui.metadata import WEBUI_MESSAGE_SOURCE_METADATA_KEY, WEBUI_TURNWEBUI_TRANSCRIPT_SCHEMA_VERSION = 3WEBUI_FORK_MARKER_EVENT = "fork_marker"+WEBUI_TRANSCRIPT_INCOMPLETE_KEY = "transcript_incomplete"_MAX_TRANSCRIPT_FILE_BYTES = 8 * 1024 * 1024_TARGET_ACTIVE_TRANSCRIPT_BYTES = _MAX_TRANSCRIPT_FILE_BYTES // 2_TRANSCRIPT_SEGMENT_MANIFEST_VERSION = 2@@ -151,6 +152,12 @@ class _TranscriptChunkRef(NamedTuple):user_count: int+class _SessionBackfillTurn(NamedTuple):+ user_event: dict[str, Any]+ assistant_signature: tuple[str, ...]+ assistant_records: tuple[dict[str, Any], ...]++def _record_json_line(record: dict[str, Any]) -> str:return json.dumps(record, ensure_ascii=False, separators=(",", ":"))@@ -665,7 +672,7 @@ class WebUITranscriptRecorder:phase: str | None = None,include_source: bool = False,transcript_overrides: dict[str, Any] | None = None,- ) -> None:+ ) -> bool:self.prepare_event(chat_id,event,@@ -676,7 +683,7 @@ class WebUITranscriptRecorder:record = dict(event)if transcript_overrides:record.update(transcript_overrides)- self.append(chat_id, record)+ return self.append(chat_id, record)def append_user_message(self,@@ -687,9 +694,9 @@ class WebUITranscriptRecorder:media_paths: list[str] | None = None,cli_apps: list[dict[str, Any]] | None = None,mcp_presets: list[dict[str, Any]] | None = None,- ) -> None:+ ) -> bool:if text.strip() == "/stop" and not media_paths:- return+ return Falsepayload = build_user_transcript_event(chat_id,text,@@ -698,15 +705,17 @@ class WebUITranscriptRecorder:mcp_presets=mcp_presets,)if payload is None:- return- self.prepare_and_append(chat_id, payload, metadata=metadata, phase="user")+ return False+ return self.prepare_and_append(chat_id, payload, metadata=metadata, phase="user")- def append(self, chat_id: str, event: dict[str, Any]) -> None:+ def append(self, chat_id: str, event: dict[str, Any]) -> bool:try:dup = json.loads(json.dumps(event, ensure_ascii=False))append_transcript_object(f"websocket:{chat_id}", dup)except (OSError, ValueError, TypeError) as e:self._log.warning("webui transcript append failed: {}", e)+ return False+ return Truedef _next_turn_seq(self, chat_id: str, turn_id: str) -> int:key = (chat_id, turn_id)@@ -921,32 +930,69 @@ def _assistant_text_signature(value: Any) -> str:return value.strip() if isinstance(value, str) else ""+def _session_assistant_event(+ session_key: str,+ message: dict[str, Any],+) -> dict[str, Any] | None:+ if message.get("role") != "assistant" or is_hidden_history_message(message):+ return None+ message = public_history_message(message)+ content = message.get("content")+ text = content if isinstance(content, str) else ""+ media = message.get("media")+ media_paths = [str(path) for path in media] if isinstance(media, list) else []+ media_paths = [path for path in media_paths if path]+ if not text.strip() and not media_paths:+ return None+ chat_id = session_key.split(":", 1)[1] if ":" in session_key else session_key+ event: dict[str, Any] = {+ "event": "message",+ "chat_id": chat_id,+ "text": text,+ }+ if media_paths:+ event["media"] = media_paths+ latency_ms = message.get("latency_ms")+ if isinstance(latency_ms, int | float) and latency_ms >= 0:+ event["latency_ms"] = int(latency_ms)+ return event++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, ...]]] = []+) -> list[_SessionBackfillTurn]:+ turns: list[_SessionBackfillTurn] = []current_user: dict[str, Any] | None = None- assistant_texts: list[str] = []+ assistant_records: list[dict[str, Any]] = []def flush() -> None:- if current_user is None:+ if current_user is None or not assistant_records:return- signature = tuple(text for text in assistant_texts if text)- if signature:- turns.append((current_user, signature))+ signature = tuple(+ text+ for record in assistant_records+ if (text := _assistant_text_signature(record.get("text")))+ )+ turns.append(+ _SessionBackfillTurn(+ current_user,+ signature,+ tuple(dict(record) for record in assistant_records),+ )+ )for message in session_messages:role = message.get("role")if role == "user":flush()current_user = _session_user_event(session_key, message)- assistant_texts = []+ assistant_records = []continueif role == "assistant" and current_user is not None:- text = _assistant_text_signature(message.get("content"))- if text:- assistant_texts.append(text)+ record = _session_assistant_event(session_key, message)+ if record is not None:+ assistant_records.append(record)flush()return turns@@ -976,7 +1022,7 @@ def _transcript_turn_signature(records: list[dict[str, Any]]) -> tuple[str, ...]def _find_unique_session_turn(- session_turns: list[tuple[dict[str, Any], tuple[str, ...]]],+ session_turns: list[_SessionBackfillTurn],signature: tuple[str, ...],start: int,) -> int | None:@@ -984,7 +1030,7 @@ def _find_unique_session_turn(return Nonefound: int | None = Nonefor index in range(start, len(session_turns)):- if session_turns[index][1] != signature:+ if session_turns[index].assistant_signature != signature:continueif found is not None:return None@@ -992,6 +1038,101 @@ def _find_unique_session_turn(return found+def _user_recovery_signature(event: dict[str, Any]) -> str:+ fields = {+ key: event[key]+ for key in ("text", "media_paths", "cli_apps", "mcp_presets")+ if key in event+ }+ return json.dumps(fields, ensure_ascii=False, sort_keys=True, separators=(",", ":"))+++def _find_unique_session_turn_by_user(+ session_turns: list[_SessionBackfillTurn],+ user_event: dict[str, Any],+) -> _SessionBackfillTurn | None:+ signature = _user_recovery_signature(user_event)+ matches = [+ turn+ for turn in session_turns+ if _user_recovery_signature(turn.user_event) == signature+ ]+ return matches[0] if len(matches) == 1 else None+++def _is_recoverable_answer_record(record: dict[str, Any]) -> bool:+ event = record.get("event")+ if event in {"delta", "stream_end"}:+ return True+ return event == "message" and record.get("kind") not in {+ "tool_hint",+ "progress",+ "reasoning",+ }+++def recover_incomplete_turns_from_session(+ lines: list[dict[str, Any]],+ session_messages: list[dict[str, Any]] | None,+ *,+ session_key: str,+) -> list[dict[str, Any]]:+ """Recover marked transcript answers only when one durable session turn matches."""+ if not lines or not session_messages:+ return lines+ session_turns = _session_backfill_turns(session_key, session_messages)+ if not session_turns:+ return lines++ recovered: list[dict[str, Any]] = []+ for turn in _split_transcript_turns(lines):+ turn_end = turn[-1] if turn else None+ if (+ not isinstance(turn_end, dict)+ or turn_end.get("event") != "turn_end"+ or turn_end.get(WEBUI_TRANSCRIPT_INCOMPLETE_KEY) is not True+ ):+ recovered.extend(turn)+ continue++ user_events = [record for record in turn if record.get("event") == "user"]+ if len(user_events) != 1:+ recovered.extend(turn)+ continue+ session_turn = _find_unique_session_turn_by_user(session_turns, user_events[0])+ if session_turn is None or not session_turn.assistant_records:+ recovered.extend(turn)+ continue++ stable_end_ms = _valid_created_at_ms(turn_end.get("created_at_ms"))+ turn_id = turn_end.get("turn_id")+ answer_records: list[dict[str, Any]] = []+ for index, source in enumerate(session_turn.assistant_records):+ answer = dict(source)+ if isinstance(turn_id, str) and turn_id:+ answer["turn_id"] = turn_id+ answer["turn_phase"] = "answer"+ if stable_end_ms is not None:+ answer["created_at_ms"] = max(+ 0,+ stable_end_ms - len(session_turn.assistant_records) + index,+ )+ answer_records.append(answer)++ # Session history is the durable source of the completed answer. Keep+ # traces/reasoning/file edits, but replace any partial answer fragments.+ recovered.extend(+ record+ for record in turn[:-1]+ if not _is_recoverable_answer_record(record)+ )+ recovered.extend(answer_records)+ completed_end = dict(turn_end)+ completed_end.pop(WEBUI_TRANSCRIPT_INCOMPLETE_KEY, None)+ recovered.append(completed_end)+ return recovered++def _with_backfilled_user(records: list[dict[str, Any]],user_event: dict[str, Any],@@ -1972,8 +2113,36 @@ def fork_boundary_message_count(lines: list[dict[str, Any]]) -> int | None:return None-def has_pending_tool_calls(lines: list[dict[str, Any]]) -> bool:+def has_pending_tool_calls(+ lines: list[dict[str, Any]],+ *,+ active_turn_started_at: float | None = None,+ active_turn_id: str | None = None,+ active_turn_transcript_persistence_failed: bool = False,+) -> bool:"""Return True when the selected transcript tail looks like an unfinished turn."""+ # An older canonical turn can remain unsafe even after a later turn+ # completes. Recovery removes this marker only after matching durable+ # session history, so no later turn_end may hide it.+ if any(+ rec.get(WEBUI_TRANSCRIPT_INCOMPLETE_KEY) is True+ for rec in lines+ ):+ return True+ if active_turn_started_at is not None:+ if active_turn_transcript_persistence_failed:+ return True+ if active_turn_id is None:+ return True+ for rec in reversed(lines):+ transcript_turn_id = rec.get("turn_id")+ if not isinstance(transcript_turn_id, str) or not transcript_turn_id:+ continue+ if transcript_turn_id != active_turn_id:+ return True+ return rec.get("event") != "turn_end"+ return True+for rec in reversed(lines):ev = rec.get("event")if ev == "turn_end":@@ -1995,6 +2164,24 @@ def has_pending_tool_calls(lines: list[dict[str, Any]]) -> bool:return False+def completed_turn_ids(lines: list[dict[str, Any]]) -> list[str]:+ """Return stable identities for turns with an explicitly persisted completion."""+ completed: list[str] = []+ seen: set[str] = set()+ for rec in lines:+ if (+ rec.get("event") != "turn_end"+ or rec.get(WEBUI_TRANSCRIPT_INCOMPLETE_KEY) is True+ ):+ continue+ turn_id = rec.get("turn_id")+ if not isinstance(turn_id, str) or not turn_id or turn_id in seen:+ continue+ seen.add(turn_id)+ completed.append(turn_id)+ return completed++def build_webui_thread_response(session_key: str,*,@@ -2002,6 +2189,9 @@ def build_webui_thread_response(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,+ active_turn_started_at: float | None = None,+ active_turn_id: str | None = None,+ active_turn_transcript_persistence_failed: bool = False,limit: int | None = None,direction: str | None = None,before: str | None = None,@@ -2013,9 +2203,14 @@ def build_webui_thread_response(lines, page = _select_transcript_page(session_key, limit=limit, before=before)else:lines = read_transcript_lines(session_key)- if not lines:+ if not lines and active_turn_started_at is None:return Nonelines = inject_missing_user_events_from_session(session_key, lines, session_messages)+ lines = recover_incomplete_turns_from_session(+ lines,+ session_messages,+ session_key=session_key,+ )fork_boundary = fork_boundary_message_count(lines)msgs = replay_transcript_to_ui_messages(lines,@@ -2027,7 +2222,16 @@ def build_webui_thread_response("schemaVersion": WEBUI_TRANSCRIPT_SCHEMA_VERSION,"sessionKey": session_key,"messages": msgs,- "has_pending_tool_calls": has_pending_tool_calls(lines),+ "completed_turn_ids": completed_turn_ids(lines),+ "has_pending_tool_calls": has_pending_tool_calls(+ lines,+ active_turn_started_at=active_turn_started_at,+ active_turn_id=active_turn_id,+ active_turn_transcript_persistence_failed=(+ active_turn_transcript_persistence_failed+ ),+ ),+ "active_turn_id": active_turn_id,}if page is not None:page["loaded_message_count"] = len(msgs)diff --git a/nanobot/webui/ws_http.py b/nanobot/webui/ws_http.pyindex af2b2a3ac..fb3a373b6 100644--- a/nanobot/webui/ws_http.py+++ b/nanobot/webui/ws_http.py@@ -474,6 +474,18 @@ class GatewayHTTPHandler:if direction is not None and direction not in {"latest"}:return _http_error(400, "invalid direction")before = _query_first(query, "before")+ from nanobot.session.webui_turns import (+ websocket_turn_id,+ websocket_turn_transcript_persistence_failed,+ websocket_turn_wall_started_at,+ )++ chat_id = decoded_key.split(":", 1)[1]+ active_turn_started_at = websocket_turn_wall_started_at(chat_id)+ active_turn_id = websocket_turn_id(chat_id)+ active_turn_transcript_persistence_failed = (+ websocket_turn_transcript_persistence_failed(chat_id)+ )data = build_webui_thread_response(decoded_key,augment_user_media=self.media.augment_transcript_media,@@ -483,6 +495,11 @@ class GatewayHTTPHandler:workspace_path=scope.project_path,),session_messages=session_messages,+ active_turn_started_at=active_turn_started_at,+ active_turn_id=active_turn_id,+ active_turn_transcript_persistence_failed=(+ active_turn_transcript_persistence_failed+ ),limit=limit,direction=direction,before=before,diff --git a/tests/agent/test_loop_direct_websocket_status.py b/tests/agent/test_loop_direct_websocket_status.pyindex 1c18a25d5..4f0a908c0 100644--- a/tests/agent/test_loop_direct_websocket_status.py+++ b/tests/agent/test_loop_direct_websocket_status.py@@ -7,8 +7,11 @@ from nanobot.agent.loop import AgentLoopfrom nanobot.bus.events import OutboundMessagefrom nanobot.bus.outbound_events import GoalStatusEventfrom nanobot.bus.queue import MessageBus+from nanobot.channels.websocket.runtime import WebSocketChannelfrom nanobot.providers.base import GenerationSettings, LLMResponse-from nanobot.session.webui_turns import WebuiTurnCoordinator+from nanobot.session import webui_turns as wth+from nanobot.session.webui_turns import WebuiTurnCoordinator, WebuiTurnRoutePolicy+from nanobot.webui.metadata import WEBSOCKET_TURN_OWNER_METADATA_KEYdef _make_loop(tmp_path):@@ -32,6 +35,7 @@ def _make_loop(tmp_path):sessions=loop.sessions,schedule_background=lambda coro: loop._schedule_background(coro),).subscribe(loop.runtime_events)+ loop.turn_delivery_factory.route_policy = WebuiTurnRoutePolicy(loop.sessions)loop.tools.get_definitions = MagicMock(return_value=[])return loop@@ -39,29 +43,51 @@ def _make_loop(tmp_path):@pytest.mark.asyncioasync def test_process_direct_websocket_clears_run_status(tmp_path) -> None:loop = _make_loop(tmp_path)-- response = await loop.process_direct(- "deliver reminder",- session_key="cron:reminder-1",- channel="websocket",- chat_id="chat-1",+ gateway = MagicMock()+ channel = WebSocketChannel(+ {"enabled": True, "allowFrom": ["*"]},+ loop.bus,+ gateway=gateway,)- assert response is not None- assert response.content == "done"+ try:+ response = await loop.process_direct(+ "deliver reminder",+ session_key="cron:reminder-1",+ channel="websocket",+ chat_id="chat-1",+ )- events = []- while loop.bus.outbound_size:- events.append(await loop.bus.consume_outbound())-- statuses = [- event.event- for event in events- if isinstance(event.event, GoalStatusEvent)- ]- assert [status.status for status in statuses] == ["running", "idle"]- assert isinstance(statuses[0].started_at, float)- assert statuses[1].started_at is None+ assert response is not None+ assert response.content == "done"++ events = []+ while loop.bus.outbound_size:+ event = await loop.bus.consume_outbound()+ events.append(event)+ await channel.send(event)++ status_messages = [+ event+ for event in events+ if isinstance(event.event, GoalStatusEvent)+ ]+ statuses = [event.event for event in status_messages]+ assert [status.status for status in statuses] == ["running", "idle"]+ assert isinstance(statuses[0].started_at, float)+ assert statuses[1].started_at is None+ owners = {+ event.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]+ for event in status_messages+ }+ assert len(owners) == 1+ assert wth.websocket_turn_wall_started_at("chat-1") is None+ assert "chat-1" not in wth._WEBSOCKET_ACTIVE_TURNS+ finally:+ wth._WEBSOCKET_ACTIVE_TURNS.clear()+ wth._WEBSOCKET_TURN_WALL_STARTED_AT.clear()+ wth._WEBSOCKET_TURN_IDS.clear()+ wth._WEBSOCKET_TURN_OWNERS.clear()@pytest.mark.asynciodiff --git a/tests/agent/test_loop_progress.py b/tests/agent/test_loop_progress.pyindex 220ae646d..e67fbfbef 100644--- a/tests/agent/test_loop_progress.py+++ b/tests/agent/test_loop_progress.py@@ -28,7 +28,10 @@ from nanobot.utils.progress_events import (invoke_file_edit_progress,on_progress_accepts_file_edit_events,)-from nanobot.webui.metadata import WEBUI_TURN_METADATA_KEY+from nanobot.webui.metadata import (+ WEBSOCKET_TURN_OWNER_METADATA_KEY,+ WEBUI_TURN_METADATA_KEY,+)def _make_loop(tmp_path: Path) -> AgentLoop:@@ -903,6 +906,12 @@ class TestToolEventProgress:turn_id = turn_ids.pop()assert isinstance(turn_id, str)assert turn_id.startswith("subagent:")+ owners = {+ message.metadata.get(WEBSOCKET_TURN_OWNER_METADATA_KEY)+ for message in visible_events+ }+ assert len(owners) == 1+ assert isinstance(owners.pop(), str)assert all((message.channel, message.chat_id) == ("websocket", "chat-a")and message.metadata.get("webui") is True@@ -910,6 +919,7 @@ class TestToolEventProgress:and set(message.metadata) <= {"webui","_wants_stream",+ WEBSOCKET_TURN_OWNER_METADATA_KEY,WEBUI_TURN_METADATA_KEY,"latency_ms",}diff --git a/tests/agent/test_turn_delivery.py b/tests/agent/test_turn_delivery.pyindex 24988a20c..48a8970c8 100644--- a/tests/agent/test_turn_delivery.py+++ b/tests/agent/test_turn_delivery.py@@ -1,12 +1,147 @@from pathlib import Path+import pytest+from nanobot.agent.turn_delivery import TurnDeliveryFactoryfrom nanobot.bus.events import InboundMessagefrom nanobot.bus.queue import MessageBusfrom nanobot.bus.runtime_events import RuntimeEventBusfrom nanobot.session.manager import SessionManagerfrom nanobot.session.webui_turns import WebuiTurnRoutePolicy-from nanobot.webui.metadata import WEBUI_TURN_METADATA_KEY+from nanobot.webui.metadata import (+ WEBSOCKET_TURN_OWNER_METADATA_KEY,+ WEBUI_TURN_METADATA_KEY,+)+++def test_websocket_lifecycles_get_distinct_internal_owners(tmp_path: Path) -> None:+ factory = TurnDeliveryFactory(+ MessageBus(),+ RuntimeEventBus(),+ route_policy=WebuiTurnRoutePolicy(SessionManager(tmp_path / "sessions")),+ )+ first_msg = InboundMessage(+ channel="websocket",+ sender_id="user",+ chat_id="chat-a",+ content="first",+ metadata={WEBSOCKET_TURN_OWNER_METADATA_KEY: "attacker-reused-owner"},+ )+ second_msg = InboundMessage(+ channel="websocket",+ sender_id="user",+ chat_id="chat-a",+ content="second",+ metadata={WEBSOCKET_TURN_OWNER_METADATA_KEY: "attacker-reused-owner"},+ )++ first = factory.create(first_msg, first_msg.session_key)+ second = factory.create(second_msg, second_msg.session_key)+ first_owner = first.lifecycle_message.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]+ second_owner = second.lifecycle_message.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]++ assert first_owner == first.delivery_message.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]+ assert first_owner != second_owner+ assert first_owner != "attacker-reused-owner"+ assert second_owner != "attacker-reused-owner"+ assert WEBUI_TURN_METADATA_KEY not in first.lifecycle_message.metadata+ assert first_msg.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY] == first_owner+ assert second_msg.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY] == second_owner+++def test_websocket_lifecycle_reuses_registered_ingress_owner(tmp_path: Path) -> None:+ from nanobot.session import webui_turns as wth++ owner = wth.register_queued_websocket_turn_if_idle("chat-queued", "turn-queued")+ assert owner is not None+ msg = InboundMessage(+ channel="websocket",+ sender_id="user",+ chat_id="chat-queued",+ content="queued",+ metadata={+ WEBSOCKET_TURN_OWNER_METADATA_KEY: owner,+ WEBUI_TURN_METADATA_KEY: "turn-queued",+ },+ )+ factory = TurnDeliveryFactory(+ MessageBus(),+ RuntimeEventBus(),+ route_policy=WebuiTurnRoutePolicy(SessionManager(tmp_path / "sessions")),+ )++ try:+ delivery = factory.create(msg, msg.session_key)++ assert delivery.lifecycle_message.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY] == owner+ assert msg.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY] == owner+ finally:+ wth.clear_websocket_turn_if_current("chat-queued", owner)+++async def test_same_chat_different_sessions_restore_previous_active_projection(+ tmp_path: Path,+) -> None:+ from unittest.mock import AsyncMock, MagicMock++ from nanobot.session import webui_turns as wth++ factory = TurnDeliveryFactory(+ MessageBus(),+ RuntimeEventBus(),+ route_policy=WebuiTurnRoutePolicy(SessionManager(tmp_path / "sessions")),+ )+ first_msg = InboundMessage(+ channel="websocket",+ sender_id="user",+ chat_id="shared-chat",+ content="first",+ metadata={WEBUI_TURN_METADATA_KEY: "turn-first"},+ session_key_override="websocket:session-first",+ )+ second_msg = InboundMessage(+ channel="websocket",+ sender_id="user",+ chat_id="shared-chat",+ content="second",+ metadata={WEBUI_TURN_METADATA_KEY: "turn-second"},+ session_key_override="websocket:session-second",+ )+ first = factory.create(first_msg, first_msg.session_key)+ second = factory.create(second_msg, second_msg.session_key)+ first_owner = first.lifecycle_message.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]+ second_owner = second.lifecycle_message.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]+ bus = MagicMock()+ bus.publish_outbound = AsyncMock()++ try:+ await wth.publish_turn_run_status(+ bus,+ first.lifecycle_message,+ "running",+ started_at=100.0,+ )+ await wth.publish_turn_run_status(+ bus,+ second.lifecycle_message,+ "running",+ started_at=200.0,+ )++ assert wth.websocket_turn_wall_started_at("shared-chat") == 200.0+ assert wth.websocket_turn_id("shared-chat") == "turn-second"+ assert wth.clear_websocket_turn_if_current("shared-chat", second_owner) is True+ assert wth.websocket_turn_wall_started_at("shared-chat") == 100.0+ assert wth.websocket_turn_id("shared-chat") == "turn-first"+ assert wth._WEBSOCKET_TURN_OWNERS["shared-chat"] == first_owner+ assert wth.clear_websocket_turn_if_current("shared-chat", first_owner) is True+ assert wth.websocket_turn_wall_started_at("shared-chat") is None+ finally:+ wth._WEBSOCKET_ACTIVE_TURNS.pop("shared-chat", None)+ wth._WEBSOCKET_TURN_WALL_STARTED_AT.pop("shared-chat", None)+ wth._WEBSOCKET_TURN_IDS.pop("shared-chat", None)+ wth._WEBSOCKET_TURN_OWNERS.pop("shared-chat", None)def test_late_subagent_route_requires_webui_owned_session(tmp_path: Path) -> None:@@ -45,6 +180,7 @@ def test_late_subagent_route_requires_webui_owned_session(tmp_path: Path) -> Nonassert set(first_visible_route.metadata) == {"webui","_wants_stream",+ WEBSOCKET_TURN_OWNER_METADATA_KEY,WEBUI_TURN_METADATA_KEY,}assert first_visible_route.metadata["webui"] is True@@ -54,6 +190,10 @@ def test_late_subagent_route_requires_webui_owned_session(tmp_path: Path) -> Nonassert first_turn_id.startswith("subagent:")assert second_turn_id.startswith("subagent:")assert first_turn_id != second_turn_id+ assert (+ first_visible_route.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]+ != second_visible_route.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]+ )assert msg.metadata == {"injected_event": "subagent_result","subagent_task_id": "sub-1",diff --git a/tests/command/test_router_dispatchable.py b/tests/command/test_router_dispatchable.pyindex e03ca0083..6c3fbadf5 100644--- a/tests/command/test_router_dispatchable.py+++ b/tests/command/test_router_dispatchable.py@@ -6,7 +6,10 @@ from unittest.mock import AsyncMock, MagicMockimport pytest-from nanobot.command.builtin import register_builtin_commands+from nanobot.command.builtin import (+ builtin_command_starts_agent_turn,+ register_builtin_commands,+)from nanobot.command.router import CommandContext, CommandRouter@@ -64,6 +67,20 @@ class TestIsDispatchableCommand:assert not router.is_dispatchable_command("/foo bar")+ ("content", "expected"),+ [+ ("/status", False),+ ("/history 5", False),+ ("/goal", False),+ ("/goal migrate the database", True),+ ("regular prompt", True),+ ],+)+def test_builtin_command_agent_turn_lifecycle(content: str, expected: bool) -> None:+ assert builtin_command_starts_agent_turn(content) is expected++class TestMidTurnCommandDispatchedDirectly:"""Verify that commands matching is_dispatchable_command() are dispatchedcorrectly when session=None (the mid-turn path)."""diff --git a/tests/utils/test_webui_transcript.py b/tests/utils/test_webui_transcript.pyindex 921982f6b..f0d7de726 100644--- a/tests/utils/test_webui_transcript.py+++ b/tests/utils/test_webui_transcript.py@@ -389,6 +389,7 @@ def test_thread_response_does_not_mark_completed_message_tool_tail_pending(assert out is not Noneassert out["has_pending_tool_calls"] is False+ assert out["completed_turn_ids"] == [turn_id]assert out["messages"][-1]["kind"] == "trace"assert out["messages"][-2]["content"] == "Cron test"@@ -410,6 +411,144 @@ def test_thread_response_marks_unfinished_tool_tail_pending(tmp_path, monkeypatcassert out is not Noneassert out["has_pending_tool_calls"] is True+ assert out["completed_turn_ids"] == []+++def test_thread_response_reports_active_registry_without_transcript(+ tmp_path,+ monkeypatch,+) -> None:+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)++ out = build_webui_thread_response(+ "websocket:active-without-transcript",+ active_turn_started_at=1_700_000_000.0,+ active_turn_id="turn-active",+ )++ assert out is not None+ assert out["messages"] == []+ assert out["completed_turn_ids"] == []+ assert out["has_pending_tool_calls"] is True+ assert out["active_turn_id"] == "turn-active"+++def test_thread_response_reports_explicit_completion_without_assistant_row(+ tmp_path,+ monkeypatch,+) -> None:+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ key = "websocket:empty-answer"+ turn_id = "turn-empty-answer"+ append_transcript_object(+ key,+ {"event": "user", "chat_id": "empty-answer", "text": "stop", "turn_id": turn_id},+ )+ append_transcript_object(+ key,+ {"event": "turn_end", "chat_id": "empty-answer", "turn_id": turn_id},+ )++ out = build_webui_thread_response(key)++ assert out is not None+ assert out["messages"][-1]["role"] == "user"+ assert out["has_pending_tool_calls"] is False+ assert out["completed_turn_ids"] == [turn_id]+++def test_incomplete_turn_with_ambiguous_session_match_stays_pending(+ tmp_path,+ monkeypatch,+) -> None:+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ key = "websocket:ambiguous-incomplete"+ turn_id = "turn-ambiguous"+ append_transcript_object(+ key,+ {+ "event": "user",+ "chat_id": "ambiguous-incomplete",+ "text": "repeat",+ "turn_id": turn_id,+ },+ )+ append_transcript_object(+ key,+ {+ "event": "turn_end",+ "chat_id": "ambiguous-incomplete",+ "turn_id": turn_id,+ "transcript_incomplete": True,+ },+ )++ out = build_webui_thread_response(+ key,+ session_messages=[+ {"role": "user", "content": "repeat"},+ {"role": "assistant", "content": "first answer"},+ {"role": "user", "content": "repeat"},+ {"role": "assistant", "content": "second answer"},+ ],+ )++ assert out is not None+ assert [(message["role"], message["content"]) for message in out["messages"]] == [+ ("user", "repeat"),+ ]+ assert out["completed_turn_ids"] == []+ assert out["has_pending_tool_calls"] is True+++def test_later_completion_does_not_hide_older_incomplete_turn(+ tmp_path,+ monkeypatch,+) -> None:+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ key = "websocket:older-incomplete"+ for event in (+ {"event": "user", "text": "first", "turn_id": "turn-first"},+ {+ "event": "turn_end",+ "turn_id": "turn-first",+ "transcript_incomplete": True,+ },+ {"event": "user", "text": "second", "turn_id": "turn-second"},+ {"event": "message", "text": "second answer", "turn_id": "turn-second"},+ {"event": "turn_end", "turn_id": "turn-second"},+ ):+ append_transcript_object(+ key,+ {"chat_id": "older-incomplete", **event},+ )++ out = build_webui_thread_response(key)++ assert out is not None+ assert out["completed_turn_ids"] == ["turn-second"]+ assert out["has_pending_tool_calls"] is True+++def test_active_registry_does_not_hide_a_newer_queued_turn(tmp_path, monkeypatch) -> None:+ monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)+ key = "websocket:queued-tail"+ for event in (+ {"event": "user", "text": "first", "turn_id": "turn-old"},+ {"event": "message", "text": "done", "turn_id": "turn-old"},+ {"event": "turn_end", "turn_id": "turn-old"},+ {"event": "user", "text": "queued next", "turn_id": "turn-new"},+ ):+ append_transcript_object(key, {"chat_id": "queued-tail", **event})++ out = build_webui_thread_response(+ key,+ active_turn_started_at=1_700_000_000.0,+ active_turn_id="turn-old",+ )++ assert out is not None+ assert out["has_pending_tool_calls"] is Truedef test_replay_preserves_turn_metadata(tmp_path, monkeypatch) -> None:diff --git a/tests/utils/test_webui_turn_helpers.py b/tests/utils/test_webui_turn_helpers.pyindex c019de30c..7a113eae9 100644--- a/tests/utils/test_webui_turn_helpers.py+++ b/tests/utils/test_webui_turn_helpers.py@@ -8,26 +8,40 @@ from nanobot.agent.tools.context import RequestContext, request_contextfrom nanobot.bus.events import InboundMessagefrom nanobot.bus.outbound_events import GoalStatusEvent, TurnModelUpdatedEventfrom nanobot.session import webui_turns as wth+from nanobot.webui.metadata import WEBSOCKET_TURN_OWNER_METADATA_KEY@pytest.fixture(autouse=True)def _clear_turn_wall_clock() -> None:+ wth._WEBSOCKET_ACTIVE_TURNS.clear()wth._WEBSOCKET_TURN_WALL_STARTED_AT.clear()+ wth._WEBSOCKET_TURN_IDS.clear()+ wth._WEBSOCKET_TURN_OWNERS.clear()yield+ wth._WEBSOCKET_ACTIVE_TURNS.clear()wth._WEBSOCKET_TURN_WALL_STARTED_AT.clear()+ wth._WEBSOCKET_TURN_IDS.clear()+ wth._WEBSOCKET_TURN_OWNERS.clear()@pytest.mark.asyncioasync def test_publish_turn_run_status_running_records_wall_clock() -> None:bus = MagicMock()bus.publish_outbound = AsyncMock()- msg = InboundMessage(channel="websocket", sender_id="u", chat_id="chat-a", content="hi")+ msg = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id="chat-a",+ content="hi",+ metadata={"webui_turn_id": "turn-a"},+ )await wth.publish_turn_run_status(bus, msg, "running")assert "chat-a" in wth._WEBSOCKET_TURN_WALL_STARTED_ATt0 = wth.websocket_turn_wall_started_at("chat-a")assert isinstance(t0, float)+ assert wth.websocket_turn_id("chat-a") == "turn-a"call = bus.publish_outbound.await_args[0][0]assert call.chat_id == "chat-a"assert isinstance(call.event, GoalStatusEvent)@@ -49,16 +63,67 @@ async def test_publish_turn_run_status_reuses_explicit_wall_clock() -> None:@pytest.mark.asyncio-async def test_publish_turn_run_status_idle_clears_wall_clock() -> None:+async def test_publish_turn_run_status_idle_retains_registry_until_delivery() -> None:bus = MagicMock()bus.publish_outbound = AsyncMock()- msg = InboundMessage(channel="websocket", sender_id="u", chat_id="chat-b", content="hi")+ msg = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id="chat-b",+ content="hi",+ metadata={"webui_turn_id": "turn-b"},+ )await wth.publish_turn_run_status(bus, msg, "running")assert wth.websocket_turn_wall_started_at("chat-b") is not None+ assert wth.websocket_turn_id("chat-b") == "turn-b"await wth.publish_turn_run_status(bus, msg, "idle")+ assert wth.websocket_turn_wall_started_at("chat-b") is not None+ assert wth.websocket_turn_id("chat-b") == "turn-b"+++def test_clear_websocket_turn_only_clears_matching_owner() -> None:+ wth._WEBSOCKET_TURN_WALL_STARTED_AT["chat-b"] = 1234.5+ wth._WEBSOCKET_TURN_IDS["chat-b"] = "turn-new"+ wth._WEBSOCKET_TURN_OWNERS["chat-b"] = "owner-new"++ assert wth.clear_websocket_turn_if_current("chat-b", "owner-old") is False+ assert wth.websocket_turn_wall_started_at("chat-b") == 1234.5+ assert wth.websocket_turn_id("chat-b") == "turn-new"++ assert wth.clear_websocket_turn_if_current("chat-b", "owner-new") is Trueassert wth.websocket_turn_wall_started_at("chat-b") is None+ assert wth.websocket_turn_id("chat-b") is None+++async def test_ownerless_turns_receive_distinct_internal_owners() -> None:+ bus = MagicMock()+ bus.publish_outbound = AsyncMock()+ first = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id="chat-ownerless",+ content="first",+ )+ second = InboundMessage(+ channel="websocket",+ sender_id="u",+ chat_id="chat-ownerless",+ content="second",+ )++ await wth.publish_turn_run_status(bus, first, "running")+ first_owner = first.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]+ await wth.publish_turn_run_status(bus, second, "running")+ second_owner = second.metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY]++ assert first_owner != second_owner+ assert wth.clear_websocket_turn_if_current("chat-ownerless", first_owner) is True+ assert wth._WEBSOCKET_TURN_OWNERS["chat-ownerless"] == second_owner+ assert wth.websocket_turn_wall_started_at("chat-ownerless") is not None+ assert wth.clear_websocket_turn_if_current("chat-ownerless", second_owner) is True@pytest.mark.asyncio@@ -70,6 +135,7 @@ async def test_publish_turn_run_status_non_websocket_noop_registry() -> None:await wth.publish_turn_run_status(bus, msg, "running")assert wth._WEBSOCKET_TURN_WALL_STARTED_AT == {}+ assert wth._WEBSOCKET_TURN_IDS == {}@pytest.mark.asynciodiff --git a/webui/src/App.tsx b/webui/src/App.tsxindex 2e9e74e95..1f5ef9782 100644--- a/webui/src/App.tsx+++ b/webui/src/App.tsx@@ -738,6 +738,7 @@ export default function App() {} else {client.updateUrl(url);}+ client.updateMaxFrameBytes(boot.limits?.transport.max_frame_bytes);setState((current) =>current.status === "ready" && current.client === client? {@@ -769,6 +770,7 @@ export default function App() {const runtimeHost = createRuntimeHost(runtimeSurface, boot.runtime_capabilities);const client = new NanobotClient({url,+ maxFrameBytes: boot.limits?.transport.max_frame_bytes,socketFactory: runtimeHost.socketFactory,onReauth: async () => {try {@@ -1206,6 +1208,7 @@ function Shell({useEffect(() => {return client.onError((error) => {if (error.kind !== "workspace_scope_rejected") return;+ if (error.chatId && error.chatId !== activeChatIdRef.current) return;setWorkspaceError(t("errors.workspaceScopeRejected.body"));void refreshWorkspaces();});diff --git a/webui/src/components/thread/StreamErrorNotice.tsx b/webui/src/components/thread/StreamErrorNotice.tsxindex c4d07b7fa..4875b7353 100644--- a/webui/src/components/thread/StreamErrorNotice.tsx+++ b/webui/src/components/thread/StreamErrorNotice.tsx@@ -67,6 +67,11 @@ function resolveCopy(title: t("errors.workspaceScopeRejected.title"),body: t("errors.workspaceScopeRejected.body"),};+ case "turn_rejected":+ return {+ title: t("errors.turnRejected.title"),+ body: t("errors.turnRejected.body"),+ };default: {// Exhaustiveness guard: if a new StreamError kind is added, TS will// complain here until we add a corresponding i18n branch.diff --git a/webui/src/components/thread/ThreadShell.tsx b/webui/src/components/thread/ThreadShell.tsxindex a889a88bd..9219ef6d3 100644--- a/webui/src/components/thread/ThreadShell.tsx+++ b/webui/src/components/thread/ThreadShell.tsx@@ -31,6 +31,7 @@ import {installedMcpPresetsFromPayload,isMcpPresetsPayload,} from "@/lib/mcp-preset-events";+import type { CanonicalRunSnapshot } from "@/lib/nanobot-client";import { inferProviderFromModelName, providerDisplayLabel } from "@/lib/provider-brand";import type {ChatSummary,@@ -44,13 +45,65 @@ import type {import { projectWebuiThreadMessages } from "@/lib/thread-display-compat";import { useClient } from "@/providers/ClientProvider";-type MessageShape = Pick<UIMessage, "role" | "kind" | "content">;+type MessageShape = Pick<UIMessage, "role" | "kind" | "content" | "isStreaming" | "turnId">;++interface PendingCanonicalHydrate {+ historyLineage: number;+ historyVersion: number;+ runGeneration: number;+ uiBaseline: MessageShape[];+ uiLineage: number | null;+ uiRevision: number;+}++interface PendingHistoryLineageCommit {+ lineage: number;+ messages: UIMessage[];+}++interface PendingCanonicalCommit {+ canonicalSnapshot: CanonicalRunSnapshot;+ completedTurnIds: string[];+ expectedUiRevision: number;+ historyLineage: number;+ historyVersion: number;+ hydrate: PendingCanonicalHydrate;+ messages: UIMessage[];+ previousMessages: UIMessage[];+}function sameMessageShape(a: MessageShape, b: MessageShape): boolean {return (a.role === b.role&& (a.kind ?? "") === (b.kind ?? "")&& a.content === b.content+ && (!a.turnId || !b.turnId || a.turnId === b.turnId)+ );+}++function snapshotPreservesMessage(+ current: MessageShape,+ candidate: MessageShape,+ allowCompletedTurnReplacement: boolean,+): boolean {+ if (sameMessageShape(current, candidate)) return true;+ if (+ allowCompletedTurnReplacement+ && current.role === "assistant"+ && candidate.role === current.role+ && (candidate.kind ?? "") === (current.kind ?? "")+ && !!current.turnId+ && candidate.turnId === current.turnId+ ) {+ return true;+ }+ return (+ current.role === "assistant"+ && current.isStreaming === true+ && candidate.role === current.role+ && (candidate.kind ?? "") === (current.kind ?? "")+ && (!current.turnId || !candidate.turnId || candidate.turnId === current.turnId)+ && candidate.content.startsWith(current.content));}@@ -64,28 +117,44 @@ function durableMessageShape(message: UIMessage): MessageShape | null {role: message.role,kind: message.kind,content: message.content,+ isStreaming: message.isStreaming,+ turnId: message.turnId,};}-function preservesDurableMessages(current: UIMessage[], snapshot: UIMessage[]): boolean {- // Canonical history refreshes can race with live websocket messages after fork/send.- // Never accept a refreshed snapshot that drops a user/assistant message already shown.- const expected = current- .map(durableMessageShape)- .filter((message): message is MessageShape => message !== null);- if (expected.length === 0) return true;- const candidates = snapshot+function durableMessageShapes(messages: UIMessage[]): MessageShape[] {+ return messages.map(durableMessageShape).filter((message): message is MessageShape => message !== null);+}+function preservesMessageShapes(+ expected: MessageShape[],+ candidates: MessageShape[],+ allowCompletedTurnReplacement: boolean,+): boolean {let cursor = 0;+ let previousCandidate: MessageShape | null = null;for (const message of expected) {+ if (+ allowCompletedTurnReplacement+ && previousCandidate?.role === "assistant"+ && message.role === "assistant"+ && !!message.turnId+ && message.turnId === previousCandidate.turnId+ ) {+ // A delayed websocket delta can briefly create a second bubble after an+ // HTTP completion snapshot. The completed replay is authoritative for+ // that turn, so both local fragments may map to its single assistant row.+ continue;+ }let found = false;while (cursor < candidates.length) {const candidate = candidates[cursor];cursor += 1;- if (sameMessageShape(message, candidate)) {+ if (snapshotPreservesMessage(message, candidate, allowCompletedTurnReplacement)) {found = true;+ previousCandidate = candidate;break;}}@@ -94,11 +163,55 @@ function preservesDurableMessages(current: UIMessage[], snapshot: UIMessage[]):return true;}-function isStaleThreadSnapshot(current: UIMessage[], snapshot: UIMessage[]): boolean {+function preservesDurableMessages(+ current: UIMessage[],+ snapshot: UIMessage[],+ allowCompletedTurnReplacement = false,+): boolean {+ // Canonical history refreshes can race with live websocket messages after fork/send.+ // Never accept a refreshed snapshot that drops a user/assistant message already shown.+ const expected = durableMessageShapes(current);+ if (expected.length === 0) return true;+ return preservesMessageShapes(+ expected,+ durableMessageShapes(snapshot),+ allowCompletedTurnReplacement,+ );+}++function resetDropsPostRequestDurableTail(+ baseline: MessageShape[],+ current: UIMessage[],+ snapshot: UIMessage[],+): boolean {+ const currentDurable = durableMessageShapes(current);+ let stablePrefixLength = 0;+ while (+ stablePrefixLength < baseline.length+ && stablePrefixLength < currentDurable.length+ && sameMessageShape(baseline[stablePrefixLength], currentDurable[stablePrefixLength])+ ) {+ stablePrefixLength += 1;+ }+ const postRequestTail = currentDurable.slice(stablePrefixLength);+ if (postRequestTail.length === 0) return false;+ return !preservesMessageShapes(+ postRequestTail,+ durableMessageShapes(snapshot),+ true,+ );+}++function isStaleThreadSnapshot(+ current: UIMessage[],+ snapshot: UIMessage[],+ allowCompletedTurnReplacement = false,+): boolean {if (current.length === 0) return false;if (snapshot.length === 0) return true;- if (!preservesDurableMessages(current, snapshot)) return true;+ if (!preservesDurableMessages(current, snapshot, allowCompletedTurnReplacement)) return true;if (snapshot.length >= current.length) return false;+ if (allowCompletedTurnReplacement) return false;return snapshot.every((message, index) => sameMessageShape(current[index], message));}@@ -114,6 +227,30 @@ function latestActiveTurnId(messages: UIMessage[]): string | null {return null;}+function completedAssistantTurnIds(messages: UIMessage[]): string[] {+ return Array.from(new Set(+ messages+ .filter((message) => message.role === "assistant" && !!message.turnId)+ .map((message) => message.turnId as string),+ ));+}++function canonicalRunSnapshot(+ messages: UIMessage[],+ hasPendingToolCalls: boolean,+ activeTurnId: string | null,+): CanonicalRunSnapshot {+ return {+ observedTurnIds: Array.from(new Set(+ messages+ .filter((message) => message.role === "user" && !!message.turnId)+ .map((message) => message.turnId as string),+ )),+ hasPendingToolCalls,+ activeTurnId,+ };+}+const FILE_PREVIEW_DEFAULT_WIDTH = 544;const FILE_PREVIEW_MIN_WIDTH = 360;const FILE_PREVIEW_MAX_WIDTH = 860;@@ -432,6 +569,10 @@ export function ThreadShell({hasMoreBefore,userMessageOffset,hasPendingToolCalls,+ completedTurnIds,+ continuity: historyContinuity,+ lineage: historyLineage,+ activeTurnId: historyActiveTurnId,refresh: refreshHistory,version: historyVersion,forkBoundaryMessageCount,@@ -474,9 +615,16 @@ export function ThreadShell({const prevChatIdForCacheRef = useRef<string | null>(null);/** Skip one message-cache write right after chatId changes (messages may not match yet). */const skipLayoutCacheRef = useRef(false);- const appliedHistoryVersionRef = useRef<Map<string, number>>(new Map());- const pendingCanonicalHydrateRef = useRef<Set<string>>(new Set());+ const pendingCanonicalHydrateRef = useRef<Map<string, PendingCanonicalHydrate>>(new Map());+ const pendingCanonicalCommitRef = useRef<Map<string, PendingCanonicalCommit>>(new Map());+ const pendingHistoryLineageCommitRef = useRef<Map<string, PendingHistoryLineageCommit>>(+ new Map(),+ );+ const completedCanonicalHydrateVersionRef = useRef<Map<string, number>>(new Map());+ const committedHistoryLineageRef = useRef<Map<string, number>>(new Map());const sessionKeyByChatIdRef = useRef<Map<string, string>>(new Map());+ const currentUiMessagesRef = useRef<UIMessage[] | null>(null);+ const uiRevisionRef = useRef(0);const initial = useMemo(() => {if (!chatId) return historical;@@ -497,11 +645,25 @@ export function ThreadShell({send,transcribeAudio,stop,+ reconcileTurnComplete,setMessages,streamError,dismissStreamError,} = useNanobotStream(chatId, initial, hasPendingToolCalls, handleTurnEnd);+ useLayoutEffect(() => {+ if (currentUiMessagesRef.current === messages) return;+ currentUiMessagesRef.current = messages;+ uiRevisionRef.current += 1;+ if (!chatId) return;+ const lineageCommit = pendingHistoryLineageCommitRef.current.get(chatId);+ if (!lineageCommit) return;+ pendingHistoryLineageCommitRef.current.delete(chatId);+ if (lineageCommit.messages === messages) {+ committedHistoryLineageRef.current.set(chatId, lineageCommit.lineage);+ }+ }, [chatId, messages]);+useEffect(() => {if (chatId && historyKey) sessionKeyByChatIdRef.current.set(chatId, historyKey);}, [chatId, historyKey]);@@ -685,47 +847,196 @@ export function ThreadShell({useEffect(() => {if (!chatId || loading) return;const cached = messageCacheRef.current.get(chatId);- const appliedVersion = appliedHistoryVersionRef.current.get(chatId) ?? 0;- const hasPendingCanonicalHydrate = pendingCanonicalHydrateRef.current.has(chatId);- const hasNewCanonicalHistory = hasPendingCanonicalHydrate && historyVersion > appliedVersion;+ const pendingCanonicalHydrate = pendingCanonicalHydrateRef.current.get(chatId);+ const hasNewCanonicalHistory = (+ pendingCanonicalHydrate !== undefined+ && historyVersion > pendingCanonicalHydrate.historyVersion+ );// When the user switches away and back, keep the local in-memory thread// state (including not-yet-persisted messages) instead of replacing it with// whatever the history endpoint currently knows about. Once a fresh// canonical replay arrives (e.g. after ``session_updated`` refresh), prefer it// so rendering converges to the same shape as a manual refresh.- setMessages((prev) => {- const normalizedHistory = projectWebuiThreadMessages(historical);- const keepLiveMessages = (messagesToKeep: UIMessage[]) => {- const projected = projectWebuiThreadMessages(messagesToKeep);- messageCacheRef.current.set(chatId, projected);- return projected;- };- if (hasNewCanonicalHistory && historical.length > 0) {- if (isStaleThreadSnapshot(prev, normalizedHistory)) return keepLiveMessages(prev);- pendingCanonicalHydrateRef.current.delete(chatId);- appliedHistoryVersionRef.current.set(chatId, historyVersion);- messageCacheRef.current.set(chatId, normalizedHistory);- return normalizedHistory;+ const normalizedHistory = projectWebuiThreadMessages(historical);+ const keepLiveMessages = (current: UIMessage[]) => projectWebuiThreadMessages(current);+ if (hasNewCanonicalHistory && pendingCanonicalHydrate) {+ // Transcript replay strips streaming metadata and uses persisted ids.+ // Never adopt it while the turn is active: even if no assistant delta+ // arrived locally yet, the next resumed delta must create/continue the+ // live cursor rather than append to an immutable replay row.+ if (hasPendingToolCalls) {+ setMessages((current) => keepLiveMessages(current));+ return;+ }+ const authoritativeReset = (+ pendingCanonicalHydrate.uiLineage !== null+ && historyLineage !== pendingCanonicalHydrate.uiLineage+ && (+ historyContinuity === "reset"+ || (+ historyContinuity === "overlap"+ && historyLineage === pendingCanonicalHydrate.historyLineage+ )+ )+ );+ const responseUiRevision = uiRevisionRef.current;+ const resetDropsRenderedTail = (+ authoritativeReset+ && responseUiRevision !== pendingCanonicalHydrate.uiRevision+ && resetDropsPostRequestDurableTail(+ pendingCanonicalHydrate.uiBaseline,+ messages,+ normalizedHistory,+ )+ );+ if (+ authoritativeReset+ ? resetDropsRenderedTail+ : isStaleThreadSnapshot(messages, normalizedHistory, true)+ ) {+ setMessages((current) => keepLiveMessages(current));+ return;+ }+ const canonicalCompletedTurnIds = Array.from(new Set([+ ...completedTurnIds,+ ...completedAssistantTurnIds(normalizedHistory),+ ]));+ const canonicalSnapshot = canonicalRunSnapshot(+ normalizedHistory,+ hasPendingToolCalls,+ historyActiveTurnId,+ );+ if (!client.canReconcileCanonicalCompletion(+ chatId,+ pendingCanonicalHydrate.runGeneration,+ canonicalCompletedTurnIds,+ canonicalSnapshot,+ )) {+ setMessages((current) => keepLiveMessages(current));+ return;}+ pendingCanonicalCommitRef.current.set(chatId, {+ canonicalSnapshot,+ completedTurnIds: canonicalCompletedTurnIds,+ expectedUiRevision: responseUiRevision + 1,+ historyLineage,+ historyVersion,+ hydrate: pendingCanonicalHydrate,+ messages: normalizedHistory,+ previousMessages: messages,+ });+ setMessages((current) => {+ if (current !== messages) return current;+ if (+ authoritativeReset+ ? resetDropsRenderedTail+ : isStaleThreadSnapshot(current, normalizedHistory, true)+ ) {+ return keepLiveMessages(current);+ }+ return normalizedHistory;+ });+ return;+ }+ const adoptsNormalizedHistory = cached && cached.length > 0+ ? (+ normalizedHistory.length > cached.length+ && !isStaleThreadSnapshot(messages, normalizedHistory)+ )+ : !isStaleThreadSnapshot(messages, normalizedHistory);+ if (adoptsNormalizedHistory) {+ pendingHistoryLineageCommitRef.current.set(chatId, {+ lineage: historyLineage,+ messages: normalizedHistory,+ });+ }+ setMessages((current) => {if (cached && cached.length > 0) {if (normalizedHistory.length > cached.length- && !isStaleThreadSnapshot(prev, normalizedHistory)+ && !isStaleThreadSnapshot(current, normalizedHistory)) {- messageCacheRef.current.set(chatId, normalizedHistory);- appliedHistoryVersionRef.current.set(chatId, historyVersion);return normalizedHistory;}- if (isStaleThreadSnapshot(prev, cached)) return keepLiveMessages(prev);- return cached;+ return isStaleThreadSnapshot(current, cached) ? keepLiveMessages(current) : cached;}- if (isStaleThreadSnapshot(prev, normalizedHistory)) return keepLiveMessages(prev);- appliedHistoryVersionRef.current.set(chatId, historyVersion);- if (normalizedHistory.length > 0) messageCacheRef.current.set(chatId, normalizedHistory);- return normalizedHistory;+ return isStaleThreadSnapshot(current, normalizedHistory)+ ? keepLiveMessages(current)+ : normalizedHistory;+ });+ }, [+ loading,+ chatId,+ client,+ completedTurnIds,+ historical,+ historyVersion,+ historyContinuity,+ historyLineage,+ historyActiveTurnId,+ hasPendingToolCalls,+ ]);++ useLayoutEffect(() => {+ if (!chatId) return;+ const commit = pendingCanonicalCommitRef.current.get(chatId);+ if (!commit) return;+ if (+ commit.historyVersion !== historyVersion+ || commit.historyLineage !== historyLineage+ || commit.messages !== messages+ ) {+ pendingCanonicalCommitRef.current.delete(chatId);+ return;+ }+ if (pendingCanonicalHydrateRef.current.get(chatId) !== commit.hydrate) {+ pendingCanonicalCommitRef.current.delete(chatId);+ return;+ }+ if (uiRevisionRef.current !== commit.expectedUiRevision) {+ pendingCanonicalCommitRef.current.delete(chatId);+ const fallback = messageCacheRef.current.get(chatId) ?? commit.previousMessages;+ messageCacheRef.current.set(chatId, fallback);+ setMessages((current) => current === commit.messages ? fallback : current);+ return;+ }+ if (!client.reconcileCanonicalCompletion(+ chatId,+ commit.hydrate.runGeneration,+ commit.completedTurnIds,+ commit.canonicalSnapshot,+ )) {+ pendingCanonicalCommitRef.current.delete(chatId);+ const fallback = messageCacheRef.current.get(chatId) ?? commit.previousMessages;+ messageCacheRef.current.set(chatId, fallback);+ setMessages((current) => current === commit.messages ? fallback : current);+ return;+ }+ pendingCanonicalHydrateRef.current.delete(chatId);+ pendingCanonicalCommitRef.current.delete(chatId);+ committedHistoryLineageRef.current.set(chatId, historyLineage);+ completedCanonicalHydrateVersionRef.current.set(chatId, historyVersion);+ }, [chatId, client, historyLineage, historyVersion, messages, setMessages]);++ useEffect(() => {+ if (!chatId || hasPendingToolCalls) return;+ if (completedCanonicalHydrateVersionRef.current.get(chatId) !== historyVersion) return;+ completedCanonicalHydrateVersionRef.current.delete(chatId);+ reconcileTurnComplete();+ }, [chatId, hasPendingToolCalls, historyVersion, messages, reconcileTurnComplete]);++ const refreshCanonicalHistory = useCallback(() => {+ if (!chatId) return;+ pendingCanonicalHydrateRef.current.set(chatId, {+ historyLineage,+ historyVersion,+ runGeneration: client.getRunGeneration(chatId),+ uiBaseline: durableMessageShapes(currentUiMessagesRef.current ?? []),+ uiLineage: committedHistoryLineageRef.current.get(chatId) ?? null,+ uiRevision: uiRevisionRef.current,});- // eslint-disable-next-line react-hooks/exhaustive-deps- }, [loading, chatId, historical, historyVersion]);+ refreshHistory();+ }, [chatId, client, historyLineage, historyVersion, refreshHistory]);useEffect(() => {if (!chatId) return;@@ -735,10 +1046,30 @@ export function ThreadShell({// A turn-end thread refresh can arrive while the viewport is easing the// final layout change. User-driven scrolling already disables following,// so keep an active programmatic follow alive across canonical hydration.- pendingCanonicalHydrateRef.current.add(chatId);- refreshHistory();+ refreshCanonicalHistory();+ });+ }, [chatId, client, refreshCanonicalHistory]);++ useEffect(() => {+ const refreshOnReturn = () => {+ if (document.visibilityState !== "visible") return;+ refreshCanonicalHistory();+ };+ document.addEventListener("visibilitychange", refreshOnReturn);+ return () => document.removeEventListener("visibilitychange", refreshOnReturn);+ }, [refreshCanonicalHistory]);++ useEffect(() => {+ let refreshOnNextOpen = client.status !== "open";+ return client.onStatus((status) => {+ if (status !== "open") {+ refreshOnNextOpen = true;+ return;+ }+ if (refreshOnNextOpen) refreshCanonicalHistory();+ refreshOnNextOpen = false;});- }, [chatId, client, refreshHistory]);+ }, [client, refreshCanonicalHistory]);useEffect(() => {if (chatId) return;@@ -944,8 +1275,8 @@ export function ThreadShell({const forkedChatId = await onForkChat(chatId, beforeUserIndex);if (!forkedChatId) return;messageCacheRef.current.delete(forkedChatId);- appliedHistoryVersionRef.current.delete(forkedChatId);- pendingCanonicalHydrateRef.current.add(forkedChatId);+ pendingCanonicalHydrateRef.current.delete(forkedChatId);+ completedCanonicalHydrateVersionRef.current.delete(forkedChatId);},[chatId, onForkChat],);diff --git a/webui/src/hooks/useNanobotStream.ts b/webui/src/hooks/useNanobotStream.tsindex 1f18e2007..e0bcde04a 100644--- a/webui/src/hooks/useNanobotStream.ts+++ b/webui/src/hooks/useNanobotStream.ts@@ -540,6 +540,8 @@ export function useNanobotStream() => SubmittedTurn | null;transcribeAudio: (dataUrl: string, options?: { durationMs?: number }) => Promise<string>;stop: () => void;+ /** Mark an accepted canonical snapshot as the definitive end of the active turn. */+ reconcileTurnComplete: () => void;setMessages: React.Dispatch<React.SetStateAction<UIMessage[]>>;/** Latest transport-level fault raised since the last ``dismissStreamError``.* ``null`` when there is nothing to show. */@@ -581,10 +583,6 @@ export function useNanobotStream(* backend changes. */const streamEndTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);- useEffect(() => {- return client.onError((err) => setStreamError(err));- }, [client]);-const dismissStreamError = useCallback(() => setStreamError(null), []);const clearPendingStreamWork = useCallback(() => {@@ -654,6 +652,66 @@ export function useNanobotStream(return !!closedStreamId;}, []);+ const applyStreamError = useCallback((err: StreamError) => {+ // One multiplexed client serves every thread. A correlated send fault+ // belongs only to its target chat. An uncorrelated transport close can+ // still be shown in the mounted thread, but cannot roll back any turn.+ if (!chatId || (err.chatId && err.chatId !== chatId)) return;+ setStreamError(err);+ if (!err.turnId) return;++ const rejectedTurnId = err.turnId;+ pendingStreamEventsRef.current = pendingStreamEventsRef.current.filter(+ (event) => event.turn.turnId !== rejectedTurnId,+ );+ sideChannelTurnIdsRef.current.delete(rejectedTurnId);+ cancelStreamEndTimer();+ setMessages((prev) => {+ const rejectedRows = prev.filter((message) => message.turnId === rejectedTurnId);+ if (rejectedRows.length === 0) return prev;+ const rejectedIds = new Set(rejectedRows.map((message) => message.id));+ const rejectedSegments = new Set(+ rejectedRows+ .map((message) => message.activitySegmentId)+ .filter((segmentId): segmentId is string => typeof segmentId === "string"),+ );+ if (+ activeAssistantRef.current+ && rejectedIds.has(activeAssistantRef.current.id)+ ) {+ activeAssistantRef.current = null;+ }+ if (buffer.current && rejectedIds.has(buffer.current.messageId)) {+ buffer.current = null;+ }+ for (const id of rejectedIds) closedAssistantStreamIdsRef.current.delete(id);+ if (+ activitySegmentRef.current+ && rejectedSegments.has(activitySegmentRef.current)+ ) {+ activitySegmentRef.current = null;+ }+ if (+ fileEditSegmentRef.current+ && rejectedSegments.has(fileEditSegmentRef.current)+ ) {+ fileEditSegmentRef.current = null;+ }+ return prev.filter((message) => message.turnId !== rejectedTurnId);+ });++ const remainingStartedAt = client.getRunStartedAt(chatId);+ const hasRemainingRun = (+ remainingStartedAt !== null+ || client.hasUnsettledRun(chatId)+ );+ setRunStartedAt(remainingStartedAt);+ setIsStreaming(hasRemainingRun);+ if (!hasRemainingRun) suppressStreamUntilTurnEndRef.current = false;+ }, [cancelStreamEndTimer, chatId, client]);++ useEffect(() => client.onError(applyStreamError), [applyStreamError, client]);+const resolveActiveAssistantIndex = useCallback((prev: UIMessage[],turn: UIMessageTurnFields = {},@@ -849,6 +907,15 @@ export function useNanobotStream(return () => document.removeEventListener("visibilitychange", flushOnReturn);}, [flushPendingStreamEvents]);+ useEffect(() => {+ return client.onStatus((status) => {+ if (status !== "reconnecting" && status !== "closed") return;+ // A transport drop does not prove the backend turn completed. Keep the+ // semantic running state intact so queued guidance is not flushed early.+ cancelStreamEndTimer();+ });+ }, [cancelStreamEndTimer, client]);+// Reset local state when switching chats. Do not reset on every// ``initialMessages`` update: a brand-new chat can receive an empty/404// history response after the optimistic first message has already rendered.@@ -883,6 +950,31 @@ export function useNanobotStream(if (!chatId) return;const handle = (ev: InboundEvent) => {+ if (ev.event === "error") {+ if (ev.detail === "message_too_big") {+ applyStreamError({+ kind: "message_too_big",+ chatId,+ turnId: ev.turn_id,+ });+ } else if (ev.detail === "workspace_scope_rejected") {+ applyStreamError({+ kind: "workspace_scope_rejected",+ reason: ev.reason,+ chatId,+ turnId: ev.turn_id,+ });+ } else if (ev.turn_id) {+ applyStreamError({+ kind: "turn_rejected",+ detail: ev.detail,+ reason: ev.reason,+ chatId,+ turnId: ev.turn_id,+ });+ }+ return;+ }const sideChannelEvent = isSideChannelEvent(ev);if (streamEndTimerRef.current !== null@@ -1187,8 +1279,7 @@ export function useNanobotStream(});return;}- // ``attached`` / ``error`` frames aren't actionable here; the client- // shell handles them separately.+ // ``attached`` frames aren't actionable here.};const unsub = client.onChat(chatId, handle);@@ -1202,6 +1293,7 @@ export function useNanobotStream(cancelStreamEndTimer();};}, [+ applyStreamError,cancelStreamEndTimer,chatId,client,@@ -1271,12 +1363,16 @@ export function useNanobotStream(});if (!sideChannel) setIsStreaming(true);const wireMedia = hasAttachments ? images!.map((i) => i.media) : undefined;- const wireOptions = { ...options, turnId };- delete wireOptions.quotedContext;- delete wireOptions.sideChannel;- delete wireOptions.finalizeActiveTurn;- delete wireOptions.continueActiveTurn;- client.sendMessage(chatId, outboundContent, wireMedia, wireOptions);+ const clientOptions = {+ ...options,+ turnId,+ ...((sideChannel || continueActiveTurn) ? { startsNewRun: false } : {}),+ };+ delete clientOptions.quotedContext;+ delete clientOptions.sideChannel;+ delete clientOptions.finalizeActiveTurn;+ delete clientOptions.continueActiveTurn;+ client.sendMessage(chatId, outboundContent, wireMedia, clientOptions);return { turnId, userMessageId, sideChannel };},[cancelStreamEndTimer, chatId, clearActivitySegment, client, flushPendingStreamEvents],@@ -1297,6 +1393,18 @@ export function useNanobotStream(client.sendMessage(chatId, "/stop");}, [chatId, clearActivitySegment, client, flushPendingStreamEvents]);+ const reconcileTurnComplete = useCallback(() => {+ cancelStreamEndTimer();+ clearPendingStreamWork();+ buffer.current = null;+ activeAssistantRef.current = null;+ closedAssistantStreamIdsRef.current.clear();+ clearActivitySegment();+ suppressStreamUntilTurnEndRef.current = false;+ setRunStartedAt(null);+ setIsStreaming(false);+ }, [cancelStreamEndTimer, clearActivitySegment, clearPendingStreamWork]);+const transcribeAudio = useCallback((dataUrl: string, options?: { durationMs?: number }) =>client.transcribeAudio(dataUrl, options),@@ -1312,6 +1420,7 @@ export function useNanobotStream(send,transcribeAudio,stop,+ reconcileTurnComplete,setMessages,streamError,dismissStreamError,diff --git a/webui/src/hooks/useSessions.ts b/webui/src/hooks/useSessions.tsindex f1faea403..512d39a65 100644--- a/webui/src/hooks/useSessions.ts+++ b/webui/src/hooks/useSessions.ts@@ -24,6 +24,8 @@ const INITIAL_HISTORY_PAGE_LIMIT = 160;const OLDER_HISTORY_PAGE_LIMIT = 120;const CHAT_CREATE_TIMEOUT_MS = 60_000;+export type SessionHistoryContinuity = "initial" | "overlap" | "reset";+function persistedMessagesToUi(messages: UIMessage[]): UIMessage[] {return messages.map((m, idx) => ({...m,@@ -32,6 +34,63 @@ function persistedMessagesToUi(messages: UIMessage[]): UIMessage[] {}));}+function sameSemanticMessage(a: UIMessage, b: UIMessage): boolean {+ return (+ a.role === b.role+ && (a.kind ?? "") === (b.kind ?? "")+ && a.content === b.content+ && (!a.turnId || !b.turnId || a.turnId === b.turnId)+ );+}++function longestSemanticOverlap(previous: UIMessage[], latest: UIMessage[]): number {+ const maxOverlap = Math.min(previous.length, latest.length);+ for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {+ const previousStart = previous.length - overlap;+ let matches = true;+ for (let index = 0; index < overlap; index += 1) {+ if (!sameSemanticMessage(previous[previousStart + index], latest[index])) {+ matches = false;+ break;+ }+ }+ if (matches) return overlap;+ }+ return 0;+}++function mergeLatestHistory(+ previous: UIMessage[],+ latest: UIMessage[],+ initial: boolean,+): {+ continuity: SessionHistoryContinuity;+ messages: UIMessage[];+ retainedPrefixLength: number;+} {+ if (initial) {+ return {+ continuity: "initial",+ messages: latest,+ retainedPrefixLength: 0,+ };+ }+ const overlapLength = longestSemanticOverlap(previous, latest);+ if (overlapLength === 0) {+ return {+ continuity: "reset",+ messages: latest,+ retainedPrefixLength: 0,+ };+ }+ const retainedPrefixLength = previous.length - overlapLength;+ return {+ continuity: "overlap",+ messages: [...previous.slice(0, retainedPrefixLength), ...latest],+ retainedPrefixLength,+ };+}+function hasPendingToolCallsFromThread(body: Awaited<ReturnType<typeof fetchWebuiThread>>,messages: UIMessage[],@@ -42,6 +101,17 @@ function hasPendingToolCallsFromThread(return hasPendingAgentActivity(messages);}+function completedTurnIdsFromThread(+ body: Awaited<ReturnType<typeof fetchWebuiThread>>,+): string[] {+ if (!Array.isArray(body?.completed_turn_ids)) return [];+ return Array.from(new Set(+ body.completed_turn_ids.filter(+ (turnId): turnId is string => typeof turnId === "string" && turnId.length > 0,+ ),+ ));+}+/** Sidebar state: fetches the full session list and exposes create / delete actions. */export function useSessions(): {sessions: ChatSummary[];@@ -191,11 +261,20 @@ export function useSessionHistory(key: string | null): {userMessageOffset: number;version: number;forkBoundaryMessageCount: number | null;- /** ``true`` when the replayed transcript ends with a trace row (turn still in flight). */+ /** ``true`` when the server reports that the turn is still in flight. */hasPendingToolCalls: boolean;+ /** Turn identities backed by explicit persisted completion events. */+ completedTurnIds: string[];+ /** Relationship between the latest canonical page and its predecessor. */+ continuity: SessionHistoryContinuity;+ /** Stable across overlapping latest pages; changes on initial load or reset. */+ lineage: number;+ /** Exact active turn when supplied by a current gateway. */+ activeTurnId: string | null;} {const { token } = useClient();const loadingOlderRef = useRef(false);+ const historyVersionRef = useRef(0);const [refreshSeq, setRefreshSeq] = useState(0);const refresh = useCallback(() => {setRefreshSeq((value) => value + 1);@@ -207,11 +286,15 @@ export function useSessionHistory(key: string | null): {loadingOlder: boolean;error: string | null;hasPendingToolCalls: boolean;+ completedTurnIds: string[];forkBoundaryMessageCount: number | null;beforeCursor: string | null;hasMoreBefore: boolean;userMessageOffset: number;version: number;+ continuity: SessionHistoryContinuity;+ lineage: number;+ activeTurnId: string | null;}>({key: null,messages: [],@@ -219,11 +302,15 @@ export function useSessionHistory(key: string | null): {loadingOlder: false,error: null,hasPendingToolCalls: false,+ completedTurnIds: [],forkBoundaryMessageCount: null,beforeCursor: null,hasMoreBefore: false,userMessageOffset: 0,version: 0,+ continuity: "initial",+ lineage: 0,+ activeTurnId: null,});useEffect(() => {@@ -235,11 +322,15 @@ export function useSessionHistory(key: string | null): {loadingOlder: false,error: null,hasPendingToolCalls: false,+ completedTurnIds: [],forkBoundaryMessageCount: null,beforeCursor: null,hasMoreBefore: false,userMessageOffset: 0,version: 0,+ continuity: "initial",+ lineage: 0,+ activeTurnId: null,});return;}@@ -255,11 +346,15 @@ export function useSessionHistory(key: string | null): {loadingOlder: false,error: null,hasPendingToolCalls: false,+ completedTurnIds: [],forkBoundaryMessageCount: null,beforeCursor: null,hasMoreBefore: false,userMessageOffset: 0,version: 0,+ continuity: "initial",+ lineage: 0,+ activeTurnId: null,});(async () => {try {@@ -268,56 +363,83 @@ export function useSessionHistory(key: string | null): {direction: "latest",});if (cancelled) return;- if (!body?.messages?.length) {- setState((prev) => ({- key,- messages: [],- loading: false,- loadingOlder: false,- error: null,- hasPendingToolCalls: false,- forkBoundaryMessageCount: null,- beforeCursor: null,- hasMoreBefore: false,- userMessageOffset: 0,- version: prev.key === key ? prev.version + 1 : 1,- }));- return;- }- const ui = persistedMessagesToUi(body.messages);+ historyVersionRef.current += 1;+ const responseVersion = historyVersionRef.current;+ const completedTurnIds = completedTurnIdsFromThread(body);+ const ui = persistedMessagesToUi(body?.messages ?? []);const hasPending = hasPendingToolCallsFromThread(body, ui);- const forkBoundary = typeof body.fork_boundary_message_count === "number"+ const forkBoundary = typeof body?.fork_boundary_message_count === "number"? Math.max(0, Math.min(body.fork_boundary_message_count, ui.length)): null;- setState((prev) => ({- key,- messages: ui,- loading: false,- loadingOlder: false,- error: null,- hasPendingToolCalls: hasPending,- forkBoundaryMessageCount: forkBoundary,- beforeCursor: body.page?.before_cursor ?? null,- hasMoreBefore: body.page?.has_more_before === true,- userMessageOffset: Math.max(0, body.page?.user_message_offset ?? 0),- version: prev.key === key ? prev.version + 1 : 1,- }));- } catch (e) {- if (cancelled) return;- if (e instanceof ApiError && e.status === 404) {- setState((prev) => ({+ setState((prev) => {+ const merged = prev.key === key+ ? mergeLatestHistory(prev.messages, ui, prev.lineage === 0)+ : mergeLatestHistory([], ui, true);+ const retainedPrefix = merged.retainedPrefixLength > 0;+ const retainedForkBoundary = (+ retainedPrefix+ && prev.forkBoundaryMessageCount !== null+ && prev.forkBoundaryMessageCount <= merged.retainedPrefixLength+ )+ ? prev.forkBoundaryMessageCount+ : null;+ return {key,- messages: [],+ messages: merged.messages,loading: false,loadingOlder: false,error: null,- hasPendingToolCalls: false,- forkBoundaryMessageCount: null,- beforeCursor: null,- hasMoreBefore: false,- userMessageOffset: 0,- version: prev.key === key ? prev.version + 1 : 1,- }));+ hasPendingToolCalls: hasPending,+ completedTurnIds,+ forkBoundaryMessageCount: forkBoundary === null+ ? retainedForkBoundary+ : forkBoundary + merged.retainedPrefixLength,+ beforeCursor: retainedPrefix+ ? prev.beforeCursor+ : body?.page?.before_cursor ?? null,+ hasMoreBefore: retainedPrefix+ ? prev.hasMoreBefore+ : body?.page?.has_more_before === true,+ userMessageOffset: retainedPrefix+ ? prev.userMessageOffset+ : Math.max(0, body?.page?.user_message_offset ?? 0),+ version: responseVersion,+ continuity: merged.continuity,+ lineage: merged.continuity === "overlap"+ ? prev.lineage+ : responseVersion,+ activeTurnId: typeof body?.active_turn_id === "string"+ ? body.active_turn_id+ : null,+ };+ });+ } catch (e) {+ if (cancelled) return;+ if (e instanceof ApiError && e.status === 404) {+ historyVersionRef.current += 1;+ const responseVersion = historyVersionRef.current;+ setState((prev) => {+ const continuity = prev.key === key && prev.lineage > 0+ ? "reset"+ : "initial";+ return {+ key,+ messages: [],+ loading: false,+ loadingOlder: false,+ error: null,+ hasPendingToolCalls: false,+ completedTurnIds: [],+ forkBoundaryMessageCount: null,+ beforeCursor: null,+ hasMoreBefore: false,+ userMessageOffset: 0,+ version: responseVersion,+ continuity,+ lineage: responseVersion,+ activeTurnId: null,+ };+ });} else {setState((prev) => ({key,@@ -326,11 +448,15 @@ export function useSessionHistory(key: string | null): {loadingOlder: false,error: (e as Error).message,hasPendingToolCalls: false,+ completedTurnIds: [],forkBoundaryMessageCount: null,beforeCursor: null,hasMoreBefore: false,userMessageOffset: 0,version: prev.key === key ? prev.version : 0,+ continuity: prev.key === key ? prev.continuity : "initial",+ lineage: prev.key === key ? prev.lineage : 0,+ activeTurnId: prev.key === key ? prev.activeTurnId : null,}));}}@@ -342,17 +468,26 @@ export function useSessionHistory(key: string | null): {const loadOlder = useCallback(async () => {if (!key || loadingOlderRef.current) return;- const before = state.key === key ? state.beforeCursor : null;- if (!before || !state.hasMoreBefore) return;+ const requestKey = key;+ const requestLineage = state.key === requestKey ? state.lineage : 0;+ const beforeCursor = state.key === requestKey ? state.beforeCursor : null;+ if (!beforeCursor || !state.hasMoreBefore || requestLineage === 0) return;+ const matchesRequest = (candidate: typeof state) => (+ candidate.key === requestKey+ && candidate.lineage === requestLineage+ && candidate.beforeCursor === beforeCursor+ );loadingOlderRef.current = true;- setState((prev) => prev.key === key ? { ...prev, loadingOlder: true, error: null } : prev);+ setState((prev) => matchesRequest(prev)+ ? { ...prev, loadingOlder: true, error: null }+ : prev);try {- const body = await fetchWebuiThread(token, key, {+ const body = await fetchWebuiThread(token, requestKey, {limit: OLDER_HISTORY_PAGE_LIMIT,- before,+ before: beforeCursor,});setState((prev) => {- if (prev.key !== key) return prev;+ if (!matchesRequest(prev)) return prev;if (!body?.messages?.length) {return {...prev,@@ -369,21 +504,21 @@ export function useSessionHistory(key: string | null): {? null: prev.forkBoundaryMessageCount + older.length;const nextMessages = [...older, ...prev.messages];+ // An older page cannot change the authoritative latest-turn lifecycle+ // state or masquerade as a completed latest-page refresh.return {...prev,messages: nextMessages,loadingOlder: false,error: null,- hasPendingToolCalls: hasPendingAgentActivity(nextMessages),forkBoundaryMessageCount: olderBoundary ?? shiftedBoundary,beforeCursor: body.page?.before_cursor ?? null,hasMoreBefore: body.page?.has_more_before === true,userMessageOffset: Math.max(0, body.page?.user_message_offset ?? 0),- version: prev.version + 1,};});} catch (e) {- setState((prev) => prev.key === key+ setState((prev) => matchesRequest(prev)? {...prev,loadingOlder: false,@@ -398,6 +533,7 @@ export function useSessionHistory(key: string | null): {state.beforeCursor,state.hasMoreBefore,state.key,+ state.lineage,token,]);@@ -414,6 +550,10 @@ export function useSessionHistory(key: string | null): {version: 0,forkBoundaryMessageCount: null,hasPendingToolCalls: false,+ completedTurnIds: [],+ continuity: "initial",+ lineage: 0,+ activeTurnId: null,};}@@ -432,6 +572,10 @@ export function useSessionHistory(key: string | null): {version: 0,forkBoundaryMessageCount: null,hasPendingToolCalls: false,+ completedTurnIds: [],+ continuity: "initial",+ lineage: 0,+ activeTurnId: null,};}@@ -447,6 +591,10 @@ export function useSessionHistory(key: string | null): {version: state.version,forkBoundaryMessageCount: state.forkBoundaryMessageCount,hasPendingToolCalls: state.hasPendingToolCalls,+ completedTurnIds: state.completedTurnIds,+ continuity: state.continuity,+ lineage: state.lineage,+ activeTurnId: state.activeTurnId,};}diff --git a/webui/src/i18n/locales/en/common.json b/webui/src/i18n/locales/en/common.jsonindex bf3260be3..417495294 100644--- a/webui/src/i18n/locales/en/common.json+++ b/webui/src/i18n/locales/en/common.json@@ -1251,6 +1251,10 @@"workspaceScopeRejected": {"title": "Workspace was not changed","body": "Nanobot kept the previous workspace because the requested project or access mode was rejected by the gateway."+ },+ "turnRejected": {+ "title": "Message was not sent",+ "body": "The gateway rejected this message. Review its text or attachments, then try again."}},"workspace": {diff --git a/webui/src/i18n/locales/es/common.json b/webui/src/i18n/locales/es/common.jsonindex b86bcda50..2a37f01a9 100644--- a/webui/src/i18n/locales/es/common.json+++ b/webui/src/i18n/locales/es/common.json@@ -1238,6 +1238,10 @@"workspaceScopeRejected": {"title": "El espacio de trabajo no cambió","body": "El gateway rechazó el proyecto o modo de acceso solicitado, así que Nanobot conservó el espacio de trabajo anterior."+ },+ "turnRejected": {+ "title": "El mensaje no se envió",+ "body": "El gateway rechazó este mensaje. Revisa el texto o los archivos adjuntos e inténtalo de nuevo."}},"workspace": {diff --git a/webui/src/i18n/locales/fr/common.json b/webui/src/i18n/locales/fr/common.jsonindex 0cc55a48c..1e61365b2 100644--- a/webui/src/i18n/locales/fr/common.json+++ b/webui/src/i18n/locales/fr/common.json@@ -1237,6 +1237,10 @@"workspaceScopeRejected": {"title": "L’espace de travail n’a pas changé","body": "La passerelle a refusé le projet ou le mode d’accès demandé ; Nanobot a conservé l’espace de travail précédent."+ },+ "turnRejected": {+ "title": "Le message n’a pas été envoyé",+ "body": "La passerelle a refusé ce message. Vérifiez le texte ou les pièces jointes, puis réessayez."}},"workspace": {diff --git a/webui/src/i18n/locales/id/common.json b/webui/src/i18n/locales/id/common.jsonindex 21d75275e..60223028a 100644--- a/webui/src/i18n/locales/id/common.json+++ b/webui/src/i18n/locales/id/common.json@@ -1237,6 +1237,10 @@"workspaceScopeRejected": {"title": "Workspace tidak berubah","body": "Gateway menolak proyek atau mode akses yang diminta, jadi Nanobot tetap memakai workspace sebelumnya."+ },+ "turnRejected": {+ "title": "Pesan tidak terkirim",+ "body": "Gateway menolak pesan ini. Periksa teks atau lampiran, lalu coba lagi."}},"workspace": {diff --git a/webui/src/i18n/locales/ja/common.json b/webui/src/i18n/locales/ja/common.jsonindex 901bc9d1b..0e256f775 100644--- a/webui/src/i18n/locales/ja/common.json+++ b/webui/src/i18n/locales/ja/common.json@@ -1237,6 +1237,10 @@"workspaceScopeRejected": {"title": "ワークスペースは変更されませんでした","body": "要求されたプロジェクトまたはアクセスモードがゲートウェイで拒否されたため、Nanobot は以前のワークスペースをそのまま使用しています。"+ },+ "turnRejected": {+ "title": "メッセージは送信されませんでした",+ "body": "ゲートウェイがこのメッセージを拒否しました。本文または添付ファイルを確認して、もう一度お試しください。"}},"workspace": {diff --git a/webui/src/i18n/locales/ko/common.json b/webui/src/i18n/locales/ko/common.jsonindex dd2ad5de4..716bea6da 100644--- a/webui/src/i18n/locales/ko/common.json+++ b/webui/src/i18n/locales/ko/common.json@@ -1237,6 +1237,10 @@"workspaceScopeRejected": {"title": "작업공간이 변경되지 않았습니다","body": "요청한 프로젝트 또는 접근 모드가 게이트웨이에서 거부되어 Nanobot이 이전 작업공간을 계속 사용합니다."+ },+ "turnRejected": {+ "title": "메시지가 전송되지 않았습니다",+ "body": "게이트웨이가 이 메시지를 거부했습니다. 텍스트나 첨부 파일을 확인한 후 다시 시도하세요."}},"workspace": {diff --git a/webui/src/i18n/locales/pt-BR/common.json b/webui/src/i18n/locales/pt-BR/common.jsonindex 0692324e2..f78f15218 100644--- a/webui/src/i18n/locales/pt-BR/common.json+++ b/webui/src/i18n/locales/pt-BR/common.json@@ -1251,6 +1251,10 @@"workspaceScopeRejected": {"title": "O workspace não foi alterado","body": "O nanobot manteve o workspace anterior porque o projeto ou modo de acesso solicitado foi rejeitado pelo gateway."+ },+ "turnRejected": {+ "title": "A mensagem não foi enviada",+ "body": "O gateway rejeitou esta mensagem. Revise o texto ou os anexos e tente novamente."}},"workspace": {diff --git a/webui/src/i18n/locales/vi/common.json b/webui/src/i18n/locales/vi/common.jsonindex 4541861da..6d633874b 100644--- a/webui/src/i18n/locales/vi/common.json+++ b/webui/src/i18n/locales/vi/common.json@@ -1237,6 +1237,10 @@"workspaceScopeRejected": {"title": "Workspace không thay đổi","body": "Gateway đã từ chối dự án hoặc chế độ truy cập được yêu cầu, nên Nanobot giữ workspace trước đó."+ },+ "turnRejected": {+ "title": "Tin nhắn chưa được gửi",+ "body": "Gateway đã từ chối tin nhắn này. Hãy kiểm tra nội dung hoặc tệp đính kèm rồi thử lại."}},"workspace": {diff --git a/webui/src/i18n/locales/zh-CN/common.json b/webui/src/i18n/locales/zh-CN/common.jsonindex 1540bbff8..40a6feafd 100644--- a/webui/src/i18n/locales/zh-CN/common.json+++ b/webui/src/i18n/locales/zh-CN/common.json@@ -1251,6 +1251,10 @@"workspaceScopeRejected": {"title": "工作区未更改","body": "网关拒绝了请求的项目或访问权限,Nanobot 已继续使用之前的工作区。"+ },+ "turnRejected": {+ "title": "消息未发送",+ "body": "网关拒绝了这条消息。请检查消息内容或附件后重试。"}},"workspace": {diff --git a/webui/src/i18n/locales/zh-TW/common.json b/webui/src/i18n/locales/zh-TW/common.jsonindex 5dca74778..2d02c80da 100644--- a/webui/src/i18n/locales/zh-TW/common.json+++ b/webui/src/i18n/locales/zh-TW/common.json@@ -1237,6 +1237,10 @@"workspaceScopeRejected": {"title": "工作區未變更","body": "閘道拒絕要求的專案或存取模式,因此 Nanobot 繼續使用先前的工作區。"+ },+ "turnRejected": {+ "title": "訊息未傳送",+ "body": "閘道拒絕了這則訊息。請檢查內容或附件後再試一次。"}},"workspace": {diff --git a/webui/src/lib/api.ts b/webui/src/lib/api.tsindex 898b6a668..1a4501d32 100644--- a/webui/src/lib/api.ts+++ b/webui/src/lib/api.ts@@ -185,6 +185,7 @@ export async function fetchWebuiThread(const res = await fetchWithTimeout(url, {headers: { Authorization: `Bearer ${token}` },credentials: "same-origin",+ cache: "no-store",});if (res.status === 404) return null;if (!res.ok) throw new ApiError(res.status, `HTTP ${res.status}`);diff --git a/webui/src/lib/nanobot-client.ts b/webui/src/lib/nanobot-client.tsindex 706805010..b7f2b2b5a 100644--- a/webui/src/lib/nanobot-client.ts+++ b/webui/src/lib/nanobot-client.ts@@ -83,8 +83,20 @@ export type StreamError =/** Server rejected the inbound frame as too large (WS close code 1009).* This is the transport fallback after text and attachment policies have* already been checked independently. */- | { kind: "message_too_big" }- | { kind: "workspace_scope_rejected"; reason?: string; chatId?: string };+ | { kind: "message_too_big"; chatId?: string; turnId?: string }+ | {+ kind: "workspace_scope_rejected";+ reason?: string;+ chatId?: string;+ turnId?: string;+ }+ | {+ kind: "turn_rejected";+ detail?: string;+ reason?: string;+ chatId: string;+ turnId: string;+ };type ErrorHandler = (error: StreamError) => void;@@ -95,6 +107,13 @@ interface PendingRequest<T> {}const SYSTEM_COMMAND_TURN_PREFIX = "webui-system:";+const TURN_REJECTION_DETAILS = new Set([+ "access_denied",+ "attachment_rejected",+ "message_rejected",+ "missing content",+ "workspace_scope_rejected",+]);export function isSystemCommandTurnId(value: string | null | undefined): value is string {return typeof value === "string" && value.startsWith(SYSTEM_COMMAND_TURN_PREFIX);@@ -103,6 +122,8 @@ export function isSystemCommandTurnId(value: string | null | undefined): value iexport interface NanobotClientOptions {url: string;reconnect?: boolean;+ /** Maximum UTF-8 bytes accepted for one websocket message. */+ maxFrameBytes?: number;/** Called when a connection drops so the app can refresh its token. */onReauth?: () => Promise<string | null>;/** Inject a custom WebSocket factory (used by unit tests). */@@ -111,6 +132,24 @@ export interface NanobotClientOptions {maxBackoffMs?: number;}+export interface CanonicalRunSnapshot {+ /** User turn ids present in the canonical transcript page. */+ observedTurnIds: readonly string[];+ /** Whether the server still considers the transcript tail active. */+ hasPendingToolCalls: boolean;+ /** Exact active turn when supplied by a current gateway. */+ activeTurnId?: string | null;+}++type PendingMessageState = "queued" | "sent" | "unknown" | "accepted";++interface PendingMessageSend {+ chatId: string;+ turnId: string;+ startsNewRun: boolean;+ state: PendingMessageState;+}+/*** Singleton WebSocket client that multiplexes chat streams.*@@ -134,6 +173,23 @@ export class NanobotClient {private knownChats = new Set<string>();/** Wall-clock run strip: updated from ``goal_status`` even with no ``onChat`` subscriber. */private runStartedAtByChatId = new Map<string, number>();+ /** Per-turn clocks let a rejected newer turn fall back without borrowing its timer. */+ private runStartedAtByTurnKey = new Map<string, number>();+ /** Monotonic per-chat generation for local sends and observed backend runs. */+ private runGenerationByChatId = new Map<string, number>();+ /** Turn associated with the latest generation, retained after idle for reconciliation. */+ private latestRunTurnIdByChatId = new Map<string, string>();+ /** Submitted or running turns not yet closed by lifecycle or canonical state. */+ private unsettledRunTurnIdsByChatId = new Map<string, Set<string>>();+ /** Correlated WebUI sends retained until protocol/canonical disposition. */+ private pendingMessageSends = new Map<string, PendingMessageSend>();+ /** Message sends written to the current socket but not yet acknowledged. */+ private socketPendingMessageSendKeys = new Set<string>();+ /** Last application frame written, used only for conservative 1009 attribution. */+ private lastSocketMessageSendKey: string | null = null;+ /** Canonically completed turns whose delayed websocket frames must be ignored. */+ private canonicalCompletedTurnIdsByChatId = new Map<string, Set<string>>();+ private static readonly COMPLETED_TURN_FENCE_MAX = 256;/** Latest ``goal_state`` snapshot per ``chat_id`` (multi-session isolation). */private goalStateByChatId = new Map<string, GoalStateWsPayload>();private pendingNewChat: PendingRequest<string> | null = null;@@ -145,6 +201,7 @@ export class NanobotClient {private reconnectTimer: ReturnType<typeof setTimeout> | null = null;private readonly shouldReconnect: boolean;private readonly maxBackoffMs: number;+ private maxFrameBytes: number | undefined;private socketFactory: (url: string) => WebSocket;private currentUrl: string;private status_: ConnectionStatus = "idle";@@ -156,6 +213,7 @@ export class NanobotClient {constructor(private options: NanobotClientOptions) {this.shouldReconnect = options.reconnect ?? true;this.maxBackoffMs = options.maxBackoffMs ?? 15_000;+ this.maxFrameBytes = this.normalizeMaxFrameBytes(options.maxFrameBytes);this.socketFactory = options.socketFactory ?? createDefaultSocket;this.currentUrl = options.url;}@@ -222,27 +280,386 @@ export class NanobotClient {return v === undefined ? null : v;}+ /** Refresh transport policy after bootstrap token renewal. */+ updateMaxFrameBytes(maxFrameBytes?: number): void {+ this.maxFrameBytes = this.normalizeMaxFrameBytes(maxFrameBytes);+ }++ /** Generation captured when an HTTP thread reconciliation starts. */+ getRunGeneration(chatId: string): number {+ return this.runGenerationByChatId.get(chatId) ?? 0;+ }++ /** Whether a locally submitted lifecycle turn still lacks a terminal disposition. */+ hasUnsettledRun(chatId: string): boolean {+ return (this.unsettledRunTurnIdsByChatId.get(chatId)?.size ?? 0) > 0;+ }++ private normalizeMaxFrameBytes(value: number | undefined): number | undefined {+ if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {+ return undefined;+ }+ return Math.floor(value);+ }++ private canonicalTurnWillSettle(+ chatId: string,+ turnId: string,+ completed: ReadonlySet<string>,+ observed: ReadonlySet<string>,+ snapshot?: CanonicalRunSnapshot,+ ): boolean {+ if (completed.has(turnId)) return true;+ if (!snapshot || snapshot.activeTurnId === turnId) return false;+ if (snapshot.hasPendingToolCalls) return false;+ if (observed.has(turnId)) return true;+ const pending = this.pendingMessageSends.get(this.runSendKey(chatId, turnId));+ return pending?.state === "unknown" || pending?.state === "accepted";+ }++ private settleNonLifecycleCanonicalSends(+ chatId: string,+ completed: ReadonlySet<string>,+ observed: ReadonlySet<string>,+ snapshot?: CanonicalRunSnapshot,+ ): void {+ for (const pending of [...this.pendingMessageSends.values()]) {+ if (pending.chatId !== chatId || pending.startsNewRun) continue;+ if (!this.canonicalTurnWillSettle(+ chatId,+ pending.turnId,+ completed,+ observed,+ snapshot,+ )) continue;+ this.clearPendingMessageSend(chatId, pending.turnId);+ }+ }++ private prunePendingInboundTurn(chatId: string, turnId: string): void {+ const pending = this.pendingInboundByChat.get(chatId);+ if (!pending) return;+ const remaining = pending.filter((event) => (+ !("turn_id" in event)+ || event.turn_id !== turnId+ ));+ if (remaining.length > 0) this.pendingInboundByChat.set(chatId, remaining);+ else this.pendingInboundByChat.delete(chatId);+ }++ /**+ * Pure preflight for canonical reconciliation.+ *+ * Unlike ``reconcileCanonicalCompletion``, this does not add completion+ * fences, prune queued frames, settle turns, or emit run-status updates.+ */+ canReconcileCanonicalCompletion(+ chatId: string,+ expectedRunGeneration: number,+ completedTurnIds: readonly string[],+ snapshot?: CanonicalRunSnapshot,+ ): boolean {+ const completed = new Set(this.canonicalCompletedTurnIdsByChatId.get(chatId));+ for (const turnId of completedTurnIds) {+ if (turnId) completed.add(turnId);+ }+ const observed = new Set(+ snapshot?.observedTurnIds.filter((turnId) => turnId.length > 0) ?? [],+ );+ const willSettle = (turnId: string): boolean => this.canonicalTurnWillSettle(+ chatId,+ turnId,+ completed,+ observed,+ snapshot,+ );+ const latestRunTurnId = this.latestRunTurnIdByChatId.get(chatId);+ const latestRunIsRepresented = (+ typeof latestRunTurnId === "string"+ && (+ completed.has(latestRunTurnId)+ || (+ observed.has(latestRunTurnId)+ && willSettle(latestRunTurnId)+ )+ )+ );+ const unsettledTurnIds = this.unsettledRunTurnIdsByChatId.get(chatId);+ const hasUnrepresentedTurn = (+ unsettledTurnIds !== undefined+ && Array.from(unsettledTurnIds).some((turnId) => !willSettle(turnId))+ );+ const hasUnidentifiedActiveRun = (+ this.runStartedAtByChatId.has(chatId)+ && latestRunTurnId === undefined+ && (snapshot === undefined || snapshot.hasPendingToolCalls)+ );+ if (hasUnrepresentedTurn || hasUnidentifiedActiveRun) return false;+ return (+ this.getRunGeneration(chatId) === expectedRunGeneration+ || latestRunIsRepresented+ );+ }++ /**+ * Atomically accept an HTTP snapshot as completed if no unrepresented run+ * started while the request was in flight.+ *+ * Completed turn ids are fenced even when the snapshot loses the generation+ * race: delayed websocket frames for older turns must never mutate newer UI.+ */+ reconcileCanonicalCompletion(+ chatId: string,+ expectedRunGeneration: number,+ completedTurnIds: readonly string[],+ snapshot?: CanonicalRunSnapshot,+ ): boolean {+ const fences = this.canonicalCompletedTurnIdsByChatId.get(chatId) ?? new Set<string>();+ for (const turnId of completedTurnIds) {+ if (!turnId) continue;+ fences.add(turnId);+ }+ while (fences.size > NanobotClient.COMPLETED_TURN_FENCE_MAX) {+ const oldest = fences.values().next().value;+ if (typeof oldest !== "string") break;+ fences.delete(oldest);+ }+ if (fences.size > 0) this.canonicalCompletedTurnIdsByChatId.set(chatId, fences);+ const pendingInbound = this.pendingInboundByChat.get(chatId);+ if (pendingInbound) {+ const remaining = pendingInbound.filter((event) => {+ const turnId = "turn_id" in event && typeof event.turn_id === "string"+ ? event.turn_id+ : null;+ return turnId === null || !fences.has(turnId);+ });+ if (remaining.length > 0) this.pendingInboundByChat.set(chatId, remaining);+ else this.pendingInboundByChat.delete(chatId);+ }++ if (!this.canReconcileCanonicalCompletion(+ chatId,+ expectedRunGeneration,+ [],+ snapshot,+ )) {+ return false;+ }++ const completed = new Set(fences);+ const observed = new Set(+ snapshot?.observedTurnIds.filter((turnId) => turnId.length > 0) ?? [],+ );+ const unsettledTurnIds = this.unsettledRunTurnIdsByChatId.get(chatId);+ if (unsettledTurnIds) {+ for (const turnId of [...unsettledTurnIds]) {+ if (!this.canonicalTurnWillSettle(+ chatId,+ turnId,+ completed,+ observed,+ snapshot,+ )) continue;+ unsettledTurnIds.delete(turnId);+ this.clearPendingMessageSend(chatId, turnId);+ this.runStartedAtByTurnKey.delete(this.runSendKey(chatId, turnId));+ }+ if (unsettledTurnIds.size === 0) this.unsettledRunTurnIdsByChatId.delete(chatId);+ }+ this.settleNonLifecycleCanonicalSends(chatId, completed, observed, snapshot);+ if (this.runStartedAtByChatId.delete(chatId)) {+ this.emitRunStatus(chatId, null);+ }+ return true;+ }+/** Last ``goal_state`` payload for *chatId*, if any frame has arrived this connection. */getGoalState(chatId: string): GoalStateWsPayload | undefined {return this.goalStateByChatId.get(chatId);}+ private advanceRunGeneration(chatId: string, turnId?: string): void {+ this.runGenerationByChatId.set(chatId, this.getRunGeneration(chatId) + 1);+ if (turnId) {+ this.latestRunTurnIdByChatId.set(chatId, turnId);+ const unsettled = this.unsettledRunTurnIdsByChatId.get(chatId) ?? new Set<string>();+ unsettled.add(turnId);+ this.unsettledRunTurnIdsByChatId.set(chatId, unsettled);+ } else {+ this.latestRunTurnIdByChatId.delete(chatId);+ }+ }++ private settleRunTurn(chatId: string, turnId?: string): void {+ if (!turnId) return;+ this.clearPendingMessageSend(chatId, turnId);+ this.runStartedAtByTurnKey.delete(this.runSendKey(chatId, turnId));+ const unsettled = this.unsettledRunTurnIdsByChatId.get(chatId);+ if (!unsettled) return;+ unsettled.delete(turnId);+ if (unsettled.size === 0) this.unsettledRunTurnIdsByChatId.delete(chatId);+ }++ private runSendKey(chatId: string, turnId: string): string {+ return `${chatId}\u0000${turnId}`;+ }++ private trackPendingMessageSend(+ chatId: string,+ turnId: string,+ startsNewRun: boolean,+ ): void {+ const key = this.runSendKey(chatId, turnId);+ this.pendingMessageSends.set(key, {+ chatId,+ turnId,+ startsNewRun,+ state: "queued",+ });+ }++ private clearPendingMessageSend(chatId: string, turnId: string): void {+ const key = this.runSendKey(chatId, turnId);+ this.pendingMessageSends.delete(key);+ this.socketPendingMessageSendKeys.delete(key);+ this.sendQueue = this.sendQueue.filter((frame) => !(+ frame.type === "message"+ && frame.chat_id === chatId+ && frame.turn_id === turnId+ ));+ }++ private recordRunAcceptance(chatId: string, turnId?: string): void {+ if (!turnId) return;+ const key = this.runSendKey(chatId, turnId);+ const pending = this.pendingMessageSends.get(key);+ if (!pending) return;+ this.socketPendingMessageSendKeys.delete(key);+ if (!pending.startsNewRun) {+ this.pendingMessageSends.delete(key);+ return;+ }+ pending.state = "accepted";+ }++ private recordRunRejection(chatId: string, turnId?: string): void {+ if (!turnId) return;+ const rejectedLatest = this.latestRunTurnIdByChatId.get(chatId) === turnId;+ this.settleRunTurn(chatId, turnId);+ this.prunePendingInboundTurn(chatId, turnId);+ if (!rejectedLatest) return;++ const unsettled = this.unsettledRunTurnIdsByChatId.get(chatId);+ const previousTurnId = unsettled ? Array.from(unsettled).at(-1) : undefined;+ if (previousTurnId) {+ this.latestRunTurnIdByChatId.set(chatId, previousTurnId);+ const previousStartedAt = this.runStartedAtByTurnKey.get(+ this.runSendKey(chatId, previousTurnId),+ );+ const currentStartedAt = this.runStartedAtByChatId.get(chatId);+ if (previousStartedAt === undefined) {+ if (this.runStartedAtByChatId.delete(chatId)) {+ this.emitRunStatus(chatId, null);+ }+ } else {+ this.runStartedAtByChatId.set(chatId, previousStartedAt);+ if (currentStartedAt !== previousStartedAt) {+ this.emitRunStatus(chatId, previousStartedAt);+ }+ }+ return;+ }+ this.latestRunTurnIdByChatId.delete(chatId);+ if (this.runStartedAtByChatId.delete(chatId)) {+ this.emitRunStatus(chatId, null);+ }+ }++ private legacyRejectionTarget(ev: Extract<InboundEvent, { event: "error" }>): {+ chatId: string;+ turnId: string;+ } | null {+ if (!ev.detail || !TURN_REJECTION_DETAILS.has(ev.detail)) return null;+ if (+ ev.detail === "workspace_scope_rejected"+ && ev.chat_id === undefined+ && this.pendingNewChat+ ) return null;+ const candidates = [...this.pendingMessageSends.values()].filter((pending) => (+ // A legacy error can only reject a frame currently awaiting its first+ // server disposition. Accepted or prior-connection unknown sends are+ // not safe candidates for an uncorrelated frame.+ pending.state === "sent"+ && (ev.chat_id === undefined || pending.chatId === ev.chat_id)+ ));+ if (candidates.length !== 1) return null;+ const [candidate] = candidates;+ if (+ this.lastSocketMessageSendKey+ !== this.runSendKey(candidate.chatId, candidate.turnId)+ ) return null;+ return { chatId: candidate.chatId, turnId: candidate.turnId };+ }++ private uniqueUnsettledTurnId(chatId: string): string | null {+ const unsettled = this.unsettledRunTurnIdsByChatId.get(chatId);+ if (!unsettled || unsettled.size !== 1) return null;+ return unsettled.values().next().value ?? null;+ }++ private isCanonicalCompletedTurnEvent(chatId: string, ev: InboundEvent): boolean {+ const turnId = "turn_id" in ev && typeof ev.turn_id === "string" ? ev.turn_id : null;+ return (+ turnId !== null+ && this.canonicalCompletedTurnIdsByChatId.get(chatId)?.has(turnId) === true+ );+ }++ private isSupersededRunCompletion(chatId: string, ev: InboundEvent): boolean {+ if (+ ev.event !== "turn_end"+ && !(ev.event === "goal_status" && ev.status === "idle")+ ) {+ return false;+ }+ const turnId = "turn_id" in ev && typeof ev.turn_id === "string" ? ev.turn_id : undefined;+ const latestRunTurnId = this.latestRunTurnIdByChatId.get(chatId);+ if (turnId === undefined && latestRunTurnId !== undefined) return true;+ return (+ turnId !== undefined+ && latestRunTurnId !== undefined+ && turnId !== latestRunTurnId+ );+ }++ private recordRunCompletion(chatId: string, turnId?: string): void {+ this.settleRunTurn(chatId, turnId);+ const latestRunTurnId = this.latestRunTurnIdByChatId.get(chatId);+ const closesCurrentRun = latestRunTurnId === undefined || turnId === latestRunTurnId;+ if (closesCurrentRun && this.runStartedAtByChatId.delete(chatId)) {+ this.emitRunStatus(chatId, null);+ }+ }+private recordGoalStatusForRunStrip(chatId: string, ev: InboundEvent): void {if (ev.event === "turn_end") {- if (this.runStartedAtByChatId.has(chatId)) {- this.runStartedAtByChatId.delete(chatId);- this.emitRunStatus(chatId, null);- }+ this.recordRunCompletion(chatId, ev.turn_id);return;}if (ev.event !== "goal_status") return;if (ev.status === "running" && typeof ev.started_at === "number") {+ this.advanceRunGeneration(chatId, ev.turn_id);+ if (ev.turn_id) {+ this.runStartedAtByTurnKey.set(+ this.runSendKey(chatId, ev.turn_id),+ ev.started_at,+ );+ }const previous = this.runStartedAtByChatId.get(chatId);this.runStartedAtByChatId.set(chatId, ev.started_at);if (previous !== ev.started_at) this.emitRunStatus(chatId, ev.started_at);- } else if (this.runStartedAtByChatId.has(chatId)) {- this.runStartedAtByChatId.delete(chatId);- this.emitRunStatus(chatId, null);+ } else {+ this.recordRunCompletion(chatId, ev.turn_id);}}@@ -390,6 +807,8 @@ export class NanobotClient {quotedContext?: string;workspaceScope?: WorkspaceScopePayload | null;turnId?: string;+ /** False for side-channel or injected messages that do not own a lifecycle. */+ startsNewRun?: boolean;},): void {this.knownChats.add(chatId);@@ -405,6 +824,22 @@ export class NanobotClient {...(options?.turnId ? { turn_id: options.turnId } : {}),webui: true,};+ if (!this.frameFitsTransport(frame)) {+ if (options?.turnId && isSystemCommandTurnId(options.turnId)) {+ this.rejectSystemCommand(options.turnId, "message_too_big");+ }+ this.emitError({+ kind: "message_too_big",+ chatId,+ ...(options?.turnId ? { turnId: options.turnId } : {}),+ });+ return;+ }+ if (options?.turnId && !isSystemCommandTurnId(options.turnId)) {+ const startsNewRun = options.startsNewRun !== false;+ if (startsNewRun) this.advanceRunGeneration(chatId, options.turnId);+ this.trackPendingMessageSend(chatId, options.turnId, startsNewRun);+ }this.queueSend(frame);}@@ -442,6 +877,7 @@ export class NanobotClient {if (this.runStartedAtByChatId.size === 0) return;const chatIds = [...this.runStartedAtByChatId.keys()];this.runStartedAtByChatId.clear();+ this.runStartedAtByTurnKey.clear();for (const chatId of chatIds) this.emitRunStatus(chatId, null);}@@ -476,16 +912,61 @@ export class NanobotClient {console.log("[nanobot ws inbound]", summarizeInboundWsPayload(parsed));}+ if (parsed.event === "error" && !parsed.turn_id) {+ const fallback = this.legacyRejectionTarget(parsed);+ if (fallback) {+ parsed = {+ ...parsed,+ chat_id: parsed.chat_id ?? fallback.chatId,+ turn_id: fallback.turnId,+ };+ }+ }+ if (+ (parsed.event === "goal_status" || parsed.event === "turn_end")+ && !parsed.turn_id+ ) {+ const fallbackTurnId = this.uniqueUnsettledTurnId(parsed.chat_id);+ if (fallbackTurnId) parsed = { ...parsed, turn_id: fallbackTurnId };+ }+const turnId = "turn_id" in parsed && typeof parsed.turn_id === "string"? parsed.turn_id: null;+ if (parsed.event === "message_accepted") {+ this.recordRunAcceptance(parsed.chat_id, parsed.turn_id);+ return;+ }if (isSystemCommandTurnId(turnId)) {- if (parsed.event === "message" || parsed.event === "turn_end") {+ if (parsed.event === "error") {+ this.rejectSystemCommand(+ turnId,+ [parsed.detail, parsed.reason].filter(Boolean).join(":") || "server error",+ );+ } else if (parsed.event === "message" || parsed.event === "turn_end") {this.resolveSystemCommand(turnId);}return;}+ const correlatedChatId = (parsed as { chat_id?: string }).chat_id;+ if (parsed.event === "error" && correlatedChatId && turnId) {+ this.recordRunRejection(correlatedChatId, turnId);+ if (parsed.detail !== "workspace_scope_rejected") {+ this.emitError({+ kind: "turn_rejected",+ detail: parsed.detail,+ reason: parsed.reason,+ chatId: correlatedChatId,+ turnId,+ });+ }+ } else if (parsed.event !== "error" && correlatedChatId && turnId) {+ // Lifecycle traffic is also an implicit acceptance signal for clients+ // connected to an older gateway that doesn't emit message_accepted.+ this.recordRunAcceptance(correlatedChatId, turnId);+ }+if (parsed.event === "ready") {this.readyChatId = parsed.chat_id;this.knownChats.add(parsed.chat_id);@@ -528,6 +1009,7 @@ export class NanobotClient {kind: "workspace_scope_rejected",reason: parsed.reason,chatId: parsed.chat_id,+ turnId: parsed.turn_id,});if (this.pendingNewChat) {clearTimeout(this.pendingNewChat.timer);@@ -546,7 +1028,10 @@ export class NanobotClient {const chatId = (parsed as { chat_id?: string }).chat_id;if (chatId) {+ if (this.isCanonicalCompletedTurnEvent(chatId, parsed)) return;+ const supersededRunCompletion = this.isSupersededRunCompletion(chatId, parsed);this.recordGoalStatusForRunStrip(chatId, parsed);+ if (supersededRunCompletion) return;this.recordGoalStateSnapshot(chatId, parsed);this.dispatch(chatId, parsed);}@@ -611,9 +1096,44 @@ export class NanobotClient {// display the error even while the client transparently reconnects.// Browsers populate ``CloseEvent.code`` with the wire-level close code;// 1009 = Message Too Big (server's max frame guard).+ const unacknowledged = Array.from(this.socketPendingMessageSendKeys)+ .map((key) => this.pendingMessageSends.get(key))+ .filter((pending): pending is PendingMessageSend => pending !== undefined);if (event?.code === 1009) {- this.emitError({ kind: "message_too_big" });+ const soleKey = unacknowledged.length === 1+ ? this.runSendKey(unacknowledged[0].chatId, unacknowledged[0].turnId)+ : null;+ if (+ unacknowledged.length === 1+ && this.lastSocketMessageSendKey === soleKey+ ) {+ const [rejected] = unacknowledged;+ this.recordRunRejection(rejected.chatId, rejected.turnId);+ this.emitError({+ kind: "message_too_big",+ chatId: rejected.chatId,+ turnId: rejected.turnId,+ });+ this.dispatch(rejected.chatId, {+ event: "error",+ detail: "message_too_big",+ chat_id: rejected.chatId,+ turn_id: rejected.turnId,+ });+ } else {+ // A close frame identifies no offending application message. Never+ // roll back multiple chats merely because they shared one socket.+ this.emitError({ kind: "message_too_big" });+ }+ }+ for (const pending of unacknowledged) {+ const current = this.pendingMessageSends.get(+ this.runSendKey(pending.chatId, pending.turnId),+ );+ if (current?.state === "sent") current.state = "unknown";}+ this.socketPendingMessageSendKeys.clear();+ this.lastSocketMessageSendKey = null;if (this.intentionallyClosed || !this.shouldReconnect) {this.setStatus("closed");return;@@ -671,6 +1191,14 @@ export class NanobotClient {pending.resolve();}+ private rejectSystemCommand(turnId: string, detail: string): void {+ const pending = this.pendingSystemCommands.get(turnId);+ if (!pending) return;+ clearTimeout(pending.timer);+ this.pendingSystemCommands.delete(turnId);+ pending.reject(new Error(detail));+ }+private scheduleReconnect(): void {this.clearRunStatusesForReconnect();this.setStatus("reconnecting");@@ -699,10 +1227,25 @@ export class NanobotClient {}}+ private frameFitsTransport(frame: Outbound): boolean {+ if (this.maxFrameBytes === undefined) return true;+ return new TextEncoder().encode(JSON.stringify(frame)).byteLength <= this.maxFrameBytes;+ }+private rawSend(frame: Outbound): void {if (!this.socket) return;try {this.socket.send(JSON.stringify(frame));+ this.lastSocketMessageSendKey = null;+ if (frame.type === "message" && frame.turn_id) {+ const key = this.runSendKey(frame.chat_id, frame.turn_id);+ const pending = this.pendingMessageSends.get(key);+ if (pending) {+ pending.state = "sent";+ this.socketPendingMessageSendKeys.add(key);+ this.lastSocketMessageSendKey = key;+ }+ }} catch {// Send failure will materialize as a close; queue the frame for retry.this.sendQueue.push(frame);diff --git a/webui/src/lib/types.ts b/webui/src/lib/types.tsindex 1db55490d..a0ef20047 100644--- a/webui/src/lib/types.ts+++ b/webui/src/lib/types.ts@@ -1082,6 +1082,7 @@ export interface InboundTurnMetadata {export type InboundEvent =| { event: "ready"; chat_id: string; client_id: string }| { event: "attached"; chat_id: string }+ | { event: "message_accepted"; chat_id: string; turn_id: string }| ({event: "message";chat_id: string;@@ -1149,14 +1150,14 @@ export type InboundEvent =/** Authoritative sustained-goal snapshot for this chat (same shape as ``goal_state`` events). */goal_state?: GoalStateWsPayload;} & InboundTurnMetadata)- | {+ | ({event: "goal_status";chat_id: string;/** Turn executing (user message through agent loop). */status: "running" | "idle";/** Server ``time.time()`` when ``status`` is ``running``. */started_at?: number;- }+ } & InboundTurnMetadata)| {event: "goal_state";chat_id: string;@@ -1175,7 +1176,14 @@ export type InboundEvent =detail?: string;provider?: string;}- | { event: "error"; chat_id?: string; detail?: string; reason?: string };+ | {+ event: "error";+ chat_id?: string;+ detail?: string;+ reason?: string;+ /** Present when this error rejects a specific outbound WebUI turn. */+ turn_id?: string;+ };/** Base64-encoded file attached to an outbound ``message`` envelope.*@@ -1224,7 +1232,11 @@ export interface WebuiThreadPersistedPayload {savedAt?: string;messages: UIMessage[];fork_boundary_message_count?: number;+ /** Turn ids backed by an explicit persisted ``turn_end`` event. */+ completed_turn_ids?: string[];has_pending_tool_calls?: boolean;+ /** Exact active turn when supplied by a current gateway. */+ active_turn_id?: string | null;page?: WebuiThreadPagePayload;workspace_scope?: WorkspaceScopePayload;}diff --git a/webui/src/tests/api.test.ts b/webui/src/tests/api.test.tsindex e2e6103a3..e620dc58c 100644--- a/webui/src/tests/api.test.ts+++ b/webui/src/tests/api.test.ts@@ -77,6 +77,7 @@ describe("webui API helpers", () => {expect.objectContaining({headers: { Authorization: "Bearer tok" },credentials: "same-origin",+ cache: "no-store",}),);});diff --git a/webui/src/tests/app-layout.test.tsx b/webui/src/tests/app-layout.test.tsxindex 2bf0c7752..63f48cdee 100644--- a/webui/src/tests/app-layout.test.tsx+++ b/webui/src/tests/app-layout.test.tsx@@ -217,6 +217,7 @@ vi.mock("@/lib/nanobot-client", () => {attach = attachSpy;close = vi.fn();updateUrl = updateUrlSpy;+ updateMaxFrameBytes = vi.fn();}return { NanobotClient: MockClient };diff --git a/webui/src/tests/nanobot-client.test.ts b/webui/src/tests/nanobot-client.test.tsindex 7284f7c10..bdecddc6d 100644--- a/webui/src/tests/nanobot-client.test.ts+++ b/webui/src/tests/nanobot-client.test.ts@@ -238,6 +238,891 @@ describe("NanobotClient", () => {expect(handler).toHaveBeenLastCalledWith("chat-strip", null);});+ it("rejects a completed snapshot when a newer run is not represented", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ const requestGeneration = client.getRunGeneration("chat-race");++ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-race",+ status: "running",+ started_at: 12_345,+ turn_id: "turn-new",+ });++ expect(+ client.reconcileCanonicalCompletion("chat-race", requestGeneration, ["turn-old"]),+ ).toBe(false);+ expect(client.getRunStartedAt("chat-race")).toBe(12_345);+ });++ it("rejects a user-only snapshot for a submitted turn that has not completed", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-submitted", "question", undefined, { turnId: "turn-submitted" });+ const requestGeneration = client.getRunGeneration("chat-submitted");++ expect(+ client.reconcileCanonicalCompletion("chat-submitted", requestGeneration, []),+ ).toBe(false);+ });++ it("does not register injected guidance as an independently unsettled run", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-guidance",+ status: "running",+ started_at: 12_345,+ turn_id: "turn-active",+ });+ const requestGeneration = client.getRunGeneration("chat-guidance");++ client.sendMessage("chat-guidance", "focus on sources", undefined, {+ turnId: "turn-guidance",+ startsNewRun: false,+ });++ expect(client.getRunGeneration("chat-guidance")).toBe(requestGeneration);+ expect(+ client.reconcileCanonicalCompletion(+ "chat-guidance",+ requestGeneration,+ ["turn-active"],+ ),+ ).toBe(true);+ });++ it("accepts an explicitly completed turn with no assistant row", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-empty-answer", "question", undefined, {+ turnId: "turn-empty-answer",+ });+ const requestGeneration = client.getRunGeneration("chat-empty-answer");++ expect(+ client.reconcileCanonicalCompletion(+ "chat-empty-answer",+ requestGeneration,+ ["turn-empty-answer"],+ ),+ ).toBe(true);+ });++ it.each([+ "message_rejected",+ "attachment_rejected",+ "workspace_scope_rejected",+ ])("settles a specifically rejected outbound turn (%s)", (detail) => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-rejected", "question", undefined, {+ turnId: "turn-rejected",+ });+ const requestGeneration = client.getRunGeneration("chat-rejected");++ expect(+ client.reconcileCanonicalCompletion("chat-rejected", requestGeneration, []),+ ).toBe(false);++ lastSocket().fakeMessage({+ event: "error",+ chat_id: "chat-rejected",+ turn_id: "turn-rejected",+ detail,+ reason: "policy",+ });++ expect(+ client.reconcileCanonicalCompletion("chat-rejected", requestGeneration, []),+ ).toBe(true);+ });++ it("does not let an older rejection settle or stop a newer run", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-rejection-race", "first", undefined, {+ turnId: "turn-old",+ });+ client.sendMessage("chat-rejection-race", "second", undefined, {+ turnId: "turn-new",+ });+ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-rejection-race",+ status: "running",+ started_at: 2_000,+ turn_id: "turn-new",+ });+ const requestGeneration = client.getRunGeneration("chat-rejection-race");++ lastSocket().fakeMessage({+ event: "error",+ chat_id: "chat-rejection-race",+ turn_id: "turn-old",+ detail: "message_rejected",+ reason: "text_too_large",+ });++ expect(client.getRunStartedAt("chat-rejection-race")).toBe(2_000);+ expect(+ client.reconcileCanonicalCompletion("chat-rejection-race", requestGeneration, []),+ ).toBe(false);+ });++ it("restores the previous turn clock when the newer running turn is rejected", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-reject-newer-clock", "first", undefined, {+ turnId: "turn-clock-first",+ });+ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-reject-newer-clock",+ status: "running",+ started_at: 1_000,+ turn_id: "turn-clock-first",+ });+ client.sendMessage("chat-reject-newer-clock", "second", undefined, {+ turnId: "turn-clock-second",+ });+ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-reject-newer-clock",+ status: "running",+ started_at: 2_000,+ turn_id: "turn-clock-second",+ });++ lastSocket().fakeMessage({+ event: "error",+ chat_id: "chat-reject-newer-clock",+ turn_id: "turn-clock-second",+ detail: "message_rejected",+ });++ expect(client.getRunStartedAt("chat-reject-newer-clock")).toBe(1_000);+ expect(client.hasUnsettledRun("chat-reject-newer-clock")).toBe(true);+ });++ it("rolls back lifecycle sends that close 1009 before server acceptance", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const errors: Array<{ kind: string; chatId?: string; turnId?: string }> = [];+ client.onError((error) => errors.push(error));+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-too-big", "oversized", undefined, {+ turnId: "turn-too-big",+ });+ const requestGeneration = client.getRunGeneration("chat-too-big");++ lastSocket().fakeCloseWithCode(1009);++ expect(errors).toEqual([{+ kind: "message_too_big",+ chatId: "chat-too-big",+ turnId: "turn-too-big",+ }]);+ expect(+ client.reconcileCanonicalCompletion("chat-too-big", requestGeneration, []),+ ).toBe(true);+ });++ it("preserves an accepted older run when a newer send closes 1009", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const errors: Array<{ kind: string; chatId?: string; turnId?: string }> = [];+ client.onError((error) => errors.push(error));+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-too-big-race", "first", undefined, {+ turnId: "turn-accepted",+ });+ lastSocket().fakeMessage({+ event: "message_accepted",+ chat_id: "chat-too-big-race",+ turn_id: "turn-accepted",+ });+ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-too-big-race",+ status: "running",+ started_at: 1_000,+ turn_id: "turn-accepted",+ });+ client.sendMessage("chat-too-big-race", "oversized", undefined, {+ turnId: "turn-rejected",+ });+ const requestGeneration = client.getRunGeneration("chat-too-big-race");++ lastSocket().fakeCloseWithCode(1009);++ expect(errors).toEqual([{+ kind: "message_too_big",+ chatId: "chat-too-big-race",+ turnId: "turn-rejected",+ }]);+ expect(client.getRunStartedAt("chat-too-big-race")).toBe(1_000);+ expect(+ client.reconcileCanonicalCompletion(+ "chat-too-big-race",+ requestGeneration,+ [],+ ),+ ).toBe(false);+ });++ it("does not roll back a lifecycle send after its acceptance ACK", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-accepted", "question", undefined, {+ turnId: "turn-accepted",+ });+ const requestGeneration = client.getRunGeneration("chat-accepted");+ lastSocket().fakeMessage({+ event: "message_accepted",+ chat_id: "chat-accepted",+ turn_id: "turn-accepted",+ });++ lastSocket().fakeCloseWithCode(1009);++ expect(+ client.reconcileCanonicalCompletion("chat-accepted", requestGeneration, []),+ ).toBe(false);+ });++ it("preflights exact websocket frame bytes and rejects only the oversized turn", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ maxFrameBytes: 180,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const errors: Array<{ kind: string; chatId?: string; turnId?: string }> = [];+ client.onError((error) => errors.push(error));+ client.connect();+ lastSocket().fakeOpen();+ const sentBefore = lastSocket().sent.length;++ client.sendMessage("chat-preflight-size", "x".repeat(500), undefined, {+ turnId: "turn-preflight-size",+ });++ expect(lastSocket().sent).toHaveLength(sentBefore);+ expect(client.hasUnsettledRun("chat-preflight-size")).toBe(false);+ expect(errors).toEqual([{+ kind: "message_too_big",+ chatId: "chat-preflight-size",+ turnId: "turn-preflight-size",+ }]);+ });++ it("does not attribute a fallback 1009 close across multiple unacknowledged chats", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const errors: Array<{ kind: string; chatId?: string; turnId?: string }> = [];+ client.onError((error) => errors.push(error));+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-size-a", "first", undefined, { turnId: "turn-size-a" });+ client.sendMessage("chat-size-b", "second", undefined, { turnId: "turn-size-b" });++ lastSocket().fakeCloseWithCode(1009);++ expect(errors).toEqual([{ kind: "message_too_big" }]);+ expect(client.hasUnsettledRun("chat-size-a")).toBe(true);+ expect(client.hasUnsettledRun("chat-size-b")).toBe(true);+ });++ it("does not attribute 1009 to an unacknowledged message when another frame followed it", async () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const errors: Array<{ kind: string; chatId?: string; turnId?: string }> = [];+ client.onError((error) => errors.push(error));+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-before-audio", "question", undefined, {+ turnId: "turn-before-audio",+ });+ const transcription = client.transcribeAudio("data:audio/webm;base64,AAAA");++ lastSocket().fakeCloseWithCode(1009);++ await expect(transcription).rejects.toThrow("socket closed");+ expect(errors).toEqual([{ kind: "message_too_big" }]);+ expect(client.hasUnsettledRun("chat-before-audio")).toBe(true);+ });++ it("settles an unknown send absent from an idle canonical snapshot after disconnect", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-never-arrived", "question", undefined, {+ turnId: "turn-never-arrived",+ });+ const requestGeneration = client.getRunGeneration("chat-never-arrived");++ lastSocket().close();++ const snapshot = {+ observedTurnIds: [],+ hasPendingToolCalls: false,+ activeTurnId: null,+ };+ expect(+ client.canReconcileCanonicalCompletion(+ "chat-never-arrived",+ requestGeneration,+ [],+ snapshot,+ ),+ ).toBe(true);+ expect(+ client.reconcileCanonicalCompletion(+ "chat-never-arrived",+ requestGeneration,+ [],+ snapshot,+ ),+ ).toBe(true);+ expect(client.hasUnsettledRun("chat-never-arrived")).toBe(false);+ });++ it("keeps an ACK-lost observed turn active, then settles it from an idle snapshot", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-ack-lost", "question", undefined, {+ turnId: "turn-ack-lost",+ });+ const requestGeneration = client.getRunGeneration("chat-ack-lost");+ lastSocket().close();++ expect(+ client.canReconcileCanonicalCompletion(+ "chat-ack-lost",+ requestGeneration,+ [],+ {+ observedTurnIds: ["turn-ack-lost"],+ hasPendingToolCalls: true,+ activeTurnId: "turn-ack-lost",+ },+ ),+ ).toBe(false);+ expect(+ client.reconcileCanonicalCompletion(+ "chat-ack-lost",+ requestGeneration,+ [],+ {+ observedTurnIds: ["turn-ack-lost"],+ hasPendingToolCalls: false,+ activeTurnId: null,+ },+ ),+ ).toBe(true);+ expect(client.hasUnsettledRun("chat-ack-lost")).toBe(false);+ });++ it("settles an accepted turn that never reached running from canonical idle", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-accepted-idle", "question", undefined, {+ turnId: "turn-accepted-idle",+ });+ const requestGeneration = client.getRunGeneration("chat-accepted-idle");+ lastSocket().fakeMessage({+ event: "message_accepted",+ chat_id: "chat-accepted-idle",+ turn_id: "turn-accepted-idle",+ });++ expect(+ client.reconcileCanonicalCompletion(+ "chat-accepted-idle",+ requestGeneration,+ [],+ {+ observedTurnIds: ["turn-accepted-idle"],+ hasPendingToolCalls: false,+ activeTurnId: null,+ },+ ),+ ).toBe(true);+ expect(client.hasUnsettledRun("chat-accepted-idle")).toBe(false);+ });++ it("does not let a pre-send idle response erase a newly accepted turn", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ const requestGeneration = client.getRunGeneration("chat-stale-idle");+ client.sendMessage("chat-stale-idle", "question", undefined, {+ turnId: "turn-after-request",+ });+ lastSocket().fakeMessage({+ event: "message_accepted",+ chat_id: "chat-stale-idle",+ turn_id: "turn-after-request",+ });++ expect(+ client.reconcileCanonicalCompletion(+ "chat-stale-idle",+ requestGeneration,+ [],+ {+ observedTurnIds: [],+ hasPendingToolCalls: false,+ activeTurnId: null,+ },+ ),+ ).toBe(false);+ expect(client.hasUnsettledRun("chat-stale-idle")).toBe(true);+ });++ it("correlates a legacy rejection only to one currently sent turn", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const errors: Array<{ kind: string; chatId?: string; turnId?: string }> = [];+ client.onError((error) => errors.push(error));+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-legacy-reject", "question", undefined, {+ turnId: "turn-legacy-reject",+ });++ lastSocket().fakeMessage({+ event: "error",+ chat_id: "chat-legacy-reject",+ detail: "message_rejected",+ reason: "text_too_large",+ });++ expect(client.hasUnsettledRun("chat-legacy-reject")).toBe(false);+ expect(errors).toEqual([expect.objectContaining({+ kind: "turn_rejected",+ chatId: "chat-legacy-reject",+ turnId: "turn-legacy-reject",+ })]);+ });++ it("correlates legacy lifecycle completion when exactly one turn is unsettled", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const handler = vi.fn();+ client.onChat("chat-legacy-idle", handler);+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-legacy-idle", "question", undefined, {+ turnId: "turn-legacy-idle",+ });+ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-legacy-idle",+ status: "running",+ started_at: 4321,+ });++ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-legacy-idle",+ status: "idle",+ });++ expect(client.hasUnsettledRun("chat-legacy-idle")).toBe(false);+ expect(client.getRunStartedAt("chat-legacy-idle")).toBeNull();+ expect(handler).toHaveBeenLastCalledWith(expect.objectContaining({+ event: "goal_status",+ status: "idle",+ turn_id: "turn-legacy-idle",+ }));+ });++ it("does not apply an uncorrelated legacy idle to multiple unsettled turns", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const handler = vi.fn();+ client.onChat("chat-legacy-ambiguous", handler);+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-legacy-ambiguous", "first", undefined, {+ turnId: "turn-legacy-first",+ });+ client.sendMessage("chat-legacy-ambiguous", "second", undefined, {+ turnId: "turn-legacy-second",+ });+ handler.mockClear();++ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-legacy-ambiguous",+ status: "idle",+ });++ expect(client.hasUnsettledRun("chat-legacy-ambiguous")).toBe(true);+ expect(handler).not.toHaveBeenCalled();+ });++ it("does not correlate a legacy scope error to an already accepted turn", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const errors: Array<{ kind: string; chatId?: string; turnId?: string }> = [];+ client.onError((error) => errors.push(error));+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-legacy-scope", "question", undefined, {+ turnId: "turn-already-accepted",+ });+ lastSocket().fakeMessage({+ event: "message_accepted",+ chat_id: "chat-legacy-scope",+ turn_id: "turn-already-accepted",+ });++ lastSocket().fakeMessage({+ event: "error",+ chat_id: "chat-legacy-scope",+ detail: "workspace_scope_rejected",+ reason: "chat_running",+ });++ expect(client.hasUnsettledRun("chat-legacy-scope")).toBe(true);+ expect(errors).toEqual([{+ kind: "workspace_scope_rejected",+ reason: "chat_running",+ chatId: "chat-legacy-scope",+ turnId: undefined,+ }]);+ });++ it("does not correlate a scope-control rejection to a preceding unacknowledged message", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-scope-control", "question", undefined, {+ turnId: "turn-before-scope-control",+ });+ client.setWorkspaceScope("chat-scope-control", {+ project_path: "/tmp/project",+ project_name: "project",+ access_mode: "restricted",+ });++ lastSocket().fakeMessage({+ event: "error",+ chat_id: "chat-scope-control",+ detail: "workspace_scope_rejected",+ reason: "chat_running",+ });++ expect(client.hasUnsettledRun("chat-scope-control")).toBe(true);+ });++ it("does not correlate a new-chat scope rejection to an unrelated sent turn", async () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-unrelated-scope", "question", undefined, {+ turnId: "turn-unrelated-scope",+ });+ const pendingChat = client.newChat(5_000, {+ project_path: "/missing",+ project_name: "missing",+ access_mode: "restricted",+ });++ lastSocket().fakeMessage({+ event: "error",+ detail: "workspace_scope_rejected",+ reason: "project_path must be an existing directory",+ });++ await expect(pendingChat).rejects.toThrow("workspace_scope_rejected");+ expect(client.hasUnsettledRun("chat-unrelated-scope")).toBe(true);+ });++ it("rejects a correlated system command instead of leaving it pending", async () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ const pending = client.sendSystemCommand("chat-system-reject", "/model invalid");+ const sent = JSON.parse(lastSocket().sent.at(-1) ?? "{}") as { turn_id?: string };+ expect(sent.turn_id).toMatch(/^webui-system:/);++ lastSocket().fakeMessage({+ event: "error",+ chat_id: "chat-system-reject",+ turn_id: sent.turn_id,+ detail: "message_rejected",+ reason: "invalid_command",+ });++ await expect(pending).rejects.toThrow("message_rejected:invalid_command");+ });++ it("ignores a delayed idle event from an older turn after a new run starts", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const chatHandler = vi.fn();+ const runHandler = vi.fn();+ client.onChat("chat-delayed-idle", chatHandler);+ client.onRunStatus(runHandler);+ client.connect();+ lastSocket().fakeOpen();+ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-delayed-idle",+ status: "running",+ started_at: 1_000,+ turn_id: "turn-old",+ });+ client.sendMessage("chat-delayed-idle", "next question", undefined, {+ turnId: "turn-new",+ });+ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-delayed-idle",+ status: "running",+ started_at: 2_000,+ turn_id: "turn-new",+ });+ chatHandler.mockClear();+ runHandler.mockClear();++ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-delayed-idle",+ status: "idle",+ turn_id: "turn-old",+ });++ expect(client.getRunStartedAt("chat-delayed-idle")).toBe(2_000);+ expect(runHandler).not.toHaveBeenCalled();+ expect(chatHandler).not.toHaveBeenCalled();+ });++ it("accepts a completed snapshot that represents a delayed running frame", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ client.connect();+ lastSocket().fakeOpen();+ const requestGeneration = client.getRunGeneration("chat-delayed-run");++ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-delayed-run",+ status: "running",+ started_at: 12_345,+ turn_id: "turn-complete",+ });++ expect(+ client.reconcileCanonicalCompletion(+ "chat-delayed-run",+ requestGeneration,+ ["turn-complete"],+ ),+ ).toBe(true);+ expect(client.getRunStartedAt("chat-delayed-run")).toBeNull();+ });++ it("preflights canonical completion without fencing or settling the turn", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const chatHandler = vi.fn();+ client.onChat("chat-preflight", chatHandler);+ client.connect();+ lastSocket().fakeOpen();+ client.sendMessage("chat-preflight", "question", undefined, {+ turnId: "turn-preflight",+ });+ const requestGeneration = client.getRunGeneration("chat-preflight");++ expect(+ client.canReconcileCanonicalCompletion(+ "chat-preflight",+ requestGeneration,+ ["turn-preflight"],+ ),+ ).toBe(true);+ expect(+ client.canReconcileCanonicalCompletion("chat-preflight", requestGeneration, []),+ ).toBe(false);++ lastSocket().fakeMessage({+ event: "delta",+ chat_id: "chat-preflight",+ turn_id: "turn-preflight",+ text: "still live",+ });+ expect(chatHandler).toHaveBeenCalledWith(+ expect.objectContaining({ event: "delta", text: "still live" }),+ );+ });++ it("clears the run cache and fences delayed frames after canonical completion", () => {+ const client = new NanobotClient({+ url: "ws://test",+ reconnect: false,+ socketFactory: (url) => new FakeSocket(url) as unknown as WebSocket,+ });+ const chatHandler = vi.fn();+ const runHandler = vi.fn();+ client.onChat("chat-canonical", chatHandler);+ client.onRunStatus(runHandler);+ client.connect();+ lastSocket().fakeOpen();+ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-canonical",+ status: "running",+ started_at: 12_345,+ turn_id: "turn-canonical",+ });+ const requestGeneration = client.getRunGeneration("chat-canonical");++ expect(+ client.reconcileCanonicalCompletion(+ "chat-canonical",+ requestGeneration,+ ["turn-canonical"],+ ),+ ).toBe(true);+ expect(client.getRunStartedAt("chat-canonical")).toBeNull();+ expect(runHandler).toHaveBeenLastCalledWith("chat-canonical", null);+ const deliveredBeforeLateFrames = chatHandler.mock.calls.length;++ lastSocket().fakeMessage({+ event: "delta",+ chat_id: "chat-canonical",+ text: " delayed",+ turn_id: "turn-canonical",+ });+ lastSocket().fakeMessage({+ event: "turn_end",+ chat_id: "chat-canonical",+ turn_id: "turn-canonical",+ });+ lastSocket().fakeMessage({+ event: "goal_status",+ chat_id: "chat-canonical",+ status: "idle",+ turn_id: "turn-canonical",+ });++ expect(chatHandler).toHaveBeenCalledTimes(deliveredBeforeLateFrames);+ expect(client.getRunStartedAt("chat-canonical")).toBeNull();+ });+it("notifies run status subscribers and replays running chats", () => {const client = new NanobotClient({url: "ws://test",diff --git a/webui/src/tests/thread-shell.test.tsx b/webui/src/tests/thread-shell.test.tsxindex 3c2852868..6954bb2b3 100644--- a/webui/src/tests/thread-shell.test.tsx+++ b/webui/src/tests/thread-shell.test.tsx@@ -1,30 +1,103 @@import { act, fireEvent, render, screen, waitFor, within } from "@testing-library/react";-import type { ReactNode } from "react";+import { StrictMode, type ReactNode } from "react";import { beforeEach, describe, expect, it, vi } from "vitest";import { preloadMarkdownText } from "@/components/MarkdownText";import { ThreadCameraController } from "@/components/thread/thread-camera";import { ThreadShell } from "@/components/thread/ThreadShell";import { CLI_APPS_CHANGED_EVENT } from "@/lib/cli-app-events";+import type { CanonicalRunSnapshot } from "@/lib/nanobot-client";import { ClientProvider } from "@/providers/ClientProvider";-import type { CliAppsPayload, SettingsPayload, UIMessage } from "@/lib/types";+import type { CliAppsPayload, ConnectionStatus, SettingsPayload, UIMessage } from "@/lib/types";const HERO_GREETING_PATTERN =/What should we work on\?|Where should we start\?|What are we building today\?|What should we tackle together\?/;function makeClient() {const errorHandlers = new Set<(err: { kind: string }) => void>();+ const statusHandlers = new Set<(status: ConnectionStatus) => void>();const chatHandlers = new Map<string, Set<(ev: import("@/lib/types").InboundEvent) => void>>();const runtimeModelHandlers = new Set<(modelName: string | null, modelPreset?: string | null) => void>();const sessionUpdateHandlers = new Set<(chatId: string, scope?: string) => void>();const runStartedAtByChatId = new Map<string, number>();+ const runGenerationByChatId = new Map<string, number>();+ const latestRunTurnIdByChatId = new Map<string, string>();+ const completedTurnIdsByChatId = new Map<string, Set<string>>();const goalStateByChatId = new Map<string, import("@/lib/types").GoalStateWsPayload>();+ let status: ConnectionStatus = "open";+ const advanceRunGeneration = (chatId: string, turnId?: string) => {+ runGenerationByChatId.set(chatId, (runGenerationByChatId.get(chatId) ?? 0) + 1);+ if (turnId) latestRunTurnIdByChatId.set(chatId, turnId);+ else latestRunTurnIdByChatId.delete(chatId);+ };+ const sendMessage = vi.fn((+ chatId: string,+ _content: string,+ _media?: unknown,+ options?: { turnId?: string; startsNewRun?: boolean },+ ) => {+ if (options?.turnId && options.startsNewRun !== false) {+ advanceRunGeneration(chatId, options.turnId);+ }+ });+ const canReconcileCanonicalCompletion = vi.fn((+ chatId: string,+ expectedRunGeneration: number,+ completedTurnIds: readonly string[],+ snapshot?: CanonicalRunSnapshot,+ ) => {+ const existingFences = completedTurnIdsByChatId.get(chatId);+ const prospectiveFences = new Set(completedTurnIds);+ const observedTurnIds = new Set(snapshot?.observedTurnIds ?? []);+ const isRepresented = (turnId: string) => (+ prospectiveFences.has(turnId)+ || existingFences?.has(turnId) === true+ || (+ snapshot?.hasPendingToolCalls === false+ && observedTurnIds.has(turnId)+ )+ );+ const currentGeneration = runGenerationByChatId.get(chatId) ?? 0;+ const latestTurnId = latestRunTurnIdByChatId.get(chatId);+ return (+ currentGeneration === expectedRunGeneration+ || (typeof latestTurnId === "string" && isRepresented(latestTurnId))+ );+ });+ const reconcileCanonicalCompletion = vi.fn((+ chatId: string,+ expectedRunGeneration: number,+ completedTurnIds: readonly string[],+ snapshot?: CanonicalRunSnapshot,+ ) => {+ if (!canReconcileCanonicalCompletion(+ chatId,+ expectedRunGeneration,+ completedTurnIds,+ snapshot,+ )) {+ return false;+ }+ const fences = completedTurnIdsByChatId.get(chatId) ?? new Set<string>();+ for (const turnId of completedTurnIds) fences.add(turnId);+ completedTurnIdsByChatId.set(chatId, fences);+ runStartedAtByChatId.delete(chatId);+ return true;+ });return {- status: "open" as const,+ get status() {+ return status;+ },defaultChatId: null as string | null,- onStatus: () => () => {},+ onStatus: (handler: (nextStatus: ConnectionStatus) => void) => {+ statusHandlers.add(handler);+ handler(status);+ return () => {+ statusHandlers.delete(handler);+ };+ },onRuntimeModelUpdate: (handler: (modelName: string | null, modelPreset?: string | null) => void,) => {@@ -34,6 +107,9 @@ function makeClient() {};},getRunStartedAt: (chatId: string) => runStartedAtByChatId.get(chatId) ?? null,+ getRunGeneration: (chatId: string) => runGenerationByChatId.get(chatId) ?? 0,+ canReconcileCanonicalCompletion,+ reconcileCanonicalCompletion,getGoalState: (chatId: string) => goalStateByChatId.get(chatId),onChat: (chatId: string, handler: (ev: import("@/lib/types").InboundEvent) => void) => {let handlers = chatHandlers.get(chatId);@@ -61,12 +137,19 @@ function makeClient() {_emitError(err: { kind: string }) {for (const h of errorHandlers) h(err);},+ _emitStatus(nextStatus: ConnectionStatus) {+ status = nextStatus;+ for (const h of statusHandlers) h(status);+ },_emitChat(chatId: string, ev: import("@/lib/types").InboundEvent) {+ const turnId = "turn_id" in ev && typeof ev.turn_id === "string" ? ev.turn_id : null;+ if (turnId && completedTurnIdsByChatId.get(chatId)?.has(turnId)) return;if (ev.event === "goal_status"&& ev.status === "running"&& typeof ev.started_at === "number") {+ advanceRunGeneration(chatId, ev.turn_id);runStartedAtByChatId.set(chatId, ev.started_at);} else if ((ev.event === "goal_status" && ev.status === "idle")@@ -85,7 +168,7 @@ function makeClient() {_emitSessionUpdate(chatId: string, scope?: string) {for (const h of sessionUpdateHandlers) h(chatId, scope);},- sendMessage: vi.fn(),+ sendMessage,sendSystemCommand: vi.fn().mockResolvedValue(undefined),newChat: vi.fn(),forkChat: vi.fn(),@@ -135,7 +218,7 @@ function session(chatId: string, modelPreset?: string | null) {}function transcriptFromSimpleMessages(- rows: Array<{ role: "user" | "assistant"; content: string }>,+ rows: Array<{ role: "user" | "assistant"; content: string; turnId?: string }>,): { schemaVersion: number; messages: UIMessage[] } {return {schemaVersion: 3,@@ -143,6 +226,7 @@ function transcriptFromSimpleMessages(id: `m-${i}`,role: m.role,content: m.content,+ ...(m.turnId ? { turnId: m.turnId } : {}),createdAt: 1000 + i,})),};@@ -1495,6 +1579,1215 @@ describe("ThreadShell", () => {expect(screen.getByText("second fork question")).toBeInTheDocument();});+ it("recovers a truncated streamed answer after reconnecting", async () => {+ const client = makeClient();+ let historyCalls = 0;+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ const url = String(input);+ if (url.includes("websocket%3Aresume-chat/webui-thread")) {+ historyCalls += 1;+ return httpJson(+ transcriptFromSimpleMessages(+ historyCalls === 1+ ? [{ role: "user", content: "question" }]+ : [+ { role: "user", content: "question" },+ { role: "assistant", content: "partial answer completed while away" },+ ],+ ),+ );+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );++ render(+ wrap(+ client,+ <ThreadShell+ session={session("resume-chat")}+ title="Resume chat"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() => expect(screen.getByText("question")).toBeInTheDocument());+ act(() => {+ client._emitChat("resume-chat", {+ event: "goal_status",+ chat_id: "resume-chat",+ status: "running",+ started_at: 1_700,+ });+ client._emitChat("resume-chat", {+ event: "delta",+ chat_id: "resume-chat",+ text: "partial answer",+ });+ });+ await waitFor(() => expect(screen.getByText("partial answer")).toBeInTheDocument());+ expect(screen.getByRole("button", { name: "Stop response" })).toBeInTheDocument();+ expect(historyCalls).toBe(1);++ act(() => client._emitStatus("reconnecting"));+ expect(screen.getByRole("button", { name: "Stop response" })).toBeInTheDocument();+ act(() => client._emitStatus("open"));++ await waitFor(() => expect(historyCalls).toBe(2));+ await waitFor(() =>+ expect(screen.getByText("partial answer completed while away")).toBeInTheDocument(),+ );+ expect(screen.queryByText("partial answer")).not.toBeInTheDocument();+ expect(screen.queryByRole("button", { name: "Stop response" })).not.toBeInTheDocument();+ });++ it("refreshes after opening when mounted while the socket is reconnecting", async () => {+ const client = makeClient();+ client._emitStatus("reconnecting");+ let historyCalls = 0;+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ if (String(input).includes("websocket%3Amount-during-reconnect/webui-thread")) {+ historyCalls += 1;+ return httpJson(transcriptFromSimpleMessages(+ historyCalls === 1+ ? [{ role: "user", content: "question before reconnect" }]+ : [+ { role: "user", content: "question before reconnect" },+ { role: "assistant", content: "answer completed before open" },+ ],+ ));+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );++ render(+ wrap(+ client,+ <ThreadShell+ session={session("mount-during-reconnect")}+ title="Mount during reconnect"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() => expect(screen.getByText("question before reconnect")).toBeInTheDocument());+ expect(historyCalls).toBe(1);++ act(() => client._emitStatus("open"));++ await waitFor(() => expect(historyCalls).toBe(2));+ await waitFor(() =>+ expect(screen.getByText("answer completed before open")).toBeInTheDocument(),+ );+ });++ it("adopts a disjoint authoritative latest-window reset after overlap falls out", async () => {+ const client = makeClient();+ let historyCalls = 0;+ const canonicalTurnId = "turn-new-window";+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ if (String(input).includes("websocket%3Awindow-reset-chat/webui-thread")) {+ historyCalls += 1;+ return httpJson({+ ...transcriptFromSimpleMessages(+ historyCalls === 1+ ? [+ {+ role: "assistant",+ content: "row from the expired latest window",+ turnId: "turn-old-window",+ },+ ]+ : [+ {+ role: "user",+ content: "question in the new latest window",+ turnId: canonicalTurnId,+ },+ {+ role: "assistant",+ content: "answer in the new latest window",+ turnId: canonicalTurnId,+ },+ ],+ ),+ has_pending_tool_calls: false,+ });+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );++ render(+ wrap(+ client,+ <ThreadShell+ session={session("window-reset-chat")}+ title="Window reset"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() =>+ expect(screen.getByText("row from the expired latest window")).toBeInTheDocument(),+ );++ act(() => document.dispatchEvent(new Event("visibilitychange")));++ await waitFor(() =>+ expect(screen.getByText("answer in the new latest window")).toBeInTheDocument(),+ );+ expect(screen.queryByText("row from the expired latest window")).not.toBeInTheDocument();+ expect(client.reconcileCanonicalCompletion).toHaveBeenCalledWith(+ "window-reset-chat",+ expect.any(Number),+ expect.arrayContaining([canonicalTurnId]),+ {+ observedTurnIds: [canonicalTurnId],+ hasPendingToolCalls: false,+ activeTurnId: null,+ },+ );+ });++ it("recovers an uncommitted reset lineage on the next foreground hydrate", async () => {+ const client = makeClient();+ let chatACalls = 0;+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ const url = String(input);+ if (url.includes("websocket%3Alineage-chat-a/webui-thread")) {+ chatACalls += 1;+ return httpJson({+ ...transcriptFromSimpleMessages(+ chatACalls === 1+ ? [{ role: "assistant", content: "committed old lineage" }]+ : [{ role: "assistant", content: "disjoint new lineage" }],+ ),+ has_pending_tool_calls: false,+ });+ }+ if (url.includes("websocket%3Alineage-chat-b/webui-thread")) {+ return httpJson(transcriptFromSimpleMessages([+ { role: "assistant", content: "other lineage chat" },+ ]));+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );+ const view = (chatId: string) => wrap(+ client,+ <ThreadShell+ session={session(chatId)}+ title={`Chat ${chatId}`}+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ );+ const { rerender } = render(view("lineage-chat-a"));++ await waitFor(() => expect(screen.getByText("committed old lineage")).toBeInTheDocument());+ rerender(view("lineage-chat-b"));+ await waitFor(() => expect(screen.getByText("other lineage chat")).toBeInTheDocument());+ rerender(view("lineage-chat-a"));+ await waitFor(() => expect(chatACalls).toBe(2));++ expect(screen.getByText("committed old lineage")).toBeInTheDocument();+ expect(screen.queryByText("disjoint new lineage")).not.toBeInTheDocument();++ act(() => document.dispatchEvent(new Event("visibilitychange")));++ await waitFor(() => expect(chatACalls).toBe(3));+ await waitFor(() => expect(screen.getByText("disjoint new lineage")).toBeInTheDocument());+ expect(screen.queryByText("committed old lineage")).not.toBeInTheDocument();+ });++ it("does not reset away a durable UI tail that arrives after the request", async () => {+ const client = makeClient();+ let historyCalls = 0;+ let resolveRefresh:+ | ((value: ReturnType<typeof httpJson>) => void)+ | null = null;+ vi.stubGlobal(+ "fetch",+ vi.fn((input: RequestInfo | URL) => {+ if (!String(input).includes("websocket%3Areset-tail-race/webui-thread")) {+ return Promise.resolve({+ ok: false,+ status: 404,+ json: async () => ({}),+ });+ }+ historyCalls += 1;+ if (historyCalls === 1) {+ return Promise.resolve(httpJson(transcriptFromSimpleMessages([+ { role: "assistant", content: "old canonical row" },+ ])));+ }+ return new Promise((resolve) => {+ resolveRefresh = resolve;+ });+ }),+ );++ render(+ wrap(+ client,+ <ThreadShell+ session={session("reset-tail-race")}+ title="Reset tail race"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() => expect(screen.getByText("old canonical row")).toBeInTheDocument());+ act(() => document.dispatchEvent(new Event("visibilitychange")));+ await waitFor(() => expect(historyCalls).toBe(2));++ act(() => {+ client._emitChat("reset-tail-race", {+ event: "message",+ chat_id: "reset-tail-race",+ text: "local durable row after request",+ });+ });+ await waitFor(() =>+ expect(screen.getByText("local durable row after request")).toBeInTheDocument(),+ );++ await act(async () => {+ resolveRefresh?.(httpJson({+ ...transcriptFromSimpleMessages([+ { role: "assistant", content: "disjoint canonical reset row" },+ ]),+ has_pending_tool_calls: false,+ }));+ await Promise.resolve();+ });++ expect(screen.getByText("old canonical row")).toBeInTheDocument();+ expect(screen.getByText("local durable row after request")).toBeInTheDocument();+ expect(screen.queryByText("disjoint canonical reset row")).not.toBeInTheDocument();+ });++ it("safely commits an empty canonical reset for a rejected local turn", async () => {+ const client = makeClient();+ let historyCalls = 0;+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ if (String(input).includes("websocket%3Aempty-reset-chat/webui-thread")) {+ historyCalls += 1;+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );++ render(+ wrap(+ client,+ <ThreadShell+ session={session("empty-reset-chat")}+ title="Empty reset"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() => expect(historyCalls).toBe(1));+ const input = screen.getByRole("textbox", { name: "Message input" });+ fireEvent.change(input, { target: { value: "rejected local turn" } });+ fireEvent.click(screen.getByRole("button", { name: "Send message" }));+ await waitFor(() => expect(screen.getByText("rejected local turn")).toBeInTheDocument());++ act(() => document.dispatchEvent(new Event("visibilitychange")));++ await waitFor(() => expect(historyCalls).toBe(2));+ await waitFor(() =>+ expect(screen.queryByText("rejected local turn")).not.toBeInTheDocument(),+ );+ expect(client.reconcileCanonicalCompletion).toHaveBeenCalledWith(+ "empty-reset-chat",+ expect.any(Number),+ [],+ {+ observedTurnIds: [],+ hasPendingToolCalls: false,+ activeTurnId: null,+ },+ );+ });++ it("runs canonical reconciliation once when React replays state calculations", async () => {+ const client = makeClient();+ const turnId = "turn-strict-canonical";+ let canonicalComplete = false;+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ if (String(input).includes("websocket%3Astrict-canonical/webui-thread")) {+ return httpJson({+ ...transcriptFromSimpleMessages(+ canonicalComplete+ ? [+ { role: "user", content: "strict question", turnId },+ { role: "assistant", content: "strict canonical answer", turnId },+ ]+ : [{ role: "user", content: "strict question", turnId }],+ ),+ has_pending_tool_calls: !canonicalComplete,+ });+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );++ render(+ wrap(+ client,+ <StrictMode>+ <ThreadShell+ session={session("strict-canonical")}+ title="Strict canonical"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />+ </StrictMode>,+ ),+ );++ await waitFor(() => expect(screen.getByText("strict question")).toBeInTheDocument());+ act(() => {+ client._emitChat("strict-canonical", {+ event: "goal_status",+ chat_id: "strict-canonical",+ status: "running",+ started_at: 2_100,+ turn_id: turnId,+ });+ client._emitChat("strict-canonical", {+ event: "delta",+ chat_id: "strict-canonical",+ text: "strict partial",+ turn_id: turnId,+ });+ });+ await waitFor(() => expect(screen.getByText("strict partial")).toBeInTheDocument());+ client.reconcileCanonicalCompletion.mockClear();+ const reconcileAfterCommit = client.reconcileCanonicalCompletion.getMockImplementation();+ client.reconcileCanonicalCompletion.mockImplementation((...args) => {+ expect(screen.getByText("strict canonical answer")).toBeInTheDocument();+ return reconcileAfterCommit?.(...args) ?? false;+ });+ canonicalComplete = true;++ act(() => document.dispatchEvent(new Event("visibilitychange")));++ await waitFor(() => expect(screen.getByText("strict canonical answer")).toBeInTheDocument());+ expect(client.reconcileCanonicalCompletion).toHaveBeenCalledTimes(1);+ expect(client.canReconcileCanonicalCompletion).toHaveBeenCalled();+ });++ it("rolls back a committed candidate when the final lifecycle recheck loses", async () => {+ const client = makeClient();+ const turnId = "turn-layout-recheck";+ let historyCalls = 0;+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ if (String(input).includes("websocket%3Alayout-recheck/webui-thread")) {+ historyCalls += 1;+ return httpJson({+ ...transcriptFromSimpleMessages(+ historyCalls === 1+ ? [{ role: "user", content: "layout question", turnId }]+ : [+ { role: "user", content: "layout question", turnId },+ { role: "assistant", content: "layout canonical answer", turnId },+ ],+ ),+ has_pending_tool_calls: historyCalls === 1,+ });+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );++ render(+ wrap(+ client,+ <ThreadShell+ session={session("layout-recheck")}+ title="Layout recheck"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() => expect(screen.getByText("layout question")).toBeInTheDocument());+ act(() => {+ client._emitChat("layout-recheck", {+ event: "goal_status",+ chat_id: "layout-recheck",+ status: "running",+ started_at: 2_200,+ turn_id: turnId,+ });+ client._emitChat("layout-recheck", {+ event: "delta",+ chat_id: "layout-recheck",+ text: "layout partial",+ turn_id: turnId,+ });+ });+ await waitFor(() => expect(screen.getByText("layout partial")).toBeInTheDocument());++ const reconcileAfterReject = client.reconcileCanonicalCompletion.getMockImplementation();+ client.reconcileCanonicalCompletion+ .mockImplementationOnce(() => false)+ .mockImplementation((...args) => reconcileAfterReject?.(...args) ?? false);++ act(() => document.dispatchEvent(new Event("visibilitychange")));++ await waitFor(() => expect(historyCalls).toBe(2));+ await waitFor(() =>+ expect(client.reconcileCanonicalCompletion).toHaveBeenCalledTimes(1),+ );+ expect(screen.getByText("layout partial")).toBeInTheDocument();+ expect(screen.queryByText("layout canonical answer")).not.toBeInTheDocument();+ expect(screen.getByRole("button", { name: "Stop response" })).toBeInTheDocument();++ act(() => document.dispatchEvent(new Event("visibilitychange")));++ await waitFor(() => expect(historyCalls).toBe(3));+ await waitFor(() => expect(screen.getByText("layout canonical answer")).toBeInTheDocument());+ expect(screen.queryByText("layout partial")).not.toBeInTheDocument();+ expect(client.reconcileCanonicalCompletion).toHaveBeenCalledTimes(2);+ });++ it("accepts the first reconnect refresh after switching away and back", async () => {+ const client = makeClient();+ const oldTurnId = "turn-old";+ let newTurnId = "";+ let chatACalls = 0;+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ const url = String(input);+ if (url.includes("websocket%3Achat-version-a/webui-thread")) {+ chatACalls += 1;+ const rows = chatACalls <= 2+ ? [+ { role: "user" as const, content: "old question", turnId: oldTurnId },+ { role: "assistant" as const, content: "old answer", turnId: oldTurnId },+ ]+ : [+ { role: "user" as const, content: "old question", turnId: oldTurnId },+ { role: "assistant" as const, content: "old answer", turnId: oldTurnId },+ { role: "user" as const, content: "new question", turnId: newTurnId },+ {+ role: "assistant" as const,+ content: "partial answer completed",+ turnId: newTurnId,+ },+ ];+ return httpJson({+ ...transcriptFromSimpleMessages(rows),+ has_pending_tool_calls: false,+ });+ }+ if (url.includes("websocket%3Achat-version-b/webui-thread")) {+ return httpJson(transcriptFromSimpleMessages([+ { role: "user", content: "other chat" },+ ]));+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );+ const view = (chatId: string) => wrap(+ client,+ <ThreadShell+ session={session(chatId)}+ title={`Chat ${chatId}`}+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ );+ const { rerender } = render(view("chat-version-a"));++ await waitFor(() => expect(screen.getByText("old answer")).toBeInTheDocument());+ act(() => client._emitSessionUpdate("chat-version-a"));+ await waitFor(() => expect(chatACalls).toBe(2));++ fireEvent.change(screen.getByRole("textbox", { name: "Message input" }), {+ target: { value: "new question" },+ });+ fireEvent.click(screen.getByRole("button", { name: "Send message" }));+ await waitFor(() => expect(client.sendMessage).toHaveBeenCalledTimes(1));+ newTurnId = (+ client.sendMessage.mock.calls[0]?.[3] as { turnId?: string } | undefined+ )?.turnId ?? "";+ expect(newTurnId).not.toBe("");+ act(() => {+ client._emitChat("chat-version-a", {+ event: "goal_status",+ chat_id: "chat-version-a",+ status: "running",+ started_at: 2_000,+ turn_id: newTurnId,+ });+ client._emitChat("chat-version-a", {+ event: "delta",+ chat_id: "chat-version-a",+ text: "partial answer",+ turn_id: newTurnId,+ });+ });+ await waitFor(() => expect(screen.getByText("partial answer")).toBeInTheDocument());++ rerender(view("chat-version-b"));+ await waitFor(() => expect(screen.getByText("other chat")).toBeInTheDocument());+ rerender(view("chat-version-a"));+ await waitFor(() => expect(chatACalls).toBe(3));+ expect(screen.getByText("partial answer")).toBeInTheDocument();+ expect(screen.queryByText("partial answer completed")).not.toBeInTheDocument();++ act(() => client._emitStatus("reconnecting"));+ act(() => client._emitStatus("open"));++ await waitFor(() => expect(chatACalls).toBe(4));+ await waitFor(() =>+ expect(screen.getByText("partial answer completed")).toBeInTheDocument(),+ );+ expect(screen.queryByText("partial answer")).not.toBeInTheDocument();+ expect(screen.queryByRole("button", { name: "Stop response" })).not.toBeInTheDocument();+ });++ it("does not let an older completed snapshot clear a run that starts in flight", async () => {+ const client = makeClient();+ const oldTurnId = "turn-before-refresh";+ let historyCalls = 0;+ let resolveRefresh:+ | ((value: { ok: boolean; status: number; json: () => Promise<unknown> }) => void)+ | null = null;+ vi.stubGlobal(+ "fetch",+ vi.fn((input: RequestInfo | URL) => {+ const url = String(input);+ if (!url.includes("websocket%3Arun-generation-chat/webui-thread")) {+ return Promise.resolve({+ ok: false,+ status: 404,+ json: async () => ({}),+ });+ }+ historyCalls += 1;+ if (historyCalls === 1) {+ return Promise.resolve(httpJson(transcriptFromSimpleMessages([+ { role: "user", content: "old question", turnId: oldTurnId },+ { role: "assistant", content: "old answer", turnId: oldTurnId },+ ])));+ }+ return new Promise((resolve) => {+ resolveRefresh = resolve;+ });+ }),+ );++ render(+ wrap(+ client,+ <ThreadShell+ session={session("run-generation-chat")}+ title="Run generation chat"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() => expect(screen.getByText("old answer")).toBeInTheDocument());+ act(() => document.dispatchEvent(new Event("visibilitychange")));+ await waitFor(() => expect(historyCalls).toBe(2));++ const newTurnId = "turn-started-during-refresh";+ act(() => {+ client._emitChat("run-generation-chat", {+ event: "goal_status",+ chat_id: "run-generation-chat",+ status: "running",+ started_at: 3_000,+ turn_id: newTurnId,+ });+ });+ const input = screen.getByRole("textbox", { name: "Message input" });+ fireEvent.change(input, { target: { value: "queued for the new run" } });+ fireEvent.keyDown(input, { key: "Enter" });+ expect(client.sendMessage).not.toHaveBeenCalled();++ await act(async () => {+ resolveRefresh?.(httpJson({+ ...transcriptFromSimpleMessages([+ { role: "user", content: "old question", turnId: oldTurnId },+ { role: "assistant", content: "old answer", turnId: oldTurnId },+ ]),+ has_pending_tool_calls: false,+ }));+ await Promise.resolve();+ });++ expect(screen.getByRole("button", { name: "Stop response" })).toBeInTheDocument();+ expect(client.sendMessage).not.toHaveBeenCalled();+ });++ it("fences websocket frames that arrive after canonical completion", async () => {+ const client = makeClient();+ const turnId = "turn-http-won";+ let historyCalls = 0;+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ const url = String(input);+ if (url.includes("websocket%3Alate-frame-chat/webui-thread")) {+ historyCalls += 1;+ return httpJson({+ ...transcriptFromSimpleMessages(+ historyCalls === 1+ ? [{ role: "user", content: "question", turnId }]+ : [+ { role: "user", content: "question", turnId },+ { role: "assistant", content: "canonical complete answer", turnId },+ ],+ ),+ has_pending_tool_calls: false,+ });+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );++ render(+ wrap(+ client,+ <ThreadShell+ session={session("late-frame-chat")}+ title="Late frame chat"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() => expect(screen.getByText("question")).toBeInTheDocument());+ act(() => {+ client._emitChat("late-frame-chat", {+ event: "goal_status",+ chat_id: "late-frame-chat",+ status: "running",+ started_at: 4_000,+ turn_id: turnId,+ });+ client._emitChat("late-frame-chat", {+ event: "delta",+ chat_id: "late-frame-chat",+ text: "partial",+ turn_id: turnId,+ });+ });+ await waitFor(() => expect(screen.getByText("partial")).toBeInTheDocument());++ act(() => document.dispatchEvent(new Event("visibilitychange")));+ await waitFor(() =>+ expect(screen.getByText("canonical complete answer")).toBeInTheDocument(),+ );++ act(() => {+ client._emitChat("late-frame-chat", {+ event: "delta",+ chat_id: "late-frame-chat",+ text: " delayed duplicate",+ turn_id: turnId,+ });+ client._emitChat("late-frame-chat", {+ event: "turn_end",+ chat_id: "late-frame-chat",+ turn_id: turnId,+ });+ client._emitSessionUpdate("late-frame-chat");+ });++ await waitFor(() => expect(historyCalls).toBe(3));+ expect(screen.getAllByText("canonical complete answer")).toHaveLength(1);+ expect(screen.queryByText(" delayed duplicate")).not.toBeInTheDocument();+ expect(screen.queryByText("canonical complete answer delayed duplicate")).not.toBeInTheDocument();+ expect(screen.queryByRole("button", { name: "Stop response" })).not.toBeInTheDocument();+ });++ it("does not revive a canonically completed run after switching chats", async () => {+ const client = makeClient();+ const turnId = "turn-visibility-complete";+ let chatACalls = 0;+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ const url = String(input);+ if (url.includes("websocket%3Avisibility-complete-a/webui-thread")) {+ chatACalls += 1;+ return httpJson({+ ...transcriptFromSimpleMessages(+ chatACalls === 1+ ? [{ role: "user", content: "question", turnId }]+ : [+ { role: "user", content: "question", turnId },+ { role: "assistant", content: "completed while hidden", turnId },+ ],+ ),+ has_pending_tool_calls: false,+ });+ }+ if (url.includes("websocket%3Avisibility-complete-b/webui-thread")) {+ return httpJson(transcriptFromSimpleMessages([+ { role: "user", content: "other thread" },+ ]));+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );+ const view = (chatId: string) => wrap(+ client,+ <ThreadShell+ session={session(chatId)}+ title={`Chat ${chatId}`}+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ );+ const { rerender } = render(view("visibility-complete-a"));++ await waitFor(() => expect(screen.getByText("question")).toBeInTheDocument());+ act(() => {+ client._emitChat("visibility-complete-a", {+ event: "goal_status",+ chat_id: "visibility-complete-a",+ status: "running",+ started_at: 5_000,+ turn_id: turnId,+ });+ });+ expect(screen.getByRole("button", { name: "Stop response" })).toBeInTheDocument();++ act(() => document.dispatchEvent(new Event("visibilitychange")));+ await waitFor(() => expect(screen.getByText("completed while hidden")).toBeInTheDocument());+ expect(screen.queryByRole("button", { name: "Stop response" })).not.toBeInTheDocument();+ expect(client.getRunStartedAt("visibility-complete-a")).toBeNull();++ rerender(view("visibility-complete-b"));+ await waitFor(() => expect(screen.getByText("other thread")).toBeInTheDocument());+ rerender(view("visibility-complete-a"));+ await waitFor(() => expect(screen.getByText("completed while hidden")).toBeInTheDocument());+ expect(screen.queryByRole("button", { name: "Stop response" })).not.toBeInTheDocument();+ });++ it("uses explicit completion ids when a completed turn has no assistant row", async () => {+ const client = makeClient();+ const turnId = "turn-empty-answer";+ let historyCalls = 0;+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ if (String(input).includes("websocket%3Aempty-answer/webui-thread")) {+ historyCalls += 1;+ return httpJson({+ ...transcriptFromSimpleMessages([+ { role: "user", content: "stop", turnId },+ ]),+ has_pending_tool_calls: historyCalls === 1,+ completed_turn_ids: historyCalls === 1 ? [] : [turnId],+ });+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );+ render(+ wrap(+ client,+ <ThreadShell+ session={session("empty-answer")}+ title="Empty answer"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() => expect(screen.getByText("stop")).toBeInTheDocument());+ act(() => {+ client._emitChat("empty-answer", {+ event: "goal_status",+ chat_id: "empty-answer",+ status: "running",+ started_at: 5_000,+ turn_id: turnId,+ });+ });+ expect(screen.getByRole("button", { name: "Stop response" })).toBeInTheDocument();++ act(() => document.dispatchEvent(new Event("visibilitychange")));++ await waitFor(() => expect(historyCalls).toBe(2));+ await waitFor(() => expect(client.reconcileCanonicalCompletion).toHaveBeenCalledWith(+ "empty-answer",+ expect.any(Number),+ expect.arrayContaining([turnId]),+ expect.objectContaining({+ observedTurnIds: [turnId],+ hasPendingToolCalls: false,+ }),+ ));+ expect(screen.queryByRole("button", { name: "Stop response" })).not.toBeInTheDocument();+ });++ it("converges after reconnecting before the first assistant delta", async () => {+ const client = makeClient();+ let historyCalls = 0;+ const turnId = "turn-resume-before-delta";+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ const url = String(input);+ if (url.includes("websocket%3Abefore-delta-chat/webui-thread")) {+ historyCalls += 1;+ const transcript = transcriptFromSimpleMessages(+ historyCalls === 1+ ? [{ role: "user", content: "question", turnId }]+ : [+ { role: "user", content: "question", turnId },+ {+ role: "assistant",+ content: historyCalls === 2+ ? "missed prefix"+ : "missed prefix resumed suffix",+ turnId,+ },+ ],+ );+ return httpJson({+ ...transcript,+ has_pending_tool_calls: historyCalls === 2,+ });+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );++ render(+ wrap(+ client,+ <ThreadShell+ session={session("before-delta-chat")}+ title="Before delta chat"+ onToggleSidebar={() => {}}+ onGoHome={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() => expect(screen.getByText("question")).toBeInTheDocument());+ act(() => {+ client._emitChat("before-delta-chat", {+ event: "goal_status",+ chat_id: "before-delta-chat",+ status: "running",+ started_at: 1_700,+ turn_id: turnId,+ });+ });+ const input = screen.getByRole("textbox", { name: "Message input" });+ fireEvent.change(input, { target: { value: "queued guidance" } });+ fireEvent.keyDown(input, { key: "Enter" });+ expect(client.sendMessage).not.toHaveBeenCalled();++ act(() => client._emitStatus("reconnecting"));+ act(() => client._emitStatus("open"));+ await waitFor(() => expect(historyCalls).toBe(2));+ expect(screen.queryByText("missed prefix")).not.toBeInTheDocument();+ expect(screen.getByRole("button", { name: "Stop response" })).toBeInTheDocument();+ expect(client.sendMessage).not.toHaveBeenCalled();++ act(() => {+ client._emitChat("before-delta-chat", {+ event: "delta",+ chat_id: "before-delta-chat",+ text: "resumed suffix",+ turn_id: turnId,+ });+ });+ await waitFor(() => expect(screen.getByText("resumed suffix")).toBeInTheDocument());++ act(() => client._emitStatus("reconnecting"));+ act(() => client._emitStatus("open"));+ await waitFor(() => expect(historyCalls).toBe(3));+ await waitFor(() =>+ expect(screen.getByText("missed prefix resumed suffix")).toBeInTheDocument(),+ );+ expect(screen.queryByText("resumed suffix")).not.toBeInTheDocument();+ await waitFor(() => expectSendMessageWithTurn(+ client,+ "before-delta-chat",+ "queued guidance",+ ));+ });++ it("keeps the live answer cursor when a resumed turn is still running", async () => {+ const client = makeClient();+ let historyCalls = 0;+ const turnId = "turn-active-resume";+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ const url = String(input);+ if (url.includes("websocket%3Aactive-resume-chat/webui-thread")) {+ historyCalls += 1;+ const transcript = transcriptFromSimpleMessages(+ historyCalls === 1+ ? [{ role: "user", content: "question", turnId }]+ : [+ { role: "user", content: "question", turnId },+ {+ role: "assistant",+ content: historyCalls === 2+ ? "partial answer missed"+ : "partial answer missed resumed",+ turnId,+ },+ ],+ );+ return httpJson(+ historyCalls === 1+ ? transcript+ : { ...transcript, has_pending_tool_calls: historyCalls === 2 },+ );+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );++ render(+ wrap(+ client,+ <ThreadShell+ session={session("active-resume-chat")}+ title="Active resume chat"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );++ await waitFor(() => expect(screen.getByText("question")).toBeInTheDocument());+ act(() => {+ client._emitChat("active-resume-chat", {+ event: "goal_status",+ chat_id: "active-resume-chat",+ status: "running",+ started_at: 1_700,+ turn_id: turnId,+ });+ client._emitChat("active-resume-chat", {+ event: "delta",+ chat_id: "active-resume-chat",+ text: "partial answer",+ turn_id: turnId,+ });+ });+ await waitFor(() => expect(screen.getByText("partial answer")).toBeInTheDocument());+ const input = screen.getByRole("textbox", { name: "Message input" });+ fireEvent.change(input, { target: { value: "queued guidance" } });+ fireEvent.keyDown(input, { key: "Enter" });+ expect(screen.getByText("queued guidance")).toBeInTheDocument();+ expect(client.sendMessage).not.toHaveBeenCalled();++ act(() => client._emitStatus("reconnecting"));+ expect(client.sendMessage).not.toHaveBeenCalled();+ act(() => client._emitStatus("open"));+ await waitFor(() => expect(historyCalls).toBe(2));+ expect(client.sendMessage).not.toHaveBeenCalled();++ act(() => {+ client._emitChat("active-resume-chat", {+ event: "delta",+ chat_id: "active-resume-chat",+ text: " resumed",+ turn_id: turnId,+ });+ });++ await waitFor(() => expect(screen.getByText("partial answer resumed")).toBeInTheDocument());+ expect(screen.queryByText(" resumed")).not.toBeInTheDocument();+ expect(client.sendMessage).not.toHaveBeenCalled();++ act(() => client._emitStatus("reconnecting"));+ expect(client.sendMessage).not.toHaveBeenCalled();+ act(() => client._emitStatus("open"));++ await waitFor(() => expect(historyCalls).toBe(3));+ await waitFor(() =>+ expect(screen.getByText("partial answer missed resumed")).toBeInTheDocument(),+ );+ expect(screen.queryByText("partial answer resumed")).not.toBeInTheDocument();+ await waitFor(() => expectSendMessageWithTurn(+ client,+ "active-resume-chat",+ "queued guidance",+ ));+ });++ it("refreshes the current thread when the page returns to the foreground", async () => {+ const client = makeClient();+ let historyCalls = 0;+ const visibilityDescriptor = Object.getOwnPropertyDescriptor(document, "visibilityState");+ vi.stubGlobal(+ "fetch",+ vi.fn(async (input: RequestInfo | URL) => {+ const url = String(input);+ if (url.includes("websocket%3Avisible-chat/webui-thread")) {+ historyCalls += 1;+ return httpJson(+ transcriptFromSimpleMessages(+ historyCalls === 1+ ? [{ role: "user", content: "question" }]+ : [+ { role: "user", content: "question" },+ { role: "assistant", content: "answer completed in background" },+ ],+ ),+ );+ }+ return {+ ok: false,+ status: 404,+ json: async () => ({}),+ };+ }),+ );++ try {+ render(+ wrap(+ client,+ <ThreadShell+ session={session("visible-chat")}+ title="Visible chat"+ onToggleSidebar={() => {}}+ onNewChat={() => {}}+ />,+ ),+ );+ await waitFor(() => expect(screen.getByText("question")).toBeInTheDocument());+ expect(historyCalls).toBe(1);++ act(() => {+ Object.defineProperty(document, "visibilityState", {+ configurable: true,+ value: "hidden",+ });+ document.dispatchEvent(new Event("visibilitychange"));+ });+ expect(historyCalls).toBe(1);++ await act(async () => {+ Object.defineProperty(document, "visibilityState", {+ configurable: true,+ value: "visible",+ });+ document.dispatchEvent(new Event("visibilitychange"));+ await Promise.resolve();+ });++ await waitFor(() => expect(historyCalls).toBe(2));+ await waitFor(() =>+ expect(screen.getByText("answer completed in background")).toBeInTheDocument(),+ );+ } finally {+ if (visibilityDescriptor) {+ Object.defineProperty(document, "visibilityState", visibilityDescriptor);+ } else {+ delete (document as Document & { visibilityState?: DocumentVisibilityState }).visibilityState;+ }+ }+ });+it("does not refetch thread history on turn_end", async () => {const client = makeClient();let historyCalls = 0;diff --git a/webui/src/tests/useNanobotStream.test.tsx b/webui/src/tests/useNanobotStream.test.tsxindex ebd2db0d9..8ced5bccf 100644--- a/webui/src/tests/useNanobotStream.test.tsx+++ b/webui/src/tests/useNanobotStream.test.tsx@@ -3,15 +3,20 @@ import type { ReactNode } from "react";import { describe, expect, it, vi } from "vitest";import { useNanobotStream } from "@/hooks/useNanobotStream";-import type { InboundEvent, GoalStateWsPayload } from "@/lib/types";+import type { StreamError } from "@/lib/nanobot-client";+import type { ConnectionStatus, InboundEvent, GoalStateWsPayload } from "@/lib/types";import { ClientProvider } from "@/providers/ClientProvider";const EMPTY_MESSAGES: import("@/lib/types").UIMessage[] = [];function fakeClient() {const handlers = new Map<string, Set<(ev: InboundEvent) => void>>();+ const statusHandlers = new Set<(status: ConnectionStatus) => void>();+ const errorHandlers = new Set<(error: StreamError) => void>();const runStartedAtByChatId = new Map<string, number>();+ const unsettledRunByChatId = new Map<string, boolean>();const goalStateByChatId = new Map<string, GoalStateWsPayload>();+ let status: ConnectionStatus = "open";function recordGoalStatusForRunStrip(chatId: string, ev: InboundEvent) {if (ev.event === "turn_end") {@@ -38,10 +43,19 @@ function fakeClient() {return {client: {- status: "open" as const,+ get status() {+ return status;+ },defaultChatId: null as string | null,- onStatus: () => () => {},- onError: () => () => {},+ onStatus(handler: (nextStatus: ConnectionStatus) => void) {+ statusHandlers.add(handler);+ handler(status);+ return () => statusHandlers.delete(handler);+ },+ onError(handler: (error: StreamError) => void) {+ errorHandlers.add(handler);+ return () => errorHandlers.delete(handler);+ },getRunStartedAt(chatId: string) {const v = runStartedAtByChatId.get(chatId);return v === undefined ? null : v;@@ -49,6 +63,9 @@ function fakeClient() {getGoalState(chatId: string) {return goalStateByChatId.get(chatId);},+ hasUnsettledRun(chatId: string) {+ return unsettledRunByChatId.get(chatId) === true;+ },onChat(chatId: string, h: (ev: InboundEvent) => void) {let set = handlers.get(chatId);if (!set) {@@ -72,6 +89,16 @@ function fakeClient() {const set = handlers.get(chatId);set?.forEach((h) => h(ev));},+ emitStatus(nextStatus: ConnectionStatus) {+ status = nextStatus;+ statusHandlers.forEach((handler) => handler(status));+ },+ emitError(error: StreamError) {+ errorHandlers.forEach((handler) => handler(error));+ },+ setUnsettled(chatId: string, unsettled: boolean) {+ unsettledRunByChatId.set(chatId, unsettled);+ },};}@@ -180,6 +207,64 @@ describe("useNanobotStream", () => {}});+ it("keeps the turn pending on disconnect without breaking a resumed stream", async () => {+ const fake = fakeClient();+ const { result } = renderHook(+ () => useNanobotStream("chat-reconnect", EMPTY_MESSAGES),+ { wrapper: wrap(fake.client) },+ );++ act(() => {+ fake.emit("chat-reconnect", {+ event: "goal_status",+ chat_id: "chat-reconnect",+ status: "running",+ started_at: 1_700,+ });+ fake.emit("chat-reconnect", {+ event: "delta",+ chat_id: "chat-reconnect",+ text: "partial",+ });+ });+ await flushStreamFrame();+ const assistantId = result.current.messages[0].id;+ expect(result.current.isStreaming).toBe(true);++ act(() => fake.emitStatus("reconnecting"));+ expect(result.current.runStartedAt).toBe(1_700);+ expect(result.current.isStreaming).toBe(true);+ expect(result.current.messages[0]).toMatchObject({+ id: assistantId,+ content: "partial",+ isStreaming: true,+ });++ act(() => {+ fake.emitStatus("open");+ fake.emit("chat-reconnect", {+ event: "goal_status",+ chat_id: "chat-reconnect",+ status: "running",+ started_at: 1_800,+ });+ fake.emit("chat-reconnect", {+ event: "delta",+ chat_id: "chat-reconnect",+ text: " resumed",+ });+ });+ await flushStreamFrame();++ expect(result.current.runStartedAt).toBe(1_800);+ expect(result.current.isStreaming).toBe(true);+ expect(result.current.messages[0]).toMatchObject({+ id: assistantId,+ content: "partial resumed",+ isStreaming: true,+ });+ });+it("flushes pending delta text before turn_end finalizes the turn", () => {const fake = fakeClient();const { result } = renderHook(() => useNanobotStream("chat-flush", EMPTY_MESSAGES), {@@ -1596,6 +1681,224 @@ describe("useNanobotStream", () => {);});+ it("removes only the optimistic turn named by a correlated rejection", () => {+ const fake = fakeClient();+ const { result } = renderHook(+ () => useNanobotStream("chat-reject-one", EMPTY_MESSAGES),+ { wrapper: wrap(fake.client) },+ );+ let first: ReturnType<typeof result.current.send> = null;+ let second: ReturnType<typeof result.current.send> = null;+ act(() => {+ first = result.current.send("first");+ second = result.current.send("second");+ });+ fake.setUnsettled("chat-reject-one", true);++ act(() => {+ fake.emitError({+ kind: "turn_rejected",+ detail: "message_rejected",+ chatId: "chat-reject-one",+ turnId: first!.turnId,+ });+ });++ expect(result.current.messages).toEqual([+ expect.objectContaining({+ id: second!.userMessageId,+ turnId: second!.turnId,+ content: "second",+ }),+ ]);+ expect(result.current.isStreaming).toBe(true);+ expect(result.current.streamError).toMatchObject({+ kind: "turn_rejected",+ turnId: first!.turnId,+ });+ });++ it("falls back to the previous running turn when the newer turn is rejected", () => {+ const fake = fakeClient();+ const { result } = renderHook(+ () => useNanobotStream("chat-reject-new", EMPTY_MESSAGES),+ { wrapper: wrap(fake.client) },+ );+ let first: ReturnType<typeof result.current.send> = null;+ let second: ReturnType<typeof result.current.send> = null;+ act(() => {+ first = result.current.send("first");+ fake.emit("chat-reject-new", {+ event: "goal_status",+ chat_id: "chat-reject-new",+ status: "running",+ started_at: 1234,+ turn_id: first!.turnId,+ });+ second = result.current.send("second");+ });++ act(() => {+ fake.emitError({+ kind: "turn_rejected",+ detail: "attachment_rejected",+ chatId: "chat-reject-new",+ turnId: second!.turnId,+ });+ });++ expect(result.current.messages).toEqual([+ expect.objectContaining({+ id: first!.userMessageId,+ turnId: first!.turnId,+ }),+ ]);+ expect(result.current.runStartedAt).toBe(1234);+ expect(result.current.isStreaming).toBe(true);+ });++ it("ends the spinner and drops pending stream work when the only turn is rejected", async () => {+ const fake = fakeClient();+ const { result } = renderHook(+ () => useNanobotStream("chat-reject-only", EMPTY_MESSAGES),+ { wrapper: wrap(fake.client) },+ );+ let submitted: ReturnType<typeof result.current.send> = null;+ act(() => {+ submitted = result.current.send("only");+ fake.emit("chat-reject-only", {+ event: "delta",+ chat_id: "chat-reject-only",+ turn_id: submitted!.turnId,+ text: "must not survive",+ });+ });++ act(() => {+ fake.emitError({+ kind: "turn_rejected",+ detail: "access_denied",+ chatId: "chat-reject-only",+ turnId: submitted!.turnId,+ });+ });+ await flushStreamFrame();++ expect(result.current.messages).toEqual([]);+ expect(result.current.runStartedAt).toBeNull();+ expect(result.current.isStreaming).toBe(false);+ });++ it("applies a correlated rejection replayed through the chat event queue", () => {+ const fake = fakeClient();+ const { result } = renderHook(+ () => useNanobotStream("chat-replayed-reject", EMPTY_MESSAGES),+ { wrapper: wrap(fake.client) },+ );+ let submitted: ReturnType<typeof result.current.send> = null;+ act(() => {+ submitted = result.current.send("queued optimistic row");+ });++ act(() => {+ fake.emit("chat-replayed-reject", {+ event: "error",+ detail: "message_rejected",+ reason: "policy",+ chat_id: "chat-replayed-reject",+ turn_id: submitted!.turnId,+ });+ });++ expect(result.current.messages).toEqual([]);+ expect(result.current.streamError).toMatchObject({+ kind: "turn_rejected",+ chatId: "chat-replayed-reject",+ turnId: submitted!.turnId,+ });+ });++ it("does not show or apply an error correlated to another chat", () => {+ const fake = fakeClient();+ const { result } = renderHook(+ () => useNanobotStream("chat-visible", EMPTY_MESSAGES),+ { wrapper: wrap(fake.client) },+ );+ let submitted: ReturnType<typeof result.current.send> = null;+ act(() => {+ submitted = result.current.send("stay");+ });++ act(() => {+ fake.emitError({+ kind: "turn_rejected",+ detail: "message_rejected",+ chatId: "chat-background",+ turnId: submitted!.turnId,+ });+ });++ expect(result.current.messages).toHaveLength(1);+ expect(result.current.messages[0].content).toBe("stay");+ expect(result.current.streamError).toBeNull();+ });++ it("shows an uncorrelated 1009 fault without rolling back the current turn", () => {+ const fake = fakeClient();+ const { result } = renderHook(+ () => useNanobotStream("chat-generic-1009", EMPTY_MESSAGES),+ { wrapper: wrap(fake.client) },+ );+ act(() => {+ result.current.send("stay visible");+ fake.emitError({ kind: "message_too_big" });+ });++ expect(result.current.messages).toEqual([+ expect.objectContaining({ role: "user", content: "stay visible" }),+ ]);+ expect(result.current.streamError).toEqual({ kind: "message_too_big" });+ });++ it("removes rejected side-channel guidance without stopping the main run", () => {+ const fake = fakeClient();+ const { result } = renderHook(+ () => useNanobotStream("chat-side-reject", EMPTY_MESSAGES),+ { wrapper: wrap(fake.client) },+ );+ let main: ReturnType<typeof result.current.send> = null;+ let side: ReturnType<typeof result.current.send> = null;+ act(() => {+ main = result.current.send("main");+ fake.emit("chat-side-reject", {+ event: "goal_status",+ chat_id: "chat-side-reject",+ status: "running",+ started_at: 9876,+ turn_id: main!.turnId,+ });+ side = result.current.send("guidance", undefined, { sideChannel: true });+ });++ act(() => {+ fake.emitError({+ kind: "turn_rejected",+ detail: "message_rejected",+ chatId: "chat-side-reject",+ turnId: side!.turnId,+ });+ });++ expect(result.current.messages).toEqual([+ expect.objectContaining({+ id: main!.userMessageId,+ turnId: main!.turnId,+ }),+ ]);+ expect(result.current.runStartedAt).toBe(9876);+ expect(result.current.isStreaming).toBe(true);+ });+it("adds optimistic user file attachments as media", () => {const fake = fakeClient();const { result } = renderHook(() => useNanobotStream("chat-file-send", EMPTY_MESSAGES), {@@ -1801,6 +2104,7 @@ describe("useNanobotStream", () => {const call = fake.client.sendMessage.mock.calls.at(-1)!;const turnId = call[3]?.turnId;expect(call[3]).not.toHaveProperty("sideChannel");+ expect(call[3]).toMatchObject({ startsNewRun: false });expect(result.current.isStreaming).toBe(false);act(() => {@@ -1956,6 +2260,7 @@ describe("useNanobotStream", () => {const guideCall = fake.client.sendMessage.mock.calls.at(-1)!;expect(guideCall[3]).not.toHaveProperty("continueActiveTurn");+ expect(guideCall[3]).toMatchObject({ startsNewRun: false });expect(result.current.messages.map((message) => message.content)).toEqual(["research this","Initial findings",diff --git a/webui/src/tests/useSessions.test.tsx b/webui/src/tests/useSessions.test.tsxindex e1f1c6d04..82f291827 100644--- a/webui/src/tests/useSessions.test.tsx+++ b/webui/src/tests/useSessions.test.tsx@@ -450,6 +450,32 @@ describe("useSessions", () => {expect(result.current.hasPendingToolCalls).toBe(false);});+ it("exposes turn ids backed by persisted completion events", async () => {+ vi.mocked(api.fetchWebuiThread).mockResolvedValue({+ schemaVersion: 3,+ has_pending_tool_calls: false,+ completed_turn_ids: ["turn-empty", "", "turn-empty"],+ messages: [+ {+ id: "u1",+ role: "user",+ content: "stop",+ turnId: "turn-empty",+ createdAt: 1,+ },+ ],+ });++ const { result } = renderHook(() => useSessionHistory("websocket:chat-empty"), {+ wrapper: wrap(fakeClient()),+ });++ await waitFor(() => expect(result.current.loading).toBe(false));++ expect(result.current.completedTurnIds).toEqual(["turn-empty"]);+ expect(result.current.hasPendingToolCalls).toBe(false);+ });+it("does not flag transcript as pending when last row is not a trace", async () => {vi.mocked(api.fetchWebuiThread).mockResolvedValue({schemaVersion: 3,@@ -520,6 +546,9 @@ describe("useSessions", () => {});expect(result.current.hasMoreBefore).toBe(true);expect(result.current.userMessageOffset).toBe(1);+ const latestVersion = result.current.version;+ const latestLineage = result.current.lineage;+ expect(result.current.continuity).toBe("initial");await act(async () => {await result.current.loadOlder();@@ -537,6 +566,372 @@ describe("useSessions", () => {]);expect(result.current.hasMoreBefore).toBe(false);expect(result.current.userMessageOffset).toBe(0);+ expect(result.current.version).toBe(latestVersion);+ expect(result.current.lineage).toBe(latestLineage);+ expect(result.current.continuity).toBe("initial");+ });++ it("preserves a loaded prefix when a canonical latest window overlaps its tail", async () => {+ vi.mocked(api.fetchWebuiThread)+ .mockResolvedValueOnce({+ schemaVersion: 3,+ has_pending_tool_calls: true,+ messages: [+ { id: "u2", role: "user", content: "middle question", createdAt: 2 },+ { id: "a2", role: "assistant", content: "middle answer", createdAt: 3 },+ ],+ page: {+ before_cursor: "cursor-middle",+ has_more_before: true,+ loaded_message_count: 2,+ user_message_offset: 1,+ },+ })+ .mockResolvedValueOnce({+ schemaVersion: 3,+ messages: [+ { id: "u1", role: "user", content: "old question", createdAt: 0 },+ { id: "a1", role: "assistant", content: "old answer", createdAt: 1 },+ ],+ page: {+ before_cursor: null,+ has_more_before: false,+ loaded_message_count: 2,+ user_message_offset: 0,+ },+ })+ .mockResolvedValueOnce({+ schemaVersion: 3,+ has_pending_tool_calls: false,+ completed_turn_ids: ["turn-3"],+ messages: [+ { id: "a2-replayed", role: "assistant", content: "middle answer", createdAt: 3 },+ {+ id: "u3",+ role: "user",+ content: "latest question",+ turnId: "turn-3",+ createdAt: 4,+ },+ {+ id: "a3",+ role: "assistant",+ content: "latest answer",+ turnId: "turn-3",+ createdAt: 5,+ },+ ],+ page: {+ before_cursor: "cursor-shifted",+ has_more_before: true,+ loaded_message_count: 3,+ user_message_offset: 1,+ },+ });++ const { result } = renderHook(() => useSessionHistory("websocket:paged-refresh"), {+ wrapper: wrap(fakeClient()),+ });++ await waitFor(() => expect(result.current.loading).toBe(false));+ await act(async () => {+ await result.current.loadOlder();+ });+ const loadedVersion = result.current.version;+ const loadedLineage = result.current.lineage;++ act(() => result.current.refresh());+ await waitFor(() => expect(result.current.version).toBeGreaterThan(loadedVersion));++ expect(result.current.messages.map((message) => message.id)).toEqual([+ "u1",+ "a1",+ "u2",+ "a2-replayed",+ "u3",+ "a3",+ ]);+ expect(result.current.hasMoreBefore).toBe(false);+ expect(result.current.userMessageOffset).toBe(0);+ expect(result.current.hasPendingToolCalls).toBe(false);+ expect(result.current.completedTurnIds).toEqual(["turn-3"]);+ expect(result.current.continuity).toBe("overlap");+ expect(result.current.lineage).toBe(loadedLineage);+ });++ it("starts a new lineage when more than 160 new rows remove all latest-page overlap", async () => {+ const oldWindow = Array.from({ length: 160 }, (_, index) => ({+ id: `old-${index}`,+ role: index % 2 === 0 ? "user" as const : "assistant" as const,+ content: `old window row ${index}`,+ turnId: `old-turn-${Math.floor(index / 2)}`,+ createdAt: index,+ }));+ const newWindow = Array.from({ length: 160 }, (_, index) => ({+ id: `new-${index}`,+ role: index % 2 === 0 ? "user" as const : "assistant" as const,+ content: `new window row ${index}`,+ turnId: `new-turn-${Math.floor(index / 2)}`,+ createdAt: 1_000 + index,+ }));+ vi.mocked(api.fetchWebuiThread)+ .mockResolvedValueOnce({+ schemaVersion: 3,+ messages: oldWindow,+ page: {+ before_cursor: "old-window-cursor",+ has_more_before: true,+ },+ })+ .mockResolvedValueOnce({+ schemaVersion: 3,+ messages: newWindow,+ page: {+ before_cursor: "new-window-cursor",+ has_more_before: true,+ },+ });++ const { result } = renderHook(() => useSessionHistory("websocket:window-reset"), {+ wrapper: wrap(fakeClient()),+ });++ await waitFor(() => expect(result.current.loading).toBe(false));+ const initialLineage = result.current.lineage;+ expect(result.current.messages[0]?.id).toBe("old-0");++ act(() => result.current.refresh());+ await waitFor(() => expect(result.current.messages[0]?.id).toBe("new-0"));++ expect(result.current.messages).toHaveLength(160);+ expect(result.current.messages.at(-1)?.id).toBe("new-159");+ expect(result.current.continuity).toBe("reset");+ expect(result.current.lineage).toBeGreaterThan(initialLineage);+ expect(result.current.hasMoreBefore).toBe(true);+ });++ it("uses the longest consecutive semantic overlap for legacy unstable replay metadata", async () => {+ vi.mocked(api.fetchWebuiThread)+ .mockResolvedValueOnce({+ schemaVersion: 3,+ messages: [+ { id: "repeat-1-old", role: "user", content: "repeat", createdAt: 10 },+ { id: "answer-1-old", role: "assistant", content: "first answer", createdAt: 11 },+ { id: "repeat-2-old", role: "user", content: "repeat", createdAt: 12 },+ { id: "answer-2-old", role: "assistant", content: "second answer", createdAt: 13 },+ ],+ page: {+ before_cursor: "legacy-cursor",+ has_more_before: true,+ },+ })+ .mockResolvedValueOnce({+ schemaVersion: 3,+ messages: [+ { id: "old-prefix", role: "user", content: "old prefix", createdAt: 1 },+ ],+ page: {+ before_cursor: null,+ has_more_before: false,+ },+ })+ .mockResolvedValueOnce({+ schemaVersion: 3,+ messages: [+ { id: "repeat-2-new", role: "user", content: "repeat", createdAt: 9_012 },+ { id: "answer-2-new", role: "assistant", content: "second answer", createdAt: 9_013 },+ { id: "new-tail", role: "assistant", content: "new tail", createdAt: 9_014 },+ ],+ page: {+ before_cursor: "shifted-legacy-cursor",+ has_more_before: true,+ },+ });++ const { result } = renderHook(() => useSessionHistory("websocket:legacy-overlap"), {+ wrapper: wrap(fakeClient()),+ });++ await waitFor(() => expect(result.current.loading).toBe(false));+ await act(async () => {+ await result.current.loadOlder();+ });+ const lineage = result.current.lineage;++ act(() => result.current.refresh());+ await waitFor(() => expect(result.current.messages.at(-1)?.id).toBe("new-tail"));++ expect(result.current.messages.map((message) => message.id)).toEqual([+ "old-prefix",+ "repeat-1-old",+ "answer-1-old",+ "repeat-2-new",+ "answer-2-new",+ "new-tail",+ ]);+ expect(result.current.continuity).toBe("overlap");+ expect(result.current.lineage).toBe(lineage);+ });++ it("ignores an older-page response after a latest refresh resets its lineage", async () => {+ let resolveOlder:+ | ((value: Awaited<ReturnType<typeof api.fetchWebuiThread>>) => void)+ | null = null;+ vi.mocked(api.fetchWebuiThread)+ .mockResolvedValueOnce({+ schemaVersion: 3,+ messages: [+ { id: "old-latest", role: "assistant", content: "old latest", createdAt: 10 },+ ],+ page: {+ before_cursor: "cursor-old-lineage",+ has_more_before: true,+ },+ })+ .mockImplementationOnce(() => new Promise((resolve) => {+ resolveOlder = resolve;+ }))+ .mockResolvedValueOnce({+ schemaVersion: 3,+ messages: [+ { id: "new-latest", role: "assistant", content: "new latest", createdAt: 20 },+ ],+ page: {+ before_cursor: "cursor-new-lineage",+ has_more_before: true,+ },+ });++ const { result } = renderHook(() => useSessionHistory("websocket:paged-race"), {+ wrapper: wrap(fakeClient()),+ });++ await waitFor(() => expect(result.current.loading).toBe(false));+ const oldLineage = result.current.lineage;+ let olderRequest: Promise<void> | undefined;+ act(() => {+ olderRequest = result.current.loadOlder();+ });+ await waitFor(() => expect(api.fetchWebuiThread).toHaveBeenCalledTimes(2));++ act(() => result.current.refresh());+ await waitFor(() => expect(result.current.messages[0]?.id).toBe("new-latest"));+ expect(result.current.continuity).toBe("reset");+ expect(result.current.lineage).toBeGreaterThan(oldLineage);++ await act(async () => {+ resolveOlder?.({+ schemaVersion: 3,+ messages: [+ { id: "stale-prefix", role: "user", content: "stale prefix", createdAt: 1 },+ ],+ page: {+ before_cursor: null,+ has_more_before: false,+ },+ });+ await olderRequest;+ });++ expect(result.current.messages.map((message) => message.id)).toEqual(["new-latest"]);+ expect(result.current.hasMoreBefore).toBe(true);+ });++ it("preserves authoritative active state while prepending older history", async () => {+ vi.mocked(api.fetchWebuiThread)+ .mockResolvedValueOnce({+ schemaVersion: 3,+ has_pending_tool_calls: true,+ messages: [+ { id: "u2", role: "user", content: "current question", createdAt: 2 },+ { id: "a2", role: "assistant", content: "partial answer", createdAt: 3 },+ ],+ page: {+ before_cursor: "cursor-active",+ has_more_before: true,+ loaded_message_count: 2,+ user_message_offset: 1,+ },+ })+ .mockResolvedValueOnce({+ schemaVersion: 3,+ has_pending_tool_calls: false,+ messages: [+ { id: "u1", role: "user", content: "old question", createdAt: 0 },+ { id: "a1", role: "assistant", content: "old answer", createdAt: 1 },+ ],+ page: {+ before_cursor: null,+ has_more_before: false,+ loaded_message_count: 2,+ user_message_offset: 0,+ },+ });++ const { result } = renderHook(() => useSessionHistory("websocket:paged-active"), {+ wrapper: wrap(fakeClient()),+ });++ await waitFor(() => expect(result.current.loading).toBe(false));+ expect(result.current.hasPendingToolCalls).toBe(true);+ const latestVersion = result.current.version;++ await act(async () => {+ await result.current.loadOlder();+ });++ expect(result.current.hasPendingToolCalls).toBe(true);+ expect(result.current.version).toBe(latestVersion);+ });++ it("preserves authoritative completed state while prepending trace history", async () => {+ vi.mocked(api.fetchWebuiThread)+ .mockResolvedValueOnce({+ schemaVersion: 3,+ has_pending_tool_calls: false,+ messages: [+ {+ id: "t2",+ role: "tool",+ kind: "trace",+ content: "completed trace",+ traces: ["completed trace"],+ createdAt: 2,+ },+ ],+ page: {+ before_cursor: "cursor-complete",+ has_more_before: true,+ loaded_message_count: 1,+ user_message_offset: 1,+ },+ })+ .mockResolvedValueOnce({+ schemaVersion: 3,+ messages: [+ { id: "u1", role: "user", content: "old question", createdAt: 0 },+ { id: "a1", role: "assistant", content: "old answer", createdAt: 1 },+ ],+ page: {+ before_cursor: null,+ has_more_before: false,+ loaded_message_count: 2,+ user_message_offset: 0,+ },+ });++ const { result } = renderHook(() => useSessionHistory("websocket:paged-complete"), {+ wrapper: wrap(fakeClient()),+ });++ await waitFor(() => expect(result.current.loading).toBe(false));+ expect(result.current.hasPendingToolCalls).toBe(false);++ await act(async () => {+ await result.current.loadOlder();+ });++ expect(result.current.hasPendingToolCalls).toBe(false);});it("keeps the session in the list when delete fails", async () => {