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
import pytest
from free_claude_code.core.anthropic.stream_contracts import (
assert_anthropic_stream_contract,
parse_sse_text,
thinking_content,
)
from free_claude_code.core.history_replay import ReplayOrigin, decode_replay
from free_claude_code.core.openai_responses.provider_stream import (
ResponsesProviderStream,
ResponsesStreamFailure,
)
from free_claude_code.core.openai_tool_names import OpenAIToolNameCodec
def _terminal_usage(usage: dict[str, object]) -> dict[str, object]:
stream = ResponsesProviderStream(
origin=ReplayOrigin("test", "responses", "", "", "m"),
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(
origin=ReplayOrigin("test", "responses", "", "", "m"),
message_id="msg_test",
model="openai/gpt-test",
input_tokens=12,
)
output = stream.start()
output.extend(
stream.feed(
"response.output_item.added",
{
"item": {
"type": "reasoning",
"id": "rs_1",
}
},
)
)
output.extend(
stream.feed(
"response.reasoning_summary_text.delta",
{"item_id": "rs_1", "delta": "reasoning"},
)
)
output.extend(
stream.feed(
"response.output_item.done",
{
"item": {
"type": "reasoning",
"id": "rs_1",
"encrypted_content": "opaque",
}
},
)
)
output.extend(
stream.feed(
"response.output_item.added",
{
"item": {
"type": "function_call",
"id": "fc_1",
"call_id": "call_1",
"name": "lookup",
}
},
)
)
output.extend(
stream.feed(
"response.function_call_arguments.delta",
{"item_id": "fc_1", "delta": '{"q":'},
)
)
output.extend(
stream.feed(
"response.function_call_arguments.delta",
{"item_id": "fc_1", "delta": '"x"}'},
)
)
output.extend(
stream.feed(
"response.output_item.done",
{
"item": {
"type": "function_call",
"id": "fc_1",
"call_id": "call_1",
"name": "lookup",
"arguments": '{"q":"x"}',
}
},
)
)
output.extend(
stream.feed(
"response.completed",
{
"response": {
"usage": {
"input_tokens": 20,
"output_tokens": 8,
"input_tokens_details": {
"cached_tokens": 15,
"cache_write_tokens": 3,
},
}
}
},
)
)
events = parse_sse_text("".join(output))
assert_anthropic_stream_contract(events)
assert thinking_content(events) == "reasoning"
starts = [
event.data["content_block"]
for event in events
if event.event == "content_block_start"
]
assert [
decode_replay(event.data["delta"]["signature"]).native["encrypted_content"]
for event in events
if event.data.get("delta", {}).get("type") == "signature_delta"
] == ["opaque"]
assert {
"type": "tool_use",
"id": "call_1",
"name": "lookup",
"input": {},
} in starts
argument_deltas = [
event.data["delta"]["partial_json"]
for event in events
if event.data.get("delta", {}).get("type") == "input_json_delta"
]
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": 2,
"output_tokens": 8,
"cache_read_input_tokens": 15,
"cache_creation_input_tokens": 3,
}
@pytest.mark.parametrize(
("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"),
[
(20, -1, 20),
(20, 21, 20),
(20, True, 20),
(None, 5, 12),
],
)
def test_responses_provider_stream_ignores_invalid_cache_partitions(
input_tokens: int | None,
cached_tokens: int | bool,
expected_input_tokens: int,
) -> None:
stream = ResponsesProviderStream(
origin=ReplayOrigin("test", "responses", "", "", "m"),
message_id="msg_test",
model="openai/gpt-test",
input_tokens=12,
)
output = stream.start()
output.extend(
stream.feed(
"response.completed",
{
"response": {
"usage": {
"input_tokens": input_tokens,
"output_tokens": 8,
"input_tokens_details": {"cached_tokens": cached_tokens},
}
}
},
)
)
message_delta = next(
event
for event in parse_sse_text("".join(output))
if event.event == "message_delta"
)
assert message_delta.data["usage"] == {
"input_tokens": expected_input_tokens,
"output_tokens": 8,
}
def test_responses_provider_stream_surfaces_failed_event() -> None:
stream = ResponsesProviderStream(
origin=ReplayOrigin("test", "responses", "", "", "m"),
message_id="msg_test",
model="gpt-test",
input_tokens=0,
)
with pytest.raises(ResponsesStreamFailure, match="capacity") as exc_info:
stream.feed(
"response.failed",
{
"response": {
"error": {
"code": "server_error",
"message": "No capacity",
}
}
},
)
assert exc_info.value.code == "server_error"
def test_responses_provider_stream_restores_added_and_done_only_tool_names() -> None:
originals = (
"mcp__responses_added__" + "x" * 70,
"mcp__responses_done__" + "y" * 70,
)
codec = OpenAIToolNameCodec.from_names(originals)
stream = ResponsesProviderStream(
origin=ReplayOrigin("test", "responses", "", "", "m"),
message_id="msg_test",
model="gpt-test",
input_tokens=0,
tool_names=codec,
)
output = stream.start()
output.extend(
stream.feed(
"response.output_item.added",
{
"item": {
"type": "function_call",
"id": "fc_added",
"call_id": "call_added",
"name": codec.encode(originals[0]),
}
},
)
)
output.extend(
stream.feed(
"response.output_item.done",
{
"item": {
"type": "function_call",
"id": "fc_added",
"call_id": "call_added",
"name": codec.encode(originals[0]),
"arguments": "{}",
}
},
)
)
output.extend(
stream.feed(
"response.output_item.done",
{
"item": {
"type": "function_call",
"id": "fc_done",
"call_id": "call_done",
"name": codec.encode(originals[1]),
"arguments": "{}",
}
},
)
)
event_text = "".join(output)
starts = [
event.data["content_block"]
for event in parse_sse_text(event_text)
if event.event == "content_block_start"
]
assert [start["name"] for start in starts] == list(originals)
assert all(codec.encode(name) not in event_text for name in originals)