Pin the output indices and sequence numbers of the Responses stream

Responses clients key the items of a stream by output_index (the OpenAI
SDK raises on a duplicate) and order the events by sequence_number, yet
no test read either field, none saw response.reasoning_text.done, and
failed() was tested only through the server and only by substring.

One test parses every data line of a stream with reasoning, text and a
tool call: exactly 15 events numbered 0..14, the reasoning, message and
function_call items at output_index 0, 1 and 2 in both their added and
done events, the reasoning_text.done event with its full field set, and
the item order of response.completed. A second one checks that
response.failed continues the numbering. Red under a mutation of each
property (e.g. "Expected: is <4> but: was <0>" with the counter reset in
failed()), green on the code.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VBFFnrhtvXiUeyxjmUc4R2

Author: claude

BUGHUNT-FOUND.md

@@ -757,6 +757,7 @@ Repos plus eins. Geprüfte Klassen ohne Fund stehen in [`BUGHUNT-CHECKED.md`](BU
 - **Rot-Grün-Nachweis:** ohne Fix rot („Expected: a string containing "event: response.output_item.added" but: was ""“), mit Fix grün (5/5 der Klasse, skipped 0); Gegenprobe per `git stash` rot, nach `pop` grün. `ResponsesApiSupportTest` 14/14, `OpenAiCompatServerHttpTest` 45/45, `LlamaArchitectureTest` 13/13, `spotbugs:check` grün (erst nach dem Helfer).
 - **Status:** gefixt
 - **Commit:** java-llama.cpp `f327156`
+- **Nachtrag (Branch-Review 2026-10-20, Fund J5-6):** `output_index`, die Fortlaufendheit der `sequence_number` und das Ereignis `response.reasoning_text.done` hatten keinen Test; die Clients ordnen die Items nach `output_index` (das OpenAI-SDK wirft bei einem doppelten). `ResponsesStreamTranslatorTest#reasoningTextAndToolCallGetConsecutiveOutputIndicesAndSequenceNumbers` (begin, Denken, Text, Werkzeugaufruf, end) zerlegt die `data:`-Zeilen und verlangt genau 15 Ereignisse mit `sequence_number` 0..14, `output_item.added`/`.done` für `reasoning`/`message`/`function_call` an den Indizes 0/1/2, `response.reasoning_text.done` mit `item_id` `rs_resp_1`, `content_index` 0, vollem Text und `sequence_number` 6 sowie die Reihenfolge der Items in `response.completed`. Gegenprobe rot: Nachricht ohne eigenen Index („no response.output_item.added at output_index 2“), `sequence = 0` am Anfang von `end()` („Expected: is <[0, 1, …, 14]> but: was <[0, 1, 2, 3, 4, 5, 0, 1, …, 8]>“), ohne `reasoning_text.done` („Expected: is <15> but: was <14>“); mit dem Code grün (9/9). upstream (b11639) gibt weder `output_index` noch `sequence_number` aus; der Maßstab ist die OpenAI-Form.
 
 <a id="f84"></a>
 ### F84 – java-llama.cpp: Anthropic-Verlauf verwirft `thinking`-Blöcke früherer Runden
@@ -1137,6 +1138,7 @@ Repos plus eins. Geprüfte Klassen ohne Fund stehen in [`BUGHUNT-CHECKED.md`](BU
 - **Rot-Grün-Nachweis:** ohne Fix beide rot („Expected: a string containing "event: response.failed" but: was "event: response.created …"“), mit Fix grün (51/51 der Klasse, skipped 0); Gegenprobe per `git stash` beider Produktionsdateien rot (2), nach `pop` grün. Breite Liste (Server-Tests inkl. `ResponsesStreamTranslatorTest`, `LlamaArchitectureTest`) grün, `spotless:apply` und `spotbugs:check` grün.
 - **Status:** gefixt
 - **Commit:** java-llama.cpp `bd3db6a`
+- **Nachtrag (Branch-Review 2026-10-20, Fund J5-6):** Die laufende `sequence_number` des `response.failed` war nur über den Server und nur per Teilstring geprüft. `ResponsesStreamTranslatorTest#failedContinuesTheSequenceNumber` (begin, ein Textchunk, `failed("boom", "server_error")`) verlangt fünf Ereignisse, das letzte `response.failed` mit `sequence_number` 4, `status` `failed` und `error.code`/`error.message`. Gegenprobe mit `sequence = 0` in `failed()` rot („Expected: is <4> but: was <0>“), mit dem Code grün (`ResponsesStreamTranslatorTest` 9/9).
 
 <a id="f118"></a>
 ### F118 – java-llama.cpp: Anthropic-Serverfehler heißen `invalid_request_error`

llama/src/test/java/net/ladenthin/llama/server/ResponsesStreamTranslatorTest.java

@@ -5,10 +5,16 @@
 package net.ladenthin.llama.server;
 
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.not;
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -18,6 +24,30 @@
  */
 public class ResponsesStreamTranslatorTest {
 
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    /** The {@code data:} payloads of the framed SSE events, in order. */
+    private static List<JsonNode> events(String sse) throws IOException {
+        List<JsonNode> events = new ArrayList<>();
+        for (String line : sse.split("\n")) {
+            if (line.startsWith("data: ")) {
+                events.add(MAPPER.readTree(line.substring("data: ".length())));
+            }
+        }
+        return events;
+    }
+
+    /** The first event of {@code type} whose {@code output_index} is {@code outputIndex}. */
+    private static JsonNode eventAt(List<JsonNode> events, String type, int outputIndex) {
+        for (JsonNode event : events) {
+            if (event.path("type").asText().equals(type)
+                    && event.path("output_index").asInt(-1) == outputIndex) {
+                return event;
+            }
+        }
+        throw new AssertionError("no " + type + " at output_index " + outputIndex);
+    }
+
     @Test
     public void beginEmitsResponseCreated() {
         ResponsesStreamTranslator translator = new ResponsesStreamTranslator("m", "resp_1");
@@ -77,6 +107,75 @@ public void reasoningDeltasStreamAsAReasoningItemLikeUpstream() {
         assertThat(completed, containsString("\"type\":\"reasoning_text\",\"text\":\"6 times 7\""));
     }
 
+    @Test
+    public void reasoningTextAndToolCallGetConsecutiveOutputIndicesAndSequenceNumbers() throws IOException {
+        // Responses clients key the items by output_index (the OpenAI SDK raises on a duplicate) and
+        // order the events by sequence_number; reasoning, message and function_call are items 0, 1, 2.
+        ResponsesStreamTranslator translator = new ResponsesStreamTranslator("m", "resp_1");
+        List<JsonNode> events = events(translator.begin()
+                + translator.onChunk("{\"choices\":[{\"delta\":{\"reasoning_content\":\"6 times 7\"}}]}")
+                + translator.onChunk("{\"choices\":[{\"delta\":{\"content\":\"42\"}}]}")
+                + translator.onChunk("{\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"c1\","
+                        + "\"function\":{\"name\":\"f\",\"arguments\":\"{}\"}}]},\"finish_reason\":\"tool_calls\"}]}")
+                + translator.end());
+
+        assertThat(events.size(), is(15));
+        List<Integer> sequence = new ArrayList<>();
+        List<Integer> expected = new ArrayList<>();
+        for (int i = 0; i < events.size(); i++) {
+            sequence.add(events.get(i).path("sequence_number").asInt(-1));
+            expected.add(i);
+        }
+        assertThat(sequence, is(expected));
+
+        String[] itemTypes = {"reasoning", "message", "function_call"};
+        for (int index = 0; index < itemTypes.length; index++) {
+            assertThat(
+                    eventAt(events, "response.output_item.added", index)
+                            .path("item")
+                            .path("type")
+                            .asText(),
+                    is(itemTypes[index]));
+            assertThat(
+                    eventAt(events, "response.output_item.done", index)
+                            .path("item")
+                            .path("type")
+                            .asText(),
+                    is(itemTypes[index]));
+        }
+
+        JsonNode reasoningDone = eventAt(events, "response.reasoning_text.done", 0);
+        assertThat(reasoningDone.path("item_id").asText(), is("rs_resp_1"));
+        assertThat(reasoningDone.path("content_index").asInt(-1), is(0));
+        assertThat(reasoningDone.path("text").asText(), is("6 times 7"));
+        assertThat(reasoningDone.path("sequence_number").asInt(-1), is(6));
+
+        JsonNode completed = events.get(events.size() - 1);
+        assertThat(completed.path("type").asText(), is("response.completed"));
+        List<String> outputTypes = new ArrayList<>();
+        for (JsonNode item : completed.path("response").path("output")) {
+            outputTypes.add(item.path("type").asText());
+        }
+        assertThat(outputTypes, contains("reasoning", "message", "function_call"));
+    }
+
+    @Test
+    public void failedContinuesTheSequenceNumber() throws IOException {
+        // response.failed ends a stream that already emitted events; its sequence_number follows them.
+        ResponsesStreamTranslator translator = new ResponsesStreamTranslator("m", "resp_1");
+        List<JsonNode> events = events(translator.begin()
+                + translator.onChunk("{\"choices\":[{\"delta\":{\"content\":\"he\"}}]}")
+                + translator.failed("boom", "server_error"));
+
+        assertThat(events.size(), is(5));
+        JsonNode failed = events.get(4);
+        assertThat(failed.path("type").asText(), is("response.failed"));
+        assertThat(failed.path("sequence_number").asInt(-1), is(4));
+        assertThat(failed.path("response").path("status").asText(), is("failed"));
+        assertThat(failed.path("response").path("error").path("code").asText(), is("server_error"));
+        assertThat(failed.path("response").path("error").path("message").asText(), is("boom"));
+    }
+
     @Test
     public void toolCallsBecomeFunctionCallItemsBeforeCompleted() {
         ResponsesStreamTranslator translator = new ResponsesStreamTranslator("m", "resp_1");