@linxiraos/pi-agent-core 1.2.0 → 1.3.0

package/src/compaction/openai.ts

@@ -42,6 +42,7 @@ import {
 	getOpenAIResponsesHistoryPayload,
 	normalizeResponsesToolCallId,
 	stripOpenAIResponsesOutputOnlyStatusesForReplay,
+	truncateResponseItemId,
 } from "@linxiraos/pi-ai/utils";
 import { captureOpenAIHttpError } from "@linxiraos/pi-ai/utils/openai-http";
 import { isBedrockOpenAIUrl } from "@linxiraos/pi-catalog/hosts";
@@ -54,7 +55,7 @@ import {
 	OPENAI_HEADERS,
 } from "@linxiraos/pi-catalog/wire/codex";
 import { $env, isRecord, logger, prompt, ptree, stringifyJson, structuredCloneJSON } from "@linxiraos/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,65 +83,94 @@ 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 {
-	value: unknown;
+/**
+ * A request as the model reads it: every string value decoded (no quoting or
+ * escapes), with keys and scalar values kept as one framing fragment.
+ */
+interface RemoteEstimateParts {
+	fragments: string[];
+	framing: string[];
 	imageTokens: number;
 }
 
-function normalizeRemoteCompactionEstimateValue(value: unknown, dropEncrypted = true): NormalizedEstimateValue {
+function collectRemoteCompactionEstimate(
+	value: unknown,
+	tokenizer: Tokenizer,
+	dropEncrypted: boolean,
+	parts: RemoteEstimateParts,
+): void {
+	if (typeof value === "string") {
+		if (value) parts.fragments.push(value);
+		return;
+	}
 	if (Array.isArray(value)) {
-		const normalized: unknown[] = [];
-		let imageTokens = 0;
-		for (const item of value) {
-			const result = normalizeRemoteCompactionEstimateValue(item, dropEncrypted);
-			normalized.push(result.value);
-			imageTokens += result.imageTokens;
-		}
-		return { value: normalized, imageTokens };
+		for (const item of value) collectRemoteCompactionEstimate(item, tokenizer, dropEncrypted, parts);
+		return;
+	}
+	if (value === null || typeof value !== "object") {
+		if (value !== undefined) parts.framing.push(String(value));
+		return;
 	}
-	if (!value || typeof value !== "object") return { value, imageTokens: 0 };
 
 	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 };
+		parts.imageTokens += cached.tokens;
+		return;
 	}
