proxitor 0.12.0 → 0.14.0

package/README.md

@@ -117,7 +117,8 @@ If the cache hit looks low, three levers fix it — tune them from `proxitor con
 
 - **`cacheControl`** — inject `cache_control` to activate caching (Anthropic-native).
 - **`sessionId`** — inject `session_id` so the provider pins from the first request.
-- **`normalizeVolatileSystem`** — strip Claude Code's volatile `cch` hash so the prefix cache warms on non-Anthropic providers (qwen/glm/…).
+- **`normalizeVolatileSystem`** — strip Claude Code's volatile `cch`/`cc_version` hashes so the prefix cache warms on non-Anthropic providers (qwen/glm/…).
+- **`rewriteBlockTtl`** — normalize the TTL on Claude Code's block `cache_control` breakpoints to match your `cacheControlTtl`. Enable it (`auto`/`always`) if Anthropic rejects requests where the root `ttl` is `1h` but the block breakpoints stay at `5m`.
 
 See the [configuration reference](./docs/configuration.md#prompt-caching) for the full detail.
 

package/dist/cli.mjs

@@ -16251,6 +16251,7 @@ const modelOverrideSchema = object({
 	headers: record(string$1(), string$1()).optional(),
 	cacheControl: triStateSchema.optional(),
 	cacheControlTtl: ttlSchema.optional(),
+	rewriteBlockTtl: triStateSchema.optional(),
 	sessionId: triStateSchema.optional(),
 	normalizeVolatileSystem: boolean().optional()
 }).strict();
@@ -16269,6 +16270,7 @@ const proxyConfigSchema = object({
 	headers: record(string$1(), string$1()).optional(),
 	cacheControl: triStateSchema.default("auto"),
 	cacheControlTtl: ttlSchema.optional(),
+	rewriteBlockTtl: triStateSchema.default("skip"),
 	sessionId: triStateSchema.default("auto"),
 	normalizeVolatileSystem: boolean().default(false),
 	modelOverrides: record(string$1().min(1), modelOverrideSchema).optional()
@@ -16398,6 +16400,7 @@ function resolveModelConfig(config, modelName) {
 		headers: config.headers ? { ...config.headers } : void 0,
 		cacheControl: config.cacheControl,
 		cacheControlTtl: config.cacheControlTtl,
+		rewriteBlockTtl: config.rewriteBlockTtl,
 		sessionId: config.sessionId,
 		normalizeVolatileSystem: config.normalizeVolatileSystem
 	};
@@ -16427,6 +16430,7 @@ function applyOverride(result, override) {
 	};
 	if (override.cacheControl !== void 0) result.cacheControl = override.cacheControl;
 	if (override.cacheControlTtl !== void 0) result.cacheControlTtl = override.cacheControlTtl;
+	if (override.rewriteBlockTtl !== void 0) result.rewriteBlockTtl = override.rewriteBlockTtl;
 	if (override.sessionId !== void 0) result.sessionId = override.sessionId;
 	if (override.normalizeVolatileSystem !== void 0) result.normalizeVolatileSystem = override.normalizeVolatileSystem;
 }
@@ -17928,6 +17932,12 @@ const CACHE_HINTS = {
 	always: "All models",
 	skip: "Passthrough — leave client cache_control headers as-is"
 };
+/** Shared hint texts for the rewrite-block-ttl tri-state — used in cache-control command + override editor. */
+const REWRITE_HINTS = {
+	auto: "Anthropic models only — normalize blocks to match root",
+	always: "All models",
+	skip: "Leave client block ttl as-is (may mismatch root)"
+};
 const NORMALIZE_HINTS = {
 	on: "Rewrite cch → stable prefix cache",
 	off: "Passthrough — rewrite nothing"
@@ -18032,8 +18042,11 @@ async function collectSessionTriState(currentSid) {
 	if (sid === "reset") return { sessionId: { remove: true } };
 	return { sessionId: { value: sid } };
 }
-/** TTL is independent of cache mode. Mode-cancel aborts; TTL-cancel keeps existing TTL. */
-async function collectCacheTriState(currentCc, currentTtl, globalTtl) {
+/**
+* Collects cacheControl mode, TTL, and rewriteBlockTtl.
+* Mode-cancel aborts; TTL-cancel keeps existing TTL; rewrite-cancel keeps existing rewrite.
+*/
+async function collectCacheTriState(currentCc, currentTtl, globalTtl, currentRewrite) {
 	const cc = await askTriState("Cache control mode", currentCc, CACHE_HINTS, { removable: true });
 	if (typeof cc === "symbol") return null;
 	let cacheControl;
@@ -18043,18 +18056,23 @@ async function collectCacheTriState(currentCc, currentTtl, globalTtl) {
 		removable: true,
 		globalTtl
 	});
-	if (typeof ttl === "symbol") return { cacheControl };
-	if (ttl === "reset") return {
-		cacheControl,
-		cacheControlTtl: { remove: true }
-	};
+	let cacheControlTtl;
+	if (typeof ttl === "symbol") cacheControlTtl = void 0;
+	else if (ttl === "reset") cacheControlTtl = { remove: true };
+	else cacheControlTtl = { value: ttl };
+	const rewrite = await askTriState("Rewrite block TTLs", currentRewrite, REWRITE_HINTS, { removable: true });
+	let rewriteBlockTtl;
+	if (typeof rewrite === "symbol") rewriteBlockTtl = void 0;
+	else if (rewrite === "reset") rewriteBlockTtl = { remove: true };
+	else rewriteBlockTtl = { value: rewrite };
 	return {
 		cacheControl,
-		cacheControlTtl: { value: ttl }
+		cacheControlTtl,
+		rewriteBlockTtl
 	};
 }
 async function collectNormalizeVolatileSystem(currentNvs) {
-	const nvs = await askNormalizeVolatileSystem("Normalize volatile system (cch hash)", currentNvs, { removable: true });
+	const nvs = await askNormalizeVolatileSystem("Normalize volatile system (cch/cc_version hashes)", currentNvs, { removable: true });
 	if (typeof nvs === "symbol") return null;
 	if (nvs === "reset") return { normalizeVolatileSystem: { remove: true } };
 	return { normalizeVolatileSystem: { value: nvs } };
@@ -18330,29 +18348,45 @@ async function browseModelsCommand(client) {
 }
 //#endregion
 //#region src/commands/config/cache-control.ts
+/**
+* Map a ResolvedField into the `fields` object for `setGlobalConfigFields`:
+* {value}→assign value, {remove}→assign undefined (delete from disk),
+* undefined→omit the key (keep existing on disk).
+*
+* This is the file-write counterpart of `applyField`. The in-memory `applyField`
+* can `delete` an existing key, but a fresh `fields` object fed to
+* `setGlobalConfigFields` needs an explicit `undefined` value to trigger
+* removal — so keep-existing (undefined field) must be distinguished from
+* remove ({remove:true}) by omitting vs. assigning the key.
+*/
+function assignField(fields, key, field) {
+	if (field === void 0) return;
+	fields[key] = "remove" in field ? void 0 : field.value;
+}
+function fieldLabel(field, fallback) {
+	if (field === void 0) return fallback;
+	if ("remove" in field) return "(default)";
+	return String(field.value);
+}
 async function cacheControlCommand(opts) {
 	const configPath = requireConfigPath(opts?.configPath);
 	const cfg = readConfigFileRaw(configPath);
 	const rawCc = cfg.cacheControl;
 	const rawTtl = cfg.cacheControlTtl;
+	const rawRewrite = cfg.rewriteBlockTtl;
 	const effectiveCc = rawCc ?? DEFAULTS.cacheControl;
+	const effectiveRewrite = rawRewrite ?? DEFAULTS.rewriteBlockTtl;
 	log.info(`Current: cacheControl = ${rawCc === void 0 ? `(default -> ${effectiveCc})` : effectiveCc}`);
 	if (rawTtl) log.info(`Current: cacheControlTtl = ${rawTtl}`);
-	const cc = await askTriState("Cache control mode", rawCc, CACHE_HINTS, { removable: true });
-	if (typeof cc === "symbol") return;
+	log.info(`Current: rewriteBlockTtl = ${rawRewrite === void 0 ? `(default -> ${effectiveRewrite})` : rawRewrite}`);
+	const result = await collectCacheTriState(rawCc, rawTtl, void 0, rawRewrite);
+	if (result === null) return;
 	const fields = {};
-	fields.cacheControl = cc === "reset" ? void 0 : cc;
-	const ttlResult = await askCacheControlTtl(rawTtl, { removable: true });
-	if (typeof ttlResult === "symbol") {
-		setGlobalConfigFields(configPath, fields);
-		log.success(`cacheControl set to ${cc === "reset" ? "(default)" : cc}`);
-		return;
-	}
-	fields.cacheControlTtl = ttlResult === "reset" ? void 0 : ttlResult;
+	assignField(fields, "cacheControl", result.cacheControl);
+	assignField(fields, "cacheControlTtl", result.cacheControlTtl);
+	assignField(fields, "rewriteBlockTtl", result.rewriteBlockTtl);
 	setGlobalConfigFields(configPath, fields);
-	const ccLabel = cc === "reset" ? "(default)" : cc;
-	const ttlLabel = ttlResult === "reset" ? "(default)" : ttlResult;
-	log.success(`cacheControl set to ${ccLabel}, TTL = ${ttlLabel}`);
+	log.success(`cacheControl set to ${fieldLabel(result.cacheControl, effectiveCc)}, TTL = ${fieldLabel(result.cacheControlTtl, "(unchanged)")}, rewrite = ${fieldLabel(result.rewriteBlockTtl, effectiveRewrite)}`);
 }
 //#endregion
 //#region src/commands/config/caching-summary.ts
@@ -18383,6 +18417,7 @@ function perModelTtl(current, globalCfg) {
 }
 function formatGlobalCachingSummary(cfg) {
 	const cc = globalTriStateLabel(cfg.cacheControl, DEFAULTS.cacheControl);
+	const rewrite = globalTriStateLabel(cfg.rewriteBlockTtl, DEFAULTS.rewriteBlockTtl);
 	const sid = globalTriStateLabel(cfg.sessionId, DEFAULTS.sessionId);
 	const nvs = globalNvsLabel(cfg.normalizeVolatileSystem);
 	return [
@@ -18390,6 +18425,7 @@ function formatGlobalCachingSummary(cfg) {
 		"",
 		`  cacheControl            = ${cc}    (activate cache)`,
 		`  cacheControlTtl         = ${describeTtl(cfg.cacheControlTtl)}`,
+		`  rewriteBlockTtl         = ${rewrite}    (normalize block ttl)`,
 		`  sessionId               = ${sid}    (pin provider)`,
 		`  normalizeVolatileSystem = ${nvs}     (stable prefix)`,
 		"",
@@ -18398,10 +18434,12 @@ function formatGlobalCachingSummary(cfg) {
 }
 function formatPerModelCachingSummary(modelKey, current, globalCfg) {
 	const gCc = globalCfg.cacheControl ?? DEFAULTS.cacheControl;
+	const gRewrite = globalCfg.rewriteBlockTtl ?? DEFAULTS.rewriteBlockTtl;
 	const gSid = globalCfg.sessionId ?? DEFAULTS.sessionId;
 	const gNvs = globalCfg.normalizeVolatileSystem ?? DEFAULTS.normalizeVolatileSystem;
 	const cc = current.cacheControl ?? `(inherit -> ${gCc})`;
 	const ttl = perModelTtl(current, globalCfg);
+	const rewrite = current.rewriteBlockTtl ?? `(inherit -> ${gRewrite})`;
 	const sid = current.sessionId ?? `(inherit -> ${gSid})`;
 	const nvs = nvsLabel(current.normalizeVolatileSystem, gNvs);
 	return [
@@ -18409,6 +18447,7 @@ function formatPerModelCachingSummary(modelKey, current, globalCfg) {
 		"",
 		`  cacheControl            = ${cc}`,
 		`  cacheControlTtl         = ${ttl}`,
+		`  rewriteBlockTtl         = ${rewrite}`,
 		`  sessionId               = ${sid}`,
 		`  normalizeVolatileSystem = ${nvs}`
 	].join("\n");
@@ -18426,7 +18465,7 @@ async function normalizeVolatileSystemCommand(opts) {
 	const raw = readConfigFileRaw(configPath).normalizeVolatileSystem;
 	const effective = raw ?? DEFAULTS.normalizeVolatileSystem;
 	log.info(`Current: normalizeVolatileSystem = ${raw === void 0 ? `(default -> ${effective ? "on" : "off"})` : effective}`);
-	const choice = await askNormalizeVolatileSystem("Normalize Claude Code's volatile cch hash in the system prompt? Stabilizes the prefix cache for non-Anthropic providers (qwen/glm/etc.).", raw, {
+	const choice = await askNormalizeVolatileSystem("Normalize Claude Code's volatile cch and cc_version hashes in the system prompt? Stabilizes the prefix cache for non-Anthropic providers (qwen/glm/etc.).", raw, {
 		removable: true,
 		resetHint: `remove (default: ${DEFAULTS.normalizeVolatileSystem})`
 	});
@@ -18456,11 +18495,12 @@ async function editSessionId(current) {
 }
 async function editCacheControl(current, configPath) {
 	const globalTtl = readGlobalTtl(configPath);
-	const result = await collectCacheTriState(current.cacheControl, current.cacheControlTtl, globalTtl);
+	const result = await collectCacheTriState(current.cacheControl, current.cacheControlTtl, globalTtl, current.rewriteBlockTtl);
 	if (result === null) return current;
 	const next = { ...current };
 	applyField(next, "cacheControl", result.cacheControl);
 	applyField(next, "cacheControlTtl", result.cacheControlTtl);
+	applyField(next, "rewriteBlockTtl", result.rewriteBlockTtl);
 	return next;
 }
 async function editNormalizeVolatileSystem(current) {
@@ -19353,7 +19393,7 @@ async function runConfigMenu(client) {
 }
 //#endregion
 //#region src/version.ts
-const version = "0.12.0";
+const version = "0.14.0";
 //#endregion
 //#region src/commands/doctor.ts
 const DEFAULT_TIMEOUT_MS = 3e3;
@@ -22905,6 +22945,56 @@ function buildCacheControl(existing, ttl, isAnthropic) {
 	}
 	return base;
 }
+/**
+* Whether to normalize block-level cache_control TTLs. Mirrors the cacheControl
+* tri-state: `auto` rewrites only when injection is active on an Anthropic-native
+* endpoint; `always` rewrites everywhere; `skip` never.
+*/
+function shouldRewriteBlockTtl(mode, cacheControlMode, modelName, path) {
+	if (mode === "skip") return false;
+	if (mode === "always") return true;
+	return isAnthropicEndpoint(modelName, path) && shouldInjectCacheControl(cacheControlMode, modelName, path);
+}
+/** Shallow, order-independent comparison of two cache_control objects. */
+function sameCacheControl(a, b) {
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	if (ka.length !== kb.length) return false;
+	return ka.every((k) => a[k] === b[k]);
+}
+/**
+* Normalize the TTL on every existing block-level cache_control breakpoint
+* (system, tools, messages[].content) to match the configured TTL. Reuses
+* buildCacheControl so block and root stay consistent. Adds no new breakpoints.
+* Returns whether any block was changed.
+*/
+function rewriteBlockTtls(body, ttl, isAnthropic) {
+	let mutated = false;
+	const rewriteNode = (obj) => {
+		const cc = obj.cache_control;
+		if (cc !== null && typeof cc === "object" && !Array.isArray(cc)) {
+			const next = buildCacheControl(cc, ttl, isAnthropic);
+			if (!sameCacheControl(cc, next)) {
+				obj.cache_control = next;
+				mutated = true;
+			}
+		}
+	};
+	const visitBlocks = (arr) => {
+		if (!Array.isArray(arr)) return;
+		for (const item of arr) {
+			if (item === null || typeof item !== "object" || Array.isArray(item)) continue;
+			const obj = item;
+			rewriteNode(obj);
+			visitBlocks(obj.content);
+		}
+	};
+	visitBlocks(body.system);
+	visitBlocks(body.tools);
+	const messages = body.messages;
+	for (const m of messages ?? []) visitBlocks(m?.content);
+	return mutated;
+}
 //#endregion
 //#region src/proxy/middleware/inject-cache-control.ts
 const injectCacheControl = createMiddleware(async (c, next) => {
@@ -22914,11 +23004,16 @@ const injectCacheControl = createMiddleware(async (c, next) => {
 		await next();
 		return;
 	}
+	const isAnthropic = isAnthropicEndpoint(c.var.modelName, c.req.path);
+	let mutated = false;
 	if (shouldInjectCacheControl(resolved.cacheControl, c.var.modelName, c.req.path)) {
-		const isAnthropic = isAnthropicEndpoint(c.var.modelName, c.req.path);
 		parsedBody.cache_control = buildCacheControl(parsedBody.cache_control, resolved.cacheControlTtl, isAnthropic);
-		c.set("bodyMutated", true);
+		mutated = true;
+	}
+	if (shouldRewriteBlockTtl(resolved.rewriteBlockTtl, resolved.cacheControl, c.var.modelName, c.req.path)) {
+		if (rewriteBlockTtls(parsedBody, resolved.cacheControlTtl, isAnthropic)) mutated = true;
 	}
+	if (mutated) c.set("bodyMutated", true);
 	await next();
 });
 //#endregion
@@ -22999,11 +23094,15 @@ const injectSessionId = createMiddleware(async (c, next) => {
 });
 //#endregion
 //#region src/proxy/middleware/normalize-volatile-system.ts
-/** Normalize Claude Code's per-request `cch=…` hash in system[0] to a constant; it drifts every turn and breaks prefix-cache for non-Anthropic providers. */
+/** Normalize Claude Code's per-request volatile hashes in system[0] to constants; they drift every turn and break prefix-cache for non-Anthropic providers:
+*  - `cch=…` per-turn hash
+*  - `cc_version=<semver>.<hash>` — the trailing build hash drifts; the readable semver is preserved. */
 const CCH_PATTERN = /cch=[0-9a-f]+/g;
 const CCH_REPLACEMENT = "cch=00000";
+const CC_VERSION_PATTERN = /cc_version=(\d+\.\d+\.\d+)\.[0-9a-f]+/g;
+const CC_VERSION_REPLACEMENT = "cc_version=$1.0";
 function normalizeText(text) {
-	return text.replace(CCH_PATTERN, CCH_REPLACEMENT);
+	return text.replace(CCH_PATTERN, CCH_REPLACEMENT).replace(CC_VERSION_PATTERN, CC_VERSION_REPLACEMENT);
 }
 function textOf(block) {
 	if (block !== null && typeof block === "object" && typeof block.text === "string") return block.text;