proxitor 0.9.0-beta.6 → 0.9.0-beta.8

package/README.md

@@ -258,25 +258,29 @@ By default, OpenRouter doesn't enable prompt caching — every request pays full
 
 **`cacheControl`** — injects `cache_control: { "type": "ephemeral" }` into the request body. OpenRouter uses this to set cache breakpoints and advance them as conversations grow.
 
-**`cacheControlTtl`** — controls the cache time-to-live. Anthropic's default TTL is 5 minutes (300s). Set to `1h` for a 1-hour cache at higher write cost (2× vs 1.25×). Only applies to Anthropic models — other providers don't support TTL.
+**`cacheControlTtl`** (`5m` / `1h` / `omit` / `skip`, default absent = passthrough) — controls the `ttl` field on injected `cache_control` (Anthropic endpoints only). TTL only has effect when caching is active (`cacheControl` is `auto`/`always`); it is now set independently of the cache mode in the editor.
 
 **`sessionId`** — injects `session_id` for provider sticky routing. Without it, OpenRouter only pins to a provider after detecting a cache hit. With it, routing sticks from the **first request** — critical for OpenAI models where delayed caching means 0 cached tokens on the first 1-2 requests.
 
-Both `cacheControl` and `sessionId` support `auto` / `always` / `never` modes:
+Both `cacheControl` and `sessionId` support `auto` / `always` / `skip` modes:
 
 | Mode | `cacheControl` | `sessionId` |
 | --- | --- | --- |
 | `auto` (default) | Anthropic models on `/v1/chat/completions`; all models on `/v1/messages` and `/v1/responses` | Passthrough client session ID if present; otherwise generate proxy UUID |
 | `always` | All models, all endpoints | Always generate proxy session ID, ignoring client-provided |
-| `never` | Disabled | Don't manage session headers — pass through as-is |
+| `skip` | Passthrough: leave the client's `cache_control` untouched and inject nothing | Passthrough: leave client session headers untouched |
 
 `cacheControlTtl` values:
 
 | Value | TTL | Write cost | Use when |
 | --- | --- | --- | --- |
-| _(not set)_ | 5 min (Anthropic default) | 1.25× | High-frequency requests (>1 per 5 min) |
-| `5m` | 5 minutes | 1.25× | Explicit short cache |
+| _(absent)_ | Passthrough: preserve client `ttl`, add nothing; per-model absent inherits the global TTL | — | Default |
+| `5m` | 5 minutes (Anthropic default) | 1.25× | Explicit short cache; high-frequency requests (>1 per 5 min) |
 | `1h` | 1 hour | 2.0× | Low-frequency or long-running sessions |
+| `omit` | Strip the `ttl` field, guaranteeing no TTL (even one sent by the client) | — | Force-disable TTL |
+| `skip` | Passthrough: preserve the client's `ttl`, add nothing, ignore an inherited value | — | Ignore global TTL without stripping |
+
+> **Note:** `null` (previously accepted in model overrides to cancel an inherited TTL) is **removed** — migrate to `skip`. `null` was undocumented and unsettable from the UI.
 
 ```yaml
 cacheControl: auto    # safe default — Anthropic and safe endpoints only
@@ -288,13 +292,13 @@ cacheControlTtl: 1h
 # Force caching for all models (may cause 400 on non-Anthropic /v1/chat/completions)
 # cacheControl: always
 
-# Per-model overrides — TTL supports '5m', '1h', or null (cancel global TTL)
+# Per-model overrides — TTL supports '5m', '1h', 'omit', or 'skip' (passthrough)
 modelOverrides:
   "gpt-*":
-    cacheControl: never       # OpenAI caches automatically, no injection needed
+    cacheControl: skip       # OpenAI caches automatically, no injection needed
     sessionId: always          # but sticky routing still helps
   "claude-opus-*":
-    cacheControlTtl: null      # cancel global 1h TTL for Opus — use Anthropic's 5 min default
+    cacheControlTtl: skip     # passthrough for Opus — ignore the global 1h TTL, use the client ttl
 ```
 
 **Why all three matter:**
@@ -362,7 +366,7 @@ If a config already exists, the wizard shows its location and asks whether to re
 
 - **Show current config** — display the resolved configuration
 - **API key & connection** — change API key, port, listen address, base URL, auth type
-- **Session routing** — set global `sessionId` mode (`auto` / `always` / `never`)
+- **Session routing** — set global `sessionId` mode (`auto` / `always` / `skip`)
 - **Cache control** — set global `cacheControl` mode and TTL
 - **Model overrides** — add, edit, remove, list, or browse models
 
