OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
fix: address interrupted-session ownership review follow-ups (#2532)
Edwin Jose795dbe026d62
diff --git a/alembic/versions/0008_session_conversation_id.py b/alembic/versions/0008_session_conversation_id.pyindex a28a6a34d..20cf679d8 100644--- a/alembic/versions/0008_session_conversation_id.py+++ b/alembic/versions/0008_session_conversation_id.py@@ -23,5 +23,6 @@ def upgrade() -> None:def downgrade() -> None:- op.drop_index("ix_session_ownership_conversation_id", table_name="session_ownership")- op.drop_column("session_ownership", "conversation_id")+ with op.batch_alter_table("session_ownership") as batch:+ batch.drop_index("ix_session_ownership_conversation_id")+ batch.drop_column("conversation_id")diff --git a/docs/docs/core-components/chat.mdx b/docs/docs/core-components/chat.mdxindex 91255de7c..7ed92b7c5 100644--- a/docs/docs/core-components/chat.mdx+++ b/docs/docs/core-components/chat.mdx@@ -34,11 +34,19 @@ These IDs can differ when Langflow returns a new response ID.Both IDs are checked against the authenticated user's session ownership; interruption recovery does not bypass those checks.Response aliases are durably associated with their canonical conversation, including across backend restarts.+After a backend restart, continuing with an owned response alias reuses the canonical sidebar thread and preserves its saved title and message count.+Successful message bodies are still retrieved from Langflow; the backend does not reconstruct them from metadata.Deleting a conversation revokes its canonical ID and all recorded aliases and attempts to remove every associated Langflow session.A deleted alias cannot be used to resume the conversation.+Bulk deletion also removes the caller's own legacy local conversation records that have no ownership row.+Those orphan records do not authorize upstream session deletion or bypass the ownership checks on chat requests.+Orphan cleanup is bulk-only at the API: single-conversation delete endpoints return `404` for records without an ownership row.IDs are sent only after ownership and its conversation association have been persisted.In `files` mode this requires a successful file write; in `db` mode it requires a committed database write.+File updates are serialized and persisted on a worker thread, so durable writes do not block the event loop or overwrite concurrent ownership changes.+File writes sync both the file contents and the parent directory after atomic replacement before ownership is acknowledged.+If directory sync fails after replacement, file-backed authorization is suspended and further file mutations require a successful reload and directory sync, preventing updates from overwriting ownership changes with stale cached data.In `hybrid` mode the database is preferred, with a successful durable JSON write as fallback if the database is unavailable.If neither configured destination can persist the claim, the stream returns an error without exposing a new response ID; an in-memory cache entry is not sufficient.diff --git a/src/agent.py b/src/agent.pyindex 8172039af..39ac4d0cb 100644--- a/src/agent.py+++ b/src/agent.py@@ -161,6 +161,8 @@ async def store_conversation_thread(user_id: str, response_id: str, conversation# 2. Store only essential metadata to disk (simplified JSON)messages = conversation_state.get("messages", [])+ # A restarted thread has durable metadata, but not successful message bodies.+ persisted_metadata = conversation_state.get("_persisted_metadata", {})first_user_msg = next((msg for msg in messages if msg.get("role") == "user"), None)title = "New Chat"if first_user_msg:@@ -170,17 +172,21 @@ async def store_conversation_thread(user_id: str, response_id: str, conversationuser_assistant_messages = [msg for msg in messages if msg.get("role") in ["user", "assistant"]]metadata_only = {"response_id": response_id,- "title": title,+ "title": persisted_metadata.get("title") or title,"endpoint": "langflow","created_at": conversation_state.get("created_at"),"last_activity": conversation_state.get("last_activity"),- "previous_response_id": conversation_state.get("previous_response_id"),+ "previous_response_id": persisted_metadata.get(+ "previous_response_id", conversation_state.get("previous_response_id")+ ),"filter_id": conversation_state.get("filter_id"),- "total_messages": len(user_assistant_messages),+ "total_messages": (persisted_metadata.get("total_messages") or 0)+ + len(user_assistant_messages),}# Snapshot error-thread turns: Langflow history is incomplete after fresh-session retries.- if any(msg.get("error") for msg in user_assistant_messages):- metadata_only["messages"] = [+ persisted_messages = persisted_metadata.get("messages", [])+ if persisted_messages or any(msg.get("error") for msg in user_assistant_messages):+ metadata_only["messages"] = persisted_messages + [{"role": msg.get("role"),"content": msg.get("content"),@@ -910,10 +916,37 @@ async def async_langflow_chat_stream(thread_id,)previous_loaded_from_memory = _conversation_thread_in_memory(user_id, thread_id)- conversation_state = get_conversation_thread(user_id, thread_id)+ owned_session_ids = []+ persisted_metadata = {}+ if thread_id and not previous_loaded_from_memory:+ from services.session_ownership_service import session_ownership_service+ owned_session_ids = await session_ownership_service.get_conversation_sessions(+ user_id, thread_id+ )+ if owned_session_ids:+ thread_id = owned_session_ids[0]+ previous_loaded_from_memory = _conversation_thread_in_memory(user_id, thread_id)+ if not previous_loaded_from_memory:+ persisted_metadata = await conversation_persistence.get_conversation_thread(+ user_id, thread_id+ )from datetime import datetime+ conversation_state = get_conversation_thread(user_id, thread_id)+ if persisted_metadata:+ conversation_state["_persisted_metadata"] = persisted_metadata+ restored_created_at = persisted_metadata.get("created_at")+ if isinstance(restored_created_at, str):+ try:+ restored_created_at = datetime.fromisoformat(restored_created_at)+ except ValueError:+ restored_created_at = None+ if isinstance(restored_created_at, datetime):+ conversation_state["created_at"] = restored_created_at+ conversation_state["filter_id"] = persisted_metadata.get("filter_id")+ conversation_state["response_ids"] = list(owned_session_ids)+conversation_state["messages"].append({"role": "user", "content": prompt, "timestamp": datetime.now()})@@ -930,7 +963,8 @@ async def async_langflow_chat_stream(usage_data = Nonecollected_chunks = [] # Store all chunks for function call dataerror_occurred = False- store_id = None+ # A durable owned group can safely retain its canonical sidebar ID on restart.+ store_id = thread_id if owned_session_ids else Noneclaimed_ids: set[str] = set()turn_finished = False@@ -1127,9 +1161,14 @@ async def async_langflow_chat_stream(await upstream.aclose()-async def delete_user_conversation(user_id: str, response_id: str) -> bool:+async def delete_user_conversation(+ user_id: str, response_id: str, *, session_ids: list[str] | None = None+) -> bool:"""Delete a conversation for a user from both memory and persistent storage.+ ``session_ids`` is the caller's already-authorized ownership snapshot, when+ provided. An empty group permits only user-scoped local orphan cleanup.+Returns:True — conversation was found and deleted from at least one store.False — conversation did not exist in any store (confirmed not-found).@@ -1140,13 +1179,15 @@ async def delete_user_conversation(user_id: str, response_id: str) -> bool:"""from services.session_ownership_service import session_ownership_service- session_ids = await session_ownership_service.get_conversation_sessions(user_id, response_id)- if not session_ids:- return False- canonical_id = session_ids[0]- # Revoke ALL durable aliases before removing the local index. Failures must- # reach the caller, not turn into a successful delete with reusable IDs.- await session_ownership_service.release_conversation_sessions(user_id, session_ids)+ if session_ids is None:+ session_ids = await session_ownership_service.get_conversation_sessions(+ user_id, response_id+ )+ canonical_id = session_ids[0] if session_ids else response_id+ if session_ids:+ # Revoke only the snapshot used for upstream cleanup. Never revoke a late+ # alias whose upstream deletion was not attempted.+ await session_ownership_service.release_conversation_sessions(user_id, session_ids)deleted = await conversation_persistence.delete_conversation_thread(user_id, canonical_id)if canonical_id in active_conversations.get(user_id, {}):del active_conversations[user_id][canonical_id]diff --git a/src/db/repositories/session_ownership_repo.py b/src/db/repositories/session_ownership_repo.pyindex 44b6bbd52..64ef9d42c 100644--- a/src/db/repositories/session_ownership_repo.py+++ b/src/db/repositories/session_ownership_repo.py@@ -3,6 +3,7 @@from datetime import UTC, datetimefrom sqlalchemy import select+from sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.ext.asyncio import AsyncSessionfrom sqlmodel import col@@ -27,11 +28,6 @@ class SessionOwnershipRepo:canonical = await self.get(canonical_id)if canonical is None or canonical.user_id != user_id:raise PermissionError("Conversation is not owned by this user")- if existing is not None and (- existing.user_id != user_id- or (existing.conversation_id is not None and existing.conversation_id != canonical_id)- ):- raise PermissionError("Session ownership or conversation conflict")if existing is None:row = SessionOwnership(response_id=response_id,@@ -40,9 +36,40 @@ class SessionOwnershipRepo:created_at=now,last_accessed=now,)- self.session.add(row)- await self.session.flush()- return row+ try:+ # begin_nested flushes pending caller work before establishing+ # its savepoint, so add only this claim inside the savepoint.+ async with self.session.begin_nested():+ self.session.add(row)+ await self.session.flush()+ except IntegrityError as exc:+ # Only primary-key/unique violations can be an INSERT race.+ # Never hide another constraint failure behind a matching row.+ if (+ getattr(exc.orig, "sqlstate", None) != "23505"+ and getattr(exc.orig, "sqlite_errorname", None)+ != "SQLITE_CONSTRAINT_PRIMARYKEY"+ ):+ raise+ # The savepoint has rolled back only this insert; preserve the+ # caller's transaction while reading the winning claim afresh.+ existing = await self.session.get(+ SessionOwnership, response_id, populate_existing=True+ )+ if existing is None:+ raise+ if canonical_id != response_id:+ canonical = await self.session.get(+ SessionOwnership, canonical_id, populate_existing=True+ )+ if canonical is None or canonical.user_id != user_id:+ raise PermissionError("Conversation is not owned by this user") from None+ else:+ return row+ if existing.user_id != user_id or (+ (existing.conversation_id or response_id) != canonical_id+ ):+ raise PermissionError("Session ownership or conversation conflict")existing.conversation_id = canonical_idexisting.last_accessed = nowself.session.add(existing)diff --git a/src/services/chat_service.py b/src/services/chat_service.pyindex 7b139cc48..d4df2d0e8 100644--- a/src/services/chat_service.py+++ b/src/services/chat_service.py@@ -688,11 +688,12 @@ class ChatService:if first_user_msgelse "New chat")+ persisted_metadata = conversation_state.get("_persisted_metadata", {})conversations.append({"response_id": response_id,- "title": title,+ "title": persisted_metadata.get("title") or title,"endpoint": "chat","messages": messages,"created_at": conversation_state.get("created_at").isoformat()@@ -703,7 +704,8 @@ class ChatService:else None,"previous_response_id": conversation_state.get("previous_response_id"),"filter_id": conversation_state.get("filter_id"),- "total_messages": len(messages),+ "total_messages": (persisted_metadata.get("total_messages") or 0)+ + len(messages),"source": "in_memory",})@@ -948,7 +950,9 @@ class ChatService:]langflow_deleted = bool(upstream_results) and all(upstream_results)- local_deleted = await delete_user_conversation(user_id, session_id)+ local_deleted = await delete_user_conversation(+ user_id, session_id, session_ids=session_ids+ )if not local_deleted:return {@@ -981,7 +985,7 @@ class ChatService:for session_id in dict.fromkeys(session_ids):try:owner = await session_ownership_service.get_session_owner(session_id)- if owner != user_id:+ if owner is not None and owner != user_id:logger.warning("bulk_delete: %s not owned by %s", session_id, user_id)failed.append(session_id)continuediff --git a/src/services/session_ownership_service.py b/src/services/session_ownership_service.pyindex 6ecb2cae1..e9c3277ca 100644--- a/src/services/session_ownership_service.py+++ b/src/services/session_ownership_service.py@@ -14,8 +14,10 @@ flipped from sync to ``await`` as part of this migration.from __future__ import annotations+import asyncioimport jsonimport os+import statimport tempfilefrom collections.abc import Callablefrom datetime import UTC, datetime@@ -32,6 +34,10 @@ from utils.logging_config import get_loggerlogger = get_logger(__name__)+class _IndeterminateOwnershipWrite(OSError):+ """The replacement is visible, but its directory entry was not synced."""++class SessionOwnershipService:"""Tracks which user owns which session."""@@ -39,6 +45,8 @@ class SessionOwnershipService:self.ownership_file = get_data_file("session_ownership.json")os.makedirs(os.path.dirname(self.ownership_file), exist_ok=True)self._session_factory = session_factory+ self._file_lock = asyncio.Lock()+ self._file_state_indeterminate = False# JSON cache — eagerly loaded so `files` and `hybrid` modes# behave like the legacy implementation.self.ownership_data: dict[str, dict[str, Any]] = self._load_ownership_data()@@ -58,22 +66,75 @@ class SessionOwnershipService:return {}def _save_ownership_data(self, data: dict[str, dict[str, Any]]) -> None:- """Publish a complete file before changing the authorization cache."""+ """Atomically replace and sync file + directory on the caller's worker thread."""temporary = Nonetry:+ try:+ mode = stat.S_IMODE(os.stat(self.ownership_file).st_mode)+ except FileNotFoundError:+ mode = Nonewith tempfile.NamedTemporaryFile(mode="w", dir=os.path.dirname(self.ownership_file), delete=False) as f:temporary = f.name+ if mode is not None:+ os.fchmod(f.fileno(), mode)json.dump(data, f, indent=2)f.flush()os.fsync(f.fileno())os.replace(temporary, self.ownership_file)- self.ownership_data = data+ temporary = None+ # Persist the replacement directory entry before publishing ownership.+ try:+ directory_fd = os.open(os.path.dirname(self.ownership_file), os.O_RDONLY)+ try:+ os.fsync(directory_fd)+ finally:+ os.close(directory_fd)+ except OSError as exc:+ raise _IndeterminateOwnershipWrite(str(exc)) from excfinally:if temporary is not None and os.path.exists(temporary):os.unlink(temporary)+ def _read_and_sync_ownership_data(self) -> dict[str, dict[str, Any]]:+ """Strictly reload an uncertain replacement and make its name durable."""+ with open(self.ownership_file) as f:+ data = json.load(f)+ directory_fd = os.open(os.path.dirname(self.ownership_file), os.O_RDONLY)+ try:+ os.fsync(directory_fd)+ finally:+ os.close(directory_fd)+ return data++ async def _reconcile_ownership_data(self) -> None:+ """Reconcile before mutation, under ``_file_lock``; failures stay closed."""+ if self._file_state_indeterminate:+ data = await asyncio.to_thread(self._read_and_sync_ownership_data)+ self.ownership_data = data+ self._file_state_indeterminate = False++ async def _persist_ownership_data(self, data: dict[str, dict[str, Any]]) -> None:+ """Persist then publish while the caller holds ``_file_lock``."""+ write = asyncio.create_task(asyncio.to_thread(self._save_ownership_data, data))+ cancelled = False+ try:+ while not write.done():+ try:+ await asyncio.shield(write)+ except asyncio.CancelledError:+ # Keep the lock until the worker finishes, even on cancellation.+ cancelled = True+ write.result()+ except _IndeterminateOwnershipWrite:+ # A failed sync cannot undo an already completed replacement.+ self._file_state_indeterminate = True+ raise+ self.ownership_data = data+ if cancelled:+ raise asyncio.CancelledError+# ------------------------------------------------------------------# Public async API# ------------------------------------------------------------------@@ -88,8 +149,15 @@ class SessionOwnershipService:An unsuccessful write never adds an authorization entry to the cache."""canonical_id = conversation_id or session_id- if file_writes_enabled() and self._file_claim_conflicts(user_id, session_id, canonical_id):- return False+ if file_writes_enabled():+ async with self._file_lock:+ try:+ await self._reconcile_ownership_data()+ except Exception as exc:+ logger.error("File ownership reconciliation failed", error=str(exc))+ return False+ if self._file_claim_conflicts(user_id, session_id, canonical_id):+ return Falsedurable = Falseif db_writes_enabled():try:@@ -97,30 +165,36 @@ class SessionOwnershipService:except PermissionError:return Falseif file_writes_enabled():- # Another claim may have published while the DB write was awaiting.- if self._file_claim_conflicts(user_id, session_id, canonical_id):- return False- now = datetime.now(UTC).isoformat()- existing = self.ownership_data.get(session_id, {})- if canonical_id != session_id and not durable:- canonical = self.ownership_data.get(canonical_id)- if not canonical or canonical.get("user_id") != user_id:+ async with self._file_lock:+ try:+ await self._reconcile_ownership_data()+ except Exception as exc:+ logger.error("File ownership reconciliation failed", error=str(exc))+ return durable+ # Recheck after DB work and after any pending file publication.+ if self._file_claim_conflicts(user_id, session_id, canonical_id):return False- updated = {- **self.ownership_data,- session_id: {- **existing,- "user_id": user_id,- "conversation_id": canonical_id,- "created_at": existing.get("created_at", now),- "last_accessed": now,- },- }- try:- self._save_ownership_data(updated)- durable = True- except Exception as exc: # noqa: BLE001- logger.error("File claim_session failed", error=str(exc))+ now = datetime.now(UTC).isoformat()+ existing = self.ownership_data.get(session_id, {})+ if canonical_id != session_id and not durable:+ canonical = self.ownership_data.get(canonical_id)+ if not canonical or canonical.get("user_id") != user_id:+ return False+ updated = {+ **self.ownership_data,+ session_id: {+ **existing,+ "user_id": user_id,+ "conversation_id": canonical_id,+ "created_at": existing.get("created_at", now),+ "last_accessed": now,+ },+ }+ try:+ await self._persist_ownership_data(updated)+ durable = True+ except Exception as exc: # noqa: BLE001+ logger.error("File claim_session failed", error=str(exc))return durableasync def get_session_owner(self, session_id: str) -> str | None:@@ -132,6 +206,8 @@ class SessionOwnershipService:if mode == "db":return None# files or hybrid-with-no-db-row → fall back to JSON+ if self._file_state_indeterminate:+ return Nonedata = self.ownership_data.get(session_id)return data.get("user_id") if data else None@@ -143,10 +219,14 @@ class SessionOwnershipService:return db_sessions# hybrid: union with JSON-only entriesjson_sessions = [- sid for sid, data in self.ownership_data.items() if data.get("user_id") == user_id+ sid+ for sid, data in self.ownership_data.items()+ if not self._file_state_indeterminate and data.get("user_id") == user_id]return list(dict.fromkeys(db_sessions + json_sessions))# files mode+ if self._file_state_indeterminate:+ return []return [sid for sid, data in self.ownership_data.items() if data.get("user_id") == user_id]async def is_session_owned_by_user(self, session_id: str, user_id: str) -> bool:@@ -163,6 +243,8 @@ class SessionOwnershipService:durable aliases authorized while reporting successful removal."""mode = get_storage_mode()+ if mode != "db" and self._file_state_indeterminate:+ raise RuntimeError("File ownership state requires reconciliation")files = self.ownership_data if mode != "db" else {}data = files.get(session_id, {})canonical_id = (@@ -222,11 +304,13 @@ class SessionOwnershipService:hybrid groups can contain JSON-only aliases absent from a DB rollback."""if file_writes_enabled():- updated = dict(self.ownership_data)- for session_id in session_ids:- if updated.get(session_id, {}).get("user_id") == user_id:- del updated[session_id]- self._save_ownership_data(updated)+ async with self._file_lock:+ await self._reconcile_ownership_data()+ updated = dict(self.ownership_data)+ for session_id in session_ids:+ if updated.get(session_id, {}).get("user_id") == user_id:+ del updated[session_id]+ await self._persist_ownership_data(updated)if db_writes_enabled():from db.repositories import SessionOwnershipRepo@@ -244,16 +328,20 @@ class SessionOwnershipService:async def release_session(self, user_id: str, session_id: str) -> bool:released = False- if file_writes_enabled() and session_id in self.ownership_data:- if self.ownership_data[session_id].get("user_id") == user_id:- updated = dict(self.ownership_data)- del updated[session_id]- self._save_ownership_data(updated)- released = True- else:- logger.warning(- f"User {user_id} tried to release session {session_id} they don't own (json)"- )+ if file_writes_enabled():+ async with self._file_lock:+ await self._reconcile_ownership_data()+ existing = self.ownership_data.get(session_id)+ if existing is not None:+ if existing.get("user_id") == user_id:+ updated = dict(self.ownership_data)+ del updated[session_id]+ await self._persist_ownership_data(updated)+ released = True+ else:+ logger.warning(+ f"User {user_id} tried to release session {session_id} they don't own (json)"+ )if db_writes_enabled():db_released = await self._db_release(session_id, user_id)@@ -319,7 +407,7 @@ class SessionOwnershipService:existingand (existing.get("user_id") != user_id- or (existing.get("conversation_id") or canonical_id) != canonical_id+ or (existing.get("conversation_id") or session_id) != canonical_id)or canonicaland canonical.get("user_id") != user_id@@ -350,10 +438,10 @@ class SessionOwnershipService:return Trueexcept PermissionError:raise- except IntegrityError as exc:- # A competing insert may now own the ID. Never turn a uniqueness- # conflict into permission to publish a JSON fallback for this user.- raise PermissionError("Concurrent session ownership conflict") from exc+ except IntegrityError:+ # The repository recovers only a confirmed, compatible INSERT+ # winner. Any other integrity failure must not authorize fallback.+ raiseexcept Exception as exc: # noqa: BLE001logger.error("DB claim_session failed", error=str(exc))return Falsediff --git a/tests/unit/db/repositories/test_session_ownership_repo_savepoint.py b/tests/unit/db/repositories/test_session_ownership_repo_savepoint.pynew file mode 100644index 000000000..e84bc108a--- /dev/null+++ b/tests/unit/db/repositories/test_session_ownership_repo_savepoint.py@@ -0,0 +1,115 @@+"""Claim-race recovery must not discard the caller's transaction."""++import sys+from pathlib import Path++import pytest+import pytest_asyncio+from sqlalchemy import text+from sqlalchemy.exc import IntegrityError+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine+from sqlmodel import SQLModel++ROOT = Path(__file__).resolve().parents[4]+SRC = ROOT / "src"+if str(SRC) not in sys.path:+ sys.path.insert(0, str(SRC))++import db.models # noqa: E402,F401+from db.models import SessionOwnership # noqa: E402+from db.repositories.session_ownership_repo import SessionOwnershipRepo # noqa: E402+++@pytest_asyncio.fixture+async def session_factory():+ engine = create_async_engine("sqlite+aiosqlite:///:memory:")+ async with engine.begin() as connection:+ await connection.run_sync(SQLModel.metadata.create_all)+ yield async_sessionmaker(engine, expire_on_commit=False)+ await engine.dispose()+++ "winner_user,winner_canonical,accepted",+ [("alice", "canonical", True), ("bob", "canonical", False), ("alice", "other", False)],+)+async def test_alias_race_preserves_pending_canonical_claim(+ monkeypatch, session_factory, winner_user, winner_canonical, accepted+):+ async with session_factory() as session:+ session.add(+ SessionOwnership(+ response_id="alias", user_id=winner_user, conversation_id=winner_canonical+ )+ )+ await session.commit()++ async with session_factory() as session:+ repo = SessionOwnershipRepo(session)+ canonical = await repo.claim("canonical", "alice")+ # Keep additional unflushed work pending as begin_nested is entered.+ canonical.last_accessed = canonical.created_at+ original_get = repo.get+ stale_read = False++ async def stale_get(response_id):+ nonlocal stale_read+ if response_id == "alias" and not stale_read:+ stale_read = True+ return None+ return await original_get(response_id)++ monkeypatch.setattr(repo, "get", stale_get)+ if accepted:+ row = await repo.claim("alias", "alice", "canonical")+ assert row.conversation_id == "canonical"+ else:+ with pytest.raises(PermissionError, match="ownership or conversation conflict"):+ await repo.claim("alias", "alice", "canonical")+ assert session.in_transaction()+ assert (await original_get("canonical")).user_id == "alice"+ await session.commit()++ async with session_factory() as session:+ repo = SessionOwnershipRepo(session)+ assert (await repo.get("canonical")).user_id == "alice"+ winner = await repo.get("alias")+ assert (winner.user_id, winner.conversation_id) == (winner_user, winner_canonical)+++async def test_nonunique_constraint_is_not_recovered_as_matching_winner(+ monkeypatch, session_factory+):+ async with session_factory() as session:+ repo = SessionOwnershipRepo(session)+ await repo.claim("canonical", "alice")+ await repo.claim("alias", "alice", "canonical")+ await session.execute(+ text(+ "CREATE TRIGGER reject_alias BEFORE INSERT ON session_ownership "+ "WHEN NEW.response_id = 'alias' BEGIN "+ "SELECT RAISE(ABORT, 'unrelated ownership constraint'); END"+ )+ )+ await session.commit()++ async with session_factory() as session:+ repo = SessionOwnershipRepo(session)+ await repo.claim("prior", "alice")+ original_get = repo.get++ async def stale_get(response_id):+ if response_id == "alias":+ return None+ return await original_get(response_id)++ monkeypatch.setattr(repo, "get", stale_get)+ with pytest.raises(IntegrityError, match="unrelated ownership constraint"):+ await repo.claim("alias", "alice", "canonical")+ assert session.is_active+ await session.commit()++ async with session_factory() as session:+ assert (await SessionOwnershipRepo(session).get("prior")).user_id == "alice"diff --git a/tests/unit/services/test_chat_session_lifecycle.py b/tests/unit/services/test_chat_session_lifecycle.pynew file mode 100644index 000000000..f3750fbac--- /dev/null+++ b/tests/unit/services/test_chat_session_lifecycle.py@@ -0,0 +1,765 @@+"""Durable chat ownership, continuation, cancellation, and deletion regressions."""++from __future__ import annotations++import asyncio+import json+from datetime import datetime+from pathlib import Path+from types import SimpleNamespace++import anyio+import httpx+import pytest+import pytest_asyncio+from fastapi import HTTPException+from openai import AsyncOpenAI+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine+from sqlmodel import SQLModel++import agent as agent_module+from api.chat import ChatBody, _assert_owns, delete_session_endpoint, langflow_endpoint+from services.chat_service import ChatService+from services.conversation_persistence_service import ConversationPersistenceService+from services.session_ownership_service import SessionOwnershipService+++async def _collect_error_chunks(stream) -> list[dict]:+ return [json.loads(raw.decode("utf-8")) async for raw in stream]+++@pytest_asyncio.fixture(params=["db", "hybrid", "files"])+async def durable_stream_stores(request, monkeypatch, tmp_path):+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", request.param)+ engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'chat.db'}")+ async with engine.begin() as connection:+ await connection.run_sync(SQLModel.metadata.create_all)+ factory = async_sessionmaker(engine, expire_on_commit=False)+ monkeypatch.setattr(+ "services.session_ownership_service.get_data_file",+ lambda name: str(tmp_path / name),+ )+ ownership = SessionOwnershipService(session_factory=factory)+ persistence = ConversationPersistenceService(+ storage_file=str(tmp_path / "conversations.json"), session_factory=factory+ )+ monkeypatch.setattr("services.session_ownership_service.session_ownership_service", ownership)+ monkeypatch.setattr(agent_module, "conversation_persistence", persistence)+ monkeypatch.setattr(agent_module, "active_conversations", {})+ yield ownership, persistence, factory+ await engine.dispose()++[email protected]("abort", ["close", "cancel"])+async def test_aborted_langflow_stream_keeps_owned_id_and_partial_turn(+ monkeypatch, durable_stream_stores, abort+):+ ownership, persistence, factory = durable_stream_stores+ waiting = asyncio.Event()+ upstream_closed = asyncio.Event()+ calls = []++ async def upstream(*_args, **kwargs):+ calls.append(kwargs.get("previous_response_id"))+ try:+ yield b'{"id":"resp-first","delta":{"content":"Partial answer"}}\n'+ waiting.set()+ await asyncio.Event().wait()+ finally:+ upstream_closed.set()++ monkeypatch.setattr(agent_module, "async_stream", upstream)+ stream = agent_module.async_langflow_chat_stream(object(), "flow", "First question", "alice")+ chunk = json.loads(await anext(stream))+ # The ID must already be durable when it first crosses the generator boundary.+ await _assert_owns(chunk["id"], "alice")+ assert (await persistence.get_conversation_thread("alice", chunk["id"]))["total_messages"] >= 1+ if abort == "close":+ await stream.aclose()+ else:+ pending = asyncio.create_task(anext(stream))+ await waiting.wait()+ pending.cancel()+ with pytest.raises(asyncio.CancelledError):+ await pending+ assert upstream_closed.is_set()+ # Reload ownership rather than relying on the live service's cache.+ reloaded = SessionOwnershipService(session_factory=factory)+ assert await reloaded.get_session_owner(chunk["id"]) == "alice"+ with pytest.raises(HTTPException) as forbidden:+ await _assert_owns(chunk["id"], "mallory")+ assert forbidden.value.status_code == 403+ with pytest.raises(HTTPException) as missing:+ await _assert_owns("unknown-session", "alice")+ assert missing.value.status_code == 404++ async def continuation(*_args, **kwargs):+ calls.append(kwargs.get("previous_response_id"))+ yield b'{"id":"resp-next","response_id":"resp-next-alias","delta":{"content":"Next"}}\n'++ monkeypatch.setattr(agent_module, "async_stream", continuation)+ await _assert_owns(chunk["id"], "alice")+ followup = agent_module.async_langflow_chat_stream(+ object(),+ "flow",+ "Follow-up",+ "alice",+ previous_response_id=chunk["id"],+ conversation_id=chunk["id"],+ )+ next_chunk = json.loads(await anext(followup))+ await _assert_owns(next_chunk["id"], "alice")+ await _assert_owns(next_chunk["response_id"], "alice")+ assert await _collect_error_chunks(followup) == []+ assert calls == [None, "resp-first"] # Never replay the interrupted prompt.+ conversations = await persistence.get_user_conversations("alice")+ assert list(conversations) == ["resp-first"] # Stable sidebar id, changing response ids.+ messages = agent_module.active_conversations["alice"]["resp-first"]["messages"]+ assert [(m["role"], m["content"]) for m in messages if m["role"] != "system"] == [+ ("user", "First question"),+ ("assistant", "Partial answer"),+ ("user", "Follow-up"),+ ("assistant", "Next"),+ ]+ assert conversations["resp-first"]["total_messages"] == 4++ # SDK callers may only carry the changing response ID, not conversation_id.+ await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(+ object(),+ "flow",+ "Third question",+ "alice",+ previous_response_id=next_chunk["response_id"],+ )+ )+ assert list(await persistence.get_user_conversations("alice")) == ["resp-first"]+ assert calls == [None, "resp-first", "resp-next-alias"]+ assert [m["content"] for m in messages if m["role"] == "user"] == [+ "First question",+ "Follow-up",+ "Third question",+ ]++[email protected]("claim_failure", ["unavailable", "foreign"])+async def test_stream_does_not_expose_unowned_response_id(+ monkeypatch, durable_stream_stores, claim_failure+):+ ownership, persistence, _ = durable_stream_stores+ if claim_failure == "foreign":+ await ownership.claim_session("mallory", "resp-unclaimable")+ else:++ async def unavailable(*_args, **_kwargs):+ return False++ monkeypatch.setattr(ownership, "claim_session", unavailable)++ async def upstream(*_args, **_kwargs):+ yield b'{"id":"resp-unclaimable","delta":{"content":"Not exposed"}}\n'++ monkeypatch.setattr(agent_module, "async_stream", upstream)+ chunks = await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")+ )+ assert len(chunks) == 1+ assert chunks[0]["status"] == "failed"+ assert "id" not in chunks[0] and "response_id" not in chunks[0]+ assert await persistence.get_user_conversations("alice") == {}+ assert await ownership.get_session_owner("resp-unclaimable") == (+ "mallory" if claim_failure == "foreign" else None+ )+++async def test_local_asgi_disconnect_smoke_preserves_followup(monkeypatch, durable_stream_stores):+ """Real endpoint → generator → OpenAI SSE adapter → durable stores, locally."""+ _, persistence, factory = durable_stream_stores+ disconnected = anyio.Event()+ upstream_closed = anyio.Event()+ calls = []++ class ProviderStream(httpx.AsyncByteStream):+ async def __aiter__(self):+ yield (+ b"event: response.created\n"+ b'data: {"type":"response.created","response":{"id":"resp-http"}}\n\n'+ )+ yield (+ b"event: response.output_text.delta\n"+ b'data: {"type":"response.output_text.delta","id":"resp-http",'+ b'"delta":{"content":"Partial HTTP answer"}}\n\n'+ )+ await anyio.sleep_forever()++ async def aclose(self):+ upstream_closed.set()++ async def provider(request):+ payload = json.loads(request.content)+ calls.append(payload)+ if len(calls) == 1:+ return httpx.Response(+ 200, headers={"content-type": "text/event-stream"}, stream=ProviderStream()+ )+ return httpx.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ content=(+ b"event: response.output_text.delta\n"+ b'data: {"type":"response.output_text.delta","id":"resp-http-next",'+ b'"delta":{"content":"Follow-up HTTP answer"}}\n\n'+ b"event: response.completed\n"+ b'data: {"type":"response.completed","response":{"id":"resp-http-next",'+ b'"usage":{"input_tokens":3,"output_tokens":4,"total_tokens":7}}}\n\n'+ ),+ )++ async with AsyncOpenAI(+ api_key="local-test-only",+ base_url="https://provider.invalid/v1",+ http_client=httpx.AsyncClient(transport=httpx.MockTransport(provider)),+ max_retries=0,+ ) as client:++ class EndpointChatService:+ async def langflow_chat(self, prompt, _subject, _jwt, **kwargs):+ return agent_module.async_langflow_chat_stream(+ client,+ "flow",+ prompt,+ kwargs["storage_user_id"],+ previous_response_id=kwargs["previous_response_id"],+ conversation_id=kwargs["conversation_id"],+ )++ user = SimpleNamespace(+ user_id="oauth-alice",+ db_user_id="alice",+ jwt_token="local-test-only",+ name="Alice",+ email="[email protected]",+ )+ service = EndpointChatService()+ response = await langflow_endpoint(+ ChatBody(prompt="First HTTP question", stream=True),+ chat_service=service,+ session_manager=None,+ user=user,+ )+ emitted = []++ async def send(message):+ if message["type"] == "http.response.body" and message.get("body"):+ chunk = json.loads(message["body"])+ emitted.append(chunk)+ response_id = chunk.get("id") or (chunk.get("response") or {}).get("id")+ if response_id:+ await _assert_owns(response_id, "alice")+ if chunk.get("delta", {}).get("content"):+ disconnected.set()++ async def receive():+ await disconnected.wait()+ return {"type": "http.disconnect"}++ # Starlette's real disconnect listener cancels the body iterator using an+ # AnyIO cancel scope, rather than manually throwing into our generator.+ with anyio.fail_after(5):+ await response({"type": "http", "asgi": {"spec_version": "2.3"}}, receive, send)+ assert upstream_closed.is_set()+ assert len(emitted) == 2+ metadata = await persistence.get_conversation_thread("alice", "resp-http")+ assert metadata["total_messages"] == 2++ followup = await langflow_endpoint(+ ChatBody(+ prompt="Next HTTP question",+ stream=True,+ previous_response_id="resp-http",+ conversation_id="resp-http",+ ),+ chat_service=service,+ session_manager=None,+ user=user,+ )+ chunks = await _collect_error_chunks(followup.body_iterator)+ await _assert_owns("resp-http-next", "alice")+ assert chunks[-1]["response"]["usage"]["total_tokens"] == 7+ assert calls[1]["previous_response_id"] == "resp-http"+ assert [call["input"] for call in calls] == ["First HTTP question", "Next HTTP question"]+ conversations = await persistence.get_user_conversations("alice")+ assert list(conversations) == ["resp-http"]+ assert conversations["resp-http"]["total_messages"] == 4+ messages = agent_module.active_conversations["alice"]["resp-http"]["messages"]+ assert [m["content"] for m in messages if m["role"] != "system"] == [+ "First HTTP question",+ "Partial HTTP answer",+ "Next HTTP question",+ "Follow-up HTTP answer",+ ]++ # Restart before canonical deletion: aliases must come from durable state.+ reloaded = SessionOwnershipService(session_factory=factory)+ monkeypatch.setattr(+ "services.session_ownership_service.session_ownership_service", reloaded+ )+ monkeypatch.setattr(agent_module, "active_conversations", {})+ upstream_deletes = []++ async def monitor_delete(method, path):+ assert method == "DELETE"+ upstream_deletes.append(path.rsplit("/", 1)[-1])+ return httpx.Response(204)++ monkeypatch.setattr("services.chat_service.clients.langflow_request", monitor_delete)+ deletion = await delete_session_endpoint(+ session_id="resp-http", chat_service=ChatService(), user=user+ )+ assert deletion.status_code == 200+ assert set(upstream_deletes) == {"resp-http", "resp-http-next"}+ fresh = SessionOwnershipService(session_factory=factory)+ monkeypatch.setattr("services.session_ownership_service.session_ownership_service", fresh)+ with pytest.raises(HTTPException) as missing:+ await langflow_endpoint(+ ChatBody(+ prompt="Cannot resurrect", stream=True, previous_response_id="resp-http-next"+ ),+ chat_service=service,+ session_manager=None,+ user=user,+ )+ assert missing.value.status_code == 404+ assert len(calls) == 2++ # Actual endpoint + SSE adapter with both persistent destinations broken.+ ownership_path = Path(fresh.ownership_file)+ if ownership_path.exists():+ ownership_path.unlink()+ ownership_path.mkdir()++ def unavailable_database():+ raise OSError("local smoke database unavailable")++ monkeypatch.setattr(fresh, "_resolve_session_factory", lambda: unavailable_database)+ failed = await langflow_endpoint(+ ChatBody(prompt="Fail closed", stream=True),+ chat_service=service,+ session_manager=None,+ user=user,+ )+ failed_chunks = await _collect_error_chunks(failed.body_iterator)+ assert len(failed_chunks) == 1 and failed_chunks[0]["status"] == "failed"+ assert "id" not in failed_chunks[0] and "response_id" not in failed_chunks[0]+ assert (+ await SessionOwnershipService(session_factory=factory).get_session_owner(+ "resp-http-next"+ )+ is None+ )+ print(+ "LOCAL SMOKE: disconnect/follow-up retained 4 messages; restart + "+ "canonical deletion removed both upstream sessions and alias authorization; "+ "persistent failures emitted no client ID"+ )++[email protected]("delta", [None, {"content": None}])+async def test_metadata_only_chunk_claims_id_before_exposure(+ monkeypatch, durable_stream_stores, delta+):+ async def upstream(*_args, **_kwargs):+ yield (json.dumps({"id": "resp-metadata", "delta": delta}) + "\n").encode()++ monkeypatch.setattr(agent_module, "async_stream", upstream)+ stream = agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")+ chunk = json.loads(await anext(stream))+ await _assert_owns(chunk["id"], "alice")+ await stream.aclose()++[email protected]("delete_id", ["resp-first", "resp-second"])+async def test_delete_canonical_revokes_aliases_after_reload(+ monkeypatch, durable_stream_stores, delete_id+):+ ownership, persistence, factory = durable_stream_stores++ async def upstream(*_args, **kwargs):+ response_id = "resp-second" if kwargs.get("previous_response_id") else "resp-first"+ yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()++ monkeypatch.setattr(agent_module, "async_stream", upstream)+ for previous in (None, "resp-first"):+ await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(+ object(), "flow", "Question", "alice", previous_response_id=previous+ )+ )+ await ownership.claim_session("mallory", "resp-foreign")+ await ownership.claim_session("alice", "resp-unrelated")+ assert list(await persistence.get_user_conversations("alice")) == ["resp-first"]+ assert await agent_module.delete_user_conversation("mallory", "resp-first") is False+ assert agent_module.active_conversations["alice"]["resp-first"]["messages"]+ # Restart: neither ownership cache nor the in-memory response_ids can help.+ reloaded = SessionOwnershipService(session_factory=factory)+ monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)+ monkeypatch.setattr(agent_module, "active_conversations", {})+ persistence = ConversationPersistenceService(+ storage_file=persistence.storage_file, session_factory=factory+ )+ monkeypatch.setattr(agent_module, "conversation_persistence", persistence)+ assert await agent_module.delete_user_conversation("alice", delete_id) is True+ fresh = SessionOwnershipService(session_factory=factory)+ monkeypatch.setattr("services.session_ownership_service.session_ownership_service", fresh)+ for response_id in ("resp-first", "resp-second"):+ with pytest.raises(HTTPException) as missing:+ await _assert_owns(response_id, "alice")+ assert missing.value.status_code == 404+ assert await fresh.get_session_owner("resp-foreign") == "mallory"+ assert await fresh.get_session_owner("resp-unrelated") == "alice"+ assert await persistence.get_user_conversations("alice") == {}+++async def test_persistent_claim_failure_never_exposes_cached_id(monkeypatch, durable_stream_stores):+ ownership, persistence, factory = durable_stream_stores+ # A real IO failure, not a stubbed claim: cache echo must not prove durability.+ Path(ownership.ownership_file).mkdir()++ def unavailable_database():+ raise OSError("local database unavailable")++ monkeypatch.setattr(ownership, "_resolve_session_factory", lambda: unavailable_database)++ async def upstream(*_args, **_kwargs):+ yield b'{"id":"resp-file-failure","delta":{"content":"Not exposed"}}\n'++ monkeypatch.setattr(agent_module, "async_stream", upstream)+ chunks = await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")+ )+ assert len(chunks) == 1+ assert chunks[0]["status"] == "failed"+ assert "id" not in chunks[0] and "response_id" not in chunks[0]+ assert await ownership.get_session_owner("resp-file-failure") is None+ assert (+ await SessionOwnershipService(session_factory=factory).get_session_owner(+ "resp-file-failure"+ )+ is None+ )+ assert await persistence.get_user_conversations("alice") == {}++[email protected]("durable_stream_stores", ["hybrid", "files"], indirect=True)+async def test_failed_file_revocation_is_not_reported_as_success(+ monkeypatch, durable_stream_stores+):+ ownership, _, _ = durable_stream_stores++ async def upstream(*_args, **_kwargs):+ yield b'{"id":"resp-delete-failure","delta":{"content":"Answer"}}\n'++ monkeypatch.setattr(agent_module, "async_stream", upstream)+ await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")+ )+ ownership_path = Path(ownership.ownership_file)+ ownership_path.unlink()+ ownership_path.mkdir()++ async def monitor_delete(_self, _session_id):+ return True++ monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)+ result = await ChatService().delete_session("alice", "resp-delete-failure")+ assert result["success"] is False+ await _assert_owns("resp-delete-failure", "alice")+ assert "resp-delete-failure" in agent_module.active_conversations["alice"]++[email protected]("durable_stream_stores", ["hybrid"], indirect=True)+async def test_json_only_alias_cleanup_precedes_failed_db_revocation(+ monkeypatch, durable_stream_stores+):+ from db.repositories import SessionOwnershipRepo++ ownership, _, factory = durable_stream_stores++ async def upstream(*_args, **kwargs):+ response_id = "alias" if kwargs.get("previous_response_id") else "canonical"+ yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()++ monkeypatch.setattr(agent_module, "async_stream", upstream)+ await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(object(), "flow", "First", "alice")+ )++ def unavailable_database():+ raise OSError("database temporarily unavailable")++ ownership._session_factory = unavailable_database+ await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(+ object(), "flow", "Next", "alice", previous_response_id="canonical"+ )+ )+ ownership._session_factory = factory+ async with factory() as session:+ assert await SessionOwnershipRepo(session).get("alias") is None+ assert await ownership.get_session_owner("alias") == "alice"+ original = SessionOwnershipRepo.release++ async def failed_release(*_args):+ raise OSError("database revocation failed")++ upstream_deletes = []++ async def monitor_delete(_self, session_id):+ upstream_deletes.append(session_id)+ return True++ monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)+ monkeypatch.setattr(SessionOwnershipRepo, "release", failed_release)+ result = await ChatService().delete_session("alice", "canonical")+ assert result["success"] is False+ assert set(upstream_deletes) == {"canonical", "alias"}+ # Even though JSON-only ownership was revoked, its upstream cleanup was not+ # lost. The surviving canonical DB row can be retried after a restart.+ reloaded = SessionOwnershipService(session_factory=factory)+ monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)+ monkeypatch.setattr(SessionOwnershipRepo, "release", original)+ assert (await ChatService().delete_session("alice", "canonical"))["success"] is True++[email protected]("storage", ["persisted", "memory"])[email protected]("operation", ["direct", "single", "bulk"])+async def test_delete_own_orphan_without_upstream_authorization(+ monkeypatch, durable_stream_stores, storage, operation+):+ ownership, persistence, _ = durable_stream_stores+ state = {"messages": [], "created_at": datetime.now()}+ if storage == "persisted":+ await persistence.store_conversation_thread("alice", "orphan", state)+ else:+ agent_module.active_conversations["alice"] = {"orphan": state}+ assert await ownership.get_session_owner("orphan") is None+ upstream_deletes = []++ async def monitor_delete(_self, session_id):+ upstream_deletes.append(session_id)+ return True++ monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)+ if operation == "direct":+ assert await agent_module.delete_user_conversation("alice", "orphan") is True+ elif operation == "single":+ assert (await ChatService().delete_session("alice", "orphan"))["success"] is True+ else:+ assert await ChatService().delete_sessions("alice", ["orphan"]) == {+ "deleted": ["orphan"],+ "failed": [],+ }+ assert await persistence.get_conversation_thread("alice", "orphan") == {}+ assert "orphan" not in agent_module.active_conversations.get("alice", {})+ assert upstream_deletes == []+ with pytest.raises(HTTPException) as missing:+ await _assert_owns("orphan", "alice")+ assert missing.value.status_code == 404+++async def test_delete_all_removes_persisted_orphans_only_for_caller(+ monkeypatch, durable_stream_stores+):+ _, persistence, _ = durable_stream_stores+ state = {"messages": [], "created_at": datetime.now()}+ await persistence.store_conversation_thread("alice", "orphan", state)+ await persistence.store_conversation_thread("mallory", "foreign", state)+ upstream_deletes = []++ async def monitor_delete(_self, session_id):+ upstream_deletes.append(session_id)+ return True++ monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)+ assert await ChatService().delete_all_user_sessions("alice") == {+ "success": True,+ "deleted_count": 1,+ "total_count": 1,+ }+ assert await persistence.get_user_conversations("alice") == {}+ assert await persistence.get_conversation_thread("mallory", "foreign")+ assert upstream_deletes == []+++async def test_missing_and_foreign_deletes_never_touch_upstream(monkeypatch, durable_stream_stores):+ ownership, persistence, _ = durable_stream_stores+ state = {"messages": [], "created_at": datetime.now()}+ await persistence.store_conversation_thread("mallory", "foreign", state)+ await ownership.claim_session("mallory", "foreign")+ upstream_deletes = []++ async def monitor_delete(_self, session_id):+ upstream_deletes.append(session_id)+ return True++ monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)+ service = ChatService()+ for session_id in ("missing", "foreign"):+ assert await agent_module.delete_user_conversation("alice", session_id) is False+ assert (await service.delete_session("alice", session_id))["not_found"] is True+ assert await service.delete_sessions("alice", ["missing", "foreign"]) == {+ "deleted": [],+ "failed": ["missing", "foreign"],+ }+ assert await persistence.get_conversation_thread("mallory", "foreign")+ assert await ownership.get_session_owner("foreign") == "mallory"+ assert upstream_deletes == []+ user = SimpleNamespace(db_user_id="alice", user_id="oauth-alice")+ for session_id, status in (("missing", 404), ("foreign", 403)):+ with pytest.raises(HTTPException) as denied:+ await delete_session_endpoint(session_id=session_id, chat_service=service, user=user)+ assert denied.value.status_code == status+++async def test_delete_uses_one_owned_snapshot_for_upstream_and_revocation(+ monkeypatch, durable_stream_stores+):+ ownership, _, _ = durable_stream_stores++ async def upstream(*_args, **_kwargs):+ yield b'{"id":"canonical","response_id":"alias","delta":{"content":"Answer"}}\n'++ monkeypatch.setattr(agent_module, "async_stream", upstream)+ await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")+ )+ resolve = ownership.get_conversation_sessions+ resolutions = []++ async def resolve_once(user_id, session_id):+ resolutions.append(session_id)+ assert len(resolutions) == 1, "Deletion resolved a different ownership snapshot"+ return await resolve(user_id, session_id)++ upstream_deletes = []++ async def monitor_delete(_self, session_id):+ upstream_deletes.append(session_id)+ if session_id == "canonical":+ assert await ownership.claim_session("alice", "late-alias", "canonical")+ return True++ monkeypatch.setattr(ownership, "get_conversation_sessions", resolve_once)+ monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)+ result = await ChatService().delete_session("alice", "alias")+ assert result["success"] is True+ assert resolutions == ["alias"]+ assert set(upstream_deletes) == {"canonical", "alias"}+ assert await ownership.get_session_owner("canonical") is None+ assert await ownership.get_session_owner("alias") is None+ # A claim arriving after the snapshot is not revoked without upstream cleanup.+ assert await ownership.get_session_owner("late-alias") == "alice"+++async def test_restart_alias_only_continuation_keeps_durable_canonical(+ monkeypatch, durable_stream_stores+):+ _, persistence, factory = durable_stream_stores+ calls = []++ async def upstream(*_args, **kwargs):+ calls.append(kwargs.get("previous_response_id"))+ response_id = ("canonical", "alias", "after-restart")[len(calls) - 1]+ yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()++ monkeypatch.setattr(agent_module, "async_stream", upstream)+ for previous in (None, "canonical"):+ await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(+ object(),+ "flow",+ "First question" if previous is None else "Follow-up",+ "alice",+ previous_response_id=previous,+ filter_id="knowledge-filter" if previous is None else None,+ )+ )+ before_restart = await persistence.get_conversation_thread("alice", "canonical")+ assert before_restart["total_messages"] == 4+ reloaded = SessionOwnershipService(session_factory=factory)+ monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)+ monkeypatch.setattr(agent_module, "active_conversations", {})+ reloaded_persistence = ConversationPersistenceService(+ storage_file=persistence.storage_file, session_factory=factory+ )+ monkeypatch.setattr(agent_module, "conversation_persistence", reloaded_persistence)+ await _assert_owns("alias", "alice")+ await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(+ object(), "flow", "After restart", "alice", previous_response_id="alias"+ )+ )+ assert calls == [None, "canonical", "alias"]+ assert list(await reloaded_persistence.get_user_conversations("alice")) == ["canonical"]+ after_restart = await reloaded_persistence.get_conversation_thread("alice", "canonical")+ assert after_restart["title"] == before_restart["title"] == "First question"+ assert after_restart["created_at"] == before_restart["created_at"]+ assert after_restart["filter_id"] == "knowledge-filter"+ assert after_restart["total_messages"] == 6+ history = await ChatService().get_chat_history("alice")+ restored = next(c for c in history["conversations"] if c["response_id"] == "canonical")+ assert restored["created_at"] == before_restart["created_at"]+ assert restored["title"] == "First question"+ assert restored["total_messages"] == 6+ fresh = SessionOwnershipService(session_factory=factory)+ assert set(await fresh.get_conversation_sessions("alice", "after-restart")) == {+ "canonical",+ "alias",+ "after-restart",+ }+ assert set(agent_module.active_conversations["alice"]) == {"canonical"}++[email protected]("durable_stream_stores", ["files"], indirect=True)[email protected]("created_at", [None, "not-a-date", 123])+async def test_restart_invalid_creation_time_keeps_default(+ monkeypatch, durable_stream_stores, created_at+):+ ownership, persistence, _ = durable_stream_stores+ await ownership.claim_session("alice", "canonical")+ await ownership.claim_session("alice", "alias", conversation_id="canonical")+ await persistence.store_conversation_thread(+ "alice",+ "canonical",+ {"title": "Saved title", "created_at": created_at, "total_messages": 4},+ )++ async def upstream(*_args, **_kwargs):+ yield b'{"id":"next","delta":{"content":"Answer"}}\n'++ monkeypatch.setattr(agent_module, "async_stream", upstream)+ started = datetime.now()+ await _collect_error_chunks(+ agent_module.async_langflow_chat_stream(+ object(), "flow", "Follow-up", "alice", previous_response_id="alias"+ )+ )+ history = await ChatService().get_chat_history("alice")+ restored = next(c for c in history["conversations"] if c["response_id"] == "canonical")+ assert started <= datetime.fromisoformat(restored["created_at"]) <= datetime.now()+ assert restored["title"] == "Saved title"+ assert restored["total_messages"] == 6diff --git a/tests/unit/services/test_session_ownership_service_modes.py b/tests/unit/services/test_session_ownership_service_modes.pyindex 10f1ec2a1..af0f64034 100644--- a/tests/unit/services/test_session_ownership_service_modes.py+++ b/tests/unit/services/test_session_ownership_service_modes.py@@ -1,7 +1,11 @@"""SessionOwnershipService — hybrid / db / files mode coverage."""+import asyncioimport json+import os+import statimport sys+import threadingfrom pathlib import Pathimport pytest@@ -314,9 +318,12 @@ async def test_hybrid_losing_db_insert_cannot_publish_fallback_owner(# Model a competing claimant whose SELECT happened just before the winner's# insert. The ensuing flush hits the real DB primary-key constraint.original = SessionOwnershipRepo.get+ stale_read = Falseasync def stale_get(repo, response_id):- if response_id == "contended":+ nonlocal stale_read+ if response_id == "contended" and not stale_read:+ stale_read = Truereturn Nonereturn await original(repo, response_id)@@ -334,8 +341,6 @@ async def test_hybrid_losing_db_insert_cannot_publish_fallback_owner(async def test_hybrid_rechecks_cache_after_awaiting_database(monkeypatch, tmp_data_dir, session_factory):- import asyncio-monkeypatch.setenv("OPENRAG_STORAGE_MODE", "hybrid")svc = _svc(session_factory)waiting = asyncio.Event()@@ -356,3 +361,349 @@ async def test_hybrid_rechecks_cache_after_awaiting_database(winner_published.set()assert await losing_claim is Falseassert json.loads(tmp_data_dir.read_text())["contended"]["user_id"] == "alice"+++async def test_file_fsync_keeps_event_loop_responsive(monkeypatch, tmp_data_dir):+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")+ svc = _svc(None)+ heartbeat = threading.Event()+ responsive = []+ original_fsync = os.fsync++ def delayed_fsync(fd):+ responsive.append(heartbeat.wait(timeout=1))+ original_fsync(fd)++ monkeypatch.setattr(os, "fsync", delayed_fsync)+ claim = asyncio.create_task(svc.claim_session("alice", "canonical"))+ await asyncio.sleep(0)+ heartbeat.set()+ assert await claim is True+ assert responsive and all(responsive), "fsync blocked the event-loop heartbeat"++[email protected]("mutation", ["claim", "release", "release_group"])+async def test_concurrent_file_mutations_keep_every_committed_change(+ monkeypatch, tmp_data_dir, mutation+):+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")+ svc = _svc(None)+ assert await svc.claim_session("alice", "existing") is True+ assert await svc.claim_session("alice", "victim") is True+ entered = threading.Event()+ finish = threading.Event()+ original_fsync = os.fsync++ def pause_first_fsync(fd):+ if not entered.is_set():+ entered.set()+ assert finish.wait(timeout=2), "file persistence blocked the event loop"+ original_fsync(fd)++ monkeypatch.setattr(os, "fsync", pause_first_fsync)+ first = asyncio.create_task(svc.claim_session("alice", "first"))+ try:+ assert await asyncio.to_thread(entered.wait, 2)+ if mutation == "claim":+ operation = svc.claim_session("alice", "second")+ elif mutation == "release":+ operation = svc.release_session("alice", "victim")+ else:+ operation = svc.release_conversation_sessions("alice", ["victim"])+ second = asyncio.create_task(operation)+ await asyncio.sleep(0)+ finally:+ finish.set()+ first_result, _ = await asyncio.gather(first, second)+ assert first_result is True+ expected = (+ {"existing", "first", "victim", "second"}+ if mutation == "claim"+ else {+ "existing",+ "first",+ }+ )+ assert set(svc.ownership_data) == expected+ assert set(json.loads(tmp_data_dir.read_text())) == expected+ assert set(await _svc(None).get_user_sessions("alice")) == expected++[email protected]("mutation", ["claim", "release", "release_group"])+async def test_failed_file_mutation_preserves_durable_ownership(+ monkeypatch, tmp_data_dir, mutation+):+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")+ svc = _svc(None)+ assert await svc.claim_session("alice", "canonical") is True+ before = tmp_data_dir.read_bytes()++ def fail_replace(*args):+ raise OSError("atomic replacement unavailable")++ monkeypatch.setattr(os, "replace", fail_replace)+ if mutation == "claim":+ assert await svc.claim_session("alice", "alias", conversation_id="canonical") is False+ else:+ with pytest.raises(OSError, match="atomic replacement unavailable"):+ if mutation == "release":+ await svc.release_session("alice", "canonical")+ else:+ await svc.release_conversation_sessions("alice", ["canonical"])+ assert tmp_data_dir.read_bytes() == before+ assert svc.ownership_data == json.loads(before)+ assert await _svc(None).get_user_sessions("alice") == ["canonical"]+ assert list(tmp_data_dir.parent.iterdir()) == [tmp_data_dir]++[email protected]("sync_fails", [False, True])+async def test_file_claim_waits_for_directory_durability_before_publishing(+ monkeypatch, tmp_data_dir, sync_fails+):+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")+ svc = _svc(None)+ entered = threading.Event()+ finish = threading.Event()+ directory_fds = []+ original_fsync = os.fsync++ def pause_directory_fsync(fd):+ if stat.S_ISDIR(os.fstat(fd).st_mode):+ directory_fds.append(fd)+ entered.set()+ assert finish.wait(timeout=2), "directory sync blocked the event loop"+ if sync_fails:+ raise OSError("directory sync unavailable")+ original_fsync(fd)++ monkeypatch.setattr(os, "fsync", pause_directory_fsync)+ claim = asyncio.create_task(svc.claim_session("alice", "canonical"))+ try:+ assert await asyncio.to_thread(entered.wait, 2)+ # Replacement alone is not a durable claim and must not authorize it.+ assert json.loads(tmp_data_dir.read_text())["canonical"]["user_id"] == "alice"+ assert not claim.done()+ assert await svc.get_session_owner("canonical") is None+ finally:+ finish.set()+ result = await claim+ assert result is not sync_fails+ assert await svc.get_session_owner("canonical") == (None if sync_fails else "alice")+ assert len(directory_fds) == 1+ with pytest.raises(OSError):+ os.fstat(directory_fds[0])+ assert list(tmp_data_dir.parent.iterdir()) == [tmp_data_dir]+++async def test_atomic_file_replacement_preserves_existing_permissions(monkeypatch, tmp_data_dir):+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", "files")+ svc = _svc(None)+ assert await svc.claim_session("alice", "canonical") is True+ tmp_data_dir.chmod(0o640)+ assert await svc.claim_session("alice", "alias", conversation_id="canonical") is True+ assert stat.S_IMODE(tmp_data_dir.stat().st_mode) == 0o640++[email protected]("mode", ["db", "hybrid"])+ ("winner_user", "winner_canonical", "accepted"),+ [+ ("alice", "canonical", True),+ ("bob", "foreign", False),+ ("alice", "other", False),+ ],+)+async def test_real_database_claim_race_checks_winning_owner_and_conversation(+ monkeypatch, tmp_data_dir, tmp_path, mode, winner_user, winner_canonical, accepted+):+ engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'ownership-race.db'}")+ async with engine.begin() as connection:+ await connection.run_sync(SQLModel.metadata.create_all)+ factory = async_sessionmaker(engine, expire_on_commit=False)+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")+ setup = _svc(factory)+ for user, canonical in (("alice", "canonical"), ("alice", "other"), ("bob", "foreign")):+ assert await setup.claim_session(user, canonical) is True+ selected_missing = asyncio.Event()+ winner_committed = asyncio.Event()+ original_get = SessionOwnershipRepo.get++ async def pause_after_missing_read(repo, response_id):+ row = await original_get(repo, response_id)+ if response_id == "contended" and row is None and not selected_missing.is_set():+ selected_missing.set()+ await winner_committed.wait()+ return row++ monkeypatch.setattr(SessionOwnershipRepo, "get", pause_after_missing_read)+ loser = _svc(factory)+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)+ pending = asyncio.create_task(+ loser.claim_session("alice", "contended", conversation_id="canonical")+ )+ try:+ await asyncio.wait_for(selected_missing.wait(), timeout=2)+ # The loser already read no row; this insert commits on another real+ # connection before its stale INSERT hits the primary-key constraint.+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")+ assert (+ await _svc(factory).claim_session(+ winner_user, "contended", conversation_id=winner_canonical+ )+ is True+ )+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)+ finally:+ winner_committed.set()+ try:+ assert await pending is accepted+ fresh = _svc(factory)+ assert await fresh.get_session_owner("contended") == winner_user+ if accepted:+ assert set(await fresh.get_conversation_sessions("alice", "canonical")) == {+ "canonical",+ "contended",+ }+ else:+ assert "contended" not in loser.ownership_data+ if mode == "hybrid":+ assert tmp_data_dir.exists() is accepted+ finally:+ await engine.dispose()++[email protected]("mode", ["db", "hybrid"])+async def test_unrelated_database_integrity_error_is_not_an_owned_race(+ monkeypatch, tmp_data_dir, session_factory, mode+):+ from sqlalchemy.exc import IntegrityError++ monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")+ assert await _svc(session_factory).claim_session("alice", "canonical") is True+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)+ svc = _svc(session_factory)++ async def unrelated_failure(*args):+ raise IntegrityError("UPDATE session_ownership", {}, ValueError("unrelated constraint"))++ monkeypatch.setattr(SessionOwnershipRepo, "claim", unrelated_failure)+ with pytest.raises(IntegrityError, match="unrelated constraint"):+ await svc.claim_session("alice", "canonical")+ assert svc.ownership_data == {}+ assert not tmp_data_dir.exists()++[email protected]("mode", ["db", "hybrid"])+async def test_nonunique_insert_integrity_error_cannot_reuse_compatible_owner(+ monkeypatch, tmp_data_dir, session_factory, mode+):+ from sqlalchemy import text+ from sqlalchemy.exc import IntegrityError++ monkeypatch.setenv("OPENRAG_STORAGE_MODE", "db")+ assert await _svc(session_factory).claim_session("alice", "canonical") is True+ async with session_factory() as session:+ await session.execute(+ text(+ "CREATE TRIGGER reject_ownership_insert BEFORE INSERT ON session_ownership "+ "BEGIN SELECT RAISE(ABORT, 'unrelated ownership constraint'); END"+ )+ )+ await session.commit()+ original_get = SessionOwnershipRepo.get+ stale_read = False++ async def stale_once(repo, response_id):+ nonlocal stale_read+ if response_id == "canonical" and not stale_read:+ stale_read = True+ return None+ return await original_get(repo, response_id)++ monkeypatch.setattr(SessionOwnershipRepo, "get", stale_once)+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)+ svc = _svc(session_factory)+ with pytest.raises(IntegrityError, match="unrelated ownership constraint"):+ await svc.claim_session("alice", "canonical")+ assert svc.ownership_data == {}+ assert not tmp_data_dir.exists()++[email protected]("mode", ["db", "hybrid", "files"])+async def test_legacy_null_association_remains_its_own_canonical_conversation(+ monkeypatch, tmp_data_dir, session_factory, mode+):+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)+ svc = _svc(session_factory)+ assert await svc.claim_session("alice", "legacy") is True+ assert await svc.claim_session("alice", "other") is True+ if mode != "files":+ async with session_factory() as session:+ row = await SessionOwnershipRepo(session).get("legacy")+ row.conversation_id = None+ await session.commit()+ if mode != "db":+ data = json.loads(tmp_data_dir.read_text())+ data["legacy"]["conversation_id"] = None+ tmp_data_dir.write_text(json.dumps(data))+ fresh = _svc(session_factory)+ assert await fresh.claim_session("alice", "legacy", conversation_id="other") is False+ assert await fresh.get_conversation_sessions("alice", "legacy") == ["legacy"]++[email protected]("mode", ["files", "hybrid"])[email protected]("operation", ["claim", "release", "release_group"])+async def test_directory_sync_failure_reconciles_before_next_mutation(+ monkeypatch, tmp_data_dir, session_factory, mode, operation+):+ monkeypatch.setenv("OPENRAG_STORAGE_MODE", mode)+ svc = _svc(session_factory)+ if mode == "hybrid":+ # Exercise the JSON fallback without a successful database write.+ monkeypatch.setattr(svc, "_resolve_session_factory", lambda: None)+ assert await svc.claim_session("alice", "existing")+ real_fsync = os.fsync++ def failed_directory_sync(fd):+ if stat.S_ISDIR(os.fstat(fd).st_mode):+ raise OSError("directory sync unavailable")+ real_fsync(fd)++ monkeypatch.setattr(os, "fsync", failed_directory_sync)+ if operation == "claim":+ assert await svc.claim_session("alice", "uncertain") is False+ else:+ with pytest.raises(OSError, match="directory sync unavailable"):+ if operation == "release":+ await svc.release_session("alice", "existing")+ else:+ await svc.release_conversation_sessions("alice", ["existing"])+ replaced = json.loads(tmp_data_dir.read_text())+ assert ("uncertain" in replaced) == (operation == "claim")+ assert ("existing" in replaced) == (operation == "claim")+ # Neither authorization nor subsequent mutations may use the stale cache.+ assert await svc.get_session_owner("existing") is None+ assert await svc.get_user_sessions("alice") == []+ assert await svc.claim_session("alice", "later") is False+ with pytest.raises(OSError, match="directory sync unavailable"):+ await svc.release_session("alice", "existing")+ assert json.loads(tmp_data_dir.read_text()) == replaced++ monkeypatch.setattr(os, "fsync", real_fsync)+ assert await svc.claim_session("alice", "later") is True+ recovered = _svc(session_factory)+ if mode == "hybrid":+ monkeypatch.setattr(recovered, "_resolve_session_factory", lambda: None)+ expected = {"existing", "uncertain", "later"} if operation == "claim" else {"later"}+ assert set(await svc.get_user_sessions("alice")) == expected+ assert set(await recovered.get_user_sessions("alice")) == expecteddiff --git a/tests/unit/test_chat_service_bulk_delete.py b/tests/unit/test_chat_service_bulk_delete.pyindex 81783308b..33b44fa8b 100644--- a/tests/unit/test_chat_service_bulk_delete.py+++ b/tests/unit/test_chat_service_bulk_delete.py@@ -16,22 +16,6 @@ def _patch_owner(monkeypatch, owners):)-async def test_bulk_delete_mixed_ownership(monkeypatch):- svc = _make_service()- # alice owns s1; s2 is bob's; s3 has no owner- _patch_owner(monkeypatch, {"s1": "alice", "s2": "bob", "s3": None})- svc.delete_session = AsyncMock(return_value={"success": True, "error": None})-- result = await svc.delete_sessions("alice", ["s1", "s2", "s3"])-- assert result["deleted"] == ["s1"]- assert sorted(result["failed"]) == ["s2", "s3"]- # only the owned id ever reaches delete_session- called = {c.args[1] for c in svc.delete_session.call_args_list}- assert called == {"s1"}--@pytest.mark.asyncioasync def test_bulk_delete_all_succeed(monkeypatch):svc = _make_service()diff --git a/tests/unit/test_langflow_stream_provider_errors.py b/tests/unit/test_langflow_stream_provider_errors.pyindex 15e9f3556..e2d3c75eb 100644--- a/tests/unit/test_langflow_stream_provider_errors.py+++ b/tests/unit/test_langflow_stream_provider_errors.py@@ -1,31 +1,13 @@-"""Langflow stream lifecycle and provider-error regressions.--Only the upstream provider is replaced; cancellation regressions use the real-conversation store and ownership guard, including durable SQLite ownership.-"""+"""Langflow provider-error formatting and stream error regressions."""from __future__ import annotations-import asyncioimport jsonfrom collections.abc import AsyncIterator-from pathlib import Path-from types import SimpleNamespace-import anyio-import httpximport pytest-import pytest_asyncio-from fastapi import HTTPException-from openai import AsyncOpenAI-from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine-from sqlmodel import SQLModelimport agent as agent_module-from api.chat import ChatBody, _assert_owns, delete_session_endpoint, langflow_endpoint-from services.chat_service import ChatService-from services.conversation_persistence_service import ConversationPersistenceService-from services.session_ownership_service import SessionOwnershipServicedef test_format_provider_error_message_extracts_embedded_json():@@ -119,6 +101,9 @@ def store_in_memory(monkeypatch):async def get_session_owner(self, session_id):return next((user_id for user_id, sid in claimed if sid == session_id), None)+ async def get_conversation_sessions(self, user_id, session_id):+ return []+monkeypatch.setattr(agent_module, "store_conversation_thread", _store)monkeypatch.setattr("services.session_ownership_service.session_ownership_service",@@ -561,514 +546,3 @@ async def test_chat_stream_yields_provider_error_chunk(monkeypatch, store_in_memassert not stored_id.startswith("error_")assert chunks[0].get("id") == stored_idassert stored_id in agent_module.active_conversations.get(user_id, {})---@pytest_asyncio.fixture(params=["db", "hybrid", "files"])-async def durable_stream_stores(request, monkeypatch, tmp_path):- monkeypatch.setenv("OPENRAG_STORAGE_MODE", request.param)- engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'chat.db'}")- async with engine.begin() as connection:- await connection.run_sync(SQLModel.metadata.create_all)- factory = async_sessionmaker(engine, expire_on_commit=False)- monkeypatch.setattr(- "services.session_ownership_service.get_data_file",- lambda name: str(tmp_path / name),- )- ownership = SessionOwnershipService(session_factory=factory)- persistence = ConversationPersistenceService(- storage_file=str(tmp_path / "conversations.json"), session_factory=factory- )- monkeypatch.setattr("services.session_ownership_service.session_ownership_service", ownership)- monkeypatch.setattr(agent_module, "conversation_persistence", persistence)- monkeypatch.setattr(agent_module, "active_conversations", {})- yield ownership, persistence, factory- await engine.dispose()--[email protected]("abort", ["close", "cancel"])-async def test_aborted_langflow_stream_keeps_owned_id_and_partial_turn(- monkeypatch, durable_stream_stores, abort-):- ownership, persistence, factory = durable_stream_stores- waiting = asyncio.Event()- upstream_closed = asyncio.Event()- calls = []-- async def upstream(*_args, **kwargs):- calls.append(kwargs.get("previous_response_id"))- try:- yield b'{"id":"resp-first","delta":{"content":"Partial answer"}}\n'- waiting.set()- await asyncio.Event().wait()- finally:- upstream_closed.set()-- monkeypatch.setattr(agent_module, "async_stream", upstream)- stream = agent_module.async_langflow_chat_stream(object(), "flow", "First question", "alice")- chunk = json.loads(await anext(stream))- # The ID must already be durable when it first crosses the generator boundary.- await _assert_owns(chunk["id"], "alice")- assert (await persistence.get_conversation_thread("alice", chunk["id"]))["total_messages"] >= 1- if abort == "close":- await stream.aclose()- else:- pending = asyncio.create_task(anext(stream))- await waiting.wait()- pending.cancel()- with pytest.raises(asyncio.CancelledError):- await pending- assert upstream_closed.is_set()- # Reload ownership rather than relying on the live service's cache.- reloaded = SessionOwnershipService(session_factory=factory)- assert await reloaded.get_session_owner(chunk["id"]) == "alice"- with pytest.raises(HTTPException) as forbidden:- await _assert_owns(chunk["id"], "mallory")- assert forbidden.value.status_code == 403- with pytest.raises(HTTPException) as missing:- await _assert_owns("unknown-session", "alice")- assert missing.value.status_code == 404-- async def continuation(*_args, **kwargs):- calls.append(kwargs.get("previous_response_id"))- yield b'{"id":"resp-next","response_id":"resp-next-alias","delta":{"content":"Next"}}\n'-- monkeypatch.setattr(agent_module, "async_stream", continuation)- await _assert_owns(chunk["id"], "alice")- followup = agent_module.async_langflow_chat_stream(- object(),- "flow",- "Follow-up",- "alice",- previous_response_id=chunk["id"],- conversation_id=chunk["id"],- )- next_chunk = json.loads(await anext(followup))- await _assert_owns(next_chunk["id"], "alice")- await _assert_owns(next_chunk["response_id"], "alice")- assert await _collect_error_chunks(followup) == []- assert calls == [None, "resp-first"] # Never replay the interrupted prompt.- conversations = await persistence.get_user_conversations("alice")- assert list(conversations) == ["resp-first"] # Stable sidebar id, changing response ids.- messages = agent_module.active_conversations["alice"]["resp-first"]["messages"]- assert [(m["role"], m["content"]) for m in messages if m["role"] != "system"] == [- ("user", "First question"),- ("assistant", "Partial answer"),- ("user", "Follow-up"),- ("assistant", "Next"),- ]- assert conversations["resp-first"]["total_messages"] == 4-- # SDK callers may only carry the changing response ID, not conversation_id.- await _collect_error_chunks(- agent_module.async_langflow_chat_stream(- object(),- "flow",- "Third question",- "alice",- previous_response_id=next_chunk["response_id"],- )- )- assert list(await persistence.get_user_conversations("alice")) == ["resp-first"]- assert calls == [None, "resp-first", "resp-next-alias"]- assert [m["content"] for m in messages if m["role"] == "user"] == [- "First question",- "Follow-up",- "Third question",- ]--[email protected]("claim_failure", ["unavailable", "foreign"])-async def test_stream_does_not_expose_unowned_response_id(- monkeypatch, durable_stream_stores, claim_failure-):- ownership, persistence, _ = durable_stream_stores- if claim_failure == "foreign":- await ownership.claim_session("mallory", "resp-unclaimable")- else:-- async def unavailable(*_args, **_kwargs):- return False-- monkeypatch.setattr(ownership, "claim_session", unavailable)-- async def upstream(*_args, **_kwargs):- yield b'{"id":"resp-unclaimable","delta":{"content":"Not exposed"}}\n'-- monkeypatch.setattr(agent_module, "async_stream", upstream)- chunks = await _collect_error_chunks(- agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")- )- assert len(chunks) == 1- assert chunks[0]["status"] == "failed"- assert "id" not in chunks[0] and "response_id" not in chunks[0]- assert await persistence.get_user_conversations("alice") == {}- assert await ownership.get_session_owner("resp-unclaimable") == (- "mallory" if claim_failure == "foreign" else None- )---async def test_local_asgi_disconnect_smoke_preserves_followup(monkeypatch, durable_stream_stores):- """Real endpoint → generator → OpenAI SSE adapter → durable stores, locally."""- _, persistence, factory = durable_stream_stores- disconnected = anyio.Event()- upstream_closed = anyio.Event()- calls = []-- class ProviderStream(httpx.AsyncByteStream):- async def __aiter__(self):- yield (- b"event: response.created\n"- b'data: {"type":"response.created","response":{"id":"resp-http"}}\n\n'- )- yield (- b"event: response.output_text.delta\n"- b'data: {"type":"response.output_text.delta","id":"resp-http",'- b'"delta":{"content":"Partial HTTP answer"}}\n\n'- )- await anyio.sleep_forever()-- async def aclose(self):- upstream_closed.set()-- async def provider(request):- payload = json.loads(request.content)- calls.append(payload)- if len(calls) == 1:- return httpx.Response(- 200, headers={"content-type": "text/event-stream"}, stream=ProviderStream()- )- return httpx.Response(- 200,- headers={"content-type": "text/event-stream"},- content=(- b"event: response.output_text.delta\n"- b'data: {"type":"response.output_text.delta","id":"resp-http-next",'- b'"delta":{"content":"Follow-up HTTP answer"}}\n\n'- b"event: response.completed\n"- b'data: {"type":"response.completed","response":{"id":"resp-http-next",'- b'"usage":{"input_tokens":3,"output_tokens":4,"total_tokens":7}}}\n\n'- ),- )-- async with AsyncOpenAI(- api_key="local-test-only",- base_url="https://provider.invalid/v1",- http_client=httpx.AsyncClient(transport=httpx.MockTransport(provider)),- max_retries=0,- ) as client:-- class EndpointChatService:- async def langflow_chat(self, prompt, _subject, _jwt, **kwargs):- return agent_module.async_langflow_chat_stream(- client,- "flow",- prompt,- kwargs["storage_user_id"],- previous_response_id=kwargs["previous_response_id"],- conversation_id=kwargs["conversation_id"],- )-- user = SimpleNamespace(- user_id="oauth-alice",- db_user_id="alice",- jwt_token="local-test-only",- name="Alice",- email="[email protected]",- )- service = EndpointChatService()- response = await langflow_endpoint(- ChatBody(prompt="First HTTP question", stream=True),- chat_service=service,- session_manager=None,- user=user,- )- emitted = []-- async def send(message):- if message["type"] == "http.response.body" and message.get("body"):- chunk = json.loads(message["body"])- emitted.append(chunk)- response_id = chunk.get("id") or (chunk.get("response") or {}).get("id")- if response_id:- await _assert_owns(response_id, "alice")- if chunk.get("delta", {}).get("content"):- disconnected.set()-- async def receive():- await disconnected.wait()- return {"type": "http.disconnect"}-- # Starlette's real disconnect listener cancels the body iterator using an- # AnyIO cancel scope, rather than manually throwing into our generator.- with anyio.fail_after(5):- await response({"type": "http", "asgi": {"spec_version": "2.3"}}, receive, send)- assert upstream_closed.is_set()- assert len(emitted) == 2- metadata = await persistence.get_conversation_thread("alice", "resp-http")- assert metadata["total_messages"] == 2-- followup = await langflow_endpoint(- ChatBody(- prompt="Next HTTP question",- stream=True,- previous_response_id="resp-http",- conversation_id="resp-http",- ),- chat_service=service,- session_manager=None,- user=user,- )- chunks = await _collect_error_chunks(followup.body_iterator)- await _assert_owns("resp-http-next", "alice")- assert chunks[-1]["response"]["usage"]["total_tokens"] == 7- assert calls[1]["previous_response_id"] == "resp-http"- assert [call["input"] for call in calls] == ["First HTTP question", "Next HTTP question"]- conversations = await persistence.get_user_conversations("alice")- assert list(conversations) == ["resp-http"]- assert conversations["resp-http"]["total_messages"] == 4- messages = agent_module.active_conversations["alice"]["resp-http"]["messages"]- assert [m["content"] for m in messages if m["role"] != "system"] == [- "First HTTP question",- "Partial HTTP answer",- "Next HTTP question",- "Follow-up HTTP answer",- ]-- # Restart before canonical deletion: aliases must come from durable state.- reloaded = SessionOwnershipService(session_factory=factory)- monkeypatch.setattr(- "services.session_ownership_service.session_ownership_service", reloaded- )- monkeypatch.setattr(agent_module, "active_conversations", {})- upstream_deletes = []-- async def monitor_delete(method, path):- assert method == "DELETE"- upstream_deletes.append(path.rsplit("/", 1)[-1])- return httpx.Response(204)-- monkeypatch.setattr("services.chat_service.clients.langflow_request", monitor_delete)- deletion = await delete_session_endpoint(- session_id="resp-http", chat_service=ChatService(), user=user- )- assert deletion.status_code == 200- assert set(upstream_deletes) == {"resp-http", "resp-http-next"}- fresh = SessionOwnershipService(session_factory=factory)- monkeypatch.setattr("services.session_ownership_service.session_ownership_service", fresh)- with pytest.raises(HTTPException) as missing:- await langflow_endpoint(- ChatBody(- prompt="Cannot resurrect", stream=True, previous_response_id="resp-http-next"- ),- chat_service=service,- session_manager=None,- user=user,- )- assert missing.value.status_code == 404- assert len(calls) == 2-- # Actual endpoint + SSE adapter with both persistent destinations broken.- ownership_path = Path(fresh.ownership_file)- if ownership_path.exists():- ownership_path.unlink()- ownership_path.mkdir()-- def unavailable_database():- raise OSError("local smoke database unavailable")-- monkeypatch.setattr(fresh, "_resolve_session_factory", lambda: unavailable_database)- failed = await langflow_endpoint(- ChatBody(prompt="Fail closed", stream=True),- chat_service=service,- session_manager=None,- user=user,- )- failed_chunks = await _collect_error_chunks(failed.body_iterator)- assert len(failed_chunks) == 1 and failed_chunks[0]["status"] == "failed"- assert "id" not in failed_chunks[0] and "response_id" not in failed_chunks[0]- assert (- await SessionOwnershipService(session_factory=factory).get_session_owner(- "resp-http-next"- )- is None- )- print(- "LOCAL SMOKE: disconnect/follow-up retained 4 messages; restart + "- "canonical deletion removed both upstream sessions and alias authorization; "- "persistent failures emitted no client ID"- )--[email protected]("delta", [None, {"content": None}])-async def test_metadata_only_chunk_claims_id_before_exposure(- monkeypatch, durable_stream_stores, delta-):- async def upstream(*_args, **_kwargs):- yield (json.dumps({"id": "resp-metadata", "delta": delta}) + "\n").encode()-- monkeypatch.setattr(agent_module, "async_stream", upstream)- stream = agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")- chunk = json.loads(await anext(stream))- await _assert_owns(chunk["id"], "alice")- await stream.aclose()--[email protected]("delete_id", ["resp-first", "resp-second"])-async def test_delete_canonical_revokes_aliases_after_reload(- monkeypatch, durable_stream_stores, delete_id-):- ownership, persistence, factory = durable_stream_stores-- async def upstream(*_args, **kwargs):- response_id = "resp-second" if kwargs.get("previous_response_id") else "resp-first"- yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()-- monkeypatch.setattr(agent_module, "async_stream", upstream)- for previous in (None, "resp-first"):- await _collect_error_chunks(- agent_module.async_langflow_chat_stream(- object(), "flow", "Question", "alice", previous_response_id=previous- )- )- await ownership.claim_session("mallory", "resp-foreign")- await ownership.claim_session("alice", "resp-unrelated")- assert list(await persistence.get_user_conversations("alice")) == ["resp-first"]- assert await agent_module.delete_user_conversation("mallory", "resp-first") is False- assert agent_module.active_conversations["alice"]["resp-first"]["messages"]- # Restart: neither ownership cache nor the in-memory response_ids can help.- reloaded = SessionOwnershipService(session_factory=factory)- monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)- monkeypatch.setattr(agent_module, "active_conversations", {})- persistence = ConversationPersistenceService(- storage_file=persistence.storage_file, session_factory=factory- )- monkeypatch.setattr(agent_module, "conversation_persistence", persistence)- assert await agent_module.delete_user_conversation("alice", delete_id) is True- fresh = SessionOwnershipService(session_factory=factory)- monkeypatch.setattr("services.session_ownership_service.session_ownership_service", fresh)- for response_id in ("resp-first", "resp-second"):- with pytest.raises(HTTPException) as missing:- await _assert_owns(response_id, "alice")- assert missing.value.status_code == 404- assert await fresh.get_session_owner("resp-foreign") == "mallory"- assert await fresh.get_session_owner("resp-unrelated") == "alice"- assert await persistence.get_user_conversations("alice") == {}---async def test_persistent_claim_failure_never_exposes_cached_id(monkeypatch, durable_stream_stores):- ownership, persistence, factory = durable_stream_stores- # A real IO failure, not a stubbed claim: cache echo must not prove durability.- Path(ownership.ownership_file).mkdir()-- def unavailable_database():- raise OSError("local database unavailable")-- monkeypatch.setattr(ownership, "_resolve_session_factory", lambda: unavailable_database)-- async def upstream(*_args, **_kwargs):- yield b'{"id":"resp-file-failure","delta":{"content":"Not exposed"}}\n'-- monkeypatch.setattr(agent_module, "async_stream", upstream)- chunks = await _collect_error_chunks(- agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")- )- assert len(chunks) == 1- assert chunks[0]["status"] == "failed"- assert "id" not in chunks[0] and "response_id" not in chunks[0]- assert await ownership.get_session_owner("resp-file-failure") is None- assert (- await SessionOwnershipService(session_factory=factory).get_session_owner(- "resp-file-failure"- )- is None- )- assert await persistence.get_user_conversations("alice") == {}--[email protected]("durable_stream_stores", ["hybrid", "files"], indirect=True)-async def test_failed_file_revocation_is_not_reported_as_success(- monkeypatch, durable_stream_stores-):- ownership, _, _ = durable_stream_stores-- async def upstream(*_args, **_kwargs):- yield b'{"id":"resp-delete-failure","delta":{"content":"Answer"}}\n'-- monkeypatch.setattr(agent_module, "async_stream", upstream)- await _collect_error_chunks(- agent_module.async_langflow_chat_stream(object(), "flow", "Question", "alice")- )- ownership_path = Path(ownership.ownership_file)- ownership_path.unlink()- ownership_path.mkdir()-- async def monitor_delete(_self, _session_id):- return True-- monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)- result = await ChatService().delete_session("alice", "resp-delete-failure")- assert result["success"] is False- await _assert_owns("resp-delete-failure", "alice")- assert "resp-delete-failure" in agent_module.active_conversations["alice"]--[email protected]("durable_stream_stores", ["hybrid"], indirect=True)-async def test_json_only_alias_cleanup_precedes_failed_db_revocation(- monkeypatch, durable_stream_stores-):- from db.repositories import SessionOwnershipRepo-- ownership, _, factory = durable_stream_stores-- async def upstream(*_args, **kwargs):- response_id = "alias" if kwargs.get("previous_response_id") else "canonical"- yield (json.dumps({"id": response_id, "delta": {"content": "Answer"}}) + "\n").encode()-- monkeypatch.setattr(agent_module, "async_stream", upstream)- await _collect_error_chunks(- agent_module.async_langflow_chat_stream(object(), "flow", "First", "alice")- )-- def unavailable_database():- raise OSError("database temporarily unavailable")-- ownership._session_factory = unavailable_database- await _collect_error_chunks(- agent_module.async_langflow_chat_stream(- object(), "flow", "Next", "alice", previous_response_id="canonical"- )- )- ownership._session_factory = factory- async with factory() as session:- assert await SessionOwnershipRepo(session).get("alias") is None- assert await ownership.get_session_owner("alias") == "alice"- original = SessionOwnershipRepo.release-- async def failed_release(*_args):- raise OSError("database revocation failed")-- upstream_deletes = []-- async def monitor_delete(_self, session_id):- upstream_deletes.append(session_id)- return True-- monkeypatch.setattr(ChatService, "_delete_langflow_session", monitor_delete)- monkeypatch.setattr(SessionOwnershipRepo, "release", failed_release)- result = await ChatService().delete_session("alice", "canonical")- assert result["success"] is False- assert set(upstream_deletes) == {"canonical", "alias"}- # Even though JSON-only ownership was revoked, its upstream cleanup was not- # lost. The surviving canonical DB row can be retried after a restart.- reloaded = SessionOwnershipService(session_factory=factory)- monkeypatch.setattr("services.session_ownership_service.session_ownership_service", reloaded)- monkeypatch.setattr(SessionOwnershipRepo, "release", original)- assert (await ChatService().delete_session("alice", "canonical"))["success"] is True