@oh-my-pi/pi-ai 18.9.0 → 18.9.2

package/src/providers/anthropic.ts

@@ -1,5 +1,4 @@
 import * as fs from "node:fs";
-import { scheduler } from "node:timers/promises";
 import * as tls from "node:tls";
 import { isAnthropicSigningProxyUrl, isOfficialAnthropicApiUrl } from "@oh-my-pi/pi-catalog/compat/anthropic";
 import { hostMatchesUrl, isVertexRawPredictUrl } from "@oh-my-pi/pi-catalog/hosts";
@@ -20,6 +19,7 @@ import { NO_AUTH_SENTINEL } from "../auth-retry";
 import { renderDemotedThinking } from "../dialect/demotion";
 import * as AIError from "../error";
 import { parseToolCallArguments } from "../utils/tool-call-arguments";
+import { waitForRetry } from "../utils/retry-wait";
 import { getEnvApiKey } from "../env-api-key";
 import { OUTPUT_FALLBACK_BUFFER } from "../stream";
 import type {
@@ -3582,11 +3582,7 @@ const streamAnthropicOnce = (
 										attempt: fallbackCreditTransientRetries,
 									},
 								);
-								if (options?.providerRetryWait) {
-									await options.providerRetryWait(500, options.signal);
-								} else {
-									await scheduler.wait(500, { signal: options?.signal });
-								}
+								await waitForRetry(options?.providerRetryWait, 500, options?.signal);
 								resetStreamOutputState();
 								continue;
 							}
@@ -3853,11 +3849,7 @@ const streamAnthropicOnce = (
 								attempt: slowWaitAttempts,
 							});
 							if (slowRetry.delayMs > 0) {
-								if (options?.providerRetryWait) {
-									await options.providerRetryWait(slowRetry.delayMs, options.signal);
-								} else {
-									await scheduler.wait(slowRetry.delayMs, { signal: options?.signal });
-								}
+								await waitForRetry(options?.providerRetryWait, slowRetry.delayMs, options?.signal);
 							}
 							resetStreamOutputState();
 							continue;
@@ -3923,11 +3915,7 @@ const streamAnthropicOnce = (
 						throw streamFailure;
 					}
 					const delayMs = headerDelayMs !== undefined ? Math.max(headerDelayMs, backoffDelayMs) : backoffDelayMs;
-					if (options?.providerRetryWait) {
-						await options.providerRetryWait(delayMs, options.signal);
-					} else {
-						await scheduler.wait(delayMs, { signal: options?.signal });
-					}
+					await waitForRetry(options?.providerRetryWait, delayMs, options?.signal);
 					output.content.length = 0;
 					output.model = model.id;
 					output.responseId = undefined;
@@ -4421,6 +4409,17 @@ function applyCacheControlToLastBlock(blocks: ContentBlockParam[], cacheControl:
 	return false;
 }
 
+/** True for a mid-conversation tool-control message (`role: "system"`, tool-change blocks only). */
+function isToolControlMessage(message: MessageParam): boolean {
+	return (
+		message.role === "system" &&
+		typeof message.content !== "string" &&
+		Array.isArray(message.content) &&
+		message.content.length > 0 &&
+		message.content.every(block => block.type === "tool_addition" || block.type === "tool_removal")
+	);
+}
+
 const ANTHROPIC_MAX_BREAKPOINTS = 4;
 const ANTHROPIC_DECIMATION_INTERVAL = 15;
 
