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

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 hasNamedNativeToolCall(source: StreamingToolCall | undefined): source is StreamingToolCall {
+	return source !== undefined && source.name.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,33 @@ 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`.
+	nativeToolStart(srcIndex: number, source: StreamingToolCall | undefined): void {
+		if (this.#stopped || !hasNamedNativeToolCall(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 && hasNamedNativeToolCall(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 +243,7 @@ class InbandStreamProjector {
 		if (this.#stopped) return;
 		const entry = this.#nativeBlocks.get(srcIndex);
 		if (entry) {
-			Object.assign(entry.block, toolCall);
+			syncToolCall(entry.block, toolCall);
 			if (this.#emitEvents)
 				this.#out.push({
 					type: "toolcall_end",
@@ -210,11 +257,11 @@ class InbandStreamProjector {
 		// 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;
+		if (!hasNamedNativeToolCall(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/index.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/src/providers/cursor.ts

@@ -102,7 +102,13 @@ import {
 	WriteSuccessSchema,
 } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
-import { $env, parseJsonWithRepair, parseStreamingJson, sanitizeText } from "@oh-my-pi/pi-utils";
+import {
+	$env,
+	parseJsonWithRepair,
+	parseStreamingJson,
+	parseStreamingJsonThrottled,
+	sanitizeText,
+} from "@oh-my-pi/pi-utils";
 import * as AIError from "../error";
 import type {
 	Api,
@@ -129,6 +135,7 @@ import {
 	clearStreamingPartialJson,
 	kStreamingBlockIndex,
 	kStreamingBlockKind,
+	kStreamingLastParseLen,
 	kStreamingPartialJson,
 } from "../utils/block-symbols";
 import { deterministicUuid } from "../utils/deterministic-id";
@@ -620,6 +627,7 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 export type ToolCallState = ToolCall & {
 	[kStreamingBlockIndex]: number;
 	[kStreamingPartialJson]?: string;
+	[kStreamingLastParseLen]?: number;
 	[kStreamingBlockKind]: "mcp" | "todo";
 };
 
@@ -2105,8 +2113,16 @@ export function processInteractionUpdate(
 			if (chunk.length === 0) {
 				return;
 			}
-			state.currentToolCall[kStreamingPartialJson] = current + chunk;
-			state.currentToolCall.arguments = parseStreamingJson(state.currentToolCall[kStreamingPartialJson]);
+			const nextBuffer = current + chunk;
+			state.currentToolCall[kStreamingPartialJson] = nextBuffer;
+			// Throttle mid-stream parses to keep total parse work O(N) instead of O(N²)
+			// in the argument-buffer length; the authoritative full parse runs in
+			// `toolCallCompleted` (mcp branch) and the fallback end-of-stream path.
+			const throttled = parseStreamingJsonThrottled(nextBuffer, state.currentToolCall[kStreamingLastParseLen] ?? 0);
+			if (throttled) {
+				state.currentToolCall.arguments = throttled.value;
+				state.currentToolCall[kStreamingLastParseLen] = throttled.parsedLen;
+			}
 			const idx = output.content.indexOf(state.currentToolCall);
 			stream.push({ type: "toolcall_delta", contentIndex: idx, delta: chunk, partial: output });
 		}
@@ -2114,6 +2130,12 @@ export function processInteractionUpdate(
 		if (state.currentToolCall) {
 			const toolCall = update.message.value.toolCall;
 			if (state.currentToolCall[kStreamingBlockKind] === "mcp") {
+				// Authoritative full parse of the accumulated argument buffer; the delta
+				// path throttles mid-stream parses, so `arguments` may lag the buffer.
+				const partial = state.currentToolCall[kStreamingPartialJson];
+				if (partial !== undefined) {
+					state.currentToolCall.arguments = parseStreamingJson(partial);
+				}
 				const decodedArgs = decodeMcpArgsMap(toolCall?.mcpToolCall?.args?.args);
 				state.currentToolCall.arguments = mergeCursorMcpToolCallArgs(
 					state.currentToolCall.arguments as Record<string, unknown> | undefined,

package/src/providers/devin.ts

@@ -28,7 +28,7 @@ import {
 	StopReason,
 } from "@oh-my-pi/pi-catalog/discovery/devin-gen/exa/codeium_common_pb/codeium_common_pb";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
-import { logger, parseStreamingJson } from "@oh-my-pi/pi-utils";
+import { logger, parseStreamingJson, parseStreamingJsonThrottled } from "@oh-my-pi/pi-utils";
 import * as AIError from "../error";
 import type {
 	Api,
@@ -105,6 +105,11 @@ export const streamDevin: StreamFunction<"devin-agent"> = (
 		// accumulated per id (kept out of the content object so finalized tool calls stay clean).
 		const toolBlocks = new Map<string, ToolCall>();
 		const toolPartialJson = new Map<string, string>();
+		// Last-parsed argument-buffer length per tool-call id — bounds the
+		// mid-stream parse work to O(N) via `parseStreamingJsonThrottled`; the
+		// authoritative final parse still runs unconditionally in the toolcall_end
+		// loop below.
+		const toolLastParseLen = new Map<string, number>();
 		let activeToolCallId: string | undefined;
 		let latestStopReason = StopReason.UNSPECIFIED;
 
@@ -279,7 +284,11 @@ export const streamDevin: StreamFunction<"devin-agent"> = (
 								: previousJson + tc.argumentsJson;
 							const delta = accumulated.slice(previousJson.length);
 							toolPartialJson.set(toolCallId, accumulated);
-							block.arguments = parseStreamingJson(accumulated);
+							const throttled = parseStreamingJsonThrottled(accumulated, toolLastParseLen.get(toolCallId) ?? 0);
+							if (throttled) {
+								block.arguments = throttled.value;
+								toolLastParseLen.set(toolCallId, throttled.parsedLen);
+							}
 							stream.push({
 								type: "toolcall_delta",
 								contentIndex: output.content.indexOf(block),

package/src/providers/pi-native-client.ts

@@ -26,7 +26,9 @@ import type {
 	Model,
 	SimpleStreamOptions,
 } from "../types";
+import { createAbortSourceTracker } from "../utils/abort";
 import { AssistantMessageEventStream } from "../utils/event-stream";
+import { getStreamFirstEventTimeoutMs, getStreamIdleTimeoutMs, iterateWithIdleTimeout } from "../utils/idle-iterator";
 
 /**
  * Fields that must not cross the wire — either non-serializable (functions,
@@ -47,6 +49,13 @@ const NON_WIRE_KEYS = new Set<keyof SimpleStreamOptions>([
 	"cursorOnToolResult",
 	"providerSessionState",
 ]);
+const PI_NATIVE_STREAM_IDLE_TIMEOUT_ERROR = "pi-native stream stalled while waiting for the next event";
+const PI_NATIVE_STREAM_FIRST_EVENT_TIMEOUT_ERROR = "pi-native stream timed out while waiting for the first event";
+
+function isPiNativeProgressEvent(event: unknown): boolean {
+	if (typeof event !== "object" || event === null || !("type" in event)) return true;
+	return event.type !== "start";
+}
 
 function buildWireOptions(options: SimpleStreamOptions | undefined): Record<string, unknown> {
 	if (!options) return {};
@@ -134,7 +143,8 @@ export function streamPiNative<TApi extends Api>(
 	const stream = new AssistantMessageEventStream();
 
 	void (async () => {
-		const signal = options?.signal;
+		const callerSignal = options?.signal;
+		const abortTracker = createAbortSourceTracker(callerSignal);
 		// Abort propagation: cancel the response body when the caller's signal
 		// fires. Mirror `streamProxy`'s shape — explicit listener + finally
 		// cleanup — so we don't leak listeners on the long-running case.
@@ -143,12 +153,16 @@ export function streamPiNative<TApi extends Api>(
 			const body = response?.body;
 			if (body) body.cancel("Request aborted by caller").catch(() => {});
 		};
-		if (signal) {
-			if (signal.aborted) {
-				stream.fail(signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason ?? "aborted")));
+		if (callerSignal) {
+			if (callerSignal.aborted) {
+				stream.fail(
+					callerSignal.reason instanceof Error
+						? callerSignal.reason
+						: new Error(String(callerSignal.reason ?? "aborted")),
+				);
 				return;
 			}
-			signal.addEventListener("abort", onAbort, { once: true });
+			callerSignal.addEventListener("abort", onAbort, { once: true });
 		}
 
 		try {
@@ -165,7 +179,7 @@ export function streamPiNative<TApi extends Api>(
 				stream: true,
 			});
 
-			response = await fetchImpl(url, { method: "POST", headers, body, signal });
+			response = await fetchImpl(url, { method: "POST", headers, body, signal: abortTracker.requestSignal });
 			if (!response.ok) {
 				stream.fail(await decodeGatewayError(response));
 				return;
@@ -177,11 +191,25 @@ export function streamPiNative<TApi extends Api>(
 				return;
 			}
 
-			let sawTerminal = false;
-			for await (const event of readSseJson<AssistantMessageEvent>(
+			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getStreamIdleTimeoutMs();
+			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs);
+			const source = readSseJson<AssistantMessageEvent>(
 				response.body as ReadableStream<Uint8Array>,
-				signal,
-			)) {
+				abortTracker.requestSignal,
+			);
+			const watchedSource = iterateWithIdleTimeout(source, {
+				idleTimeoutMs,
+				firstItemTimeoutMs: firstEventTimeoutMs,
+				errorMessage: PI_NATIVE_STREAM_IDLE_TIMEOUT_ERROR,
+				firstItemErrorMessage: PI_NATIVE_STREAM_FIRST_EVENT_TIMEOUT_ERROR,
+				onIdle: () =>
+					abortTracker.abortLocally(new AIError.StreamTimeoutError(PI_NATIVE_STREAM_IDLE_TIMEOUT_ERROR)),
+				onFirstItemTimeout: () =>
+					abortTracker.abortLocally(new AIError.StreamTimeoutError(PI_NATIVE_STREAM_FIRST_EVENT_TIMEOUT_ERROR)),
+				isProgressItem: isPiNativeProgressEvent,
+			});
+			let sawTerminal = false;
+			for await (const event of watchedSource) {
 				if (event.type === "done" || event.type === "error") sawTerminal = true;
 				stream.push(event);
 				// `stream.push` resolves `.result()` on `done`/`error`; subsequent
@@ -195,7 +223,7 @@ export function streamPiNative<TApi extends Api>(
 				// so awaiters of `.result()` resolve instead of hanging forever.
 				// Matches the gateway's own defensive fallback in
 				// `pi-native-server.encodeStream`.
-				const aborted = signal?.aborted === true;
+				const aborted = abortTracker.wasCallerAbort();
 				const partial = makeSyntheticAssistant(model as Model<Api>);
 				if (aborted) {
 					partial.stopReason = "aborted";
@@ -210,7 +238,7 @@ export function streamPiNative<TApi extends Api>(
 		} catch (err) {
 			stream.fail(err);
 		} finally {
-			if (signal) signal.removeEventListener("abort", onAbort);
+			if (callerSignal) callerSignal.removeEventListener("abort", onAbort);
 		}
 	})();
 

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/leaked-thinking-stream.ts

@@ -22,9 +22,31 @@
  */
 
 import type { AssistantMessage, TextContent, ThinkingContent, ToolCall } from "../types";
+import {
+	clearStreamingPartialJson,
+	getStreamingPartialJson,
+	type StreamingPartialJsonCarrier,
+	setStreamingPartialJson,
+} from "./block-symbols";
 import { AssistantMessageEventStream } from "./event-stream";
 import { StreamMarkupHealing, type StreamMarkupHealingEvent } from "./stream-markup-healing";
 
+type StreamingToolCall = ToolCall & StreamingPartialJsonCarrier;
+
+function cloneToolCall(source: StreamingToolCall): StreamingToolCall {
+	const block: StreamingToolCall = { ...source, arguments: source.arguments };
+	const partialJson = getStreamingPartialJson(source);
+	if (partialJson !== undefined) setStreamingPartialJson(block, partialJson);
+	return block;
+}
+
+function syncToolCall(target: StreamingToolCall, source: StreamingToolCall): void {
+	Object.assign(target, source);
+	const partialJson = getStreamingPartialJson(source);
+	if (partialJson === undefined) clearStreamingPartialJson(target);
+	else setStreamingPartialJson(target, partialJson);
+}
+
 /**
  * Wrap a provider stream so leaked reasoning fences are healed into thinking
  * blocks live, for every provider. Returns a new stream that re-projects the
@@ -55,12 +77,14 @@ export function wrapLeakedThinkingStream(inner: AssistantMessageEventStream): As
 					case "toolcall_start": {
 						projector ??= new LeakedThinkingProjector(out, event.partial);
 						const block = event.partial.content[event.contentIndex];
-						projector.toolStart(event.contentIndex, block?.type === "toolCall" ? block.name : "");
+						projector.toolStart(event.contentIndex, block?.type === "toolCall" ? block : undefined);
 						break;
 					}
-					case "toolcall_delta":
-						projector?.toolDelta(event.contentIndex, event.delta);
+					case "toolcall_delta": {
+						const block = event.partial.content[event.contentIndex];
+						projector?.toolDelta(event.contentIndex, event.delta, block?.type === "toolCall" ? block : undefined);
 						break;
+					}
 					case "toolcall_end":
 						projector?.toolEnd(event.contentIndex, event.toolCall);
 						break;
@@ -111,7 +135,7 @@ class LeakedThinkingProjector {
 	/** Latest non-undefined text signature seen, stamped onto held-back text flushed later. */
 	#lastTextSignature: string | undefined;
 	/** Forwarded native tool calls, keyed by the inner stream's `contentIndex`. */
-	#toolBlocks = new Map<number, { index: number }>();
+	#toolBlocks = new Map<number, { index: number; block: StreamingToolCall }>();
 
 	constructor(out: AssistantMessageEventStream, seed: AssistantMessage) {
 		this.#out = out;
@@ -136,29 +160,39 @@ class LeakedThinkingProjector {
 	}
 
 	/** Forward a native tool call's start, releasing any held-back text first. */
-	toolStart(srcIndex: number, name: string): void {
+	toolStart(srcIndex: number, source: StreamingToolCall | undefined): void {
+		if (!source) return;
 		this.#apply(this.#healer.flushEvents(), this.#lastTextSignature);
 		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.#toolBlocks.set(srcIndex, { index });
+		this.#toolBlocks.set(srcIndex, { index, block });
 		this.#out.push({ type: "toolcall_start", contentIndex: index, partial: this.#partial });
 	}
 
-	toolDelta(srcIndex: number, delta: string): void {
-		const entry = this.#toolBlocks.get(srcIndex);
+	toolDelta(srcIndex: number, delta: string, source: StreamingToolCall | undefined): void {
+		let entry = this.#toolBlocks.get(srcIndex);
+		if (!entry && source) {
+			this.toolStart(srcIndex, source);
+			entry = this.#toolBlocks.get(srcIndex);
+		}
 		if (!entry) return;
+		if (source) syncToolCall(entry.block, source);
 		this.#out.push({ type: "toolcall_delta", contentIndex: entry.index, delta, partial: this.#partial });
 	}
 
 	toolEnd(srcIndex: number, toolCall: ToolCall): void {
 		const entry = this.#toolBlocks.get(srcIndex);
 		if (entry) {
-			const block = this.#partial.content[entry.index] as ToolCall;
-			Object.assign(block, toolCall);
-			this.#out.push({ type: "toolcall_end", contentIndex: entry.index, toolCall: block, partial: this.#partial });
+			syncToolCall(entry.block, toolCall);
+			this.#out.push({
+				type: "toolcall_end",
+				contentIndex: entry.index,
+				toolCall: entry.block,
+				partial: this.#partial,
+			});
 			this.#toolBlocks.delete(srcIndex);
 			return;
 		}
@@ -166,7 +200,7 @@ class LeakedThinkingProjector {
 		this.#apply(this.#healer.flushEvents(), this.#lastTextSignature);
 		this.#closeText();
 		this.#closeThinking();
-		const block: ToolCall = { ...toolCall };
+		const block = cloneToolCall(toolCall);
 		this.#partial.content.push(block);
 		const index = this.#partial.content.length - 1;
 		this.#out.push({ type: "toolcall_start", contentIndex: index, partial: this.#partial });

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