Skip to content

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.md
index 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.py
index 9154481b..e01d6333 100644
--- a/e2e/conftest.py
+++ b/e2e/conftest.py
@@ -6,7 +6,6 @@ import sys
import threading
import time
from collections.abc import AsyncIterator, Iterator, Mapping
-from dataclasses import replace
from pathlib import Path
import pytest
@@ -16,13 +15,6 @@ from playwright.sync_api import Page
from e2e.code_support import CodeControl
from free_claude_code.api.app import create_app
from 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 ProviderModelInfo
from free_claude_code.config import env_migrations, paths
from 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_event
from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.providers.base import BaseProvider, ProviderConfig
from free_claude_code.providers.runtime import ProviderRuntime
from free_claude_code.runtime.application import ApplicationRuntime
from free_claude_code.runtime.asgi import RuntimeASGIApp
-from free_claude_code.runtime.chat_sqlite import SQLiteChatStore
from free_claude_code.runtime.configuration import ConfigurationService
from free_claude_code.runtime.provider_manager import ProviderRuntimeManager
@@ -68,7 +58,6 @@ class _ModelListingProvider(BaseProvider):
)
self._model_infos = model_infos
self._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.py
index 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, expect
from 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_paths
assert 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_paths
assert 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_paths
assert f"{versioned_root}/admin.js" in requested_paths
assert "/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_paths
assert "/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_paths
assert "/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.py
deleted file mode 100644
index 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.py
index 2d3ffb71..bac63e14 100644
--- a/e2e/test_code_sessions.py
+++ b/e2e/test_code_sessions.py
@@ -4,7 +4,6 @@ import uuid
import pytest
from playwright.sync_api import expect
-from e2e.test_chat_sessions import _new_chat
from 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_length
page.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_length
if 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 == expected
diff --git a/pyproject.toml b/pyproject.toml
index 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.py
index 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.js
index 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.css
deleted file mode 100644
index 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.js
deleted file mode 100644
index 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.html
index 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.css
index 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.js
index 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.py
index 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 RequestValidationError
from fastapi.responses import JSONResponse
from 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_version
from .admin_cache import AdminNoStoreMiddleware, attach_admin_no_store
from .admin_routes import router as admin_router
-from .chat_routes import router as chat_router
from .code_sessions_routes import router as code_router
from .ports import ApiServices
from .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.py
deleted file mode 100644
index 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.py
index 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 Mapping
from dataclasses import dataclass
from typing import Protocol
-from free_claude_code.application.chat import ChatApplicationPort
from free_claude_code.application.code_sessions import CodeApplicationPort
from free_claude_code.application.connected_accounts import (
ConnectedAccountLoginMode,
@@ -59,5 +58,4 @@ class ApiServices:
requests: RequestRuntimePort
admin: AdminRuntimePort
tasks: TaskController
- chat: ChatApplicationPort | None = None
code: CodeApplicationPort | None = None
diff --git a/src/free_claude_code/application/chat/__init__.py b/src/free_claude_code/application/chat/__init__.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
index 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 inspect
import math
import sys
-from collections.abc import AsyncIterator, Awaitable, Callable, Mapping
+from collections.abc import AsyncIterator, Callable, Mapping
from types import MappingProxyType
from 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:
continue
if not candidate_committed:
candidate_committed = True
- if candidate_selected is not None:
- selected_result = candidate_selected(target)
- if inspect.isawaitable(selected_result):
- await selected_result
if index > 0:
self._trace_fallback_selected(
request_id=request_id,
@@ -473,13 +458,7 @@ class ProviderExecutor:
) from exc
if 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_result
return
- if candidate_failed is not None:
- candidate_failed(candidate_failure)
if candidate_committed or index + 1 >= len(candidates):
raise candidate_failure
next_target = candidates[index + 1]
diff --git a/src/free_claude_code/config/paths.py b/src/free_claude_code/config/paths.py
index 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_FILENAME
diff --git a/src/free_claude_code/runtime/application.py b/src/free_claude_code/runtime/application.py
index 3845b87f..75f666e1 100644
--- a/src/free_claude_code/runtime/application.py
+++ b/src/free_claude_code/runtime/application.py
@@ -9,12 +9,12 @@ import uuid
from collections.abc import Awaitable, Callable, Mapping
from dataclasses import replace
+from anyio import to_thread
from loguru import logger
import free_claude_code.cli.managed as cli_managed
import free_claude_code.messaging.session as messaging_session
import free_claude_code.messaging.workflow as messaging_workflow_module
-from free_claude_code.application.chat import ChatService
from free_claude_code.application.code_sessions import CodeService
from free_claude_code.application.connected_accounts import (
ConnectedAccountLoginMode,
@@ -49,6 +49,7 @@ from free_claude_code.providers.credential_validation import (
from .configuration import ConfigurationService
from .provider_manager import ProviderRuntimeManager
+from .retired_chat import remove_retired_chat_history
RestartCallback = 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_manager
self._configuration = configuration
- self._chat_service = chat_service
self._code_service = code_service
self._transcriber = transcriber
self._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 False
if not await self._cleanup_transcriber():
return False
if not self._provider_manager_closed:
diff --git a/src/free_claude_code/runtime/bootstrap.py b/src/free_claude_code/runtime/bootstrap.py
index 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 Path
from free_claude_code.api.app import create_app
from free_claude_code.api.ports import ApiServices
-from free_claude_code.application.chat import ChatService
from free_claude_code.application.code_sessions import CodeService
from free_claude_code.config.loader import ManagedConfigStore
from free_claude_code.config.logging_config import configure_logging
from 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_provider
from .application import ApplicationRuntime, RestartCallback
from .asgi import RuntimeASGIApp
-from .chat_sqlite import SQLiteChatStore
from .code_sessions_sqlite import SQLiteCodeStore
from .codex_app_server import CodexHarnessFactory
from .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.py
deleted file mode 100644
index 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.py
new file mode 100644
index 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.py
index c52dc341..d8f93fce 100644
--- a/tests/api/support.py
+++ b/tests/api/support.py
@@ -6,7 +6,6 @@ from fastapi import FastAPI
from free_claude_code.api.app import create_app
from free_claude_code.api.ports import ApiServices
-from free_claude_code.application.chat import ChatApplicationPort
from free_claude_code.application.code_sessions import CodeApplicationPort
from free_claude_code.application.connected_accounts import ConnectedAccountPort
from 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.py
index 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.text
assert 'src="/admin/assets/9.8.7/app-icon.svg"' in response.text
assert '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.text
assert '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.text
assert 'src="/admin/assets/9.8.7/admin.js"' in response.text
assert '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.text
assert '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.py
deleted file mode 100644
index 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.py
similarity index 81%
rename from tests/api/test_chat_markdown.py
rename to tests/api/test_markdown.py
index 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![diagram](https://example.com/image.png)'
)
@@ -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 rendered
diff --git a/tests/api/test_request_lifetime.py b/tests/api/test_request_lifetime.py
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
index 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.asyncio
async 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.py
similarity index 100%
rename from tests/application/test_chat_events.py
rename to tests/application/test_session_events.py
diff --git a/tests/cli/test_server_shutdown.py b/tests/cli/test_server_shutdown.py
index 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.py
deleted file mode 100644
index 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.py
new file mode 100644
index 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.lock
index 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" },