@@ -6,6 +6,18 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+### Added
+
+- A recorded response can be replayed as a scenario, from a fixture in kartsan03/wiretruth's
+  `wiretruth.fixture/v1` format. The first is `openai/responses-stream-missing-finish-abort`, the
+  first OpenAI Responses API scenario: eight recorded events, then the connection drops.
+- The reference instrumentation covers the Responses API, so both controls grade it.
+
+### Fixed
+
+- The fake provider now drops the connection when `drop_after` equals the number of events, where
+  it used to end the stream cleanly.
+
 ## [0.2.0] - 2026-10-12
 
 ### Changed
 
@@ -127,17 +127,20 @@ endpoint per library, at `https://plexito-de.github.io/spantruth/badges/<subject
 
 ## Coverage
 
-- **Providers:** OpenAI Chat Completions and Anthropic Messages, sync and async.
-- **Scenarios (31):** plain call, stream, stream without usage, prompt-cache hit (plain, streamed,
+- **Providers:** OpenAI Chat Completions and Anthropic Messages, sync and async. The OpenAI
+  Responses API has its first scenario, a stream replayed from a recording.
+- **Scenarios (32):** plain call, stream, stream without usage, prompt-cache hit (plain, streamed,
   and with cumulative counts in `message_delta`), parallel tool calls, reasoning tokens, HTTP 429,
   a stream the app leaves early (by `close()` and by a `with` block), a dropped connection, and
-  Anthropic's mid-stream `error` event. Streams and failures run sync and async.
+  Anthropic's mid-stream `error` event. Streams and failures run sync and async. A Responses API
+  stream cut after eight recorded events replays kartsan03/wiretruth's
+  `stream.missing-finish-abort` fixture, vendored unchanged with its provenance.
 - **Subjects:** the [OpenTelemetry GenAI instrumentation](https://github.com/open-telemetry/opentelemetry-python-genai),
   [OpenLLMetry](https://github.com/traceloop/openllmetry) and
   [OpenInference](https://github.com/Arize-ai/openinference), plus the two controls.
 
-Next: Logfire, OpenLIT, the JavaScript libraries, AWS Bedrock, Gemini and the OpenAI Responses
-API. [Help is welcome](CONTRIBUTING.md#ways-to-help).
+Next: Logfire, OpenLIT, the JavaScript libraries, AWS Bedrock, Gemini and the rest of the OpenAI
+Responses API. [Help is welcome](CONTRIBUTING.md#ways-to-help).
 
 ## Related work
 
 
@@ -81,6 +81,24 @@ def _openai_chunk(c: Any, seen: Seen) -> None:
         seen.usage = c.usage.model_dump()
 
 
+def _responses_event(e: Any, seen: Seen) -> None:
+    seen.events += 1
+    if e.type == "response.created":
+        seen.response_id = e.response.id
+    elif e.type == "response.output_text.delta":
+        seen.text += e.delta
+    elif e.type == "response.completed" and e.response.usage:
+        seen.usage = e.response.usage.model_dump()
+
+
+def _openai_create(client: Any, sc: Scenario):
+    """The call for the scenario's API, and how the app reads a stream from it."""
+    if sc.api == "responses":
+        kw: dict = {"model": sc.request_model, "input": PROMPT, "stream": sc.stream}
+        return client.responses.create(**kw), None, _responses_event
+    return client.chat.completions.create(**_openai_kwargs(sc)), _openai_result, _openai_chunk
+
+
 def _anthropic_result(r: Any, seen: Seen) -> None:
     seen.text = "".join(b.text if b.type == "text" else b.name for b in r.content)
     seen.response_id, seen.usage = r.id, r.usage.model_dump()
@@ -103,8 +121,7 @@ def run(sc: Scenario, base_url: str, seen: Seen) -> None:
         import openai
 
         client = openai.OpenAI(base_url=base_url, api_key="wt-test", max_retries=0, timeout=10)
-        result = client.chat.completions.create(**_openai_kwargs(sc))
-        on_result, on_event = _openai_result, _openai_chunk
+        result, on_result, on_event = _openai_create(client, sc)
     else:
         import anthropic
 
@@ -136,8 +153,8 @@ async def _run_async(sc: Scenario, base_url: str, seen: Seen) -> None:
         import openai
 
         client = openai.AsyncOpenAI(base_url=base_url, api_key="wt-test", max_retries=0, timeout=10)
-        result = await client.chat.completions.create(**_openai_kwargs(sc))
-        on_result, on_event = _openai_result, _openai_chunk
+        pending, on_result, on_event = _openai_create(client, sc)
+        result = await pending
     else:
         import anthropic
 
 
@@ -0,0 +1,30 @@
+# Third-party fixtures
+
+`stream.missing-finish-abort.json` is copied unchanged from
+[kartsan03/wiretruth](https://github.com/kartsan03/wiretruth) at commit `4b2a835e76d77304ebb4450239acd609b850aebc`,
+`suite/fixtures/openai-responses/stream.missing-finish-abort.json`. Its `derived_from` block names
+the recording it comes from and the transform that cut it. It is used under the MIT License below.
+
+```text
+MIT License
+
+Copyright (c) 2026 kartsan03
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
@@ -0,0 +1,80 @@
+{
+  "format": "wiretruth.fixture/v1",
+  "id": "openai-responses/stream.missing-finish-abort",
+  "scenario": "stream.missing-finish-abort",
+  "provider": "openai-responses",
+  "tier": "derived",
+  "provenance": {
+    "requested_model": "gpt-6-luna",
+    "returned_model": "gpt-6-luna",
+    "request": {
+      "model": "gpt-6-luna",
+      "input": [
+        {
+          "role": "user",
+          "content": "Write a 200-word paragraph about how octopuses change colour to hide from predators."
+        }
+      ],
+      "stream": true,
+      "max_output_tokens": 16,
+      "reasoning": {
+        "effort": "none"
+      }
+    }
+  },
+  "derived_from": {
+    "fixture": "openai-responses/truncation.text-stream",
+    "transform": "cut_stream_after",
+    "args": {
+      "n": 8,
+      "end": "abort"
+    },
+    "rationale": "The connection closes before the stream has delivered every event.",
+    "evidence_url": "https://github.com/openai/openai-python/issues/2065"
+  },
+  "exchanges": [
+    {
+      "match": {
+        "method": "POST",
+        "path": "/v1/responses"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream; charset=utf-8"
+        },
+        "body": {
+          "sse": [
+            "event: response.created\ndata: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_025c23fff6653590006acbfc0086cc87d18124e70e8d3ff838\",\"object\":\"response\",\"created_at\":1791753216,\"status\":\"in_progress\",\"access_programs\":null,\"background\":false,\"completed_at\":null,\"error\":null,\"frequency_penalty\":0.0,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":16,\"max_tool_calls\":null,\"model\":\"gpt-6-luna\",\"moderation\":null,\"output\":[],\"parallel_tool_calls\":true,\"presence_penalty\":0.0,\"previous_response_id\":null,\"prompt_cache_key\":null,\"prompt_cache_retention\":\"24h\",\"reasoning\":{\"context\":\"all_turns\",\"effort\":\"none\",\"mode\":\"standard\",\"summary\":null},\"safety_identifier\":null,\"service_tier\":\"auto\",\"store\":true,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":\"auto\",\"tool_usage\":{\"image_gen\":{\"input_tokens\":0,\"input_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"output_tokens\":0,\"output_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"total_tokens\":0},\"web_search\":{\"num_requests\":0}},\"tools\":[],\"top_logprobs\":0,\"top_p\":0.98,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}},\"sequence_number\":0}\n\n",
+            "event: response.in_progress\ndata: {\"type\":\"response.in_progress\",\"response\":{\"id\":\"resp_025c23fff6653590006acbfc0086cc87d18124e70e8d3ff838\",\"object\":\"response\",\"created_at\":1791753216,\"status\":\"in_progress\",\"access_programs\":null,\"background\":false,\"completed_at\":null,\"error\":null,\"frequency_penalty\":0.0,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":16,\"max_tool_calls\":null,\"model\":\"gpt-6-luna\",\"moderation\":null,\"output\":[],\"parallel_tool_calls\":true,\"presence_penalty\":0.0,\"previous_response_id\":null,\"prompt_cache_key\":null,\"prompt_cache_retention\":\"24h\",\"reasoning\":{\"context\":\"all_turns\",\"effort\":\"none\",\"mode\":\"standard\",\"summary\":null},\"safety_identifier\":null,\"service_tier\":\"auto\",\"store\":true,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":\"auto\",\"tool_usage\":{\"image_gen\":{\"input_tokens\":0,\"input_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"output_tokens\":0,\"output_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"total_tokens\":0},\"web_search\":{\"num_requests\":0}},\"tools\":[],\"top_logprobs\":0,\"top_p\":0.98,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}},\"sequence_number\":1}\n\n",
+            "event: response.output_item.added\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"id\":\"msg_025c23fff6653590006acbfc016d8087d18e46405588162435\",\"type\":\"message\",\"status\":\"in_progress\",\"content\":[],\"phase\":\"final_answer\",\"role\":\"assistant\"},\"output_index\":0,\"sequence_number\":2}\n\n",
+            "event: response.content_part.added\ndata: {\"type\":\"response.content_part.added\",\"content_index\":0,\"item_id\":\"msg_025c23fff6653590006acbfc016d8087d18e46405588162435\",\"output_index\":0,\"part\":{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"\"},\"sequence_number\":3}\n\n",
+            "event: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"content_index\":0,\"delta\":\"Oct\",\"item_id\":\"msg_025c23fff6653590006acbfc016d8087d18e46405588162435\",\"logprobs\":[],\"obfuscation\":\"JJEbJBKhHOigL\",\"output_index\":0,\"sequence_number\":4}\n\n",
+            "event: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"content_index\":0,\"delta\":\"op\",\"item_id\":\"msg_025c23fff6653590006acbfc016d8087d18e46405588162435\",\"logprobs\":[],\"obfuscation\":\"rCPO5tGFW8ghsz\",\"output_index\":0,\"sequence_number\":5}\n\n",
+            "event: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"content_index\":0,\"delta\":\"uses\",\"item_id\":\"msg_025c23fff6653590006acbfc016d8087d18e46405588162435\",\"logprobs\":[],\"obfuscation\":\"byausMiYWM8M\",\"output_index\":0,\"sequence_number\":6}\n\n",
+            "event: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"content_index\":0,\"delta\":\" change\",\"item_id\":\"msg_025c23fff6653590006acbfc016d8087d18e46405588162435\",\"logprobs\":[],\"obfuscation\":\"lE22JEr0R\",\"output_index\":0,\"sequence_number\":7}\n\n"
+          ]
+        },
+        "end": "abort"
+      }
+    }
+  ],
+  "truth": {
+    "finish": "none",
+    "raw_finish": null,
+    "text": "Octopuses change",
+    "tool_calls": [],
+    "structured": null,
+    "error": null,
+    "stream_completed": false,
+    "usage": {
+      "input": null,
+      "cached_input": null,
+      "output": null,
+      "reasoning": null,
+      "total": null,
+      "alternatives": {},
+      "raw": null
+    }
+  }
+}
@@ -65,15 +65,15 @@ def _stream(self, sc: Scenario) -> None:
         self.end_headers()
         events = sc.response.events or ()
         drop = sc.response.drop_after
