@eddyskywalker/dsh-chatgpt-subscription 0.10.21 → 0.11.0

package/lib/index.js

@@ -5,7 +5,7 @@ import { HarnessError, LlmAdapter, LlmError, LlmError as LlmError$1, ProviderReq
 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 { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { execSync, spawn } from "node:child_process";
 import fs$1, { appendFileSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
@@ -612,10 +612,16 @@ async function rehydrateCatalogCache(name, parseModels, accept, currentFetchedAt
 /**
 * 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`).
+* The official CLI reads it and echoes it on the SAME TURN's next request — a
+* retry, an incremental append or a continuation — and the backend uses it to
+* resume instead of re-ingesting the whole history.
+*
+* Its scope is exactly one turn. The official client builds a fresh per-turn
+* session and documents that reusing one across turns violates the
+* client/server contract and can cause routing bugs; the token is also
+* account-scoped and is discarded when auth ownership changes. It is opaque,
+* short-lived, and threaded through rather than computed (see
+* `responses-client.ts`).
 */
 const CODEX_TURN_STATE_HEADER = "x-codex-turn-state";
 function codexHeaders(credentials, sessionId, options = {}) {
@@ -630,6 +636,16 @@ function codexHeaders(credentials, sessionId, options = {}) {
 		...options.turnState ? { [CODEX_TURN_STATE_HEADER]: options.turnState } : {}
 	};
 }
+/**
+* Opaque local identity of whoever signs a request.
+*
+* Turn state is account-scoped, so the client has to detect when the signer
+* changed without ever putting that fact on the wire. The digest is computed
+* and compared locally: it is not a header, not a credential, and never logged.
+*/
+function authOwnerKey(credentials) {
+	return createHash("sha256").update(credentials.accountId ?? "").update("\0").update(credentials.accessToken).digest("hex").slice(0, 32);
+}
 function stableSessionId(value) {
 	const source = value === void 0 || value === "" ? randomUUID() : value;
 	return `dsh-${createHash("sha256").update(source).digest("hex").slice(0, 32)}`;
@@ -775,7 +791,7 @@ function parseListing(payload) {
 function parseListingEntry$1(value) {
 	const record = asRecord$10(value);
 	if (record === void 0) return [];
-	const id = asString$14(record.slug) ?? asString$14(record.id);
+	const id = asString$15(record.slug) ?? asString$15(record.id);
 	if (id === void 0) return [];
 	const contextWindow = asNumber$4(record.context_window) ?? asNumber$4(record.contextWindow);
 	const modalities = parseModalities(record.input_modalities);
@@ -783,18 +799,18 @@ function parseListingEntry$1(value) {
 	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,
+		name: asString$15(record.display_name) ?? asString$15(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
+		defaultReasoningEffort: asString$15(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);
+		const name = asString$15(item);
 		if (name === "text" || name === "image") out.push(name);
 	}
 	return out.length > 0 ? out : null;
@@ -809,7 +825,7 @@ 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);
+		const effort = asString$15(item) ?? asString$15(asRecord$10(item)?.effort);
 		if (effort !== void 0 && !out.includes(effort)) out.push(effort);
 	}
 	return out.length > 0 ? out : null;
@@ -827,7 +843,7 @@ function accountKeyFor$1(credentials) {
 function asRecord$10(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
-function asString$14(value) {
+function asString$15(value) {
 	return typeof value === "string" && value !== "" ? value : void 0;
 }
 function asNumber$4(value) {
@@ -2072,6 +2088,104 @@ function createPlatformTokenStore(platform = process.platform) {
 	throw new Error(`Unsupported platform ${platform}; dsh-chatgpt-subscription supports Windows, macOS, and Linux.`);
 }
 //#endregion
+//#region src/host/common/concurrency-gate.ts
+var ConcurrencyGate = class {
+	held = /* @__PURE__ */ new Map();
+	queues = /* @__PURE__ */ new Map();
+	limits = /* @__PURE__ */ new Map();
+	/**
+	* Record the concurrency limit for one account.
+	*
+	* A non-positive or non-finite limit clears the cap, which is the same as
+	* never having set one: requests then pass through unbounded rather than
+	* being blocked by a value nobody verified.
+	*/
+	setLimit(accountId, limit) {
+		if (!Number.isFinite(limit) || limit <= 0) {
+			this.limits.delete(accountId);
+			this.drain(accountId);
+			return;
+		}
+		this.limits.set(accountId, Math.max(1, Math.floor(limit)));
+		this.drain(accountId);
+	}
+	/** Limit currently in force for one account, or undefined when uncapped. */
+	limitFor(accountId) {
+		return this.limits.get(accountId);
+	}
+	/** Requests currently in flight for one account. */
+	inFlight(accountId) {
+		return this.held.get(accountId) ?? 0;
+	}
+	/**
+	* Take one slot, waiting for it when the account is at its limit.
+	*
+	* The returned function releases the slot and is safe to call more than once:
+	* a double release on an aborted request must not hand a stranger a slot that
+	* this holder never had.
+	*/
+	async acquire(accountId, signal) {
+		if (signal?.aborted === true) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+		const limit = this.limits.get(accountId);
+		const current = this.held.get(accountId) ?? 0;
+		if (limit === void 0 || current < limit) return this.take(accountId);
+		await new Promise((resolve, reject) => {
+			const queue = this.queues.get(accountId) ?? [];
+			const waiter = { resolve: () => {
+				remove();
+				resolve();
+			} };
+			const onAbort = () => {
+				remove();
+				reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+			};
+			const remove = () => {
+				const index = queue.indexOf(waiter);
+				if (index !== -1) queue.splice(index, 1);
+				if (queue.length === 0) this.queues.delete(accountId);
+				signal?.removeEventListener("abort", onAbort);
+			};
+			queue.push(waiter);
+			this.queues.set(accountId, queue);
+			signal?.addEventListener("abort", onAbort, { once: true });
+		});
+		const release = this.releaseFn(accountId);
+		if (signal?.aborted) {
+			release();
+			throw signal.reason ?? new DOMException("Aborted", "AbortError");
+		}
+		return release;
+	}
+	take(accountId) {
+		this.held.set(accountId, (this.held.get(accountId) ?? 0) + 1);
+		return this.releaseFn(accountId);
+	}
+	releaseFn(accountId) {
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			const next = (this.held.get(accountId) ?? 1) - 1;
+			if (next <= 0) this.held.delete(accountId);
+			else this.held.set(accountId, next);
+			this.drain(accountId);
+		};
+	}
+	/** Hand slots to as many waiters as the current limit allows. */
+	drain(accountId) {
+		const queue = this.queues.get(accountId);
+		if (queue === void 0 || queue.length === 0) return;
+		const limit = this.limits.get(accountId);
+		const room = limit === void 0 ? queue.length : limit - (this.held.get(accountId) ?? 0);
+		for (let index = 0; index < room && queue.length > 0; index++) {
+			const waiter = queue.shift();
+			this.held.set(accountId, (this.held.get(accountId) ?? 0) + 1);
+			waiter.resolve();
+		}
+		if (queue.length === 0) this.queues.delete(accountId);
+	}
+};
+//#endregion
 //#region src/host/callback-server.ts
 /** One-shot localhost OAuth callback listener. */
 var OAuthCallbackServer = class {
@@ -2750,6 +2864,17 @@ function parseCodexPoolData(value) {
 * hooks the core cannot know — how to refresh one account's tokens and which
 * accounts a cached quota window already rules out.
 */
+/**
+* Per-account in-flight requests, shared by every ChatGPT request this host
+* makes. A fan-out of subagents is what reaches a plan's concurrency bound, so
+* the bound is enforced here rather than discovered by cooling every account at
+* once. Limits are learned from upstream evidence (see
+* {@link CodexAccountPool.noteConcurrencySignal}), never assumed.
+*/
+const concurrency = new ConcurrencyGate();
+function chatGPTConcurrency() {
+	return concurrency;
+}
 var CodexAccountPool = class extends AccountPoolCore {
 	refresherRef;
 	store;
@@ -3156,13 +3281,13 @@ function createCodexFetchProvider(options = {}) {
 //#region src/host/common/llm-compat.ts
 /** This package's kind in the harness message-source map. */
 const PLUGIN_MESSAGE_SOURCE_KIND = "dsh-chatgpt-subscription";
-function isRecord$23(value) {
+function isRecord$24(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** Read a message body's blocks, keeping every entry that carries a block tag. */
 function readBlocks(raw) {
 	if (!Array.isArray(raw)) return [];
-	return raw.filter((block) => isRecord$23(block) && typeof block.type === "string");
+	return raw.filter((block) => isRecord$24(block) && typeof block.type === "string");
 }
 /**
 * Normalize one harness message list into {@link Message}.
@@ -3177,10 +3302,10 @@ function readBlocks(raw) {
 function normalizeMessages(messages) {
 	const normalized = [];
 	for (const raw of messages ?? []) {
-		if (!isRecord$23(raw)) continue;
+		if (!isRecord$24(raw)) continue;
 		const content = readBlocks(raw.content);
 		if (raw.role === "tool") {
-			const source = isRecord$23(raw.source) ? raw.source : void 0;
+			const source = isRecord$24(raw.source) ? raw.source : void 0;
 			const callId = String(raw.toolCallId ?? source?.callId ?? "");
 			normalized.push({
 				id: raw.id,
@@ -3202,7 +3327,7 @@ function normalizeMessages(messages) {
 			id: raw.id,
 			role: typeof raw.role === "string" ? raw.role : "user",
 			content,
-			...isRecord$23(raw.source) ? { source: raw.source } : {}
+			...isRecord$24(raw.source) ? { source: raw.source } : {}
 		});
 	}
 	return normalized;
@@ -3744,6 +3869,666 @@ var ProxyManager = class {
 	}
 };
 //#endregion
+//#region src/host/common/model-request-control.ts
+const CONTROLLED_PROVIDERS = [
+	"codex-chatgpt",
+	"claude",
+	"antigravity",
+	"kimi-code",
+	"minimax-code",
+	"command-code",
+	"workbuddy",
+	"ollama"
+];
+/** Explicit deployment configuration. Invalid values fail closed at startup. */
+function readModelRequestLimits(env = process.env) {
+	const raw = env.DSH_PROVIDER_CONCURRENCY;
+	if (!raw) return {};
+	let value;
+	try {
+		value = JSON.parse(raw);
+	} catch {
+		throw new Error("DSH_PROVIDER_CONCURRENCY must be a JSON object");
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("DSH_PROVIDER_CONCURRENCY must be a JSON object");
+	const input = value;
+	const allowed = /* @__PURE__ */ new Set([
+		"default",
+		"queueTimeoutMs",
+		...CONTROLLED_PROVIDERS
+	]);
+	for (const key of Object.keys(input)) if (!allowed.has(key)) throw new Error("Unknown DSH_PROVIDER_CONCURRENCY field");
+	const number = (key, max) => {
+		const n = input[key];
+		if (n === void 0) return void 0;
+		if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 0 || n > max) throw new Error("Invalid DSH_PROVIDER_CONCURRENCY numeric value");
+		return n;
+	};
+	const providers = {};
+	for (const provider of CONTROLLED_PROVIDERS) {
+		const limit = number(provider, 1e4);
+		if (limit !== void 0) providers[provider] = limit;
+	}
+	return {
+		default: number("default", 1e4),
+		queueTimeoutMs: number("queueTimeoutMs", 36e5),
+		providers
+	};
+}
+/** Only generation POSTs are limited; token refresh/catalog/quota must never wait behind them. */
+function isModelRequest(input, init) {
+	if ((init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase() !== "POST") return false;
+	let path;
+	try {
+		path = new URL(input instanceof Request ? input.url : String(input)).pathname;
+	} catch {
+		return false;
+	}
+	return [
+		"/responses",
+		"/messages",
+		"/chat/completions",
+		"/api/chat"
+	].some((suffix) => path.endsWith(suffix)) || /:(?:streamGenerateContent|generateContent)$/.test(path);
+}
+/** Hold a slot until EOF, cancel, abort or failure, never merely until response headers. */
+function createControlledModelFetch(baseFetch, options) {
+	const gate = options.gate ?? new ConcurrencyGate();
+	const limit = options.limits.providers?.[options.provider] ?? options.limits.default ?? 0;
+	if (!Number.isSafeInteger(limit) || limit < 0) throw new Error("Invalid provider concurrency limit");
+	if (limit === 0) return baseFetch;
+	return async (input, init) => {
+		if (!isModelRequest(input, init)) return baseFetch(input, init);
+		const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+		const credential = headers.get("authorization") ?? headers.get("x-api-key") ?? "";
+		const key = options.provider + ":" + createHash("sha256").update(credential).digest("hex");
+		gate.setLimit(key, limit);
+		const signal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
+		const queued = new AbortController();
+		const abortQueue = () => queued.abort(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+		signal?.addEventListener("abort", abortQueue, { once: true });
+		if (signal?.aborted) abortQueue();
+		const timeout = options.limits.queueTimeoutMs ?? 12e4;
+		const timer = timeout > 0 ? setTimeout(() => queued.abort(new DOMException("Provider concurrency queue timed out", "TimeoutError")), timeout) : void 0;
+		let release;
+		try {
+			release = await gate.acquire(key, queued.signal);
+		} finally {
+			if (timer) clearTimeout(timer);
+			signal?.removeEventListener("abort", abortQueue);
+			if (gate.inFlight(key) === 0) gate.setLimit(key, 0);
+		}
+		let done = false;
+		let reader;
+		let controller;
+		const finish = () => {
+			if (done) return;
+			done = true;
+			signal?.removeEventListener("abort", abort);
+			release();
+			if (gate.inFlight(key) === 0) gate.setLimit(key, 0);
+		};
+		const abort = () => {
+			const reason = signal?.reason ?? new DOMException("Aborted", "AbortError");
+			finish();
+			if (reader) reader.cancel(reason).catch(() => void 0).finally(() => {
+				try {
+					reader?.releaseLock();
+				} catch {}
+			});
+			try {
+				controller?.error(reason);
+			} catch {}
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		try {
+			if (signal?.aborted) {
+				abort();
+				throw signal.reason ?? new DOMException("Aborted", "AbortError");
+			}
+			const response = await baseFetch(input, init);
+			if (done) {
+				response.body?.cancel().catch(() => void 0);
+				throw signal?.reason ?? new DOMException("Aborted", "AbortError");
+			}
+			if (!response.body) {
+				finish();
+				return response;
+			}
+			reader = response.body.getReader();
+			const body = new ReadableStream({
+				start(c) {
+					controller = c;
+				},
+				async pull(c) {
+					try {
+						const chunk = await reader.read();
+						if (done) return;
+						if (chunk.done) {
+							finish();
+							reader.releaseLock();
+							c.close();
+						} else c.enqueue(chunk.value);
+					} catch (error) {
+						finish();
+						try {
+							reader.releaseLock();
+						} catch {}
+						c.error(error);
+					}
+				},
+				async cancel(reason) {
+					finish();
+					try {
+						await reader.cancel(reason);
+					} finally {
+						reader.releaseLock();
+					}
+				}
+			}, { highWaterMark: 0 });
+			const wrapped = new Response(body, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers
+			});
+			for (const name of [
+				"url",
+				"redirected",
+				"type"
+			]) Object.defineProperty(wrapped, name, { value: response[name] });
+			return wrapped;
+		} catch (error) {
+			finish();
+			throw error;
+		}
+	};
+}
+//#endregion
+//#region src/host/common/request-diagnostics.ts
+/**
+* Reusable request diagnostics wrapper for model provider calls.
+*
+* Implements W5 usage, latency, and transport diagnostics:
+* - First-byte chunk latency (firstByteMs) and total duration
+* - Request payload bytes (null when unknown stream, not 0)
+* - Safe runtime-validated enum-only endpoint and provider classification
+* - Ephemeral keyed-HMAC fingerprints scoped per provider+endpoint
+* - Disjoint token usage mapping with missing vs zero differentiation and endpoint-awareness
+* - Complete SSE line and NDJSON streaming parser merging start/delta usage
+* - Stream proxy with backpressure preservation (highWaterMark: 0) and early cancel/abort
+* - Isolated failure boundary (diagnostics sink failures never break generation)
+*
+* @module dsh-chatgpt-subscription/request-diagnostics
+*/
+const DIAGNOSTIC_PROVIDERS = [
+	"codex-chatgpt",
+	"claude-subscription",
+	"antigravity",
+	"kimi-code",
+	"minimax-code",
+	"command-code",
+	"workbuddy-subscription",
+	"ollama",
+	"claude",
+	"workbuddy",
+	"codex"
+];
+const KNOWN_WIRE_ENDPOINTS = [
+	"messages",
+	"responses",
+	"chat_completions",
+	"generate_content",
+	"stream_generate_content",
+	"ollama_chat",
+	"ollama_generate",
+	"workbuddy_chat",
+	"unknown"
+];
+function isValidProvider(provider) {
+	return typeof provider === "string" && DIAGNOSTIC_PROVIDERS.includes(provider);
+}
+function isValidEndpoint(endpoint) {
+	return typeof endpoint === "string" && KNOWN_WIRE_ENDPOINTS.includes(endpoint);
+}
+const EPHEMERAL_HMAC_KEY = randomBytes(32);
+function computeHmacPrefix(data) {
+	return createHmac("sha256", EPHEMERAL_HMAC_KEY).update(data).digest("hex").slice(0, 16);
+}
+const MAX_SESSION_CACHE_SIZE = 500;
+const sessionCache = /* @__PURE__ */ new Map();
+function updateSessionFingerprints(scopedSessionKey, current) {
+	const prev = sessionCache.get(scopedSessionKey);
+	const comparison = {
+		...current,
+		authChanged: current.authFingerprint !== void 0 && prev?.authFingerprint !== void 0 ? current.authFingerprint !== prev.authFingerprint : void 0,
+		modelChanged: current.modelFingerprint !== void 0 && prev?.modelFingerprint !== void 0 ? current.modelFingerprint !== prev.modelFingerprint : void 0,
+		toolChanged: current.toolFingerprint !== void 0 && prev?.toolFingerprint !== void 0 ? current.toolFingerprint !== prev.toolFingerprint : void 0,
+		prefixChanged: current.prefixFingerprint !== void 0 && prev?.prefixFingerprint !== void 0 ? current.prefixFingerprint !== prev.prefixFingerprint : void 0
+	};
+	if (sessionCache.has(scopedSessionKey)) sessionCache.delete(scopedSessionKey);
+	else if (sessionCache.size >= MAX_SESSION_CACHE_SIZE) {
+		const oldestKey = sessionCache.keys().next().value;
+		if (oldestKey) sessionCache.delete(oldestKey);
+	}
+	sessionCache.set(scopedSessionKey, {
+		authFingerprint: current.authFingerprint ?? prev?.authFingerprint,
+		modelFingerprint: current.modelFingerprint ?? prev?.modelFingerprint,
+		toolFingerprint: current.toolFingerprint ?? prev?.toolFingerprint,
+		prefixFingerprint: current.prefixFingerprint ?? prev?.prefixFingerprint
+	});
+	return comparison;
+}
+function isDiagnosticsEnabled(options) {
+	if (options?.enabled !== void 0) return Boolean(options.enabled);
+	return process.env.DSH_PROVIDER_DIAGNOSTICS === "1";
+}
+function classifyHttpStatus(statusCode) {
+	if (statusCode === null) return "error";
+	if (statusCode >= 200 && statusCode < 300) return "2xx";
+	if (statusCode >= 300 && statusCode < 400) return "3xx";
+	if (statusCode >= 400 && statusCode < 500) return "4xx";
+	if (statusCode >= 500 && statusCode < 600) return "5xx";
+	return "error";
+}
+function isDefaultModelPath(pathname) {
+	const path = pathname.toLowerCase();
+	if (path.endsWith("/messages")) return "messages";
+	if (path.endsWith("/responses")) return "responses";
+	if (path.endsWith("/chat/completions") || path.endsWith("/chatcompletion_v2") || path.endsWith("/conversation") || path.endsWith("/latents/chat")) return "chat_completions";
+	if (path.includes(":streamgeneratecontent")) return "stream_generate_content";
+	if (path.includes(":generatecontent")) return "generate_content";
+	if (path.endsWith("/api/chat")) return "ollama_chat";
+	if (path.endsWith("/api/generate")) return "ollama_generate";
+	return null;
+}
+function getUrlAndPathname(input) {
+	let fullUrl = "";
+	if (typeof input === "string") fullUrl = input;
+	else if (input instanceof URL) fullUrl = input.toString();
+	else if (typeof input === "object" && input !== null && "url" in input) fullUrl = String(input.url);
+	try {
+		const parsed = new URL(fullUrl, "http://127.0.0.1");
+		return {
+			fullUrl,
+			pathname: parsed.pathname
+		};
+	} catch {
+		return {
+			fullUrl,
+			pathname: ""
+		};
+	}
+}
+function getHeaderValue(headers, name) {
+	if (!headers) return void 0;
+	const target = name.toLowerCase();
+	if (headers instanceof Headers) return headers.get(target) ?? void 0;
+	if (Array.isArray(headers)) {
+		for (const [key, val] of headers) if (key.toLowerCase() === target) return val;
+		return;
+	}
+	if (typeof headers === "object") {
+		for (const [key, val] of Object.entries(headers)) if (key.toLowerCase() === target) return typeof val === "string" ? val : void 0;
+	}
+}
+function measureRequestBytes(body, input, init) {
+	if (body === null || body === void 0) {
+		if (input instanceof Request && input.body) {
+			const cl = input.headers.get("content-length");
+			if (cl) {
+				const parsed = parseInt(cl, 10);
+				if (!Number.isNaN(parsed) && parsed >= 0) return parsed;
+			}
+			return null;
+		}
+		const cl = getHeaderValue(init?.headers, "content-length");
+		if (cl) {
+			const parsed = parseInt(cl, 10);
+			if (!Number.isNaN(parsed) && parsed >= 0) return parsed;
+		}
+		return 0;
+	}
+	if (typeof body === "string") return Buffer.byteLength(body, "utf-8");
+	if (body instanceof ArrayBuffer) return body.byteLength;
+	if (ArrayBuffer.isView(body)) return body.byteLength;
+	if (typeof Blob !== "undefined" && body instanceof Blob) return body.size;
+	return null;
+}
+const MAX_JSON_PARSE_BYTES = 512 * 1024;
+function extractBodyFingerprints(body) {
+	if (typeof body !== "string" || body.length > MAX_JSON_PARSE_BYTES) return {};
+	const trimmed = body.trim();
+	if (!trimmed.startsWith("{")) return {};
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		let modelFingerprint;
+		if (typeof parsed.model === "string" && parsed.model) modelFingerprint = computeHmacPrefix(parsed.model);
+		let toolFingerprint;
+		if (Array.isArray(parsed.tools)) toolFingerprint = computeHmacPrefix(JSON.stringify(parsed.tools));
+		let prefixFingerprint;
+		let prefixCandidate = "";
+		if (typeof parsed.instructions === "string" && parsed.instructions) prefixCandidate = parsed.instructions;
+		else if (typeof parsed.system === "string" && parsed.system) prefixCandidate = parsed.system;
+		else if (Array.isArray(parsed.system) && parsed.system.length > 0) prefixCandidate = JSON.stringify(parsed.system);
+		else if (Array.isArray(parsed.messages) && parsed.messages.length > 0) {
+			const first = parsed.messages[0];
+			if (first && typeof first === "object") {
+				const f = first;
+				if (f.role === "system" || f.role === "developer") prefixCandidate = typeof f.content === "string" ? f.content : JSON.stringify(f.content);
+				else prefixCandidate = JSON.stringify(f);
+			}
+		}
+		if (prefixCandidate) prefixFingerprint = computeHmacPrefix(prefixCandidate);
+		return {
+			modelFingerprint,
+			toolFingerprint,
+			prefixFingerprint
+		};
+	} catch {
+		return {};
+	}
+}
+function parseFiniteNonNegativeNumber(val) {
+	if (typeof val === "number") {
+		if (Number.isFinite(val) && val >= 0) return Math.floor(val);
+		return;
+	}
+	if (typeof val === "string" && val.trim() !== "") {
+		const num = Number(val);
+		if (Number.isFinite(num) && num >= 0) return Math.floor(num);
+	}
+}
+function parseUsageObject(raw, endpoint) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+	const r = raw;
+	const totalInput = parseFiniteNonNegativeNumber(r.prompt_tokens) ?? parseFiniteNonNegativeNumber(r.input_tokens);
+	const outputTokens = parseFiniteNonNegativeNumber(r.completion_tokens) ?? parseFiniteNonNegativeNumber(r.output_tokens);
+	const totalTokens = parseFiniteNonNegativeNumber(r.total_tokens);
+	const inputDetails = typeof r.prompt_tokens_details === "object" && r.prompt_tokens_details !== null ? r.prompt_tokens_details : typeof r.input_tokens_details === "object" && r.input_tokens_details !== null ? r.input_tokens_details : null;
+	const outputDetails = typeof r.completion_tokens_details === "object" && r.completion_tokens_details !== null ? r.completion_tokens_details : typeof r.output_tokens_details === "object" && r.output_tokens_details !== null ? r.output_tokens_details : null;
+	const cacheRead = parseFiniteNonNegativeNumber(inputDetails?.cached_tokens) ?? parseFiniteNonNegativeNumber(r.cache_read_input_tokens) ?? parseFiniteNonNegativeNumber(r.cache_read_tokens);
+	const cacheWrite = parseFiniteNonNegativeNumber(inputDetails?.cache_write_tokens) ?? parseFiniteNonNegativeNumber(r.cache_creation_input_tokens) ?? parseFiniteNonNegativeNumber(r.cache_write_tokens);
+	const reasoning = parseFiniteNonNegativeNumber(outputDetails?.reasoning_tokens) ?? parseFiniteNonNegativeNumber(r.reasoning_tokens);
+	if (totalInput === void 0 && outputTokens === void 0 && totalTokens === void 0 && cacheRead === void 0 && cacheWrite === void 0) return;
+	let disjointInput;
+	if (totalInput !== void 0) if (endpoint === "messages") disjointInput = totalInput;
+	else disjointInput = Math.max(0, totalInput - (cacheRead ?? 0) - (cacheWrite ?? 0));
+	return {
+		...disjointInput !== void 0 ? { inputTokens: disjointInput } : {},
+		...outputTokens !== void 0 ? { outputTokens } : {},
+		...cacheRead !== void 0 ? { cacheReadTokens: cacheRead } : {},
+		...cacheWrite !== void 0 ? { cacheWriteTokens: cacheWrite } : {},
+		...reasoning !== void 0 ? { reasoningTokens: reasoning } : {},
+		...totalTokens !== void 0 ? { totalTokens } : {}
+	};
+}
+function mergeUsage(target, source) {
+	if (!target) return source ? { ...source } : void 0;
+	if (!source) return target ? { ...target } : void 0;
+	return {
+		inputTokens: source.inputTokens ?? target.inputTokens,
+		outputTokens: source.outputTokens ?? target.outputTokens,
+		cacheReadTokens: source.cacheReadTokens ?? target.cacheReadTokens,
+		cacheWriteTokens: source.cacheWriteTokens ?? target.cacheWriteTokens,
+		reasoningTokens: source.reasoningTokens ?? target.reasoningTokens,
+		totalTokens: source.totalTokens ?? target.totalTokens
+	};
+}
+const MAX_LINE_BUFFER_BYTES = 64 * 1024;
+var StreamingUsageParser = class {
+	endpoint;
+	lineBuffer = "";
+	accumulatedUsage;
+	constructor(endpoint) {
+		this.endpoint = endpoint;
+	}
+	droppingLine = false;
+	feed(chunkText) {
+		let start = 0;
+		while (start < chunkText.length) {
+			const newline = chunkText.indexOf("\n", start);
+			const end = newline === -1 ? chunkText.length : newline;
+			if (!this.droppingLine) if (this.lineBuffer.length + end - start > MAX_LINE_BUFFER_BYTES) {
+				this.lineBuffer = "";
+				this.droppingLine = true;
+			} else this.lineBuffer += chunkText.slice(start, end);
+			if (newline === -1) break;
+			if (!this.droppingLine) this.processLine(this.lineBuffer.trim());
+			this.lineBuffer = "";
+			this.droppingLine = false;
+			start = newline + 1;
+		}
+	}
+	flush() {
+		const trailing = this.lineBuffer.trim();
+		if (trailing) {
+			this.processLine(trailing);
+			this.lineBuffer = "";
+		}
+		return this.accumulatedUsage;
+	}
+	processLine(line) {
+		let payload = line;
+		if (payload.startsWith("data:")) payload = payload.slice(5).trim();
+		if (!payload || payload === "[DONE]") return;
+		if (!payload.startsWith("{")) return;
+		try {
+			const parsed = JSON.parse(payload);
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+			if (parsed.type === "message_start" && parsed.message && typeof parsed.message === "object") {
+				const msg = parsed.message;
+				if (msg.usage) {
+					const parsedUsage = parseUsageObject(msg.usage, this.endpoint);
+					this.accumulatedUsage = mergeUsage(this.accumulatedUsage, parsedUsage);
+					return;
+				}
+			}
+			if (parsed.type === "message_delta" && parsed.usage) {
+				const parsedUsage = parseUsageObject(parsed.usage, this.endpoint);
+				this.accumulatedUsage = mergeUsage(this.accumulatedUsage, parsedUsage);
+				return;
+			}
+			if (parsed.done === true) {
+				const promptEval = parseFiniteNonNegativeNumber(parsed.prompt_eval_count);
+				const evalCount = parseFiniteNonNegativeNumber(parsed.eval_count);
+				if (promptEval !== void 0 || evalCount !== void 0) {
+					const ollamaUsage = {
+						...promptEval !== void 0 ? { inputTokens: promptEval } : {},
+						...evalCount !== void 0 ? { outputTokens: evalCount } : {},
+						...promptEval !== void 0 && evalCount !== void 0 ? { totalTokens: promptEval + evalCount } : {}
+					};
+					this.accumulatedUsage = mergeUsage(this.accumulatedUsage, ollamaUsage);
+					return;
+				}
+			}
+			const rawUsage = parsed.usage ?? (parsed.response && typeof parsed.response === "object" ? parsed.response.usage : void 0) ?? (parsed.message && typeof parsed.message === "object" ? parsed.message.usage : void 0);
+			if (rawUsage && typeof rawUsage === "object") {
+				const parsedUsage = parseUsageObject(rawUsage, this.endpoint);
+				this.accumulatedUsage = mergeUsage(this.accumulatedUsage, parsedUsage);
+			}
+		} catch {}
+	}
+};
+/**
+* Creates a diagnostic wrapper around fetch for model requests.
+*/
+function createDiagnosticFetch(baseFetch, options) {
+	return async function diagnosticFetch(input, init) {
+		if (!isDiagnosticsEnabled(options)) return baseFetch(input, init);
+		if ((init?.method ?? (input instanceof Request ? input.method : typeof input === "object" && input !== null && "method" in input ? String(input.method) : "GET")).toUpperCase() !== "POST") return baseFetch(input, init);
+		const { fullUrl, pathname } = getUrlAndPathname(input);
+		const rawEndpoint = options?.endpoint ?? (options?.classifyEndpoint ? options.classifyEndpoint(fullUrl, pathname) : isDefaultModelPath(pathname));
+		if (!rawEndpoint || !isValidEndpoint(rawEndpoint)) return baseFetch(input, init);
+		const endpoint = rawEndpoint;
+		const candidateProvider = options?.provider ?? "codex-chatgpt";
+		if (!isValidProvider(candidateProvider)) return baseFetch(input, init);
+		const provider = candidateProvider;
+		const requestBytes = measureRequestBytes(init?.body, input, init);
+		const startTime = performance.now();
+		const authHeader = getHeaderValue(init?.headers, "authorization") ?? getHeaderValue(init?.headers, "x-api-key") ?? (input instanceof Request ? input.headers.get("authorization") ?? input.headers.get("x-api-key") ?? void 0 : void 0);
+		const authFingerprint = authHeader ? computeHmacPrefix(authHeader) : void 0;
+		const sessionRaw = options?.correlation?.sessionId ?? getHeaderValue(init?.headers, "x-session-id") ?? getHeaderValue(init?.headers, "session_id") ?? (input instanceof Request ? input.headers.get("x-session-id") ?? input.headers.get("session_id") ?? void 0 : void 0);
+		const scopedSessionKey = sessionRaw ? computeHmacPrefix(provider + ":" + endpoint + ":" + sessionRaw) : void 0;
+		let retries;
+		if (typeof options?.correlation?.retryCount === "number") retries = options.correlation.retryCount;
+		else {
+			const retryHeader = getHeaderValue(init?.headers, "x-retry-count") ?? getHeaderValue(init?.headers, "retry-count") ?? (input instanceof Request ? input.headers.get("x-retry-count") ?? input.headers.get("retry-count") ?? void 0 : void 0);
+			if (retryHeader) {
+				const parsed = parseInt(retryHeader, 10);
+				if (!Number.isNaN(parsed)) retries = parsed;
+			}
+		}
+		const currentFingerprints = {
+			authFingerprint,
+			...extractBodyFingerprints(init?.body ?? (input instanceof Request ? void 0 : void 0))
+		};
+		let fingerprints;
+		if (scopedSessionKey) fingerprints = updateSessionFingerprints(scopedSessionKey, currentFingerprints);
+		else if (currentFingerprints.authFingerprint || currentFingerprints.modelFingerprint || currentFingerprints.toolFingerprint || currentFingerprints.prefixFingerprint) fingerprints = { ...currentFingerprints };
+		const signal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
+		let firstByteMs = null;
+		let emitted = false;
+		const usageParser = new StreamingUsageParser(endpoint);
+		const decoder = new TextDecoder("utf-8", { fatal: false });
+		function emitRecord(outcome, statusCode) {
+			if (emitted) return;
+			emitted = true;
+			const durationMs = Math.max(0, Math.round(performance.now() - startTime));
+			const usage = outcome === "completed" ? usageParser.flush() : void 0;
+			const record = {
+				provider,
+				endpoint,
+				requestBytes,
+				firstByteMs,
+				ttftMs: null,
+				durationMs,
+				statusCode,
+				statusClass: classifyHttpStatus(statusCode),
+				outcome,
+				...usage !== void 0 ? { usage } : {},
+				...retries !== void 0 ? { retries } : {},
+				...fingerprints !== void 0 ? { fingerprints } : {}
+			};
+			try {
+				const res = options?.onRecord?.(record);
+				if (res && typeof res.catch === "function") res.catch(() => {});
+			} catch {}
+		}
+		let response;
+		try {
+			response = await baseFetch(input, init);
+		} catch (error) {
+			emitRecord(Boolean(signal?.aborted) || error instanceof Error && error.name === "AbortError" ? "canceled" : "error", null);
+			throw error;
+		}
+		if (signal?.aborted) {
+			const reason = signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+			emitRecord("canceled", response.status);
+			if (response.body) try {
+				const r = response.body.getReader();
+				await r.cancel(reason);
+				r.releaseLock();
+			} catch {}
+			throw reason;
+		}
+		if (response.body === null || response.status === 204 || response.status === 304) {
+			emitRecord(response.ok ? "completed" : "error", response.status);
+			return response;
+		}
+		const reader = response.body.getReader();
+		let streamClosed = false;
+		let controllerRef;
+		const cleanup = () => {
+			streamClosed = true;
+			if (signal) try {
+				signal.removeEventListener("abort", abortListener);
+			} catch {}
+		};
+		const abortListener = () => {
+			if (streamClosed) return;
+			cleanup();
+			const reason = signal?.reason ?? new DOMException("The operation was aborted.", "AbortError");
+			emitRecord("canceled", response.status);
+			try {
+				controllerRef?.error(reason);
+			} catch {}
+			reader.cancel(reason).catch(() => {}).finally(() => {
+				try {
+					reader.releaseLock();
+				} catch {}
+			});
+		};
+		if (signal) signal.addEventListener("abort", abortListener, { once: true });
+		const wrappedBody = new ReadableStream({
+			start(controller) {
+				controllerRef = controller;
+			},
+			async pull(controller) {
+				try {
+					const { done, value } = await reader.read();
+					if (done) {
+						cleanup();
+						try {
+							reader.releaseLock();
+						} catch {}
+						emitRecord("completed", response.status);
+						controller.close();
+						return;
+					}
+					if (value && value.byteLength > 0) {
+						if (firstByteMs === null) firstByteMs = Math.max(0, Math.round(performance.now() - startTime));
+						const text = decoder.decode(value, { stream: true });
+						if (text) usageParser.feed(text);
+					}
+					controller.enqueue(value);
+				} catch (err) {
+					cleanup();
+					try {
+						reader.releaseLock();
+					} catch {}
+					emitRecord(Boolean(signal?.aborted) || err instanceof Error && err.name === "AbortError" ? "canceled" : "error", response.status);
+					controller.error(err);
+				}
+			},
+			async cancel(reason) {
+				cleanup();
+				emitRecord("canceled", response.status);
+				try {
+					await reader.cancel(reason);
+				} finally {
+					try {
+						reader.releaseLock();
+					} catch {}
+				}
+			}
+		}, { highWaterMark: 0 });
+		const wrappedResponse = new Response(wrappedBody, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		});
+		try {
+			Object.defineProperty(wrappedResponse, "url", {
+				value: response.url,
+				writable: false,
+				configurable: true
+			});
+			Object.defineProperty(wrappedResponse, "redirected", {
+				value: response.redirected,
+				writable: false,
+				configurable: true
+			});
+			Object.defineProperty(wrappedResponse, "type", {
+				value: response.type,
+				writable: false,
+				configurable: true
+			});
+		} catch {}
+		return wrappedResponse;
+	};
+}
+//#endregion
 //#region src/host/antigravity/types.ts
 const PROVIDER_NAME$6 = "Antigravity";
 const PROVIDER_ID$6 = "antigravity";
@@ -5265,7 +6050,7 @@ 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. */
+/** Cap on live turns whose routing state is remembered at once. */
 const MAX_TRACKED_TURN_STATES = 200;
 var ResponsesClient = class {
 	oauth;
@@ -5277,13 +6062,20 @@ var ResponsesClient = class {
 	reasoningSummary;
 	accountPool;
 	/**
-	* Opaque backend turn state, keyed by conversation session id.
+	* Opaque backend routing state, keyed by a unique model-request nonce.
+	* The host does not expose a reliable human-turn identity, so this is the
+	* conservative no-cross-request-reuse fallback, not full turn continuity.
 	*
 	* 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.
+	* expects it on the next request of the SAME turn, which lets it resume the
+	* turn instead of re-ingesting the whole history.
+	*
+	* It is a client/server contract with a one-turn scope: the official client
+	* creates a fresh per-turn session and warns that replaying the token across
+	* turns breaks routing. The value is also account-scoped, so each entry
+	* records the auth owner that minted it and is discarded when the signer
+	* changes. It is only ever an optimization, so a miss costs a full resend and
+	* never correctness.
 	*/
 	turnStates = /* @__PURE__ */ new Map();
 	constructor(oauth, attachments, options = {}) {
@@ -5302,13 +6094,17 @@ var ResponsesClient = class {
 		const options = normalizeGenerateOptions(rawOptions);
 		const hiddenSandboxControls = hiddenSandboxControlToolNames(options);
 		const sessionId = stableSessionId(options.sessionId);
+		const turnKey = turnKeyFor(sessionId);
 		let currentModel = options.model;
 		let attemptOptions = options;
 		let response;
+		let release;
 		while (true) {
 			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);
+				const opened = await this.send(payload, sessionId, turnKey, options.signal);
+				response = opened.response;
+				release = opened.release;
 				break;
 			} catch (error) {
 				if (error instanceof LlmError && (error.code === "NOT_FOUND" || error.status === 404)) {
@@ -5328,42 +6124,47 @@ var ResponsesClient = class {
 		try {
 			yield* wrapStreamWithWatchdog((watchdogSignal) => parseResponsesStream(response, watchdogSignal, hiddenSandboxControls), options.signal, 3e5, "LLM_STREAM_IDLE_TIMEOUT", "Codex");
 		} finally {
+			this.turnStates.delete(turnKey);
+			release?.();
 			this.onGenerationFinished();
 		}
 	}
-	async send(payload, sessionId, signal) {
-		if (this.accountPool !== null) return this.sendWithPool(payload, sessionId, signal);
+	async send(payload, sessionId, turnKey, signal) {
+		if (this.accountPool !== null) return this.sendWithPool(payload, sessionId, turnKey, signal);
 		let credentials = await this.oauth.credentials();
-		let response = await this.request(payload, credentials, sessionId, signal);
+		let response = await this.request(payload, credentials, sessionId, turnKey, signal);
 		if (response.status === 401) {
 			await response.body?.cancel().catch(() => void 0);
 			credentials = await this.oauth.credentials(true);
-			response = await this.request(payload, credentials, sessionId, signal);
+			response = await this.request(payload, credentials, sessionId, turnKey, signal);
 		}
 		if (!response.ok) throw await responseError(response);
-		this.rememberTurnState(response, sessionId);
-		return response;
+		this.rememberTurnState(response, turnKey, credentials);
+		return { response };
 	}
 	/**
-	* Record the turn state a response carried, for the next turn of this session.
+	* Record the routing state a response carried, for this turn's next request.
 	*
 	* 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) {
+	rememberTurnState(response, turnKey, credentials) {
 		const next = response.headers.get(CODEX_TURN_STATE_HEADER)?.trim();
-		if (next === void 0 || next === "") this.turnStates.delete(sessionId);
-		else this.storeTurnState(sessionId, next);
+		if (next === void 0 || next === "") this.turnStates.delete(turnKey);
+		else this.storeTurnState(turnKey, next, credentials);
 	}
 	/**
-	* 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.
+	* Bounded store: a long-lived host serves many sessions and turns, and nothing
+	* here ever signals that either ended, so the map is capped and evicts the
+	* oldest entry. The value is an optimization, so a miss only costs a resend.
 	*/
-	storeTurnState(sessionId, value) {
-		this.turnStates.delete(sessionId);
-		this.turnStates.set(sessionId, value);
+	storeTurnState(turnKey, value, credentials) {
+		this.turnStates.delete(turnKey);
+		this.turnStates.set(turnKey, {
+			value,
+			owner: authOwnerKey(credentials)
+		});
 		while (this.turnStates.size > MAX_TRACKED_TURN_STATES) {
 			const oldest = this.turnStates.keys().next();
 			if (oldest.done === true) break;
@@ -5371,6 +6172,23 @@ var ResponsesClient = class {
 		}
 	}
 	/**
+	* Routing state this turn may replay, or undefined.
+	*
+	* A token minted by a different auth owner is dropped rather than sent: the
+	* value is account-scoped, and sending it to another account is at best a
+	* routing hint for the wrong machine and at worst a replay of state that
+	* account never issued. Dropping it only costs a full resend.
+	*/
+	turnStateFor(turnKey, credentials) {
+		const entry = this.turnStates.get(turnKey);
+		if (entry === void 0) return void 0;
+		if (entry.owner !== authOwnerKey(credentials)) {
+			this.turnStates.delete(turnKey);
+			return;
+		}
+		return entry.value;
+	}
+	/**
 	* Send one payload with account rotation.
 	*
 	* The pool picks the account — skipping cooling, quota-exhausted and failed
@@ -5380,48 +6198,72 @@ var ResponsesClient = class {
 	* refresh is rejected leaves the rotation instead of invalidating the others.
 	* The payload is account-independent, so it is never rebuilt between attempts.
 	*/
-	async sendWithPool(payload, sessionId, signal) {
+	/** What one pool attempt produced, including the account that served it. */
+	async sendWithPool(payload, sessionId, turnKey, signal) {
 		const pool = this.accountPool;
 		const tried = /* @__PURE__ */ new Set();
 		while (true) {
-			const { account, credentials } = await pool.getEffectiveAccount(tried, this.fetchFn);
+			const selected = await pool.getEffectiveAccount(tried, this.fetchFn);
+			const account = selected.account;
+			let credentials = selected.credentials;
 			tried.add(account.id);
-			let response = await this.request(payload, credentials, sessionId, signal);
-			if (response.status === 401) {
-				await response.body?.cancel().catch(() => void 0);
-				try {
-					const refreshed = await pool.refreshAccountNow(account.id);
-					response = await this.request(payload, refreshed, sessionId, signal);
-				} catch (error) {
-					await pool.markAuthFailed(account.id, error instanceof Error ? error.message : "ChatGPT sign-in expired.").catch(() => void 0);
+			const release = await chatGPTConcurrency().acquire(account.id, signal);
+			let held = true;
+			const free = () => {
+				if (!held) return;
+				held = false;
+				release();
+			};
+			try {
+				let response = await this.request(payload, credentials, sessionId, turnKey, signal);
+				if (response.status === 401) {
+					await response.body?.cancel().catch(() => void 0);
+					try {
+						credentials = await pool.refreshAccountNow(account.id);
+						response = await this.request(payload, credentials, sessionId, turnKey, signal);
+					} catch (error) {
+						await pool.markAuthFailed(account.id, error instanceof Error ? error.message : "ChatGPT sign-in expired.").catch(() => void 0);
+						free();
+						if (await pool.hasAnotherAvailableAccount(tried)) continue;
+						throw new LlmError("ChatGPT sign-in has expired. Sign in again.", "AUTH", {
+							status: 401,
+							cause: error
+						});
+					}
+				}
+				if (response.status === 429) {
+					const after = retryAfterMs$1(response.headers);
+					await response.body?.cancel().catch(() => void 0);
+					await pool.markCooldown(account.id, after ?? DEFAULT_POOL_COOLDOWN_MS, "Codex 429").catch(() => void 0);
+					free();
 					if (await pool.hasAnotherAvailableAccount(tried)) continue;
-					throw new LlmError("ChatGPT sign-in has expired. Sign in again.", "AUTH", {
-						status: 401,
-						cause: error
+					throw new LlmError("Codex rate limit reached.", "RATE_LIMIT", {
+						status: 429,
+						...after === void 0 ? {} : { providerRetryAfterMs: after }
 					});
 				}
+				if (!response.ok) {
+					const error = await responseError(response);
+					free();
+					throw error;
+				}
+				this.rememberTurnState(response, turnKey, credentials);
+				return {
+					response,
+					release: free
+				};
+			} catch (error) {
+				free();
+				throw error;
 			}
-			if (response.status === 429) {
-				const after = retryAfterMs$1(response.headers);
-				await response.body?.cancel().catch(() => void 0);
-				await pool.markCooldown(account.id, after ?? DEFAULT_POOL_COOLDOWN_MS, "Codex 429").catch(() => void 0);
-				if (await pool.hasAnotherAvailableAccount(tried)) continue;
-				throw new LlmError("Codex rate limit reached.", "RATE_LIMIT", {
-					status: 429,
-					...after === void 0 ? {} : { providerRetryAfterMs: after }
-				});
-			}
-			if (!response.ok) throw await responseError(response);
-			this.rememberTurnState(response, sessionId);
-			return response;
 		}
 	}
-	async request(payload, credentials, sessionId, signal) {
+	async request(payload, credentials, sessionId, turnKey, signal) {
 		try {
 			return await this.fetchFn(CODEX_RESPONSES_URL, {
 				method: "POST",
 				headers: {
-					...codexHeaders(credentials, sessionId, { turnState: this.turnStates.get(sessionId) }),
+					...codexHeaders(credentials, sessionId, { turnState: this.turnStateFor(turnKey, credentials) }),
 					"content-type": "application/json",
 					accept: "text/event-stream"
 				},
@@ -5445,6 +6287,16 @@ var ResponsesClient = class {
 function promptCacheKeyFor(sessionId) {
 	return sessionId;
 }
+/** Request-local fallback; never infer a human turn identity from message history. */
+function turnKeyFor(sessionId) {
+	return `${sessionId}#${createHash("sha256").update(sessionId).update("\0").update(String(perRequestNonce())).digest("hex").slice(0, 24)}`;
+}
+/** A value no two requests in this process share. */
+let requestCounter = 0;
+function perRequestNonce() {
+	requestCounter += 1;
+	return requestCounter;
+}
 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();
@@ -5750,16 +6602,28 @@ function visibleReasoningDelta(delta, currentVisibleChars, alreadyTruncated) {
 		truncated: true
 	};
 }
+/**
+* Map one response's usage onto DSH's disjoint accounting.
+*
+* `input_tokens` is the whole input, so cached input has to be subtracted out of
+* it and reported on its own field. Cache WRITES are counted separately from
+* reads and billed separately: leaving a write inside `inputTokens` would make a
+* cold prefix look cheaper than it was and hide the cost of a write. A field the
+* service omits is unknown, not zero, so it is simply not reported.
+*/
 function mapUsage(value) {
 	if (value === null) return null;
 	const totalInput = number(value.input_tokens) ?? 0;
 	const outputTokens = number(value.output_tokens) ?? 0;
-	const cached = number(record$2(value.input_tokens_details)?.cached_tokens) ?? 0;
+	const details = record$2(value.input_tokens_details);
+	const cached = number(details?.cached_tokens);
+	const written = number(details?.cache_write_tokens);
 	const reasoning = number(record$2(value.output_tokens_details)?.reasoning_tokens);
 	return {
-		inputTokens: Math.max(0, totalInput - cached),
+		inputTokens: Math.max(0, totalInput - (cached ?? 0) - (written ?? 0)),
 		outputTokens,
-		...cached > 0 ? { cacheReadTokens: cached } : {},
+		...cached === void 0 ? {} : { cacheReadTokens: cached },
+		...written === void 0 ? {} : { cacheWriteTokens: written },
 		...reasoning === void 0 ? {} : { reasoningTokens: reasoning }
 	};
 }
@@ -6661,7 +7525,7 @@ function field(value, name) {
 	const candidate = value[name];
 	return typeof candidate === "string" && candidate !== "" ? candidate : null;
 }
-function isRecord$22(value) {
+function isRecord$23(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readPreferencesUpdate(value, current) {
@@ -6695,7 +7559,7 @@ function readPreferencesUpdate(value, current) {
 		patch.searchProvider = value.searchProvider;
 	}
 	if ("contextWindowOverrides" in value) {
-		if (!isRecord$22(value.contextWindowOverrides)) throw new PreferenceError("contextWindowOverrides must be an object.");
+		if (!isRecord$23(value.contextWindowOverrides)) throw new PreferenceError("contextWindowOverrides must be an object.");
 		const overrides = {};
 		for (const [model, contextWindow] of Object.entries(value.contextWindowOverrides)) {
 			if (!isCodexModelId(model)) throw new PreferenceError("Unknown Codex model for a context window override.");
@@ -7567,7 +8431,7 @@ const schemaFields = /* @__PURE__ */ new Set([
 	"required",
 	"propertyOrdering"
 ]);
-function isRecord$21(value) {
+function isRecord$22(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function mergeSchemas(left, right) {
@@ -7575,7 +8439,7 @@ function mergeSchemas(left, right) {
 		...left,
 		...right
 	};
-	if (isRecord$21(left.properties) && isRecord$21(right.properties)) merged.properties = {
+	if (isRecord$22(left.properties) && isRecord$22(right.properties)) merged.properties = {
 		...left.properties,
 		...right.properties
 	};
@@ -7583,7 +8447,7 @@ function mergeSchemas(left, right) {
 	return merged;
 }
 function toAntigravityToolSchema(schema) {
-	if (!isRecord$21(schema)) return schema;
+	if (!isRecord$22(schema)) return schema;
 	const root = schema;
 	function resolveReference(reference) {
 		let target = root;
@@ -7591,13 +8455,13 @@ function toAntigravityToolSchema(schema) {
 		const path = reference === "#" ? [] : reference.slice(2).split("/");
 		for (const segment of path) {
 			const key = segment.replace(/~1/g, "/").replace(/~0/g, "~");
-			target = isRecord$21(target) && Object.hasOwn(target, key) ? target[key] : void 0;
+			target = isRecord$22(target) && Object.hasOwn(target, key) ? target[key] : void 0;
 		}
-		if (!isRecord$21(target)) throw new LlmError(`Antigravity tool schema reference was not found: ${reference}`, "PROVIDER_ERROR");
+		if (!isRecord$22(target)) throw new LlmError(`Antigravity tool schema reference was not found: ${reference}`, "PROVIDER_ERROR");
 		return target;
 	}
 	function convert(node, references) {
-		if (!isRecord$21(node)) return {};
+		if (!isRecord$22(node)) return {};
 		let inherited = {};
 		if (typeof node.$ref === "string") {
 			if (references.has(node.$ref)) throw new LlmError(`Antigravity tool schema contains a recursive reference: ${node.$ref}`, "PROVIDER_ERROR");
@@ -7606,8 +8470,8 @@ function toAntigravityToolSchema(schema) {
 		if (Array.isArray(node.allOf)) for (const branch of node.allOf) inherited = mergeSchemas(inherited, convert(branch, references));
 		const out = {};
 		for (const [key, value] of Object.entries(node)) if (schemaFields.has(key)) out[key] = value;
-		if (isRecord$21(node.properties)) out.properties = Object.fromEntries(Object.entries(node.properties).map(([name, child]) => [name, convert(child, references)]));
-		if (isRecord$21(node.items)) out.items = convert(node.items, references);
+		if (isRecord$22(node.properties)) out.properties = Object.fromEntries(Object.entries(node.properties).map(([name, child]) => [name, convert(child, references)]));
+		if (isRecord$22(node.items)) out.items = convert(node.items, references);
 		const alternatives = Array.isArray(node.anyOf) ? node.anyOf : node.oneOf;
 		if (Array.isArray(alternatives)) out.anyOf = alternatives.map((child) => convert(child, references));
 		if (Array.isArray(node.type)) {
@@ -7635,10 +8499,10 @@ let toolCallCounter = 0;
 function sanitizeText$5(text) {
 	return text.replace(/\0/g, "");
 }
-function isRecord$20(value) {
+function isRecord$21(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function asString$13(value) {
+function asString$14(value) {
 	return typeof value === "string" ? value : void 0;
 }
 function safeJsonParse$5(text) {
@@ -7654,26 +8518,26 @@ function sanitizeToolCallId(id, fallbackName) {
 function toolCallIdNeeded(modelId, runtimeModel) {
 	return modelId.startsWith("claude-") || modelId.startsWith("gpt-oss-") || runtimeModel.startsWith("claude-") || runtimeModel.startsWith("gpt-oss-");
 }
-function parseArguments(raw) {
-	if (isRecord$20(raw)) return raw;
+function parseArguments$1(raw) {
+	if (isRecord$21(raw)) return raw;
 	if (raw === void 0 || raw === null || raw === "") return {};
 	const parsed = typeof raw === "string" ? safeJsonParse$5(raw) : raw;
-	return isRecord$20(parsed) ? parsed : {};
+	return isRecord$21(parsed) ? parsed : {};
 }
 const NO_RESOLVED_IMAGES$5 = /* @__PURE__ */ new Map();
 function attachmentOf$5(block) {
 	const attachment = block.attachment;
-	if (!isRecord$20(attachment)) return void 0;
+	if (!isRecord$21(attachment)) return void 0;
 	return typeof attachment.attachmentId === "string" ? attachment : void 0;
 }
-function attachmentLabel$5(block) {
-	const attachment = isRecord$20(block.attachment) ? block.attachment : void 0;
-	return asString$13(attachment?.name) || asString$13(attachment?.attachmentId);
+function attachmentLabel$6(block) {
+	const attachment = isRecord$21(block.attachment) ? block.attachment : void 0;
+	return asString$14(attachment?.name) || asString$14(attachment?.attachmentId);
 }
 function collectImageRefs$4(content, refs) {
 	if (!Array.isArray(content)) return;
 	for (const block of content) {
-		if (!isRecord$20(block)) continue;
+		if (!isRecord$21(block)) continue;
 		if (block.type === "image") {
 			const attachment = attachmentOf$5(block);
 			if (attachment) refs.set(attachment.attachmentId, attachment);
@@ -7682,7 +8546,7 @@ function collectImageRefs$4(content, refs) {
 		if (block.type === "tool-result") collectImageRefs$4(block.content, refs);
 	}
 }
-function isAbort$3(error, signal) {
+function isAbort$4(error, signal) {
 	return signal?.aborted === true || error instanceof Error && error.name === "AbortError";
 }
 /**
@@ -7711,13 +8575,13 @@ function base64Length$4(bytes) {
 function requestImageBytes$4(block) {
 	const attachment = attachmentOf$5(block);
 	if (attachment) return base64Length$4(attachment.bytes);
-	const inline = asString$13(block.data) || asString$13(block.base64);
+	const inline = asString$14(block.data) || asString$14(block.base64);
 	return inline ? inline.length : void 0;
 }
 function collectRequestImageBytes$4(content, lengths) {
 	if (!Array.isArray(content)) return;
 	for (const block of content) {
-		if (!isRecord$20(block) || block.type !== "image") continue;
+		if (!isRecord$21(block) || block.type !== "image") continue;
 		const bytes = requestImageBytes$4(block);
 		if (bytes !== void 0) lengths.push(bytes);
 	}
@@ -7752,7 +8616,7 @@ function offloadOldestRequestImages$4(options) {
 		if (remaining.count === 0 || !Array.isArray(message.content)) return message;
 		let replaced = false;
 		const content = message.content.map((block) => {
-			if (remaining.count === 0 || !isRecord$20(block) || block.type !== "image") return block;
+			if (remaining.count === 0 || !isRecord$21(block) || block.type !== "image") return block;
 			if (requestImageBytes$4(block) === void 0) return block;
 			remaining.count -= 1;
 			replaced = true;
@@ -7804,21 +8668,21 @@ async function resolveRequestImages$4(options, attachments, signal) {
 				data: Buffer.from(stored.data).toString("base64")
 			});
 		} catch (error) {
-			if (isAbort$3(error, signal)) throw error;
+			if (isAbort$4(error, signal)) throw error;
 			resolved.set(attachmentId, { kind: "unavailable" });
 		}
 	}));
 	return resolved;
 }
-function unavailableImageText$5(block) {
-	const label = attachmentLabel$5(block);
+function unavailableImageText$6(block) {
+	const label = attachmentLabel$6(block);
 	return `[image unavailable: ${label ? `${label} could not be read` : "the image could not be read"}; ask the user to attach it again if the image is needed]`;
 }
 function imageBlockToPart(block, images) {
-	let data = asString$13(block.data) || asString$13(block.base64);
-	const source = isRecord$20(block.source) ? block.source : void 0;
-	if (!data && source) data = asString$13(source.data) || asString$13(source.base64);
-	let mimeType = asString$13(block.mimeType) || asString$13(block.mediaType) || (source ? asString$13(source.mimeType) || asString$13(source.mediaType) : void 0) || "image/png";
+	let data = asString$14(block.data) || asString$14(block.base64);
+	const source = isRecord$21(block.source) ? block.source : void 0;
+	if (!data && source) data = asString$14(source.data) || asString$14(source.base64);
+	let mimeType = asString$14(block.mimeType) || asString$14(block.mediaType) || (source ? asString$14(source.mimeType) || asString$14(source.mediaType) : void 0) || "image/png";
 	if (data?.startsWith("data:")) {
 		const match = data.match(/^data:([^;,]+);base64,(.*)$/s);
 		if (match) {
@@ -7841,10 +8705,10 @@ function contentToUserParts(content, images) {
 	if (typeof content === "string") return [{ text: sanitizeText$5(content) }];
 	if (!Array.isArray(content)) return [];
 	const parts = [];
-	for (const block of content) if (isRecord$20(block) && block.type === "text" && typeof block.text === "string") parts.push({ text: sanitizeText$5(block.text) });
-	else if (isRecord$20(block) && block.type === "image") {
+	for (const block of content) if (isRecord$21(block) && block.type === "text" && typeof block.text === "string") parts.push({ text: sanitizeText$5(block.text) });
+	else if (isRecord$21(block) && block.type === "image") {
 		const img = imageBlockToPart(block, images);
-		parts.push(img ?? { text: unavailableImageText$5(block) });
+		parts.push(img ?? { text: unavailableImageText$6(block) });
 	}
 	return parts;
 }
@@ -7857,9 +8721,9 @@ function toolResultImageParts(blocks, images) {
 	if (!Array.isArray(blocks)) return [];
 	const parts = [];
 	for (const block of blocks) {
-		if (!isRecord$20(block)) continue;
+		if (!isRecord$21(block)) continue;
 		if (block.type === "image") {
-			parts.push(imageBlockToPart(block, images) ?? { text: unavailableImageText$5(block) });
+			parts.push(imageBlockToPart(block, images) ?? { text: unavailableImageText$6(block) });
 			continue;
 		}
 		if (block.type === "tool-result") parts.push(...toolResultImageParts(block.content, images));
@@ -7869,11 +8733,11 @@ function toolResultImageParts(blocks, images) {
 function toolResultText$5(blocks) {
 	if (!Array.isArray(blocks)) return "";
 	return blocks.map((block) => {
-		if (!isRecord$20(block)) return "";
+		if (!isRecord$21(block)) return "";
 		if (block.type === "text" && typeof block.text === "string") return sanitizeText$5(block.text);
 		if (block.type === "tool-result") return toolResultText$5(block.content);
 		if (block.type === "image") {
-			const label = attachmentLabel$5(block);
+			const label = attachmentLabel$6(block);
 			return label ? `[image: ${label}]` : "[image]";
 		}
 		return "";
@@ -7883,16 +8747,16 @@ function replayBlockFor$1(message, index) {
 	const source = message.source;
 	if (!source || source.kind !== "model" || source.provider !== "antigravity") return void 0;
 	const state = source.replayState;
-	if (!isRecord$20(state)) return void 0;
+	if (!isRecord$21(state)) return void 0;
 	if (Array.isArray(state.blocks)) return state.blocks[index];
-	const resp = isRecord$20(state.response) ? state.response : void 0;
+	const resp = isRecord$21(state.response) ? state.response : void 0;
 	if (resp) {
 		if (Array.isArray(resp.outputItems)) return resp.outputItems[index];
 		if (Array.isArray(resp.blocks)) return resp.blocks[index];
 	}
 }
 function thoughtSignature(part) {
-	return asString$13(part?.thoughtSignature) || asString$13(part?.thought_signature) || asString$13(part?.thinkingSignature) || asString$13(part?.textSignature);
+	return asString$14(part?.thoughtSignature) || asString$14(part?.thought_signature) || asString$14(part?.thinkingSignature) || asString$14(part?.textSignature);
 }
 function replayPart(part) {
 	const copy = { ...part };
@@ -7908,10 +8772,10 @@ function assistantParts(message, model, runtimeModel, toolCalls) {
 	if (!Array.isArray(message.content)) return parts;
 	for (let index = 0; index < message.content.length; index++) {
 		const block = message.content[index];
-		if (!isRecord$20(block)) continue;
+		if (!isRecord$21(block)) continue;
 		const replay = replayBlockFor$1(message, index);
-		const originalParts = Array.isArray(replay?.parts) ? replay.parts.filter(isRecord$20) : [];
-		if ((block.type === "text" || block.type === "reasoning") && originalParts.length > 0 && originalParts.every((part) => !part.functionCall) && originalParts.map((part) => asString$13(part.text) || "").join("") === sanitizeText$5(String(block.text || ""))) {
+		const originalParts = Array.isArray(replay?.parts) ? replay.parts.filter(isRecord$21) : [];
+		if ((block.type === "text" || block.type === "reasoning") && originalParts.length > 0 && originalParts.every((part) => !part.functionCall) && originalParts.map((part) => asString$14(part.text) || "").join("") === sanitizeText$5(String(block.text || ""))) {
 			parts.push(...originalParts.map(replayPart));
 			continue;
 		}
@@ -7931,8 +8795,8 @@ function assistantParts(message, model, runtimeModel, toolCalls) {
 		} else if (block.type === "tool-call") {
 			const toolId = String(block.id || "");
 			const toolName = String(block.name || "");
-			const originalCall = originalParts.find((part) => isRecord$20(part.functionCall));
-			const wireId = asString$13((isRecord$20(originalCall?.functionCall) ? originalCall.functionCall : void 0)?.id) || (toolCallIdNeeded(model.id, runtimeModel) ? sanitizeToolCallId(toolId, toolName) : originalCall ? void 0 : toolId || void 0);
+			const originalCall = originalParts.find((part) => isRecord$21(part.functionCall));
+			const wireId = asString$14((isRecord$21(originalCall?.functionCall) ? originalCall.functionCall : void 0)?.id) || (toolCallIdNeeded(model.id, runtimeModel) ? sanitizeToolCallId(toolId, toolName) : originalCall ? void 0 : toolId || void 0);
 			toolCalls.set(toolId, {
 				name: toolName,
 				id: wireId
@@ -7941,7 +8805,7 @@ function assistantParts(message, model, runtimeModel, toolCalls) {
 			parts.push({
 				functionCall: {
 					name: toolName,
-					args: parseArguments(block.arguments),
+					args: parseArguments$1(block.arguments),
 					...wireId ? { id: wireId } : {}
 				},
 				...effectiveSignature ? { thoughtSignature: effectiveSignature } : {}
@@ -7984,7 +8848,7 @@ function convertMessages(options, model, runtimeModel, images = NO_RESOLVED_IMAG
 			continue;
 		}
 		const content = Array.isArray(message.content) ? message.content : [];
-		const userParts = contentToUserParts(content.filter((b) => !isRecord$20(b) || b.type !== "tool-result"), images);
+		const userParts = contentToUserParts(content.filter((b) => !isRecord$21(b) || b.type !== "tool-result"), images);
 		if (role === "system") {
 			if (userParts.length) contents.push({
 				role: GEMINI_ROLE.user,
@@ -7996,7 +8860,7 @@ function convertMessages(options, model, runtimeModel, images = NO_RESOLVED_IMAG
 			role: GEMINI_ROLE.user,
 			parts: userParts
 		});
-		for (const b of content) if (isRecord$20(b) && b.type === "tool-result") pushToolResult(contents, b, toolCalls, model, runtimeModel, images);
+		for (const b of content) if (isRecord$21(b) && b.type === "tool-result") pushToolResult(contents, b, toolCalls, model, runtimeModel, images);
 	}
 	return contents;
 }
@@ -8119,7 +8983,7 @@ const USAGE_FIELDS = [
 	"totalTokenCount"
 ];
 function collectUsage(value, state) {
-	if (!isRecord$20(value)) return;
+	if (!isRecord$21(value)) return;
 	for (const key of USAGE_FIELDS) {
 		const count = value[key];
 		if (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0) continue;
@@ -8149,15 +9013,15 @@ function processStreamLine$2(line, state) {
 	}
 	if (!json) return [];
 	const chunk = safeJsonParse$5(json);
-	if (!isRecord$20(chunk)) return [];
-	const responseData = isRecord$20(chunk.response) ? chunk.response : chunk;
+	if (!isRecord$21(chunk)) return [];
+	const responseData = isRecord$21(chunk.response) ? chunk.response : chunk;
 	const candidates = Array.isArray(responseData.candidates) ? responseData.candidates : [];
-	const candidate = isRecord$20(candidates[0]) ? candidates[0] : void 0;
-	const content = isRecord$20(candidate?.content) ? candidate.content : void 0;
+	const candidate = isRecord$21(candidates[0]) ? candidates[0] : void 0;
+	const content = isRecord$21(candidate?.content) ? candidate.content : void 0;
 	const parts = Array.isArray(content?.parts) ? content.parts : [];
 	const out = [];
 	for (const part of parts) {
-		if (!isRecord$20(part)) continue;
+		if (!isRecord$21(part)) continue;
 		if (typeof part.text === "string" && part.text !== "") {
 			const isThinking = Boolean(part.thought);
 			const blockType = isThinking ? "reasoning" : "text";
@@ -8189,7 +9053,7 @@ function processStreamLine$2(line, state) {
 				index: state.currentBlock.index,
 				text: delta
 			});
-		} else if (!isRecord$20(part.functionCall) && thoughtSignature(part)) {
+		} else if (!isRecord$21(part.functionCall) && thoughtSignature(part)) {
 			if (state.replayBlocks.length === 0) {
 				const type = part.thought ? "reasoning" : "text";
 				state.blocks.push({
@@ -8213,12 +9077,12 @@ function processStreamLine$2(line, state) {
 			}
 			state.replayBlocks[state.replayBlocks.length - 1].parts.push(replayPart(part));
 		}
-		if (isRecord$20(part.functionCall)) {
+		if (isRecord$21(part.functionCall)) {
 			out.push(...closeCurrentBlock(state));
 			const fc = part.functionCall;
-			const toolName = asString$13(fc.name) || "";
-			const toolId = asString$13(fc.id) || sanitizeToolCallId("", toolName);
-			const argsText = JSON.stringify(isRecord$20(fc.args) ? fc.args : {});
+			const toolName = asString$14(fc.name) || "";
+			const toolId = asString$14(fc.id) || sanitizeToolCallId("", toolName);
+			const argsText = JSON.stringify(isRecord$21(fc.args) ? fc.args : {});
 			const index = state.blocks.length;
 			const block = {
 				type: "tool-call",
@@ -8255,7 +9119,7 @@ function processStreamLine$2(line, state) {
 	}
 	collectUsage(chunk.usageMetadata, state);
 	if (responseData !== chunk) collectUsage(responseData.usageMetadata, state);
-	const finishReason = asString$13(candidate?.finishReason) || asString$13(responseData.finishReason);
+	const finishReason = asString$14(candidate?.finishReason) || asString$14(responseData.finishReason);
 	if (finishReason) {
 		state.finishReason = finishReason;
 		out.push(...closeCurrentBlock(state));
@@ -9909,6 +10773,7 @@ const CALLBACK_ALLOWED_ORIGINS = [
 	"http://localhost:3000"
 ];
 const DISCOVERY_TIMEOUT_MS$3 = 15e3;
+const CATALOG_CACHE_TTL_MS$3 = 1800 * 1e3;
 const STREAM_IDLE_TIMEOUT_MS$4 = 3e5;
 const STREAM_IDLE_TIMEOUT_CODE$4 = "LLM_STREAM_IDLE_TIMEOUT";
 /**
@@ -9925,6 +10790,8 @@ const HEADER_PROJECT_SLUG = "x-command-code-project-slug";
 const HEADER_TASTE_LEARNING = "x-command-code-taste-learning";
 const HEADER_SESSION_ID = "x-command-code-session-id";
 const HEADER_OSS_PRIMARY_PROVIDER = "x-command-code-oss-primary-provider";
+/** Official header that enforces Zero Data Retention (ZDR) routing. */
+const HEADER_ZDR = "x-cmd-zdr";
 function resolveApiEnv(raw = process.env.DSH_COMMAND_CODE_ENV) {
 	const value = (raw || "").trim().toLowerCase();
 	return value === "staging" || value === "local" ? value : "prod";
@@ -9952,6 +10819,21 @@ function wireForModel$2(modelId) {
 	return /^claude[-/]/i.test(modelId.trim()) ? "anthropic" : "openai";
 }
 /**
+* Wire one catalog entry says it is served on, when the catalog said so.
+*
+* The provider publishes `supported_endpoints` per model, and that is the
+* authority on which route answers for it. A model the catalog does not describe
+* returns undefined so the caller falls back to {@link wireForModel} instead of
+* being sent to a route nobody vouched for.
+*/
+function wireForCatalogEntry$1(entry) {
+	for (const endpoint of entry.supportedEndpoints ?? []) {
+		if (/\/v1\/messages\b|\bmessages\b/i.test(endpoint)) return "anthropic";
+		if (/\/v1\/responses\b|\bresponses\b/i.test(endpoint)) return "responses";
+		if (/chat\/completions|\bcompletions\b/i.test(endpoint)) return "openai";
+	}
+}
+/**
 * Reasoning levels one model advertises, in DSH's vocabulary.
 *
 * The registry is the authority: a model it describes but gives no
@@ -10457,13 +11339,13 @@ function commandCodeHeaders(apiKey, extra = {}) {
 function timeoutSignal$3(signal, ms) {
 	return signal ? AbortSignal.any([signal, AbortSignal.timeout(ms)]) : AbortSignal.timeout(ms);
 }
-function isRecord$19(value) {
+function isRecord$20(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asRecord$9(value) {
-	return isRecord$19(value) ? value : void 0;
+	return isRecord$20(value) ? value : void 0;
 }
-function asString$12(value) {
+function asString$13(value) {
 	if (typeof value === "string" && value.trim() !== "") return value;
 	if (typeof value === "number" && Number.isFinite(value)) return String(value);
 }
@@ -10476,10 +11358,19 @@ function asNumber$3(value) {
 }
 function firstString$1(record, keys) {
 	for (const key of keys) {
-		const value = asString$12(record[key]);
+		const value = asString$13(record[key]);
 		if (value !== void 0) return value;
 	}
 }
+/** First key that holds a non-empty array of strings. */
+function firstStringArray(record, keys) {
+	for (const key of keys) {
+		const value = record[key];
+		if (!Array.isArray(value)) continue;
+		const entries = value.filter((entry) => typeof entry === "string" && entry !== "");
+		if (entries.length > 0) return entries;
+	}
+}
 function firstNumber$2(record, keys) {
 	for (const key of keys) {
 		const value = asNumber$3(record[key]);
@@ -10496,7 +11387,7 @@ function deepValue(value, keys, depth = 0) {
 		}
 		return;
 	}
-	if (!isRecord$19(value)) return void 0;
+	if (!isRecord$20(value)) return void 0;
 	for (const key of keys) if (value[key] !== void 0 && value[key] !== null) return value[key];
 	for (const nested of Object.values(value)) {
 		const hit = deepValue(nested, keys, depth + 1);
@@ -10510,7 +11401,7 @@ function collectRecords(value, keys, depth = 0, out = []) {
 		for (const entry of value) collectRecords(entry, keys, depth + 1, out);
 		return out;
 	}
-	if (!isRecord$19(value)) return out;
+	if (!isRecord$20(value)) return out;
 	if (keys.some((key) => value[key] !== void 0)) out.push(value);
 	for (const nested of Object.values(value)) collectRecords(nested, keys, depth + 1, out);
 	return out;
@@ -10714,7 +11605,7 @@ function parseCreditBalances(payload, consumed = []) {
 /** Resolve the plan id the subscription or credits payload reports, when either does. */
 function parsePlanId(payloads) {
 	for (const payload of payloads) {
-		const id = asString$12(deepValue(payload, [
+		const id = asString$13(deepValue(payload, [
 			"planId",
 			"plan_id",
 			"priceId",
@@ -10733,7 +11624,7 @@ function parsePlanId(payloads) {
 */
 function parseSubscriptionStatus(payload) {
 	const root = asRecord$9(payload) ?? {};
-	return asString$12(deepValue(asRecord$9(root.data) ?? root, ["status"])) ?? null;
+	return asString$13(deepValue(asRecord$9(root.data) ?? root, ["status"])) ?? null;
 }
 /** End of the current billing period, in Unix milliseconds. */
 function parseSubscriptionPeriodEnd(payload) {
@@ -10986,6 +11877,7 @@ function extractUnlimited(payload) {
 	return deepValue(payload, ["unlimited", "isUnlimited"]) === true;
 }
 let cachedCatalog$1;
+let catalogIsRehydrated = false;
 /** Bumped by every cache clear so a fetch already in flight cannot publish. */
 let catalogCacheEpoch$2 = 0;
 let catalogInFlight$2 = null;
@@ -11020,7 +11912,8 @@ function parseProviderModels(payload) {
 				"contextLength",
 				"context_window",
 				"contextWindow"
-			])
+			]),
+			...firstStringArray(record, ["supported_endpoints", "supportedEndpoints"]) === void 0 ? {} : { supportedEndpoints: firstStringArray(record, ["supported_endpoints", "supportedEndpoints"]) }
 		});
 	}
 	return models;
@@ -11067,6 +11960,7 @@ async function loadProviderModels(options = {}) {
 				models,
 				fetchedAt
 			};
+			catalogIsRehydrated = true;
 		}, 0);
 		const warm = cachedCatalog$1;
 		if (rehydratedAt > 0 && warm !== void 0) {
@@ -11088,6 +11982,7 @@ function refreshProviderModels$1(options = {}) {
 				models,
 				fetchedAt
 			};
+			catalogIsRehydrated = false;
 			writeCatalogSnapshot(catalogSnapshotName("command-code", options.apiEnv ?? resolveApiEnv()), models, fetchedAt);
 		}
 		return models.length > 0 ? models : cachedCatalog$1?.models ?? [];
@@ -11097,10 +11992,19 @@ function refreshProviderModels$1(options = {}) {
 		if (catalogInFlight$2 === request) catalogInFlight$2 = null;
 	});
 }
+function isCatalogStale() {
+	if (cachedCatalog$1 === void 0) return true;
+	if (catalogIsRehydrated) return true;
+	return Date.now() - cachedCatalog$1.fetchedAt >= CATALOG_CACHE_TTL_MS$3;
+}
+function getCachedCatalogFetchedAt() {
+	return cachedCatalog$1?.fetchedAt ?? null;
+}
 function clearCachedCatalog$3() {
 	catalogCacheEpoch$2 += 1;
 	cachedCatalog$1 = void 0;
 	catalogInFlight$2 = null;
+	catalogIsRehydrated = false;
 	catalogSnapshotScopesLoaded$2.clear();
 }
 async function getJson(path, apiKey, options = {}) {
@@ -11256,7 +12160,7 @@ function buildModelOptions$2(catalog, enabledModelIds, overrides) {
 			contextWindow: overrides[model.id] && overrides[model.id] > 0 ? overrides[model.id] : contextWindow,
 			defaultMaxTokens: maxOutputTokensFor$4(model.id),
 			...efforts.length > 0 ? { reasoningEfforts: efforts } : {},
-			wire: wireForModel$2(model.id)
+			wire: wireForCatalogEntry$1(model) ?? wireForModel$2(model.id)
 		};
 	});
 }
@@ -11272,10 +12176,10 @@ function buildModelOptions$2(catalog, enabledModelIds, overrides) {
 *
 * https://commandcode.ai/blog/command-code-provider-api
 */
-function isRecord$18(value) {
+function isRecord$19(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function asString$11(value) {
+function asString$12(value) {
 	return typeof value === "string" ? value : void 0;
 }
 function safeJsonParse$4(text) {
@@ -11288,7 +12192,7 @@ function safeJsonParse$4(text) {
 function sanitizeText$4(text) {
 	return text.replace(/\0/g, "");
 }
-function isAbort$2(error, signal) {
+function isAbort$3(error, signal) {
 	return signal?.aborted === true || error instanceof Error && error.name === "AbortError";
 }
 const NO_RESOLVED_IMAGES$4 = /* @__PURE__ */ new Map();
@@ -11312,17 +12216,17 @@ const SUPPORTED_IMAGE_MEDIA_TYPES$4 = /* @__PURE__ */ new Set([
 ]);
 function attachmentOf$4(block) {
 	const attachment = block.attachment;
-	if (!isRecord$18(attachment)) return void 0;
+	if (!isRecord$19(attachment)) return void 0;
 	return typeof attachment.attachmentId === "string" ? attachment : void 0;
 }
-function attachmentLabel$4(block) {
-	const attachment = isRecord$18(block.attachment) ? block.attachment : void 0;
-	return asString$11(attachment?.name) || asString$11(attachment?.attachmentId);
+function attachmentLabel$5(block) {
+	const attachment = isRecord$19(block.attachment) ? block.attachment : void 0;
+	return asString$12(attachment?.name) || asString$12(attachment?.attachmentId);
 }
 function collectImageRefs$3(content, refs) {
 	if (!Array.isArray(content)) return;
 	for (const block of content) {
-		if (!isRecord$18(block)) continue;
+		if (!isRecord$19(block)) continue;
 		if (block.type === "image") {
 			const attachment = attachmentOf$4(block);
 			if (attachment) refs.set(attachment.attachmentId, attachment);
@@ -11337,13 +12241,13 @@ function base64Length$3(bytes) {
 function requestImageBytes$3(block) {
 	const attachment = attachmentOf$4(block);
 	if (attachment) return base64Length$3(attachment.bytes);
-	const inline = asString$11(block.data) || asString$11(block.base64);
+	const inline = asString$12(block.data) || asString$12(block.base64);
 	return inline ? inline.length : void 0;
 }
 function collectRequestImageBytes$3(content, lengths) {
 	if (!Array.isArray(content)) return;
 	for (const block of content) {
-		if (!isRecord$18(block) || block.type !== "image") continue;
+		if (!isRecord$19(block) || block.type !== "image") continue;
 		const bytes = requestImageBytes$3(block);
 		if (bytes !== void 0) lengths.push(bytes);
 	}
@@ -11370,7 +12274,7 @@ function offloadOldestRequestImages$3(options) {
 		if (remaining.count === 0 || !Array.isArray(message.content)) return message;
 		let replaced = false;
 		const content = message.content.map((block) => {
-			if (remaining.count === 0 || !isRecord$18(block) || block.type !== "image") return block;
+			if (remaining.count === 0 || !isRecord$19(block) || block.type !== "image") return block;
 			if (requestImageBytes$3(block) === void 0) return block;
 			remaining.count -= 1;
 			replaced = true;
@@ -11412,21 +12316,21 @@ async function resolveRequestImages$3(options, attachments, signal) {
 				data: Buffer.from(stored.data).toString("base64")
 			});
 		} catch (error) {
-			if (isAbort$2(error, signal)) throw error;
+			if (isAbort$3(error, signal)) throw error;
 			resolved.set(attachmentId, { kind: "unavailable" });
 		}
 	}));
 	return resolved;
 }
-function unavailableImageText$4(block) {
-	const label = attachmentLabel$4(block);
+function unavailableImageText$5(block) {
+	const label = attachmentLabel$5(block);
 	return `[image unavailable: ${label ? `${label} could not be read` : "the image could not be read"}; ask the user to attach it again if the image is needed]`;
 }
 function imageBlockToInline$3(block, images) {
-	let data = asString$11(block.data) || asString$11(block.base64);
-	const source = isRecord$18(block.source) ? block.source : void 0;
-	if (!data && source) data = asString$11(source.data) || asString$11(source.base64);
-	let mediaType = asString$11(block.mimeType) || asString$11(block.mediaType) || (source ? asString$11(source.mimeType) || asString$11(source.mediaType) : void 0) || "image/png";
+	let data = asString$12(block.data) || asString$12(block.base64);
+	const source = isRecord$19(block.source) ? block.source : void 0;
+	if (!data && source) data = asString$12(source.data) || asString$12(source.base64);
+	let mediaType = asString$12(block.mimeType) || asString$12(block.mediaType) || (source ? asString$12(source.mimeType) || asString$12(source.mediaType) : void 0) || "image/png";
 	if (data?.startsWith("data:")) {
 		const matched = data.match(/^data:([^;,]+);base64,(.*)$/s);
 		if (matched) {
@@ -11450,7 +12354,7 @@ function textOf$5(content) {
 	if (!Array.isArray(content)) return "";
 	const parts = [];
 	for (const block of content) {
-		if (!isRecord$18(block)) continue;
+		if (!isRecord$19(block)) continue;
 		if (block.type === "text" && typeof block.text === "string") parts.push(sanitizeText$4(block.text));
 		else if (block.type === "tool-result") parts.push(textOf$5(block.content));
 	}
@@ -11459,10 +12363,10 @@ function textOf$5(content) {
 function toolResultText$4(blocks) {
 	if (!Array.isArray(blocks)) return "";
 	return blocks.map((block) => {
-		if (!isRecord$18(block)) return "";
+		if (!isRecord$19(block)) return "";
 		if (block.type === "text" && typeof block.text === "string") return sanitizeText$4(block.text);
 		if (block.type === "tool-result") return toolResultText$4(block.content);
-		if (block.type === "image") return `[image: ${attachmentLabel$4(block) ?? "attached image"}]`;
+		if (block.type === "image") return `[image: ${attachmentLabel$5(block) ?? "attached image"}]`;
 		return "";
 	}).join("");
 }
@@ -11477,7 +12381,7 @@ function toolResultBlocks$2(blocks, images) {
 	const out = [];
 	let hasImage = false;
 	for (const block of blocks) {
-		if (!isRecord$18(block)) continue;
+		if (!isRecord$19(block)) continue;
 		if (block.type === "text" && typeof block.text === "string") {
 			out.push({
 				type: "text",
@@ -11498,7 +12402,7 @@ function toolResultBlocks$2(blocks, images) {
 			});
 			else out.push({
 				type: "text",
-				text: unavailableImageText$4(block)
+				text: unavailableImageText$5(block)
 			});
 			continue;
 		}
@@ -11526,7 +12430,7 @@ function toolResultImageBlocks$2(blocks, images) {
 	if (!Array.isArray(blocks)) return [];
 	const out = [];
 	for (const block of blocks) {
-		if (!isRecord$18(block)) continue;
+		if (!isRecord$19(block)) continue;
 		if (block.type === "image") {
 			const inline = imageBlockToInline$3(block, images);
 			if (inline && SUPPORTED_IMAGE_MEDIA_TYPES$4.has(inline.mediaType)) out.push({
@@ -11535,7 +12439,7 @@ function toolResultImageBlocks$2(blocks, images) {
 			});
 			else out.push({
 				type: "text",
-				text: unavailableImageText$4(block)
+				text: unavailableImageText$5(block)
 			});
 			continue;
 		}
@@ -11570,7 +12474,7 @@ function nonSystemMessages$4(options) {
 }
 /** Drop the JSON-Schema keywords provider gateways reject or ignore. */
 function stripMetaSchema$2(schema) {
-	if (!isRecord$18(schema)) return {
+	if (!isRecord$19(schema)) return {
 		type: "object",
 		properties: {}
 	};
@@ -11587,7 +12491,7 @@ function openAIUserContent$2(message, images) {
 	const parts = [];
 	let hasImage = false;
 	for (const block of message.content) {
-		if (!isRecord$18(block)) continue;
+		if (!isRecord$19(block)) continue;
 		if (block.type === "text" && typeof block.text === "string") {
 			const text = sanitizeText$4(block.text);
 			if (text !== "") parts.push({
@@ -11604,7 +12508,7 @@ function openAIUserContent$2(message, images) {
 				});
 			} else parts.push({
 				type: "text",
-				text: unavailableImageText$4(block)
+				text: unavailableImageText$5(block)
 			});
 		}
 	}
@@ -11615,7 +12519,7 @@ function openAIAssistantContent$2(message) {
 	const textParts = [];
 	const toolCalls = [];
 	for (const block of message.content) {
-		if (!isRecord$18(block)) continue;
+		if (!isRecord$19(block)) continue;
 		if (block.type === "text" && typeof block.text === "string") textParts.push(sanitizeText$4(block.text));
 		else if (block.type === "tool-call" && typeof block.name === "string") toolCalls.push({
 			id: typeof block.id === "string" && block.id !== "" ? block.id : `call_${toolCalls.length}`,
@@ -11647,7 +12551,7 @@ function buildOpenAIRequest$1(options, images = NO_RESOLVED_IMAGES$4) {
 			while (index < conversation.length && isToolResultMessage$4(conversation[index])) {
 				const current = conversation[index];
 				const block = current.content[0];
-				const callId = isRecord$18(block) && typeof block.toolCallId === "string" ? block.toolCallId : "";
+				const callId = isRecord$19(block) && typeof block.toolCallId === "string" ? block.toolCallId : "";
 				messages.push({
 					role: "tool",
 					tool_call_id: callId,
@@ -11708,7 +12612,7 @@ function anthropicUserContent$2(message, images) {
 	if (!Array.isArray(message.content)) return [];
 	const blocks = [];
 	for (const block of message.content) {
-		if (!isRecord$18(block)) continue;
+		if (!isRecord$19(block)) continue;
 		if (block.type === "text" && typeof block.text === "string") {
 			const text = sanitizeText$4(block.text);
 			if (text !== "") blocks.push({
@@ -11727,7 +12631,7 @@ function anthropicUserContent$2(message, images) {
 			});
 			else blocks.push({
 				type: "text",
-				text: unavailableImageText$4(block)
+				text: unavailableImageText$5(block)
 			});
 		} else if (block.type === "tool-result") {
 			const callId = typeof block.toolCallId === "string" ? block.toolCallId : "";
@@ -11745,7 +12649,7 @@ function anthropicUserContent$2(message, images) {
 function anthropicAssistantContent$2(message) {
 	const blocks = [];
 	for (const block of message.content) {
-		if (!isRecord$18(block)) continue;
+		if (!isRecord$19(block)) continue;
 		if (block.type === "text" && typeof block.text === "string") {
 			const text = sanitizeText$4(block.text);
 			if (text !== "") blocks.push({
@@ -11758,7 +12662,7 @@ function anthropicAssistantContent$2(message) {
 				type: "tool_use",
 				id: typeof block.id === "string" && block.id !== "" ? block.id : `toolu_${blocks.length}`,
 				name: block.name,
-				input: isRecord$18(parsed) ? parsed : {}
+				input: isRecord$19(parsed) ? parsed : {}
 			});
 		}
 	}
@@ -11835,7 +12739,136 @@ function buildAnthropicRequest$1(options, images = NO_RESOLVED_IMAGES$4) {
 }
 /** Build the body for whichever endpoint serves `modelId`. */
 function buildRequest$1(options, wire, images = NO_RESOLVED_IMAGES$4) {
-	return wire === "anthropic" ? buildAnthropicRequest$1(options, images) : buildOpenAIRequest$1(options, images);
+	if (wire === "anthropic") return buildAnthropicRequest$1(options, images);
+	if (wire === "responses") return buildResponsesRequest(options, images);
+	return buildOpenAIRequest$1(options, images);
+}
+/**
+* Build one `/responses` body.
+*
+* The Responses API takes a flat `input` list instead of `messages`, and its
+* reasoning and tool calls are item types rather than message fields. This is a
+* separate builder rather than a reshaping of the Chat Completions one: the two
+* APIs differ in more than field names, and a translated body is a request the
+* route rejects.
+*/
+function responsesUserContent(message, images) {
+	if (!Array.isArray(message.content)) return [];
+	const parts = [];
+	for (const block of message.content) {
+		if (!isRecord$19(block)) continue;
+		if (block.type === "text" && typeof block.text === "string") {
+			const text = sanitizeText$4(block.text);
+			if (text !== "") parts.push({
+				type: "input_text",
+				text
+			});
+		} else if (block.type === "image") {
+			const inline = imageBlockToInline$3(block, images);
+			if (inline && SUPPORTED_IMAGE_MEDIA_TYPES$4.has(inline.mediaType)) parts.push({
+				type: "input_image",
+				image_url: "data:" + inline.mediaType + ";base64," + inline.data
+			});
+			else parts.push({
+				type: "input_text",
+				text: unavailableImageText$5(block)
+			});
+		}
+	}
+	return parts;
+}
+function responsesToolResultImageBlocks(blocks, images) {
+	if (!Array.isArray(blocks)) return [];
+	const out = [];
+	for (const block of blocks) {
+		if (!isRecord$19(block)) continue;
+		if (block.type === "image") {
+			const inline = imageBlockToInline$3(block, images);
+			if (inline && SUPPORTED_IMAGE_MEDIA_TYPES$4.has(inline.mediaType)) out.push({
+				type: "input_image",
+				image_url: "data:" + inline.mediaType + ";base64," + inline.data
+			});
+			else out.push({
+				type: "input_text",
+				text: unavailableImageText$5(block)
+			});
+			continue;
+		}
+		if (block.type === "tool-result") out.push(...responsesToolResultImageBlocks(block.content, images));
+	}
+	return out;
+}
+function buildResponsesRequest(options, images = NO_RESOLVED_IMAGES$4) {
+	const input = [];
+	const system = leadingSystemText$4(options);
+	const conversation = nonSystemMessages$4(options);
+	for (let index = 0; index < conversation.length; index++) {
+		const message = conversation[index];
+		if (isToolResultMessage$4(message)) {
+			const imageBlocks = [];
+			while (index < conversation.length && isToolResultMessage$4(conversation[index])) {
+				const current = conversation[index];
+				const toolResult = Array.isArray(current.content) ? current.content.find((b) => isRecord$19(b) && b.type === "tool-result") : void 0;
+				const callId = (isRecord$19(toolResult) && typeof toolResult.toolCallId === "string" ? toolResult.toolCallId : "") || (typeof current.source?.callId === "string" ? current.source.callId : "");
+				input.push({
+					type: "function_call_output",
+					call_id: callId,
+					output: toolResultText$4(current.content)
+				});
+				imageBlocks.push(...responsesToolResultImageBlocks(current.content, images));
+				index += 1;
+			}
+			index -= 1;
+			if (imageBlocks.length > 0) input.push({
+				role: "user",
+				content: imageBlocks
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			const { content, toolCalls } = openAIAssistantContent$2(message);
+			if (content !== "") input.push({
+				role: "assistant",
+				content
+			});
+			for (const call of toolCalls) {
+				const fn = isRecord$19(call.function) ? call.function : void 0;
+				input.push({
+					type: "function_call",
+					call_id: call.id,
+					name: typeof fn?.name === "string" ? fn.name : "",
+					arguments: typeof fn?.arguments === "string" ? fn.arguments : "{}"
+				});
+			}
+			continue;
+		}
+		const content = responsesUserContent(message, images);
+		if (content.length === 0) continue;
+		input.push({
+			role: "user",
+			content
+		});
+	}
+	const effort = wireReasoningEffort(options.reasoningEffort === void 0 ? void 0 : String(options.reasoningEffort));
+	const maxTokens = options.maxTokens ?? maxOutputTokensFor$4(options.model);
+	return {
+		model: options.model,
+		input,
+		stream: true,
+		max_output_tokens: maxTokens,
+		...system === void 0 ? {} : { instructions: system },
+		...options.temperature === void 0 ? {} : { temperature: options.temperature },
+		...options.tools && options.tools.length > 0 ? {
+			tools: options.tools.map((tool) => ({
+				type: "function",
+				name: tool.name,
+				description: tool.description,
+				parameters: stripMetaSchema$2(tool.parameters)
+			})),
+			tool_choice: "auto"
+		} : {},
+		...effort === void 0 || effort === "" ? {} : { reasoning: { effort } }
+	};
 }
 function createStreamState$5(wire) {
 	return {
@@ -11922,24 +12955,24 @@ function processOpenAIStreamLine$1(line, state) {
 	}
 	if (payload === "") return [];
 	const chunk = safeJsonParse$4(payload);
-	if (!isRecord$18(chunk)) return [];
+	if (!isRecord$19(chunk)) return [];
 	const out = [];
-	const usage = isRecord$18(chunk.usage) ? chunk.usage : void 0;
+	const usage = isRecord$19(chunk.usage) ? chunk.usage : void 0;
 	if (usage) {
 		state.sawUsage = true;
 		const prompt = numberOr$5(usage.prompt_tokens, 0);
-		const details = isRecord$18(usage.prompt_tokens_details) ? usage.prompt_tokens_details : void 0;
+		const details = isRecord$19(usage.prompt_tokens_details) ? usage.prompt_tokens_details : void 0;
 		const cached = details ? numberOr$5(details.cached_tokens, 0) : 0;
 		state.inputTokens = Math.max(0, prompt - cached);
 		state.cacheReadTokens = cached;
 		state.outputTokens = numberOr$5(usage.completion_tokens, state.outputTokens);
-		if (isRecord$18(usage.completion_tokens_details)) state.reasoningTokens = numberOr$5(usage.completion_tokens_details.reasoning_tokens, state.reasoningTokens);
+		if (isRecord$19(usage.completion_tokens_details)) state.reasoningTokens = numberOr$5(usage.completion_tokens_details.reasoning_tokens, state.reasoningTokens);
 	}
 	const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
-	const choice = isRecord$18(choices[0]) ? choices[0] : void 0;
-	const delta = isRecord$18(choice?.delta) ? choice.delta : void 0;
+	const choice = isRecord$19(choices[0]) ? choices[0] : void 0;
+	const delta = isRecord$19(choice?.delta) ? choice.delta : void 0;
 	if (delta) {
-		const reasoning = asString$11(delta.reasoning_content) ?? asString$11(delta.reasoning);
+		const reasoning = asString$12(delta.reasoning_content) ?? asString$12(delta.reasoning);
 		if (reasoning !== void 0 && reasoning !== "") {
 			out.push(...closeToolCalls$4(state));
 			if (state.current === null || state.current.type !== "reasoning") out.push(...openTextBlock$3(state, "reasoning"));
@@ -11951,7 +12984,7 @@ function processOpenAIStreamLine$1(line, state) {
 				text: sanitizeText$4(reasoning)
 			});
 		}
-		const content = asString$11(delta.content);
+		const content = asString$12(delta.content);
 		if (content !== void 0 && content !== "") {
 			out.push(...closeToolCalls$4(state));
 			if (state.current === null || state.current.type !== "text") out.push(...openTextBlock$3(state, "text"));
@@ -11965,11 +12998,11 @@ function processOpenAIStreamLine$1(line, state) {
 		}
 		const toolDeltas = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
 		for (const entry of toolDeltas) {
-			if (!isRecord$18(entry)) continue;
+			if (!isRecord$19(entry)) continue;
 			out.push(...applyOpenAIToolDelta$1(entry, state));
 		}
 	}
-	const finish = asString$11(choice?.finish_reason);
+	const finish = asString$12(choice?.finish_reason);
 	if (finish !== void 0 && finish !== "") {
 		state.finishReason = finish;
 		out.push(...closeCurrent$3(state));
@@ -11979,15 +13012,15 @@ function processOpenAIStreamLine$1(line, state) {
 }
 function applyOpenAIToolDelta$1(entry, state) {
 	const wireIndex = typeof entry.index === "number" ? entry.index : 0;
-	const fn = isRecord$18(entry.function) ? entry.function : {};
+	const fn = isRecord$19(entry.function) ? entry.function : {};
 	const out = [];
 	let call = state.toolCalls.get(wireIndex);
 	if (call === void 0) {
 		out.push(...closeCurrent$3(state));
 		call = {
 			blockIndex: state.blocks.length,
-			id: asString$11(entry.id) ?? `call_${wireIndex}`,
-			name: asString$11(fn.name) ?? "",
+			id: asString$12(entry.id) ?? `call_${wireIndex}`,
+			name: asString$12(fn.name) ?? "",
 			arguments: "",
 			started: false
 		};
@@ -12000,13 +13033,13 @@ function applyOpenAIToolDelta$1(entry, state) {
 		state.toolCalls.set(wireIndex, call);
 	} else {
 		if (call.id === `call_${wireIndex}`) {
-			const id = asString$11(entry.id);
+			const id = asString$12(entry.id);
 			if (id !== void 0) call.id = id;
 		}
-		const name = asString$11(fn.name);
+		const name = asString$12(fn.name);
 		if (name !== void 0 && name !== "") call.name = name;
 	}
-	const argsDelta = asString$11(fn.arguments) ?? "";
+	const argsDelta = asString$12(fn.arguments) ?? "";
 	if (argsDelta !== "") call.arguments += argsDelta;
 	if (!call.started) {
 		call.started = true;
@@ -12037,12 +13070,12 @@ function processAnthropicStreamLine$1(line, state) {
 	const payload = trimmed.slice(5).trim();
 	if (payload === "" || payload === "[DONE]") return [];
 	const event = safeJsonParse$4(payload);
-	if (!isRecord$18(event)) return [];
-	const type = asString$11(event.type);
+	if (!isRecord$19(event)) return [];
+	const type = asString$12(event.type);
 	const out = [];
 	if (type === "message_start") {
-		const message = isRecord$18(event.message) ? event.message : void 0;
-		const usage = message && isRecord$18(message.usage) ? message.usage : void 0;
+		const message = isRecord$19(event.message) ? event.message : void 0;
+		const usage = message && isRecord$19(message.usage) ? message.usage : void 0;
 		if (usage) {
 			state.sawUsage = true;
 			state.inputTokens = numberOr$5(usage.input_tokens, 0);
@@ -12050,21 +13083,21 @@ function processAnthropicStreamLine$1(line, state) {
 			state.cacheWriteTokens = numberOr$5(usage.cache_creation_input_tokens, 0);
 			state.outputTokens = numberOr$5(usage.output_tokens, 0);
 		}
-		const stop = message ? asString$11(message.stop_reason) : void 0;
+		const stop = message ? asString$12(message.stop_reason) : void 0;
 		if (stop !== void 0 && stop !== null) state.finishReason = stop;
 		return out;
 	}
 	if (type === "content_block_start") {
 		const contentIndex = numberOr$5(event.index, 0);
-		const block = isRecord$18(event.content_block) ? event.content_block : {};
-		const blockType = asString$11(block.type);
+		const block = isRecord$19(event.content_block) ? event.content_block : {};
+		const blockType = asString$12(block.type);
 		out.push(...closeCurrent$3(state));
 		if (blockType === "tool_use") {
 			const index = state.blocks.length;
 			const pending = {
 				blockIndex: index,
-				id: asString$11(block.id) ?? `toolu_${contentIndex}`,
-				name: asString$11(block.name) ?? "",
+				id: asString$12(block.id) ?? `toolu_${contentIndex}`,
+				name: asString$12(block.name) ?? "",
 				arguments: "",
 				started: true
 			};
@@ -12106,11 +13139,11 @@ function processAnthropicStreamLine$1(line, state) {
 	}
 	if (type === "content_block_delta") {
 		const contentIndex = numberOr$5(event.index, 0);
-		const delta = isRecord$18(event.delta) ? event.delta : {};
-		const deltaType = asString$11(delta.type);
+		const delta = isRecord$19(event.delta) ? event.delta : {};
+		const deltaType = asString$12(delta.type);
 		if (deltaType === "input_json_delta") {
 			const pending = state.toolCalls.get(contentIndex);
-			const partial = asString$11(delta.partial_json) ?? "";
+			const partial = asString$12(delta.partial_json) ?? "";
 			if (pending !== void 0) {
 				pending.arguments += partial;
 				out.push({
@@ -12123,7 +13156,7 @@ function processAnthropicStreamLine$1(line, state) {
 			}
 			return out;
 		}
-		const text = deltaType === "thinking_delta" ? asString$11(delta.thinking) : asString$11(delta.text);
+		const text = deltaType === "thinking_delta" ? asString$12(delta.thinking) : asString$12(delta.text);
 		if (text !== void 0 && text !== "") {
 			const index = state.contentIndexes.get(contentIndex) ?? state.current?.index;
 			const kind = deltaType === "thinking_delta" ? "reasoning" : "text";
@@ -12179,10 +13212,10 @@ function processAnthropicStreamLine$1(line, state) {
 		return out;
 	}
 	if (type === "message_delta") {
-		const delta = isRecord$18(event.delta) ? event.delta : void 0;
-		const stop = delta ? asString$11(delta.stop_reason) : void 0;
+		const delta = isRecord$19(event.delta) ? event.delta : void 0;
+		const stop = delta ? asString$12(delta.stop_reason) : void 0;
 		if (stop !== void 0 && stop !== "") state.finishReason = stop;
-		const usage = isRecord$18(event.usage) ? event.usage : void 0;
+		const usage = isRecord$19(event.usage) ? event.usage : void 0;
 		if (usage) {
 			state.sawUsage = true;
 			state.outputTokens = numberOr$5(usage.output_tokens, state.outputTokens);
@@ -12193,7 +13226,7 @@ function processAnthropicStreamLine$1(line, state) {
 		state.done = true;
 		return closeStream$4(state);
 	}
-	if (type === "error") throw new LlmError$1(`Command Code stream error: ${asString$11((isRecord$18(event.error) ? event.error : {}).message) ?? "unknown error"}`, "PROVIDER_ERROR");
+	if (type === "error") throw new LlmError$1(`Command Code stream error: ${asString$12((isRecord$19(event.error) ? event.error : {}).message) ?? "unknown error"}`, "PROVIDER_ERROR");
 	return out;
 }
 function tokenUsage$4(state) {
@@ -12207,10 +13240,200 @@ function tokenUsage$4(state) {
 }
 function finishReasonFor$4(state) {
 	const reason = state.finishReason ?? "";
-	if (reason === "length" || reason === "max_tokens") return { kind: "max-tokens" };
+	if (reason === "length" || reason === "max_tokens" || reason === "max_output_tokens") return { kind: "max-tokens" };
 	if (state.hasToolCall || reason === "tool_calls" || reason === "tool_use") return { kind: "tool-calls" };
 	return { kind: "stop" };
 }
+/**
+* Fold one SSE line from `/responses`.
+*
+* The Responses stream is event-typed rather than delta-shaped: text arrives as
+* `response.output_text.delta`, tool calls as `function_call_arguments.delta`
+* keyed by an item id, and the turn ends on `response.completed` or
+* `response.failed`. Those are read as written; there is no Chat Completions
+* shape to reinterpret.
+*/
+function processResponsesStreamLine(line, state) {
+	const trimmed = line.trim();
+	if (trimmed === "" || !trimmed.startsWith("data:")) return [];
+	const payload = trimmed.slice(5).trim();
+	if (payload === "" || payload === "[DONE]") return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(payload);
+	} catch {
+		return [];
+	}
+	if (!isRecord$19(parsed)) return [];
+	const type = typeof parsed.type === "string" ? parsed.type : "";
+	if (type === "response.output_text.delta") {
+		const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+		if (delta === "") return [];
+		state.hasContent = true;
+		const opened = openBlock(state, "text");
+		state.current.text += delta;
+		return [...opened, {
+			type: "text-delta",
+			index: state.current.index,
+			text: delta
+		}];
+	}
+	if (type === "response.reasoning_summary_text.delta") {
+		const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+		if (delta === "") return [];
+		state.hasContent = true;
+		const opened = openBlock(state, "reasoning");
+		state.current.text += delta;
+		return [...opened, {
+			type: "reasoning-delta",
+			index: state.current.index,
+			text: delta
+		}];
+	}
+	if (type === "response.output_item.added") {
+		const item = isRecord$19(parsed.item) ? parsed.item : null;
+		if (item === null || item.type !== "function_call") return [];
+		return startResponsesToolCall(state, parsed, item);
+	}
+	if (type === "response.function_call_arguments.delta") {
+		const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+		const call = responsesToolCall(state, parsed.item_id ?? parsed.call_id);
+		if (call === void 0 || delta === "") return [];
+		call.arguments += delta;
+		return [{
+			type: "tool-call-delta",
+			index: call.blockIndex,
+			id: toToolCallId(call.id),
+			name: call.name,
+			argumentsDelta: delta
+		}];
+	}
+	if (type === "response.function_call_arguments.done") {
+		const call = responsesToolCall(state, parsed.item_id ?? parsed.call_id);
+		if (call === void 0) return [];
+		if (typeof parsed.arguments === "string") call.arguments = parsed.arguments;
+		return [];
+	}
+	if (type === "response.completed" || type === "response.incomplete") {
+		const response = isRecord$19(parsed.response) ? parsed.response : null;
+		if (response !== null) {
+			if (response.status === "failed") {
+				state.done = true;
+				const errorObj = isRecord$19(response.error) ? response.error : null;
+				const detail = errorObj && typeof errorObj.message === "string" ? errorObj.message : typeof response.error === "string" ? response.error : "";
+				throw new LlmError$1(detail === "" ? "Command Code responses stream failed" : `Command Code responses stream failed: ${detail}`, "PROVIDER_ERROR");
+			}
+			readResponsesUsage(response, state);
+		}
+		state.done = true;
+		if (type === "response.incomplete") {
+			const details = response && isRecord$19(response.incomplete_details) ? response.incomplete_details : null;
+			const reason = details && typeof details.reason === "string" ? details.reason : "";
+			state.finishReason = reason === "max_output_tokens" || reason === "length" || reason === "max_tokens" ? "length" : reason || "length";
+		} else state.finishReason = "stop";
+		return [];
+	}
+	if (type === "response.failed" || type === "error") {
+		state.done = true;
+		const errorObj = isRecord$19(parsed.error) ? parsed.error : isRecord$19(parsed.response) && isRecord$19(parsed.response.error) ? parsed.response.error : null;
+		const detail = (typeof parsed.message === "string" ? parsed.message : "") || (errorObj && typeof errorObj.message === "string" ? errorObj.message : "") || (isRecord$19(parsed.response) && typeof parsed.response.error === "string" ? parsed.response.error : typeof parsed.error === "string" ? parsed.error : "");
+		throw new LlmError$1(detail === "" ? "Command Code responses stream failed" : `Command Code responses stream failed: ${detail}`, "PROVIDER_ERROR");
+	}
+	return [];
+}
+function openBlock(state, type) {
+	if (state.current !== null && state.current.type === type) return [];
+	const out = closeCurrent$3(state);
+	state.current = {
+		index: state.blocks.length,
+		type,
+		text: ""
+	};
+	state.blocks.push({
+		type,
+		text: ""
+	});
+	out.push({
+		type: "block-start",
+		index: state.current.index,
+		blockType: type
+	});
+	return out;
+}
+function startResponsesToolCall(state, event, item) {
+	const out = closeCurrent$3(state);
+	const index = state.blocks.length;
+	const name = typeof item.name === "string" ? item.name : "";
+	const itemId = typeof item.id === "string" ? item.id : typeof event.item_id === "string" ? event.item_id : null;
+	const call = {
+		blockIndex: index,
+		id: typeof item.call_id === "string" ? item.call_id : `call_${String(itemId ?? index)}`,
+		name,
+		arguments: "",
+		started: true
+	};
+	state.blocks.push({
+		type: "tool-call",
+		id: toToolCallId(call.id),
+		name,
+		arguments: ""
+	});
+	state.toolCalls.set(index, call);
+	if (itemId !== null) responsesItemIndexOf(state).set(itemId, call);
+	state.hasToolCall = true;
+	out.push({
+		type: "block-start",
+		index,
+		blockType: "tool-call"
+	});
+	out.push({
+		type: "tool-call-delta",
+		index,
+		id: toToolCallId(call.id),
+		name,
+		argumentsDelta: ""
+	});
+	return out;
+}
+/** Item id -> call, held beside the stream state that produced it. */
+const responsesItemIndex = /* @__PURE__ */ new WeakMap();
+function responsesItemIndexOf(state) {
+	let index = responsesItemIndex.get(state);
+	if (index === void 0) {
+		index = /* @__PURE__ */ new Map();
+		responsesItemIndex.set(state, index);
+	}
+	return index;
+}
+/**
+* The call a function-arguments event refers to.
+*
+* The event carries `item_id` while the recorded call carries `call_id`, so
+* matching on the call id alone silently dropped every argument delta. The
+* call-id fallback stays for a provider that only sends one of the two.
+*/
+function responsesToolCall(state, key) {
+	if (typeof key !== "string" || key === "") return void 0;
+	const match = responsesItemIndex.get(state)?.get(key);
+	if (match !== void 0) return match;
+	for (const call of state.toolCalls.values()) if (call.id === toToolCallId(key)) return call;
+}
+function readResponsesUsage(response, state) {
+	const usage = isRecord$19(response.usage) ? response.usage : null;
+	if (usage === null) return;
+	const cached = isRecord$19(usage.input_tokens_details) ? numberOrZero(usage.input_tokens_details.cached_tokens) : 0;
+	const written = isRecord$19(usage.input_tokens_details) ? numberOrZero(usage.input_tokens_details.cache_write_tokens) : 0;
+	state.inputTokens = Math.max(0, numberOrZero(usage.input_tokens) - cached - written);
+	state.cacheReadTokens = cached;
+	state.cacheWriteTokens = written;
+	state.outputTokens = numberOrZero(usage.output_tokens);
+	const outputDetails = isRecord$19(usage.output_tokens_details) ? usage.output_tokens_details : null;
+	if (outputDetails !== null) state.reasoningTokens = numberOrZero(outputDetails.reasoning_tokens);
+	state.sawUsage = true;
+}
+function numberOrZero(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
 /** Flush every open block, then emit usage and the terminal finish. */
 function closeStream$4(state) {
 	if (state.finished) return [];
@@ -12231,6 +13454,213 @@ function assertStreamComplete$4(state) {
 	if (!state.done && state.finishReason === null) throw new LlmError$1("Command Code stream ended before its terminal event", "PROVIDER_ERROR");
 }
 //#endregion
+//#region src/host/common/capabilities.ts
+/** Error thrown by requireCapability when a capability contract fails. */
+var CapabilityError = class extends Error {
+	query;
+	evaluation;
+	constructor(message, query, evaluation) {
+		super(message);
+		this.name = "CapabilityError";
+		this.query = query;
+		this.evaluation = evaluation;
+	}
+};
+/** Known Ollama vision model prefixes per official model documentation. */
+const KNOWN_OLLAMA_VISION_PREFIXES = [
+	"llava",
+	"bakllava",
+	"llama3.2-vision",
+	"moondream",
+	"minicpm-v",
+	"qwen2.5-vl",
+	"qwen2-vl"
+];
+/**
+* Matcher for Ollama vision models, aligned with src/host/ollama/types.ts.
+* Checks exact base name before ':' or '/' to prevent partial hijacking (e.g. 'llava-evil').
+*/
+function isKnownOllamaVisionModel(modelId) {
+	const base = modelId.toLowerCase().trim().split(":")[0]?.trim() ?? "";
+	return KNOWN_OLLAMA_VISION_PREFIXES.includes(base);
+}
+/** Ollama thinking models with level control ('low'|'medium'|'high'). */
+const KNOWN_OLLAMA_THINKING_LEVELS_PREFIXES = ["gpt-oss"];
+/** Ollama thinking models with boolean control (true|false). */
+const KNOWN_OLLAMA_THINKING_BOOLEAN_PREFIXES = [
+	"deepseek-r1",
+	"qwq",
+	"qwen3"
+];
+/** Matcher for Ollama thinking models, aligned with src/host/ollama/types.ts. */
+function isKnownOllamaThinkingModel(modelId) {
+	const base = modelId.toLowerCase().trim().split(":")[0]?.trim() ?? "";
+	return KNOWN_OLLAMA_THINKING_LEVELS_PREFIXES.includes(base) || KNOWN_OLLAMA_THINKING_BOOLEAN_PREFIXES.includes(base);
+}
+/** Immutable validated capability evidence registry. */
+const CAPABILITY_EVIDENCE_REGISTRY = Object.freeze([
+	{
+		id: "ollama-native-image",
+		provider: "ollama",
+		wire: ["openai", "native"],
+		modelSelector: isKnownOllamaVisionModel,
+		authMode: "api-key",
+		capability: "native-image",
+		status: "supported",
+		evidenceLevel: "offline-contract",
+		implemented: true,
+		date: "2026-10-03",
+		testPath: "test/ollama-projection.test.ts",
+		versionTag: "0.2.0-rc.2",
+		notes: "Supported strictly for verified vision model prefixes (llava, bakllava, llama3.2-vision, moondream, minicpm-v, qwen2.5-vl, qwen2-vl). Exact boundary prevents llava-evil."
+	},
+	{
+		id: "ollama-thinking-control",
+		provider: "ollama",
+		wire: ["openai", "native"],
+		modelSelector: isKnownOllamaThinkingModel,
+		authMode: "api-key",
+		capability: "thinking-control",
+		status: "supported",
+		evidenceLevel: "offline-contract",
+		implemented: true,
+		date: "2026-10-03",
+		testPath: "test/ollama-projection.test.ts",
+		link: "https://github.com/ollama/ollama/blob/main/docs/capabilities/thinking.mdx",
+		versionTag: "0.2.0-rc.2",
+		notes: "Model-level think control for gpt-oss (levels) and deepseek-r1/qwq/qwen3 (boolean). Replay across turns remains unsupported."
+	},
+	{
+		id: "command-code-zdr",
+		provider: "command-code",
+		wire: [
+			"responses",
+			"anthropic",
+			"openai",
+			"chat-completions",
+			"messages"
+		],
+		modelSelector: "*",
+		authMode: [
+			"api-key",
+			"token",
+			"oauth"
+		],
+		capability: "zdr",
+		status: "supported",
+		evidenceLevel: "offline-contract",
+		implemented: true,
+		date: "2026-10-03",
+		testPath: "test/command-code-adapter.test.ts",
+		link: "https://github.com/CommandCodeAI/pi-commandcode-provider/blob/main/index.ts",
+		versionTag: "0.2.0-rc.2",
+		notes: "Official contract: x-cmd-zdr: 1 header active across provider wires. 422 cmd_zdr_no_providers cannot silently degrade."
+	}
+].map((r) => Object.freeze({
+	...r,
+	wire: Array.isArray(r.wire) ? Object.freeze([...r.wire]) : r.wire,
+	authMode: Array.isArray(r.authMode) ? Object.freeze([...r.authMode]) : r.authMode,
+	modelSelector: Array.isArray(r.modelSelector) ? Object.freeze([...r.modelSelector]) : r.modelSelector
+})));
+function matchesWire(expected, actual) {
+	const normActual = actual.toLowerCase().trim();
+	if (typeof expected === "string") {
+		if (expected === "*") return true;
+		return expected.toLowerCase().trim() === normActual;
+	}
+	return expected.some((w) => w.toLowerCase().trim() === normActual);
+}
+function matchesAuth(expected, actual) {
+	const normActual = actual.toLowerCase().trim();
+	if (typeof expected === "string") {
+		if (expected === "*") return true;
+		return expected.toLowerCase().trim() === normActual;
+	}
+	return expected.some((a) => a.toLowerCase().trim() === normActual);
+}
+function matchesModel(selector, model) {
+	const normModel = model.toLowerCase().trim();
+	if (typeof selector === "function") return selector(model);
+	if (typeof selector === "string") {
+		if (selector === "*") return true;
+		const normSelector = selector.toLowerCase().trim();
+		return normModel === normSelector || normModel.startsWith(normSelector + ":") || normModel.startsWith(normSelector + "/");
+	}
+	return selector.some((s) => {
+		const normS = s.toLowerCase().trim();
+		return normModel === normS || normModel.startsWith(normS + ":") || normModel.startsWith(normS + "/");
+	});
+}
+/** Query evidence records matching the given criteria. Supports optional pure registry argument for tests. */
+function queryCapabilityEvidence(query, registry = CAPABILITY_EVIDENCE_REGISTRY) {
+	return registry.filter((rec) => {
+		if (query.provider && rec.provider.toLowerCase() !== query.provider.toLowerCase().trim()) return false;
+		if (query.capability && rec.capability !== query.capability) return false;
+		if (query.wire && !matchesWire(rec.wire, query.wire)) return false;
+		if (query.authMode && !matchesAuth(rec.authMode, query.authMode)) return false;
+		if (query.model && !matchesModel(rec.modelSelector, query.model)) return false;
+		return true;
+	});
+}
+/**
+* Evaluate whether a capability is permitted for a concrete request target.
+* Fails closed if query is missing explicit fields, or lacks matching verified evidence.
+*/
+function evaluateCapability(query, registry = CAPABILITY_EVIDENCE_REGISTRY) {
+	if (!query || typeof query.provider !== "string" || !query.provider.trim() || typeof query.wire !== "string" || !query.wire.trim() || typeof query.model !== "string" || !query.model.trim() || typeof query.authMode !== "string" || !query.authMode.trim() || typeof query.capability !== "string" || !query.capability.trim()) return {
+		allowed: false,
+		state: "unknown",
+		implemented: false,
+		reason: "Capability query requires non-empty provider, wire, model, authMode, and capability"
+	};
+	const matching = queryCapabilityEvidence(query, registry);
+	if (matching.length === 0) return {
+		allowed: false,
+		state: "unknown",
+		implemented: false,
+		reason: `No matching verified evidence for ${query.provider}/${query.wire}/${query.model} (auth: ${query.authMode}, capability: ${query.capability}).`
+	};
+	const record = matching[0];
+	const isSupportedLevel = record.evidenceLevel === "live-validated" || record.evidenceLevel === "offline-contract";
+	const isAllowed = record.implemented && record.status === "supported" && isSupportedLevel;
+	return {
+		allowed: isAllowed,
+		state: record.status,
+		implemented: record.implemented,
+		evidenceLevel: record.evidenceLevel,
+		evidence: record,
+		reason: isAllowed ? void 0 : record.notes ?? `Capability '${query.capability}' is not permitted.`
+	};
+}
+/**
+* Require that a capability is supported and allowed. Throws CapabilityError otherwise.
+*/
+function requireCapability(query, registry = CAPABILITY_EVIDENCE_REGISTRY) {
+	const result = evaluateCapability(query, registry);
+	if (!result.allowed) throw new CapabilityError(`Capability requirement rejected: '${query.capability}' on ${query.provider} (${query.wire}/${query.model}, auth: ${query.authMode}): ${result.reason ?? "not permitted"}`, query, result);
+	return result;
+}
+/** Whether Ollama image input is supported for the target model. */
+function supportsOllamaImage(model, wire = "openai", authMode = "api-key") {
+	return evaluateCapability({
+		provider: "ollama",
+		wire,
+		model,
+		authMode,
+		capability: "native-image"
+	}).allowed;
+}
+/** Whether Ollama thinking control is supported for the target model. */
+function supportsOllamaThinkingControl(model, wire = "openai", authMode = "api-key") {
+	return evaluateCapability({
+		provider: "ollama",
+		wire,
+		model,
+		authMode,
+		capability: "thinking-control"
+	}).allowed;
+}
+//#endregion
 //#region src/host/command-code/adapter.ts
 /**
 * Transient-failure retry policy for the `command-code` route.
@@ -12264,6 +13694,41 @@ const RETRY_POLICY$5 = resolveRetryPolicy({
 function resolveDefaultReasoningEffort$3(efforts, configuredEffort) {
 	if (configuredEffort && efforts.includes(configuredEffort)) return ReasoningEffortId(configuredEffort);
 }
+/**
+* Resolves whether Zero Data Retention (ZDR) routing is active for Command Code.
+* An explicit boolean on adapter options takes precedence over host environment variables.
+* When not specified in options, DSH_COMMAND_CODE_ZDR is consulted first, then CMD_ZDR.
+*/
+function resolveZeroDataRetention(optionsZdr) {
+	if (optionsZdr !== void 0) return optionsZdr;
+	if (process.env.DSH_COMMAND_CODE_ZDR !== void 0) return process.env.DSH_COMMAND_CODE_ZDR === "1";
+	return process.env.CMD_ZDR === "1";
+}
+/**
+* Classifies model-specific access or plan entitlement denials.
+* These are failures of permissions/entitlement for this model/account,
+* not invalid API credentials, so the account must not be marked invalid
+* and whole-account rotation must not occur.
+*/
+function isCommandCodeModelAccessDenied(status, detail) {
+	if (status === 403 || status === 404 || status === 400) {
+		const lower = detail.toLowerCase();
+		if (lower.includes("upgrade_required") || lower.includes("not entitled") || lower.includes("entitlement") || lower.includes("model_not_found") || lower.includes("model_not_allowed") || lower.includes("model_access_denied") || lower.includes("permission_denied") || lower.includes("access_denied") || lower.includes("insufficient_permissions") || lower.includes("model") && (lower.includes("access") || lower.includes("permission") || lower.includes("entitled") || lower.includes("forbidden") || lower.includes("not allowed") || lower.includes("unauthorized") || lower.includes("not supported") || lower.includes("plan") || lower.includes("tier")) || lower.includes("plan") && (lower.includes("upgrade") || lower.includes("tier") || lower.includes("include") || lower.includes("support"))) return true;
+		if (status === 403 && !isCommandCodeCredentialInvalid(status, detail)) return true;
+	}
+	return false;
+}
+/**
+* Classifies actual credential invalidity (e.g. 401 Unauthorized, or 403 with explicit key errors).
+*/
+function isCommandCodeCredentialInvalid(status, detail) {
+	if (status === 401) return true;
+	if (status === 403) {
+		const lower = detail.toLowerCase();
+		if (lower.includes("invalid_api_key") || lower.includes("invalid_token") || lower.includes("bad_api_key") || lower.includes("invalid key") || lower.includes("bad api key") || lower.includes("api key invalid") || lower.includes("key revoked") || lower.includes("revoked_key") || lower.includes("expired_key") || lower.includes("key expired") || lower.includes("token expired") || lower.includes("incorrect api key") || lower.includes("authentication failed")) return true;
+	}
+	return false;
+}
 /** Cooldown one rate-limited key takes when the provider states no delay. */
 const POOL_COOLDOWN_MS$4 = 15 * 6e4;
 var CommandCodeAdapter = class extends LlmAdapter {
@@ -12380,7 +13845,16 @@ var CommandCodeAdapter = class extends LlmAdapter {
 	}
 	async *requestStream(options, signal) {
 		const fetchFn = this.options.fetchFn ?? fetch;
-		const wire = wireForModel$2(options.model);
+		const catalogEntry = (await this.catalog()).find((entry) => entry.id === options.model);
+		const wire = (catalogEntry === void 0 ? void 0 : wireForCatalogEntry$1(catalogEntry)) ?? wireForModel$2(options.model);
+		const isZdr = resolveZeroDataRetention(this.options.zeroDataRetention);
+		if (isZdr) requireCapability({
+			provider: PROVIDER_ID$5,
+			wire,
+			model: options.model,
+			authMode: "api-key",
+			capability: "zdr"
+		});
 		const requestOptions = offloadOldestRequestImages$3(normalizeGenerateOptions(options));
 		const images = await resolveRequestImages$3(requestOptions, this.options.attachments, signal);
 		const body = JSON.stringify(buildRequest$1(requestOptions, wire, images));
@@ -12404,17 +13878,17 @@ var CommandCodeAdapter = class extends LlmAdapter {
 				apiKey = effective.credentials.apiKey;
 				apiEnv = effective.apiEnv;
 			}
-			const endpoint = `${providerUrl(apiEnv)}${wire === "anthropic" ? "/messages" : "/chat/completions"}`;
-			const headers = wire === "anthropic" ? {
+			const endpoint = `${providerUrl(apiEnv)}${endpointPathFor(wire)}`;
+			const baseHeaders = {
 				...commandCodeHeaders(apiKey),
 				"user-agent": PLUGIN_USER_AGENT,
 				accept: "text/event-stream",
-				"anthropic-version": "2023-06-01"
-			} : {
-				...commandCodeHeaders(apiKey),
-				"user-agent": PLUGIN_USER_AGENT,
-				accept: "text/event-stream"
+				...isZdr ? { [HEADER_ZDR]: "1" } : {}
 			};
+			const headers = wire === "anthropic" ? {
+				...baseHeaders,
+				"anthropic-version": "2023-06-01"
+			} : baseHeaders;
 			try {
 				response = await fetchFn(endpoint, {
 					method: "POST",
@@ -12428,8 +13902,13 @@ var CommandCodeAdapter = class extends LlmAdapter {
 			}
 			if (response.ok) break;
 			detail = (await response.text().catch(() => "")).slice(0, 600);
+			if (response.status === 422) {
+				if (detail.includes("cmd_zdr_no_providers")) throw new LlmError(`${PROVIDER_NAME$5} rejected request under Zero Data Retention: no ZDR-capable upstream is available for this model (${detail || "cmd_zdr_no_providers"}).`, "PROVIDER_ERROR", { status: 422 });
+				break;
+			}
 			if (pool === null || accountId === void 0) break;
-			if (response.status === 401 || response.status === 403) {
+			if (isCommandCodeModelAccessDenied(response.status, detail)) break;
+			if (isCommandCodeCredentialInvalid(response.status, detail)) {
 				await pool.markAuthFailed(accountId, `${PROVIDER_NAME$5} rejected the stored API key (${response.status}).`, "invalid").catch(() => void 0);
 				if (await pool.hasAnotherAvailableAccount(tried)) continue;
 				break;
@@ -12444,7 +13923,12 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		}
 		if (response === void 0 || !response.ok) {
 			const status = response?.status ?? 500;
-			if (status === 401 || status === 403) throw new LlmError(`${PROVIDER_NAME$5} rejected the stored API key (${status}). Sign in again from Settings > Command Code.${detail ? ` ${detail}` : ""}`, "INVALID_CREDENTIAL", { status });
+			if (status === 422) {
+				if (detail.includes("cmd_zdr_no_providers")) throw new LlmError(`${PROVIDER_NAME$5} rejected request under Zero Data Retention: no ZDR-capable upstream is available for this model (${detail || "cmd_zdr_no_providers"}).`, "PROVIDER_ERROR", { status: 422 });
+				throw new LlmError(`${PROVIDER_NAME$5} validation error (422): ${detail || "Unprocessable Entity"}`, "PROVIDER_ERROR", { status: 422 });
+			}
+			if (isCommandCodeModelAccessDenied(status, detail)) throw new LlmError(`${PROVIDER_NAME$5} access denied for model ${options.model}: this model is not included in the plan or requires higher entitlement (${status}).${detail ? ` ${detail}` : ""}`, "PROVIDER_ERROR", { status });
+			if (isCommandCodeCredentialInvalid(status, detail) || status === 401) throw new LlmError(`${PROVIDER_NAME$5} rejected the stored API key (${status}). Sign in again from Settings > Command Code.${detail ? ` ${detail}` : ""}`, "INVALID_CREDENTIAL", { status });
 			if (status === 429) {
 				const after = response === void 0 ? void 0 : retryAfterMs$1(response.headers);
 				throw new LlmError(`${PROVIDER_NAME$5} rate limit or plan quota reached (429). Check the quota card in Settings > Command Code.${detail ? ` ${detail}` : ""}`, "RATE_LIMIT", {
@@ -12482,8 +13966,16 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		}
 	}
 };
+/** Path suffix the chosen route answers on. */
+function endpointPathFor(wire) {
+	if (wire === "anthropic") return "/messages";
+	if (wire === "responses") return "/responses";
+	return "/chat/completions";
+}
 function processLine$1(line, state, wire) {
-	return wire === "anthropic" ? processAnthropicStreamLine$1(line, state) : processOpenAIStreamLine$1(line, state);
+	if (wire === "anthropic") return processAnthropicStreamLine$1(line, state);
+	if (wire === "responses") return processResponsesStreamLine(line, state);
+	return processOpenAIStreamLine$1(line, state);
 }
 //#endregion
 //#region src/host/command-code/account-pool.ts
@@ -13211,6 +14703,9 @@ async function getCommandCodeWebStatus(store, modelSettings, preferences, option
 		}),
 		quota: quota ?? null,
 		lastFetchedAt: quota?.fetchedAt ?? null,
+		catalogFetchedAt: getCachedCatalogFetchedAt(),
+		catalogStale: isCatalogStale(),
+		...resolveZeroDataRetention(options.zeroDataRetention) ? { zeroDataRetention: true } : options.zeroDataRetention !== void 0 ? { zeroDataRetention: false } : {},
 		models,
 		contextWindowOverrides: settings.contextWindowOverrides,
 		defaultReasoningEffort: settings.defaultReasoningEffort,
@@ -13571,6 +15066,48 @@ function ollamaHeaders(apiKey) {
 		"content-type": "application/json"
 	};
 }
+/**
+* Tightly-scoped check for known vision-capable models in Ollama.
+* Conservative allowlist of known vision families; unknown models default to false.
+*/
+function ollamaModelSupportsImage(modelId) {
+	return supportsOllamaImage(modelId, "openai", "api-key");
+}
+/**
+* Resolve model-specific thinking support in Ollama.
+* Source: official https://github.com/ollama/ollama/blob/main/docs/capabilities/thinking.mdx
+* - 'levels': gpt-oss family (values low, medium, high; cannot disable thinking)
+* - 'boolean': deepseek-r1, qwq, qwen3 families (values true, false)
+* - 'none': all other / unknown models (omit thinking control entirely)
+*/
+function thinkingModeForModel(modelId) {
+	if (!supportsOllamaThinkingControl(modelId, "native", "api-key")) return "none";
+	const base = modelId.toLowerCase().split(":")[0] ?? "";
+	if (base === "gpt-oss") return "levels";
+	if (base === "deepseek-r1" || base === "qwq" || base === "qwen3") return "boolean";
+	return "none";
+}
+/**
+* Map reasoning effort to wire think parameter for the target model.
+* Per Ollama docs:
+* - gpt-oss: only 'low' | 'medium' | 'high' are valid. gpt-oss cannot disable thinking, so 'none'
+*   as well as 'xhigh'/'max'/garbage MUST be omitted (undefined).
+* - boolean models: 'none' -> false; 'low'|'medium'|'high'|'auto'|'true' -> true; garbage -> undefined.
+* - all other models: omit (undefined).
+*/
+function thinkForModel(modelId, reasoningEffort) {
+	if (reasoningEffort === void 0 || reasoningEffort === null) return void 0;
+	const mode = thinkingModeForModel(modelId);
+	if (mode === "none") return void 0;
+	const effort = String(reasoningEffort).toLowerCase();
+	if (mode === "boolean") {
+		if (effort === "none") return false;
+		if (effort === "low" || effort === "medium" || effort === "high" || effort === "auto" || effort === "true") return true;
+		return;
+	}
+	if (effort === "low" || effort === "medium" || effort === "high") return effort;
+	if (effort === "auto" || effort === "true") return "medium";
+}
 //#endregion
 //#region src/host/ollama/token-store.ts
 function credentialPath$4() {
@@ -13742,36 +15279,79 @@ function buildBody(wire, request) {
 	if (wire === "openai") return buildOpenAIBody(request);
 	return buildNativeBody(request);
 }
+function toBareBase64(image) {
+	const match = /^data:[^;]+;base64,(.+)$/.exec(image);
+	return match ? match[1] : image;
+}
+function toDataUrl(image, defaultMediaType = "image/png") {
+	if (image.startsWith("data:") || image.startsWith("http://") || image.startsWith("https://")) return image;
+	return `data:${defaultMediaType};base64,${image}`;
+}
+function parseArguments(raw) {
+	if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) return raw;
+	if (raw === void 0 || raw === null || raw === "") return {};
+	if (typeof raw === "string") {
+		const trimmed = raw.trim();
+		if (trimmed === "" || trimmed === "{}") return {};
+		const parsed = JSON.parse(trimmed);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+		throw new Error(`Tool call arguments must be a JSON object, got ${typeof parsed}`);
+	}
+	throw new Error(`Invalid tool call arguments: ${String(raw)}`);
+}
 function buildOpenAIBody(request) {
-	const messages = request.messages.map((message) => {
-		if (message.role === "tool") return {
-			role: "tool",
-			tool_call_id: message.toolCallId ?? "",
-			content: message.content
-		};
-		if (message.role === "assistant" && message.toolCalls !== void 0 && message.toolCalls.length > 0) return {
-			role: "assistant",
-			content: message.content,
-			tool_calls: message.toolCalls.map((call) => ({
-				id: call.id,
-				type: "function",
-				function: {
-					name: call.name,
-					arguments: call.arguments
-				}
-			}))
-		};
-		return {
-			role: message.role,
-			content: message.content
-		};
-	});
+	const messages = [];
+	let pendingToolImages = [];
+	const flushToolImages = () => {
+		if (pendingToolImages.length > 0) {
+			messages.push({
+				role: "user",
+				content: pendingToolImages.map((image) => ({
+					type: "image_url",
+					image_url: { url: toDataUrl(image) }
+				}))
+			});
+			pendingToolImages = [];
+		}
+	};
+	for (const message of request.messages) {
+		if (message.role === "tool") {
+			messages.push({
+				role: "tool",
+				tool_call_id: message.toolCallId ?? "",
+				content: message.content
+			});
+			if (message.images !== void 0 && message.images.length > 0) pendingToolImages.push(...message.images);
+			continue;
+		}
+		flushToolImages();
+		if (message.role === "assistant" && message.toolCalls !== void 0 && message.toolCalls.length > 0) {
+			messages.push({
+				role: "assistant",
+				content: message.content,
+				tool_calls: message.toolCalls.map((call) => ({
+					id: call.id,
+					type: "function",
+					function: {
+						name: call.name,
+						arguments: typeof call.arguments === "string" ? call.arguments : JSON.stringify(call.arguments ?? {})
+					}
+				}))
+			});
+			continue;
+		}
+		messages.push(openAIContent(message));
+	}
+	flushToolImages();
 	const body = {
 		model: request.model,
 		messages,
 		stream: true,
 		max_tokens: request.maxOutputTokens ?? 8192
 	};
+	if (typeof request.think === "string") body.reasoning_effort = request.think;
+	else if (request.think === true) body.reasoning_effort = "auto";
+	else if (request.think === false) body.reasoning_effort = "none";
 	if (request.tools !== void 0 && request.tools.length > 0) body.tools = request.tools.map((tool) => ({
 		type: "function",
 		function: {
@@ -13785,28 +15365,30 @@ function buildOpenAIBody(request) {
 }
 function buildNativeBody(request) {
 	const messages = request.messages.map((message) => {
-		if (message.role === "tool") return {
-			role: "tool",
-			content: message.content
-		};
+		if (message.role === "tool") {
+			const item = {
+				role: "tool",
+				content: message.content
+			};
+			if (message.images !== void 0 && message.images.length > 0) item.images = message.images.map(toBareBase64);
+			return item;
+		}
 		if (message.role === "assistant" && message.toolCalls !== void 0 && message.toolCalls.length > 0) return {
 			role: "assistant",
 			content: message.content,
 			tool_calls: message.toolCalls.map((call) => ({ function: {
 				name: call.name,
-				arguments: call.arguments
+				arguments: parseArguments(call.arguments)
 			} }))
 		};
-		return {
-			role: message.role,
-			content: message.content
-		};
+		return nativeContent(message);
 	});
 	const body = {
 		model: request.model,
 		messages,
 		stream: true
 	};
+	if (request.think !== void 0) body.think = request.think;
 	const options = { num_predict: request.maxOutputTokens ?? 8192 };
 	if (request.temperature !== void 0) options.temperature = request.temperature;
 	body.options = options;
@@ -13820,6 +15402,42 @@ function buildNativeBody(request) {
 	}));
 	return body;
 }
+/**
+* A user turn on the OpenAI surface: text stays text, images become parts.
+*
+* Ollama's OpenAI compatibility takes the standard `image_url` part with a data URL.
+*/
+function openAIContent(message) {
+	if (message.images === void 0 || message.images.length === 0) return {
+		role: message.role,
+		content: message.content
+	};
+	return {
+		role: message.role,
+		content: [{
+			type: "text",
+			text: message.content
+		}, ...message.images.map((image) => ({
+			type: "image_url",
+			image_url: { url: toDataUrl(image) }
+		}))]
+	};
+}
+/**
+* A user turn on the native surface, where images are a sibling array of raw
+* base64 strings rather than data URLs or interleaved content parts.
+*/
+function nativeContent(message) {
+	if (message.images === void 0 || message.images.length === 0) return {
+		role: message.role,
+		content: message.content
+	};
+	return {
+		role: message.role,
+		content: message.content,
+		images: message.images.map(toBareBase64)
+	};
+}
 /** The endpoint one request goes to. */
 function chatUrl(wire) {
 	return wire === "openai" ? `${CLOUD_BASE_URL}${OPENAI_CHAT_PATH}` : `${CLOUD_BASE_URL}${NATIVE_CHAT_PATH}`;
@@ -13936,6 +15554,11 @@ function parseOpenAIChunk(record, pending) {
 				type: "text",
 				text: fields.content
 			});
+			const thinking = typeof fields.thinking === "string" ? fields.thinking : typeof fields.reasoning === "string" ? fields.reasoning : typeof fields.reasoning_content === "string" ? fields.reasoning_content : "";
+			if (thinking !== "") events.push({
+				type: "thinking",
+				text: thinking
+			});
 			if (Array.isArray(fields.tool_calls)) for (const raw of fields.tool_calls) accumulateToolCall(raw, pending, true);
 		}
 		if (typeof entry.finish_reason === "string" && entry.finish_reason !== "") events.push({
@@ -13959,6 +15582,11 @@ function parseNativeChunk(record, pending) {
 			type: "text",
 			text: fields.content
 		});
+		const thinking = typeof fields.thinking === "string" ? fields.thinking : typeof fields.reasoning === "string" ? fields.reasoning : typeof fields.reasoning_content === "string" ? fields.reasoning_content : "";
+		if (thinking !== "") events.push({
+			type: "thinking",
+			text: thinking
+		});
 		if (Array.isArray(fields.tool_calls)) for (const raw of fields.tool_calls) accumulateToolCall(raw, pending, false);
 	}
 	if (record.done === true) events.push({
@@ -14094,6 +15722,7 @@ function createStreamState$4() {
 	return {
 		nextBlockIndex: 0,
 		textBlock: null,
+		thinkingBlock: null,
 		toolCalls: /* @__PURE__ */ new Map(),
 		hasContent: false
 	};
@@ -14101,30 +15730,85 @@ function createStreamState$4() {
 /** Fold one event into chunks, opening and closing blocks as the stream needs. */
 function applyEvent(state, event) {
 	if (event.type === "text") return applyText(state, event.text);
+	if (event.type === "thinking") return applyThinking(state, event.text);
 	if (event.type === "tool_call") return applyToolCall(state, event.call);
 	return [];
 }
+/**
+* Fold a thinking delta into its own block.
+*
+* The trace and the answer interleave, so a text delta or a tool call closes
+* the reasoning block: two open blocks at once would hand the caller chunks in
+* an order the stream never produced.
+*/
+function applyThinking(state, text) {
+	state.hasContent = true;
+	if (state.thinkingBlock === null) {
+		const out = closeText(state);
+		const index = state.nextBlockIndex;
+		state.nextBlockIndex += 1;
+		state.thinkingBlock = {
+			index,
+			text
+		};
+		return [
+			...out,
+			{
+				type: "block-start",
+				index,
+				blockType: "reasoning"
+			},
+			{
+				type: "reasoning-delta",
+				index,
+				text
+			}
+		];
+	}
+	state.thinkingBlock.text += text;
+	return [{
+		type: "reasoning-delta",
+		index: state.thinkingBlock.index,
+		text
+	}];
+}
+function closeThinking(state) {
+	const block = state.thinkingBlock;
+	if (block === null) return [];
+	state.thinkingBlock = null;
+	return [{
+		type: "block-end",
+		index: block.index,
+		block: {
+			type: "reasoning",
+			text: block.text
+		}
+	}];
+}
 function applyText(state, text) {
 	state.hasContent = true;
+	const closed = closeThinking(state);
 	if (state.textBlock === null) {
+		closed.push({
+			type: "block-start",
+			index: state.nextBlockIndex,
+			blockType: "text"
+		});
 		const index = state.nextBlockIndex;
 		state.nextBlockIndex += 1;
 		state.textBlock = {
 			index,
 			text
 		};
-		return [{
-			type: "block-start",
-			index,
-			blockType: "text"
-		}, {
+		closed.push({
 			type: "text-delta",
 			index,
 			text
-		}];
+		});
+		return closed;
 	}
 	state.textBlock.text += text;
-	return [{
+	return [...closed, {
 		type: "text-delta",
 		index: state.textBlock.index,
 		text
@@ -14133,6 +15817,7 @@ function applyText(state, text) {
 function applyToolCall(state, call) {
 	state.hasContent = true;
 	const out = [];
+	out.push(...closeThinking(state));
 	out.push(...closeText(state));
 	const index = state.nextBlockIndex;
 	state.nextBlockIndex += 1;
@@ -14195,7 +15880,11 @@ function closeToolCalls$3(state) {
 */
 function closeStream$3(state) {
 	const sawToolCall = state.toolCalls.size > 0;
-	const out = [...closeText(state), ...closeToolCalls$3(state)];
+	const out = [
+		...closeThinking(state),
+		...closeText(state),
+		...closeToolCalls$3(state)
+	];
 	out.push({
 		type: "finish",
 		reason: sawToolCall ? { kind: "tool-calls" } : { kind: "stop" }
@@ -14297,7 +15986,7 @@ var OllamaAdapter = class extends LlmAdapter {
 			provider: prov,
 			id: model.id,
 			name: model.name ?? model.id,
-			inputModalities: ["text", "image"]
+			inputModalities: ollamaModelSupportsImage(model.id) ? ["text", "image"] : ["text"]
 		}));
 	}
 	async resolveModel(provider, modelId, signal) {
@@ -14307,7 +15996,7 @@ var OllamaAdapter = class extends LlmAdapter {
 			provider,
 			id: modelId,
 			name: entry?.name ?? modelId,
-			inputModalities: ["text", "image"],
+			inputModalities: ollamaModelSupportsImage(modelId) ? ["text", "image"] : ["text"],
 			context: { contextWindow: contextWindowFor(entry) },
 			...outputReservation(contextWindowFor(entry), DEFAULT_MAX_OUTPUT_TOKENS)
 		};
@@ -14321,10 +16010,11 @@ var OllamaAdapter = class extends LlmAdapter {
 	async *stream(options) {
 		yield* wrapStreamWithWatchdog((watchdogSignal) => this.requestStream(options, watchdogSignal), options.signal, STREAM_IDLE_TIMEOUT_MS$4, STREAM_IDLE_TIMEOUT_CODE$4, PROVIDER_NAME$4);
 	}
-	async *requestStream(options, signal) {
+	async *requestStream(rawOptions, signal) {
 		const fetchFn = this.options.fetchFn ?? fetch;
+		const options = normalizeGenerateOptions(rawOptions);
 		const wire = wireForModel$1(options.model);
-		const request = toOllamaRequest(options);
+		const request = await toOllamaRequest(options, this.options.attachments, signal);
 		const pool = this.accountPool;
 		const tried = /* @__PURE__ */ new Set();
 		let lastStatus;
@@ -14364,7 +16054,7 @@ var OllamaAdapter = class extends LlmAdapter {
 					spent = event.usage;
 					continue;
 				}
-				if (event.type === "text" || event.type === "tool_call") {
+				if (event.type === "text" || event.type === "thinking" || event.type === "tool_call") {
 					for (const chunk of applyEvent(state, event)) yield chunk;
 					continue;
 				}
@@ -14393,18 +16083,134 @@ var OllamaAdapter = class extends LlmAdapter {
 		throw new LlmError(`${PROVIDER_NAME$4} request failed${status === void 0 ? "" : ` (${status})`}.${lastDetail}`, status !== void 0 && status >= 500 ? "SERVER" : "INVALID_REQUEST", status === void 0 ? {} : { status });
 	}
 };
-/** Project DSH's request shape onto Ollama's, per surface. */
-function toOllamaRequest(options) {
-	const messages = [];
-	for (const message of options.messages) {
-		if (message.role === "tool") {
-			messages.push({
-				role: "tool",
-				content: textOf$4(message.content),
-				toolCallId: message.toolCallId
-			});
+function isAbort$2(error, signal) {
+	return signal?.aborted === true || error instanceof Error && error.name === "AbortError";
+}
+function isRecord$18(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString$11(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function attachmentLabel$4(block) {
+	const attachment = isRecord$18(block.attachment) ? block.attachment : void 0;
+	return asString$11(attachment?.name) || asString$11(attachment?.attachmentId);
+}
+function unavailableImageText$4(block) {
+	const label = attachmentLabel$4(block);
+	return `[image unavailable: ${label ? `${label} could not be read` : "the image could not be read"}; ask the user to attach it again if the image is needed]`;
+}
+function abortException(signal) {
+	if (signal?.reason !== void 0) return signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason));
+	return new DOMException("The operation was aborted", "AbortError");
+}
+function unsupportedImageText$1(model, block) {
+	const label = attachmentLabel$4(block);
+	return `[image unsupported: ${label ? `${label}: ` : ""}model ${model} is not known to declare image support; remove the attachment or switch to a vision model]`;
+}
+function combineTextParts(parts) {
+	let result = "";
+	for (const part of parts) {
+		if (!part) continue;
+		if (!result) result = part;
+		else if (part.startsWith("[image ") || result.endsWith("\n")) result = result.trimEnd() + "\n\n" + part;
+		else result += part;
+	}
+	return result;
+}
+async function processMessageContent(content, model, attachments, signal) {
+	if (signal?.aborted) throw abortException(signal);
+	if (typeof content === "string") return { text: content };
+	if (!Array.isArray(content)) return { text: "" };
+	const textParts = [];
+	const images = [];
+	for (const part of content) {
+		if (typeof part === "string") {
+			textParts.push(part);
 			continue;
 		}
+		if (!isRecord$18(part)) continue;
+		if (part.type === "text") {
+			if (typeof part.text === "string" && part.text !== "") textParts.push(part.text);
+			continue;
+		}
+		if (part.type === "image") {
+			if (!ollamaModelSupportsImage(model)) {
+				textParts.push(unsupportedImageText$1(model, part));
+				continue;
+			}
+			const reference = isImageRef(part.attachment) ? part.attachment : isImageRef(part.source) ? part.source : null;
+			if (reference !== null) {
+				if (!attachments) {
+					textParts.push(unavailableImageText$4(part));
+					continue;
+				}
+				try {
+					if (signal?.aborted) throw abortException(signal);
+					const loaded = await attachments.readImage(reference, signal);
+					if (signal?.aborted) throw abortException(signal);
+					if (loaded === null) textParts.push(unavailableImageText$4(part));
+					else images.push(encodeImage(loaded.data, loaded.ref.mediaType));
+				} catch (error) {
+					if (isAbort$2(error, signal)) throw error;
+					textParts.push(unavailableImageText$4(part));
+				}
+				continue;
+			}
+			const inline = part.source;
+			if (isRecord$18(inline)) {
+				const data = inline.data;
+				if (typeof data === "string" && data !== "") {
+					images.push(encodeImage(data, asMediaType(inline.mediaType)));
+					continue;
+				}
+			}
+			if (typeof part.image === "string" && part.image !== "") {
+				images.push(part.image);
+				continue;
+			}
+			textParts.push(unavailableImageText$4(part));
+			continue;
+		}
+	}
+	return {
+		text: combineTextParts(textParts),
+		...images.length > 0 ? { images } : {}
+	};
+}
+/**
+* Project DSH's request shape onto Ollama's, per surface.
+* Consumes the canonical Message vocabulary produced by normalizeGenerateOptions.
+*/
+async function toOllamaRequest(options, attachments, signal) {
+	if (signal?.aborted) throw abortException(signal);
+	const messages = [];
+	const trimmedSystem = typeof options.system === "string" && options.system.trim() !== "" ? options.system.trim() : void 0;
+	if (trimmedSystem !== void 0) messages.push({
+		role: "system",
+		content: trimmedSystem
+	});
+	for (let index = 0; index < options.messages.length; index++) {
+		const message = options.messages[index];
+		if (index === 0 && trimmedSystem !== void 0 && (message.role === "system" || message.role === "developer")) {
+			if (textOf$4(message.content).trim() === trimmedSystem) continue;
+		}
+		if ((message.source?.kind === "tool" || Array.isArray(message.content) && message.content.some((b) => b.type === "tool-result")) && Array.isArray(message.content)) {
+			const toolResultBlocks = message.content.filter((b) => b.type === "tool-result");
+			if (toolResultBlocks.length > 0) {
+				for (const block of toolResultBlocks) {
+					const toolCallId = String(block.toolCallId ?? (isRecord$18(message.source) ? message.source.callId : "") ?? "");
+					const processed = await processMessageContent(block.content, options.model, attachments, signal);
+					messages.push({
+						role: "tool",
+						content: processed.text,
+						...toolCallId !== "" ? { toolCallId } : {},
+						...processed.images ? { images: processed.images } : {}
+					});
+				}
+				continue;
+			}
+		}
 		const toolCalls = assistantToolCalls(message.content);
 		if (toolCalls.length > 0) {
 			messages.push({
@@ -14414,9 +16220,26 @@ function toOllamaRequest(options) {
 			});
 			continue;
 		}
+		if (message.role === "assistant") {
+			messages.push({
+				role: "assistant",
+				content: textOf$4(message.content)
+			});
+			continue;
+		}
+		if (message.role === "system" || message.role === "developer") {
+			const text = textOf$4(message.content).trim();
+			if (text !== "") messages.push({
+				role: "system",
+				content: text
+			});
+			continue;
+		}
+		const processed = await processMessageContent(message.content, options.model, attachments, signal);
 		messages.push({
-			role: message.role === "developer" ? "system" : message.role,
-			content: textOf$4(message.content)
+			role: "user",
+			content: processed.text,
+			...processed.images ? { images: processed.images } : {}
 		});
 	}
 	const request = {
@@ -14425,6 +16248,8 @@ function toOllamaRequest(options) {
 	};
 	if (options.maxTokens !== void 0) request.maxOutputTokens = options.maxTokens;
 	if (options.temperature !== void 0) request.temperature = options.temperature;
+	const think = thinkForModel(options.model, options.reasoningEffort);
+	if (think !== void 0) request.think = think;
 	const tools = options.tools;
 	if (Array.isArray(tools) && tools.length > 0) request.tools = tools.map((tool) => ({
 		name: tool.name,
@@ -14455,6 +16280,23 @@ function assistantToolCalls(content) {
 	}
 	return calls;
 }
+function isImageRef(value) {
+	return typeof value === "object" && value !== null && typeof value.attachmentId === "string";
+}
+function asMediaType(value) {
+	return typeof value === "string" && value !== "" ? value : "image/png";
+}
+/**
+* The base64 payload Ollama wants, with or without a data URL prefix.
+*
+* The native surface takes the bare payload; a `data:` URL is accepted by both
+* surfaces once, so one encoding serves either and avoids a route-specific
+* guess about what a given model accepts.
+*/
+function encodeImage(data, mediaType) {
+	const base64 = typeof data === "string" ? data : Buffer.from(data).toString("base64");
+	return base64.startsWith("data:") ? base64 : `data:${mediaType};base64,${base64}`;
+}
 function textOf$4(content) {
 	if (typeof content === "string") return content;
 	if (Array.isArray(content)) return content.map((part) => {
@@ -20368,6 +22210,22 @@ function redactToken(token) {
 	if (token === void 0 || token === null || token === "") return "<none>";
 	return "sha256:" + createHash("sha256").update(token).digest("hex").slice(0, 12) + "/len:" + token.length;
 }
+/**
+* Adapter-selected auth owner (nonsecret hash).
+*
+* Scoped to the specific account and credential token/key selected by the adapter.
+* Any account change or token/key replacement produces a different hash,
+* preventing thinking/signature replay across different authentication boundaries.
+*/
+function computeMinimaxAuthOwner(credentials, accountId) {
+	const token = (credentials?.apiKey || credentials?.accessToken || "").trim();
+	if (!token) return "";
+	const hash = createHash("sha256");
+	if (accountId && accountId.trim() !== "") hash.update(`acc:${accountId}\0`);
+	if (credentials?.region && credentials.region.trim() !== "") hash.update(`reg:${credentials.region}\0`);
+	hash.update(`tok:${token}`);
+	return hash.digest("hex").slice(0, 32);
+}
 //#endregion
 //#region src/host/minimax-code/mapper.ts
 /**
@@ -20457,6 +22315,31 @@ function safeJsonParse$2(text) {
 function sanitizeText$2(text) {
 	return text.replace(/\0/g, "");
 }
+function jsonSafeValue$1(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null) return null;
+	switch (typeof value) {
+		case "string":
+		case "boolean": return value;
+		case "number":
+			if (!Number.isFinite(value)) return void 0;
+			return Object.is(value, -0) ? 0 : value;
+		case "object": break;
+		default: return;
+	}
+	if (seen.has(value)) return void 0;
+	seen.add(value);
+	try {
+		if (Array.isArray(value)) return Array.from(value, (item) => jsonSafeValue$1(item, seen) ?? null);
+		const record = {};
+		for (const key of Object.keys(value)) {
+			const child = jsonSafeValue$1(value[key], seen);
+			if (child !== void 0) record[key] = child;
+		}
+		return record;
+	} finally {
+		seen.delete(value);
+	}
+}
 /** Media types the wire accepts as inline base64. */
 const SUPPORTED_IMAGE_MEDIA_TYPES$2 = /* @__PURE__ */ new Set([
 	"image/png",
@@ -20640,9 +22523,92 @@ function anthropicUserContent(message, images) {
 	}
 	return blocks;
 }
-function anthropicAssistantContent(message) {
+/**
+* Native blocks to replay for one assistant turn, as the service issued them.
+*
+* Read from the message's stored replay state rather than rebuilt from the
+* visible reasoning text: a rebuilt block is not the block the model signed, and
+* the difference is exactly what the provider validates. Falls back to nothing
+* when a turn carries no stored state, which is the current behaviour for
+* history this route did not produce.
+*/
+/** Fingerprint the entire array of emitted visible blocks in an assistant message. */
+function computeVisibleContentHash(blocks) {
+	if (!Array.isArray(blocks)) return "";
+	const canonical = blocks.map((b) => {
+		if (!isRecord$15(b)) return null;
+		const type = asString$8(b.type) ?? "";
+		if (type === "text" || type === "reasoning") return [type, sanitizeText$2(asString$8(b.text) ?? "")];
+		if (type === "tool-call") return [
+			type,
+			asString$8(b.id) ?? "",
+			asString$8(b.name) ?? "",
+			toolCallArguments$2(b.arguments)
+		];
+		return [type, jsonSafeValue$1(b)];
+	});
+	return createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 32);
+}
+/**
+* Verbatim wire block to replay for one reasoning block.
+*
+* Verifies route, model, and auth owner provenance. Fails safely on legacy unscoped state
+* or any mismatch, dropping the replay block rather than submitting invalid state.
+* Preserves raw native text and signature binding.
+*/
+function replayedThinkingBlock$1(message, index, expectedScope, block) {
+	const source = message.source;
+	if (source === void 0 || source === null || !isRecord$15(source)) return void 0;
+	if (source.provider && source.provider !== PROVIDER_ID$2 && source.provider !== "dsh-chatgpt-subscription") return;
+	if (source.model && expectedScope && source.model !== expectedScope.model) return;
+	const state = source.replayState;
+	if (!isRecord$15(state)) return void 0;
+	const resp = isRecord$15(state.response) ? state.response : state;
+	const stateRoute = asString$8(resp.route) ?? asString$8(resp.provider);
+	const stateModel = asString$8(resp.model);
+	const stateAuthOwner = asString$8(resp.authOwner);
+	if (!stateRoute || !stateModel || !stateAuthOwner || stateAuthOwner.trim() === "") return;
+	if (expectedScope === void 0) return void 0;
+	if (expectedScope.route && stateRoute !== expectedScope.route) return void 0;
+	if (expectedScope.model && stateModel !== expectedScope.model) return void 0;
+	if (!expectedScope.authOwner || expectedScope.authOwner.trim() === "" || stateAuthOwner !== expectedScope.authOwner) return;
+	let candidate;
+	if (Array.isArray(state.blocks)) {
+		const entry = state.blocks[index];
+		if (isRecord$15(entry)) candidate = entry;
+	}
+	if (candidate === void 0 && Array.isArray(resp.blocks)) {
+		const entry = resp.blocks[index];
+		if (isRecord$15(entry)) candidate = entry;
+	}
+	if (candidate === void 0 && Array.isArray(resp.nativeBlocks)) {
+		const entry = resp.nativeBlocks[index];
+		if (isRecord$15(entry)) candidate = entry;
+	}
+	if (candidate === void 0) return void 0;
+	if (Array.isArray(state.blocks) && state.blocks.length !== message.content.length) return void 0;
+	if (Array.isArray(resp.blocks) && resp.blocks.length !== message.content.length) return void 0;
+	const stateVisibleHash = asString$8(resp.visibleContentHash);
+	if (!stateVisibleHash || stateVisibleHash.trim() === "") return void 0;
+	if (computeVisibleContentHash(message.content) !== stateVisibleHash) return void 0;
+	if (candidate.type !== "thinking" && candidate.type !== "redacted_thinking") return;
+	const visibleText = asString$8(block?.text) ?? "";
+	if (candidate.type === "redacted_thinking") {
+		if (visibleText !== "") return void 0;
+		const data = asString$8(candidate.data);
+		if (!data || data.trim() === "") return void 0;
+		return structuredClone(candidate);
+	}
+	if (sanitizeText$2(asString$8(candidate.thinking) ?? "") !== sanitizeText$2(visibleText)) return;
+	const signature = asString$8(candidate.signature);
+	if (!signature || signature.trim() === "") return void 0;
+	return structuredClone(candidate);
+}
+function anthropicAssistantContent(message, expectedScope) {
 	const blocks = [];
-	for (const block of message.content) {
+	if (!Array.isArray(message.content)) return blocks;
+	for (let index = 0; index < message.content.length; index++) {
+		const block = message.content[index];
 		if (!isRecord$15(block)) continue;
 		if (block.type === "text" && typeof block.text === "string") {
 			const text = sanitizeText$2(block.text);
@@ -20660,6 +22626,12 @@ function anthropicAssistantContent(message) {
 				name: block.name,
 				input: isRecord$15(parsed) ? parsed : {}
 			});
+			continue;
+		}
+		if (block.type === "reasoning") {
+			const replay = replayedThinkingBlock$1(message, index, expectedScope, block);
+			if (replay !== void 0) blocks.push(replay);
+			continue;
 		}
 	}
 	return blocks;
@@ -20808,6 +22780,12 @@ function markMinimaxCacheBreakpoints(body) {
 }
 /** Build one Anthropic Messages body for this subscription. */
 function buildMinimaxRequest(options, images = NO_RESOLVED_IMAGES$2, request = {}) {
+	const expectedScope = request.authOwner !== void 0 ? {
+		route: request.route ?? PROVIDER_ID$2,
+		model: options.model,
+		authOwner: request.authOwner,
+		provider: PROVIDER_ID$2
+	} : void 0;
 	const entries = [];
 	for (const message of nonSystemMessages$2(options)) {
 		if (isToolResultMessage$2(message)) {
@@ -20819,7 +22797,7 @@ function buildMinimaxRequest(options, images = NO_RESOLVED_IMAGES$2, request = {
 		}
 		entries.push({
 			role: message.role === "assistant" ? "assistant" : "user",
-			content: message.role === "assistant" ? anthropicAssistantContent(message) : anthropicUserContent(message, images)
+			content: message.role === "assistant" ? anthropicAssistantContent(message, expectedScope) : anthropicUserContent(message, images)
 		});
 	}
 	const system = leadingSystemText$2(options);
@@ -20867,8 +22845,16 @@ function assertRequestBodyFits(body, limit = maxMessageBodyBytes()) {
 	if (bytes <= limit) return serialized;
 	throw new LlmError$1("MiniMax Code（编程订阅） request was not sent: the serialized body is " + bytes + " bytes, above the " + limit + "-byte ceiling this route enforces. Compact the conversation or start a new session, and check for large tool results or attached media.", "PROVIDER_ERROR");
 }
-function createStreamState() {
+function createStreamState(options) {
 	return {
+		provenance: options?.model && options?.authOwner ? {
+			route: options.route ?? PROVIDER_ID$2,
+			model: options.model,
+			authOwner: options.authOwner,
+			provider: options.provider ?? PROVIDER_ID$2
+		} : void 0,
+		replayBlocks: [],
+		pendingThinking: /* @__PURE__ */ new Map(),
 		blocks: [],
 		current: null,
 		toolCalls: /* @__PURE__ */ new Map(),
@@ -20912,6 +22898,7 @@ function openTextBlock$1(state, type) {
 		type,
 		text: ""
 	});
+	state.replayBlocks[index] = null;
 	out.push({
 		type: "block-start",
 		index,
@@ -20929,6 +22916,7 @@ function closeToolCalls$1(state) {
 			arguments: call.arguments === "" ? "{}" : call.arguments
 		};
 		state.blocks[call.blockIndex] = block;
+		state.replayBlocks[call.blockIndex] = null;
 		out.push({
 			type: "block-end",
 			index: call.blockIndex,
@@ -20961,9 +22949,34 @@ function closeMinimaxStream(state) {
 		type: "usage",
 		usage: tokenUsage$2(state)
 	});
+	const paddedBlocks = state.blocks.map((_, i) => {
+		const b = state.replayBlocks[i];
+		return b !== void 0 && b !== null ? jsonSafeValue$1(b) : null;
+	});
+	const replayThinking = paddedBlocks.filter((b) => b !== null);
+	const hasReplay = replayThinking.length > 0;
+	const visibleContentHash = computeVisibleContentHash(state.blocks);
+	const replayState = hasReplay ? state.provenance ? {
+		response: {
+			provider: state.provenance.provider ?? PROVIDER_ID$2,
+			route: state.provenance.route ?? PROVIDER_ID$2,
+			model: state.provenance.model,
+			authOwner: state.provenance.authOwner,
+			visibleContentHash,
+			minimaxThinking: replayThinking
+		},
+		blocks: paddedBlocks
+	} : {
+		response: {
+			visibleContentHash,
+			minimaxThinking: replayThinking
+		},
+		blocks: paddedBlocks
+	} : void 0;
 	out.push({
 		type: "finish",
-		reason: finishReasonFor$2(state)
+		reason: finishReasonFor$2(state),
+		...replayState !== void 0 ? { replayState } : {}
 	});
 	return out;
 }
@@ -21034,8 +23047,40 @@ function processMinimaxStreamLine(line, state) {
 			return out;
 		}
 		if (blockType === "thinking" || blockType === "redacted_thinking") {
-			out.push(...openTextBlock$1(state, "reasoning"));
-			state.contentIndexes.set(contentIndex, state.current.index);
+			const index = state.blocks.length;
+			const kind = blockType === "redacted_thinking" ? "redacted_thinking" : "thinking";
+			const data = asString$8(block.data) ?? "";
+			const signature = asString$8(block.signature) ?? "";
+			const thinking = asString$8(block.thinking) ?? "";
+			state.current = {
+				index,
+				type: "reasoning",
+				text: kind === "thinking" ? thinking : ""
+			};
+			state.blocks.push({
+				type: "reasoning",
+				text: state.current.text
+			});
+			const initialReplay = isRecord$15(event.content_block) ? structuredClone(event.content_block) : { type: blockType };
+			state.replayBlocks[index] = initialReplay;
+			state.pendingThinking.set(contentIndex, {
+				dshIndex: index,
+				kind,
+				text: thinking,
+				signature,
+				data
+			});
+			state.contentIndexes.set(contentIndex, index);
+			out.push({
+				type: "block-start",
+				index,
+				blockType: "reasoning"
+			});
+			if (state.current.text !== "") out.push({
+				type: "reasoning-delta",
+				index,
+				text: state.current.text
+			});
 			return out;
 		}
 		out.push(...openTextBlock$1(state, "text"));
@@ -21061,8 +23106,37 @@ function processMinimaxStreamLine(line, state) {
 			}
 			return out;
 		}
+		if (deltaType === "signature_delta") {
+			const signature = asString$8(delta.signature) ?? "";
+			const pending = state.pendingThinking.get(contentIndex);
+			if (pending !== void 0 && signature !== "") {
+				pending.signature += signature;
+				const replay = state.replayBlocks[pending.dshIndex];
+				if (replay !== void 0 && replay !== null) replay.signature = (asString$8(replay.signature) ?? "") + signature;
+			}
+			return out;
+		}
+		if (deltaType === "data_delta") {
+			const data = asString$8(delta.data) ?? "";
+			const pending = state.pendingThinking.get(contentIndex);
+			if (pending !== void 0 && data !== "") {
+				pending.data = (pending.data ?? "") + data;
+				const replay = state.replayBlocks[pending.dshIndex];
+				if (replay !== void 0 && replay !== null) replay.data = (asString$8(replay.data) ?? "") + data;
+			}
+			return out;
+		}
 		const text = deltaType === "thinking_delta" ? asString$8(delta.thinking) : asString$8(delta.text);
 		if (text !== void 0 && text !== "") {
+			const pending = state.pendingThinking.get(contentIndex);
+			if (pending !== void 0) {
+				pending.text += text;
+				const replay = state.replayBlocks[pending.dshIndex];
+				if (replay !== void 0 && replay !== null) {
+					const field = replay.type === "redacted_thinking" ? "data" : "thinking";
+					replay[field] = (asString$8(replay[field]) ?? "") + text;
+				}
+			}
 			const index = state.contentIndexes.get(contentIndex) ?? state.current?.index;
 			const kind = deltaType === "thinking_delta" ? "reasoning" : "text";
 			if (state.current === null || state.current.index !== index) {
@@ -21077,6 +23151,7 @@ function processMinimaxStreamLine(line, state) {
 					type: kind,
 					text: ""
 				});
+				state.replayBlocks[next] = null;
 				state.contentIndexes.set(contentIndex, next);
 				out.push({
 					type: "block-start",
@@ -21159,7 +23234,7 @@ const MINIMAX_CODE_MODELS = [
 		maxAttachments: null,
 		maxImageBytes: null,
 		maxVideoBytes: null,
-		supportsFilesApi: false,
+		filesApiDocumented: false,
 		description: "Thinking is always on and has no selectable level. Text input only."
 	},
 	{
@@ -21175,7 +23250,7 @@ const MINIMAX_CODE_MODELS = [
 		maxAttachments: null,
 		maxImageBytes: null,
 		maxVideoBytes: null,
-		supportsFilesApi: false,
+		filesApiDocumented: false,
 		description: "The high-speed M2.7. Thinking is always on with no selectable level. Text input only."
 	},
 	{
@@ -21191,7 +23266,7 @@ const MINIMAX_CODE_MODELS = [
 		maxAttachments: 9,
 		maxImageBytes: 10 * 1024 * 1024,
 		maxVideoBytes: 50 * 1024 * 1024,
-		supportsFilesApi: true,
+		filesApiDocumented: true,
 		description: "Flagship subscription model. Thinking is on by default and can be disabled. Accepts text, image and video; up to 9 attachments, 10MB per image and 50MB per video."
 	},
 	{
@@ -21214,7 +23289,7 @@ const MINIMAX_CODE_MODELS = [
 		maxAttachments: 4,
 		maxImageBytes: 10 * 1024 * 1024,
 		maxVideoBytes: 50 * 1024 * 1024,
-		supportsFilesApi: true,
+		filesApiDocumented: true,
 		description: "Preview Flash model with a 1M context window. Thinking is forced on with a selectable effort level. Accepts up to 4 attachments."
 	}
 ];
@@ -23399,11 +25474,6 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 		const contextWindow = contextWindowForModel(options.model, settings.contextWindowOverrides);
 		const requestOptions = offloadOldestRequestImages$2(normalizeGenerateOptions(options), maxRequestImageBytes());
 		const images = await resolveRequestImages$2(requestOptions, this.options.attachments, signal);
-		const requestedMax = requestOptions.maxTokens ?? maxOutputTokensFor$1(options.model, contextWindow);
-		const body = assertRequestBodyFits(buildMinimaxRequest({
-			...requestOptions,
-			maxTokens: clampOutputToContext(requestedMax, contextWindow, estimatedInputTokens(requestOptions))
-		}, images, { cacheControl: true }));
 		let credentials;
 		let accountId;
 		try {
@@ -23414,6 +25484,19 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 			if (error instanceof MinimaxCodeUnauthorizedError) throw new LlmError(error.message, "INVALID_CREDENTIAL", { cause: error });
 			throw new LlmError("MiniMax Code（编程订阅） credential could not be prepared: " + (error instanceof Error ? error.message : String(error)), "MISSING_CREDENTIAL", { cause: error });
 		}
+		let authOwner = computeMinimaxAuthOwner(credentials, accountId);
+		const effectiveMax = clampOutputToContext(requestOptions.maxTokens ?? maxOutputTokensFor$1(options.model, contextWindow), contextWindow, estimatedInputTokens(requestOptions));
+		const buildBodyForOwner = (owner) => {
+			return assertRequestBodyFits(buildMinimaxRequest({
+				...requestOptions,
+				maxTokens: effectiveMax
+			}, images, {
+				cacheControl: true,
+				authOwner: owner,
+				route: PROVIDER_ID$2
+			}));
+		};
+		let body = buildBodyForOwner(authOwner);
 		let response;
 		for (let attempt = 0;; attempt += 1) {
 			try {
@@ -23433,6 +25516,8 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 			const refused = credentials.accessToken;
 			try {
 				credentials = await this.renewCredential(accountId, fetchFn, signal, refused);
+				authOwner = computeMinimaxAuthOwner(credentials, accountId);
+				body = buildBodyForOwner(authOwner);
 			} catch (error) {
 				if (error instanceof MinimaxCodeUnauthorizedError) throw new LlmError(error.message, "INVALID_CREDENTIAL", { cause: error });
 				throw new LlmError("MiniMax Code（编程订阅） credential could not be renewed after the service refused " + redactToken(refused) + ": " + (error instanceof Error ? error.message : String(error)), "INVALID_CREDENTIAL", { cause: error });
@@ -23451,7 +25536,12 @@ var MinimaxCodeAdapter = class extends LlmAdapter {
 		if (response.body === null) throw new LlmError("MiniMax Code（编程订阅） returned an empty response body", "PROVIDER_ERROR");
 		const reader = response.body.getReader();
 		const decoder = new TextDecoder();
-		const state = createStreamState();
+		const state = createStreamState({
+			model: options.model,
+			authOwner,
+			route: PROVIDER_ID$2,
+			provider: PROVIDER_ID$2
+		});
 		let buffer = "";
 		try {
 			while (true) {
@@ -27717,6 +29807,7 @@ function createStreamState$2() {
 		inputTokens: 0,
 		outputTokens: 0,
 		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
 		reasoningTokens: 0,
 		sawUsage: false
 	};
@@ -27798,8 +29889,10 @@ function processStreamLine$1(line, state) {
 		const prompt = numberOr$1(usage.prompt_tokens, 0);
 		const details = isRecord$8(usage.prompt_tokens_details) ? usage.prompt_tokens_details : void 0;
 		const cached = details ? numberOr$1(details.cached_tokens, 0) : 0;
-		state.inputTokens = Math.max(0, prompt - cached);
+		const written = details ? numberOr$1(details.cache_write_tokens, 0) : 0;
+		state.inputTokens = Math.max(0, prompt - cached - written);
 		state.cacheReadTokens = cached;
+		state.cacheWriteTokens = written;
 		state.outputTokens = numberOr$1(usage.completion_tokens, state.outputTokens);
 		if (isRecord$8(usage.completion_tokens_details)) state.reasoningTokens = numberOr$1(usage.completion_tokens_details.reasoning_tokens, state.reasoningTokens);
 	}
@@ -27900,6 +29993,7 @@ function tokenUsage$1(state) {
 		inputTokens: state.inputTokens,
 		outputTokens: state.outputTokens,
 		...state.cacheReadTokens > 0 ? { cacheReadTokens: state.cacheReadTokens } : {},
+		...state.cacheWriteTokens > 0 ? { cacheWriteTokens: state.cacheWriteTokens } : {},
 		...state.reasoningTokens > 0 ? { reasoningTokens: state.reasoningTokens } : {}
 	};
 }
@@ -39752,8 +41846,16 @@ function apply(ctx, pluginConfig = {}) {
 			logger: ctx.logger
 		});
 		const proxyFetch = proxyManager.createFetch();
+		const providerLimits = readModelRequestLimits();
+		const modelFetch = Object.fromEntries(CONTROLLED_PROVIDERS.map((provider) => [provider, createControlledModelFetch(createDiagnosticFetch(proxyFetch, {
+			provider,
+			onRecord: (record) => ctx.logger.info("[provider-diagnostics] " + JSON.stringify(record))
+		}), {
+			provider,
+			limits: providerLimits
+		})]));
 		const antigravityAdapter = new AntigravityAdapter(antigravityStore, antigravityModelSettings, antigravityPreferences, {
-			fetchFn: proxyFetch,
+			fetchFn: modelFetch.antigravity,
 			attachments: ctx.attachments
 		}, antigravityAccountPool);
 		let antigravityRegistration;
@@ -39780,7 +41882,7 @@ function apply(ctx, pluginConfig = {}) {
 			conflict: () => commandCodeConflict
 		}, commandCodeAccountPool);
 		const commandCodeAdapter = new CommandCodeAdapter(commandCodeStore, commandCodeModelSettings, commandCodePreferences, {
-			fetchFn: proxyFetch,
+			fetchFn: modelFetch["command-code"],
 			attachments: ctx.attachments
 		}, commandCodeAccountPool);
 		let commandCodeRegistration;
@@ -39788,11 +41890,14 @@ function apply(ctx, pluginConfig = {}) {
 		const ollamaStore = new FileCredentialStore$5();
 		const ollamaModelSettings = new FileModelSettingsStore$5();
 		const ollamaAccountPool = new OllamaAccountPool({ store: ollamaStore });
-		const ollamaAdapter = new OllamaAdapter(ollamaStore, ollamaModelSettings, { fetchFn: proxyFetch }, ollamaAccountPool);
+		const ollamaAdapter = new OllamaAdapter(ollamaStore, ollamaModelSettings, {
+			fetchFn: modelFetch.ollama,
+			attachments: ctx.attachments
+		}, ollamaAccountPool);
 		let ollamaRegistration;
 		let ollamaConflict = null;
 		const kimiCodeAdapter = new KimiCodeAdapter(kimiCodeStore, kimiCodeModelSettings, kimiCodePreferences, {
-			fetchFn: proxyFetch,
+			fetchFn: modelFetch["kimi-code"],
 			attachments: ctx.attachments,
 			videos: { readVideo: async (ref) => ({
 				data: await readVideoBytes(ref),
@@ -39854,7 +41959,7 @@ function apply(ctx, pluginConfig = {}) {
 			conflict: () => kimiCodeConflict
 		}, kimiCodeAccountPool);
 		const minimaxCodeAdapter = new MinimaxCodeAdapter(minimaxCodeStore, {
-			fetchFn: proxyFetch,
+			fetchFn: modelFetch["minimax-code"],
 			attachments: ctx.attachments,
 			accountPool: minimaxCodeAccountPool
 		}, minimaxCodeModelSettings, minimaxCodePreferences);
@@ -39904,7 +42009,7 @@ function apply(ctx, pluginConfig = {}) {
 			checkin: minimaxCodeCheckin
 		}, minimaxCodeModelSettings, minimaxCodePreferences);
 		const workBuddyAdapter = new WorkBuddyAdapter(workBuddyStore, workBuddyModelSettings, workBuddyPreferences, {
-			fetchFn: proxyFetch,
+			fetchFn: modelFetch.workbuddy,
 			attachments: ctx.attachments,
 			accountPool: workBuddyAccountPool
 		});
@@ -39946,7 +42051,7 @@ function apply(ctx, pluginConfig = {}) {
 			checkin: workBuddyCheckin
 		});
 		const claudeAdapter = new ClaudeAdapter(claudeStore, claudeModelSettings, claudePreferences, {
-			fetchFn: proxyFetch,
+			fetchFn: modelFetch.claude,
 			attachments: ctx.attachments,
 			accountPool: claudeAccountPool
 		});
@@ -39983,7 +42088,7 @@ function apply(ctx, pluginConfig = {}) {
 		const usage = new UsageService(oauth, { fetchFn: proxyFetch });
 		codexAccountPool.setQuotaBlockedUntil((account, now) => usage.blockedUntilFor(account.credentials, now));
 		const adapter = new CodexChatGptAdapter(new ResponsesClient(oauth, ctx.attachments, {
-			fetchFn: proxyFetch,
+			fetchFn: modelFetch["codex-chatgpt"],
 			accountPool: codexAccountPool,
 			localRawImages: { baseUrl: localWebServerBaseUrl(ctx.webServer.host, ctx.webServer.port) },
 			onGenerationFinished: () => usage.invalidate(),