dsh-codex-subscription 1.9.0 → 1.11.0

package/lib/index.js

@@ -11,9 +11,13 @@ import { promisify } from "node:util";
 import { HttpsProxyAgent } from "https-proxy-agent";
 import { openaiCodexProvider as createOpenAICodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
 import { createModels } from "@earendil-works/pi-ai";
-import { randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { WebError } from "@deepseek-ai/dsh-web";
 import { defineTool } from "@deepseek-ai/dsh-tools";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 //#region src/credential-store.js
 const PROVIDER$1 = "openai-codex";
 const abortIfNeeded = (options) => options?.signal?.throwIfAborted();
@@ -725,12 +729,20 @@ const SETTINGS_NAMESPACE = "codex-subscription";
 const QUICK_QUOTA_MODE_FIELD = "quickQuotaMode";
 const LEGACY_QUICK_QUOTA_FIELD = "quickQuotaVisible";
 const QUICK_QUOTA_MODE_PERCENT = "percent";
+const QUICK_QUOTA_MODE_FORECAST = "forecast";
 const SEARCH_PROVIDER_FIELD = "searchProvider";
+const SEARCH_PROVIDER_AUTO = "auto";
 const SEARCH_PROVIDER_CODEX = "codex";
+const DEFAULT_SEARCH_PROVIDER = SEARCH_PROVIDER_AUTO;
 const SPEED_MODE_FIELD = "speedMode";
 const SPEED_MODE_STANDARD = "standard";
 const SPEED_MODE_FAST = "fast";
 const DEFAULT_SPEED_MODE = SPEED_MODE_STANDARD;
+const OUTPUT_VERBOSITY_FIELD = "outputVerbosity";
+const OUTPUT_VERBOSITY_DEFAULT = "default";
+const OUTPUT_VERBOSITY_MEDIUM = "medium";
+const OUTPUT_VERBOSITY_HIGH = "high";
+const DEFAULT_OUTPUT_VERBOSITY = OUTPUT_VERBOSITY_DEFAULT;
 const CONTEXT_MODE_FIELD = "contextMode";
 const CONTEXT_MODE_STANDARD = "standard";
 const CONTEXT_MODE_EXTENDED = "extended";
@@ -758,6 +770,12 @@ const CUSTOM_CONTEXT_MODEL_DEFAULTS = Object.freeze({
 	"gpt-5.5": 272e3,
 	"gpt-5.6": 272e3
 });
+const normalizeOutputVerbosity = (value) => [
+	"default",
+	"low",
+	"medium",
+	"high"
+].includes(value) ? value : DEFAULT_OUTPUT_VERBOSITY;
 const normalizeContextMode = (value) => [
 	"standard",
 	"extended",
@@ -803,7 +821,8 @@ function contextModelGroups(models) {
 const normalizeQuickQuotaMode = (value, legacyVisible = false) => [
 	"off",
 	"percent",
-	"bar"
+	"bar",
+	"forecast"
 ].includes(value) ? value : legacyVisible === true ? QUICK_QUOTA_MODE_PERCENT : "off";
 const supportsCodexFastMode = (modelId) => typeof modelId === "string" && (/^gpt-5\.(?:5|6)(?:$|-)/u.test(modelId) || modelId === "gpt-5.4");
 //#endregion
@@ -829,7 +848,7 @@ const EXTENDED_CONTEXT_WINDOWS = Object.freeze({
 	"gpt-5.6-sol": 1e6,
 	"gpt-5.6-terra": 1e6
 });
-function openaiCodexSubscriptionProvider({ resolveSpeedMode = () => void 0, resolveContextMode = () => void 0, resolveCustomContextWindow = () => void 0, runNetwork = (_area, operation) => operation() } = {}) {
+function openaiCodexSubscriptionProvider({ resolveSpeedMode = () => void 0, resolveOutputVerbosity = () => OUTPUT_VERBOSITY_DEFAULT, resolveContextMode = () => void 0, resolveCustomContextWindow = () => void 0, catalog, runNetwork = (_area, operation) => operation() } = {}) {
 	const provider = createOpenAICodexProvider();
 	const requestToken = Object.freeze({
 		name: "DSH-managed Codex OAuth request token",
@@ -842,25 +861,40 @@ function openaiCodexSubscriptionProvider({ resolveSpeedMode = () => void 0, reso
 			};
 		}
 	});
-	const withSpeed = (model, options = {}) => {
-		if (resolveSpeedMode() !== "fast" || !supportsCodexFastMode(model?.id)) return options;
+	const modelMetadata = (model) => catalog?.metadata(model?.id);
+	const supportsVerbosity = (model) => modelMetadata(model)?.supportVerbosity ?? model?.id !== "gpt-5.3-codex-spark";
+	const withPreferences = (model, options = {}) => {
+		const metadata = modelMetadata(model);
+		const requestedVerbosity = resolveOutputVerbosity();
+		const textVerbosity = supportsVerbosity(model) ? requestedVerbosity === "default" ? metadata?.defaultVerbosity ?? "medium" : requestedVerbosity : void 0;
+		const fast = resolveSpeedMode() === "fast" && (metadata?.supportsFast ?? supportsCodexFastMode(model?.id));
 		const onPayload = options.onPayload;
 		return {
 			...options,
-			serviceTier: FAST_SERVICE_TIER,
+			...textVerbosity === void 0 ? {} : { textVerbosity },
+			...fast ? { serviceTier: FAST_SERVICE_TIER } : {},
 			async onPayload(payload, requestModel) {
-				const fastPayload = {
+				const preferred = {
 					...payload,
-					service_tier: FAST_SERVICE_TIER
+					...textVerbosity === void 0 ? {} : { text: {
+						...payload.text ?? {},
+						verbosity: textVerbosity
+					} },
+					...fast ? { service_tier: FAST_SERVICE_TIER } : {}
 				};
+				const next = await onPayload?.(preferred, requestModel);
 				return {
-					...await onPayload?.(fastPayload, requestModel) ?? fastPayload,
-					service_tier: FAST_SERVICE_TIER
+					...next ?? preferred,
+					...textVerbosity === void 0 ? {} : { text: {
+						...(next ?? preferred).text ?? {},
+						verbosity: textVerbosity
+					} },
+					...fast ? { service_tier: FAST_SERVICE_TIER } : {}
 				};
 			}
 		};
 	};
-	const getModels = () => provider.getModels().map((model) => {
+	const getModels = () => (catalog?.getModels(provider.getModels()) ?? provider.getModels()).map((model) => {
 		const maximum = EXTENDED_CONTEXT_WINDOWS[model.id];
 		const mode = resolveContextMode();
 		if (maximum === void 0 || !["extended", "custom"].includes(mode)) return model;
@@ -896,17 +930,147 @@ function openaiCodexSubscriptionProvider({ resolveSpeedMode = () => void 0, reso
 			apiKey: requestToken
 		}),
 		getModels,
-		stream: (model, context, options) => networkIterable(() => provider.stream(model, context, withSpeed(model, options))),
-		streamSimple: (model, context, options) => networkIterable(() => provider.streamSimple(model, context, withSpeed(model, options)))
+		stream: (model, context, options) => networkIterable(() => provider.stream(model, context, withPreferences(model, options))),
+		streamSimple: (model, context, options) => networkIterable(() => provider.streamSimple(model, context, withPreferences(model, options)))
 	});
 }
 //#endregion
 //#region src/version.js
-const PACKAGE_VERSION = "1.9.0";
+const PACKAGE_VERSION = "1.11.0";
 const USER_AGENT = `dsh-codex-subscription/${PACKAGE_VERSION}`;
 //#endregion
+//#region src/model-catalog.js
+const CODEX_MODELS_URL = `https://chatgpt.com/backend-api/codex/models?client_version=${encodeURIComponent(PACKAGE_VERSION)}`;
+const LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const record$4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const nonEmpty$2 = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+const positiveInteger$1 = (value) => Number.isSafeInteger(value) && value > 0 ? value : void 0;
+function reasoningMap(levels) {
+	const supported = new Set((Array.isArray(levels) ? levels : []).map((level) => nonEmpty$2(record$4(level) ? level.effort : void 0)).filter(Boolean));
+	const map = Object.fromEntries(LEVELS.map((level) => [level, null]));
+	if (supported.has("none")) map.off = "none";
+	for (const level of LEVELS.slice(1)) if (supported.has(level)) map[level] = level;
+	return map;
+}
+function visibleModel(value) {
+	if (!record$4(value)) return void 0;
+	const id = nonEmpty$2(value.slug);
+	if (id === void 0 || value.supported_in_api !== true || value.visibility !== "list") return void 0;
+	const supported = Array.isArray(value.supported_reasoning_levels) ? value.supported_reasoning_levels : [];
+	const input = Array.isArray(value.input_modalities) ? value.input_modalities.filter((item) => ["text", "image"].includes(item)) : ["text", "image"];
+	return {
+		id,
+		name: nonEmpty$2(value.display_name) ?? id,
+		description: nonEmpty$2(value.description),
+		priority: Number.isFinite(value.priority) ? value.priority : 0,
+		input: input.length > 0 ? input : ["text"],
+		contextWindow: positiveInteger$1(value.context_window) ?? positiveInteger$1(value.max_context_window),
+		reasoning: supported.length > 0,
+		thinkingLevelMap: reasoningMap(supported),
+		supportVerbosity: value.support_verbosity === true,
+		defaultVerbosity: [
+			"low",
+			"medium",
+			"high"
+		].includes(value.default_verbosity) ? value.default_verbosity : void 0,
+		supportsFast: [...Array.isArray(value.additional_speed_tiers) ? value.additional_speed_tiers : [], ...Array.isArray(value.service_tiers) ? value.service_tiers.map((tier) => tier?.id) : []].some((tier) => tier === "fast" || tier === "priority")
+	};
+}
+function parseOfficialModelCatalog(value) {
+	if (!record$4(value) || !Array.isArray(value.models)) throw new Error("Codex returned a malformed model catalog");
+	const seen = /* @__PURE__ */ new Set();
+	return value.models.map(visibleModel).filter((model) => model !== void 0 && !seen.has(model.id) && seen.add(model.id)).sort((left, right) => right.priority - left.priority);
+}
+function mergeModel(baseModels, remote) {
+	const base = baseModels.find((model) => model.id === remote.id) ?? baseModels.find((model) => model.id !== "gpt-5.3-codex-spark") ?? baseModels[0];
+	if (base === void 0) return void 0;
+	return {
+		...base,
+		id: remote.id,
+		name: remote.name,
+		input: remote.input,
+		reasoning: remote.reasoning,
+		thinkingLevelMap: remote.thinkingLevelMap,
+		...remote.contextWindow === void 0 ? {} : { contextWindow: remote.contextWindow },
+		...base.id === remote.id ? {} : { cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		} }
+	};
+}
+function createOfficialModelCatalog(options = {}) {
+	const fetchCatalog = options.fetch ?? fetch;
+	let models;
+	let metadata = /* @__PURE__ */ new Map();
+	let etag;
+	let revision = 0;
+	let refreshing;
+	const refresh = async ({ signal } = {}) => {
+		if (refreshing !== void 0) return refreshing;
+		refreshing = (async () => {
+			const auth = await options.getAuth({ signal });
+			const credential = await options.readCredential({ signal });
+			const access = auth?.auth?.apiKey;
+			const accountId = credential?.type === "oauth" ? credential.accountId : void 0;
+			if (typeof access !== "string" || access.length === 0 || typeof accountId !== "string" || accountId.length === 0) return false;
+			const headers = {
+				authorization: `Bearer ${access}`,
+				"chatgpt-account-id": accountId,
+				accept: "application/json",
+				originator: "pi",
+				"user-agent": USER_AGENT,
+				...etag === void 0 ? {} : { "if-none-match": etag }
+			};
+			const response = await fetchCatalog(CODEX_MODELS_URL, {
+				method: "GET",
+				redirect: "error",
+				headers,
+				signal
+			});
+			if (response.status === 304) return false;
+			if (!response.ok) throw new Error(`Codex model catalog failed (HTTP ${response.status})`);
+			const remote = parseOfficialModelCatalog(await response.json());
+			if (remote.length === 0) throw new Error("Codex returned an empty model catalog");
+			const baseModels = options.baseModels();
+			const next = remote.map((model) => mergeModel(baseModels, model)).filter(Boolean);
+			if (next.length === 0) throw new Error("Codex model catalog has no compatible models");
+			models = next;
+			metadata = new Map(remote.map((model) => [model.id, model]));
+			etag = nonEmpty$2(response.headers.get("etag")) ?? etag;
+			revision += 1;
+			return true;
+		})().finally(() => {
+			refreshing = void 0;
+		});
+		return refreshing;
+	};
+	return Object.freeze({
+		refresh,
+		getModels: (fallback) => models ?? fallback,
+		metadata: (modelId) => metadata.get(modelId),
+		revision: () => revision,
+		clear() {
+			models = void 0;
+			metadata = /* @__PURE__ */ new Map();
+			etag = void 0;
+			revision += 1;
+		}
+	});
+}
+//#endregion
 //#region src/codex-search.js
 const CODEX_SEARCH_PROVIDER_ID = "codex-subscription";
+const CODEX_AUTO_SEARCH_PROVIDER_ID = "codex-subscription-auto";
 const CODEX_SEARCH_URL = "https://chatgpt.com/backend-api/codex/alpha/search";
 const DEFAULT_MODEL = "gpt-5.6-luna";
 const MAX_OUTPUT_TOKENS = 4096;
@@ -1021,6 +1185,55 @@ function createCodexSearchProvider(options) {
 		}
 	});
 }
+/** Route each request by its initiating model without changing the user's explicit overrides. */
+function createCodexAutoSearchProvider(options) {
+	return Object.freeze({
+		id: CODEX_AUTO_SEARCH_PROVIDER_ID,
+		available: () => true,
+		async search(request, signal) {
+			if (options.resolveModelProvider?.() === "openai-codex") return options.codex.search(request, signal);
+			const provider = options.resolveDshProvider?.();
+			if (provider === void 0 || provider.id === "codex-subscription-auto" || provider.id === "codex-subscription" || provider.available() !== true) throw new WebError("DSH default search is unavailable", "WEB_PROVIDER_UNAVAILABLE");
+			return provider.search(request, signal);
+		}
+	});
+}
+const ORIGINAL_IMAGE_CHUNK_BYTES = 4 * 1024 * 1024;
+const ORIGINAL_IMAGE_ID_PATTERN = /^img_[0-9a-f]{32}$/u;
+const positiveInteger = (value) => Number.isSafeInteger(value) && value > 0;
+function decodeOriginalImageRef(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value) || typeof value.assetId !== "string" || !ORIGINAL_IMAGE_ID_PATTERN.test(value.assetId) || value.mediaType !== "image/png" || !positiveInteger(value.bytes) || value.bytes > 48 * 1024 * 1024 || !positiveInteger(value.width) || !positiveInteger(value.height) || typeof value.name !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value.name) || typeof value.sha256 !== "string" || !/^[0-9a-f]{64}$/u.test(value.sha256)) return void 0;
+	return {
+		assetId: value.assetId,
+		mediaType: value.mediaType,
+		bytes: value.bytes,
+		width: value.width,
+		height: value.height,
+		name: value.name,
+		sha256: value.sha256
+	};
+}
+function decodeImagePresentation(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value) || value.kind !== "codex-subscription-image" || value.schemaVersion !== 1) return void 0;
+	const original = decodeOriginalImageRef(value.original);
+	return original === void 0 ? void 0 : { original };
+}
+function originalImageRefsEqual(left, right) {
+	const a = decodeOriginalImageRef(left);
+	const b = decodeOriginalImageRef(right);
+	return a !== void 0 && b !== void 0 && a.assetId === b.assetId && a.mediaType === b.mediaType && a.bytes === b.bytes && a.width === b.width && a.height === b.height && a.name === b.name && a.sha256 === b.sha256;
+}
+/** Resolve only an exact original reference copied into a DSH fork prefix. */
+function inheritedOriginalImageRef(session, assetId) {
+	const parentSession = session?.header?.parentSession;
+	const seedLength = session?.header?.seedLength;
+	if (typeof parentSession !== "string" || parentSession.length === 0 || !Number.isSafeInteger(seedLength) || seedLength < 0 || !Array.isArray(session?.events) || !ORIGINAL_IMAGE_ID_PATTERN.test(assetId)) return void 0;
+	for (const event of session.events) {
+		if (!Number.isSafeInteger(event?.seq) || event.seq < 0 || event.seq >= seedLength || event.type !== "tool/result") continue;
+		const original = decodeImagePresentation(event.data?.meta)?.original;
+		if (original?.assetId === assetId) return original;
+	}
+}
 //#endregion
 //#region src/codex-images.js
 const CODEX_IMAGE_TOOL_NAME = "codex_image_generate";
