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
15.8 KB
Raw Blame
"""Continuation replay is independent of how source text is represented."""

import asyncio
from copy import deepcopy
from itertools import pairwise

import pytest

from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.core.stream_delivery import current_stream_delivery
from free_claude_code.providers.stream_recovery import RecoveryHoldbackBuffer
from tests.api.test_delivered_stream_recovery import public_text, text_events
from tests.api.test_hidden_stream_retries import delivered
from tests.api.test_tool_call_buffer import _frames, _response
from tests.providers.test_history_transports import _harness


@pytest.fixture(autouse=True)
def immediate_events(monkeypatch):
    monkeypatch.setattr(
        "free_claude_code.providers.stream_recovery.RecoveryHoldbackBuffer",
        lambda: RecoveryHoldbackBuffer(max_bytes=1),
    )


def responses_parts(parts, *, separate_items=False, representation="deltas"):
    """Describe one answer with consistent source snapshots at every level."""
    template = text_events("responses", "")
    items = []
    events = [template[0]]
    groups = [[part] for part in parts] if separate_items else [parts]
    for index, group in enumerate(groups):
        item = {
            "id": f"msg_piece_{index}",
            "type": "message",
            "role": "assistant",
            "status": "completed",
            "content": [
                {"type": "output_text", "text": text, "annotations": []}
                for text in group
            ],
        }
        items.append(item)
        events.append(
            {
                "type": "response.output_item.added",
                "output_index": index,
                "item": {
                    **item,
                    "content": item["content"]
                    if representation == "item_added"
                    else [],
                    "status": "in_progress",
                },
            }
        )
        for position, part in enumerate(item["content"]):
            identity = {
                "output_index": index,
                "item_id": item["id"],
                "content_index": position,
            }
            events.append(
                {
                    "type": "response.content_part.added",
                    **identity,
                    "part": {
                        **part,
                        "text": part["text"]
                        if representation in {"part_added", "item_added"}
                        else part["text"][:1]
                        if representation == "mixed"
                        else "",
                    },
                }
            )
            if representation in {"deltas", "mixed"}:
                events.extend(
                    {
                        "type": "response.output_text.delta",
                        **identity,
                        "delta": character,
                    }
                    for character in (
                        part["text"][1:] if representation == "mixed" else part["text"]
                    )
                )
            if representation not in {"item_done", "part_done", "terminal"}:
                events.append(
                    {
                        "type": "response.output_text.done",
                        **identity,
                        "text": part["text"],
                    }
                )
            if representation not in {"item_done", "terminal"}:
                events.append(
                    {"type": "response.content_part.done", **identity, "part": part}
                )
        events.append(
            {"type": "response.output_item.done", "output_index": index, "item": item}
        )
    terminal = deepcopy(template[-1])
    terminal["response"]["output"] = items
    events.append(terminal)
    if representation == "terminal":
        events = [events[0], terminal]
    return [
        {**deepcopy(event), "sequence_number": number}
        for number, event in enumerate(events)
    ]


def response_text(event):
    return "".join(
        part.get("text", "")
        for item in event.data["response"]["output"]
        for part in item.get("content", [])
    )


def assert_completion_text_agrees(events):
    final = {
        item["id"]: item
        for item in events[-1].data["response"]["output"]
        if item["type"] == "message"
    }
    for event in events:
        data = event.data
        if event.event == "response.output_text.done":
            part = final[data["item_id"]]["content"][data["content_index"]]
            assert data["text"] == part["text"]
        elif event.event == "response.content_part.done":
            part = final[data["item_id"]]["content"][data["content_index"]]
            assert data["part"] == part
        elif event.event == "response.output_item.done":
            assert data["item"]["content"] == final[data["item"]["id"]]["content"]
    numbers = [event.data["sequence_number"] for event in events]
    assert all(before < after for before, after in pairwise(numbers)), numbers


@pytest.mark.asyncio
@pytest.mark.parametrize("separate_items", [False, True])
@pytest.mark.parametrize(
    "representation",
    [
        "terminal",
        "item_done",
        "part_done",
        "text_done",
        "deltas",
        "part_added",
        "item_added",
        "mixed",
    ],
)
async def test_split_replay_has_one_answer_across_representations(
    separate_items, representation
):
    def reply(bodies):
        if len(bodies) == 1:
            return 200, text_events("responses", "Hello ", complete=False)
        return 200, responses_parts(
            ["He", "llo world."],
            separate_items=separate_items,
            representation=representation,
        )

    async with _harness("responses", reply, max_attempts=2) as (send, bodies, _):
        raw = await delivered(
            send("responses", [{"role": "user", "content": "greet"}]), "responses"
        )
    events = parse_sse_text(raw)
    assert len(bodies) == 2
    assert events[-1].event == "response.completed"
    assert response_text(events[-1]) == "Hello world."
    retained = [
        part["text"]
        for item in events[-1].data["response"]["output"][1:]
        for part in item["content"]
    ]
    assert retained == ["", "world."]
    assert_completion_text_agrees(events)


