@agimon-ai/po-cache 0.0.0-alpha.0

package/dist/extensions/server.mjs

@@ -0,0 +1,3701 @@
+import { a as PO_PROMPT_CACHE_ROOT_SESSION_ENV, i as PO_PROMPT_CACHE_PARENT_NAMESPACE_ENV, r as PO_PROMPT_CACHE_CHILD_PROJECTION_ENV } from "../environment-vyw-n84h.mjs";
+import { c as createPromptCacheModelFingerprint, h as sha256Base64Url, i as rewritePromptCacheKey, l as createRootSessionIdentity, o as createParentPromptCacheNamespace, p as PromptCacheTelemetryService, s as createPromptCacheKey, t as PromptCacheTelemetry, u as canonicalJson } from "../promptCacheTelemetry-CguL1ZqT.mjs";
+import { createHash, randomUUID } from "node:crypto";
+import { composeServerProviderOverrides, defineServerPlugin } from "@agimon-ai/po-core/serverFacet";
+import { composeRootHooks, defineHook, defineRoot } from "@agimon-ai/po-core/extensionFile";
+import { getSessionHarnessState } from "@agimon-ai/po-config/harnessStore";
+import { DOOM_MINOR_MODE_CATALOG_SERVICE, readMinorModeCatalog } from "@agimon-ai/po-minor-mode";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { readFileSync, statSync } from "node:fs";
+import { lstat, mkdir, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+//#region src/services/environment/index.ts
+const environmentLeases = /* @__PURE__ */ new WeakMap();
+/** Same-value session leases restore only after the final owner leaves. External writes win. */
+function acquireEnvironmentValue(name, value, environment = process.env) {
+	let leases = environmentLeases.get(environment);
+	if (!leases) {
+		leases = /* @__PURE__ */ new Map();
+		environmentLeases.set(environment, leases);
+	}
+	let lease = leases.get(name);
+	if (lease && lease.value !== value) throw new Error(`Conflicting environment lease for ${name}.`);
+	if (!lease) {
+		const owner = new OwnedEnvironmentValue(name, environment);
+		owner.set(value);
+		lease = {
+			count: 0,
+			value,
+			owner
+		};
+		leases.set(name, lease);
+	}
+	lease.count++;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		if (--lease.count > 0) return;
+		lease.owner.restore();
+		leases.delete(name);
+	};
+}
+var OwnedEnvironmentValue = class {
+	#environment;
+	#name;
+	#baseline;
+	#ownedValue;
+	constructor(name, environment = process.env) {
+		this.#name = name;
+		this.#environment = environment;
+		this.#baseline = {
+			present: Object.hasOwn(environment, name),
+			value: environment[name]
+		};
+	}
+	set(value) {
+		this.#environment[this.#name] = value;
+		this.#ownedValue = value;
+	}
+	restore() {
+		if (this.#ownedValue === void 0 || this.#environment[this.#name] !== this.#ownedValue) return;
+		if (this.#baseline.present) this.#environment[this.#name] = this.#baseline.value;
+		else delete this.#environment[this.#name];
+		this.#ownedValue = void 0;
+	}
+};
+//#endregion
+//#region src/services/promptCacheUsage/index.ts
+function recordValue(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function nonNegativeNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function firstNumber(...values) {
+	for (const value of values) {
+		const number = nonNegativeNumber(value);
+		if (number !== void 0) return number;
+	}
+}
+function normalizedUsage(usage) {
+	const cacheRead = nonNegativeNumber(usage.cacheRead);
+	const cacheWrite = nonNegativeNumber(usage.cacheWrite);
+	if (cacheRead === void 0 && cacheWrite === void 0) return void 0;
+	const input = nonNegativeNumber(usage.input) ?? 0;
+	return {
+		cacheRead: cacheRead ?? 0,
+		cacheWrite: cacheWrite ?? 0,
+		totalInput: input + (cacheRead ?? 0) + (cacheWrite ?? 0)
+	};
+}
+function openAiUsage(usage) {
+	const promptDetails = recordValue(usage.prompt_tokens_details) ?? recordValue(usage.promptTokensDetails);
+	const inputDetails = recordValue(usage.input_tokens_details) ?? recordValue(usage.inputTokensDetails);
+	const cacheRead = firstNumber(promptDetails?.cached_tokens, promptDetails?.cachedTokens, inputDetails?.cached_tokens, inputDetails?.cachedTokens);
+	const cacheWrite = firstNumber(promptDetails?.cache_write_tokens, promptDetails?.cacheWriteTokens, inputDetails?.cache_write_tokens, inputDetails?.cacheWriteTokens);
+	if (cacheRead === void 0 && cacheWrite === void 0) return void 0;
+	const floor = (cacheRead ?? 0) + (cacheWrite ?? 0);
+	const reportedTotal = firstNumber(usage.prompt_tokens, usage.promptTokens, usage.input_tokens, usage.inputTokens);
+	return {
+		cacheRead: cacheRead ?? 0,
+		cacheWrite: cacheWrite ?? 0,
+		totalInput: Math.max(reportedTotal ?? floor, floor)
+	};
+}
+function anthropicUsage(usage) {
+	const cacheRead = firstNumber(usage.cache_read_input_tokens, usage.cacheReadInputTokens);
+	const cacheWrite = firstNumber(usage.cache_creation_input_tokens, usage.cacheCreationInputTokens);
+	if (cacheRead === void 0 && cacheWrite === void 0) return void 0;
+	const input = firstNumber(usage.input_tokens, usage.inputTokens) ?? 0;
+	return {
+		cacheRead: cacheRead ?? 0,
+		cacheWrite: cacheWrite ?? 0,
+		totalInput: input + (cacheRead ?? 0) + (cacheWrite ?? 0)
+	};
+}
+function geminiUsage(usage) {
+	const metadata = recordValue(usage.usage_metadata) ?? recordValue(usage.usageMetadata) ?? usage;
+	const cacheRead = firstNumber(metadata.cachedContentTokenCount, metadata.cached_content_token_count);
+	if (cacheRead === void 0) return void 0;
+	const totalInput = firstNumber(metadata.promptTokenCount, metadata.prompt_token_count, usage.input_tokens, usage.inputTokens, usage.prompt_tokens, usage.promptTokens);
+	return {
+		cacheRead,
+		cacheWrite: 0,
+		totalInput: Math.max(totalInput ?? cacheRead, cacheRead)
+	};
+}
+/** Normalize only usage values carried by a provider-produced assistant message. */
+function normalizePromptCacheUsage(message) {
+	const usage = recordValue(recordValue(message)?.usage);
+	if (!usage) return void 0;
+	return normalizedUsage(usage) ?? openAiUsage(usage) ?? anthropicUsage(usage) ?? geminiUsage(usage);
+}
+//#endregion
+//#region src/services/cacheRuntime/index.ts
+function stringValue(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function minorModeState(record) {
+	const state = record.state;
+	return {
+		source: record.descriptor.source,
+		id: record.descriptor.id,
+		activation: state.activation,
+		...state.modelContextVariant ? { modelContextVariant: state.modelContextVariant } : {}
+	};
+}
+function isErrorMessage(message) {
+	const record = typeof message === "object" && message !== null ? message : void 0;
+	return record?.stopReason === "error" || record?.stopReason === "aborted";
+}
+function createCacheRuntime(dependencies, environment) {
+	const parentNamespaceEnvironment = new OwnedEnvironmentValue(PO_PROMPT_CACHE_PARENT_NAMESPACE_ENV);
+	const rootSessionEnvironment = new OwnedEnvironmentValue(PO_PROMPT_CACHE_ROOT_SESSION_ENV);
+	const projectedParentNamespace = stringValue(environment[PO_PROMPT_CACHE_PARENT_NAMESPACE_ENV]);
+	const childProjection = stringValue(environment[PO_PROMPT_CACHE_CHILD_PROJECTION_ENV]);
+	const isProjectedChild = Boolean(projectedParentNamespace && childProjection);
+	let rootSessionId;
+	let parentNamespace = projectedParentNamespace;
+	let minorModes = [];
+	const refreshParentNamespace = () => {
+		if (isProjectedChild) return parentNamespace;
+		if (!rootSessionId) return void 0;
+		const harness = getSessionHarnessState(rootSessionId);
+		parentNamespace = createParentPromptCacheNamespace({
+			rootSessionId,
+			compositionFingerprint: harness.compositionFingerprint,
+			majorMode: harness.majorMode,
+			domains: harness.domains,
+			profile: harness.profile,
+			persona: harness.personaFile,
+			minorModes
+		}, sha256Base64Url);
+		parentNamespaceEnvironment.set(parentNamespace);
+		rootSessionEnvironment.set(createRootSessionIdentity(rootSessionId, sha256Base64Url));
+		return parentNamespace;
+	};
+	const plugin = (cordis) => {
+		cordis.inject([DOOM_MINOR_MODE_CATALOG_SERVICE], (context) => {
+			if (isProjectedChild) return void 0;
+			const catalog = readMinorModeCatalog(context);
+			if (!catalog) return void 0;
+			const refreshModes = () => {
+				minorModes = catalog.getSnapshot().modes.map(minorModeState);
+				refreshParentNamespace();
+			};
+			refreshModes();
+			return catalog.subscribe(refreshModes);
+		});
+	};
+	return {
+		plugin,
+		events: {
+			session_start: (_event, ctx) => {
+				if (!isProjectedChild) {
+					rootSessionId = stringValue(ctx.sessionId);
+					refreshParentNamespace();
+				}
+			},
+			message_end: (event) => {
+				if (isErrorMessage(event.message)) return;
+				const usage = normalizePromptCacheUsage(event.message);
+				if (usage) dependencies.telemetry.observe(usage, dependencies.now());
+			}
+		},
+		dispose: () => {
+			parentNamespaceEnvironment.restore();
+			rootSessionEnvironment.restore();
+			dependencies.telemetry.reset();
+		}
+	};
+}
+//#endregion
+//#region src/services/optimizerSupport/index.ts
+function createOptimizerSupport(STATE_DIR, environment) {
+	const MODELS_JSON_PATH = join(STATE_DIR, "models.json");
+	function isVirtualRoutingModel(model) {
+		return !!model && (isNativeVirtualModel(model) || model.provider.toLowerCase() === "router");
+	}
+	const ROUTED_FALLBACK_MODEL_SYMBOL = Symbol("pi-cache-optimizer.routed-fallback-model");
+	const LOG_PREFIX = "pi-cache-optimizer";
+	const STATE_FILE_PATH = join(STATE_DIR, "pi-cache-optimizer-stats.json");
+	const LEGACY_STATE_FILE_PATH = join(STATE_DIR, "deepseek-cache-optimizer-stats.json");
+	const SHARD_STATE_DIR = join(STATE_DIR, "pi-cache-optimizer-stats.d");
+	const SHARD_FILES_DIR = join(SHARD_STATE_DIR, "shards");
+	const SHARD_EPOCH_DIR = join(SHARD_STATE_DIR, "epochs");
+	const SHARD_MODEL_EPOCH_DIR = join(SHARD_EPOCH_DIR, "models");
+	const SHARD_MAINTENANCE_DIR = join(SHARD_STATE_DIR, "maintenance");
+	const SHARD_GLOBAL_EPOCH_PATH = join(SHARD_EPOCH_DIR, "global.json");
+	const SHARD_CLEANUP_LOCK_PATH = join(SHARD_MAINTENANCE_DIR, "cleanup.lock");
+	const SHARD_CLEANUP_MARKER_PATH = join(SHARD_MAINTENANCE_DIR, "last-cleanup");
+	const CONFIG_FILE_PATH = join(STATE_DIR, "pi-cache-optimizer-config.json");
+	const SHARD_RETENTION_MS = 1728e5;
+	const SHARD_TEMP_RETENTION_MS = 864e5;
+	const SHARD_CLEANUP_INTERVAL_MS = 216e5;
+	const SHARD_CLEANUP_LOCK_STALE_MS = 36e5;
+	const FOOTER_MODE_ENV = "PI_CACHE_OPTIMIZER_FOOTER_MODE";
+	const PI_VIRTUAL_MODEL_API = "pi-virtual";
+	const ASSISTANT_MESSAGE_MODEL_TOKEN_KEYS = ["model", "name"];
+	const OPENAI_REASONING_MODEL_PATTERN = /(^|[/\s:_-])o[1345]($|[-_.:/\s])/;
+	const XAI_MODEL_PATTERN = /(^|[/\s:_-])xai($|[-_.:/\s])/;
+	const MIMO_MODEL_PATTERN = /(^|[/\s:_-])mi-?mo($|[-_.:/\s])/i;
+	const PPLX_MODEL_PATTERN = /(^|[/\s:_-])pplx($|[-_.:/\s])/i;
+	const NOVA_MODEL_PATTERN = /(^|[/\s:_-])nova($|[-_.:/\s])/i;
+	const MPT_MODEL_PATTERN = /(^|[/\s:_-])mpt($|[-_.:/\s])/i;
+	const ALEPH_MODEL_PATTERN = /(^|[/\s:_-])aleph($|[-_.:/\s])/i;
+	const ARCTIC_MODEL_PATTERN = /(^|[/\s:_-])arctic($|[-_.:/\s])/i;
+	const AYA_MODEL_PATTERN = /(^|[/\s:_-])aya($|[-_.:/\s])/i;
+	const ORION_MODEL_PATTERN = /(^|[/\s:_-])orion($|[-_.:/\s])/i;
+	function hashSessionId(sessionId) {
+		return createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+	}
+	function firstNonEmptyString(...values) {
+		for (const value of values) if (isNonEmptyString(value)) return value.trim();
+	}
+	function isRoutedFallbackModel(model) {
+		return !!model && model[ROUTED_FALLBACK_MODEL_SYMBOL] === true;
+	}
+	function isNativeVirtualModel(model) {
+		return model?.api === PI_VIRTUAL_MODEL_API;
+	}
+	function makeSessionModelKey(sessionHash, provider, id) {
+		return `${sessionHash}:${provider}/${id}`;
+	}
+	function asRecord(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+		return value;
+	}
+	function lower(value) {
+		return typeof value === "string" ? value.toLowerCase() : "";
+	}
+	function getNumber(value) {
+		return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+	}
+	function getNonNegativeNumber(record, key) {
+		const value = getNumber(record[key]);
+		return value !== void 0 && value >= 0 ? value : void 0;
+	}
+	const NESTED_COMPAT_KEYS = [
+		"openRouterRouting",
+		"vercelGatewayRouting",
+		"chatTemplateKwargs",
+		"chatTemplateArgs"
+	];
+	function findLastExactModelDefinition(models, modelId) {
+		if (!models) return void 0;
+		for (let index = models.length - 1; index >= 0; index--) {
+			const candidate = asRecord(models[index]);
+			if (candidate?.id === modelId) return candidate;
+		}
+	}
+	function mergeCacheCompat(...sources) {
+		const merged = {};
+		for (const source of sources) {
+			if (!source) continue;
+			const previousNested = Object.fromEntries(NESTED_COMPAT_KEYS.map((key) => [key, asRecord(merged[key])]));
+			Object.assign(merged, source);
+			for (const key of NESTED_COMPAT_KEYS) {
+				const baseValue = previousNested[key];
+				const overrideValue = asRecord(source[key]);
+				if (baseValue || overrideValue) merged[key] = {
+					...baseValue,
+					...overrideValue
+				};
+			}
+		}
+		return merged;
+	}
+	function getEffectiveCompatSources(model, config) {
+		const provider = asRecord(asRecord(asRecord(config)?.providers)?.[model.provider]);
+		const providerCompat = asRecord(provider?.compat);
+		const customModelCompat = asRecord(asRecord(findLastExactModelDefinition(Array.isArray(provider?.models) ? provider.models : void 0, model.id))?.compat);
+		const runtimeCompat = asRecord(model.compat);
+		const modelOverrideCompat = asRecord(asRecord(asRecord(provider?.modelOverrides)?.[model.id])?.compat);
+		return [
+			...providerCompat ? [{
+				source: "provider",
+				compat: providerCompat
+			}] : [],
+			...customModelCompat ? [{
+				source: "model",
+				compat: customModelCompat
+			}] : [],
+			...runtimeCompat ? [{
+				source: "runtime",
+				compat: runtimeCompat
+			}] : [],
+			...modelOverrideCompat ? [{
+				source: "modelOverride",
+				compat: modelOverrideCompat
+			}] : []
+		];
+	}
+	function resolveEffectiveCompatFromConfig(model, config) {
+		return mergeCacheCompat(...getEffectiveCompatSources(model, config).map(({ compat }) => compat));
+	}
+	function isOptionalString(value) {
+		return value === void 0 || typeof value === "string" && value.length > 0;
+	}
+	function isOptionalBoolean(value) {
+		return value === void 0 || typeof value === "boolean";
+	}
+	function isFiniteNumber(value) {
+		return typeof value === "number" && Number.isFinite(value);
+	}
+	function isRecordOfStrings(value) {
+		const record = asRecord(value);
+		return !!record && Object.values(record).every((entry) => typeof entry === "string");
+	}
+	function isThinkingLevelMap(value) {
+		const map = asRecord(value);
+		if (!map) return false;
+		return [
+			"off",
+			"minimal",
+			"low",
+			"medium",
+			"high",
+			"xhigh",
+			"max"
+		].every((key) => map[key] === void 0 || map[key] === null || typeof map[key] === "string");
+	}
+	function isValidModelCostTier(value) {
+		const tier = asRecord(value);
+		return !!tier && isFiniteNumber(tier.inputTokensAbove) && isFiniteNumber(tier.input) && isFiniteNumber(tier.output) && isFiniteNumber(tier.cacheRead) && isFiniteNumber(tier.cacheWrite);
+	}
+	function isValidModelCost(value, partial) {
+		const cost = asRecord(value);
+		if (!cost) return false;
+		for (const key of [
+			"input",
+			"output",
+			"cacheRead",
+			"cacheWrite"
+		]) if ((!partial || cost[key] !== void 0) && !isFiniteNumber(cost[key])) return false;
+		return cost.tiers === void 0 || Array.isArray(cost.tiers) && cost.tiers.every(isValidModelCostTier);
+	}
+	function isValidModelDefinition(value) {
+		const model = asRecord(value);
+		if (!model || !isNonEmptyString(model.id)) return false;
+		if (!isOptionalString(model.name) || !isOptionalString(model.api) || !isOptionalString(model.baseUrl)) return false;
+		if (!isOptionalBoolean(model.reasoning) || !isValidCompatRecord(model.compat)) return false;
+		if (model.thinkingLevelMap !== void 0 && !isThinkingLevelMap(model.thinkingLevelMap)) return false;
+		if (model.input !== void 0 && (!Array.isArray(model.input) || !model.input.every((entry) => entry === "text" || entry === "image"))) return false;
+		if (model.cost !== void 0 && !isValidModelCost(model.cost, false)) return false;
+		if (model.contextWindow !== void 0 && !isFiniteNumber(model.contextWindow)) return false;
+		if (model.maxTokens !== void 0 && !isFiniteNumber(model.maxTokens)) return false;
+		if (model.samplingParams !== void 0 && !asRecord(model.samplingParams)) return false;
+		if (model.headers !== void 0 && !isRecordOfStrings(model.headers)) return false;
+		return true;
+	}
+	function isValidModelOverride(value) {
+		const override = asRecord(value);
+		if (!override || !isValidCompatRecord(override.compat)) return false;
+		if (!isOptionalString(override.name) || !isOptionalBoolean(override.reasoning)) return false;
+		if (override.thinkingLevelMap !== void 0 && !isThinkingLevelMap(override.thinkingLevelMap)) return false;
+		if (override.input !== void 0 && (!Array.isArray(override.input) || !override.input.every((entry) => entry === "text" || entry === "image"))) return false;
+		if (override.cost !== void 0 && !isValidModelCost(override.cost, true)) return false;
+		if (override.contextWindow !== void 0 && !isFiniteNumber(override.contextWindow)) return false;
+		if (override.maxTokens !== void 0 && !isFiniteNumber(override.maxTokens)) return false;
+		if (override.samplingParams !== void 0 && !asRecord(override.samplingParams)) return false;
+		if (override.headers !== void 0 && !isRecordOfStrings(override.headers)) return false;
+		return true;
+	}
+	function isValidOpenAICompletionsCompat(compat) {
+		if ([
+			"supportsStore",
+			"supportsDeveloperRole",
+			"supportsReasoningEffort",
+			"supportsUsageInStreaming",
+			"requiresToolResultName",
+			"requiresAssistantAfterToolResult",
+			"requiresThinkingAsText",
+			"requiresReasoningContentOnAssistantMessages",
+			"supportsOpenAIGrammarTools",
+			"supportsStrictMode",
+			"sendSessionAffinityHeaders",
+			"supportsLongCacheRetention"
+		].some((key) => !isOptionalBoolean(compat[key]))) return false;
+		if (compat.maxTokensField !== void 0 && compat.maxTokensField !== "max_completion_tokens" && compat.maxTokensField !== "max_tokens") return false;
+		if (compat.thinkingFormat !== void 0 && ![
+			"openai",
+			"openrouter",
+			"together",
+			"baseten",
+			"deepseek",
+			"zai",
+			"qwen",
+			"chat-template",
+			"qwen-chat-template",
+			"string-thinking",
+			"ant-ling"
+		].includes(typeof compat.thinkingFormat === "string" ? compat.thinkingFormat : "")) return false;
+		if (compat.cacheControlFormat !== void 0 && compat.cacheControlFormat !== "anthropic") return false;
+		if (compat.deferredToolsMode !== void 0 && compat.deferredToolsMode !== "kimi") return false;
+		if (compat.sessionAffinityFormat !== void 0 && ![
+			"openai",
+			"openai-nosession",
+			"openrouter"
+		].includes(typeof compat.sessionAffinityFormat === "string" ? compat.sessionAffinityFormat : "")) return false;
+		for (const key of NESTED_COMPAT_KEYS) if (compat[key] !== void 0 && !asRecord(compat[key])) return false;
+		return true;
+	}
+	function isValidOpenAIResponsesCompat(compat) {
+		if ([
+			"supportsDeveloperRole",
+			"supportsLongCacheRetention",
+			"supportsStrictMode",
+			"supportsOpenAIGrammarTools",
+			"supportsAdditionalTools",
+			"supportsToolSearch"
+		].some((key) => !isOptionalBoolean(compat[key]))) return false;
+		return compat.sessionAffinityFormat === void 0 || [
+			"openai",
+			"openai-nosession",
+			"openrouter"
+		].includes(typeof compat.sessionAffinityFormat === "string" ? compat.sessionAffinityFormat : "");
+	}
+	function isValidAnthropicMessagesCompat(compat) {
+		return [
+			"supportsEagerToolInputStreaming",
+			"supportsLongCacheRetention",
+			"sendSessionAffinityHeaders",
+			"supportsCacheControlOnTools",
+			"supportsTemperature",
+			"forceAdaptiveThinking",
+			"allowEmptySignature",
+			"supportsStrictTools",
+			"supportsToolReferences"
+		].every((key) => isOptionalBoolean(compat[key]));
+	}
+	function isValidCompatRecord(value) {
+		if (value === void 0) return true;
+		const compat = asRecord(value);
+		return !!compat && !Object.prototype.hasOwnProperty.call(compat, "supportsPromptCacheKey") && (isValidOpenAICompletionsCompat(compat) || isValidOpenAIResponsesCompat(compat) || isValidAnthropicMessagesCompat(compat));
+	}
+	function isValidModelsConfigForEffectiveCompat(value) {
+		const root = asRecord(value);
+		const providers = asRecord(root?.providers);
+		if (!root || !providers) return false;
+		for (const providerValue of Object.values(providers)) {
+			const provider = asRecord(providerValue);
+			if (!provider) return false;
+			if (!isOptionalString(provider.name) || !isOptionalString(provider.baseUrl) || !isOptionalString(provider.apiKey) || !isOptionalString(provider.api)) return false;
+			if (!isOptionalBoolean(provider.authHeader) || !isValidCompatRecord(provider.compat)) return false;
+			if (provider.oauth !== void 0 && provider.oauth !== "radius") return false;
+			if (provider.headers !== void 0 && !isRecordOfStrings(provider.headers)) return false;
+			if (provider.models !== void 0 && (!Array.isArray(provider.models) || !provider.models.every(isValidModelDefinition))) return false;
+			const overrides = provider.modelOverrides === void 0 ? void 0 : asRecord(provider.modelOverrides);
+			if (provider.modelOverrides !== void 0 && (!overrides || !Object.values(overrides).every(isValidModelOverride))) return false;
+		}
+		return true;
+	}
+	let modelsConfigCache;
+	function getModelsConfigSignature() {
+		try {
+			const info = statSync(MODELS_JSON_PATH);
+			return `${info.dev}:${info.ino}:${info.size}:${info.mtimeMs}:${info.ctimeMs}`;
+		} catch {
+			return "missing";
+		}
+	}
+	function readEffectiveCompatConfig() {
+		const signature = getModelsConfigSignature();
+		if (modelsConfigCache?.signature === signature) return modelsConfigCache.value;
+		let value;
+		if (signature !== "missing") try {
+			const parsed = parseJsonc(readFileSync(MODELS_JSON_PATH, "utf8"));
+			value = isValidModelsConfigForEffectiveCompat(parsed) ? parsed : void 0;
+		} catch {
+			value = void 0;
+		}
+		modelsConfigCache = {
+			signature,
+			value
+		};
+		return value;
+	}
+	function getCompat(model) {
+		if (!model) return {};
+		return resolveEffectiveCompatFromConfig(model, readEffectiveCompatConfig());
+	}
+	function joinDisplayPath(base, child, platform = process.platform) {
+		const sep = platform.startsWith("win") ? "\\" : "/";
+		return `${base.replace(/[\\/]+$/, "")}${sep}${child}`;
+	}
+	function getAgentDirDisplayPath(platform = process.platform, agentDir = STATE_DIR, homeDir = homedir()) {
+		const sep = platform.startsWith("win") ? "\\" : "/";
+		const normalizedAgentDir = agentDir.replace(/[\\/]+/g, sep);
+		const normalizedHomeDir = homeDir.replace(/[\\/]+/g, sep).replace(/[\\/]+$/, "");
+		const homePrefix = `${normalizedHomeDir}${sep}`;
+		if (normalizedAgentDir === normalizedHomeDir || normalizedAgentDir.startsWith(homePrefix)) {
+			const relative = normalizedAgentDir.slice(normalizedHomeDir.length).replace(/^[\\/]+/, "");
+			const homeLabel = platform.startsWith("win") ? "%USERPROFILE%" : "~";
+			return relative ? `${homeLabel}${sep}${relative}` : homeLabel;
+		}
+		return normalizedAgentDir;
+	}
+	function getModelsJsonDisplayPath(platform = process.platform, agentDir = STATE_DIR, homeDir = homedir()) {
+		return joinDisplayPath(getAgentDirDisplayPath(platform, agentDir, homeDir), "models.json", platform);
+	}
+	function parseFooterStatsMode(value) {
+		if (typeof value !== "string") return void 0;
+		const normalized = value.trim().toLowerCase();
+		return normalized === "session" || normalized === "total" || normalized === "process" ? normalized : void 0;
+	}
+	function parsePersistedCacheOptimizerConfig(value) {
+		const record = asRecord(value);
+		if (!record || record.version !== 1 && record.version !== 2 && record.version !== 3) return void 0;
+		const allowedTopLevel = new Set(record.version === 1 ? ["version", "footerMode"] : record.version === 2 ? [
+			"version",
+			"footerMode",
+			"promptCacheKey"
+		] : [
+			"version",
+			"footerMode",
+			"promptCacheKey",
+			"features"
+		]);
+		if (Object.keys(record).some((key) => !allowedTopLevel.has(key))) return void 0;
+		const footerMode = parseFooterStatsMode(record.footerMode);
+		if (record.footerMode !== void 0 && !footerMode) return void 0;
+		if (record.version === 1) return {
+			version: 1,
+			...footerMode ? { footerMode } : {}
+		};
+		const rawFeatures = record.version === 3 ? record.features : void 0;
+		if (rawFeatures !== void 0 && !asRecord(rawFeatures)) return void 0;
+		const featuresRecord = asRecord(rawFeatures);
+		const featureNames = /* @__PURE__ */ new Set([
+			"promptRewrite",
+			"virtualRewrite",
+			"skillCompression",
+			"openAICacheKey",
+			"toolOrder"
+		]);
+		if (featuresRecord && Object.keys(featuresRecord).some((key) => !featureNames.has(key) || typeof featuresRecord[key] !== "boolean")) return void 0;
+		const rawPromptCacheKey = record.promptCacheKey;
+		if (rawPromptCacheKey !== void 0 && !asRecord(rawPromptCacheKey)) return void 0;
+		const promptCacheKey = asRecord(rawPromptCacheKey);
+		if (promptCacheKey && Object.keys(promptCacheKey).some((key) => key !== "omit")) return void 0;
+		const omit = promptCacheKey?.omit;
+		if (omit !== void 0 && (!Array.isArray(omit) || omit.some((value) => !isNonEmptyString(value)))) return void 0;
+		const stringOmit = omit;
+		const uniqueOmit = stringOmit ? [...new Set(stringOmit.map((value) => value.trim()))].sort() : void 0;
+		return {
+			version: record.version === 3 ? 3 : 2,
+			...footerMode ? { footerMode } : {},
+			...uniqueOmit && uniqueOmit.length > 0 ? { promptCacheKey: { omit: uniqueOmit } } : {},
+			...featuresRecord ? { features: Object.fromEntries(Object.entries(featuresRecord)) } : {}
+		};
+	}
+	function normalizePersistedCacheOptimizerConfig(value) {
+		if (!value) return { version: 2 };
+		const features = value.version === 3 ? value.features : void 0;
+		return {
+			version: features ? 3 : 2,
+			...value.footerMode ? { footerMode: value.footerMode } : {},
+			...value.version !== 1 && value.promptCacheKey ? { promptCacheKey: value.promptCacheKey } : {},
+			...features ? { features } : {}
+		};
+	}
+	function readPersistedCacheOptimizerConfig(configPath = CONFIG_FILE_PATH) {
+		try {
+			return normalizePersistedCacheOptimizerConfig(parsePersistedCacheOptimizerConfig(JSON.parse(readFileSync(configPath, "utf8"))));
+		} catch (error) {
+			if (getErrorCode(error) !== "ENOENT") console.warn(`${LOG_PREFIX}: failed to read optimizer config; using defaults`, error);
+			return { version: 2 };
+		}
+	}
+	function resolveFooterStatsMode(configuredMode, env = environment) {
+		if (configuredMode) return {
+			mode: configuredMode,
+			source: "config"
+		};
+		const envMode = parseFooterStatsMode(env[FOOTER_MODE_ENV]);
+		return envMode ? {
+			mode: envMode,
+			source: "env"
+		} : {
+			mode: "session",
+			source: "default"
+		};
+	}
+	function footerStatsMode(env = environment, configuredMode = persistedFooterStatsMode) {
+		return resolveFooterStatsMode(configuredMode, env).mode;
+	}
+	const persistedFooterStatsMode = readPersistedCacheOptimizerConfig().footerMode;
+	function isAssistantMessage(message) {
+		return asRecord(message)?.role === "assistant";
+	}
+	function getAssistantRecord(message) {
+		const record = asRecord(message);
+		return record?.role === "assistant" ? record : void 0;
+	}
+	function getModelIdNameTokenValues(model) {
+		if (!model) return [];
+		return [model.id, model.name].map(lower).filter(Boolean);
+	}
+	function getAssistantMessageModelTokenValues(message) {
+		const record = asRecord(message);
+		if (!record) return [];
+		return ASSISTANT_MESSAGE_MODEL_TOKEN_KEYS.map((key) => lower(record[key])).filter(Boolean);
+	}
+	function hasAnyTokenContaining(tokens, needles) {
+		return tokens.some((token) => needles.some((needle) => token.includes(needle)));
+	}
+	function modelOrAssistantMessageHas(message, model, needles) {
+		return hasAnyTokenContaining([...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)], needles);
+	}
+	function isDeepSeekLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["deepseek"]);
+	}
+	function isDeepSeekLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["deepseek"]);
+	}
+	function isOpenAICompatibleApi(api) {
+		const value = lower(api);
+		return value === "openai-completions" || value === "openai-responses";
+	}
+	function isOpenAICompatibleProxyApi(api) {
+		return lower(api) === "openai-completions";
+	}
+	function isPiBuiltInLlamaCppModel(model) {
+		if (lower(model?.provider) !== "llama.cpp" || !isOpenAICompatibleProxyApi(model?.api)) return false;
+		const compat = getCompat(model);
+		return compat.supportsStore === false && compat.supportsDeveloperRole === false && compat.supportsReasoningEffort === false && compat.supportsStrictMode === false && compat.maxTokensField === "max_tokens" && compat.sendSessionAffinityHeaders === void 0 && compat.sessionAffinityFormat === void 0 && compat.supportsLongCacheRetention === void 0;
+	}
+	function hasAnthropicCacheTtlOrderError(message) {
+		const record = getAssistantRecord(message);
+		if (record?.stopReason !== "error" || typeof record.errorMessage !== "string") return false;
+		const error = lower(record.errorMessage);
+		return error.includes("cache_control") && error.includes("ttl='1h'") && error.includes("ttl='5m'") && error.includes("must not come after");
+	}
+	function isOpenAIFamilyToken(token) {
+		return token.includes("gpt-") || token.includes("chatgpt") || OPENAI_REASONING_MODEL_PATTERN.test(token);
+	}
+	function isOpenAIFamilyModel(model) {
+		return getModelIdNameTokenValues(model).some(isOpenAIFamilyToken);
+	}
+	function isOpenAIFamilyAssistantMessage(message, model) {
+		return [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)].some(isOpenAIFamilyToken);
+	}
+	function isClaudeLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["anthropic", "claude"]);
+	}
+	function isClaudeLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["anthropic", "claude"]);
+	}
+	function isGeminiLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["gemini", "vertex"]);
+	}
+	function isGeminiLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["gemini", "vertex"]);
+	}
+	const ADAPTIVE_OPUS_PATTERN = /(^|[/\s:_-])(opus-4[.-][6-9]|opus-4-[1-9][0-9]|opus-([5-9]|[1-9][0-9]))($|[-_.:/\s[])/i;
+	const ADAPTIVE_SONNET_PATTERN = /(^|[/\s:_-])(sonnet-4[.-][6-9]|sonnet-4-[1-9][0-9]|sonnet-([5-9]|[1-9][0-9]))($|[-_.:/\s[])/i;
+	const ADAPTIVE_FABLE_PATTERN = /(^|[/\s:_-])fable-([5-9]|[1-9][0-9])($|[-_.:/\s[])/i;
+	function isAdaptiveGenerationModel(model) {
+		if (!model) return false;
+		return getModelIdNameTokenValues(model).some((t) => ADAPTIVE_OPUS_PATTERN.test(t) || ADAPTIVE_SONNET_PATTERN.test(t) || ADAPTIVE_FABLE_PATTERN.test(t));
+	}
+	function isKimiCodingAdaptiveModel(model) {
+		if (!model) return false;
+		const provider = lower(model.provider);
+		const baseUrl = lower(model.baseUrl);
+		if (!(provider.includes("kimi-coding") || baseUrl.includes("api.kimi.com/coding"))) return false;
+		return getModelIdNameTokenValues(model).some((token) => token === "k3" || token.includes("kimi-k3") || token.includes("kimi k3") || token.includes("kimi-for-coding") || token.includes("kimi for coding"));
+	}
+	function isKimiCodingEmptySignatureModel(model) {
+		if (!isKimiCodingAdaptiveModel(model)) return false;
+		return getModelIdNameTokenValues(model).some((token) => token === "k3" || token === "kimi-k3" || token.startsWith("kimi-k3-") || token === "kimi k3" || token === "kimi-for-coding" || token === "kimi for coding");
+	}
+	function isAdaptiveThinkingCompatApplicable(model) {
+		if (isRoutedFallbackModel(model) && !isNonEmptyString(model.baseUrl)) return false;
+		return lower(model.api) === "anthropic-messages" && (isAdaptiveGenerationModel(model) || isKimiCodingAdaptiveModel(model));
+	}
+	function describeMissingAdaptiveThinkingCompat(model) {
+		const compat = getCompat(model);
+		const missing = [];
+		if (compat.forceAdaptiveThinking !== true) missing.push("forceAdaptiveThinking");
+		if (isKimiCodingEmptySignatureModel(model) && compat.allowEmptySignature !== true) missing.push("allowEmptySignature");
+		return missing;
+	}
+	function buildAdaptiveThinkingCompatSuggestion(missing) {
+		const suggestion = {};
+		if (missing.includes("forceAdaptiveThinking")) suggestion.forceAdaptiveThinking = true;
+		if (missing.includes("allowEmptySignature")) suggestion.allowEmptySignature = true;
+		return suggestion;
+	}
+	function appendAdaptiveThinkingCompatAdviceLines(lines, missing, placement = {}) {
+		const suggestion = buildAdaptiveThinkingCompatSuggestion(missing);
+		if (Object.keys(suggestion).length > 0) {
+			lines.push("Suggested fix:");
+			lines.push(JSON.stringify(suggestion, null, 2));
+		}
+		lines.push("- forceAdaptiveThinking: true tells Pi to use adaptive thinking format");
+		lines.push("  (thinking: {type: 'adaptive'}) instead of legacy budget tokens format.");
+		lines.push("  Without this flag, Pi sends legacy thinking which adaptive-only upstreams reject.");
+		if (missing.includes("allowEmptySignature")) lines.push("- allowEmptySignature: true preserves Kimi Coding K3 thinking blocks whose replay signature is empty.");
+		appendCredentialSafeProviderGuidance(lines, placement, suggestion);
+	}
+	function buildAdaptiveThinkingCompatWarningText(key, missing) {
+		const slashIdx = key.indexOf("/");
+		const providerLabel = slashIdx > 0 ? key.slice(0, slashIdx) : key;
+		const modelId = slashIdx > 0 ? key.slice(slashIdx + 1) : void 0;
+		const modelsJsonPath = getModelsJsonDisplayPath();
+		const lines = [
+			`💡 pi-cache-optimizer: ${key} is an adaptive-generation model but merged compat lacks ${missing.join(" and ")}.`,
+			`Without the required compat, Pi may send legacy thinking or replay thinking blocks incorrectly.`,
+			`Edit ${modelsJsonPath} -> providers["${providerLabel}"] -> compat (at the same level as baseUrl/api/apiKey/models).`,
+			""
+		];
+		appendAdaptiveThinkingCompatAdviceLines(lines, missing, {
+			providerLabel,
+			modelId
+		});
+		return lines.join("\n");
+	}
+	function isKimiLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["kimi"]);
+	}
+	function isKimiLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["kimi"]);
+	}
+	function isQwenLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["qwen"]);
+	}
+	function isQwenLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["qwen"]);
+	}
+	function isGLMLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["glm"]);
+	}
+	function isGLMLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["glm"]);
+	}
+	function isMiniMaxLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["minimax"]);
+	}
+	function isMiniMaxLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["minimax"]);
+	}
+	function isMimoLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, ["xiaomimimo"]) || tokens.some((t) => MIMO_MODEL_PATTERN.test(t));
+	}
+	function isMimoLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, ["xiaomimimo"]) || allTokens.some((t) => MIMO_MODEL_PATTERN.test(t));
+	}
+	function isHunyuanLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["hunyuan"]);
+	}
+	function isHunyuanLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["hunyuan"]);
+	}
+	function isMistralLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"mistral",
+			"mixtral",
+			"codestral"
+		]);
+	}
+	function isMistralLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"mistral",
+			"mixtral",
+			"codestral"
+		]);
+	}
+	function isGrokLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, ["grok"]) || tokens.some((t) => XAI_MODEL_PATTERN.test(t));
+	}
+	function isGrokLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, ["grok"]) || allTokens.some((t) => XAI_MODEL_PATTERN.test(t));
+	}
+	function isLlamaLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["llama"]);
+	}
+	function isLlamaLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["llama"]);
+	}
+	function isNemotronLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["nemotron"]);
+	}
+	function isNemotronLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["nemotron"]);
+	}
+	function isCohereLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["cohere", "command-r"]);
+	}
+	function isCohereLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["cohere", "command-r"]);
+	}
+	const YI_MODEL_PATTERN = /(^|[/\s:_-])yi($|[-_.:/\s])/;
+	function isYiLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, [
+			"yi-",
+			"01-ai",
+			"zero-one"
+		]) || tokens.some((t) => YI_MODEL_PATTERN.test(t));
+	}
+	function isYiLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, [
+			"yi-",
+			"01-ai",
+			"zero-one"
+		]) || allTokens.some((t) => YI_MODEL_PATTERN.test(t));
+	}
+	const DOUBAO_SEED_PATTERN = /(^|[/\s:_-])seed($|[-_.:/\s])/i;
+	function isDoubaoLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, [
+			"doubao",
+			"豆包",
+			"volcengine",
+			"bytedance",
+			"byte-dance"
+		]) || tokens.some((t) => DOUBAO_SEED_PATTERN.test(t));
+	}
+	function isDoubaoLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, [
+			"doubao",
+			"豆包",
+			"volcengine",
+			"bytedance",
+			"byte-dance"
+		]) || allTokens.some((t) => DOUBAO_SEED_PATTERN.test(t));
+	}
+	function isErnieLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"ernie",
+			"wenxin",
+			"文心",
+			"yiyan",
+			"一言",
+			"baidu"
+		]);
+	}
+	function isErnieLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"ernie",
+			"wenxin",
+			"文心",
+			"yiyan",
+			"一言",
+			"baidu"
+		]);
+	}
+	function isBaichuanLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["baichuan", "百川"]);
+	}
+	function isBaichuanLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["baichuan", "百川"]);
+	}
+	function isStepFunLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["stepfun", "step-"]);
+	}
+	function isStepFunLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["stepfun", "step-"]);
+	}
+	function isSparkLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"spark",
+			"xinghuo",
+			"星火",
+			"iflytek",
+			"讯飞"
+		]);
+	}
+	function isSparkLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"spark",
+			"xinghuo",
+			"星火",
+			"iflytek",
+			"讯飞"
+		]);
+	}
+	function isInternLMLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"internlm",
+			"intern-lm",
+			"书生"
+		]);
+	}
+	function isInternLMLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"internlm",
+			"intern-lm",
+			"书生"
+		]);
+	}
+	function isGemmaLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["gemma"]);
+	}
+	function isGemmaLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["gemma"]);
+	}
+	const PHI_MODEL_PATTERN = /(^|[/\s:_-])phi($|[-_.:/\s])/i;
+	function isPhiLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, ["phi-"]) || tokens.some((t) => PHI_MODEL_PATTERN.test(t));
+	}
+	function isPhiLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, ["phi-"]) || allTokens.some((t) => PHI_MODEL_PATTERN.test(t));
+	}
+	function isJambaLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["jamba", "ai21"]);
+	}
+	function isJambaLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["jamba", "ai21"]);
+	}
+	function isSolarLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["solar", "upstage"]);
+	}
+	function isSolarLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["solar", "upstage"]);
+	}
+	function isPerplexityLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, ["sonar", "perplexity"]) || tokens.some((t) => PPLX_MODEL_PATTERN.test(t));
+	}
+	function isPerplexityLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, ["sonar", "perplexity"]) || allTokens.some((t) => PPLX_MODEL_PATTERN.test(t));
+	}
+	function isNovaLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, ["amazon-nova"]) || tokens.some((t) => NOVA_MODEL_PATTERN.test(t));
+	}
+	function isNovaLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, ["amazon-nova"]) || allTokens.some((t) => NOVA_MODEL_PATTERN.test(t));
+	}
+	function isRekaLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["reka"]);
+	}
+	function isRekaLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["reka"]);
+	}
+	function isFalconLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["falcon", "tiiuae"]);
+	}
+	function isFalconLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["falcon", "tiiuae"]);
+	}
+	function isDbrxLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["dbrx", "databricks"]);
+	}
+	function isDbrxLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["dbrx", "databricks"]);
+	}
+	function isMptLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, ["mosaicml", "mpt-"]) || tokens.some((t) => MPT_MODEL_PATTERN.test(t));
+	}
+	function isMptLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, ["mosaicml", "mpt-"]) || allTokens.some((t) => MPT_MODEL_PATTERN.test(t));
+	}
+	function isStableLMLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"stablelm",
+			"stable-lm",
+			"stability-ai"
+		]);
+	}
+	function isStableLMLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"stablelm",
+			"stable-lm",
+			"stability-ai"
+		]);
+	}
+	function isAquilaLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["aquila", "baai"]);
+	}
+	function isAquilaLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["aquila", "baai"]);
+	}
+	function isExaoneLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["exaone"]);
+	}
+	function isExaoneLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["exaone"]);
+	}
+	function isHyperCLOVALikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["hyperclova", "clova-x"]);
+	}
+	function isHyperCLOVALikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["hyperclova", "clova-x"]);
+	}
+	function isLuminousLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, ["luminous", "aleph-alpha"]) || tokens.some((t) => ALEPH_MODEL_PATTERN.test(t));
+	}
+	function isLuminousLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, ["luminous", "aleph-alpha"]) || allTokens.some((t) => ALEPH_MODEL_PATTERN.test(t));
+	}
+	function isHermesLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"nous",
+			"hermes",
+			"openhermes"
+		]);
+	}
+	function isHermesLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"nous",
+			"hermes",
+			"openhermes"
+		]);
+	}
+	function isGraniteLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["granite", "ibm-granite"]);
+	}
+	function isGraniteLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["granite", "ibm-granite"]);
+	}
+	function isArcticLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, ["snowflake-arctic"]) || tokens.some((t) => ARCTIC_MODEL_PATTERN.test(t));
+	}
+	function isArcticLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, ["snowflake-arctic"]) || allTokens.some((t) => ARCTIC_MODEL_PATTERN.test(t));
+	}
+	function isPanguLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"pangu",
+			"pan-gu",
+			"盘古",
+			"huawei-pangu"
+		]);
+	}
+	function isPanguLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"pangu",
+			"pan-gu",
+			"盘古",
+			"huawei-pangu"
+		]);
+	}
+	function isSenseNovaLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"sensenova",
+			"sense-nova",
+			"sensechat",
+			"商汤"
+		]);
+	}
+	function isSenseNovaLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"sensenova",
+			"sense-nova",
+			"sensechat",
+			"商汤"
+		]);
+	}
+	function isZhinaoLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"360gpt",
+			"360-gpt",
+			"zhinao",
+			"智脑"
+		]);
+	}
+	function isZhinaoLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"360gpt",
+			"360-gpt",
+			"zhinao",
+			"智脑"
+		]);
+	}
+	function isMiniCPMLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"minicpm",
+			"mini-cpm",
+			"openbmb"
+		]);
+	}
+	function isMiniCPMLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"minicpm",
+			"mini-cpm",
+			"openbmb"
+		]);
+	}
+	function isXVerseLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["xverse"]);
+	}
+	function isXVerseLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["xverse"]);
+	}
+	function isOrionLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, ["orionstar", "orion-star"]) || tokens.some((t) => ORION_MODEL_PATTERN.test(t));
+	}
+	function isOrionLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, ["orionstar", "orion-star"]) || allTokens.some((t) => ORION_MODEL_PATTERN.test(t));
+	}
+	function isOpenChatLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["openchat"]);
+	}
+	function isOpenChatLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["openchat"]);
+	}
+	function isVicunaLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["vicuna"]);
+	}
+	function isVicunaLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["vicuna"]);
+	}
+	function isWizardLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), [
+			"wizardlm",
+			"wizard-lm",
+			"wizardcoder",
+			"wizard-coder"
+		]);
+	}
+	function isWizardLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, [
+			"wizardlm",
+			"wizard-lm",
+			"wizardcoder",
+			"wizard-coder"
+		]);
+	}
+	function isZephyrLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["zephyr"]);
+	}
+	function isZephyrLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["zephyr"]);
+	}
+	function isDolphinLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["dolphin"]);
+	}
+	function isDolphinLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["dolphin"]);
+	}
+	function isOpenOrcaLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["openorca", "open-orca"]);
+	}
+	function isOpenOrcaLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["openorca", "open-orca"]);
+	}
+	function isStarlingLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["starling"]);
+	}
+	function isStarlingLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["starling"]);
+	}
+	function isBloomLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["bloom", "bigscience"]);
+	}
+	function isBloomLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["bloom", "bigscience"]);
+	}
+	function isRwkvLikeModel(model) {
+		return hasAnyTokenContaining(getModelIdNameTokenValues(model), ["rwkv"]);
+	}
+	function isRwkvLikeAssistantMessage(message, model) {
+		return modelOrAssistantMessageHas(message, model, ["rwkv"]);
+	}
+	function isAyaLikeModel(model) {
+		const tokens = getModelIdNameTokenValues(model);
+		return hasAnyTokenContaining(tokens, ["aya-expanse"]) || tokens.some((t) => AYA_MODEL_PATTERN.test(t));
+	}
+	function isAyaLikeAssistantMessage(message, model) {
+		const allTokens = [...getModelIdNameTokenValues(model), ...getAssistantMessageModelTokenValues(message)];
+		return hasAnyTokenContaining(allTokens, ["aya-expanse"]) || allTokens.some((t) => AYA_MODEL_PATTERN.test(t));
+	}
+	function modelKey(model) {
+		return `${model.provider}/${model.id}`;
+	}
+	function modelFromAssistantMessage(message, fallback) {
+		const record = getAssistantRecord(message);
+		if (!record) return fallback;
+		const id = firstNonEmptyString(record.responseModel, record.model, fallback?.id);
+		const provider = firstNonEmptyString(record.provider, fallback?.provider);
+		const api = firstNonEmptyString(record.api, fallback?.api) ?? "";
+		if (!id || !provider) return fallback;
+		const fallbackName = isNonEmptyString(fallback?.name) ? fallback.name : void 0;
+		const preservesFallbackIdentity = !isVirtualRoutingModel(fallback) && provider === fallback?.provider && id === fallback?.id && fallbackName !== void 0;
+		return {
+			...fallback,
+			id,
+			name: preservesFallbackIdentity ? fallbackName : id,
+			provider,
+			api,
+			baseUrl: fallback?.baseUrl ?? ""
+		};
+	}
+	/** Physical catalog identity for native virtual dispatch, including registry misses. */
+	function resolvePhysicalModel(dispatch, registered) {
+		const model = registered && registered.api !== PI_VIRTUAL_MODEL_API ? registered : {
+			provider: dispatch.provider,
+			id: dispatch.id,
+			name: dispatch.name,
+			api: dispatch.api === PI_VIRTUAL_MODEL_API ? "" : dispatch.api,
+			baseUrl: "",
+			[ROUTED_FALLBACK_MODEL_SYMBOL]: true
+		};
+		const provider = asRecord(asRecord(asRecord(readEffectiveCompatConfig())?.providers)?.[model.provider]);
+		const customModel = findLastExactModelDefinition(Array.isArray(provider?.models) ? provider.models : void 0, model.id);
+		const configuredApi = customModel?.api ?? provider?.api;
+		const configuredBaseUrl = customModel?.baseUrl ?? provider?.baseUrl;
+		const api = isNonEmptyString(model.api) ? model.api : isNonEmptyString(configuredApi) ? configuredApi : model.api;
+		const baseUrl = isNonEmptyString(model.baseUrl) ? model.baseUrl : isNonEmptyString(configuredBaseUrl) ? configuredBaseUrl : model.baseUrl;
+		return api === model.api && baseUrl === model.baseUrl ? model : {
+			...model,
+			api,
+			baseUrl
+		};
+	}
+	function consolidateDirectProviderStatsModel(statsModel, ctxModel) {
+		if (!statsModel || !ctxModel) return statsModel;
+		if (isVirtualRoutingModel(ctxModel)) return statsModel;
+		if (statsModel.provider !== ctxModel.provider) return statsModel;
+		const statsAdapter = selectAdapterForModel(statsModel);
+		const ctxAdapter = selectAdapterForModel(ctxModel);
+		if (!statsAdapter || !ctxAdapter || statsAdapter !== ctxAdapter) return statsModel;
+		if (statsModel.id === ctxModel.id) return statsModel;
+		return {
+			...statsModel,
+			id: ctxModel.id,
+			name: ctxModel.name || ctxModel.id
+		};
+	}
+	function usageRecordFromAssistant(message) {
+		return asRecord(getAssistantRecord(message)?.usage);
+	}
+	function getNestedRecord(record, key) {
+		return asRecord(record?.[key]);
+	}
+	function getFirstNonNegativeNumber(...values) {
+		for (const value of values) {
+			const number = getNumber(value);
+			if (number !== void 0 && number >= 0) return number;
+		}
+	}
+	function readCachedTokensFromDetails(details) {
+		return getFirstNonNegativeNumber(details?.cached_tokens, details?.cachedTokens);
+	}
+	function readCacheWriteFromDetails(details) {
+		return getFirstNonNegativeNumber(details?.cache_write_tokens, details?.cacheWriteTokens);
+	}
+	function getPiNormalizedUsage(message, allowInputOnly = false) {
+		const usage = usageRecordFromAssistant(message);
+		if (!usage) return void 0;
+		const input = getNonNegativeNumber(usage, "input");
+		const cacheRead = getNonNegativeNumber(usage, "cacheRead");
+		const cacheWrite = getNonNegativeNumber(usage, "cacheWrite");
+		if (!(cacheRead !== void 0 || cacheWrite !== void 0) && (input === void 0 || !allowInputOnly)) return void 0;
+		const computed = (input ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0);
+		const floor = (cacheRead ?? 0) + (cacheWrite ?? 0);
+		return {
+			cacheRead: cacheRead ?? 0,
+			cacheWrite: cacheWrite ?? 0,
+			totalInput: computed >= floor ? computed : floor
+		};
+	}
+	function getDeepSeekRawUsage(message) {
+		const usage = usageRecordFromAssistant(message);
+		if (!usage) return void 0;
+		const cacheRead = getFirstNonNegativeNumber(usage.prompt_cache_hit_tokens);
+		if (cacheRead === void 0) return void 0;
+		const cacheMiss = getFirstNonNegativeNumber(usage.prompt_cache_miss_tokens);
+		return {
+			cacheRead,
+			cacheWrite: 0,
+			totalInput: getFirstNonNegativeNumber(usage.prompt_tokens) ?? cacheRead + (cacheMiss ?? 0)
+		};
+	}
+	function getOpenAIRawUsage(message) {
+		const usage = usageRecordFromAssistant(message);
+		if (!usage) return void 0;
+		const promptDetails = getNestedRecord(usage, "prompt_tokens_details") ?? getNestedRecord(usage, "promptTokensDetails");
+		const inputDetails = getNestedRecord(usage, "input_tokens_details") ?? getNestedRecord(usage, "inputTokensDetails");
+		const cacheRead = readCachedTokensFromDetails(promptDetails) ?? readCachedTokensFromDetails(inputDetails);
+		if (cacheRead === void 0) return void 0;
+		const cacheWrite = readCacheWriteFromDetails(promptDetails) ?? readCacheWriteFromDetails(inputDetails) ?? 0;
+		return {
+			cacheRead,
+			cacheWrite,
+			totalInput: getFirstNonNegativeNumber(usage.prompt_tokens, usage.promptTokens, usage.input_tokens, usage.inputTokens) ?? cacheRead + cacheWrite
+		};
+	}
+	function getAnthropicRawUsage(message) {
+		const usage = usageRecordFromAssistant(message);
+		if (!usage) return void 0;
+		const cacheRead = getFirstNonNegativeNumber(usage.cache_read_input_tokens, usage.cacheReadInputTokens);
+		const cacheWrite = getFirstNonNegativeNumber(usage.cache_creation_input_tokens, usage.cacheCreationInputTokens);
+		if (cacheRead === void 0 && cacheWrite === void 0) return void 0;
+		const input = getFirstNonNegativeNumber(usage.input_tokens, usage.inputTokens) ?? 0;
+		return {
+			cacheRead: cacheRead ?? 0,
+			cacheWrite: cacheWrite ?? 0,
+			totalInput: input + (cacheRead ?? 0) + (cacheWrite ?? 0)
+		};
+	}
+	function getGeminiRawUsage(message) {
+		const record = getAssistantRecord(message);
+		if (!record) return void 0;
+		const usage = asRecord(record.usage);
+		const metadata = getNestedRecord(record, "usageMetadata") ?? getNestedRecord(record, "usage_metadata") ?? getNestedRecord(usage, "usageMetadata") ?? getNestedRecord(usage, "usage_metadata") ?? usage;
+		if (!metadata) return void 0;
+		const cacheRead = getFirstNonNegativeNumber(metadata.cachedContentTokenCount, metadata.cached_content_token_count);
+		if (cacheRead === void 0) return void 0;
+		return {
+			cacheRead,
+			cacheWrite: 0,
+			totalInput: getFirstNonNegativeNumber(metadata.promptTokenCount, metadata.prompt_token_count, metadata.inputTokenCount, metadata.input_token_count, usage?.input_tokens, usage?.inputTokens, usage?.prompt_tokens, usage?.promptTokens) ?? cacheRead
+		};
+	}
+	function normalizeWithFallback(message, rawNormalizer, options = {}) {
+		return getPiNormalizedUsage(message, options.allowInputOnlyPiUsage) ?? rawNormalizer(message);
+	}
+	function isNonEmptyString(value) {
+		return typeof value === "string" && value.trim().length > 0;
+	}
+	function isOfficialOpenAIBaseUrl(model) {
+		const value = lower(model.baseUrl).trim();
+		if (!value) return lower(model.provider) === "openai";
+		try {
+			return new URL(value).hostname === "api.openai.com";
+		} catch {
+			return value === "api.openai.com" || value.startsWith("api.openai.com/");
+		}
+	}
+	function isKnownThirdPartyOpenAIEndpoint(model) {
+		return isNonEmptyString(model.baseUrl) && !isOfficialOpenAIBaseUrl(model);
+	}
+	function describeMissingOpenAICompatibleProxyCompat(model) {
+		const compat = getCompat(model);
+		const missing = [];
+		if (!isOpenAICompatibleProxyApi(model.api)) return missing;
+		if (!isKnownThirdPartyOpenAIEndpoint(model)) return missing;
+		if (isPiBuiltInLlamaCppModel(model)) return missing;
+		if (compat.sendSessionAffinityHeaders === void 0) missing.push("sendSessionAffinityHeaders");
+		return missing;
+	}
+	function buildSafeOpenAIProxyCompatSuggestion(missing) {
+		const suggestion = {};
+		if (missing.includes("sendSessionAffinityHeaders")) suggestion.sendSessionAffinityHeaders = true;
+		return suggestion;
+	}
+	function getPromptCacheRetentionUnsupportedHint() {
+		return "If this channel returns `400 Unsupported parameter: prompt_cache_retention`, remove/avoid `supportsLongCacheRetention`; this extension does not write that field directly, but Pi may send it when long retention is requested and compat says the proxy supports it.";
+	}
+	function hasPromptCacheRetentionUnsupportedText(value) {
+		const normalized = lower(value);
+		if (!normalized.includes("prompt_cache_retention")) return false;
+		return [
+			"unsupported parameter",
+			"unsupported_parameter",
+			"unknown parameter",
+			"not supported",
+			"unsupported field",
+			"extra inputs",
+			"not permitted",
+			"unrecognized"
+		].some((needle) => normalized.includes(needle));
+	}
+	function hasPromptCacheRetentionUnsupportedErrorMessage(message) {
+		const record = getAssistantRecord(message);
+		return record?.stopReason === "error" && hasPromptCacheRetentionUnsupportedText(record.errorMessage);
+	}
+	function hasPromptCacheKeyUnsupportedText(value) {
+		const normalized = lower(value).replace(/["'`]/g, "").replace(/[\s_-]+/g, " ").replace(/\s+/g, " ").trim();
+		const key = String.raw`(?:prompt ?cache ?key|promptcachekey)`;
+		const field = String.raw`(?:parameter|field|input|argument)`;
+		const unsupported = String.raw`(?:unsupported|unknown|unrecognized|unexpected|not supported|not allowed|not permitted|must be omitted|should be omitted)`;
+		if (!new RegExp(key).test(normalized)) return false;
+		const terminal = String.raw`(?=$|[}\]>,.;])`;
+		return new RegExp(String.raw`(?:unsupported|unknown|unrecognized|unexpected)\s+${field}\s*[:=]?\s*${key}${terminal}`).test(normalized) || new RegExp(String.raw`(?:extra\s+inputs?|${field}\s+not\s+(?:allowed|permitted|supported))\s*[:=]\s*${key}${terminal}`).test(normalized) || new RegExp(String.raw`${key}(?:\s+${field})?\s*[:=]?\s*(?:is\s+)?${unsupported}${terminal}`).test(normalized);
+	}
+	function hasPromptCacheKeyUnsupportedErrorMessage(message) {
+		const record = getAssistantRecord(message);
+		return record?.stopReason === "error" && getOptionalAssistantHttpStatus(record) === 400 && hasPromptCacheKeyUnsupportedText(record.errorMessage);
+	}
+	function isPromptCacheKeyUnsupportedApplicable(model) {
+		return isOpenAICompatibleApi(model.api);
+	}
+	function hasReasoningProtocolRejectionText(value) {
+		const normalized = lower(value).replace(/\s+/g, " ").trim();
+		if (!normalized) return false;
+		const thinkingParameterRejectionPatterns = [
+			/(?:^|[^a-z0-9_])["'`]?thinking["'`]?(?:\s+(?:parameter|field|argument))?\s*(?:is\s+)?(?:not supported|unsupported|unknown|unrecognized|not allowed|not permitted|rejected|invalid|not valid|not accepted|disallowed|not a valid(?:\s+(?:parameter|field|argument))?)(?![a-z0-9_])/,
+			/(?:^|[^a-z0-9_])(?:unsupported|unknown|unrecognized|invalid|disallowed|rejected|not\s+(?:a\s+)?valid|not\s+accepted|not\s+allowed|not\s+permitted)(?:[_ ](?:parameter|field|argument))?\s*[:=]?\s*["'`]?thinking["'`]?(?![a-z0-9_])/,
+			/(?:^|[^a-z0-9_])(?:extra\s+inputs?|additional\s+(?:inputs?|parameters?))\s+(?:are\s+)?(?:not permitted|not allowed|unsupported)\s*[:=]?\s*["'`]?thinking["'`]?(?![a-z0-9_])/
+		];
+		let rejectionEnd = -1;
+		for (const pattern of thinkingParameterRejectionPatterns) {
+			const match = pattern.exec(normalized);
+			if (match && match.index + match[0].length > rejectionEnd) rejectionEnd = match.index + match[0].length;
+		}
+		if (rejectionEnd < 0) return false;
+		const recommendation = normalized.slice(rejectionEnd, rejectionEnd + 260);
+		if (!/\breasoning[_.]effort\b/.test(recommendation)) return false;
+		return recommendation.split(/[.;!?\n]/).some((clause) => {
+			if (!/\breasoning[_.]effort\b/.test(clause)) return false;
+			if (/\b(?:do\s+not|don't|never|avoid)\s+(?:use|set|send|pass|provide)?\s*["'`]?reasoning[_.]effort\b/.test(clause) || /\breasoning[_.]effort\b[^.;]{0,80}\b(?:must|should|may|do)\s+(?:not|never)\b/.test(clause) || /\breasoning[_.]effort\b[^.;]{0,80}\b(?:unsupported|disabled|unavailable|not\s+(?:supported|accepted|allowed|available|enabled|required|recommended|expected))\b/.test(clause)) return false;
+			return [
+				/(?:use|try|set|send|pass|provide)\s+(?:the\s+)?(?:top[- ]level\s+)?["'`]?reasoning[_.]effort["'`]?(?![a-z0-9_])/,
+				/(?:reasoning[_.]effort)\b[^.;]{0,120}(?:instead|required|must\s+be|should\s+be|is\s+(?:supported|accepted|preferred|recommended|expected))\b/,
+				/(?:parameter|field|option)\s+(?:is|should be)\s+["'`]?reasoning[_.]effort["'`]?(?![a-z0-9_])/,
+				/instead[^.;]{0,120}(?:use|try|set|send|pass|provide)\s+(?:the\s+)?["'`]?reasoning[_.]effort["'`]?(?![a-z0-9_])/,
+				/(?:replace|change|switch)\s+(?:the\s+)?["'`]?thinking["'`]?\s+(?:with|to)\s+["'`]?reasoning[_.]effort["'`]?(?![a-z0-9_])/
+			].some((pattern) => pattern.test(clause));
+		});
+	}
+	function getOptionalAssistantHttpStatus(record) {
+		const readStatus = (value) => {
+			if (typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599) return value;
+			if (typeof value === "string" && /^\d{3}$/.test(value.trim())) {
+				const parsed = Number(value.trim());
+				return parsed >= 100 && parsed <= 599 ? parsed : void 0;
+			}
+		};
+		for (const key of [
+			"status",
+			"statusCode",
+			"httpStatus",
+			"httpStatusCode"
+		]) {
+			const status = readStatus(record[key]);
+			if (status !== void 0) return status;
+		}
+		const scanDiagnosticStatus = (value, depth) => {
+			if (depth > 2) return void 0;
+			if (Array.isArray(value)) {
+				for (const item of value) {
+					const status = scanDiagnosticStatus(item, depth + 1);
+					if (status !== void 0) return status;
+				}
+				return;
+			}
+			const source = asRecord(value);
+			if (!source) return void 0;
+			for (const key of [
+				"status",
+				"statusCode",
+				"httpStatus",
+				"httpStatusCode",
+				"code"
+			]) {
+				const status = readStatus(source[key]);
+				if (status !== void 0) return status;
+			}
+			for (const key of [
+				"details",
+				"error",
+				"cause",
+				"diagnostics"
+			]) {
+				const status = scanDiagnosticStatus(source[key], depth + 1);
+				if (status !== void 0) return status;
+			}
+		};
+		for (const key of [
+			"diagnostics",
+			"diagnostic",
+			"details",
+			"error",
+			"cause"
+		]) {
+			const status = scanDiagnosticStatus(record[key], 0);
+			if (status !== void 0) return status;
+		}
+		if (typeof record.errorMessage === "string") {
+			const errorText = record.errorMessage;
+			for (const pattern of [
+				/^\s*([1-5]\d{2})\b/,
+				/^\s*(?:http(?:\s+status)?|status(?:\s+code)?)\s*[:(]?\s*([1-5]\d{2})\b/i,
+				/^\s*[^():\n]{1,100}\(\s*([1-5]\d{2})\b/,
+				/^\s*(?:error|api\s+error|provider\s+error|request\s+failed|http\s+error)\s*[:(]\s*([1-5]\d{2})\b/i
+			]) {
+				const match = pattern.exec(errorText);
+				if (match) return Number(match[1]);
+			}
+		}
+	}
+	function hasReasoningProtocolRejectionErrorMessage(message) {
+		const record = getAssistantRecord(message);
+		if (!record || record.stopReason !== "error") return false;
+		return getOptionalAssistantHttpStatus(record) === 400 && hasReasoningProtocolRejectionText(record.errorMessage);
+	}
+	function isReasoningProtocolRejectionSignalApplicable(model) {
+		return !!model && isOpenAICompatibleProxyApi(model.api) && isDeepSeekLikeModel(model);
+	}
+	function isReasoningProtocolRejectionForModel(message, model) {
+		if (!model || !isReasoningProtocolRejectionSignalApplicable(model)) return false;
+		if (!hasReasoningProtocolRejectionErrorMessage(message)) return false;
+		const record = getAssistantRecord(message);
+		if (!record) return false;
+		const messageProvider = firstNonEmptyString(record.provider);
+		const messageModel = firstNonEmptyString(record.responseModel, record.model);
+		return (!messageProvider || messageProvider === model.provider) && (!messageModel || messageModel === model.id);
+	}
+	function buildProviderCompatOverride(providerLabel, compat) {
+		return { providers: { [providerLabel]: { compat } } };
+	}
+	function buildModelCompatOverride(providerLabel, modelId, compat) {
+		return { providers: { [providerLabel]: { modelOverrides: { [modelId]: { compat } } } } };
+	}
+	function appendCredentialSafeProviderGuidance(lines, placement, compatSuggestion) {
+		const providerLabel = placement.providerLabel;
+		if (!providerLabel) return;
+		lines.push("");
+		lines.push("If this channel has no models.json provider entry yet:");
+		lines.push("- Keep existing authentication as-is; do not copy credentials, tokens, or API keys.");
+		lines.push(`- Add only cache/routing compat overrides in ${getModelsJsonDisplayPath()}.`);
+		if (Object.keys(compatSuggestion).length === 0) {
+			lines.push("- No safe copyable override is available for the missing flags shown above.");
+			return;
+		}
+		lines.push("Provider-level minimal override:");
+		lines.push(JSON.stringify(buildProviderCompatOverride(providerLabel, compatSuggestion), null, 2));
+		if (placement.modelId) {
+			lines.push("Single-model override (use this if only this model should change):");
+			lines.push(JSON.stringify(buildModelCompatOverride(providerLabel, placement.modelId, compatSuggestion), null, 2));
+		}
+	}
+	function appendOpenAIProxyCompatAdviceLines(lines, missing, options = {}) {
+		const suggestion = buildSafeOpenAIProxyCompatSuggestion(missing);
+		if (Object.keys(suggestion).length > 0) {
+			if (options.includeJsonIntro !== false) lines.push("Safe default suggestion:");
+			lines.push(JSON.stringify(suggestion, null, 2));
+		}
+		if (missing.includes("sendSessionAffinityHeaders")) lines.push("- sendSessionAffinityHeaders: recommended for third-party proxies when supported; it helps keep one Pi session on the same upstream/backend.");
+		appendCredentialSafeProviderGuidance(lines, options, suggestion);
+	}
+	function buildOpenAIProxyCompatWarningText(key, missing) {
+		const slashIdx = key.indexOf("/");
+		const providerLabel = slashIdx > 0 ? key.slice(0, slashIdx) : key;
+		const modelId = slashIdx > 0 ? key.slice(slashIdx + 1) : void 0;
+		const modelsJsonPath = getModelsJsonDisplayPath();
+		const lines = [
+			`💡 pi-cache-optimizer: ${key} is a third-party OpenAI-compatible proxy but merged compat lacks ${missing.join(" and ")}.`,
+			`Review a precise model-scoped repair (or edit ${modelsJsonPath} -> providers["${providerLabel}"] -> compat manually).`,
+			``
+		];
+		appendOpenAIProxyCompatAdviceLines(lines, missing, {
+			providerLabel,
+			modelId
+		});
+		return lines.join("\n");
+	}
+	function isDeepSeekWireCompatApplicable(model) {
+		return isDeepSeekLikeModel(model) && isOpenAICompatibleProxyApi(model.api) && getCompat(model).thinkingFormat === "deepseek";
+	}
+	function describeMissingDeepSeekCompat(model) {
+		if (!isDeepSeekWireCompatApplicable(model)) return [];
+		const compat = getCompat(model);
+		const missing = [];
+		if (compat.requiresReasoningContentOnAssistantMessages !== true) missing.push("requiresReasoningContentOnAssistantMessages");
+		return missing;
+	}
+	function isDeepSeekCompatCheckApplicable(model) {
+		return isDeepSeekWireCompatApplicable(model);
+	}
+	function describeMissingCacheCompatForModel(model) {
+		if (isAdaptiveThinkingCompatApplicable(model)) return describeMissingAdaptiveThinkingCompat(model);
+		const missing = describeMissingOpenAICompatibleProxyCompat(model);
+		if (isDeepSeekWireCompatApplicable(model)) missing.push(...describeMissingDeepSeekCompat(model));
+		return missing;
+	}
+	function buildDeepSeekCompatSuggestion(missing) {
+		const suggestion = { ...buildSafeOpenAIProxyCompatSuggestion(missing) };
+		if (missing.includes("requiresReasoningContentOnAssistantMessages")) suggestion.requiresReasoningContentOnAssistantMessages = true;
+		return suggestion;
+	}
+	function appendDeepSeekCompatAdviceLines(lines, missing, placement = {}) {
+		const suggestion = buildDeepSeekCompatSuggestion(missing);
+		if (Object.keys(suggestion).length > 0) {
+			lines.push("Recommended DeepSeek reasoning/replay compat snippet:");
+			lines.push(JSON.stringify(suggestion, null, 2));
+		}
+		if (missing.includes("requiresReasoningContentOnAssistantMessages")) lines.push("- requiresReasoningContentOnAssistantMessages: true keeps replayed assistant turns compatible with an explicitly selected DeepSeek reasoning wire format.");
+		if (missing.includes("sendSessionAffinityHeaders")) lines.push("- sendSessionAffinityHeaders: recommended for third-party OpenAI-compatible proxies when supported; it helps keep one Pi session on the same upstream/backend.");
+		appendCredentialSafeProviderGuidance(lines, placement, suggestion);
+	}
+	function buildDeepSeekCompatWarningText(key, missing) {
+		const slashIdx = key.indexOf("/");
+		const providerLabel = slashIdx > 0 ? key.slice(0, slashIdx) : key;
+		const modelId = slashIdx > 0 ? key.slice(slashIdx + 1) : void 0;
+		const modelsJsonPath = getModelsJsonDisplayPath();
+		const lines = [
+			`💡 pi-cache-optimizer: ${key} is DeepSeek-like but merged compat lacks ${missing.join(" and ")}.`,
+			`Proxies may reduce or hide cache hits. Edit ${modelsJsonPath} -> providers["${providerLabel}"] -> compat (at the same level as baseUrl/api/apiKey/models).`,
+			""
+		];
+		appendDeepSeekCompatAdviceLines(lines, missing, {
+			providerLabel,
+			modelId
+		});
+		return lines.join("\n");
+	}
+	const CACHE_PROVIDER_ADAPTERS = [
+		{
+			id: "deepseek",
+			label: "DS cache",
+			matchesModel: isDeepSeekLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isDeepSeekLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getDeepSeekRawUsage, { allowInputOnlyPiUsage: true });
+			},
+			warningText(model) {
+				const missing = describeMissingCacheCompatForModel(model);
+				if (missing.length === 0) return void 0;
+				const key = modelKey(model);
+				return isDeepSeekWireCompatApplicable(model) ? buildDeepSeekCompatWarningText(key, missing) : buildOpenAIProxyCompatWarningText(key, missing);
+			}
+		},
+		{
+			id: "claude",
+			label: "Claude cache",
+			showCacheWrite: true,
+			matchesModel: isClaudeLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isClaudeLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getAnthropicRawUsage);
+			},
+			warningText(model) {
+				if (!isClaudeLikeModel(model) || !isOpenAICompatibleApi(model.api) || isPiBuiltInLlamaCppModel(model)) return void 0;
+				if (getCompat(model).cacheControlFormat === "anthropic") return void 0;
+				return `💡 Cache optimizer: ${modelKey(model)} looks Claude/Anthropic-like but OpenAI-compatible compat lacks cacheControlFormat: "anthropic". Pi may not place Anthropic cache_control breakpoints unless this endpoint supports and enables that compat flag.`;
+			}
+		},
+		{
+			id: "openai",
+			label: "OpenAI cache",
+			matchesModel: isOpenAIFamilyModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isOpenAIFamilyAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "gemini",
+			label: "Gemini cache",
+			matchesModel: isGeminiLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isGeminiLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getGeminiRawUsage);
+			}
+		},
+		{
+			id: "openai",
+			label: "Kimi cache",
+			matchesModel: isKimiLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isKimiLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Qwen cache",
+			matchesModel: isQwenLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isQwenLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "GLM cache",
+			matchesModel: isGLMLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isGLMLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "MiniMax cache",
+			matchesModel: isMiniMaxLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isMiniMaxLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Mimo cache",
+			matchesModel: isMimoLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isMimoLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Hunyuan cache",
+			matchesModel: isHunyuanLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isHunyuanLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Mistral cache",
+			matchesModel: isMistralLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isMistralLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Grok cache",
+			matchesModel: isGrokLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isGrokLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Llama cache",
+			matchesModel: isLlamaLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isLlamaLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Nemotron cache",
+			matchesModel: isNemotronLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isNemotronLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Cohere cache",
+			matchesModel: isCohereLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isCohereLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Yi cache",
+			matchesModel: isYiLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isYiLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Doubao cache",
+			matchesModel: isDoubaoLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isDoubaoLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "ERNIE cache",
+			matchesModel: isErnieLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isErnieLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Baichuan cache",
+			matchesModel: isBaichuanLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isBaichuanLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "StepFun cache",
+			matchesModel: isStepFunLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isStepFunLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Spark cache",
+			matchesModel: isSparkLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isSparkLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "InternLM cache",
+			matchesModel: isInternLMLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isInternLMLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Gemma cache",
+			matchesModel: isGemmaLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isGemmaLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Phi cache",
+			matchesModel: isPhiLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isPhiLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Jamba cache",
+			matchesModel: isJambaLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isJambaLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Solar cache",
+			matchesModel: isSolarLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isSolarLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Sonar cache",
+			matchesModel: isPerplexityLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isPerplexityLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Nova cache",
+			matchesModel: isNovaLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isNovaLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Reka cache",
+			matchesModel: isRekaLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isRekaLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Falcon cache",
+			matchesModel: isFalconLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isFalconLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "DBRX cache",
+			matchesModel: isDbrxLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isDbrxLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "MPT cache",
+			matchesModel: isMptLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isMptLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "StableLM cache",
+			matchesModel: isStableLMLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isStableLMLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Aquila cache",
+			matchesModel: isAquilaLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isAquilaLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "EXAONE cache",
+			matchesModel: isExaoneLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isExaoneLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "HyperCLOVA cache",
+			matchesModel: isHyperCLOVALikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isHyperCLOVALikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Luminous cache",
+			matchesModel: isLuminousLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isLuminousLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Hermes cache",
+			matchesModel: isHermesLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isHermesLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Granite cache",
+			matchesModel: isGraniteLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isGraniteLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Arctic cache",
+			matchesModel: isArcticLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isArcticLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Pangu cache",
+			matchesModel: isPanguLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isPanguLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "SenseNova cache",
+			matchesModel: isSenseNovaLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isSenseNovaLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Zhinao cache",
+			matchesModel: isZhinaoLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isZhinaoLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "MiniCPM cache",
+			matchesModel: isMiniCPMLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isMiniCPMLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "XVERSE cache",
+			matchesModel: isXVerseLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isXVerseLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Orion cache",
+			matchesModel: isOrionLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isOrionLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "OpenChat cache",
+			matchesModel: isOpenChatLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isOpenChatLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Vicuna cache",
+			matchesModel: isVicunaLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isVicunaLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Wizard cache",
+			matchesModel: isWizardLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isWizardLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Zephyr cache",
+			matchesModel: isZephyrLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isZephyrLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Dolphin cache",
+			matchesModel: isDolphinLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isDolphinLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "OpenOrca cache",
+			matchesModel: isOpenOrcaLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isOpenOrcaLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Starling cache",
+			matchesModel: isStarlingLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isStarlingLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "BLOOM cache",
+			matchesModel: isBloomLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isBloomLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "RWKV cache",
+			matchesModel: isRwkvLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isRwkvLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		},
+		{
+			id: "openai",
+			label: "Aya cache",
+			matchesModel: isAyaLikeModel,
+			matchesAssistantMessage(message, model) {
+				if (!isAssistantMessage(message)) return false;
+				return isAyaLikeAssistantMessage(message, model);
+			},
+			normalizeUsage(message) {
+				return normalizeWithFallback(message, getOpenAIRawUsage);
+			},
+			warningText(model) {
+				const missing = describeMissingOpenAICompatibleProxyCompat(model);
+				if (missing.length === 0) return void 0;
+				return buildOpenAIProxyCompatWarningText(modelKey(model), missing);
+			}
+		}
+	];
+	function selectAdapterForModel(model) {
+		if (isNativeVirtualModel(model)) return void 0;
+		return CACHE_PROVIDER_ADAPTERS.find((adapter) => adapter.matchesModel(model));
+	}
+	function selectAdapterForAssistantMessage(message, model) {
+		const responseModel = modelFromAssistantMessage(message, model);
+		return CACHE_PROVIDER_ADAPTERS.find((adapter) => adapter.matchesAssistantMessage(message, responseModel));
+	}
+	function notifyCacheCompatIfNeeded(model, notify, warnedModels) {
+		if (!model) return;
+		if (isAdaptiveThinkingCompatApplicable(model)) {
+			const missing = describeMissingAdaptiveThinkingCompat(model);
+			if (missing.length > 0) {
+				const key = `adaptive-thinking:${modelKey(model)}`;
+				if (!warnedModels.has(key)) {
+					warnedModels.add(key);
+					notify(buildAdaptiveThinkingCompatWarningText(modelKey(model), missing), "warning");
+				}
+			}
+		}
+		const adapter = selectAdapterForModel(model);
+		const text = adapter?.warningText?.(model);
+		if (!adapter || !text) return;
+		const key = adapter.warningText !== void 0 && describeMissingOpenAICompatibleProxyCompat(model).length === 1 && describeMissingCacheCompatForModel(model).length === 1 ? `proxy-affinity:${model.provider}` : `${adapter.id}:${modelKey(model)}`;
+		if (warnedModels.has(key)) return;
+		warnedModels.add(key);
+		notify(text, "warning");
+	}
+	function currentLocalDay() {
+		const now = /* @__PURE__ */ new Date();
+		return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+	}
+	function emptyCacheStats(day = currentLocalDay()) {
+		return {
+			day,
+			totalRequests: 0,
+			hitRequests: 0,
+			cachedInputTokens: 0,
+			cacheWriteInputTokens: 0,
+			totalInputTokens: 0
+		};
+	}
+	function addUsageToCacheStats(stats, usage) {
+		stats.totalRequests += 1;
+		if (usage.cacheRead > 0) stats.hitRequests += 1;
+		stats.cachedInputTokens += usage.cacheRead;
+		stats.cacheWriteInputTokens += usage.cacheWrite;
+		stats.totalInputTokens += usage.totalInput;
+	}
+	function formatTokenCount(value) {
+		const millions = Math.max(0, Math.round(value)) / 1e6;
+		if (millions === 0) return "0M";
+		if (millions < .001) return `${millions.toFixed(4)}M`;
+		if (millions < .01) return `${millions.toFixed(3)}M`;
+		if (millions >= 10) return `${millions.toFixed(1)}M`;
+		return `${millions.toFixed(2)}M`;
+	}
+	function formatCacheStats(adapter, stats) {
+		const percent = stats.totalInputTokens > 0 ? stats.cachedInputTokens / stats.totalInputTokens * 100 : 0;
+		const writeText = adapter.showCacheWrite && stats.cacheWriteInputTokens > 0 ? `·write ${formatTokenCount(stats.cacheWriteInputTokens)}` : "";
+		return `${adapter.label} ${stats.hitRequests}/${stats.totalRequests}·${formatTokenCount(stats.cachedInputTokens)}/${formatTokenCount(stats.totalInputTokens)} ${percent.toFixed(1)}%${writeText}`;
+	}
+	function prefixFooterStatus(statusText) {
+		if (!statusText || statusText.startsWith("· ")) return statusText;
+		return `· ${statusText}`;
+	}
+	function hasMissingUsageFields(message, adapter) {
+		const usage = usageRecordFromAssistant(message);
+		if (!usage) return true;
+		const input = getNonNegativeNumber(usage, "input");
+		const cacheRead = getNonNegativeNumber(usage, "cacheRead");
+		const cacheWrite = getNonNegativeNumber(usage, "cacheWrite");
+		if (cacheRead !== void 0 || cacheWrite !== void 0 || input !== void 0 && input > 0) return false;
+		const rawUsage = adapter.normalizeUsage(message);
+		if (!rawUsage || rawUsage.cacheRead === 0 && rawUsage.cacheWrite === 0 && rawUsage.totalInput === 0) return true;
+		return false;
+	}
+	function getErrorCode(error) {
+		return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+	}
+	function parseCacheStats(value) {
+		const stats = asRecord(value);
+		if (!stats || typeof stats.day !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(stats.day)) return;
+		const totalRequests = getNonNegativeNumber(stats, "totalRequests");
+		const hitRequests = getNonNegativeNumber(stats, "hitRequests");
+		const cachedInputTokens = getNonNegativeNumber(stats, "cachedInputTokens");
+		const cacheWriteInputTokens = getNonNegativeNumber(stats, "cacheWriteInputTokens") ?? 0;
+		const totalInputTokens = getNonNegativeNumber(stats, "totalInputTokens");
+		if (totalRequests === void 0 || hitRequests === void 0 || cachedInputTokens === void 0 || totalInputTokens === void 0 || hitRequests > totalRequests || cachedInputTokens > totalInputTokens || cacheWriteInputTokens > totalInputTokens) return;
+		return {
+			day: stats.day,
+			totalRequests,
+			hitRequests,
+			cachedInputTokens,
+			cacheWriteInputTokens,
+			totalInputTokens
+		};
+	}
+	function cloneCacheStats(stats) {
+		return { ...stats };
+	}
+	function addCacheStatsTotals(target, source) {
+		target.totalRequests += source.totalRequests;
+		target.hitRequests += source.hitRequests;
+		target.cachedInputTokens += source.cachedInputTokens;
+		target.cacheWriteInputTokens += source.cacheWriteInputTokens;
+		target.totalInputTokens += source.totalInputTokens;
+	}
+	function mergeCacheStatsForTotal(existing, incoming) {
+		if (!existing) return cloneCacheStats(incoming);
+		if (incoming.day > existing.day) return cloneCacheStats(incoming);
+		if (incoming.day < existing.day) return existing;
+		addCacheStatsTotals(existing, incoming);
+		return existing;
+	}
+	function parsePersistedRoutedModelRef(value) {
+		const record = asRecord(value);
+		const provider = record?.provider;
+		const id = record?.id;
+		const name = record?.name;
+		if (!isNonEmptyString(provider) || !isNonEmptyString(id)) return void 0;
+		return {
+			provider: provider.trim(),
+			id: id.trim(),
+			name: isNonEmptyString(name) ? name.trim() : id.trim()
+		};
+	}
+	function routedModelRefToCacheModel(ref) {
+		return {
+			id: ref.id,
+			name: ref.name ?? ref.id,
+			provider: ref.provider,
+			api: "",
+			baseUrl: ""
+		};
+	}
+	function selectFooterStatsForModel(mode, sessionHash, statsByModel, totalsByModel, model, processByModel = {}) {
+		if (mode === "total") return totalsByModel[modelKey(model)];
+		if (mode === "process") return processByModel[modelKey(model)];
+		if (!sessionHash) return void 0;
+		return statsByModel[makeSessionModelKey(sessionHash, model.provider, model.id)];
+	}
+	function buildExactRouterStatusEntry(sessionHash, statsByModel, lastRoutedModel, totalsByModel = {}, mode = "total", processByModel = {}) {
+		if (!sessionHash || !lastRoutedModel) return void 0;
+		const model = routedModelRefToCacheModel(lastRoutedModel);
+		const adapter = selectAdapterForModel(model);
+		if (!adapter) return void 0;
+		return {
+			model,
+			adapter,
+			stats: selectFooterStatsForModel(mode, sessionHash, statsByModel, totalsByModel, model, processByModel) ?? emptyCacheStats()
+		};
+	}
+	function findBestRouterModelStats(mode, sessionHash, statsByModel, totalsByModel, processByModel = {}) {
+		const entries = mode === "total" ? Object.entries(totalsByModel) : mode === "process" ? Object.entries(processByModel) : sessionHash ? Object.entries(statsByModel).filter(([key]) => key.startsWith(`${sessionHash}:`)).map(([key, stats]) => [key.slice(sessionHash.length + 1), stats]) : [];
+		let best;
+		for (const [modelKeyPart, stats] of entries) {
+			const slashIdx = modelKeyPart.indexOf("/");
+			if (slashIdx < 1 || slashIdx >= modelKeyPart.length - 1) continue;
+			const model = routedModelRefToCacheModel({
+				provider: modelKeyPart.slice(0, slashIdx),
+				id: modelKeyPart.slice(slashIdx + 1)
+			});
+			const adapter = selectAdapterForModel(model);
+			if (!adapter) continue;
+			if (!best || stats.totalRequests > best.total) best = {
+				model,
+				adapter,
+				stats,
+				total: stats.totalRequests
+			};
+		}
+		return best ? {
+			model: best.model,
+			adapter: best.adapter,
+			stats: best.stats
+		} : void 0;
+	}
+	function createSerializedAsyncRunner() {
+		let tail = Promise.resolve();
+		return (operation) => {
+			const result = tail.then(operation);
+			tail = result.catch(() => void 0);
+			return result;
+		};
+	}
+	function modelEpochPath(modelKeyValue) {
+		return join(SHARD_MODEL_EPOCH_DIR, `${createHash("sha256").update(modelKeyValue).digest("hex")}.json`);
+	}
+	function initialEpoch(scope) {
+		return `initial:${scope}`;
+	}
+	function parseEpochRecord(value) {
+		const record = asRecord(value);
+		return record?.version === 1 && isNonEmptyString(record.epoch) ? record.epoch.trim() : void 0;
+	}
+	async function readEpochFile(path, fallback) {
+		try {
+			return parseEpochRecord(JSON.parse(await readFile(path, "utf8"))) ?? fallback;
+		} catch {
+			return fallback;
+		}
+	}
+	async function readGlobalStatsEpoch() {
+		return readEpochFile(SHARD_GLOBAL_EPOCH_PATH, initialEpoch("global"));
+	}
+	async function readModelStatsEpoch(modelKeyValue) {
+		return readEpochFile(modelEpochPath(modelKeyValue), initialEpoch(`model:${modelKeyValue}`));
+	}
+	async function writeStatsEpoch(path, epoch) {
+		await mkdir(dirname(path), { recursive: true });
+		const tempPath = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+		await writeFile(tempPath, JSON.stringify({
+			version: 1,
+			epoch,
+			createdAt: Date.now()
+		}, null, 2) + "\n", "utf8");
+		await rename(tempPath, path);
+	}
+	async function advanceGlobalStatsEpoch() {
+		const epoch = `${Date.now()}-${randomUUID()}`;
+		await writeStatsEpoch(SHARD_GLOBAL_EPOCH_PATH, epoch);
+		return epoch;
+	}
+	async function advanceModelStatsEpoch(modelKeyValue) {
+		const epoch = `${Date.now()}-${randomUUID()}`;
+		await writeStatsEpoch(modelEpochPath(modelKeyValue), epoch);
+		return epoch;
+	}
+	function parsePersistedStatsShardV7(value) {
+		const record = asRecord(value);
+		const processRecord = asRecord(record?.process);
+		const lifecycle = asRecord(record?.lifecycle);
+		const rawModels = asRecord(record?.models);
+		if (record?.version !== 7 || record.kind !== "pi-cache-optimizer-shard" || !isNonEmptyString(record.instanceId) || !isNonEmptyString(record.sessionHash) || !processRecord || !Number.isInteger(processRecord.pid) || !Number.isInteger(processRecord.ppid) || typeof processRecord.instanceStartedAt !== "number" || !lifecycle || lifecycle.state !== "active" && lifecycle.state !== "closed" || typeof lifecycle.createdAt !== "number" || typeof lifecycle.updatedAt !== "number" || !isNonEmptyString(record.day) || !/^\d{4}-\d{2}-\d{2}$/.test(record.day) || !isNonEmptyString(record.globalEpoch) || !rawModels) return void 0;
+		const models = {};
+		for (const [key, rawEntry] of Object.entries(rawModels)) {
+			const entry = asRecord(rawEntry);
+			const stats = parseCacheStats(entry?.stats);
+			if (!entry || !stats || !isNonEmptyString(entry.modelEpoch) || !isNonEmptyString(entry.provider) || !isNonEmptyString(entry.modelId) || key !== `${entry.provider.trim()}/${entry.modelId.trim()}`) continue;
+			models[key] = {
+				modelEpoch: entry.modelEpoch.trim(),
+				provider: entry.provider.trim(),
+				modelId: entry.modelId.trim(),
+				...isNonEmptyString(entry.modelName) ? { modelName: entry.modelName.trim() } : {},
+				...isNonEmptyString(entry.api) ? { api: entry.api.trim() } : {},
+				stats
+			};
+		}
+		const lastRoutedModel = parsePersistedRoutedModelRef(record.lastRoutedModel);
+		return {
+			version: 7,
+			kind: "pi-cache-optimizer-shard",
+			instanceId: record.instanceId.trim(),
+			sessionHash: record.sessionHash.trim(),
+			process: {
+				pid: Number(processRecord.pid),
+				ppid: Number(processRecord.ppid),
+				instanceStartedAt: processRecord.instanceStartedAt
+			},
+			lifecycle: {
+				state: lifecycle.state,
+				createdAt: lifecycle.createdAt,
+				updatedAt: lifecycle.updatedAt,
+				...typeof lifecycle.closedAt === "number" ? { closedAt: lifecycle.closedAt } : {}
+			},
+			day: record.day,
+			globalEpoch: record.globalEpoch.trim(),
+			models,
+			...lastRoutedModel ? { lastRoutedModel } : {}
+		};
+	}
+	async function writeStatsShardV7(path, shard) {
+		await mkdir(dirname(path), { recursive: true });
+		const tempPath = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+		await writeFile(tempPath, JSON.stringify(shard, null, 2) + "\n", "utf8");
+		await rename(tempPath, path);
+	}
+	async function readValidStatsShardsV7(directory = SHARD_FILES_DIR) {
+		let names;
+		try {
+			names = await readdir(directory);
+		} catch (error) {
+			if (getErrorCode(error) === "ENOENT") return [];
+			throw error;
+		}
+		const shards = [];
+		for (const name of names) {
+			if (!/^[0-9a-f-]+\.json$/i.test(name)) continue;
+			const path = join(directory, name);
+			try {
+				const info = await lstat(path);
+				if (!info.isFile() || info.isSymbolicLink()) continue;
+				const parsed = parsePersistedStatsShardV7(JSON.parse(await readFile(path, "utf8")));
+				const filenameInstanceId = name.slice(0, -5);
+				if (parsed && parsed.instanceId === filenameInstanceId) shards.push(parsed);
+			} catch {}
+		}
+		return shards;
+	}
+	async function aggregateStatsShardsV7(shards, day = currentLocalDay()) {
+		const globalEpoch = await readGlobalStatsEpoch();
+		const modelEpochs = /* @__PURE__ */ new Map();
+		const result = {
+			bySession: {},
+			totalsByModel: {},
+			instancesBySession: {},
+			instancesBySessionModel: {},
+			sessionsByModel: {},
+			instancesByModel: {},
+			modelRefsByKey: {},
+			lastRoutedModelBySession: {}
+		};
+		const routedUpdatedAt = /* @__PURE__ */ new Map();
+		const modelRefUpdatedAt = /* @__PURE__ */ new Map();
+		const modelSessions = /* @__PURE__ */ new Map();
+		for (const shard of shards) {
+			if (shard.day !== day || shard.globalEpoch !== globalEpoch) continue;
+			let contributed = false;
+			if (shard.lastRoutedModel && (routedUpdatedAt.get(shard.sessionHash) ?? -1) < shard.lifecycle.updatedAt) {
+				routedUpdatedAt.set(shard.sessionHash, shard.lifecycle.updatedAt);
+				result.lastRoutedModelBySession[shard.sessionHash] = shard.lastRoutedModel;
+			}
+			for (const [key, entry] of Object.entries(shard.models)) {
+				let epoch = modelEpochs.get(key);
+				if (!epoch) {
+					epoch = await readModelStatsEpoch(key);
+					modelEpochs.set(key, epoch);
+				}
+				if (entry.modelEpoch !== epoch || entry.stats.day !== day) continue;
+				contributed = true;
+				const sessionModels = result.bySession[shard.sessionHash] ??= {};
+				sessionModels[key] = mergeCacheStatsForTotal(sessionModels[key], entry.stats);
+				result.totalsByModel[key] = mergeCacheStatsForTotal(result.totalsByModel[key], entry.stats);
+				result.instancesByModel[key] = (result.instancesByModel[key] ?? 0) + 1;
+				if ((modelRefUpdatedAt.get(key) ?? -1) < shard.lifecycle.updatedAt) {
+					modelRefUpdatedAt.set(key, shard.lifecycle.updatedAt);
+					result.modelRefsByKey[key] = {
+						provider: entry.provider,
+						id: entry.modelId,
+						name: entry.modelName ?? entry.modelId
+					};
+				}
+				const sessionInstances = result.instancesBySessionModel[shard.sessionHash] ??= {};
+				sessionInstances[key] = (sessionInstances[key] ?? 0) + 1;
+				const sessions = modelSessions.get(key) ?? /* @__PURE__ */ new Set();
+				sessions.add(shard.sessionHash);
+				modelSessions.set(key, sessions);
+			}
+			if (contributed) result.instancesBySession[shard.sessionHash] = (result.instancesBySession[shard.sessionHash] ?? 0) + 1;
+		}
+		for (const [key, sessions] of modelSessions) result.sessionsByModel[key] = sessions.size;
+		return result;
+	}
+	function isProcessAlive(pid) {
+		if (!Number.isInteger(pid) || pid <= 0) return false;
+		try {
+			process.kill(pid, 0);
+			return true;
+		} catch (error) {
+			return getErrorCode(error) === "EPERM";
+		}
+	}
+	async function removeLegacyStatsFiles() {
+		for (const path of [STATE_FILE_PATH, LEGACY_STATE_FILE_PATH]) try {
+			await unlink(path);
+		} catch (error) {
+			if (getErrorCode(error) !== "ENOENT") console.warn(`${LOG_PREFIX}: failed to remove obsolete stats file ${path}`, error);
+		}
+	}
+	async function cleanupStatsShardsV7(now = Date.now(), directory = SHARD_FILES_DIR) {
+		let names;
+		try {
+			names = await readdir(directory);
+		} catch (error) {
+			return getErrorCode(error) === "ENOENT" ? 0 : Promise.reject(error);
+		}
+		const today = currentLocalDay();
+		let removed = 0;
+		for (const name of names) {
+			const isShard = /^[0-9a-f-]+\.json$/i.test(name);
+			const isTemp = name.endsWith(".tmp");
+			if (!isShard && !isTemp) continue;
+			const path = join(directory, name);
+			try {
+				const info = await lstat(path);
+				if (!info.isFile() || info.isSymbolicLink()) continue;
+				if (isTemp) {
+					if (now - info.mtimeMs < SHARD_TEMP_RETENTION_MS) continue;
+				} else {
+					const parsed = parsePersistedStatsShardV7(JSON.parse(await readFile(path, "utf8")));
+					if (parsed?.day === today) continue;
+					if (now - (parsed?.lifecycle.updatedAt ?? info.mtimeMs) < SHARD_RETENTION_MS) continue;
+					if (parsed?.lifecycle.state === "active" && isProcessAlive(parsed.process.pid)) continue;
+				}
+				await unlink(path);
+				removed += 1;
+			} catch {}
+		}
+		return removed;
+	}
+	async function maybeCleanupStatsShardsV7(now = Date.now()) {
+		await mkdir(SHARD_MAINTENANCE_DIR, { recursive: true });
+		try {
+			if (now - (await stat(SHARD_CLEANUP_MARKER_PATH)).mtimeMs < SHARD_CLEANUP_INTERVAL_MS) return;
+		} catch {}
+		try {
+			await mkdir(SHARD_CLEANUP_LOCK_PATH);
+		} catch (error) {
+			if (getErrorCode(error) !== "EEXIST") return;
+			try {
+				if (now - (await stat(SHARD_CLEANUP_LOCK_PATH)).mtimeMs <= SHARD_CLEANUP_LOCK_STALE_MS) return;
+				await rm(SHARD_CLEANUP_LOCK_PATH, {
+					recursive: true,
+					force: true
+				});
+				await mkdir(SHARD_CLEANUP_LOCK_PATH);
+			} catch {
+				return;
+			}
+		}
+		try {
+			await cleanupStatsShardsV7(now);
+			const tempPath = `${SHARD_CLEANUP_MARKER_PATH}.${process.pid}.${randomUUID()}.tmp`;
+			await writeFile(tempPath, `${now}\n`, "utf8");
+			await rename(tempPath, SHARD_CLEANUP_MARKER_PATH);
+		} finally {
+			await rm(SHARD_CLEANUP_LOCK_PATH, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	function isExplicitPromptCacheRetentionUnsupportedApplicable(model) {
+		return isOpenAICompatibleApi(model.api) && !isOfficialOpenAIBaseUrl(model) && !isPiBuiltInLlamaCppModel(model);
+	}
+	function isJsonWhitespace(ch) {
+		return ch === " " || ch === "\n" || ch === "\r" || ch === "	";
+	}
+	function readJsonStringLiteral(text, pos) {
+		if (text[pos] !== "\"") return void 0;
+		let i = pos + 1;
+		let value = "";
+		while (i < text.length) {
+			const ch = text[i];
+			if (ch === "\\") {
+				const next = text[i + 1];
+				if (next === void 0) return void 0;
+				if (next === "u") {
+					const hex = text.slice(i + 2, i + 6);
+					if (!/^[0-9a-fA-F]{4}$/.test(hex)) return void 0;
+					value += String.fromCharCode(parseInt(hex, 16));
+					i += 6;
+				} else {
+					if (next === "n") value += "\n";
+					else if (next === "t") value += "	";
+					else if (next === "r") value += "\r";
+					else if (next === "b") value += "\b";
+					else if (next === "f") value += "\f";
+					else value += next;
+					i += 2;
+				}
+				continue;
+			}
+			if (ch === "\"") return {
+				value,
+				end: i + 1
+			};
+			value += ch;
+			i++;
+		}
+	}
+	function buildFixSuggestion(model) {
+		const missing = describeMissingCacheCompatForModel(model);
+		if (missing.length === 0) return void 0;
+		let compatKeys = {};
+		if (isAdaptiveThinkingCompatApplicable(model)) compatKeys = buildAdaptiveThinkingCompatSuggestion(missing);
+		else if (isDeepSeekCompatCheckApplicable(model)) compatKeys = buildDeepSeekCompatSuggestion(missing);
+		else compatKeys = buildSafeOpenAIProxyCompatSuggestion(missing);
+		if (Object.keys(compatKeys).length === 0) return void 0;
+		const key = modelKey(model);
+		const slashIdx = key.indexOf("/");
+		return {
+			providerLabel: slashIdx > 0 ? key.slice(0, slashIdx) : key,
+			modelId: model.id,
+			compatKeys
+		};
+	}
+	function stripJsoncComments(text) {
+		const out = [];
+		let i = 0;
+		while (i < text.length) {
+			const ch = text[i];
+			if (ch === "\"") {
+				out.push(ch);
+				i++;
+				while (i < text.length) {
+					const sc = text[i];
+					out.push(sc);
+					i++;
+					if (sc === "\\" && i < text.length) {
+						out.push(text[i]);
+						i++;
+					} else if (sc === "\"") break;
+				}
+				continue;
+			}
+			if (ch === "/" && i + 1 < text.length && text[i + 1] === "/") {
+				out.push(" ", " ");
+				i += 2;
+				while (i < text.length && text[i] !== "\n") {
+					out.push(" ");
+					i++;
+				}
+				continue;
+			}
+			if (ch === "/" && i + 1 < text.length && text[i + 1] === "*") {
+				out.push(" ", " ");
+				i += 2;
+				while (i < text.length) {
+					if (text[i] === "*" && i + 1 < text.length && text[i + 1] === "/") {
+						out.push(" ", " ");
+						i += 2;
+						break;
+					}
+					out.push(text[i] === "\n" ? "\n" : " ");
+					i++;
+				}
+				continue;
+			}
+			out.push(ch);
+			i++;
+		}
+		return out.join("");
+	}
+	function stripJsoncTrailingCommas(text) {
+		const chars = text.split("");
+		let i = 0;
+		while (i < chars.length) {
+			if (chars[i] === "\"") {
+				const str = readJsonStringLiteral(text, i);
+				if (!str) break;
+				i = str.end;
+				continue;
+			}
+			if (chars[i] === ",") {
+				let j = i + 1;
+				while (j < chars.length && isJsonWhitespace(chars[j])) j++;
+				if (chars[j] === "}" || chars[j] === "]") chars[i] = " ";
+			}
+			i++;
+		}
+		return chars.join("");
+	}
+	function parseJsonc(text) {
+		return JSON.parse(stripJsoncTrailingCommas(stripJsoncComments(text)));
+	}
+	return {
+		selectAdapterForModel,
+		selectAdapterForAssistantMessage,
+		notifyCacheCompatIfNeeded,
+		buildFixSuggestion,
+		hasMissingUsageFields,
+		formatCacheStats,
+		prefixFooterStatus,
+		emptyCacheStats,
+		addUsageToCacheStats,
+		cloneCacheStats,
+		selectFooterStatsForModel,
+		findBestRouterModelStats,
+		buildExactRouterStatusEntry,
+		hashSessionId,
+		readValidStatsShardsV7,
+		aggregateStatsShardsV7,
+		writeStatsShardV7,
+		readGlobalStatsEpoch,
+		readModelStatsEpoch,
+		advanceGlobalStatsEpoch,
+		advanceModelStatsEpoch,
+		maybeCleanupStatsShardsV7,
+		removeLegacyStatsFiles,
+		createSerializedAsyncRunner,
+		hasReasoningProtocolRejectionErrorMessage,
+		isReasoningProtocolRejectionForModel,
+		hasPromptCacheKeyUnsupportedErrorMessage,
+		isPromptCacheKeyUnsupportedApplicable,
+		hasPromptCacheRetentionUnsupportedErrorMessage,
+		isExplicitPromptCacheRetentionUnsupportedApplicable,
+		hasAnthropicCacheTtlOrderError,
+		getPromptCacheRetentionUnsupportedHint,
+		modelFromAssistantMessage,
+		resolvePhysicalModel,
+		consolidateDirectProviderStatsModel,
+		footerStatsMode,
+		currentLocalDay,
+		modelKey,
+		initialEpoch,
+		parsePersistedStatsShardV7,
+		cleanupStatsShardsV7,
+		readEffectiveCompatConfig,
+		getCompat,
+		SHARD_FILES_DIR,
+		LOG_PREFIX
+	};
+}
+//#endregion
+//#region src/services/nativeOptimizer/index.ts
+const STATUS_KEY = "pi-cache-stats";
+const PERSIST_DEBOUNCE_MS = 2e3;
+const MAX_RECENT_SAMPLES = 50;
+function asModel(model) {
+	return model ? {
+		...model,
+		api: model.api ?? "",
+		name: model.name ?? model.id,
+		baseUrl: model.baseUrl ?? ""
+	} : void 0;
+}
+/** One native session owner. Only V7 counters, never payloads or credentials, reach disk. */
+function createNativeOptimizer(initial, stateDir = getAgentDir()) {
+	const support = createOptimizerSupport(stateDir, initial.environment);
+	const serialized = support.createSerializedAsyncRunner();
+	const instanceId = randomUUID();
+	const instanceStartedAt = Date.now();
+	const sessionHash = support.hashSessionId(initial.sessionId);
+	const shardPath = join(support.SHARD_FILES_DIR, `${instanceId}.json`);
+	let currentGlobalEpoch = support.initialEpoch("global");
+	const modelEpochs = /* @__PURE__ */ new Map();
+	const models = /* @__PURE__ */ new Map();
+	let processStats = {};
+	let bySession = {};
+	let totals = {};
+	let lastRoutedModel;
+	let lastStatus;
+	let shardCreatedAt = Date.now();
+	let persistTimer;
+	let releaseRetention;
+	let started = false;
+	let closed = false;
+	let persistenceWarningShown = false;
+	const warnedModels = /* @__PURE__ */ new Set();
+	const warnedErrors = /* @__PURE__ */ new Set();
+	const recentSamples = /* @__PURE__ */ new Map();
+	const notify = (context, body) => {
+		context.client.notify({
+			body,
+			level: "warning"
+		});
+	};
+	function buildShard(state = "active") {
+		const entries = {};
+		for (const [key, stats] of Object.entries(processStats)) {
+			const model = models.get(key);
+			if (!model) continue;
+			entries[key] = {
+				modelEpoch: modelEpochs.get(key) ?? support.initialEpoch(`model:${key}`),
+				provider: model.provider,
+				modelId: model.id,
+				modelName: model.name,
+				...model.api ? { api: model.api } : {},
+				stats: support.cloneCacheStats(stats)
+			};
+		}
+		const now = Date.now();
+		return {
+			version: 7,
+			kind: "pi-cache-optimizer-shard",
+			instanceId,
+			sessionHash,
+			process: {
+				pid: process.pid,
+				ppid: process.ppid,
+				instanceStartedAt
+			},
+			lifecycle: {
+				state,
+				createdAt: shardCreatedAt,
+				updatedAt: now,
+				...state === "closed" ? { closedAt: now } : {}
+			},
+			day: support.currentLocalDay(),
+			globalEpoch: currentGlobalEpoch,
+			models: entries,
+			...lastRoutedModel ? { lastRoutedModel: { ...lastRoutedModel } } : {}
+		};
+	}
+	async function refresh() {
+		const shards = (await support.readValidStatsShardsV7()).filter((shard) => shard.instanceId !== instanceId);
+		if (started) shards.push(buildShard());
+		const aggregate = await support.aggregateStatsShardsV7(shards);
+		const epoch = await support.readGlobalStatsEpoch();
+		if (epoch !== currentGlobalEpoch) {
+			currentGlobalEpoch = epoch;
+			processStats = {};
+			modelEpochs.clear();
+			models.clear();
+			lastRoutedModel = void 0;
+		} else for (const key of Object.keys(processStats)) {
+			const latest = await support.readModelStatsEpoch(key);
+			if ((modelEpochs.get(key) ?? support.initialEpoch(`model:${key}`)) === latest) continue;
+			delete processStats[key];
+			modelEpochs.set(key, latest);
+			models.delete(key);
+		}
+		bySession = {};
+		for (const [hash, stats] of Object.entries(aggregate.bySession)) for (const [key, value] of Object.entries(stats)) bySession[`${hash}:${key}`] = value;
+		totals = aggregate.totalsByModel;
+		lastRoutedModel = aggregate.lastRoutedModelBySession[sessionHash];
+		lastStatus = void 0;
+	}
+	async function persist(context, state = "active") {
+		try {
+			await support.writeStatsShardV7(shardPath, buildShard(state));
+		} catch (error) {
+			console.warn(`${support.LOG_PREFIX}: failed to persist cache stats shard`, error);
+			if (!persistenceWarningShown) {
+				persistenceWarningShown = true;
+				notify(context, `${support.LOG_PREFIX}: failed to persist footer stats; using in-memory stats for this process.`);
+			}
+		}
+	}
+	async function flush(context, state = "active") {
+		if (persistTimer) clearTimeout(persistTimer);
+		persistTimer = void 0;
+		await refresh();
+		await persist(context, state);
+		await refresh();
+	}
+	function schedulePersist(context) {
+		if (persistTimer) clearTimeout(persistTimer);
+		persistTimer = setTimeout(() => {
+			persistTimer = void 0;
+			serialized(async () => {
+				if (!closed) {
+					await persist(context);
+					await refresh();
+				}
+			}).catch((error) => notify(context, `Cache stats refresh failed: ${String(error)}`));
+		}, PERSIST_DEBOUNCE_MS);
+		persistTimer.unref?.();
+	}
+	async function rollover(context) {
+		const day = support.currentLocalDay();
+		let changed = false;
+		for (const key of Object.keys(processStats)) if (processStats[key]?.day !== day) {
+			processStats[key] = support.emptyCacheStats(day);
+			changed = true;
+		}
+		if (changed) {
+			shardCreatedAt = Date.now();
+			lastStatus = void 0;
+			await flush(context);
+		}
+	}
+	function selectedModel(context) {
+		const selected = asModel(context.model);
+		if (selected?.api === "pi-virtual" && lastRoutedModel) {
+			const physical = models.get(support.modelKey(lastRoutedModel)) ?? {
+				...lastRoutedModel,
+				name: lastRoutedModel.name ?? lastRoutedModel.id,
+				api: "",
+				baseUrl: ""
+			};
+			return support.resolvePhysicalModel(physical, asModel(context.getModel?.(physical.provider, physical.id)));
+		}
+		return selected;
+	}
+	async function publish(context, model = selectedModel(context)) {
+		await rollover(context);
+		const adapter = support.selectAdapterForModel(model);
+		const mode = support.footerStatsMode();
+		let status;
+		if (adapter && model) {
+			const stats = support.selectFooterStatsForModel(mode, sessionHash, bySession, totals, model, processStats);
+			status = support.formatCacheStats(adapter, stats ?? support.emptyCacheStats());
+			if (support.buildFixSuggestion(model)) status += " ⚠️ compat";
+		} else if (context.model?.api === "pi-virtual" || context.model?.provider === "router") {
+			if (lastStatus !== void 0) return;
+			const entry = support.buildExactRouterStatusEntry(sessionHash, bySession, lastRoutedModel, totals, mode, processStats) ?? support.findBestRouterModelStats(mode, sessionHash, bySession, totals, processStats);
+			if (entry) status = support.formatCacheStats(entry.adapter, entry.stats);
+		}
+		status = support.prefixFooterStatus(status);
+		if (status === lastStatus) return;
+		lastStatus = status;
+		context.client.setStatus(STATUS_KEY, status);
+	}
+	function diagnose(message, model, context) {
+		if (!model) return;
+		const key = support.modelKey(model);
+		const observations = [
+			[
+				"reasoning",
+				support.hasReasoningProtocolRejectionErrorMessage(message) && support.isReasoningProtocolRejectionForModel(message, model),
+				`${key} returned a reasoning-protocol rejection. Review model-scoped thinkingFormat and supportsReasoningEffort compat. No configuration was changed automatically.`
+			],
+			[
+				"key",
+				support.hasPromptCacheKeyUnsupportedErrorMessage(message) && support.isPromptCacheKeyUnsupportedApplicable(model),
+				`${key} rejected prompt_cache_key. Review a precise model-scoped repair. No configuration was changed automatically.`
+			],
+			[
+				"retention",
+				support.hasPromptCacheRetentionUnsupportedErrorMessage(message) && support.isExplicitPromptCacheRetentionUnsupportedApplicable(model),
+				`${key} rejected prompt_cache_retention. ${support.getPromptCacheRetentionUnsupportedHint()}`
+			],
+			[
+				"ttl",
+				support.hasAnthropicCacheTtlOrderError(message) && model.api === "anthropic-messages",
+				`${key} returned an Anthropic cache-control TTL ordering error. Review model-level supportsLongCacheRetention: false. No configuration was changed automatically.`
+			]
+		];
+		for (const [kind, applicable, text] of observations) {
+			const observationKey = `${kind}:${key}`;
+			if (!applicable || warnedErrors.has(observationKey)) continue;
+			warnedErrors.add(observationKey);
+			notify(context, `⚠️ ${support.LOG_PREFIX}: ${text}`);
+		}
+	}
+	async function observe(message, context) {
+		const record = typeof message === "object" && message !== null ? message : {};
+		const active = asModel(context.model);
+		const nativeVirtual = active?.api === "pi-virtual";
+		const identity = support.modelFromAssistantMessage(nativeVirtual ? {
+			...record,
+			responseModel: record.model ?? record.responseModel
+		} : message, active);
+		const registered = identity && asModel(context.getModel?.(identity.provider, identity.id));
+		let model = nativeVirtual && identity ? support.resolvePhysicalModel(identity, registered) : registered || identity;
+		diagnose(message, model, context);
+		if (record.stopReason === "error" || record.stopReason === "aborted") return;
+		model = support.consolidateDirectProviderStatsModel(model, active);
+		const adapter = (nativeVirtual && model ? support.selectAdapterForModel(model) : void 0) ?? support.selectAdapterForAssistantMessage(message, model ?? active);
+		if (!adapter) return;
+		const usage = adapter.normalizeUsage(message);
+		let routeChanged = false;
+		if (model && (active?.api === "pi-virtual" || active?.provider === "router")) {
+			const next = {
+				provider: model.provider,
+				id: model.id,
+				name: model.name
+			};
+			routeChanged = JSON.stringify(lastRoutedModel) !== JSON.stringify(next);
+			lastRoutedModel = next;
+		}
+		if (model) {
+			const key = support.modelKey(model);
+			const samples = recentSamples.get(key) ?? [];
+			samples.push({
+				timestamp: Date.now(),
+				hit: (usage?.cacheRead ?? 0) > 0,
+				cachedInputTokens: usage?.cacheRead ?? 0,
+				cacheWriteInputTokens: usage?.cacheWrite ?? 0,
+				totalInputTokens: usage?.totalInput ?? 0,
+				missingUsageFields: !usage || usage.cacheRead === 0 && usage.cacheWrite === 0 && usage.totalInput === 0 || support.hasMissingUsageFields(message, adapter)
+			});
+			if (samples.length > MAX_RECENT_SAMPLES) samples.splice(0, samples.length - MAX_RECENT_SAMPLES);
+			recentSamples.set(key, samples);
+		}
+		if (!usage) {
+			if (routeChanged) schedulePersist(context);
+			return;
+		}
+		await rollover(context);
+		if (model) {
+			const key = support.modelKey(model);
+			const globalEpoch = await support.readGlobalStatsEpoch();
+			const modelEpoch = await support.readModelStatsEpoch(key);
+			if (globalEpoch !== currentGlobalEpoch) {
+				currentGlobalEpoch = globalEpoch;
+				processStats = {};
+				modelEpochs.clear();
+			}
+			if (modelEpochs.get(key) !== modelEpoch) {
+				delete processStats[key];
+				modelEpochs.set(key, modelEpoch);
+			}
+			models.set(key, model);
+			support.addUsageToCacheStats(processStats[key] ??= support.emptyCacheStats(), usage);
+		}
+		schedulePersist(context);
+		await refresh();
+		await publish(context, model);
+	}
+	async function shutdown(context) {
+		if (closed) return;
+		closed = true;
+		try {
+			if (started) await flush(context, "closed");
+		} finally {
+			if (persistTimer) clearTimeout(persistTimer);
+			persistTimer = void 0;
+			releaseRetention?.();
+			releaseRetention = void 0;
+			context.client.setStatus(STATUS_KEY, void 0);
+		}
+	}
+	return {
+		hooks: [
+			{
+				event: "session_start",
+				handle: (_event, context) => serialized(async () => {
+					if (started || closed) return;
+					started = true;
+					releaseRetention = acquireEnvironmentValue("PI_CACHE_RETENTION", "long");
+					currentGlobalEpoch = await support.readGlobalStatsEpoch();
+					await support.removeLegacyStatsFiles();
+					await refresh();
+					await flush(context);
+					await support.maybeCleanupStatsShardsV7();
+					await refresh();
+					await publish(context);
+				})
+			},
+			{
+				event: "tool_execution_end",
+				handle: (event, context) => serialized(async () => {
+					if (typeof event.parentToolCallId === "string" && event.parentToolCallId.trim()) return;
+					if (started && !closed) {
+						await refresh();
+						await publish(context);
+					}
+				})
+			},
+			{
+				event: "agent_settled",
+				handle: (_event, context) => serialized(async () => {
+					if (started && !closed) {
+						await refresh();
+						await publish(context);
+					}
+				})
+			},
+			{
+				event: "model_select",
+				handle: (_event, context) => serialized(async () => {
+					if (!started || closed) return;
+					const model = selectedModel(context);
+					support.notifyCacheCompatIfNeeded(model, (text) => notify(context, text), warnedModels);
+					await refresh();
+					await publish(context, model);
+				})
+			},
+			{
+				event: "message_end",
+				handle: (event, context) => serialized(async () => {
+					if (started && !closed) await observe(event.message, context);
+				})
+			},
+			{
+				event: "session_shutdown",
+				handle: (_event, context) => serialized(() => shutdown(context))
+			}
+		],
+		dispose: () => serialized(() => shutdown(initial)),
+		snapshot: () => ({
+			sessionHash,
+			processStats,
+			bySession,
+			totals,
+			recentSamples
+		})
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = defineRoot(({ agent }) => {
+	if (!agent) throw new Error("Cache statistics require the native session host.");
+	const telemetry = new PromptCacheTelemetry();
+	const runtime = createCacheRuntime({
+		telemetry,
+		now: Date.now
+	}, agent.context.environment);
+	const optimizer = createNativeOptimizer(agent.context);
+	return {
+		value: { hooks: optimizer.hooks.map((hook) => {
+			if (hook.event === "session_start") return {
+				...hook,
+				async handle(event, context) {
+					await runtime.events.session_start(event, context);
+					await hook.handle(event, context);
+				}
+			};
+			if (hook.event === "message_end") return {
+				...hook,
+				async handle(event, context) {
+					runtime.events.message_end(event, context);
+					await hook.handle(event, context);
+				}
+			};
+			return hook;
+		}) },
+		services: [(context) => {
+			new PromptCacheTelemetryService(context, telemetry);
+		}, runtime.plugin],
+		async onDispose() {
+			try {
+				await optimizer.dispose();
+			} finally {
+				runtime.dispose();
+			}
+		}
+	};
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-settled.server.ts
+var agent_settled_server_default = defineHook((context) => context.root.hooks.find((hook) => hook.event === "agent_settled"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_lib/cacheHooks.ts
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function modelIdentity(model, payload) {
+	const request = record(payload);
+	return {
+		virtualProvider: model?.provider,
+		virtualModel: model?.id,
+		api: model?.api,
+		wireModel: typeof request.model === "string" ? request.model : void 0
+	};
+}
+function cacheNamespace(context) {
+	return `dph_${sha256Base64Url(canonicalJson({
+		version: 1,
+		session: context.sessionId,
+		selection: context.selection
+	}))}`;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/before-provider-request.server.ts
+var before_provider_request_server_default = defineHook([{
+	event: "before_provider_request",
+	handle(event, execution) {
+		const payload = record(event.payload);
+		const identity = modelIdentity(event.model, payload);
+		const modelFingerprint = createPromptCacheModelFingerprint(identity, sha256Base64Url);
+		const key = createPromptCacheKey(cacheNamespace({
+			sessionId: execution.sessionId,
+			selection: execution.selection
+		}), "parent", modelFingerprint, sha256Base64Url);
+		const rewritten = rewritePromptCacheKey(payload, identity.api, key, true);
+		return rewritten === void 0 ? void 0 : { payload: rewritten };
+	}
+}].find((hook) => hook.event === "before_provider_request"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/message-end.server.ts
+var message_end_server_default = defineHook((context) => context.root.hooks.find((hook) => hook.event === "message_end"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/model-select.server.ts
+var model_select_server_default = defineHook((context) => context.root.hooks.find((hook) => hook.event === "model_select"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-shutdown.server.ts
+var session_shutdown_server_default = defineHook((context) => context.root.hooks.find((hook) => hook.event === "session_shutdown"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-start.server.ts
+var session_start_server_default = defineHook((context) => context.root.hooks.find((hook) => hook.event === "session_start"));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/tool-execution-end.server.ts
+var tool_execution_end_server_default = defineHook((context) => context.root.hooks.find((hook) => hook.event === "tool_execution_end"));
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = defineServerPlugin({
+	name: "@agimon-ai/po-cache",
+	providerOverrides: composeServerProviderOverrides(root_server_default),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...composeRootHooks(scopeSession),
+			get hooks() {
+				return [
+					via({ event: "agent_settled" }, at(agent_settled_server_default, contextSession)),
+					via({ event: "before_provider_request" }, at(before_provider_request_server_default, contextSession)),
+					via({ event: "message_end" }, at(message_end_server_default, contextSession)),
+					via({ event: "model_select" }, at(model_select_server_default, contextSession)),
+					via({ event: "session_shutdown" }, at(session_shutdown_server_default, contextSession)),
+					via({ event: "session_start" }, at(session_start_server_default, contextSession)),
+					via({ event: "tool_execution_end" }, at(tool_execution_end_server_default, contextSession))
+				];
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+export { facet as default, facet };
+
+//# sourceMappingURL=server.mjs.map