-        for index, event in enumerate(events):
-            if drop is not None and index == drop:
-                self.wfile.flush()
-                self.connection.shutdown(socket.SHUT_RDWR)
-                self.close_connection = True
-                return
+        for event in events[:drop]:
             chunk = _sse(event)
             self.wfile.write(f"{len(chunk):x}\r\n".encode() + chunk + b"\r\n")
             self.wfile.flush()
+        if drop is not None:
+            # A drop after the last event too: a recorded abort ends where the recording stops.
+            self.connection.shutdown(socket.SHUT_RDWR)
+            self.close_connection = True
+            return
         self.wfile.write(b"0\r\n\r\n")
         self.wfile.flush()
 
 
@@ -80,6 +80,7 @@ class Scenario:
     `with_block` makes the app read the stream inside a `with` block and leave it, instead of
     calling `close()`.
     `stream_usage` False leaves out OpenAI's `include_usage`, so the stream carries no usage.
+    `api` is the OpenAI API the app calls: `chat` (Chat Completions) or `responses`.
     """
 
     id: str
@@ -93,6 +94,7 @@ class Scenario:
     tools: bool = False
     stream_usage: bool = True
     asynchronous: bool = False
+    api: str = "chat"
     catches: str = ""
     tags: tuple[str, ...] = field(default_factory=tuple)
 
 
@@ -0,0 +1,51 @@
+"""Replay a recorded provider response, in kartsan03/wiretruth's fixture format.
+
+The scenarios in `scenarios.py` build their responses in code. A recorded fixture is the other
+source: a real provider stream, kept byte for byte, with the provenance of where it came from.
+Only what replay needs is read: one exchange, its status, its SSE frames, and how it ended.
+Format: https://github.com/kartsan03/wiretruth/blob/main/docs/formats.md
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .model import Event, Response
+
+FIXTURES = Path(__file__).resolve().parent / "fixtures"
+FORMAT = "wiretruth.fixture/v1"
+
+
+def frame(raw: str) -> Event:
+    """One recorded SSE frame, `event: <name>\\ndata: <json>`, as an Event."""
+    name, data = None, []
+    for line in raw.splitlines():
+        if line.startswith("event:"):
+            name = line[len("event:") :].strip()
+        elif line.startswith("data:"):
+            data.append(line[len("data:") :].lstrip())
+    return Event(data="\n".join(data), event=name)
+
+
+def load(path: Path) -> Response:
+    """The response of a recorded fixture. An `abort` end drops the connection after the end."""
+    doc = json.loads(Path(path).read_text())
+    if doc.get("format") != FORMAT:
+        raise ValueError(f"{path}: format {doc.get('format')!r}, expected {FORMAT!r}")
+    if len(doc["exchanges"]) != 1:
+        raise ValueError(f"{path}: replay needs exactly one exchange")
+    response = doc["exchanges"][0]["response"]
+    events = tuple(frame(raw) for raw in response["body"]["sse"])
+    end = response.get("end", "complete")
+    if end not in ("complete", "abort"):
+        raise ValueError(f"{path}: unknown end {end!r}")
+    return Response(
+        status=response["status"],
+        events=events,
+        drop_after=len(events) if end == "abort" else None,
+    )
+
+
+def requested_model(path: Path) -> str:
+    return json.loads(Path(path).read_text())["provenance"]["requested_model"]
@@ -96,6 +96,22 @@ def _openai_chunk(call: _Call, c: Any) -> None:
         _openai_usage(call, c.usage)
 
 