-
-	const normalized: Record<string, unknown> = {};
-	let imageTokens = 0;
-	for (const [key, item] of Object.entries(record)) {
+	for (const key in record) {
+		const item = record[key];
 		// Opaque encrypted reasoning/compaction state: its local base64 size far
 		// 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);
-		normalized[key] = result.value;
-		imageTokens += result.imageTokens;
+		if (item === undefined || (dropEncrypted && key === "encrypted_content" && typeof item === "string")) continue;
+		parts.framing.push(key);
+		collectRemoteCompactionEstimate(item, tokenizer, dropEncrypted, parts);
 	}
-	return { value: normalized, imageTokens };
+}
+
+/**
+ * Text fragments and image tokens for `value`. Strings count decoded: JSON
+ * escaping inflates quote-, backslash- and newline-dense text (code,
+ * disassembly) well past what the model reads.
+ */
+function remoteCompactionEstimateParts(
+	value: unknown,
+	tokenizer: Tokenizer,
+	dropEncrypted: boolean,
+): { fragments: string[]; imageTokens: number } {
+	const parts: RemoteEstimateParts = { fragments: [], framing: [], imageTokens: 0 };
+	collectRemoteCompactionEstimate(value, tokenizer, dropEncrypted, parts);
+	if (parts.framing.length > 0) parts.fragments.push(parts.framing.join(" "));
+	return { fragments: parts.fragments, imageTokens: parts.imageTokens };
 }
 
 /**
  * Tokens of stored Responses replacement history. Retained `input_image` parts
  * count at their image estimate rather than as base64 text; everything else,
- * opaque compaction state included, counts as serialized.
+ * opaque compaction state included, counts as decoded text.
  */
 export function countResponsesHistoryTokens(items: unknown[], tokenizer: Tokenizer): number {
-	const normalized = normalizeRemoteCompactionEstimateValue(items, false);
-	const serialized = stringifyJson(normalized.value);
-	return (serialized === undefined ? 0 : tokenizer.countTokens(serialized)) + normalized.imageTokens;
+	const { fragments, imageTokens } = remoteCompactionEstimateParts(items, tokenizer, false);
+	return (fragments.length === 0 ? 0 : tokenizer.countTokens(fragments)) + imageTokens;
 }
 
 export interface TrimRemoteCompactionInputResult {
@@ -169,10 +199,10 @@ interface RemoteCompactionBudgetProbe {
 /**
  * Cheap-first sizing of a remote-compaction request. Images (priced from their
  * dimensions) and the request frame come off the budget rather than through
- * the tokenizer; opaque `encrypted_content` payloads are excluded. The
- * serialized transcript is then probed with {@link Tokenizer.checkTokenBudget},
- * which only pays for an exact count when the byte bound cannot already prove
- * the request fits.
+ * the tokenizer; opaque `encrypted_content` payloads are excluded. The decoded
+ * request text is then probed with {@link Tokenizer.checkTokenBudget}, which
+ * only pays for an exact count when the byte bound cannot already prove the
+ * request fits.
  */
 function probeRemoteCompactionInputBudget(
 	input: Array<Record<string, unknown>>,
@@ -181,13 +211,16 @@ function probeRemoteCompactionInputBudget(
 	tools: unknown[] | undefined,
 	contextWindow: number | null | undefined,
 ): RemoteCompactionBudgetProbe {
-	const normalized = normalizeRemoteCompactionEstimateValue({ instructions, input, ...(tools ? { tools } : {}) });
-	const serialized = stringifyJson(normalized.value) ?? "";
-	const flatTokens = normalized.imageTokens + REMOTE_COMPACTION_REQUEST_OVERHEAD_TOKENS;
+	const { fragments, imageTokens } = remoteCompactionEstimateParts(
+		{ instructions, input, ...(tools ? { tools } : {}) },
+		tokenizer,
+		true,
+	);
+	const flatTokens = imageTokens + REMOTE_COMPACTION_REQUEST_OVERHEAD_TOKENS;
 	if (!contextWindow || contextWindow <= 0) {
-		return { tokens: tokenizer.countTokens(serialized, "upperbound") + flatTokens, fits: true, textFits: true };
+		return { tokens: tokenizer.countTokens(fragments, "upperbound") + flatTokens, fits: true, textFits: true };
 	}
-	const budget = tokenizer.checkTokenBudget(serialized, Math.max(0, contextWindow - flatTokens));
+	const budget = tokenizer.checkTokenBudget(fragments, Math.max(0, contextWindow - flatTokens));
 	return {
 		tokens: budget.tokens + flatTokens,
 		fits: budget.fits,
@@ -219,6 +252,16 @@ function isToolResultImageAttachment(item: Record<string, unknown>): boolean {
 	return hasLabel && hasImage;
 }
 
+/** Options for {@link trimRemoteCompactionInputToContextWindow}. */
+export interface TrimRemoteCompactionOptions {
+	/**
+	 * Whether oversized trailing tool outputs may be rewritten (default true).
+	 * False when a caller can compact a shorter prefix instead, so a kept tool
+	 * result replays intact rather than being replaced.
+	 */
+	rewriteOutputs?: boolean;
+}
+
 /**
  * Preserve the full native transcript unless trailing tool outputs alone push a
  * remote compaction request beyond the model window. Replacing only those
@@ -233,15 +276,16 @@ export function trimRemoteCompactionInputToContextWindow(
 	contextWindow: number | null | undefined,
 	instructions: string,
 	tools?: unknown[],
+	options?: TrimRemoteCompactionOptions,
 ): TrimRemoteCompactionInputResult {
 	const before = probeRemoteCompactionInputBudget(input, tokenizer, instructions, tools, contextWindow);
-	if (before.fits) {
+	if (before.fits || options?.rewriteOutputs === false) {
 		return {
 			input,
 			rewrittenOutputs: 0,
 			estimatedTokensBefore: before.tokens,
 			estimatedTokensAfter: before.tokens,
-			fits: true,
+			fits: before.fits || before.textFits,
 		};
 	}
 
@@ -670,8 +714,8 @@ export function buildOpenAiNativeHistory(
 					let msgId = parsedSignature?.id;
 					if (!msgId) {
 						msgId = `msg_${msgIndex}`;
-					} else if (msgId.length > 64) {
-						msgId = `msg_${Bun.hash(msgId).toString(36)}`;
+					} else {
+						msgId = truncateResponseItemId(msgId, "msg");
 					}
 					input.push({
 						type: "message",
@@ -816,6 +860,8 @@ export async function requestOpenAiRemoteCompaction(
 		sessionId?: string;
 		providerSessionState?: Map<string, ProviderSessionState>;
 		codexCompaction?: CodexCompactionContext;
+		/** Forwarded to {@link trimRemoteCompactionInputToContextWindow}. */
+		rewriteOutputs?: boolean;
 	},
 ): Promise<OpenAiRemoteCompactionResponse> {
 	let fetchImpl: FetchImpl = opts?.fetch ?? fetch;
@@ -829,6 +875,8 @@ export async function requestOpenAiRemoteCompaction(
 		new Tokenizer(model),
 		model.contextWindow,
 		instructions,
+		undefined,
+		{ rewriteOutputs: opts?.rewriteOutputs },
 	);
 	if (trimmed.rewrittenOutputs > 0) {
 		logger.info("Rewrote trailing tool outputs before OpenAI remote compaction", {

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/compaction/utils.ts

@@ -226,9 +226,10 @@ export function escapeSummaryBoundaryTags(text: string): string {
 
 /**
  * Serialize LLM messages as plain summary input without provider control tokens.
+ * `dropThinking` is the summarizer's resolved `classifier-cot-extraction` policy.
  */
-export function serializeConversationForSummary(messages: Message[], dialect?: Dialect): string {
-	const conversation = serializeConversation(messages, dialect);
+export function serializeConversationForSummary(messages: Message[], dialect?: Dialect, dropThinking = false): string {
+	const conversation = serializeConversation(messages, dialect, dropThinking);
 	const escaped = dialect === "harmony" ? escapeHarmonyControlTokens(conversation) : conversation;
 	return escapeSummaryBoundaryTags(escaped);
 }
@@ -236,8 +237,12 @@ export function serializeConversationForSummary(messages: Message[], dialect?: D
 /**
  * Serialize LLM messages to transcript text.
  * Call convertToLlm() first to handle custom message types.
+ * `dropThinking` omits assistant reasoning from dialect transcripts: set it from
+ * the reader's resolved `classifier-cot-extraction` catalog policy (Claude's
+ * classifier refuses inputs that reproduce the model's own reasoning as text,
+ * "reasoning_extraction"). Reasoning is ephemeral and low-signal for a summary.
  */
-export function serializeConversation(messages: Message[], dialect?: Dialect): string {
+export function serializeConversation(messages: Message[], dialect?: Dialect, dropThinking = false): string {
 	// Tool results flagged contextually useless (and their paired calls) are
 	// dropped from the serialized text: the source region is discarded after
 	// summarization anyway, so excluding them costs nothing and keeps garbage
@@ -249,13 +254,6 @@ export function serializeConversation(messages: Message[], dialect?: Dialect): s
 		}
 	}
 	if (dialect) {
-		// Claude's classifier refuses inputs that reproduce the model's own
-		// reasoning as text ("reasoning_extraction"), and the anthropic dialect
-		// otherwise renders thinking verbatim inside <thinking> tags. Reasoning is
-		// ephemeral and low-signal for a summary, so drop it from Anthropic-target
-		// summary input. Other dialects (e.g. Harmony) carry reasoning natively in
-		// their transcript format and keep it.
-		const dropThinking = dialect === "anthropic";
 		const processed: Message[] = [];
 		for (const msg of messages) {
 			if (msg.role === "assistant") {

package/src/image-tokens.ts

@@ -13,12 +13,10 @@ import { parseImageMetadata } from "@linxiraos/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/output-budget.ts

@@ -17,14 +17,23 @@ export const MIN_FITTED_OUTPUT_TOKENS = 1024;
  */
 const PROMPT_ESTIMATE_MARGIN_DIVISOR = 10;
 
+/**
+ * Chat-template framing charged per locally counted message. `Tokenizer.countMessage`
+ * counts content only, but every template wraps each message in role markers and
+ * separators, and tool results in response wrappers: about 5 tokens per merged
+ * Qwen3 `<tool_response>` or Llama 3 turn, 10–15 for harmony or Mistral tool results.
+ * The proportional margin scales with content, so many short messages (a turn's
+ * parallel tool results) leave this uncovered. Provider-anchored messages need no
+ * charge: the host's own report already includes their framing.
+ */
+export const MESSAGE_FRAMING_TOKENS = 16;
+
 /**
  * Absolute headway subtracted from the remaining room (unconditionally, on anchored and
- * fully-local counts alike). Proportional padding covers
- * tokenizer drift that scales with the prompt, but a host can still count a few tokens more
- * than any local estimate can see (chat-template framing, reasoning wrappers). Measured
- * against a 262,144-token host: fitted caps landed +11 to +42 tokens over and were rejected
- * with 400s. 64 tokens covers the observed drift with margin to spare; the
- * {@link MIN_FITTED_OUTPUT_TOKENS} floor still applies.
+ * fully-local counts alike). Covers per-request framing no message count sees: the
+ * generation prompt, the anchoring turn's end marker, reasoning wrappers. Measured
+ * against a 262,144-token host: fitted caps landed +11 to +42 tokens over and were
+ * rejected with 400s. The {@link MIN_FITTED_OUTPUT_TOKENS} floor still applies.
  */
 export const OUTPUT_FIT_HEADWAY_TOKENS = 64;
 
@@ -43,7 +52,9 @@ export const OUTPUT_FIT_HEADWAY_TOKENS = 64;
  * The prompt size is the provider's own report from the newest trustworthy
  * assistant turn (see {@link findRequestUsageAnchor}) plus a local count of
  * only the messages appended after it; the whole context is counted locally
- * only when no turn can anchor (fresh or freshly rewritten context).
+ * only when no turn can anchor (fresh or freshly rewritten context). Local
+ * counts carry a proportional tokenizer margin plus
+ * {@link MESSAGE_FRAMING_TOKENS} per message.
  *
  * Returns `maxTokens` unchanged when the requested cap already fits, the
  * model declares no window, the host ends generation at the window itself
@@ -122,12 +133,14 @@ function withMargin(localTokens: number): number {
 function countPromptTokens(context: Context, tokenizer: Tokenizer): number {
 	const { messages } = context;
 	const anchor = findRequestUsageAnchor(messages);
-	if (!anchor) return withMargin(countContextTokens(context, tokenizer));
+	if (!anchor) {
+		return withMargin(countContextTokens(context, tokenizer)) + messages.length * MESSAGE_FRAMING_TOKENS;
+	}
 	let tail = 0;
 	for (let index = anchor.index + 1; index < messages.length; index++) {
 		tail += tokenizer.countMessage(messages[index]);
 	}
-	return anchor.tokens + withMargin(tail);
+	return anchor.tokens + withMargin(tail) + (messages.length - anchor.index - 1) * MESSAGE_FRAMING_TOKENS;
 }
 
 function countContextTokens(context: Context, tokenizer: Tokenizer): number {