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

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [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/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/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.2.9",
+	"version": "16.2.11",
 	"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.11",
+		"@oh-my-pi/pi-utils": "16.2.11",
+		"@oh-my-pi/pi-wire": "16.2.11",
 		"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 {

package/src/dialect/owned-stream.ts

@@ -5,6 +5,12 @@ import type {
 	ThinkingContent,
 	ToolCall,
 } from "../types";
+import {
+	clearStreamingPartialJson,
+	getStreamingPartialJson,
+	type StreamingPartialJsonCarrier,
+	setStreamingPartialJson,
+} from "../utils/block-symbols";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { buildStringArgsResolver } from "./coercion";
 import { createInbandScanner } from "./factory";
@@ -36,6 +42,35 @@ function firstTokenIndex(text: string, tokens: readonly string[]): number {
 type OpenText = { index: number } | undefined;
 type OpenThinking = { index: number; text: string } | undefined;
 
+type StreamingToolCall = ToolCall & StreamingPartialJsonCarrier;
+
+function cloneToolCall(source: StreamingToolCall): StreamingToolCall {
+	const block: StreamingToolCall = {
+		type: "toolCall",
+		id: source.id,
+		name: source.name,
+		arguments: source.arguments,
+		...(source.rawBlock !== undefined ? { rawBlock: source.rawBlock } : {}),
+	};
+	const partialJson = getStreamingPartialJson(source);
+	if (partialJson !== undefined) setStreamingPartialJson(block, partialJson);
+	return block;
+}
+
+function syncToolCall(target: StreamingToolCall, source: StreamingToolCall): void {
+	target.id = source.id;
+	target.name = source.name;
+	target.arguments = source.arguments;
+	target.rawBlock = source.rawBlock;
+	const partialJson = getStreamingPartialJson(source);
+	if (partialJson === undefined) clearStreamingPartialJson(target);
+	else setStreamingPartialJson(target, partialJson);
+}
+
+function hasUsableNativeToolCall(source: StreamingToolCall | undefined): source is StreamingToolCall {
+	return source !== undefined && source.name.trim().length > 0 && source.id.trim().length > 0;
+}
+
 export function parseInbandToolMessage(
 	message: AssistantMessage,
 	dialect: Dialect,
@@ -95,12 +130,18 @@ export function wrapInbandToolStream(
 						// projector ignores nameless "ghost" parts and de-conflicts with the
 						// in-band channel.
 						const src = event.partial.content[event.contentIndex];
-						projector?.nativeToolStart(event.contentIndex, src?.type === "toolCall" ? src.name : "");
+						projector?.nativeToolStart(event.contentIndex, src?.type === "toolCall" ? src : undefined);
 						break;
 					}
-					case "toolcall_delta":
-						projector?.nativeToolDelta(event.contentIndex, event.delta);
+					case "toolcall_delta": {
+						const src = event.partial.content[event.contentIndex];
+						projector?.nativeToolDelta(
+							event.contentIndex,
+							event.delta,
+							src?.type === "toolCall" ? src : undefined,
+						);
 						break;
+					}
 					case "toolcall_end":
 						projector?.nativeToolEnd(event.contentIndex, event.toolCall);
 						break;
@@ -138,7 +179,7 @@ class InbandStreamProjector {
 	// `contentIndex`. `#toolChannel` records which channel produced the turn's
 	// first real call so the other is dropped — no double-dispatch, and no
 	// guessing from emptiness. Nameless "ghost" parts never lock a channel.
-	#nativeBlocks = new Map<number, { index: number; block: ToolCall }>();
+	#nativeBlocks = new Map<number, { index: number; block: StreamingToolCall }>();
 	#toolChannel: "native" | "inband" | undefined;
 
 	constructor(
@@ -167,27 +208,36 @@ class InbandStreamProjector {
 		this.#partial.content.push(block);
 	}
 
-	// Forward a native tool call's lifecycle live. `name` comes from the inner
-	// stream's partial (set at start for well-behaved providers). Empty `name`
-	// means a not-yet-identified or "ghost" call — skip until `nativeToolEnd`
-	// can confirm. Once the in-band channel owns the turn, native calls are
-	// dropped to avoid double-dispatch.
-	nativeToolStart(srcIndex: number, name: string): void {
-		if (this.#stopped || !name || this.#toolChannel === "inband") return;
+	// Forward a native tool call's lifecycle live. `source` comes from the inner
+	// stream's current partial block. When owned mode wraps a provider that still
+	// emits native tool calls, the projected block must mirror the provider's live
+	// id / args / partial-json state rather than inventing `{ id: "", arguments:
+	// {} }` placeholders — otherwise the UI loses streaming args, can mis-key the
+	// call until `toolcall_end`, and may even persist an invalid empty id into
+	// replay history. So we do NOT start until the provider has emitted both a
+	// non-empty name and a non-empty id; if either lands late, `nativeToolDelta`
+	// retries the start on subsequent deltas.
+	nativeToolStart(srcIndex: number, source: StreamingToolCall | undefined): void {
+		if (this.#stopped || !hasUsableNativeToolCall(source) || this.#toolChannel === "inband") return;
 		this.#toolChannel = "native";
 		this.#closeText();
 		this.#closeThinking();
-		const block: ToolCall = { type: "toolCall", id: "", name, arguments: {} };
+		const block = cloneToolCall(source);
 		this.#partial.content.push(block);
 		const index = this.#partial.content.length - 1;
 		this.#nativeBlocks.set(srcIndex, { index, block });
 		if (this.#emitEvents) this.#out.push({ type: "toolcall_start", contentIndex: index, partial: this.#partial });
 	}
 
-	nativeToolDelta(srcIndex: number, delta: string): void {
+	nativeToolDelta(srcIndex: number, delta: string, source: StreamingToolCall | undefined): void {
 		if (this.#stopped) return;
-		const entry = this.#nativeBlocks.get(srcIndex);
+		let entry = this.#nativeBlocks.get(srcIndex);
+		if (!entry && hasUsableNativeToolCall(source) && this.#toolChannel !== "inband") {
+			this.nativeToolStart(srcIndex, source);
+			entry = this.#nativeBlocks.get(srcIndex);
+		}
 		if (!entry) return;
+		if (source) syncToolCall(entry.block, source);
 		if (this.#emitEvents)
 			this.#out.push({ type: "toolcall_delta", contentIndex: entry.index, delta, partial: this.#partial });
 	}
@@ -196,7 +246,7 @@ class InbandStreamProjector {
 		if (this.#stopped) return;
 		const entry = this.#nativeBlocks.get(srcIndex);
 		if (entry) {
-			Object.assign(entry.block, toolCall);
+			if (hasUsableNativeToolCall(toolCall)) syncToolCall(entry.block, toolCall);
 			if (this.#emitEvents)
 				this.#out.push({
 					type: "toolcall_end",
@@ -207,14 +257,14 @@ class InbandStreamProjector {
 			this.#nativeBlocks.delete(srcIndex);
 			return;
 		}
-		// Never streamed (name was empty at start). Salvage a real call whose name
-		// only arrived now; drop nameless ghosts and anything the in-band channel
-		// already claimed.
-		if (!toolCall.name || this.#toolChannel === "inband") return;
+		// Never streamed (name/id were incomplete at start). Salvage only a real
+		// native call whose identifier is now present; drop nameless/id-less ghosts
+		// and anything the in-band channel already claimed.
+		if (!hasUsableNativeToolCall(toolCall) || this.#toolChannel === "inband") return;
 		this.#toolChannel = "native";
 		this.#closeText();
 		this.#closeThinking();
-		const block: ToolCall = { ...toolCall };
+		const block = cloneToolCall(toolCall);
 		this.#partial.content.push(block);
 		const index = this.#partial.content.length - 1;
 		if (this.#emitEvents) {

package/src/dialect/thinking.ts

@@ -1,7 +1,8 @@
 import { partialSuffixOverlapAny } from "./coercion";
+import { FencedThinkingScanner } from "./fenced-thinking";
 import type { InbandScanEvent, InbandScanner } from "./types";
 
-type Tag = { readonly open: string; readonly close: string };
+type Tag = { readonly open: string; readonly close: string; readonly fenced?: boolean };
 
 /**
  * Every dialect's in-band thinking section in its canonical `renderThinking`
@@ -18,7 +19,7 @@ const TAGS: readonly Tag[] = [
 	{ open: "<think>", close: "</think>" }, // deepseek, glm, hermes, kimi, qwen3 (and anthropic/minimax/xml)
 	{ open: "<thinking>", close: "</thinking>" }, // anthropic, minimax, xml
 	{ open: "<scratchpad>", close: "</scratchpad>" }, // anthropic
-	{ open: "```thinking\n", close: "```" }, // gemini fenced thinking
+	{ open: "```thinking\n", close: "```", fenced: true }, // gemini fenced thinking
 	{ open: "<|channel>thought\n", close: "<channel|>" }, // gemma reasoning channel
 	{ open: "<|start|>assistant<|channel|>analysis<|message|>", close: "<|end|>" }, // harmony analysis (rendered)
 	{ open: "<|channel|>analysis<|message|>", close: "<|end|>" }, // harmony analysis (bare leak)
@@ -29,6 +30,8 @@ export class ThinkingInbandScanner implements InbandScanner {
 	#buffer = "";
 	#closeTag = "";
 	#thinking = "";
+	/** Fence-aware close-matcher while inside a ` ```thinking ` block; undefined otherwise. */
+	#fenced: FencedThinkingScanner | undefined;
 
 	feed(text: string): InbandScanEvent[] {
 		if (text.length === 0) return [];
@@ -52,7 +55,22 @@ export class ThinkingInbandScanner implements InbandScanner {
 
 	#consume(final: boolean): InbandScanEvent[] {
 		const events: InbandScanEvent[] = [];
-		while (this.#buffer.length > 0) {
+		for (;;) {
+			if (this.#fenced) {
+				// Run even with an empty buffer so a held partial close flushes on final.
+				const result = this.#fenced.feed(this.#buffer, final);
+				this.#buffer = result.closed ? result.rest : "";
+				this.#emitThinking(result.thinking, events);
+				if (result.closed || final) {
+					events.push({ type: "thinkingEnd", thinking: this.#thinking });
+					this.#thinking = "";
+					this.#closeTag = "";
+					this.#fenced = undefined;
+				}
+				if (this.#fenced) break;
+				continue;
+			}
+			if (this.#buffer.length === 0) break;
 			if (this.#closeTag) {
 				const close = this.#buffer.indexOf(this.#closeTag);
 				if (close === -1) {
@@ -81,6 +99,7 @@ export class ThinkingInbandScanner implements InbandScanner {
 			this.#buffer = this.#buffer.slice(tag.index + tag.open.length);
 			this.#closeTag = tag.close;
 			this.#thinking = "";
+			if (tag.fenced) this.#fenced = new FencedThinkingScanner();
 			events.push({ type: "thinkingStart" });
 		}
 		return events;

package/src/providers/transform-messages.ts

@@ -126,18 +126,20 @@ function deduplicateToolCallIds(
 }
 
 /**
- * Drop assistant `toolCall` blocks whose `name` is empty or whitespace-only,
+ * Drop assistant `toolCall` blocks whose `id` or `name` is empty / whitespace-only,
  * the `toolResult` messages they point at, and any assistant turn that has no
  * replayable content left.
  *
- * Models occasionally emit `{ "name": "", "arguments": "{}" }` (observed:
- * GLM-5.2 + thinking on long turns, #3458). The agent loop rejects the call
- * at execution time with `Tool  not found`, but the malformed block and its
- * error tool-result stay in `currentContext.messages`, so every subsequent
- * request replays them. Every provider validates the function name —
- * Anthropic 400s on `tool_use.name` (alongside an orphan `tool_result`),
- * OpenAI Chat Completions 400s on `tool_calls[i].function.name` — wedging the
- * session in a 400 loop until manual `/clear`.
+ * Models occasionally emit malformed calls such as `{ "name": "", "arguments": "{}" }`
+ * (observed: GLM-5.2 + thinking on long turns, #3458) or a structurally valid
+ * `toolCall` whose provider/native passthrough id never materialized (`id: ""`).
+ * The agent loop rejects or skips these at execution time, but the malformed block
+ * and its error tool-result can stay in `currentContext.messages`, so every
+ * subsequent request replays them. Every provider validates the call shape —
+ * Anthropic 400s on `tool_use.name` / `tool_use.id` (alongside an orphan
+ * `tool_result`), OpenAI Chat Completions 400s on malformed
+ * `tool_calls[i].function.*` — wedging the session in a 400 loop until manual
+ * `/clear`.
  *
  * Run before any other transform so the rest of the pipeline never sees a
  * malformed call. Idempotent: a re-run on an already-sanitized list returns
@@ -147,13 +149,21 @@ function isMalformedToolCallName(name: string | undefined): boolean {
 	return !name || name.trim().length === 0;
 }
 
+function isMalformedToolCallId(id: string | undefined): boolean {
+	return !id || id.trim().length === 0;
+}
+
+function isMalformedToolCall(block: { id: string; name: string }): boolean {
+	return isMalformedToolCallId(block.id) || isMalformedToolCallName(block.name);
+}
+
 function sanitizeMalformedToolCalls(messages: Message[]): Message[] {
 	// Fast path: skip the rewrite entirely when nothing is malformed.
 	let hasMalformed = false;
 	outer: for (const msg of messages) {
 		if (msg.role !== "assistant") continue;
 		for (const block of msg.content) {
-			if (block.type === "toolCall" && isMalformedToolCallName(block.name)) {
+			if (block.type === "toolCall" && isMalformedToolCall(block)) {
 				hasMalformed = true;
 				break outer;
 			}
@@ -179,7 +189,7 @@ function sanitizeMalformedToolCalls(messages: Message[]): Message[] {
 			const filtered: AssistantMessage["content"] = [];
 			for (const block of msg.content) {
 				if (block.type === "toolCall") {
-					const malformed = isMalformedToolCallName(block.name);
+					const malformed = isMalformedToolCall(block);
 					const queue = dropQueues.get(block.id);
 					if (queue) queue.push(malformed);
 					else dropQueues.set(block.id, [malformed]);
@@ -283,9 +293,10 @@ export function transformMessages<TApi extends Api>(
 	duplicateToolCallIdSuffixPrefix = "_dup",
 	targetCompat: Model<TApi>["compat"] = model.compat,
 ): Message[] {
-	// Drop assistant `toolCall` blocks with empty/whitespace `name` (and their
-	// matched `toolResult` messages) before anything else looks at the history.
-	// Replays of these would 400 every provider — see `sanitizeMalformedToolCalls`.
+	// Drop assistant `toolCall` blocks with empty/whitespace `id` or `name`
+	// (and their matched `toolResult` messages) before anything else looks at
+	// the history. Replays of these would 400 every provider — see
+	// `sanitizeMalformedToolCalls`.
 	messages = sanitizeMalformedToolCalls(messages);
 
 	// Build a map of original tool call IDs to normalized IDs

package/src/utils/thinking-loop.ts

@@ -287,12 +287,17 @@ export 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 const GEMINI_HEADER_RUNAWAY_THRESHOLD = 10;
+export const GEMINI_HEADER_RUNAWAY_THRESHOLD = 24;
 
 /**
  * True when a single trimmed line is a Gemini reasoning-summary title: a markdown