Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
Remove Chat Sessions and its saved history (#1710)
Ali Khokhar1972d14dbf23
diff --git a/README.md b/README.mdindex 59d1548e..b8b3e8a5 100644--- a/README.md+++ b/README.md@@ -30,7 +30,7 @@- **Keep coding through provider outages.** After retries are exhausted, FCC automatically tries your next configured model without making you restart the turn—across every client.- **Up to 90% fewer terminal-output tokens.** Optional [RTK](https://github.com/rtk-ai/rtk) filters common command output, while five FCC optimizations handle quota probes, command-prefix detection, titles, suggestions, and filepaths without calling a provider.- **Terminal, desktop, IDE, or phone.** Work through native launchers, [VS Code](https://code.visualstudio.com/), [Codex App](https://learn.chatgpt.com/docs/app), [JetBrains](https://www.jetbrains.com/), [Discord](https://discord.com/), or [Telegram](https://telegram.org/).-- **Private local chat.** Use Chat Sessions in Admin to talk with any configured FCC model, with persisted history, thinking controls, streaming, fallback, and compaction.+- **Code sessions in your browser.** Choose a folder and run Codex in Admin. Return to your session after navigating away or refreshing.- **Voice notes in. Code out.** Talk to your agent using local [Whisper](https://github.com/openai/whisper) or [NVIDIA NIM](https://docs.nvidia.com/nim/speech/latest/asr/deploy-asr-models/whisper.html) transcription.- **Agent capabilities stay intact.** Stream responses, use tools, preserve native interleaved thinking for maximum performance, send images, and route [Fable](https://www.anthropic.com/claude/fable), [Opus](https://www.anthropic.com/claude/opus), [Sonnet](https://www.anthropic.com/claude/sonnet), and [Haiku](https://www.anthropic.com/claude/haiku) independently with compatible models.diff --git a/e2e/conftest.py b/e2e/conftest.pyindex 9154481b..e01d6333 100644--- a/e2e/conftest.py+++ b/e2e/conftest.py@@ -6,7 +6,6 @@ import sysimport threadingimport timefrom collections.abc import AsyncIterator, Iterator, Mapping-from dataclasses import replacefrom pathlib import Pathimport pytest@@ -16,13 +15,6 @@ from playwright.sync_api import Pagefrom e2e.code_support import CodeControlfrom free_claude_code.api.app import create_appfrom free_claude_code.api.ports import ApiServices-from free_claude_code.application.chat import (- ChatContextEstimate,- ChatReasoning,- ChatService,- ChatSessionDetail,- ChatSessionPage,-)from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config import env_migrations, pathsfrom free_claude_code.config.env_migrations import recognized_env_keys@@ -32,14 +24,12 @@ from free_claude_code.config.loader import (get_settings,)from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.base import BaseProvider, ProviderConfigfrom free_claude_code.providers.runtime import ProviderRuntimefrom free_claude_code.runtime.application import ApplicationRuntimefrom free_claude_code.runtime.asgi import RuntimeASGIApp-from free_claude_code.runtime.chat_sqlite import SQLiteChatStorefrom free_claude_code.runtime.configuration import ConfigurationServicefrom free_claude_code.runtime.provider_manager import ProviderRuntimeManager@@ -68,7 +58,6 @@ class _ModelListingProvider(BaseProvider):)self._model_infos = model_infosself._error = error- self._message_attempts: dict[str, int] = {}def preflight_messages(self,@@ -106,116 +95,8 @@ class _ModelListingProvider(BaseProvider):request_headers: Mapping[str, str] | None = None,model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:- del input_tokens, request_id, response_model- summary = str(request.system).startswith("Summarize")- user_content = str(request.messages[-1].content) if request.messages else ""- attempt = self._message_attempts.get(user_content, 0) + 1- self._message_attempts[user_content] = attempt- slow = (- ("[slow]" in user_content and attempt == 1)- or ("[slow-regenerate]" in user_content and attempt == 2)- or (summary and "[slow-compaction]" in user_content and attempt == 1)- )- fragmented = "[fragmented]" in user_content- failed_regeneration = "[fail-regenerate]" in user_content and attempt > 1- if summary:- text = "Earlier details retained."- elif failed_regeneration:- text = "Partial replacement"- else:- text = "E2E answer"- frames = [- format_sse_event(- "message_start",- {"type": "message_start", "message": {"content": []}},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "thinking", "thinking": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "thinking_delta", "thinking": "E2E thought"},- },- ),- format_sse_event(- "content_block_stop", {"type": "content_block_stop", "index": 0}- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 1,- "content_block": {"type": "text", "text": ""},- },- ),- ]- if not fragmented:- frames.append(- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": text},- },- )- )- for frame in frames:- yield frame- await asyncio.sleep(0)- if fragmented:- for _index in range(2_000):- yield format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": "abcd"},- },- )- await asyncio.sleep(0)- if summary and "[fail-compaction]" in user_content:- yield format_sse_event(- "error",- {- "type": "error",- "error": {- "type": "api_error",- "message": "summary provider failed",- },- },- )- return- if not summary and ("[fail-turn]" in user_content or failed_regeneration):- yield format_sse_event(- "error",- {- "type": "error",- "error": {- "type": "api_error",- "message": "E2E provider failed",- },- },- )- return- if slow:- await asyncio.Event().wait()- yield format_sse_event(- "content_block_stop", {"type": "content_block_stop", "index": 1}- )- yield format_sse_event(- "message_delta",- {"type": "message_delta", "delta": {"stop_reason": "end_turn"}},- )- yield format_sse_event("message_stop", {"type": "message_stop"})+ if False:+ yield ""async def stream_responses(self,@@ -296,116 +177,10 @@ def admin_base_url(get_settings(),runtime_factory=lambda snapshot: ProviderRuntime(snapshot, dict(providers)),)- chat_store = SQLiteChatStore(- config_dir / "chat" / "chat.db",- config_dir / "chat" / "chat.lock",- )- chat = ChatService(manager, chat_store)- original_estimate = chat.estimate- original_get_detail = chat.get_detail- original_get_turn_page = chat.get_turn_page- original_list_sessions = chat.list_sessions- original_update_session = chat.update_session- original_begin_send = chat_store.begin_send- delayed_estimate_seen = False-- async def estimate_with_delayed_first_result(- session_id: str,- *,- draft: str,- ) -> ChatContextEstimate:- nonlocal delayed_estimate_seen- delay_result = "[delay-first-estimate]" in draft and not delayed_estimate_seen- delayed_estimate_seen = delayed_estimate_seen or delay_result- try:- return await original_estimate(session_id, draft=draft)- finally:- if delay_result:- await asyncio.sleep(0.75)-- monkeypatch.setattr(chat, "estimate", estimate_with_delayed_first_result)-- async def get_detail_with_test_pagination(- session_id: str,- ) -> ChatSessionDetail:- detail = await original_get_detail(session_id)- if "[delay-detail]" in detail.session.title:- await asyncio.sleep(0.75)- if "[delay-older-page]" in detail.session.title and len(detail.turns) > 1:- return replace(- detail,- turns=detail.turns[-1:],- next_before=detail.turns[-1].sequence,- )- return detail-- async def get_turn_page_with_delayed_result(- session_id: str,- *,- before_sequence: int | None,- limit: int,- ):- result = await original_get_turn_page(- session_id,- before_sequence=before_sequence,- limit=limit,- )- if before_sequence is not None:- session = await chat.get_session(session_id)- if "[delay-older-page]" in session.title:- await asyncio.sleep(0.75)- return result-- async def list_sessions_with_delayed_result(- *,- query: str,- cursor: tuple[int, str] | None,- limit: int,- ) -> ChatSessionPage:- result = await original_list_sessions(query=query, cursor=cursor, limit=limit)- if query == "race-old":- await asyncio.sleep(0.75)- elif cursor is not None:- await asyncio.sleep(0.5)- return result-- monkeypatch.setattr(chat, "get_detail", get_detail_with_test_pagination)- monkeypatch.setattr(chat, "get_turn_page", get_turn_page_with_delayed_result)- monkeypatch.setattr(chat, "list_sessions", list_sessions_with_delayed_result)-- async def update_session_with_delayed_result(- session_id: str,- *,- expected_revision: int,- title: str | None = None,- model: str | None = None,- reasoning: ChatReasoning | None = None,- ):- result = await original_update_session(- session_id,- expected_revision=expected_revision,- title=title,- model=model,- reasoning=reasoning,- )- if title is not None and "[delay-title-save]" in title:- await asyncio.sleep(0.75)- return result-- monkeypatch.setattr(chat, "update_session", update_session_with_delayed_result)-- async def begin_send_with_delayed_ack(*args, **kwargs):- result = await original_begin_send(*args, **kwargs)- if kwargs.get("user_text") == "[delay-send-ack] keep one draft":- await asyncio.sleep(0.75)- return result-- monkeypatch.setattr(chat_store, "begin_send", begin_send_with_delayed_ack)runtime = ApplicationRuntime(manager,configuration=ConfigurationService(ManagedConfigStore()),transcriber=None,- chat_service=chat,code_service=code_control.service,)app = RuntimeASGIApp(@@ -414,7 +189,6 @@ def admin_base_url(requests=manager,admin=runtime,tasks=runtime,- chat=chat,code=code_control.service,)),diff --git a/e2e/test_admin_assets.py b/e2e/test_admin_assets.pyindex 9ea5b53e..caab621c 100644--- a/e2e/test_admin_assets.py+++ b/e2e/test_admin_assets.py@@ -7,6 +7,60 @@ from playwright.sync_api import Error, Page, Request, expectfrom free_claude_code.core.version import package_version+def test_admin_removes_chat_drafts_and_preserves_other_storage(page, admin_base_url):+ page.add_init_script("""(() => {+ for (let index = 0; index < 16; index++) {+ sessionStorage.setItem(`fcc.chat.draft.${index}`, `old draft ${index}`);+ }+ for (let index = 0; index < 16; index++) {+ sessionStorage.setItem(`fcc.code.${index}`, `keep code draft ${index}`);+ }+ sessionStorage.setItem('fcc.chat.draftWithoutDot', 'keep unrelated key');+ sessionStorage.setItem('other-admin-state', 'keep admin state');+ })();""")+ page.goto(f"{admin_base_url}/admin")+ expect(page.locator('[data-provider="nvidia_nim"]')).to_be_visible()+ assert page.evaluate("Object.fromEntries(Object.entries(sessionStorage))") == {+ **{f"fcc.code.{index}": f"keep code draft {index}" for index in range(16)},+ "fcc.chat.draftWithoutDot": "keep unrelated key",+ "other-admin-state": "keep admin state",+ }+ expect(page.locator('.nav-link[data-view="providers"]')).to_have_attribute(+ "aria-current", "page"+ )+ expect(page.get_by_role("button", name="Chat Sessions", exact=True)).to_have_count(+ 0+ )+ page.get_by_role("button", name="Code sessions", exact=True).click()+ expect(page).to_have_url(f"{admin_base_url}/admin/code")+ expect(+ page.get_by_role("button", name="New code session", exact=True)+ ).to_be_enabled()+++def test_admin_storage_denial_keeps_admin_usable(page, admin_base_url):+ errors = []+ warnings = []+ page.on("pageerror", lambda error: errors.append(str(error)))+ page.on(+ "console",+ lambda message: (+ warnings.append(message.text) if message.type == "warning" else None+ ),+ )+ page.add_init_script("""Object.defineProperty(window, 'sessionStorage', {+ get() { throw new DOMException('Storage is denied', 'SecurityError'); }+ });""")+ page.goto(f"{admin_base_url}/admin")+ expect(page.locator('[data-provider="nvidia_nim"]')).to_be_visible()+ page.get_by_role("button", name="Code sessions", exact=True).click()+ expect(+ page.get_by_role("button", name="New code session", exact=True)+ ).to_be_enabled()+ assert errors == []+ assert any("Chat draft cleanup deferred" in message for message in warnings)++def test_admin_loads_current_release_assets_before_rendering_dynamic_content(page: Page,admin_base_url: str,@@ -38,13 +92,14 @@ def test_admin_loads_current_release_assets_before_rendering_dynamic_content(versioned_root = f"/admin/assets/{package_version()}"assert f"{versioned_root}/app-icon.svg" in requested_pathsassert f"{versioned_root}/admin.css" in requested_paths- assert f"{versioned_root}/chat_sessions.css" in requested_paths+ assert f"{versioned_root}/code_sessions.css" in requested_pathsassert f"{versioned_root}/model_combobox.js" in requested_paths- assert f"{versioned_root}/chat_sessions.js" in requested_paths+ assert f"{versioned_root}/code_sessions.js" in requested_pathsassert f"{versioned_root}/admin.js" in requested_pathsassert "/admin/assets/admin.css" not in requested_paths- assert "/admin/assets/chat_sessions.css" not in requested_paths+ assert "/admin/assets/code_sessions.css" not in requested_pathsassert "/admin/assets/model_combobox.js" not in requested_paths- assert "/admin/assets/chat_sessions.js" not in requested_paths+ assert "/admin/assets/code_sessions.js" not in requested_pathsassert "/admin/assets/admin.js" not in requested_paths+ assert not any("/chat_sessions." in path for path in requested_paths)assert page_errors == []diff --git a/e2e/test_chat_sessions.py b/e2e/test_chat_sessions.pydeleted file mode 100644index 65380978..00000000--- a/e2e/test_chat_sessions.py+++ /dev/null@@ -1,1197 +0,0 @@-import json-import re--from playwright.sync_api import Page, Request, Route, expect---def _new_chat(page: Page, admin_base_url: str) -> None:- page.goto(f"{admin_base_url}/admin")- page.get_by_role("button", name="Chat Sessions").click()- expect(page).to_have_url(f"{admin_base_url}/admin/chat")- page.get_by_role("button", name="New chat").click()- expect(page).to_have_url(re.compile(r"/admin/chat/[0-9a-f-]{36}$"))- expect(page.get_by_role("textbox", name="Message", exact=True)).to_be_visible()---def _hold_next_chat_operation(page: Page, action: str) -> None:- page.evaluate(- """- action => {- const originalFetch = window.fetch.bind(window);- window.fetch = (...args) => {- if (!String(args[0]).endsWith(`/${action}`)) {- return originalFetch(...args);- }- window.fetch = originalFetch;- return new Promise((resolve, reject) => {- window.__releaseHeldChatRequest = () => {- originalFetch(...args).then(resolve, reject);- };- });- };- }- """,- action,- )---def test_stale_chat_selection_reloads_as_default(page: Page, admin_base_url: str):- session = page.request.post(- f"{admin_base_url}/admin/api/chat/sessions", data={}- ).json()- response = page.request.patch(- f"{admin_base_url}/admin/api/chat/sessions/{session['id']}",- data={- "expected_revision": session["revision"],- "model": "github_models/openai/old",- },- )- assert response.ok- page.goto(f"{admin_base_url}/admin/chat/{session['id']}")- expect(page.get_by_role("combobox", name="Selected model")).to_have_value(- "open_router/e2e-default"- )- expect(page.get_by_role("textbox", name="Message", exact=True)).to_be_visible()---def _select_model(page: Page, model_ref: str) -> None:- model = page.get_by_role("combobox", name="Selected model")- model.click()- model.fill(model_ref)- expect(page.get_by_role("option", name=model_ref, exact=True)).to_be_visible()- with page.expect_response(- lambda response: (- response.request.method == "PATCH"- and "/admin/api/chat/sessions/" in response.url- )- ):- model.press("Enter")- expect(page.get_by_role("combobox", name="Selected model")).to_have_value(model_ref)---def test_chat_navigation_create_and_browser_history(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)-- expect(page.locator(".action-bar")).to_be_hidden()- page.get_by_role("button", name="Chats", exact=False).click()- expect(page).to_have_url(f"{admin_base_url}/admin/chat")- expect(page.locator(".session-card")).to_have_count(1)- page.go_back()- expect(page.get_by_role("textbox", name="Message", exact=True)).to_be_visible()- page.go_forward()- expect(page.get_by_role("button", name="New chat", exact=True)).to_be_visible()---def test_chat_routes_render_while_provider_health_is_still_loading(- page: Page,- admin_base_url: str,-) -> None:- session = page.request.post(- f"{admin_base_url}/admin/api/chat/sessions",- data={},- ).json()- routes = (- ("/admin/chat", page.get_by_role("button", name="New chat", exact=True)),- (- f"/admin/chat/{session['id']}",- page.get_by_role("textbox", name="Message", exact=True),- ),- )- page.add_init_script(- """- const originalFetch = window.fetch.bind(window);- window.__localProviderStatusRequested = false;- window.fetch = (...args) => {- const input = args[0];- const value = typeof input === "string" ? input : input.url;- const url = new URL(value, window.location.href);- if (url.pathname === "/admin/api/providers/local-status") {- window.__localProviderStatusRequested = true;- return new Promise(() => {});- }- return originalFetch(...args);- };- """- )-- for path, ready in routes:- page.goto(f"{admin_base_url}{path}")- expect(ready).to_be_visible()- assert page.evaluate("window.__localProviderStatusRequested === true")---def test_model_refresh_updates_chat_bootstrap(- page: Page,- admin_base_url: str,-) -> None:- bootstrap = page.request.get(f"{admin_base_url}/admin/api/chat/bootstrap").json()- target = "open_router/vendor/model-b"- stale_bootstrap = {- **bootstrap,- "models": [- option for option in bootstrap["models"] if option["model_ref"] != target- ],- }- refreshed = False-- def serve_bootstrap(route) -> None:- payload = bootstrap if refreshed else stale_bootstrap- route.fulfill(- status=200,- content_type="application/json",- body=json.dumps(payload),- )-- page.route("**/admin/api/chat/bootstrap", serve_bootstrap)- page.goto(f"{admin_base_url}/admin")- expect(page.locator("#messageArea")).to_have_text("")- session = page.request.post(- f"{admin_base_url}/admin/api/chat/sessions",- data={},- ).json()- updated = page.request.patch(- f"{admin_base_url}/admin/api/chat/sessions/{session['id']}",- data={"expected_revision": session["revision"], "model": target},- )- assert updated.ok-- refreshed = True- card = page.locator('[data-provider="open_router"]')- card.get_by_role("button", name="Refresh models", exact=True).click()- expect(card.locator(".provider-check-result")).to_have_text("3 models available")- page.get_by_role("button", name="Chat Sessions").click()- page.locator(".session-card").click()-- expect(page.get_by_role("combobox", name="Selected model")).to_have_value(target)- page.get_by_role("textbox", name="Message", exact=True).fill("still available")- expect(page.get_by_role("button", name="Send")).to_be_enabled()---def test_chat_model_picker_searches_and_selects_in_one_control(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- model_patches: list[str] = []- page.on(- "request",- lambda request: (- model_patches.append(request.url)- if request.method == "PATCH" and "/admin/api/chat/sessions/" in request.url- else None- ),- )-- model = page.get_by_role("combobox", name="Selected model")- expect(model).to_have_value("open_router/e2e-default")- expect(page.get_by_role("searchbox", name="Filter models")).to_have_count(0)- expect(page.locator("select#chatModel")).to_have_count(0)- expect(page.locator("#chatNotice")).to_be_hidden()-- page.reload()- expect(model).to_have_value("open_router/e2e-default")- model.click()- options = page.get_by_role("listbox").get_by_role("option")- expect(options).to_have_count(1)- expect(options).to_have_text("open_router/e2e-default")- model.press("Escape")-- model.fill("not-a-catalog-model")- expect(page.get_by_text("No matching models.", exact=True)).to_be_visible()- page.get_by_label("Thinking").click()- expect(model).to_have_value("open_router/e2e-default")-- _select_model(page, "open_router/vendor/small-context")- expect(page.get_by_role("listbox")).to_be_hidden()- page.wait_for_timeout(100)- assert len(model_patches) == 1---def test_chat_context_meter_shows_used_over_advertised_context_window(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- _select_model(page, "open_router/vendor/model-b")- with page.expect_response(- lambda response: (- response.request.method == "PATCH"- and "/admin/api/chat/sessions/" in response.url- )- ):- page.get_by_label("Thinking").select_option("high")- page.get_by_role("textbox", name="Message", exact=True).fill("hello")-- meter = page.locator("#chatContextMeter")- expect(meter).to_have_text(re.compile(r"^Context: \d+% · \d+ / 100K$"))---def test_delayed_older_page_cannot_cross_into_another_chat(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("A OLD LEAK")- page.get_by_role("button", name="Send").click()- expect(page.locator(".assistant-message")).to_have_count(1)- message.fill("A latest")- page.get_by_role("button", name="Send").click()- expect(page.locator(".assistant-message:not(.live-message)")).to_have_count(2)- title = page.get_by_label("Chat title")- title.fill("[delay-older-page] Chat A")- with page.expect_response(- lambda response: (- response.request.method == "PATCH"- and "/admin/api/chat/sessions/" in response.url- )- ):- title.press("Enter")-- page.get_by_role("button", name="Chats", exact=False).click()- page.get_by_role("button", name="New chat", exact=True).click()- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("B only")- page.get_by_role("button", name="Send").click()- expect(page.get_by_text("B only", exact=True)).to_be_visible()-- page.get_by_role("button", name="Chats", exact=False).click()- page.locator(".session-card", has_text="[delay-older-page] Chat A").click()- load_older = page.get_by_role("button", name="Load older messages")- expect(load_older).to_be_visible()- with page.expect_request(lambda request: "/turns?before=" in request.url):- load_older.click()-- page.get_by_role("button", name="Chats", exact=False).click()- page.locator(".session-card", has_text="B only").click()- expect(page.get_by_text("B only", exact=True)).to_be_visible()- page.wait_for_timeout(1_000)- expect(page.get_by_text("A OLD LEAK", exact=True)).to_have_count(0)---def test_out_of_order_library_search_keeps_latest_results(- page: Page,- admin_base_url: str,-) -> None:- page.goto(f"{admin_base_url}/admin")- for title in ("race-old result", "race-new result"):- session = page.request.post(- f"{admin_base_url}/admin/api/chat/sessions",- data={},- ).json()- renamed = page.request.patch(- f"{admin_base_url}/admin/api/chat/sessions/{session['id']}",- data={"expected_revision": session["revision"], "title": title},- )- assert renamed.ok- page.get_by_role("button", name="Chat Sessions").click()- expect(page.locator(".session-card")).to_have_count(2)-- search = page.get_by_role("searchbox", name="Search chats")- with page.expect_request(lambda request: "query=race-old" in request.url):- search.fill("race-old")- with page.expect_response(lambda response: "query=race-new" in response.url):- search.fill("race-new")-- expect(page.locator(".session-card", has_text="race-new result")).to_be_visible()- page.wait_for_timeout(1_000)- expect(page.locator(".session-card", has_text="race-new result")).to_be_visible()- expect(page.locator(".session-card", has_text="race-old result")).to_have_count(0)---def test_double_load_more_appends_each_session_once(- page: Page,- admin_base_url: str,-) -> None:- page.goto(f"{admin_base_url}/admin")- for _index in range(26):- created = page.request.post(- f"{admin_base_url}/admin/api/chat/sessions",- data={},- )- assert created.ok- page.get_by_role("button", name="Chat Sessions").click()- expect(page.locator(".session-card")).to_have_count(25)- more = page.get_by_role("button", name="Load more")- expect(more).to_be_visible()-- more.evaluate("button => { button.click(); button.click(); }")-- expect(page.locator(".session-card")).to_have_count(26, timeout=3_000)- page.wait_for_timeout(750)- expect(page.locator(".session-card")).to_have_count(26)---def test_chat_streams_thinking_and_persists_answer(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)-- page.get_by_role("textbox", name="Message", exact=True).fill("hello")- page.get_by_role("button", name="Send").click()- expect(page.get_by_text("E2E answer")).to_be_visible()- expect(- page.locator(".session-thinking summary", has_text="Thinking")- ).to_be_visible()- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()- expect(page.locator("#chatContextMeter")).to_contain_text("Context:")-- page.reload()- expect(page.get_by_text("E2E answer")).to_be_visible()- expect(page.get_by_text("hello", exact=True)).to_be_visible()---def test_generation_status_occupies_the_answer_slot(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- message = page.get_by_role("textbox", name="Message", exact=True)-- _hold_next_chat_operation(page, "send")- message.fill("answer in place")- page.get_by_role("button", name="Send").click()-- assistant = page.locator(".assistant-message")- expect(assistant).to_have_count(1)- expect(assistant.get_by_text("Thinking…", exact=True)).to_be_visible()- expect(page.locator("#chatComposerStatus")).to_be_empty()-- page.evaluate("() => { window.__releaseHeldChatRequest(); }")- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()-- _hold_next_chat_operation(page, "regenerate")- page.get_by_role("button", name="Regenerate").click()-- expect(assistant).to_have_count(1)- expect(assistant.get_by_text("Thinking…", exact=True)).to_be_visible()- expect(assistant).not_to_contain_text("E2E answer")- expect(page.locator("#chatComposerStatus")).to_be_empty()-- page.evaluate("() => { window.__releaseHeldChatRequest(); }")- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()- expect(assistant).to_contain_text("E2E answer")---def test_fragmented_stream_does_not_rebuild_transcript_per_delta(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- page.evaluate(- """- () => {- const original = Element.prototype.replaceChildren;- window.__chatTranscriptRenderCount = 0;- Element.prototype.replaceChildren = function (...children) {- if (this.id === "chatTranscript") {- window.__chatTranscriptRenderCount += 1;- }- return original.apply(this, children);- };- }- """- )-- page.get_by_role("textbox", name="Message", exact=True).fill("[fragmented]")- page.get_by_role("button", name="Send").click()-- expect(page.get_by_role("button", name="Regenerate")).to_be_visible(timeout=10_000)- expect(page.locator(".assistant-message .session-markdown").last).to_contain_text(- "abcd" * 20- )- render_count = page.evaluate("window.__chatTranscriptRenderCount")- assert isinstance(render_count, int)- assert render_count < 100---def test_rejected_send_preserves_draft_after_stale_revision(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- session_id = page.url.rsplit("/", 1)[-1]- _hold_next_chat_operation(page, "send")- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("do not discard this draft")- page.get_by_role("button", name="Send").click()-- renamed = page.request.patch(- f"{admin_base_url}/admin/api/chat/sessions/{session_id}",- data={"expected_revision": 1, "title": "Changed elsewhere"},- )- assert renamed.ok- page.evaluate("() => { window.__releaseHeldChatRequest(); }")-- expect(message).to_have_value("do not discard this draft")- expect(page.locator("#chatNotice")).to_contain_text("changed in another tab")---def test_provider_failure_appears_only_in_assistant_reply(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- page.get_by_role("textbox", name="Message", exact=True).fill("[fail-turn]")- page.get_by_role("button", name="Send").click()-- expect(page.get_by_role("button", name="Retry")).to_be_visible()- expect(- page.locator(".assistant-message .session-generation-status.failed")- ).to_have_text("E2E provider failed")- expect(page.locator("#chatNotice")).to_be_hidden()- expect(page.get_by_text("E2E provider failed", exact=True)).to_have_count(1)---def test_committed_send_does_not_restore_draft_when_stream_ack_is_lost(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- session_id = page.url.rsplit("/", 1)[-1]- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("[delay-send-ack] keep one draft")- page.get_by_role("button", name="Send").click()-- turn_url = f"{admin_base_url}/admin/api/chat/sessions/{session_id}"- for _attempt in range(50):- detail = page.request.get(turn_url).json()- if detail["turns"]:- break- page.wait_for_timeout(20)- else:- raise AssertionError("The delayed send did not commit its turn.")-- page.get_by_role("button", name="Stop").click()- expect(page.get_by_role("button", name="Retry")).to_be_visible()-- expect(page.get_by_role("textbox", name="Message", exact=True)).to_have_value("")- expect(- page.get_by_text("[delay-send-ack] keep one draft", exact=True)- ).to_be_visible()---def test_send_keeps_composer_ready_for_the_next_draft(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- message = page.get_by_role("textbox", name="Message", exact=True)-- message.fill("first")- message.press("Enter")- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()- expect(message).to_be_focused()-- message.fill("[slow] second")- message.press("Enter")- expect(page.locator(".live-message")).to_contain_text("E2E answer")- expect(message).to_be_enabled()- expect(message).to_be_focused()- message.fill("next draft")-- page.get_by_role("button", name="Stop").click()- expect(page.get_by_role("button", name="Retry")).to_be_visible()- expect(message).to_have_value("next draft")---def test_chat_stop_then_retry_uses_one_operation_owner(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)-- page.get_by_role("textbox", name="Message", exact=True).fill("[slow] please answer")- page.get_by_role("button", name="Send").click()- expect(page.get_by_text("E2E answer")).to_be_visible()- stop = page.get_by_role("button", name="Stop")- expect(stop).to_be_visible()- send_is_hidden = page.locator("#chatSend").is_hidden()- stop.click()- expect(page.get_by_role("button", name="Retry")).to_be_visible()- assert send_is_hidden-- page.get_by_role("button", name="Retry").click()- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()- expect(page.get_by_text("E2E answer")).to_be_visible()---def test_chat_opened_in_another_tab_shares_live_operation_and_stop(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- page.get_by_role("textbox", name="Message", exact=True).fill("[slow] wait")- page.get_by_role("button", name="Send").click()- expect(page.get_by_role("button", name="Stop")).to_be_visible()-- other = page.context.new_page()- try:- other.goto(page.url)- expect(other.get_by_text("E2E answer", exact=True)).to_be_visible()- expect(other.get_by_role("button", name="Stop")).to_be_visible()- other.get_by_role("button", name="Stop").click()- expect(page.get_by_role("button", name="Retry")).to_be_visible()- expect(other.get_by_role("button", name="Retry")).to_be_visible(timeout=3_000)- finally:- other.close()---def test_refresh_keeps_one_live_operation_and_reconstructs_its_answer(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("[slow] survive refresh")- message.press("Enter")- expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()- expect(page.get_by_role("button", name="Stop")).to_be_visible()-- page.reload()-- expect(page.get_by_text("[slow] survive refresh", exact=True)).to_have_count(1)- expect(page.locator(".assistant-message")).to_have_count(1)- expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()- page.get_by_role("button", name="Stop").click()- expect(page.get_by_role("button", name="Retry")).to_be_visible()---def test_terminal_event_cannot_be_undone_by_an_older_detail_response(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- title = page.get_by_label("Chat title")- title.fill("[delay-detail] stale operation snapshot")- with page.expect_response(lambda response: response.request.method == "PATCH"):- title.press("Enter")- page.get_by_role("textbox", name="Message", exact=True).fill("[slow] finish once")- page.get_by_role("button", name="Send").click()- expect(page.get_by_role("button", name="Stop")).to_be_visible()-- other = page.context.new_page()- try:- with other.expect_request(- lambda request: (- request.method == "GET"- and request.url.endswith(page.url.rsplit("/", 1)[-1])- )- ):- other.goto(page.url, wait_until="commit")- page.wait_for_timeout(150)- page.get_by_role("button", name="Stop").click()- expect(page.get_by_role("button", name="Retry")).to_be_visible()-- expect(other.get_by_role("button", name="Retry")).to_be_visible(timeout=3_000)- expect(other.get_by_role("button", name="Stop")).to_have_count(0)- expect(other.locator("#chatComposerStatus")).not_to_have_text("Thinking…")- finally:- other.close()---def test_two_sessions_run_concurrently_across_navigation(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- first_url = page.url- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("[slow] first active chat")- message.press("Enter")- expect(page.get_by_role("button", name="Stop")).to_be_visible()-- page.get_by_role("button", name="Chats", exact=False).click()- page.get_by_role("button", name="New chat", exact=True).click()- expect(page).to_have_url(re.compile(r"/admin/chat/[0-9a-f-]{36}$"))- second_url = page.url- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("[slow] second active chat")- message.press("Enter")- expect(page.get_by_role("button", name="Stop")).to_be_visible()-- page.get_by_role("button", name="Chats", exact=False).click()- expect(page.locator(".session-status", has_text="Thinking…")).to_have_count(2)-- page.goto(first_url)- expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()- page.get_by_role("button", name="Stop").click()- expect(page.get_by_role("button", name="Retry")).to_be_visible()-- page.goto(second_url)- expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()- page.get_by_role("button", name="Stop").click()- expect(page.get_by_role("button", name="Retry")).to_be_visible()---def test_library_card_tracks_background_operation_and_durable_summary(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- title = page.get_by_label("Chat title")- title.fill("Library observer")- with page.expect_response(lambda response: response.request.method == "PATCH"):- title.press("Enter")- other = page.context.new_page()- try:- other.goto(f"{admin_base_url}/admin/chat")- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("[slow] live library preview")- message.press("Enter")-- card = other.locator(".session-card", has_text="Library observer")- expect(card).to_be_visible(timeout=3_000)- expect(card.locator("p")).to_have_text("[slow] live library preview")- expect(card.locator(".session-status")).to_have_text("Thinking…")-- page.get_by_role("button", name="Stop").click()- expect(page.get_by_role("button", name="Retry")).to_be_visible()- expect(card.locator(".session-status")).to_have_count(0, timeout=3_000)- expect(card.locator("p")).to_have_text("[slow] live library preview")- expect(card.locator("span").first).to_contain_text("just now")- finally:- other.close()---def test_chat_operation_continues_while_providers_view_is_open(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- session_url = page.url- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("[slow] keep running outside chat")- message.press("Enter")- expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()-- page.get_by_role("button", name="Providers", exact=True).click()- expect(page.locator("#pageTitle")).to_have_text("Providers")- page.goto(session_url)-- expect(- page.get_by_text("[slow] keep running outside chat", exact=True)- ).to_have_count(1)- expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()- expect(page.get_by_role("button", name="Stop")).to_be_visible()- page.get_by_role("button", name="Stop").click()- expect(page.get_by_role("button", name="Retry")).to_be_visible()---def test_event_feed_reconnect_preserves_transcript_and_draft(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("before reconnect")- message.press("Enter")- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()- message.fill("draft during reconnect")-- page.context.set_offline(True)- expect(page.locator("#chatComposerStatus")).to_have_text("Reconnecting…")- expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()- expect(message).to_have_value("draft during reconnect")- expect(page.get_by_role("button", name="Send")).to_be_disabled()-- page.context.set_offline(False)- expect(page.locator("#chatComposerStatus")).to_be_empty(timeout=10_000)- expect(message).to_have_value("draft during reconnect")- expect(page.get_by_role("button", name="Send")).to_be_enabled()- expect(page.get_by_text("E2E answer", exact=True)).to_have_count(1)---def test_drafts_are_session_scoped_and_private_to_each_tab(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- first_url = page.url- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("first private draft")- page.reload()- expect(message).to_have_value("first private draft")-- other = page.context.new_page()- try:- other.goto(first_url)- expect(other.get_by_role("textbox", name="Message", exact=True)).to_be_empty()- finally:- other.close()-- page.get_by_role("button", name="Chats", exact=False).click()- page.get_by_role("button", name="New chat", exact=True).click()- page.get_by_role("textbox", name="Message", exact=True).fill("second private draft")- page.goto(first_url)- expect(page.get_by_role("textbox", name="Message", exact=True)).to_have_value(- "first private draft"- )---def test_session_settings_sync_without_disturbing_another_tab_draft(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- other = page.context.new_page()- try:- other.goto(page.url)- other_patches: list[str] = []-- def remember_other_patch(request: Request) -> None:- if request.method == "PATCH":- other_patches.append(request.post_data or "")-- other.on("request", remember_other_patch)- other_message = other.get_by_role("textbox", name="Message", exact=True)- other_message.fill("private draft")- other_title = other.get_by_label("Chat title")- other_title.fill("Local title draft")-- title = page.get_by_label("Chat title")- title.fill("Shared title")- with page.expect_response(lambda response: response.request.method == "PATCH"):- title.press("Enter")- expect(other_title).to_have_value("Local title draft")- other.wait_for_timeout(50)- assert other_patches == []- with other.expect_response(lambda response: response.request.method == "PATCH"):- other_title.press("Enter")- assert len(other_patches) == 1- expect(title).to_have_value("Local title draft")-- _select_model(page, "open_router/vendor/model-b")- expect(other.get_by_label("Selected model")).to_have_value(- "open_router/vendor/model-b"- )- with page.expect_response(lambda response: response.request.method == "PATCH"):- page.get_by_label("Thinking").select_option("high")- expect(other.get_by_label("Thinking")).to_have_value("high")- expect(other_message).to_have_value("private draft")- finally:- other.close()---def test_active_chat_deleted_in_another_tab_returns_to_library(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- session_url = page.url- page.get_by_role("textbox", name="Message", exact=True).fill("[slow] delete me")- page.get_by_role("button", name="Send").click()- expect(page.get_by_role("button", name="Stop")).to_be_visible()-- other = page.context.new_page()- try:- other.goto(session_url)- expect(other.get_by_text("E2E answer", exact=True)).to_be_visible()- expect(other.get_by_role("button", name="Stop")).to_be_visible()- other.on("dialog", lambda dialog: dialog.accept())- other.get_by_role("button", name="Delete").click()- expect(other).to_have_url(f"{admin_base_url}/admin/chat")-- expect(page).to_have_url(f"{admin_base_url}/admin/chat", timeout=3_000)- expect(page.get_by_role("button", name="New chat", exact=True)).to_be_visible()- expect(page.get_by_role("button", name="Stop")).to_have_count(0)- finally:- other.close()---def test_deleted_chat_cannot_render_from_an_inflight_detail_request(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- session_url = page.url- title = page.get_by_label("Chat title")- title.fill("[delay-detail] delete while loading")- with page.expect_response(- lambda response: (- response.request.method == "PATCH"- and "/admin/api/chat/sessions/" in response.url- )- ):- title.press("Enter")-- other = page.context.new_page()- try:- with other.expect_request(- lambda request: (- request.method == "GET" and "/admin/api/chat/sessions/" in request.url- )- ):- other.goto(session_url)-- page.on("dialog", lambda dialog: dialog.accept())- page.get_by_role("button", name="Delete").click()- expect(page).to_have_url(f"{admin_base_url}/admin/chat")-- expect(other).to_have_url(f"{admin_base_url}/admin/chat", timeout=3_000)- expect(other.get_by_role("button", name="New chat", exact=True)).to_be_visible()- expect(other.get_by_role("textbox", name="Message", exact=True)).to_have_count(- 0- )- finally:- other.close()---def test_regeneration_is_visible_and_recovers_in_another_tab(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- page.get_by_role("textbox", name="Message", exact=True).fill(- "[slow-regenerate] answer twice"- )- page.get_by_role("button", name="Send").click()- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()-- page.get_by_role("button", name="Regenerate").click()- expect(page.get_by_role("button", name="Stop")).to_be_visible()- other = page.context.new_page()- try:- other.goto(page.url)- expect(other.get_by_text("E2E answer", exact=True)).to_be_visible()- expect(other.get_by_role("button", name="Stop")).to_be_visible()- expect(other.get_by_label("Selected model")).to_be_disabled()-- other.get_by_role("button", name="Stop").click()-- expect(other.get_by_label("Selected model")).to_be_enabled(timeout=3_000)- expect(other.get_by_role("button", name="Regenerate")).to_be_visible()- finally:- other.close()---def test_failed_regeneration_replaces_the_reply_without_a_page_notice(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- page.get_by_role("textbox", name="Message", exact=True).fill("[fail-regenerate]")- page.get_by_role("button", name="Send").click()- expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()-- page.get_by_role("button", name="Regenerate").click()-- expect(page.get_by_role("button", name="Retry")).to_be_visible()- expect(page.get_by_text("E2E answer", exact=True)).to_have_count(0)- expect(page.get_by_text("Partial replacement", exact=True)).to_be_visible()- expect(- page.locator(".assistant-message .session-generation-status.failed")- ).to_have_text("E2E provider failed")- expect(page.locator("#chatNotice")).to_be_hidden()- expect(page.get_by_text("E2E provider failed", exact=True)).to_have_count(1)---def test_manual_compaction_is_visible_and_recovers_in_another_tab(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("[slow-compaction] first")- page.get_by_role("button", name="Send").click()- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()- message.fill("second")- page.get_by_role("button", name="Send").click()- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()-- page.get_by_role("button", name="Compact now").click()- expect(page.get_by_role("button", name="Stop")).to_be_visible()- other = page.context.new_page()- try:- other.goto(page.url)- expect(other.locator("#chatComposerStatus")).to_have_text("Compacting…")- expect(other.get_by_role("button", name="Stop")).to_be_visible()- expect(other.get_by_label("Thinking")).to_be_disabled()-- other.get_by_role("button", name="Stop").click()-- expect(other.get_by_label("Thinking")).to_be_enabled(timeout=3_000)- finally:- other.close()---def test_manual_compaction_failure_remains_visible(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("[fail-compaction] first")- page.get_by_role("button", name="Send").click()- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()- message.fill("second")- page.get_by_role("button", name="Send").click()- expect(page.get_by_role("button", name="Regenerate")).to_be_visible()-- page.get_by_role("button", name="Compact now").click()-- notice = page.locator("#chatNotice")- expect(notice).to_be_visible()- expect(notice).to_have_text("summary provider failed")---def test_long_transcript_keeps_composer_visible_and_preserves_reader_scroll_position(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- long_message = "[slow]\n" + "\n".join(- f"line {index}: keep reading here" for index in range(100)- )- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill(long_message)- page.get_by_role("button", name="Send").click()- expect(page.get_by_role("button", name="Stop")).to_be_visible()- expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()- scroller = page.locator("#chatTranscript")- page.wait_for_function(- """() => {- const node = document.getElementById('chatTranscript');- return node && node.scrollHeight > node.clientHeight;- }"""- )- expect(message).to_be_in_viewport(ratio=1)- page.evaluate("document.getElementById('chatTranscript').scrollTop = 0")-- session_id = page.url.rsplit("/", 1)[-1]- detail_url = f"{admin_base_url}/admin/api/chat/sessions/{session_id}"- held_details: list[Route] = []- page.route(detail_url, lambda route: held_details.append(route))- try:- with page.expect_request(detail_url):- page.get_by_role("button", name="Stop").click()-- detail = page.request.get(detail_url).json()- renamed = page.request.patch(- detail_url,- data={- "expected_revision": detail["session"]["revision"],- "title": "Renamed while the stopped conversation reloads",- },- )- assert renamed.ok- expect(page.get_by_label("Chat title")).to_have_value(- "Renamed while the stopped conversation reloads"- )- expect(scroller).to_contain_text(long_message)- finally:- for held_detail in held_details:- held_detail.continue_()- page.unroute(detail_url)-- expect(page.get_by_role("button", name="Retry")).to_be_visible()- assert page.evaluate("document.getElementById('chatTranscript').scrollTop") < 10---def test_chat_composer_is_one_compact_surface_and_grows_to_six_lines(- page: Page,- admin_base_url: str,-) -> None:- page.set_viewport_size({"width": 1_258, "height": 566})- _new_chat(page, admin_base_url)- composer = page.locator(".session-composer")- message = page.get_by_role("textbox", name="Message", exact=True)-- surface = composer.evaluate(- """node => {- const box = node.getBoundingClientRect();- const textarea = node.querySelector("textarea").getBoundingClientRect();- const send = node.querySelector("#chatSend").getBoundingClientRect();- const surfaceStyle = getComputedStyle(node);- const textareaStyle = getComputedStyle(node.querySelector("textarea"));- return {- contained:- textarea.left >= box.left && textarea.right <= box.right &&- textarea.top >= box.top && textarea.bottom <= box.bottom &&- send.left >= box.left && send.right <= box.right &&- send.top >= box.top && send.bottom <= box.bottom,- surfaceBorder: surfaceStyle.borderLeftWidth,- textareaBorder: textareaStyle.borderLeftWidth,- bottomGap: window.innerHeight - box.bottom,- };- }"""- )- assert surface == {- "contained": True,- "surfaceBorder": "1px",- "textareaBorder": "0px",- "bottomGap": 16,- }-- two_line_height = message.evaluate("node => node.getBoundingClientRect().height")- message.fill("one\ntwo\nthree\nfour")- four_line_height = message.evaluate("node => node.getBoundingClientRect().height")- message.fill("\n".join(f"line {index}" for index in range(6)))- six_line_height = message.evaluate("node => node.getBoundingClientRect().height")- six_line_overflow = message.evaluate("node => getComputedStyle(node).overflowY")- message.fill("\n".join(f"line {index}" for index in range(8)))- capped_height = message.evaluate("node => node.getBoundingClientRect().height")- overflow = message.evaluate("node => getComputedStyle(node).overflowY")- message.fill("short again")- reset_height = message.evaluate("node => node.getBoundingClientRect().height")-- assert four_line_height > two_line_height- assert six_line_height > four_line_height- assert six_line_overflow == "hidden"- assert capped_height == six_line_height- assert overflow == "auto"- assert reset_height == two_line_height---def test_chat_uses_desktop_width_with_one_responsive_gutter(- page: Page,- admin_base_url: str,-) -> None:- page.set_viewport_size({"width": 1_600, "height": 900})- _new_chat(page, admin_base_url)- page.get_by_role("textbox", name="Message", exact=True).fill("hello")- page.get_by_role("button", name="Send").click()- expect(page.get_by_text("E2E answer")).to_be_visible()- page.reload()- expect(page.get_by_text("E2E answer")).to_be_visible()-- layout = page.locator(".session-shell").evaluate(- """shell => {- const main = document.querySelector(".main").getBoundingClientRect();- const shellBox = shell.getBoundingClientRect();- const composer = shell.querySelector(".session-composer").getBoundingClientRect();- const transcript = shell.querySelector(".session-transcript").getBoundingClientRect();- const user = shell.querySelector(".user-message").getBoundingClientRect();- const assistant = shell.querySelector(".assistant-message").getBoundingClientRect();- return {- shellShare: shellBox.width / main.width,- composerShare: composer.width / main.width,- leftGutter: composer.left - shellBox.left,- rightGutter: shellBox.right - composer.right,- userRightGap: transcript.right - user.right,- assistantLeftGap: assistant.left - transcript.left,- };- }"""- )-- assert layout["shellShare"] > 0.9- assert layout["composerShare"] > 0.9- assert layout["leftGutter"] < 0.5- assert layout["rightGutter"] < 0.5- assert abs(layout["leftGutter"] - layout["rightGutter"]) < 0.5- assert abs(layout["userRightGap"]) < 0.5- assert abs(layout["assistantLeftGap"]) < 0.5---def test_chat_rename_prompt_and_delete(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)-- title = page.get_by_label("Chat title")- title.fill("Release notes")- title.press("Enter")- expect(page.get_by_label("Chat title")).to_have_value("Release notes")-- page.get_by_role("button", name="System prompt").click()- prompt = page.get_by_role("dialog").get_by_label("System prompt")- prompt.fill("Be concise.")- page.get_by_role("dialog").get_by_role("button", name="Save").click()- page.get_by_role("button", name="System prompt").click()- expect(page.get_by_role("dialog").get_by_label("System prompt")).to_have_value(- "Be concise."- )- page.get_by_role("dialog").get_by_role("button", name="Reset to default").click()-- page.on("dialog", lambda dialog: dialog.accept())- page.get_by_role("button", name="Delete").click()- expect(page).to_have_url(f"{admin_base_url}/admin/chat")- expect(page.locator(".session-card")).to_have_count(0)---def test_delayed_title_save_cannot_restore_chat_after_back_navigation(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- title = page.get_by_label("Chat title")- title.fill("[delay-title-save] Release notes")- with page.expect_request(- lambda request: (- request.method == "PATCH" and "/admin/api/chat/sessions/" in request.url- )- ):- title.press("Enter")-- page.get_by_role("button", name="Chats", exact=False).click()- expect(page).to_have_url(f"{admin_base_url}/admin/chat")- expect(page.get_by_role("button", name="New chat", exact=True)).to_be_visible()- page.wait_for_timeout(1_000)- expect(page.get_by_role("button", name="New chat", exact=True)).to_be_visible()- expect(page).to_have_url(f"{admin_base_url}/admin/chat")---def test_reset_system_prompt_refreshes_context_and_unblocks_send(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- _select_model(page, "open_router/vendor/small-context")- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("send after reset")-- page.get_by_role("button", name="System prompt").click()- prompt = page.get_by_role("dialog").get_by_label("System prompt")- prompt.fill("oversized prompt " * 5_000)- page.get_by_role("dialog").get_by_role("button", name="Save").click()- expect(page.get_by_role("button", name="Send")).to_be_disabled()- expect(page.locator("#chatComposerStatus")).to_contain_text(- "exceeds the model context"- )- message.fill("[delay-first-estimate] send after reset")- page.wait_for_timeout(350)-- page.get_by_role("button", name="System prompt").click()- page.get_by_role("dialog").get_by_role("button", name="Reset to default").click()-- expect(page.get_by_role("button", name="Send")).to_be_enabled(timeout=3_000)- page.wait_for_timeout(800)- expect(page.get_by_role("button", name="Send")).to_be_enabled()---def test_estimate_from_before_operation_cannot_overwrite_terminal_context(- page: Page,- admin_base_url: str,-) -> None:- _new_chat(page, admin_base_url)- message = page.get_by_role("textbox", name="Message", exact=True)- message.fill("first")- page.get_by_role("button", name="Send").click()- expect(page.locator(".assistant-message")).to_have_count(1)-- message.fill("[delay-first-estimate] second")- page.wait_for_timeout(350)- page.get_by_role("button", name="Send").click()-- expect(page.locator(".assistant-message")).to_have_count(2)- compact = page.get_by_role("button", name="Compact now")- expect(compact).to_be_enabled(timeout=3_000)- page.wait_for_timeout(800)- expect(compact).to_be_enabled()---def test_chat_remains_usable_at_narrow_viewport(- page: Page,- admin_base_url: str,-) -> None:- page.set_viewport_size({"width": 390, "height": 844})- _new_chat(page, admin_base_url)-- expect(page.get_by_role("combobox", name="Selected model")).to_be_visible()- expect(page.get_by_label("Thinking")).to_be_visible()- expect(page.get_by_role("textbox", name="Message", exact=True)).to_be_in_viewport()diff --git a/e2e/test_code_sessions.py b/e2e/test_code_sessions.pyindex 2d3ffb71..bac63e14 100644--- a/e2e/test_code_sessions.py+++ b/e2e/test_code_sessions.py@@ -4,7 +4,6 @@ import uuidimport pytestfrom playwright.sync_api import expect-from e2e.test_chat_sessions import _new_chatfrom free_claude_code.application.code_sessions.models import (HarnessEvent,PromptRequest,@@ -316,7 +315,7 @@ def hold_deleted_detail(page, code_control, session_id):@pytest.mark.parametrize("source", ["event", "detail404"])-def test_hidden_code_removal_preserves_chat_and_deleted_history(+def test_hidden_code_removal_preserves_providers_and_deleted_history(page, admin_base_url, tmp_path, code_control, source):control_feed(page)@@ -324,13 +323,12 @@ def test_hidden_code_removal_preserves_chat_and_deleted_history(session_id = url.rsplit("/", 1)[1]if source == "detail404":hold_deleted_detail(page, code_control, session_id)- page.get_by_role("button", name="Chat Sessions", exact=True).click()- page.get_by_role("button", name="New chat", exact=True).click()- expect(page).to_have_url(re.compile(r"/admin/chat/[0-9a-f-]+$"))- chat_url = page.url- composer = page.locator("#chatComposer")- composer.fill("Keep this Chat draft")- composer.evaluate("input => input.setSelectionRange(2, 7)")+ page.get_by_role("button", name="Providers", exact=True).click()+ providers_url = f"{admin_base_url}/admin"+ expect(page).to_have_url(providers_url)+ field = page.locator("#field-MISTRAL_API_KEY")+ field.fill("Keep this provider edit")+ field.evaluate("input => input.setSelectionRange(2, 7)")history_length = page.evaluate("history.length")if source == "event":delete_from_other_client(code_control, session_id)@@ -338,39 +336,30 @@ def test_hidden_code_removal_preserves_chat_and_deleted_history(else:page.evaluate("window.releaseCodeReads()")expect(page.locator("#codeLibrary")).to_have_count(1)- expect(page).to_have_url(chat_url)+ expect(page).to_have_url(providers_url)assert page.evaluate("history.length") == history_length- expect(page.locator("#view-chat")).to_be_visible()- expect(page.locator('.nav-link[data-view="chat"]')).to_have_attribute(+ expect(page.locator("#view-providers")).to_be_visible()+ expect(page.locator('.nav-link[data-view="providers"]')).to_have_attribute("aria-current", "page")- expect(composer).to_be_focused()- expect(composer).to_have_value("Keep this Chat draft")- assert composer.evaluate("input => [input.selectionStart, input.selectionEnd]") == [+ expect(field).to_be_focused()+ expect(field).to_have_value("Keep this provider edit")+ assert field.evaluate("input => [input.selectionStart,input.selectionEnd]") == [2,7,]-- # The old Code entry remains in history until it is visited and replaced.reads = []endpoint = f"/admin/api/code/sessions/{session_id}"page.on("request", lambda request: reads.append(request.url))page.go_back()- expect(page).to_have_url(f"{admin_base_url}/admin/chat")- page.go_back()expect(page).to_have_url(f"{admin_base_url}/admin/code")expect(page.locator("#codeNew")).to_be_enabled()expect(page.locator("#codeLibrary .session-card")).to_have_count(0)assert not any(request.endswith(endpoint) for request in reads)assert page.evaluate("history.length") == history_lengthpage.go_forward()- expect(page).to_have_url(f"{admin_base_url}/admin/chat")- page.go_forward()- expect(page).to_have_url(chat_url)- expect(composer).to_have_value("Keep this Chat draft")- page.reload()- expect(page).to_have_url(chat_url)- expect(composer).to_have_value("Keep this Chat draft")+ expect(page).to_have_url(providers_url)+ expect(field).to_have_value("Keep this provider edit")@pytest.mark.parametrize("source", ["event", "detail404", "returned_detail404"])@@ -383,7 +372,7 @@ def test_visible_code_removal_replaces_history(if source != "event":hold_deleted_detail(page, code_control, session_id)if source == "returned_detail404":- page.get_by_role("button", name="Chat Sessions", exact=True).click()+ page.get_by_role("button", name="Providers", exact=True).click()page.go_back()expect(page).to_have_url(url)expect(page.locator("#view-code")).to_be_visible()@@ -399,7 +388,7 @@ def test_visible_code_removal_replaces_history(assert page.evaluate("history.length") == history_lengthif source == "returned_detail404":page.go_forward()- expect(page).to_have_url(f"{admin_base_url}/admin/chat")+ expect(page).to_have_url(f"{admin_base_url}/admin")page.go_back()expect(page).to_have_url(f"{admin_base_url}/admin/code")reads = []@@ -426,7 +415,9 @@ def test_code_removal_does_not_redirect_another_code_session(page.locator(f'#codeLibrary [data-id="{other.id}"]').click()other_url = f"{admin_base_url}/admin/code/{other.id}"expect(page).to_have_url(other_url)- page.locator("#codeComposer").fill("Keep B's draft")+ composer = page.locator("#codeComposer")+ composer.fill("Keep B's draft")+ composer.evaluate("input => input.setSelectionRange(2, 7)")history_length = page.evaluate("history.length")if source == "event":delete_from_other_client(code_control, session_id)@@ -435,8 +426,16 @@ def test_code_removal_does_not_redirect_another_code_session(page.evaluate("window.releaseCodeReads()")expect(page.locator("#codeSend")).to_be_enabled()expect(page).to_have_url(other_url)- expect(page.locator("#codeComposer")).to_have_value("Keep B's draft")+ expect(composer).to_have_value("Keep B's draft")+ expect(composer).to_be_focused()+ assert composer.evaluate("input => [input.selectionStart,input.selectionEnd]") == [+ 2,+ 7,+ ]assert page.evaluate("history.length") == history_length+ page.reload()+ expect(page).to_have_url(other_url)+ expect(composer).to_have_value("Keep B's draft")def control_feed(page):@@ -447,7 +446,6 @@ def control_feed(page):super(...args);this.isCode = String(args[0]).includes('/api/code/events');if (this.isCode) window.codeFeed = this;- if (String(args[0]).includes('/api/chat/events')) window.chatFeed = this;}addEventListener(type, listener, ...options) {return super.addEventListener(type, event => {@@ -505,48 +503,6 @@ def send_from_other_client(page, url, text):return response.json()["id"]-def test_hidden_chat_cannot_change_code_control_state(- page, admin_base_url, tmp_path, code_control-):- control_feed(page)- _new_chat(page, admin_base_url)- chat_id = page.url.rsplit("/", 1)[1]- expect(page.locator("#chatModel")).to_be_enabled()- page.get_by_role("button", name="Code sessions", exact=True).click()- page.get_by_role("button", name="New code session", exact=True).click()- page.get_by_role("textbox", name="Folder", exact=True).fill(str(tmp_path))- page.get_by_role("button", name="Create session", exact=True).click()- send(page, "Keep working")- connection = code_control.connection()- controls = page.locator(- "#codeRoot .session-model-control input, "- "#codeRoot .session-model-control button, #codeReasoning, #codeDelete"- )- assert controls.count() == 4- for control in controls.all():- expect(control).to_be_disabled()- endpoint = f"{admin_base_url}/admin/api/chat/sessions/{chat_id}"- session = page.request.get(endpoint).json()["session"]- response = page.request.patch(- endpoint,- data={"expected_revision": session["revision"], "title": "Hidden update"},- )- assert response.ok- expect(page.locator("#chatRoot .session-title")).to_have_value("Hidden update")- for control in controls.all():- expect(control).to_be_disabled()- expect(page.locator("#codeRoot .session-title")).to_be_enabled()-- code_control.run(connection.finish("turn-1"))- for control in controls.all():- expect(control).to_be_enabled()- page.evaluate("window.chatFeed.dispatchEvent(new Event('error'))")- expect(page.locator("#chatModel")).to_be_disabled()- for control in controls.all():- expect(control).to_be_enabled()- expect(page.locator("#codeRoot .session-title")).to_be_enabled()--def test_model_default_clears_effort_when_all_choices_disappear(page, context, admin_base_url, tmp_path, code_control):@@ -908,7 +864,7 @@ def test_library_reconnect_removes_missed_deletion_and_searches_beyond_first_pag@pytest.mark.parametrize("width,height", [(1440, 1000), (390, 844)])-def test_code_composer_uses_chat_geometry_and_preserves_focus(+def test_code_composer_fits_viewport_and_preserves_focus(page, admin_base_url, tmp_path, code_control, width, height):page.set_viewport_size({"width": width, "height": height})@@ -916,9 +872,6 @@ def test_code_composer_uses_chat_geometry_and_preserves_focus(composer = page.locator("#codeComposer")composer.fill("a draft\nwith a second line")composer.evaluate("input => input.setSelectionRange(2, 6)")- expected = composer.evaluate(- "input => { const s=getComputedStyle(input); return [s.minHeight,s.maxHeight,s.padding,s.lineHeight,s.resize]; }"- )page.locator("#codeModel").click()page.keyboard.press("Escape")composer.focus()@@ -934,11 +887,3 @@ def test_code_composer_uses_chat_geometry_and_preserves_focus(+ page.locator("#codeComposer").bounding_box()["height"]<= height)- page.goto(f"{admin_base_url}/admin/chat")- page.get_by_role("button", name="New chat", exact=True).click()- chat = page.locator("#chatComposer")- expect(chat).to_be_visible()- actual = chat.evaluate(- "input => { const s=getComputedStyle(input); return [s.minHeight,s.maxHeight,s.padding,s.lineHeight,s.resize]; }"- )- assert actual == expecteddiff --git a/pyproject.toml b/pyproject.tomlindex 1978dc35..f62abf71 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "5.23.6"+version = "6.0.0"description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"readme = "README.md"requires-python = ">=3.14.0"diff --git a/src/free_claude_code/api/admin_routes.py b/src/free_claude_code/api/admin_routes.pyindex 64fb14da..2da86f13 100644--- a/src/free_claude_code/api/admin_routes.py+++ b/src/free_claude_code/api/admin_routes.py@@ -43,8 +43,6 @@ _ADMIN_ASSET_FILENAMES = frozenset("admin.css","admin.js","app-icon.svg",- "chat_sessions.css",- "chat_sessions.js","code_sessions.css","code_sessions.js","session_layout.css",diff --git a/src/free_claude_code/api/admin_static/admin.js b/src/free_claude_code/api/admin_static/admin.jsindex 447dde16..3a668700 100644--- a/src/free_claude_code/api/admin_static/admin.js+++ b/src/free_claude_code/api/admin_static/admin.js@@ -33,13 +33,6 @@ const VIEW_GROUPS = [sections: ["messaging", "voice"],containerId: "messagingSections",},- {- id: "chat",- label: "Chat Sessions",- title: "Chat Sessions",- sections: [],- containerId: "chatRoot",- },{id: "code",label: "Code sessions",@@ -50,7 +43,7 @@ const VIEW_GROUPS = [];function sessionViewFromPath() {- return ["chat", "code"].find((id) => window.location.pathname.startsWith(`/admin/${id}`)) || "providers";+ return window.location.pathname.startsWith("/admin/code") ? "code" : "providers";}const byId = (id) => document.getElementById(id);@@ -117,7 +110,6 @@ async function load() {refreshConnectedAccounts(),hydrateModelOptions(),refreshLocalStatus(),- window.ChatSessions ? window.ChatSessions.initialize(api) : Promise.resolve(),window.CodeSessions.initialize(api),]);updateDirtyState();@@ -149,8 +141,7 @@ function setActiveView(viewId, { scroll = false } = {}) {VIEW_GROUPS.find((view) => view.id === viewId) || VIEW_GROUPS[0];state.activeView = activeView.id;byId("pageTitle").textContent = activeView.title;- const chatActive = activeView.id === "chat";- const sessionActive = chatActive || activeView.id === "code";+ const sessionActive = activeView.id === "code";document.querySelector(".app-shell").classList.toggle("session-active", sessionActive);document.querySelector(".main").classList.toggle("session-main", sessionActive);document.querySelector(".topbar").hidden = sessionActive;@@ -175,14 +166,11 @@ function setActiveView(viewId, { scroll = false } = {}) {if (scroll) {window.scrollTo({ top: 0, behavior: "smooth" });}- if (chatActive && window.ChatSessions) {- window.ChatSessions.activate(window.location.pathname);- }if (activeView.id === "code") window.CodeSessions.activate(window.location.pathname);}function navigateToView(viewId) {- if (["chat", "code"].includes(viewId)) {+ if (viewId === "code") {if (window.location.pathname !== `/admin/${viewId}`) {window.history.pushState({}, "", `/admin/${viewId}`);}@@ -965,7 +953,7 @@ function showCredentialErrors(checks) {function setApplying(applying) {state.applying = applying;- VIEW_GROUPS.filter((view) => !["chat", "code"].includes(view.id)).forEach((view) => {+ VIEW_GROUPS.filter((view) => view.id !== "code").forEach((view) => {byId(`view-${view.id}`).inert = applying || !!state.restart;});if (applying) state.modelComboboxes.forEach((combobox) => combobox.close());@@ -1180,7 +1168,6 @@ async function loadModelOptions(refresh = false) {method: refresh ? "POST" : "GET",});setModelOptions(result.models);- if (refresh && window.ChatSessions) await window.ChatSessions.refresh();if (refresh && window.CodeSessions) await window.CodeSessions.refresh();return result;}@@ -1243,6 +1230,14 @@ window.addEventListener("popstate", () => {setActiveView(viewId, { scroll: false });});+try {+ for (const key of Object.keys(sessionStorage)) {+ if (key.startsWith("fcc.chat.draft.")) sessionStorage.removeItem(key);+ }+} catch {+ console.warn("Chat draft cleanup deferred until the next page load: storage unavailable");+}+load().then(showRestartNotice).catch((error) => {showMessage(error.message, "error");});diff --git a/src/free_claude_code/api/admin_static/chat_sessions.css b/src/free_claude_code/api/admin_static/chat_sessions.cssdeleted file mode 100644index 0d87e7a5..00000000--- a/src/free_claude_code/api/admin_static/chat_sessions.css+++ /dev/null@@ -1,89 +0,0 @@-.chat-dialog-actions {- display: flex;- align-items: center;-}--.chat-context-meter {- align-self: end;- min-height: 38px;- border: 1px solid var(--line);- border-radius: var(--radius-sm);- padding: 9px 11px;- color: var(--muted);- font-size: 12px;-}--.chat-context-meter.warn {- border-color: var(--warn-border);- color: var(--warn);-}--.chat-fallback-label {- color: var(--info);- font-weight: 500;-}--.chat-compaction {- margin: 12px 0;- border-left: 2px solid var(--line-strong);- padding: 4px 0 4px 14px;- color: var(--muted);-}--.chat-compaction summary {- cursor: pointer;- font-size: 13px;- font-weight: 700;-}--.chat-compaction {- max-width: 1120px;- margin: 0 auto 24px;- border: 1px solid var(--line);- border-radius: var(--radius-md);- padding: 12px 15px;-}--.chat-prompt-dialog {- width: min(680px, calc(100vw - 32px));- border: 1px solid var(--line-strong);- border-radius: var(--radius-lg);- background: var(--panel);- padding: 22px;- color: var(--text);-}--.chat-prompt-dialog::backdrop {- background: rgba(0, 0, 0, 0.7);-}--.chat-prompt-dialog h3 {- margin-top: 0;-}--.chat-prompt-dialog textarea {- width: 100%;- resize: vertical;- border: 1px solid var(--line-strong);- border-radius: var(--radius-sm);- background: var(--input);- padding: 12px;-}--.chat-dialog-actions {- justify-content: flex-end;- gap: 8px;- margin-top: 16px;-}--@media (max-width: 900px) {- .chat-context-meter {- grid-column: 1 / -1;- }-}--@media (max-width: 700px) {- .chat-context-meter {- grid-column: auto;- }-}diff --git a/src/free_claude_code/api/admin_static/chat_sessions.js b/src/free_claude_code/api/admin_static/chat_sessions.jsdeleted file mode 100644index 48694e14..00000000--- a/src/free_claude_code/api/admin_static/chat_sessions.js+++ /dev/null@@ -1,1914 +0,0 @@-(() => {- const state = {- api: null,- initialized: false,- bootstrap: null,- bootstrapRequestVersion: 0,- session: null,- turns: [],- compaction: null,- nextBefore: null,- context: null,- contextError: "",- libraryCursor: null,- libraryItems: [],- libraryQuery: "",- libraryRequestVersion: 0,- libraryLoadMore: null,- olderLoad: null,- operation: null,- activeOperations: new Map(),- pendingCommands: new Map(),- sessionSummaries: new Map(),- sessionRevisions: new Map(),- deletedSessions: new Set(),- retiredTitleInputs: new WeakSet(),- draft: "",- draftSessionId: null,- draftOperationId: null,- draftSubmittedText: "",- routeVersion: 0,- estimateTimer: null,- estimateVersion: 0,- feed: null,- feedStatus: "connecting",- feedLastId: 0,- feedSyncVersion: 0,- eventBuffer: null,- feedRestartTimer: null,- modelComboboxes: new Set(),- };-- const CHAT_EVENT_TYPES = [- "session.created",- "session.updated",- "session.deleted",- "preferences.updated",- "operation.started",- "turn.started",- "segment.started",- "segment.delta",- "segment.completed",- "compaction.started",- "compaction.progress",- "compaction.completed",- "compaction.failed",- "compaction.stopped",- "turn.completed",- "turn.failed",- "turn.stopped",- "operation.failed",- ];-- const UI = window.SessionUI;- const {- node,- button,- nearBottom,- resizeComposer,- focusIsUnclaimed: composerFocusIsUnclaimed,- } = UI;- const root = () => document.getElementById("chatRoot");-- function setNotice(message, kind = "") {- const area = document.getElementById("chatNotice");- if (!area) return;- area.textContent = message;- area.className = `session-notice ${kind}`.trim();- area.hidden = !message;- }-- async function initialize(api) {- if (state.initialized) return;- state.api = api;- state.initialized = true;- connectEventFeed();- if (chatIsVisible()) {- renderLoading();- }- }-- function mutationsReady() {- return state.feedStatus === "live";- }-- function connectEventFeed() {- window.clearTimeout(state.feedRestartTimer);- state.feedRestartTimer = null;- state.feed?.close();- state.feedStatus = state.feedLastId ? "reconnecting" : "connecting";- refreshFeedState();- const feed = new EventSource("/admin/api/chat/events");- state.feed = feed;- feed.addEventListener("feed.ready", (event) => {- if (state.feed === feed) void synchronizeFeed(event);- });- feed.addEventListener("feed.resync_required", () => {- if (state.feed === feed) restartEventFeed();- });- CHAT_EVENT_TYPES.forEach((type) => {- feed.addEventListener(type, (event) => {- if (state.feed === feed) receiveChatEvent(type, event);- });- });- feed.addEventListener("error", () => {- if (state.feed !== feed) return;- state.feedSyncVersion += 1;- state.feedStatus = "reconnecting";- refreshFeedState();- if (!state.bootstrap) void refresh(window.location.pathname);- });- }-- function restartEventFeed() {- state.feedSyncVersion += 1;- state.feed?.close();- state.feed = null;- state.feedStatus = "reconnecting";- refreshFeedState();- window.clearTimeout(state.feedRestartTimer);- state.feedRestartTimer = window.setTimeout(connectEventFeed, 250);- }-- async function synchronizeFeed(event) {- const cursor = Number.parseInt(event.lastEventId, 10);- let snapshot;- try {- snapshot = JSON.parse(event.data);- } catch {- restartEventFeed();- return;- }- if (- !Number.isSafeInteger(cursor) ||- cursor < 0 ||- snapshot?.cursor !== cursor ||- !Array.isArray(snapshot?.active_operations)- ) {- restartEventFeed();- return;- }- const syncVersion = ++state.feedSyncVersion;- state.feedLastId = cursor;- state.feedStatus = "synchronizing";- refreshFeedState();- const snapshotOperationIds = installActiveSnapshot(- snapshot.active_operations,- );- if (!snapshotOperationIds) {- restartEventFeed();- return;- }- await withBufferedEvents(() => refresh(window.location.pathname));- if (syncVersion !== state.feedSyncVersion) return;- settlePendingAfterSnapshot(snapshotOperationIds);- state.feedStatus = "live";- refreshFeedState();- }-- async function withBufferedEvents(loadSnapshot) {- if (state.eventBuffer) {- await loadSnapshot();- return;- }- const buffer = [];- state.eventBuffer = buffer;- try {- await loadSnapshot();- } finally {- if (state.eventBuffer !== buffer) return;- state.eventBuffer = null;- buffer.forEach(applyChatEvent);- }- }-- function receiveChatEvent(type, event) {- let payload;- const id = Number.parseInt(event.lastEventId, 10);- try {- payload = JSON.parse(event.data);- } catch {- restartEventFeed();- return;- }- if (!Number.isSafeInteger(id) || id <= 0 || !payload) {- restartEventFeed();- return;- }- if (id <= state.feedLastId) return;- if (id !== state.feedLastId + 1) {- restartEventFeed();- return;- }- state.feedLastId = id;- const chatEvent = { type, id, payload };- if (state.eventBuffer) {- state.eventBuffer.push(chatEvent);- } else {- applyChatEvent(chatEvent);- }- }-- function applyChatEvent(event) {- const { type, payload } = event;- if (type === "session.created" || type === "session.updated") {- applySessionSummary(payload);- return;- }- if (type === "session.deleted") {- applySessionDeletion(payload.session_id);- return;- }- if (type === "preferences.updated") {- applyPreferencesUpdate(payload);- return;- }- applyOperationEvent(type, payload);- }-- function applySessionSummary(payload) {- const summary = sessionSummaryFromPayload(payload);- const current = summary ? reduceSessionSummary(summary) : null;- if (!current) return;- upsertLibrarySummary(current);- if (state.session?.id !== current.id) {- if (!state.session && chatIsVisible()) renderLibraryItems();- return;- }- if (current.revision < state.session.revision) return;- const controlsChanged =- state.session.title !== current.title ||- state.session.model !== current.model ||- state.session.reasoning !== current.reasoning;- const titleEdit = captureTitleEdit();- const selection = captureComposerSelection();- state.session = {- ...state.session,- title: current.title,- model: current.model,- reasoning: current.reasoning,- revision: current.revision,- created_at: current.created_at,- updated_at: current.updated_at,- };- if (controlsChanged) {- renderSessionPreservingScroll(titleEdit);- restoreComposerSelection(selection);- }- scheduleEstimate(true);- }-- function sessionSummaryFromPayload(payload) {- if (- typeof payload.session_id !== "string" ||- typeof payload.title !== "string" ||- typeof payload.model !== "string" ||- typeof payload.reasoning !== "string" ||- !Number.isInteger(payload.revision) ||- typeof payload.preview !== "string" ||- !Number.isInteger(payload.created_at) ||- !Number.isInteger(payload.updated_at)- )- return null;- return {- id: payload.session_id,- title: payload.title,- model: payload.model,- reasoning: payload.reasoning,- revision: payload.revision,- preview: payload.preview,- created_at: payload.created_at,- updated_at: payload.updated_at,- };- }-- function reduceSessionSummary(summary) {- if (state.deletedSessions.has(summary.id)) return null;- const knownRevision = state.sessionRevisions.get(summary.id) || 0;- if (summary.revision < knownRevision) return null;- state.sessionRevisions.set(summary.id, summary.revision);- state.sessionSummaries.set(summary.id, summary);- return summary;- }-- function upsertLibrarySummary(summary) {- state.libraryItems = state.libraryItems.filter(- (item) => item.id !== summary.id,- );- if (matchesLibraryQuery(summary)) state.libraryItems.push(summary);- sortLibraryItems();- }-- function matchesLibraryQuery(summary) {- const query = state.libraryQuery.trim().toLocaleLowerCase();- return !query || summary.title.toLocaleLowerCase().includes(query);- }-- function sortLibraryItems() {- state.libraryItems.sort(- (left, right) =>- right.updated_at - left.updated_at || right.id.localeCompare(left.id),- );- }-- function applySessionDeletion(sessionId) {- if (typeof sessionId !== "string") return;- state.deletedSessions.add(sessionId);- state.sessionSummaries.delete(sessionId);- state.sessionRevisions.delete(sessionId);- const operation = state.activeOperations.get(sessionId);- if (operation) cancelOperationRender(operation);- state.activeOperations.delete(sessionId);- const pending = state.pendingCommands.get(sessionId);- if (pending) cancelOperationRender(pending);- state.pendingCommands.delete(sessionId);- removeDraft(sessionId);- state.libraryItems = state.libraryItems.filter(- (session) => session.id !== sessionId,- );- if (- state.session?.id === sessionId ||- routedSessionId(window.location.pathname) === sessionId- ) {- detachVisibleOperation();- window.history.replaceState({}, "", "/admin/chat");- void route(window.location.pathname);- } else if (!state.session && chatIsVisible()) {- renderLibraryItems();- }- }-- function applyPreferencesUpdate(payload) {- if (!state.bootstrap || !Number.isInteger(payload.updated_at)) return;- const current = state.bootstrap.preferences;- if (current && payload.updated_at < current.updated_at) return;- state.bootstrap.preferences = {- system_prompt: payload.system_prompt,- last_model: payload.last_model,- last_reasoning: payload.last_reasoning,- updated_at: payload.updated_at,- };- if (state.session) scheduleEstimate(true);- }-- function createOperation(values) {- const phase = values.phase || "generating";- return {- id: values.id,- sessionId: values.sessionId,- action: values.action,- phase,- segments: values.segments || [],- sequence: values.sequence || 0,- status: phase === "compacting" ? "Compacting…" : "Thinking…",- userText: values.userText || "",- accepted: Boolean(values.accepted),- failureMessage: "",- renderFrame: null,- returnFocusToComposer: Boolean(values.returnFocusToComposer),- commandPending: Boolean(values.commandPending),- serverObserved: Boolean(values.serverObserved),- ambiguousError: "",- turnId: values.turnId || null,- generationId: values.generationId || null,- regeneration: Boolean(values.regeneration),- actualModel: values.actualModel || null,- };- }-- function operationFromSnapshot(snapshot, existing = null) {- const operation =- existing && existing.id === snapshot.operation_id- ? existing- : createOperation({- id: snapshot.operation_id,- sessionId: snapshot.session_id,- action: snapshot.kind,- });- if (snapshot.operation_sequence < operation.sequence) return operation;- operation.action = snapshot.kind;- operation.phase = snapshot.phase;- operation.status =- snapshot.phase === "compacting" ? "Compacting…" : "Thinking…";- operation.userText = snapshot.submitted_text || "";- operation.turnId = snapshot.turn_id;- operation.generationId = snapshot.generation_id;- operation.regeneration = Boolean(snapshot.regeneration);- operation.actualModel = snapshot.actual_model;- operation.segments = (snapshot.segments || []).map((segment) => ({- kind: segment.kind,- text: segment.text,- pending: [],- }));- operation.sequence = snapshot.operation_sequence;- operation.accepted = Boolean(snapshot.turn_id || snapshot.generation_id);- operation.serverObserved = true;- operation.commandPending = false;- operation.ambiguousError = "";- return operation;- }-- function validOperationKind(value) {- return ["send", "retry", "regenerate", "compact"].includes(value);- }-- function validOperationSnapshot(snapshot) {- return Boolean(- snapshot &&- typeof snapshot.session_id === "string" &&- typeof snapshot.operation_id === "string" &&- validOperationKind(snapshot.kind) &&- ["generating", "compacting"].includes(snapshot.phase) &&- Number.isInteger(snapshot.operation_sequence) &&- Array.isArray(snapshot.segments),- );- }-- function installActiveSnapshot(snapshots) {- const next = new Map();- const operationIds = new Set();- for (const snapshot of snapshots) {- if (!validOperationSnapshot(snapshot) || next.has(snapshot.session_id)) {- return null;- }- const current = state.activeOperations.get(snapshot.session_id);- const pending = state.pendingCommands.get(snapshot.session_id);- const reusable =- current?.id === snapshot.operation_id- ? current- : pending?.id === snapshot.operation_id- ? pending- : null;- const operation = operationFromSnapshot(snapshot, reusable);- next.set(snapshot.session_id, operation);- operationIds.add(snapshot.operation_id);- if (pending?.id === snapshot.operation_id) {- state.pendingCommands.delete(snapshot.session_id);- }- }- state.activeOperations.forEach((operation, sessionId) => {- if (next.get(sessionId) !== operation) cancelOperationRender(operation);- });- state.activeOperations = next;- selectVisibleOperation();- if (!state.session && chatIsVisible()) renderLibraryItems();- return operationIds;- }-- function settlePendingAfterSnapshot(operationIds) {- if (!operationIds) {- restartEventFeed();- return;- }- [...state.pendingCommands.values()].forEach((pending) => {- if (pending.commandPending || operationIds.has(pending.id)) return;- if (pending.serverObserved) {- clearPendingCommand(pending);- } else if (pending.ambiguousError) {- markCommandUncertain(pending);- }- });- selectVisibleOperation();- if (state.session) renderSessionPreservingScroll();- }-- function selectVisibleOperation() {- if (!state.session) {- state.operation = null;- return;- }- state.operation =- state.activeOperations.get(state.session.id) ||- state.pendingCommands.get(state.session.id) ||- null;- }-- function applyOperationEvent(type, payload) {- if (- typeof payload.session_id !== "string" ||- typeof payload.operation_id !== "string" ||- !validOperationKind(payload.kind) ||- !Number.isInteger(payload.operation_sequence)- )- return;- const active = state.activeOperations.get(payload.session_id);- const pending = state.pendingCommands.get(payload.session_id);- const matchingActive = active?.id === payload.operation_id ? active : null;- const matchingPending =- pending?.id === payload.operation_id ? pending : null;- if (isTerminalEvent(type, payload.kind)) {- if (- matchingActive &&- payload.operation_sequence <= matchingActive.sequence- )- return;- if (matchingActive) matchingActive.sequence = payload.operation_sequence;- if (matchingPending) matchingPending.serverObserved = true;- void settleOperation(type, payload, matchingActive || matchingPending);- return;- }- let operation = matchingActive || matchingPending;- if (!operation) {- operation = createOperation({- id: payload.operation_id,- sessionId: payload.session_id,- action: payload.kind,- });- }- if (payload.operation_sequence <= operation.sequence) return;- if (active && active !== operation) cancelOperationRender(active);- state.activeOperations.set(payload.session_id, operation);- if (matchingPending) state.pendingCommands.delete(payload.session_id);- operation.serverObserved = true;- operation.commandPending = false;- let structural = true;- let restoreComposerFocus = false;- if (type === "operation.started") {- operation.action = payload.kind;- operation.phase = payload.phase;- operation.status =- payload.phase === "compacting" ? "Compacting…" : "Thinking…";- operation.userText = payload.submitted_text || "";- } else if (type === "turn.started") {- operation.accepted = true;- operation.phase = "generating";- operation.status = "Thinking…";- operation.turnId = payload.turn_id;- operation.generationId = payload.generation_id;- operation.regeneration = Boolean(payload.regeneration);- if (operation.action === "send") confirmSubmittedDraft(operation.id);- restoreComposerFocus =- operation.returnFocusToComposer && composerFocusIsUnclaimed();- } else if (type === "segment.started") {- operation.segments[payload.ordinal] = {- kind: payload.segment_kind,- text: "",- pending: [],- };- } else if (type === "segment.delta") {- const segment = operation.segments[payload.ordinal];- if (segment) {- if (state.operation === operation) {- segment.pending.push(payload.delta);- structural = false;- scheduleLiveRender(operation);- } else {- segment.text += payload.delta;- }- }- } else if (type === "compaction.started") {- operation.phase = "compacting";- operation.status = "Compacting…";- } else if (- type === "compaction.completed" &&- operation.action !== "compact"- ) {- operation.phase = "generating";- operation.status = "Thinking…";- }- operation.sequence = payload.operation_sequence;- if (state.session?.id === operation.sessionId) state.operation = operation;- if (structural && state.operation === operation) {- renderOperationStructure(operation);- if (restoreComposerFocus) focusComposerAtEnd();- } else if (!state.session && chatIsVisible()) {- renderLibraryItems();- }- }-- function isTerminalEvent(type, kind) {- return (- [- "turn.completed",- "turn.failed",- "turn.stopped",- "compaction.failed",- "compaction.stopped",- "operation.failed",- ].includes(type) ||- (type === "compaction.completed" && kind === "compact")- );- }-- async function settleOperation(type, payload, operation) {- const sessionId = payload.session_id;- const operationId = payload.operation_id;- if (operation) cancelOperationRender(operation);- if (state.activeOperations.get(sessionId)?.id === operationId) {- state.activeOperations.delete(sessionId);- }- if (state.pendingCommands.get(sessionId)?.id === operationId) {- state.pendingCommands.delete(sessionId);- }- if (state.session?.id !== sessionId) {- if (!state.session && chatIsVisible()) renderLibraryItems();- return;- }- if (type === "operation.failed") {- selectVisibleOperation();- if (payload.kind === "send") rejectSubmittedDraft(operationId);- renderSessionPreservingScroll();- setNotice(payload.message || "Chat operation failed.", "error");- return;- }- // Keep the visible answer until the saved turns replace it.- await reloadSession();- selectVisibleOperation();- refreshComposerState();- if (type === "compaction.failed") {- setNotice(payload.message || "Compaction failed.", "error");- }- }-- function refreshFeedState() {- if (state.session) refreshComposerState();- const newChat = document.querySelector('[data-testid="chat-new"]');- if (newChat) newChat.disabled = !mutationsReady();- }-- function focusComposerAtEnd() {- const textarea = document.getElementById("chatComposer");- restoreComposerSelection(- textarea- ? {- start: textarea.value.length,- end: textarea.value.length,- direction: "none",- }- : null,- );- }-- function draftKey(sessionId) {- return `fcc.chat.draft.${sessionId}`;- }-- function loadDraft(sessionId) {- state.draftSessionId = sessionId;- state.draft = "";- state.draftOperationId = null;- state.draftSubmittedText = "";- try {- const stored = JSON.parse(- sessionStorage.getItem(draftKey(sessionId)) || "null",- );- if (!stored || typeof stored !== "object") return;- if (typeof stored.text === "string") state.draft = stored.text;- if (typeof stored.operationId === "string") {- state.draftOperationId = stored.operationId;- }- if (typeof stored.submittedText === "string") {- state.draftSubmittedText = stored.submittedText;- }- } catch {- // In-memory draft state remains usable when browser storage is unavailable.- }- }-- function saveDraft() {- if (!state.draftSessionId) return;- try {- if (!state.draft && !state.draftOperationId) {- sessionStorage.removeItem(draftKey(state.draftSessionId));- return;- }- sessionStorage.setItem(- draftKey(state.draftSessionId),- JSON.stringify({- text: state.draft,- operationId: state.draftOperationId,- submittedText: state.draftSubmittedText,- }),- );- } catch {- // In-memory draft state remains usable when browser storage is unavailable.- }- }-- function removeDraft(sessionId) {- try {- sessionStorage.removeItem(draftKey(sessionId));- } catch {- // Deletion remains correct even when browser storage is unavailable.- }- if (state.draftSessionId === sessionId) {- state.draft = "";- state.draftSessionId = null;- state.draftOperationId = null;- state.draftSubmittedText = "";- }- }-- function confirmSubmittedDraft(operationId) {- if (state.draftOperationId !== operationId) return;- if (state.draft === state.draftSubmittedText) state.draft = "";- state.draftOperationId = null;- state.draftSubmittedText = "";- saveDraft();- const textarea = document.getElementById("chatComposer");- if (textarea) textarea.value = state.draft;- }-- function rejectSubmittedDraft(operationId) {- if (state.draftOperationId !== operationId) return;- if (!state.draft) state.draft = state.draftSubmittedText;- state.draftOperationId = null;- state.draftSubmittedText = "";- saveDraft();- }-- function rejectCommand(operation, message) {- cancelOperationRender(operation);- if (state.pendingCommands.get(operation.sessionId) === operation) {- state.pendingCommands.delete(operation.sessionId);- }- if (operation.action === "send") rejectSubmittedDraft(operation.id);- if (state.operation === operation) {- selectVisibleOperation();- renderSessionPreservingScroll();- setNotice(message, "error");- }- }-- function clearPendingCommand(operation) {- if (state.pendingCommands.get(operation.sessionId) === operation) {- state.pendingCommands.delete(operation.sessionId);- }- if (- operation.action === "send" &&- state.turns.some((turn) => turn.operation_id === operation.id)- ) {- confirmSubmittedDraft(operation.id);- }- cancelOperationRender(operation);- }-- function markCommandUncertain(operation) {- clearPendingCommand(operation);- if (state.operation !== operation) return;- selectVisibleOperation();- renderSessionPreservingScroll();- setNotice(- "The connection was lost before FCC could confirm this command. Check the chat before trying it again.",- "error",- );- }-- function reconcileAmbiguousCommand(operation) {- if (state.pendingCommands.get(operation.sessionId) !== operation) return;- restartEventFeed();- }-- function detachVisibleOperation() {- if (!state.operation) return;- cancelOperationRender(state.operation);- commitPendingDeltas(state.operation);- state.operation = null;- }-- async function refresh(path = window.location.pathname) {- if (!state.initialized) return;- const requestVersion = ++state.bootstrapRequestVersion;- const routeVersion = state.routeVersion;- let bootstrap;- try {- bootstrap = await state.api("/admin/api/chat/bootstrap");- } catch (error) {- bootstrap = {- available: false,- message: error.message,- models: [],- preferences: null,- };- }- if (requestVersion !== state.bootstrapRequestVersion) return;- state.bootstrap = bootstrap;- if (!chatIsVisible() || routeVersion !== state.routeVersion) return;- await route(path);- }-- async function activate(path) {- if (!state.initialized) {- renderLoading();- return;- }- state.routeVersion += 1;- renderLoading();- await withBufferedEvents(() => refresh(path));- }-- function chatIsVisible() {- const view = root()?.closest(".admin-view");- return Boolean(view && !view.hidden);- }-- async function route(path) {- const version = ++state.routeVersion;- const sessionId = routedSessionId(path);- if (!sessionId) {- await showLibrary(version);- return;- }- await showSession(sessionId, version);- }-- function routedSessionId(path) {- return (- path.match(/^\/admin\/chat\/([0-9a-f-]+)$/i)?.[1].toLowerCase() || null- );- }-- function renderLoading() {- state.modelComboboxes.clear();- const container = root();- container.replaceChildren(- node("div", "session-empty", "Loading Chat Sessions…"),- );- }-- function renderUnavailable() {- state.modelComboboxes.clear();- const container = node("section", "session-empty");- container.append(- node("h3", "", "Chat Sessions unavailable"),- node(- "p",- "",- state.bootstrap?.message || "Chat storage could not be opened.",- ),- );- root().replaceChildren(container);- }-- async function showLibrary(version) {- detachVisibleOperation();- state.session = null;- if (!state.bootstrap?.available) {- renderUnavailable();- return;- }- renderLibraryShell();- await loadLibrary(true, version);- }-- function renderLibraryShell() {- state.modelComboboxes.clear();- const create = button("New chat", "primary-button", createSession);- create.dataset.testid = "chat-new";- create.disabled = !mutationsReady();- const header = UI.libraryHeader(- "Chat Sessions",- "Talk directly to any configured FCC model.",- create,- );- const search = UI.search("Search chats", state.libraryQuery, (value) => {- state.libraryQuery = value;- loadLibrary(true, state.routeVersion);- });- const notice = node("div", "session-notice");- notice.id = "chatNotice";- notice.hidden = true;- const list = node("div", "session-list");- list.id = "chatSessionList";- const more = button("Load more", "secondary-button session-load-more", () =>- loadLibrary(false, state.routeVersion),- );- more.id = "chatLoadMore";- more.hidden = true;- root().replaceChildren(header, search, notice, list, more);- }-- async function loadLibrary(reset, version) {- const list = document.getElementById("chatSessionList");- if (!list) return;- const query = state.libraryQuery;- const cursor = reset ? null : state.libraryCursor;- if (!reset && (!cursor || state.libraryLoadMore)) return;- const requestVersion = reset- ? ++state.libraryRequestVersion- : state.libraryRequestVersion;- const loadMore = reset ? null : {};- if (reset) {- state.libraryItems = [];- state.libraryCursor = null;- state.libraryLoadMore = null;- list.replaceChildren(node("div", "session-empty", "Loading chats…"));- } else {- state.libraryLoadMore = loadMore;- const more = document.getElementById("chatLoadMore");- if (more) more.disabled = true;- }- const params = new URLSearchParams({ query, limit: "25" });- if (cursor) params.set("cursor", cursor);- const isCurrent = () =>- version === state.routeVersion &&- requestVersion === state.libraryRequestVersion &&- !state.session &&- query === state.libraryQuery &&- (reset || state.libraryCursor === cursor);- try {- const page = await state.api(`/admin/api/chat/sessions?${params}`);- if (!isCurrent()) return;- const merged = new Map(- state.libraryItems.map((session) => [session.id, session]),- );- page.sessions.forEach((session) => {- if (state.deletedSessions.has(session.id)) return;- const current = reduceSessionSummary(session);- if (current && matchesLibraryQuery(current))- merged.set(current.id, current);- });- state.libraryItems = [...merged.values()].filter(matchesLibraryQuery);- sortLibraryItems();- state.libraryCursor = page.next_cursor;- renderLibraryItems();- } catch (error) {- if (isCurrent()) setNotice(error.message, "error");- } finally {- if (loadMore && state.libraryLoadMore === loadMore) {- state.libraryLoadMore = null;- const more = document.getElementById("chatLoadMore");- if (more) more.disabled = false;- }- }- }-- function renderLibraryItems() {- const list = document.getElementById("chatSessionList");- if (!list) return;- list.replaceChildren();- if (!state.libraryItems.length) {- list.appendChild(- node(- "div",- "session-empty",- state.libraryQuery ? "No matching chats." : "Start your first chat.",- ),- );- }- state.libraryItems.forEach((session) => {- const item = UI.card(- session.title,- session.preview || "No messages yet",- `${session.model} · ${relativeTime(session.updated_at)}`,- () => openSession(session.id),- );- const active = state.activeOperations.get(session.id);- if (active) {- item.appendChild(- node(- "span",- "session-status",- active.action === "compact" ? "Compacting…" : "Thinking…",- ),- );- }- list.appendChild(item);- });- const more = document.getElementById("chatLoadMore");- if (more) {- more.hidden = !state.libraryCursor;- more.disabled = Boolean(state.libraryLoadMore);- }- }-- async function createSession() {- if (!mutationsReady()) return;- setNotice("Creating chat…");- try {- const session = await state.api("/admin/api/chat/sessions", {- method: "POST",- body: "{}",- });- openSession(session.id);- } catch (error) {- setNotice(error.message, "error");- }- }-- function openSession(id) {- window.history.pushState({}, "", `/admin/chat/${id}`);- route(window.location.pathname);- }-- async function showSession(id, version, freshnessRetry = false) {- if (!state.bootstrap?.available) {- renderUnavailable();- return;- }- const refreshingVisibleSession =- state.session?.id === id &&- Boolean(document.getElementById("chatTranscript"));- if (!refreshingVisibleSession) renderLoading();- try {- const detail = await state.api(`/admin/api/chat/sessions/${id}`);- if (version !== state.routeVersion) return;- const titleEdit = refreshingVisibleSession ? captureTitleEdit() : null;- const composerSelection = refreshingVisibleSession- ? captureComposerSelection()- : null;- if (!applyDetail(detail)) {- if (!freshnessRetry && !state.deletedSessions.has(id)) {- await showSession(id, version, true);- }- return;- }- if (refreshingVisibleSession) {- renderSessionPreservingScroll(titleEdit);- restoreComposerSelection(composerSelection);- } else {- renderSession();- }- } catch (error) {- if (version !== state.routeVersion) return;- const empty = node("section", "session-empty");- empty.append(- node("h3", "", "Could not open this chat"),- node("p", "", error.message),- button("Back to chats", "secondary-button", goLibrary),- );- root().replaceChildren(empty);- }- }-- function applyDetail(detail) {- const sessionId = detail.session.id;- const knownRevision = state.sessionRevisions.get(sessionId) || 0;- if (- state.deletedSessions.has(sessionId) ||- detail.session.revision < knownRevision ||- (state.session?.id === sessionId &&- detail.session.revision < state.session.revision)- ) {- return false;- }- state.sessionRevisions.set(sessionId, detail.session.revision);- invalidateEstimate();- if (state.draftSessionId !== sessionId) {- loadDraft(sessionId);- }- const pendingTurn =- state.draftOperationId &&- detail.turns.find((turn) => turn.operation_id === state.draftOperationId);- if (pendingTurn) confirmSubmittedDraft(state.draftOperationId);- state.session = detail.session;- state.turns = detail.turns;- state.nextBefore = detail.next_before;- state.compaction = detail.compaction;- state.context = detail.context;- state.contextError = detail.context_error || "";- selectVisibleOperation();- if (state.draft && !state.operation) scheduleEstimate(true);- return true;- }-- function renderSession({ followLatest = true, scrollTop = 0 } = {}) {- const session = state.session;- if (!session) return;- const previousTitle = root().querySelector(".session-title");- if (previousTitle instanceof HTMLInputElement) {- state.retiredTitleInputs.add(previousTitle);- }- state.modelComboboxes.clear();- const header = renderSessionHeader(session);- const notice = node("div", "session-notice");- notice.id = "chatNotice";- notice.hidden = true;- const scroller = node("div", "session-transcript");- scroller.id = "chatTranscript";- scroller.setAttribute("aria-label", "Conversation");- const composer = renderComposer();- root().replaceChildren(UI.shell(header, notice, scroller, composer));- renderTranscript();- refreshComposerState();- if (followLatest) {- scrollLatest(false);- } else {- scroller.scrollTop = scrollTop;- }- }-- function renderSessionPreservingScroll(titleEdit = captureTitleEdit()) {- const scroller = document.getElementById("chatTranscript");- renderSession({- followLatest: !scroller || nearBottom(scroller),- scrollTop: scroller?.scrollTop || 0,- });- restoreTitleEdit(titleEdit);- }-- function renderSessionHeader(session) {- const controls = node("div", "session-controls");- const compact = button("Compact now", "secondary-button", compactSession);- compact.id = "chatCompact";- controls.append(- renderModelControl(session),- renderReasoningControl(session),- renderContextMeter(),- compact,- button("System prompt", "secondary-button", editSystemPrompt),- );- return UI.header(- "← Chats",- goLibrary,- session.title,- "Chat title",- (title) => {- if (- !state.retiredTitleInputs.has(title) &&- title.value !== state.session?.title- )- void updateSession({ title: title.value });- },- [button("Delete", "danger-button", deleteSession)],- controls,- );- }-- function renderModelControl(session) {- return UI.modelControl(- "chatModel",- session.model,- () => (state.bootstrap?.models || []).map((option) => option.model_ref),- state.modelComboboxes,- (model) => {- void updateSession({ model });- },- ).group;- }-- function renderReasoningControl(session) {- return UI.reasoningControl(- "chatReasoning",- [- ["off", "Off"],- ["low", "Low"],- ["medium", "Medium"],- ["high", "High"],- ["xhigh", "Extra High"],- ["max", "Max"],- ],- session.reasoning,- (reasoning) => updateSession({ reasoning }),- ).group;- }-- function renderContextMeter() {- const meter = node("div", "chat-context-meter");- meter.id = "chatContextMeter";- updateContextMeter(meter);- return meter;- }-- function updateContextMeter(- element = document.getElementById("chatContextMeter"),- ) {- if (!element) return;- const context = state.context;- if (!context || context.context_window_tokens === null) {- element.textContent = "Context: Not reported";- element.className = "chat-context-meter unknown";- return;- }- const percent = Math.round((context.usage_ratio || 0) * 100);- element.textContent = `Context: ${percent}% · ${formatCount(context.estimated_input_tokens)} / ${formatCount(context.context_window_tokens)}`;- element.className = `chat-context-meter${percent >= 85 ? " warn" : ""}`;- }-- function renderComposer() {- return UI.composer(- "chat",- state.draft,- "Message this model",- (value) => {- state.draft = value;- state.draftOperationId = null;- state.draftSubmittedText = "";- saveDraft();- refreshComposerState();- scheduleEstimate();- },- sendMessage,- stopOperation,- );- }-- function captureComposerSelection() {- return UI.captureSelection(document.getElementById("chatComposer"));- }-- function restoreComposerSelection(selection) {- UI.restoreSelection(document.getElementById("chatComposer"), selection);- }-- function captureTitleEdit() {- const input = root().querySelector(".session-title");- if (- !(input instanceof HTMLInputElement) ||- document.activeElement !== input ||- input.value === state.session?.title- )- return null;- return {- value: input.value,- start: input.selectionStart,- end: input.selectionEnd,- direction: input.selectionDirection,- };- }-- function restoreTitleEdit(edit) {- const input = root().querySelector(".session-title");- if (!(input instanceof HTMLInputElement) || !edit) return;- input.value = edit.value;- input.focus({ preventScroll: true });- const start = Math.min(edit.start ?? edit.value.length, edit.value.length);- const end = Math.min(edit.end ?? edit.value.length, edit.value.length);- input.setSelectionRange(start, end, edit.direction || "none");- }-- function renderTranscript() {- const scroller = document.getElementById("chatTranscript");- if (!scroller) return;- if (state.operation) commitPendingDeltas(state.operation);- scroller.replaceChildren();- if (state.nextBefore) {- scroller.appendChild(- button(- "Load older messages",- "secondary-button session-older",- loadOlder,- ),- );- }- if (!state.turns.length && !state.operation) {- scroller.appendChild(- node(- "div",- "session-empty session-transcript-empty",- "Start the conversation.",- ),- );- return;- }- let dividerRendered = false;- state.turns.forEach((turn, index) => {- scroller.appendChild(renderUserMessage(turn));- const replacingLatest =- turn.id === state.operation?.turnId ||- (index === state.turns.length - 1 &&- !state.operation?.turnId &&- ["retry", "regenerate"].includes(state.operation?.action));- if (!replacingLatest) scroller.appendChild(renderAssistantMessage(turn));- if (- state.compaction &&- turn.sequence === state.compaction.covered_through_sequence- ) {- scroller.appendChild(renderCompaction());- dividerRendered = true;- }- });- const operationHasTurn = state.turns.some(- (turn) => turn.operation_id === state.operation?.id,- );- if (- state.operation?.action === "send" &&- state.operation.userText &&- !operationHasTurn- ) {- const pending = node("article", "session-message user-message");- pending.append(- node("div", "session-message-label", "You"),- node("div", "session-message-plain", state.operation.userText),- );- scroller.appendChild(pending);- }- if (state.compaction && !dividerRendered) {- scroller.insertBefore(renderCompaction(), scroller.firstChild);- }- if (state.operation && state.operation.action !== "compact") {- scroller.appendChild(renderLiveAssistant(state.operation));- }- }-- function renderUserMessage(turn) {- const message = UI.message("user", "You");- const body = node("div", "session-message-plain", turn.user_text);- message.appendChild(body);- return message;- }-- function renderAssistantMessage(turn) {- const generation = turn.generation;- const message = UI.message("assistant", "Assistant");- const label = message.firstElementChild;- if (- generation.actual_model &&- generation.actual_model !== generation.requested_model- ) {- label.appendChild(- node(- "span",- "chat-fallback-label",- `Answered by ${generation.actual_model}`,- ),- );- }- message.appendChild(label);- generation.segments.forEach((segment) => {- if (segment.kind === "thinking") {- const details = UI.thinking();- const content = node("div", "session-markdown");- content.innerHTML = segment.html;- details.appendChild(content);- message.appendChild(details);- } else {- const content = node("div", "session-markdown");- // The server renders this with raw HTML disabled and safe-link rules.- content.innerHTML = segment.html;- message.appendChild(content);- }- });- if (!generation.segments.length && generation.status === "running") {- message.appendChild(- node("p", "session-muted", "Running in another tab…"),- );- }- if (generation.status !== "completed" && generation.status !== "running") {- const status = node(- "div",- `session-generation-status ${generation.status}`,- );- status.textContent =- generation.error_message || `${capitalize(generation.status)} answer`;- message.appendChild(status);- }- if (turn === state.turns[state.turns.length - 1]) {- const actions = node("div", "session-message-actions");- if (["failed", "stopped", "interrupted"].includes(generation.status)) {- actions.appendChild(button("Retry", "secondary-button", retryMessage));- }- if (generation.status === "completed") {- actions.appendChild(- button("Regenerate", "secondary-button", regenerateMessage),- );- }- message.appendChild(actions);- }- return message;- }-- function renderLiveAssistant(operation) {- const message = node(- "article",- "session-message assistant-message live-message",- );- message.appendChild(node("div", "session-message-label", "Assistant"));- if (!operation.segments.length || operation.status !== "Thinking…") {- const status = node(- "p",- "session-muted chat-operation-status",- operation.status,- );- status.setAttribute("aria-live", "polite");- message.appendChild(status);- }- operation.segments.forEach((segment, ordinal) => {- const content = node("div", "session-message-plain");- content.dataset.liveSegment = String(ordinal);- content.appendChild(document.createTextNode(segment.text));- if (segment.kind === "thinking") {- const details = document.createElement("details");- details.className = "session-thinking";- details.open = true;- details.appendChild(node("summary", "", "Thinking"));- details.appendChild(content);- message.appendChild(details);- } else {- message.appendChild(content);- }- });- return message;- }-- function renderCompaction() {- const details = document.createElement("details");- details.className = "chat-compaction";- details.appendChild(node("summary", "", "Earlier conversation compacted"));- const summary = node("div", "session-markdown");- summary.innerHTML = state.compaction.summary_html;- details.appendChild(summary);- return details;- }-- async function loadOlder() {- const scroller = document.getElementById("chatTranscript");- if (!scroller || !state.nextBefore || !state.session) return;- const sessionId = state.session.id;- const revision = state.session.revision;- const before = state.nextBefore;- const routeVersion = state.routeVersion;- if (- state.olderLoad?.sessionId === sessionId &&- state.olderLoad.before === before- )- return;- const request = { sessionId, before };- state.olderLoad = request;- const button = scroller.querySelector(".session-older");- if (button) button.disabled = true;- const oldHeight = scroller.scrollHeight;- const isCurrent = () =>- routeVersion === state.routeVersion &&- state.session?.id === sessionId &&- state.session.revision === revision &&- state.nextBefore === before &&- document.getElementById("chatTranscript") === scroller;- try {- const page = await state.api(- `/admin/api/chat/sessions/${sessionId}/turns?before=${before}&limit=50`,- );- if (!isCurrent()) return;- state.turns = [...page.turns, ...state.turns];- state.nextBefore = page.next_before;- state.compaction = page.compaction;- renderTranscript();- scroller.scrollTop += scroller.scrollHeight - oldHeight;- } catch (error) {- if (isCurrent()) setNotice(error.message, "error");- } finally {- if (state.olderLoad === request) {- state.olderLoad = null;- if (button?.isConnected) button.disabled = false;- }- }- }-- async function updateSession(changes) {- if (!state.session || !mutationsReady()) return;- if (state.operation && (changes.model || changes.reasoning)) return;- const sessionId = state.session.id;- const expectedRevision = state.session.revision;- const routeVersion = state.routeVersion;- try {- const session = await state.api(`/admin/api/chat/sessions/${sessionId}`, {- method: "PATCH",- body: JSON.stringify({- expected_revision: expectedRevision,- ...changes,- }),- });- if (- routeVersion !== state.routeVersion ||- state.session?.id !== sessionId ||- state.session.revision !== expectedRevision ||- state.deletedSessions.has(sessionId)- )- return;- state.session = session;- state.sessionRevisions.set(session.id, session.revision);- renderSessionPreservingScroll();- scheduleEstimate(true);- } catch (error) {- if (- routeVersion !== state.routeVersion ||- state.session?.id !== sessionId- )- return;- await reloadSession();- setNotice(error.message, "error");- }- }-- async function deleteSession() {- if (!state.session || !mutationsReady()) return;- if (!window.confirm(`Permanently delete “${state.session.title}”?`)) return;- const sessionId = state.session.id;- try {- await state.api(`/admin/api/chat/sessions/${sessionId}`, {- method: "DELETE",- body: JSON.stringify({ expected_revision: state.session.revision }),- });- goLibrary();- } catch (error) {- setNotice(error.message, "error");- }- }-- function goLibrary() {- detachVisibleOperation();- window.history.pushState({}, "", "/admin/chat");- route(window.location.pathname);- }-- function editSystemPrompt() {- if (!mutationsReady()) return;- const current = state.bootstrap.preferences?.system_prompt || "";- const dialog = document.createElement("dialog");- dialog.className = "chat-prompt-dialog";- const form = document.createElement("form");- form.method = "dialog";- form.append(- node("h3", "", "System prompt"),- node(- "p",- "session-muted",- "Shared by every Chat Session and applied on the next turn.",- ),- );- const textarea = node("textarea");- textarea.value = current;- textarea.rows = 12;- textarea.setAttribute("aria-label", "System prompt");- form.appendChild(textarea);- const actions = node("div", "chat-dialog-actions");- const reset = button("Reset to default", "secondary-button", async () => {- try {- const preferences = await state.api(- "/admin/api/chat/preferences/system-prompt",- { method: "DELETE" },- );- state.bootstrap.preferences = preferences;- dialog.close();- scheduleEstimate(true);- } catch (error) {- setNotice(error.message, "error");- }- });- const cancel = button("Cancel", "secondary-button", () => dialog.close());- const save = button("Save", "primary-button", async () => {- try {- const preferences = await state.api(- "/admin/api/chat/preferences/system-prompt",- { method: "PUT", body: JSON.stringify({ value: textarea.value }) },- );- state.bootstrap.preferences = preferences;- dialog.close();- scheduleEstimate(true);- } catch (error) {- setNotice(error.message, "error");- }- });- actions.append(reset, cancel, save);- form.appendChild(actions);- dialog.appendChild(form);- dialog.addEventListener("close", () => dialog.remove());- document.body.appendChild(dialog);- dialog.showModal();- textarea.focus();- }-- function invalidateEstimate() {- window.clearTimeout(state.estimateTimer);- state.estimateTimer = null;- state.estimateVersion += 1;- }-- function scheduleEstimate(immediate = false) {- invalidateEstimate();- const version = state.estimateVersion;- state.estimateTimer = window.setTimeout(- () => updateEstimate(version),- immediate ? 0 : 250,- );- }-- async function updateEstimate(version) {- const session = state.session;- if (!session || state.operation || version !== state.estimateVersion)- return;- const textarea = document.getElementById("chatComposer");- const revision = session.revision;- const draft = textarea?.value || "";- try {- const context = await state.api(- `/admin/api/chat/sessions/${session.id}/estimate`,- {- method: "POST",- body: JSON.stringify({ draft }),- },- );- if (- state.session?.id !== session.id ||- state.session.revision !== revision ||- state.draft !== draft ||- state.operation ||- version !== state.estimateVersion- )- return;- state.context = context;- state.contextError = "";- updateContextMeter();- refreshComposerState();- } catch (error) {- if (- state.session?.id !== session.id ||- state.session.revision !== revision ||- state.draft !== draft ||- state.operation ||- version !== state.estimateVersion- )- return;- state.context = null;- state.contextError = error.message;- updateContextMeter();- refreshComposerState();- setNotice(error.message, "error");- }- }-- function modelOption(modelRef) {- return (state.bootstrap.models || []).find(- (option) => option.model_ref === modelRef,- );- }-- function sendBlockReason() {- if (!state.session) return "Chat unavailable";- if (!mutationsReady()) return "Reconnecting…";- if (state.operation) return "A chat operation is already running";- const latest = state.turns[state.turns.length - 1];- if (latest?.generation?.status === "running") return "This chat is running";- const option = modelOption(state.session.model);- if (!option) return "Choose an available model";- if (- option.supports_reasoning === false &&- state.session.reasoning !== "off"- ) {- return "This model requires Thinking Off";- }- if (state.contextError) return state.contextError;- if (- state.context?.usable_input_tokens !== null &&- state.context?.estimated_input_tokens >- state.context?.usable_input_tokens &&- !state.context?.can_compact- ) {- return "This message exceeds the model context";- }- return "";- }-- function refreshComposerState() {- const textarea = document.getElementById("chatComposer");- const send = document.getElementById("chatSend");- const stop = document.getElementById("chatStop");- const compact = document.getElementById("chatCompact");- const status = document.getElementById("chatComposerStatus");- if (!textarea || !send || !stop || !status) return;- resizeComposer(textarea);- const blocked = sendBlockReason();- const latest = state.turns[state.turns.length - 1];- const busy = Boolean(- state.operation || latest?.generation?.status === "running",- );- send.disabled = Boolean(blocked) || !textarea.value.trim();- send.hidden = Boolean(state.operation);- stop.hidden = !state.operation;- textarea.disabled = Boolean(state.operation && !state.operation.accepted);- status.textContent =- state.operation?.action === "compact"- ? state.operation.status- : state.operation- ? ""- : blocked;- root()- .querySelectorAll(- ".session-controls button, .session-controls input, .session-controls select",- )- .forEach((control) => {- control.disabled = busy || !mutationsReady();- });- root()- .querySelectorAll(".session-header-row .danger-button, .session-title")- .forEach((control) => {- control.disabled = !mutationsReady();- });- if (compact) {- compact.disabled = busy || !state.context?.can_compact;- }- }-- async function sendMessage() {- const textarea = document.getElementById("chatComposer");- const text = textarea?.value || "";- if (!text.trim() || !state.session) return;- await runOperation("send", { text });- }-- async function retryMessage() {- await runOperation("retry", {});- }-- async function regenerateMessage() {- await runOperation("regenerate", {});- }-- async function compactSession() {- await runOperation("compact", {});- }-- async function runOperation(action, extra) {- if (!state.session || state.operation || !mutationsReady()) return;- invalidateEstimate();- const activeElementId = document.activeElement?.id;- const operation = createOperation({- id: crypto.randomUUID(),- sessionId: state.session.id,- action,- phase: action === "compact" ? "compacting" : "generating",- userText: extra.text || "",- returnFocusToComposer:- action === "send" &&- (activeElementId === "chatComposer" || activeElementId === "chatSend"),- commandPending: true,- });- if (action === "send") {- state.draftOperationId = operation.id;- state.draftSubmittedText = operation.userText;- saveDraft();- }- state.pendingCommands.set(operation.sessionId, operation);- state.operation = operation;- renderSessionPreservingScroll();- try {- const acknowledgement = await state.api(- `/admin/api/chat/sessions/${operation.sessionId}/${action}`,- {- method: "POST",- body: JSON.stringify({- expected_revision: state.session.revision,- operation_id: operation.id,- ...extra,- }),- },- );- if (- acknowledgement.session_id !== operation.sessionId ||- acknowledgement.operation_id !== operation.id ||- acknowledgement.kind !== action- ) {- throw new Error(- "The server returned an invalid operation acknowledgement.",- );- }- operation.commandPending = false;- operation.serverObserved = true;- } catch (error) {- operation.commandPending = false;- const active = state.activeOperations.get(operation.sessionId);- const pending = state.pendingCommands.get(operation.sessionId);- if (- active?.id === operation.id ||- (pending !== operation && operation.serverObserved)- )- return;- if (error.status) {- rejectCommand(operation, error.message);- return;- }- operation.ambiguousError = error.message;- reconcileAmbiguousCommand(operation);- }- }-- function commitPendingDeltas(operation) {- const updates = [];- operation.segments.forEach((segment, ordinal) => {- if (!segment?.pending.length) return;- const delta = segment.pending.join("");- segment.pending.length = 0;- segment.text += delta;- updates.push({ ordinal, delta });- });- return updates;- }-- function cancelOperationRender(operation) {- if (operation.renderFrame === null) return;- window.cancelAnimationFrame(operation.renderFrame);- operation.renderFrame = null;- }-- function scheduleLiveRender(operation) {- if (operation.renderFrame !== null) return;- operation.renderFrame = window.requestAnimationFrame(() => {- operation.renderFrame = null;- if (state.operation !== operation) return;- const scroller = document.getElementById("chatTranscript");- const shouldFollow = scroller ? nearBottom(scroller) : true;- commitPendingDeltas(operation).forEach(({ ordinal, delta }) => {- const content = scroller?.querySelector(- `[data-live-segment="${ordinal}"]`,- );- const text = content?.firstChild;- if (text?.nodeType === Node.TEXT_NODE) {- text.appendData(delta);- } else if (content) {- content.textContent = operation.segments[ordinal].text;- }- });- if (shouldFollow) scrollLatest(false);- });- }-- function renderOperationStructure(operation) {- cancelOperationRender(operation);- commitPendingDeltas(operation);- const scroller = document.getElementById("chatTranscript");- const shouldFollow = scroller ? nearBottom(scroller) : true;- renderTranscript();- refreshComposerState();- if (shouldFollow) scrollLatest(false);- }-- async function stopOperation() {- const operation = state.operation;- if (!operation) return;- operation.status = "Stopping…";- renderOperationStructure(operation);- try {- const result = await state.api(- `/admin/api/chat/sessions/${operation.sessionId}/stop`,- {- method: "POST",- body: JSON.stringify({ operation_id: operation.id }),- },- );- if (!result.stopped) restartEventFeed();- } catch (error) {- setNotice(error.message, "error");- }- }-- async function reloadSession() {- const id = state.session?.id;- if (!id) return;- const selection = captureComposerSelection();- try {- const detail = await state.api(`/admin/api/chat/sessions/${id}`);- if (state.session?.id !== id) return;- const titleEdit = captureTitleEdit();- if (!applyDetail(detail)) return;- renderSessionPreservingScroll(titleEdit);- restoreComposerSelection(selection);- } catch (error) {- if (error.status === 404 && state.session?.id === id) {- detachVisibleOperation();- window.history.replaceState({}, "", "/admin/chat");- await route(window.location.pathname);- return;- }- setNotice(error.message, "error");- }- }-- function scrollLatest(smooth) {- const scroller = document.getElementById("chatTranscript");- if (!scroller) return;- scroller.scrollTo({- top: scroller.scrollHeight,- behavior: smooth ? "smooth" : "auto",- });- }-- function relativeTime(timestamp) {- const elapsed = Math.max(0, Date.now() - timestamp);- if (elapsed < 60_000) return "just now";- if (elapsed < 3_600_000) return `${Math.floor(elapsed / 60_000)}m ago`;- if (elapsed < 86_400_000) return `${Math.floor(elapsed / 3_600_000)}h ago`;- return new Date(timestamp).toLocaleDateString();- }-- function formatCount(value) {- return new Intl.NumberFormat(undefined, {- notation: "compact",- maximumFractionDigits: 1,- }).format(value);- }-- function capitalize(value) {- return value ? value[0].toUpperCase() + value.slice(1) : value;- }-- window.ChatSessions = { initialize, activate, refresh };-- window.addEventListener("offline", () => {- if (!state.initialized) return;- state.feedSyncVersion += 1;- state.feedStatus = "reconnecting";- refreshFeedState();- });-- window.addEventListener("online", () => {- if (state.initialized && state.feedStatus !== "live") restartEventFeed();- });-- document.addEventListener("pointerdown", (event) => {- state.modelComboboxes.forEach((combobox) => {- if (combobox.isOpen && !combobox.element.contains(event.target)) {- combobox.close();- }- });- });-})();diff --git a/src/free_claude_code/api/admin_static/index.html b/src/free_claude_code/api/admin_static/index.htmlindex ced5e042..8407ca30 100644--- a/src/free_claude_code/api/admin_static/index.html+++ b/src/free_claude_code/api/admin_static/index.html@@ -6,7 +6,6 @@<title>Free Claude Code Admin</title><link rel="icon" href="data:," /><link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/admin.css" />- <link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/chat_sessions.css" /><link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/code_sessions.css" /><link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/session_layout.css" /></head>@@ -83,9 +82,6 @@></div></section>- <section id="view-chat" class="admin-view" data-view="chat" hidden>- <div id="chatRoot" class="chat-root session-root" aria-live="off"></div>- </section><section id="view-code" class="admin-view" data-view="code" hidden><div id="codeRoot" class="code-root session-root" aria-live="off"></div></section>@@ -105,7 +101,6 @@</div><script src="/admin/assets/__FCC_VERSION__/model_combobox.js"></script><script src="/admin/assets/__FCC_VERSION__/session_ui.js"></script>- <script src="/admin/assets/__FCC_VERSION__/chat_sessions.js"></script><script src="/admin/assets/__FCC_VERSION__/code_sessions.js"></script><script src="/admin/assets/__FCC_VERSION__/admin.js"></script></body>diff --git a/src/free_claude_code/api/admin_static/session_layout.css b/src/free_claude_code/api/admin_static/session_layout.cssindex 2e196390..e07e3551 100644--- a/src/free_claude_code/api/admin_static/session_layout.css+++ b/src/free_claude_code/api/admin_static/session_layout.css@@ -164,17 +164,11 @@white-space: nowrap;}-.session-card span,-.session-muted {+.session-card span {color: var(--muted);font-size: 12px;}-.session-card .session-status {- color: var(--accent);- font-weight: 700;-}-.session-load-more {margin-top: 18px;}@@ -274,10 +268,6 @@height: 38px;}-.session-controls > button {- align-self: end;-}-.session-notice {grid-area: notice;margin-top: 12px;@@ -289,12 +279,6 @@font-size: 13px;}-.session-notice.error {- border-color: var(--error-border);- background: var(--error-bg);- color: var(--error);-}-.session-transcript {grid-area: transcript;min-height: 0;@@ -399,12 +383,6 @@color: var(--error);}-.session-message-actions {- display: flex;- gap: 8px;- margin-top: 12px;-}-.session-composer {grid-area: composer;margin: 8px 0 0;@@ -459,15 +437,6 @@text-align: center;}-.session-empty h3,-.session-empty p {- margin: 0;-}--.session-transcript-empty {- min-height: 100%;-}-.danger-button {min-height: 38px;border: 1px solid var(--error-border);diff --git a/src/free_claude_code/api/admin_static/session_ui.js b/src/free_claude_code/api/admin_static/session_ui.jsindex 3f6effdd..d9440974 100644--- a/src/free_claude_code/api/admin_static/session_ui.js+++ b/src/free_claude_code/api/admin_static/session_ui.js@@ -188,32 +188,7 @@scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight < 80);}- function captureSelection(input) {- if (!input || document.activeElement !== input) return null;- return {- start: input.selectionStart,- end: input.selectionEnd,- direction: input.selectionDirection,- };- }- function restoreSelection(input, selection) {- if (!input || input.disabled || !selection) return;- input.focus({ preventScroll: true });- input.setSelectionRange(- Math.min(selection.start, input.value.length),- Math.min(selection.end, input.value.length),- selection.direction,- );- }- function focusIsUnclaimed() {- const active = document.activeElement;- return (- !active || active === document.body || active === document.documentElement- );- }window.SessionUI = {- node,- button,libraryHeader,search,card,@@ -226,8 +201,5 @@thinking,resizeComposer,nearBottom,- captureSelection,- restoreSelection,- focusIsUnclaimed,};})();diff --git a/src/free_claude_code/api/app.py b/src/free_claude_code/api/app.pyindex a61c9cb8..60552bfb 100644--- a/src/free_claude_code/api/app.py+++ b/src/free_claude_code/api/app.py@@ -6,13 +6,6 @@ from fastapi.exceptions import RequestValidationErrorfrom fastapi.responses import JSONResponsefrom loguru import logger-from free_claude_code.application.chat import (- ChatConflictError,- ChatError,- ChatNotFoundError,- ChatUnavailableError,- ChatValidationError,-)from free_claude_code.application.code_sessions import (CodeConflictError,CodeError,@@ -35,7 +28,6 @@ from free_claude_code.core.version import package_versionfrom .admin_cache import AdminNoStoreMiddleware, attach_admin_no_storefrom .admin_routes import router as admin_router-from .chat_routes import router as chat_routerfrom .code_sessions_routes import router as code_routerfrom .ports import ApiServicesfrom .request_errors import ordinary_application_error_response@@ -58,31 +50,9 @@ def create_app(services: ApiServices) -> FastAPI:app.add_middleware(RequestCorrelationMiddleware)app.include_router(admin_router)- app.include_router(chat_router)app.include_router(code_router)app.include_router(router)- @app.exception_handler(ChatError)- async def chat_error_handler(request: Request, exc: ChatError):- """Serialize Chat application failures for the local Admin client."""-- if isinstance(exc, ChatNotFoundError):- status_code = 404- elif isinstance(exc, ChatConflictError):- status_code = 409- elif isinstance(exc, ChatValidationError):- status_code = 400- elif isinstance(exc, ChatUnavailableError):- status_code = 503- else:- status_code = 500- response = JSONResponse(- status_code=status_code,- content={"detail": str(exc), "code": type(exc).__name__},- )- attach_admin_no_store(response, path=request.url.path)- return response-@app.exception_handler(CodeError)async def code_error_handler(request: Request, exc: CodeError):if isinstance(exc, CodeNotFoundError):diff --git a/src/free_claude_code/api/chat_routes.py b/src/free_claude_code/api/chat_routes.pydeleted file mode 100644index d6e3cde8..00000000--- a/src/free_claude_code/api/chat_routes.py+++ /dev/null@@ -1,548 +0,0 @@-"""Loopback-only HTTP adapter for local Chat Sessions."""--import base64-import uuid-from collections.abc import AsyncIterator--from fastapi import APIRouter, Depends, Query, Request-from fastapi.sse import EventSourceResponse, ServerSentEvent-from pydantic import BaseModel, Field--from free_claude_code.application.chat import (- ChatActiveOperation,- ChatApplicationPort,- ChatCompaction,- ChatContextEstimate,- ChatModelOption,- ChatOperationAcknowledgement,- ChatPreferences,- ChatReasoning,- ChatSession,- ChatSessionSummary,- ChatTurn,- ChatUnavailableError,- ChatValidationError,-)-from free_claude_code.application.session_events import (- EventOverflowError,- PublishedEvent,-)-from free_claude_code.core.json_types import JsonObject--from .admin_routes import admin_page_response-from .admin_security import require_loopback_admin-from .dependencies import get_services-from .markdown import render_markdown-from .ports import ApiServices--router = APIRouter()---class ChatSessionUpdatePayload(BaseModel):- expected_revision: int = Field(gt=0)- title: str | None = None- model: str | None = None- reasoning: ChatReasoning | None = None---class ChatRevisionPayload(BaseModel):- expected_revision: int = Field(gt=0)---class ChatOperationPayload(ChatRevisionPayload):- operation_id: str---class ChatSendPayload(ChatOperationPayload):- text: str = Field(max_length=1_000_000)---class ChatEstimatePayload(BaseModel):- draft: str = Field(default="", max_length=1_000_000)---class ChatStopPayload(BaseModel):- operation_id: str---class ChatPromptPayload(BaseModel):- value: str = Field(max_length=100_000)--[email protected]("/admin/chat", include_in_schema=False)[email protected]("/admin/chat/{session_id}", include_in_schema=False)-def chat_page(request: Request, session_id: str | None = None):- del session_id- require_loopback_admin(request)- return admin_page_response()--[email protected]("/admin/api/chat/bootstrap")-async def chat_bootstrap(- request: Request,- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- chat = _chat(services)- available, message = chat.availability()- payload: JsonObject = {- "available": available,- "message": message,- "models": [_model_payload(option) for option in chat.models()],- "preferences": None,- }- if available:- payload["preferences"] = _preferences_payload(await chat.preferences())- return payload--[email protected]("/admin/api/chat/events", response_class=EventSourceResponse)-async def chat_events(- request: Request,- services: ApiServices = Depends(get_services),-) -> AsyncIterator[ServerSentEvent]:- require_loopback_admin(request)- subscription, active_operations = await _chat(services).subscribe()- try:- yield ServerSentEvent(- event="feed.ready",- id=str(subscription.cursor),- retry=1_000,- data={- "cursor": subscription.cursor,- "active_operations": [- _active_operation_payload(active) for active in active_operations- ],- },- )- try:- async for event in subscription:- yield _sse_event(event)- except EventOverflowError as exc:- yield ServerSentEvent(- event="feed.resync_required",- id=str(exc.cursor),- data={"cursor": exc.cursor},- )- finally:- await subscription.aclose()--[email protected]("/admin/api/chat/sessions")-async def list_chat_sessions(- request: Request,- query: str = Query(default="", max_length=200),- cursor: str | None = None,- limit: int = Query(default=25, ge=1, le=25),- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- page = await _chat(services).list_sessions(- query=query,- cursor=_decode_cursor(cursor),- limit=limit,- )- return {- "sessions": [_session_summary_payload(session) for session in page.sessions],- "next_cursor": _encode_cursor(page.next_cursor),- }--[email protected]("/admin/api/chat/sessions", status_code=201)-async def create_chat_session(- request: Request,- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- return _session_payload(await _chat(services).create_session())--[email protected]("/admin/api/chat/sessions/{session_id}")-async def get_chat_session(- session_id: str,- request: Request,- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- detail = await _chat(services).get_detail(session_id)- return {- "session": _session_payload(detail.session),- "turns": [_turn_payload(turn) for turn in detail.turns],- "next_before": detail.next_before,- "compaction": _compaction_payload(detail.compaction),- "context": (- _estimate_payload(detail.context) if detail.context is not None else None- ),- "context_error": detail.context_error,- }--[email protected]("/admin/api/chat/sessions/{session_id}")-async def update_chat_session(- session_id: str,- payload: ChatSessionUpdatePayload,- request: Request,- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- if payload.title is None and payload.model is None and payload.reasoning is None:- raise ChatValidationError("Choose a chat field to update.")- session = await _chat(services).update_session(- session_id,- expected_revision=payload.expected_revision,- title=payload.title,- model=payload.model,- reasoning=payload.reasoning,- )- return _session_payload(session)--[email protected]("/admin/api/chat/sessions/{session_id}")-async def delete_chat_session(- session_id: str,- payload: ChatRevisionPayload,- request: Request,- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- await _chat(services).delete_session(- session_id,- expected_revision=payload.expected_revision,- )- return {"deleted": True}--[email protected]("/admin/api/chat/sessions/{session_id}/turns")-async def get_chat_turns(- session_id: str,- request: Request,- before: int | None = Query(default=None, ge=1),- limit: int = Query(default=50, ge=1, le=50),- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- turns, next_before, compaction = await _chat(services).get_turn_page(- session_id,- before_sequence=before,- limit=limit,- )- return {- "turns": [_turn_payload(turn) for turn in turns],- "next_before": next_before,- "compaction": _compaction_payload(compaction),- }--[email protected]("/admin/api/chat/sessions/{session_id}/estimate")-async def estimate_chat_context(- session_id: str,- payload: ChatEstimatePayload,- request: Request,- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- estimate = await _chat(services).estimate(session_id, draft=payload.draft)- return _estimate_payload(estimate)--[email protected]("/admin/api/chat/sessions/{session_id}/send", status_code=202)-async def send_chat_message(- session_id: str,- payload: ChatSendPayload,- request: Request,- services: ApiServices = Depends(get_services),-):- require_loopback_admin(request)- acknowledgement = await _chat(services).send(- session_id,- expected_revision=payload.expected_revision,- operation_id=payload.operation_id,- text=payload.text,- )- return _operation_acknowledgement_payload(acknowledgement)--[email protected]("/admin/api/chat/sessions/{session_id}/retry", status_code=202)-async def retry_chat_message(- session_id: str,- payload: ChatOperationPayload,- request: Request,- services: ApiServices = Depends(get_services),-):- require_loopback_admin(request)- acknowledgement = await _chat(services).retry(- session_id,- expected_revision=payload.expected_revision,- operation_id=payload.operation_id,- )- return _operation_acknowledgement_payload(acknowledgement)--[email protected]("/admin/api/chat/sessions/{session_id}/regenerate", status_code=202)-async def regenerate_chat_message(- session_id: str,- payload: ChatOperationPayload,- request: Request,- services: ApiServices = Depends(get_services),-):- require_loopback_admin(request)- acknowledgement = await _chat(services).regenerate(- session_id,- expected_revision=payload.expected_revision,- operation_id=payload.operation_id,- )- return _operation_acknowledgement_payload(acknowledgement)--[email protected]("/admin/api/chat/sessions/{session_id}/compact", status_code=202)-async def compact_chat_session(- session_id: str,- payload: ChatOperationPayload,- request: Request,- services: ApiServices = Depends(get_services),-):- require_loopback_admin(request)- acknowledgement = await _chat(services).compact(- session_id,- expected_revision=payload.expected_revision,- operation_id=payload.operation_id,- )- return _operation_acknowledgement_payload(acknowledgement)--[email protected]("/admin/api/chat/sessions/{session_id}/stop")-async def stop_chat_operation(- session_id: str,- payload: ChatStopPayload,- request: Request,- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- stopped = await _chat(services).stop(- session_id,- operation_id=payload.operation_id,- )- return {"stopped": stopped}--[email protected]("/admin/api/chat/preferences")-async def get_chat_preferences(- request: Request,- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- return _preferences_payload(await _chat(services).preferences())--[email protected]("/admin/api/chat/preferences/system-prompt")-async def save_chat_system_prompt(- payload: ChatPromptPayload,- request: Request,- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- return _preferences_payload(await _chat(services).save_system_prompt(payload.value))--[email protected]("/admin/api/chat/preferences/system-prompt")-async def reset_chat_system_prompt(- request: Request,- services: ApiServices = Depends(get_services),-) -> JsonObject:- require_loopback_admin(request)- return _preferences_payload(await _chat(services).reset_system_prompt())---def _chat(services: ApiServices) -> ChatApplicationPort:- if services.chat is None:- raise ChatUnavailableError("Chat Sessions is unavailable.")- return services.chat---def _sse_event(event: PublishedEvent) -> ServerSentEvent:- return ServerSentEvent(- event=event.event,- id=str(event.id),- data=event.data,- )---def _operation_acknowledgement_payload(- acknowledgement: ChatOperationAcknowledgement,-) -> JsonObject:- return {- "session_id": acknowledgement.session_id,- "operation_id": acknowledgement.operation_id,- "kind": acknowledgement.kind.value,- }---def _encode_cursor(cursor: tuple[int, str] | None) -> str | None:- if cursor is None:- return None- raw = f"{cursor[0]}:{cursor[1]}".encode()- return base64.urlsafe_b64encode(raw).decode().rstrip("=")---def _decode_cursor(cursor: str | None) -> tuple[int, str] | None:- if cursor is None:- return None- try:- padded = cursor + "=" * (-len(cursor) % 4)- raw = base64.b64decode(padded, altchars=b"-_", validate=True).decode()- updated_at_text, separator, session_id = raw.partition(":")- updated_at = int(updated_at_text)- except (ValueError, UnicodeError) as exc:- raise ChatValidationError("Invalid session cursor.") from exc- if not separator or updated_at < 0 or not _is_canonical_uuid(session_id):- raise ChatValidationError("Invalid session cursor.")- return updated_at, session_id---def _is_canonical_uuid(value: str) -> bool:- try:- parsed = uuid.UUID(value)- except ValueError, AttributeError:- return False- return parsed.version == 4 and str(parsed) == value.lower()---def _preferences_payload(preferences: ChatPreferences) -> JsonObject:- return {- "system_prompt": preferences.system_prompt,- "last_model": preferences.last_model,- "last_reasoning": preferences.last_reasoning.value,- "updated_at": preferences.updated_at,- }---def _model_payload(option: ChatModelOption) -> JsonObject:- return {- "model_ref": option.model_ref,- "provider_id": option.provider_id,- "model_id": option.model_id,- "supports_reasoning": option.supports_reasoning,- "input_modalities": (- sorted(modality.value for modality in option.input_modalities)- if option.input_modalities is not None- else None- ),- "context_window_tokens": option.context_window_tokens,- "max_output_tokens": option.max_output_tokens,- }---def _session_payload(session: ChatSession) -> JsonObject:- return {- "id": session.id,- "title": session.title,- "model": session.model,- "reasoning": session.reasoning.value,- "revision": session.revision,- "created_at": session.created_at,- "updated_at": session.updated_at,- }---def _session_summary_payload(session: ChatSessionSummary) -> JsonObject:- return {- **_session_payload(- ChatSession(- id=session.id,- title=session.title,- model=session.model,- reasoning=session.reasoning,- revision=session.revision,- created_at=session.created_at,- updated_at=session.updated_at,- )- ),- "preview": session.preview[:240],- }---def _active_operation_payload(- active: ChatActiveOperation | None,-) -> JsonObject | None:- if active is None:- return None- return {- "session_id": active.session_id,- "operation_id": active.operation_id,- "kind": active.kind.value,- "phase": active.phase.value,- "operation_sequence": active.operation_sequence,- "submitted_text": active.submitted_text,- "turn_id": active.turn_id,- "generation_id": active.generation_id,- "regeneration": active.regeneration,- "actual_model": active.actual_model,- "segments": [- {- "ordinal": segment.ordinal,- "kind": segment.kind.value,- "text": segment.text,- }- for segment in active.segments- ],- }---def _turn_payload(turn: ChatTurn) -> JsonObject:- generation = turn.generation- return {- "id": turn.id,- "session_id": turn.session_id,- "operation_id": turn.operation_id,- "sequence": turn.sequence,- "user_text": turn.user_text,- "created_at": turn.created_at,- "generation": {- "id": generation.id,- "status": generation.status.value,- "requested_model": generation.requested_model,- "actual_model": generation.actual_model,- "reasoning": generation.reasoning.value,- "effective_output_limit": generation.effective_output_limit,- "stop_reason": generation.stop_reason,- "error_code": generation.error_code,- "error_message": generation.error_message,- "started_at": generation.started_at,- "finished_at": generation.finished_at,- "segments": [- {- "ordinal": segment.ordinal,- "kind": segment.kind.value,- "text": segment.text,- "html": render_markdown(segment.text),- }- for segment in generation.segments- ],- },- }---def _compaction_payload(compaction: ChatCompaction | None) -> JsonObject | None:- if compaction is None:- return None- return {- "covered_through_sequence": compaction.covered_through_sequence,- "summary": compaction.summary,- "summary_html": render_markdown(compaction.summary),- "estimated_tokens": compaction.estimated_tokens,- "requested_model": compaction.requested_model,- "actual_model": compaction.actual_model,- "updated_at": compaction.updated_at,- }---def _estimate_payload(estimate: ChatContextEstimate) -> JsonObject:- return {- "estimated_input_tokens": estimate.estimated_input_tokens,- "completion_tokens": estimate.completion_tokens,- "context_window_tokens": estimate.context_window_tokens,- "usable_input_tokens": estimate.usable_input_tokens,- "usage_ratio": estimate.usage_ratio,- "should_auto_compact": estimate.should_auto_compact,- "can_compact": estimate.can_compact,- }diff --git a/src/free_claude_code/api/ports.py b/src/free_claude_code/api/ports.pyindex a0b89c4a..053eba79 100644--- a/src/free_claude_code/api/ports.py+++ b/src/free_claude_code/api/ports.py@@ -4,7 +4,6 @@ from collections.abc import Mappingfrom dataclasses import dataclassfrom typing import Protocol-from free_claude_code.application.chat import ChatApplicationPortfrom free_claude_code.application.code_sessions import CodeApplicationPortfrom free_claude_code.application.connected_accounts import (ConnectedAccountLoginMode,@@ -59,5 +58,4 @@ class ApiServices:requests: RequestRuntimePortadmin: AdminRuntimePorttasks: TaskController- chat: ChatApplicationPort | None = Nonecode: CodeApplicationPort | None = Nonediff --git a/src/free_claude_code/application/chat/__init__.py b/src/free_claude_code/application/chat/__init__.pydeleted file mode 100644index 26f94c66..00000000--- a/src/free_claude_code/application/chat/__init__.py+++ /dev/null@@ -1,63 +0,0 @@-"""FCC-owned local Chat Sessions capability."""--from .models import (- DEFAULT_CHAT_SYSTEM_PROMPT,- ChatActiveOperation,- ChatCompaction,- ChatConflictError,- ChatContextEstimate,- ChatError,- ChatGeneration,- ChatModelOption,- ChatNotFoundError,- ChatOperationAcknowledgement,- ChatOperationKind,- ChatOperationPhase,- ChatPreferences,- ChatReasoning,- ChatSegment,- ChatSession,- ChatSessionDetail,- ChatSessionPage,- ChatSessionSummary,- ChatTranscript,- ChatTurn,- ChatUnavailableError,- ChatValidationError,- GenerationStatus,- SegmentKind,-)-from .ports import ChatApplicationPort, ChatEventSubscriptionPort, ChatStorePort-from .service import ChatService--__all__ = [- "DEFAULT_CHAT_SYSTEM_PROMPT",- "ChatActiveOperation",- "ChatApplicationPort",- "ChatCompaction",- "ChatConflictError",- "ChatContextEstimate",- "ChatError",- "ChatEventSubscriptionPort",- "ChatGeneration",- "ChatModelOption",- "ChatNotFoundError",- "ChatOperationAcknowledgement",- "ChatOperationKind",- "ChatOperationPhase",- "ChatPreferences",- "ChatReasoning",- "ChatSegment",- "ChatService",- "ChatSession",- "ChatSessionDetail",- "ChatSessionPage",- "ChatSessionSummary",- "ChatStorePort",- "ChatTranscript",- "ChatTurn",- "ChatUnavailableError",- "ChatValidationError",- "GenerationStatus",- "SegmentKind",-]diff --git a/src/free_claude_code/application/chat/context.py b/src/free_claude_code/application/chat/context.pydeleted file mode 100644index 5d34730e..00000000--- a/src/free_claude_code/application/chat/context.py+++ /dev/null@@ -1,384 +0,0 @@-"""Portable request construction and context accounting for Chat Sessions."""--from dataclasses import dataclass--from free_claude_code.application.model_metadata import ProviderModelInfo-from free_claude_code.application.ports import RequestRuntimePort-from free_claude_code.application.routing import ModelRouter, RoutedMessagesRequest-from free_claude_code.config.model_refs import (- configured_chat_model_refs,- split_provider_model_ref,-)-from free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic import (- ContentBlockText,- ContentBlockThinking,- Message,- MessagesRequest,- get_token_count,-)-from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy--from .models import (- ChatContextEstimate,- ChatModelOption,- ChatReasoning,- ChatTranscript,- ChatTurn,- ChatValidationError,- SegmentKind,-)--_VISIBLE_ANSWER_TOKENS = 16_384-_MINIMUM_VISIBLE_ANSWER_TOKENS = 1_024-_MINIMUM_INPUT_TOKENS = 1_024-_AUTO_COMPACT_RATIO = 0.85-_COMPACT_TARGET_RATIO = 0.60-_SUMMARY_SYSTEM_PROMPT = """Summarize the earlier conversation for another assistant.-Preserve user facts and preferences, decisions, requirements, unresolved work,-important explanations, and source titles or URLs. Preserve the meaning of any-described documents or images. Do not include hidden reasoning, chain-of-thought,-provider errors, or conversational filler. Be concise, factual, and structured.-"""---@dataclass(frozen=True, slots=True)-class PreparedChatRequest:- routed: RoutedMessagesRequest- estimate: ChatContextEstimate- model: ChatModelOption---class ChatContextBuilder:- """Build exactly one provider-portable request from durable Chat state."""-- def __init__(- self,- runtime: RequestRuntimePort,- *,- settings: Settings | None = None,- model_infos: tuple[ProviderModelInfo, ...] | None = None,- ) -> None:- self._runtime = runtime- self._settings = settings- self._model_infos = model_infos-- def _current_settings(self) -> Settings:- return self._settings or self._runtime.current_settings()-- def models(self) -> tuple[ChatModelOption, ...]:- """Return configured and discovered direct models with rich metadata."""-- settings = self._current_settings()- snapshot = self._model_infos- discovered = (- self._runtime.cached_prefixed_model_infos()- if snapshot is None- else snapshot- )- snapshot_by_ref = (- {info.model_id: info for info in snapshot} if snapshot is not None else None- )- options: dict[str, ChatModelOption] = {}- for ref in configured_chat_model_refs(settings):- info = (- self._runtime.cached_model_info(ref.provider_id, ref.model_id)- if snapshot_by_ref is None- else snapshot_by_ref.get(ref.model_ref)- )- options[ref.model_ref] = ChatModelOption(- model_ref=ref.model_ref,- provider_id=ref.provider_id,- model_id=ref.model_id,- supports_reasoning=(- info.supports_thinking if info is not None else None- ),- input_modalities=(info.input_modalities if info is not None else None),- context_window_tokens=(- info.context_window_tokens if info is not None else None- ),- max_output_tokens=(- info.max_output_tokens if info is not None else None- ),- )-- for info in discovered:- try:- provider_id, model_id = split_provider_model_ref(info.model_id)- except ValueError:- continue- options[info.model_id] = ChatModelOption(- model_ref=info.model_id,- provider_id=provider_id,- model_id=model_id,- supports_reasoning=info.supports_thinking,- input_modalities=info.input_modalities,- context_window_tokens=info.context_window_tokens,- max_output_tokens=info.max_output_tokens,- )- return tuple(- sorted(options.values(), key=lambda item: item.model_ref.casefold())- )-- def model(self, model_ref: str) -> ChatModelOption:- option = next(- (- candidate- for candidate in self.models()- if candidate.model_ref == model_ref- ),- None,- )- if option is None:- raise ChatValidationError(- "The selected model is unavailable. Choose an available model."- )- return option-- def prepare(- self,- transcript: ChatTranscript,- *,- system_prompt: str,- draft: str | None = None,- exclude_generation_id: str | None = None,- ) -> PreparedChatRequest:- option = self.model(transcript.session.model)- reasoning = transcript.session.reasoning.policy()- self._validate_reasoning(option, transcript.session.reasoning)- output_limit = self._completion_limit(option, reasoning)- request = MessagesRequest(- model=transcript.session.model,- max_tokens=output_limit,- messages=self._messages(- transcript,- draft=draft,- exclude_generation_id=exclude_generation_id,- ),- system=system_prompt or None,- stream=True,- )- estimate = self._estimate(- request,- option=option,- output_limit=output_limit,- can_compact=self.can_compact(transcript),- )- routed = ModelRouter(- self._current_settings()- ).resolve_messages_request_with_policy(request, reasoning=reasoning)- return PreparedChatRequest(routed=routed, estimate=estimate, model=option)-- def prepare_summary(- self,- *,- model_ref: str,- source: str,- output_tokens: int,- ) -> RoutedMessagesRequest:- option = self.model(model_ref)- reasoning = (- ReasoningPolicy.off()- if option.supports_reasoning is False- else ReasoningPolicy.on(effort=ReasoningEffort.LOW)- )- reasoning_tokens = reasoning.numeric_budget_tokens or 0- total_output = output_tokens + reasoning_tokens- if option.max_output_tokens is not None and option.max_output_tokens > 0:- total_output = min(total_output, option.max_output_tokens)- if total_output <= reasoning_tokens:- raise ChatValidationError(- "The selected model cannot reserve enough output for compaction."- )- request = MessagesRequest(- model=model_ref,- max_tokens=total_output,- messages=[Message(role="user", content=source)],- system=_SUMMARY_SYSTEM_PROMPT,- stream=True,- )- return ModelRouter(- self._current_settings()- ).resolve_messages_request_with_policy(- request,- reasoning=reasoning,- )-- def summary_output_tokens(self, option: ChatModelOption) -> int:- if option.context_window_tokens is None:- return 4_096- return max(1_024, min(8_192, option.context_window_tokens // 20))-- def summary_source_fits(- self,- *,- model_ref: str,- source: str,- output_tokens: int,- ) -> bool:- option = self.model(model_ref)- if option.context_window_tokens is None:- return True- routed = self.prepare_summary(- model_ref=model_ref,- source=source,- output_tokens=output_tokens,- )- estimated = get_token_count(- routed.request.messages,- routed.request.system,- routed.request.tools,- )- return (- estimated + (routed.request.max_tokens or 0) <= option.context_window_tokens- )-- @staticmethod- def can_compact(transcript: ChatTranscript) -> bool:- covered = (- transcript.compaction.covered_through_sequence- if transcript.compaction is not None- else 0- )- return sum(turn.sequence > covered for turn in transcript.turns) > 1-- @staticmethod- def compaction_source(- existing_summary: str | None,- turns: tuple[ChatTurn, ...],- ) -> str:- sections: list[str] = []- if existing_summary:- sections.append(f"CURRENT SUMMARY\n{existing_summary}")- for turn in turns:- answer = "\n".join(- segment.text- for segment in turn.generation.segments- if segment.kind is SegmentKind.TEXT and segment.text- )- section = f"USER\n{turn.user_text}"- if answer:- section = f"{section}\n\nASSISTANT\n{answer}"- sections.append(section)- return "\n\n--- EXCHANGE ---\n\n".join(sections)-- @staticmethod- def _messages(- transcript: ChatTranscript,- *,- draft: str | None,- exclude_generation_id: str | None,- ) -> list[Message]:- messages: list[Message] = []- covered = 0- if transcript.compaction is not None:- covered = transcript.compaction.covered_through_sequence- messages.append(- Message(- role="user",- content=(- "[Earlier conversation summary]\n"- f"{transcript.compaction.summary}\n"- "[End earlier conversation summary]"- ),- )- )-- for turn in transcript.turns:- if turn.sequence <= covered:- continue- messages.append(Message(role="user", content=turn.user_text))- generation = turn.generation- if generation.id == exclude_generation_id:- continue- blocks: list[ContentBlockText | ContentBlockThinking] = []- for segment in generation.segments:- if not segment.text:- continue- if segment.kind is SegmentKind.THINKING:- blocks.append(- ContentBlockThinking(- type="thinking",- thinking=segment.text,- signature=None,- )- )- else:- blocks.append(ContentBlockText(type="text", text=segment.text))- if blocks:- messages.append(Message(role="assistant", content=blocks))-- if draft is not None:- messages.append(Message(role="user", content=draft))- return messages-- @staticmethod- def _completion_limit(option: ChatModelOption, reasoning: ReasoningPolicy) -> int:- reasoning_tokens = reasoning.numeric_budget_tokens or 0- desired = _VISIBLE_ANSWER_TOKENS + reasoning_tokens- if option.max_output_tokens is not None and option.max_output_tokens > 0:- desired = min(desired, option.max_output_tokens)- if (- option.context_window_tokens is not None- and option.context_window_tokens > 0- ):- desired = min(- desired,- option.context_window_tokens - _MINIMUM_INPUT_TOKENS,- )- if desired - reasoning_tokens < _MINIMUM_VISIBLE_ANSWER_TOKENS:- raise ChatValidationError(- "The selected model cannot fit this thinking level. Lower thinking."- )- return desired-- @staticmethod- def _validate_reasoning(option: ChatModelOption, reasoning: ChatReasoning) -> None:- if option.supports_reasoning is False and reasoning is not ChatReasoning.OFF:- raise ChatValidationError(- "This model does not support reasoning. Set thinking to Off."- )-- @staticmethod- def _estimate(- request: MessagesRequest,- *,- option: ChatModelOption,- output_limit: int,- can_compact: bool,- ) -> ChatContextEstimate:- input_tokens = get_token_count(request.messages, request.system, request.tools)- context_window = option.context_window_tokens- if context_window is None or context_window <= 0:- return ChatContextEstimate(- estimated_input_tokens=input_tokens,- completion_tokens=output_limit,- context_window_tokens=None,- usable_input_tokens=None,- usage_ratio=None,- should_auto_compact=False,- can_compact=can_compact,- )- usable = context_window - output_limit- if usable <= 0:- raise ChatValidationError(- "The selected model's output reserve leaves no input context."- )- ratio = input_tokens / context_window- return ChatContextEstimate(- estimated_input_tokens=input_tokens,- completion_tokens=output_limit,- context_window_tokens=context_window,- usable_input_tokens=usable,- usage_ratio=ratio,- should_auto_compact=(- can_compact and (ratio > _AUTO_COMPACT_RATIO or input_tokens > usable)- ),- can_compact=can_compact,- )---def compaction_target_tokens(estimate: ChatContextEstimate) -> int | None:- if estimate.usable_input_tokens is None:- return None- return int(estimate.usable_input_tokens * _COMPACT_TARGET_RATIO)diff --git a/src/free_claude_code/application/chat/models.py b/src/free_claude_code/application/chat/models.pydeleted file mode 100644index 83eb9acb..00000000--- a/src/free_claude_code/application/chat/models.py+++ /dev/null@@ -1,226 +0,0 @@-"""Precise domain values for local Chat Sessions."""--from dataclasses import dataclass-from enum import StrEnum--from free_claude_code.core.model_capabilities import ModelInputModality-from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy--DEFAULT_CHAT_SYSTEM_PROMPT = (- "You are a helpful assistant. Answer accurately and clearly, using Markdown "- "when it improves readability."-)---class ChatReasoning(StrEnum):- """Reasoning controls exposed by the Chat UI."""-- OFF = "off"- LOW = "low"- MEDIUM = "medium"- HIGH = "high"- XHIGH = "xhigh"- MAX = "max"-- def policy(self) -> ReasoningPolicy:- """Return the provider-neutral policy for one Chat selection."""-- if self is ChatReasoning.OFF:- return ReasoningPolicy.off()- return ReasoningPolicy.on(effort=ReasoningEffort(self.value))---class GenerationStatus(StrEnum):- """Durable terminal and in-progress generation states."""-- RUNNING = "running"- COMPLETED = "completed"- STOPPED = "stopped"- INTERRUPTED = "interrupted"- FAILED = "failed"---class SegmentKind(StrEnum):- """Visible assistant segment kinds retained in exact stream order."""-- THINKING = "thinking"- TEXT = "text"---class ChatOperationKind(StrEnum):- """Long-running Chat commands owned by the application."""-- SEND = "send"- RETRY = "retry"- REGENERATE = "regenerate"- COMPACT = "compact"---class ChatOperationPhase(StrEnum):- """Current work phase exposed to Chat observers."""-- GENERATING = "generating"- COMPACTING = "compacting"---@dataclass(frozen=True, slots=True)-class ChatPreferences:- system_prompt: str- last_model: str | None- last_reasoning: ChatReasoning- updated_at: int---@dataclass(frozen=True, slots=True)-class ChatSession:- id: str- title: str- model: str- reasoning: ChatReasoning- revision: int- created_at: int- updated_at: int---@dataclass(frozen=True, slots=True)-class ChatSessionSummary:- id: str- title: str- model: str- reasoning: ChatReasoning- revision: int- preview: str- created_at: int- updated_at: int---@dataclass(frozen=True, slots=True)-class ChatSessionPage:- sessions: tuple[ChatSessionSummary, ...]- next_cursor: tuple[int, str] | None---@dataclass(frozen=True, slots=True)-class ChatSegment:- ordinal: int- kind: SegmentKind- text: str---@dataclass(frozen=True, slots=True)-class ChatGeneration:- id: str- status: GenerationStatus- requested_model: str- actual_model: str | None- reasoning: ChatReasoning- effective_output_limit: int- stop_reason: str | None- error_code: str | None- error_message: str | None- started_at: int- finished_at: int | None- segments: tuple[ChatSegment, ...]---@dataclass(frozen=True, slots=True)-class ChatTurn:- id: str- session_id: str- operation_id: str- sequence: int- user_text: str- created_at: int- generation: ChatGeneration---@dataclass(frozen=True, slots=True)-class ChatCompaction:- session_id: str- covered_through_sequence: int- summary: str- estimated_tokens: int- requested_model: str- actual_model: str- updated_at: int---@dataclass(frozen=True, slots=True)-class ChatTranscript:- session: ChatSession- turns: tuple[ChatTurn, ...]- compaction: ChatCompaction | None---@dataclass(frozen=True, slots=True)-class ChatModelOption:- model_ref: str- provider_id: str- model_id: str- supports_reasoning: bool | None- input_modalities: frozenset[ModelInputModality] | None- context_window_tokens: int | None- max_output_tokens: int | None---@dataclass(frozen=True, slots=True)-class ChatContextEstimate:- estimated_input_tokens: int- completion_tokens: int- context_window_tokens: int | None- usable_input_tokens: int | None- usage_ratio: float | None- should_auto_compact: bool- can_compact: bool---@dataclass(frozen=True, slots=True)-class ChatOperationAcknowledgement:- session_id: str- operation_id: str- kind: ChatOperationKind---@dataclass(frozen=True, slots=True)-class ChatActiveOperation:- session_id: str- operation_id: str- kind: ChatOperationKind- phase: ChatOperationPhase- operation_sequence: int- submitted_text: str | None- turn_id: str | None- generation_id: str | None- regeneration: bool- actual_model: str | None- segments: tuple[ChatSegment, ...]---@dataclass(frozen=True, slots=True)-class ChatSessionDetail:- session: ChatSession- turns: tuple[ChatTurn, ...]- next_before: int | None- compaction: ChatCompaction | None- context: ChatContextEstimate | None- context_error: str | None---class ChatError(Exception):- """Base class for application-owned Chat failures."""---class ChatUnavailableError(ChatError):- """Chat state or lifecycle is unavailable while the proxy remains usable."""---class ChatNotFoundError(ChatError):- """A requested Chat-owned resource does not exist."""---class ChatConflictError(ChatError):- """The requested mutation conflicts with current session state."""---class ChatValidationError(ChatError):- """The requested Chat operation cannot be executed as supplied."""diff --git a/src/free_claude_code/application/chat/ports.py b/src/free_claude_code/application/chat/ports.pydeleted file mode 100644index 65b728f0..00000000--- a/src/free_claude_code/application/chat/ports.py+++ /dev/null@@ -1,270 +0,0 @@-"""Narrow ports owned by the local Chat Sessions application."""--from collections.abc import AsyncIterator-from typing import Protocol--from free_claude_code.application.session_events import PublishedEvent--from .models import (- ChatActiveOperation,- ChatCompaction,- ChatContextEstimate,- ChatGeneration,- ChatModelOption,- ChatOperationAcknowledgement,- ChatPreferences,- ChatReasoning,- ChatSegment,- ChatSession,- ChatSessionDetail,- ChatSessionPage,- ChatSessionSummary,- ChatTranscript,- ChatTurn,- GenerationStatus,-)---class ChatStorePort(Protocol):- """Transactions required by Chat use cases, independent of SQLite."""-- async def start(self) -> None: ...-- async def close(self) -> None: ...-- async def repair_retired_model_selections(- self,- *,- retired_provider_ids: frozenset[str],- default_model: str,- disable_reasoning: bool,- ) -> int: ...-- async def load_preferences(self) -> ChatPreferences: ...-- async def save_system_prompt(self, system_prompt: str) -> ChatPreferences: ...-- async def create_session(- self, *, session_id: str, model: str, reasoning: ChatReasoning- ) -> ChatSession: ...-- async def list_sessions(- self,- *,- query: str,- cursor: tuple[int, str] | None,- limit: int,- ) -> ChatSessionPage: ...-- async def get_session_summary(self, session_id: str) -> ChatSessionSummary: ...-- async def get_session(self, session_id: str) -> ChatSession: ...-- async def update_session(- self,- session_id: str,- *,- expected_revision: int,- title: str | None,- model: str | None,- reasoning: ChatReasoning | None,- ) -> ChatSession: ...-- async def delete_session(- self, session_id: str, *, expected_revision: int- ) -> None: ...-- async def get_transcript(self, session_id: str) -> ChatTranscript: ...-- async def get_turn_page(- self,- session_id: str,- *,- before_sequence: int | None,- limit: int,- ) -> tuple[tuple[ChatTurn, ...], int | None, ChatCompaction | None]: ...-- async def generation_start_committed(- self,- session_id: str,- *,- generation_id: str,- staged: bool,- ) -> bool: ...-- async def begin_send(- self,- session_id: str,- *,- expected_revision: int,- turn_id: str,- generation_id: str,- operation_id: str,- user_text: str,- requested_model: str,- reasoning: ChatReasoning,- effective_output_limit: int,- ) -> ChatTurn: ...-- async def begin_retry(- self,- session_id: str,- *,- expected_revision: int,- requested_model: str,- reasoning: ChatReasoning,- effective_output_limit: int,- ) -> ChatGeneration: ...-- async def begin_regenerate(- self,- session_id: str,- *,- expected_revision: int,- generation_id: str,- requested_model: str,- reasoning: ChatReasoning,- effective_output_limit: int,- ) -> tuple[ChatTurn, ChatGeneration]: ...-- async def set_generation_actual_model(- self, generation_id: str, actual_model: str- ) -> None: ...-- async def replace_generation_segments(- self, generation_id: str, segments: tuple[ChatSegment, ...]- ) -> None: ...-- async def finish_generation(- self,- generation_id: str,- *,- status: GenerationStatus,- stop_reason: str | None,- error_code: str | None,- error_message: str | None,- ) -> ChatSession: ...-- async def discard_generation(self, generation_id: str) -> None: ...-- async def finish_regeneration(- self,- generation_id: str,- *,- status: GenerationStatus,- stop_reason: str | None,- error_code: str | None,- error_message: str | None,- ) -> ChatSession: ...-- async def upsert_compaction(- self,- session_id: str,- *,- covered_through_sequence: int,- summary: str,- estimated_tokens: int,- requested_model: str,- actual_model: str,- ) -> ChatCompaction: ...---class ChatEventSubscriptionPort(Protocol):- """Read-only process-local Chat event subscription."""-- cursor: int-- def __aiter__(self) -> AsyncIterator[PublishedEvent]: ...-- async def aclose(self) -> None: ...---class ChatApplicationPort(Protocol):- """Complete Chat capability consumed by the local HTTP adapter."""-- def availability(self) -> tuple[bool, str | None]: ...-- def models(self) -> tuple[ChatModelOption, ...]: ...-- async def subscribe(- self,- ) -> tuple[ChatEventSubscriptionPort, tuple[ChatActiveOperation, ...]]: ...-- async def preferences(self) -> ChatPreferences: ...-- async def save_system_prompt(self, value: str) -> ChatPreferences: ...-- async def reset_system_prompt(self) -> ChatPreferences: ...-- async def create_session(self) -> ChatSession: ...-- async def list_sessions(- self,- *,- query: str,- cursor: tuple[int, str] | None,- limit: int,- ) -> ChatSessionPage: ...-- async def get_session(self, session_id: str) -> ChatSession: ...-- async def get_detail(self, session_id: str) -> ChatSessionDetail: ...-- async def update_session(- self,- session_id: str,- *,- expected_revision: int,- title: str | None,- model: str | None,- reasoning: ChatReasoning | None,- ) -> ChatSession: ...-- async def delete_session(- self, session_id: str, *, expected_revision: int- ) -> None: ...-- async def get_turn_page(- self,- session_id: str,- *,- before_sequence: int | None,- limit: int,- ) -> tuple[tuple[ChatTurn, ...], int | None, ChatCompaction | None]: ...-- async def estimate(self, session_id: str, *, draft: str) -> ChatContextEstimate: ...-- async def send(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- text: str,- ) -> ChatOperationAcknowledgement: ...-- async def retry(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- ) -> ChatOperationAcknowledgement: ...-- async def regenerate(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- ) -> ChatOperationAcknowledgement: ...-- async def compact(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- ) -> ChatOperationAcknowledgement: ...-- async def stop(self, session_id: str, *, operation_id: str) -> bool: ...diff --git a/src/free_claude_code/application/chat/service.py b/src/free_claude_code/application/chat/service.pydeleted file mode 100644index ed9090db..00000000--- a/src/free_claude_code/application/chat/service.py+++ /dev/null@@ -1,1968 +0,0 @@-"""Application lifecycle and commands for durable local Chat Sessions."""--import asyncio-import sys-import time-import uuid-from collections.abc import Awaitable, Callable-from dataclasses import dataclass, field, replace-from enum import StrEnum--from loguru import logger--from free_claude_code.application.execution import ProviderExecutor-from free_claude_code.application.ports import RequestRuntimeLease, RequestRuntimePort-from free_claude_code.application.routing import ProviderModelTarget-from free_claude_code.application.session_events import EventPublisher-from free_claude_code.config.model_refs import (- RETIRED_PROVIDER_IDS,- is_retired_model_ref,-)-from free_claude_code.core.anthropic import (- ContentBlockText,- MessagesResponse,- aggregate_anthropic_sse_to_message,-)-from free_claude_code.core.anthropic.streaming import AnthropicSSEDecoder-from free_claude_code.core.anthropic.tokens import estimate_text_tokens-from free_claude_code.core.failures import ExecutionFailure, FailureKind-from free_claude_code.core.json_types import JsonObject-from free_claude_code.core.trace import close_stream_input--from .context import (- ChatContextBuilder,- PreparedChatRequest,- compaction_target_tokens,-)-from .models import (- DEFAULT_CHAT_SYSTEM_PROMPT,- ChatActiveOperation,- ChatCompaction,- ChatConflictError,- ChatContextEstimate,- ChatModelOption,- ChatOperationAcknowledgement,- ChatOperationKind,- ChatOperationPhase,- ChatPreferences,- ChatReasoning,- ChatSegment,- ChatSession,- ChatSessionDetail,- ChatSessionPage,- ChatSessionSummary,- ChatTranscript,- ChatTurn,- ChatUnavailableError,- ChatValidationError,- GenerationStatus,- SegmentKind,-)-from .ports import ChatEventSubscriptionPort, ChatStorePort--_PERSIST_INTERVAL_SECONDS = 0.25-_PERSIST_CHARACTER_THRESHOLD = 4_096-_TURN_PAGE_LIMIT = 50-_SESSION_PAGE_LIMIT = 25-_STORAGE_RESTART_MESSAGE = (- "Chat storage became unavailable. Restart FCC to repair Chat Sessions."-)---class _CancellationReason(StrEnum):- STOPPED = "stopped"- INTERRUPTED = "interrupted"- DELETED = "deleted"---class _OperationLifecycle(StrEnum):- RUNNING = "running"- SETTLING = "settling"---@dataclass(frozen=True, slots=True)-class _TerminalEvent:- event: str- data: JsonObject- publish_summary: bool---class _TerminalPersistenceError(ChatUnavailableError):- """A bounded terminal write failed and requires startup repair."""---@dataclass(slots=True)-class _ActiveOperation:- session_id: str- operation_id: str- kind: ChatOperationKind- phase: ChatOperationPhase- submitted_text: str | None = None- work_task: asyncio.Task[None] | None = None- supervisor_task: asyncio.Task[None] | None = None- lifecycle: _OperationLifecycle = _OperationLifecycle.RUNNING- cancellation_reason: _CancellationReason | None = None- turn_id: str | None = None- generation_id: str | None = None- regeneration: bool = False- segments: list[ChatSegment] = field(default_factory=list)- event_sequence: int = 0- actual_model: str | None = None- terminal_event: _TerminalEvent | None = None---class ChatService:- """Single owner of Chat session commands and active provider work."""-- def __init__(self, runtime: RequestRuntimePort, store: ChatStorePort) -> None:- self._runtime = runtime- self._store = store- self._context = ChatContextBuilder(runtime)- self._events = EventPublisher()- self._active: dict[str, _ActiveOperation] = {}- self._deleting: set[str] = set()- self._active_lock = asyncio.Lock()- self._started = False- self._accepting = False- self._unavailable_message: str | None = "Chat Sessions is starting."-- async def start(self) -> None:- if self._started:- if self._accepting:- return- # A prior startup cleanup failed. Release its store before retrying.- retry_cleanup = asyncio.create_task(self._close_startup_store())- cancellation = await _wait_task_despite_cancellation(retry_cleanup)- try:- retry_cleanup.result()- except Exception as exc:- if cancellation is not None:- raise cancellation from exc- raise- if cancellation is not None:- raise cancellation- cancellation: asyncio.CancelledError | None = None- try:- await self._store.start()- self._started = True- default_model = self._runtime.current_settings().model- option = self._context.model(default_model)- repair_task = asyncio.create_task(- self._store.repair_retired_model_selections(- retired_provider_ids=RETIRED_PROVIDER_IDS,- default_model=default_model,- disable_reasoning=option.supports_reasoning is False,- ),- name="fcc-chat-retirement-repair",- )- cancellation = await _wait_task_despite_cancellation(repair_task)- repaired = repair_task.result()- if cancellation is not None:- raise cancellation- if repaired:- logger.info(- "Repaired retired model selections in {} Chat sessions", repaired- )- except BaseException as exc:- if self._started:- try:- cleanup_task = asyncio.create_task(- self._close_startup_store(), name="fcc-chat-start-cleanup"- )- cleanup_cancellation = await _wait_task_despite_cancellation(- cleanup_task- )- cancellation = cancellation or cleanup_cancellation- cleanup_task.result()- except Exception as cleanup_exc:- logger.warning(- "Chat startup cleanup failed: exc_type={}",- type(cleanup_exc).__name__,- )- if not isinstance(exc, Exception):- raise- if cancellation is not None:- raise cancellation from exc- self._unavailable_message = (- str(exc)- if isinstance(exc, ChatUnavailableError)- else "Chat storage could not be opened."- )- logger.warning(- "Chat Sessions unavailable: exc_type={}",- type(exc).__name__,- )- return- self._started = True- self._accepting = True- self._unavailable_message = None-- async def _close_startup_store(self) -> None:- await self._store.close()- self._started = False-- def begin_shutdown(self) -> None:- """Stop new Chat work and finish feeds before HTTP connections drain."""- self._accepting = False- self._unavailable_message = "Chat Sessions is stopping."- self._events.disconnect_subscribers()-- async def close(self) -> None:- self._accepting = False- async with self._active_lock:- active = tuple(self._active.values())- await asyncio.gather(- *(- self._cancel_active(- operation,- reason=_CancellationReason.INTERRUPTED,- wait_if_settling=True,- )- for operation in active- )- )- self._events.close()- await self._store.close()- self._started = False- self._unavailable_message = "Chat Sessions is stopped."-- def availability(self) -> tuple[bool, str | None]:- return self._started and self._accepting, self._unavailable_message-- def models(self) -> tuple[ChatModelOption, ...]:- return self._context.models()-- async def subscribe(- self,- ) -> tuple[ChatEventSubscriptionPort, tuple[ChatActiveOperation, ...]]:- self._require_available()- subscription = self._events.subscribe()- try:- async with self._active_lock:- active = tuple(_active_snapshot(item) for item in self._active.values())- except BaseException:- await subscription.aclose()- raise- return subscription, active-- async def preferences(self) -> ChatPreferences:- self._require_available()- return await self._store.load_preferences()-- async def save_system_prompt(self, value: str) -> ChatPreferences:- self._require_available()- preferences = await self._store.save_system_prompt(value)- self._publish_preferences(preferences)- return preferences-- async def reset_system_prompt(self) -> ChatPreferences:- self._require_available()- preferences = await self._store.save_system_prompt(DEFAULT_CHAT_SYSTEM_PROMPT)- self._publish_preferences(preferences)- return preferences-- async def create_session(self) -> ChatSession:- self._require_available()- preferences = await self._store.load_preferences()- options = self.models()- if not options:- raise ChatUnavailableError(- "No configured models are available for Chat Sessions."- )- available = {option.model_ref: option for option in options}- configured_default = self._runtime.current_settings().model- model = preferences.last_model- if model not in available:- model = (- configured_default- if configured_default in available- else options[0].model_ref- )- reasoning = preferences.last_reasoning- if available[model].supports_reasoning is False:- reasoning = ChatReasoning.OFF- session = await self._store.create_session(- session_id=str(uuid.uuid4()),- model=model,- reasoning=reasoning,- )- await self._publish_session_summary(session.id, event="session.created")- return session-- async def list_sessions(- self,- *,- query: str,- cursor: tuple[int, str] | None,- limit: int,- ) -> ChatSessionPage:- self._require_available()- return await self._store.list_sessions(- query=query,- cursor=cursor,- limit=max(1, min(_SESSION_PAGE_LIMIT, limit)),- )-- async def get_session(self, session_id: str) -> ChatSession:- self._require_available()- return await self._store.get_session(_canonical_uuid(session_id, "session"))-- async def get_detail(self, session_id: str) -> ChatSessionDetail:- self._require_available()- session_id = _canonical_uuid(session_id, "session")- transcript = await self._store.get_transcript(session_id)- prompt = (await self._store.load_preferences()).system_prompt- context: ChatContextEstimate | None- context_error: str | None = None- try:- context = self._context.prepare(- transcript,- system_prompt=prompt,- ).estimate- except ChatValidationError as exc:- context = None- context_error = str(exc)- has_more = len(transcript.turns) > _TURN_PAGE_LIMIT- turns = transcript.turns[-_TURN_PAGE_LIMIT:]- next_before = turns[0].sequence if has_more and turns else None- return ChatSessionDetail(- session=transcript.session,- turns=turns,- next_before=next_before,- compaction=transcript.compaction,- context=context,- context_error=context_error,- )-- async def update_session(- self,- session_id: str,- *,- expected_revision: int,- title: str | None,- model: str | None,- reasoning: ChatReasoning | None,- ) -> ChatSession:- self._require_available()- session_id = _canonical_uuid(session_id, "session")- if title is not None:- title = " ".join(title.split())- if not title:- raise ChatValidationError("Chat title cannot be empty.")- if len(title) > 200:- raise ChatValidationError("Chat title cannot exceed 200 characters.")- if model is not None:- retired = is_retired_model_ref(model)- if retired:- model = self._runtime.current_settings().model- option = self._context.model(model)- if retired and option.supports_reasoning is False:- reasoning = ChatReasoning.OFF- async with self._active_lock:- if session_id in self._deleting:- raise ChatConflictError("This chat is being deleted.")- if (- model is not None or reasoning is not None- ) and session_id in self._active:- raise ChatConflictError(- "Model and thinking cannot change while this chat is running."- )- session = await self._store.update_session(- session_id,- expected_revision=expected_revision,- title=title,- model=model,- reasoning=reasoning,- )- await self._publish_session_summary(session.id)- return session-- async def delete_session(self, session_id: str, *, expected_revision: int) -> None:- self._require_available()- session_id = _canonical_uuid(session_id, "session")- async with self._active_lock:- if session_id in self._deleting:- raise ChatConflictError("This chat is already being deleted.")- self._deleting.add(session_id)- active = self._active.get(session_id)- try:- current = await self._store.get_session(session_id)- _expect_revision(current, expected_revision)-- async def finish_deletion() -> None:- settled = current- if active is not None:- await self._cancel_active(- active,- reason=_CancellationReason.DELETED,- wait_if_settling=True,- )- settled = await self._store.get_session(session_id)- await self._store.delete_session(- session_id,- expected_revision=settled.revision,- )- self._events.publish("session.deleted", {"session_id": session_id})-- deletion_task = asyncio.create_task(- finish_deletion(),- name=f"fcc-chat-delete-{session_id}",- )- _result, cancellation = await _await_task_despite_cancellation(- deletion_task- )- if cancellation is not None:- raise cancellation- finally:- async with self._active_lock:- self._deleting.discard(session_id)-- async def get_turn_page(- self,- session_id: str,- *,- before_sequence: int | None,- limit: int,- ) -> tuple[tuple[ChatTurn, ...], int | None, ChatCompaction | None]:- self._require_available()- if before_sequence is not None and before_sequence <= 0:- raise ChatValidationError("Turn cursor must be positive.")- return await self._store.get_turn_page(- _canonical_uuid(session_id, "session"),- before_sequence=before_sequence,- limit=max(1, min(_TURN_PAGE_LIMIT, limit)),- )-- async def estimate(self, session_id: str, *, draft: str) -> ChatContextEstimate:- self._require_available()- transcript = await self._store.get_transcript(- _canonical_uuid(session_id, "session")- )- prompt = (await self._store.load_preferences()).system_prompt- return self._context.prepare(- transcript,- system_prompt=prompt,- draft=draft,- ).estimate-- async def send(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- text: str,- ) -> ChatOperationAcknowledgement:- self._require_available()- session_id = _canonical_uuid(session_id, "session")- operation_id = _canonical_uuid(operation_id, "operation")- if not text.strip():- raise ChatValidationError("Write a message before sending.")- transcript = await self._store.get_transcript(session_id)- _expect_revision(transcript.session, expected_revision)- prompt = (await self._store.load_preferences()).system_prompt- self._context.prepare(transcript, system_prompt=prompt, draft=text)- return await self._start_operation(- session_id,- operation_id=operation_id,- kind=ChatOperationKind.SEND,- submitted_text=text,- action=lambda active: self._run_send(- active,- expected_revision=expected_revision,- text=text,- ),- )-- async def retry(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- ) -> ChatOperationAcknowledgement:- self._require_available()- session_id = _canonical_uuid(session_id, "session")- operation_id = _canonical_uuid(operation_id, "operation")- transcript = await self._store.get_transcript(session_id)- _expect_revision(transcript.session, expected_revision)- latest = _latest_turn(transcript)- if latest.generation.status not in {- GenerationStatus.STOPPED,- GenerationStatus.INTERRUPTED,- GenerationStatus.FAILED,- }:- raise ChatConflictError("Only the latest unfinished answer can be retried.")- prompt = (await self._store.load_preferences()).system_prompt- self._context.prepare(- transcript,- system_prompt=prompt,- exclude_generation_id=latest.generation.id,- )- return await self._start_operation(- session_id,- operation_id=operation_id,- kind=ChatOperationKind.RETRY,- action=lambda active: self._run_retry(- active,- expected_revision=expected_revision,- ),- )-- async def regenerate(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- ) -> ChatOperationAcknowledgement:- self._require_available()- session_id = _canonical_uuid(session_id, "session")- operation_id = _canonical_uuid(operation_id, "operation")- transcript = await self._store.get_transcript(session_id)- _expect_revision(transcript.session, expected_revision)- latest = _latest_turn(transcript)- if latest.generation.status is not GenerationStatus.COMPLETED:- raise ChatConflictError("Only the latest completed answer can regenerate.")- prompt = (await self._store.load_preferences()).system_prompt- self._context.prepare(- transcript,- system_prompt=prompt,- exclude_generation_id=latest.generation.id,- )- return await self._start_operation(- session_id,- operation_id=operation_id,- kind=ChatOperationKind.REGENERATE,- action=lambda active: self._run_regenerate(- active,- expected_revision=expected_revision,- ),- )-- async def compact(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- ) -> ChatOperationAcknowledgement:- self._require_available()- session_id = _canonical_uuid(session_id, "session")- operation_id = _canonical_uuid(operation_id, "operation")- transcript = await self._store.get_transcript(session_id)- _expect_revision(transcript.session, expected_revision)- if not self._context.can_compact(transcript):- raise ChatValidationError(- "There is not enough older conversation to compact."- )- return await self._start_operation(- session_id,- operation_id=operation_id,- kind=ChatOperationKind.COMPACT,- action=lambda active: self._run_manual_compaction(- active,- expected_revision=expected_revision,- ),- )-- async def stop(self, session_id: str, *, operation_id: str) -> bool:- self._require_available()- session_id = _canonical_uuid(session_id, "session")- operation_id = _canonical_uuid(operation_id, "operation")- async with self._active_lock:- active = self._active.get(session_id)- if active is None:- return False- if active.operation_id != operation_id:- raise ChatConflictError("That operation is no longer active.")- return await self._cancel_active(- active,- reason=_CancellationReason.STOPPED,- wait_if_settling=False,- )-- async def _start_operation(- self,- session_id: str,- *,- operation_id: str,- kind: ChatOperationKind,- submitted_text: str | None = None,- action: Callable[[_ActiveOperation], Awaitable[None]],- ) -> ChatOperationAcknowledgement:- async with self._active_lock:- if not self._accepting:- raise ChatUnavailableError("Chat Sessions is shutting down.")- if session_id in self._deleting:- raise ChatConflictError("This chat is being deleted.")- if session_id in self._active:- raise ChatConflictError("This chat already has an active operation.")- active = _ActiveOperation(- session_id=session_id,- operation_id=operation_id,- kind=kind,- phase=(- ChatOperationPhase.COMPACTING- if kind is ChatOperationKind.COMPACT- else ChatOperationPhase.GENERATING- ),- submitted_text=submitted_text,- )-- async def run_work() -> None:- await action(active)-- self._active[session_id] = active- active.work_task = asyncio.create_task(- run_work(),- name=f"fcc-chat-{kind.value}-{operation_id}-work",- )- active.supervisor_task = asyncio.create_task(- self._run_active(active),- name=f"fcc-chat-{kind.value}-{operation_id}",- )- self._emit(- active,- "operation.started",- {- "kind": kind.value,- "phase": active.phase.value,- "submitted_text": submitted_text,- },- )- return ChatOperationAcknowledgement(- session_id=session_id,- operation_id=operation_id,- kind=kind,- )-- async def _run_active(- self,- active: _ActiveOperation,- ) -> None:- work_task = active.work_task- if work_task is None:- raise RuntimeError("Chat operation work was not initialized.")- try:- await work_task- except asyncio.CancelledError:- await self._claim_settlement(- active,- reason=active.cancellation_reason or _CancellationReason.STOPPED,- )- await self._handle_cancelled(active)- except Exception as exc:- await self._claim_settlement(active)- if active.cancellation_reason is not None:- await self._handle_cancelled(active)- else:- await self._handle_failure(active, exc)- finally:- publish_summary = await self._release_active(active)- if publish_summary:- await self._publish_session_summary(active.session_id)-- async def _run_send(- self,- active: _ActiveOperation,- *,- expected_revision: int,- text: str,- ) -> None:- lease = await self._runtime.acquire(include_model_infos=True)- try:- builder = ChatContextBuilder(- self._runtime,- settings=lease.settings,- model_infos=lease.model_infos,- )- prompt = (await self._store.load_preferences()).system_prompt- transcript = await self._store.get_transcript(active.session_id)- _expect_revision(transcript.session, expected_revision)- prepared = builder.prepare(transcript, system_prompt=prompt, draft=text)- if prepared.estimate.should_auto_compact:- await self._compact_transcript(- active,- builder=builder,- lease=lease,- transcript=transcript,- prompt=prompt,- pending_draft=text,- excluded_generation_id=None,- )- transcript = await self._store.get_transcript(active.session_id)- prepared = builder.prepare(- transcript,- system_prompt=prompt,- draft=text,- )- _require_request_fits(prepared.estimate)- generation_id = str(uuid.uuid4())- turn_id = str(uuid.uuid4())- await _commit_generation_start(- active,- store=self._store,- generation_id=generation_id,- operation=self._store.begin_send(- active.session_id,- expected_revision=transcript.session.revision,- turn_id=turn_id,- generation_id=generation_id,- operation_id=active.operation_id,- user_text=text,- requested_model=transcript.session.model,- reasoning=transcript.session.reasoning,- effective_output_limit=prepared.routed.request.max_tokens or 1,- ),- )- active.turn_id = turn_id- await self._publish_session_summary(active.session_id)- self._emit(- active,- "turn.started",- {- "turn_id": turn_id,- "generation_id": generation_id,- "revision": transcript.session.revision + 1,- },- )- await self._execute_generation_with_context_recovery(- active,- prepared=prepared,- builder=builder,- lease=lease,- prompt=prompt,- excluded_generation_id=generation_id,- )- finally:- await lease.release()-- async def _run_retry(- self,- active: _ActiveOperation,- *,- expected_revision: int,- ) -> None:- lease = await self._runtime.acquire(include_model_infos=True)- try:- builder = ChatContextBuilder(- self._runtime,- settings=lease.settings,- model_infos=lease.model_infos,- )- prompt = (await self._store.load_preferences()).system_prompt- transcript = await self._store.get_transcript(active.session_id)- _expect_revision(transcript.session, expected_revision)- latest = _latest_turn(transcript)- prepared = builder.prepare(- transcript,- system_prompt=prompt,- exclude_generation_id=latest.generation.id,- )- if prepared.estimate.should_auto_compact:- await self._compact_transcript(- active,- builder=builder,- lease=lease,- transcript=transcript,- prompt=prompt,- pending_draft=None,- excluded_generation_id=latest.generation.id,- )- transcript = await self._store.get_transcript(active.session_id)- latest = _latest_turn(transcript)- prepared = builder.prepare(- transcript,- system_prompt=prompt,- exclude_generation_id=latest.generation.id,- )- _require_request_fits(prepared.estimate)- generation_id = latest.generation.id- await _commit_generation_start(- active,- store=self._store,- generation_id=generation_id,- operation=self._store.begin_retry(- active.session_id,- expected_revision=transcript.session.revision,- requested_model=transcript.session.model,- reasoning=transcript.session.reasoning,- effective_output_limit=prepared.routed.request.max_tokens or 1,- ),- )- active.turn_id = latest.id- await self._publish_session_summary(active.session_id)- self._emit(- active,- "turn.started",- {- "turn_id": latest.id,- "generation_id": generation_id,- "revision": transcript.session.revision + 1,- },- )- await self._execute_generation_with_context_recovery(- active,- prepared=prepared,- builder=builder,- lease=lease,- prompt=prompt,- excluded_generation_id=generation_id,- )- finally:- await lease.release()-- async def _run_regenerate(- self,- active: _ActiveOperation,- *,- expected_revision: int,- ) -> None:- lease = await self._runtime.acquire(include_model_infos=True)- try:- builder = ChatContextBuilder(- self._runtime,- settings=lease.settings,- model_infos=lease.model_infos,- )- prompt = (await self._store.load_preferences()).system_prompt- transcript = await self._store.get_transcript(active.session_id)- _expect_revision(transcript.session, expected_revision)- latest = _latest_turn(transcript)- prepared = builder.prepare(- transcript,- system_prompt=prompt,- exclude_generation_id=latest.generation.id,- )- if prepared.estimate.should_auto_compact:- await self._compact_transcript(- active,- builder=builder,- lease=lease,- transcript=transcript,- prompt=prompt,- pending_draft=None,- excluded_generation_id=latest.generation.id,- )- transcript = await self._store.get_transcript(active.session_id)- latest = _latest_turn(transcript)- prepared = builder.prepare(- transcript,- system_prompt=prompt,- exclude_generation_id=latest.generation.id,- )- _require_request_fits(prepared.estimate)- generation_id = str(uuid.uuid4())- await _commit_generation_start(- active,- store=self._store,- generation_id=generation_id,- regeneration=True,- operation=self._store.begin_regenerate(- active.session_id,- expected_revision=transcript.session.revision,- generation_id=generation_id,- requested_model=transcript.session.model,- reasoning=transcript.session.reasoning,- effective_output_limit=prepared.routed.request.max_tokens or 1,- ),- )- active.turn_id = latest.id- await self._publish_session_summary(active.session_id)- self._emit(- active,- "turn.started",- {- "turn_id": latest.id,- "generation_id": generation_id,- "revision": transcript.session.revision + 1,- "regeneration": True,- },- )- await self._execute_generation_with_context_recovery(- active,- prepared=prepared,- builder=builder,- lease=lease,- prompt=prompt,- excluded_generation_id=latest.generation.id,- )- finally:- await lease.release()-- async def _run_manual_compaction(- self,- active: _ActiveOperation,- *,- expected_revision: int,- ) -> None:- lease = await self._runtime.acquire(include_model_infos=True)- try:- builder = ChatContextBuilder(- self._runtime,- settings=lease.settings,- model_infos=lease.model_infos,- )- transcript = await self._store.get_transcript(active.session_id)- _expect_revision(transcript.session, expected_revision)- prompt = (await self._store.load_preferences()).system_prompt- await self._compact_transcript(- active,- builder=builder,- lease=lease,- transcript=transcript,- prompt=prompt,- pending_draft=None,- excluded_generation_id=None,- )- finally:- await lease.release()-- async def _execute_generation(- self,- active: _ActiveOperation,- *,- prepared: PreparedChatRequest,- lease: RequestRuntimeLease,- candidate_failures: list[FailureKind] | None = None,- ) -> None:- generation_id = active.generation_id- if generation_id is None:- raise RuntimeError("Chat generation was not initialized.")- executor = ProviderExecutor(- lease.resolve_provider,- progress_timeout_seconds=lease.settings.provider_progress_timeout,- generation_id=lease.generation_id,- log_raw_payloads=lease.settings.log_raw_api_payloads,- )-- async def selected(target_model: ProviderModelTarget) -> None:- active.actual_model = target_model.provider_model_ref- await self._store.set_generation_actual_model(- generation_id, target_model.provider_model_ref- )-- def failed(failure: ExecutionFailure) -> None:- if candidate_failures is not None:- candidate_failures.append(failure.kind)-- stream = executor.stream_messages(- prepared.routed,- raw_log_payload=prepared.routed.request.model_dump(mode="json"),- request_id=active.operation_id,- candidate_selected=selected,- candidate_failed=failed if candidate_failures is not None else None,- )- decoder = AnthropicSSEDecoder()- block_segments: dict[int, int] = {}- saw_message_stop = False- stop_reason: str | None = None- last_flush = time.monotonic()- pending_characters = 0- try:- async for chunk in stream:- for event in decoder.feed(chunk):- (- delta_characters,- event_stop,- event_reason,- ) = await self._handle_sse_event(- active,- event_name=event.event,- data=event.data,- block_segments=block_segments,- )- pending_characters += delta_characters- saw_message_stop = saw_message_stop or event_stop- stop_reason = event_reason or stop_reason- now = time.monotonic()- if (- pending_characters >= _PERSIST_CHARACTER_THRESHOLD- or now - last_flush >= _PERSIST_INTERVAL_SECONDS- ):- await self._flush_segments(active)- last_flush = now- pending_characters = 0- for event in decoder.finish():- (- delta_characters,- event_stop,- event_reason,- ) = await self._handle_sse_event(- active,- event_name=event.event,- data=event.data,- block_segments=block_segments,- )- pending_characters += delta_characters- saw_message_stop = saw_message_stop or event_stop- stop_reason = event_reason or stop_reason- finally:- await close_stream_input(- stream,- owner="chat_sessions",- source="application",- preserved_error=sys.exception(),- )-- if not saw_message_stop:- raise ChatValidationError("The provider stream ended before completing.")-- if not await self._claim_settlement(active):- raise asyncio.CancelledError-- async def commit_completion() -> ChatSession:- await self._flush_terminal_segments(active)- if active.regeneration:- return await self._finish_regeneration(- generation_id,- status=GenerationStatus.COMPLETED,- stop_reason=stop_reason,- error_code=None,- error_message=None,- )- return await self._finish_generation(- generation_id,- status=GenerationStatus.COMPLETED,- stop_reason=stop_reason,- error_code=None,- error_message=None,- )-- session = await commit_completion()- self._stage_terminal(- active,- "turn.completed",- {- "generation_id": generation_id,- "revision": session.revision,- "actual_model": active.actual_model,- },- publish_summary=True,- )-- async def _execute_generation_with_context_recovery(- self,- active: _ActiveOperation,- *,- prepared: PreparedChatRequest,- builder: ChatContextBuilder,- lease: RequestRuntimeLease,- prompt: str,- excluded_generation_id: str,- ) -> None:- candidate_failures: list[FailureKind] = []- try:- await self._execute_generation(- active,- prepared=prepared,- lease=lease,- candidate_failures=candidate_failures,- )- return- except ExecutionFailure as exc:- if (- exc.kind is not FailureKind.CONTEXT_WINDOW_EXCEEDED- or active.segments- or not candidate_failures- or any(- kind is not FailureKind.CONTEXT_WINDOW_EXCEEDED- for kind in candidate_failures- )- ):- raise- context_failure = exc-- transcript = await self._store.get_transcript(active.session_id)- if not builder.can_compact(transcript):- raise context_failure- await self._compact_transcript(- active,- builder=builder,- lease=lease,- transcript=transcript,- prompt=prompt,- pending_draft=None,- excluded_generation_id=excluded_generation_id,- )- transcript = await self._store.get_transcript(active.session_id)- prepared = builder.prepare(- transcript,- system_prompt=prompt,- exclude_generation_id=excluded_generation_id,- )- _require_request_fits(prepared.estimate)- await self._execute_generation(active, prepared=prepared, lease=lease)-- async def _handle_sse_event(- self,- active: _ActiveOperation,- *,- event_name: str,- data: dict[str, object],- block_segments: dict[int, int],- ) -> tuple[int, bool, str | None]:- payload_type = _optional_string(data.get("type"))- if event_name == "error" or payload_type == "error":- error = data.get("error")- message = "The provider returned an error."- if isinstance(error, dict):- candidate = error.get("message")- if isinstance(candidate, str) and candidate.strip():- message = candidate- raise ExecutionFailure(- kind=FailureKind.UPSTREAM,- status_code=502,- message=message,- retryable=False,- )- if payload_type == "content_block_start":- index = _required_index(data)- block = data.get("content_block")- if not isinstance(block, dict):- raise ChatValidationError(- "The provider emitted a malformed content block."- )- block_type = _optional_string(block.get("type"))- if block_type == "redacted_thinking":- return 0, False, None- if block_type not in {"text", "thinking"}:- raise ChatValidationError(- "The provider emitted an unsupported tool or content block."- )- kind = (- SegmentKind.THINKING if block_type == "thinking" else SegmentKind.TEXT- )- ordinal = len(active.segments)- active.segments.append(ChatSegment(ordinal=ordinal, kind=kind, text=""))- block_segments[index] = ordinal- self._emit(- active,- "segment.started",- {"ordinal": ordinal, "segment_kind": kind.value},- )- eager_key = "thinking" if kind is SegmentKind.THINKING else "text"- eager = _optional_string(block.get(eager_key)) or ""- if eager:- await self._append_delta(active, ordinal, eager)- return len(eager), False, None- if payload_type == "content_block_delta":- index = _required_index(data)- delta = data.get("delta")- if not isinstance(delta, dict):- raise ChatValidationError(- "The provider emitted a malformed content delta."- )- ordinal = block_segments.get(index)- if ordinal is None:- raise ChatValidationError(- "The provider emitted a delta for no open block."- )- delta_type = _optional_string(delta.get("type"))- if delta_type == "signature_delta":- return 0, False, None- key = "thinking" if delta_type == "thinking_delta" else "text"- if delta_type not in {"thinking_delta", "text_delta"}:- raise ChatValidationError(- "The provider emitted an unsupported content delta."- )- text = _optional_string(delta.get(key)) or ""- if text:- await self._append_delta(active, ordinal, text)- return len(text), False, None- if payload_type == "content_block_stop":- index = _required_index(data)- ordinal = block_segments.pop(index, None)- if ordinal is not None:- await self._flush_segments(active)- self._emit(active, "segment.completed", {"ordinal": ordinal})- return 0, False, None- if payload_type == "message_delta":- delta = data.get("delta")- reason = None- if isinstance(delta, dict):- reason = _optional_string(delta.get("stop_reason"))- return 0, False, reason- if payload_type == "message_stop":- return 0, True, None- return 0, False, None-- async def _append_delta(- self, active: _ActiveOperation, ordinal: int, delta: str- ) -> None:- current = active.segments[ordinal]- active.segments[ordinal] = replace(current, text=f"{current.text}{delta}")- self._emit(- active,- "segment.delta",- {- "ordinal": ordinal,- "segment_kind": current.kind.value,- "delta": delta,- },- )-- async def _flush_segments(self, active: _ActiveOperation) -> None:- if active.generation_id is None:- return- await self._store.replace_generation_segments(- active.generation_id,- tuple(active.segments),- )-- async def _compact_transcript(- self,- active: _ActiveOperation,- *,- builder: ChatContextBuilder,- lease: RequestRuntimeLease,- transcript: ChatTranscript,- prompt: str,- pending_draft: str | None,- excluded_generation_id: str | None,- ) -> ChatCompaction:- covered = (- transcript.compaction.covered_through_sequence- if transcript.compaction is not None- else 0- )- remaining = tuple(turn for turn in transcript.turns if turn.sequence > covered)- if len(remaining) <= 1:- raise ChatValidationError(- "There is not enough older conversation to compact."- )- active.phase = ChatOperationPhase.COMPACTING- self._emit(active, "compaction.started", {"phase": active.phase.value})- option = builder.model(transcript.session.model)- output_tokens = builder.summary_output_tokens(option)- retain_count = min(4, len(remaining) - 1)- initial_count = len(remaining) - retain_count- next_turns = remaining[:initial_count]- summary = transcript.compaction.summary if transcript.compaction else None- summary, actual_model = await self._summarize_turns(- active,- builder=builder,- lease=lease,- model_ref=transcript.session.model,- existing_summary=summary,- turns=next_turns,- output_tokens=output_tokens,- )- covered = next_turns[-1].sequence-- while True:- candidate = ChatCompaction(- session_id=transcript.session.id,- covered_through_sequence=covered,- summary=summary,- estimated_tokens=estimate_text_tokens(summary),- requested_model=transcript.session.model,- actual_model=actual_model,- updated_at=0,- )- virtual = replace(transcript, compaction=candidate)- estimate = builder.prepare(- virtual,- system_prompt=prompt,- draft=pending_draft,- exclude_generation_id=excluded_generation_id,- ).estimate- target = compaction_target_tokens(estimate)- if target is None or estimate.estimated_input_tokens <= target:- break- later = tuple(turn for turn in remaining if turn.sequence > covered)- if len(later) <= 1:- raise ChatValidationError(- "The newest exchange cannot fit this model. Shorten the system "- "prompt, lower thinking, or choose a larger-context model."- )- summary, actual_model = await self._summarize_turns(- active,- builder=builder,- lease=lease,- model_ref=transcript.session.model,- existing_summary=summary,- turns=(later[0],),- output_tokens=output_tokens,- )- covered = later[0].sequence-- async def commit_compaction() -> ChatCompaction:- return await self._retry_terminal_persistence(- lambda: self._store.upsert_compaction(- transcript.session.id,- covered_through_sequence=covered,- summary=summary,- estimated_tokens=estimate_text_tokens(summary),- requested_model=transcript.session.model,- actual_model=actual_model,- ),- label=(- f"compaction session_id={transcript.session.id} "- f"covered_through_sequence={covered}"- ),- )-- cancellation: asyncio.CancelledError | None = None- if active.kind is ChatOperationKind.COMPACT:- if not await self._claim_settlement(active):- raise asyncio.CancelledError- compaction = await commit_compaction()- else:- commit_task = asyncio.create_task(- commit_compaction(),- name=f"fcc-chat-compaction-commit-{transcript.session.id}",- )- compaction, cancellation = await _await_task_despite_cancellation(- commit_task- )- completion: JsonObject = {- "covered_through_sequence": covered,- "revision": transcript.session.revision + 1,- }- if active.kind is ChatOperationKind.COMPACT:- self._stage_terminal(- active,- "compaction.completed",- completion,- publish_summary=True,- )- else:- active.phase = ChatOperationPhase.GENERATING- completion["phase"] = active.phase.value- self._emit(active, "compaction.completed", completion)- if cancellation is not None:- raise cancellation- await self._publish_session_summary(active.session_id)- return compaction-- async def _summarize_turns(- self,- active: _ActiveOperation,- *,- builder: ChatContextBuilder,- lease: RequestRuntimeLease,- model_ref: str,- existing_summary: str | None,- turns: tuple[ChatTurn, ...],- output_tokens: int,- ) -> tuple[str, str]:- summary = existing_summary- pending = list(turns)- actual_model = model_ref- while pending:- take = len(pending)- if builder.model(model_ref).context_window_tokens is not None:- take = 0- for candidate_count in range(1, len(pending) + 1):- source = builder.compaction_source(- summary,- tuple(pending[:candidate_count]),- )- if not builder.summary_source_fits(- model_ref=model_ref,- source=source,- output_tokens=output_tokens,- ):- break- take = candidate_count- if take == 0:- take = 1- while True:- source = builder.compaction_source(summary, tuple(pending[:take]))- try:- summary, actual_model = await self._execute_summary(- active,- builder=builder,- lease=lease,- model_ref=model_ref,- source=source,- output_tokens=output_tokens,- )- break- except ExecutionFailure as exc:- if exc.kind is not FailureKind.CONTEXT_WINDOW_EXCEEDED:- raise- if take == 1:- raise ChatValidationError(- "The newest exchange cannot fit this model. Shorten the "- "system prompt, lower thinking, or choose a larger-context "- "model."- ) from exc- take = max(1, take // 2)- del pending[:take]- if summary is None:- raise ChatValidationError("Compaction produced no summary.")- return summary, actual_model-- async def _execute_summary(- self,- active: _ActiveOperation,- *,- builder: ChatContextBuilder,- lease: RequestRuntimeLease,- model_ref: str,- source: str,- output_tokens: int,- ) -> tuple[str, str]:- routed = builder.prepare_summary(- model_ref=model_ref,- source=source,- output_tokens=output_tokens,- )- executor = ProviderExecutor(- lease.resolve_provider,- progress_timeout_seconds=lease.settings.provider_progress_timeout,- generation_id=lease.generation_id,- log_raw_payloads=lease.settings.log_raw_api_payloads,- )- selected_model: str | None = None-- def selected(target_model: ProviderModelTarget) -> None:- nonlocal selected_model- selected_model = target_model.provider_model_ref-- stream = executor.stream_messages(- routed,- raw_log_payload=routed.request.model_dump(mode="json"),- request_id=str(uuid.uuid4()),- candidate_selected=selected,- )- try:- body, error, complete = await aggregate_anthropic_sse_to_message(stream)- finally:- await close_stream_input(- stream,- owner="chat_compaction",- source="application",- preserved_error=sys.exception(),- )- if error is not None:- message = error.get("message")- raise ExecutionFailure(- kind=FailureKind.UPSTREAM,- status_code=502,- message=message if isinstance(message, str) else "Compaction failed.",- retryable=False,- )- if not complete:- raise ChatValidationError("The provider stream ended before completing.")- response = MessagesResponse.model_validate(body)- summary = "\n".join(- block.text- for block in response.content- if isinstance(block, ContentBlockText)- ).strip()- if not summary:- raise ChatValidationError("The model returned an empty compaction summary.")- if selected_model is None:- raise ChatValidationError(- "The provider did not identify the compaction model."- )- self._emit(- active,- "compaction.progress",- {"covered_exchange_count": 1},- )- return summary, selected_model-- async def _handle_cancelled(self, active: _ActiveOperation) -> None:- reason = active.cancellation_reason or _CancellationReason.STOPPED- terminal_data: JsonObject = {"reason": reason.value}- publish_summary = False- if active.generation_id is not None:- try:- if active.regeneration:- await self._discard_regeneration(active.generation_id)- else:- await self._flush_terminal_segments(active)- status = (- GenerationStatus.INTERRUPTED- if reason is _CancellationReason.INTERRUPTED- else GenerationStatus.STOPPED- )- session = await self._finish_generation(- active.generation_id,- status=status,- stop_reason=reason.value,- error_code=None,- error_message=None,- )- terminal_data["revision"] = session.revision- publish_summary = True- except Exception as exc:- if reason is _CancellationReason.INTERRUPTED:- logger.warning(- "Chat shutdown could not persist terminal state: "- "session_id={} operation_id={} exc_type={}",- active.session_id,- active.operation_id,- type(exc).__name__,- )- return- self._disable_after_terminal_write_failure(active, exc)- if reason is _CancellationReason.DELETED:- raise- self._stage_terminal(- active,- "turn.failed",- {- "code": "chat_storage_unavailable",- "message": _STORAGE_RESTART_MESSAGE,- },- )- return- if reason is _CancellationReason.DELETED:- return- event = (- "compaction.stopped"- if active.kind is ChatOperationKind.COMPACT- else "turn.stopped"- )- self._stage_terminal(- active,- event,- terminal_data,- publish_summary=publish_summary,- )-- async def _handle_failure(self, active: _ActiveOperation, exc: Exception) -> None:- if isinstance(exc, _TerminalPersistenceError):- self._disable_after_terminal_write_failure(active, exc)- event = (- "compaction.failed"- if active.kind is ChatOperationKind.COMPACT- else (- "turn.failed"- if active.generation_id is not None- else "operation.failed"- )- )- self._stage_terminal(- active,- event,- {- "code": "chat_storage_unavailable",- "message": _STORAGE_RESTART_MESSAGE,- },- )- return- code = "chat_error"- message = "Chat operation failed."- if isinstance(exc, ExecutionFailure):- code = exc.kind.value- message = exc.message- elif isinstance(- exc,- (ChatValidationError, ChatConflictError, ChatUnavailableError),- ):- code = type(exc).__name__- message = str(exc)- else:- logger.warning(- "Chat operation failed: session_id={} operation_id={} exc_type={}",- active.session_id,- active.operation_id,- type(exc).__name__,- )- terminal_data: JsonObject = {"code": code, "message": message}- publish_summary = False- if active.generation_id is not None:- try:- await self._flush_terminal_segments(active)- if active.regeneration:- session = await self._finish_regeneration(- active.generation_id,- status=GenerationStatus.FAILED,- stop_reason=None,- error_code=code,- error_message=message,- )- else:- session = await self._finish_generation(- active.generation_id,- status=GenerationStatus.FAILED,- stop_reason=None,- error_code=code,- error_message=message,- )- terminal_data["revision"] = session.revision- publish_summary = True- except Exception as persistence_exc:- self._disable_after_terminal_write_failure(- active,- persistence_exc,- )- code = "chat_storage_unavailable"- message = _STORAGE_RESTART_MESSAGE- terminal_data = {"code": code, "message": message}- event = (- "compaction.failed"- if active.kind is ChatOperationKind.COMPACT- else "turn.failed"- if active.generation_id is not None- else "operation.failed"- )- self._stage_terminal(- active,- event,- terminal_data,- publish_summary=publish_summary,- )-- async def _flush_terminal_segments(self, active: _ActiveOperation) -> None:- await self._retry_terminal_persistence(- lambda: self._flush_segments(active),- label=(- f"segment flush session_id={active.session_id} "- f"operation_id={active.operation_id}"- ),- )-- async def _finish_generation(- self,- generation_id: str,- *,- status: GenerationStatus,- stop_reason: str | None,- error_code: str | None,- error_message: str | None,- ) -> ChatSession:- return await self._retry_terminal_persistence(- lambda: self._store.finish_generation(- generation_id,- status=status,- stop_reason=stop_reason,- error_code=error_code,- error_message=error_message,- ),- label=f"generation_id={generation_id} status={status.value}",- )-- async def _finish_regeneration(- self,- generation_id: str,- *,- status: GenerationStatus,- stop_reason: str | None,- error_code: str | None,- error_message: str | None,- ) -> ChatSession:- return await self._retry_terminal_persistence(- lambda: self._store.finish_regeneration(- generation_id,- status=status,- stop_reason=stop_reason,- error_code=error_code,- error_message=error_message,- ),- label=f"regeneration_id={generation_id} status={status.value}",- )-- async def _discard_regeneration(self, generation_id: str) -> None:- await self._retry_terminal_persistence(- lambda: self._store.discard_generation(generation_id),- label=f"regeneration_id={generation_id} status=discarded",- )-- @staticmethod- async def _retry_terminal_persistence[T](- operation: Callable[[], Awaitable[T]],- *,- label: str,- ) -> T:- try:- return await operation()- except ChatUnavailableError:- logger.warning(- "Retrying transient Chat terminal persistence failure: {}",- label,- )- try:- return await operation()- except ChatUnavailableError as exc:- raise _TerminalPersistenceError(_STORAGE_RESTART_MESSAGE) from exc-- def _disable_after_terminal_write_failure(- self,- active: _ActiveOperation,- exc: Exception,- ) -> None:- self._accepting = False- self._unavailable_message = _STORAGE_RESTART_MESSAGE- logger.error(- "Chat Sessions disabled after terminal persistence failure: "- "session_id={} operation_id={} exc_type={}",- active.session_id,- active.operation_id,- type(exc).__name__,- )-- def _emit(self, active: _ActiveOperation, event: str, data: JsonObject) -> None:- active.event_sequence += 1- payload: JsonObject = {- "session_id": active.session_id,- "operation_id": active.operation_id,- "kind": active.kind.value,- "operation_sequence": active.event_sequence,- **data,- }- self._events.publish(event, payload)-- def _stage_terminal(- self,- active: _ActiveOperation,- event: str,- data: JsonObject,- *,- publish_summary: bool = False,- ) -> None:- if active.terminal_event is not None:- return- active.terminal_event = _TerminalEvent(- event=event,- data={**data},- publish_summary=publish_summary,- )-- async def _claim_settlement(- self,- active: _ActiveOperation,- *,- reason: _CancellationReason | None = None,- ) -> bool:- async with self._active_lock:- if self._active.get(active.session_id) is not active:- return False- if active.lifecycle is _OperationLifecycle.SETTLING:- return False- active.lifecycle = _OperationLifecycle.SETTLING- active.cancellation_reason = reason- return True-- async def _cancel_active(- self,- active: _ActiveOperation,- *,- reason: _CancellationReason,- wait_if_settling: bool,- ) -> bool:- async with self._active_lock:- if self._active.get(active.session_id) is not active:- return False- accepted = False- if active.lifecycle is _OperationLifecycle.RUNNING:- active.lifecycle = _OperationLifecycle.SETTLING- active.cancellation_reason = reason- accepted = True- work_task = active.work_task- if work_task is not None and not work_task.done():- work_task.cancel()- elif (- reason is _CancellationReason.STOPPED- and active.cancellation_reason is _CancellationReason.STOPPED- ):- accepted = True- supervisor_task = active.supervisor_task- if supervisor_task is not None and (accepted or wait_if_settling):- cancellation = await _wait_task_despite_cancellation(supervisor_task)- supervisor_task.result()- if cancellation is not None:- raise cancellation- return accepted-- async def _release_active(self, active: _ActiveOperation) -> bool:- publish_summary = False- async with self._active_lock:- if self._active.get(active.session_id) is not active:- return False- self._active.pop(active.session_id, None)- terminal = active.terminal_event- if terminal is not None:- self._emit(active, terminal.event, terminal.data)- publish_summary = terminal.publish_summary- return publish_summary-- def _require_available(self) -> None:- if not self._started or not self._accepting:- raise ChatUnavailableError(- self._unavailable_message or "Chat Sessions is unavailable."- )-- def _publish_preferences(self, preferences: ChatPreferences) -> None:- self._events.publish(- "preferences.updated",- {- "system_prompt": preferences.system_prompt,- "last_model": preferences.last_model,- "last_reasoning": preferences.last_reasoning.value,- "updated_at": preferences.updated_at,- },- )-- async def _publish_session_summary(- self,- session_id: str,- *,- event: str = "session.updated",- ) -> None:- try:- summary = await self._store.get_session_summary(session_id)- self._events.publish(event, _session_summary_event_data(summary))- except Exception as exc:- logger.warning(- "Could not publish Chat session summary: session_id={} exc_type={}",- session_id,- type(exc).__name__,- )- return---async def _commit_generation_start(- active: _ActiveOperation,- *,- store: ChatStorePort,- generation_id: str,- operation: Awaitable[object],- regeneration: bool = False,-) -> None:- """Publish durable generation ownership before restoring cancellation."""-- async def run() -> None:- await operation-- task = asyncio.create_task(- run(),- name=f"fcc-chat-generation-start-{generation_id}",- )- cancellation = await _wait_task_despite_cancellation(task)- try:- task.result()- except ChatUnavailableError:-- async def reconcile() -> bool:- return await store.generation_start_committed(- active.session_id,- generation_id=generation_id,- staged=regeneration,- )-- reconciliation_task = asyncio.create_task(- reconcile(),- name=f"fcc-chat-generation-reconcile-{generation_id}",- )- try:- (- committed,- reconciliation_cancellation,- ) = await _await_task_despite_cancellation(reconciliation_task)- except ChatUnavailableError as exc:- raise _TerminalPersistenceError(_STORAGE_RESTART_MESSAGE) from exc- cancellation = cancellation or reconciliation_cancellation- if not committed:- raise- active.generation_id = generation_id- active.regeneration = regeneration- if cancellation is not None:- raise cancellation---async def _wait_task_despite_cancellation[T](- task: asyncio.Task[T],-) -> asyncio.CancelledError | None:- """Wait for a child outcome while retaining cancellation for its caller."""-- current = asyncio.current_task()- cancellation: asyncio.CancelledError | None = None- while not task.done():- try:- await asyncio.shield(task)- except asyncio.CancelledError as exc:- if current is not None and current.cancelling():- cancellation = cancellation or exc- except Exception:- break- return cancellation---async def _await_task_despite_cancellation[T](- task: asyncio.Task[T],-) -> tuple[T, asyncio.CancelledError | None]:- """Wait for an already-started task before restoring caller cancellation."""-- cancellation = await _wait_task_despite_cancellation(task)- result = task.result()- return result, cancellation---def _latest_turn(transcript: ChatTranscript) -> ChatTurn:- if not transcript.turns:- raise ChatConflictError("This chat has no answer to operate on.")- return transcript.turns[-1]---def _expect_revision(session: ChatSession, expected: int) -> None:- if expected <= 0 or session.revision != expected:- raise ChatConflictError("This chat changed in another tab. Refresh it.")---def _require_request_fits(estimate: ChatContextEstimate) -> None:- if (- estimate.usable_input_tokens is not None- and estimate.estimated_input_tokens > estimate.usable_input_tokens- ):- raise ChatValidationError(- "This turn cannot fit the selected model. Shorten the message or system "- "prompt, lower thinking, or choose a larger-context model."- )---def _canonical_uuid(value: str, label: str) -> str:- try:- parsed = uuid.UUID(value)- except (ValueError, AttributeError) as exc:- raise ChatValidationError(f"Invalid {label} ID.") from exc- if parsed.version != 4 or str(parsed) != value.lower():- raise ChatValidationError(f"Invalid {label} ID.")- return str(parsed)---def _required_index(data: dict[str, object]) -> int:- value = data.get("index")- if not isinstance(value, int) or isinstance(value, bool) or value < 0:- raise ChatValidationError("The provider emitted an invalid content index.")- return value---def _optional_string(value: object) -> str | None:- return value if isinstance(value, str) else None---def _active_snapshot(active: _ActiveOperation) -> ChatActiveOperation:- return ChatActiveOperation(- session_id=active.session_id,- operation_id=active.operation_id,- kind=active.kind,- phase=active.phase,- operation_sequence=active.event_sequence,- submitted_text=active.submitted_text,- turn_id=active.turn_id,- generation_id=active.generation_id,- regeneration=active.regeneration,- actual_model=active.actual_model,- segments=tuple(active.segments),- )---def _session_summary_event_data(session: ChatSessionSummary) -> JsonObject:- return {- "session_id": session.id,- "title": session.title,- "model": session.model,- "reasoning": session.reasoning.value,- "revision": session.revision,- "preview": session.preview[:240],- "created_at": session.created_at,- "updated_at": session.updated_at,- }diff --git a/src/free_claude_code/application/execution.py b/src/free_claude_code/application/execution.pyindex 93ad02d7..4ea33bd2 100644--- a/src/free_claude_code/application/execution.py+++ b/src/free_claude_code/application/execution.py@@ -1,10 +1,9 @@"""Provider execution shared by inbound API adapters."""import asyncio-import inspectimport mathimport sys-from collections.abc import AsyncIterator, Awaitable, Callable, Mapping+from collections.abc import AsyncIterator, Callable, Mappingfrom types import MappingProxyTypefrom typing import Literal@@ -45,8 +44,6 @@ TokenCounter = Callable[ResponsesTokenCounter = Callable[[OpenAIResponsesRequest], int]WireApi = Literal["messages", "responses"]CandidateStreamOpener = Callable[[int, ProviderModelTarget], AsyncIterator[str]]-CandidateSelected = Callable[[ProviderModelTarget], Awaitable[None] | None]-CandidateFailed = Callable[[ExecutionFailure], None]class ProviderExecutor:@@ -169,8 +166,6 @@ class ProviderExecutor:*,raw_log_payload: object,request_id: str,- candidate_selected: CandidateSelected | None = None,- candidate_failed: CandidateFailed | None = None,) -> AsyncIterator[str]:"""Preflight and execute one Anthropic Messages request."""@@ -238,8 +233,6 @@ class ProviderExecutor:ingress_count=len(routed.request.messages),request_id=request_id,open_candidate=open_candidate,- candidate_selected=candidate_selected,- candidate_failed=candidate_failed,)def stream_responses(@@ -315,8 +308,6 @@ class ProviderExecutor:ingress_count=input_item_count,request_id=request_id,open_candidate=open_candidate,- candidate_selected=None,- candidate_failed=None,)def _stream_candidates(@@ -332,8 +323,6 @@ class ProviderExecutor:ingress_count: int,request_id: str,open_candidate: CandidateStreamOpener,- candidate_selected: CandidateSelected | None,- candidate_failed: CandidateFailed | None,) -> AsyncIterator[str]:"""Run one protocol-blind candidate lifecycle after eager preflight."""@@ -435,10 +424,6 @@ class ProviderExecutor:continueif not candidate_committed:candidate_committed = True- if candidate_selected is not None:- selected_result = candidate_selected(target)- if inspect.isawaitable(selected_result):- await selected_resultif index > 0:self._trace_fallback_selected(request_id=request_id,@@ -473,13 +458,7 @@ class ProviderExecutor:) from excif candidate_failure is None:- if not candidate_committed and candidate_selected is not None:- selected_result = candidate_selected(target)- if inspect.isawaitable(selected_result):- await selected_resultreturn- if candidate_failed is not None:- candidate_failed(candidate_failure)if candidate_committed or index + 1 >= len(candidates):raise candidate_failurenext_target = candidates[index + 1]diff --git a/src/free_claude_code/config/paths.py b/src/free_claude_code/config/paths.pyindex 0b97f168..979a1b9c 100644--- a/src/free_claude_code/config/paths.py+++ b/src/free_claude_code/config/paths.py@@ -16,9 +16,6 @@ OPENAI_AUTH_LOCK_FILENAME = "openai.lock"CONFIG_LOCK_FILENAME = "config.lock"FCC_TEMP_DIRNAME = "tmp"LAUNCHER_TEMP_DIRNAME = "launchers"-CHAT_STATE_DIRNAME = "chat"-CHAT_DATABASE_FILENAME = "chat.db"-CHAT_LOCK_FILENAME = "chat.lock"CODE_STATE_DIRNAME = "code"CODE_DATABASE_FILENAME = "code.db"CODE_LOCK_FILENAME = "code.lock"@@ -48,24 +45,6 @@ def launcher_temp_dir_path() -> Path:return config_dir_path() / FCC_TEMP_DIRNAME / LAUNCHER_TEMP_DIRNAME-def chat_state_dir_path() -> Path:- """Return the managed Chat Sessions state directory."""-- return config_dir_path() / CHAT_STATE_DIRNAME---def chat_database_path() -> Path:- """Return the managed Chat Sessions database path."""-- return chat_state_dir_path() / CHAT_DATABASE_FILENAME---def chat_lock_path() -> Path:- """Return the exclusive Chat Sessions process-lock path."""-- return chat_state_dir_path() / CHAT_LOCK_FILENAME--def code_database_path() -> Path:"""Return the managed Code sessions database path."""return config_dir_path() / CODE_STATE_DIRNAME / CODE_DATABASE_FILENAMEdiff --git a/src/free_claude_code/runtime/application.py b/src/free_claude_code/runtime/application.pyindex 3845b87f..75f666e1 100644--- a/src/free_claude_code/runtime/application.py+++ b/src/free_claude_code/runtime/application.py@@ -9,12 +9,12 @@ import uuidfrom collections.abc import Awaitable, Callable, Mappingfrom dataclasses import replace+from anyio import to_threadfrom loguru import loggerimport free_claude_code.cli.managed as cli_managedimport free_claude_code.messaging.session as messaging_sessionimport free_claude_code.messaging.workflow as messaging_workflow_module-from free_claude_code.application.chat import ChatServicefrom free_claude_code.application.code_sessions import CodeServicefrom free_claude_code.application.connected_accounts import (ConnectedAccountLoginMode,@@ -49,6 +49,7 @@ from free_claude_code.providers.credential_validation import (from .configuration import ConfigurationServicefrom .provider_manager import ProviderRuntimeManager+from .retired_chat import remove_retired_chat_historyRestartCallback = Callable[[], None]@@ -140,14 +141,12 @@ class ApplicationRuntime:*,configuration: ConfigurationService,transcriber: Transcriber | None,- chat_service: ChatService | None = None,code_service: CodeService | None = None,restart_callback: RestartCallback | None = None,connected_accounts: Mapping[str, ConnectedAccountPort] | None = None,) -> None:self.provider_manager = provider_managerself._configuration = configuration- self._chat_service = chat_serviceself._code_service = code_serviceself._transcriber = transcriberself._restart_callback = restart_callback@@ -193,14 +192,15 @@ class ApplicationRuntime:await _await_owned_task(asyncio.create_task(self._configuration.initialize()))+ await _await_owned_task(+ asyncio.create_task(to_thread.run_sync(remove_retired_chat_history))+ )if self._draining:raise ApplicationUnavailableError("Application runtime is shutting down.")await self.provider_manager.warm_referenced_model_cache()self.provider_manager.start_model_list_refresh()- if self._chat_service is not None:- await self._chat_service.start()if self._code_service is not None:await self._code_service.start()await self._start_messaging_if_configured()@@ -226,8 +226,6 @@ class ApplicationRuntime:def begin_shutdown(self) -> None:"""Finish indefinite observer responses before the server drains HTTP."""self._draining = True- if self._chat_service is not None:- self._chat_service.begin_shutdown()if self._code_service is not None:self._code_service.begin_shutdown()@@ -596,12 +594,6 @@ class ApplicationRuntime:log_verbose_errors=verbose,):return False- if self._chat_service is not None and not await best_effort(- "chat_service.close",- self._chat_service.close(),- log_verbose_errors=verbose,- ):- return Falseif not await self._cleanup_transcriber():return Falseif not self._provider_manager_closed:diff --git a/src/free_claude_code/runtime/bootstrap.py b/src/free_claude_code/runtime/bootstrap.pyindex 43b2d8c9..f7612f0b 100644--- a/src/free_claude_code/runtime/bootstrap.py+++ b/src/free_claude_code/runtime/bootstrap.py@@ -6,13 +6,10 @@ from pathlib import Pathfrom free_claude_code.api.app import create_appfrom free_claude_code.api.ports import ApiServices-from free_claude_code.application.chat import ChatServicefrom free_claude_code.application.code_sessions import CodeServicefrom free_claude_code.config.loader import ManagedConfigStorefrom free_claude_code.config.logging_config import configure_loggingfrom free_claude_code.config.paths import (- chat_database_path,- chat_lock_path,code_database_path,code_lock_path,server_log_path,@@ -34,7 +31,6 @@ from free_claude_code.providers.runtime.factory import create_providerfrom .application import ApplicationRuntime, RestartCallbackfrom .asgi import RuntimeASGIApp-from .chat_sqlite import SQLiteChatStorefrom .code_sessions_sqlite import SQLiteCodeStorefrom .codex_app_server import CodexHarnessFactoryfrom .codex_catalog import CodexModelCatalogPublisher@@ -77,10 +73,6 @@ def build_asgi_app(),model_catalog_publisher=CodexModelCatalogPublisher(),)- chat_service = ChatService(- provider_manager,- SQLiteChatStore(chat_database_path(), chat_lock_path()),- )code_service = CodeService(SQLiteCodeStore(code_database_path(), code_lock_path()),CodexHarnessFactory(provider_manager),@@ -88,7 +80,6 @@ def build_asgi_app(runtime = ApplicationRuntime(provider_manager,configuration=ConfigurationService(ManagedConfigStore()),- chat_service=chat_service,code_service=code_service,transcriber=_create_transcriber(settings),restart_callback=restart_callback,@@ -98,7 +89,6 @@ def build_asgi_app(requests=provider_manager,admin=runtime,tasks=runtime,- chat=chat_service,code=code_service,)return RuntimeASGIApp(create_app(services), runtime)diff --git a/src/free_claude_code/runtime/chat_sqlite.py b/src/free_claude_code/runtime/chat_sqlite.pydeleted file mode 100644index 43174e4e..00000000--- a/src/free_claude_code/runtime/chat_sqlite.py+++ /dev/null@@ -1,1257 +0,0 @@-"""SQLite persistence owned exclusively by local Chat Sessions."""--import os-import sqlite3-import time-from collections.abc import Callable-from functools import partial-from pathlib import Path-from typing import TypeVar--import anyio.to_thread--from free_claude_code.application.chat.models import (- DEFAULT_CHAT_SYSTEM_PROMPT,- ChatCompaction,- ChatConflictError,- ChatGeneration,- ChatNotFoundError,- ChatPreferences,- ChatReasoning,- ChatSegment,- ChatSession,- ChatSessionPage,- ChatSessionSummary,- ChatTranscript,- ChatTurn,- ChatUnavailableError,- GenerationStatus,- SegmentKind,-)-from free_claude_code.core.interprocess_lock import InterprocessFileLock--T = TypeVar("T")--_SCHEMA_VERSION = 1-_BUSY_TIMEOUT_MS = 5_000-_NEW_CHAT_TITLE = "New chat"-_SESSION_SUMMARY_SELECT = """- SELECT s.*,- COALESCE((- SELECT t.user_text FROM chat_turns AS t- WHERE t.session_id = s.id- ORDER BY t.sequence DESC LIMIT 1- ), '') AS preview- FROM chat_sessions AS s-"""---class SQLiteChatStore:- """Short per-operation SQLite transactions behind one process lock."""-- def __init__(self, database_path: Path, lock_path: Path) -> None:- self._database_path = database_path- self._lock = InterprocessFileLock(lock_path)- self._started = False-- async def start(self) -> None:- if self._started:- return- directory = self._database_path.parent- await anyio.to_thread.run_sync(- partial(directory.mkdir, parents=True, exist_ok=True)- )- _owner_only(directory, 0o700)- acquired = await anyio.to_thread.run_sync(self._lock.acquire)- if not acquired:- raise ChatUnavailableError(- "Chat Sessions is already open in another FCC server process."- )- try:- await anyio.to_thread.run_sync(self._run_sync, self._migrate_and_repair)- _owner_only(self._database_path, 0o600)- for suffix in ("-wal", "-shm"):- sidecar = Path(f"{self._database_path}{suffix}")- if sidecar.exists():- _owner_only(sidecar, 0o600)- except sqlite3.Error as exc:- self._lock.release()- raise ChatUnavailableError("Chat storage is unavailable.") from exc- except BaseException:- self._lock.release()- raise- self._started = True-- async def close(self) -> None:- self._started = False- await anyio.to_thread.run_sync(self._lock.release)-- async def load_preferences(self) -> ChatPreferences:- return await self._run(self._load_preferences)-- async def repair_retired_model_selections(- self,- *,- retired_provider_ids: frozenset[str],- default_model: str,- disable_reasoning: bool,- ) -> int:- """Repair current selections atomically, preserving historical model facts."""-- def operation(connection: sqlite3.Connection) -> int:- connection.execute("BEGIN IMMEDIATE")- repaired = 0- now = _now_ms()- for provider_id in sorted(retired_provider_ids):- prefix = f"{provider_id}/"- cursor = connection.execute(- """- UPDATE chat_sessions- SET model = ?, reasoning = CASE WHEN ? THEN 'off' ELSE reasoning END,- revision = revision + 1, updated_at = ?- WHERE substr(model, 1, ?) = ? AND length(trim(substr(model, ?))) > 0- """,- (- default_model,- disable_reasoning,- now,- len(prefix),- prefix,- len(prefix) + 1,- ),- )- repaired += cursor.rowcount- connection.execute(- """- UPDATE chat_settings- SET last_model = ?,- last_reasoning = CASE WHEN ? THEN 'off' ELSE last_reasoning END,- updated_at = ?- WHERE substr(last_model, 1, ?) = ?- AND length(trim(substr(last_model, ?))) > 0- """,- (- default_model,- disable_reasoning,- now,- len(prefix),- prefix,- len(prefix) + 1,- ),- )- connection.commit()- return repaired-- return await self._run(operation)-- async def save_system_prompt(self, system_prompt: str) -> ChatPreferences:- def operation(connection: sqlite3.Connection) -> ChatPreferences:- now = _now_ms()- connection.execute("BEGIN IMMEDIATE")- connection.execute(- "UPDATE chat_settings SET system_prompt = ?, updated_at = ? WHERE id = 1",- (system_prompt, now),- )- connection.commit()- return self._load_preferences(connection)-- return await self._run(operation)-- async def create_session(- self, *, session_id: str, model: str, reasoning: ChatReasoning- ) -> ChatSession:- def operation(connection: sqlite3.Connection) -> ChatSession:- now = _now_ms()- connection.execute("BEGIN IMMEDIATE")- connection.execute(- """- INSERT INTO chat_sessions (- id, title, title_search, auto_title_pending, model, reasoning,- revision, created_at, updated_at- ) VALUES (?, ?, ?, 1, ?, ?, 1, ?, ?)- """,- (- session_id,- _NEW_CHAT_TITLE,- _NEW_CHAT_TITLE.casefold(),- model,- reasoning.value,- now,- now,- ),- )- connection.execute(- """- UPDATE chat_settings- SET last_model = ?, last_reasoning = ?, updated_at = ?- WHERE id = 1- """,- (model, reasoning.value, now),- )- connection.commit()- return self._get_session(connection, session_id)-- return await self._run(operation)-- async def list_sessions(- self,- *,- query: str,- cursor: tuple[int, str] | None,- limit: int,- ) -> ChatSessionPage:- def operation(connection: sqlite3.Connection) -> ChatSessionPage:- clauses: list[str] = []- parameters: list[object] = []- folded = query.strip().casefold()- if folded:- clauses.append("instr(s.title_search, ?) > 0")- parameters.append(folded)- if cursor is not None:- clauses.append("(s.updated_at < ? OR (s.updated_at = ? AND s.id < ?))")- parameters.extend((cursor[0], cursor[0], cursor[1]))- where = f"WHERE {' AND '.join(clauses)}" if clauses else ""- rows = connection.execute(- f"""- {_SESSION_SUMMARY_SELECT}- {where}- ORDER BY s.updated_at DESC, s.id DESC- LIMIT ?- """,- (*parameters, limit + 1),- ).fetchall()- has_more = len(rows) > limit- selected = rows[:limit]- sessions = tuple(_session_summary_from_row(row) for row in selected)- next_cursor = None- if has_more and selected:- last = selected[-1]- next_cursor = (_row_int(last, "updated_at"), _row_str(last, "id"))- return ChatSessionPage(sessions=sessions, next_cursor=next_cursor)-- return await self._run(operation)-- async def get_session_summary(self, session_id: str) -> ChatSessionSummary:- def operation(connection: sqlite3.Connection) -> ChatSessionSummary:- row = connection.execute(- f"{_SESSION_SUMMARY_SELECT} WHERE s.id = ?",- (session_id,),- ).fetchone()- if row is None:- raise ChatNotFoundError("Chat session not found.")- return _session_summary_from_row(row)-- return await self._run(operation)-- async def get_session(self, session_id: str) -> ChatSession:- return await self._run(- lambda connection: self._get_session(connection, session_id)- )-- async def update_session(- self,- session_id: str,- *,- expected_revision: int,- title: str | None,- model: str | None,- reasoning: ChatReasoning | None,- ) -> ChatSession:- def operation(connection: sqlite3.Connection) -> ChatSession:- connection.execute("BEGIN IMMEDIATE")- current = self._get_session(connection, session_id)- _expect_revision(current, expected_revision)- next_title = current.title if title is None else title- next_model = current.model if model is None else model- next_reasoning = current.reasoning if reasoning is None else reasoning- now = _now_ms()- cursor = connection.execute(- """- UPDATE chat_sessions- SET title = ?, title_search = ?,- auto_title_pending = CASE- WHEN ? IS NULL THEN auto_title_pending ELSE 0- END,- model = ?, reasoning = ?,- revision = revision + 1, updated_at = ?- WHERE id = ? AND revision = ?- """,- (- next_title,- next_title.casefold(),- title,- next_model,- next_reasoning.value,- now,- session_id,- expected_revision,- ),- )- if cursor.rowcount != 1:- connection.rollback()- raise ChatConflictError("This chat changed in another tab. Refresh it.")- if model is not None or reasoning is not None:- connection.execute(- """- UPDATE chat_settings- SET last_model = ?, last_reasoning = ?, updated_at = ?- WHERE id = 1- """,- (next_model, next_reasoning.value, now),- )- connection.commit()- return self._get_session(connection, session_id)-- return await self._run(operation)-- async def delete_session(self, session_id: str, *, expected_revision: int) -> None:- def operation(connection: sqlite3.Connection) -> None:- connection.execute("BEGIN IMMEDIATE")- cursor = connection.execute(- "DELETE FROM chat_sessions WHERE id = ? AND revision = ?",- (session_id, expected_revision),- )- if cursor.rowcount != 1:- exists = connection.execute(- "SELECT 1 FROM chat_sessions WHERE id = ?", (session_id,)- ).fetchone()- connection.rollback()- if exists is None:- raise ChatNotFoundError("Chat session not found.")- raise ChatConflictError("This chat changed in another tab. Refresh it.")- connection.commit()-- await self._run(operation)-- async def get_transcript(self, session_id: str) -> ChatTranscript:- def operation(connection: sqlite3.Connection) -> ChatTranscript:- connection.execute("BEGIN")- try:- session = self._get_session(connection, session_id)- rows = connection.execute(- "SELECT * FROM chat_turns WHERE session_id = ? ORDER BY sequence",- (session_id,),- ).fetchall()- turns = tuple(self._turn_from_row(connection, row) for row in rows)- transcript = ChatTranscript(- session=session,- turns=turns,- compaction=self._get_compaction(connection, session_id),- )- connection.commit()- return transcript- except BaseException:- connection.rollback()- raise-- return await self._run(operation)-- async def get_turn_page(- self,- session_id: str,- *,- before_sequence: int | None,- limit: int,- ) -> tuple[tuple[ChatTurn, ...], int | None, ChatCompaction | None]:- def operation(- connection: sqlite3.Connection,- ) -> tuple[tuple[ChatTurn, ...], int | None, ChatCompaction | None]:- self._get_session(connection, session_id)- parameters: list[object] = [session_id]- before = ""- if before_sequence is not None:- before = "AND sequence < ?"- parameters.append(before_sequence)- rows = connection.execute(- f"""- SELECT * FROM chat_turns- WHERE session_id = ? {before}- ORDER BY sequence DESC LIMIT ?- """,- (*parameters, limit + 1),- ).fetchall()- has_more = len(rows) > limit- selected = rows[:limit]- selected.reverse()- turns = tuple(self._turn_from_row(connection, row) for row in selected)- next_before = turns[0].sequence if has_more and turns else None- return turns, next_before, self._get_compaction(connection, session_id)-- return await self._run(operation)-- async def generation_start_committed(- self,- session_id: str,- *,- generation_id: str,- staged: bool,- ) -> bool:- def operation(connection: sqlite3.Connection) -> bool:- row = connection.execute(- """- SELECT g.visible, g.status- FROM chat_generations AS g- JOIN chat_turns AS t ON t.id = g.turn_id- WHERE g.id = ? AND t.session_id = ?- """,- (generation_id, session_id),- ).fetchone()- if row is None:- return False- expected_visibility = 0 if staged else 1- return (- _row_int(row, "visible") == expected_visibility- and _row_str(row, "status") == GenerationStatus.RUNNING.value- )-- return await self._run(operation)-- async def begin_send(- self,- session_id: str,- *,- expected_revision: int,- turn_id: str,- generation_id: str,- operation_id: str,- user_text: str,- requested_model: str,- reasoning: ChatReasoning,- effective_output_limit: int,- ) -> ChatTurn:- def operation(connection: sqlite3.Connection) -> ChatTurn:- connection.execute("BEGIN IMMEDIATE")- session = self._get_session(connection, session_id)- _expect_revision(session, expected_revision)- row = connection.execute(- "SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence "- "FROM chat_turns WHERE session_id = ?",- (session_id,),- ).fetchone()- if row is None:- raise ChatUnavailableError("Could not allocate the next chat turn.")- sequence = _row_int(row, "next_sequence")- auto_title_row = connection.execute(- "SELECT auto_title_pending FROM chat_sessions WHERE id = ?",- (session_id,),- ).fetchone()- if auto_title_row is None:- raise ChatNotFoundError("Chat session not found.")- now = _now_ms()- title = session.title- if _row_int(auto_title_row, "auto_title_pending") == 1:- title = _title_from_text(user_text)- connection.execute(- """- INSERT INTO chat_turns (- id, session_id, operation_id, sequence, user_text, created_at- ) VALUES (?, ?, ?, ?, ?, ?)- """,- (turn_id, session_id, operation_id, sequence, user_text, now),- )- connection.execute(- """- INSERT INTO chat_generations (- id, turn_id, visible, status, requested_model, actual_model,- reasoning, effective_output_limit, stop_reason, error_code,- error_message, started_at, finished_at- ) VALUES (?, ?, 1, ?, ?, NULL, ?, ?, NULL, NULL, NULL, ?, NULL)- """,- (- generation_id,- turn_id,- GenerationStatus.RUNNING.value,- requested_model,- reasoning.value,- effective_output_limit,- now,- ),- )- cursor = connection.execute(- """- UPDATE chat_sessions- SET title = ?, title_search = ?, auto_title_pending = 0,- revision = revision + 1, updated_at = ?- WHERE id = ? AND revision = ?- """,- (title, title.casefold(), now, session_id, expected_revision),- )- if cursor.rowcount != 1:- connection.rollback()- raise ChatConflictError("This chat changed in another tab. Refresh it.")- turn = self._turn_by_id(connection, turn_id)- connection.commit()- return turn-- return await self._run(operation)-- async def begin_retry(- self,- session_id: str,- *,- expected_revision: int,- requested_model: str,- reasoning: ChatReasoning,- effective_output_limit: int,- ) -> ChatGeneration:- def operation(connection: sqlite3.Connection) -> ChatGeneration:- connection.execute("BEGIN IMMEDIATE")- session = self._get_session(connection, session_id)- _expect_revision(session, expected_revision)- row = self._latest_visible_generation_row(connection, session_id)- if _row_str(row, "status") not in {- GenerationStatus.STOPPED.value,- GenerationStatus.INTERRUPTED.value,- GenerationStatus.FAILED.value,- }:- raise ChatConflictError(- "Only the latest unfinished answer can be retried."- )- generation_id = _row_str(row, "id")- now = _now_ms()- connection.execute(- "DELETE FROM chat_generation_segments WHERE generation_id = ?",- (generation_id,),- )- connection.execute(- """- UPDATE chat_generations- SET status = ?, requested_model = ?, actual_model = NULL,- reasoning = ?, effective_output_limit = ?, stop_reason = NULL,- error_code = NULL, error_message = NULL, started_at = ?,- finished_at = NULL- WHERE id = ?- """,- (- GenerationStatus.RUNNING.value,- requested_model,- reasoning.value,- effective_output_limit,- now,- generation_id,- ),- )- self._bump_session(connection, session_id, expected_revision, now)- generation = self._generation_by_id(connection, generation_id)- connection.commit()- return generation-- return await self._run(operation)-- async def begin_regenerate(- self,- session_id: str,- *,- expected_revision: int,- generation_id: str,- requested_model: str,- reasoning: ChatReasoning,- effective_output_limit: int,- ) -> tuple[ChatTurn, ChatGeneration]:- def operation(- connection: sqlite3.Connection,- ) -> tuple[ChatTurn, ChatGeneration]:- connection.execute("BEGIN IMMEDIATE")- session = self._get_session(connection, session_id)- _expect_revision(session, expected_revision)- visible = self._latest_visible_generation_row(connection, session_id)- if _row_str(visible, "status") != GenerationStatus.COMPLETED.value:- raise ChatConflictError(- "Only the latest completed answer can regenerate."- )- turn_id = _row_str(visible, "turn_id")- now = _now_ms()- connection.execute(- """- INSERT INTO chat_generations (- id, turn_id, visible, status, requested_model, actual_model,- reasoning, effective_output_limit, stop_reason, error_code,- error_message, started_at, finished_at- ) VALUES (?, ?, 0, ?, ?, NULL, ?, ?, NULL, NULL, NULL, ?, NULL)- """,- (- generation_id,- turn_id,- GenerationStatus.RUNNING.value,- requested_model,- reasoning.value,- effective_output_limit,- now,- ),- )- self._bump_session(connection, session_id, expected_revision, now)- turn = self._turn_by_id(connection, turn_id)- generation = self._generation_by_id(connection, generation_id)- connection.commit()- return turn, generation-- return await self._run(operation)-- async def set_generation_actual_model(- self, generation_id: str, actual_model: str- ) -> None:- def operation(connection: sqlite3.Connection) -> None:- connection.execute("BEGIN IMMEDIATE")- cursor = connection.execute(- "UPDATE chat_generations SET actual_model = ? WHERE id = ?",- (actual_model, generation_id),- )- if cursor.rowcount != 1:- connection.rollback()- raise ChatNotFoundError("Chat generation not found.")- connection.commit()-- await self._run(operation)-- async def replace_generation_segments(- self, generation_id: str, segments: tuple[ChatSegment, ...]- ) -> None:- def operation(connection: sqlite3.Connection) -> None:- connection.execute("BEGIN IMMEDIATE")- if (- connection.execute(- "SELECT 1 FROM chat_generations WHERE id = ?", (generation_id,)- ).fetchone()- is None- ):- connection.rollback()- raise ChatNotFoundError("Chat generation not found.")- connection.execute(- "DELETE FROM chat_generation_segments WHERE generation_id = ?",- (generation_id,),- )- connection.executemany(- """- INSERT INTO chat_generation_segments- (generation_id, ordinal, kind, text)- VALUES (?, ?, ?, ?)- """,- (- (generation_id, segment.ordinal, segment.kind.value, segment.text)- for segment in segments- ),- )- connection.commit()-- await self._run(operation)-- async def finish_generation(- self,- generation_id: str,- *,- status: GenerationStatus,- stop_reason: str | None,- error_code: str | None,- error_message: str | None,- ) -> ChatSession:- if status is GenerationStatus.RUNNING:- raise ValueError("A generation cannot finish in Running state.")-- def operation(connection: sqlite3.Connection) -> ChatSession:- connection.execute("BEGIN IMMEDIATE")- row = connection.execute(- """- SELECT g.visible, g.status, t.session_id- FROM chat_generations AS g- JOIN chat_turns AS t ON t.id = g.turn_id- WHERE g.id = ?- """,- (generation_id,),- ).fetchone()- if row is None:- raise ChatNotFoundError("Chat generation not found.")- session_id = _row_str(row, "session_id")- visible = bool(_row_int(row, "visible"))- if not visible:- connection.rollback()- raise ChatConflictError(- "Staged regenerations must finish through finish_regeneration."- )- if _row_str(row, "status") != GenerationStatus.RUNNING.value:- connection.rollback()- return self._get_session(connection, session_id)- now = _now_ms()- cursor = connection.execute(- """- UPDATE chat_generations- SET status = ?, stop_reason = ?, error_code = ?, error_message = ?,- finished_at = ?- WHERE id = ? AND status = ?- """,- (- status.value,- stop_reason,- error_code,- error_message,- now,- generation_id,- GenerationStatus.RUNNING.value,- ),- )- if cursor.rowcount != 1:- connection.rollback()- return self._get_session(connection, session_id)- connection.execute(- """- UPDATE chat_sessions- SET revision = revision + 1, updated_at = ? WHERE id = ?- """,- (now, session_id),- )- connection.commit()- return self._get_session(connection, session_id)-- return await self._run(operation)-- async def discard_generation(self, generation_id: str) -> None:- def operation(connection: sqlite3.Connection) -> None:- connection.execute("BEGIN IMMEDIATE")- row = connection.execute(- "SELECT visible FROM chat_generations WHERE id = ?",- (generation_id,),- ).fetchone()- if row is None:- connection.rollback()- return- if _row_int(row, "visible") != 0:- connection.rollback()- raise ChatConflictError("Visible answers cannot be discarded.")- connection.execute(- "DELETE FROM chat_generations WHERE id = ?",- (generation_id,),- )- connection.commit()-- await self._run(operation)-- async def finish_regeneration(- self,- generation_id: str,- *,- status: GenerationStatus,- stop_reason: str | None,- error_code: str | None,- error_message: str | None,- ) -> ChatSession:- if status not in {GenerationStatus.COMPLETED, GenerationStatus.FAILED}:- raise ValueError("A regeneration must finish as Completed or Failed.")-- def operation(connection: sqlite3.Connection) -> ChatSession:- connection.execute("BEGIN IMMEDIATE")- row = connection.execute(- """- SELECT g.turn_id, g.visible, g.status, t.session_id- FROM chat_generations AS g- JOIN chat_turns AS t ON t.id = g.turn_id- WHERE g.id = ?- """,- (generation_id,),- ).fetchone()- if row is None:- connection.rollback()- raise ChatConflictError("Staged regeneration is unavailable.")- session_id = _row_str(row, "session_id")- if bool(_row_int(row, "visible")):- if _row_str(row, "status") == status.value:- connection.rollback()- return self._get_session(connection, session_id)- connection.rollback()- raise ChatConflictError("Staged regeneration is unavailable.")- if _row_str(row, "status") != GenerationStatus.RUNNING.value:- connection.rollback()- raise ChatConflictError("Staged regeneration is not running.")- turn_id = _row_str(row, "turn_id")- now = _now_ms()- connection.execute(- "UPDATE chat_generations SET visible = 0 WHERE turn_id = ? AND visible = 1",- (turn_id,),- )- connection.execute(- """- UPDATE chat_generations- SET visible = 1, status = ?, stop_reason = ?, error_code = ?,- error_message = ?, finished_at = ?- WHERE id = ? AND visible = 0 AND status = ?- """,- (- status.value,- stop_reason,- error_code,- error_message,- now,- generation_id,- GenerationStatus.RUNNING.value,- ),- )- connection.execute(- "DELETE FROM chat_generations WHERE turn_id = ? AND id != ?",- (turn_id, generation_id),- )- connection.execute(- """- UPDATE chat_sessions- SET revision = revision + 1, updated_at = ? WHERE id = ?- """,- (now, session_id),- )- connection.commit()- return self._get_session(connection, session_id)-- return await self._run(operation)-- async def upsert_compaction(- self,- session_id: str,- *,- covered_through_sequence: int,- summary: str,- estimated_tokens: int,- requested_model: str,- actual_model: str,- ) -> ChatCompaction:- def operation(connection: sqlite3.Connection) -> ChatCompaction:- connection.execute("BEGIN IMMEDIATE")- self._get_session(connection, session_id)- current = self._get_compaction(connection, session_id)- if current is not None and (- current.covered_through_sequence == covered_through_sequence- and current.summary == summary- and current.estimated_tokens == estimated_tokens- and current.requested_model == requested_model- and current.actual_model == actual_model- ):- connection.rollback()- return current- now = _now_ms()- connection.execute(- """- INSERT INTO chat_compactions (- session_id, covered_through_sequence, summary,- estimated_tokens, requested_model, actual_model, updated_at- ) VALUES (?, ?, ?, ?, ?, ?, ?)- ON CONFLICT(session_id) DO UPDATE SET- covered_through_sequence = excluded.covered_through_sequence,- summary = excluded.summary,- estimated_tokens = excluded.estimated_tokens,- requested_model = excluded.requested_model,- actual_model = excluded.actual_model,- updated_at = excluded.updated_at- """,- (- session_id,- covered_through_sequence,- summary,- estimated_tokens,- requested_model,- actual_model,- now,- ),- )- connection.execute(- """- UPDATE chat_sessions- SET revision = revision + 1, updated_at = ? WHERE id = ?- """,- (now, session_id),- )- compaction = self._get_compaction(connection, session_id)- if compaction is None:- connection.rollback()- raise ChatUnavailableError("Could not persist chat compaction.")- connection.commit()- return compaction-- return await self._run(operation)-- async def _run(self, operation: Callable[[sqlite3.Connection], T]) -> T:- if not self._started:- raise ChatUnavailableError("Chat storage is not available.")- try:- return await anyio.to_thread.run_sync(lambda: self._run_sync(operation))- except sqlite3.Error as exc:- raise ChatUnavailableError("Chat storage is unavailable.") from exc-- def _run_sync(self, operation: Callable[[sqlite3.Connection], T]) -> T:- connection = sqlite3.connect(- self._database_path,- timeout=_BUSY_TIMEOUT_MS / 1_000,- isolation_level=None,- )- connection.row_factory = sqlite3.Row- try:- connection.execute("PRAGMA foreign_keys = ON")- connection.execute(f"PRAGMA busy_timeout = {_BUSY_TIMEOUT_MS}")- connection.execute("PRAGMA journal_mode = WAL")- return operation(connection)- finally:- connection.close()-- def _migrate_and_repair(self, connection: sqlite3.Connection) -> None:- version_row = connection.execute("PRAGMA user_version").fetchone()- if version_row is None:- raise ChatUnavailableError("Could not read the Chat database schema.")- version_value: object = version_row[0]- if not isinstance(version_value, int):- raise ChatUnavailableError("Chat database schema is invalid.")- if version_value > _SCHEMA_VERSION:- raise ChatUnavailableError(- "Chat data was created by a newer FCC version. Update FCC to open it."- )- if version_value == 0:- try:- connection.executescript(_SCHEMA_V1)- connection.execute(- """- INSERT INTO chat_settings (- id, system_prompt, last_model, last_reasoning, updated_at- ) VALUES (1, ?, NULL, 'medium', 0)- """,- (DEFAULT_CHAT_SYSTEM_PROMPT,),- )- connection.execute(f"PRAGMA user_version = {_SCHEMA_VERSION}")- connection.commit()- except BaseException:- connection.rollback()- raise- elif version_value != _SCHEMA_VERSION:- raise ChatUnavailableError("Chat database schema is unsupported.")-- now = _now_ms()- connection.execute("BEGIN IMMEDIATE")- connection.execute(- """- DELETE FROM chat_generations- WHERE visible = 0- """- )- affected = connection.execute(- """- SELECT DISTINCT t.session_id- FROM chat_generations AS g- JOIN chat_turns AS t ON t.id = g.turn_id- WHERE g.visible = 1 AND g.status = 'running'- """- ).fetchall()- connection.execute(- """- UPDATE chat_generations- SET status = 'interrupted', stop_reason = 'server_restart',- finished_at = ?- WHERE visible = 1 AND status = 'running'- """,- (now,),- )- connection.executemany(- """- UPDATE chat_sessions- SET revision = revision + 1, updated_at = ? WHERE id = ?- """,- ((_now_ms(), _row_str(row, "session_id")) for row in affected),- )- connection.commit()-- @staticmethod- def _load_preferences(connection: sqlite3.Connection) -> ChatPreferences:- row = connection.execute("SELECT * FROM chat_settings WHERE id = 1").fetchone()- if row is None:- raise ChatUnavailableError("Chat settings are unavailable.")- return ChatPreferences(- system_prompt=_row_str(row, "system_prompt"),- last_model=_row_optional_str(row, "last_model"),- last_reasoning=ChatReasoning(_row_str(row, "last_reasoning")),- updated_at=_row_int(row, "updated_at"),- )-- @staticmethod- def _get_session(connection: sqlite3.Connection, session_id: str) -> ChatSession:- row = connection.execute(- "SELECT * FROM chat_sessions WHERE id = ?", (session_id,)- ).fetchone()- if row is None:- raise ChatNotFoundError("Chat session not found.")- return _session_from_row(row)-- @staticmethod- def _latest_visible_generation_row(- connection: sqlite3.Connection, session_id: str- ) -> sqlite3.Row:- row = connection.execute(- """- SELECT g.* FROM chat_generations AS g- JOIN chat_turns AS t ON t.id = g.turn_id- WHERE t.session_id = ? AND g.visible = 1- ORDER BY t.sequence DESC LIMIT 1- """,- (session_id,),- ).fetchone()- if row is None:- raise ChatConflictError("This chat has no answer to operate on.")- return row-- def _turn_by_id(self, connection: sqlite3.Connection, turn_id: str) -> ChatTurn:- row = connection.execute(- "SELECT * FROM chat_turns WHERE id = ?", (turn_id,)- ).fetchone()- if row is None:- raise ChatNotFoundError("Chat turn not found.")- return self._turn_from_row(connection, row)-- def _turn_from_row(- self, connection: sqlite3.Connection, row: sqlite3.Row- ) -> ChatTurn:- generation_row = connection.execute(- """- SELECT * FROM chat_generations- WHERE turn_id = ? AND visible = 1- """,- (_row_str(row, "id"),),- ).fetchone()- if generation_row is None:- raise ChatUnavailableError("Chat turn has no visible generation.")- return ChatTurn(- id=_row_str(row, "id"),- session_id=_row_str(row, "session_id"),- operation_id=_row_str(row, "operation_id"),- sequence=_row_int(row, "sequence"),- user_text=_row_str(row, "user_text"),- created_at=_row_int(row, "created_at"),- generation=self._generation_from_row(connection, generation_row),- )-- def _generation_by_id(- self, connection: sqlite3.Connection, generation_id: str- ) -> ChatGeneration:- row = connection.execute(- "SELECT * FROM chat_generations WHERE id = ?", (generation_id,)- ).fetchone()- if row is None:- raise ChatNotFoundError("Chat generation not found.")- return self._generation_from_row(connection, row)-- @staticmethod- def _generation_from_row(- connection: sqlite3.Connection, row: sqlite3.Row- ) -> ChatGeneration:- segment_rows = connection.execute(- """- SELECT * FROM chat_generation_segments- WHERE generation_id = ? ORDER BY ordinal- """,- (_row_str(row, "id"),),- ).fetchall()- return ChatGeneration(- id=_row_str(row, "id"),- status=GenerationStatus(_row_str(row, "status")),- requested_model=_row_str(row, "requested_model"),- actual_model=_row_optional_str(row, "actual_model"),- reasoning=ChatReasoning(_row_str(row, "reasoning")),- effective_output_limit=_row_int(row, "effective_output_limit"),- stop_reason=_row_optional_str(row, "stop_reason"),- error_code=_row_optional_str(row, "error_code"),- error_message=_row_optional_str(row, "error_message"),- started_at=_row_int(row, "started_at"),- finished_at=_row_optional_int(row, "finished_at"),- segments=tuple(- ChatSegment(- ordinal=_row_int(segment, "ordinal"),- kind=SegmentKind(_row_str(segment, "kind")),- text=_row_str(segment, "text"),- )- for segment in segment_rows- ),- )-- @staticmethod- def _get_compaction(- connection: sqlite3.Connection, session_id: str- ) -> ChatCompaction | None:- row = connection.execute(- "SELECT * FROM chat_compactions WHERE session_id = ?", (session_id,)- ).fetchone()- if row is None:- return None- return ChatCompaction(- session_id=session_id,- covered_through_sequence=_row_int(row, "covered_through_sequence"),- summary=_row_str(row, "summary"),- estimated_tokens=_row_int(row, "estimated_tokens"),- requested_model=_row_str(row, "requested_model"),- actual_model=_row_str(row, "actual_model"),- updated_at=_row_int(row, "updated_at"),- )-- @staticmethod- def _bump_session(- connection: sqlite3.Connection,- session_id: str,- expected_revision: int,- now: int,- ) -> None:- cursor = connection.execute(- """- UPDATE chat_sessions- SET revision = revision + 1, updated_at = ?- WHERE id = ? AND revision = ?- """,- (now, session_id, expected_revision),- )- if cursor.rowcount != 1:- connection.rollback()- raise ChatConflictError("This chat changed in another tab. Refresh it.")---def _session_from_row(row: sqlite3.Row) -> ChatSession:- return ChatSession(- id=_row_str(row, "id"),- title=_row_str(row, "title"),- model=_row_str(row, "model"),- reasoning=ChatReasoning(_row_str(row, "reasoning")),- revision=_row_int(row, "revision"),- created_at=_row_int(row, "created_at"),- updated_at=_row_int(row, "updated_at"),- )---def _session_summary_from_row(row: sqlite3.Row) -> ChatSessionSummary:- return ChatSessionSummary(- id=_row_str(row, "id"),- title=_row_str(row, "title"),- model=_row_str(row, "model"),- reasoning=ChatReasoning(_row_str(row, "reasoning")),- revision=_row_int(row, "revision"),- preview=_row_str(row, "preview"),- created_at=_row_int(row, "created_at"),- updated_at=_row_int(row, "updated_at"),- )---def _expect_revision(session: ChatSession, expected: int) -> None:- if session.revision != expected:- raise ChatConflictError("This chat changed in another tab. Refresh it.")---def _title_from_text(text: str) -> str:- collapsed = " ".join(text.split())- if len(collapsed) <= 64:- return collapsed- return f"{collapsed[:61].rstrip()}..."---def _row_str(row: sqlite3.Row, key: str) -> str:- value: object = row[key]- if not isinstance(value, str):- raise ChatUnavailableError(f"Chat database field {key!r} is invalid.")- return value---def _row_optional_str(row: sqlite3.Row, key: str) -> str | None:- value: object = row[key]- if value is None:- return None- if not isinstance(value, str):- raise ChatUnavailableError(f"Chat database field {key!r} is invalid.")- return value---def _row_int(row: sqlite3.Row, key: str) -> int:- value: object = row[key]- if not isinstance(value, int) or isinstance(value, bool):- raise ChatUnavailableError(f"Chat database field {key!r} is invalid.")- return value---def _row_optional_int(row: sqlite3.Row, key: str) -> int | None:- value: object = row[key]- if value is None:- return None- if not isinstance(value, int) or isinstance(value, bool):- raise ChatUnavailableError(f"Chat database field {key!r} is invalid.")- return value---def _now_ms() -> int:- return time.time_ns() // 1_000_000---def _owner_only(path: Path, mode: int) -> None:- if os.name != "nt" and path.exists():- path.chmod(mode)---_SCHEMA_V1 = """-BEGIN EXCLUSIVE;-CREATE TABLE IF NOT EXISTS chat_settings (- id INTEGER PRIMARY KEY CHECK (id = 1),- system_prompt TEXT NOT NULL,- last_model TEXT,- last_reasoning TEXT NOT NULL CHECK (- last_reasoning IN ('off', 'low', 'medium', 'high', 'xhigh', 'max')- ),- updated_at INTEGER NOT NULL-);-CREATE TABLE IF NOT EXISTS chat_sessions (- id TEXT PRIMARY KEY,- title TEXT NOT NULL,- title_search TEXT NOT NULL,- auto_title_pending INTEGER NOT NULL CHECK (auto_title_pending IN (0, 1)),- model TEXT NOT NULL,- reasoning TEXT NOT NULL CHECK (- reasoning IN ('off', 'low', 'medium', 'high', 'xhigh', 'max')- ),- revision INTEGER NOT NULL CHECK (revision > 0),- created_at INTEGER NOT NULL,- updated_at INTEGER NOT NULL-);-CREATE INDEX IF NOT EXISTS chat_sessions_updated_idx- ON chat_sessions(updated_at DESC, id DESC);--CREATE TABLE IF NOT EXISTS chat_turns (- id TEXT PRIMARY KEY,- session_id TEXT NOT NULL REFERENCES chat_sessions(id) ON DELETE CASCADE,- operation_id TEXT NOT NULL,- sequence INTEGER NOT NULL CHECK (sequence > 0),- user_text TEXT NOT NULL,- created_at INTEGER NOT NULL,- UNIQUE(session_id, sequence)-);--CREATE TABLE IF NOT EXISTS chat_generations (- id TEXT PRIMARY KEY,- turn_id TEXT NOT NULL REFERENCES chat_turns(id) ON DELETE CASCADE,- visible INTEGER NOT NULL CHECK (visible IN (0, 1)),- status TEXT NOT NULL CHECK (- status IN ('running', 'completed', 'stopped', 'interrupted', 'failed')- ),- requested_model TEXT NOT NULL,- actual_model TEXT,- reasoning TEXT NOT NULL CHECK (- reasoning IN ('off', 'low', 'medium', 'high', 'xhigh', 'max')- ),- effective_output_limit INTEGER NOT NULL CHECK (effective_output_limit > 0),- stop_reason TEXT,- error_code TEXT,- error_message TEXT,- started_at INTEGER NOT NULL,- finished_at INTEGER-);-CREATE UNIQUE INDEX IF NOT EXISTS chat_visible_generation_idx- ON chat_generations(turn_id) WHERE visible = 1;--CREATE TABLE IF NOT EXISTS chat_generation_segments (- generation_id TEXT NOT NULL REFERENCES chat_generations(id) ON DELETE CASCADE,- ordinal INTEGER NOT NULL CHECK (ordinal >= 0),- kind TEXT NOT NULL CHECK (kind IN ('thinking', 'text')),- text TEXT NOT NULL,- PRIMARY KEY(generation_id, ordinal)-);--CREATE TABLE IF NOT EXISTS chat_compactions (- session_id TEXT PRIMARY KEY REFERENCES chat_sessions(id) ON DELETE CASCADE,- covered_through_sequence INTEGER NOT NULL CHECK (covered_through_sequence > 0),- summary TEXT NOT NULL,- estimated_tokens INTEGER NOT NULL CHECK (estimated_tokens > 0),- requested_model TEXT NOT NULL,- actual_model TEXT NOT NULL,- updated_at INTEGER NOT NULL-);-"""diff --git a/src/free_claude_code/runtime/retired_chat.py b/src/free_claude_code/runtime/retired_chat.pynew file mode 100644index 00000000..51b26372--- /dev/null+++ b/src/free_claude_code/runtime/retired_chat.py@@ -0,0 +1,47 @@+"""Remove saved data belonging to the retired Admin Chat Sessions feature."""++from loguru import logger++from free_claude_code.config import paths+from free_claude_code.core.interprocess_lock import InterprocessFileLock+++def remove_retired_chat_history() -> None:+ """Delete only owned history files, deferring failures to the next startup."""+ try:+ directory = paths.config_dir_path().resolve() / "chat"+ try:+ resolved = directory.resolve(strict=True)+ except FileNotFoundError:+ return+ if resolved != directory:+ logger.warning("Chat history cleanup deferred: redirected directory")+ return+ files = tuple(+ directory / name+ for name in ("chat.db", "chat.db-wal", "chat.db-shm", "chat.db-journal")+ )+ for path in files:+ try:+ path.lstat()+ except FileNotFoundError:+ continue+ break+ else:+ return++ lock = InterprocessFileLock(directory / "chat.lock")+ try:+ if not lock.acquire():+ logger.warning("Chat history cleanup deferred: history is in use")+ return+ for path in files:+ path.unlink(missing_ok=True)+ finally:+ # Keep the lock file: unlinking it could create two independent locks.+ lock.release()+ except OSError as exc:+ logger.warning(+ "Chat history cleanup deferred until next startup: exc_type={}",+ type(exc).__name__,+ )diff --git a/tests/api/support.py b/tests/api/support.pyindex c52dc341..d8f93fce 100644--- a/tests/api/support.py+++ b/tests/api/support.py@@ -6,7 +6,6 @@ from fastapi import FastAPIfrom free_claude_code.api.app import create_appfrom free_claude_code.api.ports import ApiServices-from free_claude_code.application.chat import ChatApplicationPortfrom free_claude_code.application.code_sessions import CodeApplicationPortfrom free_claude_code.application.connected_accounts import ConnectedAccountPortfrom free_claude_code.config.loader import ManagedConfigStore@@ -24,7 +23,6 @@ def create_test_app(providers: MutableMapping[str, BaseProvider] | None = None,restart_callback: RestartCallback | None = None,connected_accounts: Mapping[str, ConnectedAccountPort] | None = None,- chat: ChatApplicationPort | None = None,code: CodeApplicationPort | None = None,) -> FastAPI:"""Build an API app with explicit in-memory runtime services."""@@ -66,7 +64,6 @@ def create_test_app(requests=manager,admin=runtime,tasks=runtime,- chat=chat,code=code,))diff --git a/tests/api/test_admin.py b/tests/api/test_admin.pyindex 3cd60bf7..a2c3b45c 100644--- a/tests/api/test_admin.py+++ b/tests/api/test_admin.py@@ -32,6 +32,33 @@ def _local_client(app):)+ "path",+ (+ "/admin/chat",+ "/admin/chat/old-session",+ "/admin/api/chat/sessions",+ "/admin/api/chat/events",+ "/admin/api/chat/settings",+ f"/admin/assets/{package_version()}/chat_sessions.js",+ f"/admin/assets/{package_version()}/chat_sessions.css",+ ),+)+def test_retired_chat_urls_are_not_served(path):+ client = _local_client(create_test_app())+ assert client.get(path).status_code == 404+++def test_admin_retains_code_without_chat_markup():+ client = _local_client(create_test_app())+ response = client.get("/admin")+ assert response.status_code == 200+ assert 'id="view-code"' in response.text+ assert 'id="view-chat"' not in response.text+ assert "chat_sessions" not in response.text+ assert client.get("/admin/code").status_code == 200++def test_admin_retirement_preview_apply_and_runtime_agree(monkeypatch, tmp_path):_set_home(monkeypatch, tmp_path)_clear_process_config(monkeypatch)@@ -161,13 +188,13 @@ def test_admin_page_uses_installed_version(monkeypatch, tmp_path):assert 'aria-label="Open Free Claude Code on GitHub"' in response.textassert 'src="/admin/assets/9.8.7/app-icon.svg"' in response.textassert 'href="/admin/assets/9.8.7/admin.css"' in response.text- assert 'href="/admin/assets/9.8.7/chat_sessions.css"' in response.text+ assert 'href="/admin/assets/9.8.7/code_sessions.css"' in response.textassert 'src="/admin/assets/9.8.7/model_combobox.js"' in response.text- assert 'src="/admin/assets/9.8.7/chat_sessions.js"' in response.text+ assert 'src="/admin/assets/9.8.7/code_sessions.js"' in response.textassert 'src="/admin/assets/9.8.7/admin.js"' in response.textassert 'href="/admin/assets/admin.css"' not in response.text- assert 'href="/admin/assets/chat_sessions.css"' not in response.text- assert 'src="/admin/assets/chat_sessions.js"' not in response.text+ assert 'href="/admin/assets/code_sessions.css"' not in response.text+ assert 'src="/admin/assets/code_sessions.js"' not in response.textassert 'src="/admin/assets/admin.js"' not in response.text@@ -176,8 +203,8 @@ def test_admin_page_uses_installed_version(monkeypatch, tmp_path):(("admin.css", "text/css"),("admin.js", "text/javascript"),- ("chat_sessions.css", "text/css"),- ("chat_sessions.js", "text/javascript"),+ ("code_sessions.css", "text/css"),+ ("code_sessions.js", "text/javascript"),("session_ui.js", "text/javascript"),("model_combobox.js", "text/javascript"),),@@ -231,8 +258,8 @@ def test_admin_versioned_logo_reuses_packaged_app_icon(monkeypatch, tmp_path):f"/admin/assets/{package_version()}/app-icon.svg",f"/admin/assets/{package_version()}/admin.css",f"/admin/assets/{package_version()}/admin.js",- f"/admin/assets/{package_version()}/chat_sessions.css",- f"/admin/assets/{package_version()}/chat_sessions.js",+ f"/admin/assets/{package_version()}/code_sessions.css",+ f"/admin/assets/{package_version()}/code_sessions.js",f"/admin/assets/{package_version()}/model_combobox.js","/admin/api/config",),diff --git a/tests/api/test_chat_routes.py b/tests/api/test_chat_routes.pydeleted file mode 100644index dd9df64e..00000000--- a/tests/api/test_chat_routes.py+++ /dev/null@@ -1,548 +0,0 @@-import base64-from dataclasses import replace--import pytest-from fastapi.testclient import TestClient--from free_claude_code.application.chat import (- ChatActiveOperation,- ChatCompaction,- ChatContextEstimate,- ChatModelOption,- ChatOperationAcknowledgement,- ChatOperationKind,- ChatOperationPhase,- ChatPreferences,- ChatReasoning,- ChatSegment,- ChatSession,- ChatSessionDetail,- ChatSessionPage,- ChatSessionSummary,- ChatTurn,- ChatValidationError,- GenerationStatus,- SegmentKind,-)-from free_claude_code.application.chat.models import ChatGeneration-from free_claude_code.application.session_events import (- EventOverflowError,- PublishedEvent,-)-from free_claude_code.core.model_capabilities import ModelInputModality-from tests.api.support import create_test_app--SESSION_ID = "29e3b8fd-8744-4377-b8cf-4c9d48daf962"-OPERATION_ID = "7cd43d62-c1aa-42f8-9963-6c0811c0dfaf"---class StubSubscription:- cursor = 4-- def __init__(self) -> None:- self.closed = False-- def __aiter__(self):- return self._events()-- async def _events(self):- yield PublishedEvent(- event="turn.completed",- id=5,- data={- "operation_id": OPERATION_ID,- "session_id": SESSION_ID,- "kind": "send",- "operation_sequence": 3,- },- )-- async def aclose(self) -> None:- self.closed = True---class OverflowSubscription(StubSubscription):- cursor = 7-- async def _events(self):- if False:- yield- raise EventOverflowError(9)---class StubChat:- def __init__(self) -> None:- self.session = ChatSession(- id=SESSION_ID,- title="Example",- model="groq/model",- reasoning=ChatReasoning.MEDIUM,- revision=1,- created_at=1,- updated_at=2,- )- generation = ChatGeneration(- id="generation",- status=GenerationStatus.COMPLETED,- requested_model="groq/model",- actual_model="open_router/fallback",- reasoning=ChatReasoning.MEDIUM,- effective_output_limit=1024,- stop_reason="end_turn",- error_code=None,- error_message=None,- started_at=1,- finished_at=2,- segments=(ChatSegment(0, SegmentKind.TEXT, "**safe** <script>x</script>"),),- )- self.turn = ChatTurn(- id="turn",- session_id=SESSION_ID,- operation_id="operation",- sequence=1,- user_text="hello",- created_at=1,- generation=generation,- )- self.preferences_value = ChatPreferences(- system_prompt="prompt",- last_model=self.session.model,- last_reasoning=self.session.reasoning,- updated_at=1,- )- self.last_subscription: StubSubscription | None = None- self.deleted = False- self.active_operation: ChatActiveOperation | None = None-- def availability(self) -> tuple[bool, str | None]:- return True, None-- def models(self) -> tuple[ChatModelOption, ...]:- return (- ChatModelOption(- model_ref="groq/model",- provider_id="groq",- model_id="model",- supports_reasoning=True,- input_modalities=frozenset({ModelInputModality.TEXT}),- context_window_tokens=32_000,- max_output_tokens=8_000,- ),- )-- async def subscribe(- self,- ) -> tuple[StubSubscription, tuple[ChatActiveOperation, ...]]:- self.last_subscription = StubSubscription()- active = (self.active_operation,) if self.active_operation is not None else ()- return self.last_subscription, active-- async def preferences(self) -> ChatPreferences:- return self.preferences_value-- async def save_system_prompt(self, value: str) -> ChatPreferences:- self.preferences_value = replace(self.preferences_value, system_prompt=value)- return self.preferences_value-- async def reset_system_prompt(self) -> ChatPreferences:- return await self.save_system_prompt("default")-- async def create_session(self) -> ChatSession:- return self.session-- async def get_detail(self, session_id: str) -> ChatSessionDetail:- session = await self.get_session(session_id)- turns, next_before, compaction = await self.get_turn_page(- session_id,- before_sequence=None,- limit=50,- )- context: ChatContextEstimate | None- context_error: str | None = None- try:- context = await self.estimate(session_id, draft="")- except ChatValidationError as exc:- context = None- context_error = str(exc)- return ChatSessionDetail(- session=session,- turns=turns,- next_before=next_before,- compaction=compaction,- context=context,- context_error=context_error,- )-- async def list_sessions(- self,- *,- query: str,- cursor: tuple[int, str] | None,- limit: int,- ) -> ChatSessionPage:- del query, cursor, limit- return ChatSessionPage(- sessions=(- ChatSessionSummary(- id=self.session.id,- title=self.session.title,- model=self.session.model,- reasoning=self.session.reasoning,- revision=self.session.revision,- preview="hello",- created_at=self.session.created_at,- updated_at=self.session.updated_at,- ),- ),- next_cursor=None,- )-- async def get_session(self, session_id: str) -> ChatSession:- assert session_id == SESSION_ID- return self.session-- async def update_session(- self,- session_id: str,- *,- expected_revision: int,- title: str | None,- model: str | None,- reasoning: ChatReasoning | None,- ) -> ChatSession:- assert session_id == SESSION_ID- assert expected_revision == self.session.revision- self.session = replace(- self.session,- title=title or self.session.title,- model=model or self.session.model,- reasoning=reasoning or self.session.reasoning,- revision=self.session.revision + 1,- )- return self.session-- async def delete_session(self, session_id: str, *, expected_revision: int) -> None:- assert session_id == SESSION_ID- assert expected_revision == self.session.revision- self.deleted = True-- async def get_turn_page(- self,- session_id: str,- *,- before_sequence: int | None,- limit: int,- ) -> tuple[tuple[ChatTurn, ...], int | None, ChatCompaction | None]:- assert session_id == SESSION_ID- del before_sequence, limit- return (self.turn,), None, None-- async def estimate(self, session_id: str, *, draft: str) -> ChatContextEstimate:- assert session_id == SESSION_ID- del draft- return ChatContextEstimate(100, 1_024, 32_000, 30_976, 0.01, False, False)-- async def send(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- text: str,- ) -> ChatOperationAcknowledgement:- assert (session_id, expected_revision, operation_id, text) == (- SESSION_ID,- self.session.revision,- OPERATION_ID,- "hello",- )- return ChatOperationAcknowledgement(- session_id=session_id,- operation_id=operation_id,- kind=ChatOperationKind.SEND,- )-- async def retry(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- ) -> ChatOperationAcknowledgement:- del expected_revision- return ChatOperationAcknowledgement(- session_id=session_id,- operation_id=operation_id,- kind=ChatOperationKind.RETRY,- )-- async def regenerate(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- ) -> ChatOperationAcknowledgement:- del expected_revision- return ChatOperationAcknowledgement(- session_id=session_id,- operation_id=operation_id,- kind=ChatOperationKind.REGENERATE,- )-- async def compact(- self,- session_id: str,- *,- expected_revision: int,- operation_id: str,- ) -> ChatOperationAcknowledgement:- del expected_revision- return ChatOperationAcknowledgement(- session_id=session_id,- operation_id=operation_id,- kind=ChatOperationKind.COMPACT,- )-- async def stop(self, session_id: str, *, operation_id: str) -> bool:- return (session_id, operation_id) == (SESSION_ID, OPERATION_ID)---class UnestimatableChat(StubChat):- async def estimate(self, session_id: str, *, draft: str) -> ChatContextEstimate:- assert session_id == SESSION_ID- del draft- raise ChatValidationError(- "This model does not support reasoning. Set thinking to Off."- )---class OverflowChat(StubChat):- async def subscribe(- self,- ) -> tuple[OverflowSubscription, tuple[ChatActiveOperation, ...]]:- subscription = OverflowSubscription()- self.last_subscription = subscription- return subscription, ()-- async def stop(self, session_id: str, *, operation_id: str) -> bool:- raise AssertionError((session_id, operation_id))---def _client(chat: StubChat | None = None) -> TestClient:- return TestClient(- create_test_app(chat=chat),- base_url="http://127.0.0.1",- client=("127.0.0.1", 50000),- )---def test_chat_deep_links_serve_the_versioned_admin_shell():- response = _client().get(f"/admin/chat/{SESSION_ID}")-- assert response.status_code == 200- assert "chat_sessions.js" in response.text- assert "Chat Sessions" not in response.headers.get("cache-control", "")- assert response.headers["cache-control"] == "no-store"---def test_chat_bootstrap_and_detail_project_rich_models_and_safe_markdown():- chat = StubChat()- chat.active_operation = ChatActiveOperation(- session_id=SESSION_ID,- operation_id=OPERATION_ID,- kind=ChatOperationKind.SEND,- phase=ChatOperationPhase.GENERATING,- operation_sequence=2,- submitted_text="next",- turn_id="turn-next",- generation_id="generation-next",- regeneration=False,- actual_model="groq/model",- segments=(ChatSegment(0, SegmentKind.TEXT, "live"),),- )- client = _client(chat)-- bootstrap = client.get("/admin/api/chat/bootstrap").json()- detail = client.get(f"/admin/api/chat/sessions/{SESSION_ID}").json()- feed = client.get("/admin/api/chat/events")-- assert bootstrap["models"][0]["supports_reasoning"] is True- assert bootstrap["models"][0]["input_modalities"] == ["text"]- segment = detail["turns"][0]["generation"]["segments"][0]- assert segment["text"] == "**safe** <script>x</script>"- assert "<strong>safe</strong>" in segment["html"]- assert "<script>" not in segment["html"]- assert detail["turns"][0]["generation"]["actual_model"] == ("open_router/fallback")- assert detail["turns"][0]["operation_id"] == "operation"- assert "active_operation" not in detail- assert '"submitted_text": "next"' in feed.text---def test_chat_detail_stays_readable_when_context_controls_need_repair():- response = _client(UnestimatableChat()).get(- f"/admin/api/chat/sessions/{SESSION_ID}"- )-- assert response.status_code == 200- assert response.json()["context"] is None- assert response.json()["context_error"] == (- "This model does not support reasoning. Set thinking to Off."- )---def test_chat_crud_and_prompt_routes_use_application_port():- chat = StubChat()- client = _client(chat)-- created = client.post("/admin/api/chat/sessions", json={})- renamed = client.patch(- f"/admin/api/chat/sessions/{SESSION_ID}",- json={"expected_revision": 1, "title": "Renamed"},- )- prompt = client.put(- "/admin/api/chat/preferences/system-prompt",- json={"value": "custom"},- )- deleted = client.request(- "DELETE",- f"/admin/api/chat/sessions/{SESSION_ID}",- json={"expected_revision": 2},- )-- assert created.status_code == 201- assert renamed.json()["title"] == "Renamed"- assert prompt.json()["system_prompt"] == "custom"- assert deleted.json() == {"deleted": True}- assert chat.deleted is True---def test_chat_long_operation_acknowledges_without_owning_its_event_stream():- chat = StubChat()- response = _client(chat).post(- f"/admin/api/chat/sessions/{SESSION_ID}/send",- json={- "expected_revision": 1,- "operation_id": OPERATION_ID,- "text": "hello",- },- )-- assert response.status_code == 202- assert response.json() == {- "session_id": SESSION_ID,- "operation_id": OPERATION_ID,- "kind": "send",- }- assert chat.last_subscription is None---def test_chat_event_feed_starts_at_snapshot_barrier_and_closes_subscription():- chat = StubChat()-- response = _client(chat).get("/admin/api/chat/events")-- assert response.status_code == 200- assert response.headers["content-type"].startswith("text/event-stream")- assert response.headers["cache-control"] == "no-store"- assert response.headers["x-accel-buffering"] == "no"- assert "event: feed.ready" in response.text- assert "id: 4" in response.text- assert 'data: {"cursor": 4, "active_operations": []}' in response.text- assert "event: turn.completed" in response.text- assert "id: 5" in response.text- assert chat.last_subscription is not None- assert chat.last_subscription.closed is True---def test_chat_event_feed_overflow_requests_resync_without_stopping_work():- chat = OverflowChat()-- response = _client(chat).get("/admin/api/chat/events")-- assert response.status_code == 200- assert "event: feed.ready" in response.text- assert "id: 7" in response.text- assert "event: feed.resync_required" in response.text- assert "id: 9" in response.text- assert 'data: {"cursor": 9}' in response.text- assert chat.last_subscription is not None- assert chat.last_subscription.closed is True---def test_chat_routes_apply_loopback_and_origin_protection():- chat = StubChat()- remote = TestClient(- create_test_app(chat=chat),- client=("203.0.113.5", 50000),- )- local = _client(chat)-- assert remote.get("/admin/api/chat/bootstrap").status_code == 403- assert (- local.get(- "/admin/api/chat/bootstrap",- headers={"Origin": "https://example.com"},- ).status_code- == 403- )- assert (- local.get(- "/admin/api/chat/bootstrap",- headers={"Host": "attacker.example:8000"},- ).status_code- == 403- )--- "origin",- (- "http://127.0.0.1:not-a-port",- "https://[::1",- ),-)-def test_chat_routes_reject_malformed_local_origins(origin: str):- response = _client(StubChat()).get(- "/admin/api/chat/bootstrap",- headers={"Origin": origin},- )-- assert response.status_code == 403- assert response.json() == {"detail": "Admin UI is local-only"}--- "origin",- (- "http://127.0.0.1:8000",- "https://localhost",- "http://[::1]:8000",- ),-)-def test_chat_routes_accept_valid_local_origins(origin: str):- response = _client(StubChat()).get(- "/admin/api/chat/bootstrap",- headers={"Origin": origin},- )-- assert response.status_code == 200---def test_chat_without_composed_service_isolated_as_503():- response = _client().get("/admin/api/chat/bootstrap")-- assert response.status_code == 503- assert response.json()["code"] == "ChatUnavailableError"---def test_invalid_session_cursor_is_rejected():- client = _client(StubChat())- malformed = client.get("/admin/api/chat/sessions", params={"cursor": "not-valid"})- non_uuid = base64.urlsafe_b64encode(b"1:not-a-session").decode().rstrip("=")- invalid_id = client.get("/admin/api/chat/sessions", params={"cursor": non_uuid})-- assert malformed.status_code == 400- assert malformed.json()["code"] == "ChatValidationError"- assert invalid_id.status_code == 400- assert invalid_id.json()["code"] == "ChatValidationError"diff --git a/tests/api/test_chat_markdown.py b/tests/api/test_markdown.pysimilarity index 81%rename from tests/api/test_chat_markdown.pyrename to tests/api/test_markdown.pyindex 4e65ff0f..eeb0ecdc 100644--- a/tests/api/test_chat_markdown.py+++ b/tests/api/test_markdown.py@@ -1,7 +1,7 @@from free_claude_code.api.markdown import render_markdown-def test_chat_markdown_escapes_html_and_never_loads_remote_images():+def test_markdown_escapes_html_and_never_loads_remote_images():rendered = render_markdown('<script>alert("x")</script>\n\n')@@ -13,7 +13,7 @@ def test_chat_markdown_escapes_html_and_never_loads_remote_images():assert 'rel="noopener noreferrer"' in rendered-def test_chat_markdown_disables_non_http_links():+def test_markdown_disables_non_http_links():rendered = render_markdown("[unsafe](javascript:alert(1))")assert "href=" not in rendereddiff --git a/tests/api/test_request_lifetime.py b/tests/api/test_request_lifetime.pyindex 72786123..4f897f4c 100644--- a/tests/api/test_request_lifetime.py+++ b/tests/api/test_request_lifetime.py@@ -60,8 +60,8 @@ async def _unused_send(_message: Message) -> None:[_http_scope("/health"),_http_scope("/v1/messages", method="OPTIONS"),- _http_scope("/admin/api/chat/sessions/session/send"),- _http_scope("/admin/api/chat/sessions/session/stop"),+ _http_scope("/admin/api/code/sessions/session/turns"),+ _http_scope("/admin/api/code/sessions/session/stop"),cast(Scope, {"type": "lifespan", "asgi": {"version": "3.0"}}),],)diff --git a/tests/application/test_chat_context.py b/tests/application/test_chat_context.pydeleted file mode 100644index 7bd616e5..00000000--- a/tests/application/test_chat_context.py+++ /dev/null@@ -1,356 +0,0 @@-from free_claude_code.application.chat import (- ChatCompaction,- ChatGeneration,- ChatReasoning,- ChatSegment,- ChatSession,- ChatTranscript,- ChatTurn,- ChatValidationError,- GenerationStatus,- SegmentKind,-)-from free_claude_code.application.chat.context import ChatContextBuilder-from free_claude_code.application.model_metadata import ProviderModelInfo-from free_claude_code.application.ports import RequestRuntimeLease-from free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic import ContentBlockText, ContentBlockThinking-from free_claude_code.core.model_capabilities import ModelInputModality-from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort---class FakeRuntime:- def __init__(- self,- *,- configured: ProviderModelInfo,- discovered: tuple[ProviderModelInfo, ...] = (),- ) -> None:- self.settings = Settings().model_copy(- update={- "model": "groq/model",- "model_fallbacks": None,- }- )- self.configured = configured- self.discovered = discovered-- async def acquire(- self, *, include_model_infos: bool = False- ) -> RequestRuntimeLease:- del include_model_infos- raise AssertionError("Context construction must not acquire a runtime lease")-- def current_settings(self) -> Settings:- return self.settings-- def cached_model_info(- self, provider_id: str, model_id: str- ) -> ProviderModelInfo | None:- if provider_id == "groq" and model_id == "model":- return self.configured- return None-- def cached_prefixed_model_infos(self) -> tuple[ProviderModelInfo, ...]:- return self.discovered---def _transcript(- *,- reasoning: ChatReasoning = ChatReasoning.HIGH,- compaction: ChatCompaction | None = None,-) -> ChatTranscript:- session = ChatSession(- id="session",- title="Chat",- model="groq/model",- reasoning=reasoning,- revision=1,- created_at=1,- updated_at=1,- )- generation = ChatGeneration(- id="generation",- status=GenerationStatus.COMPLETED,- requested_model=session.model,- actual_model=session.model,- reasoning=reasoning,- effective_output_limit=4096,- stop_reason="end_turn",- error_code=None,- error_message=None,- started_at=1,- finished_at=2,- segments=(- ChatSegment(0, SegmentKind.THINKING, "private-looking but exposed"),- ChatSegment(1, SegmentKind.TEXT, "answer"),- ),- )- return ChatTranscript(- session=session,- turns=(- ChatTurn(- id="turn",- session_id=session.id,- operation_id="operation",- sequence=1,- user_text="question",- created_at=1,- generation=generation,- ),- ),- compaction=compaction,- )---def test_models_merge_configured_and_discovered_capabilities():- runtime = FakeRuntime(- configured=ProviderModelInfo(- "model",- supports_thinking=True,- input_modalities=frozenset(- {ModelInputModality.TEXT, ModelInputModality.IMAGE}- ),- context_window_tokens=100_000,- max_output_tokens=20_000,- ),- discovered=(- ProviderModelInfo(- "groq/discovered",- supports_thinking=False,- context_window_tokens=32_000,- ),- ),- )-- options = ChatContextBuilder(runtime).models()-- assert [option.model_ref for option in options] == [- "groq/discovered",- "groq/model",- ]- assert options[1].input_modalities == frozenset(- {ModelInputModality.TEXT, ModelInputModality.IMAGE}- )---def test_explicit_model_metadata_snapshot_does_not_follow_live_cache():- runtime = FakeRuntime(- configured=ProviderModelInfo(- "model",- context_window_tokens=100_000,- max_output_tokens=20_000,- )- )- builder = ChatContextBuilder(- runtime,- model_infos=(- ProviderModelInfo(- "groq/model",- context_window_tokens=32_000,- max_output_tokens=4_096,- ),- ),- )-- prepared = builder.prepare(- _transcript(reasoning=ChatReasoning.OFF),- system_prompt="",- draft="hello",- )-- assert prepared.model.context_window_tokens == 32_000- assert prepared.routed.request.max_tokens == 4_096---def test_prepare_builds_ordered_messages_and_authoritative_reasoning():- runtime = FakeRuntime(- configured=ProviderModelInfo(- "model",- supports_thinking=True,- context_window_tokens=100_000,- max_output_tokens=20_000,- )- )- prepared = ChatContextBuilder(runtime).prepare(- _transcript(),- system_prompt="custom",- draft="follow up",- )-- request = prepared.routed.request- assert request.system == "custom"- assert [message.role for message in request.messages] == [- "user",- "assistant",- "user",- ]- assistant = request.messages[1].content- assert isinstance(assistant, list)- assert isinstance(assistant[0], ContentBlockThinking)- assert isinstance(assistant[1], ContentBlockText)- assert prepared.routed.reasoning.control is ReasoningControl.ON- assert prepared.routed.reasoning.effort is ReasoningEffort.HIGH- assert request.max_tokens == 18_432---def test_known_unsupported_reasoning_is_rejected_but_unknown_is_allowed():- unsupported = ChatContextBuilder(- FakeRuntime(configured=ProviderModelInfo("model", supports_thinking=False))- )- try:- unsupported.prepare(_transcript(), system_prompt="")- except ChatValidationError as exc:- assert "Thinking" in str(exc) or "thinking" in str(exc)- else:- raise AssertionError("Known unsupported reasoning was accepted")-- unknown = ChatContextBuilder(- FakeRuntime(configured=ProviderModelInfo("model", supports_thinking=None))- )- assert unknown.prepare(- _transcript(), system_prompt=""- ).routed.reasoning.requests_reasoning---def test_compaction_disables_reasoning_for_known_non_reasoning_model():- routed = ChatContextBuilder(- FakeRuntime(- configured=ProviderModelInfo(- "model",- supports_thinking=False,- max_output_tokens=20_000,- )- )- ).prepare_summary(- model_ref="groq/model",- source="Summarize this conversation.",- output_tokens=4_096,- )-- assert routed.reasoning.control is ReasoningControl.OFF- assert routed.request.max_tokens == 4_096---def test_unknown_context_disables_auto_compaction_without_inventing_a_limit():- builder = ChatContextBuilder(- FakeRuntime(configured=ProviderModelInfo("model", context_window_tokens=None))- )- estimate = builder.prepare(_transcript(), system_prompt="").estimate-- assert estimate.context_window_tokens is None- assert estimate.usage_ratio is None- assert estimate.should_auto_compact is False---def test_known_context_reserves_input_when_output_cap_is_unknown():- builder = ChatContextBuilder(- FakeRuntime(- configured=ProviderModelInfo(- "model",- context_window_tokens=16_384,- max_output_tokens=None,- )- )- )-- prepared = builder.prepare(- _transcript(reasoning=ChatReasoning.OFF),- system_prompt="",- draft="hello",- )-- assert prepared.routed.request.max_tokens == 15_360- assert prepared.estimate.usable_input_tokens == 1_024- assert prepared.estimate.usage_ratio == (- prepared.estimate.estimated_input_tokens / 16_384- )---def test_auto_compaction_uses_visible_context_ratio_with_fit_safety():- transcript = _transcript(reasoning=ChatReasoning.OFF)- transcript = ChatTranscript(- session=transcript.session,- turns=transcript.turns * 2,- compaction=None,- )- builder = ChatContextBuilder(- FakeRuntime(- configured=ProviderModelInfo(- "model",- context_window_tokens=100_000,- max_output_tokens=4_096,- )- )- )-- below = builder.prepare(- transcript,- system_prompt="",- draft="token " * 83_000,- ).estimate- above = builder.prepare(- transcript,- system_prompt="",- draft="token " * 86_000,- ).estimate-- assert below.usable_input_tokens is not None- assert below.usage_ratio is not None and below.usage_ratio < 0.85- assert below.estimated_input_tokens / below.usable_input_tokens > 0.85- assert below.should_auto_compact is False- assert above.usage_ratio is not None and above.usage_ratio > 0.85- assert above.should_auto_compact is True-- tight = (- ChatContextBuilder(- FakeRuntime(- configured=ProviderModelInfo(- "model",- context_window_tokens=40_000,- max_output_tokens=20_000,- )- )- )- .prepare(- transcript,- system_prompt="",- draft="token " * 24_000,- )- .estimate- )- assert tight.usable_input_tokens is not None- assert tight.usage_ratio is not None and tight.usage_ratio < 0.85- assert tight.estimated_input_tokens > tight.usable_input_tokens- assert tight.should_auto_compact is True---def test_existing_compaction_replaces_only_covered_context():- runtime = FakeRuntime(- configured=ProviderModelInfo("model", context_window_tokens=100_000)- )- transcript = _transcript(- reasoning=ChatReasoning.OFF,- compaction=ChatCompaction(- session_id="session",- covered_through_sequence=1,- summary="durable summary",- estimated_tokens=10,- requested_model="groq/model",- actual_model="groq/model",- updated_at=2,- ),- )- request = (- ChatContextBuilder(runtime)- .prepare(- transcript,- system_prompt="",- draft="new message",- )- .routed.request- )-- assert len(request.messages) == 2- assert "durable summary" in str(request.messages[0].content)- assert request.messages[1].content == "new message"diff --git a/tests/application/test_chat_service.py b/tests/application/test_chat_service.pydeleted file mode 100644index c5a26e82..00000000--- a/tests/application/test_chat_service.py+++ /dev/null@@ -1,2895 +0,0 @@-import asyncio-import sqlite3-import threading-from collections.abc import AsyncIterator, Awaitable, Callable, Mapping-from dataclasses import dataclass-from pathlib import Path--import pytest--from free_claude_code.application.chat import (- ChatConflictError,- ChatEventSubscriptionPort,- ChatNotFoundError,- ChatOperationAcknowledgement,- ChatOperationKind,- ChatReasoning,- ChatService,- ChatSession,- ChatUnavailableError,- GenerationStatus,-)-from free_claude_code.application.model_metadata import ProviderModelInfo-from free_claude_code.application.ports import ProviderPort, RequestRuntimeLease-from free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic import MessagesRequest-from free_claude_code.core.anthropic.streaming import format_sse_event-from free_claude_code.core.failures import ExecutionFailure, FailureKind-from free_claude_code.core.interprocess_lock import InterprocessFileLock-from free_claude_code.core.openai_responses import OpenAIResponsesRequest-from free_claude_code.core.reasoning import ReasoningPolicy-from free_claude_code.runtime.chat_sqlite import SQLiteChatStore--[email protected]("repair_fails", [False, True])-async def test_cancelled_startup_drains_retirement_worker_before_releasing_lock(- tmp_path, monkeypatch, repair_fails-):- store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- await store.start()- original_run = store._run_sync- entered = threading.Event()- release = threading.Event()- finished = threading.Event()-- def blocked_run(operation):- entered.set()- assert release.wait(5)- try:- if repair_fails:- raise OSError("injected repair failure after cancellation")- return original_run(operation)- finally:- finished.set()-- monkeypatch.setattr(store, "_run_sync", blocked_run)- service = ChatService(FakeRuntime(FakeChatProvider()), store)- task = asyncio.create_task(service.start())- replacement_lock = InterprocessFileLock(tmp_path / "chat.lock")- try:- assert await asyncio.to_thread(entered.wait, 2)- task.cancel()- await asyncio.sleep(0.05)- assert not task.done()- assert not finished.is_set()- assert not replacement_lock.acquire()- release.set()- with pytest.raises(asyncio.CancelledError):- await task- assert finished.is_set()- assert replacement_lock.acquire()- finally:- release.set()- await asyncio.gather(task, return_exceptions=True)- replacement_lock.release()- await service.close()--[email protected]("supports_thinking", [True, False, None])-async def test_retired_chat_selection_startup_and_stale_patch(- tmp_path, monkeypatch, supports_thinking-):- runtime = FakeRuntime(FakeChatProvider())- monkeypatch.setattr(- runtime,- "cached_model_info",- lambda provider_id, model_id: ProviderModelInfo(- model_id, supports_thinking=supports_thinking- ),- )- store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- await store.start()- old = await store.create_session(- session_id="aaaaaaaa-aaaa-4aaa-aaaa-aaaaaaaaaaaa",- model="github_models/old",- reasoning=ChatReasoning.HIGH,- )- await store.close()- service = ChatService(runtime, store)- await service.start()- try:- assert service.availability() == (True, None)- repaired = await service.get_session(old.id)- assert repaired.model == runtime.settings.model- assert repaired.revision == old.revision + 1- expected_reasoning = (- ChatReasoning.OFF if supports_thinking is False else ChatReasoning.HIGH- )- assert repaired.reasoning is expected_reasoning- with pytest.raises(ChatConflictError):- await service.update_session(- old.id,- expected_revision=old.revision,- title=None,- model="github_models/old",- reasoning=None,- )- assert await service.get_session(old.id) == repaired- # Simulate a stale tab submitting an old selection while thinking is enabled.- enabled = await store.update_session(- old.id,- expected_revision=repaired.revision,- title=None,- model=None,- reasoning=ChatReasoning.HIGH,- )- patched = await service.update_session(- old.id,- expected_revision=enabled.revision,- title=None,- model="github_models/old",- reasoning=None,- )- assert patched.model == runtime.settings.model- assert patched.reasoning is expected_reasoning- assert runtime.leases == []- finally:- await service.close()--[email protected]("cancel", [True, False])-async def test_chat_retirement_failure_releases_store_lock(- tmp_path, monkeypatch, cancel-):- store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- service = ChatService(FakeRuntime(FakeChatProvider()), store)-- async def fail_repair(**kwargs):- if cancel:- raise asyncio.CancelledError()- raise OSError("injected repair failure")-- monkeypatch.setattr(store, "repair_retired_model_selections", fail_repair)- if cancel:- with pytest.raises(asyncio.CancelledError):- await service.start()- else:- await service.start()- assert not service.availability()[0]- replacement = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- await replacement.start()- await replacement.close()- await service.close()---async def test_chat_retirement_failed_cleanup_is_retried_before_start(- tmp_path, monkeypatch-):- store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- service = ChatService(FakeRuntime(FakeChatProvider()), store)- original_repair = store.repair_retired_model_selections- original_close = store.close-- async def fail_repair(**kwargs):- raise OSError("injected repair failure")-- async def fail_close():- raise OSError("injected cleanup failure")-- monkeypatch.setattr(store, "repair_retired_model_selections", fail_repair)- monkeypatch.setattr(store, "close", fail_close)- await service.start()- assert not service.availability()[0]- monkeypatch.setattr(store, "repair_retired_model_selections", original_repair)- monkeypatch.setattr(store, "close", original_close)- await service.start()- try:- assert service.availability() == (True, None)- await service.create_session()- finally:- await service.close()---class FakeChatProvider:- def __init__(- self,- *,- block_after_delta: bool = False,- truncate_summary: bool = False,- ) -> None:- self.block_after_delta = block_after_delta- self.truncate_summary = truncate_summary- self.started = asyncio.Event()- self.closed = 0- self.requests: list[MessagesRequest] = []-- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- ) -> None:- del reasoning- self.requests.append(request)-- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy,- ) -> None:- raise AssertionError((request, reasoning))-- async def stream_messages(- self,- request: MessagesRequest,- *,- input_tokens: int,- request_id: str,- response_model: str,- reasoning: ReasoningPolicy,- request_headers: Mapping[str, str] | None = None,- model_info: ProviderModelInfo | None = None,- ) -> AsyncIterator[str]:- del input_tokens, request_id, response_model, reasoning- text = "summary" if str(request.system).startswith("Summarize") else "answer"- frames = [- format_sse_event(- "message_start",- {"type": "message_start", "message": {"content": []}},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "thinking", "thinking": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "thinking_delta", "thinking": "thought"},- },- ),- format_sse_event(- "content_block_stop", {"type": "content_block_stop", "index": 0}- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 1,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": text},- },- ),- ]- try:- wire = "".join(frames)- midpoint = len(wire) // 2- yield wire[:midpoint]- yield wire[midpoint:]- self.started.set()- if self.truncate_summary and text == "summary":- return- if self.block_after_delta:- await asyncio.Event().wait()- yield format_sse_event(- "content_block_stop", {"type": "content_block_stop", "index": 1}- )- yield format_sse_event(- "message_delta",- {"type": "message_delta", "delta": {"stop_reason": "end_turn"}},- )- yield format_sse_event("message_stop", {"type": "message_stop"})- finally:- self.closed += 1-- async def stream_responses(- self,- request: OpenAIResponsesRequest,- *,- input_tokens: int,- request_id: str,- response_model: str,- reasoning: ReasoningPolicy,- request_headers: Mapping[str, str] | None = None,- ) -> AsyncIterator[str]:- raise AssertionError(- (request, input_tokens, request_id, response_model, reasoning)- )- yield ""---def _context_failure() -> ExecutionFailure:- return ExecutionFailure(- kind=FailureKind.CONTEXT_WINDOW_EXCEEDED,- status_code=400,- message="Provider input exceeds the model context window.",- retryable=False,- )---class ContextRecoveryProvider(FakeChatProvider):- def __init__(self) -> None:- super().__init__()- self.generation_failures = 0- self.generation_failure_after_segment = False- self.generation_attempts = 0- self.summary_batch_limit: int | None = None- self.summary_failure: ExecutionFailure | None = None- self.summary_batch_sizes: list[int] = []- self.block_summary = False- self.summary_started = asyncio.Event()-- async def stream_messages(- self,- request: MessagesRequest,- *,- input_tokens: int,- request_id: str,- response_model: str,- reasoning: ReasoningPolicy,- request_headers: Mapping[str, str] | None = None,- model_info: ProviderModelInfo | None = None,- ) -> AsyncIterator[str]:- is_summary = str(request.system).startswith("Summarize")- if is_summary:- source = request.messages[0].content- if not isinstance(source, str):- raise AssertionError("Compaction source must be text.")- batch_size = source.count("USER\n")- self.summary_batch_sizes.append(batch_size)- self.summary_started.set()- if self.block_summary:- await asyncio.Event().wait()- if self.summary_failure is not None:- raise self.summary_failure- if (- self.summary_batch_limit is not None- and batch_size > self.summary_batch_limit- ):- raise _context_failure()- else:- self.generation_attempts += 1- if self.generation_failures > 0:- self.generation_failures -= 1- if self.generation_failure_after_segment:- yield format_sse_event(- "message_start",- {"type": "message_start", "message": {"content": []}},- )- yield format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- )- raise _context_failure()-- async for frame in super().stream_messages(- request,- input_tokens=input_tokens,- request_id=request_id,- response_model=response_model,- reasoning=reasoning,- ):- yield frame---class MixedFallbackFailureProvider(ContextRecoveryProvider):- def __init__(self) -> None:- super().__init__()- self.fail_candidates = False-- async def stream_messages(- self,- request: MessagesRequest,- *,- input_tokens: int,- request_id: str,- response_model: str,- reasoning: ReasoningPolicy,- request_headers: Mapping[str, str] | None = None,- model_info: ProviderModelInfo | None = None,- ) -> AsyncIterator[str]:- if self.fail_candidates and not str(request.system).startswith("Summarize"):- if request.model == "model":- raise ExecutionFailure(- kind=FailureKind.PERMISSION,- status_code=403,- message="primary denied access",- retryable=False,- )- if request.model == "fallback":- raise _context_failure()- raise AssertionError(f"Unexpected fallback model: {request.model}")- async for frame in super().stream_messages(- request,- input_tokens=input_tokens,- request_id=request_id,- response_model=response_model,- reasoning=reasoning,- ):- yield frame---class BackpressuredCompletionProvider(FakeChatProvider):- async def stream_messages(- self,- request: MessagesRequest,- *,- input_tokens: int,- request_id: str,- response_model: str,- reasoning: ReasoningPolicy,- request_headers: Mapping[str, str] | None = None,- model_info: ProviderModelInfo | None = None,- ) -> AsyncIterator[str]:- del request, input_tokens, request_id, response_model, reasoning- yield format_sse_event(- "message_start",- {"type": "message_start", "message": {"content": []}},- )- yield format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- )- for _ in range(125):- yield format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "x"},- },- )- yield format_sse_event(- "content_block_stop", {"type": "content_block_stop", "index": 0}- )- yield format_sse_event(- "message_delta",- {"type": "message_delta", "delta": {"stop_reason": "end_turn"}},- )- yield format_sse_event("message_stop", {"type": "message_stop"})---class FakeLease:- def __init__(- self,- settings: Settings,- provider: FakeChatProvider,- model_infos: tuple[ProviderModelInfo, ...],- ) -> None:- self._settings = settings- self._provider = provider- self.model_infos = model_infos- self.released = 0-- @property- def generation_id(self) -> int:- return 1-- @property- def settings(self) -> Settings:- return self._settings-- def is_provider_cached(self, provider_id: str) -> bool:- return provider_id == "groq"-- def resolve_provider(self, provider_id: str) -> ProviderPort:- assert provider_id == "groq"- return self._provider-- async def release(self) -> None:- self.released += 1---class FakeRuntime:- def __init__(- self,- provider: FakeChatProvider,- *,- context_window_tokens: int | None = 100_000,- ) -> None:- self.settings = Settings().model_copy(- update={- "model": "groq/model",- "model_fallbacks": None,- "provider_progress_timeout": 5.0,- }- )- self.provider = provider- self.context_window_tokens = context_window_tokens- self.leases: list[FakeLease] = []-- async def acquire(- self, *, include_model_infos: bool = False- ) -> RequestRuntimeLease:- lease = FakeLease(- self.settings,- self.provider,- (- ProviderModelInfo(- "groq/model",- supports_thinking=True,- context_window_tokens=self.context_window_tokens,- max_output_tokens=20_000,- ),- )- if include_model_infos- else (),- )- self.leases.append(lease)- return lease-- def current_settings(self) -> Settings:- return self.settings-- def cached_model_info(- self, provider_id: str, model_id: str- ) -> ProviderModelInfo | None:- if (provider_id, model_id) == ("groq", "model"):- return ProviderModelInfo(- "model",- supports_thinking=True,- context_window_tokens=self.context_window_tokens,- max_output_tokens=20_000,- )- return None-- def cached_prefixed_model_infos(self) -> tuple[ProviderModelInfo, ...]:- return ()---async def _service(- tmp_path: Path, provider: FakeChatProvider-) -> tuple[ChatService, FakeRuntime, SQLiteChatStore]:- runtime = FakeRuntime(provider)- store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- service = ChatService(runtime, store)- await service.start()- return service, runtime, store---_TURN_TERMINAL_EVENTS = frozenset(- {"turn.completed", "turn.failed", "turn.stopped", "operation.failed"}-)-_COMPACTION_TERMINAL_EVENTS = frozenset(- {- "compaction.completed",- "compaction.failed",- "compaction.stopped",- "operation.failed",- }-)---@dataclass(slots=True)-class _ObservedOperation:- acknowledgement: ChatOperationAcknowledgement- subscription: ChatEventSubscriptionPort-- async def aclose(self) -> None:- await self.subscription.aclose()---async def _observe_call[**P](- service: ChatService,- command: Callable[P, Awaitable[ChatOperationAcknowledgement]],- *args: P.args,- **kwargs: P.kwargs,-) -> _ObservedOperation:- subscription, _active = await service.subscribe()- try:- acknowledgement = await command(*args, **kwargs)- except BaseException:- await subscription.aclose()- raise- return _ObservedOperation(acknowledgement, subscription)---async def _drain(operation: _ObservedOperation) -> list[str]:- events: list[str] = []- terminal_events = (- _COMPACTION_TERMINAL_EVENTS- if operation.acknowledgement.kind is ChatOperationKind.COMPACT- else _TURN_TERMINAL_EVENTS- )- try:- async for event in operation.subscription:- if event.data.get("operation_id") != operation.acknowledgement.operation_id:- continue- assert event.data["kind"] == operation.acknowledgement.kind.value- events.append(event.event)- if event.event in terminal_events:- break- finally:- await operation.aclose()- return events---async def _seed_completed_turns(- service: ChatService,- session: ChatSession,- *,- count: int,- operation_offset: int = 1,-) -> ChatSession:- current = session- for index in range(operation_offset, operation_offset + count):- operation = await _observe_call(- service,- service.send,- current.id,- expected_revision=current.revision,- operation_id=f"00000000-0000-4000-8000-{index:012d}",- text=f"turn {index}",- )- assert (await _drain(operation))[-1] == "turn.completed"- current = await service.get_session(current.id)- return current---async def test_send_streams_and_persists_interleaved_segments(tmp_path: Path):- provider = FakeChatProvider()- service, runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="b21677f0-aa9a-4acb-b197-64d3dbd56536",- text="hello",- )- events = await _drain(stream)-- transcript = await store.get_transcript(session.id)- generation = transcript.turns[0].generation- assert events[-1] == "turn.completed"- assert [segment.text for segment in generation.segments] == [- "thought",- "answer",- ]- assert generation.actual_model == "groq/model"- assert runtime.leases[0].released == 1- assert provider.closed == 1- finally:- await service.close()---async def test_completion_persistence_exhaustion_never_downgrades_to_failed(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- statuses: list[GenerationStatus] = []- original_finish_generation = store.finish_generation-- async def unavailable_completion(*args, **kwargs):- status = kwargs["status"]- statuses.append(status)- if len(statuses) <= 2:- raise ChatUnavailableError("Chat storage is temporarily unavailable.")- return await original_finish_generation(*args, **kwargs)-- monkeypatch.setattr(store, "finish_generation", unavailable_completion)- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="f69c7c4d-9a46-40f0-b6ad-7f288a2c2dd7",- text="finish successfully",- )-- assert (await _drain(stream))[-1] == "turn.failed"- assert statuses == [GenerationStatus.COMPLETED, GenerationStatus.COMPLETED]- generation = (await store.get_transcript(session.id)).turns[0].generation- assert generation.status is GenerationStatus.RUNNING- assert service.availability() == (- False,- "Chat storage became unavailable. Restart FCC to repair Chat Sessions.",- )- finally:- await service.close()---async def test_regeneration_retries_an_ambiguous_terminal_commit(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- initial = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="e8476211-c6a1-45c4-a463-b7d92bfcc7d8",- text="answer once",- )- assert (await _drain(initial))[-1] == "turn.completed"- before = await store.get_transcript(session.id)- original_id = before.turns[0].generation.id-- attempts = 0- original_finish_regeneration = store.finish_regeneration-- async def ambiguous_finish_regeneration(*args, **kwargs):- nonlocal attempts- attempts += 1- result = await original_finish_regeneration(*args, **kwargs)- if attempts == 1:- raise ChatUnavailableError("Chat commit result was unavailable.")- return result-- monkeypatch.setattr(- store,- "finish_regeneration",- ambiguous_finish_regeneration,- )- replacement = await _observe_call(- service,- service.regenerate,- session.id,- expected_revision=before.session.revision,- operation_id="8a99c4a9-e4f5-4ebd-a8c9-982a9227a557",- )-- assert (await _drain(replacement))[-1] == "turn.completed"- after = await store.get_transcript(session.id)- assert attempts == 2- assert after.turns[0].generation.id != original_id- assert after.turns[0].generation.status is GenerationStatus.COMPLETED- assert service.availability()[0] is True- finally:- await service.close()---async def test_failed_regeneration_replaces_original_with_failed_generation(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- initial = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="01355e92-06c4-4820-b80a-fc8e0dff2553",- text="replace this answer",- )- assert (await _drain(initial))[-1] == "turn.completed"- before = await store.get_transcript(session.id)- original_id = before.turns[0].generation.id-- async def failing_stream(*args, **kwargs):- del args, kwargs- yield "".join(- (- format_sse_event(- "message_start",- {"type": "message_start", "message": {"content": []}},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "partial"},- },- ),- format_sse_event(- "error",- {- "type": "error",- "error": {"message": "provider failed"},- },- ),- )- )-- monkeypatch.setattr(provider, "stream_messages", failing_stream)- replacement = await _observe_call(- service,- service.regenerate,- session.id,- expected_revision=before.session.revision,- operation_id="810b8d15-adab-4df6-9084-3189ca534d09",- )-- assert (await _drain(replacement))[-1] == "turn.failed"- generation = (await store.get_transcript(session.id)).turns[0].generation- assert generation.id != original_id- assert generation.status is GenerationStatus.FAILED- assert generation.error_message == "provider failed"- assert generation.segments[-1].text == "partial"- finally:- await service.close()---async def test_stopped_regeneration_retries_an_ambiguous_discard(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- initial = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="14e14878-842d-425a-952c-4e9f105760c0",- text="keep the original answer",- )- assert (await _drain(initial))[-1] == "turn.completed"- before = await store.get_transcript(session.id)- original_generation = before.turns[0].generation-- discard_attempts = 0- segment_writes = 0- original_discard_generation = store.discard_generation- original_replace_segments = store.replace_generation_segments-- async def ambiguous_discard(*args, **kwargs):- nonlocal discard_attempts- discard_attempts += 1- await original_discard_generation(*args, **kwargs)- if discard_attempts == 1:- raise ChatUnavailableError("Chat commit result was unavailable.")-- async def observed_replace_segments(*args, **kwargs):- nonlocal segment_writes- segment_writes += 1- return await original_replace_segments(*args, **kwargs)-- monkeypatch.setattr(store, "discard_generation", ambiguous_discard)- monkeypatch.setattr(- store, "replace_generation_segments", observed_replace_segments- )- provider.started.clear()- provider.block_after_delta = True- replacement = await _observe_call(- service,- service.regenerate,- session.id,- expected_revision=before.session.revision,- operation_id="19cbb991-38ff-4cd2-a20e-f94783f78003",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)- writes_before_stop = segment_writes-- assert await service.stop(- session.id,- operation_id="19cbb991-38ff-4cd2-a20e-f94783f78003",- )- assert (await _drain(replacement))[-1] == "turn.stopped"-- after = await store.get_transcript(session.id)- assert discard_attempts == 2- assert segment_writes == writes_before_stop- assert after.turns[0].generation == original_generation- assert service.availability()[0] is True- finally:- await service.close()---async def test_closing_subscription_does_not_cancel_active_operation(- tmp_path: Path,-):- provider = FakeChatProvider(block_after_delta=True)- service, runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="9781df8c-aa92-422e-97d9-e9ea7f542b89",- text="hello",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)- await stream.aclose()-- assert runtime.leases[0].released == 0- assert provider.closed == 0-- replacement_subscription, active_operations = await service.subscribe()- assert [active.operation_id for active in active_operations] == [- stream.acknowledgement.operation_id- ]- replacement_observer = _ObservedOperation(- stream.acknowledgement, replacement_subscription- )- assert await service.stop(- session.id,- operation_id=stream.acknowledgement.operation_id,- )- events = await asyncio.wait_for(_drain(replacement_observer), timeout=1)-- generation = (await store.get_transcript(session.id)).turns[0].generation- assert events[-1] == "turn.stopped"- assert generation.status is GenerationStatus.STOPPED- assert generation.segments[-1].text == "answer"- assert runtime.leases[0].released == 1- assert provider.closed == 1- finally:- await service.close()---async def test_stop_retries_transient_terminal_persistence_failure(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider(block_after_delta=True)- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- operation_id = "3a1c071f-f558-4be3-a072-f9af230352ec"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="survive one storage failure",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)-- attempts = 0- original_finish_generation = store.finish_generation-- async def flaky_finish_generation(*args, **kwargs):- nonlocal attempts- attempts += 1- if attempts == 1:- raise ChatUnavailableError("Chat storage is temporarily unavailable.")- return await original_finish_generation(*args, **kwargs)-- monkeypatch.setattr(store, "finish_generation", flaky_finish_generation)-- assert await service.stop(session.id, operation_id=operation_id) is True- assert (await _drain(stream))[-1] == "turn.stopped"-- transcript = await store.get_transcript(session.id)- assert attempts == 2- assert transcript.turns[-1].generation.status is GenerationStatus.STOPPED- snapshot_subscription, active_operations = await service.subscribe()- await snapshot_subscription.aclose()- assert active_operations == ()-- provider.block_after_delta = False- replacement = await _observe_call(- service,- service.send,- session.id,- expected_revision=transcript.session.revision,- operation_id="f5190fdb-ce16-402d-a5a2-1633ba0cae55",- text="keep going",- )- assert (await _drain(replacement))[-1] == "turn.completed"- finally:- await service.close()---async def test_stop_retries_transient_terminal_segment_flush(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider(block_after_delta=True)- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- operation_id = "242841f6-d826-48b5-9ed7-bf073b17840e"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="preserve the final partial segment",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)-- attempts = 0- original_replace_segments = store.replace_generation_segments-- async def flaky_replace_segments(*args, **kwargs):- nonlocal attempts- attempts += 1- if attempts == 1:- raise ChatUnavailableError("Chat storage is temporarily unavailable.")- return await original_replace_segments(*args, **kwargs)-- monkeypatch.setattr(- store, "replace_generation_segments", flaky_replace_segments- )-- assert await service.stop(session.id, operation_id=operation_id) is True- assert (await _drain(stream))[-1] == "turn.stopped"-- generation = (await store.get_transcript(session.id)).turns[-1].generation- assert attempts == 2- assert generation.status is GenerationStatus.STOPPED- assert generation.segments[-1].text == "answer"- finally:- await service.close()---async def test_terminal_persistence_failure_disables_chat_instead_of_lying(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider(block_after_delta=True)- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- operation_id = "f744570e-0ec6-4f70-b74d-19de6bc60547"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="surface a persistent storage failure",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)-- attempts = 0-- async def unavailable_finish_generation(*args, **kwargs):- nonlocal attempts- attempts += 1- raise ChatUnavailableError("Chat storage is unavailable.")-- monkeypatch.setattr(- store,- "finish_generation",- unavailable_finish_generation,- )-- assert await service.stop(session.id, operation_id=operation_id) is True- assert (await _drain(stream))[-1] == "turn.failed"- assert attempts == 2-- available, message = service.availability()- assert available is False- assert message == (- "Chat storage became unavailable. Restart FCC to repair Chat Sessions."- )- with pytest.raises(ChatUnavailableError, match="Restart FCC"):- await service.get_detail(session.id)-- generation = (await store.get_transcript(session.id)).turns[-1].generation- assert generation.status is GenerationStatus.RUNNING- finally:- await service.close()---async def test_immediate_stop_before_operation_task_starts_releases_owner(- tmp_path: Path,-):- provider = FakeChatProvider()- service, _runtime, _store = await _service(tmp_path, provider)- try:- session = await service.create_session()- operation_id = "2029b65e-f4d9-4b80-8c6a-563a32fb8b8f"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="stop before start",- )-- assert await service.stop(session.id, operation_id=operation_id) is True- assert (await _drain(stream))[-1] == "turn.stopped"-- replacement = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="4b50506e-92bf-46ba-aa35-333dc0946e14",- text="still usable",- )- assert (await _drain(replacement))[-1] == "turn.completed"- finally:- await service.close()---async def test_ambiguous_generation_start_adopts_the_committed_owner(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- original_begin_send = store.begin_send-- async def ambiguous_begin_send(*args, **kwargs):- await original_begin_send(*args, **kwargs)- raise ChatUnavailableError("Chat commit result was unavailable.")-- monkeypatch.setattr(store, "begin_send", ambiguous_begin_send)- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="cc47acc3-d7c2-46d0-a1b6-fe2acda191e4",- text="recover the committed start",- )-- assert (await _drain(stream))[-1] == "turn.completed"- generation = (await store.get_transcript(session.id)).turns[0].generation- assert generation.status is GenerationStatus.COMPLETED- assert (- await service.stop(- session.id,- operation_id="cc47acc3-d7c2-46d0-a1b6-fe2acda191e4",- )- is False- )- assert service.availability()[0] is True- finally:- await service.close()---async def test_disconnect_does_not_interrupt_failure_terminalization(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- release_flush = asyncio.Event()- try:-- async def failing_stream(*args, **kwargs):- del args, kwargs- yield "".join(- (- format_sse_event(- "message_start",- {"type": "message_start", "message": {"content": []}},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "partial"},- },- ),- format_sse_event(- "error",- {- "type": "error",- "error": {"message": "provider failed"},- },- ),- )- )-- monkeypatch.setattr(provider, "stream_messages", failing_stream)- entered_flush = asyncio.Event()- original_replace_segments = store.replace_generation_segments-- async def blocked_replace_segments(generation_id, segments):- entered_flush.set()- await release_flush.wait()- await original_replace_segments(generation_id, segments)-- monkeypatch.setattr(- store,- "replace_generation_segments",- blocked_replace_segments,- )- session = await service.create_session()- operation_id = "63523531-024d-47f2-a0ce-ff7104d4e3af"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="fail before disconnect",- )- await asyncio.wait_for(entered_flush.wait(), timeout=1)-- await stream.aclose()- replacement_subscription, _active = await service.subscribe()- replacement_observer = _ObservedOperation(- stream.acknowledgement, replacement_subscription- )- release_flush.set()-- assert (await _drain(replacement_observer))[-1] == "turn.failed"- generation = (await store.get_transcript(session.id)).turns[0].generation- assert generation.status is GenerationStatus.FAILED- assert await service.stop(session.id, operation_id=operation_id) is False- assert service.availability()[0] is True- finally:- release_flush.set()- await service.close()---async def test_second_operation_on_same_session_is_rejected(tmp_path: Path):- provider = FakeChatProvider(block_after_delta=True)- service, _runtime, _store = await _service(tmp_path, provider)- try:- session = await service.create_session()- first = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="3e363fbc-25ee-414e-a954-02d11990497f",- text="first",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)- running = await service.get_session(session.id)- with pytest.raises(ChatConflictError, match="active operation"):- await _observe_call(- service,- service.send,- session.id,- expected_revision=running.revision,- operation_id="223ad9ac-e830-42ec-b73d-b1cbd81511c4",- text="second",- )- await first.aclose()- finally:- await service.close()---async def test_durable_mutations_publish_once_and_stale_mutation_publishes_nothing(- tmp_path: Path,-):- service, _runtime, _store = await _service(tmp_path, FakeChatProvider())- subscription, active_operations = await service.subscribe()- assert active_operations == ()- events = subscription.__aiter__()- try:- session = await service.create_session()- created = await anext(events)-- with pytest.raises(ChatConflictError, match="another tab"):- await service.update_session(- session.id,- expected_revision=session.revision + 10,- title="Stale title",- model=None,- reasoning=None,- )-- updated = await service.update_session(- session.id,- expected_revision=session.revision,- title="Durable title",- model=None,- reasoning=None,- )- update_event = await anext(events)- preferences = await service.save_system_prompt("Shared prompt")- preferences_event = await anext(events)- await service.delete_session(- session.id,- expected_revision=updated.revision,- )- deleted = await anext(events)-- assert [- (created.id, created.event),- (update_event.id, update_event.event),- (preferences_event.id, preferences_event.event),- (deleted.id, deleted.event),- ] == [- (1, "session.created"),- (2, "session.updated"),- (3, "preferences.updated"),- (4, "session.deleted"),- ]- assert update_event.data["revision"] == updated.revision- assert preferences_event.data["updated_at"] == preferences.updated_at- finally:- await subscription.aclose()- await service.close()---async def test_delete_validates_stale_revision_before_cancelling_active_send(- tmp_path: Path,-):- provider = FakeChatProvider(block_after_delta=True)- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- operation_id = "3b4390e2-bbd0-499a-94c5-d7813b1d5f75"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="keep running",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)- assert (await service.get_session(session.id)).revision > session.revision-- with pytest.raises(ChatConflictError, match="another tab"):- await service.delete_session(- session.id,- expected_revision=session.revision,- )-- assert await service.stop(session.id, operation_id=operation_id) is True- generation = (await store.get_transcript(session.id)).turns[0].generation- assert generation.status is GenerationStatus.STOPPED- await stream.aclose()- finally:- await service.close()---async def test_delete_active_send_finishes_generation_before_removing_session(- tmp_path: Path,-):- provider = FakeChatProvider(block_after_delta=True)- service, _runtime, _store = await _service(tmp_path, provider)- try:- session = await service.create_session()- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="0162e7e5-aabd-4ffb-ae50-ed864825ec71",- text="delete me",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)- running = await service.get_session(session.id)-- await service.delete_session(session.id, expected_revision=running.revision)-- with pytest.raises(ChatNotFoundError):- await service.get_session(session.id)- await stream.aclose()- finally:- await service.close()---async def test_cancellation_waits_for_generation_start_commit_before_cleanup(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider(block_after_delta=True)- service, _runtime, store = await _service(tmp_path, provider)- blocker: sqlite3.Connection | None = None- try:- session = await service.create_session()- initial_stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="7f4c7a3f-c06e-42c3-9887-f748dc5aa518",- text="partial answer",- )- await asyncio.wait_for(provider.started.wait(), timeout=5)- assert await service.stop(- session.id,- operation_id="7f4c7a3f-c06e-42c3-9887-f748dc5aa518",- )- await initial_stream.aclose()-- entered = asyncio.Event()- original_begin_retry = store.begin_retry-- async def observed_begin_retry(*args, **kwargs):- entered.set()- return await original_begin_retry(*args, **kwargs)-- monkeypatch.setattr(store, "begin_retry", observed_begin_retry)- blocker = sqlite3.connect(tmp_path / "chat.db", isolation_level=None)- blocker.execute("PRAGMA journal_mode = WAL")- blocker.execute("BEGIN IMMEDIATE")-- current = await service.get_session(session.id)- retry_stream = await _observe_call(- service,- service.retry,- session.id,- expected_revision=current.revision,- operation_id="38dcb3e5-04b7-4ecf-bc8b-7c72550839b0",- )- await asyncio.wait_for(entered.wait(), timeout=1)- await asyncio.sleep(0.05)-- stop_task = asyncio.create_task(- service.stop(- session.id,- operation_id=retry_stream.acknowledgement.operation_id,- )- )- await asyncio.sleep(0.05)- waited_for_commit = not stop_task.done()- blocker.commit()- blocker.close()- blocker = None- assert await asyncio.wait_for(stop_task, timeout=1) is True- assert (await _drain(retry_stream))[-1] == "turn.stopped"-- generation = (await store.get_transcript(session.id)).turns[-1].generation- assert waited_for_commit- assert generation.status is GenerationStatus.STOPPED- finally:- if blocker is not None:- blocker.rollback()- blocker.close()- await service.close()---async def test_repeated_cancellation_waits_for_terminal_cleanup(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider(block_after_delta=True)- service, _runtime, store = await _service(tmp_path, provider)- blocker: sqlite3.Connection | None = None- try:- session = await service.create_session()- operation_id = "f02c0da7-1ec9-4433-bef3-dc760753e451"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="preserve partial output",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)-- entered_cleanup = asyncio.Event()- original_replace_segments = store.replace_generation_segments-- async def observed_replace_segments(generation_id, segments):- entered_cleanup.set()- await original_replace_segments(generation_id, segments)-- monkeypatch.setattr(- store,- "replace_generation_segments",- observed_replace_segments,- )- blocker = sqlite3.connect(tmp_path / "chat.db", isolation_level=None)- blocker.execute("PRAGMA journal_mode = WAL")- blocker.execute("BEGIN IMMEDIATE")-- first_stop_task = asyncio.create_task(- service.stop(session.id, operation_id=operation_id)- )- await asyncio.wait_for(entered_cleanup.wait(), timeout=1)- second_stop_task = asyncio.create_task(- service.stop(session.id, operation_id=operation_id)- )- await asyncio.sleep(0.05)-- assert not first_stop_task.done()- assert not second_stop_task.done()- blocker.commit()- blocker.close()- blocker = None- assert await asyncio.wait_for(first_stop_task, timeout=1) is True- assert await asyncio.wait_for(second_stop_task, timeout=1) is True- assert (await _drain(stream))[-1] == "turn.stopped"-- generation = (await store.get_transcript(session.id)).turns[0].generation- assert generation.status is GenerationStatus.STOPPED- assert await service.stop(session.id, operation_id=operation_id) is False- finally:- if blocker is not None:- blocker.rollback()- blocker.close()- await service.close()---async def test_stop_at_generation_commit_preserves_completed_result(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- entered_commit = asyncio.Event()- release_commit = asyncio.Event()- original_finish_generation = store.finish_generation-- async def observed_finish_generation(*args, **kwargs):- entered_commit.set()- await release_commit.wait()- return await original_finish_generation(*args, **kwargs)-- monkeypatch.setattr(store, "finish_generation", observed_finish_generation)- session = await service.create_session()- operation_id = "03ba5dce-bd47-452c-a878-229d4df65944"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="finish this answer",- )- await asyncio.wait_for(entered_commit.wait(), timeout=1)-- stop_task = asyncio.create_task(- service.stop(session.id, operation_id=operation_id)- )- assert await asyncio.wait_for(stop_task, timeout=1) is False- release_commit.set()-- events = await _drain(stream)- generation = (await store.get_transcript(session.id)).turns[0].generation- assert events[-1] == "turn.completed"- assert generation.status is GenerationStatus.COMPLETED- finally:- await service.close()---async def test_snapshot_never_advertises_unpublished_terminal_sequence(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- service, _runtime, _store = await _service(tmp_path, FakeChatProvider())- release_terminal = asyncio.Event()- late_subscription: ChatEventSubscriptionPort | None = None- fresh_subscription: ChatEventSubscriptionPort | None = None- try:- entered_terminal = asyncio.Event()- original_release_active = service._release_active-- async def observed_release_active(active):- entered_terminal.set()- await release_terminal.wait()- return await original_release_active(active)-- monkeypatch.setattr(service, "_release_active", observed_release_active)- session = await service.create_session()- operation_id = "025295bc-d2f5-4208-9dab-ed507471fb33"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="publish this terminal event",- )- await asyncio.wait_for(entered_terminal.wait(), timeout=1)-- late_subscription, active = await service.subscribe()- assert len(active) == 1- assert active[0].operation_id == operation_id- snapshot_sequence = active[0].operation_sequence-- release_terminal.set()- late_events = late_subscription.__aiter__()- terminal = await asyncio.wait_for(anext(late_events), timeout=1)- assert terminal.event == "turn.completed"- assert terminal.data["operation_sequence"] == snapshot_sequence + 1- assert (await _drain(stream))[-1] == "turn.completed"-- fresh_subscription, current_active = await service.subscribe()- assert current_active == ()- finally:- release_terminal.set()- if late_subscription is not None:- await late_subscription.aclose()- if fresh_subscription is not None:- await fresh_subscription.aclose()- await service.close()---async def test_stop_after_completed_regeneration_cannot_discard_result(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- service, _runtime, store = await _service(tmp_path, FakeChatProvider())- release_terminal = asyncio.Event()- try:- session = await service.create_session()- initial = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="25362cff-95ae-4051-9d15-36317753eb29",- text="replace this answer",- )- await _drain(initial)- before = await store.get_transcript(session.id)-- entered_terminal = asyncio.Event()- original_release_active = service._release_active-- async def observed_release_active(active):- entered_terminal.set()- await release_terminal.wait()- return await original_release_active(active)-- discarded = 0- original_discard_generation = store.discard_generation-- async def observed_discard_generation(*args, **kwargs):- nonlocal discarded- discarded += 1- return await original_discard_generation(*args, **kwargs)-- monkeypatch.setattr(service, "_release_active", observed_release_active)- monkeypatch.setattr(store, "discard_generation", observed_discard_generation)- operation_id = "a2f69564-3eb5-4805-8578-2be42d710e5a"- replacement = await _observe_call(- service,- service.regenerate,- session.id,- expected_revision=before.session.revision,- operation_id=operation_id,- )- await asyncio.wait_for(entered_terminal.wait(), timeout=1)-- assert await service.stop(session.id, operation_id=operation_id) is False- release_terminal.set()- assert (await _drain(replacement))[-1] == "turn.completed"-- after = await store.get_transcript(session.id)- assert discarded == 0- assert after.turns[-1].generation.status is GenerationStatus.COMPLETED- assert service.availability()[0] is True- finally:- release_terminal.set()- await service.close()---async def test_delete_waits_for_terminal_settlement_before_removing_session(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- service, _runtime, store = await _service(tmp_path, FakeChatProvider())- release_commit = asyncio.Event()- try:- entered_commit = asyncio.Event()- original_finish_generation = store.finish_generation-- async def observed_finish_generation(*args, **kwargs):- entered_commit.set()- await release_commit.wait()- return await original_finish_generation(*args, **kwargs)-- monkeypatch.setattr(store, "finish_generation", observed_finish_generation)- session = await service.create_session()- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="77a5fc8a-6043-49f9-a291-b0545bd47ed8",- text="finish before deletion",- )- await asyncio.wait_for(entered_commit.wait(), timeout=1)- running = await service.get_session(session.id)-- delete_task = asyncio.create_task(- service.delete_session(session.id, expected_revision=running.revision)- )- await asyncio.sleep(0.05)- assert not delete_task.done()- release_commit.set()- await asyncio.wait_for(delete_task, timeout=1)-- with pytest.raises(ChatNotFoundError):- await service.get_session(session.id)- await stream.aclose()- finally:- release_commit.set()- await service.close()---async def test_cancelled_delete_request_still_finishes_accepted_deletion(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider(block_after_delta=True)- service, _runtime, store = await _service(tmp_path, provider)- release_settlement = asyncio.Event()- subscription: ChatEventSubscriptionPort | None = None- try:- entered_settlement = asyncio.Event()- original_finish_generation = store.finish_generation-- async def observed_finish_generation(*args, **kwargs):- entered_settlement.set()- await release_settlement.wait()- return await original_finish_generation(*args, **kwargs)-- monkeypatch.setattr(store, "finish_generation", observed_finish_generation)- session = await service.create_session()- subscription, _active = await service.subscribe()- operation_id = "cd352568-fefd-4324-8062-9dadc4efbba6"- await service.send(- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="delete this chat",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)- running = await service.get_session(session.id)-- request_task = asyncio.create_task(- service.delete_session(session.id, expected_revision=running.revision)- )- await asyncio.wait_for(entered_settlement.wait(), timeout=1)- request_task.cancel()- await asyncio.sleep(0.05)- assert not request_task.done()-- release_settlement.set()- with pytest.raises(asyncio.CancelledError):- await asyncio.wait_for(request_task, timeout=1)- with pytest.raises(ChatNotFoundError):- await service.get_session(session.id)-- events = subscription.__aiter__()- while True:- event = await asyncio.wait_for(anext(events), timeout=1)- if event.event == "session.deleted":- break- fresh_subscription, active = await service.subscribe()- try:- assert active == ()- finally:- await fresh_subscription.aclose()- finally:- release_settlement.set()- if subscription is not None:- await subscription.aclose()- await service.close()--[email protected]("drain_feeds", [False, True])-async def test_close_waits_for_terminal_settlement(- tmp_path: Path, monkeypatch, drain_feeds-):- service, _runtime, store = await _service(tmp_path, FakeChatProvider())- release_commit = asyncio.Event()- service_closed = False- reopened: SQLiteChatStore | None = None- try:- entered_commit = asyncio.Event()- original_finish_generation = store.finish_generation-- async def observed_finish_generation(*args, **kwargs):- entered_commit.set()- await release_commit.wait()- return await original_finish_generation(*args, **kwargs)-- monkeypatch.setattr(store, "finish_generation", observed_finish_generation)- session = await service.create_session()- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="aa6d0128-de80-43ff-ab8c-aa1f7c4bf5ba",- text="finish before shutdown",- )- await asyncio.wait_for(entered_commit.wait(), timeout=1)-- if drain_feeds:- service.begin_shutdown()- service.begin_shutdown()- assert service.availability()[0] is False- with pytest.raises(ChatUnavailableError):- await service.subscribe()- with pytest.raises(StopAsyncIteration):- await asyncio.wait_for(- anext(stream.subscription.__aiter__()), timeout=1- )-- close_task = asyncio.create_task(service.close())- await asyncio.sleep(0.05)- assert not close_task.done()- release_commit.set()- await asyncio.wait_for(close_task, timeout=1)- service_closed = True- await stream.aclose()-- reopened = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- await reopened.start()- transcript = await reopened.get_transcript(session.id)- assert transcript.turns[-1].generation.status is GenerationStatus.COMPLETED- finally:- release_commit.set()- if reopened is not None:- await reopened.close()- if not service_closed:- await service.close()---async def test_cancelled_stop_waiter_does_not_cancel_supervisor(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider(block_after_delta=True)- service, _runtime, store = await _service(tmp_path, provider)- release_settlement = asyncio.Event()- try:- entered_settlement = asyncio.Event()- original_finish_generation = store.finish_generation-- async def observed_finish_generation(*args, **kwargs):- entered_settlement.set()- await release_settlement.wait()- return await original_finish_generation(*args, **kwargs)-- monkeypatch.setattr(store, "finish_generation", observed_finish_generation)- session = await service.create_session()- operation_id = "13d97a77-aef0-4f2c-8415-1525ab70c427"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="stop independently of this request",- )- await asyncio.wait_for(provider.started.wait(), timeout=1)-- stop_task = asyncio.create_task(- service.stop(session.id, operation_id=operation_id)- )- await asyncio.wait_for(entered_settlement.wait(), timeout=1)- stop_task.cancel()- await asyncio.sleep(0.05)- assert not stop_task.done()-- release_settlement.set()- with pytest.raises(asyncio.CancelledError):- await asyncio.wait_for(stop_task, timeout=1)- assert (await _drain(stream))[-1] == "turn.stopped"- transcript = await store.get_transcript(session.id)- assert transcript.turns[-1].generation.status is GenerationStatus.STOPPED- finally:- release_settlement.set()- await service.close()---async def test_terminal_event_precedes_best_effort_summary(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- service, _runtime, store = await _service(tmp_path, FakeChatProvider())- release_summary = asyncio.Event()- fresh_subscription: ChatEventSubscriptionPort | None = None- try:- entered_summary = asyncio.Event()- blocked_summary = False- original_get_session_summary = store.get_session_summary-- async def observed_get_session_summary(session_id: str):- nonlocal blocked_summary- transcript = await store.get_transcript(session_id)- completed = bool(- transcript.turns- and transcript.turns[-1].generation.status is GenerationStatus.COMPLETED- )- if completed and not blocked_summary:- blocked_summary = True- entered_summary.set()- await release_summary.wait()- raise ChatUnavailableError("Summary read failed.")- return await original_get_session_summary(session_id)-- monkeypatch.setattr(- store,- "get_session_summary",- observed_get_session_summary,- )- session = await service.create_session()- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="526be960-a16f-4d83-8f02-d51568003b60",- text="publish before the summary",- )-- assert (await _drain(stream))[-1] == "turn.completed"- await asyncio.wait_for(entered_summary.wait(), timeout=1)- fresh_subscription, active = await service.subscribe()- assert active == ()-- current = await service.get_session(session.id)- next_stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=current.revision,- operation_id="ee7985a6-adf8-454f-9785-53d13c4eef8d",- text="start while the old summary waits",- )- release_summary.set()- assert (await _drain(next_stream))[-1] == "turn.completed"- assert service.availability()[0] is True- finally:- release_summary.set()- if fresh_subscription is not None:- await fresh_subscription.aclose()- await service.close()---async def test_detail_snapshot_keeps_operation_owner_visible_through_completion(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- release_commit = asyncio.Event()- release_snapshot = asyncio.Event()- try:- entered_commit = asyncio.Event()- committed = asyncio.Event()- original_finish_generation = store.finish_generation-- async def observed_finish_generation(*args, **kwargs):- entered_commit.set()- await release_commit.wait()- result = await original_finish_generation(*args, **kwargs)- committed.set()- return result-- monkeypatch.setattr(store, "finish_generation", observed_finish_generation)- session = await service.create_session()- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="9e34cdcb-3d56-44f2-8921-a5d43cb0ed20",- text="complete while detail loads",- )- await asyncio.wait_for(entered_commit.wait(), timeout=1)-- entered_snapshot = asyncio.Event()- original_get_transcript = store.get_transcript-- async def observed_get_transcript(session_id: str):- entered_snapshot.set()- await release_snapshot.wait()- return await original_get_transcript(session_id)-- monkeypatch.setattr(store, "get_transcript", observed_get_transcript)- detail_task = asyncio.create_task(service.get_detail(session.id))- await asyncio.wait_for(entered_snapshot.wait(), timeout=1)-- release_commit.set()- await asyncio.wait_for(committed.wait(), timeout=1)- release_snapshot.set()- detail = await asyncio.wait_for(detail_task, timeout=1)- await _drain(stream)-- assert not hasattr(detail, "active_operation")- assert detail.session.revision > session.revision- finally:- release_commit.set()- release_snapshot.set()- await service.close()---async def test_terminal_event_releases_owner_while_an_older_detail_read_waits(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- release_commit = asyncio.Event()- release_snapshot = asyncio.Event()- try:- entered_commit = asyncio.Event()- original_finish_generation = store.finish_generation-- async def observed_finish_generation(*args, **kwargs):- entered_commit.set()- await release_commit.wait()- return await original_finish_generation(*args, **kwargs)-- monkeypatch.setattr(store, "finish_generation", observed_finish_generation)- session = await service.create_session()- operation_id = "7f4dcfd1-bc69-4df1-9737-f434d357133a"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="finish while detail owns the lifecycle lock",- )- await asyncio.wait_for(entered_commit.wait(), timeout=1)-- entered_snapshot = asyncio.Event()- original_get_transcript = store.get_transcript-- async def observed_get_transcript(session_id: str):- entered_snapshot.set()- await release_snapshot.wait()- return await original_get_transcript(session_id)-- monkeypatch.setattr(store, "get_transcript", observed_get_transcript)- detail_task = asyncio.create_task(service.get_detail(session.id))- await asyncio.wait_for(entered_snapshot.wait(), timeout=1)-- release_commit.set()- assert (await asyncio.wait_for(_drain(stream), timeout=1))[-1] == (- "turn.completed"- )- release_snapshot.set()- older_detail = await asyncio.wait_for(detail_task, timeout=1)- assert not hasattr(older_detail, "active_operation")-- current_detail = await service.get_detail(session.id)- assert not hasattr(current_detail, "active_operation")-- current = await service.get_session(session.id)- next_stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=current.revision,- operation_id="87f5dd83-ee78-48d8-82f5-b65cd91034fc",- text="the next operation can start",- )- await _drain(next_stream)- finally:- release_commit.set()- release_snapshot.set()- await service.close()---async def test_disconnect_after_durable_completion_cannot_downgrade_status(- tmp_path: Path,-):- provider = BackpressuredCompletionProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="80354cee-d3b1-4760-963f-9cc7a1558ffc",- text="fill the event queue",- )-- async def wait_for_completion() -> None:- while True:- transcript = await store.get_transcript(session.id)- if (- transcript.turns- and transcript.turns[0].generation.status- is GenerationStatus.COMPLETED- ):- return- await asyncio.sleep(0)-- await asyncio.wait_for(wait_for_completion(), timeout=1)- await stream.aclose()-- generation = (await store.get_transcript(session.id)).turns[0].generation- assert generation.status is GenerationStatus.COMPLETED- assert generation.stop_reason == "end_turn"- finally:- await service.close()--[email protected]("operation_kind", ["send", "regenerate"])-async def test_context_failure_compacts_once_and_retries_same_operation(- tmp_path: Path,- operation_kind: str,-) -> None:- provider = ContextRecoveryProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await _seed_completed_turns(- service,- await service.create_session(),- count=2,- )- prior_generation_id = (- (await store.get_transcript(session.id)).turns[-1].generation.id- )- provider.generation_attempts = 0- provider.summary_batch_sizes.clear()- provider.generation_failures = 1-- if operation_kind == "send":- operation = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000100",- text="recover this send",- )- else:- operation = await _observe_call(- service,- service.regenerate,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000101",- )- events = await _drain(operation)-- transcript = await store.get_transcript(session.id)- generation = transcript.turns[-1].generation- assert events.count("turn.started") == 1- assert events.count("compaction.started") == 1- assert events.count("compaction.completed") == 1- assert events[-1] == "turn.completed"- assert "turn.failed" not in events- assert provider.generation_attempts == 2- assert provider.summary_batch_sizes == [1]- assert transcript.compaction is not None- assert generation.status is GenerationStatus.COMPLETED- if operation_kind == "send":- assert len(transcript.turns) == 3- else:- assert len(transcript.turns) == 2- assert generation.id != prior_generation_id- generation_requests = [- request- for request in provider.requests- if not str(request.system).startswith("Summarize")- ]- retried_messages = generation_requests[-1].messages- assert all(message.role != "assistant" for message in retried_messages)- finally:- await service.close()---async def test_mixed_fallback_failures_do_not_trigger_context_recovery(- tmp_path: Path,-) -> None:- provider = MixedFallbackFailureProvider()- service, runtime, store = await _service(tmp_path, provider)- try:- session = await _seed_completed_turns(- service,- await service.create_session(),- count=2,- )- runtime.settings = runtime.settings.model_copy(- update={"model_fallbacks": ("groq/fallback",)}- )- provider.fail_candidates = True- provider.summary_batch_sizes.clear()-- operation = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000105",- text="do not compact for mixed failures",- )- events = await _drain(operation)-- transcript = await store.get_transcript(session.id)- generation = transcript.turns[-1].generation- assert events.count("compaction.started") == 0- assert events[-1] == "turn.failed"- assert transcript.compaction is None- assert provider.summary_batch_sizes == []- assert generation.status is GenerationStatus.FAILED- assert generation.error_code == FailureKind.CONTEXT_WINDOW_EXCEEDED.value- finally:- await service.close()---async def test_retry_context_failure_reuses_failed_generation_after_compaction(- tmp_path: Path,-) -> None:- provider = ContextRecoveryProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await _seed_completed_turns(- service,- await service.create_session(),- count=1,- )- provider.generation_failures = 1- provider.generation_failure_after_segment = True- failed = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000110",- text="fail after output starts",- )- assert (await _drain(failed))[-1] == "turn.failed"- transcript = await store.get_transcript(session.id)- failed_generation_id = transcript.turns[-1].generation.id- assert transcript.compaction is None-- session = transcript.session- provider.generation_attempts = 0- provider.summary_batch_sizes.clear()- provider.generation_failure_after_segment = False- provider.generation_failures = 1- retry = await _observe_call(- service,- service.retry,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000111",- )- events = await _drain(retry)-- transcript = await store.get_transcript(session.id)- generation = transcript.turns[-1].generation- assert events.count("turn.started") == 1- assert events.count("compaction.started") == 1- assert events.count("compaction.completed") == 1- assert events[-1] == "turn.completed"- assert generation.id == failed_generation_id- assert generation.status is GenerationStatus.COMPLETED- assert provider.generation_attempts == 2- assert provider.summary_batch_sizes == [1]- finally:- await service.close()---async def test_second_context_failure_finishes_as_one_failed_generation(- tmp_path: Path,-) -> None:- provider = ContextRecoveryProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await _seed_completed_turns(- service,- await service.create_session(),- count=2,- )- provider.generation_attempts = 0- provider.generation_failures = 2- operation = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000120",- text="still too large after compaction",- )- events = await _drain(operation)-- transcript = await store.get_transcript(session.id)- generation = transcript.turns[-1].generation- assert events.count("turn.started") == 1- assert events.count("compaction.started") == 1- assert events.count("compaction.completed") == 1- assert events.count("turn.failed") == 1- assert provider.generation_attempts == 2- assert generation.status is GenerationStatus.FAILED- assert generation.error_code == FailureKind.CONTEXT_WINDOW_EXCEEDED.value- finally:- await service.close()---async def test_uncompactable_context_failure_keeps_canonical_error(- tmp_path: Path,-) -> None:- provider = ContextRecoveryProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- provider.generation_failures = 1- operation = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000125",- text="one oversized turn",- )- events = await _drain(operation)-- transcript = await store.get_transcript(session.id)- generation = transcript.turns[-1].generation- assert events.count("compaction.started") == 0- assert events[-1] == "turn.failed"- assert transcript.compaction is None- assert generation.error_code == FailureKind.CONTEXT_WINDOW_EXCEEDED.value- assert generation.error_message == (- "Provider input exceeds the model context window."- )- finally:- await service.close()---async def test_stop_during_reactive_compaction_stops_the_original_generation(- tmp_path: Path,-) -> None:- provider = ContextRecoveryProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await _seed_completed_turns(- service,- await service.create_session(),- count=2,- )- provider.generation_failures = 1- provider.block_summary = True- provider.summary_started.clear()- operation = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000130",- text="stop while compacting",- )- await asyncio.wait_for(provider.summary_started.wait(), timeout=1)-- assert await service.stop(- session.id,- operation_id=operation.acknowledgement.operation_id,- )- events = await _drain(operation)-- transcript = await store.get_transcript(session.id)- assert events.count("compaction.started") == 1- assert events[-1] == "turn.stopped"- assert transcript.compaction is None- assert transcript.turns[-1].generation.status is GenerationStatus.STOPPED- finally:- await service.close()---async def test_unknown_context_compaction_halves_only_whole_exchange_batches(- tmp_path: Path,-) -> None:- provider = ContextRecoveryProvider()- runtime = FakeRuntime(provider, context_window_tokens=None)- store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- service = ChatService(runtime, store)- await service.start()- try:- session = await _seed_completed_turns(- service,- await service.create_session(),- count=8,- )- provider.summary_batch_limit = 2- provider.summary_batch_sizes.clear()- compact = await _observe_call(- service,- service.compact,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000140",- )-- assert (await _drain(compact))[-1] == "compaction.completed"- assert provider.summary_batch_sizes == [4, 2, 2]- transcript = await store.get_transcript(session.id)- assert transcript.compaction is not None- assert transcript.compaction.covered_through_sequence == 4- assert len(transcript.turns) == 8- finally:- await service.close()---async def test_unknown_context_single_exchange_failure_is_actionable(- tmp_path: Path,-) -> None:- provider = ContextRecoveryProvider()- runtime = FakeRuntime(provider, context_window_tokens=None)- store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- service = ChatService(runtime, store)- await service.start()- try:- session = await _seed_completed_turns(- service,- await service.create_session(),- count=2,- )- provider.summary_batch_limit = 0- provider.summary_batch_sizes.clear()- compact = await _observe_call(- service,- service.compact,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000150",- )-- assert (await _drain(compact))[-1] == "compaction.failed"- assert provider.summary_batch_sizes == [1]- assert (await store.get_transcript(session.id)).compaction is None- finally:- await service.close()---async def test_unknown_context_non_context_summary_failure_is_not_resized(- tmp_path: Path,-) -> None:- provider = ContextRecoveryProvider()- runtime = FakeRuntime(provider, context_window_tokens=None)- store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- service = ChatService(runtime, store)- await service.start()- try:- session = await _seed_completed_turns(- service,- await service.create_session(),- count=6,- )- provider.summary_failure = ExecutionFailure(- kind=FailureKind.UPSTREAM,- status_code=502,- message="provider failed",- retryable=False,- )- provider.summary_batch_sizes.clear()- compact = await _observe_call(- service,- service.compact,- session.id,- expected_revision=session.revision,- operation_id="00000000-0000-4000-8000-000000000160",- )-- assert (await _drain(compact))[-1] == "compaction.failed"- assert provider.summary_batch_sizes == [2]- assert (await store.get_transcript(session.id)).compaction is None- finally:- await service.close()---async def test_stop_during_compaction_commit_waits_and_reports_completion(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- blocker: sqlite3.Connection | None = None- try:- session = await service.create_session()- for index, operation_id in enumerate(- (- "08ea4712-3732-4626-9590-ac78cd273982",- "35d15a22-88e4-476f-aec2-9c0cdfb5cb87",- )- ):- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text=f"turn {index}",- )- await _drain(stream)- session = await service.get_session(session.id)-- entered_commit = asyncio.Event()- original_upsert_compaction = store.upsert_compaction-- async def observed_upsert_compaction(*args, **kwargs):- entered_commit.set()- return await original_upsert_compaction(*args, **kwargs)-- monkeypatch.setattr(store, "upsert_compaction", observed_upsert_compaction)- blocker = sqlite3.connect(tmp_path / "chat.db", isolation_level=None)- blocker.execute("PRAGMA journal_mode = WAL")- blocker.execute("BEGIN IMMEDIATE")-- operation_id = "b15f0721-acd3-482f-812d-28d2d3cc568b"- compact = await _observe_call(- service,- service.compact,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- )- await asyncio.wait_for(entered_commit.wait(), timeout=1)- stop_task = asyncio.create_task(- service.stop(session.id, operation_id=operation_id)- )- assert await asyncio.wait_for(stop_task, timeout=1) is False-- blocker.commit()- blocker.close()- blocker = None- events = await _drain(compact)-- transcript = await store.get_transcript(session.id)- assert events[-1] == "compaction.completed"- assert transcript.compaction is not None- assert transcript.compaction.covered_through_sequence == 1- finally:- if blocker is not None:- blocker.rollback()- blocker.close()- await service.close()---async def test_compaction_retries_an_ambiguous_commit_once(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- for operation_id, text in (- ("110ce497-5d5f-4659-b2c7-7ae4bf362900", "first"),- ("64de0c33-c956-4ac2-b172-9f9fc5caf13b", "second"),- ):- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text=text,- )- assert (await _drain(stream))[-1] == "turn.completed"- session = await service.get_session(session.id)-- revision_before_compaction = session.revision- attempts = 0- original_upsert_compaction = store.upsert_compaction-- async def ambiguous_upsert_compaction(*args, **kwargs):- nonlocal attempts- attempts += 1- result = await original_upsert_compaction(*args, **kwargs)- if attempts == 1:- raise ChatUnavailableError("Chat commit result was unavailable.")- return result-- monkeypatch.setattr(store, "upsert_compaction", ambiguous_upsert_compaction)- compact = await _observe_call(- service,- service.compact,- session.id,- expected_revision=session.revision,- operation_id="861cba8a-fca4-47eb-84cb-de1a7059714c",- )-- assert (await _drain(compact))[-1] == "compaction.completed"- transcript = await store.get_transcript(session.id)- assert attempts == 2- assert transcript.compaction is not None- assert transcript.session.revision == revision_before_compaction + 1- assert service.availability()[0] is True- finally:- await service.close()---async def test_manual_compaction_keeps_full_transcript_and_adds_checkpoint(- tmp_path: Path,-):- provider = FakeChatProvider()- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- first = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="e90f819b-a835-4c1f-80d7-6e7c17c429a7",- text="first",- )- await _drain(first)- session = await service.get_session(session.id)- second = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="8de64c2a-34c8-4b30-a880-37d3678c62de",- text="second",- )- await _drain(second)- session = await service.get_session(session.id)- compact = await _observe_call(- service,- service.compact,- session.id,- expected_revision=session.revision,- operation_id="b5c9bc6f-3b74-4218-bac5-17b6813f443a",- )- events = await _drain(compact)-- transcript = await store.get_transcript(session.id)- assert events[-1] == "compaction.completed"- assert len(transcript.turns) == 2- assert transcript.compaction is not None- assert transcript.compaction.covered_through_sequence == 1- assert transcript.compaction.summary == "summary"- finally:- await service.close()---async def test_manual_compaction_rejects_incomplete_summary_stream(tmp_path: Path):- provider = FakeChatProvider(truncate_summary=True)- service, _runtime, store = await _service(tmp_path, provider)- try:- session = await service.create_session()- for operation_id, text in (- ("560c7a0f-c074-489b-8b90-e7e031577716", "first"),- ("d77427c1-8417-4ab5-a380-94860c778db8", "second"),- ):- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text=text,- )- await _drain(stream)- session = await service.get_session(session.id)-- compact = await _observe_call(- service,- service.compact,- session.id,- expected_revision=session.revision,- operation_id="8895d9ae-c896-4af2-be44-d6328e1da736",- )- events = await _drain(compact)-- transcript = await store.get_transcript(session.id)- assert events[-1] == "compaction.failed"- assert transcript.compaction is None- finally:- await service.close()---async def test_send_auto_compacts_without_removing_original_turns(tmp_path: Path):- provider = FakeChatProvider()- runtime = FakeRuntime(provider, context_window_tokens=40_000)- store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- service = ChatService(runtime, store)- await service.start()- try:- session = await service.create_session()- operation_ids = (- "4e542b5b-8386-46d2-8643-67a523c216f0",- "86293f1e-2899-47b9-8590-27450fc00989",- "dd945983-b49c-4749-83b3-3051d3998bc2",- "3a4f8108-2cf4-45c1-b412-56a8551e7f8b",- )- for operation_id in operation_ids:- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="token " * 5_000,- )- await _drain(stream)- session = await service.get_session(session.id)-- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id="195faf19-ea0a-4633-ad81-a09734f5e17c",- text="token " * 5_000,- )- events = await _drain(stream)-- transcript = await store.get_transcript(session.id)- assert "compaction.started" in events- assert "compaction.completed" in events- assert len(transcript.turns) == 5- assert transcript.compaction is not None- assert transcript.compaction.covered_through_sequence >= 1- finally:- await service.close()---async def test_stop_during_auto_compaction_commit_keeps_checkpoint_without_new_turn(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-):- provider = FakeChatProvider()- runtime = FakeRuntime(provider, context_window_tokens=40_000)- store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")- service = ChatService(runtime, store)- await service.start()- blocker: sqlite3.Connection | None = None- try:- session = await service.create_session()- for operation_id in (- "d3bb405e-245f-4dbf-bbdd-b72508926367",- "d4fec5fe-a75a-4752-8c33-f51fd105774f",- "79cd9bd9-df33-4ed4-8a5c-5e34770a30f7",- "71ac3c34-7be1-4c26-b69e-f6f7193fa353",- ):- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="token " * 5_000,- )- await _drain(stream)- session = await service.get_session(session.id)-- entered_commit = asyncio.Event()- original_upsert_compaction = store.upsert_compaction-- async def observed_upsert_compaction(*args, **kwargs):- entered_commit.set()- return await original_upsert_compaction(*args, **kwargs)-- monkeypatch.setattr(store, "upsert_compaction", observed_upsert_compaction)- blocker = sqlite3.connect(tmp_path / "chat.db", isolation_level=None)- blocker.execute("PRAGMA journal_mode = WAL")- blocker.execute("BEGIN IMMEDIATE")-- operation_id = "443b12d9-8989-4bb5-a609-c9c2c0e2ecf5"- stream = await _observe_call(- service,- service.send,- session.id,- expected_revision=session.revision,- operation_id=operation_id,- text="token " * 5_000,- )- await asyncio.wait_for(entered_commit.wait(), timeout=1)- stop_task = asyncio.create_task(- service.stop(session.id, operation_id=operation_id)- )- await asyncio.sleep(0.05)- assert not stop_task.done()-- blocker.commit()- blocker.close()- blocker = None- assert await asyncio.wait_for(stop_task, timeout=1) is True- events = await _drain(stream)-- transcript = await store.get_transcript(session.id)- assert events[-2:] == ["compaction.completed", "turn.stopped"]- assert transcript.compaction is not None- assert len(transcript.turns) == 4- finally:- if blocker is not None:- blocker.rollback()- blocker.close()- await service.close()---async def test_storage_start_failure_disables_only_chat(tmp_path: Path):- database_path = tmp_path / "chat.db"- database_path.mkdir()- store = SQLiteChatStore(database_path, tmp_path / "chat.lock")- service = ChatService(FakeRuntime(FakeChatProvider()), store)-- await service.start()- try:- available, message = service.availability()- assert available is False- assert message == "Chat storage is unavailable."- with pytest.raises(ChatUnavailableError, match="storage is unavailable"):- await service.create_session()- finally:- await service.close()diff --git a/tests/application/test_execution.py b/tests/application/test_execution.pyindex 2a2ab696..d39b1116 100644--- a/tests/application/test_execution.py+++ b/tests/application/test_execution.py@@ -465,69 +465,6 @@ def _executor_stream()-async def test_candidate_observer_runs_once_before_committed_output() -> None:- provider = FakeProvider()- selected: list[str] = []- executor = ProviderExecutor(- lambda _provider_id: provider,- progress_timeout_seconds=1.0,- )-- async def observe(target: ProviderModelTarget) -> None:- selected.append(target.provider_model_ref)-- stream = executor.stream_messages(- _routed_request(),- raw_log_payload={},- request_id="req_candidate_observer",- candidate_selected=observe,- )-- assert [chunk async for chunk in stream]- assert selected == ["provider/provider-model"]---async def test_candidate_observer_records_only_successful_fallback() -> None:- primary = ControlledProvider([_execution_failure("overloaded")])- fallback = FakeProvider()- providers = {"provider": primary, "fallback": fallback}- selected: list[str] = []- executor = ProviderExecutor(- providers.__getitem__,- progress_timeout_seconds=1.0,- )- stream = executor.stream_messages(- _routed_request(_target("fallback", "model")),- raw_log_payload={},- request_id="req_candidate_fallback_observer",- candidate_selected=lambda target: selected.append(target.provider_model_ref),- )-- assert [chunk async for chunk in stream]- assert selected == ["fallback/model"]---async def test_candidate_observer_records_normal_empty_completion() -> None:- provider = ControlledProvider([])- selected: list[str] = []- executor = ProviderExecutor(- lambda _provider_id: provider,- progress_timeout_seconds=1.0,- )- stream = executor.stream_messages(- _routed_request(),- raw_log_payload={},- request_id="req_empty_candidate_observer",- candidate_selected=lambda target: selected.append(target.provider_model_ref),- )-- assert [chunk async for chunk in stream] == []- assert selected == ["provider/provider-model"]--@pytest.mark.asyncioasync def test_executor_routes_native_responses_without_messages_conversion() -> None:provider = ResponsesFakeProvider()@@ -876,7 +813,6 @@ async def test_primary_canonical_preflight_failure_selects_fallback() -> None:primary = ExecutionFailurePreflightProvider(primary_failure)fallback = ControlledProvider(["fallback-frame"])providers = {"provider": primary, "fallback": fallback}- failures: list[ExecutionFailure] = []executor = ProviderExecutor(providers.__getitem__,progress_timeout_seconds=60.0,@@ -886,11 +822,9 @@ async def test_primary_canonical_preflight_failure_selects_fallback() -> None:_routed_request(_target("fallback", "fallback-model")),raw_log_payload={},request_id="req_preflight_fallback",- candidate_failed=failures.append,)assert [chunk async for chunk in stream] == ["fallback-frame"]- assert failures == [primary_failure]assert primary.stream_calls == []assert fallback.preflight_calls[0][0].model == "fallback-model"diff --git a/tests/application/test_chat_events.py b/tests/application/test_session_events.pysimilarity index 100%rename from tests/application/test_chat_events.pyrename to tests/application/test_session_events.pydiff --git a/tests/cli/test_server_shutdown.py b/tests/cli/test_server_shutdown.pyindex 92ffbef1..e6a7a500 100644--- a/tests/cli/test_server_shutdown.py+++ b/tests/cli/test_server_shutdown.py@@ -41,7 +41,7 @@ async def test_supervisor_drains_admin_event_feed_without_forced_cancellation(def create_app(settings: Settings, *, restart_callback: RestartCallback):app = build_asgi_app(settings, restart_callback=restart_callback)- # Only provider discovery is external; retain the real Chat, HTTP,+ # Only provider discovery is external; retain the real Code, HTTP,# runtime cleanup, and supervisor lifecycle under investigation.monkeypatch.setattr(app.runtime.provider_manager, "warm_referenced_model_cache", AsyncMock()@@ -72,7 +72,7 @@ async def test_supervisor_drains_admin_event_feed_without_forced_cancellation(async with httpx.AsyncClient(timeout=3, trust_env=False) as client:status_url = f"http://127.0.0.1:{port}/admin/api/status"old_instance = (await client.get(status_url)).json()["instance_id"]- events_url = f"http://127.0.0.1:{port}/admin/api/chat/events"+ events_url = f"http://127.0.0.1:{port}/admin/api/code/events"async with (client.stream("GET", events_url) as first,client.stream("GET", events_url) as second,diff --git a/tests/runtime/test_chat_sqlite.py b/tests/runtime/test_chat_sqlite.pydeleted file mode 100644index 67132c08..00000000--- a/tests/runtime/test_chat_sqlite.py+++ /dev/null@@ -1,782 +0,0 @@-import asyncio-import sqlite3-import threading-import uuid-from contextlib import closing-from pathlib import Path--import pytest--from free_claude_code.application.chat import (- DEFAULT_CHAT_SYSTEM_PROMPT,- ChatConflictError,- ChatReasoning,- ChatSegment,- ChatUnavailableError,- GenerationStatus,- SegmentKind,-)-from free_claude_code.runtime.chat_sqlite import SQLiteChatStore--[email protected]("disable_reasoning", [True, False])[email protected]("healthy_preference", [True, False])-async def test_retirement_repairs_current_selections_only(- tmp_path, disable_reasoning, healthy_preference-):- store = _store(tmp_path)- await store.start()- try:- retired = await store.create_session(- session_id=_id(),- model="github_models/vendor/old",- reasoning=ChatReasoning.HIGH,- )- generation_id = _id()- await store.begin_send(- retired.id,- expected_revision=retired.revision,- turn_id=_id(),- generation_id=generation_id,- operation_id=_id(),- user_text="Keep history",- requested_model=retired.model,- reasoning=retired.reasoning,- effective_output_limit=100,- )- await store.set_generation_actual_model(generation_id, retired.model)- await store.finish_generation(- generation_id,- status=GenerationStatus.COMPLETED,- stop_reason="end_turn",- error_code=None,- error_message=None,- )- await store.upsert_compaction(- retired.id,- covered_through_sequence=1,- summary="Keep summary",- estimated_tokens=5,- requested_model=retired.model,- actual_model=retired.model,- )- before = await store.get_transcript(retired.id)- untouched = [- await store.create_session(- session_id=_id(), model=model, reasoning=ChatReasoning.MEDIUM- )- for model in ("githubXmodels/old", "github_models/", "groq/healthy")- ]- if not healthy_preference:- temporary = await store.create_session(- session_id=_id(), model=retired.model, reasoning=ChatReasoning.HIGH- )- await store.delete_session(- temporary.id, expected_revision=temporary.revision- )- preferences = await store.load_preferences()- assert (- await store.repair_retired_model_selections(- retired_provider_ids=frozenset({"github_models"}),- default_model="groq/default",- disable_reasoning=disable_reasoning,- )- == 1- )- after = await store.get_transcript(retired.id)- assert after.session.model == "groq/default"- assert after.session.revision == before.session.revision + 1- assert after.session.reasoning is (- ChatReasoning.OFF if disable_reasoning else ChatReasoning.HIGH- )- assert after.session.title == before.session.title- assert after.turns == before.turns- assert after.compaction == before.compaction- for session in untouched:- assert await store.get_session(session.id) == session- updated_preferences = await store.load_preferences()- if healthy_preference:- assert updated_preferences == preferences- else:- assert updated_preferences.last_model == "groq/default"- assert updated_preferences.last_reasoning is (- ChatReasoning.OFF if disable_reasoning else ChatReasoning.HIGH- )- assert (- await store.repair_retired_model_selections(- retired_provider_ids=frozenset({"github_models"}),- default_model="groq/default",- disable_reasoning=disable_reasoning,- )- == 0- )- assert await store.get_transcript(retired.id) == after- assert await store.load_preferences() == updated_preferences- finally:- await store.close()---async def test_retirement_repairs_global_preference_without_sessions(tmp_path):- store = _store(tmp_path)- await store.start()- try:- session = await store.create_session(- session_id=_id(), model="github_models/old", reasoning=ChatReasoning.HIGH- )- await store.delete_session(session.id, expected_revision=session.revision)- assert (- await store.repair_retired_model_selections(- retired_provider_ids=frozenset({"github_models"}),- default_model="groq/default",- disable_reasoning=True,- )- == 0- )- preferences = await store.load_preferences()- assert preferences.last_model == "groq/default"- assert preferences.last_reasoning is ChatReasoning.OFF- finally:- await store.close()---async def test_retirement_rolls_back_sessions_when_preference_update_fails(tmp_path):- store = _store(tmp_path)- await store.start()- try:- session = await store.create_session(- session_id=_id(), model="github_models/old", reasoning=ChatReasoning.HIGH- )- before = await store.load_preferences()- with closing(sqlite3.connect(tmp_path / "chat.db")) as connection:- connection.execute(- "CREATE TRIGGER fail_preference BEFORE UPDATE ON chat_settings BEGIN SELECT RAISE(ABORT, 'injected'); END"- )- connection.commit()- with pytest.raises(ChatUnavailableError):- await store.repair_retired_model_selections(- retired_provider_ids=frozenset({"github_models"}),- default_model="groq/default",- disable_reasoning=True,- )- assert await store.get_session(session.id) == session- assert await store.load_preferences() == before- finally:- await store.close()---def _id() -> str:- return str(uuid.uuid4())---def _store(tmp_path: Path) -> SQLiteChatStore:- return SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")---async def test_store_creates_schema_preferences_and_searchable_sessions(tmp_path: Path):- store = _store(tmp_path)- await store.start()- try:- preferences = await store.load_preferences()- assert preferences.system_prompt == DEFAULT_CHAT_SYSTEM_PROMPT- assert preferences.last_reasoning is ChatReasoning.MEDIUM-- first = await store.create_session(- session_id=_id(), model="groq/first", reasoning=ChatReasoning.MEDIUM- )- second = await store.create_session(- session_id=_id(), model="open_router/second", reasoning=ChatReasoning.OFF- )- renamed = await store.update_session(- first.id,- expected_revision=first.revision,- title="Café launch",- model=None,- reasoning=None,- )-- page = await store.list_sessions(query="CAFÉ", cursor=None, limit=25)- assert [session.id for session in page.sessions] == [renamed.id]- assert await store.get_session_summary(renamed.id) == page.sessions[0]- assert (await store.load_preferences()).last_model == second.model- finally:- await store.close()---async def test_store_rejects_stale_session_revision_atomically(tmp_path: Path):- store = _store(tmp_path)- await store.start()- try:- session = await store.create_session(- session_id=_id(), model="groq/model", reasoning=ChatReasoning.OFF- )- updated = await store.update_session(- session.id,- expected_revision=session.revision,- title="Current",- model=None,- reasoning=None,- )- with pytest.raises(ChatConflictError, match="another tab"):- await store.update_session(- session.id,- expected_revision=session.revision,- title="Stale",- model=None,- reasoning=None,- )- with pytest.raises(ChatConflictError, match="another tab"):- await store.delete_session(- session.id,- expected_revision=session.revision,- )- assert (await store.get_session(session.id)).title == updated.title- finally:- await store.close()---async def test_user_title_new_chat_is_not_replaced_on_first_turn(tmp_path: Path):- store = _store(tmp_path)- await store.start()- try:- session = await store.create_session(- session_id=_id(), model="groq/model", reasoning=ChatReasoning.OFF- )- renamed = await store.update_session(- session.id,- expected_revision=session.revision,- title="New chat",- model=None,- reasoning=None,- )-- await store.begin_send(- session.id,- expected_revision=renamed.revision,- turn_id=_id(),- generation_id=_id(),- operation_id=_id(),- user_text="First question",- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )-- assert (await store.get_session(session.id)).title == "New chat"- finally:- await store.close()---async def test_store_persists_generation_segments_and_actual_fallback(tmp_path: Path):- store = _store(tmp_path)- await store.start()- try:- session = await store.create_session(- session_id=_id(), model="groq/requested", reasoning=ChatReasoning.HIGH- )- generation_id = _id()- operation_id = _id()- turn = await store.begin_send(- session.id,- expected_revision=session.revision,- turn_id=_id(),- generation_id=generation_id,- operation_id=operation_id,- user_text="Explain this",- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=4096,- )- assert turn.operation_id == operation_id- assert await store.generation_start_committed(- session.id,- generation_id=generation_id,- staged=False,- )- assert not await store.generation_start_committed(- session.id,- generation_id=generation_id,- staged=True,- )- await store.set_generation_actual_model(generation_id, "open_router/fallback")- await store.replace_generation_segments(- generation_id,- (- ChatSegment(0, SegmentKind.THINKING, "considering"),- ChatSegment(1, SegmentKind.TEXT, "answer"),- ),- )- completed = await store.finish_generation(- generation_id,- status=GenerationStatus.COMPLETED,- stop_reason="end_turn",- error_code=None,- error_message=None,- )- repeated = await store.finish_generation(- generation_id,- status=GenerationStatus.STOPPED,- stop_reason="stopped",- error_code=None,- error_message=None,- )-- stored = (await store.get_transcript(session.id)).turns[0]- assert repeated.revision == completed.revision- assert stored.generation.status is GenerationStatus.COMPLETED- assert stored.generation.stop_reason == "end_turn"- assert stored.id == turn.id- assert stored.generation.actual_model == "open_router/fallback"- assert [segment.text for segment in stored.generation.segments] == [- "considering",- "answer",- ]- finally:- await store.close()---async def test_transcript_reads_one_revision_snapshot(- tmp_path: Path,- monkeypatch: pytest.MonkeyPatch,-) -> None:- store = _store(tmp_path)- await store.start()- release_read = threading.Event()- session_read = threading.Event()- try:- session = await store.create_session(- session_id=_id(), model="groq/model", reasoning=ChatReasoning.OFF- )- generation_id = _id()- await store.begin_send(- session.id,- expected_revision=session.revision,- turn_id=_id(),- generation_id=generation_id,- operation_id=_id(),- user_text="Keep one coherent snapshot",- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=4_096,- )- original_get_session = store._get_session- gate_next_read = True-- def gated_get_session(- connection: sqlite3.Connection,- session_id: str,- ):- nonlocal gate_next_read- current = original_get_session(connection, session_id)- if gate_next_read:- gate_next_read = False- session_read.set()- if not release_read.wait(timeout=5):- raise AssertionError(- "Timed out waiting to finish the transcript read."- )- return current-- monkeypatch.setattr(store, "_get_session", gated_get_session)- transcript_task = asyncio.create_task(store.get_transcript(session.id))- assert await asyncio.to_thread(session_read.wait, 1)-- completed = await store.finish_generation(- generation_id,- status=GenerationStatus.COMPLETED,- stop_reason="end_turn",- error_code=None,- error_message=None,- )- release_read.set()- transcript = await asyncio.wait_for(transcript_task, timeout=1)-- assert completed.revision == transcript.session.revision + 1- assert transcript.turns[0].generation.status is GenerationStatus.RUNNING- finally:- release_read.set()- await store.close()---async def test_retry_reuses_generation_and_replaces_partial_output(tmp_path: Path):- store = _store(tmp_path)- await store.start()- try:- session = await store.create_session(- session_id=_id(), model="groq/model", reasoning=ChatReasoning.OFF- )- generation_id = _id()- await store.begin_send(- session.id,- expected_revision=session.revision,- turn_id=_id(),- generation_id=generation_id,- operation_id=_id(),- user_text="hello",- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )- await store.replace_generation_segments(- generation_id, (ChatSegment(0, SegmentKind.TEXT, "partial"),)- )- session = await store.finish_generation(- generation_id,- status=GenerationStatus.STOPPED,- stop_reason="stopped",- error_code=None,- error_message=None,- )- retried = await store.begin_retry(- session.id,- expected_revision=session.revision,- requested_model="open_router/new",- reasoning=ChatReasoning.LOW,- effective_output_limit=2048,- )-- assert retried.id == generation_id- assert retried.status is GenerationStatus.RUNNING- assert retried.segments == ()- assert retried.requested_model == "open_router/new"- finally:- await store.close()---async def test_regeneration_keeps_visible_answer_until_atomic_swap(tmp_path: Path):- store = _store(tmp_path)- await store.start()- try:- session = await store.create_session(- session_id=_id(), model="groq/model", reasoning=ChatReasoning.OFF- )- original_id = _id()- await store.begin_send(- session.id,- expected_revision=session.revision,- turn_id=_id(),- generation_id=original_id,- operation_id=_id(),- user_text="hello",- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )- await store.replace_generation_segments(- original_id, (ChatSegment(0, SegmentKind.TEXT, "original"),)- )- session = await store.finish_generation(- original_id,- status=GenerationStatus.COMPLETED,- stop_reason="end_turn",- error_code=None,- error_message=None,- )- replacement_id = _id()- _turn, replacement = await store.begin_regenerate(- session.id,- expected_revision=session.revision,- generation_id=replacement_id,- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )- assert replacement.id == replacement_id- assert await store.generation_start_committed(- session.id,- generation_id=replacement_id,- staged=True,- )- assert not await store.generation_start_committed(- session.id,- generation_id=replacement_id,- staged=False,- )- assert (await store.get_transcript(session.id)).turns[- 0- ].generation.id == original_id-- await store.replace_generation_segments(- replacement_id, (ChatSegment(0, SegmentKind.TEXT, "replacement"),)- )- with pytest.raises(ChatConflictError, match="Staged"):- await store.finish_generation(- replacement_id,- status=GenerationStatus.COMPLETED,- stop_reason="end_turn",- error_code=None,- error_message=None,- )- await store.finish_regeneration(- replacement_id,- status=GenerationStatus.COMPLETED,- stop_reason="end_turn",- error_code=None,- error_message=None,- )- visible = (await store.get_transcript(session.id)).turns[0].generation- assert visible.id == replacement_id- assert visible.status is GenerationStatus.COMPLETED- assert visible.stop_reason == "end_turn"- assert visible.segments[0].text == "replacement"- finally:- await store.close()---async def test_failed_regeneration_atomically_replaces_visible_answer(tmp_path: Path):- store = _store(tmp_path)- await store.start()- try:- session = await store.create_session(- session_id=_id(), model="groq/model", reasoning=ChatReasoning.OFF- )- original_id = _id()- await store.begin_send(- session.id,- expected_revision=session.revision,- turn_id=_id(),- generation_id=original_id,- operation_id=_id(),- user_text="hello",- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )- session = await store.finish_generation(- original_id,- status=GenerationStatus.COMPLETED,- stop_reason="end_turn",- error_code=None,- error_message=None,- )- replacement_id = _id()- await store.begin_regenerate(- session.id,- expected_revision=session.revision,- generation_id=replacement_id,- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )- await store.replace_generation_segments(- replacement_id, (ChatSegment(0, SegmentKind.TEXT, "partial"),)- )-- finished = await store.finish_regeneration(- replacement_id,- status=GenerationStatus.FAILED,- stop_reason=None,- error_code="provider_error",- error_message="provider failed",- )- repeated = await store.finish_regeneration(- replacement_id,- status=GenerationStatus.FAILED,- stop_reason=None,- error_code="provider_error",- error_message="provider failed",- )-- visible = (await store.get_transcript(session.id)).turns[0].generation- assert repeated.revision == finished.revision- assert visible.id == replacement_id- assert visible.status is GenerationStatus.FAILED- assert visible.error_code == "provider_error"- assert visible.error_message == "provider failed"- assert visible.segments[0].text == "partial"- with closing(sqlite3.connect(tmp_path / "chat.db")) as connection:- assert connection.execute(- "SELECT COUNT(*) FROM chat_generations WHERE turn_id = "- "(SELECT turn_id FROM chat_generations WHERE id = ?)",- (replacement_id,),- ).fetchone() == (1,)- finally:- await store.close()---async def test_startup_recovers_visible_and_discards_staged_running_generations(- tmp_path: Path,-):- store = _store(tmp_path)- await store.start()- session = await store.create_session(- session_id=_id(), model="groq/model", reasoning=ChatReasoning.OFF- )- original_id = _id()- await store.begin_send(- session.id,- expected_revision=session.revision,- turn_id=_id(),- generation_id=original_id,- operation_id=_id(),- user_text="hello",- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )- await store.close()-- reopened = _store(tmp_path)- await reopened.start()- try:- generation = (await reopened.get_transcript(session.id)).turns[0].generation- assert generation.status is GenerationStatus.INTERRUPTED- assert generation.stop_reason == "server_restart"- finally:- await reopened.close()---async def test_startup_discards_uncommitted_regeneration_and_keeps_visible_answer(- tmp_path: Path,-):- store = _store(tmp_path)- await store.start()- session = await store.create_session(- session_id=_id(), model="groq/model", reasoning=ChatReasoning.OFF- )- original_id = _id()- await store.begin_send(- session.id,- expected_revision=session.revision,- turn_id=_id(),- generation_id=original_id,- operation_id=_id(),- user_text="hello",- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )- await store.replace_generation_segments(- original_id, (ChatSegment(0, SegmentKind.TEXT, "original"),)- )- session = await store.finish_generation(- original_id,- status=GenerationStatus.COMPLETED,- stop_reason="end_turn",- error_code=None,- error_message=None,- )- staged_id = _id()- await store.begin_regenerate(- session.id,- expected_revision=session.revision,- generation_id=staged_id,- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )- await store.close()-- reopened = _store(tmp_path)- await reopened.start()- try:- visible = (await reopened.get_transcript(session.id)).turns[0].generation- assert visible.id == original_id- with closing(sqlite3.connect(tmp_path / "chat.db")) as connection:- assert connection.execute(- "SELECT COUNT(*) FROM chat_generations WHERE id = ?", (staged_id,)- ).fetchone() == (0,)- finally:- await reopened.close()---async def test_startup_discards_terminal_staged_regeneration(tmp_path: Path):- store = _store(tmp_path)- await store.start()- session = await store.create_session(- session_id=_id(), model="groq/model", reasoning=ChatReasoning.OFF- )- original_id = _id()- await store.begin_send(- session.id,- expected_revision=session.revision,- turn_id=_id(),- generation_id=original_id,- operation_id=_id(),- user_text="hello",- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )- session = await store.finish_generation(- original_id,- status=GenerationStatus.COMPLETED,- stop_reason="end_turn",- error_code=None,- error_message=None,- )- staged_id = _id()- await store.begin_regenerate(- session.id,- expected_revision=session.revision,- generation_id=staged_id,- requested_model=session.model,- reasoning=session.reasoning,- effective_output_limit=1024,- )- await store.close()-- with closing(sqlite3.connect(tmp_path / "chat.db")) as connection:- connection.execute(- "UPDATE chat_generations SET status = 'completed' WHERE id = ?",- (staged_id,),- )- connection.commit()-- reopened = _store(tmp_path)- await reopened.start()- try:- with closing(sqlite3.connect(tmp_path / "chat.db")) as connection:- assert connection.execute(- "SELECT COUNT(*) FROM chat_generations WHERE id = ?", (staged_id,)- ).fetchone() == (0,)- finally:- await reopened.close()---async def test_failed_initial_schema_creation_does_not_claim_schema_version(- tmp_path: Path,-):- database = tmp_path / "chat.db"- with closing(sqlite3.connect(database)) as connection:- connection.execute("CREATE TABLE chat_settings (id INTEGER PRIMARY KEY)")-- store = _store(tmp_path)- with pytest.raises(ChatUnavailableError, match="storage is unavailable"):- await store.start()-- with closing(sqlite3.connect(database)) as connection:- assert connection.execute("PRAGMA user_version").fetchone() == (0,)---async def test_newer_schema_and_lock_contention_disable_only_chat(tmp_path: Path):- database = tmp_path / "newer.db"- with closing(sqlite3.connect(database)) as connection:- connection.execute("PRAGMA user_version = 99")- newer = SQLiteChatStore(database, tmp_path / "newer.lock")- with pytest.raises(ChatUnavailableError, match="newer FCC version"):- await newer.start()-- first = _store(tmp_path / "locked")- second = _store(tmp_path / "locked")- await first.start()- try:- with pytest.raises(ChatUnavailableError, match="another FCC server"):- await second.start()- finally:- await first.close()diff --git a/tests/runtime/test_retired_chat.py b/tests/runtime/test_retired_chat.pynew file mode 100644index 00000000..d939a130--- /dev/null+++ b/tests/runtime/test_retired_chat.py@@ -0,0 +1,293 @@+import asyncio+import sqlite3+import threading+from concurrent.futures import ThreadPoolExecutor+from contextlib import closing+from pathlib import Path+from unittest.mock import AsyncMock++import pytest+from loguru import logger++from free_claude_code.config import paths+from free_claude_code.config.loader import ManagedConfigStore+from free_claude_code.core.interprocess_lock import InterprocessFileLock+from free_claude_code.providers.runtime import ProviderRuntime+from free_claude_code.runtime.application import ApplicationRuntime+from free_claude_code.runtime.configuration import ConfigurationService+from free_claude_code.runtime.provider_manager import ProviderRuntimeManager+from free_claude_code.runtime.retired_chat import remove_retired_chat_history++[email protected](autouse=True)+def _offline_discovery(monkeypatch):+ monkeypatch.setattr(+ ProviderRuntimeManager, "warm_referenced_model_cache", AsyncMock()+ )+ monkeypatch.setattr(+ ProviderRuntimeManager, "start_model_list_refresh", lambda _: None+ )+++def cleanup_logs():+ messages = []+ sink = logger.add(lambda message: messages.append(str(message)))+ try:+ yield messages+ finally:+ logger.remove(sink)+++def _runtime():+ store = ManagedConfigStore()+ store.initialize()+ manager = ProviderRuntimeManager(+ store.read().settings,+ runtime_factory=lambda snapshot: ProviderRuntime(snapshot, {}),+ )+ return ApplicationRuntime(+ manager, configuration=ConfigurationService(store), transcriber=None+ )+++async def _start_and_close(runtime=None):+ runtime = runtime or _runtime()+ try:+ await runtime.start()+ finally:+ assert await runtime.close()+++def _history():+ directory = paths.config_dir_path() / "chat"+ directory.mkdir(parents=True)+ database = directory / "chat.db"+ with closing(sqlite3.connect(database)) as connection, connection:+ for name in (+ "chat_settings",+ "chat_sessions",+ "chat_turns",+ "chat_generations",+ "chat_generation_segments",+ "chat_compactions",+ ):+ connection.execute(f"CREATE TABLE {name} (saved TEXT)")+ connection.execute(f"INSERT INTO {name} VALUES (?)", ("old private data",))+ owned = [database]+ for suffix in ("-wal", "-shm", "-journal"):+ sidecar = directory / f"chat.db{suffix}"+ sidecar.write_bytes(b"old private sidecar")+ owned.append(sidecar)+ return directory, owned+++async def test_startup_removes_retired_history_and_preserves_other_files():+ runtime = _runtime()+ directory, owned = _history()+ root = paths.config_dir_path()+ preserved = {root / ".env": (root / ".env").read_bytes()}+ for relative in (+ "code/code.db",+ "code/code.db-wal",+ "messaging/sessions.json",+ "accounts.json",+ "chat/notes.txt",+ "chat/chat.db.backup",+ ):+ path = root / relative+ path.parent.mkdir(parents=True, exist_ok=True)+ path.write_bytes(b"keep this file")+ preserved[path] = path.read_bytes()+ await _start_and_close(runtime)+ assert not [path for path in owned if path.exists()]+ assert {path: path.read_bytes() for path in preserved} == preserved+ assert (directory / "chat.lock").is_file()+ await _start_and_close()+ assert not [path for path in owned if path.exists()]+++async def test_fresh_and_repeated_startup_do_not_create_chat_directory():+ await _start_and_close()+ await _start_and_close()+ assert not (paths.config_dir_path() / "chat").exists()+++def test_startup_removes_history_on_uvloop():+ uvloop = pytest.importorskip("uvloop")+ _, owned = _history()+ asyncio.run(_start_and_close(), loop_factory=uvloop.new_event_loop)+ assert not [path for path in owned if path.exists()]+++async def test_busy_history_is_left_intact_and_removed_on_next_startup(cleanup_logs):+ directory, owned = _history()+ original = {path: path.read_bytes() for path in owned}+ lock = InterprocessFileLock(directory / "chat.lock")+ assert lock.acquire()+ try:+ await _start_and_close()+ assert {path: path.read_bytes() for path in owned} == original+ assert any(+ "cleanup deferred: history is in use" in entry for entry in cleanup_logs+ )+ finally:+ lock.release()+ await _start_and_close()+ assert not [path for path in owned if path.exists()]+++async def test_partial_deletion_releases_lock_and_retries(monkeypatch, cleanup_logs):+ directory, owned = _history()+ unlink = Path.unlink++ def denied_sidecar(path, *args, **kwargs):+ if path == owned[1]:+ raise PermissionError("file in use")+ return unlink(path, *args, **kwargs)++ with monkeypatch.context() as patch:+ patch.setattr(Path, "unlink", denied_sidecar)+ await _start_and_close()+ assert not owned[0].exists()+ assert all(path.exists() for path in owned[1:])+ assert any(+ "cleanup deferred until next startup: exc_type=PermissionError" in entry+ for entry in cleanup_logs+ )+ probe = InterprocessFileLock(directory / "chat.lock")+ try:+ assert probe.acquire()+ finally:+ probe.release()+ await _start_and_close()+ assert not [path for path in owned if path.exists()]++[email protected]("operation", ["resolve", "lstat", "open"])+async def test_inaccessible_history_does_not_block_startup(+ monkeypatch, cleanup_logs, operation+):+ directory, owned = _history()+ original = getattr(Path, operation)+ denied = {"resolve": directory, "lstat": owned[0], "open": directory / "chat.lock"}[+ operation+ ]++ def inaccessible(path, *args, **kwargs):+ if path == denied:+ raise PermissionError("access denied")+ return original(path, *args, **kwargs)++ with monkeypatch.context() as patch:+ patch.setattr(Path, operation, inaccessible)+ await _start_and_close()+ assert all(path.exists() for path in owned)+ assert any("cleanup deferred" in entry for entry in cleanup_logs)+ await _start_and_close()+ assert not [path for path in owned if path.exists()]+++async def test_redirected_directory_is_left_untouched(tmp_path, cleanup_logs):+ root = paths.config_dir_path()+ root.mkdir()+ outside = tmp_path / "outside"+ outside.mkdir()+ database = outside / "chat.db"+ database.write_bytes(b"not owned by FCC")+ try:+ (root / "chat").symlink_to(outside, target_is_directory=True)+ except OSError as exc:+ pytest.skip(f"Directory symlinks unavailable: {exc}")+ await _start_and_close()+ assert database.read_bytes() == b"not owned by FCC"+ assert list(outside.iterdir()) == [database]+ assert any(+ "cleanup deferred: redirected directory" in entry for entry in cleanup_logs+ )+++def test_empty_chat_directory_does_not_create_a_lock():+ directory = paths.config_dir_path() / "chat"+ directory.mkdir(parents=True)+ remove_retired_chat_history()+ assert list(directory.iterdir()) == []+++def test_disappearing_files_are_safe_and_deletion_holds_the_lock(monkeypatch):+ directory, owned = _history()+ unlink = Path.unlink+ removed = []++ def disappearing(path, *args, **kwargs):+ if path in owned:+ probe = InterprocessFileLock(directory / "chat.lock")+ try:+ assert not probe.acquire()+ finally:+ probe.release()+ removed.append(path)+ unlink(path)+ return unlink(path, *args, **kwargs)++ monkeypatch.setattr(Path, "unlink", disappearing)+ remove_retired_chat_history()+ assert removed == owned+ assert list(directory.iterdir()) == [directory / "chat.lock"]+++def test_concurrent_cleanups_leave_no_history():+ directory, owned = _history()+ ready = threading.Barrier(4)++ def cleanup(_):+ ready.wait(timeout=5)+ remove_retired_chat_history()++ with ThreadPoolExecutor(max_workers=4) as workers:+ list(workers.map(cleanup, range(4)))+ assert not [path for path in owned if path.exists()]+ assert list(directory.iterdir()) == [directory / "chat.lock"]+++async def test_startup_cancellation_waits_for_cleanup_and_lock_release(monkeypatch):+ directory, owned = _history()+ runtime = _runtime()+ entered, release = threading.Event(), threading.Event()+ unlink = Path.unlink++ def held_unlink(path, *args, **kwargs):+ if path == owned[0]:+ entered.set()+ assert release.wait(5), "cleanup worker was not released"+ return unlink(path, *args, **kwargs)++ monkeypatch.setattr(Path, "unlink", held_unlink)+ startup = asyncio.create_task(runtime.start())+ probe = InterprocessFileLock(directory / "chat.lock")+ try:+ assert await asyncio.to_thread(entered.wait, 5)+ startup.cancel()+ await asyncio.sleep(0)+ assert not startup.done()+ assert not runtime.is_closed+ assert not probe.acquire()+ finally:+ release.set()+ await asyncio.gather(startup, return_exceptions=True)+ probe.release()+ await runtime.close()+ assert startup.cancelled()+ assert runtime.is_closed+ assert not [path for path in owned if path.exists()]+ try:+ assert probe.acquire()+ finally:+ probe.release()diff --git a/uv.lock b/uv.lockindex b5a6e31b..011d3dc7 100644--- a/uv.lock+++ b/uv.lock@@ -598,7 +598,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "5.23.6"+version = "6.0.0"source = { editable = "." }dependencies = [{ name = "aiohttp" },