@eddyskywalker/dsh-chatgpt-subscription 0.10.12 → 0.10.13

package/lib/index.js

@@ -2,13 +2,13 @@ import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
 import * as LlmModule from "@deepseek-ai/dsh-llm";
 import { HarnessError, LlmAdapter, LlmError, LlmError as LlmError$1, ProviderRequestId, ReasoningEffortId, attributionHeaders, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
+import fs, { chmod, lstat, mkdir, open, readFile, rename, stat, unlink } from "node:fs/promises";
 import path, { basename, dirname, join, relative, resolve } from "node:path";
 import os, { homedir } from "node:os";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { execSync, spawn } from "node:child_process";
-import fsPromises, { chmod, lstat, mkdir, open, readFile, rename, stat, unlink } from "node:fs/promises";
-import fs, { appendFileSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
+import fs$1, { appendFileSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import http, { createServer } from "node:http";
 import { WebError } from "@deepseek-ai/dsh-web";
 import { lookup } from "node:dns/promises";
@@ -60,7 +60,23 @@ const OAUTH_CALLBACK_HOST = "localhost";
 const OAUTH_CALLBACK_PORT = 1455;
 const OAUTH_REDIRECT_URI = `http://${OAUTH_CALLBACK_HOST}:${OAUTH_CALLBACK_PORT}/auth/callback`;
 const OAUTH_SCOPE = "openid profile email offline_access";
-const OAUTH_ORIGINATOR = "opencode";
+/**
+* The single `originator` this line presents to the Codex backend on every
+* request, and the one OAuth sends during sign-in.
+*
+* This used to be three different values - `opencode` for chat and sign-in,
+* `pi` for the image and search endpoints - which was an archaeological record
+* of when each endpoint was reverse-engineered, not a decision. The Codex
+* backend keys behaviour off this value (`codex_cli_rs` is what the official
+* CLI sends) and treats it as one client identity, so splitting it across three
+* files meant three unrelated failure signatures for one account. Both spellings
+* are known-good against the backend; `opencode` is kept because it is the value
+* the OAuth flow has always presented, and changing the sign-in originator is a
+* different risk from changing the request originator.
+*/
+const CODEX_ORIGINATOR = "opencode";
+/** OAuth presents the same identity the request path does (see above). */
+const OAUTH_ORIGINATOR = CODEX_ORIGINATOR;
 const TOKEN_REFRESH_MARGIN_MS = 6e4;
 const ROUTE_PREFIX$4 = "/api/dsh-chatgpt-subscription";
 const PLUGIN_VERSION = "0.1.0-alpha.0";
@@ -70,9 +86,18 @@ const CODEX_RESPONSES_URL = `${CODEX_API_BASE}/responses`;
 const CODEX_IMAGE_GENERATION_URL = `${CODEX_API_BASE}/images/generations`;
 const CODEX_SEARCH_URL = `${CODEX_API_BASE}/alpha/search`;
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CODEX_MODELS_URL = `${CODEX_API_BASE}/models?client_version=0.99.0`;
+/**
+* Beta gate the Codex backend expects on every responses request.
+*
+* The subscription backend is served under a beta flag, not as stable API:
+* without this header the endpoint is a different (and, on older builds,
+* rejected) surface. Kept as a single constant so the value is reviewable in
+* one place with the rest of the wire contract in `wire-auth.ts`.
+*/
+const CODEX_OPENAI_BETA = "responses=experimental";
 const CODEX_RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
 const CODEX_RESET_CREDITS_CONSUME_URL = `${CODEX_RESET_CREDITS_URL}/consume`;
-const CODEX_ORIGINATOR = "opencode";
 const CODEX_IMAGE_TOOL_NAME = "codex_image_generate";
 const CODEX_IMAGE_MODEL = "gpt-image-2";
 const CODEX_SEARCH_PROVIDER_ID = "codex-subscription";
@@ -227,6 +252,9 @@ function reasoningEffortsForModel(model) {
 	if (profile === "gpt-6") return GPT_6_REASONING_EFFORTS;
 	return profile === "gpt-5.6" ? GPT_56_REASONING_EFFORTS : STANDARD_REASONING_EFFORTS;
 }
+function isCodexReasoningEffort(value) {
+	return typeof value === "string" && GPT_56_REASONING_EFFORTS.some((effort) => effort === value);
+}
 function isCodexModelId(model) {
 	return typeof model === "string" && CODEX_MODEL_CATALOG.some((entry) => entry.id === model);
 }
@@ -270,28 +298,40 @@ function resolveCodexFallbackModel(model) {
 //#region src/host/model-catalog.ts
 const PROVIDER_ID$6 = CODEX_CHATGPT_PROVIDER_ID;
 const PROVIDER_NAME$6 = "Codex（ChatGPT 订阅）";
-function listCodexModels(preferences) {
+function listCodexModels(preferences, live) {
 	const status = preferences?.status();
 	if (status?.enabled === false) return [];
-	const visible = new Set(status?.visibleModelIds ?? CODEX_MODEL_CATALOG.map((entry) => entry.id));
-	return CODEX_MODEL_CATALOG.filter((entry) => visible.has(entry.id)).map((entry) => ({
+	const source = live !== void 0 && live.length > 0 ? live.map((entry) => ({
+		id: entry.id,
+		name: entry.name,
+		inputModalities: entry.inputModalities
+	})) : CODEX_MODEL_CATALOG.map((entry) => ({
+		id: entry.id,
+		name: entry.name,
+		inputModalities: entry.inputModalities
+	}));
+	const visible = new Set(status?.visibleModelIds ?? source.map((entry) => entry.id));
+	return source.filter((entry) => visible.has(entry.id)).map((entry) => ({
 		provider: PROVIDER_ID$6,
 		id: entry.id,
 		name: entry.name,
 		inputModalities: [...entry.inputModalities]
 	}));
 }
-function resolveCodexModel(model, preferences) {
+function resolveCodexModel(model, preferences, live) {
 	const entry = resolveCodexCatalogEntry(model);
+	const liveEntry = live?.find((candidate) => candidate.id === model);
 	const configuredContextWindow = (preferences?.status())?.contextWindowOverrides[model];
-	const efforts = reasoningEffortsForModel(model);
-	const defaultEffort = efforts.includes(entry.defaultReasoningEffort) ? entry.defaultReasoningEffort : efforts[0];
+	const listedEfforts = liveEntry?.reasoningEfforts?.filter(isCodexReasoningEffort);
+	const efforts = listedEfforts !== void 0 && listedEfforts.length > 0 ? listedEfforts : reasoningEffortsForModel(model);
+	const statedDefault = liveEntry?.defaultReasoningEffort ?? entry.defaultReasoningEffort;
+	const defaultEffort = isCodexReasoningEffort(statedDefault) && efforts.includes(statedDefault) ? statedDefault : efforts[0];
 	return {
 		provider: PROVIDER_ID$6,
 		id: model,
-		name: entry.id === model ? entry.name : model,
-		inputModalities: [...entry.inputModalities],
-		context: { contextWindow: configuredContextWindow ?? entry.contextWindow },
+		name: liveEntry?.name ?? (entry.id === model ? entry.name : model),
+		inputModalities: [...liveEntry?.inputModalities ?? entry.inputModalities],
+		context: { contextWindow: configuredContextWindow ?? liveEntry?.contextWindow ?? entry.contextWindow },
 		defaultMaxTokens: codexModelMaxTokens(model),
 		reasoning: {
 			efforts: efforts.map((effort) => ({
@@ -324,10 +364,12 @@ const RETRY_POLICY$5 = resolveRetryPolicy({
 var CodexChatGptAdapter = class extends LlmAdapter {
 	client;
 	preferences;
-	constructor(client, preferences) {
+	loadCatalog;
+	constructor(client, preferences, loadCatalog) {
 		super();
 		this.client = client;
 		this.preferences = preferences;
+		this.loadCatalog = loadCatalog;
 	}
 	providerInfo(provider) {
 		return {
@@ -340,10 +382,21 @@ var CodexChatGptAdapter = class extends LlmAdapter {
 	}
 	imageRequestPricing(_provider, _model) {}
 	async listModels() {
-		return listCodexModels(this.preferences);
+		return listCodexModels(this.preferences, await this.catalog());
 	}
 	async resolveModel(_provider, model, signal) {
-		return resolveCodexModel(model, this.preferences);
+		return resolveCodexModel(model, this.preferences, await this.catalog(signal));
+	}
+	/**
+	* The live listing, or undefined when this line has no way to fetch one.
+	*
+	* Never throws: a listing failure must not become a failed picker or a
+	* rejected model resolution. `loadCodexCatalog` already answers with the
+	* shipped table on failure, so the catch here only covers a throwing loader.
+	*/
+	async catalog(signal) {
+		if (this.loadCatalog === void 0) return void 0;
+		return this.loadCatalog({ signal }).catch(() => void 0);
 	}
 	async prepareCall(provider, model, signal) {
 		return {
@@ -367,6 +420,347 @@ function dshHomeDir() {
 	return process.env.DSH_HOME?.trim() || path.join(os.homedir(), ".dsh");
 }
 //#endregion
+//#region src/host/common/catalog-snapshot.ts
+/**
+* Persistent snapshot for one provider's live model catalog.
+*
+* The in-memory catalog caches keep a process alive between requests, but they
+* start cold: on the first call after a restart (or a plugin reinstall) the
+* picker and the settings page both wait on the upstream listing before they
+* can render anything, and an unreachable endpoint turns that wait into the
+* full discovery timeout — "the model server is unavailable" on a fresh
+* install. The catalog is not fast-moving data, so the last successful listing
+* is persisted to `<DSH_HOME>/storages/` and rehydrated into the in-memory
+* cache on first use. A snapshot the caller can read is therefore available
+* from the very first call, with no network in the path.
+*
+* Writes are best-effort: persistence is an optimization, never a capability.
+* A read-only home or a locked file must not fail the fetch that produced the
+* snapshot.
+*/
+/** File name of the persisted snapshot for one catalog. */
+function catalogSnapshotPath(name) {
+	return path.join(dshHomeDir(), "storages", `${name}-catalog.json`);
+}
+/**
+* Snapshot name for one catalog *and* one credential scope.
+*
+* A persisted snapshot answers before any credential is read — that is the whole
+* point of it — so the file itself has to carry the scope it was fetched under.
+* Otherwise the first call after a restart, for any account, is answered by
+* whatever listing some other scope happened to persist last: a Kimi listing
+* fetched for the mainland-cn endpoint would answer a global caller with models
+* and context windows that region does not serve, and a Command Code listing
+* fetched against one API environment would answer the other.
+*
+* The scope is part of the file name rather than of the payload because a caller
+* that cannot name the account — the harness resolves this catalog with no token
+* at all — still has to find the snapshot its own scope owns.
+*
+* Everything outside `[a-z0-9]` is folded to `_`, so no scope can escape the
+* `storages` directory.
+*/
+function catalogSnapshotName(base, scope) {
+	const normalized = scope.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+	return normalized === "" ? base : `${base}-${normalized}`;
+}
+/**
+* Read the persisted snapshot for one catalog.
+*
+* Shape errors and unreadable files both return `undefined` — the caller keeps
+* its in-memory state, and the next successful fetch overwrites the file.
+*/
+async function readCatalogSnapshot(name, parseModels) {
+	try {
+		const content = await fs.readFile(catalogSnapshotPath(name), "utf8");
+		const parsed = JSON.parse(content);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+		const record = parsed;
+		const fetchedAt = record.fetchedAt;
+		if (typeof fetchedAt !== "number" || !Number.isFinite(fetchedAt) || fetchedAt <= 0) return void 0;
+		const models = parseModels(record.models);
+		if (models === void 0 || models.length === 0) return void 0;
+		return {
+			fetchedAt,
+			models
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* Snapshot writes still in flight.
+*
+* Callers fire-and-forget these writes, so nothing in production ever awaits
+* one. A test that deletes its private `storages` directory between cases
+* cannot know when that is safe, and a write that lands after the delete
+* recreates the file the next case asserts is absent — which is how a stale
+* listing leaked into a later test and failed it on CI. Registering each write
+* gives {@link flushCatalogSnapshots} a deterministic point to wait on.
+*/
+const pendingSnapshotWrites = /* @__PURE__ */ new Set();
+/** Persist one snapshot; a failure is logged nowhere and never thrown. */
+function writeCatalogSnapshot(name, models, fetchedAt) {
+	const write = (async () => {
+		try {
+			const filePath = catalogSnapshotPath(name);
+			await fs.mkdir(path.dirname(filePath), { recursive: true });
+			const tmp = `${filePath}.tmp.${Date.now()}`;
+			await fs.writeFile(tmp, JSON.stringify({
+				fetchedAt,
+				models
+			}, null, 2), "utf8");
+			await fs.rename(tmp, filePath);
+		} catch {}
+	})();
+	pendingSnapshotWrites.add(write);
+	write.finally(() => {
+		pendingSnapshotWrites.delete(write);
+	});
+	return write;
+}
+/**
+* Warm an in-memory cache from the persisted snapshot when it is fresher than
+* what the cache currently holds. Called lazily on the first cache miss of a
+* process, so a restart serves the previous listing without waiting on the
+* network.
+*
+* @returns the snapshot's `fetchedAt`, or `0` when no usable snapshot exists —
+*   the caller then fetches as before.
+*/
+async function rehydrateCatalogCache(name, parseModels, accept, currentFetchedAt) {
+	const snapshot = await readCatalogSnapshot(name, parseModels);
+	if (snapshot === void 0 || snapshot.fetchedAt <= currentFetchedAt) return 0;
+	accept(snapshot.fetchedAt, snapshot.models);
+	return snapshot.fetchedAt;
+}
+//#endregion
+//#region src/host/wire-auth.ts
+/**
+* Turn-state header the Codex backend hands back on a responses response.
+*
+* The official CLI reads it and echoes it on the next request of the same
+* conversation; the backend uses it to resume instead of re-ingesting the
+* whole history. It is opaque, short-lived and account-scoped, so it is
+* threaded through rather than computed (see `responses-client.ts`).
+*/
+const CODEX_TURN_STATE_HEADER = "x-codex-turn-state";
+function codexHeaders(credentials, sessionId, options = {}) {
+	const dshAgent = attributionHeaders()["user-agent"] ?? "dsh/unknown";
+	return {
+		authorization: `Bearer ${credentials.accessToken}`,
+		...credentials.accountId ? { "chatgpt-account-id": credentials.accountId } : {},
+		"openai-beta": CODEX_OPENAI_BETA,
+		originator: CODEX_ORIGINATOR,
+		"user-agent": `dsh-chatgpt-subscription/${PLUGIN_VERSION} (${dshAgent})`,
+		...sessionId ? { "session-id": sessionId } : {},
+		...options.turnState ? { [CODEX_TURN_STATE_HEADER]: options.turnState } : {}
+	};
+}
+function stableSessionId(value) {
+	const source = value === void 0 || value === "" ? randomUUID() : value;
+	return `dsh-${createHash("sha256").update(source).digest("hex").slice(0, 32)}`;
+}
+function retryAfterMs$1(headers) {
+	const raw = headers.get("retry-after");
+	if (raw === null) return void 0;
+	const seconds = Number(raw);
+	if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, 10 * 6e4);
+	const timestamp = Date.parse(raw);
+	if (!Number.isFinite(timestamp)) return void 0;
+	return Math.min(Math.max(0, timestamp - Date.now()), 10 * 6e4);
+}
+//#endregion
+//#region src/host/codex-catalog.ts
+/** How long a live listing is reused before the server is asked again. */
+const CATALOG_TTL_MS = 15 * 6e4;
+/**
+* Snapshot scope.
+*
+* The Codex listing is account-scoped (each plan sees its own models), so the
+* persisted snapshot is filed under the account it was fetched for. Without the
+* scope a rehydrated listing from one account would answer another's picker.
+*/
+const SNAPSHOT_SCOPE = "chatgpt-codex";
+let catalogCache$2 = null;
+const catalogInFlight$3 = /* @__PURE__ */ new Map();
+let snapshotRehydrated = null;
+/**
+* The listing currently held, or undefined before the first load.
+*
+* Callers that need a catalog with no credential read the shipped table
+* directly; returning it here under a different entry type would force every
+* one of them to convert it.
+*/
+function getCachedCatalog() {
+	return catalogCache$2?.models;
+}
+/**
+* Read the models this subscription can call.
+*
+* The shipped table in `shared/model-catalog.ts` stays the floor: it is what
+* answers a picker before the first sign-in, and what a failed listing falls
+* back to. The subscription listing is the authority once one is available,
+* because only the backend knows which models a plan currently serves and at
+* what context window — the reason subscription-only models exist at all.
+*
+* Single-flighted per account, because the harness resolves every model of every
+* provider when it builds the picker; without that, one picker build is one
+* round trip per model.
+*/
+function loadCodexCatalog(credentials, options = {}) {
+	const key = accountKeyFor$1(credentials);
+	if (options.force !== true) {
+		const cached = catalogCache$2;
+		if (cached !== null && cached.key === key && Date.now() - cached.at < CATALOG_TTL_MS) return Promise.resolve(cached.models);
+	}
+	const pending = catalogInFlight$3.get(key);
+	if (pending !== void 0) return pending;
+	const run = performCatalogLoad$1(credentials, options).then((models) => {
+		catalogInFlight$3.delete(key);
+		return models;
+	}, (error) => {
+		catalogInFlight$3.delete(key);
+		throw error;
+	});
+	catalogInFlight$3.set(key, run);
+	return run;
+}
+async function performCatalogLoad$1(credentials, options) {
+	const key = accountKeyFor$1(credentials);
+	const fetchFn = options.fetchFn ?? fetch;
+	snapshotRehydrated ??= rehydrateSnapshot(key);
+	await snapshotRehydrated;
+	const cached = catalogCache$2;
+	if (cached !== null && cached.key === key && Date.now() - cached.at < CATALOG_TTL_MS) return cached.models;
+	let models;
+	let live = false;
+	try {
+		const response = await fetchFn(CODEX_MODELS_URL, {
+			method: "GET",
+			headers: {
+				...codexHeaders(credentials),
+				accept: "application/json"
+			},
+			signal: options.signal
+		});
+		if (!response.ok) throw new Error(`Codex model listing failed (${response.status}).`);
+		const listing = parseListing(await response.json().catch(() => void 0));
+		if (listing.length === 0) throw new Error("Codex model listing named no models this line understands.");
+		models = listing;
+		live = true;
+		writeCatalogSnapshot(catalogSnapshotName(SNAPSHOT_SCOPE, key), [...models], Date.now());
+	} catch {
+		models = getCachedCatalog() ?? [];
+		live = false;
+	}
+	catalogCache$2 = {
+		at: Date.now(),
+		models,
+		key,
+		live
+	};
+	return models;
+}
+/**
+* Seed the in-memory cache from the last persisted listing.
+*
+* Best effort by construction: a missing or malformed snapshot leaves the cache
+* cold, and the caller then simply makes the network call.
+*/
+async function rehydrateSnapshot(key) {
+	const snapshot = await readCatalogSnapshot(catalogSnapshotName(SNAPSHOT_SCOPE, key), (value) => Array.isArray(value) ? value.flatMap((item) => parseListingEntry$1(item)) : void 0).catch(() => void 0);
+	if (snapshot === void 0 || snapshot.models.length === 0) return;
+	if (catalogCache$2 !== null) return;
+	catalogCache$2 = {
+		at: snapshot.fetchedAt,
+		models: snapshot.models,
+		key,
+		live: true
+	};
+}
+/**
+* Read the listing payload.
+*
+* The documented shape is `{ models: [...] }`, but a bare array is accepted too
+* so a backend that flattens the envelope does not read as an empty catalog.
+*/
+function parseListing(payload) {
+	const record = asRecord$10(payload);
+	const models = Array.isArray(payload) ? payload : record?.models;
+	if (!Array.isArray(models)) return [];
+	return models.flatMap((item) => parseListingEntry$1(item));
+}
+/**
+* One listing entry.
+*
+* Only fields the backend actually documents are read. A model id this line has
+* never heard of still produces an entry, because the listing is the authority
+* on what the account may call — but every capability it does not state falls
+* back to a conservative answer rather than to a guess.
+*/
+function parseListingEntry$1(value) {
+	const record = asRecord$10(value);
+	if (record === void 0) return [];
+	const id = asString$14(record.slug) ?? asString$14(record.id);
+	if (id === void 0) return [];
+	const contextWindow = asNumber$4(record.context_window) ?? asNumber$4(record.contextWindow);
+	const modalities = parseModalities(record.input_modalities);
+	const efforts = parseEfforts(record.supported_reasoning_levels);
+	const fallback = CODEX_MODEL_CATALOG.find((entry) => entry.id === id);
+	return [{
+		id,
+		name: asString$14(record.display_name) ?? asString$14(record.displayName) ?? fallback?.name ?? id,
+		contextWindow: contextWindow !== void 0 && contextWindow > 0 ? contextWindow : null,
+		inputModalities: modalities ?? (fallback ? [...fallback.inputModalities] : ["text"]),
+		...efforts !== null ? { reasoningEfforts: efforts } : {},
+		defaultReasoningEffort: asString$14(record.default_reasoning_level) ?? fallback?.defaultReasoningEffort ?? null
+	}];
+}
+function parseModalities(value) {
+	if (!Array.isArray(value)) return null;
+	const out = [];
+	for (const item of value) {
+		const name = asString$14(item);
+		if (name === "text" || name === "image") out.push(name);
+	}
+	return out.length > 0 ? out : null;
+}
+/**
+* Reasoning levels the listing states, in the order it stated them.
+*
+* The backend writes each level as `{ "effort": "high" }`; a bare string is
+* accepted too, since that is the other spelling seen in the wild.
+*/
+function parseEfforts(value) {
+	if (!Array.isArray(value)) return null;
+	const out = [];
+	for (const item of value) {
+		const effort = asString$14(item) ?? asString$14(asRecord$10(item)?.effort);
+		if (effort !== void 0 && !out.includes(effort)) out.push(effort);
+	}
+	return out.length > 0 ? out : null;
+}
+/**
+* Cache identity for one credential.
+*
+* The account id is the entitlement boundary: two accounts of the same user can
+* see different listings, and a pool rotates between them, so the key has to
+* follow the account rather than the person.
+*/
+function accountKeyFor$1(credentials) {
+	return credentials.accountId || "default";
+}
+function asRecord$10(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asString$14(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function asNumber$4(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+//#endregion
 //#region src/host/common/credential-read-cache.ts
 /**
 * Identity a file-backed credential store reports when nothing is stored.
@@ -2752,31 +3146,6 @@ function normalizeGenerateOptions(options) {
 	};
 }
 //#endregion
-//#region src/host/wire-auth.ts
-function codexHeaders(credentials, sessionId) {
-	const dshAgent = attributionHeaders()["user-agent"] ?? "dsh/unknown";
-	return {
-		authorization: `Bearer ${credentials.accessToken}`,
-		...credentials.accountId ? { "chatgpt-account-id": credentials.accountId } : {},
-		originator: CODEX_ORIGINATOR,
-		"user-agent": `dsh-chatgpt-subscription/${PLUGIN_VERSION} (${dshAgent})`,
-		...sessionId ? { "session-id": sessionId } : {}
-	};
-}
-function stableSessionId(value) {
-	const source = value === void 0 || value === "" ? randomUUID() : value;
-	return `dsh-${createHash("sha256").update(source).digest("hex").slice(0, 32)}`;
-}
-function retryAfterMs$1(headers) {
-	const raw = headers.get("retry-after");
-	if (raw === null) return void 0;
-	const seconds = Number(raw);
-	if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, 10 * 6e4);
-	const timestamp = Date.parse(raw);
-	if (!Number.isFinite(timestamp)) return void 0;
-	return Math.min(Math.max(0, timestamp - Date.now()), 10 * 6e4);
-}
-//#endregion
 //#region src/host/codex-images.ts
 const PNG_SIGNATURE = [
 	137,
@@ -2930,7 +3299,6 @@ function requestImage(fetchFn, credentials, prompt, turnId, signal) {
 		method: "POST",
 		headers: {
 			...codexHeaders(credentials),
-			originator: "pi",
 			accept: "application/json",
 			"content-type": "application/json",
 			"x-codex-image-turn-id": turnId
@@ -3030,7 +3398,6 @@ function sendSearch(fetchFn, credentials, query, model, id, signal) {
 		method: "POST",
 		headers: {
 			...codexHeaders(credentials),
-			originator: "pi",
 			accept: "application/json",
 			"content-type": "application/json"
 		},
@@ -3183,8 +3550,8 @@ function parseEnvProxy(env = process.env, options = {}) {
 	try {
 		const dshHome = env.DSH_HOME || path.join(os.homedir(), ".dsh");
 		const envFile = options.envFile ?? path.join(dshHome, ".env");
-		if (fs.existsSync(envFile)) {
-			const match = fs.readFileSync(envFile, "utf8").match(/^(?:export\s+)?(?:HTTPS_PROXY|https_proxy|HTTP_PROXY|http_proxy|ALL_PROXY|all_proxy)\s*=\s*["']?([^"'\r\n]+)["']?/m);
+		if (fs$1.existsSync(envFile)) {
+			const match = fs$1.readFileSync(envFile, "utf8").match(/^(?:export\s+)?(?:HTTPS_PROXY|https_proxy|HTTP_PROXY|http_proxy|ALL_PROXY|all_proxy)\s*=\s*["']?([^"'\r\n]+)["']?/m);
 			if (match && match[1]?.trim()) return normalizeProxyUrl(match[1].trim());
 		}
 	} catch {}
@@ -3805,7 +4172,7 @@ var FileCredentialStore$2 = class {
 	}
 	async removeLegacy() {
 		try {
-			await fsPromises.unlink(this.filePath);
+			await fs.unlink(this.filePath);
 		} catch (error) {
 			if (error.code !== "ENOENT") throw new Error("Antigravity legacy credential removal failed");
 		}
@@ -3824,11 +4191,11 @@ var FileCredentialStore$2 = class {
 			}
 			let legacy;
 			try {
-				const stats = await fsPromises.lstat(this.filePath);
+				const stats = await fs.lstat(this.filePath);
 				if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Invalid credential file");
 				if (process.getuid && stats.uid !== process.getuid()) throw new Error("Invalid credential owner");
-				if (process.platform !== "win32") await fsPromises.chmod(this.filePath, 384);
-				legacy = await fsPromises.readFile(this.filePath, "utf8");
+				if (process.platform !== "win32") await fs.chmod(this.filePath, 384);
+				legacy = await fs.readFile(this.filePath, "utf8");
 			} catch (error) {
 				if (error.code === "ENOENT") return null;
 				throw new Error("Antigravity legacy credential read failed");
@@ -3863,7 +4230,7 @@ var FileModelSettingsStore$2 = class {
 	}
 	async read() {
 		try {
-			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const content = await fs.readFile(this.filePath, "utf8");
 			const parsed = JSON.parse(content);
 			if (typeof parsed === "object" && parsed !== null) {
 				const record = parsed;
@@ -3889,10 +4256,10 @@ var FileModelSettingsStore$2 = class {
 		};
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const tmp = `${this.filePath}.tmp.${Date.now()}`;
-		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
-		await fsPromises.rename(tmp, this.filePath);
+		await fs.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fs.rename(tmp, this.filePath);
 	}
 	async updateSettings(patch) {
 		const current = await this.read();
@@ -4018,7 +4385,7 @@ var FilePreferencesStore = class {
 	async readDocument() {
 		let parsed;
 		try {
-			parsed = JSON.parse(await fsPromises.readFile(this.filePath, "utf8"));
+			parsed = JSON.parse(await fs.readFile(this.filePath, "utf8"));
 		} catch {
 			return;
 		}
@@ -4039,17 +4406,17 @@ var FilePreferencesStore = class {
 		for (const listener of [...this.listeners]) listener(next, prev);
 	}
 	async write(value) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		writeSequence += 1;
 		const tmp = `${this.filePath}.tmp.${process.pid}.${writeSequence}`;
 		try {
-			await fsPromises.writeFile(tmp, JSON.stringify(value, null, 2), {
+			await fs.writeFile(tmp, JSON.stringify(value, null, 2), {
 				encoding: "utf8",
 				mode: 384
 			});
-			await fsPromises.rename(tmp, this.filePath);
+			await fs.rename(tmp, this.filePath);
 		} finally {
-			await fsPromises.unlink(tmp).catch(() => void 0);
+			await fs.unlink(tmp).catch(() => void 0);
 		}
 	}
 };
@@ -4114,7 +4481,7 @@ const LEGACY_DOCUMENTS = ["settings.yaml", "settings.yaml.imported"];
 */
 async function readLegacyPreferences(homeDir = dshHomeDir$2()) {
 	for (const name of LEGACY_DOCUMENTS) {
-		const document = await fsPromises.readFile(path.join(homeDir, name), "utf8").catch(() => void 0);
+		const document = await fs.readFile(path.join(homeDir, name), "utf8").catch(() => void 0);
 		if (document === void 0) continue;
 		const section = sectionOf(document, PREFERENCES_NAMESPACE);
 		if (section !== void 0 && Object.keys(section).length > 0) return section;
@@ -4422,7 +4789,7 @@ function normalizeReplayCallIds(items, normalizeCallId) {
 		call_id: normalizeCallId(item.call_id)
 	} : item);
 }
-async function buildResponsesPayload(options, attachments, localRawImages = {}, outputVerbosity = null, fastMode = false, reasoningSummary = null) {
+async function buildResponsesPayload(options, attachments, localRawImages = {}, outputVerbosity = null, fastMode = false, reasoningSummary = null, promptCacheKey) {
 	const sandboxRetryTools = recentSandboxRetryToolNames(options.messages);
 	const resolveLocalRawImages = supportsImageInput(options);
 	const normalizeCallId = createCallIdNormalizer();
@@ -4490,7 +4857,8 @@ async function buildResponsesPayload(options, attachments, localRawImages = {},
 		input,
 		stream: true,
 		store: false,
-		include: ["reasoning.encrypted_content"]
+		include: ["reasoning.encrypted_content"],
+		...promptCacheKey ? { prompt_cache_key: promptCacheKey } : {}
 	};
 	const instructions = [...instructionParts, localRawImageInstruction(localImageStats)].filter((value) => Boolean(value));
 	if (instructions.length > 0) payload.instructions = instructions.join("\n\n");
@@ -4506,6 +4874,8 @@ async function buildResponsesPayload(options, attachments, localRawImages = {},
 	}
 	if (outputVerbosity !== null) payload.text = { verbosity: outputVerbosity };
 	if (fastMode) payload.service_tier = "priority";
+	const modelMaxTokens = codexModelMaxTokens(options.model);
+	payload.max_output_tokens = options.maxTokens === void 0 ? modelMaxTokens : Math.min(options.maxTokens, modelMaxTokens);
 	if (options.reasoningEffort !== void 0) {
 		const effort = codexWireReasoningEffort(options.model, options.reasoningEffort);
 		payload.reasoning = codexModelSupportsReasoningSummary(options.model) ? {
@@ -4823,6 +5193,8 @@ const MAX_VISIBLE_REASONING_CHARS = 12e3;
 const DEFAULT_POOL_COOLDOWN_MS = 15 * 6e4;
 const REASONING_DELTA_FLUSH_CHARS = 768;
 const REASONING_TRUNCATED_NOTICE = "\n\n[Reasoning summary truncated to keep the DSH web UI responsive.]";
+/** Cap on conversations whose turn state is remembered at once. */
+const MAX_TRACKED_TURN_STATES = 200;
 var ResponsesClient = class {
 	oauth;
 	attachments;
@@ -4832,6 +5204,16 @@ var ResponsesClient = class {
 	fastMode;
 	reasoningSummary;
 	accountPool;
+	/**
+	* Opaque backend turn state, keyed by conversation session id.
+	*
+	* The Codex backend hands `x-codex-turn-state` back on each response and
+	* expects it on the next request of the same conversation, which lets it
+	* resume the turn instead of re-ingesting the whole history. The value is
+	* short-lived and account-scoped, so it is stored per session and simply
+	* dropped when the backend stops sending it — never a correctness input.
+	*/
+	turnStates = /* @__PURE__ */ new Map();
 	constructor(oauth, attachments, options = {}) {
 		this.oauth = oauth;
 		this.attachments = attachments;
@@ -4852,7 +5234,7 @@ var ResponsesClient = class {
 		let attemptOptions = options;
 		let response;
 		while (true) {
-			const payload = await buildResponsesPayload(attemptOptions, this.attachments, this.localRawImages, this.outputVerbosity(), this.fastMode(), this.reasoningSummary());
+			const payload = await buildResponsesPayload(attemptOptions, this.attachments, this.localRawImages, this.outputVerbosity(), this.fastMode(), this.reasoningSummary(), promptCacheKeyFor(sessionId));
 			try {
 				response = await this.send(payload, sessionId, options.signal);
 				break;
@@ -4887,9 +5269,36 @@ var ResponsesClient = class {
 			response = await this.request(payload, credentials, sessionId, signal);
 		}
 		if (!response.ok) throw await responseError(response);
+		this.rememberTurnState(response, sessionId);
 		return response;
 	}
 	/**
+	* Record the turn state a response carried, for the next turn of this session.
+	*
+	* A response that carries none clears any stored value: a backend that stops
+	* sending the header has stopped honouring it, and replaying a stale value
+	* would be guessing. An empty header is treated the same as absent.
+	*/
+	rememberTurnState(response, sessionId) {
+		const next = response.headers.get(CODEX_TURN_STATE_HEADER)?.trim();
+		if (next === void 0 || next === "") this.turnStates.delete(sessionId);
+		else this.storeTurnState(sessionId, next);
+	}
+	/**
+	* Bounded store: a long-lived host serves many sessions, and nothing here ever
+	* signals that a session ended, so the map is capped and evicts the oldest
+	* entry. The value is an optimization, so a miss only costs a full resend.
+	*/
+	storeTurnState(sessionId, value) {
+		this.turnStates.delete(sessionId);
+		this.turnStates.set(sessionId, value);
+		while (this.turnStates.size > MAX_TRACKED_TURN_STATES) {
+			const oldest = this.turnStates.keys().next();
+			if (oldest.done === true) break;
+			this.turnStates.delete(oldest.value);
+		}
+	}
+	/**
 	* Send one payload with account rotation.
 	*
 	* The pool picks the account — skipping cooling, quota-exhausted and failed
@@ -4931,6 +5340,7 @@ var ResponsesClient = class {
 				});
 			}
 			if (!response.ok) throw await responseError(response);
+			this.rememberTurnState(response, sessionId);
 			return response;
 		}
 	}
@@ -4939,7 +5349,7 @@ var ResponsesClient = class {
 			return await this.fetchFn(CODEX_RESPONSES_URL, {
 				method: "POST",
 				headers: {
-					...codexHeaders(credentials, sessionId),
+					...codexHeaders(credentials, sessionId, { turnState: this.turnStates.get(sessionId) }),
 					"content-type": "application/json",
 					accept: "text/event-stream"
 				},
@@ -4952,6 +5362,17 @@ var ResponsesClient = class {
 		}
 	}
 };
+/**
+* Prompt cache key for one conversation.
+*
+* The backend keys its prefix cache on this string, so it must be stable for a
+* conversation and distinct between conversations — otherwise one session would
+* be served another session's cached prefix. The session id is already a hashed
+* opaque string, so it is reused directly rather than hashed again.
+*/
+function promptCacheKeyFor(sessionId) {
+	return sessionId;
+}
 async function* parseResponsesStream(response, signal, hiddenSandboxControls = /* @__PURE__ */ new Set()) {
 	if (response.body === null) throw new LlmError("Codex returned no response stream.", "PROVIDER_ERROR");
 	const reader = response.body.getReader();
@@ -5943,7 +6364,7 @@ function registerRoutes(ctx, oauth, usage, preferences, proxyManager, searchSwit
 					"Content-Type": "application/javascript; charset=utf-8",
 					"Cache-Control": "public, max-age=86400"
 				});
-				fs.createReadStream(mermaidPath).pipe(response);
+				fs$1.createReadStream(mermaidPath).pipe(response);
 			} catch {
 				response.writeHead(404, { "Content-Type": "text/plain" });
 				response.end("Not found");
@@ -9509,7 +9930,7 @@ var FileCredentialStore$1 = class {
 	}
 	async removeLegacy() {
 		try {
-			await fsPromises.unlink(this.filePath);
+			await fs.unlink(this.filePath);
 		} catch (error) {
 			if (error.code !== "ENOENT") throw new Error("Command Code legacy credential removal failed");
 		}
@@ -9528,11 +9949,11 @@ var FileCredentialStore$1 = class {
 			}
 			let legacy;
 			try {
-				const stats = await fsPromises.lstat(this.filePath);
+				const stats = await fs.lstat(this.filePath);
 				if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Invalid credential file");
 				if (process.getuid && stats.uid !== process.getuid()) throw new Error("Invalid credential owner");
-				if (process.platform !== "win32") await fsPromises.chmod(this.filePath, 384);
-				legacy = await fsPromises.readFile(this.filePath, "utf8");
+				if (process.platform !== "win32") await fs.chmod(this.filePath, 384);
+				legacy = await fs.readFile(this.filePath, "utf8");
 			} catch (error) {
 				if (error.code === "ENOENT") return null;
 				throw new Error("Command Code legacy credential read failed");
@@ -9568,7 +9989,7 @@ var FileModelSettingsStore$1 = class {
 	}
 	async read() {
 		try {
-			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const content = await fs.readFile(this.filePath, "utf8");
 			const parsed = JSON.parse(content);
 			if (typeof parsed === "object" && parsed !== null) {
 				const record = parsed;
@@ -9594,10 +10015,10 @@ var FileModelSettingsStore$1 = class {
 		};
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const tmp = `${this.filePath}.tmp.${Date.now()}`;
-		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
-		await fsPromises.rename(tmp, this.filePath);
+		await fs.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fs.rename(tmp, this.filePath);
 	}
 	async updateSettings(patch) {
 		const current = await this.read();
@@ -9696,121 +10117,6 @@ function commandCodePlanLabel(planId) {
 	return resolveCommandCodePlan(planId)?.name ?? planId;
 }
 //#endregion
-//#region src/host/common/catalog-snapshot.ts
-/**
-* Persistent snapshot for one provider's live model catalog.
-*
-* The in-memory catalog caches keep a process alive between requests, but they
-* start cold: on the first call after a restart (or a plugin reinstall) the
-* picker and the settings page both wait on the upstream listing before they
-* can render anything, and an unreachable endpoint turns that wait into the
-* full discovery timeout — "the model server is unavailable" on a fresh
-* install. The catalog is not fast-moving data, so the last successful listing
-* is persisted to `<DSH_HOME>/storages/` and rehydrated into the in-memory
-* cache on first use. A snapshot the caller can read is therefore available
-* from the very first call, with no network in the path.
-*
-* Writes are best-effort: persistence is an optimization, never a capability.
-* A read-only home or a locked file must not fail the fetch that produced the
-* snapshot.
-*/
-/** File name of the persisted snapshot for one catalog. */
-function catalogSnapshotPath(name) {
-	return path.join(dshHomeDir(), "storages", `${name}-catalog.json`);
-}
-/**
-* Snapshot name for one catalog *and* one credential scope.
-*
-* A persisted snapshot answers before any credential is read — that is the whole
-* point of it — so the file itself has to carry the scope it was fetched under.
-* Otherwise the first call after a restart, for any account, is answered by
-* whatever listing some other scope happened to persist last: a Kimi listing
-* fetched for the mainland-cn endpoint would answer a global caller with models
-* and context windows that region does not serve, and a Command Code listing
-* fetched against one API environment would answer the other.
-*
-* The scope is part of the file name rather than of the payload because a caller
-* that cannot name the account — the harness resolves this catalog with no token
-* at all — still has to find the snapshot its own scope owns.
-*
-* Everything outside `[a-z0-9]` is folded to `_`, so no scope can escape the
-* `storages` directory.
-*/
-function catalogSnapshotName(base, scope) {
-	const normalized = scope.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-	return normalized === "" ? base : `${base}-${normalized}`;
-}
-/**
-* Read the persisted snapshot for one catalog.
-*
-* Shape errors and unreadable files both return `undefined` — the caller keeps
-* its in-memory state, and the next successful fetch overwrites the file.
-*/
-async function readCatalogSnapshot(name, parseModels) {
-	try {
-		const content = await fsPromises.readFile(catalogSnapshotPath(name), "utf8");
-		const parsed = JSON.parse(content);
-		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
-		const record = parsed;
-		const fetchedAt = record.fetchedAt;
-		if (typeof fetchedAt !== "number" || !Number.isFinite(fetchedAt) || fetchedAt <= 0) return void 0;
-		const models = parseModels(record.models);
-		if (models === void 0 || models.length === 0) return void 0;
-		return {
-			fetchedAt,
-			models
-		};
-	} catch {
-		return;
-	}
-}
-/**
-* Snapshot writes still in flight.
-*
-* Callers fire-and-forget these writes, so nothing in production ever awaits
-* one. A test that deletes its private `storages` directory between cases
-* cannot know when that is safe, and a write that lands after the delete
-* recreates the file the next case asserts is absent — which is how a stale
-* listing leaked into a later test and failed it on CI. Registering each write
-* gives {@link flushCatalogSnapshots} a deterministic point to wait on.
-*/
-const pendingSnapshotWrites = /* @__PURE__ */ new Set();
-/** Persist one snapshot; a failure is logged nowhere and never thrown. */
-function writeCatalogSnapshot(name, models, fetchedAt) {
-	const write = (async () => {
-		try {
-			const filePath = catalogSnapshotPath(name);
-			await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
-			const tmp = `${filePath}.tmp.${Date.now()}`;
-			await fsPromises.writeFile(tmp, JSON.stringify({
-				fetchedAt,
-				models
-			}, null, 2), "utf8");
-			await fsPromises.rename(tmp, filePath);
-		} catch {}
-	})();
-	pendingSnapshotWrites.add(write);
-	write.finally(() => {
-		pendingSnapshotWrites.delete(write);
-	});
-	return write;
-}
-/**
-* Warm an in-memory cache from the persisted snapshot when it is fresher than
-* what the cache currently holds. Called lazily on the first cache miss of a
-* process, so a restart serves the previous listing without waiting on the
-* network.
-*
-* @returns the snapshot's `fetchedAt`, or `0` when no usable snapshot exists —
-*   the caller then fetches as before.
-*/
-async function rehydrateCatalogCache(name, parseModels, accept, currentFetchedAt) {
-	const snapshot = await readCatalogSnapshot(name, parseModels);
-	if (snapshot === void 0 || snapshot.fetchedAt <= currentFetchedAt) return 0;
-	accept(snapshot.fetchedAt, snapshot.models);
-	return snapshot.fetchedAt;
-}
-//#endregion
 //#region src/host/command-code/client.ts
 const CLI_VERSION = "1.0.0";
 /**
@@ -13080,6 +13386,10 @@ function maxOutputTokensFor$3(modelId, contextWindow) {
 	const capped = (contextWindow ?? kimiCodeModelDef(modelId)?.contextWindow ?? 262144) - CONTEXT_HEADROOM_TOKENS$1;
 	return Math.max(declared, capped);
 }
+/** Whether a stored preference names a tier this line can send. */
+function isKimiCacheTtl(value) {
+	return value === "5m" || value === "1h";
+}
 /**
 * Reduce the requested output cap so prompt + output fit the window.
 *
@@ -13129,7 +13439,8 @@ function registerKimiCodePreferenceStore(settings, fallbackStore = new FileModel
 			enabledModelIds: [...DEFAULT_ENABLED_MODEL_IDS$3],
 			catalogModels: [],
 			contextWindowOverrides: {},
-			defaultReasoningEffort: null
+			defaultReasoningEffort: null,
+			cacheTtl: null
 		};
 		fallbackStore.read().then((stored) => {
 			snapshot = stored;
@@ -13146,7 +13457,12 @@ function registerKimiCodePreferenceStore(settings, fallbackStore = new FileModel
 		enabled: z.boolean().default(true),
 		enabledModelIds: z.array(z.string()).default([...DEFAULT_ENABLED_MODEL_IDS$3]),
 		contextWindowOverrides: z.dict(z.number()).default({}),
-		defaultReasoningEffort: z.union([...KIMI_CODE_REASONING_EFFORTS.map((effort) => z.const(effort)), z.const(null)]).default(null)
+		defaultReasoningEffort: z.union([...KIMI_CODE_REASONING_EFFORTS.map((effort) => z.const(effort)), z.const(null)]).default(null),
+		cacheTtl: z.union([
+			z.const("5m"),
+			z.const("1h"),
+			z.const(null)
+		]).default(null)
 	}));
 	return {
 		status: () => {
@@ -13156,7 +13472,8 @@ function registerKimiCodePreferenceStore(settings, fallbackStore = new FileModel
 				enabledModelIds: value.enabledModelIds,
 				catalogModels: [],
 				contextWindowOverrides: value.contextWindowOverrides,
-				defaultReasoningEffort: value.defaultReasoningEffort
+				defaultReasoningEffort: value.defaultReasoningEffort,
+				cacheTtl: isKimiCacheTtl(value.cacheTtl) ? value.cacheTtl : null
 			};
 		},
 		update: async (patch) => {
@@ -13165,7 +13482,8 @@ function registerKimiCodePreferenceStore(settings, fallbackStore = new FileModel
 				enabled: patch.enabled !== void 0 ? patch.enabled : current.enabled !== false,
 				enabledModelIds: patch.enabledModelIds ?? current.enabledModelIds,
 				contextWindowOverrides: patch.contextWindowOverrides ? mergeContextWindowOverrides(current.contextWindowOverrides, patch.contextWindowOverrides) : current.contextWindowOverrides,
-				defaultReasoningEffort: patch.defaultReasoningEffort !== void 0 ? patch.defaultReasoningEffort : current.defaultReasoningEffort
+				defaultReasoningEffort: patch.defaultReasoningEffort !== void 0 ? patch.defaultReasoningEffort : current.defaultReasoningEffort,
+				cacheTtl: patch.cacheTtl !== void 0 ? patch.cacheTtl : current.cacheTtl
 			};
 			await scope.update(normalized);
 			fallbackStore.updateSettings(patch).catch(() => void 0);
@@ -13287,7 +13605,7 @@ var FileCredentialStore$3 = class {
 	}
 	async removeLegacy() {
 		try {
-			await fsPromises.unlink(this.filePath);
+			await fs.unlink(this.filePath);
 		} catch (error) {
 			if (error.code !== "ENOENT") throw new Error("Kimi Code legacy credential removal failed");
 		}
@@ -13306,11 +13624,11 @@ var FileCredentialStore$3 = class {
 			}
 			let legacy;
 			try {
-				const stats = await fsPromises.lstat(this.filePath);
+				const stats = await fs.lstat(this.filePath);
 				if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Invalid credential file");
 				if (process.getuid && stats.uid !== process.getuid()) throw new Error("Invalid credential owner");
-				if (process.platform !== "win32") await fsPromises.chmod(this.filePath, 384);
-				legacy = await fsPromises.readFile(this.filePath, "utf8");
+				if (process.platform !== "win32") await fs.chmod(this.filePath, 384);
+				legacy = await fs.readFile(this.filePath, "utf8");
 			} catch (error) {
 				if (error.code === "ENOENT") return null;
 				throw new Error("Kimi Code legacy credential read failed");
@@ -13346,7 +13664,7 @@ var FileModelSettingsStore$3 = class {
 	}
 	async read() {
 		try {
-			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const content = await fs.readFile(this.filePath, "utf8");
 			const parsed = JSON.parse(content);
 			if (typeof parsed === "object" && parsed !== null) {
 				const record = parsed;
@@ -13359,7 +13677,8 @@ var FileModelSettingsStore$3 = class {
 					enabledModelIds,
 					catalogModels,
 					contextWindowOverrides,
-					defaultReasoningEffort
+					defaultReasoningEffort,
+					cacheTtl: isKimiCacheTtl(record.cacheTtl) ? record.cacheTtl : null
 				};
 			}
 		} catch {}
@@ -13368,14 +13687,15 @@ var FileModelSettingsStore$3 = class {
 			enabledModelIds: [...DEFAULT_ENABLED_MODEL_IDS$3],
 			catalogModels: [],
 			contextWindowOverrides: {},
-			defaultReasoningEffort: null
+			defaultReasoningEffort: null,
+			cacheTtl: null
 		};
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const tmp = `${this.filePath}.tmp.${Date.now()}`;
-		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
-		await fsPromises.rename(tmp, this.filePath);
+		await fs.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fs.rename(tmp, this.filePath);
 	}
 	async updateSettings(patch) {
 		const current = await this.read();
@@ -13384,7 +13704,8 @@ var FileModelSettingsStore$3 = class {
 			...patch.enabled !== void 0 ? { enabled: patch.enabled } : {},
 			...patch.enabledModelIds !== void 0 ? { enabledModelIds: patch.enabledModelIds } : {},
 			...patch.contextWindowOverrides !== void 0 ? { contextWindowOverrides: mergeContextWindowOverrides(current.contextWindowOverrides, patch.contextWindowOverrides) } : {},
-			...patch.defaultReasoningEffort !== void 0 ? { defaultReasoningEffort: patch.defaultReasoningEffort } : {}
+			...patch.defaultReasoningEffort !== void 0 ? { defaultReasoningEffort: patch.defaultReasoningEffort } : {},
+			...patch.cacheTtl !== void 0 && patch.cacheTtl !== null ? { cacheTtl: isKimiCacheTtl(patch.cacheTtl) ? patch.cacheTtl : current.cacheTtl } : patch.cacheTtl === null ? { cacheTtl: null } : {}
 		};
 		await this.write(next);
 		return next;
@@ -13414,7 +13735,7 @@ async function resolveRegion(env = process.env) {
 		return pinned.includes(".ai") ? "global" : "mainland-cn";
 	}
 	try {
-		const marker = (await fsPromises.readFile(regionMarkerPath(), "utf8")).trim();
+		const marker = (await fs.readFile(regionMarkerPath(), "utf8")).trim();
 		if (isRegion$4(marker)) return marker;
 	} catch {}
 	return "mainland-cn";
@@ -13423,8 +13744,8 @@ async function resolveRegion(env = process.env) {
 async function persistRegion(region) {
 	try {
 		const file = regionMarkerPath();
-		await fsPromises.mkdir(path.dirname(file), { recursive: true });
-		await fsPromises.writeFile(file, region, "utf8");
+		await fs.mkdir(path.dirname(file), { recursive: true });
+		await fs.writeFile(file, region, "utf8");
 	} catch {}
 }
 //#endregion
@@ -13526,13 +13847,13 @@ function deviceModel() {
 async function getDeviceId() {
 	const file = deviceIdPath();
 	try {
-		const existing = (await fsPromises.readFile(file, "utf8")).trim();
+		const existing = (await fs.readFile(file, "utf8")).trim();
 		if (existing !== "") return existing;
 	} catch {}
 	const created = randomUUID();
 	try {
-		await fsPromises.mkdir(path.dirname(file), { recursive: true });
-		await fsPromises.writeFile(file, created, {
+		await fs.mkdir(path.dirname(file), { recursive: true });
+		await fs.writeFile(file, created, {
 			encoding: "utf8",
 			mode: 384
 		});
@@ -15348,6 +15669,39 @@ function imageBlockToInline$2(block, images) {
 		data: resolved.data
 	} : void 0;
 }
+/**
+* Media a single request build may carry.
+*
+* Passed as one object so adding a media kind never grows a positional
+* signature the existing callers already bind.
+*/
+/**
+* The cache field for the Anthropic-compatible wire.
+*
+* TOP LEVEL, not per block: the service documents that a `cache_control` inside
+* a message is ignored, and omitting the field means "read a 5m entry but do
+* not write one" — which is why this is only attached when the caller asked
+* for a tier.
+*/
+function kimiAnthropicCacheControl(ttl) {
+	return { cache_control: {
+		type: "ephemeral",
+		ttl
+	} };
+}
+/**
+* The cache field for the OpenAI-compatible wire.
+*
+* `mode: 'implicit'` is the only mode the service supports — it identifies the
+* prefix itself, so this is not a request to break the cache but a request to
+* write it at a chosen TTL.
+*/
+function kimiOpenAICacheOptions(ttl) {
+	return { prompt_cache_options: {
+		mode: "implicit",
+		ttl
+	} };
+}
 function textOf$3(content) {
 	if (typeof content === "string") return sanitizeText$3(content);
 	if (!Array.isArray(content)) return "";
@@ -15883,6 +16237,7 @@ function buildOpenAIRequest(options, images = NO_RESOLVED_IMAGES$3, preserveThin
 		stream: true,
 		stream_options: { include_usage: true },
 		max_completion_tokens: maxTokens,
+		...media.cacheTtl === null || media.cacheTtl === void 0 ? {} : kimiOpenAICacheOptions(media.cacheTtl),
 		...stopSequences(options.stop).length > 0 ? { stop: stopSequences(options.stop) } : {},
 		...options.tools && options.tools.length > 0 ? {
 			tools: options.tools.map((tool) => ({
@@ -16016,7 +16371,8 @@ function mergeAnthropicMessages$1(entries) {
 	return merged;
 }
 /** Build one `/v1/messages` body. */
-function buildAnthropicRequest(options, images = NO_RESOLVED_IMAGES$3, _media = {}) {
+function buildAnthropicRequest(options, images = NO_RESOLVED_IMAGES$3, media = {}) {
+	const cacheTtl = media.cacheTtl ?? null;
 	const carriers = options.messages.filter((message) => message.role === "system" && messageToolsOf(message) !== void 0);
 	const unsentDeclarations = carriers.reduce((total, message) => total + (messageToolsOf(message)?.length ?? 0), 0);
 	const carrierText = carriers.map((message) => textOf$3(message.content)).filter((text) => text !== "");
@@ -16047,6 +16403,7 @@ function buildAnthropicRequest(options, images = NO_RESOLVED_IMAGES$3, _media =
 		model: options.model,
 		max_tokens: maxTokens,
 		messages: mergeAnthropicMessages$1(entries),
+		...cacheTtl === null || cacheTtl === void 0 ? {} : kimiAnthropicCacheControl(cacheTtl),
 		...system === void 0 ? {} : { system },
 		...options.temperature === void 0 || budget !== void 0 ? {} : { temperature: options.temperature },
 		...options.stop && options.stop.length > 0 ? { stop_sequences: options.stop } : {},
@@ -16849,12 +17206,13 @@ var KimiCodeAdapter = class extends LlmAdapter {
 		const entry = catalog.find((model) => model.id === options.model);
 		const requestOptions = offloadOldestRequestVideos(offloadOldestRequestImages$2(normalizeGenerateOptions(options)));
 		const [images, videos] = await Promise.all([resolveRequestImages$2(requestOptions, this.options.attachments, signal), resolveRequestVideos(requestOptions, this.options.videos, signal)]);
+		const settings = await this.settings();
 		const media = {
 			videos,
 			videoAccepted: inputModalitiesForEntry(options.model, catalog).includes("video"),
-			messageTools: dynamicToolsForEntry(options.model, catalog)
+			messageTools: dynamicToolsForEntry(options.model, catalog),
+			cacheTtl: settings.cacheTtl
 		};
-		const settings = await this.settings();
 		const contextWindow = this.contextWindowFor(options.model, entry, settings.contextWindowOverrides);
 		const requestedMax = options.maxTokens ?? maxOutputTokensFor$3(options.model, contextWindow);
 		const body = assertRequestBodyFits$1(buildRequest({
@@ -17233,6 +17591,7 @@ async function getKimiCodeWebStatus(store, modelSettings, preferences, options =
 		models,
 		contextWindowOverrides: settings.contextWindowOverrides,
 		defaultReasoningEffort: settings.defaultReasoningEffort,
+		cacheTtl: settings.cacheTtl,
 		loginRegion: region,
 		serving: readOption$3(options.serving, true),
 		conflict: readOption$3(options.conflict, null)
@@ -17458,6 +17817,10 @@ function registerKimiCodeRoutes(ctx, store, modelSettings, preferences, options
 						const effort = body.defaultReasoningEffort;
 						if (effort === null || isKimiCodeEffort(effort)) patch.defaultReasoningEffort = effort;
 					}
+					if (body.cacheTtl !== void 0) {
+						const ttl = body.cacheTtl;
+						if (ttl === null || isKimiCacheTtl(ttl)) patch.cacheTtl = ttl;
+					}
 					if (preferences) await preferences.update(patch);
 					else await modelSettings.updateSettings(patch);
 					if (patch.enabledModelIds !== void 0 || patch.enabled !== void 0) ctx.emit?.("llm/adapters-updated");
@@ -17667,15 +18030,15 @@ async function saveVideo(input) {
 	const digest = createHash("sha256").update(input.data).digest("hex");
 	const attachmentId = `sha256:${digest}`;
 	const dir = videoStoreDir();
-	await fsPromises.mkdir(dir, {
+	await fs.mkdir(dir, {
 		recursive: true,
 		mode: 448
 	});
 	const target = path.join(dir, digest + extensionFor(input.declaredType));
-	if (!await fsPromises.stat(target).then(() => true).catch(() => false)) {
+	if (!await fs.stat(target).then(() => true).catch(() => false)) {
 		const tmp = `${target}.tmp.${process.pid}.${Date.now()}`;
-		await fsPromises.writeFile(tmp, input.data);
-		await fsPromises.rename(tmp, target);
+		await fs.writeFile(tmp, input.data);
+		await fs.rename(tmp, target);
 	}
 	pruneVideoStore().catch(() => void 0);
 	return {
@@ -17705,14 +18068,14 @@ async function pruneVideoStore(budgetBytes = VIDEO_STORE_BUDGET_BYTES) {
 	const dir = videoStoreDir();
 	let entries;
 	try {
-		const names = await fsPromises.readdir(dir);
+		const names = await fs.readdir(dir);
 		entries = [];
 		for (const name of names) {
 			if (name.includes(".tmp.")) {
-				await fsPromises.rm(path.join(dir, name), { force: true }).catch(() => void 0);
+				await fs.rm(path.join(dir, name), { force: true }).catch(() => void 0);
 				continue;
 			}
-			const stats = await fsPromises.stat(path.join(dir, name)).catch(() => void 0);
+			const stats = await fs.stat(path.join(dir, name)).catch(() => void 0);
 			if (stats === void 0 || !stats.isFile()) continue;
 			entries.push({
 				path: path.join(dir, name),
@@ -17729,7 +18092,7 @@ async function pruneVideoStore(budgetBytes = VIDEO_STORE_BUDGET_BYTES) {
 	let removed = 0;
 	for (const entry of entries) {
 		if (total <= budgetBytes) break;
-		await fsPromises.rm(entry.path, { force: true }).catch(() => void 0);
+		await fs.rm(entry.path, { force: true }).catch(() => void 0);
 		total -= entry.size;
 		removed += 1;
 	}
@@ -17753,7 +18116,7 @@ async function readVideoBytes(ref) {
 	if (stored === void 0) throw new VideoIngestError("video reference is not one this store issued", "VIDEO_REFERENCE_INVALID");
 	let data;
 	try {
-		data = await fsPromises.readFile(stored);
+		data = await fs.readFile(stored);
 	} catch {
 		throw new VideoIngestError("stored video is missing; attach it again", "VIDEO_MISSING");
 	}
@@ -17814,14 +18177,14 @@ function humanBytes(bytes) {
 /** Read one local file, refusing anything that is not a regular file. */
 async function readLocalFile(input) {
 	if (!path.isAbsolute(input)) throw new HarnessError(`video path must be absolute: ${input}`, "KIMI_VIDEO_PATH_NOT_ABSOLUTE");
-	const stats = await fsPromises.stat(input).catch(() => void 0);
+	const stats = await fs.stat(input).catch(() => void 0);
 	if (stats === void 0) throw new HarnessError(`video file not found: ${input}`, "KIMI_VIDEO_NOT_FOUND");
 	if (!stats.isFile()) throw new HarnessError(`video path is not a regular file: ${input}`, "KIMI_VIDEO_NOT_A_FILE");
 	if (stats.size > 31457280) throw new HarnessError(`video is ${humanBytes(stats.size)}, above the ${humanBytes(MAX_VIDEO_FILE_BYTES)} limit this route sends`, "KIMI_VIDEO_TOO_LARGE");
 	const type = mediaTypeForPath(input);
 	if (type === void 0) throw new HarnessError(`unsupported video extension "${path.extname(input)}"; supported: .mp4 .m4v .webm .mov .avi .mpeg .mpg .flv .wmv .3gp`, "KIMI_VIDEO_TYPE_UNSUPPORTED");
 	return {
-		data: await fsPromises.readFile(input),
+		data: await fs.readFile(input),
 		name: path.basename(input),
 		type
 	};
@@ -19302,16 +19665,16 @@ function credentialNeedsRefresh(credentials, now = Date.now()) {
 * leaves the destination untouched.
 */
 async function writeFileAtomic(filePath, contents) {
-	await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
 	const temporary = filePath + ".dsh-tmp-" + process.pid + "-" + Date.now();
 	try {
-		await fsPromises.writeFile(temporary, contents, {
+		await fs.writeFile(temporary, contents, {
 			encoding: "utf8",
 			mode: 384
 		});
-		await fsPromises.rename(temporary, filePath);
+		await fs.rename(temporary, filePath);
 	} catch (error) {
-		await fsPromises.rm(temporary, { force: true }).catch(() => void 0);
+		await fs.rm(temporary, { force: true }).catch(() => void 0);
 		throw new Error("MiniMax Code credential write failed; the previous file was left untouched (" + (error instanceof Error ? error.message : String(error)) + ")");
 	}
 }
@@ -19521,7 +19884,7 @@ async function readNativeDocument(region) {
 	const filePath = authJsonPath(region);
 	let raw;
 	try {
-		raw = await fsPromises.readFile(filePath, "utf8");
+		raw = await fs.readFile(filePath, "utf8");
 	} catch {
 		return null;
 	}
@@ -19558,7 +19921,7 @@ async function syncAuthState(region, options) {
 	const filePath = authStateJsonPath(region);
 	let parsed;
 	try {
-		parsed = JSON.parse(await fsPromises.readFile(filePath, "utf8"));
+		parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
 	} catch {
 		return;
 	}
@@ -19606,7 +19969,7 @@ var MinimaxCodeCredentialStore = class {
 	async readPluginFile() {
 		let raw;
 		try {
-			raw = await fsPromises.readFile(pluginCredentialPath(), "utf8");
+			raw = await fs.readFile(pluginCredentialPath(), "utf8");
 		} catch {
 			return null;
 		}
@@ -19748,7 +20111,7 @@ var MinimaxCodeCredentialStore = class {
 	*/
 	delete() {
 		return serialize(pluginCredentialPath(), async () => {
-			await fsPromises.rm(pluginCredentialPath(), { force: true });
+			await fs.rm(pluginCredentialPath(), { force: true });
 			recentRead = null;
 		});
 	}
@@ -19847,17 +20210,17 @@ var MinimaxCodeModelSettingsStore = class {
 	}
 	async read() {
 		try {
-			return parseMinimaxCodeModelSettings(JSON.parse(await fsPromises.readFile(this.filePath, "utf8")));
+			return parseMinimaxCodeModelSettings(JSON.parse(await fs.readFile(this.filePath, "utf8")));
 		} catch {
 			return defaultMinimaxCodeSettings();
 		}
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const temporary = this.filePath + ".tmp." + Date.now();
-		await fsPromises.writeFile(temporary, JSON.stringify(settings, null, 2) + "\n", "utf8");
-		await fsPromises.rename(temporary, this.filePath);
-		if (!isDeepStrictEqual(parseMinimaxCodeModelSettings(JSON.parse(await fsPromises.readFile(this.filePath, "utf8"))), settings)) throw new Error("MiniMax Code model settings write failed; the stored selection does not match what was written");
+		await fs.writeFile(temporary, JSON.stringify(settings, null, 2) + "\n", "utf8");
+		await fs.rename(temporary, this.filePath);
+		if (!isDeepStrictEqual(parseMinimaxCodeModelSettings(JSON.parse(await fs.readFile(this.filePath, "utf8"))), settings)) throw new Error("MiniMax Code model settings write failed; the stored selection does not match what was written");
 	}
 	/**
 	* Read-modify-write under the same per-path lock the credential writes use.
@@ -23572,7 +23935,7 @@ function isCanonicalFile(name) {
 async function scanCredentials(dir = codeBuddyAuthDir()) {
 	let names;
 	try {
-		names = await fsPromises.readdir(dir);
+		names = await fs.readdir(dir);
 	} catch (error) {
 		if (error.code === "ENOENT") return [];
 		throw new Error(`WorkBuddy credential directory could not be read: ${dir}`);
@@ -23582,9 +23945,9 @@ async function scanCredentials(dir = codeBuddyAuthDir()) {
 		if (!name.endsWith(".info")) continue;
 		const file = path.join(dir, name);
 		try {
-			const stats = await fsPromises.stat(file);
+			const stats = await fs.stat(file);
 			if (!stats.isFile()) continue;
-			const raw = await fsPromises.readFile(file, "utf8");
+			const raw = await fs.readFile(file, "utf8");
 			found.push(parseCredentialFile(JSON.parse(raw), file, stats.mtimeMs));
 		} catch {
 			continue;
@@ -23721,7 +24084,7 @@ var FileCredentialStore$4 = class {
 	async isStillCurrent(credentials) {
 		if (credentials.source === "managed") return true;
 		try {
-			return (await fsPromises.stat(credentials.sourceFile)).mtimeMs === credentials.sourceMtimeMs;
+			return (await fs.stat(credentials.sourceFile)).mtimeMs === credentials.sourceMtimeMs;
 		} catch {
 			return false;
 		}
@@ -23761,9 +24124,9 @@ var FileCredentialStore$4 = class {
 	*/
 	async readDesktopFile(filePath) {
 		try {
-			const stats = await fsPromises.stat(filePath);
+			const stats = await fs.stat(filePath);
 			if (!stats.isFile()) return null;
-			const raw = await fsPromises.readFile(filePath, "utf8");
+			const raw = await fs.readFile(filePath, "utf8");
 			return parseCredentialFile(JSON.parse(raw), filePath, stats.mtimeMs);
 		} catch {
 			return null;
@@ -23822,25 +24185,25 @@ var FileCredentialStore$4 = class {
 	*/
 	async writeBack(credentials) {
 		try {
-			const raw = await fsPromises.readFile(credentials.sourceFile, "utf8");
+			const raw = await fs.readFile(credentials.sourceFile, "utf8");
 			const parsed = JSON.parse(raw);
 			if (!isRecord$11(parsed) || !isRecord$11(parsed.auth)) return;
 			parsed.auth.accessToken = credentials.accessToken;
 			if (credentials.refreshToken !== "") parsed.auth.refreshToken = credentials.refreshToken;
 			parsed.auth.expiresAt = credentials.expiresAt;
 			parsed.auth.lastRefreshTime = Date.now();
-			const sourceMode = process.platform === "win32" ? void 0 : (await fsPromises.stat(credentials.sourceFile)).mode & 511;
+			const sourceMode = process.platform === "win32" ? void 0 : (await fs.stat(credentials.sourceFile)).mode & 511;
 			const tmp = `${credentials.sourceFile}.tmp.${process.pid}`;
 			try {
-				await fsPromises.writeFile(tmp, JSON.stringify(parsed, null, 2), {
+				await fs.writeFile(tmp, JSON.stringify(parsed, null, 2), {
 					encoding: "utf8",
 					...sourceMode === void 0 ? {} : { mode: sourceMode }
 				});
-				await fsPromises.rename(tmp, credentials.sourceFile);
+				await fs.rename(tmp, credentials.sourceFile);
 			} finally {
-				await fsPromises.unlink(tmp).catch(() => void 0);
+				await fs.unlink(tmp).catch(() => void 0);
 			}
-			credentials.sourceMtimeMs = (await fsPromises.stat(credentials.sourceFile)).mtimeMs;
+			credentials.sourceMtimeMs = (await fs.stat(credentials.sourceFile)).mtimeMs;
 		} catch {}
 	}
 };
@@ -23855,7 +24218,7 @@ var FileModelSettingsStore$4 = class {
 	}
 	async read() {
 		try {
-			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const content = await fs.readFile(this.filePath, "utf8");
 			const parsed = JSON.parse(content);
 			if (isRecord$11(parsed)) {
 				const enabledModelIds = Array.isArray(parsed.enabledModelIds) ? parsed.enabledModelIds.filter((id) => typeof id === "string") : [...DEFAULT_ENABLED_MODEL_IDS$1];
@@ -23883,10 +24246,10 @@ var FileModelSettingsStore$4 = class {
 		};
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const tmp = `${this.filePath}.tmp.${Date.now()}`;
-		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
-		await fsPromises.rename(tmp, this.filePath);
+		await fs.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fs.rename(tmp, this.filePath);
 	}
 	async updateSettings(patch) {
 		const current = await this.read();
@@ -26510,6 +26873,25 @@ const CLAUDE_CODE_BETA = "claude-code-20250219";
 /** Lets thinking blocks interleave with tool use across a multi-turn loop. */
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
 /**
+* Licenses the extended one-hour prompt-cache TTL.
+*
+* `cache_control: { type: 'ephemeral', ttl: '1h' }` is NOT accepted without this
+* beta: the one-hour tier is a separate licensed capability, and a body that
+* asks for it without the marker is refused the same way `block_binding` is.
+*/
+const EXTENDED_CACHE_TTL_BETA = "extended-cache-ttl-2025-04-11";
+/** A cache marker for one tier. Absent `ttl` means the five-minute default. */
+function cacheControlFor(ttl) {
+	return {
+		type: "ephemeral",
+		ttl
+	};
+}
+/** Whether a stored preference names a tier this line can send. */
+function isClaudeCacheTtl$1(value) {
+	return value === "5m" || value === "1h";
+}
+/**
 * Licenses `thinking.block_binding` in a request body.
 *
 * The field is not optional to license: the vendor documents that a body
@@ -27478,6 +27860,7 @@ function defaultClaudeSettings() {
 		enabledModelIds: [...DEFAULT_ENABLED_MODEL_IDS],
 		contextWindowOverrides: {},
 		defaultReasoningEffort: null,
+		cacheTtl: null,
 		selectedAccountId: null
 	};
 }
@@ -27713,12 +28096,14 @@ function parseClaudeModelSettings(value) {
 		for (const [model, window] of Object.entries(record.contextWindowOverrides)) if (typeof window === "number" && Number.isFinite(window) && window > 0) contextWindowOverrides[model] = window;
 	}
 	const defaultReasoningEffort = nonEmptyString$3(record.defaultReasoningEffort) ?? null;
+	const cacheTtl = isClaudeCacheTtl$1(record.cacheTtl) ? record.cacheTtl : null;
 	const selectedAccountId = nonEmptyString$3(record.selectedAccountId) ?? null;
 	return {
 		enabled: record.enabled !== false,
 		enabledModelIds,
 		contextWindowOverrides,
 		defaultReasoningEffort,
+		cacheTtl,
 		selectedAccountId
 	};
 }
@@ -27729,6 +28114,7 @@ function mergeClaudeSettings(current, patch) {
 		enabledModelIds: patch.enabledModelIds !== void 0 ? [...patch.enabledModelIds] : current.enabledModelIds,
 		contextWindowOverrides: patch.contextWindowOverrides !== void 0 ? mergeContextWindowOverrides(current.contextWindowOverrides, patch.contextWindowOverrides) : current.contextWindowOverrides,
 		defaultReasoningEffort: patch.defaultReasoningEffort !== void 0 ? patch.defaultReasoningEffort : current.defaultReasoningEffort,
+		cacheTtl: patch.cacheTtl !== void 0 ? patch.cacheTtl : current.cacheTtl,
 		selectedAccountId: patch.selectedAccountId !== void 0 ? patch.selectedAccountId : current.selectedAccountId
 	};
 }
@@ -27801,7 +28187,7 @@ var FileCredentialStore = class {
 	}
 	async removeLegacy() {
 		try {
-			await fsPromises.unlink(this.filePath);
+			await fs.unlink(this.filePath);
 		} catch (error) {
 			if (error.code !== "ENOENT") throw new Error("Claude legacy credential removal failed");
 		}
@@ -27822,11 +28208,11 @@ var FileCredentialStore = class {
 		}
 		let legacy;
 		try {
-			const stats = await fsPromises.lstat(this.filePath);
+			const stats = await fs.lstat(this.filePath);
 			if (!stats.isFile() || stats.isSymbolicLink()) throw new Error("Invalid credential file");
 			if (process.getuid && stats.uid !== process.getuid()) throw new Error("Invalid credential owner");
-			if (process.platform !== "win32") await fsPromises.chmod(this.filePath, 384);
-			legacy = await fsPromises.readFile(this.filePath, "utf8");
+			if (process.platform !== "win32") await fs.chmod(this.filePath, 384);
+			legacy = await fs.readFile(this.filePath, "utf8");
 		} catch (error) {
 			if (error.code === "ENOENT") return null;
 			throw new Error("Claude legacy credential read failed");
@@ -27934,17 +28320,17 @@ var FileModelSettingsStore = class {
 	}
 	async read() {
 		try {
-			const content = await fsPromises.readFile(this.filePath, "utf8");
+			const content = await fs.readFile(this.filePath, "utf8");
 			return parseClaudeModelSettings(JSON.parse(content));
 		} catch {
 			return defaultClaudeSettings();
 		}
 	}
 	async write(settings) {
-		await fsPromises.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
 		const tmp = this.filePath + ".tmp." + Date.now();
-		await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
-		await fsPromises.rename(tmp, this.filePath);
+		await fs.writeFile(tmp, JSON.stringify(settings, null, 2), "utf8");
+		await fs.rename(tmp, this.filePath);
 	}
 	/**
 	* Read-modify-write under the same per-path lock the credentials use.
@@ -27986,6 +28372,11 @@ function registerClaudePreferenceStore(settings, fallbackStore = new FileModelSe
 		enabledModelIds: z.array(z.string()).default([...DEFAULT_ENABLED_MODEL_IDS]),
 		contextWindowOverrides: z.dict(z.number()).default({}),
 		defaultReasoningEffort: z.union([z.string(), z.const(null)]).default(null),
+		cacheTtl: z.union([
+			z.const("5m"),
+			z.const("1h"),
+			z.const(null)
+		]).default(null),
 		selectedAccountId: z.union([z.string(), z.const(null)]).default(null)
 	}));
 	return {
@@ -27996,6 +28387,7 @@ function registerClaudePreferenceStore(settings, fallbackStore = new FileModelSe
 				enabledModelIds: value.enabledModelIds,
 				contextWindowOverrides: value.contextWindowOverrides,
 				defaultReasoningEffort: value.defaultReasoningEffort,
+				cacheTtl: isClaudeCacheTtl$1(value.cacheTtl) ? value.cacheTtl : null,
 				selectedAccountId: value.selectedAccountId ?? null
 			};
 		},
@@ -28191,6 +28583,7 @@ function claudeBetas(options = {}) {
 	betas.push(OAUTH_BETA);
 	if (options.thinking === true) betas.push(INTERLEAVED_THINKING_BETA);
 	if (options.thinkingBinding === true) betas.push(THINKING_BINDING_CONTROLS_BETA);
+	if (options.cacheTtl === "1h") betas.push(EXTENDED_CACHE_TTL_BETA);
 	return betas;
 }
 /** The `User-Agent` value this line reports for one surface. */
@@ -29788,7 +30181,7 @@ function leadingSystemText(options) {
 *
 * @param cacheControl - false is the opt-OUT; the default requests caching.
 */
-function buildClaudeSystemBlocks(options, cacheControl = true) {
+function buildClaudeSystemBlocks(options, cacheControl = true, ttl = "5m") {
 	const blocks = [{
 		type: "text",
 		text: CLAUDE_CODE_IDENTITY_TEXT
@@ -29800,7 +30193,7 @@ function buildClaudeSystemBlocks(options, cacheControl = true) {
 	});
 	if (cacheControl) {
 		const last = blocks[blocks.length - 1];
-		last.cache_control = { type: "ephemeral" };
+		last.cache_control = cacheControlFor(ttl);
 	}
 	return blocks;
 }
@@ -29838,13 +30231,14 @@ function lastCacheableUserBlock(messages) {
 *   and has not been handed to a caller yet.
 * @returns the number of breakpoints written.
 */
-function markClaudeCacheBreakpoints(body) {
+function markClaudeCacheBreakpoints(body, ttl = "5m") {
 	let marked = 0;
+	const marker = cacheControlFor(ttl);
 	const system = body.system;
 	if (Array.isArray(system)) {
 		const last = system[system.length - 1];
 		if (last !== void 0) {
-			last.cache_control = { type: "ephemeral" };
+			last.cache_control = { ...marker };
 			marked += 1;
 		}
 	}
@@ -29852,7 +30246,7 @@ function markClaudeCacheBreakpoints(body) {
 	if (Array.isArray(messages)) {
 		const target = lastCacheableUserBlock(messages);
 		if (target !== void 0) {
-			target.cache_control = { type: "ephemeral" };
+			target.cache_control = { ...marker };
 			marked += 1;
 		}
 	}
@@ -29860,7 +30254,7 @@ function markClaudeCacheBreakpoints(body) {
 	if (Array.isArray(tools) && tools.length > 0) {
 		const last = tools[tools.length - 1];
 		if (last !== void 0) {
-			last.cache_control = { type: "ephemeral" };
+			last.cache_control = { ...marker };
 			marked += 1;
 		}
 	}
@@ -30094,11 +30488,12 @@ function buildClaudeRequestBody(options, images = NO_RESOLVED_IMAGES, request =
 	const thinkingEnabled = thinking !== void 0 && thinking.type !== "disabled";
 	const temperatureAllowed = claudeModelSupportsTemperature(options.model) && !thinkingEnabled;
 	const caching = request.cacheControl !== false;
+	const cacheTtl = request.cacheTtl ?? "5m";
 	const body = {
 		model: options.model,
 		max_tokens: maxTokens,
 		stream: true,
-		system: buildClaudeSystemBlocks(options, caching),
+		system: buildClaudeSystemBlocks(options, caching, cacheTtl),
 		messages: mergeClaudeMessages(entries),
 		...options.tools !== void 0 && options.tools.length > 0 ? { tools: options.tools.map((tool) => wireTool(tool, names)) } : {},
 		...thinking === void 0 ? {} : { thinking },
@@ -30106,7 +30501,7 @@ function buildClaudeRequestBody(options, images = NO_RESOLVED_IMAGES, request =
 		...temperatureAllowed && options.temperature !== void 0 ? { temperature: options.temperature } : {},
 		...options.stop !== void 0 && options.stop.length > 0 ? { stop_sequences: [...options.stop] } : {}
 	};
-	if (caching) markClaudeCacheBreakpoints(body);
+	if (caching) markClaudeCacheBreakpoints(body, cacheTtl);
 	return body;
 }
 /**
@@ -31888,7 +32283,7 @@ var ClaudeAccountTokenStore = class {
 		await this.store.saveAccount(credentials, { internalId: this.internalId });
 	}
 };
-var ClaudeAdapter = class extends LlmAdapter {
+var ClaudeAdapter = class ClaudeAdapter extends LlmAdapter {
 	store;
 	modelSettings;
 	preferences;
@@ -32070,10 +32465,25 @@ var ClaudeAdapter = class extends LlmAdapter {
 	* driven by {@link shouldRotateAccount}, which bypasses the pool ENTIRELY when
 	* no credentials were resolved for it.
 	*/
-	async attemptRequest(credentials, requestOptions, images, toolNames, thinking, signal, fetchFn) {
+	/**
+	* The prompt-cache tier this line requests.
+	*
+	* A stored value wins; nothing stored falls back to the tier the OFFICIAL
+	* client uses for a subscription's main conversation, so a user comparing
+	* this plugin with Claude Code sees the same cache lifetime rather than half
+	* of it.
+	*
+	* @param settings - the document the caller already read for this turn.
+	*/
+	static cacheTtlFor(settings) {
+		return settings?.cacheTtl ?? "1h";
+	}
+	async attemptRequest(credentials, requestOptions, images, toolNames, thinking, settings, signal, fetchFn) {
+		const cacheTtl = ClaudeAdapter.cacheTtlFor(settings);
 		const payload = buildClaudeRequestBody(requestOptions, images, {
 			toolNames,
-			cacheControl: true
+			cacheControl: true,
+			cacheTtl
 		});
 		try {
 			return await fetchFn("https://api.anthropic.com/v1/messages?beta=true", {
@@ -32082,6 +32492,7 @@ var ClaudeAdapter = class extends LlmAdapter {
 					model: requestOptions.model,
 					thinking,
 					thinkingBinding: claudeBodyBindsThinking(payload),
+					cacheTtl,
 					method: "POST"
 				}),
 				body: JSON.stringify(payload),
@@ -32100,6 +32511,7 @@ var ClaudeAdapter = class extends LlmAdapter {
 		assertClaudeCliVersionMeetsFloor(requestOptions.model, await this.catalogForRequest());
 		const effort = requestOptions.reasoningEffort === void 0 || requestOptions.reasoningEffort === null ? void 0 : String(requestOptions.reasoningEffort);
 		const thinking = claudeRequestThinks(requestOptions.model, effort);
+		const settings = await this.settings().catch(() => null);
 		const pool = this.accountPool;
 		const tried = /* @__PURE__ */ new Set();
 		let response;
@@ -32119,7 +32531,7 @@ var ClaudeAdapter = class extends LlmAdapter {
 		let outputStarted = false;
 		while (true) {
 			const { credentials, accountId } = await this.resolveCredential(pool, tried, fetchFn, signal);
-			response = await this.attemptRequest(credentials, requestOptions, images, toolNames, thinking, signal, fetchFn);
+			response = await this.attemptRequest(credentials, requestOptions, images, toolNames, thinking, settings, signal, fetchFn);
 			if (response.ok) break;
 			const detail = (await response.text().catch(() => "")).slice(0, 2e3);
 			const failure = classifyFailure(response.status, detail, response.headers);
@@ -33589,6 +34001,16 @@ const CLAUDE_REASONING_EFFORTS = [
 function isClaudeReasoningEffort(value) {
 	return typeof value === "string" && CLAUDE_REASONING_EFFORTS.includes(value);
 }
+/**
+* Whether a posted value names a tier this route can send.
+*
+* Membership is checked at the wire boundary for the same reason effort levels
+* are: the one-hour tier is a LICENSED capability, so a value that reached the
+* body without the matching beta would be refused by the service.
+*/
+function isClaudeCacheTtl(value) {
+	return value === "5m" || value === "1h";
+}
 //#endregion
 //#region src/host/claude/routes.ts
 /** Ceiling on one request body. Identical to every sibling line's. */
@@ -33780,6 +34202,7 @@ async function getClaudeWebStatus(store, modelSettings, preferences, options = {
 		models,
 		contextWindowOverrides: settings.contextWindowOverrides,
 		defaultReasoningEffort: settings.defaultReasoningEffort,
+		cacheTtl: settings.cacheTtl,
 		selectedAccountId: settings.selectedAccountId,
 		accounts: poolAccounts.map((summary) => summary),
 		rotationStrategy: poolData?.rotationStrategy ?? "sequential",
@@ -34058,6 +34481,10 @@ function registerClaudeRoutes(ctx, store, modelSettings, preferences, options =
 						const effort = body.defaultReasoningEffort;
 						if (effort === null || isClaudeReasoningEffort(effort)) patch.defaultReasoningEffort = effort;
 					}
+					if (body.cacheTtl !== void 0) {
+						const ttl = body.cacheTtl;
+						if (ttl === null || isClaudeCacheTtl(ttl)) patch.cacheTtl = ttl;
+					}
 					if (body.selectedAccountId !== void 0) {
 						const selected = body.selectedAccountId;
 						if (selected !== null && typeof selected !== "string") return sendJson(response, 400, {
@@ -34593,7 +35020,7 @@ var WorkBuddyCheckinService = class {
 		if (this.loaded) return;
 		this.loaded = true;
 		try {
-			const parsed = JSON.parse(await fsPromises.readFile(this.statePath, "utf8"));
+			const parsed = JSON.parse(await fs.readFile(this.statePath, "utf8"));
 			if (isRecord$2(parsed)) {
 				const lastRunAt = asCount$1(parsed.lastRunAt);
 				if (lastRunAt !== void 0) this.lastRunAt = lastRunAt;
@@ -34606,15 +35033,15 @@ var WorkBuddyCheckinService = class {
 	}
 	async save() {
 		try {
-			await fsPromises.mkdir(path.dirname(this.statePath), { recursive: true });
+			await fs.mkdir(path.dirname(this.statePath), { recursive: true });
 			const tmp = `${this.statePath}.tmp.${process.pid}`;
 			const document = {
 				version: 2,
 				lastRunAt: this.lastRunAt,
 				accounts: this.state
 			};
-			await fsPromises.writeFile(tmp, JSON.stringify(document, null, 2), "utf8");
-			await fsPromises.rename(tmp, this.statePath);
+			await fs.writeFile(tmp, JSON.stringify(document, null, 2), "utf8");
+			await fs.rename(tmp, this.statePath);
 		} catch {}
 	}
 	async post(url, headers) {
@@ -35262,7 +35689,7 @@ var MinimaxCodeCheckinService = class {
 		if (this.loaded) return;
 		this.loaded = true;
 		try {
-			const parsed = JSON.parse(await fsPromises.readFile(this.statePath, "utf8"));
+			const parsed = JSON.parse(await fs.readFile(this.statePath, "utf8"));
 			if (isRecord(parsed)) {
 				const lastRunAt = asCount(parsed.lastRunAt);
 				if (lastRunAt !== void 0) this.lastRunAt = lastRunAt;
@@ -35281,7 +35708,7 @@ var MinimaxCodeCheckinService = class {
 	}
 	async save() {
 		try {
-			await fsPromises.mkdir(path.dirname(this.statePath), { recursive: true });
+			await fs.mkdir(path.dirname(this.statePath), { recursive: true });
 			const tmp = `${this.statePath}.tmp.${process.pid}`;
 			const document = {
 				version: 1,
@@ -35289,8 +35716,8 @@ var MinimaxCodeCheckinService = class {
 				accounts: this.state,
 				identities: this.identities
 			};
-			await fsPromises.writeFile(tmp, JSON.stringify(document, null, 2), "utf8");
-			await fsPromises.rename(tmp, this.statePath);
+			await fs.writeFile(tmp, JSON.stringify(document, null, 2), "utf8");
+			await fs.rename(tmp, this.statePath);
 		} catch {}
 	}
 };
@@ -37682,7 +38109,10 @@ function apply(ctx, pluginConfig = {}) {
 			outputVerbosity: () => preferences.status().outputVerbosity,
 			fastMode: () => preferences.status().fastMode,
 			reasoningSummary: () => preferences.status().reasoningSummary
-		}), preferences);
+		}), preferences, (options) => oauth.credentials(void 0, { purpose: "tool" }).then((credentials) => loadCodexCatalog(credentials, {
+			fetchFn: proxyFetch,
+			signal: options?.signal
+		})).catch(() => []));
 		const searchSwitcher = new SearchProviderSwitcher(ctx.loader);
 		const applyWebProviders = (current = preferences.status()) => {
 			const pluginFetch = proxyManager.resolveActiveProxyUrl() !== null;