Drive ChatResponseParser and CompletionResponseParser to 100% PIT coverage

Closes the two remaining near-100% json parsers flagged in the cross-repo
mutation-coverage expansion and adds both to the gated targetClasses list.

Production (behaviour-preserving refactors that remove equivalent mutants):
- parseChoices / parseToolCalls: collapse the "guard returns empty list /
  body builds a list" two-branch shape into a single mutable-ArrayList
  return. An empty or non-array input now falls through the loop and returns
  the same empty ArrayList, so the immutable-emptyList() empty-branch mutant
  and the redundant arr.size()==0 conditional mutants disappear, while the
  Error Prone MixedMutabilityReturnType contract is still satisfied.
- parseLogprobs: same single-return collapse.
- parseLogprobEntry: drop the emptyList()/ArrayList ternary for nested
  alternatives in favour of a single mutable list filled only when the
  nested array is present, removing the size()>0 boundary mutant.

Tests (no behaviour change; cover the previously untested typed-parse paths):
- ChatResponseParserTest: parseResponse full/multi-choice/tool-calls
  (string + object arguments)/plain/empty-choices(mutable contract)/absent/
  malformed, plus a LogCaptor test pinning the TimingsLogger.log side-effect.
- CompletionResponseParserTest: parseLogprobs post- and pre-sampling
  (top_probs vs top_logprobs), nested recursion, missing id, empty/absent
  array (mutable contract); parseCompletionResult full/limit/malformed and a
  LogCaptor timing-line test.

Verified: ChatResponseParser + CompletionResponseParser 39/39 mutations
killed; full jllama PIT gate 207/207 (100%); spotless:check clean; the two
test classes 65/65 green.

Author: claude

pom.xml

@@ -662,6 +662,8 @@ SPDX-License-Identifier: MIT
 						<param>net.ladenthin.llama.args.*</param>
 						<param>net.ladenthin.llama.json.TimingsLogger</param>
 						<param>net.ladenthin.llama.json.RerankResponseParser</param>
+						<param>net.ladenthin.llama.json.ChatResponseParser</param>
+						<param>net.ladenthin.llama.json.CompletionResponseParser</param>
 					</targetClasses>
 					<targetTests>
 						<param>net.ladenthin.llama.value.*</param>

src/main/java/net/ladenthin/llama/json/ChatResponseParser.java