@@ -1029,6 +1242,17 @@ const CODEX_IMAGE_EDIT_URL = "https://chatgpt.com/backend-api/codex/images/edits
 const IMAGE_MODEL = "gpt-image-2";
 const MAX_REFERENCE_IMAGES = 5;
 const RESPONSE_ENVELOPE_BYTES = 1024 * 1024;
+const IMAGE_QUALITIES = /* @__PURE__ */ new Set([
+	"auto",
+	"low",
+	"medium",
+	"high"
+]);
+const IMAGE_BACKGROUNDS = /* @__PURE__ */ new Set([
+	"auto",
+	"transparent",
+	"opaque"
+]);
 const PNG_SIGNATURE = Buffer.from([
 	137,
 	80,
@@ -1041,6 +1265,27 @@ const PNG_SIGNATURE = Buffer.from([
 ]);
 const record$2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const nonEmpty = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+function normalizeImageOptions(args) {
+	const quality = nonEmpty(args?.quality) ?? "auto";
+	const background = nonEmpty(args?.background) ?? "auto";
+	const size = nonEmpty(args?.size) ?? "auto";
+	if (!IMAGE_QUALITIES.has(quality)) throw new Error("quality must be auto, low, medium, or high");
+	if (!IMAGE_BACKGROUNDS.has(background)) throw new Error("background must be auto, transparent, or opaque");
+	if (size !== "auto") {
+		const match = /^(\d+)x(\d+)$/u.exec(size);
+		const width = Number(match?.[1]);
+		const height = Number(match?.[2]);
+		const short = Math.min(width, height);
+		const long = Math.max(width, height);
+		const pixels = width * height;
+		if (match === null || width % 16 !== 0 || height % 16 !== 0 || long > 3840 || long > short * 3 || pixels < 655360 || pixels > 8294400) throw new Error("size must be auto or a valid GPT Image 2 widthxheight resolution");
+	}
+	return {
+		quality,
+		background,
+		size
+	};
+}
 function encodedLimit(decodedBytes) {
 	return Math.ceil(decodedBytes / 3) * 4;
 }
@@ -1157,6 +1402,42 @@ function imageOutputSchema() {
 					name: { type: "string" }
 				}
 			},
+			original: {
+				type: "object",
+				required: true,
+				additionalProperties: false,
+				properties: {
+					assetId: {
+						type: "string",
+						required: true
+					},
+					mediaType: {
+						type: "string",
+						enum: ["image/png"],
+						required: true
+					},
+					bytes: {
+						type: "integer",
+						required: true
+					},
+					width: {
+						type: "integer",
+						required: true
+					},
+					height: {
+						type: "integer",
+						required: true
+					},
+					name: {
+						type: "string",
+						required: true
+					},
+					sha256: {
+						type: "string",
+						required: true
+					}
+				}
+			},
 			background: { type: "string" },
 			quality: { type: "string" },
 			size: { type: "string" }
@@ -1187,6 +1468,29 @@ function createCodexImageTool(options) {
 				required: true,
 				description: "A complete, production-ready description of the image to generate."
 			},
+			size: {
+				type: "string",
+				description: "Optional GPT Image 2 output size. Use auto unless the user requests an exact valid widthxheight resolution."
+			},
+			quality: {
+				type: "string",
+				enum: [
+					"auto",
+					"low",
+					"medium",
+					"high"
+				],
+				description: "Optional rendering quality. Use auto unless the user requests draft speed or final quality."
+			},
+			background: {
+				type: "string",
+				enum: [
+					"auto",
+					"transparent",
+					"opaque"
+				],
+				description: "Optional background mode. Request transparent only when the user needs transparency."
+			},
 			referenceImages: {
 				type: "array",
 				description: "Optional explicit references to 1-5 prior images to edit. Omit for a new image.",
@@ -1221,13 +1525,19 @@ function createCodexImageTool(options) {
 		},
 		output: {
 			schema: imageOutputSchema(),
-			render: (_args, value) => imageContent(value)
+			render: (_args, value) => imageContent(value),
+			presentationMeta: (_args, value) => ({
+				kind: "codex-subscription-image",
+				schemaVersion: 1,
+				original: value.original
+			})
 		},
 		timeoutMs: 300 * 1e3,
 		isConcurrencySafe: () => false,
 		async execute(args, exec) {
 			const prompt = nonEmpty(args.prompt);
 			if (prompt === void 0) throw new Error("prompt must be a non-empty string");
+			const imageOptions = normalizeImageOptions(args);
 			const auth = await options.getAuth({ signal: exec.signal });
 			const credential = await options.readCredential({ signal: exec.signal });
 			const access = auth?.auth?.apiKey;
@@ -1254,10 +1564,10 @@ function createCodexImageTool(options) {
 					body: JSON.stringify({
 						...images === void 0 ? {} : { images },
 						prompt,
-						background: "auto",
+						background: imageOptions.background,
 						model: IMAGE_MODEL,
-						quality: "auto",
-						size: "auto"
+						quality: imageOptions.quality,
+						size: imageOptions.size
 					}),
 					signal: exec.signal
 				});
@@ -1272,12 +1582,23 @@ function createCodexImageTool(options) {
 			}
 			const metadata = responseMetadata(await readJsonWithin(response, encodedLimit(maximumBytes) + RESPONSE_ENVELOPE_BYTES));
 			const data = decodeCodexPng(metadata.encoded, maximumBytes);
-			const result = {
-				image: imageReference(await attachments.saveImage({
+			const sessionId = exec.agent?.id;
+			if (sessionId === void 0) throw new Error("Codex image generation requires a session-owned tool call");
+			const original = await options.originalImages.save(String(sessionId), data);
+			let ref;
+			try {
+				ref = await attachments.saveImage({
 					data,
 					mediaType: "image/png",
 					name: "codex-generated.png"
-				})),
+				});
+			} catch (error) {
+				await options.originalImages.remove(original);
+				throw error;
+			}
+			const result = {
+				image: imageReference(ref),
+				original,
 				...metadata.background === void 0 ? {} : { background: metadata.background },
 				...metadata.quality === void 0 ? {} : { quality: metadata.quality },
 				...metadata.size === void 0 ? {} : { size: metadata.size }
@@ -1294,6 +1615,142 @@ function createCodexImageTool(options) {
 	});
 }
 //#endregion
+//#region src/image-original-store.js
+const ORIGINAL_IMAGE_DIRECTORY = "dsh-codex-subscription/images/v1";
+const METADATA_VERSION = 1;
+const digest = (data) => createHash("sha256").update(data).digest("hex");
+const validSessionId = (value) => typeof value === "string" && value.length > 0 && value.length <= 512;
+function pngDimensions(data) {
+	if (!(data instanceof Uint8Array) || data.byteLength < 24 || Buffer.from(data.subarray(0, 8)).toString("hex") !== "89504e470d0a1a0a" || Buffer.from(data.subarray(12, 16)).toString("ascii") !== "IHDR") throw new TypeError("invalid PNG dimensions");
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const width = view.getUint32(16, false);
+	const height = view.getUint32(20, false);
+	if (width === 0 || height === 0) throw new TypeError("invalid PNG dimensions");
+	return {
+		width,
+		height
+	};
+}
+async function writeExclusive(filename, data) {
+	await mkdir(dirname(filename), {
+		recursive: true,
+		mode: 448
+	});
+	const handle = await open(filename, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+	try {
+		await handle.writeFile(data);
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+}
+async function assertPrivateFile(filename) {
+	const stat = await lstat(filename);
+	if (!stat.isFile()) throw new Error("not a regular file");
+	if (process.platform !== "win32" && (stat.mode & 63) !== 0) throw new Error("file is not owner-only");
+}
+function parseMetadata(text) {
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch {
+		return;
+	}
+	if (value?.version !== METADATA_VERSION || !validSessionId(value.sessionId)) return void 0;
+	const image = decodeOriginalImageRef(value.image);
+	return image === void 0 ? void 0 : {
+		sessionId: value.sessionId,
+		image
+	};
+}
+var OriginalImageStore = class {
+	constructor(dshHome) {
+		this.root = resolve(join(resolveDshHome(dshHome), ORIGINAL_IMAGE_DIRECTORY));
+	}
+	directory(assetId) {
+		if (!ORIGINAL_IMAGE_ID_PATTERN.test(assetId)) throw new TypeError("invalid original image asset id");
+		return join(this.root, assetId.slice(4, 6), assetId);
+	}
+	async save(sessionId, data, name = "codex-generated-original.png") {
+		if (!validSessionId(sessionId) || !(data instanceof Uint8Array) || data.byteLength === 0 || data.byteLength > 48 * 1024 * 1024) throw new TypeError("invalid original image input");
+		const { width, height } = pngDimensions(data);
+		const assetId = `img_${randomBytes(16).toString("hex")}`;
+		const directory = this.directory(assetId);
+		const ref = {
+			assetId,
+			mediaType: "image/png",
+			bytes: data.byteLength,
+			width,
+			height,
+			name,
+			sha256: digest(data)
+		};
+		try {
+			await mkdir(dirname(directory), {
+				recursive: true,
+				mode: 448
+			});
+			await mkdir(directory, {
+				recursive: false,
+				mode: 448
+			});
+			await writeExclusive(join(directory, "original"), data);
+			const temporary = join(directory, `metadata.${randomBytes(8).toString("hex")}.tmp`);
+			await writeExclusive(temporary, Buffer.from(`${JSON.stringify({
+				version: METADATA_VERSION,
+				sessionId,
+				image: ref
+			}, null, 2)}\n`));
+			await rename(temporary, join(directory, "metadata.json"));
+			return ref;
+		} catch (error) {
+			await rm(directory, {
+				recursive: true,
+				force: true
+			}).catch(() => void 0);
+			throw error;
+		}
+	}
+	async remove(ref) {
+		if (ref !== void 0 && ORIGINAL_IMAGE_ID_PATTERN.test(ref.assetId)) await rm(this.directory(ref.assetId), {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+	}
+	async read(sessionId, assetId, inherited) {
+		if (!validSessionId(sessionId) || !ORIGINAL_IMAGE_ID_PATTERN.test(assetId)) return void 0;
+		try {
+			const directory = this.directory(assetId);
+			const metadataFile = join(directory, "metadata.json");
+			const originalFile = join(directory, "original");
+			await Promise.all([assertPrivateFile(metadataFile), assertPrivateFile(originalFile)]);
+			const metadata = parseMetadata(await readFile(metadataFile, "utf8"));
+			if (metadata === void 0 || metadata.image.assetId !== assetId || metadata.sessionId !== sessionId && !originalImageRefsEqual(metadata.image, inherited)) return void 0;
+			const data = new Uint8Array(await readFile(originalFile));
+			const dimensions = pngDimensions(data);
+			if (data.byteLength !== metadata.image.bytes || digest(data) !== metadata.image.sha256 || dimensions.width !== metadata.image.width || dimensions.height !== metadata.image.height) return void 0;
+			return {
+				ref: metadata.image,
+				data
+			};
+		} catch {
+			return;
+		}
+	}
+	async chunk(sessionId, assetId, offset, inherited) {
+		if (!Number.isSafeInteger(offset) || offset < 0) return void 0;
+		const stored = await this.read(sessionId, assetId, inherited);
+		if (stored === void 0 || offset >= stored.data.byteLength || offset % 4194304 !== 0) return void 0;
+		const end = Math.min(stored.data.byteLength, offset + ORIGINAL_IMAGE_CHUNK_BYTES);
+		return {
+			ref: stored.ref,
+			offset,
+			encoded: Buffer.from(stored.data.subarray(offset, end)).toString("base64"),
+			done: end === stored.data.byteLength
+		};
+	}
+};
+//#endregion
 //#region src/diagnostics.js
 const requestAreas = /* @__PURE__ */ new Set([
 	"login",
@@ -1367,6 +1824,7 @@ async function createSubscriptionDiagnostics({ auth, preferences, login = { phas
 		configuration: {
 			contextMode: preference.contextMode,
 			quickQuotaMode: preference.quickQuotaMode,
+			...typeof preference.outputVerbosity === "string" ? { outputVerbosity: preference.outputVerbosity } : {},
 			searchProvider: preference.searchProvider,
 			speedMode: preference.speedMode,
 			writable: preference.writable === true
@@ -1561,6 +2019,136 @@ function createCodexUsageReader(options) {
 	});
 }
 //#endregion
+//#region src/quota-forecast.js
+const HOUR_MS = 3600 * 1e3;
+const HISTORY_MS = 24 * HOUR_MS;
+const MIN_SPAN_MS = 1800 * 1e3;
+const MIN_CONSUMED_PERCENT = 1;
+const PLATEAU_SAMPLE_MS = 900 * 1e3;
+const finite = (value) => Number.isFinite(Number(value));
+const clampPercent = (value) => Math.max(0, Math.min(100, Number(value)));
+const keyFor = (window) => `codex:${Number(window.windowSeconds) || "limit"}`;
+function observeQuotaForecast(state, windows, now = Date.now()) {
+	const next = { windows: { ...state?.windows ?? {} } };
+	let changed = false;
+	for (const window of windows ?? []) {
+		if (!finite(window?.remainingPercent)) continue;
+		const key = keyFor(window);
+		const resetsAt = finite(window.resetsAt) ? Number(window.resetsAt) : null;
+		const remainingPercent = Math.round(clampPercent(window.remainingPercent) * 1e4) / 1e4;
+		const previous = next.windows[key];
+		const resetChanged = previous !== void 0 && (previous.resetsAt === null !== (resetsAt === null) || previous.resetsAt !== null && Math.abs(previous.resetsAt - resetsAt) > 300);
+		const last = previous?.samples?.at(-1);
+		const quotaIncreased = last !== void 0 && remainingPercent > last.remainingPercent + .5;
+		const record = resetChanged || quotaIncreased ? {
+			resetsAt,
+			samples: []
+		} : {
+			resetsAt,
+			samples: [...previous?.samples ?? []]
+		};
+		const latest = record.samples.at(-1);
+		if (latest === void 0 || now > latest.at && (Math.abs(remainingPercent - latest.remainingPercent) >= .001 || now - latest.at >= PLATEAU_SAMPLE_MS)) {
+			record.samples.push({
+				at: now,
+				remainingPercent
+			});
+			record.samples = record.samples.filter((sample) => sample.at >= now - HISTORY_MS).slice(-192);
+			changed = true;
+		}
+		next.windows[key] = record;
+	}
+	return {
+		state: next,
+		changed
+	};
+}
+function estimateQuotaForecast(state, window, now = Date.now()) {
+	if (!finite(window?.remainingPercent)) return { status: "calibrating" };
+	const record = state?.windows?.[keyFor(window)];
+	if (record === void 0) return { status: "calibrating" };
+	const resetsAt = finite(window.resetsAt) ? Number(window.resetsAt) : null;
+	if (record.resetsAt === null !== (resetsAt === null) || resetsAt !== null && Math.abs(record.resetsAt - resetsAt) > 300) return { status: "calibrating" };
+	const samples = record.samples.filter((sample) => sample.at >= now - HISTORY_MS && sample.at <= now + 6e4);
+	if (samples.length < 3) return {
+		status: "calibrating",
+		sampleCount: samples.length
+	};
+	const first = samples[0];
+	const last = samples.at(-1);
+	const spanMs = last.at - first.at;
+	const consumedPercent = Math.max(0, first.remainingPercent - last.remainingPercent);
+	if (spanMs < MIN_SPAN_MS || consumedPercent < MIN_CONSUMED_PERCENT) return {
+		status: "calibrating",
+		sampleCount: samples.length,
+		observedSpanMs: spanMs,
+		consumedPercent
+	};
+	const firstAt = first.at;
+	const weighted = samples.map((sample) => ({
+		x: (sample.at - firstAt) / HOUR_MS,
+		y: first.remainingPercent - sample.remainingPercent,
+		weight: Math.exp((sample.at - last.at) / (6 * HOUR_MS))
+	}));
+	const totalWeight = weighted.reduce((sum, point) => sum + point.weight, 0);
+	const meanX = weighted.reduce((sum, point) => sum + point.x * point.weight, 0) / totalWeight;
+	const meanY = weighted.reduce((sum, point) => sum + point.y * point.weight, 0) / totalWeight;
+	const numerator = weighted.reduce((sum, point) => sum + point.weight * (point.x - meanX) * (point.y - meanY), 0);
+	const denominator = weighted.reduce((sum, point) => sum + point.weight * (point.x - meanX) ** 2, 0);
+	const pacePerHour = denominator > 0 ? numerator / denominator : 0;
+	if (!Number.isFinite(pacePerHour) || pacePerHour < .02) return {
+		status: "idle",
+		pacePerHour: 0
+	};
+	const runwaySeconds = clampPercent(window.remainingPercent) / pacePerHour * 3600;
+	const resetSeconds = resetsAt === null ? null : Math.max(0, resetsAt - now / 1e3);
+	return {
+		status: "ready",
+		pacePerHour,
+		runwaySeconds,
+		survivesReset: resetSeconds !== null && runwaySeconds >= resetSeconds,
+		sampleCount: samples.length,
+		observedSpanMs: spanMs,
+		consumedPercent
+	};
+}
+function forecastUsage(usage, state = { windows: {} }, now = Date.now()) {
+	const observed = observeQuotaForecast(state, usage?.rateLimits?.find((limit) => limit.id === "codex")?.windows ?? [], now);
+	return {
+		state: observed.state,
+		changed: observed.changed,
+		usage: {
+			...usage,
+			rateLimits: (usage?.rateLimits ?? []).map((limit) => limit.id !== "codex" ? limit : {
+				...limit,
+				windows: limit.windows.map((window) => ({
+					...window,
+					forecast: estimateQuotaForecast(observed.state, window, now)
+				}))
+			})
+		}
+	};
+}
+function createQuotaForecastReader({ reader, enabled, now = Date.now }) {
+	let state = { windows: {} };
+	return Object.freeze({
+		async read(options) {
+			const usage = await reader.read(options);
+			if (!enabled()) {
+				state = { windows: {} };
+				return usage;
+			}
+			const forecast = forecastUsage(usage, state, now());
+			state = forecast.state;
+			return forecast.usage;
+		},
+		clear() {
+			state = { windows: {} };
+			reader.clear();
+		}
+	});
+}
+//#endregion
 //#region src/reset-credits.js
 const CODEX_RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
 const CODEX_RESET_CONSUME_URL = `${CODEX_RESET_CREDITS_URL}/consume`;
@@ -1783,8 +2371,22 @@ const publicError = (code, message) => ({
 		details: { issues: [] }
 	}
 });
-function createSubscriptionRpcHandler({ authHandler, usageReader, resetCreditService, preferences, diagnosticsReader }) {
+function createSubscriptionRpcHandler({ authHandler, usageReader, resetCreditService, preferences, diagnosticsReader, modelCatalog, originalImages, resolveInheritedOriginal }) {
 	return async (endpoint, payload, signal) => {
+		if (endpoint === "image/original/chunk") try {
+			signal.throwIfAborted();
+			if (typeof payload?.sessionId !== "string" || payload.sessionId.length === 0 || payload.sessionId.length > 512 || typeof payload?.assetId !== "string" || !ORIGINAL_IMAGE_ID_PATTERN.test(payload.assetId) || !Number.isSafeInteger(payload?.offset) || payload.offset < 0 || payload.offset % 4194304 !== 0) return publicError("invalid-input", "Invalid original image request");
+			const inherited = resolveInheritedOriginal?.(payload.sessionId, payload.assetId);
+			const chunk = await originalImages?.chunk(payload.sessionId, payload.assetId, payload.offset, inherited);
+			if (chunk === void 0) return publicError("not-found", "Original image is unavailable");
+			return {
+				ok: true,
+				value: chunk
+			};
+		} catch (error) {
+			if (signal.aborted) throw error;
+			return publicError("internal", "Could not read the original image");
+		}
 		if (endpoint === "diagnostics") try {
 			signal.throwIfAborted();
 			return {
@@ -1803,18 +2405,32 @@ function createSubscriptionRpcHandler({ authHandler, usageReader, resetCreditSer
 					if (![
 						"off",
 						"percent",
-						"bar"
+						"bar",
+						"forecast"
 					].includes(payload["quickQuotaMode"])) return publicError("internal", "Invalid quick quota preference");
 					patch[QUICK_QUOTA_MODE_FIELD] = payload[QUICK_QUOTA_MODE_FIELD];
 				}
 				if (Object.hasOwn(payload ?? {}, "searchProvider")) {
-					if (!["dsh", "codex"].includes(payload["searchProvider"])) return publicError("internal", "Invalid search provider preference");
+					if (![
+						"auto",
+						"dsh",
+						"codex"
+					].includes(payload["searchProvider"])) return publicError("internal", "Invalid search provider preference");
 					patch[SEARCH_PROVIDER_FIELD] = payload[SEARCH_PROVIDER_FIELD];
 				}
 				if (Object.hasOwn(payload ?? {}, "speedMode")) {
 					if (!["standard", "fast"].includes(payload["speedMode"])) return publicError("internal", "Invalid speed mode preference");
 					patch[SPEED_MODE_FIELD] = payload[SPEED_MODE_FIELD];
 				}
+				if (Object.hasOwn(payload ?? {}, "outputVerbosity")) {
+					if (![
+						"default",
+						"low",
+						"medium",
+						"high"
+					].includes(payload["outputVerbosity"])) return publicError("internal", "Invalid output verbosity preference");
+					patch[OUTPUT_VERBOSITY_FIELD] = payload[OUTPUT_VERBOSITY_FIELD];
+				}
 				if (Object.hasOwn(payload ?? {}, "contextMode")) {
 					if (![
 						"standard",
@@ -1890,37 +2506,56 @@ function createSubscriptionRpcHandler({ authHandler, usageReader, resetCreditSer
 		if (endpoint === "logout" && result.ok === true) {
 			usageReader.clear();
 			resetCreditService.clear();
-		}
+			modelCatalog?.clear();
+		} else if (result.ok === true && (endpoint === "status" || result.value?.authenticated === true)) modelCatalog?.refresh({ signal: void 0 }).catch(() => {});
 		return result;
 	};
 }
 function createSearchProviderSwitcher(loader) {
 	const webEntry = () => [...loader.entries()].find((entry) => entry.options?.id === WEB_ENTRY_ID);
-	return Object.freeze({ async select(selection) {
-		const entry = webEntry();
-		const fiber = entry?.fiber;
-		if (entry === void 0 || fiber === void 0 || typeof fiber.update !== "function") throw new Error("DSH web runtime is unavailable");
-		const baseConfig = entry.options?.config ?? {};
-		const currentConfig = fiber.config ?? baseConfig;
-		const dshProvider = typeof baseConfig.searchProvider === "string" && baseConfig.searchProvider.length > 0 ? baseConfig.searchProvider : DSH_SEARCH_PROVIDER_FALLBACK;
-		const provider = selection === "codex" ? CODEX_SEARCH_PROVIDER_ID : dshProvider;
-		if (currentConfig.searchProvider === provider) return;
-		await fiber.update({
-			...currentConfig,
-			searchProvider: provider
-		}, true);
-	} });
+	const dshProviderId = () => {
+		const baseConfig = webEntry()?.options?.config ?? {};
+		return typeof baseConfig.searchProvider === "string" && baseConfig.searchProvider.length > 0 ? baseConfig.searchProvider : DSH_SEARCH_PROVIDER_FALLBACK;
+	};
+	return Object.freeze({
+		dshProviderId,
+		async select(selection) {
+			const entry = webEntry();
+			const fiber = entry?.fiber;
+			if (entry === void 0 || fiber === void 0 || typeof fiber.update !== "function") throw new Error("DSH web runtime is unavailable");
+			const baseConfig = entry.options?.config ?? {};
+			const currentConfig = fiber.config ?? baseConfig;
+			const dshProvider = dshProviderId();
+			const provider = selection === "codex" ? CODEX_SEARCH_PROVIDER_ID : selection === "auto" ? CODEX_AUTO_SEARCH_PROVIDER_ID : dshProvider;
+			if (currentConfig.searchProvider === provider) return;
+			await fiber.update({
+				...currentConfig,
+				searchProvider: provider
+			}, true);
+		}
+	});
 }
 function apply(ctx) {
 	const settings = ctx.settings.register(settingsNamespace(SETTINGS_NAMESPACE), z.object({
 		[QUICK_QUOTA_MODE_FIELD]: z.union([
 			"off",
 			QUICK_QUOTA_MODE_PERCENT,
-			"bar"
+			"bar",
+			QUICK_QUOTA_MODE_FORECAST
 		]),
 		[LEGACY_QUICK_QUOTA_FIELD]: z.boolean(),
-		[SEARCH_PROVIDER_FIELD]: z.union(["dsh", SEARCH_PROVIDER_CODEX]).default("dsh"),
+		[SEARCH_PROVIDER_FIELD]: z.union([
+			SEARCH_PROVIDER_AUTO,
+			"dsh",
+			SEARCH_PROVIDER_CODEX
+		]).default(DEFAULT_SEARCH_PROVIDER),
 		[SPEED_MODE_FIELD]: z.union([SPEED_MODE_STANDARD, SPEED_MODE_FAST]).default(DEFAULT_SPEED_MODE),
+		[OUTPUT_VERBOSITY_FIELD]: z.union([
+			OUTPUT_VERBOSITY_DEFAULT,
+			"low",
+			OUTPUT_VERBOSITY_MEDIUM,
+			OUTPUT_VERBOSITY_HIGH
+		]).default(DEFAULT_OUTPUT_VERBOSITY),
 		[CONTEXT_MODE_FIELD]: z.union([
 			CONTEXT_MODE_STANDARD,
 			CONTEXT_MODE_EXTENDED,
@@ -1931,13 +2566,25 @@ function apply(ctx) {
 	}));
 	const searchProvider = createSearchProviderSwitcher(ctx.loader);
 	const network = createCodexNetworkTransport();
+	const originalImages = new OriginalImageStore();
+	const store = new DshOAuthCredentialStore(ctx.credentials, CREDENTIAL_REF, [LEGACY_CREDENTIAL_REF]);
+	const baseProvider = createOpenAICodexProvider();
+	let resolveAuth = async () => void 0;
+	const modelCatalog = createOfficialModelCatalog({
+		getAuth: (options) => resolveAuth(options),
+		readCredential: (options) => store.read(PROVIDER, options),
+		baseModels: () => baseProvider.getModels(),
+		fetch: (input, init) => network.fetch("catalog", input, init)
+	});
 	const provider = openaiCodexSubscriptionProvider({
 		resolveSpeedMode: () => settings.get()[SPEED_MODE_FIELD],
+		resolveOutputVerbosity: () => normalizeOutputVerbosity(settings.get()[OUTPUT_VERBOSITY_FIELD]),
 		resolveContextMode: () => normalizeContextMode(settings.get()[CONTEXT_MODE_FIELD]),
 		resolveCustomContextWindow: (modelKey) => {
 			const field = CUSTOM_CONTEXT_MODEL_FIELDS[modelKey];
 			return normalizeCustomContextWindow(settings.get()[field] ?? CUSTOM_CONTEXT_MODEL_DEFAULTS[modelKey], CUSTOM_CONTEXT_MODEL_CAPS[modelKey]);
 		},
+		catalog: modelCatalog,
 		runNetwork: network.run
 	});
 	const preferences = {
@@ -1945,15 +2592,16 @@ function apply(ctx) {
 			[QUICK_QUOTA_MODE_FIELD]: normalizeQuickQuotaMode(settings.get()[QUICK_QUOTA_MODE_FIELD], settings.get()[LEGACY_QUICK_QUOTA_FIELD]),
 			[SEARCH_PROVIDER_FIELD]: settings.get()[SEARCH_PROVIDER_FIELD],
 			[SPEED_MODE_FIELD]: settings.get()[SPEED_MODE_FIELD],
+			[OUTPUT_VERBOSITY_FIELD]: normalizeOutputVerbosity(settings.get()[OUTPUT_VERBOSITY_FIELD]),
 			[CONTEXT_MODE_FIELD]: normalizeContextMode(settings.get()[CONTEXT_MODE_FIELD]),
 			[CUSTOM_CONTEXT_WINDOW_FIELD]: normalizeCustomContextWindow(settings.get()[CUSTOM_CONTEXT_WINDOW_FIELD]),
 			...Object.fromEntries(Object.entries(CUSTOM_CONTEXT_MODEL_FIELDS).map(([modelKey, field]) => [field, normalizeCustomContextWindow(settings.get()[field] ?? CUSTOM_CONTEXT_MODEL_DEFAULTS[modelKey], CUSTOM_CONTEXT_MODEL_CAPS[modelKey])])),
 			contextModels: contextModelGroups(provider.getModels()),
+			verbosityModels: provider.getModels().filter((model) => modelCatalog.metadata(model.id)?.supportVerbosity ?? model.id !== "gpt-5.3-codex-spark").map((model) => model.id),
 			writable: ctx.settings.writable
 		}),
 		update: (patch) => settings.update(patch)
 	};
-	const store = new DshOAuthCredentialStore(ctx.credentials, CREDENTIAL_REF, [LEGACY_CREDENTIAL_REF]);
 	const authModels = createModels({ credentials: store });
 	authModels.setProvider(provider);
 	const profile = Object.freeze({
@@ -1971,14 +2619,18 @@ function apply(ctx) {
 	let profileKey;
 	let profileSnapshot;
 	const profiles = () => {
-		const key = [normalizeContextMode(settings.get()[CONTEXT_MODE_FIELD]), ...Object.values(CUSTOM_CONTEXT_MODEL_FIELDS).map((field) => settings.get()[field])].join(":");
+		const key = [
+			modelCatalog.revision(),
+			normalizeContextMode(settings.get()[CONTEXT_MODE_FIELD]),
+			...Object.values(CUSTOM_CONTEXT_MODEL_FIELDS).map((field) => settings.get()[field])
+		].join(":");
 		if (key !== profileKey) {
 			profileKey = key;
 			profileSnapshot = /* @__PURE__ */ new Map([[PROVIDER, profile]]);
 		}
 		return profileSnapshot;
 	};
-	const resolveAuth = () => authModels.getAuth(PROVIDER);
+	resolveAuth = () => authModels.getAuth(PROVIDER);
 	const adapterAuth = Object.freeze({
 		credentials: store,
 		authContext: Object.freeze({
@@ -1990,6 +2642,7 @@ function apply(ctx) {
 		getAuth: resolveAuth,
 		readCredential: (options) => store.read(PROVIDER, options),
 		attachments: ctx.attachments,
+		originalImages,
 		fetch: (input, init) => network.fetch("image", input, init)
 	}));
 	const adapter = new PiAiAdapter({
@@ -2009,7 +2662,7 @@ function apply(ctx) {
 	});
 	ctx.llm.registerAdapter([PROVIDER], adapter);
 	const currentAgent = () => ctx.get?.("agents")?.currentInitiator?.();
-	ctx.web.registerSearchProvider(createCodexSearchProvider({
+	const codexSearch = createCodexSearchProvider({
 		getAuth: resolveAuth,
 		readCredential: (options) => store.read(PROVIDER, options),
 		resolveModel: () => {
@@ -2018,6 +2671,12 @@ function apply(ctx) {
 		},
 		resolveSessionId: () => currentAgent()?.session.id,
 		fetch: (input, init) => network.fetch("search", input, init)
+	});
+	ctx.web.registerSearchProvider(codexSearch);
+	ctx.web.registerSearchProvider(createCodexAutoSearchProvider({
+		codex: codexSearch,
+		resolveModelProvider: () => currentAgent()?.session.requestContext?.()?.provider,
+		resolveDshProvider: () => ctx.web.searchProviders?.get(searchProvider.dshProviderId())
 	}));
 	ctx.effect(() => {
 		const select = async (value) => {
@@ -2032,10 +2691,13 @@ function apply(ctx) {
 	}, "codex-subscription: search provider selection");
 	const auth = createCodexAuthService(authModels, store, { runLogin: (operation) => network.run("login", operation) });
 	const coordinator = new CodexLoginCoordinator(auth);
-	const usageReader = createCodexUsageReader({
-		getAuth: resolveAuth,
-		readCredential: (options) => store.read(PROVIDER, options),
-		fetch: (input, init) => network.fetch("quota", input, init)
+	const usageReader = createQuotaForecastReader({
+		reader: createCodexUsageReader({
+			getAuth: resolveAuth,
+			readCredential: (options) => store.read(PROVIDER, options),
+			fetch: (input, init) => network.fetch("quota", input, init)
+		}),
+		enabled: () => normalizeQuickQuotaMode(settings.get()[QUICK_QUOTA_MODE_FIELD], settings.get()[LEGACY_QUICK_QUOTA_FIELD]) === QUICK_QUOTA_MODE_FORECAST
 	});
 	const resetCreditService = createCodexResetCreditService({
 		getAuth: resolveAuth,
@@ -2053,9 +2715,15 @@ function apply(ctx) {
 			preferences,
 			login: coordinator.supportState(),
 			network
-		})
+		}),
+		modelCatalog,
+		originalImages,
+		resolveInheritedOriginal: (sessionId, assetId) => inheritedOriginalImageRef(ctx.get?.("sessions")?.get?.(sessionId), assetId)
 	});
-	ctx.effect(() => ctx.connection.rpc.handle(CHANNEL, handler, { authority: "loopback" }), "codex-subscription: loopback account RPC");
+	ctx.effect(() => {
+		modelCatalog.refresh().catch((error) => ctx.logger?.debug?.("could not refresh Codex model catalog: %s", error.message));
+	}, "codex-subscription: official model catalog");
+	ctx.effect(() => ctx.connection.rpc.handle(CHANNEL, handler, { authority: "trusted-host" }), "codex-subscription: DSH-trusted account RPC");
 }
 //#endregion
 export { CODEX_IMAGE_GENERATION_URL, CODEX_IMAGE_TOOL_NAME, CODEX_RESET_CONSUME_URL, CODEX_RESET_CREDITS_URL, CODEX_USAGE_URL, CodexLoginCoordinator, DshOAuthCredentialStore, apply, assertCodexAuthUrl, commandForCodexAuthUrl, createCodexAuthService, createCodexImageTool, createCodexResetCreditService, createCodexRpcHandler, createCodexUsageReader, createSearchProviderSwitcher, createSubscriptionDiagnostics, createSubscriptionRpcHandler, decodeCodexPng, inject, name, normalizeContextMode, normalizeCustomContextWindow, openCodexAuthUrl, parseCodexUsage };