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

Show context usage in native Code Sessions (#1785)

Ali Khokharbf59598ccc04
diff --git a/e2e/test_code_sessions.py b/e2e/test_code_sessions.py
index 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.toml
index 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.js
index 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.css
index 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.py
index 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 = None
native_permission_defaults: JsonObject | None = None
native_may_have_input: bool = False
+ context_used_tokens: int | None = Field(default=None, ge=0)
revision: int = 1
status: Literal["ready", "deleting", "delete_uncertain"] = "ready"
error: str | None = None
@@ -121,6 +122,7 @@ class CodeModel(Record):
model_name: str
reasoning_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 = None
item: ItemUpdate | None = None
prompt: PromptRequest | None = None
request_id: str | int | None = None
diff --git a/src/free_claude_code/application/code_sessions/ports.py b/src/free_claude_code/application/code_sessions/ports.py
index 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.py
index 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:
return
if 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")
+ return
run = owner.run
matches = (
run is not None
diff --git a/src/free_claude_code/runtime/code_sessions_sqlite.py b/src/free_claude_code/runtime/code_sessions_sqlite.py
index 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.py
index 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 None
and 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.py
index 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.py
index 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.asyncio
async def test_http_send_competition_and_safe_item_projection(code_api):
client, code, harness, _, _ = code_api
diff --git a/tests/application/test_code_sessions.py b/tests/application/test_code_sessions.py
index 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.asyncio
async def test_catalog_replacement_is_limited_to_selected_entry_and_session(code):
service, harness, _ = code
diff --git a/tests/code_sessions_support.py b/tests/code_sessions_support.py
index 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.py
index 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.py
index 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_rewritte
assert 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.asyncio
async 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, tmp
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 = 1")
for _ in range(2):
@@ -208,7 +232,7 @@ async def test_version_one_database_gains_mode_without_losing_history(store, tmp
assert (await store.get_run(session.id, run.id)).mode == "config"
assert await store.items(session.id, None, None) == items
with 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] == 3
with 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, tmp
await 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.asyncio
async 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] == expected
with closing(sqlite3.connect(path)) as connection:
- assert connection.execute("PRAGMA user_version").fetchone()[0] == 2
+ assert connection.execute("PRAGMA user_version").fetchone()[0] == 3
assert 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.py
index 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.asyncio
async 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.py
index 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_000
assert model.reasoning_efforts == ("off", "low", "medium", "high", "xhigh", "max")
selected = factory.prepare(model.id, None, "config")
assert selected.model == model.id
diff --git a/tests/runtime/test_codex_protocol.py b/tests/runtime/test_codex_protocol.py
index 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.lock
index 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" },