Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

Add opt-in cross-browser Partner conversation continuity

Bingxi Zhao (Frank)0558356d140a
diff --git a/deeptutor/api/routers/partners.py b/deeptutor/api/routers/partners.py
index 2b82fa521..27ebf6a25 100644
--- a/deeptutor/api/routers/partners.py
+++ b/deeptutor/api/routers/partners.py
@@ -12,6 +12,7 @@ from __future__ import annotations
import asyncio
import base64
import binascii
+from contextlib import nullcontext
import json
import logging
from typing import Any, AsyncGenerator, Literal
@@ -49,12 +50,21 @@ from deeptutor.services.partners.manager import (
LEGACY_GLOBAL_DELIVERY_KEYS,
PartnerConfig,
PartnerInstance,
+ PartnerStaleSessionError,
+ PartnerTurnBusyError,
mask_channel_secrets,
strip_legacy_global_delivery,
)
from deeptutor.services.partners.runtime_status import (
get_partner_runtime_status_repository,
)
+from deeptutor.services.partners.web_continuity import (
+ fresh_web_session_key,
+ get_web_continuity,
+ move_active_web_session,
+ set_web_continuity,
+ validate_session_key,
+)
from deeptutor.services.partners.workspace import (
list_assets,
provision_assets,
@@ -305,6 +315,11 @@ class SessionBranchBody(BaseModel):
new_key: str = Field(..., min_length=1)
+class WebContinuityBody(BaseModel):
+ enabled: bool
+ session_key: str | None = None
+
+
class SoulCreateRequest(BaseModel):
id: str
name: str
@@ -1357,6 +1372,43 @@ async def get_partner_history(
)
[email protected]("/{partner_id}/history/page", dependencies=_USABLE)
+async def get_partner_history_page(
+ partner_id: str,
+ session_key: str,
+ before: int | None = Query(default=None, ge=0),
+ limit: int = Query(default=60, ge=1, le=200),
+):
+ """Read older turns of one actor-scoped conversation in bounded pages."""
+ return (
+ get_partner_manager()
+ .session_store(partner_id)
+ .messages_page(session_key, before=before, limit=limit)
+ )
+
+
[email protected]("/{partner_id}/web-continuity", dependencies=_USABLE)
+async def get_partner_web_continuity(partner_id: str):
+ return get_web_continuity(partner_id, get_current_user().id)
+
+
[email protected]("/{partner_id}/web-continuity", dependencies=_USABLE)
+async def put_partner_web_continuity(partner_id: str, payload: WebContinuityBody):
+ mgr = get_partner_manager()
+ try:
+ return set_web_continuity(
+ partner_id,
+ get_current_user().id,
+ enabled=payload.enabled,
+ session_key=payload.session_key,
+ idle_lock=lambda key: mgr.web_session_idle_lock(partner_id, key),
+ )
+ except ValueError as exc:
+ raise HTTPException(status_code=422, detail=str(exc)) from None
+ except PartnerTurnBusyError as exc:
+ raise HTTPException(status_code=409, detail=str(exc)) from None
+
+
@router.get("/{partner_id}/sessions", dependencies=_USABLE)
async def get_partner_sessions(partner_id: str):
mgr = get_partner_manager()
@@ -1367,38 +1419,113 @@ async def get_partner_sessions(partner_id: str):
async def archive_partner_session(partner_id: str, payload: SessionKeyBody):
"""Soft-archive a session (web /new) — it stays resumable, file untouched."""
mgr = get_partner_manager()
- if not mgr.archive_session(partner_id, payload.session_key):
- raise HTTPException(status_code=404, detail="Session not found")
- return {"partner_id": partner_id, "archived": True, "session_key": payload.session_key}
+ try:
+ with mgr.web_session_idle_lock(partner_id, payload.session_key):
+ if not mgr.archive_session(partner_id, payload.session_key):
+ raise HTTPException(status_code=404, detail="Session not found")
+ active_key = move_active_web_session(
+ partner_id,
+ get_current_user().id,
+ session_key=payload.session_key,
+ new_session_key=fresh_web_session_key(),
+ )
+ except PartnerTurnBusyError as exc:
+ raise HTTPException(status_code=409, detail=str(exc)) from None
+ return {
+ "partner_id": partner_id,
+ "archived": True,
+ "session_key": payload.session_key,
+ "active_session_key": active_key,
+ }
@router.post("/{partner_id}/sessions/resume", dependencies=_USABLE)
async def resume_partner_session(partner_id: str, payload: SessionKeyBody):
"""Clear a session's archived flag so the web app can continue it."""
mgr = get_partner_manager()
- summary = mgr.resume_session(partner_id, payload.session_key)
- if summary is None:
- raise HTTPException(status_code=404, detail="Session not found")
- return {"partner_id": partner_id, "resumed": True, "session": summary}
+ try:
+ session_key = validate_session_key(payload.session_key)
+ except ValueError as exc:
+ raise HTTPException(status_code=422, detail=str(exc)) from None
+ try:
+ with mgr.web_session_idle_lock(partner_id, session_key):
+ summary = mgr.resume_session(partner_id, session_key)
+ if summary is None:
+ raise HTTPException(status_code=404, detail="Session not found")
+ active_key = move_active_web_session(
+ partner_id,
+ get_current_user().id,
+ session_key=session_key,
+ new_session_key=session_key,
+ only_if_current=False,
+ idle_lock=lambda key: mgr.web_session_idle_lock(partner_id, key),
+ )
+ except PartnerTurnBusyError as exc:
+ raise HTTPException(status_code=409, detail=str(exc)) from None
+ return {
+ "partner_id": partner_id,
+ "resumed": True,
+ "session": summary,
+ "active_session_key": active_key,
+ }
@router.post("/{partner_id}/sessions/delete", dependencies=_USABLE)
async def delete_partner_session(partner_id: str, payload: SessionKeyBody):
mgr = get_partner_manager()
- removed = mgr.delete_session(partner_id, payload.session_key)
- if not removed:
- raise HTTPException(status_code=404, detail="Session not found")
- return {"partner_id": partner_id, "deleted": True, "session_key": payload.session_key}
+ try:
+ with mgr.web_session_idle_lock(partner_id, payload.session_key):
+ removed = mgr.delete_session(partner_id, payload.session_key)
+ if not removed:
+ raise HTTPException(status_code=404, detail="Session not found")
+ active_key = move_active_web_session(
+ partner_id,
+ get_current_user().id,
+ session_key=payload.session_key,
+ new_session_key=fresh_web_session_key(),
+ )
+ except PartnerTurnBusyError as exc:
+ raise HTTPException(status_code=409, detail=str(exc)) from None
+ return {
+ "partner_id": partner_id,
+ "deleted": True,
+ "session_key": payload.session_key,
+ "active_session_key": active_key,
+ }
@router.post("/{partner_id}/sessions/branch", dependencies=_USABLE)
async def branch_partner_session(partner_id: str, payload: SessionBranchBody):
"""Copy a session's full history into a new key and archive the source."""
mgr = get_partner_manager()
- summary = mgr.branch_session(partner_id, payload.source_key, payload.new_key)
- if summary is None:
- raise HTTPException(status_code=400, detail="Nothing to branch (source is empty)")
- return {"partner_id": partner_id, "branched": True, "session": summary}
+ try:
+ target_key = validate_session_key(payload.new_key)
+ except ValueError as exc:
+ raise HTTPException(status_code=422, detail=str(exc)) from None
+ if mgr.session_store(partner_id)._stem(payload.source_key) == target_key:
+ raise HTTPException(status_code=400, detail="Branch needs a different session key")
+ try:
+ with mgr.web_session_idle_lock(partner_id, payload.source_key):
+ with mgr.web_session_idle_lock(partner_id, target_key):
+ summary = mgr.branch_session(partner_id, payload.source_key, target_key)
+ if summary is None:
+ raise HTTPException(
+ status_code=400, detail="Nothing to branch (source is empty)"
+ )
+ active_key = move_active_web_session(
+ partner_id,
+ get_current_user().id,
+ session_key=payload.source_key,
+ new_session_key=target_key,
+ )
+ except PartnerTurnBusyError as exc:
+ raise HTTPException(status_code=409, detail=str(exc)) from None
+ return {
+ "partner_id": partner_id,
+ "branched": True,
+ "session": summary,
+ "active_session_key": active_key,
+ }
@router.get("/commands/palette")
@@ -1426,6 +1553,12 @@ def _resolve_http_session(payload: ChatMessageRequest) -> tuple[str, str]:
return session_id, session_id
+def _assert_selected_web_session(partner_id: str, account_id: str, session_key: str) -> None:
+ state = get_web_continuity(partner_id, account_id)
+ if state["enabled"] and state["session_key"] != validate_session_key(session_key):
+ raise PartnerStaleSessionError(str(state["session_key"]))
+
+
# Fallback caps when the settings layer is unavailable; the effective values
# come from the shared chat-attachment policy (data/user/settings/system.json,
# editable at /settings/attachments).
@@ -1513,14 +1646,29 @@ async def partner_chat_http(partner_id: str, payload: ChatMessageRequest) -> dic
mgr = get_partner_manager()
session_id, chat_id = _resolve_http_session(payload)
try:
- response = await mgr.send_message(
- partner_id,
- content,
- chat_id=chat_id,
- session_id=session_id,
- media=media_paths,
- session_key=payload.session_key,
+ lock = (
+ mgr.web_session_idle_lock(partner_id, payload.session_key)
+ if payload.session_key
+ else nullcontext()
)
+ with lock:
+ if payload.session_key:
+ _assert_selected_web_session(partner_id, get_current_user().id, payload.session_key)
+ response = await mgr.send_message(
+ partner_id,
+ content,
+ chat_id=chat_id,
+ session_id=session_id,
+ media=media_paths,
+ session_key=payload.session_key,
+ )
+ except PartnerStaleSessionError as exc:
+ raise HTTPException(
+ status_code=409,
+ detail={"message": str(exc), "active_session_key": exc.active_session_key},
+ ) from None
+ except PartnerTurnBusyError as exc:
+ raise HTTPException(status_code=409, detail=str(exc)) from None
except RuntimeError as exc:
raise HTTPException(status_code=400, detail=str(exc)) from None
return {
@@ -1533,6 +1681,7 @@ async def partner_chat_http(partner_id: str, payload: ChatMessageRequest) -> dic
async def _partner_chat_stream(
partner_id: str,
payload: ChatMessageRequest,
+ account_id: str,
) -> AsyncGenerator[str, None]:
from deeptutor.core.stream import StreamEventType
@@ -1555,15 +1704,23 @@ async def _partner_chat_stream(
async def run() -> None:
try:
- holder["content"] = await mgr.send_message(
- partner_id,
- content,
- chat_id=chat_id,
- session_id=session_id,
- media=media_paths,
- on_event=on_event,
- session_key=payload.session_key,
+ lock = (
+ mgr.web_session_idle_lock(partner_id, payload.session_key)
+ if payload.session_key
+ else nullcontext()
)
+ with lock:
+ if payload.session_key:
+ _assert_selected_web_session(partner_id, account_id, payload.session_key)
+ holder["content"] = await mgr.send_message(
+ partner_id,
+ content,
+ chat_id=chat_id,
+ session_id=session_id,
+ media=media_paths,
+ on_event=on_event,
+ session_key=payload.session_key,
+ )
except Exception as exc: # noqa: BLE001
holder["error"] = str(exc)
finally:
@@ -1598,7 +1755,7 @@ async def partner_chat_http_stream(partner_id: str, payload: ChatMessageRequest)
raise HTTPException(status_code=400, detail=t("api.content_required"))
await _ensure_running_partner(partner_id, allow_stopped=True)
return StreamingResponse(
- _partner_chat_stream(partner_id, payload),
+ _partner_chat_stream(partner_id, payload, get_current_user().id),
media_type="text/event-stream",
headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
)
@@ -1736,6 +1893,12 @@ async def partner_chat_ws(ws: WebSocket, partner_id: str):
if turn.user_content:
await _safe_send({"type": "user_echo", "content": turn.user_content})
_start_drain(turn.subscribe())
+ else:
+ key = _resolve_key(data)
+ frame_type = (
+ "attach_busy" if mgr.web_session_is_busy(partner_id, key) else "attach_idle"
+ )
+ await _safe_send({"type": frame_type, "session_key": key})
continue
content = data.get("content", "").strip()
@@ -1762,11 +1925,43 @@ async def partner_chat_ws(ws: WebSocket, partner_id: str):
content = _default_attachment_prompt(attachments)
try:
- turn = mgr.start_web_turn(partner_id, _resolve_key(data), content, media_paths)
+ session_key = _resolve_key(data)
+ turn = mgr.start_web_turn(
+ partner_id,
+ session_key,
+ content,
+ media_paths,
+ account_id=get_current_user_or_none().id
+ if get_current_user_or_none()
+ else None,
+ )
+ except PartnerStaleSessionError as exc:
+ if not await _safe_send(
+ {
+ "type": "stale_session",
+ "content": str(exc),
+ "active_session_key": exc.active_session_key,
+ }
+ ):
+ break
+ continue
+ except PartnerTurnBusyError as exc:
+ if not await _safe_send({"type": "turn_busy", "content": str(exc)}):
+ break
+ continue
+ except ValueError as exc:
+ if not await _safe_send({"type": "error", "content": str(exc)}):
+ break
+ continue
except RuntimeError as exc:
if not await _safe_send({"type": "error", "content": str(exc)}):
break
continue
+ # Admission is distinct from execution: a later error can happen
+ # after the question was persisted, so clients must not restore it
+ # as a rejected draft and accidentally submit it twice.
+ if not await _safe_send({"type": "accepted", "session_key": session_key}):
+ break
_start_drain(turn.subscribe())
async def _handle_channel_activity():
diff --git a/deeptutor/services/partners/manager.py b/deeptutor/services/partners/manager.py
index 89dad72ea..bfd3051ea 100644
--- a/deeptutor/services/partners/manager.py
+++ b/deeptutor/services/partners/manager.py
@@ -9,15 +9,18 @@ isolated chat-format workspace under ``data/partners/{partner_id}/``.
from __future__ import annotations
import asyncio
+from contextlib import contextmanager
from dataclasses import dataclass, field
from datetime import datetime
+import errno
import hashlib
import logging
import os
from pathlib import Path
import re
import shutil
-from typing import Any, Awaitable, Callable
+import sys
+from typing import Any, Awaitable, BinaryIO, Callable, Iterator
import yaml
@@ -45,6 +48,61 @@ from deeptutor.services.partners.workspace import (
logger = logging.getLogger(__name__)
+
+class PartnerTurnBusyError(RuntimeError):
+ """A new message cannot take over an in-flight web conversation."""
+
+
+class PartnerStaleSessionError(RuntimeError):
+ """A browser submitted a key that is no longer selected for its account."""
+
+ def __init__(self, active_session_key: str) -> None:
+ super().__init__("The active conversation changed in another browser.")
+ self.active_session_key = active_session_key
+
+
+def _acquire_web_turn_lock(path: Path) -> BinaryIO:
+ """Hold a per-session process lock for the full streamed web turn."""
+ handle = path.open("a+b")
+ try:
+ handle.seek(0, 2)
+ if handle.tell() == 0:
+ handle.write(b"\0")
+ handle.flush()
+ handle.seek(0)
+ if sys.platform == "win32": # pragma: no cover - Windows only
+ import msvcrt
+
+ msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+ else:
+ import fcntl
+
+ fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+ return handle
+ except OSError as exc:
+ handle.close()
+ if exc.errno in {errno.EACCES, errno.EAGAIN}:
+ raise PartnerTurnBusyError(
+ "This conversation is already replying. Please wait."
+ ) from exc
+ raise
+
+
+def _release_web_turn_lock(handle: BinaryIO) -> None:
+ try:
+ handle.seek(0)
+ if sys.platform == "win32": # pragma: no cover - Windows only
+ import msvcrt
+
+ msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+ else:
+ import fcntl
+
+ fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+ finally:
+ handle.close()
+
+
_RESERVED_NAMES = {"workspace", "media", "sessions", "_souls"}
_HYPHEN_RUN_RE = re.compile(r"-+")
LEGACY_GLOBAL_DELIVERY_KEYS = frozenset(
@@ -248,6 +306,7 @@ class LiveTurn:
done: bool = False
subscribers: set[asyncio.Queue] = field(default_factory=set, repr=False)
task: asyncio.Task | None = field(default=None, repr=False)
+ turn_lock: BinaryIO | None = field(default=None, repr=False)
def emit(self, frame: dict[str, Any]) -> None:
self.events.append(frame)
@@ -261,6 +320,10 @@ class LiveTurn:
for frame in frames:
queue.put_nowait(frame)
self.subscribers.clear()
+ if self.turn_lock is not None:
+ handle = self.turn_lock
+ self.turn_lock = None
+ _release_web_turn_lock(handle)
def subscribe(self) -> asyncio.Queue:
"""Preload the backlog and register — atomically (no await between) so
@@ -1130,26 +1193,68 @@ class PartnerManager:
session_key: str,
content: str,
media: list[str] | None = None,
+ *,
+ account_id: str | None = None,
) -> "LiveTurn":
- """Run a web turn as an instance-owned task and return its LiveTurn.
+ """Run a new web turn, rejecting concurrent sends on the same session.
- If a turn is already in flight for this session, returns it (one at a
- time per session). The turn keeps running even if every socket detaches.
+ Reconnects use :meth:`subscribe_web_turn`; a fresh send must never
+ receive another browser's answer as if it were its own.
"""
instance = self._partners.get(partner_id)
if not instance or not instance.running or not instance.runner:
raise RuntimeError(f"Partner '{partner_id}' is not running")
existing = instance.live_turns.get(session_key)
if existing is not None and not existing.done:
- return existing
- turn = LiveTurn(user_content=content)
+ raise PartnerTurnBusyError("This conversation is already replying. Please wait.")
+ lock_path = self.web_turn_lock_path(partner_id, session_key)
+ turn_lock = _acquire_web_turn_lock(lock_path)
+ try:
+ if account_id is not None:
+ from deeptutor.services.partners.web_continuity import (
+ get_web_continuity,
+ validate_session_key,
+ )
+
+ state = get_web_continuity(partner_id, account_id)
+ if state["enabled"] and state["session_key"] != validate_session_key(session_key):
+ raise PartnerStaleSessionError(str(state["session_key"]))
+ except Exception:
+ _release_web_turn_lock(turn_lock)
+ raise
+ turn = LiveTurn(user_content=content, turn_lock=turn_lock)
instance.live_turns[session_key] = turn
- turn.task = asyncio.create_task(
- self._drive_web_turn(partner_id, session_key, content, media or [], turn),
- name=f"partner:{partner_id}:webturn",
- )
+ try:
+ turn.task = asyncio.create_task(
+ self._drive_web_turn(partner_id, session_key, content, media or [], turn),
+ name=f"partner:{partner_id}:webturn",
+ )
+ except Exception:
+ turn.finish([])
+ instance.live_turns.pop(session_key, None)
+ raise
return turn
+ def web_turn_lock_path(self, partner_id: str, session_key: str) -> Path:
+ return self.session_store(partner_id)._path(session_key).with_suffix(".turn.lock")
+
+ @contextmanager
+ def web_session_idle_lock(self, partner_id: str, session_key: str) -> Iterator[None]:
+ """Exclude in-flight turns while changing or deleting their session."""
+ handle = _acquire_web_turn_lock(self.web_turn_lock_path(partner_id, session_key))
+ try:
+ yield
+ finally:
+ _release_web_turn_lock(handle)
+
+ def web_session_is_busy(self, partner_id: str, session_key: str) -> bool:
+ """Detect a turn owned by this or another backend worker."""
+ try:
+ with self.web_session_idle_lock(partner_id, session_key):
+ return False
+ except PartnerTurnBusyError:
+ return True
+
def subscribe_web_turn(self, partner_id: str, session_key: str) -> "LiveTurn | None":
"""The in-flight turn for a session, or None (completed turns are read
back from history instead)."""
diff --git a/deeptutor/services/partners/sessions.py b/deeptutor/services/partners/sessions.py
index e48b883b7..ade6aadb0 100644
--- a/deeptutor/services/partners/sessions.py
+++ b/deeptutor/services/partners/sessions.py
@@ -9,6 +9,7 @@ and back the history API, so a flat append-only file per session is enough.
from __future__ import annotations
+from collections import deque
from datetime import datetime
import json
import logging
@@ -298,6 +299,53 @@ class PartnerSessionStore:
redact_private_message_metadata(records)
return records
+ def messages_page(
+ self, session_key: str, *, before: int | None = None, limit: int = 60
+ ) -> dict[str, Any]:
+ """One bounded history page, oldest first, with a stable older cursor.
+
+ ``before`` is an exclusive record index. Appending new turns therefore
+ cannot shift the cursor while a browser is reading earlier pages.
+ """
+ from deeptutor.services.session.provider_response_state import (
+ redact_private_message_metadata,
+ )
+
+ capped_limit = max(1, min(limit, 200))
+ cursor = None if before is None else max(before, 0)
+ window: deque[dict[str, Any]] = deque(maxlen=capped_limit)
+ total = 0
+ path = self._path(session_key)
+ if path.exists():
+ try:
+ with path.open(encoding="utf-8") as handle:
+ for line in handle:
+ try:
+ record = json.loads(line)
+ except json.JSONDecodeError:
+ continue
+ if (
+ not isinstance(record, dict)
+ or not record.get("role")
+ or not record.get("content")
+ ):
+ continue
+ if cursor is None or total < cursor:
+ window.append(record)
+ total += 1
+ except OSError:
+ logger.exception("Failed to read partner session %s", session_key)
+ end = total if cursor is None else min(cursor, total)
+ start = max(0, end - capped_limit)
+ page = list(window)
+ redact_private_message_metadata(page)
+ return {
+ "messages": page,
+ "next_before": start if start > 0 else None,
+ "start": start,
+ "total": total,
+ }
+
def previous_model_turn(self, session_key: str) -> dict[str, Any] | None:
"""Last private request header, used for tool order and cache diagnostics."""
from deeptutor.services.session.model_history import model_turn
diff --git a/deeptutor/services/partners/web_continuity.py b/deeptutor/services/partners/web_continuity.py
new file mode 100644
index 000000000..b5e666ae5
--- /dev/null
+++ b/deeptutor/services/partners/web_continuity.py
@@ -0,0 +1,175 @@
+"""Opt-in active web conversation shared by one account's browsers.
+
+Conversation files retain their existing actor scope. This preference is kept
+under the real account id even for admins, whose legacy Partner conversation
+store is shared, so one admin's browser selection cannot move another's.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+import json
+from pathlib import Path
+import re
+import sys
+from threading import Lock
+from typing import Callable, ContextManager, Iterator
+from uuid import uuid4
+
+from deeptutor.partners.config.paths import get_partner_user_dir
+from deeptutor.partners.helpers import safe_filename
+
+_KEY_RE = re.compile(r'^[^<>"/\\|?*\x00-\x1f\x7f]{1,128}$')
+_lock = Lock()
+
+
+@contextmanager
+def _state_lock(path: Path) -> Iterator[None]:
+ """Serialize read-modify-write across backend workers as well as threads."""
+ with _lock:
+ lock_path = path.with_name(f".{path.name}.lock")
+ with lock_path.open("a+b") as handle:
+ handle.seek(0, 2)
+ if handle.tell() == 0:
+ handle.write(b"\0")
+ handle.flush()
+ handle.seek(0)
+ if sys.platform == "win32": # pragma: no cover - Windows only
+ import msvcrt
+
+ msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)
+ else:
+ import fcntl
+
+ fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+ try:
+ yield
+ finally:
+ handle.seek(0)
+ if sys.platform == "win32": # pragma: no cover - Windows only
+ msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+ else:
+ fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
+def validate_session_key(session_key: str) -> str:
+ """Return the session-store stem used by history and the session list."""
+ key = str(session_key or "").strip()
+ if not _KEY_RE.fullmatch(key):
+ raise ValueError("Invalid Partner session key")
+ stem = safe_filename(key)
+ # Existing channel sessions can have Unicode, spaces or punctuation in
+ # their listed stems. Only colon's legacy filename substitution is allowed
+ # when accepting a noncanonical caller key; all other lossy aliases fail.
+ if not stem or stem != key.replace(":", "_"):
+ raise ValueError("Invalid Partner session key")
+ return stem
+
+
+def _path(partner_id: str, account_id: str) -> Path:
+ return get_partner_user_dir(partner_id, account_id) / "web_continuity.json"
+
+
+def _read(path: Path) -> dict[str, str | bool | None]:
+ try:
+ data = json.loads(path.read_text(encoding="utf-8"))
+ except FileNotFoundError:
+ return {"enabled": False, "session_key": None}
+ except (OSError, json.JSONDecodeError) as exc:
+ raise RuntimeError("Partner web continuity state could not be read") from exc
+ if not isinstance(data, dict) or not isinstance(data.get("enabled"), bool):
+ raise RuntimeError("Partner web continuity state is invalid")
+ if data["enabled"] is not True:
+ return {"enabled": False, "session_key": None}
+ key = data.get("session_key")
+ try:
+ return {"enabled": True, "session_key": validate_session_key(key)}
+ except ValueError as exc:
+ raise RuntimeError("Partner web continuity state is invalid") from exc
+
+
+def _write(path: Path, state: dict[str, str | bool | None]) -> None:
+ temporary = path.with_name(f".{path.name}.{uuid4().hex}.tmp")
+ try:
+ temporary.write_text(json.dumps(state), encoding="utf-8")
+ temporary.replace(path)
+ finally:
+ temporary.unlink(missing_ok=True)
+
+
+def get_web_continuity(partner_id: str, account_id: str) -> dict[str, str | bool | None]:
+ path = _path(partner_id, account_id)
+ with _state_lock(path):
+ return _read(path)
+
+
+def set_web_continuity(
+ partner_id: str,
+ account_id: str,
+ *,
+ enabled: bool,
+ session_key: str | None = None,
+ idle_lock: Callable[[str], ContextManager[None]] | None = None,
+) -> dict[str, str | bool | None]:
+ state: dict[str, str | bool | None] = {
+ "enabled": enabled,
+ "session_key": validate_session_key(session_key) if enabled else None,
+ }
+ path = _path(partner_id, account_id)
+ with _state_lock(path):
+ previous = _read(path)
+ old_key = previous["session_key"] if previous["enabled"] else None
+ # A turn on the selected key must finish before another browser can
+ # switch away or disable continuity. The nonblocking per-session lock
+ # also serializes this update with a just-started web turn.
+ if old_key and old_key != state["session_key"] and idle_lock is not None:
+ with idle_lock(str(old_key)):
+ _write(path, state)
+ else:
+ _write(path, state)
+ return state
+
+
+def move_active_web_session(
+ partner_id: str,
+ account_id: str,
+ *,
+ session_key: str,
+ new_session_key: str,
+ only_if_current: bool = True,
+ idle_lock: Callable[[str], ContextManager[None]] | None = None,
+) -> str | None:
+ """Update a selected key after archive/delete/branch/resume while enabled."""
+ path = _path(partner_id, account_id)
+ with _state_lock(path):
+ state = _read(path)
+ if not state["enabled"]:
+ return None
+ if only_if_current:
+ try:
+ source_key = validate_session_key(session_key)
+ except ValueError:
+ return None
+ if state["session_key"] != source_key:
+ return None
+ next_key = validate_session_key(new_session_key)
+ old_key = str(state["session_key"])
+ if old_key != next_key and idle_lock is not None:
+ with idle_lock(old_key):
+ _write(path, {"enabled": True, "session_key": next_key})
+ else:
+ _write(path, {"enabled": True, "session_key": next_key})
+ return next_key
+
+
+def fresh_web_session_key() -> str:
+ return f"web-{uuid4().hex}"
+
+
+__all__ = [
+ "fresh_web_session_key",
+ "get_web_continuity",
+ "move_active_web_session",
+ "set_web_continuity",
+ "validate_session_key",
+]
diff --git a/tests/api/test_partners_router.py b/tests/api/test_partners_router.py
index 56c91e7f1..ff3af5564 100644
--- a/tests/api/test_partners_router.py
+++ b/tests/api/test_partners_router.py
@@ -5,6 +5,7 @@ from __future__ import annotations
import base64
import json
from pathlib import Path
+from types import SimpleNamespace
import pytest
import yaml
@@ -67,6 +68,7 @@ def client(isolated_root, monkeypatch) -> TestClient:
app = FastAPI()
app.include_router(partners_router_mod.router, prefix="/api/partners")
+ app.include_router(partners_router_mod.ws_router, prefix="/ws/partners")
try:
yield TestClient(app)
finally:
@@ -710,6 +712,272 @@ class TestHistory:
client.post("/api/partners/ada/sessions/delete", json={"session_key": "web-a"})
).status_code == 404
+ def test_history_pages_reach_the_beginning_with_stable_cursor(self, client):
+ from deeptutor.api.routers import partners as router_mod
+
+ _create(client)
+ store = router_mod.get_partner_manager().session_store("ada")
+ for index in range(135):
+ store.append("web-long", "user", f"message {index}")
+
+ first = client.get("/api/partners/ada/history/page?session_key=web-long&limit=60")
+ assert first.status_code == 200
+ assert [row["content"] for row in first.json()["messages"]] == [
+ f"message {index}" for index in range(75, 135)
+ ]
+ assert first.json()["next_before"] == 75
+
+ # A new turn does not move the absolute older-page cursor.
+ store.append("web-long", "assistant", "late reply")
+ second = client.get(
+ "/api/partners/ada/history/page?session_key=web-long&limit=60&before=75"
+ )
+ third = client.get("/api/partners/ada/history/page?session_key=web-long&limit=60&before=15")
+ assert [row["content"] for row in second.json()["messages"]] == [
+ f"message {index}" for index in range(15, 75)
+ ]
+ assert [row["content"] for row in third.json()["messages"]] == [
+ f"message {index}" for index in range(15)
+ ]
+ assert third.json()["next_before"] is None
+ assert client.get("/api/partners/ada/history/page?session_key=other").json() == {
+ "messages": [],
+ "next_before": None,
+ "start": 0,
+ "total": 0,
+ }
+ assert (
+ client.get("/api/partners/ada/history/page?session_key=web-long&limit=201").status_code
+ == 422
+ )
+
+
+class TestWebContinuity:
+ def test_websocket_admission_and_stale_selection_frames(self, client, monkeypatch):
+ from deeptutor.api.routers import partners as router_mod
+ from deeptutor.multi_user.models import LOCAL_ADMIN_ID
+ from deeptutor.services.partners.web_continuity import set_web_continuity
+
+ with client:
+ _create(client, start=False)
+ manager = router_mod.get_partner_manager()
+
+ async def reply(_partner_id, _content, **_kwargs):
+ return "answer"
+
+ monkeypatch.setattr(manager, "send_message", reply)
+ # Auth-disabled sockets install the runtime's local-admin identity.
+ set_web_continuity("ada", LOCAL_ADMIN_ID, enabled=True, session_key="web-current")
+ with client.websocket_connect("/ws/partners/ada") as socket:
+ assert socket.receive_json()["type"] == "ready"
+ socket.send_json({"action": "attach", "session_key": "web-current"})
+ assert socket.receive_json() == {
+ "type": "attach_idle",
+ "session_key": "web-current",
+ }
+ socket.send_json({"content": "stale", "session_key": "web-old"})
+ stale = socket.receive_json()
+ assert stale["type"] == "stale_session"
+ assert stale["active_session_key"] == "web-current"
+ socket.send_json({"content": "valid", "session_key": "web-current"})
+ assert socket.receive_json() == {
+ "type": "accepted",
+ "session_key": "web-current",
+ }
+ assert socket.receive_json() == {"type": "content", "content": "answer"}
+ assert socket.receive_json() == {"type": "done"}
+
+ def test_http_send_rejects_stale_selected_key(self, client, monkeypatch):
+ from deeptutor.api.routers import partners as router_mod
+
+ seen: list[str] = []
+ with client:
+ _create(client, start=False)
+ manager = router_mod.get_partner_manager()
+
+ async def reply(_partner_id, content, **_kwargs):
+ seen.append(content)
+ return "answer"
+
+ monkeypatch.setattr(manager, "send_message", reply)
+ client.put(
+ "/api/partners/ada/web-continuity",
+ json={"enabled": True, "session_key": "web-current"},
+ )
+ stale = client.post(
+ "/api/partners/ada/chat",
+ json={"content": "must not persist", "session_key": "web-old"},
+ )
+ assert stale.status_code == 409
+ assert stale.json()["detail"]["active_session_key"] == "web-current"
+ accepted = client.post(
+ "/api/partners/ada/chat",
+ json={"content": "valid", "session_key": "web-current"},
+ )
+ assert accepted.status_code == 200
+ assert seen == ["valid"]
+
+ def test_legacy_colon_key_is_canonical_across_pointer_and_session_list(self, client):
+ from deeptutor.api.routers import partners as router_mod
+
+ _create(client)
+ store = router_mod.get_partner_manager().session_store("ada")
+ store.append("web:abc", "user", "legacy conversation")
+ assert (
+ client.put(
+ "/api/partners/ada/web-continuity",
+ json={"enabled": True, "session_key": "web:abc"},
+ ).json()["session_key"]
+ == "web_abc"
+ )
+ assert [row["session_key"] for row in client.get("/api/partners/ada/sessions").json()] == [
+ "web_abc"
+ ]
+ deleted = client.post("/api/partners/ada/sessions/delete", json={"session_key": "web_abc"})
+ assert deleted.status_code == 200
+ assert deleted.json()["active_session_key"] not in {None, "web_abc"}
+
+ def test_busy_turn_prevents_lifecycle_and_pointer_move(self, client):
+ from deeptutor.api.routers import partners as router_mod
+
+ _create(client)
+ mgr = router_mod.get_partner_manager()
+ store = mgr.session_store("ada")
+ store.append("web-active", "user", "being answered")
+ store.append("web-other", "user", "older")
+ client.put(
+ "/api/partners/ada/web-continuity",
+ json={"enabled": True, "session_key": "web-active"},
+ )
+ with mgr.web_session_idle_lock("ada", "web-active"):
+ assert (
+ client.put(
+ "/api/partners/ada/web-continuity",
+ json={"enabled": True, "session_key": "web-other"},
+ ).status_code
+ == 409
+ )
+ for action, body in (
+ ("archive", {"session_key": "web-active"}),
+ ("delete", {"session_key": "web-active"}),
+ ("branch", {"source_key": "web-active", "new_key": "web-copy"}),
+ ):
+ assert (
+ client.post(f"/api/partners/ada/sessions/{action}", json=body).status_code
+ == 409
+ )
+ # Resume targets a different file, but cannot move the selected
+ # pointer away from the in-flight conversation either.
+ assert (
+ client.post(
+ "/api/partners/ada/sessions/resume", json={"session_key": "web-other"}
+ ).status_code
+ == 409
+ )
+ assert client.get("/api/partners/ada/web-continuity").json()["session_key"] == "web-active"
+
+ def test_invalid_branch_target_does_not_archive_source(self, client):
+ from deeptutor.api.routers import partners as router_mod
+
+ _create(client)
+ store = router_mod.get_partner_manager().session_store("ada")
+ store.append("web-original", "user", "keep this")
+ result = client.post(
+ "/api/partners/ada/sessions/branch",
+ json={"source_key": "web-original", "new_key": "../bad"},
+ )
+ assert result.status_code == 422
+ summary = next(s for s in store.list_sessions() if s["session_key"] == "web-original")
+ assert summary["archived"] is False
+
+ def test_opt_in_is_per_account_even_for_admins(self, client, monkeypatch):
+ from deeptutor.api.routers import partners as router_mod
+
+ _create(client)
+ assert client.get("/api/partners/ada/web-continuity").json() == {
+ "enabled": False,
+ "session_key": None,
+ }
+ assert client.put(
+ "/api/partners/ada/web-continuity",
+ json={"enabled": True, "session_key": "web-first"},
+ ).json() == {"enabled": True, "session_key": "web-first"}
+
+ with monkeypatch.context() as patcher:
+ patcher.setattr(
+ router_mod, "get_current_user", lambda: SimpleNamespace(id="other-admin")
+ )
+ assert client.get("/api/partners/ada/web-continuity").json() == {
+ "enabled": False,
+ "session_key": None,
+ }
+ client.put(
+ "/api/partners/ada/web-continuity",
+ json={"enabled": True, "session_key": "web-second"},
+ )
+ assert (
+ client.get("/api/partners/ada/web-continuity").json()["session_key"] == "web-second"
+ )
+ assert client.get("/api/partners/ada/web-continuity").json()["session_key"] == "web-first"
+
+ invalid = client.put(
+ "/api/partners/ada/web-continuity",
+ json={"enabled": True, "session_key": "../web-other"},
+ )
+ assert invalid.status_code == 422
+ assert client.put("/api/partners/ada/web-continuity", json={"enabled": False}).json() == {
+ "enabled": False,
+ "session_key": None,
+ }
+
+ def test_lifecycle_keeps_enabled_selection_valid(self, client):
+ from deeptutor.api.routers import partners as router_mod
+
+ _create(client)
+ store = router_mod.get_partner_manager().session_store("ada")
+ store.append("web-original", "user", "hello")
+ store.append("web-other", "user", "separate browser")
+ client.put(
+ "/api/partners/ada/web-continuity",
+ json={"enabled": True, "session_key": "web-original"},
+ )
+
+ branched = client.post(
+ "/api/partners/ada/sessions/branch",
+ json={"source_key": "web-original", "new_key": "web-branch"},
+ )
+ assert branched.status_code == 200
+ assert branched.json()["active_session_key"] == "web-branch"
+ assert client.get("/api/partners/ada/web-continuity").json()["session_key"] == "web-branch"
+
+ resumed = client.post(
+ "/api/partners/ada/sessions/resume", json={"session_key": "web-original"}
+ )
+ assert resumed.json()["active_session_key"] == "web-original"
+ archived = client.post(
+ "/api/partners/ada/sessions/archive", json={"session_key": "web-original"}
+ )
+ replacement = archived.json()["active_session_key"]
+ assert replacement.startswith("web-") and replacement != "web-original"
+ assert client.get("/api/partners/ada/web-continuity").json()["session_key"] == replacement
+
+ # Deleting an unrelated legacy session leaves the selected key alone.
+ unrelated = client.post(
+ "/api/partners/ada/sessions/delete", json={"session_key": "web-other"}
+ )
+ assert unrelated.json()["active_session_key"] is None
+ assert client.get("/api/partners/ada/web-continuity").json()["session_key"] == replacement
+
+ store.append(replacement, "user", "new shared conversation")
+ deleted = client.post(
+ "/api/partners/ada/sessions/delete", json={"session_key": replacement}
+ )
+ assert deleted.json()["active_session_key"] not in {None, replacement}
+ assert (
+ client.get("/api/partners/ada/web-continuity").json()["session_key"]
+ == deleted.json()["active_session_key"]
+ )
+
class TestChatAttachments:
def test_web_chat_lazily_starts_partner_without_enabling_boot_start(
diff --git a/tests/services/partners/test_partner_runtime.py b/tests/services/partners/test_partner_runtime.py
index e5d8b5f23..a8aea610b 100644
--- a/tests/services/partners/test_partner_runtime.py
+++ b/tests/services/partners/test_partner_runtime.py
@@ -1185,6 +1185,85 @@ class TestLiveTurn:
finally:
await mgr.stop_partner("ada")
+ @pytest.mark.asyncio
+ async def test_second_browser_cannot_replace_an_active_web_turn(
+ self, partners_root, fake_orchestrator, monkeypatch
+ ):
+ from deeptutor.services.partners.manager import PartnerManager, PartnerTurnBusyError
+
+ mgr = PartnerManager()
+ mgr.save_config("ada", PartnerConfig(name="Ada"), auto_start=True)
+ await mgr.start_partner("ada")
+ release = asyncio.Event()
+ seen: list[str] = []
+
+ async def reply(_partner_id, content, **_kwargs):
+ seen.append(content)
+ await release.wait()
+ return f"answer to {content}"
+
+ monkeypatch.setattr(mgr, "send_message", reply)
+ try:
+ first = mgr.start_web_turn("ada", "web-shared", "first browser")
+ await asyncio.sleep(0)
+ with pytest.raises(PartnerTurnBusyError, match="already replying"):
+ mgr.start_web_turn("ada", "web-shared", "second browser")
+ assert mgr.subscribe_web_turn("ada", "web-shared") is first
+ assert mgr.web_session_is_busy("ada", "web-shared") is True
+ # A different worker's manager has no in-memory LiveTurn, but the
+ # file lease still rejects mutation of the same actor-scoped key.
+ other_manager = PartnerManager()
+ assert other_manager.subscribe_web_turn("ada", "web-shared") is None
+ assert other_manager.web_session_is_busy("ada", "web-shared") is True
+ assert seen == ["first browser"]
+
+ release.set()
+ await asyncio.wait_for(first.task, timeout=1)
+ assert first.done
+ assert mgr.web_session_is_busy("ada", "web-shared") is False
+ second = mgr.start_web_turn("ada", "web-shared", "second browser")
+ await asyncio.wait_for(second.task, timeout=1)
+ assert seen == ["first browser", "second browser"]
+ finally:
+ release.set()
+ await mgr.stop_partner("ada")
+
+ @pytest.mark.asyncio
+ async def test_stale_browser_send_does_not_append_to_old_shared_session(
+ self, partners_root, fake_orchestrator, monkeypatch
+ ):
+ from deeptutor.services.partners.manager import (
+ PartnerManager,
+ PartnerStaleSessionError,
+ )
+ from deeptutor.services.partners.web_continuity import set_web_continuity
+
+ mgr = PartnerManager()
+ mgr.save_config("ada", PartnerConfig(name="Ada"), auto_start=True)
+ await mgr.start_partner("ada")
+ set_web_continuity("ada", "account-a", enabled=True, session_key="web-current")
+ seen: list[str] = []
+
+ async def reply(_partner_id, content, **_kwargs):
+ seen.append(content)
+ return "reply"
+
+ monkeypatch.setattr(mgr, "send_message", reply)
+ try:
+ with pytest.raises(PartnerStaleSessionError) as stale:
+ mgr.start_web_turn(
+ "ada", "web-old", "question from stale browser", account_id="account-a"
+ )
+ assert stale.value.active_session_key == "web-current"
+ assert seen == []
+ turn = mgr.start_web_turn(
+ "ada", "web-current", "question on current thread", account_id="account-a"
+ )
+ await asyncio.wait_for(turn.task, timeout=1)
+ assert seen == ["question on current thread"]
+ finally:
+ await mgr.stop_partner("ada")
+
@pytest.mark.asyncio
async def test_manager_captures_authenticated_actor_for_private_history(
self, partners_root, fake_orchestrator
diff --git a/web/app/(workspace)/partners/[partnerId]/page.tsx b/web/app/(workspace)/partners/[partnerId]/page.tsx
index c4bc8437a..3d1345371 100644
--- a/web/app/(workspace)/partners/[partnerId]/page.tsx
+++ b/web/app/(workspace)/partners/[partnerId]/page.tsx
@@ -5,7 +5,7 @@
* Header carries identity + run state; everything else lives in the tabs.
*/
-import { Suspense, useCallback, useEffect, useMemo, useState } from "react";
+import { Suspense, useCallback, useEffect, useMemo, useRef, useState } from "react";
import Link from "next/link";
import { useParams, useRouter, useSearchParams } from "next/navigation";
import {
@@ -27,6 +27,9 @@ import {
archivePartnerSession,
destroyPartner,
getPartner,
+ getPartnerSessions,
+ getPartnerWebContinuity,
+ setPartnerWebContinuity,
startPartner,
stopPartner,
type PartnerInfo,
@@ -37,7 +40,7 @@ import {
} from "@/lib/chat-export";
import {
freshPartnerSessionKey,
- loadPartnerSessionKey,
+ initializePartnerSessionKey,
persistPartnerSessionKey,
} from "@/lib/partner-session";
import PartnerAvatar from "@/components/partners/PartnerAvatar";
@@ -50,6 +53,7 @@ import SaveToNotebookModal, {
type NotebookSaveMessage,
type NotebookSavePayload,
} from "@/components/notebook/SaveToNotebookModal";
+import { useAuthStatus } from "@/hooks/useAuthStatus";
type Tab = "chat" | "configure" | "channels" | "archive";
@@ -59,6 +63,7 @@ function PartnerDetail() {
const router = useRouter();
const { t } = useTranslation();
const partnerId = params.partnerId;
+ const auth = useAuthStatus();
const initialTab = (searchParams.get("tab") as Tab) || "chat";
const [tab, setTab] = useState<Tab>(
@@ -89,17 +94,179 @@ function PartnerDetail() {
// The active web session key lives here so the Archive tab's Resume can
// point the (always-mounted) Chat tab at a different conversation.
const [sessionKey, setSessionKey] = useState("");
+ const [localSessionKey, setLocalSessionKey] = useState("");
+ const [continuityEnabled, setContinuityEnabled] = useState(false);
+ const [continuityReady, setContinuityReady] = useState(false);
+ const [continuityBusy, setContinuityBusy] = useState(false);
+ const [continuityError, setContinuityError] = useState(false);
+ const [runtimeContinuityError, setRuntimeContinuityError] = useState(false);
+ const [continuityRetry, setContinuityRetry] = useState(0);
+ const [switchingSession, setSwitchingSession] = useState(false);
+ const [chatBusy, setChatBusy] = useState(false);
+ const selectionEpochRef = useRef(0);
+ const refreshInFlightRef = useRef(false);
+ const selectionMutationRef = useRef(false);
+ const accountId = auth.userId ?? (!auth.enabled && auth.statusAvailable ? "local-admin" : null);
+
useEffect(() => {
- setSessionKey(loadPartnerSessionKey(partnerId));
- }, [partnerId]);
+ if (auth.loading) return;
+ if (!accountId) {
+ setContinuityError(true);
+ return;
+ }
+ let cancelled = false;
+ setContinuityReady(false);
+ setContinuityError(false);
+ setRuntimeContinuityError(false);
+ void (async () => {
+ const localKey = await initializePartnerSessionKey(
+ partnerId,
+ accountId,
+ {
+ enabled: auth.enabled,
+ isAdmin: auth.isAdmin,
+ statusAvailable: auth.statusAvailable,
+ },
+ async () => (await getPartnerSessions(partnerId)).map((item) => item.session_key),
+ );
+ const state = await getPartnerWebContinuity(partnerId);
+ if (cancelled) return;
+ setLocalSessionKey(localKey);
+ setContinuityEnabled(state.enabled);
+ setSessionKey(state.enabled && state.session_key ? state.session_key : localKey);
+ setContinuityReady(true);
+ })().catch(() => {
+ if (!cancelled) setContinuityError(true);
+ });
+ return () => {
+ cancelled = true;
+ };
+ }, [partnerId, auth.loading, auth.enabled, auth.isAdmin, auth.statusAvailable, accountId, continuityRetry]);
+
+ const refreshAuthoritative = useCallback(async (required = false) => {
+ if (!required && (refreshInFlightRef.current || selectionMutationRef.current)) return;
+ refreshInFlightRef.current = true;
+ const epoch = selectionEpochRef.current;
+ try {
+ const state = await getPartnerWebContinuity(partnerId);
+ if (epoch !== selectionEpochRef.current) return;
+ setContinuityEnabled(state.enabled);
+ setSessionKey(state.enabled && state.session_key ? state.session_key : localSessionKey);
+ setRuntimeContinuityError(false);
+ } catch (error) {
+ if (required) {
+ setRuntimeContinuityError(true);
+ setToast(error instanceof Error ? error.message : t("Load failed"));
+ }
+ } finally {
+ refreshInFlightRef.current = false;
+ }
+ }, [partnerId, localSessionKey, t]);
+
+ // A second browser can change the selected conversation. Pick it up when
+ // this page becomes active, without moving a turn that is still streaming.
+ useEffect(() => {
+ if (!continuityReady) return;
+ const refresh = () => {
+ if (document.visibilityState !== "visible" || chatBusy || continuityBusy || switchingSession) return;
+ void refreshAuthoritative();
+ };
+ const timer = continuityEnabled ? window.setInterval(refresh, 15_000) : null;
+ window.addEventListener("focus", refresh);
+ document.addEventListener("visibilitychange", refresh);
+ return () => {
+ if (timer !== null) window.clearInterval(timer);
+ window.removeEventListener("focus", refresh);
+ document.removeEventListener("visibilitychange", refresh);
+ };
+ }, [continuityReady, continuityEnabled, chatBusy, continuityBusy, switchingSession, refreshAuthoritative]);
+
+ const reconcileSelection = useCallback(async () => {
+ selectionEpochRef.current += 1;
+ selectionMutationRef.current = true;
+ setSwitchingSession(true);
+ try {
+ await refreshAuthoritative(true);
+ } finally {
+ selectionMutationRef.current = false;
+ setSwitchingSession(false);
+ }
+ }, [refreshAuthoritative]);
+ const handleSelectionStale = useCallback(() => reconcileSelection(), [reconcileSelection]);
+
const changeSessionKey = useCallback(
- (key: string) => {
- persistPartnerSessionKey(partnerId, key);
+ async (key: string, alreadySaved = false) => {
+ selectionEpochRef.current += 1;
setSessionKey(key);
+ if (continuityEnabled) {
+ if (alreadySaved) return;
+ selectionMutationRef.current = true;
+ setSwitchingSession(true);
+ try {
+ const state = await setPartnerWebContinuity(partnerId, {
+ enabled: true,
+ session_key: key,
+ });
+ if (state.session_key && state.session_key !== key) setSessionKey(state.session_key);
+ } catch (error) {
+ setToast(error instanceof Error ? error.message : t("Action failed"));
+ await reconcileSelection();
+ } finally {
+ selectionMutationRef.current = false;
+ setSwitchingSession(false);
+ }
+ } else {
+ if (accountId) persistPartnerSessionKey(partnerId, key, accountId);
+ setLocalSessionKey(key);
+ }
},
- [partnerId],
+ [partnerId, continuityEnabled, accountId, reconcileSelection, t],
);
+ const toggleContinuity = useCallback(async () => {
+ if (!continuityReady || continuityBusy || switchingSession || runtimeContinuityError || chatBusy || !sessionKey) return;
+ selectionEpochRef.current += 1;
+ selectionMutationRef.current = true;
+ setContinuityBusy(true);
+ try {
+ if (continuityEnabled) {
+ await setPartnerWebContinuity(partnerId, {
+ enabled: false,
+ session_key: null,
+ });
+ const localKey = freshPartnerSessionKey();
+ if (accountId) persistPartnerSessionKey(partnerId, localKey, accountId);
+ setLocalSessionKey(localKey);
+ setSessionKey(localKey);
+ setContinuityEnabled(false);
+ } else {
+ await setPartnerWebContinuity(partnerId, {
+ enabled: true,
+ session_key: sessionKey,
+ });
+ setContinuityEnabled(true);
+ }
+ } catch (error) {
+ setToast(error instanceof Error ? error.message : t("Action failed"));
+ await refreshAuthoritative(true);
+ } finally {
+ selectionMutationRef.current = false;
+ setContinuityBusy(false);
+ }
+ }, [
+ accountId,
+ chatBusy,
+ continuityBusy,
+ continuityEnabled,
+ continuityReady,
+ runtimeContinuityError,
+ switchingSession,
+ partnerId,
+ refreshAuthoritative,
+ sessionKey,
+ t,
+ ]);
+
useEffect(() => {
if (!toast) return;
const timer = setTimeout(() => setToast(""), 3500);
@@ -163,9 +330,14 @@ function PartnerDetail() {
if (!sessionKey || chatMessages.length === 0 || archiveBusy) return;
setArchiveBusy(true);
try {
- await archivePartnerSession(partnerId, sessionKey);
+ const result = await archivePartnerSession(partnerId, sessionKey);
setChatMessages([]);
- changeSessionKey(freshPartnerSessionKey());
+ if (continuityEnabled) {
+ if (result.active_session_key) changeSessionKey(result.active_session_key, true);
+ else await reconcileSelection();
+ } else {
+ changeSessionKey(freshPartnerSessionKey());
+ }
setToast(t("Archived conversation"));
} catch (error) {
setToast(error instanceof Error ? error.message : t("Action failed"));
@@ -176,7 +348,9 @@ function PartnerDetail() {
archiveBusy,
changeSessionKey,
chatMessages.length,
+ continuityEnabled,
partnerId,
+ reconcileSelection,
sessionKey,
t,
]);
@@ -234,7 +408,7 @@ function PartnerDetail() {
}
};
- if (loading) {
+ if (loading || auth.loading || (!continuityReady && !continuityError)) {
return (
<div className="flex h-full items-center justify-center">
<Loader2 className="h-5 w-5 animate-spin text-[var(--muted-foreground)]" />
@@ -258,6 +432,24 @@ function PartnerDetail() {
);
}
+ if (continuityError) {
+ return (
+ <div className="flex h-full flex-col items-center justify-center gap-3 text-[13px]">
+ <p className="text-[var(--muted-foreground)]">{t("Could not load browser sync state")}</p>
+ <button
+ type="button"
+ onClick={() => {
+ if (!accountId) window.location.reload();
+ else setContinuityRetry((value) => value + 1);
+ }}
+ className="rounded-md border border-[var(--border)] px-3 py-1.5 text-[var(--foreground)] hover:bg-[var(--muted)]"
+ >
+ {t("Retry")}
+ </button>
+ </div>
+ );
+ }
+
const tabs: { key: Tab; label: string; icon: typeof MessageCircle }[] = [
{ key: "chat", label: t("Chat"), icon: MessageCircle },
...(canManage
@@ -266,7 +458,7 @@ function PartnerDetail() {
{ key: "channels", label: t("Channels"), icon: Radio },
] as const)
: []),
- { key: "archive", label: t("Archive"), icon: Archive },
+ { key: "archive", label: t("Conversations"), icon: Archive },
];
return (
@@ -327,13 +519,29 @@ function PartnerDetail() {
</nav>
<div className="flex min-w-0 items-center justify-end gap-0.5">
+ <label
+ title={t("Share this conversation across browsers")}
+ className="mr-1 inline-flex cursor-pointer items-center gap-1.5 text-[11px] text-[var(--muted-foreground)]"
+ >
+ <input
+ type="checkbox"
+ aria-label={t("Sync browsers")}
+ checked={continuityEnabled}
+ disabled={continuityBusy || switchingSession || runtimeContinuityError || chatBusy}
+ onChange={() => void toggleContinuity()}
+ className="h-3.5 w-3.5 accent-[var(--primary)]"
+ />
+ <span className="hidden whitespace-nowrap xl:inline">
+ {t("Sync browsers")}
+ </span>
+ </label>
{(activeTab === "chat" || activeTab === "archive") && (
<>
{activeTab === "chat" ? (
<button
type="button"
onClick={() => void handleArchiveConversation()}
- disabled={!chatMessages.length || archiveBusy}
+ disabled={!chatMessages.length || archiveBusy || switchingSession || chatBusy}
title={t("Archive")}
aria-label={t("Archive")}
className="rounded-md p-1.5 text-[var(--muted-foreground)] hover:bg-[var(--muted)] hover:text-[var(--foreground)] disabled:cursor-not-allowed disabled:opacity-40"
@@ -414,6 +622,19 @@ function PartnerDetail() {
/>
) : null}
+ {runtimeContinuityError ? (
+ <div className="flex items-center justify-center gap-2 border-b border-[var(--border)] px-4 py-2 text-[12px] text-[var(--muted-foreground)]">
+ {t("Could not load browser sync state")}
+ <button
+ type="button"
+ onClick={() => void reconcileSelection()}
+ className="rounded-md border border-[var(--border)] px-2 py-1 text-[var(--foreground)] hover:bg-[var(--muted)]"
+ >
+ {t("Retry")}
+ </button>
+ </div>
+ ) : null}
+
{/* Body. Chat stays mounted (hidden off-tab) so an in-progress turn —
its WebSocket and live trace — survives switching to another tab. */}
<div className="min-h-0 flex-1">
@@ -430,6 +651,10 @@ function PartnerDetail() {
onToast={setToast}
onMessagesChange={setChatMessages}
onRuntimeReady={handleRuntimeReady}
+ onBusyChange={setChatBusy}
+ switchingSession={switchingSession || continuityBusy || archiveBusy || runtimeContinuityError}
+ sharedAcrossBrowsers={continuityEnabled}
+ onSelectionStale={handleSelectionStale}
/>
</div>
</div>
@@ -439,8 +664,21 @@ function PartnerDetail() {
partnerId={partnerId}
onToast={setToast}
onMessagesChange={setArchiveMessages}
- onResume={(key) => {
- changeSessionKey(key);
+ onDeleted={(deletedKey, activeKey) => {
+ if (continuityEnabled) {
+ if (activeKey) changeSessionKey(activeKey, true);
+ else if (deletedKey === sessionKey) void reconcileSelection();
+ } else if (deletedKey === sessionKey) {
+ changeSessionKey(freshPartnerSessionKey());
+ }
+ }}
+ onResume={(key, activeKey, didCallResume) => {
+ if (continuityEnabled && didCallResume) {
+ if (activeKey) changeSessionKey(activeKey, true);
+ else void reconcileSelection();
+ } else {
+ changeSessionKey(key);
+ }
setTab("chat");
}}
/>
diff --git a/web/components/partners/PartnerArchives.tsx b/web/components/partners/PartnerArchives.tsx
index 423c84120..4c96f4c09 100644
--- a/web/components/partners/PartnerArchives.tsx
+++ b/web/components/partners/PartnerArchives.tsx
@@ -1,6 +1,6 @@
"use client";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import {
Archive,
Clock3,
@@ -14,7 +14,7 @@ import {
import { useTranslation } from "react-i18next";
import {
deletePartnerSession,
- getPartnerHistory,
+ getPartnerHistoryPage,
getPartnerSessions,
resumePartnerSession,
type PartnerSessionInfo,
@@ -46,6 +46,7 @@ export default function PartnerArchives({
onToast,
onMessagesChange,
onResume,
+ onDeleted,
}: {
partnerId: string;
onToast: (message: string) => void;
@@ -53,14 +54,21 @@ export default function PartnerArchives({
* Empty array when nothing is selected (or while loading). */
onMessagesChange?: (messages: ExportableMessage[]) => void;
/** Continue a conversation in the Chat tab (un-archives it first). */
- onResume?: (sessionKey: string) => void;
+ onResume?: (sessionKey: string, activeKey: string | null, didCallResume: boolean) => void;
+ /** The page owns both its local key and its shared selection. */
+ onDeleted?: (sessionKey: string, activeKey: string | null) => void;
}) {
const { t } = useTranslation();
const [sessions, setSessions] = useState<PartnerSessionInfo[]>([]);
const [selectedKey, setSelectedKey] = useState("");
const [messages, setMessages] = useState<HistoryMessage[]>([]);
+ const [olderBefore, setOlderBefore] = useState<number | null>(null);
+ const [loadingOlder, setLoadingOlder] = useState(false);
const [loadingSessions, setLoadingSessions] = useState(true);
const [loadingMessages, setLoadingMessages] = useState(false);
+ const messageScrollRef = useRef<HTMLDivElement>(null);
+ const selectedKeyRef = useRef(selectedKey);
+ selectedKeyRef.current = selectedKey;
const selected = useMemo(
() =>
@@ -71,9 +79,7 @@ export default function PartnerArchives({
const loadSessions = useCallback(async () => {
setLoadingSessions(true);
try {
- const next = (await getPartnerSessions(partnerId)).filter(
- (session) => session.archived,
- );
+ const next = await getPartnerSessions(partnerId);
setSessions(next);
setSelectedKey((current) => {
if (
@@ -98,10 +104,10 @@ export default function PartnerArchives({
const handleResume = useCallback(
async (session: PartnerSessionInfo) => {
try {
- if (session.archived) {
- await resumePartnerSession(partnerId, session.session_key);
- }
- onResume?.(session.session_key);
+ const result = session.archived
+ ? await resumePartnerSession(partnerId, session.session_key)
+ : null;
+ onResume?.(session.session_key, result?.active_session_key ?? null, result !== null);
} catch (e) {
onToast(e instanceof Error ? e.message : t("Load failed"));
}
@@ -112,7 +118,8 @@ export default function PartnerArchives({
const handleDelete = useCallback(
async (session: PartnerSessionInfo) => {
try {
- await deletePartnerSession(partnerId, session.session_key);
+ const result = await deletePartnerSession(partnerId, session.session_key);
+ onDeleted?.(session.session_key, result.active_session_key);
if (selectedKey === session.session_key) setSelectedKey("");
onToast(t("Conversation deleted"));
await loadSessions();
@@ -120,19 +127,26 @@ export default function PartnerArchives({
onToast(e instanceof Error ? e.message : t("Delete failed"));
}
},
- [partnerId, selectedKey, loadSessions, onToast, t],
+ [partnerId, selectedKey, loadSessions, onToast, onDeleted, t],
);
useEffect(() => {
if (!selectedKey) {
setMessages([]);
+ setOlderBefore(null);
return;
}
let cancelled = false;
setLoadingMessages(true);
- void getPartnerHistory(partnerId, { sessionKey: selectedKey, limit: 200 })
- .then((history) => {
- if (!cancelled) setMessages(history);
+ setLoadingOlder(false);
+ setMessages([]);
+ setOlderBefore(null);
+ void getPartnerHistoryPage(partnerId, selectedKey, { limit: 100 })
+ .then((page) => {
+ if (!cancelled) {
+ setMessages(page.messages);
+ setOlderBefore(page.next_before);
+ }
})
.catch((e) => {
if (!cancelled) {
@@ -148,6 +162,32 @@ export default function PartnerArchives({
};
}, [partnerId, selectedKey, onToast, t]);
+ const loadOlder = useCallback(async () => {
+ if (!selectedKey || olderBefore === null || loadingOlder) return;
+ const container = messageScrollRef.current;
+ const previousHeight = container?.scrollHeight ?? 0;
+ const previousTop = container?.scrollTop ?? 0;
+ setLoadingOlder(true);
+ try {
+ const page = await getPartnerHistoryPage(partnerId, selectedKey, {
+ before: olderBefore,
+ limit: 100,
+ });
+ if (selectedKeyRef.current !== selectedKey) return;
+ setMessages((current) => [...page.messages, ...current]);
+ setOlderBefore(page.next_before);
+ requestAnimationFrame(() => {
+ if (selectedKeyRef.current === selectedKey && container) {
+ container.scrollTop = previousTop + container.scrollHeight - previousHeight;
+ }
+ });
+ } catch (error) {
+ onToast(error instanceof Error ? error.message : t("Load failed"));
+ } finally {
+ if (selectedKeyRef.current === selectedKey) setLoadingOlder(false);
+ }
+ }, [selectedKey, olderBefore, loadingOlder, partnerId, onToast, t]);
+
// Report the selected conversation up for header export controls.
useEffect(() => {
if (!onMessagesChange) return;
@@ -168,7 +208,7 @@ export default function PartnerArchives({
<div className="mb-3 flex items-center justify-between gap-2">
<div>
<h2 className="text-[13px] font-medium text-[var(--foreground)]">
- {t("Archived conversations")}
+ {t("Conversations")}
</h2>
<p className="text-[11.5px] text-[var(--muted-foreground)]">
{sessions.length
@@ -256,7 +296,7 @@ export default function PartnerArchives({
</div>
</div>
- <div className="min-h-0 overflow-y-auto">
+ <div ref={messageScrollRef} className="min-h-0 overflow-y-auto">
{selected ? (
<div className="mx-auto max-w-2xl pb-4">
<div className="sticky top-0 z-10 border-b border-[var(--border)] bg-[var(--background)] py-2">
@@ -301,6 +341,16 @@ export default function PartnerArchives({
</div>
<div className="space-y-4 py-4">
+ {olderBefore !== null && !loadingMessages ? (
+ <button
+ type="button"
+ onClick={() => void loadOlder()}
+ disabled={loadingOlder}
+ className="mx-auto block rounded-md border border-[var(--border)] px-3 py-1.5 text-[12px] text-[var(--muted-foreground)] hover:bg-[var(--muted)] disabled:opacity-50"
+ >
+ {loadingOlder ? t("Loading...") : t("Load older messages")}
+ </button>
+ ) : null}
{loadingMessages ? (
<p className="text-[12px] text-[var(--muted-foreground)]">
{t("Loading...")}
diff --git a/web/components/partners/PartnerChat.tsx b/web/components/partners/PartnerChat.tsx
index f3e6703b0..83352ada7 100644
--- a/web/components/partners/PartnerChat.tsx
+++ b/web/components/partners/PartnerChat.tsx
@@ -20,9 +20,10 @@ import {
archivePartnerSession,
branchPartnerSession,
deletePartnerSession,
- getPartnerHistory,
+ getPartnerHistoryPage,
getPartnerSessions,
resumePartnerSession,
+ type PartnerHistoryMessage,
} from "@/lib/partners-api";
import { freshPartnerSessionKey } from "@/lib/partner-session";
import { displaySessionTitle } from "@/lib/session-title";
@@ -58,6 +59,7 @@ interface ChatMsg {
/** Full turn event stream (live turns only; restored history has none). */
events?: StreamEvent[];
error?: boolean;
+ optimisticId?: number;
}
interface ExternalDraft {
@@ -124,6 +126,22 @@ function normalizeHistoryAttachments(
.filter((item): item is PartnerMessageAttachment => item !== null);
}
+function normalizeHistoryMessages(history: PartnerHistoryMessage[]): ChatMsg[] {
+ return history
+ .filter((message) => message.role === "user" || message.role === "assistant")
+ .map((message) => ({
+ role: message.role as "user" | "assistant",
+ content: message.content,
+ activityId:
+ typeof message.metadata?.activity_id === "string"
+ ? message.metadata.activity_id
+ : undefined,
+ channel: message.channel,
+ attachments: normalizeHistoryAttachments(message.attachments),
+ events: normalizeHistoryEvents(message.events),
+ }));
+}
+
function sentAttachmentsForMessage(
attachments: PartnerPendingAttachment[],
): PartnerMessageAttachment[] {
@@ -207,6 +225,10 @@ export default function PartnerChat({
onToast,
onMessagesChange,
onRuntimeReady,
+ onBusyChange,
+ switchingSession = false,
+ sharedAcrossBrowsers = false,
+ onSelectionStale,
embedded = false,
}: {
partnerId: string;
@@ -218,7 +240,7 @@ export default function PartnerChat({
* Archive tab can switch which conversation the Chat tab is on. */
sessionKey: string;
/** Rotate to a different session (new / branch / resume / delete-current). */
- onSessionKeyChange?: (key: string) => void;
+ onSessionKeyChange?: (key: string, alreadySaved?: boolean) => void | Promise<void>;
/** Keep an embedded consultation on its bound conversation. */
embedded?: boolean;
onToast?: (message: string) => void;
@@ -228,10 +250,40 @@ export default function PartnerChat({
onMessagesChange?: (messages: ExportableMessage[]) => void;
/** The socket sends ready only after the on-demand partner runtime exists. */
onRuntimeReady?: () => void;
+ /** Let the owning page defer cross-browser selection changes during a turn. */
+ onBusyChange?: (busy: boolean) => void;
+ switchingSession?: boolean;
+ sharedAcrossBrowsers?: boolean;
+ onSelectionStale?: () => void | Promise<void>;
}) {
const { t } = useTranslation();
const [messages, setMessages] = useState<ChatMsg[]>([]);
+ const [olderBefore, setOlderBefore] = useState<number | null>(null);
+ const [loadingOlder, setLoadingOlder] = useState(false);
+ const [historyLoadedKey, setHistoryLoadedKey] = useState("");
+ const [historyLoadError, setHistoryLoadError] = useState(false);
+ const [historyRetry, setHistoryRetry] = useState(0);
+ const [reconciling, setReconciling] = useState(false);
+ const [commandBusy, setCommandBusy] = useState(false);
+ const commandBusyRef = useRef(false);
+ const [restoreDraft, setRestoreDraft] = useState<{
+ id: number;
+ content: string;
+ attachments: PartnerPendingAttachment[];
+ } | null>(null);
+ const nextSendIdRef = useRef(0);
+ const pendingSendRef = useRef<{
+ id: number;
+ content: string;
+ attachments: PartnerPendingAttachment[];
+ visibleContent: string;
+ baselineTotal: number;
+ } | null>(null);
+ const orphanPendingRef = useRef(false);
+ const acceptedRef = useRef(false);
const [streaming, setStreaming] = useState(false);
+ const streamingRef = useRef(streaming);
+ streamingRef.current = streaming;
const [connected, setConnected] = useState(false);
// Live turn snapshot for rendering. The authoritative accumulator is a
// local variable inside the socket effect (event handlers may mutate it
@@ -246,6 +298,11 @@ export default function PartnerChat({
// over the effect's first render) attaches to the CURRENT session.
const sessionKeyRef = useRef(sessionKey);
sessionKeyRef.current = sessionKey;
+ const loadedTotalRef = useRef(0);
+ const oldestIndexRef = useRef(0);
+ const refreshInFlightRef = useRef(false);
+ useEffect(() => onBusyChange?.(streaming), [onBusyChange, streaming]);
+ useEffect(() => () => onBusyChange?.(false), [onBusyChange]);
// Attach to an in-flight turn only AFTER history has loaded, so the replay's
// echoed question + answer aren't clobbered by the history replace. Attach
// once per socket connection.
@@ -301,40 +358,133 @@ export default function PartnerChat({
let cancelled = false;
historyReadyRef.current = false;
attachedRef.current = false;
- void getPartnerHistory(partnerId, { sessionKey, limit: 60 })
- .then((history) => {
+ acceptedRef.current = false;
+ loadedTotalRef.current = 0;
+ oldestIndexRef.current = 0;
+ setMessages([]);
+ setOlderBefore(null);
+ setLoadingOlder(false);
+ setHistoryLoadedKey("");
+ setHistoryLoadError(false);
+ void getPartnerHistoryPage(partnerId, sessionKey, { limit: 60 })
+ .then((page) => {
if (cancelled) return;
shouldAutoScrollRef.current = true;
- setMessages(
- history
- .filter((m) => m.role === "user" || m.role === "assistant")
- .map((m) => {
- const activityId =
- typeof m.metadata?.activity_id === "string"
- ? m.metadata.activity_id
- : undefined;
- return {
- role: m.role as "user" | "assistant",
- content: m.content,
- activityId,
- channel: m.channel,
- attachments: normalizeHistoryAttachments(m.attachments),
- events: normalizeHistoryEvents(m.events),
- };
- }),
- );
+ setMessages(normalizeHistoryMessages(page.messages));
+ setOlderBefore(page.next_before);
+ loadedTotalRef.current = page.total;
+ oldestIndexRef.current = page.start;
+ setHistoryLoadedKey(sessionKey);
historyReadyRef.current = true;
tryAttach();
requestAnimationFrame(() => scrollToBottom("instant"));
})
.catch(() => {
+ if (cancelled) return;
+ setHistoryLoadError(true);
historyReadyRef.current = true;
tryAttach();
});
return () => {
cancelled = true;
};
- }, [partnerId, sessionKey, scrollToBottom, shouldAutoScrollRef, tryAttach]);
+ }, [partnerId, sessionKey, historyRetry, scrollToBottom, shouldAutoScrollRef, tryAttach]);
+
+ const loadOlder = useCallback(async () => {
+ if (olderBefore === null || loadingOlder) return;
+ const key = sessionKey;
+ const container = scrollRef.current;
+ const previousHeight = container?.scrollHeight ?? 0;
+ const previousTop = container?.scrollTop ?? 0;
+ shouldAutoScrollRef.current = false;
+ setLoadingOlder(true);
+ try {
+ const page = await getPartnerHistoryPage(partnerId, key, {
+ before: olderBefore,
+ limit: 60,
+ });
+ if (sessionKeyRef.current !== key) return;
+ setMessages((current) => [...normalizeHistoryMessages(page.messages), ...current]);
+ setOlderBefore(page.next_before);
+ oldestIndexRef.current = page.start;
+ requestAnimationFrame(() => {
+ if (sessionKeyRef.current !== key || !container) return;
+ container.scrollTop = previousTop + container.scrollHeight - previousHeight;
+ });
+ } catch (error) {
+ onToast?.(error instanceof Error ? error.message : t("Load failed"));
+ } finally {
+ if (sessionKeyRef.current === key) setLoadingOlder(false);
+ }
+ }, [olderBefore, loadingOlder, sessionKey, scrollRef, shouldAutoScrollRef, partnerId, onToast, t]);
+
+ const refreshSharedHistory = useCallback(async () => {
+ if (
+ !sharedAcrossBrowsers ||
+ streaming ||
+ draft ||
+ externalDrafts.length > 0 ||
+ document.visibilityState !== "visible" ||
+ !historyReadyRef.current ||
+ historyLoadedKey !== sessionKey ||
+ refreshInFlightRef.current
+ ) return;
+ refreshInFlightRef.current = true;
+ const key = sessionKeyRef.current;
+ try {
+ const latest = await getPartnerHistoryPage(partnerId, key, { limit: 60 });
+ if (
+ sessionKeyRef.current !== key ||
+ streamingRef.current ||
+ pendingSendRef.current ||
+ latest.total === loadedTotalRef.current
+ ) return;
+ const chunks = [latest.messages];
+ let before = latest.next_before;
+ let firstIndex = latest.start;
+ // Preserve already loaded older history while refreshing the newest
+ // segment. Each request remains bounded even for long conversations.
+ while (before !== null && before > oldestIndexRef.current) {
+ const older = await getPartnerHistoryPage(partnerId, key, {
+ before,
+ limit: 60,
+ });
+ if (sessionKeyRef.current !== key || streamingRef.current || pendingSendRef.current) return;
+ chunks.unshift(older.messages);
+ before = older.next_before;
+ firstIndex = older.start;
+ }
+ if (sessionKeyRef.current !== key || streamingRef.current || pendingSendRef.current) return;
+ setMessages((current) =>
+ streamingRef.current || pendingSendRef.current
+ ? current
+ : [
+ ...normalizeHistoryMessages(chunks.flat()),
+ ...current.filter((message) => message.error),
+ ],
+ );
+ setOlderBefore(before);
+ loadedTotalRef.current = latest.total;
+ oldestIndexRef.current = firstIndex;
+ } catch {
+ // Keep the visible transcript and retry on the next idle poll.
+ } finally {
+ refreshInFlightRef.current = false;
+ }
+ }, [sharedAcrossBrowsers, streaming, draft, externalDrafts.length, historyLoadedKey, sessionKey, partnerId]);
+
+ useEffect(() => {
+ if (!sharedAcrossBrowsers) return;
+ const refresh = () => void refreshSharedHistory();
+ const timer = window.setInterval(refresh, 15_000);
+ window.addEventListener("focus", refresh);
+ document.addEventListener("visibilitychange", refresh);
+ return () => {
+ window.clearInterval(timer);
+ window.removeEventListener("focus", refresh);
+ document.removeEventListener("visibilitychange", refresh);
+ };
+ }, [sharedAcrossBrowsers, refreshSharedHistory]);
useEffect(() => {
attachedRef.current = false;
@@ -362,6 +512,7 @@ export default function PartnerChat({
let data: {
type: string;
content?: string;
+ session_key?: string;
event?: StreamEvent;
activity_id?: string;
channel?: string;
@@ -449,11 +600,83 @@ export default function PartnerChat({
}
if (data.type === "resuming") {
// Server is about to replay an in-flight turn (after a refresh).
+ orphanPendingRef.current = false;
+ acceptedRef.current = true;
+ setReconciling(false);
live = { events: [], content: "" };
setStreaming(true);
publish();
return;
}
+ if (data.type === "turn_busy" || data.type === "stale_session") {
+ const rejected = pendingSendRef.current;
+ pendingSendRef.current = null;
+ acceptedRef.current = false;
+ if (rejected) {
+ setMessages((current) =>
+ current.filter((message) => message.optimisticId !== rejected.id),
+ );
+ setRestoreDraft(rejected);
+ }
+ live = null;
+ setDraft(null);
+ setStreaming(false);
+ setReconciling(false);
+ if (data.type === "stale_session") {
+ void onSelectionStale?.();
+ onToast?.(t("Conversation changed in another browser. Please retry."));
+ } else {
+ onToast?.(t("This conversation is already replying. Please wait."));
+ }
+ return;
+ }
+ if (data.type === "accepted") {
+ acceptedRef.current = true;
+ return;
+ }
+ if (data.type === "attach_busy" && data.session_key === sessionKeyRef.current) {
+ if (orphanPendingRef.current) {
+ window.setTimeout(() => {
+ if (!orphanPendingRef.current || sessionKeyRef.current !== data.session_key) return;
+ attachedRef.current = false;
+ tryAttach();
+ }, 2_000);
+ }
+ return;
+ }
+ if (data.type === "attach_idle" && data.session_key === sessionKeyRef.current) {
+ if (!orphanPendingRef.current) return;
+ const key = data.session_key;
+ const pending = pendingSendRef.current;
+ void getPartnerHistoryPage(partnerId, key, { limit: 60 })
+ .then((page) => {
+ if (sessionKeyRef.current !== key || !orphanPendingRef.current) return;
+ const persisted = pending && page.messages.some((item, index) =>
+ page.start + index >= pending.baselineTotal &&
+ item.role === "user" && item.content === pending.visibleContent,
+ );
+ setMessages(normalizeHistoryMessages(page.messages));
+ setOlderBefore(page.next_before);
+ loadedTotalRef.current = page.total;
+ oldestIndexRef.current = page.start;
+ pendingSendRef.current = null;
+ acceptedRef.current = false;
+ orphanPendingRef.current = false;
+ setStreaming(false);
+ setDraft(null);
+ setReconciling(false);
+ if (pending && !persisted) setRestoreDraft(pending);
+ })
+ .catch(() => {
+ if (sessionKeyRef.current !== key) return;
+ window.setTimeout(() => {
+ if (!orphanPendingRef.current || sessionKeyRef.current !== key) return;
+ attachedRef.current = false;
+ tryAttach();
+ }, 2_000);
+ });
+ return;
+ }
if (data.type === "user_echo") {
// Reconnects replay the active question. Keep the optimistic row that
// is already present in this mounted page instead of duplicating it.
@@ -493,6 +716,10 @@ export default function PartnerChat({
]);
publishNow();
} else if (data.type === "done") {
+ pendingSendRef.current = null;
+ acceptedRef.current = false;
+ orphanPendingRef.current = false;
+ setReconciling(false);
setStreaming(false);
live = null;
publishNow();
@@ -511,6 +738,10 @@ export default function PartnerChat({
},
]);
}
+ pendingSendRef.current = null;
+ acceptedRef.current = false;
+ orphanPendingRef.current = false;
+ setReconciling(false);
setStreaming(false);
publishNow();
} else if (data.type === "proactive") {
@@ -519,10 +750,20 @@ export default function PartnerChat({
{ role: "assistant", content: data.content ?? "" },
]);
} else if (data.type === "error") {
- setMessages((msgs) => [
- ...msgs,
- { role: "assistant", content: data.content ?? "Error", error: true },
- ]);
+ const rejected = !acceptedRef.current ? pendingSendRef.current : null;
+ if (rejected) {
+ pendingSendRef.current = null;
+ setMessages((current) =>
+ current.filter((item) => item.optimisticId !== rejected.id),
+ );
+ setRestoreDraft(rejected);
+ onToast?.(data.content ?? t("Action failed"));
+ } else {
+ setMessages((msgs) => [
+ ...msgs,
+ { role: "assistant", content: data.content ?? "Error", error: true },
+ ]);
+ }
live = null;
publishNow();
setStreaming(false);
@@ -542,6 +783,8 @@ export default function PartnerChat({
onMessage: handleMessage,
onDisconnect: () => {
setConnected(false);
+ orphanPendingRef.current = Boolean(pendingSendRef.current || streamingRef.current);
+ if (orphanPendingRef.current) setReconciling(true);
setStreaming(false);
externalLive.clear();
setExternalDrafts([]);
@@ -577,7 +820,7 @@ export default function PartnerChat({
connection.stop();
if (connectionRef.current === connection) connectionRef.current = null;
};
- }, [onRuntimeReady, partnerId, tryAttach]);
+ }, [onRuntimeReady, onSelectionStale, onToast, partnerId, t, tryAttach]);
// Report the settled transcript to the parent for header export controls.
useEffect(() => {
@@ -633,23 +876,42 @@ export default function PartnerChat({
switch (command) {
case "/new":
case "/clear": {
- await archivePartnerSession(partnerId, sessionKey).catch(() => {});
- setMessages([]);
- onSessionKeyChange?.(freshPartnerSessionKey());
+ const next = freshPartnerSessionKey();
+ if (messages.length === 0) {
+ await onSessionKeyChange?.(next);
+ break;
+ }
+ try {
+ const result = await archivePartnerSession(partnerId, sessionKey);
+ setMessages([]);
+ if (sharedAcrossBrowsers) {
+ if (result.active_session_key) await onSessionKeyChange?.(result.active_session_key, true);
+ else await onSelectionStale?.();
+ } else {
+ await onSessionKeyChange?.(next);
+ }
+ } catch (error) {
+ onToast?.(error instanceof Error ? error.message : t("Action failed"));
+ }
break;
}
case "/branch": {
const next = freshPartnerSessionKey();
try {
- await branchPartnerSession(partnerId, sessionKey, next);
+ const result = await branchPartnerSession(partnerId, sessionKey, next);
onToast?.(
t("Branched — the original is archived as {{id}}", {
id: sessionKey,
}),
);
- onSessionKeyChange?.(next); // history reload picks up the copy
- } catch {
- onToast?.(t("Nothing to branch yet."));
+ if (sharedAcrossBrowsers) {
+ if (result.active_session_key) await onSessionKeyChange?.(result.active_session_key, true);
+ else await onSelectionStale?.();
+ } else {
+ await onSessionKeyChange?.(next); // history reload picks up the copy
+ }
+ } catch (error) {
+ onToast?.(error instanceof Error ? error.message : t("Nothing to branch yet."));
}
break;
}
@@ -659,8 +921,13 @@ export default function PartnerChat({
break;
}
try {
- await resumePartnerSession(partnerId, arg);
- onSessionKeyChange?.(arg);
+ const result = await resumePartnerSession(partnerId, arg);
+ if (sharedAcrossBrowsers) {
+ if (result.active_session_key) await onSessionKeyChange?.(result.active_session_key, true);
+ else await onSelectionStale?.();
+ } else {
+ await onSessionKeyChange?.(arg);
+ }
} catch {
onToast?.(t("Session not found"));
}
@@ -672,11 +939,18 @@ export default function PartnerChat({
break;
}
try {
- await deletePartnerSession(partnerId, arg);
+ const result = await deletePartnerSession(partnerId, arg);
onToast?.(t("Conversation deleted"));
if (arg === sessionKey) {
setMessages([]);
- onSessionKeyChange?.(freshPartnerSessionKey());
+ if (sharedAcrossBrowsers) {
+ if (result.active_session_key) await onSessionKeyChange?.(result.active_session_key, true);
+ else await onSelectionStale?.();
+ } else {
+ await onSessionKeyChange?.(freshPartnerSessionKey());
+ }
+ } else if (sharedAcrossBrowsers && result.active_session_key) {
+ await onSessionKeyChange?.(result.active_session_key, true);
}
} catch {
onToast?.(t("Session not found"));
@@ -720,7 +994,10 @@ export default function PartnerChat({
[
partnerId,
sessionKey,
+ messages.length,
+ sharedAcrossBrowsers,
onSessionKeyChange,
+ onSelectionStale,
onToast,
scrollToBottom,
sendStop,
@@ -729,8 +1006,8 @@ export default function PartnerChat({
);
const handleSend = useCallback(
- (content: string, attachments: PartnerPendingAttachment[]) => {
- if (streaming || !connected) return false;
+ (content: string, attachments: PartnerPendingAttachment[]): boolean | "handled" => {
+ if (streaming || reconciling || commandBusyRef.current || !connected || switchingSession || historyLoadedKey !== sessionKey) return false;
// A new user-authored turn explicitly returns to live-follow mode.
// During the answer, the shared hook releases that mode as soon as the
@@ -739,8 +1016,15 @@ export default function PartnerChat({
const command =
attachments.length === 0 ? parseClientCommand(content) : null;
if (command) {
- void runClientCommand(command.command, command.arg);
- return false;
+ if (command.command !== "/sessions" && command.command !== "/stop") {
+ commandBusyRef.current = true;
+ setCommandBusy(true);
+ }
+ void runClientCommand(command.command, command.arg).finally(() => {
+ commandBusyRef.current = false;
+ setCommandBusy(false);
+ });
+ return "handled";
}
const visibleContent =
@@ -761,12 +1045,22 @@ export default function PartnerChat({
}),
);
if (!sent) return false;
+ const optimisticId = ++nextSendIdRef.current;
+ acceptedRef.current = false;
+ pendingSendRef.current = {
+ id: optimisticId,
+ content,
+ attachments: [...attachments],
+ visibleContent,
+ baselineTotal: loadedTotalRef.current,
+ };
setMessages((msgs) => [
...msgs,
{
role: "user",
content: visibleContent,
attachments: sentAttachmentsForMessage(attachments),
+ optimisticId,
},
]);
setDraft({ events: [], content: "" });
@@ -778,6 +1072,9 @@ export default function PartnerChat({
sessionKey,
connected,
streaming,
+ reconciling,
+ switchingSession,
+ historyLoadedKey,
scrollToBottom,
runClientCommand,
shouldAutoScrollRef,
@@ -793,6 +1090,18 @@ export default function PartnerChat({
onScroll={handleScroll}
className="min-h-0 flex-1 overflow-y-auto px-1 py-4"
>
+ {historyLoadError ? (
+ <div className="flex items-center justify-center gap-2 py-2 text-[12px] text-[var(--muted-foreground)]">
+ {t("Load failed")}
+ <button
+ type="button"
+ onClick={() => setHistoryRetry((value) => value + 1)}
+ className="rounded-md border border-[var(--border)] px-2 py-1 text-[var(--foreground)]"
+ >
+ {t("Retry")}
+ </button>
+ </div>
+ ) : null}
{messages.length === 0 && !draft ? (
<div className="flex h-full flex-col items-center justify-center gap-3 text-center">
<PartnerAvatar
@@ -815,6 +1124,16 @@ export default function PartnerChat({
</div>
) : (
<div className="mx-auto flex max-w-2xl flex-col gap-5">
+ {olderBefore !== null ? (
+ <button
+ type="button"
+ onClick={() => void loadOlder()}
+ disabled={loadingOlder}
+ className="self-center rounded-md border border-[var(--border)] px-3 py-1.5 text-[12px] text-[var(--muted-foreground)] hover:bg-[var(--muted)] disabled:opacity-50"
+ >
+ {loadingOlder ? t("Loading...") : t("Load older messages")}
+ </button>
+ ) : null}
{messages.map((msg, i) =>
msg.role === "user" ? (
<div key={i} className="flex justify-end">
@@ -923,7 +1242,8 @@ export default function PartnerChat({
onSend={handleSend}
onStop={sendStop}
streaming={streaming}
- disabled={!connected}
+ disabled={!connected || reconciling || commandBusy || switchingSession || historyLoadedKey !== sessionKey}
+ restoreDraft={restoreDraft ?? undefined}
/>
</div>
</div>
diff --git a/web/components/partners/PartnerComposer.tsx b/web/components/partners/PartnerComposer.tsx
index a90f63043..6986223d9 100644
--- a/web/components/partners/PartnerComposer.tsx
+++ b/web/components/partners/PartnerComposer.tsx
@@ -44,19 +44,36 @@ export const PartnerComposer = memo(function PartnerComposer({
disabled,
streaming,
placeholder,
+ restoreDraft,
}: {
- /** Returns true when sending starts an asynchronous streamed response. */
- onSend: (content: string, attachments: PartnerPendingAttachment[]) => boolean;
+ /** True starts a turn, "handled" consumes a client command, false keeps the draft. */
+ onSend: (content: string, attachments: PartnerPendingAttachment[]) => boolean | "handled";
onStop?: () => void;
disabled?: boolean;
streaming?: boolean;
placeholder?: string;
+ /** A rejected cross-browser send restores the cleared text and attachments. */
+ restoreDraft?: {
+ id: number;
+ content: string;
+ attachments: PartnerPendingAttachment[];
+ };
}) {
const { t } = useTranslation();
const [input, setInput] = useState("");
const [attachments, setAttachments] = useState<PartnerPendingAttachment[]>(
[],
);
+ useEffect(() => {
+ if (!restoreDraft) return;
+ let cancelled = false;
+ queueMicrotask(() => {
+ if (cancelled) return;
+ setInput(restoreDraft.content);
+ setAttachments(restoreDraft.attachments);
+ });
+ return () => { cancelled = true; };
+ }, [restoreDraft]);
const attachmentLimits = useAttachmentLimits();
const [dragging, setDragging] = useState(false);
const [attachmentError, setAttachmentError] = useState<string | null>(null);
@@ -241,10 +258,14 @@ export const PartnerComposer = memo(function PartnerComposer({
const submit = useCallback(() => {
const content = input.trim();
if ((!content && attachments.length === 0) || disabled) return;
- const awaitsResponse = onSend(content, attachments);
+ const result = onSend(content, attachments);
+ if (result === false) {
+ focusTextarea();
+ return;
+ }
setInput("");
setAttachments([]);
- if (awaitsResponse) {
+ if (result === true) {
restoreFocusAfterSendRef.current = true;
} else {
focusTextarea();
diff --git a/web/lib/partner-session.ts b/web/lib/partner-session.ts
index 46d7c0ed5..be4baae54 100644
--- a/web/lib/partner-session.ts
+++ b/web/lib/partner-session.ts
@@ -7,29 +7,85 @@
import { browserStorage } from "@/shared/storage";
-function storageKey(partnerId: string): string {
- return `partner-session:${partnerId}`;
+function storageKey(partnerId: string, accountId?: string | null): string {
+ return accountId
+ ? `partner-session:${accountId}:${partnerId}`
+ : `partner-session:${partnerId}`;
+}
+
+/** Read without creating a key; callers decide whether an old key is owned by
+ * the current account before migrating it. */
+export function readPartnerSessionKey(
+ partnerId: string,
+ accountId: string,
+): string | null {
+ try {
+ return browserStorage.readRaw("local", storageKey(partnerId, accountId)) || null;
+ } catch {
+ return null;
+ }
+}
+
+export function readLegacyPartnerSessionKey(partnerId: string): string | null {
+ try {
+ return browserStorage.readRaw("local", storageKey(partnerId)) || null;
+ } catch {
+ return null;
+ }
+}
+
+export async function initializePartnerSessionKey(
+ partnerId: string,
+ accountId: string | null,
+ auth: { enabled: boolean; isAdmin: boolean; statusAvailable: boolean },
+ listSessionKeys: () => Promise<string[]>,
+): Promise<string> {
+ if (!accountId) return freshPartnerSessionKey();
+ const scoped = readPartnerSessionKey(partnerId, accountId);
+ if (scoped) return scoped;
+
+ let key: string | null = null;
+ const legacy = readLegacyPartnerSessionKey(partnerId);
+ if (legacy && auth.statusAvailable) {
+ if (!auth.enabled && auth.isAdmin) {
+ key = legacy;
+ } else if (!auth.isAdmin) {
+ const owned = await listSessionKeys().catch((): string[] => []);
+ if (owned.includes(legacy)) key = legacy;
+ }
+ }
+ key ||= freshPartnerSessionKey();
+ persistPartnerSessionKey(partnerId, key, accountId);
+ return key;
}
export function freshPartnerSessionKey(): string {
return `web-${Math.random().toString(36).slice(2, 10)}`;
}
-export function loadPartnerSessionKey(partnerId: string): string {
+export function loadPartnerSessionKey(
+ partnerId: string,
+ accountId?: string | null,
+): string {
try {
- const existing = browserStorage.readRaw("local", storageKey(partnerId));
+ const key = storageKey(partnerId, accountId);
+ const existing = browserStorage.readRaw("local", key);
if (existing) return existing;
const fresh = freshPartnerSessionKey();
- browserStorage.writeRaw("local", storageKey(partnerId), fresh);
+ browserStorage.writeRaw("local", key, fresh);
return fresh;
} catch {
return freshPartnerSessionKey();
}
}
-export function persistPartnerSessionKey(partnerId: string, key: string): void {
+export function persistPartnerSessionKey(
+ partnerId: string,
+ key: string,
+ accountId?: string | null,
+): void {
try {
- browserStorage.writeRaw("local", storageKey(partnerId), key);
+ browserStorage.writeRaw("local", storageKey(partnerId, accountId), key);
} catch {
/* private mode / storage disabled — in-memory only */
}
diff --git a/web/lib/partners-api.ts b/web/lib/partners-api.ts
index 1ccaeb344..523236e3c 100644
--- a/web/lib/partners-api.ts
+++ b/web/lib/partners-api.ts
@@ -105,6 +105,31 @@ export interface PartnerSessionInfo {
scope?: string;
}
+export interface PartnerWebContinuity {
+ enabled: boolean;
+ session_key: string | null;
+}
+
+export interface PartnerHistoryMessage {
+ role: string;
+ content: string;
+ timestamp?: string;
+ channel?: string;
+ sender_id?: string;
+ metadata?: Record<string, unknown>;
+ attachments?: Record<string, unknown>[];
+ /** Persisted turn trace (assistant rows only) for rehydrating activity. */
+ events?: Record<string, unknown>[];
+}
+
+export interface PartnerHistoryPage {
+ messages: PartnerHistoryMessage[];
+ next_before: number | null;
+ /** Index of the first record returned, and current record count. */
+ start: number;
+ total: number;
+}
+
export interface PartnerCommandInfo {
command: string;
description: string;
@@ -500,19 +525,7 @@ export async function getChannelSchemas(): Promise<ChannelsSchemaResponse> {
export async function getPartnerHistory(
partnerId: string,
options?: { sessionKey?: string; sessionId?: string; limit?: number },
-): Promise<
- {
- role: string;
- content: string;
- timestamp?: string;
- channel?: string;
- sender_id?: string;
- metadata?: Record<string, unknown>;
- attachments?: Record<string, unknown>[];
- /** Persisted turn trace (assistant rows only) for rehydrating activity. */
- events?: Record<string, unknown>[];
- }[]
-> {
+): Promise<PartnerHistoryMessage[]> {
const params = new URLSearchParams();
if (options?.sessionKey) params.set("session_key", options.sessionKey);
if (options?.sessionId) params.set("session_id", options.sessionId);
@@ -525,6 +538,51 @@ export async function getPartnerHistory(
);
}
+export async function getPartnerHistoryPage(
+ partnerId: string,
+ sessionKey: string,
+ options?: { before?: number; limit?: number },
+): Promise<PartnerHistoryPage> {
+ const params = new URLSearchParams({ session_key: sessionKey });
+ if (options?.before !== undefined) params.set("before", String(options.before));
+ if (options?.limit !== undefined) params.set("limit", String(options.limit));
+ return json(
+ await apiFetch(
+ apiUrl(
+ `/api/partners/${encodeURIComponent(partnerId)}/history/page?${params.toString()}`,
+ ),
+ { cache: "no-store" },
+ ),
+ );
+}
+
+export async function getPartnerWebContinuity(
+ partnerId: string,
+): Promise<PartnerWebContinuity> {
+ return json(
+ await apiFetch(
+ apiUrl(`/api/partners/${encodeURIComponent(partnerId)}/web-continuity`),
+ { cache: "no-store" },
+ ),
+ );
+}
+
+export async function setPartnerWebContinuity(
+ partnerId: string,
+ state: PartnerWebContinuity,
+): Promise<PartnerWebContinuity> {
+ return json(
+ await apiFetch(
+ apiUrl(`/api/partners/${encodeURIComponent(partnerId)}/web-continuity`),
+ {
+ method: "PUT",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(state),
+ },
+ ),
+ );
+}
+
export async function getPartnerSessions(
partnerId: string,
): Promise<PartnerSessionInfo[]> {
@@ -540,8 +598,8 @@ async function postSessionAction(
partnerId: string,
action: "archive" | "resume" | "delete",
sessionKey: string,
-): Promise<void> {
- await json(
+): Promise<{ active_session_key: string | null }> {
+ return json(
await apiFetch(
apiUrl(
`/api/partners/${encodeURIComponent(partnerId)}/sessions/${action}`,
@@ -571,7 +629,7 @@ export async function branchPartnerSession(
partnerId: string,
sourceKey: string,
newKey: string,
-): Promise<{ session: PartnerSessionInfo }> {
+): Promise<{ session: PartnerSessionInfo; active_session_key: string | null }> {
return json(
await apiFetch(
apiUrl(`/api/partners/${encodeURIComponent(partnerId)}/sessions/branch`),
diff --git a/web/locales/en/app.json b/web/locales/en/app.json
index 36a7f01c5..ae4086792 100644
--- a/web/locales/en/app.json
+++ b/web/locales/en/app.json
@@ -3090,6 +3090,12 @@
"Edit course": "Edit course",
"Delete course": "Delete course",
"Conversations": "Conversations",
+ "Sync browsers": "Sync browsers",
+ "Share this conversation across browsers": "Share this conversation across browsers",
+ "Load older messages": "Load older messages",
+ "Could not load browser sync state": "Could not load browser sync state",
+ "Conversation changed in another browser. Please retry.": "Conversation changed in another browser. Please retry.",
+ "This conversation is already replying. Please wait.": "This conversation is already replying. Please wait.",
"Tutor threads stay nested under the conversation they came from.": "Tutor threads stay nested under the conversation they came from.",
"Archived conversations": "Archived conversations",
"Delete course?": "Delete course?",
diff --git a/web/locales/fr/app.json b/web/locales/fr/app.json
index 99db89020..94590321f 100644
--- a/web/locales/fr/app.json
+++ b/web/locales/fr/app.json
@@ -3555,6 +3555,12 @@
"Edit course": "Modifier le cours",
"Delete course": "Supprimer le cours",
"Conversations": "Conversations",
+ "Sync browsers": "Synchroniser les navigateurs",
+ "Share this conversation across browsers": "Partager cette conversation entre navigateurs",
+ "Load older messages": "Charger les messages précédents",
+ "Could not load browser sync state": "Impossible de charger l’état de synchronisation des navigateurs",
+ "Conversation changed in another browser. Please retry.": "La conversation a changé dans un autre navigateur. Réessayez.",
+ "This conversation is already replying. Please wait.": "Cette conversation prépare déjà une réponse. Veuillez patienter.",
"Tutor threads stay nested under the conversation they came from.": "Les fils du tuteur restent imbriqués sous la conversation dont ils proviennent.",
"Archived conversations": "Conversations archivées",
"Delete course?": "Supprimer le cours ?",
diff --git a/web/locales/uk/app.json b/web/locales/uk/app.json
index 11812faf3..4f5301030 100644
--- a/web/locales/uk/app.json
+++ b/web/locales/uk/app.json
@@ -3001,6 +3001,12 @@
"Edit course": "Редагувати курс",
"Delete course": "Видалити курс",
"Conversations": "Чати",
+ "Sync browsers": "Синхронізувати браузери",
+ "Share this conversation across browsers": "Ділитися цим чатом між браузерами",
+ "Load older messages": "Завантажити давніші повідомлення",
+ "Could not load browser sync state": "Не вдалося завантажити стан синхронізації браузерів",
+ "Conversation changed in another browser. Please retry.": "Розмову змінено в іншому браузері. Спробуйте ще раз.",
+ "This conversation is already replying. Please wait.": "У цій розмові вже готується відповідь. Зачекайте.",
"Tutor threads stay nested under the conversation they came from.": "Гілки тьютора залишаються вкладеними в чат, з якого вони походять.",
"Archived conversations": "Заархівовані чати",
"Delete course?": "Видалити курс?",
diff --git a/web/locales/zh/app.json b/web/locales/zh/app.json
index 7d988b13f..e99034df8 100644
--- a/web/locales/zh/app.json
+++ b/web/locales/zh/app.json
@@ -3090,6 +3090,12 @@
"Edit course": "编辑课程",
"Delete course": "删除课程",
"Conversations": "聊天",
+ "Sync browsers": "跨浏览器同步",
+ "Share this conversation across browsers": "在多个浏览器之间共享当前聊天",
+ "Load older messages": "加载更早的消息",
+ "Could not load browser sync state": "无法加载浏览器同步状态",
+ "Conversation changed in another browser. Please retry.": "此聊天已在另一个浏览器中切换,请重试。",
+ "This conversation is already replying. Please wait.": "此聊天正在回复,请稍候。",
"Tutor threads stay nested under the conversation they came from.": "小老师追问会折叠在它所来源的聊天下面。",
"Archived conversations": "已归档聊天",
"Delete course?": "删除课程?",
diff --git a/web/tests/consultation-sidebar.spec.tsx b/web/tests/consultation-sidebar.spec.tsx
index 63e069d4d..b562cc99b 100644
--- a/web/tests/consultation-sidebar.spec.tsx
+++ b/web/tests/consultation-sidebar.spec.tsx
@@ -7,8 +7,15 @@ const fixture = vi.hoisted(() => ({
send: vi.fn(() => true),
frame: null as null | ((event: { data: string }) => void),
}))
+const translate = vi.hoisted(() => (key: string) => key)
+const autoScroll = vi.hoisted(() => ({
+ containerRef: { current: null },
+ shouldAutoScrollRef: { current: true },
+ handleScroll: () => {},
+ scrollToBottom: () => {},
+}))
vi.mock('react-i18next', () => ({
- useTranslation: () => ({ t: (key: string) => key, i18n: { language: 'en' } }),
+ useTranslation: () => ({ t: translate, i18n: { language: 'en' } }),
}))
vi.mock('@/features/chat/trace', () => ({
AssistantActivity: () => null,
@@ -24,12 +31,7 @@ vi.mock('next/dynamic', () => ({
}))
vi.mock('@/lib/api', () => ({ wsUrl: (path: string) => path }))
vi.mock('@/hooks/useChatAutoScroll', () => ({
- useChatAutoScroll: () => ({
- containerRef: { current: null },
- shouldAutoScrollRef: { current: true },
- handleScroll: vi.fn(),
- scrollToBottom: vi.fn(),
- }),
+ useChatAutoScroll: () => autoScroll,
}))
vi.mock('@/components/chat/home/TurnNavigator', () => ({ TurnNavigator: () => null }))
vi.mock('@/lib/reconnecting-websocket', () => ({
@@ -51,6 +53,12 @@ vi.mock('@/lib/reconnecting-websocket', () => ({
vi.mock('@/lib/partners-api', () => ({
getPartner: async () => ({ partner_id: 'frank', name: 'Frank', emoji: '🦊' }),
getPartnerHistory: async () => [{ role: 'user', content: 'Earlier question' }, { role: 'assistant', content: 'Earlier answer' }],
+ getPartnerHistoryPage: async () => ({
+ messages: [{ role: 'user', content: 'Earlier question' }, { role: 'assistant', content: 'Earlier answer' }],
+ next_before: null,
+ start: 0,
+ total: 2,
+ }),
getPartnerCommands: async () => [],
}))
vi.mock('@/lib/attachment-limits', () => ({ useAttachmentLimits: () => ({ maxBytes: 1000000, maxCount: 5 }) }))
diff --git a/web/tests/partner-channel-activity.test.ts b/web/tests/partner-channel-activity.test.ts
index 763b74e91..b14e66b93 100644
--- a/web/tests/partner-channel-activity.test.ts
+++ b/web/tests/partner-channel-activity.test.ts
@@ -11,7 +11,7 @@ const source = readFileSync(
test("partner chat restores only the active conversation", () => {
assert.match(
source,
- /getPartnerHistory\(partnerId, \{ sessionKey, limit: 60 \}\)/,
+ /getPartnerHistoryPage\(partnerId, sessionKey, \{ limit: 60 \}\)/,
);
});
@@ -27,7 +27,7 @@ test("partner chat renders external user echoes and live trace events", () => {
});
test("history activity ids prevent replayed channel turns from duplicating", () => {
- assert.match(source, /m\.metadata\?\.activity_id/);
+ assert.match(source, /message\.metadata\?\.activity_id/);
assert.match(
source,
/msg\.activityId === activityId && msg\.role === "user"/,
diff --git a/web/tests/partner-chat-continuity.spec.tsx b/web/tests/partner-chat-continuity.spec.tsx
new file mode 100644
index 000000000..c736c7b4c
--- /dev/null
+++ b/web/tests/partner-chat-continuity.spec.tsx
@@ -0,0 +1,244 @@
+import { act, render, screen, waitFor } from "@testing-library/react";
+import { beforeEach, expect, it, vi } from "vitest";
+import PartnerChat from "@/components/partners/PartnerChat";
+
+interface MockComposerProps {
+ onSend: (content: string, attachments: []) => boolean | "handled";
+ restoreDraft?: { id: number; content: string; attachments: unknown[] };
+ disabled?: boolean;
+}
+
+const api = vi.hoisted(() => ({
+ historyPage: vi.fn(),
+ sessions: vi.fn(),
+ commands: vi.fn(),
+}));
+const translate = vi.hoisted(() => (key: string) => key);
+const composer = vi.hoisted(() => ({ current: null as MockComposerProps | null }));
+const sockets = vi.hoisted(() => ({
+ instances: [] as Array<{
+ emit: (frame: Record<string, unknown>) => void;
+ messages: string[];
+ }>,
+}));
+
+vi.mock("react-i18next", () => ({ useTranslation: () => ({ t: translate }) }));
+vi.mock("@/lib/partners-api", () => ({
+ getPartnerHistoryPage: api.historyPage,
+ getPartnerSessions: api.sessions,
+ getPartnerCommands: api.commands,
+}));
+vi.mock("@/lib/reconnecting-websocket", () => {
+ class MockSocket {
+ connected = true;
+ messages: string[] = [];
+ constructor(
+ _url: string,
+ private handlers: {
+ onOpen: () => void;
+ onMessage: (event: MessageEvent) => void;
+ onDisconnect: () => void;
+ },
+ ) {
+ sockets.instances.push(this);
+ }
+ start() {
+ this.handlers.onOpen();
+ this.emit({ type: "ready" });
+ }
+ send(payload: string) {
+ this.messages.push(payload);
+ return true;
+ }
+ stop() {}
+ wake() {}
+ emit(frame: Record<string, unknown>) {
+ this.handlers.onMessage({ data: JSON.stringify(frame) } as MessageEvent);
+ }
+ disconnect() {
+ this.handlers.onDisconnect();
+ }
+ }
+ return { ReconnectingWebSocket: MockSocket };
+});
+vi.mock("@/components/partners/PartnerComposer", () => ({
+ PartnerComposer: (props: MockComposerProps) => {
+ composer.current = props;
+ return <div data-testid="composer" />;
+ },
+}));
+vi.mock("@/components/partners/PartnerAvatar", () => ({
+ default: () => <div data-testid="avatar" />,
+}));
+vi.mock("@/features/chat/trace", () => ({ AssistantActivity: () => null }));
+vi.mock("next/dynamic", () => ({
+ default: () => ({ content }: { content: string }) => <span>{content}</span>,
+}));
+vi.mock("@/hooks/useChatAutoScroll", async () => {
+ const React = await import("react");
+ return {
+ useChatAutoScroll: () => ({
+ containerRef: React.useRef<HTMLDivElement>(null),
+ shouldAutoScrollRef: React.useRef(true),
+ scrollToBottom: React.useCallback(() => {}, []),
+ handleScroll: React.useCallback(() => {}, []),
+ }),
+ };
+});
+
+const initialPage = {
+ messages: [{ role: "assistant", content: "Earlier answer" }],
+ start: 0,
+ total: 1,
+ next_before: null,
+};
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ sockets.instances.length = 0;
+ composer.current = null;
+ api.historyPage.mockResolvedValue(initialPage);
+ api.sessions.mockResolvedValue([]);
+ api.commands.mockResolvedValue([]);
+ vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => {
+ callback(0);
+ return 1;
+ });
+});
+
+async function ready() {
+ await waitFor(() => expect(composer.current?.disabled).toBe(false));
+ return sockets.instances[0];
+}
+
+it.each(["turn_busy", "stale_session"])(
+ "restores the rejected draft after %s and removes its optimistic row",
+ async (type) => {
+ const onSelectionStale = vi.fn();
+ render(
+ <PartnerChat
+ partnerId="ada"
+ partnerName="Ada"
+ sessionKey="web-current"
+ onSelectionStale={onSelectionStale}
+ />,
+ );
+ const socket = await ready();
+ act(() => {
+ expect(composer.current?.onSend("Keep this draft", [])).toBe(true);
+ });
+ expect(screen.getByText("Keep this draft")).toBeInTheDocument();
+ act(() => socket.emit({ type }));
+ await waitFor(() => {
+ expect(composer.current?.restoreDraft?.content).toBe("Keep this draft");
+ expect(screen.queryByText("Keep this draft")).not.toBeInTheDocument();
+ });
+ expect(onSelectionStale).toHaveBeenCalledTimes(type === "stale_session" ? 1 : 0);
+ },
+);
+
+it("keeps an accepted question when the turn later errors", async () => {
+ render(<PartnerChat partnerId="ada" partnerName="Ada" sessionKey="web-current" />);
+ const socket = await ready();
+ act(() => {
+ expect(composer.current?.onSend("Submitted question", [])).toBe(true);
+ socket.emit({ type: "accepted", session_key: "web-current" });
+ socket.emit({ type: "error", content: "Provider unavailable" });
+ socket.emit({ type: "done" });
+ });
+ expect(screen.getByText("Submitted question")).toBeInTheDocument();
+ expect(screen.getByText("Provider unavailable")).toBeInTheDocument();
+ expect(composer.current?.restoreDraft).toBeUndefined();
+});
+
+it("restores a question rejected before acceptance", async () => {
+ render(<PartnerChat partnerId="ada" partnerName="Ada" sessionKey="web-current" />);
+ const socket = await ready();
+ act(() => {
+ expect(composer.current?.onSend("Invalid attachment question", [])).toBe(true);
+ socket.emit({ type: "error", content: "Invalid attachments" });
+ });
+ expect(screen.queryByText("Invalid attachment question")).not.toBeInTheDocument();
+ expect(composer.current?.restoreDraft?.content).toBe("Invalid attachment question");
+});
+
+it("clears the pending send when a turn stops so shared history can refresh", async () => {
+ api.historyPage
+ .mockResolvedValueOnce(initialPage)
+ .mockResolvedValueOnce({
+ messages: [
+ { role: "assistant", content: "Earlier answer" },
+ { role: "assistant", content: "Other browser answer" },
+ ],
+ start: 0,
+ total: 2,
+ next_before: null,
+ });
+ render(
+ <PartnerChat partnerId="ada" partnerName="Ada" sessionKey="web-current" sharedAcrossBrowsers />,
+ );
+ const socket = await ready();
+ act(() => {
+ expect(composer.current?.onSend("Cancelled question", [])).toBe(true);
+ socket.emit({ type: "accepted", session_key: "web-current" });
+ socket.emit({ type: "stopped" });
+ });
+ act(() => window.dispatchEvent(new Event("focus")));
+ expect(await screen.findByText("Other browser answer")).toBeInTheDocument();
+});
+
+it("keeps an optimistic send while an earlier history poll resolves", async () => {
+ let resolveRefresh: ((value: typeof initialPage) => void) | undefined;
+ api.historyPage
+ .mockResolvedValueOnce(initialPage)
+ .mockImplementationOnce(() => new Promise((resolve) => { resolveRefresh = resolve; }));
+ render(
+ <PartnerChat
+ partnerId="ada"
+ partnerName="Ada"
+ sessionKey="web-current"
+ sharedAcrossBrowsers
+ />,
+ );
+ await ready();
+ act(() => window.dispatchEvent(new Event("focus")));
+ await waitFor(() => expect(api.historyPage).toHaveBeenCalledTimes(2));
+ act(() => {
+ expect(composer.current?.onSend("Optimistic question", [])).toBe(true);
+ });
+ await act(async () => {
+ resolveRefresh?.({
+ messages: [
+ { role: "assistant", content: "Earlier answer" },
+ { role: "assistant", content: "Other browser answer" },
+ ],
+ start: 0,
+ total: 2,
+ next_before: null,
+ });
+ });
+ expect(screen.getByText("Optimistic question")).toBeInTheDocument();
+ expect(screen.queryByText("Other browser answer")).not.toBeInTheDocument();
+});
+
+it("does not recreate the socket for an ordinary parent rerender", async () => {
+ const onSelectionStale = vi.fn();
+ const { rerender } = render(
+ <PartnerChat
+ partnerId="ada"
+ partnerName="Ada"
+ sessionKey="web-current"
+ onSelectionStale={onSelectionStale}
+ />,
+ );
+ await ready();
+ rerender(
+ <PartnerChat
+ partnerId="ada"
+ partnerName="Ada renamed"
+ sessionKey="web-current"
+ onSelectionStale={onSelectionStale}
+ />,
+ );
+ expect(sockets.instances).toHaveLength(1);
+});
diff --git a/web/tests/partner-continuity.spec.tsx b/web/tests/partner-continuity.spec.tsx
new file mode 100644
index 000000000..4f02de977
--- /dev/null
+++ b/web/tests/partner-continuity.spec.tsx
@@ -0,0 +1,131 @@
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import PartnerArchives from "@/components/partners/PartnerArchives";
+import { initializePartnerSessionKey, loadPartnerSessionKey, persistPartnerSessionKey } from "@/lib/partner-session";
+
+const api = vi.hoisted(() => ({
+ sessions: vi.fn(),
+ historyPage: vi.fn(),
+ resume: vi.fn(),
+ remove: vi.fn(),
+}));
+const translate = vi.hoisted(() => (key: string) => key);
+vi.mock("@/lib/partners-api", () => ({
+ getPartnerSessions: api.sessions,
+ getPartnerHistoryPage: api.historyPage,
+ resumePartnerSession: api.resume,
+ deletePartnerSession: api.remove,
+}));
+vi.mock("react-i18next", () => ({
+ useTranslation: () => ({ t: translate }),
+}));
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ localStorage.clear();
+ vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => {
+ callback(0);
+ return 1;
+ });
+ api.sessions.mockResolvedValue([
+ {
+ session_key: "web-old-local",
+ title: "Old browser conversation",
+ archived: false,
+ message_count: 121,
+ updated_at: "2026-09-23T10:00:00",
+ last_message: "newer",
+ },
+ {
+ session_key: "web-archived",
+ title: "Archived conversation",
+ archived: true,
+ message_count: 1,
+ updated_at: "2026-09-22T10:00:00",
+ last_message: "older",
+ },
+ ]);
+ api.historyPage.mockImplementation(async (_partner: string, key: string, options: { before?: number }) => {
+ if (key === "web-archived") {
+ return { messages: [{ role: "user", content: "older" }], next_before: null };
+ }
+ return options.before === 1
+ ? { messages: [{ role: "user", content: "beginning" }], next_before: null }
+ : { messages: [{ role: "assistant", content: "newer" }], next_before: 1 };
+ });
+});
+afterEach(() => {
+ cleanup();
+ vi.unstubAllGlobals();
+});
+
+it("keeps non-archived browser conversations selectable and loads their beginning", async () => {
+ const onResume = vi.fn();
+ render(
+ <PartnerArchives partnerId="ada" onToast={vi.fn()} onResume={onResume} />,
+ );
+ expect((await screen.findAllByText("Old browser conversation")).length).toBeGreaterThan(0);
+ expect(screen.getAllByText("Archived conversation").length).toBeGreaterThan(0);
+ expect((await screen.findAllByText("newer")).length).toBeGreaterThan(0);
+
+ fireEvent.click(await screen.findByRole("button", { name: "Load older messages" }));
+ expect(await screen.findByText("beginning")).toBeInTheDocument();
+ expect(api.historyPage).toHaveBeenCalledWith("ada", "web-old-local", {
+ before: 1,
+ limit: 100,
+ });
+
+ fireEvent.click(screen.getByRole("button", { name: "Continue" }));
+ await waitFor(() => expect(onResume).toHaveBeenCalledWith("web-old-local", null, false));
+ expect(api.resume).not.toHaveBeenCalled();
+});
+
+it("rotates the selected shared key when its conversation is deleted", async () => {
+ api.remove.mockResolvedValue({ active_session_key: "web-replacement" });
+ const onDeleted = vi.fn();
+ render(
+ <PartnerArchives
+ partnerId="ada"
+ onToast={vi.fn()}
+ onDeleted={onDeleted}
+ />,
+ );
+ await screen.findAllByText("Old browser conversation");
+ fireEvent.click(screen.getByRole("button", { name: "Delete conversation" }));
+ await waitFor(() =>
+ expect(onDeleted).toHaveBeenCalledWith("web-old-local", "web-replacement"),
+ );
+});
+
+it("stores browser-local keys separately for each account and partner", () => {
+ persistPartnerSessionKey("ada", "web-alice", "alice");
+ persistPartnerSessionKey("ada", "web-bob", "bob");
+ persistPartnerSessionKey("bea", "web-other-partner", "alice");
+ expect(loadPartnerSessionKey("ada", "alice")).toBe("web-alice");
+ expect(loadPartnerSessionKey("ada", "bob")).toBe("web-bob");
+ expect(loadPartnerSessionKey("bea", "alice")).toBe("web-other-partner");
+});
+
+it("migrates an old key only when ownership is provable", async () => {
+ persistPartnerSessionKey("ada", "web-legacy");
+ const owned = await initializePartnerSessionKey(
+ "ada", "alice", { enabled: true, isAdmin: false, statusAvailable: true },
+ async () => ["web-legacy"],
+ );
+ expect(owned).toBe("web-legacy");
+ const other = await initializePartnerSessionKey(
+ "ada", "bob", { enabled: true, isAdmin: false, statusAvailable: true },
+ async () => [],
+ );
+ expect(other).not.toBe("web-legacy");
+ const admin = await initializePartnerSessionKey(
+ "ada", "admin", { enabled: true, isAdmin: true, statusAvailable: true },
+ async () => ["web-legacy"],
+ );
+ expect(admin).not.toBe("web-legacy");
+ const localAdmin = await initializePartnerSessionKey(
+ "ada", "local-admin", { enabled: false, isAdmin: true, statusAvailable: true },
+ async () => [],
+ );
+ expect(localAdmin).toBe("web-legacy");
+});
diff --git a/web/tests/partner-direct-chat.test.ts b/web/tests/partner-direct-chat.test.ts
index bd4af1192..b85fbb195 100644
--- a/web/tests/partner-direct-chat.test.ts
+++ b/web/tests/partner-direct-chat.test.ts
@@ -18,7 +18,7 @@ const archiveSource = readFileSync(
test("partner web chat waits for runtime readiness, not channel running state", () => {
assert.match(chatSource, /data\.type === "ready"/);
- assert.match(chatSource, /disabled=\{!connected\}/);
+ assert.match(chatSource, /disabled=\{!connected \|\| reconciling \|\| commandBusy \|\| switchingSession/);
assert.doesNotMatch(chatSource, /if \(!running\)/);
assert.doesNotMatch(chatSource, /disabled=\{!connected \|\| !running\}/);
});
@@ -31,10 +31,10 @@ test("partner tabs use a stable centered header column", () => {
assert.match(pageSource, /<nav className="flex justify-self-center/);
});
-test("partner chat has a complete archive and resume surface", () => {
+test("partner chat keeps old active and archived conversations reachable", () => {
assert.match(pageSource, /handleArchiveConversation/);
assert.match(pageSource, /archivePartnerSession\(partnerId, sessionKey\)/);
- assert.match(pageSource, /changeSessionKey\(freshPartnerSessionKey\(\)\)/);
- assert.match(archiveSource, /\.filter\(\s*\(session\) => session\.archived,/);
+ assert.match(pageSource, /if \(result\.active_session_key\) changeSessionKey\(result\.active_session_key, true\)/);
+ assert.match(archiveSource, /const next = await getPartnerSessions\(partnerId\)/);
assert.match(archiveSource, /resumePartnerSession/);
});