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
Show context usage in native Code Sessions (#1785)
Ali Khokharbf59598ccc04
diff --git a/e2e/test_code_sessions.py b/e2e/test_code_sessions.pyindex 6cb7d970..6a74519d 100644--- a/e2e/test_code_sessions.py+++ b/e2e/test_code_sessions.py@@ -38,6 +38,92 @@ def test_five_header_controls_fit_without_hiding_composer(page.screenshot(path=str(tmp_path / f"code-modes-{width}.png"))[email protected]("width", [1440, 390])+def test_context_usage_is_live_persistent_and_uses_only_raw_provider_capacity(+ page, admin_base_url, tmp_path, code_control, width+):+ code_control.harness.context_windows["provider/model"] = 100_000+ code_control.harness.configurations["provider/unknown"] = "unknown"+ page.set_viewport_size({"width": width, "height": 900})+ create_session(page, admin_base_url, tmp_path)+ usage = page.locator("#codeContextUsage")+ expect(usage).to_be_hidden()++ send(page, "Measure the active context")+ connection = code_control.connection()+ code_control.run(connection.context_usage("turn-1", 90_000))+ expect(usage).to_have_text("90K / 100K (90%)")+ code_control.run(connection.context_usage("turn-1", 12_438))+ expect(usage).to_have_text("12.4K / 100K (12%)")+ expect(usage).to_have_attribute(+ "title", "Context used: 12,438 of 100,000 tokens (12%)"+ )+ expect(usage).to_have_accessible_name(+ "Context used: 12,438 of 100,000 tokens (12%)"+ )+ usage_box = usage.bounding_box()+ stop_box = page.locator("#codeStop").bounding_box()+ assert usage_box["x"] + usage_box["width"] <= stop_box["x"]+ assert stop_box["x"] + stop_box["width"] <= width++ page.reload()+ expect(usage).to_have_text("12.4K / 100K (12%)")+ code_control.run(connection.context_usage("turn-1", 104_000))+ expect(usage).to_have_text("104K / 100K (104%)")+ code_control.run(connection.finish("turn-1"))++ page.locator("#codeModel").fill("unknown")+ page.get_by_role("option", name="unknown", exact=True).click()+ expect(usage).to_have_text("104K")+ expect(usage).to_have_accessible_name("Context used: 104,000 tokens")+ send(page, "Use the model without capacity metadata")+ code_control.run(code_control.harness.wait_inputs(2))+ code_control.run(connection.context_usage("turn-2", 12_438))+ expect(usage).to_have_text("12.4K")+ expect(usage).to_have_attribute("title", "Context used: 12,438 tokens")+ expect(usage).to_have_accessible_name("Context used: 12,438 tokens")+ code_control.run(connection.finish("turn-2"))+++def test_delayed_settings_response_cannot_replace_newer_context_usage(+ page, admin_base_url, tmp_path, code_control+):+ code_control.harness.context_windows["provider/model"] = 100_000+ create_session(page, admin_base_url, tmp_path)+ send(page, "Start")+ connection = code_control.connection()+ code_control.run(connection.context_usage("turn-1", 10_000))+ code_control.run(connection.finish("turn-1"))+ usage = page.locator("#codeContextUsage")+ expect(usage).to_have_text("10K / 100K (10%)")++ page.evaluate(+ """+ () => {+ const originalFetch = window.fetch;+ window.fetch = async (...args) => {+ const response = await originalFetch(...args);+ const options = args[1] || {};+ if (options.method === "PATCH" && String(args[0]).includes("/sessions/")) {+ await new Promise((resolve) => { window.releaseCodeSettings = resolve; });+ }+ return response;+ };+ }+ """+ )+ title = page.get_by_role("textbox", name="Code title", exact=True)+ title.fill("Renamed while usage changes")+ title.press("Tab")+ page.wait_for_function("() => typeof window.releaseCodeSettings === 'function'")++ code_control.run(connection.context_usage("turn-1", 20_000))+ expect(usage).to_have_text("20K / 100K (20%)")+ page.evaluate("window.releaseCodeSettings()")+ expect(title).to_be_enabled()+ expect(usage).to_have_text("20K / 100K (20%)")++def test_header_provider_draft_and_mode_sync(page, context, admin_base_url, tmp_path, code_control):diff --git a/pyproject.toml b/pyproject.tomlindex 9be00d88..8eb61bd8 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "6.2.22"+version = "6.2.23"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_static/code_sessions.js b/src/free_claude_code/api/admin_static/code_sessions.jsindex 087f99e1..275fbb51 100644--- a/src/free_claude_code/api/admin_static/code_sessions.js+++ b/src/free_claude_code/api/admin_static/code_sessions.js@@ -101,6 +101,49 @@function ready(record) {return synchronized && record?.loaded && record.session?.status === "ready";}+ function compactTokens(tokens) {+ let value = tokens;+ let unit = 0;+ const units = ["", "K", "M", "B"];+ while (value >= 1000 && unit < units.length - 1) {+ value /= 1000;+ unit += 1;+ }+ let rounded = Math.round(value * 10) / 10;+ if (rounded >= 1000 && unit < units.length - 1) {+ rounded /= 1000;+ unit += 1;+ }+ return `${rounded}${units[unit]}`;+ }+ function renderContextUsage(record) {+ const node = root.querySelector("#codeContextUsage"),+ used = record?.session?.context_used_tokens;+ if (!node || !Number.isInteger(used) || used < 0) {+ if (node) {+ node.hidden = true;+ node.textContent = "";+ node.removeAttribute("title");+ node.removeAttribute("aria-label");+ }+ return;+ }+ const maximum = catalog.find(+ (model) => model.id === record.session.model,+ )?.context_window_tokens,+ knownMaximum = Number.isInteger(maximum) && maximum > 0,+ percentage = knownMaximum ? Math.round((used / maximum) * 100) : null,+ exactUsed = used.toLocaleString("en-US");+ node.textContent = knownMaximum+ ? `${compactTokens(used)} / ${compactTokens(maximum)} (${percentage}%)`+ : compactTokens(used);+ const description = knownMaximum+ ? `Context used: ${exactUsed} of ${maximum.toLocaleString("en-US")} tokens (${percentage}%)`+ : `Context used: ${exactUsed} tokens`;+ node.title = description;+ node.setAttribute("aria-label", description);+ node.hidden = false;+ }function mergeEntries(target, entries, version) {for (const value of entries || []) {if ((target.get(value.id)?.version ?? -1) <= version)@@ -747,7 +790,7 @@});if (!deleted.has(id) &&- session.revision >= (records.get(id)?.session?.revision || 0)+ session.revision > (records.get(id)?.session?.revision || 0))get(id).session = session;} catch (error) {@@ -1001,6 +1044,11 @@void stop();},);+ const contextUsage = element("span", "", "code-context-usage");+ contextUsage.id = "codeContextUsage";+ contextUsage.setAttribute("role", "status");+ contextUsage.hidden = true;+ composer.querySelector(".session-composer-actions").prepend(contextUsage);root.append(UI.shell(header, message, transcript, composer));UI.resizeComposer(composer.querySelector("textarea"));} else {@@ -1153,6 +1201,7 @@const record = records.get(selected),isBusy = busy(record),input = root.querySelector("#codeComposer");+ renderContextUsage(record);if (providerDraft &&(providerDraft.id !== selected ||diff --git a/src/free_claude_code/api/admin_static/session_layout.css b/src/free_claude_code/api/admin_static/session_layout.cssindex 02731def..556444d2 100644--- a/src/free_claude_code/api/admin_static/session_layout.css+++ b/src/free_claude_code/api/admin_static/session_layout.css@@ -451,6 +451,13 @@margin-top: 4px;}+.code-context-usage {+ color: var(--muted);+ font-size: 12px;+ font-variant-numeric: tabular-nums;+ white-space: nowrap;+}+.code-activity {color: var(--muted);font-size: 14px;diff --git a/src/free_claude_code/application/code_sessions/models.py b/src/free_claude_code/application/code_sessions/models.pyindex 032c8ec3..5e2bb885 100644--- a/src/free_claude_code/application/code_sessions/models.py+++ b/src/free_claude_code/application/code_sessions/models.py@@ -35,6 +35,7 @@ class CodeSession(Record):native_thread_id: str | None = Nonenative_permission_defaults: JsonObject | None = Nonenative_may_have_input: bool = False+ context_used_tokens: int | None = Field(default=None, ge=0)revision: int = 1status: Literal["ready", "deleting", "delete_uncertain"] = "ready"error: str | None = None@@ -121,6 +122,7 @@ class CodeModel(Record):model_name: strreasoning_efforts: tuple[str, ...] = ()default_reasoning_effort: str | None = None+ context_window_tokens: int | None = Field(default=None, gt=0)@dataclass(frozen=True, slots=True)@@ -170,9 +172,11 @@ class HarnessEvent:"resolved","error","notice",+ "context_usage","closed",]turn_id: str | None = None+ context_used_tokens: int | None = Noneitem: ItemUpdate | None = Noneprompt: PromptRequest | None = Nonerequest_id: str | int | None = Nonediff --git a/src/free_claude_code/application/code_sessions/ports.py b/src/free_claude_code/application/code_sessions/ports.pyindex 016a3aea..a2739a20 100644--- a/src/free_claude_code/application/code_sessions/ports.py+++ b/src/free_claude_code/application/code_sessions/ports.py@@ -20,6 +20,7 @@ from .models import (NativeThread,)+# Harness connections must await each call and preserve native wire order.type EventSink = Callable[[HarnessEvent], Awaitable[None]]diff --git a/src/free_claude_code/application/code_sessions/service.py b/src/free_claude_code/application/code_sessions/service.pyindex be1247db..044810ee 100644--- a/src/free_claude_code/application/code_sessions/service.py+++ b/src/free_claude_code/application/code_sessions/service.py@@ -875,6 +875,20 @@ class CodeService:returnif owner.session.status != "ready":return+ if event.kind == "context_usage":+ if (+ event.context_used_tokens is None+ or event.context_used_tokens+ == owner.session.context_used_tokens+ ):+ return+ session = owner.session.model_copy(+ update={"context_used_tokens": event.context_used_tokens}+ )+ await self._persist(owner, session)+ owner.session = session+ self._publish(owner, "session.updated")+ returnrun = owner.runmatches = (run is not Nonediff --git a/src/free_claude_code/runtime/code_sessions_sqlite.py b/src/free_claude_code/runtime/code_sessions_sqlite.pyindex a9f5625f..036efc48 100644--- a/src/free_claude_code/runtime/code_sessions_sqlite.py+++ b/src/free_claude_code/runtime/code_sessions_sqlite.py@@ -146,6 +146,7 @@ def _write_session("model","reasoning_effort","mode",+ "context_used_tokens","revision","updated_at",}@@ -154,6 +155,7 @@ def _write_session("native_thread_id","native_permission_defaults","native_may_have_input",+ "context_used_tokens","revision","updated_at","status",@@ -428,6 +430,12 @@ class SQLiteCodeStore:"(json_valid(native_permission_defaults) AND json_type(native_permission_defaults) = 'object'))")connection.execute("PRAGMA user_version = 2")+ if connection.execute("PRAGMA user_version").fetchone()[0] == 2:+ connection.execute(+ "ALTER TABLE code_sessions ADD COLUMN context_used_tokens INTEGER "+ "CHECK(context_used_tokens IS NULL OR context_used_tokens >= 0)"+ )+ connection.execute("PRAGMA user_version = 3")connection.execute("UPDATE code_runs SET status = 'interrupted', finished_at = ?, error = ? ""WHERE status IN ('preparing','running','stopping')",diff --git a/src/free_claude_code/runtime/codex_app_server.py b/src/free_claude_code/runtime/codex_app_server.pyindex 45a5b403..bc578447 100644--- a/src/free_claude_code/runtime/codex_app_server.py+++ b/src/free_claude_code/runtime/codex_app_server.py@@ -641,7 +641,11 @@ class CodexHarnessFactory:return CodeCatalog(settings.model,tuple(- _model_option(model.provider_model_ref, object_value(entry))+ _model_option(+ model.provider_model_ref,+ object_value(entry),+ context_window_tokens=model.context_window_tokens,+ )for model, entry in zip(models, entries, strict=True)),)@@ -672,7 +676,11 @@ class CodexHarnessFactory:for value in array_value(catalog.get("models"))if (entry := object_value(value))}- option = _model_option(model, entries[selected.wire_slug])+ option = _model_option(+ model,+ entries[selected.wire_slug],+ context_window_tokens=selected.context_window_tokens,+ )if (reasoning_effort is not Noneand reasoning_effort not in option.reasoning_efforts@@ -714,7 +722,9 @@ class CodexHarnessFactory:return connection-def _model_option(model: str, entry: JsonObject) -> CodeModel:+def _model_option(+ model: str, entry: JsonObject, *, context_window_tokens: int | None+) -> CodeModel:provider_id, model_name = split_provider_model_ref(model)efforts = tuple(string_value(object_value(level).get("effort"))@@ -731,6 +741,7 @@ def _model_option(model: str, entry: JsonObject) -> CodeModel:or ("off",),default_reasoning_effort=string_value(entry.get("default_reasoning_level"))or "off",+ context_window_tokens=context_window_tokens,)diff --git a/src/free_claude_code/runtime/codex_protocol.py b/src/free_claude_code/runtime/codex_protocol.pyindex a09dd228..5dc7bf6f 100644--- a/src/free_claude_code/runtime/codex_protocol.py+++ b/src/free_claude_code/runtime/codex_protocol.py@@ -54,6 +54,25 @@ class CodexProtocol:turn_id = (string_value(params.get("turnId")) or string_value(turn.get("id")) or None)+ if method == "thread/tokenUsage/updated":+ used = object_value(object_value(params.get("tokenUsage")).get("last")).get(+ "totalTokens"+ )+ if (+ not thread_id+ or not turn_id+ or not isinstance(used, int)+ or isinstance(used, bool)+ or used < 0+ ):+ return None+ return HarnessEvent(+ self.generation,+ thread_id,+ "context_usage",+ turn_id=turn_id,+ context_used_tokens=used,+ )if method in {"turn/started", "turn/completed"}:status: RunStatus = "completed"if turn.get("status") == "interrupted":diff --git a/tests/api/test_code_sessions_routes.py b/tests/api/test_code_sessions_routes.pyindex 80a0e3fe..b7d3e8a8 100644--- a/tests/api/test_code_sessions_routes.py+++ b/tests/api/test_code_sessions_routes.py@@ -129,6 +129,36 @@ async def test_code_library_has_one_harness_and_no_native_work_on_open(code_api)assert page.status_code == 200+async def test_context_usage_and_raw_provider_capacity_are_public_session_state(+ code_api,+):+ client, code, harness, _, _ = code_api+ harness.context_windows[harness.model] = 100_000+ harness.configurations["unknown/model"] = "unknown"+ bootstrap = (await client.get("/admin/api/code/bootstrap")).json()+ models = {model["id"]: model for model in bootstrap["models"]}+ assert models[harness.model]["context_window_tokens"] == 100_000+ assert models["unknown/model"]["context_window_tokens"] is None++ session = await create_session(code_api)+ assert session["context_used_tokens"] is None+ await code.send(+ session["id"],+ str(uuid.uuid4()),+ session["revision"],+ "hello",+ expected_epoch=code.epoch,+ )+ await harness.started.wait()+ await harness.connections[0].context_usage("turn-1", 12_438)++ detail = (await client.get(f"/admin/api/code/sessions/{session['id']}")).json()+ assert detail["session"]["context_used_tokens"] == 12_438+ library = (await client.get("/admin/api/code/sessions")).json()+ assert library["sessions"][0]["context_used_tokens"] == 12_438++@pytest.mark.asyncioasync def test_http_send_competition_and_safe_item_projection(code_api):client, code, harness, _, _ = code_apidiff --git a/tests/application/test_code_sessions.py b/tests/application/test_code_sessions.pyindex 59d17106..403f1363 100644--- a/tests/application/test_code_sessions.py+++ b/tests/application/test_code_sessions.py@@ -1618,6 +1618,124 @@ async def test_streaming_does_not_invalidate_rename_revision(code):assert (await service.get_detail(session.id)).session.title == "My code"+async def test_context_usage_is_an_absolute_deduplicated_session_snapshot(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch+ )+ await harness.started.wait()+ connection = harness.connections[0]+ before = await service.get_detail(session.id)+ subscription, _ = await service.subscribe()+ events = subscription.__aiter__()+ try:+ await connection.context_usage("turn-1", 90_000)+ async with asyncio.timeout(2):+ event = await anext(events)+ after = await service.get_detail(session.id)+ assert event.event == "session.updated"+ assert event.data["session"]["context_used_tokens"] == 90_000+ assert after.session.context_used_tokens == 90_000+ assert after.session.revision == before.session.revision+ assert after.session.updated_at == before.session.updated_at+ assert (+ await service._store.get_session(session.id)+ ).context_used_tokens == 90_000++ await connection.context_usage("turn-1", 90_000)+ duplicate = await service.get_detail(session.id)+ assert duplicate.version == after.version++ await connection.context_usage("turn-1", 25_000)+ compacted = await service.get_detail(session.id)+ assert compacted.session.context_used_tokens == 25_000+ assert compacted.session.revision == after.session.revision+ assert compacted.session.updated_at == after.session.updated_at+ await connection.finish("turn-1")+ finally:+ await subscription.aclose()+++async def test_context_usage_is_retained_across_model_changes(code):+ service, harness, _ = code+ harness.configurations["provider/other"] = "other"+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch+ )+ await harness.started.wait()+ connection = harness.connections[0]+ await connection.context_usage("turn-1", 40_000)+ await connection.finish("turn-1")++ detail = await service.get_detail(session.id)+ changed = await service.update_settings(+ session.id, detail.session.revision, {"model": "provider/other"}+ )+ assert changed.context_used_tokens == 40_000+ restored = await service.update_settings(+ session.id, changed.revision, {"model": "provider/model"}+ )+ assert restored.context_used_tokens == 40_000+ assert (await service._store.get_session(session.id)).context_used_tokens == 40_000++ await service.send(+ session.id,+ new_id(),+ restored.revision,+ "second",+ expected_epoch=service.epoch,+ )+ await harness.wait_inputs(2)+ await connection.context_usage("turn-2", 7_500)+ current = await service.get_detail(session.id)+ assert current.session.context_used_tokens == 7_500+ await connection.finish("turn-2")+++async def test_resumed_context_usage_is_accepted_after_the_next_run_is_admitted(code):+ service, harness, _ = code+ session = await session_for(code)+ await service.send(+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch+ )+ await harness.started.wait()+ original = harness.connections[0]+ await original.context_usage("turn-1", 10_000)+ await original.finish("turn-1")++ session = (await service.get_detail(session.id)).session+ harness.configurations[harness.model] = "replacement"+ harness.start_gate.clear()+ harness.started.clear()+ harness.submitted.clear()+ await service.send(+ session.id, new_id(), session.revision, "second", expected_epoch=service.epoch+ )+ await harness.submitted.wait()+ resumed = harness.connections[1]+ assert original.closed+ assert resumed.resumed == [session.native_thread_id]++ await resumed.context_usage("turn-1", 11_000)+ await resumed.context_usage("turn-1", 12_000, generation=original.generation)+ await resumed.context_usage("turn-1", 13_000, thread_id="another-thread")+ replayed = await service.get_detail(session.id)+ assert replayed.session.context_used_tokens == 11_000+ assert (await service._store.get_session(session.id)).context_used_tokens == 11_000++ harness.start_gate.set()+ await harness.started.wait()+ await resumed.context_usage("turn-2", 20_000)+ current = await service.get_detail(session.id)+ assert current.session.context_used_tokens == 20_000+ await resumed.finish("turn-2")++@pytest.mark.asyncioasync def test_catalog_replacement_is_limited_to_selected_entry_and_session(code):service, harness, _ = codediff --git a/tests/code_sessions_support.py b/tests/code_sessions_support.pyindex c65ef86f..1e24c424 100644--- a/tests/code_sessions_support.py+++ b/tests/code_sessions_support.py@@ -126,6 +126,7 @@ class FakeHarness:"activePermissionProfile": {"id": ":workspace"},}self.configurations = {self.model: "capabilities-1"}+ self.context_windows: dict[str, int | None] = {self.model: None}self.efforts = ("off", "low", "medium", "high", "xhigh", "max")self.default_effort = "medium"self.creation_gate = asyncio.Event()@@ -165,6 +166,7 @@ class FakeHarness:model_name=split_provider_model_ref(model)[1],reasoning_efforts=self.efforts,default_reasoning_effort=self.default_effort,+ context_window_tokens=self.context_windows.get(model),)for model in self.configurations),@@ -329,6 +331,24 @@ class FakeConnection:))+ async def context_usage(+ self,+ turn_id: str,+ used_tokens: int,+ *,+ thread_id: str | None = None,+ generation: str | None = None,+ ):+ await self.sink(+ HarnessEvent(+ generation or self.generation,+ self.thread_id if thread_id is None else thread_id,+ "context_usage",+ turn_id=turn_id,+ context_used_tokens=used_tokens,+ )+ )+async def prompt(self, request_id: str | int, turn_id: str | None = "turn-1"):prompt = PromptRequest(request_id,diff --git a/tests/runtime/codex_fake_process.py b/tests/runtime/codex_fake_process.pyindex 669b4e53..524becbe 100644--- a/tests/runtime/codex_fake_process.py+++ b/tests/runtime/codex_fake_process.py@@ -63,7 +63,27 @@ for line in sys.stdin.buffer:},})- if mode in {"prompt", "child-prompt"}:+ if mode == "ordered-usage":+ emit(+ {+ "method": "thread/tokenUsage/updated",+ "params": {+ "threadId": "native-1",+ "turnId": turn,+ "tokenUsage": {"last": {"totalTokens": 12_438}},+ },+ }+ )+ emit(+ {+ "method": "turn/completed",+ "params": {+ "threadId": "native-1",+ "turn": {"id": turn, "status": "completed"},+ },+ }+ )+ elif mode in {"prompt", "child-prompt"}:if mode == "child-prompt":emit({diff --git a/tests/runtime/test_code_sessions_sqlite.py b/tests/runtime/test_code_sessions_sqlite.pyindex 28cb00df..d6100150 100644--- a/tests/runtime/test_code_sessions_sqlite.py+++ b/tests/runtime/test_code_sessions_sqlite.py@@ -170,6 +170,29 @@ async def test_mode_and_original_defaults_survive_restart_and_cannot_be_rewritteassert saved.native_permission_defaults == defaults+async def test_context_usage_progress_and_settings_use_existing_session_writes(+ store,+):+ session = await _session(store)+ snapshot = session.model_copy(update={"context_used_tokens": 12_438})+ await store.save_progress(snapshot, session.revision)+ saved = await store.get_session(session.id)+ assert saved.context_used_tokens == 12_438+ assert saved.revision == session.revision+ assert saved.updated_at == session.updated_at++ changed = snapshot.model_copy(+ update={+ "model": "provider/other",+ "revision": snapshot.revision + 1,+ }+ )+ changed = await store.update_settings(changed, snapshot.revision)+ assert changed.model == "provider/other"+ assert changed.context_used_tokens == 12_438++@pytest.mark.asyncioasync def test_mode_is_guarded_by_sqlite_busy_and_run_immutability(store):session, run = await _admit(store, await _session(store))@@ -198,6 +221,7 @@ async def test_version_one_database_gains_mode_without_losing_history(store, tmpconnection.execute("ALTER TABLE code_sessions DROP COLUMN native_permission_defaults")+ connection.execute("ALTER TABLE code_sessions DROP COLUMN context_used_tokens")connection.execute("ALTER TABLE code_runs DROP COLUMN mode")connection.execute("PRAGMA user_version = 1")for _ in range(2):@@ -208,7 +232,7 @@ async def test_version_one_database_gains_mode_without_losing_history(store, tmpassert (await store.get_run(session.id, run.id)).mode == "config"assert await store.items(session.id, None, None) == itemswith closing(sqlite3.connect(tmp_path / "code.db")) as connection:- assert connection.execute("PRAGMA user_version").fetchone()[0] == 2+ assert connection.execute("PRAGMA user_version").fetchone()[0] == 3with pytest.raises(sqlite3.IntegrityError):connection.execute("UPDATE code_sessions SET mode = 'unknown'")with pytest.raises(sqlite3.IntegrityError):@@ -218,6 +242,32 @@ async def test_version_one_database_gains_mode_without_losing_history(store, tmpawait store.close()+async def test_version_two_database_gains_nullable_context_usage(store, tmp_path):+ session = await _session(store)+ await store.close()+ with closing(sqlite3.connect(tmp_path / "code.db")) as connection, connection:+ connection.execute("ALTER TABLE code_sessions DROP COLUMN context_used_tokens")+ connection.execute("PRAGMA user_version = 2")+ for _ in range(2):+ await store.start()+ assert (await store.get_session(session.id)).context_used_tokens is None+ with closing(sqlite3.connect(tmp_path / "code.db")) as connection:+ assert connection.execute("PRAGMA user_version").fetchone()[0] == 3+ column = next(+ row+ for row in connection.execute("PRAGMA table_info(code_sessions)")+ if row[1] == "context_used_tokens"+ )+ assert column[3] == 0+ with pytest.raises(sqlite3.IntegrityError):+ connection.execute(+ "UPDATE code_sessions SET context_used_tokens = -1 WHERE id = ?",+ (session.id,),+ )+ await store.close()++@pytest.mark.asyncioasync def test_admission_is_atomic_and_idempotent(store):session = await _session(store)@@ -504,6 +554,7 @@ async def _legacy_prompt_database(store, path):connection.execute("ALTER TABLE code_sessions DROP COLUMN native_permission_defaults")+ connection.execute("ALTER TABLE code_sessions DROP COLUMN context_used_tokens")connection.execute("ALTER TABLE code_runs DROP COLUMN mode")connection.execute("PRAGMA user_version = 0")for prompt in prompts:@@ -563,7 +614,7 @@ async def test_legacy_prompts_migrate_once_to_run_ends_without_resequencing()assert saved[prompt.id] == expectedwith closing(sqlite3.connect(path)) as connection:- assert connection.execute("PRAGMA user_version").fetchone()[0] == 2+ assert connection.execute("PRAGMA user_version").fetchone()[0] == 3assert connection.execute("PRAGMA foreign_key_check").fetchall() == []assert any(row[2] == "code_items"diff --git a/tests/runtime/test_codex_app_server.py b/tests/runtime/test_codex_app_server.pyindex 0dd3e552..3ad5275a 100644--- a/tests/runtime/test_codex_app_server.py+++ b/tests/runtime/test_codex_app_server.py@@ -210,6 +210,55 @@ async def connect(tmp_path, mode):return native, events, completed, prompted+async def test_jsonl_sink_preserves_usage_before_turn_completion(tmp_path):+ events = []+ usage_received = asyncio.Event()+ release_usage = asyncio.Event()+ completed = asyncio.Event()++ async def receive(event):+ events.append(event.kind)+ if event.kind == "context_usage":+ usage_received.set()+ await release_usage.wait()+ elif event.kind == "turn_completed":+ completed.set()++ native = CodexAppServer(+ [+ sys.executable,+ str(Path(__file__).with_name("codex_fake_process.py")),+ "ordered-usage",+ ],+ dict(os.environ),+ str(tmp_path),+ receive,+ model_slugs={"provider/model": "provider/model"},+ fingerprints={"provider/model": "capabilities-1"},+ )+ try:+ await native.start()+ await native.create_thread()+ turn_id = await native.start_turn(+ "hello",+ FakeHarness().prepare("provider/model", None, "config"),+ "input-1",+ FakeHarness().permission_defaults,+ )+ assert turn_id == "turn-1"+ await asyncio.wait_for(usage_received.wait(), 3)+ assert not completed.is_set()+ release_usage.set()+ await asyncio.wait_for(completed.wait(), 3)+ assert [+ kind for kind in events if kind in {"context_usage", "turn_completed"}+ ] == ["context_usage", "turn_completed"]+ finally:+ release_usage.set()+ await native.close()++@pytest.mark.asyncioasync def test_jsonl_large_unicode_events_can_precede_rpc_ack(tmp_path):native, events, completed, _ = await connect(tmp_path, "large")diff --git a/tests/runtime/test_codex_catalog.py b/tests/runtime/test_codex_catalog.pyindex 7f741a05..1c522506 100644--- a/tests/runtime/test_codex_catalog.py+++ b/tests/runtime/test_codex_catalog.py@@ -48,7 +48,9 @@ def _runtime() -> FakeRequestRuntime:settings = Settings().model_copy(update={"model": "nvidia_nim/configured"})return FakeRequestRuntime(settings=settings,- cached_infos=(ProviderModelInfo("open_router/discovered"),),+ cached_infos=(+ ProviderModelInfo("open_router/discovered", context_window_tokens=100_000),+ ),)@@ -111,6 +113,8 @@ def test_code_picker_and_native_selection_use_the_same_advertised_efforts():advertised = factory.catalog()assert advertised.default_model == "nvidia_nim/configured"model = advertised.models[1]+ assert advertised.models[0].context_window_tokens is None+ assert model.context_window_tokens == 100_000assert model.reasoning_efforts == ("off", "low", "medium", "high", "xhigh", "max")selected = factory.prepare(model.id, None, "config")assert selected.model == model.iddiff --git a/tests/runtime/test_codex_protocol.py b/tests/runtime/test_codex_protocol.pyindex d2534e3f..2a407bd3 100644--- a/tests/runtime/test_codex_protocol.py+++ b/tests/runtime/test_codex_protocol.py@@ -77,6 +77,49 @@ def notification(protocol, method, **extra):)+def test_context_usage_projects_the_latest_active_context_not_cumulative_usage():+ event = notification(+ CodexProtocol("generation"),+ "thread/tokenUsage/updated",+ tokenUsage={+ "total": {"totalTokens": 98_765},+ "last": {"totalTokens": 12_438},+ "modelContextWindow": 95_000,+ },+ )++ assert event is not None+ assert event.kind == "context_usage"+ assert event.context_used_tokens == 12_438+ assert event.turn_id == "turn"+++ "value",+ [None, True, False, -1, 1.5, "12", [], {}],+)+def test_context_usage_ignores_invalid_active_context_totals(value):+ assert (+ notification(+ CodexProtocol("generation"),+ "thread/tokenUsage/updated",+ tokenUsage={"total": {"totalTokens": 20}, "last": {"totalTokens": value}},+ )+ is None+ )+++def test_context_usage_accepts_an_empty_active_context():+ event = notification(+ CodexProtocol("generation"),+ "thread/tokenUsage/updated",+ tokenUsage={"total": {"totalTokens": 0}, "last": {"totalTokens": 0}},+ )++ assert event is not None+ assert event.context_used_tokens == 0++def test_reasoning_keeps_summary_and_content_indices_and_original_completion():protocol = CodexProtocol("generation")notification(diff --git a/uv.lock b/uv.lockindex 84d5de45..ce14aca9 100644--- a/uv.lock+++ b/uv.lock@@ -598,7 +598,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "6.2.22"+version = "6.2.23"source = { editable = "." }dependencies = [{ name = "aiohttp" },