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
patch: preserve reasoning history across Messages round trips (#2083)
Ali Khokhardf79210b3079
diff --git a/src/free_claude_code/core/openai_responses/provider_input.py b/src/free_claude_code/core/openai_responses/provider_input.pyindex 0249525c..ac41c27f 100644--- a/src/free_claude_code/core/openai_responses/provider_input.py+++ b/src/free_claude_code/core/openai_responses/provider_input.py@@ -235,6 +235,16 @@ def _assistant_items(}if isinstance(signature, str) and signature:item["encrypted_content"] = signature+ if not is_replay(signature):+ items.append(item)+ thinking = str(get_block_attr(block, "thinking", ""))+ if thinking:+ items.append(+ _assistant_message(+ [{"type": "output_text", "text": thinking}]+ )+ )+ continueif not signature or (not is_replay(signature) or not has_readable_replay(signature)):diff --git a/src/free_claude_code/core/openai_responses/provider_stream.py b/src/free_claude_code/core/openai_responses/provider_stream.pyindex 4911aa4f..374343d0 100644--- a/src/free_claude_code/core/openai_responses/provider_stream.py+++ b/src/free_claude_code/core/openai_responses/provider_stream.py@@ -1,10 +1,16 @@"""Translate upstream OpenAI Responses events into Anthropic Messages SSE."""from dataclasses import dataclass, field-from typing import Any+from typing import Any, castfrom free_claude_code.core.anthropic.streaming import AnthropicStreamLedgerfrom free_claude_code.core.anthropic.usage import anthropic_input_usage_fields+from free_claude_code.core.history_replay import (+ ReplayOrigin,+ ReplayRecord,+ encode_replay,+)+from free_claude_code.core.json_types import JsonObjectfrom free_claude_code.core.openai_tool_names import OpenAIToolNameCodec@@ -59,6 +65,7 @@ class ResponsesProviderStream:message_id: str,model: str,input_tokens: int,+ origin: ReplayOrigin,log_raw_events: bool = False,tool_names: OpenAIToolNameCodec | None = None,pad_empty: bool = True,@@ -70,6 +77,7 @@ class ResponsesProviderStream:log_raw_events=log_raw_events,)self.completed = False+ self._origin = originself._pad_empty = pad_emptyself.generated_output = Falseself._tool_names = tool_names or OpenAIToolNameCodec.from_names(())@@ -257,6 +265,7 @@ class ResponsesProviderStream:return eventsif item_type == "reasoning":encrypted = item.get("encrypted_content")+ carrier = encode_replay(ReplayRecord(self._origin, cast(JsonObject, item)))events = self._item_readable(item, completed=True)state = self._reasoning[item_id]if (@@ -272,14 +281,13 @@ class ResponsesProviderStream:):events.extend(self._ensure_reasoning_started(state, completed=True))if state.block_index is not None:- if isinstance(encrypted, str) and encrypted:- events.append(- self.ledger.content_block_delta(- state.block_index,- "signature_delta",- encrypted,- )+ events.append(+ self.ledger.content_block_delta(+ state.block_index,+ "signature_delta",+ carrier,)+ )events.append(self.ledger.content_block_stop(state.block_index))state.stopped = Truereturn events@@ -287,7 +295,7 @@ class ResponsesProviderStream:index = self.ledger.blocks.allocate_index()events.append(self.ledger.content_block_start(- index, "redacted_thinking", data=encrypted+ index, "redacted_thinking", data=carrier))events.append(self.ledger.content_block_stop(index))diff --git a/src/free_claude_code/providers/history_replay.py b/src/free_claude_code/providers/history_replay.pyindex 26a38bbc..da9834b4 100644--- a/src/free_claude_code/providers/history_replay.py+++ b/src/free_claude_code/providers/history_replay.py@@ -264,13 +264,33 @@ def _rejected_record()return next((entry for entry in candidates if entry[0] == path), None)message = str(error.get("message", ""))+ named_ids = {+ value+ for match in re.findall(+ r"\b(?:for item|reasoning item|and item)\s+"+ r"(?:'([^']+)'|\"([^\"]+)\"|([A-Za-z0-9_-]+))(?=\s|[.,:]|$)",+ message,+ re.I,+ )+ for value in match+ if value+ }identified = [entryfor entry in candidates- if isinstance(entry[1].get("id"), str) and f"'{entry[1]['id']}'" in message+ if isinstance(entry[1].get("id"), str)+ and (+ entry[1]["id"] in named_ids+ or f"'{entry[1]['id']}'" in message+ or f'"{entry[1]["id"]}"' in message+ )]- if len(identified) == 1:+ if len(identified) == 1 and (+ not named_ids or named_ids == {identified[0][1]["id"]}+ ):return identified[0]+ if named_ids or identified:+ return Noneopaque = [entryfor entry in candidatesdiff --git a/src/free_claude_code/providers/openai_responses/presentation.py b/src/free_claude_code/providers/openai_responses/presentation.pyindex b0be1788..a5aad238 100644--- a/src/free_claude_code/providers/openai_responses/presentation.py+++ b/src/free_claude_code/providers/openai_responses/presentation.py@@ -5,6 +5,7 @@ from dataclasses import dataclassfrom typing import Protocolfrom free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.history_replay import ReplayOriginfrom free_claude_code.core.json_types import JsonObjectfrom free_claude_code.core.openai_responses import (NativeResponsesRelay,@@ -132,4 +133,6 @@ class ResponsesExecutionOutcome:failure: Exception | None = None-type ResponsesPresenterFactory = Callable[[bool], ResponsesStreamPresenter]+type ResponsesPresenterFactory = Callable[+ [bool, ReplayOrigin], ResponsesStreamPresenter+]diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.pyindex 5f30ce93..ac430a7d 100644--- a/src/free_claude_code/providers/openai_responses/transport.py+++ b/src/free_claude_code/providers/openai_responses/transport.py@@ -85,6 +85,7 @@ from .presentation import (NativeResponsesPresenter,ResponsesExecutionOutcome,ResponsesPresenterFactory,+ ResponsesStreamPresenter,)type ResponsesEventAdapter = Callable[[str, JsonObject], JsonObject]@@ -162,11 +163,12 @@ class OpenAIResponsesTransport:extra_headers=dict(extra_headers or {}),request_id=request_id,response_model=response_model,- presenter_factory=lambda pad_empty: MessagesResponsesPresenter(+ presenter_factory=lambda pad_empty, origin: MessagesResponsesPresenter(ResponsesProviderStream(message_id=message_id,model=response_model,input_tokens=input_tokens,+ origin=origin,tool_names=tool_names,log_raw_events=self._log_raw_sse_events,pad_empty=pad_empty,@@ -195,7 +197,7 @@ class OpenAIResponsesTransport:extra_headers=dict(extra_headers or {}),request_id=request_id,response_model=response_model,- presenter_factory=lambda _pad_empty: NativeResponsesPresenter(+ presenter_factory=lambda _pad_empty, _origin: NativeResponsesPresenter(public_model=response_model, tool_events=tools.event_adapter()),continuation=continuation,@@ -355,10 +357,7 @@ class OpenAIResponsesTransport:while execution.can_attempt:normal_stop_seen = Falsesource = SourceRecoveryState(execution, previous=source)- presenter = presenter_factory(- operation_kind is ProviderOperationKind.GENERATION- )- start_events = tuple(presenter.start())+ presenter: ResponsesStreamPresenter | None = Nonepresenter_started = Falseadapt_event = (self._event_adapter_factory()@@ -382,6 +381,10 @@ class OpenAIResponsesTransport:endpoint=endpoint.snapshot if endpoint is not None else None,)sent_body = prepare_history(body, origin)+ presenter = presenter_factory(+ operation_kind is ProviderOperationKind.GENERATION, origin+ )+ start_events = tuple(presenter.start())attempt = await execution.open_attempt(operation_kind)scope = ProviderAttemptScope(attempt,@@ -581,11 +584,13 @@ class OpenAIResponsesTransport:body=body,protocol="responses",normal_stop_seen=normal_stop_seen,- responses_failure_payload=presenter.failure_payload(- raw_error, failure+ responses_failure_payload=(+ presenter.failure_payload(raw_error, failure)+ if presenter is not None+ else None),) from raw_error- if not decision.committed:+ if not decision.committed or presenter is None:recovery.discard()raise failure from raw_errorfor event in presenter.terminal_failure(raw_error, failure):diff --git a/tests/core/openai_responses/test_provider_input.py b/tests/core/openai_responses/test_provider_input.pyindex 6218fc6b..2edaf528 100644--- a/tests/core/openai_responses/test_provider_input.py+++ b/tests/core/openai_responses/test_provider_input.py@@ -15,6 +15,37 @@ _KEEP_ALL_THINKING_EDIT = {}+def test_raw_signed_thinking_keeps_readable_context_outside_opaque_item():+ request = MessagesRequest.model_validate(+ {+ "model": "m",+ "messages": [+ {+ "role": "assistant",+ "content": [+ {+ "type": "thinking",+ "thinking": "Earlier summary",+ "signature": "old-cipher",+ },+ {"type": "text", "text": "Answer"},+ ],+ }+ ],+ }+ )+ original = request.model_dump()+ body = build_responses_provider_request(request, reasoning=ReasoningPolicy.on())+ opaque, context = body["input"][:2]+ assert opaque["encrypted_content"] == "old-cipher"+ assert opaque["summary"] == []+ assert "content" not in opaque+ assert context["role"] == "assistant"+ assert "Earlier summary" in json.dumps(context)+ assert json.dumps(body).count("Earlier summary") == 1+ assert request.model_dump() == original++def test_build_responses_provider_request_preserves_multiturn_protocol() -> None:request = MessagesRequest.model_validate({diff --git a/tests/core/openai_responses/test_provider_stream.py b/tests/core/openai_responses/test_provider_stream.pyindex 3817a2c4..c41f6862 100644--- a/tests/core/openai_responses/test_provider_stream.py+++ b/tests/core/openai_responses/test_provider_stream.py@@ -5,6 +5,7 @@ from free_claude_code.core.anthropic.stream_contracts import (parse_sse_text,thinking_content,)+from free_claude_code.core.history_replay import ReplayOrigin, decode_replayfrom free_claude_code.core.openai_responses.provider_stream import (ResponsesProviderStream,ResponsesStreamFailure,@@ -14,6 +15,7 @@ from free_claude_code.core.openai_tool_names import OpenAIToolNameCodecdef _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,@@ -34,6 +36,7 @@ def _terminal_usage(usage: dict[str, object]) -> dict[str, object]: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,@@ -134,7 +137,7 @@ def test_responses_provider_stream_preserves_reasoning_tools_usage_and_ids() ->if event.event == "content_block_start"]assert [- event.data["delta"]["signature"]+ decode_replay(event.data["delta"]["signature"]).native["encrypted_content"]for event in eventsif event.data.get("delta", {}).get("type") == "signature_delta"] == ["opaque"]@@ -264,6 +267,7 @@ def test_responses_provider_stream_ignores_invalid_cache_partitions(expected_input_tokens: int,) -> None:stream = ResponsesProviderStream(+ origin=ReplayOrigin("test", "responses", "", "", "m"),message_id="msg_test",model="openai/gpt-test",input_tokens=12,@@ -297,6 +301,7 @@ def test_responses_provider_stream_ignores_invalid_cache_partitions(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,@@ -325,6 +330,7 @@ def test_responses_provider_stream_restores_added_and_done_only_tool_names() ->)codec = OpenAIToolNameCodec.from_names(originals)stream = ResponsesProviderStream(+ origin=ReplayOrigin("test", "responses", "", "", "m"),message_id="msg_test",model="gpt-test",input_tokens=0,diff --git a/tests/providers/test_history_corrections.py b/tests/providers/test_history_corrections.pyindex f9e74243..9b866422 100644--- a/tests/providers/test_history_corrections.py+++ b/tests/providers/test_history_corrections.py@@ -99,6 +99,63 @@ def test_unidentified_cipher_failure_with_multiple_records_is_not_guessed():)[email protected]("quote", ["", "'", '"'])+def test_encrypted_rejection_matches_exact_named_item(quote):+ body = {+ "input": [+ {+ "type": "reasoning",+ "id": name,+ "encrypted_content": name,+ "summary": [{"type": "summary_text", "text": name}],+ }+ for name in ("rs_a", "rs_ab")+ ]+ }+ original = deepcopy(body)+ result = history_retry_body(+ _error(+ f"The encrypted content for item {quote}rs_ab{quote} could not be verified. Reason: Encrypted content item_id did not match the target item id.",+ code="invalid_encrypted_content",+ ),+ body,+ "responses",+ )+ assert result == {+ "input": [body["input"][0], {"role": "assistant", "content": "rs_ab"}]+ }+ assert body == original+++ "ids,message",+ [+ (["rs_a"], "The encrypted content for item rs_unknown could not be verified."),+ (+ ["rs_a", "rs_a"],+ "The encrypted content for item rs_a could not be verified.",+ ),+ (+ ["rs_a", "rs_b"],+ "The encrypted content for item rs_a and item rs_b could not be verified.",+ ),+ ],+)+def test_named_rejection_never_guesses(ids, message):+ body = {+ "input": [+ {"type": "reasoning", "id": id_, "encrypted_content": "opaque"}+ for id_ in ids+ ]+ }+ assert (+ history_retry_body(+ _error(message, code="invalid_encrypted_content"), body, "responses"+ )+ is None+ )++def test_missing_reference_targets_its_item_only():body = {"input": [@@ -115,6 +172,66 @@ def test_missing_reference_targets_its_item_only():assert result["input"] == [body["input"][0]][email protected]("quote", ["'", '"'])[email protected]("item_id", ["rs_a:rs_b", "rs_a.part", "rs_a/part"])+def test_quoted_legacy_id_recovers_without_matching_its_prefix(quote, item_id):+ body = {+ "input": [+ {"type": "reasoning", "id": "rs_a", "encrypted_content": "keep"},+ {+ "type": "reasoning",+ "id": item_id,+ "encrypted_content": "reject",+ "summary": [{"type": "summary_text", "text": "Keep context"}],+ },+ ]+ }+ original = deepcopy(body)+ result = history_retry_body(+ _error(+ f"Referenced reasoning item {quote}{item_id}{quote} was not found or has expired."+ ),+ body,+ "responses",+ )+ assert result == {+ "input": [body["input"][0], {"role": "assistant", "content": "Keep context"}]+ }+ assert body == original+++ "ids,message",+ [+ (+ ["rs_a"],+ "The encrypted content for item 'rs_a:unknown' could not be verified.",+ ),+ (+ ["rs_a:rs_b", "rs_a:rs_b"],+ 'The encrypted content for item "rs_a:rs_b" could not be verified.',+ ),+ (+ ["rs_a:rs_b", "rs_other"],+ "The encrypted content for item 'rs_a:rs_b' and item rs_other could not be verified.",+ ),+ ],+)+def test_quoted_legacy_id_recovery_remains_unambiguous(ids, message):+ body = {+ "input": [+ {"type": "reasoning", "id": item_id, "encrypted_content": "opaque"}+ for item_id in ids+ ]+ }+ assert (+ history_retry_body(+ _error(message, code="invalid_encrypted_content"), body, "responses"+ )+ is None+ )++def test_messages_signature_path_retains_readable_text_and_other_blocks():body = {"messages": [diff --git a/tests/providers/test_history_transports.py b/tests/providers/test_history_transports.pyindex 644dc6c7..9479080e 100644--- a/tests/providers/test_history_transports.py+++ b/tests/providers/test_history_transports.py@@ -237,6 +237,51 @@ async def _saved_reply(stream, wire):return events[-1].data["response"]["output"][email protected]("opaque_only", [False, True])+async def test_responses_messages_roundtrip_preserves_bound_reasoning(opaque_only):+ native = [+ {+ "type": "reasoning",+ "id": f"rs_original_{i}",+ "summary": []+ if opaque_only+ else [{"type": "summary_text", "text": f"Plan {i}."}],+ "content": [],+ "encrypted_content": f"cipher-bound-to-original-{i}",+ }+ for i in range(2)+ ]+ completed = _completed_response(model="requested")+ completed["output"] = native+ events = [+ {"type": "response.created", "response": {**completed, "output": []}},+ *[+ {"type": "response.output_item.done", "output_index": i, "item": item}+ for i, item in enumerate(native)+ ],+ {"type": "response.completed", "response": completed},+ ]++ def responder(bodies):+ if len(bodies) > 1:+ replayed = [x for x in bodies[-1]["input"] if x.get("type") == "reasoning"]+ assert replayed == native+ return 200, events++ async with _harness("responses", responder) as (send, bodies, _):+ saved = await _saved_reply(+ send("messages", [{"role": "user", "content": "hello"}]), "messages"+ )+ history = json.loads(+ json.dumps([*saved, {"role": "user", "content": "continue"}])+ )+ original = deepcopy(history)+ await _saved_reply(send("messages", history), "messages")+ assert history == original+ assert len(bodies) == 2++def _carrier(history, wire):if wire == "responses":return next(@@ -253,6 +298,64 @@ def _carrier(history, wire):)[email protected]("max_attempts", [2, 5])+async def test_old_raw_thinking_recovers_named_rejections_within_budget(max_attempts):+ history = [+ {+ "role": "assistant",+ "content": [+ {+ "type": "thinking",+ "thinking": "Keep first context",+ "signature": "old-first",+ },+ {+ "type": "thinking",+ "thinking": "Keep second context",+ "signature": "old-second",+ },+ {"type": "text", "text": "Keep answer"},+ ],+ },+ {"role": "user", "content": "continue"},+ ]+ original = deepcopy(history)++ def responder(bodies):+ body = bodies[-1]+ items = [x for x in body["input"] if x.get("type") == "reasoning"]+ for item in items:+ assert "content" not in item+ for text in ("Keep first context", "Keep second context", "Keep answer"):+ assert json.dumps(body).count(text) == 1+ if items:+ return 400, {+ "code": "invalid_encrypted_content",+ "param": None,+ "message": f"The encrypted content for item {items[0]['id']} could not be verified. Reason: Encrypted content item_id did not match the target item id.",+ }+ return 200, _events_for("responses")++ async with _harness("responses", responder, max_attempts=max_attempts) as (+ send,+ bodies,+ _,+ ):+ if max_attempts == 2:+ with pytest.raises(ExecutionFailure):+ await _saved_reply(send("messages", history), "messages")+ else:+ await _saved_reply(send("messages", history), "messages")+ assert len(bodies) == min(max_attempts, 3)+ assert [+ x["encrypted_content"]+ for x in bodies[1]["input"]+ if x.get("type") == "reasoning"+ ] == ["old-second"]+ assert history == original++@pytest.mark.asyncio@pytest.mark.parametrize("protocol", ["responses", "messages", "chat"])@pytest.mark.parametrize("wire", ["responses", "messages"])diff --git a/tests/providers/test_native_reasoning_completion.py b/tests/providers/test_native_reasoning_completion.pyindex 45362462..0a2cce0d 100644--- a/tests/providers/test_native_reasoning_completion.py+++ b/tests/providers/test_native_reasoning_completion.py@@ -11,6 +11,7 @@ from free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.history_replay import ReplayOrigin, decode_replayfrom free_claude_code.core.openai_responses.chat_request import (build_responses_chat_request,)@@ -377,7 +378,7 @@ async def test_responses_late_cipher_preserves_thinking_and_final_answer():event.data["index"] for event in events if event.event == "content_block_stop"][-1] == text_indexassert [- event.data["delta"]["signature"]+ decode_replay(event.data["delta"]["signature"]).native["encrypted_content"]for event in eventsif event.data.get("delta", {}).get("type") == "signature_delta"] == ["opaque-original"]@@ -503,7 +504,10 @@ def test_responses_summary_maps_to_structured_chat_summary():def test_existing_responses_tool_delta_does_not_close_final_text():stream = ResponsesProviderStream(- message_id="msg_test", model="native", input_tokens=1+ origin=ReplayOrigin("test", "responses", "", "", "m"),+ message_id="msg_test",+ model="native",+ input_tokens=1,)frames = stream.start()frames += stream.feed(@@ -713,7 +717,10 @@ async def test_completed_full_reasoning_survives_streamed_summary(answer_before_@pytest.mark.parametrize("summary", [False, True])def test_responses_seeded_reasoning_and_fragments_are_completed_once(summary):stream = ResponsesProviderStream(- message_id="msg_test", model="native", input_tokens=1+ 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"diff --git a/tests/providers/test_reasoning_representation_lifecycle.py b/tests/providers/test_reasoning_representation_lifecycle.pyindex f70e925c..f94efde2 100644--- a/tests/providers/test_reasoning_representation_lifecycle.py+++ b/tests/providers/test_reasoning_representation_lifecycle.py@@ -6,6 +6,7 @@ from copy import deepcopyimport pytestfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.core.history_replay import decode_replayfrom free_claude_code.core.json_types import JsonObjectfrom free_claude_code.providers.kilo import KiloProviderfrom free_claude_code.providers.openai_chat.reasoning_details import (@@ -217,7 +218,10 @@ async def test_independent_native_items_keep_their_own_text_and_signature():send("messages", [{"role": "user", "content": "hello"}]), "messages")thinking = [- (block["thinking"], block.get("signature"))+ (+ block["thinking"],+ decode_replay(block["signature"]).native["encrypted_content"],+ )for block in saved[0]["content"]if block["type"] == "thinking"]@@ -233,11 +237,13 @@ async def test_native_signed_empty_thinking_keeps_its_block_kind():saved = await _saved_reply(send("messages", [{"role": "user", "content": "hello"}]), "messages")- assert saved[0]["content"][0] == {- "type": "thinking",- "thinking": "",- "signature": "empty-signed",- }+ block = saved[0]["content"][0]+ assert block["type"] == "thinking"+ assert block["thinking"] == ""+ assert (+ decode_replay(block["signature"]).native+ == upstream[-1]["response"]["output"][0]+ )@pytest.mark.asyncio