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
18.4 KB
Raw Blame
"""Native reasoning item and part ownership survives completion and replay."""

import json
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 (
    StructuredReasoningStream,
)
from free_claude_code.providers.openai_chat.stream_output import (
    AnthropicChatStreamOutput,
    ChatStreamUsage,
)
from tests.providers.support import immediate_admission, make_provider_config
from tests.providers.test_history_transports import _events_for, _harness, _saved_reply
from tests.providers.test_native_reasoning_completion import _chunks


def _responses_events(
    texts, *, field="summary", streamed=True, late=False, signature=None
):
    source = deepcopy(_events_for("responses"))
    reasoning = {**source[3]["item"], "summary": [], "content": []}
    reasoning.pop("encrypted_content", None)
    part_type = "summary_text" if field == "summary" else "reasoning_text"
    reasoning[field] = [{"type": part_type, "text": text} for text in texts]
    if signature is not None:
        reasoning["encrypted_content"] = signature
    message = {
        "id": "msg_answer",
        "type": "message",
        "role": "assistant",
        "status": "completed",
        "content": [{"type": "output_text", "text": "Answer.", "annotations": []}],
    }
    events = [
        source[0],
        {
            "type": "response.output_item.added",
            "output_index": 0,
            "item": {
                **reasoning,
                "status": "in_progress",
                "summary": [],
                "content": [],
                "encrypted_content": None,
            },
        },
    ]
    if streamed:
        for index, text in enumerate(texts):
            events.append(
                {
                    "type": "response.reasoning_summary_text.delta"
                    if field == "summary"
                    else "response.reasoning_text.delta",
                    "item_id": reasoning["id"],
                    "output_index": 0,
                    "summary_index" if field == "summary" else "content_index": index,
                    "delta": text,
                }
            )
    done = {"type": "response.output_item.done", "output_index": 0, "item": reasoning}
    if not late:
        events.append(done)
    events += [
        {
            "type": "response.output_item.added",
            "output_index": 1,
            "item": {**message, "status": "in_progress", "content": []},
        },
        {
            "type": "response.output_text.delta",
            "item_id": message["id"],
            "output_index": 1,
            "content_index": 0,
            "delta": "Answer.",
        },
        {"type": "response.output_item.done", "output_index": 1, "item": message},
    ]
    if late:
        events.append(done)
    events.append(
        {
            "type": "response.completed",
            "response": {**source[-1]["response"], "output": [reasoning, message]},
        }
    )
    for sequence, event in enumerate(events):
        event["sequence_number"] = sequence
    return events


@pytest.mark.asyncio
@pytest.mark.parametrize("field", ["summary", "content"])
async def test_native_reasoning_parts_are_saved_and_replayed_once(field):
    upstream = _responses_events(["First part.", "Second part."], field=field)
    async with _harness("responses", lambda _: (200, upstream)) as (send, bodies, _):
        saved = await _saved_reply(
            send("messages", [{"role": "user", "content": "hello"}]), "messages"
        )
        await _saved_reply(
            send("messages", [*saved, {"role": "user", "content": "next"}]), "messages"
        )
    for text in ("First part.", "Second part."):
        assert json.dumps(saved).count(text) == 1
        assert json.dumps(bodies[-1]).count(text) == 1


@pytest.mark.asyncio
@pytest.mark.parametrize("field", ["summary", "content"])
async def test_completed_only_reasoning_keeps_final_answer_open(field):
    upstream = _responses_events(
        ["Completed thought."],
        field=field,
        streamed=False,
        late=True,
        signature="cipher",
    )
    async with _harness("responses", lambda _: (200, upstream)) as (send, _, _):
        frames = [
            frame
            async for frame in send("messages", [{"role": "user", "content": "hello"}])
        ]
    events = parse_sse_text("".join(frames))
    starts = {
        event.data["index"]: event.data["content_block"]["type"]
        for event in events
        if event.event == "content_block_start"
    }
    stops = [
        event.data["index"] for event in events if event.event == "content_block_stop"
    ]
    assert starts[stops[-1]] == "text"
    assert "Answer." in "".join(frames)
    assert "Completed thought." in "".join(frames)


