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

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.py
index 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}]
+ )
+ )
+ continue
if 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.py
index 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, cast
from free_claude_code.core.anthropic.streaming import AnthropicStreamLedger
from 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 JsonObject
from 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 = origin
self._pad_empty = pad_empty
self.generated_output = False
self._tool_names = tool_names or OpenAIToolNameCodec.from_names(())
@@ -257,6 +265,7 @@ class ResponsesProviderStream:
return events
if 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 = True
return 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.py
index 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 = [
entry
for 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 None
opaque = [
entry
for entry in candidates
diff --git a/src/free_claude_code/providers/openai_responses/presentation.py b/src/free_claude_code/providers/openai_responses/presentation.py
index 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 dataclass
from typing import Protocol
from free_claude_code.core.failures import ExecutionFailure
+from free_claude_code.core.history_replay import ReplayOrigin
from free_claude_code.core.json_types import JsonObject
from 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.py
index 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 = False
source = SourceRecoveryState(execution, previous=source)
- presenter = presenter_factory(
- operation_kind is ProviderOperationKind.GENERATION
- )
- start_events = tuple(presenter.start())
+ presenter: ResponsesStreamPresenter | None = None
presenter_started = False
adapt_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_error
for 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.py
index 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.py
index 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_replay
from free_claude_code.core.openai_responses.provider_stream import (
ResponsesProviderStream,
ResponsesStreamFailure,
@@ -14,6 +15,7 @@ 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,
@@ -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 events
if 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.py
index 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.py
index 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.py
index 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 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,
)
@@ -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_index
assert [
- event.data["delta"]["signature"]
+ decode_replay(event.data["delta"]["signature"]).native["encrypted_content"]
for event in events
if 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.py
index 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 deepcopy
import pytest
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
+from free_claude_code.core.history_replay import decode_replay
from free_claude_code.core.json_types import JsonObject
from free_claude_code.providers.kilo import KiloProvider
from 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