@pytest.mark.asyncio
@pytest.mark.parametrize("representation", ["terminal", "text_done", "mixed"])
async def test_split_pure_replay_is_not_public_progress(representation):
    def reply(bodies):
        if len(bodies) == 1:
            return 200, text_events("responses", "Hello ", complete=False)
        return 200, responses_parts(["He", "llo "], representation=representation)

    async with _harness("responses", reply, max_attempts=3) as (send, bodies, _):
        raw = await delivered(
            send("responses", [{"role": "user", "content": "greet"}]), "responses"
        )
    events = parse_sse_text(raw)
    assert len(bodies) == 2
    assert events[-1].event == "response.failed"
    assert response_text(events[-1]) == "Hello "


@pytest.mark.asyncio
@pytest.mark.parametrize("wire", ["messages", "responses"])
@pytest.mark.parametrize("seeded", [False, True])
async def test_messages_replay_across_blocks_uses_the_same_rule(wire, seeded):
    def reply(bodies):
        if len(bodies) == 1:
            return 200, text_events("messages", "abcabc", complete=False)
        template = text_events("messages", "")
        events = [template[0]]
        for index, text in enumerate(["abc", "abcX"]):
            part = text_events("messages", text)[1:-2]
            for event in part:
                event["index"] = index
            if seeded:
                part[0]["content_block"]["text"] = text
                part.pop(1)
            events.extend(part)
        return 200, [*events, *template[-2:]]

    async with _harness("messages", reply, max_attempts=2) as (send, bodies, _):
        raw = await delivered(
            send(wire, [{"role": "user", "content": "continue"}]), wire
        )
    events = parse_sse_text(raw)
    assert len(bodies) == 2
    assert events[-1].event == (
        "message_stop" if wire == "messages" else "response.completed"
    )
    assert public_text(events, wire) == "abcabcX"
    if wire == "responses":
        assert response_text(events[-1]) == "abcabcX"
        assert_completion_text_agrees(events)


@pytest.mark.asyncio
async def test_overflow_preserves_public_prefix_and_closes_the_source(monkeypatch):
    monkeypatch.setattr(
        "free_claude_code.core.continuation_overlap.RECOVERY_RETENTION_BYTES", 1000
    )
    closed = []
    attempts = []

    async def source():
        state = current_stream_delivery()
        assert state is not None
        try:
            state.begin_attempt()
            attempts.append(1)
            for frame in _frames(
                "responses",
                [
                    (event["type"], event)
                    for event in text_events("responses", "Hello ", complete=False)
                ],
            ):
                yield frame
            state.begin_continuation()
            state.begin_attempt()
            attempts.append(2)
            for event in responses_parts(["He"], representation="text_done")[:4]:
                yield _frames("responses", [(event["type"], event)])[0]
            for _ in range(30):
                event = {"type": "ping", "padding": "x" * 60}
                yield _frames("responses", [(event["type"], event)])[0]
            pytest.fail("the owner must stop reading after its overlap limit")
        finally:
            closed.append(True)

    raw = await delivered(source(), "responses")
    events = parse_sse_text(raw)
    assert attempts == [1, 2]
    assert closed == [True]
    assert events[-1].event == "response.failed"
    assert response_text(events[-1]) == "Hello "
    assert sum(event.event == "response.failed" for event in events) == 1
    assert not any(event.event == "response.completed" for event in events)


