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
Preserve cache-write accounting across translated outputs (#1594)
Ali Khokhar44c2d330999d
diff --git a/pyproject.toml b/pyproject.tomlindex f9e64c53..e88847fc 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "5.15.4"+version = "5.15.5"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/core/anthropic/usage.py b/src/free_claude_code/core/anthropic/usage.pynew file mode 100644index 00000000..6340be07--- /dev/null+++ b/src/free_claude_code/core/anthropic/usage.py@@ -0,0 +1,38 @@+"""Anthropic terminal usage accounting helpers."""+++def anthropic_input_usage_fields(+ total_tokens: int | None,+ *,+ cache_read_tokens: int | None,+ cache_creation_tokens: int | None,+) -> dict[str, int]:+ """Partition an inclusive input total into trustworthy Anthropic fields."""+ if (+ not isinstance(total_tokens, int)+ or isinstance(total_tokens, bool)+ or total_tokens < 0+ ):+ return {}++ fields: dict[str, int] = {}+ remaining_tokens = total_tokens+ if (+ isinstance(cache_read_tokens, int)+ and not isinstance(cache_read_tokens, bool)+ and 0 <= cache_read_tokens <= remaining_tokens+ ):+ fields["cache_read_input_tokens"] = cache_read_tokens+ remaining_tokens -= cache_read_tokens++ if (+ isinstance(cache_creation_tokens, int)+ and not isinstance(cache_creation_tokens, bool)+ and 0 <= cache_creation_tokens <= remaining_tokens+ ):+ fields["cache_creation_input_tokens"] = cache_creation_tokens+ remaining_tokens -= cache_creation_tokens++ if not fields:+ return {}+ return {"input_tokens": remaining_tokens, **fields}diff --git a/src/free_claude_code/core/openai_responses/provider_stream.py b/src/free_claude_code/core/openai_responses/provider_stream.pyindex eed75314..95ffb5b2 100644--- a/src/free_claude_code/core/openai_responses/provider_stream.py+++ b/src/free_claude_code/core/openai_responses/provider_stream.py@@ -4,6 +4,7 @@ from dataclasses import dataclassfrom typing import Anyfrom free_claude_code.core.anthropic.streaming import AnthropicStreamLedger+from free_claude_code.core.anthropic.usage import anthropic_input_usage_fieldsfrom free_claude_code.core.openai_tool_names import OpenAIToolNameCodec@@ -217,15 +218,12 @@ class ResponsesProviderStream:details = usage.get("input_tokens_details")details = details if isinstance(details, dict) else {}cached_tokens = _integer(details.get("cached_tokens"))- usage_fields = None- if (- input_tokens is not None- and input_tokens >= 0- and cached_tokens is not None- and 0 <= cached_tokens <= input_tokens- ):- input_tokens -= cached_tokens- usage_fields = {"cache_read_input_tokens": cached_tokens}+ cache_write_tokens = _integer(details.get("cache_write_tokens"))+ usage_fields = anthropic_input_usage_fields(+ input_tokens,+ cache_read_tokens=cached_tokens,+ cache_creation_tokens=cache_write_tokens,+ )stop_reason = "max_tokens" if incomplete else "end_turn"events.append(self.ledger.message_delta(diff --git a/src/free_claude_code/providers/openai_chat/provider.py b/src/free_claude_code/providers/openai_chat/provider.pyindex f0ffd65d..889f1c5d 100644--- a/src/free_claude_code/providers/openai_chat/provider.py+++ b/src/free_claude_code/providers/openai_chat/provider.py@@ -32,6 +32,7 @@ from free_claude_code.core.anthropic.streaming import (parse_complete_tool_input,tool_schemas_by_name,)+from free_claude_code.core.anthropic.usage import anthropic_input_usage_fieldsfrom free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.core.openai_responses import (OpenAIResponsesRequest,@@ -726,23 +727,21 @@ class OpenAIChatProvider(BaseProvider):"cached_tokens",)- def _anthropic_usage_fields(self, usage_info: Any) -> dict[str, int]:- """Split standard cached prompt tokens for final Anthropic usage."""- prompt_tokens = usage_int(usage_info, "prompt_tokens")- cached_tokens = self._cached_input_tokens(usage_info)- if (- prompt_tokens is None- or prompt_tokens < 0- or cached_tokens is None- or cached_tokens < 0- or cached_tokens > prompt_tokens- ):- return {}+ def _cache_write_input_tokens(self, usage_info: object) -> int | None:+ """Return the provider's cache-write count from final Chat usage."""+ return nested_usage_int(+ usage_info,+ "prompt_tokens_details",+ "cache_write_tokens",+ )- return {- "input_tokens": prompt_tokens - cached_tokens,- "cache_read_input_tokens": cached_tokens,- }+ def _anthropic_usage_fields(self, usage_info: Any) -> dict[str, int]:+ """Split standard prompt cache counts for final Anthropic usage."""+ return anthropic_input_usage_fields(+ usage_int(usage_info, "prompt_tokens"),+ cache_read_tokens=self._cached_input_tokens(usage_info),+ cache_creation_tokens=self._cache_write_input_tokens(usage_info),+ )async def _create_stream(self,@@ -1104,6 +1103,9 @@ class _OpenAIChatStreamRunner:output_tokens=completion.output_tokens,cached_tokens=self._provider._cached_input_tokens(assembler.usage_info)or 0,+ cache_write_tokens=self._provider._cache_write_input_tokens(+ assembler.usage_info+ ),reasoning_tokens=(nested_usage_int(assembler.usage_info,diff --git a/src/free_claude_code/providers/openai_chat/stream_output.py b/src/free_claude_code/providers/openai_chat/stream_output.pyindex 6f4e4579..a574fe8b 100644--- a/src/free_claude_code/providers/openai_chat/stream_output.py+++ b/src/free_claude_code/providers/openai_chat/stream_output.py@@ -47,6 +47,7 @@ class ChatStreamUsage:input_tokens: intoutput_tokens: intcached_tokens: int = 0+ cache_write_tokens: int | None = Nonereasoning_tokens: int = 0anthropic_fields: Mapping[str, int] = field(default_factory=dict)@@ -684,11 +685,25 @@ class ResponsesChatStreamOutput(ChatStreamOutput):def _responses_usage(usage: ChatStreamUsage) -> dict[str, object]:- cached_tokens = max(0, min(usage.cached_tokens, usage.input_tokens))+ cached_tokens = usage.cached_tokens+ if (+ not isinstance(cached_tokens, int)+ or isinstance(cached_tokens, bool)+ or not 0 <= cached_tokens <= usage.input_tokens+ ):+ cached_tokens = 0reasoning_tokens = max(0, min(usage.reasoning_tokens, usage.output_tokens))+ input_token_details = {"cached_tokens": cached_tokens}+ cache_write_tokens = usage.cache_write_tokens+ if (+ isinstance(cache_write_tokens, int)+ and not isinstance(cache_write_tokens, bool)+ and 0 <= cache_write_tokens <= usage.input_tokens - cached_tokens+ ):+ input_token_details["cache_write_tokens"] = cache_write_tokensreturn {"input_tokens": usage.input_tokens,- "input_tokens_details": {"cached_tokens": cached_tokens},+ "input_tokens_details": input_token_details,"output_tokens": usage.output_tokens,"output_tokens_details": {"reasoning_tokens": reasoning_tokens},"total_tokens": usage.input_tokens + usage.output_tokens,diff --git a/tests/core/anthropic/test_usage.py b/tests/core/anthropic/test_usage.pynew file mode 100644index 00000000..342bcc83--- /dev/null+++ b/tests/core/anthropic/test_usage.py@@ -0,0 +1,105 @@+from typing import cast++import pytest++from free_claude_code.core.anthropic.usage import anthropic_input_usage_fields+++ ("total_tokens", "cache_read_tokens", "cache_creation_tokens", "expected"),+ [+ (+ 30,+ 10,+ 5,+ {+ "input_tokens": 15,+ "cache_read_input_tokens": 10,+ "cache_creation_input_tokens": 5,+ },+ ),+ (30, 10, None, {"input_tokens": 20, "cache_read_input_tokens": 10}),+ (+ 30,+ None,+ 5,+ {"input_tokens": 25, "cache_creation_input_tokens": 5},+ ),+ (+ 30,+ 0,+ 0,+ {+ "input_tokens": 30,+ "cache_read_input_tokens": 0,+ "cache_creation_input_tokens": 0,+ },+ ),+ (30, None, None, {}),+ (None, 10, 5, {}),+ (-1, 0, 0, {}),+ (True, 0, 0, {}),+ (30.0, 10, 5, {}),+ (+ 30,+ -1,+ 5,+ {"input_tokens": 25, "cache_creation_input_tokens": 5},+ ),+ (+ 30,+ True,+ 5,+ {"input_tokens": 25, "cache_creation_input_tokens": 5},+ ),+ (+ 30,+ "10",+ 5,+ {"input_tokens": 25, "cache_creation_input_tokens": 5},+ ),+ (+ 30,+ 31,+ 5,+ {"input_tokens": 25, "cache_creation_input_tokens": 5},+ ),+ (30, 10, -1, {"input_tokens": 20, "cache_read_input_tokens": 10}),+ (30, 10, True, {"input_tokens": 20, "cache_read_input_tokens": 10}),+ (30, 10, "5", {"input_tokens": 20, "cache_read_input_tokens": 10}),+ (30, 10, 21, {"input_tokens": 20, "cache_read_input_tokens": 10}),+ ],+ ids=[+ "read-and-creation",+ "read-only",+ "creation-only",+ "explicit-zeroes",+ "no-cache-details",+ "missing-total",+ "negative-total",+ "boolean-total",+ "float-total",+ "negative-read",+ "boolean-read",+ "string-read",+ "read-over-total",+ "negative-creation",+ "boolean-creation",+ "string-creation",+ "creation-over-remaining-total",+ ],+)+def test_anthropic_input_usage_fields_preserve_only_trustworthy_partitions(+ total_tokens: object,+ cache_read_tokens: object,+ cache_creation_tokens: object,+ expected: dict[str, int],+) -> None:+ assert (+ anthropic_input_usage_fields(+ cast(int | None, total_tokens),+ cache_read_tokens=cast(int | None, cache_read_tokens),+ cache_creation_tokens=cast(int | None, cache_creation_tokens),+ )+ == expected+ )diff --git a/tests/core/openai_responses/test_native.py b/tests/core/openai_responses/test_native.pyindex 48926e6d..9700e947 100644--- a/tests/core/openai_responses/test_native.py+++ b/tests/core/openai_responses/test_native.py@@ -140,7 +140,15 @@ def test_native_relay_preserves_payload_and_rewrites_only_response_model() -> No"model": "upstream-model","status": "completed","output": [item["item"]],- "usage": {"input_tokens": 11, "output_tokens": 4, "total_tokens": 15},+ "usage": {+ "input_tokens": 11,+ "input_tokens_details": {+ "cached_tokens": 6,+ "cache_write_tokens": 2,+ },+ "output_tokens": 4,+ "total_tokens": 15,+ },},}diff --git a/tests/core/openai_responses/test_provider_stream.py b/tests/core/openai_responses/test_provider_stream.pyindex 7dfebd55..b4222f19 100644--- a/tests/core/openai_responses/test_provider_stream.py+++ b/tests/core/openai_responses/test_provider_stream.py@@ -12,6 +12,26 @@ from free_claude_code.core.openai_responses.provider_stream import (from free_claude_code.core.openai_tool_names import OpenAIToolNameCodec+def _terminal_usage(usage: dict[str, object]) -> dict[str, object]:+ stream = ResponsesProviderStream(+ message_id="msg_test",+ model="openai/gpt-test",+ input_tokens=12,+ )+ output = stream.start()+ output.extend(+ stream.feed(+ "response.completed",+ {"response": {"usage": usage}},+ )+ )+ return next(+ event.data["usage"]+ for event in parse_sse_text("".join(output))+ if event.event == "message_delta"+ )++def test_responses_provider_stream_preserves_reasoning_tools_usage_and_ids() -> None:stream = ResponsesProviderStream(message_id="msg_test",@@ -95,7 +115,10 @@ def test_responses_provider_stream_preserves_reasoning_tools_usage_and_ids() ->"usage": {"input_tokens": 20,"output_tokens": 8,- "input_tokens_details": {"cached_tokens": 15},+ "input_tokens_details": {+ "cached_tokens": 15,+ "cache_write_tokens": 3,+ },}}},@@ -125,12 +148,103 @@ def test_responses_provider_stream_preserves_reasoning_tools_usage_and_ids() ->assert argument_deltas == ['{"q":', '"x"}']message_delta = next(event for event in events if event.event == "message_delta")assert message_delta.data["usage"] == {- "input_tokens": 5,+ "input_tokens": 2,"output_tokens": 8,"cache_read_input_tokens": 15,+ "cache_creation_input_tokens": 3,}+ ("details", "expected"),+ [+ (+ {"cached_tokens": 10, "cache_write_tokens": 5},+ {+ "input_tokens": 15,+ "output_tokens": 8,+ "cache_read_input_tokens": 10,+ "cache_creation_input_tokens": 5,+ },+ ),+ (+ {"cached_tokens": 10},+ {+ "input_tokens": 20,+ "output_tokens": 8,+ "cache_read_input_tokens": 10,+ },+ ),+ (+ {"cache_write_tokens": 5},+ {+ "input_tokens": 25,+ "output_tokens": 8,+ "cache_creation_input_tokens": 5,+ },+ ),+ (+ {"cached_tokens": 0, "cache_write_tokens": 0},+ {+ "input_tokens": 30,+ "output_tokens": 8,+ "cache_read_input_tokens": 0,+ "cache_creation_input_tokens": 0,+ },+ ),+ (+ {"cached_tokens": 10, "cache_write_tokens": -1},+ {+ "input_tokens": 20,+ "output_tokens": 8,+ "cache_read_input_tokens": 10,+ },+ ),+ (+ {"cached_tokens": 10, "cache_write_tokens": 21},+ {+ "input_tokens": 20,+ "output_tokens": 8,+ "cache_read_input_tokens": 10,+ },+ ),+ (+ {"cached_tokens": -1, "cache_write_tokens": 5},+ {+ "input_tokens": 25,+ "output_tokens": 8,+ "cache_creation_input_tokens": 5,+ },+ ),+ ({}, {"input_tokens": 30, "output_tokens": 8}),+ ],+ ids=[+ "read-and-creation",+ "read-only",+ "creation-only",+ "explicit-zeroes",+ "invalid-creation",+ "creation-over-remaining-total",+ "invalid-read-preserves-creation",+ "no-cache-details",+ ],+)+def test_responses_provider_stream_preserves_trustworthy_cache_partitions(+ details: dict[str, object],+ expected: dict[str, object],+) -> None:+ assert (+ _terminal_usage(+ {+ "input_tokens": 30,+ "output_tokens": 8,+ "input_tokens_details": details,+ }+ )+ == expected+ )++@pytest.mark.parametrize(("input_tokens", "cached_tokens", "expected_input_tokens"),[diff --git a/tests/providers/test_openai_chat_stream_output.py b/tests/providers/test_openai_chat_stream_output.pyindex 8df42f1e..3d8509e4 100644--- a/tests/providers/test_openai_chat_stream_output.py+++ b/tests/providers/test_openai_chat_stream_output.py@@ -1,4 +1,7 @@import json+from typing import cast++import pytestfrom free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.openai_responses.models import OpenAIResponsesRequest@@ -19,6 +22,18 @@ def _object_dict(value: object) -> dict[str, object]:return value+def _finished_responses_usage(usage: ChatStreamUsage) -> dict[str, object]:+ output = ResponsesChatStreamOutput(+ OpenAIResponsesRequest.model_validate(+ {"model": "public-model", "input": "Hello"}+ ),+ input_tokens=1,+ )+ frames = output.finish_success(stop_reason="stop", usage=usage)+ final = _object_dict(_parse_frame(frames[-1])[1]["response"])+ return _object_dict(final["usage"])++def test_anthropic_chat_output_preserves_existing_wire_lifecycle() -> None:output = AnthropicChatStreamOutput(message_id="msg_test",@@ -112,6 +127,7 @@ def test_responses_chat_output_emits_one_native_lifecycle_with_exact_usage() ->input_tokens=20,output_tokens=8,cached_tokens=5,+ cache_write_tokens=4,reasoning_tokens=3,),)@@ -134,7 +150,7 @@ def test_responses_chat_output_emits_one_native_lifecycle_with_exact_usage() ->assert final["status"] == "completed"assert final["usage"] == {"input_tokens": 20,- "input_tokens_details": {"cached_tokens": 5},+ "input_tokens_details": {"cached_tokens": 5, "cache_write_tokens": 4},"output_tokens": 8,"output_tokens_details": {"reasoning_tokens": 3},"total_tokens": 28,@@ -158,6 +174,70 @@ def test_responses_chat_output_emits_one_native_lifecycle_with_exact_usage() ->}+def test_responses_chat_output_preserves_explicit_zero_cache_write() -> None:+ usage = _finished_responses_usage(+ ChatStreamUsage(+ input_tokens=20,+ output_tokens=8,+ cached_tokens=5,+ cache_write_tokens=0,+ )+ )++ assert usage["input_tokens_details"] == {+ "cached_tokens": 5,+ "cache_write_tokens": 0,+ }+++ "cache_write_tokens",+ [None, -1, 16, True, "4"],+ ids=["absent", "negative", "over-remaining-total", "boolean", "string"],+)+def test_responses_chat_output_omits_untrustworthy_cache_write_without_losing_read(+ cache_write_tokens: object,+) -> None:+ usage = _finished_responses_usage(+ ChatStreamUsage(+ input_tokens=20,+ output_tokens=8,+ cached_tokens=5,+ cache_write_tokens=cast(int | None, cache_write_tokens),+ )+ )++ assert usage == {+ "input_tokens": 20,+ "input_tokens_details": {"cached_tokens": 5},+ "output_tokens": 8,+ "output_tokens_details": {"reasoning_tokens": 0},+ "total_tokens": 28,+ }+++def test_responses_chat_output_ignores_overflowing_read_without_losing_write() -> None:+ usage = _finished_responses_usage(+ ChatStreamUsage(+ input_tokens=20,+ output_tokens=8,+ cached_tokens=21,+ cache_write_tokens=5,+ )+ )++ assert usage == {+ "input_tokens": 20,+ "input_tokens_details": {+ "cached_tokens": 0,+ "cache_write_tokens": 5,+ },+ "output_tokens": 8,+ "output_tokens_details": {"reasoning_tokens": 0},+ "total_tokens": 28,+ }++def test_responses_chat_output_finishes_committed_failure_once() -> None:output = ResponsesChatStreamOutput(OpenAIResponsesRequest.model_validate(diff --git a/tests/providers/test_openai_chat_usage.py b/tests/providers/test_openai_chat_usage.pyindex 9ff5cf05..71bed953 100644--- a/tests/providers/test_openai_chat_usage.py+++ b/tests/providers/test_openai_chat_usage.py@@ -15,6 +15,7 @@ from free_claude_code.core.anthropic.sse_aggregation import (aggregate_anthropic_sse_to_message,)from free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderOperationKindfrom free_claude_code.providers.openai_chat import (@@ -152,34 +153,93 @@ def test_usage_int_reads_dict_object_and_model_extra():assert usage_int({"prompt_tokens": True}, "prompt_tokens") is None+ ("usage", "expected"),+ [+ (+ {"prompt_tokens_details": {"cache_write_tokens": 5}},+ 5,+ ),+ (+ CompletionUsage(+ completion_tokens=4,+ prompt_tokens=22,+ total_tokens=26,+ prompt_tokens_details=PromptTokensDetails(cache_write_tokens=5),+ ),+ 5,+ ),+ (+ SimpleNamespace(+ prompt_tokens_details=None,+ model_extra={+ "prompt_tokens_details": {"cache_write_tokens": 5},+ },+ ),+ 5,+ ),+ ({"prompt_tokens_details": {"cache_write_tokens": 0}}, 0),+ ({"prompt_tokens_details": {"cache_write_tokens": True}}, None),+ ({"prompt_tokens_details": {"cache_write_tokens": 5.0}}, None),+ ({"prompt_tokens_details": {"cache_write_tokens": "5"}}, None),+ ({"prompt_tokens_details": None}, None),+ ],+)+def test_extracts_standard_chat_cache_write_tokens(usage, expected) -> None:+ provider = _UsageTestProvider()++ assert provider._cache_write_input_tokens(usage) == expected++@pytest.mark.parametrize(("usage", "expected"),[({"prompt_tokens": 22,- "prompt_tokens_details": {"cached_tokens": 15},+ "prompt_tokens_details": {+ "cached_tokens": 15,+ "cache_write_tokens": 3,+ },+ },+ {+ "input_tokens": 4,+ "cache_read_input_tokens": 15,+ "cache_creation_input_tokens": 3,},- {"input_tokens": 7, "cache_read_input_tokens": 15},),(CompletionUsage(completion_tokens=4,prompt_tokens=22,total_tokens=26,- prompt_tokens_details=PromptTokensDetails(cached_tokens=15),+ prompt_tokens_details=PromptTokensDetails(+ cached_tokens=15,+ cache_write_tokens=3,+ ),),- {"input_tokens": 7, "cache_read_input_tokens": 15},+ {+ "input_tokens": 4,+ "cache_read_input_tokens": 15,+ "cache_creation_input_tokens": 3,+ },),(SimpleNamespace(prompt_tokens=22,prompt_tokens_details=None,model_extra={- "prompt_tokens_details": {"cached_tokens": 15},+ "prompt_tokens_details": {+ "cached_tokens": 15,+ "cache_write_tokens": 3,+ },},),- {"input_tokens": 7, "cache_read_input_tokens": 15},+ {+ "input_tokens": 4,+ "cache_read_input_tokens": 15,+ "cache_creation_input_tokens": 3,+ },),({@@ -195,6 +255,23 @@ def test_usage_int_reads_dict_object_and_model_extra():},{"input_tokens": 0, "cache_read_input_tokens": 0},),+ (+ {+ "prompt_tokens": 22,+ "prompt_tokens_details": {"cache_write_tokens": 3},+ },+ {"input_tokens": 19, "cache_creation_input_tokens": 3},+ ),+ (+ {+ "prompt_tokens": 22,+ "prompt_tokens_details": {+ "cached_tokens": 15,+ "cache_write_tokens": 8,+ },+ },+ {"input_tokens": 7, "cache_read_input_tokens": 15},+ ),],)def test_maps_standard_chat_cache_usage_to_anthropic_fields(usage, expected):@@ -282,7 +359,10 @@ async def test_openai_chat_stream_requests_usage_and_uses_provider_prompt_tokenscompletion_tokens=4,prompt_tokens=22,total_tokens=26,- prompt_tokens_details=PromptTokensDetails(cached_tokens=15),+ prompt_tokens_details=PromptTokensDetails(+ cached_tokens=15,+ cache_write_tokens=3,+ ),)create = AsyncMock(return_value=_stream(@@ -314,9 +394,10 @@ async def test_openai_chat_stream_requests_usage_and_uses_provider_prompt_tokens)assert start_usage["input_tokens"] == 7assert final_usage == {- "input_tokens": 7,+ "input_tokens": 4,"output_tokens": 4,"cache_read_input_tokens": 15,+ "cache_creation_input_tokens": 3,}assert sum(event.event == "message_delta" for event in parsed) == 1assert sum(event.event == "message_stop" for event in parsed) == 1@@ -330,7 +411,10 @@ async def test_openai_chat_nonstream_message_uses_final_cache_partition():completion_tokens=4,prompt_tokens=22,total_tokens=26,- prompt_tokens_details=PromptTokensDetails(cached_tokens=15),+ prompt_tokens_details=PromptTokensDetails(+ cached_tokens=15,+ cache_write_tokens=3,+ ),)create = AsyncMock(return_value=_stream(@@ -349,9 +433,55 @@ async def test_openai_chat_nonstream_message_uses_final_cache_partition():assert error is Noneassert message["usage"] == {- "input_tokens": 7,+ "input_tokens": 4,"output_tokens": 4,"cache_read_input_tokens": 15,+ "cache_creation_input_tokens": 3,+ }+++async def test_openai_chat_responses_stream_preserves_cache_write_usage():+ provider = _UsageTestProvider()+ request = OpenAIResponsesRequest.model_validate({"model": "m", "input": "hello"})+ usage = CompletionUsage(+ completion_tokens=4,+ prompt_tokens=22,+ total_tokens=26,+ prompt_tokens_details=PromptTokensDetails(+ cached_tokens=15,+ cache_write_tokens=3,+ ),+ )+ create = AsyncMock(+ return_value=_stream(+ [+ _chunk(content="hello"),+ _chunk(finish_reason="stop"),+ _chunk(usage=usage),+ ]+ )+ )++ with patch.object(provider._client.chat.completions, "create", create):+ events = [+ event async for event in provider.stream_responses(request, input_tokens=7)+ ]++ completed = next(+ event.data["response"]+ for event in parse_sse_text("".join(events))+ if event.event == "response.completed"+ )+ assert completed["usage"] == {+ "input_tokens": 22,+ "input_tokens_details": {+ "cached_tokens": 15,+ "cache_write_tokens": 3,+ },+ "output_tokens": 4,+ "output_tokens_details": {"reasoning_tokens": 0},+ "total_tokens": 26,}diff --git a/uv.lock b/uv.lockindex 6f169da3..d6fe5031 100644--- a/uv.lock+++ b/uv.lock@@ -607,7 +607,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "5.15.4"+version = "5.15.5"source = { editable = "." }dependencies = [{ name = "aiohttp" },