@oh-my-pi/pi-agent-core 18.10.1 → 18.10.3

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [18.10.3] - 2026-10-12
+
+### Breaking Changes
+
+- Removed `estimateImageContentTokens()` from `@oh-my-pi/pi-agent-core/image-tokens`; use `Tokenizer.imageTokens(size, detail)`, which prices with the reading model's catalog image rule ([#15446](https://github.com/can1357/oh-my-pi/pull/15446) by [@will-bogusz](https://github.com/will-bogusz))
+- `applyShakeRegion()` and `applyShakeRegions()` take the replacement's token count (`replacementTokens`); a block rewrite of an assistant turn adds the tokens it removes to `elidedOutputTokens`, so a replayed Claude turn's count stays lowered after a reload ([#15446](https://github.com/can1357/oh-my-pi/pull/15446) by [@will-bogusz](https://github.com/will-bogusz))
+
+### Fixed
+
+- Fixed Claude context counts reading Opus 5.5 requests about 55% over their billed input: a replayed thinking turn now counts at the output size Claude billed for it, not its signature's bytes ([#15446](https://github.com/can1357/oh-my-pi/pull/15446) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed screenshots and other non-frame images being counted at the OpenAI rate for every model instead of the reading model's own; Claude billed them about 16% higher ([#15446](https://github.com/can1357/oh-my-pi/pull/15446) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed OpenAI Responses and Codex context estimates leaving out replayed reasoning: each turn whose encrypted reasoning actually replays now counts its reported reasoning tokens (its ciphertext when the backend reports none), and none while a cold session rebuilds it out of the request, so compaction and snapcompact sizing match billing; branch summaries no longer budget for encrypted reasoning they never send ([#15447](https://github.com/can1357/oh-my-pi/pull/15447) by [@will-bogusz](https://github.com/will-bogusz))
+
+## [18.10.2] - 2026-10-12
+
+### Added
+
+- Added `AgentLoopConfig.onDetachedToolUpdate`: a tool's `onUpdate` frames that arrive after its run's event stream ended (a returned call whose background job keeps reporting) reach it instead of being dropped; `Agent` forwards them to its subscribers as `tool_execution_update` events
+
 ## [18.9.2] - 2026-10-11
 
 ### Changed

package/THIRD-PARTY-NOTICES.txt

@@ -79,9 +79,9 @@ uutils coreutils (https://github.com/uutils/coreutils), MIT
 --------------------------------------------------------------------------------
 Covers: base32, base64, basename, cat, cksum (shared checksum machinery),
 b2sum, md5sum, sha1sum, sha224sum, sha256sum, sha384sum, sha512sum, comm, cp,
-cut, date, dirname, head, hostname, ln, ls, mkdir, mktemp, mv, nproc, paste,
-printenv, readlink, realpath, rm, seq, sort, stat, tac, tail, tee, touch, tr,
-truncate, uname, uniq, wc, whoami, yes.
+cut, date, dirname, head, hostname, ln, ls, mkdir, mktemp, mv, nl, nproc,
+paste, printenv, readlink, realpath, rm, seq, sort, stat, tac, tail, tee,
+touch, tr, truncate, uname, uniq, wc, whoami, yes.
 
   Copyright (c) uutils developers
 

package/dist/types/agent.d.ts

@@ -395,8 +395,10 @@ export declare class Agent {
     get state(): AgentState;
     /**
      * Tokenizer for the active model. The instance is replaced whenever the
-     * active model's encoding or snapcompact frame pricing changes (see
-     * {@link setModel}), so callers must not cache it across model switches.
+     * active model's encoding, image or thinking-replay pricing, or
+     * replayed-reasoning reader changes (see {@link setModel}), or its Responses
+     * session turns cold or warm, so callers must not cache it across model
+     * switches or requests.
      */
     get tokenizer(): Tokenizer;
     get appendOnlyContext(): AppendOnlyContextManager | undefined;

package/dist/types/compaction/shake.d.ts

@@ -87,12 +87,13 @@ export declare function collectShakeRegions(entries: SessionEntry[], tokenizer:
  *
  * Tool-result: replaces its first non-empty text block with the placeholder,
  * removes its other text blocks, preserves every non-text block, and stamps
- * `prunedAt`. Block: splices `replacement` over `[start, end)` of the
- * target text block. When several block regions share one text block they MUST
- * be applied highest-start-first so earlier offsets stay valid — use
- * {@link applyShakeRegions}, which orders them correctly.
+ * `prunedAt`. Block: splices `replacement` (`replacementTokens` long) over
+ * `[start, end)` of the target text block, and on an assistant turn adds the
+ * tokens removed to `elidedOutputTokens`. When several block regions share one
+ * text block they MUST be applied highest-start-first so earlier offsets stay
+ * valid — use {@link applyShakeRegions}, which orders them correctly.
  */
-export declare function applyShakeRegion(region: ShakeRegion, replacement: string): void;
+export declare function applyShakeRegion(region: ShakeRegion, replacement: string, replacementTokens: number): void;
 /**
  * Apply many regions at once. Block regions are applied highest-start-first so
  * that splicing one region never shifts the offsets of another in the same text
@@ -101,4 +102,5 @@ export declare function applyShakeRegion(region: ShakeRegion, replacement: strin
 export declare function applyShakeRegions(items: Array<{
     region: ShakeRegion;
     replacement: string;
+    replacementTokens: number;
 }>): void;

package/dist/types/image-tokens.d.ts

@@ -1,29 +1,26 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import { type ImageSize } from "@oh-my-pi/pi-catalog/compat/image-tokenization";
+import { type ImageSize, type ImageTokenization } from "@oh-my-pi/pi-catalog/compat/image-tokenization";
 /**
  * Dimension-based image token estimates shared by the local context counter
  * ({@link Tokenizer.countMessage}) and the native remote-compaction fit probe.
  * Both sides must price the same image the same way: when they disagreed
  * (1.2k flat locally vs a 12k flat worst case remotely) an image-heavy session
  * stayed under the local compaction trigger yet was refused as over-window by
- * the remote probe.
- *
- * Follows the catalog's image rule for the OpenAI Responses wire (GPT-5.5's
- * 32px patches, a per-detail pixel limit and patch budget, x1.2 multiplier),
- * which is also a close upper estimate for other providers once omp has
- * downscaled the image (≤1568px by default).
+ * the remote probe. Both price with the reading model's catalog image rule
+ * ({@link Tokenizer.imageTokens}); a reader without one falls back to the
+ * OpenAI Responses wire's rule (GPT-5.5's 32px patches, a per-detail pixel
+ * limit and patch budget, x1.2 multiplier).
  */
 /** OpenAI image `detail` values; `undefined` means the provider default (`auto`). */
 export type ImageDetail = ImageContent["detail"];
 export type { ImageSize };
 /**
- * Estimated input tokens for one image. Unknown dimensions (undecodable data,
- * remote URLs, provider file ids) charge the detail level's full patch budget.
+ * Estimated input tokens for one image under `rule`, the OpenAI Responses
+ * wire's by default. Unknown dimensions (undecodable data, remote URLs,
+ * provider file ids) charge the rule's most expensive size.
  */
-export declare function estimateImageTokens(size: ImageSize | null | undefined, detail?: ImageDetail): number;
+export declare function estimateImageTokens(size: ImageSize | null | undefined, detail?: ImageDetail, rule?: ImageTokenization): number;
 /** Pixel size read from the header of base64-encoded image data, or null. */
 export declare function base64ImageSize(base64: string): ImageSize | null;
 /** Pixel size of a `data:<mime>;base64,` URL, or null for any other URL. */
 export declare function dataUrlImageSize(url: string): ImageSize | null;
-/** {@link estimateImageTokens} for an in-memory image block. */
-export declare function estimateImageContentTokens(image: Pick<ImageContent, "data" | "detail">): number;

package/dist/types/tokenizer.d.ts

@@ -1,9 +1,27 @@
 import type { Model } from "@oh-my-pi/pi-ai";
+import { type ThinkingReplayTokens } from "@oh-my-pi/pi-catalog/compat/thinking-replay";
 import * as natives from "@oh-my-pi/pi-natives";
 import * as snapcompact from "@oh-my-pi/snapcompact";
+import { type ImageDetail, type ImageSize } from "./image-tokens.js";
 import type { AgentMessage } from "./types.js";
 /** Maps the catalog-resolved tokenizer family to its native implementation. */
 export declare function tokenizerEncodingForModel(model: Pick<Model, "tokenizer"> | null | undefined): natives.Encoding | null;
+type TokenizerModel = Pick<Model, "tokenizer"> & snapcompact.ShapeTarget & {
+    compat?: Model["compat"];
+    thinking?: Model["thinking"];
+};
+/** Identity of the reader whose replayed reasoning a {@link Tokenizer} counts; equal keys count it alike. */
+export declare function reasoningReplayKey(model: TokenizerModel | null | undefined): string;
+/** Request state a {@link Tokenizer} counts for, beyond its model. */
+export interface TokenizerOptions {
+    /**
+     * Whether the request replays native Responses history (pi-ai's
+     * `openAIResponsesReplaysNativeHistory`). A cold session rebuilds a turn
+     * holding encrypted reasoning from its text and tool calls, without the
+     * reasoning or its signature. Default: true.
+     */
+    nativeHistoryReplay?: boolean;
+}
 /**
  * `strict` always tries an exact native count (the catalog-resolved tokenizer
  * when known, o200k_base otherwise), falling back to the byte upper bound when
@@ -19,11 +37,15 @@ export interface MessageCountOptions {
     /**
      * Drop opaque provider reasoning payloads (`thinkingSignature`,
      * `redactedThinking`, native server-tool blocks) from the estimate. Those
-     * are billed by the provider on replay, so the default counts them — but
-     * their *local* byte size can diverge wildly from what the provider
-     * charges, so the compaction floor (which only needs the reliably-countable,
-     * on-wire-compressible content) excludes them to avoid false triggers on
-     * thinking-heavy turns.
+     * are billed by the provider on replay, so the default counts them (a reader
+     * billing replayed thinking at `output` size: the reasoning, at its turn's
+     * output size) — but their *local* byte size can diverge wildly from what
+     * the provider charges, so the compaction floor (which only needs the
+     * reliably-countable, on-wire-compressible content) excludes them to avoid
+     * false triggers on thinking-heavy turns.
+     * Native Responses reasoning that actually replays is not an opaque byte
+     * guess: it is charged at the turn's provider-reported reasoning tokens in
+     * both arms.
      */
     excludeEncryptedReasoning?: boolean;
 }
@@ -43,15 +65,28 @@ export interface TokenBudgetCheck {
  * Model-aware local token counter. Immutable: the catalog-resolved encoding
  * is fixed at construction, so a cached count can never straddle two
  * encodings. An `Agent` owns one for its active model (swapping the instance
- * when the model's encoding or snapcompact frame pricing changes); one-shot
- * flows construct their own for the model that will be billed. Known
- * tokenizer families use exact native counts; unknown models keep the fast
- * byte estimate (or o200k when `PI_TOKENIZER_ACCURATE=1`).
+ * when the model's encoding, image or thinking-replay pricing, replay
+ * identity or native-history replay state changes); one-shot flows construct
+ * their own for the model that will be billed. Known tokenizer families use
+ * exact native counts; unknown models keep the fast byte estimate (or o200k
+ * when `PI_TOKENIZER_ACCURATE=1`).
  */
 export declare class Tokenizer {
     #private;
     readonly frameBillingKey: string;
-    constructor(model?: (Pick<Model, "tokenizer"> & snapcompact.ShapeTarget) | null);
+    readonly reasoningReplayKey: string;
+    /** How the reader bills replayed signed thinking (catalog `thinking-replay-tokens`). */
+    readonly thinkingReplayTokens: ThinkingReplayTokens;
+    /** Whether the counted request replays native Responses history; see {@link TokenizerOptions}. */
+    readonly nativeHistoryReplay: boolean;
+    /**
+     * Counts what `streamSimple` sends `model`. Its catalog compat decides
+     * whether Responses reasoning history is filtered: `streamOpenAIResponses`'
+     * per-request `filterReasoningHistory` override is a debugging hook
+     * `streamSimple` never forwards, so a caller using it passes `model` with
+     * that compat set.
+     */
+    constructor(model?: TokenizerModel | null, options?: TokenizerOptions);
     get encoding(): natives.Encoding | null;
     countTokens(text: string | string[], mode?: TokenCountMode): number;
     /**
@@ -72,10 +107,25 @@ export declare class Tokenizer {
      * Settled historical messages are counted once and reused until an owner
      * (prune/shake/strip-images) calls `invalidateMessageCache`; streaming
      * assistants bypass the memo entirely (see the message-cache settle-gate
-     * invariant). Image blocks charge {@link estimateImageContentTokens}, the
-     * same dimension-based estimate the native remote-compaction probe applies.
+     * invariant). Image blocks charge {@link imageTokens}, the same estimate
+     * the native remote-compaction probe applies.
      */
     countMessage(message: AgentMessage, options?: MessageCountOptions): number;
     /** Sum of {@link countMessage} over `messages`. */
     countMessages(messages: readonly AgentMessage[], options?: MessageCountOptions): number;
+    /**
+     * Input tokens for one image (not a snapcompact frame) under the reader's
+     * catalog image rule, or the generic estimate when it has none.
+     */
+    imageTokens(size: ImageSize | null | undefined, detail?: ImageDetail): number;
+    /**
+     * The replayed native Responses reasoning {@link countMessage} charges
+     * across `messages`: the part of a count that changes with the reading
+     * model. A replay whose backend reported no reasoning tokens counts at the
+     * signature price `countMessage` gives it.
+     */
+    replayedReasoningTokens(messages: readonly AgentMessage[]): number;
+    /** Whether a Tokenizer built for `model` with `options` would count every message as this one does. */
+    countsAlike(model: TokenizerModel | null | undefined, options?: TokenizerOptions): boolean;
 }
+export {};

package/dist/types/types.d.ts

@@ -279,6 +279,15 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      * tools finish first.
      */
     hasQueuedAsides?: () => boolean | Promise<boolean>;
+    /**
+     * Receives a tool's `onUpdate` frames that arrive after this run's event
+     * stream ended: a call that returned while its background job keeps
+     * reporting (`details.async`), whose run yielded before the job settled.
+     * Without it those frames are dropped.
+     */
+    onDetachedToolUpdate?: (event: Extract<AgentEvent, {
+        type: "tool_execution_update";
+    }>) => void;
     /**
      * Returns follow-up messages to process after the agent would otherwise stop.
      *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "18.10.1",
+	"version": "18.10.3",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -38,16 +38,16 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.10.1",
-		"@oh-my-pi/pi-catalog": "18.10.1",
-		"@oh-my-pi/pi-natives": "18.10.1",
-		"@oh-my-pi/pi-utils": "18.10.1",
-		"@oh-my-pi/pi-wire": "18.10.1",
-		"@oh-my-pi/snapcompact": "18.10.1",
+		"@oh-my-pi/pi-ai": "18.10.3",
+		"@oh-my-pi/pi-catalog": "18.10.3",
+		"@oh-my-pi/pi-natives": "18.10.3",
+		"@oh-my-pi/pi-utils": "18.10.3",
+		"@oh-my-pi/pi-wire": "18.10.3",
+		"@oh-my-pi/snapcompact": "18.10.3",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/omptype": "18.10.1",
+		"@oh-my-pi/omptype": "18.10.3",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@types/bun": "^1.3.14"

package/src/agent-loop.ts

@@ -3570,13 +3570,15 @@ async function executeToolCalls(
 							executionArgs,
 							record.signal,
 							partialResult => {
-								stream.push({
+								const event: Extract<AgentEvent, { type: "tool_execution_update" }> = {
 									type: "tool_execution_update",
 									toolCallId: toolCall.id,
 									toolName: toolCall.name,
 									args: executionArgs,
 									partialResult: coerceToolResult(partialResult).result,
-								});
+								};
+								if (stream.done) config.onDetachedToolUpdate?.(event);
+								else stream.push(event);
 							},
 							toolContext,
 						);

package/src/agent.ts

@@ -23,10 +23,10 @@ import {
 	type ToolResultMessage,
 } from "@oh-my-pi/pi-ai";
 import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
+import { openAIResponsesReplaysNativeHistory } from "@oh-my-pi/pi-ai/providers/openai-responses";
 import type { HarmonyAuditEvent } from "@oh-my-pi/pi-ai/utils/harmony-leak";
 import { getBundledModel } from "@oh-my-pi/pi-catalog/models";
 import { logger } from "@oh-my-pi/pi-utils";
-import * as snapcompact from "@oh-my-pi/snapcompact";
 import {
 	abortReasonText,
 	agentLoop,
@@ -41,7 +41,7 @@ import {
 import type { AppendOnlyContextManager } from "./append-only-context";
 import { isProviderRefusalMessage } from "./replay-policy";
 import { SentToolDefinitions } from "./sent-tool-definitions";
-import { Tokenizer, tokenizerEncodingForModel } from "./tokenizer";
+import { Tokenizer } from "./tokenizer";
 import {
 	createAdditionalContextMessage,
 	joinAdditionalContext,
@@ -850,24 +850,32 @@ export class Agent {
 
 	/**
 	 * Tokenizer for the active model. The instance is replaced whenever the
-	 * active model's encoding or snapcompact frame pricing changes (see
-	 * {@link setModel}), so callers must not cache it across model switches.
+	 * active model's encoding, image or thinking-replay pricing, or
+	 * replayed-reasoning reader changes (see {@link setModel}), or its Responses
+	 * session turns cold or warm, so callers must not cache it across model
+	 * switches or requests.
 	 */
 	get tokenizer(): Tokenizer {
+		// The provider warms or closes a session inside a request, so the replay
+		// state is read here rather than only on model switches.
+		const model = this.#state.model;
+		if (
+			openAIResponsesReplaysNativeHistory(model, this.#providerSessionState) !== this.#tokenizer.nativeHistoryReplay
+		) {
+			this.#syncTokenizer(model);
+		}
 		return this.#tokenizer;
 	}
 
 	/**
-	 * Swap the tokenizer only when the encoding or frame pricing actually
-	 * changes, so the warm per-message memo survives same-pricing model switches.
+	 * Swap the tokenizer only when the encoding, image or thinking-replay
+	 * pricing, replayed-reasoning reader or native-history replay state
+	 * actually changes, so the warm
+	 * per-message memo survives same-pricing model switches.
 	 */
 	#syncTokenizer(model: Model | null | undefined): void {
-		if (
-			tokenizerEncodingForModel(model) !== this.#tokenizer.encoding ||
-			snapcompact.frameBillingKey(snapcompact.frameBilling(model ?? undefined)) !== this.#tokenizer.frameBillingKey
-		) {
-			this.#tokenizer = new Tokenizer(model);
-		}
+		const options = { nativeHistoryReplay: openAIResponsesReplaysNativeHistory(model, this.#providerSessionState) };
+		if (!this.#tokenizer.countsAlike(model, options)) this.#tokenizer = new Tokenizer(model, options);
 	}
 
 	get appendOnlyContext(): AppendOnlyContextManager | undefined {
@@ -1950,6 +1958,7 @@ export class Agent {
 			getFollowUpMessages: signal => this.#dequeueFollowUpMessagesAfterHooks(signal ?? loopSignal),
 			getAsideMessages: async () => (await this.#asideMessageProvider?.()) ?? [],
 			onBeforeYield: () => this.#onBeforeYield?.(),
+			onDetachedToolUpdate: event => this.emitExternalEvent(event),
 			telemetry: this.#telemetry,
 		};
 

package/src/compaction/branch-summarization.ts

@@ -208,7 +208,16 @@ function getMessageFromEntry(entry: SessionEntry): AgentMessage | undefined {
 	}
 }
 
+/**
+ * Tokens `message` adds to the summarizer's input, which is the branch
+ * serialized as plain text: tool results truncated as serialization truncates
+ * them, assistants without their native replay items or opaque reasoning
+ * payloads, which the text never carries.
+ */
 function estimateBranchSummaryTokens(message: AgentMessage, tokenizer: Tokenizer): number {
+	if (message.role === "assistant") {
+		return tokenizer.countMessage({ ...message, providerPayload: undefined }, { excludeEncryptedReasoning: true });
+	}
 	if (message.role !== "toolResult") return tokenizer.countMessage(message);
 	const text = message.content
 		.filter((c): c is { type: "text"; text: string } => c.type === "text")

package/src/compaction/openai.ts

@@ -54,7 +54,7 @@ import {
 	OPENAI_HEADERS,
 } from "@oh-my-pi/pi-catalog/wire/codex";
 import { $env, isRecord, logger, prompt, ptree, stringifyJson, structuredCloneJSON } from "@oh-my-pi/pi-utils";
-import { dataUrlImageSize, estimateImageTokens } from "../image-tokens";
+import { dataUrlImageSize } from "../image-tokens";
 import { Tokenizer } from "../tokenizer";
 import { appendAzureApiVersion, resolveAzureOpenAiBaseUrl } from "./azure-openai-endpoint";
 import { prepareBedrockCompactionRequest } from "./bedrock";
@@ -82,8 +82,11 @@ export const REMOTE_COMPACTION_TIMEOUT_MS = 300_000;
 export const CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE = prompt.render(contextWindowTruncatedOutputPrompt);
 
 const REMOTE_COMPACTION_REQUEST_OVERHEAD_TOKENS = 256;
-/** Per-`input_image` record estimates; trim re-probes share untouched items by reference. */
-const remoteImageTokenCache = new WeakMap<Record<string, unknown>, number>();
+/**
+ * Per-`input_image` record estimates, tagged with the pricing tokenizer's
+ * billing key; trim re-probes share untouched items by reference.
+ */
+const remoteImageTokenCache = new WeakMap<Record<string, unknown>, { billingKey: string; tokens: number }>();
 const TOOL_RESULT_IMAGE_ATTACHMENT_TEXT = "Attached image(s) from tool result:";
 
 interface NormalizedEstimateValue {
@@ -91,12 +94,16 @@ interface NormalizedEstimateValue {
 	imageTokens: number;
 }
 
-function normalizeRemoteCompactionEstimateValue(value: unknown, dropEncrypted = true): NormalizedEstimateValue {
+function normalizeRemoteCompactionEstimateValue(
+	value: unknown,
+	tokenizer: Tokenizer,
+	dropEncrypted = true,
+): NormalizedEstimateValue {
 	if (Array.isArray(value)) {
 		const normalized: unknown[] = [];
 		let imageTokens = 0;
 		for (const item of value) {
-			const result = normalizeRemoteCompactionEstimateValue(item, dropEncrypted);
+			const result = normalizeRemoteCompactionEstimateValue(item, tokenizer, dropEncrypted);
 			normalized.push(result.value);
 			imageTokens += result.imageTokens;
 		}
@@ -106,18 +113,20 @@ function normalizeRemoteCompactionEstimateValue(value: unknown, dropEncrypted =
 
 	const record = value as Record<string, unknown>;
 	if (record.type === "input_image") {
-		let imageTokens = remoteImageTokenCache.get(record);
-		if (imageTokens === undefined) {
+		let cached = remoteImageTokenCache.get(record);
+		if (cached?.billingKey !== tokenizer.frameBillingKey) {
 			const detail = record.detail;
-			imageTokens = estimateImageTokens(
-				typeof record.image_url === "string" ? dataUrlImageSize(record.image_url) : null,
-				detail === "low" || detail === "high" || detail === "original" || detail === "auto" ? detail : undefined,
-			);
-			remoteImageTokenCache.set(record, imageTokens);
+			cached = {
+				billingKey: tokenizer.frameBillingKey,
+				tokens: tokenizer.imageTokens(
+					typeof record.image_url === "string" ? dataUrlImageSize(record.image_url) : null,
+					detail === "low" || detail === "high" || detail === "original" || detail === "auto" ? detail : undefined,
+				),
+			};
+			remoteImageTokenCache.set(record, cached);
 		}
-		return { value: { ...record, image_url: "<image>" }, imageTokens };
+		return { value: { ...record, image_url: "<image>" }, imageTokens: cached.tokens };
 	}
-
 	const normalized: Record<string, unknown> = {};
 	let imageTokens = 0;
 	for (const [key, item] of Object.entries(record)) {
@@ -125,7 +134,7 @@ function normalizeRemoteCompactionEstimateValue(value: unknown, dropEncrypted =
 		// exceeds what the provider bills, so it stays out of the fit estimate
 		// (same policy as `MessageCountOptions.excludeEncryptedReasoning`).
 		if (dropEncrypted && key === "encrypted_content" && typeof item === "string") continue;
-		const result = normalizeRemoteCompactionEstimateValue(item, dropEncrypted);
+		const result = normalizeRemoteCompactionEstimateValue(item, tokenizer, dropEncrypted);
 		normalized[key] = result.value;
 		imageTokens += result.imageTokens;
 	}
@@ -138,7 +147,7 @@ function normalizeRemoteCompactionEstimateValue(value: unknown, dropEncrypted =
  * opaque compaction state included, counts as serialized.
  */
 export function countResponsesHistoryTokens(items: unknown[], tokenizer: Tokenizer): number {
-	const normalized = normalizeRemoteCompactionEstimateValue(items, false);
+	const normalized = normalizeRemoteCompactionEstimateValue(items, tokenizer, false);
 	const serialized = stringifyJson(normalized.value);
 	return (serialized === undefined ? 0 : tokenizer.countTokens(serialized)) + normalized.imageTokens;
 }
@@ -181,7 +190,10 @@ function probeRemoteCompactionInputBudget(
 	tools: unknown[] | undefined,
 	contextWindow: number | null | undefined,
 ): RemoteCompactionBudgetProbe {
-	const normalized = normalizeRemoteCompactionEstimateValue({ instructions, input, ...(tools ? { tools } : {}) });
+	const normalized = normalizeRemoteCompactionEstimateValue(
+		{ instructions, input, ...(tools ? { tools } : {}) },
+		tokenizer,
+	);
 	const serialized = stringifyJson(normalized.value) ?? "";
 	const flatTokens = normalized.imageTokens + REMOTE_COMPACTION_REQUEST_OVERHEAD_TOKENS;
 	if (!contextWindow || contextWindow <= 0) {

package/src/compaction/shake.ts

@@ -422,12 +422,13 @@ function getBlockTextSlot(entry: SessionMessageEntry | CustomMessageEntry, block
  *
  * Tool-result: replaces its first non-empty text block with the placeholder,
  * removes its other text blocks, preserves every non-text block, and stamps
- * `prunedAt`. Block: splices `replacement` over `[start, end)` of the
- * target text block. When several block regions share one text block they MUST
- * be applied highest-start-first so earlier offsets stay valid — use
- * {@link applyShakeRegions}, which orders them correctly.
+ * `prunedAt`. Block: splices `replacement` (`replacementTokens` long) over
+ * `[start, end)` of the target text block, and on an assistant turn adds the
+ * tokens removed to `elidedOutputTokens`. When several block regions share one
+ * text block they MUST be applied highest-start-first so earlier offsets stay
+ * valid — use {@link applyShakeRegions}, which orders them correctly.
  */
-export function applyShakeRegion(region: ShakeRegion, replacement: string): void {
+export function applyShakeRegion(region: ShakeRegion, replacement: string, replacementTokens: number): void {
 	if (region.kind === "toolResult") {
 		const message = region.entry.message as ToolResultMessage;
 		const replacementIndex = message.content.findIndex(block => block.type === "text" && block.text.length > 0);
@@ -451,7 +452,14 @@ export function applyShakeRegion(region: ShakeRegion, replacement: string): void
 	// rebuilds, so an in-place block rewrite must drop its cached estimate/convert.
 	// Custom-message entries are re-materialized into a fresh AgentMessage on every
 	// buildSessionContext, so they carry no stable cached identity to invalidate.
-	if (region.entry.type === "message") invalidateMessageCache(region.entry.message);
+	if (region.entry.type !== "message") return;
+	const message = region.entry.message;
+	// `usage.output` keeps billing the removed text; the persisted tally lets
+	// every later count of a replayed turn take it off again.
+	if (message.role === "assistant") {
+		message.elidedOutputTokens = (message.elidedOutputTokens ?? 0) + Math.max(0, region.tokens - replacementTokens);
+	}
+	invalidateMessageCache(message);
 }
 
 /**
@@ -459,11 +467,14 @@ export function applyShakeRegion(region: ShakeRegion, replacement: string): void
  * that splicing one region never shifts the offsets of another in the same text
  * block; tool-result regions are independent.
  */
-export function applyShakeRegions(items: Array<{ region: ShakeRegion; replacement: string }>): void {
+export function applyShakeRegions(
+	items: Array<{ region: ShakeRegion; replacement: string; replacementTokens: number }>,
+): void {
 	const ordered = [...items].sort((a, b) => {
 		const aStart = a.region.kind === "block" ? a.region.start : -1;
 		const bStart = b.region.kind === "block" ? b.region.start : -1;
 		return bStart - aStart;
 	});
-	for (const { region, replacement } of ordered) applyShakeRegion(region, replacement);
+	for (const { region, replacement, replacementTokens } of ordered)
+		applyShakeRegion(region, replacement, replacementTokens);
 }

package/src/image-tokens.ts

@@ -13,12 +13,10 @@ import { parseImageMetadata } from "@oh-my-pi/pi-utils";
  * Both sides must price the same image the same way: when they disagreed
  * (1.2k flat locally vs a 12k flat worst case remotely) an image-heavy session
  * stayed under the local compaction trigger yet was refused as over-window by
- * the remote probe.
- *
- * Follows the catalog's image rule for the OpenAI Responses wire (GPT-5.5's
- * 32px patches, a per-detail pixel limit and patch budget, x1.2 multiplier),
- * which is also a close upper estimate for other providers once omp has
- * downscaled the image (≤1568px by default).
+ * the remote probe. Both price with the reading model's catalog image rule
+ * ({@link Tokenizer.imageTokens}); a reader without one falls back to the
+ * OpenAI Responses wire's rule (GPT-5.5's 32px patches, a per-detail pixel
+ * limit and patch budget, x1.2 multiplier).
  */
 
 /** OpenAI image `detail` values; `undefined` means the provider default (`auto`). */
@@ -42,11 +40,16 @@ function openAiWireRule(): ImageTokenization {
 }
 
 /**
- * Estimated input tokens for one image. Unknown dimensions (undecodable data,
- * remote URLs, provider file ids) charge the detail level's full patch budget.
+ * Estimated input tokens for one image under `rule`, the OpenAI Responses
+ * wire's by default. Unknown dimensions (undecodable data, remote URLs,
+ * provider file ids) charge the rule's most expensive size.
  */
-export function estimateImageTokens(size: ImageSize | null | undefined, detail?: ImageDetail): number {
-	return imageTokens(openAiWireRule(), size && size.width > 0 && size.height > 0 ? size : UNKNOWN_SIZE, detail);
+export function estimateImageTokens(
+	size: ImageSize | null | undefined,
+	detail?: ImageDetail,
+	rule: ImageTokenization = openAiWireRule(),
+): number {
+	return imageTokens(rule, size && size.width > 0 && size.height > 0 ? size : UNKNOWN_SIZE, detail);
 }
 
 // Enough decoded bytes to reach a JPEG SOF marker behind typical EXIF/ICC
@@ -70,8 +73,3 @@ export function dataUrlImageSize(url: string): ImageSize | null {
 	if (comma < 0 || !url.slice(0, comma).endsWith(";base64")) return null;
 	return base64ImageSize(url.slice(comma + 1));
 }
-
-/** {@link estimateImageTokens} for an in-memory image block. */
-export function estimateImageContentTokens(image: Pick<ImageContent, "data" | "detail">): number {
-	return estimateImageTokens(base64ImageSize(image.data), image.detail);
-}

package/src/tokenizer.ts

@@ -1,11 +1,18 @@
-import type { Model } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, Model } from "@oh-my-pi/pi-ai";
+import { isColdReplayableResponsesTurn } from "@oh-my-pi/pi-ai/providers/openai-shared";
+import { shouldDropTruncatedThinkingOnlyAssistant } from "@oh-my-pi/pi-ai/providers/transform-messages";
+import {
+	getOpenAIResponsesHistoryItems,
+	sanitizeOpenAIResponsesAssistantHistoryItemsForReplay,
+} from "@oh-my-pi/pi-ai/utils";
+import { resolveThinkingReplayTokens, type ThinkingReplayTokens } from "@oh-my-pi/pi-catalog/compat/thinking-replay";
 import type { ModelTokenizer } from "@oh-my-pi/pi-catalog/types";
 import * as natives from "@oh-my-pi/pi-natives";
 import { materializeString, stringifyJson } from "@oh-my-pi/pi-utils";
 import { LRUCache } from "@oh-my-pi/pi-utils/lru";
 import * as snapcompact from "@oh-my-pi/snapcompact";
 import { isEstimateCacheable, messageEstimateVersion } from "./compaction/message-cache";
-import { base64ImageSize, estimateImageContentTokens } from "./image-tokens";
+import { base64ImageSize, estimateImageTokens, type ImageDetail, type ImageSize } from "./image-tokens";
 import type { AgentMessage } from "./types";
 
 const testEnv = Bun.env.NODE_ENV === "test";
@@ -20,6 +27,7 @@ const NATIVE_ENCODING: Record<ModelTokenizer, natives.Encoding> = {
 	"deepseek-v3": natives.Encoding.DeepSeekV3,
 	"kimi-k2": natives.Encoding.KimiK2,
 	glm5: natives.Encoding.Glm5,
+	o200k: natives.Encoding.O200kBase,
 };
 
 /** Maps the catalog-resolved tokenizer family to its native implementation. */
@@ -27,6 +35,41 @@ export function tokenizerEncodingForModel(model: Pick<Model, "tokenizer"> | null
 	return model?.tokenizer ? NATIVE_ENCODING[model.tokenizer] : null;
 }
 
+type TokenizerModel = Pick<Model, "tokenizer"> &
+	snapcompact.ShapeTarget & { compat?: Model["compat"]; thinking?: Model["thinking"] };
+
+/** The model an assistant turn's native reasoning (signed thinking, Responses history) is replayed to. */
+interface ReasoningReplayReader {
+	api: string;
+	provider: string;
+	id: string;
+}
+
+function reasoningReplayReader(model: TokenizerModel | null | undefined): ReasoningReplayReader | undefined {
+	if (!model?.api || !model.provider || !model.id) return undefined;
+	// Filtering targets strip native reasoning items before the request is encoded.
+	const compat = model.compat;
+	if (compat && "filterReasoningHistory" in compat && compat.filterReasoningHistory) return undefined;
+	return { api: model.api, provider: model.provider, id: model.id };
+}
+
+/** Identity of the reader whose replayed reasoning a {@link Tokenizer} counts; equal keys count it alike. */
+export function reasoningReplayKey(model: TokenizerModel | null | undefined): string {
+	const reader = reasoningReplayReader(model);
+	return reader ? `${reader.api}\0${reader.provider}\0${reader.id}` : "";
+}
+
+/** Request state a {@link Tokenizer} counts for, beyond its model. */
+export interface TokenizerOptions {
+	/**
+	 * Whether the request replays native Responses history (pi-ai's
+	 * `openAIResponsesReplaysNativeHistory`). A cold session rebuilds a turn
+	 * holding encrypted reasoning from its text and tool calls, without the
+	 * reasoning or its signature. Default: true.
+	 */
+	nativeHistoryReplay?: boolean;
+}
+
 /**
  * `strict` always tries an exact native count (the catalog-resolved tokenizer
  * when known, o200k_base otherwise), falling back to the byte upper bound when
@@ -43,11 +86,15 @@ export interface MessageCountOptions {
 	/**
 	 * Drop opaque provider reasoning payloads (`thinkingSignature`,
 	 * `redactedThinking`, native server-tool blocks) from the estimate. Those
-	 * are billed by the provider on replay, so the default counts them — but
-	 * their *local* byte size can diverge wildly from what the provider
-	 * charges, so the compaction floor (which only needs the reliably-countable,
-	 * on-wire-compressible content) excludes them to avoid false triggers on
-	 * thinking-heavy turns.
+	 * are billed by the provider on replay, so the default counts them (a reader
+	 * billing replayed thinking at `output` size: the reasoning, at its turn's
+	 * output size) — but their *local* byte size can diverge wildly from what
+	 * the provider charges, so the compaction floor (which only needs the
+	 * reliably-countable, on-wire-compressible content) excludes them to avoid
+	 * false triggers on thinking-heavy turns.
+	 * Native Responses reasoning that actually replays is not an opaque byte
+	 * guess: it is charged at the turn's provider-reported reasoning tokens in
+	 * both arms.
 	 */
 	excludeEncryptedReasoning?: boolean;
 }
@@ -149,15 +196,24 @@ interface MessageEstimate {
  * Model-aware local token counter. Immutable: the catalog-resolved encoding
  * is fixed at construction, so a cached count can never straddle two
  * encodings. An `Agent` owns one for its active model (swapping the instance
- * when the model's encoding or snapcompact frame pricing changes); one-shot
- * flows construct their own for the model that will be billed. Known
- * tokenizer families use exact native counts; unknown models keep the fast
- * byte estimate (or o200k when `PI_TOKENIZER_ACCURATE=1`).
+ * when the model's encoding, image or thinking-replay pricing, replay
+ * identity or native-history replay state changes); one-shot flows construct
+ * their own for the model that will be billed. Known tokenizer families use
+ * exact native counts; unknown models keep the fast byte estimate (or o200k
+ * when `PI_TOKENIZER_ACCURATE=1`).
  */
 export class Tokenizer {
 	readonly #encoding: natives.Encoding | null;
 	readonly #frameBilling: snapcompact.FrameBilling;
 	readonly frameBillingKey: string;
+	readonly #reasoningReader: ReasoningReplayReader | undefined;
+	/** Claude's own API and prefix-bound hosts keep another model's signature from their deployment. */
+	readonly #readsDeploymentSignatures: boolean;
+	readonly reasoningReplayKey: string;
+	/** How the reader bills replayed signed thinking (catalog `thinking-replay-tokens`). */
+	readonly thinkingReplayTokens: ThinkingReplayTokens;
+	/** Whether the counted request replays native Responses history; see {@link TokenizerOptions}. */
+	readonly nativeHistoryReplay: boolean;
 
 	/** Exact counts only; byte fallbacks remain mode-dependent and uncached. */
 	readonly #nativeCounts = new LRUCache<string, number>({
@@ -176,10 +232,26 @@ export class Tokenizer {
 	 */
 	#estimates = new WeakMap<AgentMessage, MessageEstimate>();
 
-	constructor(model?: (Pick<Model, "tokenizer"> & snapcompact.ShapeTarget) | null) {
+	/**
+	 * Counts what `streamSimple` sends `model`. Its catalog compat decides
+	 * whether Responses reasoning history is filtered: `streamOpenAIResponses`'
+	 * per-request `filterReasoningHistory` override is a debugging hook
+	 * `streamSimple` never forwards, so a caller using it passes `model` with
+	 * that compat set.
+	 */
+	constructor(model?: TokenizerModel | null, options?: TokenizerOptions) {
 		this.#encoding = tokenizerEncodingForModel(model);
 		this.#frameBilling = snapcompact.frameBilling(model ?? undefined);
 		this.frameBillingKey = snapcompact.frameBillingKey(this.#frameBilling);
+		this.#reasoningReader = reasoningReplayReader(model);
+		const compat = model?.compat;
+		this.#readsDeploymentSignatures =
+			model?.api === "anthropic-messages" &&
+			((compat !== undefined && "officialEndpoint" in compat && compat.officialEndpoint) ||
+				model.thinking?.prefixBinding === true);
+		this.reasoningReplayKey = reasoningReplayKey(model);
+		this.thinkingReplayTokens = resolveThinkingReplayTokens(model ?? {});
+		this.nativeHistoryReplay = options?.nativeHistoryReplay ?? true;
 	}
 
 	get encoding(): natives.Encoding | null {
@@ -218,8 +290,8 @@ export class Tokenizer {
 	 * Settled historical messages are counted once and reused until an owner
 	 * (prune/shake/strip-images) calls `invalidateMessageCache`; streaming
 	 * assistants bypass the memo entirely (see the message-cache settle-gate
-	 * invariant). Image blocks charge {@link estimateImageContentTokens}, the
-	 * same dimension-based estimate the native remote-compaction probe applies.
+	 * invariant). Image blocks charge {@link imageTokens}, the same estimate
+	 * the native remote-compaction probe applies.
 	 */
 	countMessage(message: AgentMessage, options?: MessageCountOptions): number {
 		const floored = options?.excludeEncryptedReasoning === true;
@@ -245,6 +317,50 @@ export class Tokenizer {
 		return total;
 	}
 
+	/**
+	 * Input tokens for one image (not a snapcompact frame) under the reader's
+	 * catalog image rule, or the generic estimate when it has none.
+	 */
+	imageTokens(size: ImageSize | null | undefined, detail?: ImageDetail): number {
+		return estimateImageTokens(size, detail, this.#frameBilling.rule);
+	}
+
+	/**
+	 * Whether `message`'s signed reasoning reaches this reader natively: from
+	 * the same model, host and wire, or from another Claude model on the same
+	 * Anthropic deployment, which keeps the signature (`transformMessages`).
+	 * Claude bills that reasoning when the reader can read it and drops the
+	 * block otherwise, so such a turn counts high rather than low.
+	 */
+	#replaysReasoningNatively(message: AssistantMessage): boolean {
+		const reader = this.#reasoningReader;
+		return (
+			reader !== undefined &&
+			message.api === reader.api &&
+			message.provider === reader.provider &&
+			(message.model === reader.id || this.#readsDeploymentSignatures)
+		);
+	}
+
+	/**
+	 * The replayed native Responses reasoning {@link countMessage} charges
+	 * across `messages`: the part of a count that changes with the reading
+	 * model. A replay whose backend reported no reasoning tokens counts at the
+	 * signature price `countMessage` gives it.
+	 */
+	replayedReasoningTokens(messages: readonly AgentMessage[]): number {
+		let total = 0;
+		for (const message of messages) {
+			if (message.role !== "assistant") continue;
+			const replayed = this.#replayedReasoningTokens(message);
+			total +=
+				replayed === null
+					? this.countMessage(message) - this.countMessage(message, { excludeEncryptedReasoning: true })
+					: (replayed ?? 0);
+		}
+		return total;
+	}
+
 	#measureMessage(message: AgentMessage, excludeEncryptedReasoning: boolean): number {
 		const fragments: string[] = [];
 		let extra = 0;
@@ -273,35 +389,63 @@ export class Tokenizer {
 						if (block.type === "text" && block.text) {
 							fragments.push(block.text);
 						} else if (block.type === "image") {
-							extra += estimateImageContentTokens(block);
+							extra += this.imageTokens(base64ImageSize(block.data), block.detail);
 						}
 					}
 				}
 				break;
 			}
 			case "assistant": {
-				for (const block of message.content) {
+				// Replayed native Responses reasoning is billed as input at the turn's
+				// reported reasoning tokens, not at its ~3x larger ciphertext size, so it
+				// is a token price and counts in both arms. Its thinking signature never
+				// reaches the wire then (the payload items replay instead); a turn whose
+				// backend reported no reasoning tokens keeps the signature as its price.
+				const replayedReasoning = this.#replayedReasoningTokens(message);
+				if (typeof replayedReasoning === "number") extra += replayedReasoning;
+				const signaturesPriced = this.thinkingReplayTokens === "signature";
+				// The replay's signature rule (`transformMessages`): an aborted or
+				// errored turn's final block can hold a partial signature, and a turn
+				// whose tool calls ended without a tool-use stop is abandoned, so all
+				// its signatures are stripped. Every other block completed. The latest
+				// assistant turn keeps an abandoned turn's signatures byte-for-byte;
+				// a per-message count cannot see position, so it follows the rule for
+				// older turns, and that latest turn's own usage anchors transcript counts.
+				const content = message.content;
+				const invalidStop = message.stopReason === "aborted" || message.stopReason === "error";
+				const abandonedToolUse =
+					!invalidStop && message.stopReason !== "toolUse" && content.some(block => block.type === "toolCall");
+				const untrustedIndex = invalidStop ? content.length - 1 : -1;
+				let signedReasoning = false;
+				for (let index = 0; index < content.length; index++) {
+					const block = content[index];
 					if (block.type === "text") {
 						fragments.push(block.text);
 					} else if (block.type === "thinking") {
 						fragments.push(block.thinking);
 						// Providers charge for the opaque signature/reasoning payload that
 						// rides alongside the thinking text (OpenAI Responses encrypted
-						// reasoning items, Anthropic signed thinking blocks, etc.). Without
-						// counting it, this estimator can read ~half of the provider-reported
-						// usage on thinking-heavy turns — see #2275 for the resulting
-						// compaction-trigger / post-check metric divergence. The compaction
-						// floor excludes it (its local byte size diverges from provider billing).
-						if (block.thinkingSignature && !excludeEncryptedReasoning) {
+						// reasoning items, Gemini thought signatures). A reader billing at
+						// `output` size (Claude) charges the reasoning, priced below, not
+						// these bytes. The compaction floor excludes it (its local byte size
+						// diverges from provider billing).
+						if (
+							block.thinkingSignature &&
+							!excludeEncryptedReasoning &&
+							signaturesPriced &&
+							typeof replayedReasoning !== "number"
+						) {
 							fragments.push(block.thinkingSignature);
 						}
+						if (block.thinkingSignature && !abandonedToolUse && index !== untrustedIndex) signedReasoning = true;
 					} else if (block.type === "toolCall") {
 						fragments.push(block.name);
 						fragments.push(stringifyJson(block.arguments) ?? "null");
 					} else if (block.type === "redactedThinking") {
 						// Encrypted reasoning blob the provider still bills for on replay;
 						// excluded from the compaction floor for the same reason as above.
-						if (!excludeEncryptedReasoning) fragments.push(block.data);
+						signedReasoning = true;
+						if (!excludeEncryptedReasoning && signaturesPriced) fragments.push(block.data);
 					} else if (block.type === "anthropicServerTool") {
 						// Native Anthropic server-tool call/result replayed verbatim on the
 						// wire (server_tool_use input and opaque result content). The provider
@@ -311,6 +455,19 @@ export class Tokenizer {
 						if (!excludeEncryptedReasoning) fragments.push(stringifyJson(block.block) ?? "null");
 					}
 				}
+				// The visible text undercounts a native replay: the provider rebuilds
+				// the full reasoning from its signature, billed at the turn's output
+				// size less the visible text shake has since elided from it. The
+				// floor keeps the visible count.
+				if (
+					signedReasoning &&
+					!excludeEncryptedReasoning &&
+					!signaturesPriced &&
+					this.#replaysReasoningNatively(message)
+				) {
+					const visible = fragments.length === 0 ? extra : extra + this.countTokens(fragments);
+					return Math.max(visible, message.usage.output - (message.elidedOutputTokens ?? 0));
+				}
 				break;
 			}
 			case "custom":
@@ -323,7 +480,7 @@ export class Tokenizer {
 						if (block.type === "text" && block.text) {
 							fragments.push(block.text);
 						} else if (block.type === "image") {
-							extra += estimateImageContentTokens(block);
+							extra += this.imageTokens(base64ImageSize(block.data), block.detail);
 						}
 					}
 				}
@@ -354,6 +511,41 @@ export class Tokenizer {
 		return extra + this.countTokens(fragments);
 	}
 
+	/**
+	 * Input tokens this reader bills for replaying `message`'s native Responses
+	 * reasoning; `undefined` when the reader re-encodes the turn from its
+	 * blocks instead, `null` when it replays but the backend reported no
+	 * reasoning tokens to price it by. The payload goes back on the wire only
+	 * to the api, model and provider that produced it (`convertMessages` in
+	 * pi-ai's Responses providers), and then only what survives replay: a
+	 * truncated thinking-only turn is dropped, a hidden-empty or reasoning-only
+	 * payload sanitizes to nothing, and a cold session rebuilds the turn without
+	 * its reasoning, so those send no reasoning and no signature (0).
+	 */
+	#replayedReasoningTokens(message: AssistantMessage): number | null | undefined {
+		const reader = this.#reasoningReader;
+		if (!reader || message.api !== reader.api || message.model !== reader.id) return undefined;
+		const items = getOpenAIResponsesHistoryItems(message.providerPayload, reader.provider, message.provider);
+		if (!items) return undefined;
+		if (!items.some(item => item.type === "reasoning") || shouldDropTruncatedThinkingOnlyAssistant(message)) return 0;
+		const replay = sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(items);
+		if (!replay?.some(item => item.type === "reasoning")) return 0;
+		// Cold, only plaintext reasoning bound to no server state replays natively.
+		if (!this.nativeHistoryReplay && !isColdReplayableResponsesTurn(replay)) return 0;
+		return message.usage?.reasoningTokens ?? null;
+	}
+
+	/** Whether a Tokenizer built for `model` with `options` would count every message as this one does. */
+	countsAlike(model: TokenizerModel | null | undefined, options?: TokenizerOptions): boolean {
+		return (
+			tokenizerEncodingForModel(model) === this.#encoding &&
+			snapcompact.frameBillingKey(snapcompact.frameBilling(model ?? undefined)) === this.frameBillingKey &&
+			reasoningReplayKey(model) === this.reasoningReplayKey &&
+			resolveThinkingReplayTokens(model ?? {}) === this.thinkingReplayTokens &&
+			(options?.nativeHistoryReplay ?? true) === this.nativeHistoryReplay
+		);
+	}
+
 	/** One snapcompact frame at the active model's price for its pixel size; unreadable frames cost the ceiling. */
 	#frameTokens(data: string): number {
 		const size = base64ImageSize(data);

package/src/types.ts

@@ -338,6 +338,13 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 	 * tools finish first.
 	 */
 	hasQueuedAsides?: () => boolean | Promise<boolean>;
+	/**
+	 * Receives a tool's `onUpdate` frames that arrive after this run's event
+	 * stream ended: a call that returned while its background job keeps
+	 * reporting (`details.async`), whose run yielded before the job settled.
+	 * Without it those frames are dropped.
+	 */
+	onDetachedToolUpdate?: (event: Extract<AgentEvent, { type: "tool_execution_update" }>) => void;
 
 	/**
 	 * Returns follow-up messages to process after the agent would otherwise stop.