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

package/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 ## [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
+
+- Added `OAuthCallbackFlowOptions.allowPortFallback` to allow disabling random-port fallback, enabling strict port enforcement and early configuration errors for OAuth flows with static redirect URIs.
+
+### Changed
+
+- Improved `OAuthCallbackFlow` port conflict error messages to include the busy port, configured redirect URI, and actionable remediation steps.
+
+### Fixed
+
+- Fixed an issue where malformed tool-call JSON from local Ollama or llama.cpp models was incorrectly retried as generic 500 errors, now surfacing a clear recovery message.
+- Fixed a race condition in OAuth callback flows where abort signals triggered before the callback listener was registered were ignored.
+
 ## [16.2.7] - 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/error/flags.d.ts

@@ -23,6 +23,13 @@ export declare const Flag: {
 export type Flag = (typeof Flag)[keyof typeof Flag];
 export declare const STREAM_READ_ERROR_PATTERN: RegExp;
 export declare const TRANSIENT_TRANSPORT_PATTERN: RegExp;
+/**
+ * Local llama.cpp / Ollama deterministic tool-call argument JSON parse failure.
+ * The model emitted invalid JSON in a tool call and the server returned HTTP 500
+ * with this exact text — replaying the same prompt yields the same malformed
+ * output, so callers strip {@link Flag.Transient} when this matches.
+ */
+export declare const LLAMA_CPP_TOOL_CALL_PARSE_PATTERN: RegExp;
 /** Whether an OAuth refresh error message means the grant is definitively dead. */
 export declare function isOAuthExpiry(errorMessage: string): boolean;
 export declare function create(...flags: number[]): number;

package/dist/types/error/format.d.ts

@@ -5,7 +5,7 @@ export interface FormatMessageOptions {
     rawRequestDump?: RawHttpRequestDump;
     /** Captured non-2xx response body, appended to the message when available. */
     capturedErrorResponse?: CapturedHttpErrorResponse;
-    /** Provider id; `"github-copilot"` triggers the copilot message rewrite. */
+    /** Provider id; gates provider-specific user-facing rewrites. */
     provider?: string;
 }
 /**

package/dist/types/registry/oauth/callback-server.d.ts

@@ -9,6 +9,20 @@ export interface OAuthCallbackFlowOptions {
     callbackHostname?: string;
     /** Exact redirect URI advertised to the provider; disables port fallback. */
     redirectUri?: string;
+    /**
+     * Whether the flow may bind to a random port when {@link preferredPort} is
+     * unavailable. Defaults to `true` so historical AI-provider flows (which
+     * pick uncommon ports and tolerate any loopback callback) keep working.
+     *
+     * Set to `false` for providers that validate the redirect URI against a
+     * registered callback — silently advertising a random-port URI would be
+     * rejected by the authorization server, leaving the browser on an opaque
+     * 500 page and the local callback waiting until the 5-minute timeout fires.
+     * With fallback disabled, {@link OAuthCallbackFlow.login} throws a
+     * {@link AIError.ConfigurationError} immediately so the caller can surface
+     * an actionable message before opening the browser.
+     */
+    allowPortFallback?: boolean;
 }
 /**
  * Abstract base class for OAuth flows with local callback servers.
@@ -20,6 +34,7 @@ export declare abstract class OAuthCallbackFlow {
     callbackPath: string;
     callbackHostname: string;
     redirectUri?: string;
+    allowPortFallback: boolean;
     constructor(ctrl: OAuthController, preferredPortOrOptions: number | OAuthCallbackFlowOptions, callbackPath?: string);
     /**
      * Generate provider-specific authorization URL.

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.8",
+	"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.8",
-		"@oh-my-pi/pi-utils": "16.2.8",
-		"@oh-my-pi/pi-wire": "16.2.8",
+		"@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/error/flags.ts

@@ -94,6 +94,14 @@ const MALFORMED_FUNCTION_CALL_PATTERN = /\bmalformed.?function.?call\b/i;
 const PROVIDER_FINISH_ERROR_PATTERN = /\bProvider (?:returned error finish_reason|finish_reason:\s*error)\b/i;
 const STALE_RESPONSE_ITEM_PATTERNS = [/\bItem with id ['"][^'"]+['"] not found\.?/i, /previous[ _]?response/i] as const;
 const STALE_RESPONSE_ITEM_DETAIL_PATTERN = /not[ _]?found|invalid|expired|stale|zero[ _-]?data[ _-]?retention/i;
+/**
+ * Local llama.cpp / Ollama deterministic tool-call argument JSON parse failure.
+ * The model emitted invalid JSON in a tool call and the server returned HTTP 500
+ * with this exact text — replaying the same prompt yields the same malformed
+ * output, so callers strip {@link Flag.Transient} when this matches.
+ */
+export const LLAMA_CPP_TOOL_CALL_PARSE_PATTERN =
+	/failed to parse tool call arguments as json|\[json\.exception\.parse_error\.101\]/i;
 
 // Copilot routing flap: HTTP 400 `model_not_supported` (structural code on the
 // error, also surfaced in text). Treated as transient — a retry usually lands
