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

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [16.2.13] - 2026-07-01
+
+### Fixed
+
+- Fixed pre-5.4 OpenAI Codex models (`gpt-5.1-codex`, `gpt-5.3-codex`, `gpt-5.3-codex-spark`) rejecting requests with `Unsupported parameter: 'reasoning.summary' is not supported with this model` by gating `reasoning.summary` behind the same gpt-5.4 wire floor as `reasoning.context: "all_turns"`.
+
+## [16.2.12] - 2026-07-01
+
+### Changed
+
+- Improved streaming performance for Cursor and Devin providers by optimizing mid-stream tool-call argument parsing to prevent UI stalls when handling large payloads.
+
+### Fixed
+
+- Fixed issues with tool call streaming where tool call IDs, partial JSON payloads, or late-arriving IDs could be lost, filtered, or incorrectly initialized.
+- Fixed an issue where stream healing for leaked thinking blocks could replace live tool-call blocks with empty-id placeholders, breaking streamed tool arguments on Anthropic-compatible streams.
+- Fixed an issue where stalled auth-gateway SSE responses could hang indefinitely in pi-native streams by ensuring first-event and idle timeout watchdogs are properly honored.
+- Fixed cross-turn tool-call loops going undetected by adding a guard for consecutive identical tool calls. (#3971)
+
 ## [16.2.11] - 2026-07-01
 
 ### Fixed

package/dist/types/index.d.ts

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

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

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

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

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

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.2.11",
+	"version": "16.2.13",
 	"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.11",
-		"@oh-my-pi/pi-utils": "16.2.11",
-		"@oh-my-pi/pi-wire": "16.2.11",
+		"@oh-my-pi/pi-catalog": "16.2.13",
+		"@oh-my-pi/pi-utils": "16.2.13",
+		"@oh-my-pi/pi-wire": "16.2.13",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/dialect/owned-stream.ts

@@ -67,8 +67,8 @@ function syncToolCall(target: StreamingToolCall, source: StreamingToolCall): voi
 	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;
+function hasNamedNativeToolCall(source: StreamingToolCall | undefined): source is StreamingToolCall {
+	return source !== undefined && source.name.trim().length > 0;
 }
 
 export function parseInbandToolMessage(
@@ -213,12 +213,9 @@ class InbandStreamProjector {
 	// 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.
+	// call until `toolcall_end`.
 	nativeToolStart(srcIndex: number, source: StreamingToolCall | undefined): void {
-		if (this.#stopped || !hasUsableNativeToolCall(source) || this.#toolChannel === "inband") return;
+		if (this.#stopped || !hasNamedNativeToolCall(source) || this.#toolChannel === "inband") return;
 		this.#toolChannel = "native";
 		this.#closeText();
 		this.#closeThinking();
@@ -232,7 +229,7 @@ class InbandStreamProjector {
 	nativeToolDelta(srcIndex: number, delta: string, source: StreamingToolCall | undefined): void {
 		if (this.#stopped) return;
 		let entry = this.#nativeBlocks.get(srcIndex);
-		if (!entry && hasUsableNativeToolCall(source) && this.#toolChannel !== "inband") {
+		if (!entry && hasNamedNativeToolCall(source) && this.#toolChannel !== "inband") {
 			this.nativeToolStart(srcIndex, source);
 			entry = this.#nativeBlocks.get(srcIndex);
 		}
@@ -246,7 +243,7 @@ class InbandStreamProjector {
 		if (this.#stopped) return;
 		const entry = this.#nativeBlocks.get(srcIndex);
 		if (entry) {
-			if (hasUsableNativeToolCall(toolCall)) syncToolCall(entry.block, toolCall);
+			syncToolCall(entry.block, toolCall);
 			if (this.#emitEvents)
 				this.#out.push({
 					type: "toolcall_end",
@@ -257,10 +254,10 @@ class InbandStreamProjector {
 			this.#nativeBlocks.delete(srcIndex);
 			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;
+		// 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 (!hasNamedNativeToolCall(toolCall) || this.#toolChannel === "inband") return;
 		this.#toolChannel = "native";
 		this.#closeText();
 		this.#closeThinking();

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/openai-codex/request-transformer.ts

@@ -1,5 +1,5 @@
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
-import { supportsAllTurnsReasoningContext } from "@oh-my-pi/pi-catalog/identity";
+import { supportsAllTurnsReasoningContext, supportsCodexReasoningSummary } from "@oh-my-pi/pi-catalog/identity";
 import { requireSupportedEffort } from "@oh-my-pi/pi-catalog/model-thinking";
 import type { Api, Model } from "../../types";
 
@@ -85,7 +85,12 @@ function getReasoningConfig(model: Model<Api>, options: CodexRequestOptions): Re
 		effort:
 			options.reasoningEffort === "none" ? "none" : requireSupportedEffort(model, options.reasoningEffort as Effort),
 	};
-	if (options.reasoningSummary !== null) {
+	// `reasoning.summary` is accepted only from gpt-5.4 onward; earlier Codex ids
+	// (gpt-5.1-codex, gpt-5.3-codex, gpt-5.3-codex-spark) reject it with
+	// "Unsupported parameter: 'reasoning.summary' is not supported with this model".
+	// Mirrors the all_turns gate: an explicit summary is suppressed on unsupported
+	// ids, letting the server skip the human-readable summary stream.
+	if (options.reasoningSummary !== null && supportsCodexReasoningSummary(model.id)) {
 		config.summary = options.reasoningSummary ?? "detailed";
 	}
 	return config;

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/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/tool-call-loop-guard.ts

@@ -0,0 +1,107 @@
+import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
+import type { AssistantMessage, ToolCall, ToolResultMessage } from "../types";
+
+const LEGACY_INTENT_FIELD = "__intent";
+const RESULT_SUMMARY_LIMIT = 200;
+const ARGUMENT_SUMMARY_LIMIT = 400;
+
+/** Runtime settings for cross-turn tool-call repetition detection. */
+export interface ToolCallLoopGuardOptions {
+	readonly threshold: number;
+	readonly exemptTools: readonly string[];
+}
+
+/** A completed assistant turn plus the tool results it produced. */
+export interface ToolCallLoopTurn {
+	readonly message: AssistantMessage;
+	readonly toolResults: readonly ToolResultMessage[];
+}
+
+/** Details needed to steer the model away from a repeated tool call. */
+export interface RepeatedToolCallDetection {
+	readonly kind: "repeated_tool_call";
+	readonly toolName: string;
+	readonly count: number;
+	readonly resultSummary: string;
+	readonly argumentsSummary: string;
+}
+
+function canonicalizeToolCallValue(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		return value.map(item => canonicalizeToolCallValue(item));
+	}
+	if (!value || typeof value !== "object") {
+		return value;
+	}
+
+	const input = value as Record<string, unknown>;
+	const output: Record<string, unknown> = {};
+	for (const key of Object.keys(input).sort()) {
+		if (key === INTENT_FIELD || key === LEGACY_INTENT_FIELD) continue;
+		output[key] = canonicalizeToolCallValue(input[key]);
+	}
+	return output;
+}
+
+function summarizeText(text: string, limit: number): string {
+	let summary = text.replace(/\s+/g, " ").trim();
+	if (summary.length > limit) {
+		summary = `${summary.slice(0, limit)}…`;
+	}
+	return summary;
+}
+
+function summarizeToolResult(toolResults: readonly ToolResultMessage[], toolCallId: string): string {
+	const result = toolResults.find(candidate => candidate.toolCallId === toolCallId);
+	if (!result) return "";
+
+	const textParts: string[] = [];
+	for (const block of result.content) {
+		if (block.type === "text") {
+			textParts.push(block.text);
+		}
+	}
+	return summarizeText(textParts.join("\n"), RESULT_SUMMARY_LIMIT);
+}
+
+/** Detects consecutive identical assistant tool calls across model turns. */
+export class ToolCallLoopGuard {
+	#threshold: number;
+	#exemptTools: ReadonlySet<string>;
+	#lastHash: string | undefined;
+	#count = 0;
+
+	constructor(options: ToolCallLoopGuardOptions) {
+		this.#threshold = Math.max(1, Math.trunc(options.threshold));
+		this.#exemptTools = new Set(options.exemptTools);
+	}
+
+	/** Records one completed turn and returns the threshold hit, if any. */
+	recordTurn(turn: ToolCallLoopTurn): RepeatedToolCallDetection | null {
+		const toolCalls = turn.message.content.filter((part): part is ToolCall => part.type === "toolCall");
+		if (toolCalls.length !== 1 || this.#exemptTools.has(toolCalls[0]!.name)) {
+			this.#lastHash = undefined;
+			this.#count = 0;
+			return null;
+		}
+
+		const toolCall = toolCalls[0]!;
+		const canonicalArgs = JSON.stringify(canonicalizeToolCallValue(toolCall.arguments));
+		const hash = `${toolCall.name}:${canonicalArgs}`;
+		if (hash === this.#lastHash) {
+			this.#count++;
+		} else {
+			this.#lastHash = hash;
+			this.#count = 1;
+		}
+
+		if (this.#count !== this.#threshold) return null;
+		return {
+			kind: "repeated_tool_call",
+			toolName: toolCall.name,
+			count: this.#count,
+			resultSummary: summarizeToolResult(turn.toolResults, toolCall.id),
+			argumentsSummary: summarizeText(canonicalArgs, ARGUMENT_SUMMARY_LIMIT),
+		};
+	}
+}