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
"""Native reasoning survives conversion without trailing FCC replay records."""
import asyncio
import json
from copy import deepcopy
import httpx2
import pytest
from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.core.failures import ExecutionFailure, FailureKind
from free_claude_code.core.history_replay import ReplayOrigin, decode_replay
from free_claude_code.core.openai_responses.chat_request import (
build_responses_chat_request,
)
from free_claude_code.core.openai_responses.models import OpenAIResponsesRequest
from free_claude_code.core.openai_responses.provider_input import (
build_responses_provider_request,
)
from free_claude_code.core.openai_responses.provider_stream import (
ResponsesProviderStream,
)
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.gemini import GeminiProvider
from free_claude_code.providers.openai_chat.reasoning_details import (
StructuredReasoningStream,
)
from free_claude_code.providers.openai_chat.stream_output import (
AnthropicChatStreamOutput,
)
from tests.api.test_hidden_stream_retries import delivered
from tests.providers.support import immediate_admission, make_provider_config
from tests.providers.test_history_transports import (
_events_for,
_harness,
_native,
_saved_reply,
)
def _chunks(deltas):
return [
{
"id": "chat_native_reasoning",
"object": "chat.completion.chunk",
"created": 0,
"model": "actual-returned",
"choices": [{"index": 0, "delta": delta, "finish_reason": finish}],
}
for delta, finish in deltas
]
@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
@pytest.mark.parametrize("thinking", ["", "Plan."])
async def test_plain_reasoning_emits_no_artificial_replay_state(wire, thinking):
upstream = _chunks(
[
({"reasoning_content": thinking}, None),
({"content": "Answer."}, "stop"),
]
)
async with _harness("chat", lambda _: (200, upstream)) as (send, _, _):
stream = "".join(
[
chunk
async for chunk in send(wire, [{"role": "user", "content": "hello"}])
]
)
assert "fcc:history:" not in stream
events = parse_sse_text(stream)
if wire == "messages":
starts = [
event.data for event in events if event.event == "content_block_start"
]
assert [event["content_block"]["type"] for event in starts] == ["text"] + (
["thinking"] if thinking else []
)
stops = [
event.data["index"]
for event in events
if event.event == "content_block_stop"
]
assert stops[-1] == next(
event["index"]
for event in starts
if event["content_block"]["type"] == "text"
)
else:
output = events[-1].data["response"]["output"]
assert [item["type"] for item in output] == ["message"] + (
["reasoning"] if thinking else []
)
assert all(not item.get("encrypted_content") for item in output)
@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
async def test_late_opaque_metadata_finishes_before_answer(wire):
upstream = _chunks(
[
(
{
"reasoning_content": "Plan.",
"reasoning_details": [
{"type": "reasoning.encrypted", "data": "first", "index": 0}
],
},
None,
),
({"content": "Answer."}, None),
(
{
"reasoning_details": [
{"type": "reasoning.encrypted", "data": "second", "index": 0}
]
},
"stop",
),
]
)
async with _harness("chat", lambda _: (200, upstream)) as (send, _, _):
stream = "".join(
[
chunk
async for chunk in send(wire, [{"role": "user", "content": "hello"}])
]
)
assert "fcc:history:" not in stream
events = parse_sse_text(stream)
if wire == "messages":
starts = [
event.data for event in events if event.event == "content_block_start"
]
text_index = next(
event["index"]
for event in starts
if event["content_block"]["type"] == "text"
)
assert [
event.data["index"]
for event in events
if event.event == "content_block_stop"
][-1] == text_index
assert [
event.data["delta"]["signature"]
for event in events
if event.data.get("delta", {}).get("type") == "signature_delta"
] == ["firstsecond"]
else:
done = [
event.data["item"]
for event in events
if event.event == "response.output_item.done"
]
assert [
item.get("encrypted_content")
for item in done
if item["type"] == "reasoning"
] == ["firstsecond"]
assert done[-1]["type"] == "message"
@pytest.mark.asyncio
@pytest.mark.parametrize("protocol", ["messages", "responses"])
async def test_native_reasoning_is_forwarded_without_replacement(protocol):
async with _harness(protocol) as (send, _, _):
saved = await _saved_reply(
send(protocol, [{"role": "user", "content": "hello"}]), protocol
)
item = saved[0]["content"][0] if protocol == "messages" else saved[0]
assert item == _native(protocol)
@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
@pytest.mark.parametrize("signature_first", [False, True])
async def test_google_message_signature_round_trips_in_its_native_field(
wire, signature_first
):
upstream = _chunks(
[
({"content": "Pong"}, None),
(
{
"extra_content": {
"google": {"thought_signature": "google-signature"}
}
},
"stop",
),
]
)
if signature_first:
signature = upstream[1]["choices"][0]
signature["finish_reason"] = None
upstream[0]["choices"][0]["finish_reason"] = "stop"
upstream.reverse()
def factory():
return GeminiProvider(
make_provider_config(
api_key="test-key", base_url="https://provider.invalid/v1"
),
admission=immediate_admission(),
)
async with _harness(
"chat", lambda _: (200, upstream), chat_provider_factory=factory
) as (send, bodies, _):
saved = await _saved_reply(
send(wire, [{"role": "user", "content": "hello"}]), wire
)
await _saved_reply(
send(wire, [*saved, {"role": "user", "content": "next"}]), wire
)
assistant = [
message for message in bodies[-1]["messages"] if message["role"] == "assistant"
]
assert len(assistant) == 1
assert assistant[0]["content"] == "Pong"
assert (
assistant[0]["extra_content"]["google"]["thought_signature"]
== "google-signature"
)
assert "reasoning_details" not in assistant[0]
@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
@pytest.mark.parametrize("provider_kind", ["google", "structured"])
async def test_interrupted_opaque_only_state_keeps_hidden_retry_eligible(
wire, provider_kind
):
delta = (
{"extra_content": {"google": {"thought_signature": "abandoned-signature"}}}
if provider_kind == "google"
else {
"reasoning_details": [
{
"type": "reasoning.encrypted",
"data": "abandoned-signature",
"index": 0,
}
]
}
)
first = _chunks([(delta, None)])
class Cutoff(httpx2.AsyncByteStream):
async def __aiter__(self):
yield ("data: " + json.dumps(first[0]) + "\n\n").encode()
await asyncio.sleep(0.9)
def factory():
return GeminiProvider(
make_provider_config(
api_key="test-key", base_url="https://provider.invalid/v1"
),
admission=immediate_admission(max_attempts=2),
)
second = _chunks([({"content": "Recovered answer."}, "stop")])
async with _harness(
"chat",
lambda bodies: (200, Cutoff() if len(bodies) == 1 else second),
chat_provider_factory=factory if provider_kind == "google" else None,
max_attempts=2,
) as (_, bodies, provider):
if wire == "messages":
stream = provider.stream_messages(
MessagesRequest(
model="requested", messages=[{"role": "user", "content": "hello"}]
),
reasoning=ReasoningPolicy.off(),
)
else:
stream = provider.stream_responses(
OpenAIResponsesRequest(model="requested", input="hello"),
reasoning=ReasoningPolicy.off(),
)
raw = await delivered(stream, wire)
assert len(bodies) == 2
assert "Recovered answer." in raw
assert "abandoned-signature" not in raw
assert "response.failed" not in raw
def test_failure_does_not_publish_unfinished_opaque_state():
output = AnthropicChatStreamOutput(
message_id="msg_test", model="public", input_tokens=1
)
reasoning = StructuredReasoningStream()
output.reasoning_replay = reasoning
frames = output.start_events()
frames += list(
reasoning.events(
{
"reasoning_details": [
{
"type": "reasoning.encrypted",
"data": "partial-cipher",
"index": 0,
}
]
},
output,
native_reasoning="Plan.",
)
)
frames += output.ensure_text_block()
frames.append(output.emit_text_delta("Partial answer."))
output.defer_opaque_reasoning("pending-message-signature")
frames += output.finish_failure(
ExecutionFailure(FailureKind.UPSTREAM, 502, "Disconnected", True)
)
stream = "".join(frames)
assert "partial-cipher" not in stream
assert "pending-message-signature" not in stream
assert "message_stop" not in stream
@pytest.mark.asyncio
async def test_responses_late_cipher_preserves_thinking_and_final_answer():
original = _events_for("responses")
message = {
"id": "msg_answer",
"type": "message",
"role": "assistant",
"status": "completed",
"content": [{"type": "output_text", "text": "Pong", "annotations": []}],
}
terminal = original[-1]
terminal["response"]["output"].append(message)
upstream = [
*original[:3],
{
"type": "response.output_item.added",
"sequence_number": 3,
"output_index": 1,
"item": {**message, "status": "in_progress", "content": []},
},
{
"type": "response.output_text.delta",
"sequence_number": 4,
"output_index": 1,
"item_id": "msg_answer",
"content_index": 0,
"delta": "Pong",
},
{
"type": "response.output_item.done",
"sequence_number": 5,
"output_index": 1,
"item": message,
},
{**original[3], "sequence_number": 6},
{**terminal, "sequence_number": 7},
]
async with _harness("responses", lambda _: (200, upstream)) as (send, _, _):
stream = "".join(
[
chunk
async for chunk in send(
"messages", [{"role": "user", "content": "hello"}]
)
]
)
events = parse_sse_text(stream)
starts = [event.data for event in events if event.event == "content_block_start"]
text_index = next(
event["index"] for event in starts if event["content_block"]["type"] == "text"
)
assert [
event.data["index"] for event in events if event.event == "content_block_stop"
][-1] == text_index
assert [
decode_replay(event.data["delta"]["signature"]).native["encrypted_content"]
for event in events
if event.data.get("delta", {}).get("type") == "signature_delta"
] == ["opaque-original"]
@pytest.mark.asyncio
async def test_responses_retains_distinct_summary_and_full_reasoning():
upstream = _chunks(
[
(
{
"reasoning_details": [
{
"type": "reasoning.summary",
"summary": "Short summary.",
"index": 0,
}
]
},
None,
),
({"reasoning_content": "Distinct full thought."}, None),
({"content": "Answer."}, "stop"),
]
)
async with _harness("chat", lambda _: (200, upstream)) as (send, _, _):
saved = await _saved_reply(
send("responses", [{"role": "user", "content": "hello"}]), "responses"
)
reasoning = saved[0]
assert reasoning["summary"] == [{"type": "summary_text", "text": "Short summary."}]
assert reasoning["content"] == [
{"type": "reasoning_text", "text": "Distinct full thought."}
]
@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
async def test_hiding_readable_thinking_preserves_opaque_replay_state(wire):
upstream = _chunks(
[
(
{
"reasoning_content": "Hidden thought.",
"reasoning_details": [
{
"type": "reasoning.encrypted",
"data": "opaque-kept",
"index": 0,
}
],
},
None,
),
({"content": "Answer."}, "stop"),
]
)
async with _harness("chat", lambda _: (200, upstream)) as (_, _, provider):
if wire == "messages":
stream = provider.stream_messages(
MessagesRequest(
model="requested", messages=[{"role": "user", "content": "hello"}]
),
input_tokens=0,
reasoning=ReasoningPolicy.off(),
)
else:
stream = provider.stream_responses(
OpenAIResponsesRequest(model="requested", input="hello"),
input_tokens=0,
reasoning=ReasoningPolicy.off(),
)
output = "".join([chunk async for chunk in stream])
assert "Hidden thought." not in output
assert "opaque-kept" in output
def test_converted_top_level_thought_has_valid_responses_identity():
body = build_responses_provider_request(
MessagesRequest(
model="native",
messages=[
{
"role": "assistant",
"content": "Answer.",
"reasoning_content": "Plan.",
}
],
),
reasoning=ReasoningPolicy.on(),
)
assert body["input"][0]["id"].startswith("rs_")
def test_responses_summary_maps_to_structured_chat_summary():
request = OpenAIResponsesRequest(
model="native",
input=[
{
"type": "reasoning",
"summary": [{"type": "summary_text", "text": "Short summary."}],
"content": [{"type": "reasoning_text", "text": "Full thought."}],
"encrypted_content": "cipher",
},
{"type": "message", "role": "assistant", "content": "Answer."},
],
)
body = build_responses_chat_request(
request,
reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,
structured_reasoning_details=True,
).body
messages = body["messages"]
assert isinstance(messages, list)
assistant = messages[0]
assert assistant["content"] == "Answer."
assert assistant["reasoning_details"] == [
{"type": "reasoning.text", "text": "Full thought.", "signature": "cipher"},
{"type": "reasoning.summary", "summary": "Short summary."},
]
assert json.dumps(body).count("Full thought.") == 1
def test_existing_responses_tool_delta_does_not_close_final_text():
stream = ResponsesProviderStream(
origin=ReplayOrigin("test", "responses", "", "", "m"),
message_id="msg_test",
model="native",
input_tokens=1,
)
frames = stream.start()
frames += stream.feed(
"response.output_item.added",
{
"item": {
"type": "function_call",
"id": "fc_1",
"call_id": "call_1",
"name": "lookup",
}
},
)
frames += stream.feed(
"response.function_call_arguments.delta", {"item_id": "fc_1", "delta": '{"q":'}
)
frames += stream.feed(
"response.output_text.delta", {"item_id": "msg_answer", "delta": "Answer."}
)
frames += stream.feed(
"response.function_call_arguments.delta", {"item_id": "fc_1", "delta": '"x"}'}
)
frames += stream.feed("response.completed", {"response": {}})
events = parse_sse_text("".join(frames))
starts = [event.data for event in events if event.event == "content_block_start"]
text_index = next(
event["index"] for event in starts if event["content_block"]["type"] == "text"
)
assert [
event.data["index"] for event in events if event.event == "content_block_stop"
][-1] == text_index
@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
async def test_unrecognized_detail_data_is_not_a_reasoning_signature(wire):
upstream = _chunks(
[
(
{
"reasoning_details": [
{"type": "provider.usage", "data": "ordinary-extra-data"}
],
"content": "Answer.",
},
"stop",
)
]
)
async with _harness("chat", lambda _: (200, upstream)) as (send, _, _):
saved = await _saved_reply(
send(wire, [{"role": "user", "content": "hello"}]), wire
)
assert "ordinary-extra-data" not in str(saved)
blocks = saved[0]["content"] if wire == "messages" else saved
assert [block["type"] for block in blocks] == [
"text" if wire == "messages" else "message"
]
@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
async def test_fragmented_summary_and_distinct_full_thought_replay_once(wire):
upstream = _chunks(
[
(
{
"reasoning_details": [
{"type": "reasoning.summary", "summary": "Short ", "index": 0}
]
},
None,
),
(
{
"reasoning_details": [
{"type": "reasoning.summary", "summary": "summary.", "index": 0}
]
},
None,
),
({"reasoning_content": "Full thought."}, None),
({"content": "Answer."}, "stop"),
]
)
async with _harness("chat", lambda _: (200, upstream)) as (send, bodies, _):
saved = await _saved_reply(
send(wire, [{"role": "user", "content": "hello"}]), wire
)
await _saved_reply(
send(wire, [*saved, {"role": "user", "content": "next"}]), wire
)
assert json.dumps(saved).count("Short summary.") == 1
assert json.dumps(saved).count("Full thought.") == 1
assert json.dumps(bodies[-1]).count("Short summary.") == 1
assert json.dumps(bodies[-1]).count("Full thought.") == 1
@pytest.mark.asyncio
async def test_hidden_readable_only_cutoff_retries_without_delivered_content():
first = _chunks(
[
(
{
"reasoning_details": [
{
"type": "reasoning.text",
"text": "Hidden thought.",
"index": 0,
}
]
},
None,
)
]
)
class Cutoff(httpx2.AsyncByteStream):
async def __aiter__(self):
yield ("data: " + json.dumps(first[0]) + "\n\n").encode()
await asyncio.sleep(0.9)
second = _chunks([({"content": "Recovered answer."}, "stop")])
async with _harness(
"chat",
lambda bodies: (200, Cutoff() if len(bodies) == 1 else second),
max_attempts=2,
) as (_, bodies, provider):
stream = provider.stream_responses(
OpenAIResponsesRequest(model="requested", input="hello"),
reasoning=ReasoningPolicy.off(),
)
raw = await delivered(stream, "responses")
assert len(bodies) == 2
assert "Recovered answer." in raw
assert "Hidden thought." not in raw
assert "response.failed" not in raw
assert '"type": "reasoning"' not in raw
@pytest.mark.asyncio
@pytest.mark.parametrize("answer_before_done", [False, True])
async def test_completed_full_reasoning_survives_streamed_summary(answer_before_done):
upstream = deepcopy(_events_for("responses"))
upstream[3]["item"]["content"] = [
{"type": "reasoning_text", "text": "Distinct full thought."}
]
if answer_before_done:
message = {
"id": "msg_answer",
"type": "message",
"role": "assistant",
"status": "completed",
"content": [{"type": "output_text", "text": "Answer.", "annotations": []}],
}
upstream[3:3] = [
{
"type": "response.output_item.added",
"output_index": 1,
"item": {**message, "status": "in_progress", "content": []},
},
{
"type": "response.output_text.delta",
"item_id": "msg_answer",
"output_index": 1,
"content_index": 0,
"delta": "Answer.",
},
{"type": "response.output_item.done", "output_index": 1, "item": message},
]
upstream[-1]["response"]["output"].append(message)
for sequence, event in enumerate(upstream):
event["sequence_number"] = sequence
async with _harness("responses", lambda _: (200, upstream)) as (send, bodies, _):
frames = [
frame
async for frame in send("messages", [{"role": "user", "content": "hello"}])
]
async def saved_frames():
for frame in frames:
yield frame
saved = await _saved_reply(saved_frames(), "messages")
await _saved_reply(
send("messages", [*saved, {"role": "user", "content": "next"}]), "messages"
)
assert json.dumps(saved).count("Find 17.") == 1
assert json.dumps(saved).count("Distinct full thought.") == 1
assert json.dumps(bodies[-1]).count("Find 17.") == 1
assert json.dumps(bodies[-1]).count("Distinct full thought.") == 1
if answer_before_done:
events = parse_sse_text("".join(frames))
text_index = next(
event.data["index"]
for event in events
if event.event == "content_block_start"
and event.data["content_block"]["type"] == "text"
)
assert [
event.data["index"]
for event in events
if event.event == "content_block_stop"
][-1] == text_index
@pytest.mark.parametrize("summary", [False, True])
def test_responses_seeded_reasoning_and_fragments_are_completed_once(summary):
stream = ResponsesProviderStream(
origin=ReplayOrigin("test", "responses", "", "", "m"),
message_id="msg_test",
model="native",
input_tokens=1,
)
field = "summary" if summary else "content"
part = "summary_text" if summary else "reasoning_text"
item = {
"type": "reasoning",
"id": "rs_seeded",
field: [{"type": part, "text": "First, "}],
}
frames = stream.start()
frames += stream.feed("response.output_item.added", {"item": item})
frames += stream.feed(
"response.reasoning_summary_text.delta"
if summary
else "response.reasoning_text.delta",
{"item_id": "rs_seeded", "delta": "think."},
)
frames += stream.feed(
"response.output_item.done",
{"item": {**item, field: [{"type": part, "text": "First, think."}]}},
)
frames += stream.feed("response.completed", {"response": {}})
events = parse_sse_text("".join(frames))
assert (
"".join(
event.data["delta"]["thinking"]
for event in events
if event.data.get("delta", {}).get("type") == "thinking_delta"
)
== "First, think."
)