@@ -163,36 +163,40 @@ public ChatResponse parseResponse(String json) {
     }
 
     private List<ChatChoice> parseChoices(JsonNode arr) {
-        // Mutable ArrayList on both branches keeps the return-type contract consistent
-        // (Error Prone MixedMutabilityReturnType).
-        if (!arr.isArray() || arr.size() == 0) return new ArrayList<>();
-        List<ChatChoice> out = new ArrayList<ChatChoice>(arr.size());
-        for (JsonNode c : arr) {
-            int index = c.path("index").asInt(0);
-            JsonNode msg = c.path("message");
-            String role = msg.path("role").asText("assistant");
-            String content = msg.path("content").asText("");
-            List<ToolCall> toolCalls = parseToolCalls(msg.path("tool_calls"));
-            ChatMessage message = toolCalls.isEmpty()
-                    ? new ChatMessage(role, content)
-                    : ChatMessage.assistantToolCalls(content, toolCalls);
-            String finishReason = c.path("finish_reason").asText("");
-            out.add(new ChatChoice(index, message, finishReason));
+        // Single mutable-ArrayList return: an empty (or non-array) input falls
+        // through the loop and returns the same empty ArrayList, keeping the
+        // return-type contract consistent (Error Prone MixedMutabilityReturnType)
+        // and leaving no equivalent empty-branch mutant for PIT to flag.
+        List<ChatChoice> out = new ArrayList<>();
+        if (arr.isArray()) {
+            for (JsonNode c : arr) {
+                int index = c.path("index").asInt(0);
+                JsonNode msg = c.path("message");
+                String role = msg.path("role").asText("assistant");
+                String content = msg.path("content").asText("");
+                List<ToolCall> toolCalls = parseToolCalls(msg.path("tool_calls"));
+                ChatMessage message = toolCalls.isEmpty()
+                        ? new ChatMessage(role, content)
+                        : ChatMessage.assistantToolCalls(content, toolCalls);
+                String finishReason = c.path("finish_reason").asText("");
+                out.add(new ChatChoice(index, message, finishReason));
+            }
         }
         return out;
     }
 
     private List<ToolCall> parseToolCalls(JsonNode arr) {
-        if (!arr.isArray() || arr.size() == 0) return new ArrayList<>();
-        List<ToolCall> out = new ArrayList<ToolCall>(arr.size());
-        for (JsonNode tc : arr) {
-            String id = tc.path("id").asText("");
-            JsonNode fn = tc.path("function");
-            String name = fn.path("name").asText("");
-            JsonNode argsNode = fn.path("arguments");
-            // OAI emits arguments as a string; some shapes emit a nested object.
-            String args = argsNode.isTextual() ? argsNode.asText("") : argsNode.toString();
-            out.add(new ToolCall(id, name, args));
+        List<ToolCall> out = new ArrayList<>();
+        if (arr.isArray()) {
+            for (JsonNode tc : arr) {
+                String id = tc.path("id").asText("");
+                JsonNode fn = tc.path("function");
+                String name = fn.path("name").asText("");
+                JsonNode argsNode = fn.path("arguments");
+                // OAI emits arguments as a string; some shapes emit a nested object.
+                String args = argsNode.isTextual() ? argsNode.asText("") : argsNode.toString();
+                out.add(new ToolCall(id, name, args));
+            }
         }
         return out;
     }

src/main/java/net/ladenthin/llama/json/CompletionResponseParser.java

@@ -158,14 +158,15 @@ public Map<String, Float> parseProbabilities(JsonNode root) {
      */
     public List<TokenLogprob> parseLogprobs(JsonNode root) {
         JsonNode array = root.path("completion_probabilities");
-        if (!array.isArray() || array.size() == 0) {
-            // Return a mutable empty ArrayList to keep the return type consistent
-            // with the non-empty branch below (Error Prone MixedMutabilityReturnType).
-            return new ArrayList<>();
-        }
-        List<TokenLogprob> result = new ArrayList<TokenLogprob>(array.size());
-        for (JsonNode entry : array) {
-            result.add(parseLogprobEntry(entry));
+        // Single mutable-ArrayList return: an empty (or absent) array falls
+        // through the loop and returns the same empty ArrayList, keeping the
+        // return type consistent (Error Prone MixedMutabilityReturnType) and
+        // leaving no equivalent empty-branch mutant for PIT to flag.
+        List<TokenLogprob> result = new ArrayList<>();
+        if (array.isArray()) {
+            for (JsonNode entry : array) {
+                result.add(parseLogprobEntry(entry));
+            }
         }
         return result;
     }
@@ -219,14 +220,14 @@ private TokenLogprob parseLogprobEntry(JsonNode entry) {
         if (!top.isArray()) {
             top = entry.path("top_logprobs");
         }
-        List<TokenLogprob> topLogprobs;
-        if (top.isArray() && top.size() > 0) {
-            topLogprobs = new ArrayList<TokenLogprob>(top.size());
+        // Single mutable-ArrayList accumulation: a missing or empty nested array
+        // skips the loop and yields an empty ArrayList, so there is no equivalent
+        // empty-branch mutant (the prior emptyList()/ArrayList ternary left one).
+        List<TokenLogprob> topLogprobs = new ArrayList<>();
+        if (top.isArray()) {
             for (JsonNode t : top) {
                 topLogprobs.add(parseLogprobEntry(t));
             }
-        } else {
-            topLogprobs = Collections.emptyList();
         }
         return new TokenLogprob(token, tokenId, logprob, topLogprobs);
     }

src/test/java/net/ladenthin/llama/json/ChatResponseParserTest.java

@@ -9,6 +9,12 @@
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.List;
+import net.ladenthin.llama.value.ChatChoice;
+import net.ladenthin.llama.value.ChatMessage;
+import net.ladenthin.llama.value.ChatResponse;
+import net.ladenthin.llama.value.ToolCall;
+import nl.altindag.log.LogCaptor;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -211,4 +217,136 @@ public void testCountChoices_absent() throws Exception {
         JsonNode node = MAPPER.readTree("{\"id\":\"x\"}");
         assertEquals(0, parser.countChoices(node));
     }
+
+    // ------------------------------------------------------------------
+    // parseResponse(String) — full typed parse
+    // ------------------------------------------------------------------
+
+    @Test
+    public void testParseResponse_fullResponse() {
+        String json = "{\"id\":\"chatcmpl-abc\",\"choices\":[{\"index\":0,"
+                + "\"message\":{\"role\":\"assistant\",\"content\":\"Hi there\"},"
+                + "\"finish_reason\":\"stop\"}],"
+                + "\"usage\":{\"prompt_tokens\":7,\"completion_tokens\":3}}";
+        ChatResponse r = parser.parseResponse(json);
+
+        assertEquals("chatcmpl-abc", r.getId());
+        assertEquals(1, r.getChoices().size());
+        ChatChoice c = r.getChoices().get(0);
+        assertEquals(0, c.getIndex());
+        assertEquals("assistant", c.getMessage().getRole());
+        assertEquals("Hi there", c.getMessage().getContent());
+        assertEquals("stop", c.getFinishReason());
+        assertEquals(7L, r.getUsage().getPromptTokens());
+        assertEquals(3L, r.getUsage().getCompletionTokens());
+        assertEquals(json, r.getRawJson());
+    }
+
+    @Test
+    public void testParseResponse_multipleChoicesPreserveIndexAndOrder() {
+        String json = "{\"id\":\"x\",\"choices\":["
+                + "{\"index\":0,\"message\":{\"role\":\"assistant\",\"content\":\"first\"},\"finish_reason\":\"stop\"},"
+                + "{\"index\":1,\"message\":{\"role\":\"assistant\",\"content\":\"second\"},\"finish_reason\":\"length\"}"
+                + "]}";
+        ChatResponse r = parser.parseResponse(json);
+
+        assertEquals(2, r.getChoices().size());
+        assertEquals(0, r.getChoices().get(0).getIndex());
+        assertEquals("first", r.getChoices().get(0).getMessage().getContent());
+        assertEquals(1, r.getChoices().get(1).getIndex());
+        assertEquals("second", r.getChoices().get(1).getMessage().getContent());
+        assertEquals("length", r.getChoices().get(1).getFinishReason());
+    }
+
+    @Test
+    public void testParseResponse_toolCallsWithStringArguments() {
+        String json = "{\"id\":\"x\",\"choices\":[{\"index\":0,"
+                + "\"message\":{\"role\":\"assistant\",\"content\":\"\","
+                + "\"tool_calls\":[{\"id\":\"call_1\",\"type\":\"function\","
+                + "\"function\":{\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"NYC\\\"}\"}}]},"
+                + "\"finish_reason\":\"tool_calls\"}]}";
+        ChatResponse r = parser.parseResponse(json);
+
+        ChatMessage m = r.getChoices().get(0).getMessage();
+        List<ToolCall> tcs = m.getToolCalls();
+        assertEquals(1, tcs.size());
+        assertEquals("call_1", tcs.get(0).getId());
+        assertEquals("get_weather", tcs.get(0).getName());
+        // arguments is a JSON string in the wire form → unwrapped verbatim, not re-quoted.
+        assertEquals("{\"city\":\"NYC\"}", tcs.get(0).getArgumentsJson());
+    }
+
+    @Test
+    public void testParseResponse_toolCallsWithObjectArguments() {
+        // Some shapes emit arguments as a nested object rather than a string;
+        // the parser serialises it back to its JSON text.
+        String json = "{\"id\":\"x\",\"choices\":[{\"index\":0,"
+                + "\"message\":{\"role\":\"assistant\",\"content\":\"\","
+                + "\"tool_calls\":[{\"id\":\"call_2\","
+                + "\"function\":{\"name\":\"f\",\"arguments\":{\"a\":1}}}]}}]}";
+        ChatResponse r = parser.parseResponse(json);
+
+        ToolCall tc = r.getChoices().get(0).getMessage().getToolCalls().get(0);
+        assertEquals("{\"a\":1}", tc.getArgumentsJson());
+    }
+
+    @Test
+    public void testParseResponse_noToolCalls_plainAssistantMessage() {
+        String json = "{\"id\":\"x\",\"choices\":[{\"index\":0,"
+                + "\"message\":{\"role\":\"assistant\",\"content\":\"plain\"}}]}";
+        ChatResponse r = parser.parseResponse(json);
+
+        ChatMessage m = r.getChoices().get(0).getMessage();
+        assertEquals("plain", m.getContent());
+        assertTrue(m.getToolCalls().isEmpty(), "plain message carries no tool calls");
+    }
+
+    @Test
+    public void testParseResponse_emptyChoicesArray_returnsMutableEmptyList() {
+        ChatResponse r = parser.parseResponse("{\"id\":\"x\",\"choices\":[]}");
+        assertTrue(r.getChoices().isEmpty());
+        // The choices list is exposed by reference and documented as mutable —
+        // adding to it must not throw (kills the immutable-emptyList() mutant).
+        r.getChoices().add(new ChatChoice(0, new ChatMessage("assistant", "added"), "stop"));
+        assertEquals(1, r.getChoices().size());
+    }
+
+    @Test
+    public void testParseResponse_absentChoices_returnsEmptyList() {
+        ChatResponse r = parser.parseResponse("{\"id\":\"x\"}");
+        assertEquals("x", r.getId());
+        assertTrue(r.getChoices().isEmpty());
+    }
+
+    @Test
+    public void testParseResponse_malformedJson_returnsEmptyResponsePreservingRawJson() {
+        String bad = "{not valid json";
+        ChatResponse r = parser.parseResponse(bad);
+        assertEquals("", r.getId());
+        assertTrue(r.getChoices().isEmpty());
+        assertEquals(0L, r.getUsage().getPromptTokens());
+        assertEquals(0L, r.getUsage().getCompletionTokens());
+        // Raw JSON is preserved verbatim even on parse failure (escape hatch).
+        assertEquals(bad, r.getRawJson());
+    }
+
+    /**
+     * Parsing a response carrying real timings must emit exactly one per-run
+     * timing line through the dedicated SLF4J logger — pins the {@code
+     * TimingsLogger.log(...)} side-effect so its removal (VoidMethodCall mutant)
+     * is detected.
+     */
+    @Test
+    public void testParseResponse_emitsTimingLine() {
+        String json = "{\"id\":\"x\",\"choices\":[{\"index\":0,"
+                + "\"message\":{\"role\":\"assistant\",\"content\":\"ok\"}}],"
+                + "\"timings\":{\"prompt_n\":7,\"prompt_ms\":10.0,\"prompt_per_second\":700.0,"
+                + "\"predicted_n\":3,\"predicted_ms\":20.0,\"predicted_per_second\":150.0}}";
+
+        try (LogCaptor captor = LogCaptor.forName(TimingsLogger.LOGGER_NAME)) {
+            ChatResponse r = parser.parseResponse(json);
+            assertEquals(7, r.getTimings().getPromptN());
+            assertEquals(1, captor.getInfoLogs().size(), "exactly one timing line must be emitted");
+        }
+    }
 }