@@ -4482,85 +4481,98 @@ function applyPromptCaching(params: MessageCreateParamsStreaming, cacheControl?:
 	// the suffix after it. Turn-scoped `clear_at` messages are absent next
 	// request, so they still truncate the decimation range (ordinals would
 	// shift), but per-call marks no longer freeze the tail.
-	let stableMessageEnd = messageEnd;
-	for (let index = 0; index <= messageEnd; index++) {
-		const message = params.messages[index];
-		if (message && (message.clear_at === "next_user_message" || isPerCallContextMessage(message))) {
-			stableMessageEnd = index - 1;
-			break;
-		}
-	}
-
-	// Decimation counts conversational turns, so it reads the provenance marker
-	// `convertAnthropicMessages` records rather than the wire role. A wire `user`
-	// can also be a serialized `developer` message, a tool_result run, or an
-	// interior `Continue.` pad, none of which advance the user turn ordinal.
-	const userIndices: number[] = [];
-	for (let index = 0; index <= stableMessageEnd; index++) {
-		const message = params.messages[index];
-		if (message && isConversationalUser(message)) {
-			userIndices.push(index);
-		}
-	}
-
-	// Stable historical decimation checkpoint every 15 user turns (15th, 30th, 45th...)
-	const decimationIndices = userIndices.filter((_, ordinal) => (ordinal + 1) % ANTHROPIC_DECIMATION_INTERVAL === 0);
-
+	//
+	// One backward walk over the message tail resolves everything the anchor
+	// selection needs at once: the trailing candidates, the stable prefix end,
+	// and the conversational-turn count under it. The first per-call/turn-scoped
+	// message from the start is the last mark this walk sees (so `markIndex` ends
+	// up as that boundary), and the turn counter — reset on every mark — ends up
+	// counting exactly the conversational turns before the first mark (the range
+	// the old forward scan covered). Nothing is materialized: the checkpoint
+	// search below walks the same history backwards and stops as soon as the
+	// breakpoint budget is spent.
+	let markIndex = -1;
+	let stableUserTurns = 0;
 	// Collect up to 2 trailing candidates from the message tail, skipping
 	// per-call messages, turn-scoped messages, and mid-conversation
 	// tool-control messages. A per-call tail candidate is rebuilt next request
 	// (fresh timestamps on appended probes, fresh redaction bytes), so a
 	// breakpoint on it cannot match — it would spend the tail anchor on bytes
-	// that never repeat while the persisted history behind it goes uncached.
+	// that never repeat while the persisted history behind it gets uncached.
 	// Turn-scoped messages are absent next request for the same reason, and
 	// tool controls reject cache_control outright. The walk starts at the
 	// message tail (not the truncated prefix end) so the anchor advances every
 	// turn; the sub-prefix candidate below covers the reusable region behind
 	// a mark.
 	const trailingCandidates: number[] = [];
-	for (let index = messageEnd; index >= 0 && trailingCandidates.length < 2; index--) {
+	for (let index = messageEnd; index >= 0; index--) {
 		const message = params.messages[index];
-		if (!message || message.clear_at === "next_user_message" || isPerCallContextMessage(message)) continue;
-		if (
-			message.role === "system" &&
-			typeof message.content !== "string" &&
-			Array.isArray(message.content) &&
-			message.content.length > 0 &&
-			message.content.every(block => block.type === "tool_addition" || block.type === "tool_removal")
-		) {
+		if (!message) continue;
+		if (message.clear_at === "next_user_message" || isPerCallContextMessage(message)) {
+			markIndex = index;
+			stableUserTurns = 0;
 			continue;
 		}
-		trailingCandidates.push(index);
-	}
-	// Prioritize:
+		if (trailingCandidates.length < 2 && !isToolControlMessage(message)) {
+			trailingCandidates.push(index);
+		}
+		// Decimation counts conversational turns, so it reads the provenance marker
+		// `convertAnthropicMessages` records rather than the wire role. A wire `user`
+		// can also be a serialized `developer` message, a tool_result run, or an
+		// interior `Continue.` pad, none of which advance the user turn ordinal.
+		if (isConversationalUser(message)) stableUserTurns++;
+	}
+	const stableMessageEnd = markIndex === -1 ? messageEnd : markIndex - 1;
+
+	// Decimation checkpoints are generated newest-first on demand instead of
+	// being materialized as index arrays: the newest sits `stableUserTurns %
+	// ANTHROPIC_DECIMATION_INTERVAL` conversational turns back from the stable
+	// prefix end and every 15th turn follows it, so the walk stops as soon as the
+	// breakpoint budget is spent. Candidates repeat when a trailing or sub-prefix
+	// anchor is already a checkpoint; re-decorating the same message is a no-op
+	// (its block already carries cache_control), so the budget accounting is
+	// unchanged.
+	//
+	// Priority order:
 	// 1. Most recent trailing message
 	// 2. Latest decimation checkpoints (newest first) to maintain stable long-context anchors
 	// 3. Newest message at or before the first per-call/turn-scoped mark, so a
 	//    volatile interior message costs only its own re-billed bytes instead
 	//    of invalidating the whole reusable prefix behind it
 	// 4. Second trailing message
-	const candidateIndices: number[] = [];
-	if (trailingCandidates.length > 0) {
-		candidateIndices.push(trailingCandidates[0]);
-	}
-	for (let i = decimationIndices.length - 1; i >= 0; i--) {
-		if (!candidateIndices.includes(decimationIndices[i])) {
-			candidateIndices.push(decimationIndices[i]);
+	//
+	// Count only successful block decorations toward the message budget so an uncacheable
+	// block (such as a thinking-only assistant) does not silently consume a breakpoint.
+	let appliedCount = 0;
+	if (trailingCandidates.length > 0 && appliedCount < messageBudget) {
+		const message = params.messages[trailingCandidates[0]];
+		if (message && applyCacheControlToMessage(message, cacheControl)) {
+			appliedCount++;
 		}
 	}
-	if (stableMessageEnd < messageEnd && stableMessageEnd >= 0 && !candidateIndices.includes(stableMessageEnd)) {
-		candidateIndices.push(stableMessageEnd);
+	// Stable historical decimation checkpoint every 15 user turns (15th, 30th, 45th...)
+	if (stableUserTurns >= ANTHROPIC_DECIMATION_INTERVAL) {
+		let turnsSinceCheckpoint = stableUserTurns % ANTHROPIC_DECIMATION_INTERVAL;
+		for (let index = stableMessageEnd; index >= 0 && appliedCount < messageBudget; index--) {
+			const message = params.messages[index];
+			if (!message || !isConversationalUser(message)) continue;
+			if (turnsSinceCheckpoint > 0) {
+				turnsSinceCheckpoint--;
+				continue;
+			}
+			turnsSinceCheckpoint = ANTHROPIC_DECIMATION_INTERVAL - 1;
+			if (applyCacheControlToMessage(message, cacheControl)) {
+				appliedCount++;
+			}
+		}
 	}
-	for (const index of trailingCandidates) {
-		if (!candidateIndices.includes(index)) {
-			candidateIndices.push(index);
+	if (stableMessageEnd < messageEnd && stableMessageEnd >= 0 && appliedCount < messageBudget) {
+		const message = params.messages[stableMessageEnd];
+		if (message && applyCacheControlToMessage(message, cacheControl)) {
+			appliedCount++;
 		}
 	}
-
-	// Count only successful block decorations toward the message budget so an uncacheable
-	// block (such as a thinking-only assistant) does not silently consume a breakpoint.
-	let appliedCount = 0;
-	for (const index of candidateIndices) {
+	for (const index of trailingCandidates) {
 		if (appliedCount >= messageBudget) break;
 		const message = params.messages[index];
 		if (message && applyCacheControlToMessage(message, cacheControl)) {

package/src/providers/cursor.ts

@@ -2,7 +2,6 @@ import * as fs from "node:fs/promises";
 import http2 from "node:http2";
 import { cursorModelParameters } from "@oh-my-pi/pi-catalog/compat/behavior";
 import { isCursorMaxModeWireId } from "@oh-my-pi/pi-catalog/compat/collapse";
-import { scheduler } from "node:timers/promises";
 import { classifyModel, collapseVariantId } from "@oh-my-pi/pi-catalog/compat/taxonomy";
 import type {
 	ConversationStep,
@@ -227,6 +226,7 @@ import { deterministicUuid } from "../utils/deterministic-id";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { connectProxiedSocket, getProxyForUrl, wrapFetchForProxy } from "../utils/proxy";
 import { createRequestDebugSession, isRequestDebugEnabled, type RequestDebugResponseLog } from "../utils/request-debug";
+import { waitForRetry } from "../utils/retry-wait";
 import { sanitizeSchemaForCursor, toolWireSchema } from "../utils/schema";
 import { formatConnectEndStreamError, hasRetryableCursorErrorDetail } from "./connect-error-detail";
 import { CONNECT_END_STREAM_FLAG, ConnectFrameDecoder, frameConnectMessage } from "./connect-frame";
@@ -1759,11 +1759,7 @@ function streamCursorWithWireMode(
 				});
 				let retryDelayCompleted = false;
 				try {
-					if (options?.providerRetryWait) {
-						await options.providerRetryWait(delayMs, options.signal);
-					} else {
-						await scheduler.wait(delayMs, { signal: options?.signal });
-					}
+					await waitForRetry(options?.providerRetryWait, delayMs, options?.signal);
 					retryDelayCompleted = !options?.signal?.aborted;
 				} catch (waitError) {
 					error = waitError;

package/src/providers/devin.ts

@@ -61,7 +61,7 @@ import {
 	ConnectFrameDecoder,
 	frameConnectMessage,
 } from "./connect-frame";
-import { transformMessages } from "./transform-messages";
+import { isResponsesFamilyApi, responsesCallComponent, transformMessages } from "./transform-messages";
 
 /** Base host for Codeium/Windsurf's Cascade chat API (Connect protocol over HTTP/1.1). */
 export const DEVIN_API_URL = DEVIN_DEFAULT_BASE_URL;
@@ -79,6 +79,13 @@ const CHAT_MESSAGE_PATH = "/exa.api_server_pb.ApiServerService/GetChatMessage";
 const DEVIN_ASSIGN_MODEL_PATH = "/exa.api_server_pb.ApiServerService/AssignModel";
 const DEVIN_AUTH_PATH = "/exa.auth_pb.AuthService/GetUserJwt";
 
+/**
+ * Cascade forwards replayed tool-call ids to the backend serving the chat model;
+ * OpenAI-routed models reject ids past OpenAI's 40-char cap or outside
+ * `[a-zA-Z0-9_-]` with an opaque `invalid_argument` (#15234).
+ */
+const DEVIN_TOOL_CALL_ID_MAX_LENGTH = 40;
+
 /**
  * Hard upper bound on a single Connect frame payload. The 4-byte length prefix
  * is otherwise attacker-controlled (up to `2**32 - 1`), so a malicious or buggy
@@ -230,7 +237,18 @@ export const streamDevin: StreamFunction<"devin-agent"> = (
 				apiKey: auth.apiKey,
 				userJwt: auth.userJwt,
 				cascadeId: options?.conversationId ?? options?.sessionId ?? crypto.randomUUID(),
-				messages: transformMessages(context.messages, model),
+				// Foreign ids (cross-model calls and their results alike): Responses
+				// composites (`call_id|item_id`) keep their wire `call_id`; opaque ids
+				// from other APIs keep every segment. Both are then sanitized and capped.
+				messages: transformMessages(
+					context.messages,
+					model,
+					(id, _target, source) =>
+						(isResponsesFamilyApi(source.api) ? responsesCallComponent(id) : id)
+							.replace(/[^a-zA-Z0-9_-]/g, "_")
+							.slice(0, DEVIN_TOOL_CALL_ID_MAX_LENGTH),
+					DEVIN_TOOL_CALL_ID_MAX_LENGTH,
+				),
 			};
 			// Router models (`adaptive`) are not valid chat model uids: the server
 			// resolves them through AssignModel and expects the returned uid plus

package/src/providers/openai-responses.ts

@@ -1,4 +1,3 @@
-import { scheduler } from "node:timers/promises";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import {
 	$flag,
@@ -40,6 +39,7 @@ import {
 } from "../utils/idle-iterator";
 import { OpenAIHttpError, postOpenAIStream } from "../utils/openai-http";
 import { notifyProviderResponse } from "../utils/provider-response";
+import { waitForRetry } from "../utils/retry-wait";
 import {
 	adaptSchemaForStrict,
 	findStrictToolSchemaViolation,
@@ -249,8 +249,7 @@ export async function pollOpenAIResponsesResultForCompletion(args: {
 		if (attempt > 0) {
 			if (Date.now() + OPENAI_RESPONSES_RESUME_POLL_INTERVAL_MS >= deadline) return undefined;
 			try {
-				if (args.wait) await args.wait(OPENAI_RESPONSES_RESUME_POLL_INTERVAL_MS, args.signal);
-				else await scheduler.wait(OPENAI_RESPONSES_RESUME_POLL_INTERVAL_MS, { signal: args.signal });
+				await waitForRetry(args.wait, OPENAI_RESPONSES_RESUME_POLL_INTERVAL_MS, args.signal);
 			} catch {
 				return undefined;
 			}
@@ -1268,11 +1267,11 @@ const streamOpenAIResponsesOnce = (
 					firstTokenTime = undefined;
 					nativeOutputItems.length = 0;
 
-					if (options?.providerRetryWait) {
-						await options.providerRetryWait(OPENAI_RESPONSES_TRANSIENT_STREAM_RETRY_DELAY_MS, options.signal);
-					} else {
-						await scheduler.wait(OPENAI_RESPONSES_TRANSIENT_STREAM_RETRY_DELAY_MS, { signal: options?.signal });
-					}
+					await waitForRetry(
+						options?.providerRetryWait,
+						OPENAI_RESPONSES_TRANSIENT_STREAM_RETRY_DELAY_MS,
+						options?.signal,
+					);
 					if (abortTracker.wasCallerAbort()) throw new AIError.AbortError();
 					openaiStream = await openResponsesStreamWithFallbacks();
 				}

package/src/providers/systemone-server.ts

@@ -1,6 +1,6 @@
 /**
  * Server side of TypeSafe's System One wire format (`POST /v1/systemone`),
- * served by the auth-gateway so TypeSafe SDKs and omp's own `TypeSafeJudge`
+ * served by the auth-gateway so TypeSafe SDKs and omp's own `NativeJudge`
  * can point `TYPESAFE_BASE_URL` at the gateway and never hold the real key.
  *
  * Requests are validated only as far as routing needs — the `model` id and

package/src/providers/transform-messages.ts

@@ -43,7 +43,7 @@ export const MAX_TOOL_CALL_ID_LENGTH = 64;
  * ids verbatim as provider correlation tokens), so ONLY these origins may be
  * canonicalized to their `call_` component for pairing.
  */
-function isResponsesFamilyApi(api: Api | undefined): boolean {
+export function isResponsesFamilyApi(api: Api | undefined): boolean {
 	return api === "openai-responses" || api === "openai-codex-responses" || api === "azure-openai-responses";
 }
 
@@ -53,7 +53,7 @@ function isResponsesFamilyApi(api: Api | undefined): boolean {
  * index 0) keeps its full id so unrelated empty-half ids never collapse onto
  * one empty-string bucket.
  */
-function responsesCallComponent(id: string): string {
+export function responsesCallComponent(id: string): string {
 	const pipe = id.indexOf("|");
 	return pipe <= 0 ? id : id.slice(0, pipe);
 }
@@ -82,19 +82,27 @@ interface ToolCallOriginScope {
 	opaqueCompositeCallIds: ReadonlySet<string>;
 }
 
-function collectToolCallOriginScope(messages: readonly Message[]): ToolCallOriginScope {
-	const responsesComponents = new Set<string>();
-	const opaqueCompositeCallIds = new Set<string>();
-	for (const msg of messages) {
-		if (msg.role !== "assistant") continue;
-		const responsesOrigin = isResponsesFamilyApi(msg.api);
-		for (const block of msg.content) {
-			if (block.type !== "toolCall") continue;
-			if (responsesOrigin) responsesComponents.add(responsesCallComponent(block.id));
-			else if (block.id.includes("|")) opaqueCompositeCallIds.add(block.id);
-		}
+/**
+ * Record one assistant turn's tool-call ids into the origin-scope sets.
+ *
+ * Called from the normalization map (`transformMessages`) in document order, on
+ * the SAME post-transform content that message emits, so the two sets cover
+ * every assistant turn exactly once and hold its post-normalization, pre-dedup
+ * ids (`_dupN` replacements minted later by dedup are never scope members).
+ * Both sets are only read via `.has`, so ordering is inert.
+ */
+function recordToolCallOriginScope(
+	msg: AssistantMessage,
+	content: Readonly<AssistantMessage["content"]>,
+	responsesComponents: Set<string>,
+	opaqueCompositeCallIds: Set<string>,
+): void {
+	const responsesOrigin = isResponsesFamilyApi(msg.api);
+	for (const block of content) {
+		if (block.type !== "toolCall") continue;
+		if (responsesOrigin) responsesComponents.add(responsesCallComponent(block.id));
+		else if (block.id.includes("|")) opaqueCompositeCallIds.add(block.id);
 	}
-	return { responsesComponents, opaqueCompositeCallIds };
 }
 
 /**
@@ -158,16 +166,70 @@ function appendSegmentDuplicateSuffix(segment: string, suffix: string, maxLength
 
 type PendingToolResultRewrite = { replacementId: string } | undefined;
 
+/** A real (non-synthetic) tool result filed at its position in the transformed transcript. */
+interface IndexedToolResult {
+	index: number;
+	msg: ToolResultMessage;
+	consumed: boolean;
+}
+
+/**
+ * File a SURVIVING (post-dedup) tool result into the request-wide index.
+ *
+ * Called from the dedup pass, once per tool result message, at the position the
+ * message occupies in that pass's output array — so the entries and their order
+ * describe the transcript the request will actually carry.
+ * The caller passes the pairing key for the id that survived the pass (a `_dup`
+ * rewrite changes it), which is what the consumers downstream must pair against.
+ */
+function indexToolResult(
+	msg: ToolResultMessage,
+	index: number,
+	key: string,
+	realToolResultsById: Map<string, IndexedToolResult[]>,
+): void {
+	const entry: IndexedToolResult = { index, msg, consumed: false };
+	const entries = realToolResultsById.get(key);
+	if (entries) entries.push(entry);
+	else realToolResultsById.set(key, [entry]);
+}
+
+/**
+ * Outputs of {@link deduplicateToolCallIds}.
+ *
+ * Both indexes describe the pass's OWN output — a `_dup` rewrite changes ids — so
+ * callers read them only after the pass completes, and no caller can hand in a
+ * pre-filled container.
+ */
+interface DeduplicatedToolCallIds {
+	messages: Message[];
+	/** Every real tool result filed at its position, keyed by pairing key. */
+	realToolResultsById: Map<string, IndexedToolResult[]>;
+	/** Pairing key of every `tool_use` id the pass left standing. */
+	validToolUseIds: Set<string>;
+}
+
 function deduplicateToolCallIds(
 	messages: Message[],
 	originScope: ToolCallOriginScope,
-	maxToolCallIdLength = MAX_TOOL_CALL_ID_LENGTH,
-	duplicateSuffixPrefix = "_dup",
-): Message[] {
+	maxToolCallIdLength: number,
+	duplicateSuffixPrefix: string,
+): DeduplicatedToolCallIds {
 	const seenToolCallIds = new Map<string, number>();
 	const pendingToolResultRewrites = new Map<string, PendingToolResultRewrite[]>();
+	const realToolResultsById = new Map<string, IndexedToolResult[]>();
+	const validToolUseIds = new Set<string>();
 
-	return messages.map(msg => {
+	const enqueueToolResultRewrite = (id: string, rewrite: PendingToolResultRewrite): void => {
+		const rewrites = pendingToolResultRewrites.get(id);
+		if (rewrites) {
+			rewrites.push(rewrite);
+			return;
+		}
+		pendingToolResultRewrites.set(id, [rewrite]);
+	};
+
+	const transformed = messages.map((msg, index) => {
 		if (msg.role === "toolResult") {
 			// Pair on the call_ component: a composite result id
 			// (`call_X|fc_Y`) must find the rewrite enqueued under its assistant
@@ -176,29 +238,34 @@ function deduplicateToolCallIds(
 			// result is dropped downstream.
 			const key = toolCallPairingKey(msg.toolCallId, originScope);
 			const rewrites = pendingToolResultRewrites.get(key);
-			if (!rewrites || rewrites.length === 0) return msg;
+			if (!rewrites || rewrites.length === 0) {
+				indexToolResult(msg, index, key, realToolResultsById);
+				return msg;
+			}
 
 			const rewrite = rewrites.shift();
 			if (rewrites.length === 0) pendingToolResultRewrites.delete(key);
-			if (rewrite) return { ...msg, toolCallId: rewrite.replacementId };
+			if (rewrite) {
+				const rewritten = { ...msg, toolCallId: rewrite.replacementId };
+				indexToolResult(
+					rewritten,
+					index,
+					toolCallPairingKey(rewritten.toolCallId, originScope),
+					realToolResultsById,
+				);
+				return rewritten;
+			}
+			indexToolResult(msg, index, key, realToolResultsById);
 			return msg;
 		}
 
 		if (msg.role !== "assistant") return msg;
 
-		const enqueueToolResultRewrite = (id: string, rewrite: PendingToolResultRewrite): void => {
-			const rewrites = pendingToolResultRewrites.get(id);
-			if (rewrites) {
-				rewrites.push(rewrite);
-				return;
-			}
-			pendingToolResultRewrites.set(id, [rewrite]);
-		};
-
-		// Ids this turn has already touched; used to scope the "drop carried-over
-		// pending rewrites" semantics to the FIRST occurrence per turn so multiple
-		// blocks of the same id within one turn still accumulate as duplicates.
-		const idsTouchedInTurn = new Set<string>();
+		// Ids this turn has already touched; scopes the "drop carried-over pending
+		// rewrites" step to an id's FIRST occurrence per turn, so multiple blocks
+		// of the same id within one turn still accumulate as duplicates. Empty
+		// sets always miss `.has`, so turns with no tool call allocate nothing.
+		let idsTouchedInTurn: Set<string> | undefined;
 		let contentChanged = false;
 		const content = msg.content.map(block => {
 			if (block.type !== "toolCall") return block;
@@ -217,9 +284,9 @@ function deduplicateToolCallIds(
 			// "No result provided" for it, and the upcoming real result(id) must
 			// route to one of THIS turn's calls. Without this guard the older
 			// `_dup` id would steal the next result.
-			if (!idsTouchedInTurn.has(blockKey)) {
+			if (!idsTouchedInTurn?.has(blockKey)) {
+				(idsTouchedInTurn ??= new Set()).add(blockKey);
 				pendingToolResultRewrites.delete(blockKey);
-				idsTouchedInTurn.add(blockKey);
 			}
 
 			const previousCount = seenToolCallIds.get(blockKey) ?? 0;
@@ -250,9 +317,20 @@ function deduplicateToolCallIds(
 			return { ...block, id: replacementId };
 		});
 
+		// Surviving `tool_use` pairing keys, read off the SAME post-dedup content the
+		// pass emits — a rewrite changes the id, so the keys must come from here and
+		// not from the input message. Recorded before the early-out because
+		// `!contentChanged` still returns element-identical content.
+		for (const block of content) {
+			if (block.type !== "toolCall") continue;
+			validToolUseIds.add(toolCallPairingKey(block.id, originScope));
+		}
+
 		if (!contentChanged) return msg;
 		return { ...msg, content };
 	});
+
+	return { messages: transformed, realToolResultsById, validToolUseIds };
 }
 
 const MAX_TOOL_CALL_NAME_LENGTH = 128;
@@ -728,6 +806,11 @@ export function transformMessages<TApi extends Api>(
 		}
 	}
 	const targetHasReasoningSlot = targetReplaysPlaintextReasoning(model, targetCompat);
+	// Origin-scope sets, accumulated by the normalization map itself (below) so
+	// the scope needs no second transcript walk. Only read via `.has`, so
+	// iteration order is inert.
+	const responsesComponents = new Set<string>();
+	const opaqueCompositeCallIds = new Set<string>();
 	// First pass: transform messages (thinking blocks, tool call ID normalization)
 	const normalizedMessages = messages.map((msg, index) => {
 		// User and developer messages pass through unchanged
@@ -1123,6 +1206,13 @@ export function transformMessages<TApi extends Api>(
 				transformedContent[transformedContent.length - 1] = { ...finalBlock, text: finalBlock.text.trimEnd() };
 			}
 
+			// Record this turn's tool-call ids into the origin scope. Origin scope
+			// must be complete before dedup reads it: filled here off the SAME
+			// post-transform content this map emits, in document order, and never
+			// read inside the map — so by the time the dedup pass consults it the
+			// sets hold every assistant id, never a partial build.
+			recordToolCallOriginScope(assistantMsg, transformedContent, responsesComponents, opaqueCompositeCallIds);
+
 			return {
 				...assistantMsg,
 				content: transformedContent,
@@ -1133,31 +1223,32 @@ export function transformMessages<TApi extends Api>(
 	// Per-concrete-id origin classification — the only scope `toolCallPairingKey`
 	// consults to decide whether a pipe-bearing id is a canonicalizable Responses
 	// composite or an opaque Chat Completions token that pairs by raw equality.
-	const originScope = collectToolCallOriginScope(normalizedMessages);
-	const transformed = deduplicateToolCallIds(
+	// The normalization map above fills both; naming the pair is all this does.
+	const originScope: ToolCallOriginScope = { responsesComponents, opaqueCompositeCallIds };
+	// All real tool results, keyed by pairing key, in document order. One id can
+	// map to more than one result: compaction can fold an assistant `tool_use`
+	// into a summary string while its `tool_result` survives, and a later turn may
+	// reuse the id. The dedup pass files them at each result's position in its own
+	// output array, so `takeRealToolResult` below pulls the earliest unconsumed
+	// result positioned AFTER the call's assistant turn (an orphaned earlier
+	// result is never pulled forward onto a later call).
+	//
+	// The set carries the `tool_use` pairing keys the dedup pass left standing.
+	// Anthropic rejects `tool_result` blocks whose `tool_use_id` does not appear in
+	// a prior `tool_use` block. After handoff/compaction folds an assistant turn
+	// into a summary string, the user-side `toolResult` for that turn can survive
+	// while the originating `tool_use` disappears — leaving an orphan that
+	// triggers HTTP 400, which the second pass drops as unreplayable.
+	const {
+		messages: transformed,
+		realToolResultsById,
+		validToolUseIds,
+	} = deduplicateToolCallIds(
 		normalizedMessages,
 		originScope,
 		maxNormalizedToolCallIdLength,
 		duplicateToolCallIdSuffixPrefix,
 	);
-	// All real tool results, keyed by id, in document order. One id can map to
-	// more than one result: compaction can fold an assistant `tool_use` into a
-	// summary string while its `tool_result` survives, and a later turn may reuse
-	// the id. `takeRealToolResult` pulls the earliest unconsumed result positioned
-	// AFTER the call's assistant turn, so an orphaned earlier result is never
-	// pulled forward onto a later call (which would surface a prior turn's output).
-	type IndexedToolResult = { index: number; msg: ToolResultMessage; consumed: boolean };
-	const realToolResultsById = new Map<string, IndexedToolResult[]>();
-	for (let index = 0; index < transformed.length; index++) {
-		const msg = transformed[index];
-		if (msg.role === "toolResult") {
-			const entry: IndexedToolResult = { index, msg, consumed: false };
-			const key = toolCallPairingKey(msg.toolCallId, originScope);
-			const entries = realToolResultsById.get(key);
-			if (entries) entries.push(entry);
-			else realToolResultsById.set(key, [entry]);
-		}
-	}
 	const takeRealToolResult = (id: string, afterIndex: number): ToolResultMessage | undefined => {
 		const entries = realToolResultsById.get(toolCallPairingKey(id, originScope));
 		if (!entries) return undefined;
@@ -1169,19 +1260,6 @@ export function transformMessages<TApi extends Api>(
 		return undefined;
 	};
 
-	// Anthropic rejects `tool_result` blocks whose `tool_use_id` does not appear in a prior
-	// `tool_use` block. After handoff/compaction folds an assistant turn into a summary
-	// string, the user-side `toolResult` for that turn can survive while the originating
-	// `tool_use` disappears — leaving an orphan that triggers HTTP 400. Track the set of
-	// `tool_use` ids that survive transformation so the second pass can drop orphans cleanly.
-	const validToolUseIds = new Set<string>();
-	for (const msg of transformed) {
-		if (msg.role !== "assistant") continue;
-		for (const block of msg.content) {
-			if (block.type === "toolCall") validToolUseIds.add(toolCallPairingKey(block.id, originScope));
-		}
-	}
-
 	// Second pass: ensure each surviving assistant tool call is immediately
 	// followed by exactly one corresponding tool result.
 	const result: Message[] = [];