@pytest.mark.asyncio
async def test_overlap_release_records_each_frame_only_when_returned():
    states = []
    resumed = []

    async def source():
        state = current_stream_delivery()
        assert state is not None
        states.append(state)
        for frame in _frames(
            "responses",
            [
                (event["type"], event)
                for event in text_events("responses", "Hello ", complete=False)
            ],
        ):
            yield frame
        state.begin_continuation()
        for event in responses_parts(["He", "llo world."], representation="text_done"):
            yield _frames("responses", [(event["type"], event)])[0]
            prefix = state.prefix
            assert prefix is not None
            if (
                event["type"] == "response.output_text.done"
                and event["content_index"] == 0
            ):
                assert prefix.text == "Hello "
            if (
                event["type"] == "response.output_text.done"
                and event["content_index"] == 1
            ):
                resumed.append(prefix.text)

    response = await _response("responses", source())
    events = []
    try:
        async for chunk in response.body_iterator:
            frames = parse_sse_text(str(chunk))
            assert len(frames) == 1
            event = frames[0]
            events.append(event)
            if (
                event.event == "response.output_text.done"
                and event.data["text"] == "world."
            ):
                assert states[0].prefix.text == "Hello world."
                assert resumed == []
        assert resumed == ["Hello world."]
        assert_completion_text_agrees(events)
    finally:
        await response.aclose()


@pytest.mark.asyncio
async def test_hidden_attempt_replacement_discards_queued_replay():
    unpublished = []

    async def source():
        state = current_stream_delivery()
        assert state is not None
        state.begin_attempt()
        prefix = text_events("responses", "Hello ", complete=False)
        for frame in _frames("responses", [(event["type"], event) for event in prefix]):
            yield frame
        state.begin_continuation()
        for _ in range(2):
            state.begin_attempt()
            event = {
                "type": "response.output_text.delta",
                "output_index": 0,
                "content_index": 0,
                "item_id": "msg_abandoned",
                "delta": "He",
            }
            yield _frames("responses", [(event["type"], event)])[0]
            prefix = state.prefix
            assert prefix is not None
            unpublished.append((state.attempt_content_released, prefix.text))
        state.begin_attempt()
        for event in responses_parts(["world."], representation="text_done"):
            yield _frames("responses", [(event["type"], event)])[0]

    raw = await delivered(source(), "responses")
    assert unpublished == [(False, "Hello "), (False, "Hello ")]
    events = parse_sse_text(raw)
    assert events[-1].event == "response.completed"
    assert response_text(events[-1]) == "Hello world."
    assert "msg_abandoned" not in raw
    assert_completion_text_agrees(events)


@pytest.mark.asyncio
async def test_cancellation_drops_ambiguous_replay_and_closes_the_source():
    waiting = asyncio.Event()
    closed = []
    states = []

    async def source():
        state = current_stream_delivery()
        assert state is not None
        states.append(state)
        try:
            prefix = text_events("responses", "Hello ", complete=False)
            for frame in _frames(
                "responses", [(event["type"], event) for event in prefix]
            ):
                yield frame
            state.begin_continuation()
            for event in responses_parts(["He"], representation="text_done")[:4]:
                yield _frames("responses", [(event["type"], event)])[0]
            waiting.set()
            await asyncio.Event().wait()
        finally:
            closed.append(True)

    response = await _response("responses", source())
    returned = []

    async def consume():
        async for chunk in response.body_iterator:
            returned.extend(parse_sse_text(str(chunk)))

    reader = asyncio.create_task(consume())
    try:
        await asyncio.wait_for(waiting.wait(), 1)
        assert states[0].prefix.text == "Hello "
        reader.cancel()
        with pytest.raises(asyncio.CancelledError):
            await reader
    finally:
        reader.cancel()
        await asyncio.gather(reader, return_exceptions=True)
        await response.aclose()
    assert closed == [True]
    assert not any(
        event.event in {"response.failed", "response.completed"} for event in returned
    )
    assert all(
        event.data["text"] == "Hello "
        for event in returned
        if event.event == "response.output_text.done"
    )


@pytest.mark.asyncio
@pytest.mark.parametrize("representation", ["text_done", "part_done", "item_done"])
async def test_snapshot_text_is_published_once_before_another_interruption(
    representation,
):
    def reply(bodies):
        if len(bodies) == 1:
            return 200, text_events("responses", "Hello ", complete=False)
        if len(bodies) == 2:
            return 200, responses_parts(
                ["Hello world."], representation=representation
            )[:-1]
        return 200, text_events("responses", " Finished.")

    async with _harness("responses", reply, max_attempts=3) as (send, bodies, _):
        raw = await delivered(
            send("responses", [{"role": "user", "content": "greet"}]), "responses"
        )
    assert len(bodies) == 3
    assert bodies[2]["input"][-2]["content"] == [
        {"type": "output_text", "text": "Hello world."}
    ]
    events = parse_sse_text(raw)
    assert events[-1].event == "response.completed"
    assert response_text(events[-1]) == "Hello world. Finished."
    assert_completion_text_agrees(events)