@@ -441,7 +449,13 @@ export function classifyMessage(message: {
 	const currentStatus = message.errorStatus ?? statusFromId(existingId);
 	const textId = classifyText(message.errorMessage, currentStatus, message.api);
 
-	const kinds = ((existingId ?? 0) | textId) & KIND_MASK;
+	let kinds = ((existingId ?? 0) | textId) & KIND_MASK;
+	if (message.errorMessage && LLAMA_CPP_TOOL_CALL_PARSE_PATTERN.test(message.errorMessage)) {
+		// Deterministic local-model tool-call JSON parse failure: HTTP 500 is misleading
+		// because the same prompt reproduces the same malformed output, so the agent-level
+		// auto-retry would loop. Strip Transient so the recovery message surfaces immediately.
+		kinds &= ~Flag.Transient;
+	}
 	const id = kinds !== 0 ? create(kinds) : (statusFromId(textId) ?? statusFromId(existingId) ?? currentStatus ?? 0);
 
 	message.errorId = id;

package/src/error/format.ts

@@ -5,6 +5,12 @@ import {
 	rewriteCopilotError,
 } from "../utils/http-inspector";
 import { formatErrorMessageWithRetryAfter } from "../utils/retry-after";
+import { LLAMA_CPP_TOOL_CALL_PARSE_PATTERN } from "./flags";
+
+function rewriteOllamaToolCallJsonError(message: string): string {
+	if (!LLAMA_CPP_TOOL_CALL_PARSE_PATTERN.test(message)) return message;
+	return `Local Ollama model emitted malformed tool-call JSON and llama.cpp rejected it (HTTP 500). This is usually a deterministic model-output failure after context degradation, not a transient server outage; reload the model or reduce context, then retry.\n${message}`;
+}
 
 /** Inputs that steer {@link formatMessage}'s formatter selection. */
 export interface FormatMessageOptions {
@@ -12,7 +18,7 @@ export interface FormatMessageOptions {
 	rawRequestDump?: RawHttpRequestDump;
 	/** Captured non-2xx response body, appended to the message when available. */
 	capturedErrorResponse?: CapturedHttpErrorResponse;
-	/** Provider id; `"github-copilot"` triggers the copilot message rewrite. */
+	/** Provider id; gates provider-specific user-facing rewrites. */
 	provider?: string;
 }
 
@@ -32,5 +38,8 @@ export async function formatMessage(error: unknown, opts: FormatMessageOptions =
 	if (opts.provider === "github-copilot") {
 		message = rewriteCopilotError(message, error, opts.provider);
 	}
+	if (opts.provider === "ollama") {
+		message = rewriteOllamaToolCallJsonError(message);
+	}
 	return message;
 }

package/src/providers/ollama.ts

@@ -323,6 +323,10 @@ function createChatBody(model: Model<"ollama-chat">, context: Context, options:
 	};
 }
 
+function shouldRetryOllamaResponse(response: Response, bodyText: string): boolean {
+	return response.status < 500 || !AIError.LLAMA_CPP_TOOL_CALL_PARSE_PATTERN.test(bodyText);
+}
+
 async function captureHttpErrorResponse(response: Response): Promise<CapturedHttpErrorResponse> {
 	let bodyText: string | undefined;
 	let bodyJson: unknown;
@@ -598,6 +602,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 					body: JSON.stringify(body),
 					signal: watchdog.signal,
 					defaultDelayMs: OLLAMA_RETRY_DELAYS_MS,
+					shouldRetryResponse: shouldRetryOllamaResponse,
 					fetch: options.fetch,
 					timeout: false,
 				});
@@ -747,6 +752,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			}
 			const result = await AIError.finalize(error, {
 				api: model.api,
+				provider: model.provider,
 				signal: options.signal,
 				rawRequestDump,
 				capturedErrorResponse,

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/registry/oauth/callback-server.ts

@@ -26,6 +26,20 @@ export interface OAuthCallbackFlowOptions {
 	callbackHostname?: string;
 	/** Exact redirect URI advertised to the provider; disables port fallback. */
 	redirectUri?: string;
+	/**
+	 * Whether the flow may bind to a random port when {@link preferredPort} is
+	 * unavailable. Defaults to `true` so historical AI-provider flows (which
+	 * pick uncommon ports and tolerate any loopback callback) keep working.
+	 *
+	 * Set to `false` for providers that validate the redirect URI against a
+	 * registered callback — silently advertising a random-port URI would be
+	 * rejected by the authorization server, leaving the browser on an opaque
+	 * 500 page and the local callback waiting until the 5-minute timeout fires.
+	 * With fallback disabled, {@link OAuthCallbackFlow.login} throws a
+	 * {@link AIError.ConfigurationError} immediately so the caller can surface
+	 * an actionable message before opening the browser.
+	 */
+	allowPortFallback?: boolean;
 }
 
 /**
@@ -37,6 +51,7 @@ export abstract class OAuthCallbackFlow {
 	callbackPath: string;
 	callbackHostname: string;
 	redirectUri?: string;
+	allowPortFallback: boolean;
 	#callbackResolve?: (result: CallbackResult) => void;
 	#callbackReject?: (error: string) => void;
 
@@ -50,6 +65,7 @@ export abstract class OAuthCallbackFlow {
 			this.preferredPort = preferredPortOrOptions;
 			this.callbackPath = callbackPath;
 			this.callbackHostname = DEFAULT_HOSTNAME;
+			this.allowPortFallback = true;
 			return;
 		}
 
@@ -57,6 +73,7 @@ export abstract class OAuthCallbackFlow {
 		this.callbackPath = preferredPortOrOptions.callbackPath ?? CALLBACK_PATH;
 		this.callbackHostname = preferredPortOrOptions.callbackHostname ?? DEFAULT_HOSTNAME;
 		this.redirectUri = preferredPortOrOptions.redirectUri;
+		this.allowPortFallback = preferredPortOrOptions.allowPortFallback ?? true;
 	}
 
 	/**
@@ -87,18 +104,29 @@ export abstract class OAuthCallbackFlow {
 			.join("");
 	}
 
+	#loginCancelledError(): AIError.LoginCancelledError {
+		return new AIError.LoginCancelledError(`OAuth callback cancelled: ${this.ctrl.signal?.reason}`);
+	}
+
+	#throwIfCancelled(): void {
+		if (this.ctrl.signal?.aborted) throw this.#loginCancelledError();
+	}
+
 	/**
 	 * Execute the OAuth login flow.
 	 */
 	async login(): Promise<OAuthCredentials> {
 		const state = this.generateState();
+		this.#throwIfCancelled();
 
 		// Start callback server first to get actual redirect URI
 		const { server, redirectUri } = await this.#startCallbackServer(state);
 
 		try {
+			this.#throwIfCancelled();
 			// Generate auth URL with the ACTUAL redirect URI (may differ from expected if port was busy)
 			const { url: authUrl, instructions } = await this.generateAuthUrl(state, redirectUri);
+			this.#throwIfCancelled();
 
 			// Notify controller that auth is ready
 			this.ctrl.onAuth?.({ url: authUrl, instructions });
@@ -106,6 +134,7 @@ export abstract class OAuthCallbackFlow {
 
 			// Wait for callback or manual input
 			const { code } = await this.#waitForCallback(state);
+			this.#throwIfCancelled();
 
 			this.ctrl.onProgress?.("Exchanging authorization code for tokens...");
 
@@ -126,10 +155,17 @@ export abstract class OAuthCallbackFlow {
 			}
 			const redirectUri = `http://${this.callbackHostname}:${this.preferredPort}${this.callbackPath}`;
 			return { server, redirectUri };
-		} catch {
+		} catch (cause) {
 			if (this.redirectUri) {
 				throw new AIError.ConfigurationError(
-					`OAuth callback port ${this.preferredPort} unavailable; cannot fall back to a random port when oauth.redirectUri is set`,
+					`OAuth callback port ${this.preferredPort} is in use, but oauth.redirectUri (${this.redirectUri}) requires this exact port. Free port ${this.preferredPort} (e.g. stop the process bound to it) and retry, or change oauth.redirectUri to point at an available port.`,
+					{ cause },
+				);
+			}
+			if (!this.allowPortFallback) {
+				throw new AIError.ConfigurationError(
+					`OAuth callback port ${this.preferredPort} is in use. The OAuth provider validates redirect URIs against its registered callback, so falling back to a random port would be rejected. Free port ${this.preferredPort} (e.g. stop the process bound to it) and retry, or set oauth.callbackPort/oauth.redirectUri to a port the provider has registered.`,
+					{ cause },
 				);
 			}
 			const server = this.#createServer(0, expectedState);
@@ -208,17 +244,18 @@ export abstract class OAuthCallbackFlow {
 	#waitForCallback(expectedState: string): Promise<CallbackResult> {
 		const timeoutSignal = AbortSignal.timeout(DEFAULT_TIMEOUT);
 		const signal = this.ctrl.signal ? AbortSignal.any([this.ctrl.signal, timeoutSignal]) : timeoutSignal;
+		if (signal.aborted) return Promise.reject(this.#loginCancelledError());
 
-		const callbackPromise = new Promise<CallbackResult>((resolve, reject) => {
-			this.#callbackResolve = resolve;
-			this.#callbackReject = reject;
+		const callback = Promise.withResolvers<CallbackResult>();
+		this.#callbackResolve = callback.resolve;
+		this.#callbackReject = callback.reject;
 
-			signal.addEventListener("abort", () => {
-				this.#callbackResolve = undefined;
-				this.#callbackReject = undefined;
-				reject(new AIError.LoginCancelledError(`OAuth callback cancelled: ${signal.reason}`));
-			});
+		signal.addEventListener("abort", () => {
+			this.#callbackResolve = undefined;
+			this.#callbackReject = undefined;
+			callback.reject(new AIError.LoginCancelledError(`OAuth callback cancelled: ${signal.reason}`));
 		});
+		const callbackPromise = callback.promise;
 
 		// Manual input race (if supported)
 		if (this.ctrl.onManualCodeInput) {

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