@oh-my-pi/pi-ai 16.2.9 → 16.2.12

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## [Unreleased]
 
+## [16.2.12] - 2026-07-01
+
+### Changed
+
+- Improved streaming performance for Cursor and Devin providers by optimizing mid-stream tool-call argument parsing to prevent UI stalls when handling large payloads.
+
+### Fixed
+
+- Fixed issues with tool call streaming where tool call IDs, partial JSON payloads, or late-arriving IDs could be lost, filtered, or incorrectly initialized.
+- Fixed an issue where stream healing for leaked thinking blocks could replace live tool-call blocks with empty-id placeholders, breaking streamed tool arguments on Anthropic-compatible streams.
+- Fixed an issue where stalled auth-gateway SSE responses could hang indefinitely in pi-native streams by ensuring first-event and idle timeout watchdogs are properly honored.
+- Fixed cross-turn tool-call loops going undetected by adding a guard for consecutive identical tool calls. (#3971)
+
+## [16.2.11] - 2026-07-01
+
+### Fixed
+
+- Fixed streaming UI glitches and resolved an issue where invalid empty tool call IDs were persisted in the chat history.
+
+## [16.2.10] - 2026-06-30
+
+### Added
+
+- Added streaming support for keyed parameter argument deltas in XML-family in-band tool call scanners (Anthropic, DeepSeek, XML, Minimax)
+
+### Changed
+
+- Improved native tool-call passthrough in `wrapInbandToolStream` to accurately mirror live streaming IDs, arguments, and partial JSON states from the underlying provider
+
+### Fixed
+
+- Fixed a bug where tool calls with empty or missing IDs were not detected as malformed, causing API validation failures (e.g., 400 errors with Anthropic) on subsequent requests
+- Raised Gemini header runaway threshold to prevent premature interruption of complex reasoning loops
+- Fixed leaked ` ```thinking ` fences with nested language-tagged Markdown code blocks so inner fences remain inside structured thinking instead of leaking as visible reply text.
+
 ## [16.2.9] - 2026-06-30
 
 ### Added

package/dist/types/dialect/fenced-thinking.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Close-matcher for a ` ```thinking ` block that respects nested Markdown code
+ * fences. A naive `indexOf("```")` closes the thinking section at the FIRST
+ * backtick fence inside the reasoning, so an inner ` ```rs … ``` ` code block
+ * leaks its body (and everything after) into the visible channel. This scanner
+ * tracks inner-fence nesting so only the real thinking closer ends the block.
+ *
+ * Distinguishing an inner opener from the closer: a fenced code block opener is
+ * ` ``` ` immediately followed by a language token (`rs`, `tool_code`, `c++` …)
+ * and a newline. The thinking closer is a bare ` ``` `, or ` ``` ` glued to the
+ * visible reply — its remainder is prose (contains whitespace/punctuation), not
+ * a language token. So a top-level fence whose info is a single language-token
+ * word opens a nested block; anything else closes the thinking, and the text
+ * after the fence run is the visible reply. This preserves the long-standing
+ * inline-close behavior (` ```Visible reply ` ends the block) while skipping
+ * language-tagged inner fences.
+ *
+ * Used by both the owned Gemini scanner (live ` ```thinking ` stream) and the
+ * generic `ThinkingInbandScanner` (leaked-idiom healing).
+ *
+ * Limitation: an *info-less* nested fence (a bare ` ``` ` opening a code block
+ * inside the reasoning) is indistinguishable from the thinking closer and ends
+ * the block. Models tag their fences with a language in practice, so this is
+ * strictly better than the previous first-` ``` ` behavior.
+ */
+/** Result of feeding bytes to {@link FencedThinkingScanner}. */
+export interface FencedThinkingResult {
+    /** Thinking text to emit for this feed (may be empty). */
+    readonly thinking: string;
+    /** True once the thinking closer has been consumed. */
+    readonly closed: boolean;
+    /** Bytes after the closing fence (visible reply); only meaningful when {@link closed}. */
+    readonly rest: string;
+}
+/**
+ * Stateful, line-oriented close-matcher for one ` ```thinking ` block. Owns the
+ * partial-line buffer so an ambiguous trailing fence is held until it resolves.
+ *
+ * Streaming stays character-level for ordinary content: a line is emitted as its
+ * bytes arrive, yet retained in the buffer until its newline so the complete
+ * line can be classified ({@link #emitted} tracks how many leading bytes are
+ * already emitted). A top-level fence candidate is held until its info
+ * disambiguates opener (language token) from closer (prose / bare).
+ */
+export declare class FencedThinkingScanner {
+    #private;
+    /**
+     * Feed bytes and return thinking deltas plus close state. When `final`, the
+     * held tail resolves: a bare ` ``` ` or a ` ```<reply> ` fence closes the
+     * block (remainder becomes `rest`), otherwise it is unterminated thinking.
+     */
+    feed(text: string, final: boolean): FencedThinkingResult;
+}

package/dist/types/index.d.ts

@@ -45,4 +45,5 @@ export * from "./utils/openrouter-headers";
 export * from "./utils/retry";
 export * from "./utils/schema";
 export * from "./utils/thinking-loop";
+export * from "./utils/tool-call-loop-guard";
 export * from "./utils/validation";

package/dist/types/providers/cursor.d.ts

@@ -1,6 +1,6 @@
 import { type JsonValue } from "@bufbuild/protobuf";
 import type { AssistantMessage, CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, StreamFunction, StreamOptions, TextContent, ThinkingContent, ToolCall, ToolResultMessage } from "../types";
-import { kStreamingBlockIndex, kStreamingBlockKind, kStreamingPartialJson } from "../utils/block-symbols";
+import { kStreamingBlockIndex, kStreamingBlockKind, kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 export declare const CURSOR_API_URL = "https://api2.cursor.sh";
 export declare const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
@@ -14,6 +14,7 @@ export declare const streamCursor: StreamFunction<"cursor-agent">;
 export type ToolCallState = ToolCall & {
     [kStreamingBlockIndex]: number;
     [kStreamingPartialJson]?: string;
+    [kStreamingLastParseLen]?: number;
     [kStreamingBlockKind]: "mcp" | "todo";
 };
 export interface BlockState {

package/dist/types/utils/thinking-loop.d.ts

@@ -41,12 +41,17 @@ export declare class ThinkingLoopDetector {
  * stream that trips the tool-call reminder. Gemini occasionally narrates a long
  * chain of titled summaries ("Examining Result Handling", "Refining Result
  * Rendering", …) without ever calling a tool, burning the whole budget on
- * planning; at this many distinct titles it has almost certainly stalled. This
- * is the over-planning shape {@link ThinkingLoopDetector} misses — those titles
- * are stripped before its similarity analysis precisely because their wording
- * keeps changing, so a genuinely-distinct planning runaway never trips it.
+ * planning. This is the over-planning shape {@link ThinkingLoopDetector} misses —
+ * those titles are stripped before its similarity analysis precisely because their
+ * wording keeps changing, so a genuinely-distinct planning runaway never trips it.
+ *
+ * Set well above legitimate hard-problem depth: a capable model can emit ~10
+ * distinct, progressing hypotheses in a single reasoning block before acting (and
+ * a false trip is costly — the interrupt discards the whole reasoning turn). A
+ * real narration runaway burns dozens-to-hundreds of titles, so this still trips
+ * fast on the actual pathology.
  */
-export declare const GEMINI_HEADER_RUNAWAY_THRESHOLD = 10;
+export declare const GEMINI_HEADER_RUNAWAY_THRESHOLD = 24;
 /**
  * True when a single trimmed line is a Gemini reasoning-summary title: a markdown
  * ATX heading (`## …`) or a whole-line bold / bold-italic run (`**Title**`,

package/dist/types/utils/tool-call-loop-guard.d.ts

@@ -0,0 +1,26 @@
+import type { AssistantMessage, ToolResultMessage } from "../types";
+/** Runtime settings for cross-turn tool-call repetition detection. */
+export interface ToolCallLoopGuardOptions {
+    readonly threshold: number;
+    readonly exemptTools: readonly string[];
+}
+/** A completed assistant turn plus the tool results it produced. */
+export interface ToolCallLoopTurn {
+    readonly message: AssistantMessage;
+    readonly toolResults: readonly ToolResultMessage[];
+}
+/** Details needed to steer the model away from a repeated tool call. */
+export interface RepeatedToolCallDetection {
+    readonly kind: "repeated_tool_call";
+    readonly toolName: string;
+    readonly count: number;
+    readonly resultSummary: string;
+    readonly argumentsSummary: string;
+}
+/** Detects consecutive identical assistant tool calls across model turns. */
+export declare class ToolCallLoopGuard {
+    #private;
+    constructor(options: ToolCallLoopGuardOptions);
+    /** Records one completed turn and returns the threshold hit, if any. */
+    recordTurn(turn: ToolCallLoopTurn): RepeatedToolCallDetection | null;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.2.9",
+	"version": "16.2.12",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.2.9",
-		"@oh-my-pi/pi-utils": "16.2.9",
-		"@oh-my-pi/pi-wire": "16.2.9",
+		"@oh-my-pi/pi-catalog": "16.2.12",
+		"@oh-my-pi/pi-utils": "16.2.12",
+		"@oh-my-pi/pi-wire": "16.2.12",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/dialect/anthropic.ts

@@ -132,7 +132,7 @@ export class AnthropicInbandScanner implements InbandScanner {
 					progressed = this.#consumeInvoke(final, events);
 					break;
 				case "parameter":
-					progressed = this.#consumeParameter(final);
+					progressed = this.#consumeParameter(final, events);
 					break;
 				case "thinking":
 					progressed = this.#consumeThinking(final, events);
@@ -272,7 +272,7 @@ export class AnthropicInbandScanner implements InbandScanner {
 		return true;
 	}
 
-	#consumeParameter(final: boolean): boolean {
+	#consumeParameter(final: boolean, events: InbandScanEvent[]): boolean {
 		const tagStart = this.#buffer.indexOf("<");
 		if (tagStart === -1) {
 			if (final) {
@@ -280,14 +280,14 @@ export class AnthropicInbandScanner implements InbandScanner {
 				this.#buffer = "";
 				return false;
 			}
-			this.#appendParameterValue(this.#buffer);
+			this.#appendParameterValue(this.#buffer, events);
 			this.#rawBlock += this.#buffer;
 			this.#buffer = "";
 			return false;
 		}
 		if (tagStart > 0) {
 			const consumed = this.#buffer.slice(0, tagStart);
-			this.#appendParameterValue(consumed);
+			this.#appendParameterValue(consumed, events);
 			this.#rawBlock += consumed;
 			this.#buffer = this.#buffer.slice(tagStart);
 			return true;
@@ -307,7 +307,7 @@ export class AnthropicInbandScanner implements InbandScanner {
 			return false;
 		}
 		const consumed = this.#buffer[0]!;
-		this.#appendParameterValue(consumed);
+		this.#appendParameterValue(consumed, events);
 		this.#rawBlock += consumed;
 		this.#buffer = this.#buffer.slice(1);
 		return true;
@@ -378,10 +378,22 @@ export class AnthropicInbandScanner implements InbandScanner {
 		this.#state = "parameter";
 	}
 
-	#appendParameterValue(delta: string): void {
+	#appendParameterValue(delta: string, events: InbandScanEvent[]): void {
 		if (delta.length === 0) return;
 		const remaining = MAX_PARAMETER_VALUE_LENGTH - this.#paramValue.length;
-		if (remaining > 0) this.#paramValue += delta.slice(0, remaining);
+		const accepted = remaining > 0 ? delta.slice(0, remaining) : "";
+		if (accepted.length > 0) {
+			this.#paramValue += accepted;
+			if (this.#started && this.#paramName.length > 0) {
+				events.push({
+					type: "toolArgDelta",
+					id: this.#id,
+					name: this.#name,
+					key: this.#paramName,
+					delta: accepted,
+				});
+			}
+		}
 		if (delta.length > remaining) this.#paramTruncated = true;
 	}
 

package/src/dialect/deepseek.ts

@@ -99,6 +99,7 @@ export class DeepSeekInbandScanner implements InbandScanner {
 	#dsmlArgs: Record<string, unknown> = {};
 	#dsmlParamName = "";
 	#dsmlParamIsString = true;
+	#dsmlParamRaw = "";
 	#rawBlock = "";
 	#stripLeadingWhitespace = false;
 
@@ -153,7 +154,7 @@ export class DeepSeekInbandScanner implements InbandScanner {
 				if (!this.#consumeDsmlInvoke(final, events)) break;
 				continue;
 			}
-			if (!this.#consumeDsmlParam(final)) break;
+			if (!this.#consumeDsmlParam(final, events)) break;
 		}
 		if (final && this.#state === "thinking") this.#endThinking(events);
 		if (final && this.#buffer.length === 0 && this.#rawBlock.length > 0) this.#rawBlock = "";
@@ -396,18 +397,23 @@ export class DeepSeekInbandScanner implements InbandScanner {
 		return final;
 	}
 
-	#consumeDsmlParam(final: boolean): boolean {
+	#consumeDsmlParam(final: boolean, events: InbandScanEvent[]): boolean {
 		const close = findEarliestToken(this.#buffer, DSML_PARAMETER_CLOSE_TOKENS);
 		if (!close) {
+			const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, DSML_PARAMETER_CLOSE_TOKENS);
+			const chunk = this.#buffer.slice(0, this.#buffer.length - hold);
+			this.#streamDsmlParam(chunk, events);
+			this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
 			if (final) this.#resetDsmlTool();
 			return false;
 		}
-		const rawValue = this.#buffer.slice(0, close.index);
-		this.#dsmlArgs[this.#dsmlParamName] = coerceDsmlValue(rawValue, this.#dsmlParamIsString);
-		this.#rawBlock += rawValue + close.token;
+		this.#streamDsmlParam(this.#buffer.slice(0, close.index), events);
+		this.#dsmlArgs[this.#dsmlParamName] = coerceDsmlValue(this.#dsmlParamRaw, this.#dsmlParamIsString);
+		this.#rawBlock += close.token;
 		this.#buffer = this.#buffer.slice(close.index + close.token.length);
 		this.#dsmlParamName = "";
 		this.#dsmlParamIsString = true;
+		this.#dsmlParamRaw = "";
 		this.#state = "dsmlInvoke";
 		return true;
 	}
@@ -418,6 +424,13 @@ export class DeepSeekInbandScanner implements InbandScanner {
 		events.push({ type: "toolStart", id: this.#id, name: this.#name });
 	}
 
+	#streamDsmlParam(chunk: string, events: InbandScanEvent[]): void {
+		if (chunk.length === 0) return;
+		this.#dsmlParamRaw += chunk;
+		this.#rawBlock += chunk;
+		events.push({ type: "toolArgDelta", id: this.#id, name: this.#name, key: this.#dsmlParamName, delta: chunk });
+	}
+
 	#emitThinking(delta: string, events: InbandScanEvent[]): void {
 		if (delta.length === 0) return;
 		if (this.#parseThinking) {
@@ -509,6 +522,7 @@ export class DeepSeekInbandScanner implements InbandScanner {
 		this.#dsmlArgs = {};
 		this.#dsmlParamName = "";
 		this.#dsmlParamIsString = true;
+		this.#dsmlParamRaw = "";
 		this.#rawBlock = "";
 	}
 }

package/src/dialect/fenced-thinking.ts

@@ -0,0 +1,184 @@
+/**
+ * Close-matcher for a ` ```thinking ` block that respects nested Markdown code
+ * fences. A naive `indexOf("```")` closes the thinking section at the FIRST
+ * backtick fence inside the reasoning, so an inner ` ```rs … ``` ` code block
+ * leaks its body (and everything after) into the visible channel. This scanner
+ * tracks inner-fence nesting so only the real thinking closer ends the block.
+ *
+ * Distinguishing an inner opener from the closer: a fenced code block opener is
+ * ` ``` ` immediately followed by a language token (`rs`, `tool_code`, `c++` …)
+ * and a newline. The thinking closer is a bare ` ``` `, or ` ``` ` glued to the
+ * visible reply — its remainder is prose (contains whitespace/punctuation), not
+ * a language token. So a top-level fence whose info is a single language-token
+ * word opens a nested block; anything else closes the thinking, and the text
+ * after the fence run is the visible reply. This preserves the long-standing
+ * inline-close behavior (` ```Visible reply ` ends the block) while skipping
+ * language-tagged inner fences.
+ *
+ * Used by both the owned Gemini scanner (live ` ```thinking ` stream) and the
+ * generic `ThinkingInbandScanner` (leaked-idiom healing).
+ *
+ * Limitation: an *info-less* nested fence (a bare ` ``` ` opening a code block
+ * inside the reasoning) is indistinguishable from the thinking closer and ends
+ * the block. Models tag their fences with a language in practice, so this is
+ * strictly better than the previous first-` ``` ` behavior.
+ */
+
+/** A complete fence line: ≤3 lead spaces, a run of ≥3 backticks/tildes, then an info string. */
+const FENCE_LINE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+/** ≤3 lead spaces then a (possibly partial) backtick run and whatever follows it. */
+const BACKTICK_LEAD = /^ {0,3}(`*)([\s\S]*)$/;
+/** A language-tag info string: one token, no whitespace (markers an inner fence opener carries). */
+const LANG_TOKEN = /^[A-Za-z0-9_+#-]+$/;
+
+/** Result of feeding bytes to {@link FencedThinkingScanner}. */
+export interface FencedThinkingResult {
+	/** Thinking text to emit for this feed (may be empty). */
+	readonly thinking: string;
+	/** True once the thinking closer has been consumed. */
+	readonly closed: boolean;
+	/** Bytes after the closing fence (visible reply); only meaningful when {@link closed}. */
+	readonly rest: string;
+}
+
+/**
+ * Stateful, line-oriented close-matcher for one ` ```thinking ` block. Owns the
+ * partial-line buffer so an ambiguous trailing fence is held until it resolves.
+ *
+ * Streaming stays character-level for ordinary content: a line is emitted as its
+ * bytes arrive, yet retained in the buffer until its newline so the complete
+ * line can be classified ({@link #emitted} tracks how many leading bytes are
+ * already emitted). A top-level fence candidate is held until its info
+ * disambiguates opener (language token) from closer (prose / bare).
+ */
+export class FencedThinkingScanner {
+	#buffer = "";
+	/** The fence run that opened the current nested code block, or "" at top level. */
+	#inner = "";
+	/** Bytes of the leading (incomplete) line already returned as thinking. */
+	#emitted = 0;
+
+	/**
+	 * Feed bytes and return thinking deltas plus close state. When `final`, the
+	 * held tail resolves: a bare ` ``` ` or a ` ```<reply> ` fence closes the
+	 * block (remainder becomes `rest`), otherwise it is unterminated thinking.
+	 */
+	feed(text: string, final: boolean): FencedThinkingResult {
+		this.#buffer += text;
+		let thinking = "";
+		for (;;) {
+			const nl = this.#buffer.indexOf("\n");
+			if (nl === -1) break;
+			const line = this.#buffer.slice(0, nl);
+			if (!this.#inner) {
+				const close = this.#closeRest(line);
+				if (close !== undefined) {
+					// Closer bytes are always held, so #emitted is 0 and nothing leaked.
+					const rest = close + this.#buffer.slice(nl); // keep the newline with the reply
+					this.#reset();
+					return { thinking, closed: true, rest };
+				}
+			}
+			// Content line (including an inner-fence open/close).
+			thinking += this.#buffer.slice(this.#emitted, nl + 1);
+			this.#updateInner(line);
+			this.#buffer = this.#buffer.slice(nl + 1);
+			this.#emitted = 0;
+		}
+
+		const tail = this.#buffer;
+		if (this.#inner) {
+			// Inside a nested block every byte is thinking content: emit eagerly,
+			// keeping it buffered until the newline classifies the line.
+			thinking += tail.slice(this.#emitted);
+			this.#emitted = tail.length;
+			return { thinking, closed: false, rest: "" };
+		}
+
+		if (final) {
+			const close = this.#closeRestFinal(tail);
+			if (close !== undefined) {
+				this.#reset();
+				return { thinking, closed: true, rest: close };
+			}
+		} else {
+			const close = this.#closeRestStreamingTail(tail);
+			if (close !== undefined) {
+				this.#reset();
+				return { thinking, closed: true, rest: close };
+			}
+			if (this.#mustHold(tail)) return { thinking, closed: false, rest: "" };
+		}
+		// Either final (flush the remainder) or a line that can no longer be a fence.
+		thinking += tail.slice(this.#emitted);
+		if (final) this.#reset();
+		else this.#emitted = tail.length;
+		return { thinking, closed: false, rest: "" };
+	}
+
+	/**
+	 * Complete line close test. A bare backtick fence closes thinking; a
+	 * language-token fence line opens an inner block; prose-like remainder is the
+	 * inline visible reply.
+	 */
+	#closeRest(line: string): string | undefined {
+		const m = BACKTICK_LEAD.exec(line);
+		if (!m || m[1]!.length < 3) return undefined;
+		const rest = m[2]!;
+		if (rest === "" || rest.trim() === "") return ""; // bare close (only whitespace)
+		if (LANG_TOKEN.test(rest)) return undefined; // language-tagged inner opener
+		return rest;
+	}
+
+	/** Final tail close test: EOF disambiguates any top-level backtick run as the closer. */
+	#closeRestFinal(tail: string): string | undefined {
+		const m = BACKTICK_LEAD.exec(tail);
+		if (!m || m[1]!.length < 3) return undefined;
+		const rest = m[2]!;
+		return rest.trim() === "" ? "" : rest;
+	}
+
+	/** Streaming tail close test: only a prose-like inline reply resolves the close. */
+	#closeRestStreamingTail(tail: string): string | undefined {
+		const m = BACKTICK_LEAD.exec(tail);
+		if (!m || m[1]!.length < 3) return undefined;
+		const rest = m[2]!;
+		if (rest === "" || rest.trim() === "" || LANG_TOKEN.test(rest)) return undefined;
+		return rest;
+	}
+
+	/** Whether a top-level trailing partial is still undecided and must be held. */
+	#mustHold(tail: string): boolean {
+		const m = BACKTICK_LEAD.exec(tail);
+		if (!m) return false;
+		const ticks = m[1]!.length;
+		const rest = m[2]!;
+		// A growing backtick run could still reach a fence. A complete run plus
+		// a language-token prefix is also undecided until a newline confirms an
+		// inner opener or a non-token character confirms an inline close.
+		if (rest === "" || rest.trim() === "") return ticks >= 1 || /^ {0,3}$/.test(tail);
+		return ticks >= 3 && LANG_TOKEN.test(rest);
+	}
+
+	#reset(): void {
+		this.#buffer = "";
+		this.#inner = "";
+		this.#emitted = 0;
+	}
+
+	/** Toggle nested-fence state for a completed content line. */
+	#updateInner(line: string): void {
+		const fence = FENCE_LINE.exec(line);
+		if (!fence) return;
+		const run = fence[1]!;
+		const info = fence[2]!.trim();
+		if (!this.#inner) {
+			// A top-level closer was already handled by #closeRest, so this opens a
+			// nested code block (tilde fence, or backtick fence with a language token).
+			this.#inner = run;
+		} else if (run[0] === this.#inner[0] && run.length >= this.#inner.length && info === "") {
+			// Closing fence: same char, at least as long, no info string.
+			this.#inner = "";
+		}
+	}
+}

package/src/dialect/gemini.ts

@@ -1,5 +1,6 @@
 import type { Message, ToolCall } from "../types";
-import { mintToolCallId, partialSuffixOverlap, partialSuffixOverlapAny } from "./coercion";
+import { mintToolCallId, partialSuffixOverlapAny } from "./coercion";
+import { FencedThinkingScanner } from "./fenced-thinking";
 import dialectPrompt from "./gemini.md" with { type: "text" };
 import { assistantTranscriptParts, collectToolResultRun, joinUserBodies, messageContentText } from "./rendering";
 import type {
@@ -37,6 +38,8 @@ export class GeminiInbandScanner implements InbandScanner {
 	#buffer = "";
 	#state: State = "outside";
 	#thinking = "";
+	/** Fence-aware close-matcher while {@link #state} is "thinking"; undefined otherwise. */
+	#fenced: FencedThinkingScanner | undefined;
 	readonly #parseThinking: boolean;
 
 	constructor(options: InbandScannerOptions = {}) {
@@ -55,21 +58,23 @@ export class GeminiInbandScanner implements InbandScanner {
 
 	#consume(final: boolean): InbandScanEvent[] {
 		const events: InbandScanEvent[] = [];
-		while (this.#buffer.length > 0) {
-			if (this.#state === "outside") {
-				this.#consumeOutside(final, events);
-				if (this.#state === "outside") break;
-				continue;
-			}
+		for (;;) {
 			if (this.#state === "thinking") {
+				// Always run on final so the fenced scanner flushes its held tail even
+				// when #buffer is empty (a partial close held from the previous feed).
 				this.#consumeThinking(final, events);
 				if (this.#state === "thinking") break;
 				continue;
 			}
+			if (this.#buffer.length === 0) break;
+			if (this.#state === "outside") {
+				this.#consumeOutside(final, events);
+				if (this.#state === "outside") break;
+				continue;
+			}
 			this.#consumeTool(final, events);
 			if (this.#state === "tool") break;
 		}
-		if (final && this.#state === "thinking") this.#endThinking(events);
 		return events;
 	}
 
@@ -94,6 +99,7 @@ export class GeminiInbandScanner implements InbandScanner {
 		if (isThink) {
 			this.#buffer = this.#buffer.slice(start + THINK_OPEN.length);
 			this.#thinking = "";
+			this.#fenced = new FencedThinkingScanner();
 			events.push({ type: "thinkingStart" });
 			this.#state = "thinking";
 			return;
@@ -103,18 +109,13 @@ export class GeminiInbandScanner implements InbandScanner {
 	}
 
 	#consumeThinking(final: boolean, events: InbandScanEvent[]): void {
-		const close = this.#buffer.indexOf(FENCE);
-		if (close === -1) {
-			const hold = final ? 0 : partialSuffixOverlap(this.#buffer, FENCE);
-			this.#emitThinking(this.#buffer.slice(0, this.#buffer.length - hold), events);
-			this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
-			if (final) this.#endThinking(events);
-			return;
+		const result = this.#fenced!.feed(this.#buffer, final);
+		this.#buffer = result.closed ? result.rest : "";
+		this.#emitThinking(result.thinking, events);
+		if (result.closed || final) {
+			this.#endThinking(events);
+			this.#fenced = undefined;
 		}
-		this.#emitThinking(this.#buffer.slice(0, close), events);
-		this.#buffer = this.#buffer.slice(close + FENCE.length);
-		this.#endThinking(events);
-		this.#state = "outside";
 	}
 
 	#emitThinking(delta: string, events: InbandScanEvent[]): void {