Forward Gemini finishReason to usage and correct truncation docs

Author: TheGreatAxios

vendor/intx-inference/PATCHES.md

@@ -414,10 +414,15 @@ prior code fell back to a `{ _raw: <partial JSON> }` tool_call block, which
 the reactor dispatched — executing a tool with truncated arguments when the
 model was cut off by `max_tokens` (CL-7783: a truncated `Bash`
 `rm -rf /tm…` fragment reached the executor). Now: when `stopReason` is
-`max_tokens` and a tool call is still open, the turn fails retryably with a
-message naming the tool and the truncated prefix, telling the model to retry
-with a narrower scope; any other unparseable-args case fails retryably as
-invalid JSON. Two supporting changes: `providers/anthropic.ts` parses
+`max_tokens` and a tool call is still open, the turn fails with an
+`inference.error` naming the tool and the truncated prefix, advising a
+larger budget or a narrower scope for the model's next attempt; any other
+unparseable-args case fails the same way as invalid JSON. Both errors carry
+category `retryable`, but end-of-stream finalization always runs after the
+attempt has committed visible output, so the harness commitment boundary
+suppresses the mechanical retry — the failure is terminal for the turn, and
+the message is guidance for the next attempt rather than a re-issued retry.
+Two supporting changes: `providers/anthropic.ts` parses
 `stop_reason` out of `MessageDelta` (previously stripped by the schema) and
 surfaces it on `inference.usage`, and `vendor/intx-types`' `InferenceUsageEvent`
 gains the optional `stopReason` field both halves flow through. Guarded by the
@@ -426,7 +431,12 @@ exact incident wire sequence and asserts no `tool_call` block reaches the
 reactor. The OpenAI-compatible adapter was audited for the same path: it has
 no adapter-local args fallback (the harness was the only dispatch site) but
 still drops `finish_reason` on both paths, so OpenAI streams get the generic
-invalid-JSON failure rather than the truncation-specific message.
+invalid-JSON failure rather than the truncation-specific message. The Gemini
+adapter forwards its terminal `finishReason` onto `inference.usage` (same
+spread idiom as Anthropic), but forwards the provider's raw spelling
+(`MAX_TOKENS`), which the harness `max_tokens` comparison does not match —
+so Gemini truncation still lands on the generic invalid-JSON failure until
+the harness normalizes provider spellings.
 
 **Disposition:** Promotion candidate. Safety/correctness fix — prevents
 executing tools with truncated arguments after a `max_tokens` cutoff.

vendor/intx-inference/src/harness.ts

@@ -1124,8 +1124,10 @@ async function* runSingleAttempt(
     // validate every open call before emitting any of them, and never
     // dispatch a call whose arguments are incomplete or unparseable. A turn
     // cut at max_tokens with calls still open is unambiguous truncation;
-    // anything else unparseable is still not a normal call. Both fail the
-    // turn retryably so the model can re-issue it with room to finish.
+    // anything else unparseable is still not a normal call. Both yield an
+    // inference.error (category retryable) naming the call; post-commit the
+    // harness surfaces it terminally rather than mechanically retrying, so
+    // the message guides the model's next attempt.
     const finalizedToolCalls: {
       tc: ToolCallState;
       parsedArgs: Record<string, unknown>;

vendor/intx-inference/src/providers/google-genai.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import type { LastCycleSource } from "@intx/types/runtime";
+import { createGoogleGenAIAdapter } from "./google-genai";
+
+const TEST_SOURCE: LastCycleSource = {
+  sourceId: "test-google-genai",
+  provider: "google-genai",
+  model: "test-gemini-model",
+};
+
+describe("google-genai adapter — finishReason forwarding (CL-7783)", () => {
+  test("terminal finishReason surfaces on the usage event", () => {
+    const adapter = createGoogleGenAIAdapter(TEST_SOURCE);
+    const events = adapter.parseResponse(
+      JSON.stringify({
+        candidates: [
+          {
+            content: { parts: [{ text: "partial" }], role: "model" },
+            finishReason: "MAX_TOKENS",
+            index: 0,
+          },
+        ],
+        usageMetadata: { promptTokenCount: 5, candidatesTokenCount: 3 },
+      }),
+    );
+    const usage = events.filter((e) => e.type === "inference.usage");
+    expect(usage).toHaveLength(1);
+    expect(usage[0]?.data.stopReason).toBe("MAX_TOKENS");
+  });
+
+  test("non-terminal event without finishReason emits no usage", () => {
+    const adapter = createGoogleGenAIAdapter(TEST_SOURCE);
+    const events = adapter.parseResponse(
+      JSON.stringify({
+        candidates: [
+          {
+            content: { parts: [{ text: "partial" }], role: "model" },
+            index: 0,
+          },
+        ],
+        usageMetadata: { promptTokenCount: 5, candidatesTokenCount: 3 },
+      }),
+    );
+    expect(events.some((e) => e.type === "inference.usage")).toBe(false);
+  });
+});

vendor/intx-inference/src/providers/google-genai.ts

@@ -1461,7 +1461,14 @@ function parseResponse(
     out.push({
       type: "inference.usage",
       seq,
-      data: { usage: tokenUsage, source },
+      // Locally patched — see vendor/intx-inference/PATCHES.md#inference-ts-cl-7783-truncated-tool-call
+      data: {
+        usage: tokenUsage,
+        ...(candidate.finishReason === undefined
+          ? {}
+          : { stopReason: candidate.finishReason }),
+        source,
+      },
     });
 
     // Terminal events seal the response. A still-pending

vendor/intx-types/PATCHES.md

@@ -22,7 +22,8 @@ seq 0. Companion to `store-ts-load-errors` in `@intx/storage-isogit` and
 
 `src/runtime.ts` — The `inference.usage` variant of `InferenceEvent`
 gains optional `data.stopReason: string`, populated by adapters that
-observe a wire-level stop/finish reason (Anthropic `stop_reason`).
+observe a wire-level stop/finish reason (Anthropic `stop_reason`, Gemini
+`finishReason`).
 `inference.usage` is the only harness-level signal that records how a
 turn ended; without the provider's stop reason the harness cannot
 distinguish a complete turn from a truncation (`max_tokens` with a tool