+def _responses_event(call: _Call, e: Any) -> None:
+    if e.type in ("response.created", "response.completed"):
+        call.set("gen_ai.response.model", e.response.model)
+        call.set("gen_ai.response.id", e.response.id)
+    if e.type == "response.completed" and e.response.usage:
+        u = e.response.usage
+        call.usage(
+            u.input_tokens,
+            u.output_tokens,
+            read=u.input_tokens_details.cached_tokens or 0,
+            reasoning=u.output_tokens_details.reasoning_tokens or 0,
+        )
+    elif e.type == "response.output_text.delta":
+        call.text += e.delta
+
+
 def _anthropic_response(call: _Call, r: Any) -> None:
     call.set("gen_ai.response.model", r.model)
     call.set("gen_ai.response.id", r.id)
@@ -231,11 +247,23 @@ def instrument(tracer_provider, faults: set[str] = frozenset()) -> None:
     tracer = tracer_provider.get_tracer("spantruth.reference")
     import anthropic.resources.messages as am
     import openai.resources.chat.completions as oc
+    import openai.resources.responses as orr
 
     for cls, is_async in ((oc.Completions, False), (oc.AsyncCompletions, True)):
         cls.create = _wrap(
             tracer, "openai", set(faults), _openai_response, _openai_chunk, cls.create, is_async
         )