@@ -386,6 +390,8 @@ proxitor doctor --offline      # skip network checks
 
 When adding or editing a model override, you can also configure per-model `sessionId` and `cacheControl` — useful for models that need different caching or routing behavior than the global default.
 
+In `config edit`, any field (provider, session ID, cache control, cache TTL) can be reset to inherit the global/default value via the **Reset / inherit** prompt option. The global `config cache-control` and `config session-routing` commands support the same reset — it reverts the field to the schema default.
+
 ### Add override walkthrough
 
 ```sh

package/dist/cli.mjs

@@ -8369,7 +8369,6 @@ const string$2 = (params) => {
 const integer = /^-?\d+$/;
 const number$2 = /^-?\d+(?:\.\d+)?$/;
 const boolean$1 = /^(?:true|false)$/i;
-const _null$2 = /^null$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
 //#endregion
@@ -9182,22 +9181,6 @@ const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
 		return payload;
 	};
 });
-const $ZodNull = /*@__PURE__*/ $constructor("$ZodNull", (inst, def) => {
-	$ZodType.init(inst, def);
-	inst._zod.pattern = _null$2;
-	inst._zod.values = new Set([null]);
-	inst._zod.parse = (payload, _ctx) => {
-		const input = payload.value;
-		if (input === null) return payload;
-		payload.issues.push({
-			expected: "null",
-			code: "invalid_type",
-			input,
-			inst
-		});
-		return payload;
-	};
-});
 const $ZodUnknown = /*@__PURE__*/ $constructor("$ZodUnknown", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload) => payload;
@@ -10346,13 +10329,6 @@ function _boolean(Class, params) {
 	});
 }
 // @__NO_SIDE_EFFECTS__
-function _null$1(Class, params) {
-	return new Class({
-		type: "null",
-		...normalizeParams(params)
-	});
-}
-// @__NO_SIDE_EFFECTS__
 function _unknown(Class) {
 	return new Class({ type: "unknown" });
 }
@@ -10901,13 +10877,6 @@ const numberProcessor = (schema, ctx, _json, _params) => {
 const booleanProcessor = (_schema, _ctx, json, _params) => {
 	json.type = "boolean";
 };
-const nullProcessor = (_schema, ctx, json, _params) => {
-	if (ctx.target === "openapi-3.0") {
-		json.type = "string";
-		json.nullable = true;
-		json.enum = [null];
-	} else json.type = "null";
-};
 const neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
@@ -11577,14 +11546,6 @@ const ZodBoolean = /*@__PURE__*/ $constructor("ZodBoolean", (inst, def) => {
 function boolean(params) {
 	return /* @__PURE__ */ _boolean(ZodBoolean, params);
 }
-const ZodNull = /*@__PURE__*/ $constructor("ZodNull", (inst, def) => {
-	$ZodNull.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => nullProcessor(inst, ctx, json, params);
-});
-function _null(params) {
-	return /* @__PURE__ */ _null$1(ZodNull, params);
-}
 const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
@@ -11992,13 +11953,19 @@ const providerConfigSchema = object({
 const triStateSchema = _enum([
 	"auto",
 	"always",
-	"never"
+	"skip"
+]);
+const ttlSchema = _enum([
+	"5m",
+	"1h",
+	"omit",
+	"skip"
 ]);
 const modelOverrideSchema = object({
 	provider: providerConfigSchema.optional(),
 	headers: record(string$1(), string$1()).optional(),
 	cacheControl: triStateSchema.optional(),
-	cacheControlTtl: union([_enum(["5m", "1h"]), _null()]).optional(),
+	cacheControlTtl: ttlSchema.optional(),
 	sessionId: triStateSchema.optional()
 }).strict();
 const proxyConfigSchema = object({
@@ -12015,7 +11982,7 @@ const proxyConfigSchema = object({
 	attributionTitle: string$1().min(1).default("proxitor"),
 	headers: record(string$1(), string$1()).optional(),
 	cacheControl: triStateSchema.default("auto"),
-	cacheControlTtl: _enum(["5m", "1h"]).optional(),
+	cacheControlTtl: ttlSchema.optional(),
 	sessionId: triStateSchema.default("auto"),
 	modelOverrides: record(string$1().min(1), modelOverrideSchema).optional()
 }).strict();
@@ -12171,7 +12138,7 @@ function applyOverride(result, override) {
 		...override.headers
 	};
 	if (override.cacheControl !== void 0) result.cacheControl = override.cacheControl;
-	if (override.cacheControlTtl !== void 0) result.cacheControlTtl = override.cacheControlTtl ?? void 0;
+	if (override.cacheControlTtl !== void 0) result.cacheControlTtl = override.cacheControlTtl;
 	if (override.sessionId !== void 0) result.sessionId = override.sessionId;
 }
 /** Reject base URLs ending in /v1 — paths are forwarded as-is, so /v1 suffix causes doubled paths. */
@@ -20259,85 +20226,113 @@ async function askHost(current) {
 const SESSION_HINTS = {
 	auto: "Passthrough client ID, generate if missing",
 	always: "Always generate proxy session ID",
-	never: "Don't manage session headers"
+	skip: "Passthrough — leave client session headers as-is"
 };
 /** Shared hint texts for cache control tri-state — used in add, edit, cache-control. */
 const CACHE_HINTS = {
 	auto: "Anthropic models only",
 	always: "All models",
-	never: "Off"
+	skip: "Passthrough — leave client cache_control headers as-is"
 };
-async function askTriState(message, current, hints) {
-	const result = await select({
+async function askTriState(message, current, hints, opts) {
+	const options = [
+		{
+			value: "auto",
+			label: "auto",
+			hint: hints.auto
+		},
+		{
+			value: "always",
+			label: "always",
+			hint: hints.always
+		},
+		{
+			value: "skip",
+			label: "skip",
+			hint: hints.skip
+		}
+	];
+	if (opts?.removable) options.push({
+		value: "reset",
+		label: "Reset / inherit",
+		hint: "Remove override"
+	});
+	return await select({
 		message,
 		initialValue: current ?? "auto",
-		options: [
-			{
-				value: "auto",
-				label: "auto",
-				hint: hints.auto
-			},
-			{
-				value: "always",
-				label: "always",
-				hint: hints.always
-			},
-			{
-				value: "never",
-				label: "never",
-				hint: hints.never
-			}
-		]
+		options
 	});
-	if (isCancel(result)) return null;
-	return result;
 }
-async function askCacheControlTtl(current) {
-	const options = [{
-		value: "5m",
-		label: "5 minutes",
-		hint: "Anthropic default"
-	}, {
-		value: "1h",
-		label: "1 hour",
-		hint: "Higher write cost"
-	}];
-	if (current) options.push({
+async function askCacheControlTtl(current, opts) {
+	const inherit = opts?.globalTtl === void 0 ? "inherit global (none)" : `inherit global (${opts.globalTtl})`;
+	const overrides = opts?.globalTtl === void 0 ? "overrides inherited" : `overrides global ${opts.globalTtl}`;
+	const options = [
+		{
+			value: "5m",
+			label: "5 minutes",
+			hint: "Anthropic default"
+		},
+		{
+			value: "1h",
+			label: "1 hour",
+			hint: "Higher write cost"
+		},
+		{
+			value: "skip",
+			label: "Passthrough",
+			hint: `Preserve client ttl, ${overrides}`
+		},
+		{
+			value: "omit",
+			label: "Strip",
+			hint: `Guarantee no ttl (${overrides})`
+		}
+	];
+	if (opts?.removable) options.push({
 		value: "reset",
-		label: "Reset to default",
-		hint: "Remove TTL override"
+		label: "Reset / inherit",
+		hint: inherit
 	});
-	const result = await select({
+	return await select({
 		message: "Cache TTL",
 		initialValue: current ?? "5m",
 		options
 	});
-	if (isCancel(result)) return null;
-	if (result === "reset") return "reset";
-	return result;
 }
 //#endregion
 //#region src/commands/config/tri-state.ts
-async function collectSessionTriState(currentSid) {
-	const sid = await askTriState("Session ID mode", currentSid ?? "auto", SESSION_HINTS);
-	if (sid === null) return null;
-	return { sessionId: sid };
+/** Apply a resolved field: {value}→assign, {remove}→delete, undefined→keep. */
+function applyField(obj, key, field) {
+	if (field === void 0) return;
+	if ("remove" in field) delete obj[key];
+	else obj[key] = field.value;
 }
-/**
-* TTL cancel behaviour: pressing Escape on the TTL prompt preserves the
-* existing TTL rather than silently dropping it.
-*/
-async function collectCacheTriState(currentCc, currentTtl) {
-	const cc = await askTriState("Cache control mode", currentCc ?? "auto", CACHE_HINTS);
-	if (cc === null) return null;
-	const result = { cacheControl: cc };
-	if (cc !== "never") {
-		const ttl = await askCacheControlTtl(currentTtl ?? void 0);
-		if (ttl === null) {
-			if (currentTtl) result.cacheControlTtl = currentTtl;
-		} else if (ttl !== "reset") result.cacheControlTtl = ttl;
-	}
-	return result;
+async function collectSessionTriState(currentSid) {
+	const sid = await askTriState("Session ID mode", currentSid ?? "auto", SESSION_HINTS, { removable: true });
+	if (typeof sid === "symbol") return null;
+	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) {
+	const cc = await askTriState("Cache control mode", currentCc ?? "auto", CACHE_HINTS, { removable: true });
+	if (typeof cc === "symbol") return null;
+	let cacheControl;
+	if (cc === "reset") cacheControl = { remove: true };
+	else cacheControl = { value: cc };
+	const ttl = await askCacheControlTtl(currentTtl, {
+		removable: true,
+		globalTtl
+	});
+	if (typeof ttl === "symbol") return { cacheControl };
+	if (ttl === "reset") return {
+		cacheControl,
+		cacheControlTtl: { remove: true }
+	};
+	return {
+		cacheControl,
+		cacheControlTtl: { value: ttl }
+	};
 }
 //#endregion
 //#region src/commands/config/add.ts
@@ -20457,7 +20452,7 @@ async function collectSession(override) {
 	});
 	if (isCancel(want) || !want) return override;
 	const result = await collectSessionTriState();
-	if (result) override.sessionId = result.sessionId;
+	if (result && !("remove" in result.sessionId)) override.sessionId = result.sessionId.value;
 	return override;
 }
 async function collectCache(override) {
@@ -20468,8 +20463,8 @@ async function collectCache(override) {
 	if (isCancel(want) || !want) return override;
 	const result = await collectCacheTriState();
 	if (result) {
-		override.cacheControl = result.cacheControl;
-		if (result.cacheControlTtl) override.cacheControlTtl = result.cacheControlTtl;
+		if (!("remove" in result.cacheControl)) override.cacheControl = result.cacheControl.value;
+		if (result.cacheControlTtl && !("remove" in result.cacheControlTtl)) override.cacheControlTtl = result.cacheControlTtl.value;
 	}
 	return override;
 }
@@ -20610,6 +20605,20 @@ function formatOverrideHint(override) {
 	if (override.headers) parts.push(`${Object.keys(override.headers).length} header(s)`);
 	return parts.join(", ") || "(empty)";
 }
+function formatCacheHint(cc, ttl) {
+	let ttlLabel = ttl ?? "";
+	if (ttl === "omit") ttlLabel = "ttl strip";
+	else if (ttl === "skip") ttlLabel = "ttl passthrough";
+	return [cc, ttlLabel].filter(Boolean).join(", ") || "(inherit)";
+}
+function readGlobalTtl(configPath) {
+	if (!configPath) return void 0;
+	try {
+		return readConfigFile(configPath).cacheControlTtl;
+	} catch {
+		return;
+	}
+}
 function showCurrentConfig(modelKey, current) {
 	log.info(`Current config for "${modelKey}":`);
 	if (current.provider) for (const [field, value] of Object.entries(current.provider)) log.info(`  provider.${field}: ${JSON.stringify(value)}`);
@@ -20638,21 +20647,19 @@ async function editProvider(modelKey, current, client) {
 async function editSessionId(current) {
 	const result = await collectSessionTriState(current.sessionId);
 	if (result === null) return current;
-	const { sessionId: _, ...rest } = current;
-	return {
-		...rest,
-		sessionId: result.sessionId
-	};
+	const next = { ...current };
+	applyField(next, "sessionId", result.sessionId);
+	return next;
 }
 /** @internal */
-async function editCacheControl(current) {
-	const result = await collectCacheTriState(current.cacheControl, current.cacheControlTtl);
+async function editCacheControl(current, configPath) {
+	const globalTtl = readGlobalTtl(configPath);
+	const result = await collectCacheTriState(current.cacheControl, current.cacheControlTtl, globalTtl);
 	if (result === null) return current;
-	const { cacheControl: _cc, cacheControlTtl: _ttl, ...rest } = current;
-	return {
-		...rest,
-		...result
-	};
+	const next = { ...current };
+	applyField(next, "cacheControl", result.cacheControl);
+	applyField(next, "cacheControlTtl", result.cacheControlTtl);
+	return next;
 }
 /** Run the interactive "Edit model override" flow. */
 async function editOverrideCommand(client, configPath) {
@@ -20694,7 +20701,7 @@ async function editOverrideCommand(client, configPath) {
 				{
 					value: "cacheControl",
 					label: "Cache control",
-					hint: [current.cacheControl, current.cacheControlTtl].filter(Boolean).join(", ") || "(inherit)"
+					hint: formatCacheHint(current.cacheControl, current.cacheControlTtl)
 				},
 				{
 					value: "done",
@@ -20711,7 +20718,7 @@ async function editOverrideCommand(client, configPath) {
 				current = await editSessionId(current);
 				break;
 			case "cacheControl":
-				current = await editCacheControl(current);
+				current = await editCacheControl(current, resolvedConfigPath);
 				break;
 		}
 	}
@@ -21251,18 +21258,21 @@ async function cacheControlCommand(opts) {
 	const currentTtl = cfg.cacheControlTtl;
 	log.info(`Current: cacheControl = ${currentCc}`);
 	if (currentTtl) log.info(`Current: cacheControlTtl = ${currentTtl}`);
-	const cc = await askTriState("Cache control mode", currentCc, CACHE_HINTS);
-	if (cc === null) return;
-	const fields = { cacheControl: cc };
-	if (cc !== "never") {
-		const ttlResult = await askCacheControlTtl(currentTtl);
-		if (ttlResult === null) return;
-		if (ttlResult === "reset") fields.cacheControlTtl = void 0;
-		else fields.cacheControlTtl = ttlResult;
+	const cc = await askTriState("Cache control mode", currentCc, CACHE_HINTS, { removable: true });
+	if (typeof cc === "symbol") return;
+	const fields = {};
+	fields.cacheControl = cc === "reset" ? void 0 : cc;
+	const ttlResult = await askCacheControlTtl(currentTtl, { 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;
 	setGlobalConfigFields(configPath, fields);
-	const ttlPart = fields.cacheControlTtl ? `, TTL = ${fields.cacheControlTtl}` : "";
-	log.success(`cacheControl set to ${cc}${ttlPart}`);
+	const ccLabel = cc === "reset" ? "(default)" : cc;
+	const ttlLabel = ttlResult === "reset" ? "(default)" : ttlResult;
+	log.success(`cacheControl set to ${ccLabel}, TTL = ${ttlLabel}`);
 }
 //#endregion
 //#region src/commands/config/connection.ts
@@ -21343,8 +21353,13 @@ async function sessionRoutingCommand(opts) {
 	const configPath = requireConfigPath(opts?.configPath);
 	const current = readConfigFile(configPath).sessionId ?? DEFAULTS.sessionId;
 	log.info(`Current: sessionId = ${current}`);
-	const result = await askTriState("Session routing mode", current, SESSION_HINTS);
-	if (result === null) return;
+	const result = await askTriState("Session routing mode", current, SESSION_HINTS, { removable: true });
+	if (typeof result === "symbol") return;
+	if (result === "reset") {
+		setGlobalConfigField(configPath, "sessionId", void 0);
+		log.success("sessionId reset to default (auto)");
+		return;
+	}
 	setGlobalConfigField(configPath, "sessionId", result);
 	log.success(`sessionId set to ${result}`);
 }
@@ -21457,7 +21472,7 @@ async function runConfigMenu(client) {
 }
 //#endregion
 //#region src/version.ts
-const version = "0.9.0-beta.6";
+const version = "0.9.0-beta.8";
 //#endregion
 //#region src/commands/doctor.ts
 const DEFAULT_TIMEOUT_MS = 3e3;
@@ -24741,14 +24756,17 @@ function isAnthropicEndpoint(modelName, path) {
 	return ANTHROPIC_NATIVE_ENDPOINTS.has(endpoint) || isAnthropicModel(modelName ?? "");
 }
 function shouldInjectCacheControl(mode, modelName, path) {
-	if (mode === "never") return false;
+	if (mode === "skip") return false;
 	if (mode === "always") return true;
 	return isAnthropicEndpoint(modelName, path);
 }
 function buildCacheControl(existing, ttl, isAnthropic) {
 	const base = existing !== null && typeof existing === "object" && !Array.isArray(existing) ? { ...existing } : {};
 	if (!("type" in base)) base.type = "ephemeral";
-	if (ttl && isAnthropic) base.ttl = ttl;
+	if (ttl === "omit") delete base.ttl;
+	else if (ttl === "5m" || ttl === "1h") {
+		if (isAnthropic) base.ttl = ttl;
+	}
 	return base;
 }
 //#endregion
@@ -24823,7 +24841,7 @@ function extractConversationFingerprint(parsedBody, path) {
 	return hash.digest("hex");
 }
 function deriveSessionId(incomingHeaders, parsedBody, path, mode) {
-	if (mode === "never") return void 0;
+	if (mode === "skip") return void 0;
 	if (mode === "auto") {
 		const fromHeader = incomingHeaders.get("x-claude-code-session-id");
 		if (fromHeader) return fromHeader.slice(0, 256);