Spaces:
Running
Running
Download tests/api/test_continuation_overlap.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 16.3 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/api/test_continuation_overlap.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/tests/api/test_continuation_overlap.py
-
curl -L -o test_continuation_overlap.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/tests/api/test_continuation_overlap.py
16.3 kB
| """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.core.stream_output import completed_output | |
| 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.support import assistant_history_text | |
| from tests.providers.test_history_transports import _harness | |
| 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 | |
| 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) | |
| 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 " | |
| 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) | |
| 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 completed_output((frame,)) | |
| state.begin_continuation() | |
| state.begin_attempt() | |
| attempts.append(2) | |
| for event in responses_parts(["He"], representation="text_done")[:4]: | |
| yield completed_output( | |
| (_frames("responses", [(event["type"], event)])[0],) | |
| ) | |
| for _ in range(30): | |
| event = {"type": "ping", "padding": "x" * 60} | |
| yield completed_output( | |
| (_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) | |
| async def test_overlap_release_records_each_packet_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 completed_output((frame,)) | |
| state.begin_continuation() | |
| for event in responses_parts(["He", "llo world."], representation="text_done"): | |
| yield completed_output((_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)) | |
| events.extend(frames) | |
| if any( | |
| event.event == "response.output_text.done" | |
| and event.data["text"] == "world." | |
| for event in frames | |
| ): | |
| assert states[0].prefix.text == "Hello world." | |
| assert resumed == [] | |
| assert resumed == ["Hello world."] | |
| assert_completion_text_agrees(events) | |
| finally: | |
| await response.aclose() | |
| 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 completed_output((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 completed_output((_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 completed_output((_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) | |
| 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 completed_output((frame,)) | |
| state.begin_continuation() | |
| for event in responses_parts(["He"], representation="text_done")[:4]: | |
| yield completed_output( | |
| (_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" | |
| ) | |
| 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 assistant_history_text(bodies[2]["input"]) == "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) | |