+    for cls, is_async in ((orr.Responses, False), (orr.AsyncResponses, True)):
+        # Only streams are exercised so far, so a plain response is not read.
+        cls.create = _wrap(
+            tracer,
+            "openai",
+            set(faults),
+            lambda call, r: None,
+            _responses_event,
+            cls.create,
+            is_async,
+        )
     for cls, is_async in ((am.Messages, False), (am.AsyncMessages, True)):
         cls.create = _wrap(
             tracer,
 
@@ -8,6 +8,7 @@
 
 from dataclasses import replace
 
+from . import recorded
 from . import wire_anthropic as an
 from . import wire_openai as oa
 from .model import Scenario, Truth
@@ -135,6 +136,24 @@ def sc(name: str, title: str, catches: str, response, **kw) -> Scenario:
     ]
 
 
+def _recorded() -> list[Scenario]:
+    """Scenarios replayed from recorded provider streams, rather than built in code."""
+    abort = recorded.FIXTURES / "openai-responses" / "stream.missing-finish-abort.json"
+    return [
+        Scenario(
+            id="openai/responses-stream-missing-finish-abort",
+            provider="openai",
+            api="responses",
+            title="Responses API stream cut after eight recorded events",
+            catches="an aborted stream recorded as a success",
+            request_model=recorded.requested_model(abort),
+            response=recorded.load(abort),
+            stream=True,
+            tags=("recorded",),
+        )
+    ]
+
+
 def _anthropic() -> list[Scenario]:
     def sc(name: str, title: str, catches: str, response, **kw) -> Scenario:
         return Scenario(
@@ -290,7 +309,7 @@ def _with_async(scenarios: list[Scenario]) -> list[Scenario]:
 
 
 SCENARIOS: dict[str, Scenario] = {
-    s.id: s for s in _with_async(_with_block(_openai() + _anthropic()))
+    s.id: s for s in _with_async(_with_block(_openai() + _anthropic())) + _recorded()
 }
 
 
@@ -306,5 +325,8 @@ def by_key(key: str) -> Scenario:
 
 
 def truth(scenario: Scenario) -> Truth:
-    derive = oa.truth if scenario.provider == "openai" else an.truth
+    if scenario.api == "responses":
+        derive = oa.responses_truth
+    else:
+        derive = oa.truth if scenario.provider == "openai" else an.truth
     return derive(scenario.request_model, scenario.response, scenario.read_events)