@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
async def test_chat_secondary_reasoning_prefix_is_not_repeated(wire):
    upstream = _chunks(
        [
            (
                {
                    "reasoning_details": [
                        {
                            "type": "reasoning.summary",
                            "summary": "Short summary.",
                            "index": 0,
                        }
                    ]
                },
                None,
            ),
            ({"reasoning_content": "Full "}, None),
            ({"content": "Answer."}, None),
            ({"reasoning_content": "thought."}, "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("Full ") == 1
    assert "Full thought." in json.dumps(saved)
    assert json.dumps(bodies[-1]).count("Full ") == 1


@pytest.mark.asyncio
async def test_independent_native_items_keep_their_own_text_and_signature():
    upstream = _responses_events(
        ["Alpha."], field="content", signature="cipher-a", late=True
    )
    second = {
        "type": "reasoning",
        "id": "rs_second",
        "status": "completed",
        "summary": [],
        "content": [{"type": "reasoning_text", "text": "Beta."}],
        "encrypted_content": "cipher-b",
    }
    upstream[3:3] = [
        {
            "type": "response.output_item.added",
            "output_index": 2,
            "item": {
                **second,
                "status": "in_progress",
                "content": [],
                "encrypted_content": None,
            },
        },
        {
            "type": "response.reasoning_text.delta",
            "item_id": second["id"],
            "output_index": 2,
            "content_index": 0,
            "delta": "Beta.",
        },
    ]
    upstream.insert(
        -1, {"type": "response.output_item.done", "output_index": 2, "item": second}
    )
    upstream[-1]["response"]["output"].append(second)
    for sequence, event in enumerate(upstream):
        event["sequence_number"] = sequence
    async with _harness("responses", lambda _: (200, upstream)) as (send, _, _):
        saved = await _saved_reply(
            send("messages", [{"role": "user", "content": "hello"}]), "messages"
        )
    thinking = [
        (
            block["thinking"],
            decode_replay(block["signature"]).native["encrypted_content"],
        )
        for block in saved[0]["content"]
        if block["type"] == "thinking"
    ]
    assert thinking == [("Alpha.", "cipher-a"), ("Beta.", "cipher-b")]


@pytest.mark.asyncio
async def test_native_signed_empty_thinking_keeps_its_block_kind():
    upstream = _responses_events(
        [""], field="content", streamed=False, signature="empty-signed"
    )
    async with _harness("responses", lambda _: (200, upstream)) as (send, _, _):
        saved = await _saved_reply(
            send("messages", [{"role": "user", "content": "hello"}]), "messages"
        )
    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
@pytest.mark.parametrize("wire", ["messages", "responses"])
@pytest.mark.parametrize("fragmented", [False, True])
@pytest.mark.parametrize("native_alias", [False, True])
async def test_chat_signed_details_keep_their_own_text_on_replay(
    wire, fragmented, native_alias
):
    deltas: list[tuple[JsonObject, str | None]]
    if fragmented:
        deltas = [
            (
                {
                    "reasoning_details": [
                        {"type": "reasoning.text", "text": "Al", "index": 0}
                    ]
                },
                None,
            ),
            (
                {
                    "reasoning_details": [
                        {"type": "reasoning.text", "text": "pha.", "index": 0},
                        {"type": "reasoning.text", "text": "Beta.", "index": 1},
                    ]
                },
                None,
            ),
            ({"content": "Answer."}, None),
            (
                {
                    "reasoning_details": [
                        {"type": "reasoning.text", "signature": "sig-", "index": 0}
                    ]
                },
                None,
            ),
            (
                {
                    "reasoning_details": [
                        {"type": "reasoning.text", "signature": "alpha", "index": 0},
                        {"type": "reasoning.text", "signature": "sig-beta", "index": 1},
                    ]
                },
                "stop",
            ),
        ]
        aliases = ["Al", "pha.Beta."]
    else:
        deltas = [
            (
                {
                    "reasoning_details": [
                        {
                            "type": "reasoning.text",
                            "text": "Alpha.",
                            "signature": "sig-alpha",
                            "index": 0,
                        },
                        {
                            "type": "reasoning.text",
                            "text": "Beta.",
                            "signature": "sig-beta",
                            "index": 1,
                        },
                    ]
                },
                None,
            ),
            ({"content": "Answer."}, "stop"),
        ]
        aliases = ["Alpha.Beta."]
    if native_alias:
        for (delta, _), text in zip(deltas, aliases, strict=False):
            delta["reasoning_content"] = text
    async with _harness("chat", lambda _: (200, _chunks(deltas))) 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
        )
    if wire == "messages":
        pairs = [
            (block["thinking"], block.get("signature"))
            for block in saved[0]["content"]
            if block["type"] == "thinking"
        ]
    else:
        pairs = [
            (
                "".join(part["text"] for part in item.get("content", [])),
                item.get("encrypted_content"),
            )
            for item in saved
            if item["type"] == "reasoning"
        ]
    assert pairs == [("Alpha.", "sig-alpha"), ("Beta.", "sig-beta")]
    details = bodies[-1]["messages"][0]["reasoning_details"]
    assert [(detail["text"], detail.get("signature")) for detail in details] == pairs
    assert json.dumps(bodies[-1]).count("Alpha.") == 1
    assert json.dumps(bodies[-1]).count("Beta.") == 1


@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
async def test_chat_explicit_signed_empty_text_retains_its_kind(wire):
    upstream = _chunks(
        [
            (
                {
                    "reasoning_details": [
                        {
                            "type": "reasoning.text",
                            "text": "",
                            "signature": "empty-signature",
                            "index": 0,
                        }
                    ]
                },
                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
        )
    if wire == "messages":
        assert {
            "type": "thinking",
            "thinking": "",
            "signature": "empty-signature",
        } in saved[0]["content"]
    else:
        reasoning = next(item for item in saved if item["type"] == "reasoning")
        assert reasoning["content"] == [{"type": "reasoning_text", "text": ""}]
        assert reasoning["encrypted_content"] == "empty-signature"
    assert bodies[-1]["messages"][0]["reasoning_details"] == [
        {"type": "reasoning.text", "text": "", "signature": "empty-signature"}
    ]


@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
@pytest.mark.parametrize("after_answer", [False, True])
@pytest.mark.parametrize("fragmented", [False, True])
async def test_native_first_alias_preserves_later_signed_details(
    wire, after_answer, fragmented
):
    details = [
        {
            "type": "reasoning.text",
            "text": "Alpha.",
            "signature": "sig-alpha",
            "index": 0,
        },
        {
            "type": "reasoning.text",
            "text": "Beta.",
            "signature": "sig-beta",
            "index": 1,
        },
    ]
    typed = (
        [
            ([{"type": "reasoning.text", "text": "Al", "index": 0}], None),
            (
                [{**details[0], "text": "pha."}, details[1]],
                "stop" if after_answer else None,
            ),
        ]
        if fragmented
        else [(details, "stop" if after_answer else None)]
    )
    deltas = [({"reasoning": "Alpha.Beta."}, None)]
    if after_answer:
        deltas.append(({"content": "Answer."}, None))
    deltas.extend(({"reasoning_details": parts}, finish) for parts, finish in typed)
    if not after_answer:
        deltas.append(({"content": "Answer."}, "stop"))
    async with _harness(
        "chat",
        lambda _: (200, _chunks(deltas)),
        chat_provider_factory=lambda: KiloProvider(
            make_provider_config(api_key="a", base_url="https://provider.invalid/v1"),
            admission=immediate_admission(),
        ),
    ) 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
        )
    replayed = bodies[-1]["messages"][0]["reasoning_details"]
    assert [(part.get("text"), part.get("signature")) for part in replayed] == [
        ("Alpha.", "sig-alpha"),
        ("Beta.", "sig-beta"),
    ]
    assert json.dumps(saved).count("Alpha.") == 1
    assert json.dumps(saved).count("Beta.") == 1
    assert "Alpha.Beta." not in json.dumps(saved)
    assert json.dumps(bodies[-1]).count("Alpha.") == 1
    assert json.dumps(bodies[-1]).count("Beta.") == 1


@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
async def test_identical_signed_details_keep_independent_ownership(wire):
    upstream = _chunks(
        [
            ({"reasoning_content": "Same.Same."}, None),
            ({"content": "Answer."}, None),
            (
                {
                    "reasoning_details": [
                        {
                            "type": "reasoning.text",
                            "text": "Same.",
                            "signature": "a",
                            "index": 0,
                        },
                        {
                            "type": "reasoning.text",
                            "text": "Same.",
                            "signature": "b",
                            "index": 1,
                        },
                    ]
                },
                "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 bodies[-1]["messages"][0]["reasoning_details"] == [
        {"type": "reasoning.text", "text": "Same.", "signature": "a"},
        {"type": "reasoning.text", "text": "Same.", "signature": "b"},
    ]


@pytest.mark.parametrize("typed", [False, True])
def test_typed_reasoning_streams_while_native_fallback_waits(typed):
    output = AnthropicChatStreamOutput(
        message_id="msg_test", model="test", input_tokens=1
    )
    reasoning = StructuredReasoningStream()
    output.reasoning_replay = reasoning
    early = list(
        reasoning.events(
            {
                "reasoning_details": [
                    {"type": "reasoning.text", "text": "Plan.", "index": 0}
                ]
            }
            if typed
            else {},
            output,
            native_reasoning="Plan.",
        )
    )
    assert ("Plan." in "".join(early)) == typed
    answer = [*output.ensure_text_block(), output.emit_text_delta("Answer.")]
    assert "Answer." in "".join(answer)
    complete = output.finish_success(
        stop_reason="end_turn", usage=ChatStreamUsage(input_tokens=1, output_tokens=3)
    )
    events = parse_sse_text("".join(early + answer + complete))
    assert (
        sum(event.data.get("delta", {}).get("thinking") == "Plan." for event in events)
        == 1
    )
    starts = {
        event.data["index"]: event.data["content_block"]["type"]
        for event in events
        if event.event == "content_block_start"
    }
    stops = [
        event.data["index"] for event in events if event.event == "content_block_stop"
    ]
    assert starts[stops[-1]] == "text"