dsh-plugin-subscriptions 0.5.0 → 0.5.2

package/lib/index.js

@@ -2,13 +2,14 @@ import z from "@deepseek-ai/schemastery";
 import { CONTEXT_WINDOW_EXCEEDED_CODE, CallId, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, QUOTA_EXCEEDED_CODE, ReasoningEffortId, attributionHeaders, errorChain, isContextWindowExceededError, isQuotaExceededError, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { createServer } from "node:http";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { ProxyAgent, fetch as fetch$1 } from "undici";
 import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 import { execFileSync } from "node:child_process";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { AttachmentId } from "@deepseek-ai/dsh-attachment";
-import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 
 //#region src/auth/pkce.ts
@@ -155,7 +156,7 @@ var OAuthFlowManager = class {
 		if (this.attempts.has(provider)) throw new Error(`a ${provider} login attempt is already in progress`);
 		const input = {
 			redirectUri: "",
-			state: randomToken(16),
+			state: randomToken(32),
 			pkce: createPkce(),
 			nonce: randomHex(8)
 		};
@@ -250,6 +251,503 @@ var OAuthFlowManager = class {
 	}
 };
 
+//#endregion
+//#region src/http.ts
+/**
+* undici's own fetch, typed to the DOM fetch signature: its bundled types are
+* stricter (Request requires `duplex`, `RequestInit.body` is non-null) and
+* incompatible with the DOM shapes the provider code passes. The runtime
+* object is the same Web-fetch implementation Node uses.
+*/
+const dispatchFetch = fetch$1;
+/** Destination the `proxyTest` endpoint probes when none is given. */
+const DEFAULT_PROXY_TEST_URL = "https://api.x.ai/v1/models";
+/** Probe deadline; a hung proxy must not pin the Settings dialog forever. */
+const DEFAULT_PROXY_TEST_TIMEOUT_MS = 15e3;
+/** Disabled configuration: the module state before the first load. */
+const DISABLED = {
+	enabled: false,
+	url: "",
+	bypass: []
+};
+/** Current config; updated by every load/apply/save. */
+let current = DISABLED;
+/** The live dispatcher, or undefined when proxies are off/errored. */
+let agent;
+/** Last load/apply failure, surfaced by the config view. */
+let configError;
+/** One lazy load of the on-disk config (module-import cheap; file read once). */
+let ready;
+/** Absolute path of the proxy config file. */
+function proxyFilePath() {
+	return dshHomePath("plugins", "subscriptions", "proxy.json");
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Flatten a fetch failure into a readable message: undici wraps the true
+* cause (`connect ECONNREFUSED ...`) behind a bare "fetch failed", so walk
+* the cause chain and append each distinct layer (up to four, cycle-safe).
+* A hostname resolving to several addresses (e.g. `localhost` → ::1 and
+* 127.0.0.1) fails as an `AggregateError` with an empty message, so its
+* per-address `errors` entries are folded in too.
+*/
+function describeFetchError(error) {
+	const parts = [];
+	let node = error;
+	for (let depth = 0; depth < 4 && node !== void 0 && node !== null; depth += 1) {
+		const layer = node;
+		if (Array.isArray(layer.errors)) for (const child of layer.errors) {
+			const childText = child instanceof Error && child.message !== "" ? child.message : String(child);
+			if (childText !== "" && !parts.includes(childText)) parts.push(childText);
+		}
+		let text = layer instanceof Error ? layer.message : String(node);
+		const code = layer.code;
+		if (typeof code === "string" && code !== "") {
+			if (text === "") text = code;
+			else if (!text.includes(code)) text = `${text} (${code})`;
+		}
+		if (text !== "" && !parts.includes(text)) parts.push(text);
+		const next = layer.cause;
+		if (next === void 0 || next === null || next === node) break;
+		node = next;
+	}
+	return parts.join(" → ");
+}
+function withError(error) {
+	configError = errorMessage(error);
+}
+/**
+* Parse and validate a proxy URL. Only HTTP(S) proxies are supported because
+* the undici dispatcher speaks CONNECT over HTTP; socks5 is not supported.
+* @param raw - the URL the user configured.
+* @returns the parsed URL (credentials attached by the caller).
+*/
+function parseProxyUrl(raw) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new Error(`proxy URL "${raw}" is not a valid URL`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`proxy URL must use the http:// or https:// scheme (got "${raw}")`);
+	if (url.hostname === "") throw new Error("proxy URL must include a host");
+	return url;
+}
+/**
+* Whether a request hostname bypasses the proxy.
+* @param hostname - the request's hostname.
+* @param entries - configured bypass entries: exact host, plain suffix
+*   (`example.com` also matches `api.example.com`), or `*.example.com`.
+*/
+function matchesBypass(hostname, entries) {
+	const host = hostname.toLowerCase();
+	for (const raw of entries) {
+		let entry = raw.trim().toLowerCase();
+		if (entry === "") continue;
+		if (entry.includes("://")) try {
+			entry = new URL(entry).hostname;
+		} catch {
+			continue;
+		}
+		entry = entry.replace(/:\d+$/, "");
+		if (entry === "" || entry === "*") continue;
+		if (entry.startsWith("*.")) {
+			if (host.endsWith(entry.slice(1))) return true;
+		} else if (host === entry || host.endsWith(`.${entry}`)) return true;
+	}
+	return false;
+}
+/** Validate and normalize one config (throws with a user-facing message). */
+function normalizeConfig(input) {
+	const url = input.url.trim();
+	if (input.enabled && url === "") throw new Error("a proxy URL is required when the proxy is enabled");
+	if (url !== "") parseProxyUrl(url);
+	const bypass = Array.from(new Set((input.bypass ?? []).map((entry) => entry.trim()).filter((entry) => entry !== "")));
+	return {
+		enabled: input.enabled,
+		url,
+		...input.username !== void 0 && input.username !== "" ? { username: input.username.trim() } : {},
+		...input.password !== void 0 && input.password !== "" && input.password !== null ? { password: input.password } : {},
+		bypass
+	};
+}
+/** Build the undici agent for a config (throws on an unusable URL). */
+function buildAgent(cfg) {
+	if (!cfg.enabled || cfg.url === "") return void 0;
+	const url = parseProxyUrl(cfg.url);
+	if (cfg.username !== void 0) url.username = cfg.username;
+	if (cfg.password !== void 0) url.password = cfg.password;
+	return new ProxyAgent(url.toString());
+}
+/** Swap in a config and its agent; a failed agent keeps the requests direct. */
+async function applyConfig(cfg) {
+	let next;
+	if (cfg !== void 0) {
+		configError = void 0;
+		try {
+			next = buildAgent(cfg);
+		} catch (error) {
+			withError(error);
+			next = void 0;
+		}
+		current = cfg;
+	}
+	const previous = agent;
+	agent = next;
+	if (previous !== void 0) previous.close().catch(() => void 0);
+}
+/** Read the on-disk config. A missing file is the disabled default. */
+async function loadConfigFile(path) {
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			...DISABLED,
+			bypass: []
+		};
+		throw error;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new Error(`subscriptions proxy config at ${path} is not valid JSON; fix or delete the file`);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("subscriptions proxy config must be a JSON object");
+	const record = parsed;
+	const enabled = record.enabled === true;
+	const url = typeof record.url === "string" ? record.url : "";
+	const username = typeof record.username === "string" ? record.username : void 0;
+	const password = typeof record.password === "string" ? record.password : void 0;
+	const bypass = Array.isArray(record.bypass) ? record.bypass.filter((entry) => typeof entry === "string") : [];
+	return normalizeConfig({
+		enabled,
+		url,
+		...username === void 0 ? {} : { username },
+		...password === void 0 ? {} : { password },
+		bypass
+	});
+}
+/** Resolve the module state once from disk; failures disable the proxy. */
+async function ensureReady() {
+	ready ??= loadConfigFile(proxyFilePath()).then(async (cfg) => {
+		await applyConfig(cfg);
+		return current;
+	}, async (error) => {
+		withError(error);
+		await applyConfig(void 0);
+		return current;
+	});
+	return ready;
+}
+/** Persist a config atomically with owner-only permissions, then apply it. */
+async function persistConfig(cfg, path) {
+	await mkdir(dirname(path), { recursive: true });
+	const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+	try {
+		await writeFile(tmp, JSON.stringify(cfg, null, 2), { mode: 384 });
+		await chmod(tmp, 384);
+		await rename(tmp, path);
+	} catch (error) {
+		await rm(tmp, { force: true });
+		throw error;
+	}
+}
+/**
+* Current proxy config as served to the client (secrets omitted).
+* @returns the view; {@link ProxyConfigView.error} carries the last
+*   load/apply failure when the stored config is unusable.
+*/
+async function proxyGetConfig() {
+	await ensureReady();
+	return {
+		enabled: current.enabled,
+		url: current.url,
+		...current.username === void 0 ? {} : { username: current.username },
+		passwordSet: current.password !== void 0 && current.password !== "",
+		bypass: [...current.bypass],
+		...configError === void 0 ? {} : { error: configError }
+	};
+}
+/**
+* Validate, persist, and apply one proxy config. A `password` of `undefined`
+* keeps the stored value; `null` or `''` clears it.
+* @param input - the client's payload.
+* @returns the resulting view (secrets omitted).
+*/
+async function proxySetConfig(input) {
+	await ensureReady();
+	const password = input.password === void 0 ? current.password : input.password === null || input.password === "" ? void 0 : input.password;
+	const next = normalizeConfig({
+		enabled: input.enabled,
+		url: input.url,
+		...input.username === void 0 ? {} : { username: input.username },
+		...password === void 0 ? {} : { password },
+		bypass: input.bypass ?? current.bypass
+	});
+	await persistConfig(next, proxyFilePath());
+	await applyConfig(next);
+	return proxyGetConfig();
+}
+/**
+* The fetch caller all subscription code uses: routes through the configured
+* proxy unless the host bypasses it. Identity-passthrough otherwise.
+*
+* Proxied requests run on undici's own fetch (not the global one) so the
+* ProxyAgent dispatcher always comes from the same undici build the request
+* is issued with — a mismatched dispatcher can be silently ignored by the
+* host's global fetch.
+*/
+async function proxiedFetch(input, init = {}) {
+	await ensureReady();
+	let dispatcher;
+	if (current.enabled && agent !== void 0) {
+		let hostname = "";
+		try {
+			hostname = (typeof input === "string" ? new URL(input) : input instanceof URL ? input : new URL(input.url)).hostname;
+		} catch {
+			hostname = "";
+		}
+		if (!matchesBypass(hostname, current.bypass)) dispatcher = agent;
+	}
+	if (dispatcher === void 0) return fetch(input, init);
+	return dispatchFetch(input, {
+		...init,
+		dispatcher
+	});
+}
+/**
+* Probe a destination through a proxy, answering with the HTTP status or a
+* flattened transport error. The probe uses `draft` when given (the dialog's
+* current inputs, without saving) and the stored config otherwise.
+* @param target - `http(s)` URL to fetch; defaults to {@link DEFAULT_PROXY_TEST_URL}.
+* @param draft - unsaved proxy inputs to test; absent means the stored config.
+* @returns the result; any HTTP status counts as a successful connection,
+*   only a transport failure is an error.
+*/
+async function proxyTestConnection(target = DEFAULT_PROXY_TEST_URL, draft) {
+	let parsed;
+	try {
+		parsed = new URL(target);
+		if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return {
+			ok: false,
+			viaProxy: false,
+			error: `test destination must be http or https (got "${parsed.protocol}//")`
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			viaProxy: false,
+			error: errorMessage(error)
+		};
+	}
+	await ensureReady();
+	let probeAgent;
+	let viaProxy;
+	let closeProbe = false;
+	if (draft !== void 0) try {
+		probeAgent = buildAgent(normalizeConfig({
+			enabled: true,
+			url: draft.url,
+			...draft.username === void 0 || draft.username === "" ? {} : { username: draft.username },
+			...draft.password === void 0 || draft.password === "" ? {} : { password: draft.password },
+			bypass: []
+		}));
+		viaProxy = probeAgent !== void 0;
+		closeProbe = true;
+	} catch (error) {
+		return {
+			ok: false,
+			viaProxy: false,
+			error: errorMessage(error)
+		};
+	}
+	else {
+		viaProxy = current.enabled && agent !== void 0 && !matchesBypass(parsed.hostname, current.bypass);
+		probeAgent = viaProxy ? agent : void 0;
+	}
+	const started = Date.now();
+	try {
+		const init = probeAgent !== void 0 ? {
+			method: "GET",
+			dispatcher: probeAgent,
+			signal: AbortSignal.timeout(DEFAULT_PROXY_TEST_TIMEOUT_MS)
+		} : {
+			method: "GET",
+			signal: AbortSignal.timeout(DEFAULT_PROXY_TEST_TIMEOUT_MS)
+		};
+		const response = probeAgent !== void 0 ? await dispatchFetch(parsed.toString(), init) : await fetch(parsed.toString(), init);
+		response.arrayBuffer().catch(() => void 0);
+		return {
+			ok: true,
+			viaProxy,
+			status: response.status,
+			latencyMs: Date.now() - started
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			viaProxy,
+			latencyMs: Date.now() - started,
+			error: describeFetchError(error)
+		};
+	} finally {
+		if (closeProbe && probeAgent !== void 0) await probeAgent.close().catch(() => void 0);
+	}
+}
+
+//#endregion
+//#region src/auth/device-flow.ts
+/** Default poll interval when the device-code response omits one. */
+const DEFAULT_INTERVAL_SEC = 5;
+/** Default device-code lifetime when the response omits one (GitHub: 15 minutes). */
+const DEFAULT_EXPIRES_IN_SEC = 900;
+/** Sleep for `ms`, rejecting early when the signal aborts. */
+function sleep$1(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			reject(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("aborted"));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		timer.unref();
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("aborted"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Own the set of in-flight device-flow attempts, keyed by provider. One
+* attempt per provider at a time; an attempt removes itself when it settles.
+*/
+var DeviceFlowManager = class {
+	attempts = /* @__PURE__ */ new Map();
+	/**
+	* Whether a device-flow attempt is running for one provider.
+	* @param provider - the provider route.
+	* @returns true while an attempt is polling.
+	*/
+	isBusy(provider) {
+		return this.attempts.has(provider);
+	}
+	/**
+	* The pending attempt for one provider, when any.
+	* @param provider - the provider route.
+	* @returns the in-flight attempt, or `undefined`.
+	*/
+	pending(provider) {
+		return this.attempts.get(provider);
+	}
+	/**
+	* Start a device-flow attempt: request a device code, then poll the token
+	* endpoint in the background of `waitToken`.
+	* @param provider - the provider route (one attempt at a time).
+	* @param spec - static flow facts for this provider.
+	* @returns the live attempt; its `waitToken()` settles the login.
+	* @throws when an attempt is already running or the device-code request fails.
+	*/
+	async start(provider, spec) {
+		if (this.attempts.has(provider)) throw new Error(`a ${provider} login attempt is already in progress`);
+		const fetchFn = spec.fetchFn ?? proxiedFetch;
+		const response = await fetchFn(spec.deviceCodeUrl, {
+			method: "POST",
+			headers: {
+				"accept": "application/json",
+				"content-type": "application/x-www-form-urlencoded"
+			},
+			body: new URLSearchParams({
+				client_id: spec.clientId,
+				scope: spec.scope
+			}).toString()
+		});
+		if (!response.ok) throw new Error(`${provider} device-code request failed (HTTP ${String(response.status)})`);
+		const wire = await response.json();
+		if (typeof wire.device_code !== "string" || wire.device_code.length === 0 || typeof wire.user_code !== "string" || wire.user_code.length === 0 || typeof wire.verification_uri !== "string" || wire.verification_uri.length === 0) throw new Error(`${provider} device-code response is missing device_code/user_code/verification_uri`);
+		const intervalSec = typeof wire.interval === "number" && wire.interval > 0 ? wire.interval : DEFAULT_INTERVAL_SEC;
+		const expiresInSec = typeof wire.expires_in === "number" && wire.expires_in > 0 ? wire.expires_in : DEFAULT_EXPIRES_IN_SEC;
+		const controller = new AbortController();
+		let resolveToken;
+		let rejectToken;
+		const tokenPromise = new Promise((resolve, reject) => {
+			resolveToken = resolve;
+			rejectToken = reject;
+		});
+		tokenPromise.catch(() => void 0);
+		const settle = (error, token) => {
+			if (this.attempts.get(provider) !== attempt) return;
+			this.attempts.delete(provider);
+			if (error !== void 0) rejectToken(error);
+			else if (token !== void 0) resolveToken(token);
+		};
+		const poll = async () => {
+			let intervalMs = intervalSec * 1e3;
+			const deadline = Date.now() + expiresInSec * 1e3;
+			while (true) {
+				await sleep$1(intervalMs, controller.signal);
+				if (Date.now() >= deadline) {
+					settle(/* @__PURE__ */ new Error(`login timed out after ${String(Math.round(expiresInSec))}s`));
+					return;
+				}
+				const pollResponse = await fetchFn(spec.tokenUrl, {
+					method: "POST",
+					headers: {
+						"accept": "application/json",
+						"content-type": "application/x-www-form-urlencoded"
+					},
+					body: new URLSearchParams({
+						client_id: spec.clientId,
+						device_code: wire.device_code,
+						grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+					}).toString(),
+					signal: controller.signal
+				});
+				const result = await pollResponse.json();
+				if (typeof result.access_token === "string" && result.access_token.length > 0) {
+					settle(void 0, result.access_token);
+					return;
+				}
+				switch (result.error) {
+					case "authorization_pending": break;
+					case "slow_down":
+						intervalMs += 5e3;
+						break;
+					case "access_denied":
+						settle(/* @__PURE__ */ new Error("login declined on the GitHub authorization page"));
+						return;
+					case "expired_token":
+						settle(/* @__PURE__ */ new Error("the device code expired before authorization completed"));
+						return;
+					default:
+						settle(/* @__PURE__ */ new Error(`${provider} device-flow polling failed: ${result.error_description ?? result.error ?? `HTTP ${String(pollResponse.status)}`}`));
+						return;
+				}
+			}
+		};
+		const attempt = {
+			verificationUrl: wire.verification_uri,
+			userCode: wire.user_code,
+			waitToken: () => tokenPromise,
+			cancel: () => {
+				controller.abort(/* @__PURE__ */ new Error("login cancelled"));
+				settle(/* @__PURE__ */ new Error("login cancelled"));
+			}
+		};
+		this.attempts.set(provider, attempt);
+		poll().catch((error) => {
+			settle(error instanceof Error ? error : new Error(String(error)));
+		});
+		return attempt;
+	}
+};
+
 //#endregion
 //#region src/auth/claude-code-creds.ts
 const PRIMARY_SERVICE = "Claude Code-credentials";
@@ -437,7 +935,8 @@ async function refreshClaudeSynced(session, doRefresh) {
 const PROVIDER_IDS = [
 	"codex",
 	"claude",
-	"grok"
+	"grok",
+	"copilot"
 ];
 /**
 * Absolute path of the auth store file.
@@ -513,6 +1012,34 @@ async function writeStore(store, path) {
 	}
 }
 /**
+* One write chain per store path. Every mutation is a read-modify-write of a
+* single JSON file, and the plugin has several independent writers — a login,
+* a logout, and one token refresh per provider adapter, each on its own
+* schedule. Overlapping them unserialized costs whichever provider read the
+* store first its entry.
+*
+* A chain is dropped once nothing is queued behind it, so the map holds an
+* entry only while writes are in flight.
+*/
+const writeChains = /* @__PURE__ */ new Map();
+/**
+* Run one read-modify-write of a store path after every write already queued
+* for it. Callers join the chain synchronously, so call order is write order.
+* @param path - the store file being mutated.
+* @param action - the read-modify-write to run.
+* @returns whatever `action` returns.
+*/
+async function serialize(path, action) {
+	const next = (writeChains.get(path) ?? Promise.resolve()).then(action, action);
+	const tail = next.then(() => void 0, () => void 0);
+	writeChains.set(path, tail);
+	try {
+		return await next;
+	} finally {
+		if (writeChains.get(path) === tail) writeChains.delete(path);
+	}
+}
+/**
 * Read one provider's session.
 * @param provider - the provider route.
 * @param path - store file path; defaults to {@link authFilePath}.
@@ -528,9 +1055,11 @@ async function getSession(provider, path = authFilePath()) {
 * @param path - store file path; defaults to {@link authFilePath}.
 */
 async function saveSession(provider, session, path = authFilePath()) {
-	const store = await loadStore(path);
-	store[provider] = session;
-	await writeStore(store, path);
+	return serialize(path, async () => {
+		const store = await loadStore(path);
+		store[provider] = session;
+		await writeStore(store, path);
+	});
 }
 /**
 * Delete one provider's session (logout).
@@ -538,10 +1067,12 @@ async function saveSession(provider, session, path = authFilePath()) {
 * @param path - store file path; defaults to {@link authFilePath}.
 */
 async function deleteSession(provider, path = authFilePath()) {
-	const store = await loadStore(path);
-	if (store[provider] === void 0) return;
-	delete store[provider];
-	await writeStore(store, path);
+	return serialize(path, async () => {
+		const store = await loadStore(path);
+		if (store[provider] === void 0) return;
+		delete store[provider];
+		await writeStore(store, path);
+	});
 }
 
 //#endregion
@@ -644,7 +1175,69 @@ function readSessionId(payload) {
 	if (typeof payload !== "object" || payload === null) throw new BadRequest("payload must be an object");
 	return readString(payload, "sessionId");
 }
-async function dispatch(controller, speed, endpoint, payload, signal) {
+/** Validate a `proxySet` payload into a shape `ProxyInput` accepts. */
+function readProxyInput(payload) {
+	if (typeof payload !== "object" || payload === null) throw new BadRequest("payload must be an object");
+	const record = payload;
+	if (typeof record.enabled !== "boolean") throw new BadRequest("payload.enabled must be a boolean");
+	if (typeof record.url !== "string") throw new BadRequest("payload.url must be a string");
+	let username;
+	if (record.username !== void 0) {
+		if (typeof record.username !== "string") throw new BadRequest("payload.username must be a string when present");
+		username = record.username;
+	}
+	let password;
+	if (record.password !== void 0) {
+		if (record.password !== null && typeof record.password !== "string") throw new BadRequest("payload.password must be a string or null when present");
+		password = record.password;
+	}
+	let bypass;
+	if (record.bypass !== void 0) {
+		if (!Array.isArray(record.bypass) || record.bypass.some((entry) => typeof entry !== "string")) throw new BadRequest("payload.bypass must be an array of strings when present");
+		bypass = record.bypass;
+	}
+	return {
+		enabled: record.enabled,
+		url: record.url,
+		...username === void 0 ? {} : { username },
+		...password === void 0 ? {} : { password },
+		...bypass === void 0 ? {} : { bypass }
+	};
+}
+/** Validate a `proxyTest` payload (the destination URL and an optional draft). */
+function readProxyTestPayload(payload) {
+	if (typeof payload !== "object" || payload === null) return {};
+	const record = payload;
+	const url = record.url;
+	if (url === void 0 && record.proxy === void 0) return {};
+	if (url !== void 0 && (typeof url !== "string" || url.length === 0)) throw new BadRequest("payload.url must be a non-empty string when present");
+	let proxy;
+	if (record.proxy !== void 0) {
+		if (typeof record.proxy !== "object" || record.proxy === null) throw new BadRequest("payload.proxy must be an object when present");
+		const draftRecord = record.proxy;
+		if (typeof draftRecord.url !== "string" || draftRecord.url.length === 0) throw new BadRequest("payload.proxy.url must be a non-empty string");
+		let username;
+		if (draftRecord.username !== void 0) {
+			if (typeof draftRecord.username !== "string") throw new BadRequest("payload.proxy.username must be a string when present");
+			username = draftRecord.username;
+		}
+		let password;
+		if (draftRecord.password !== void 0) {
+			if (typeof draftRecord.password !== "string") throw new BadRequest("payload.proxy.password must be a string when present");
+			password = draftRecord.password;
+		}
+		proxy = {
+			url: draftRecord.url,
+			...username === void 0 ? {} : { username },
+			...password === void 0 ? {} : { password }
+		};
+	}
+	return {
+		...url === void 0 ? {} : { url },
+		...proxy === void 0 ? {} : { proxy }
+	};
+}
+async function dispatch(controller, speed, proxy, endpoint, payload, signal) {
 	switch (endpoint) {
 		case "status": {
 			const entries = await Promise.all(PROVIDER_IDS.map(async (provider) => [provider, await controller.status(provider)]));
@@ -669,6 +1262,15 @@ async function dispatch(controller, speed, endpoint, payload, signal) {
 		case "setSpeed":
 			await speed.setSpeed(readSessionId(payload), readSpeedTier(payload));
 			return ok({ ok: true });
+		case "proxyGet":
+			if (proxy === void 0) throw new BadRequest("proxy configuration is unavailable");
+			return ok(await proxy.get());
+		case "proxySet":
+			if (proxy === void 0) throw new BadRequest("proxy configuration is unavailable");
+			return ok(await proxy.set(readProxyInput(payload)));
+		case "proxyTest":
+			if (proxy === void 0) throw new BadRequest("proxy configuration is unavailable");
+			return ok(await proxy.test(readProxyTestPayload(payload)));
 		default: throw new BadRequest(`unknown /subscriptions-auth endpoint "${endpoint}"`);
 	}
 }
@@ -677,13 +1279,14 @@ async function dispatch(controller, speed, endpoint, payload, signal) {
 * @param ctx - the plugin context (headless profiles have no `connection`).
 * @param controller - the auth operations backing the endpoints.
 * @param speed - the per-session speed-tier state backing the Speed toggle.
+* @param proxy - optional proxy-config controller backing `proxyGet`/`proxySet`/`proxyTest`.
 */
-function registerAuthRpc(ctx, controller, speed) {
+function registerAuthRpc(ctx, controller, speed, proxy = void 0) {
 	ctx.inject(["connection"], (ctx$1) => {
 		const connection = ctx$1.get("connection");
 		ctx$1.effect(() => connection.rpc.handle(SUBSCRIPTIONS_AUTH_CHANNEL, async (endpoint, payload, signal) => {
 			try {
-				return await dispatch(controller, speed, endpoint, payload, signal);
+				return await dispatch(controller, speed, proxy, endpoint, payload, signal);
 			} catch (error) {
 				return failure(error);
 			}
@@ -707,6 +1310,7 @@ function validateModels(models, label) {
 		if (model.contextWindow !== void 0 && (!Number.isInteger(model.contextWindow) || model.contextWindow <= 0)) throw new Error(`${label}: catalog model "${model.id}" contextWindow must be a positive integer`);
 		if (model.maxTokens !== void 0 && (!Number.isInteger(model.maxTokens) || model.maxTokens <= 0)) throw new Error(`${label}: catalog model "${model.id}" maxTokens must be a positive integer`);
 		if (model.inputModalities !== void 0 && (model.inputModalities.length === 0 || model.inputModalities.some((modality) => modality !== "text" && modality !== "image"))) throw new Error(`${label}: catalog model "${model.id}" inputModalities must be a non-empty list of "text"/"image"`);
+		if (model.wire !== void 0 && model.wire !== "chat-completions" && model.wire !== "responses") throw new Error(`${label}: catalog model "${model.id}" wire must be "chat-completions" or "responses"`);
 		if (seen.has(model.id)) throw new Error(`${label}: duplicate catalog model "${model.id}"`);
 		seen.add(model.id);
 		return {
@@ -714,7 +1318,8 @@ function validateModels(models, label) {
 			...model.name === void 0 ? {} : { name: model.name },
 			...model.contextWindow === void 0 ? {} : { contextWindow: model.contextWindow },
 			...model.maxTokens === void 0 ? {} : { maxTokens: model.maxTokens },
-			...model.inputModalities === void 0 ? {} : { inputModalities: [...model.inputModalities] }
+			...model.inputModalities === void 0 ? {} : { inputModalities: [...model.inputModalities] },
+			...model.wire === void 0 ? {} : { wire: model.wire }
 		};
 	});
 }
@@ -882,9 +1487,9 @@ var TokenManager = class {
 		}
 	}
 	async doRefresh(session) {
-		const current = await this.options.load();
-		if (current !== void 0 && current.accessToken !== session.accessToken && current.expiresAt - Date.now() > this.options.preemptMs) return current;
-		const next = await this.options.refresh(current ?? session);
+		const current$1 = await this.options.load();
+		if (current$1 !== void 0 && current$1.accessToken !== session.accessToken && current$1.expiresAt - Date.now() > this.options.preemptMs) return current$1;
+		const next = await this.options.refresh(current$1 ?? session);
 		await this.options.save(next);
 		return next;
 	}
@@ -901,7 +1506,7 @@ const DISCOVERY_TTL_MS = 5 * 6e4;
 * while a stale entry refreshes in the background, and only awaits the fetch
 * when nothing is known yet. An optional {@link CatalogPersistence} seeds the
 * last-known state across restarts and receives every successful fetch. A 401
-* during a fetch must call {@link invalidate}.
+* that still fails after a forced token refresh must call {@link invalidate}.
 */
 var ModelCatalogCache = class {
 	entry;
@@ -922,6 +1527,14 @@ var ModelCatalogCache = class {
 		if (this.entry === void 0 || Date.now() - this.entry.at >= this.ttlMs) return void 0;
 		return this.entry.models;
 	}
+	/**
+	* The last successfully fetched catalog, ignoring TTL. Used to carry
+	* capability metadata forward when a later fetch cannot re-enrich.
+	* @returns the last-known models, or `undefined` when nothing has been stored.
+	*/
+	lastKnown() {
+		return this.entry?.models;
+	}
 	/** Load the persisted snapshot once; a fetch or invalidate that landed first wins. */
 	ensureSeeded() {
 		if (this.persistence === void 0) return Promise.resolve();
@@ -986,6 +1599,34 @@ var ModelCatalogCache = class {
 		this.persistence?.clear().catch(() => void 0);
 	}
 };
+/** Whether discovery failed because the stored login is gone. */
+function isMissingOrInvalidCredential(error) {
+	return error instanceof LlmError && (error.code === "MISSING_CREDENTIAL" || error.code === "INVALID_CREDENTIAL");
+}
+/** Whether discovery failed because the access token was rejected. */
+function isDiscoveryAuthFailure(error) {
+	return error instanceof OAuthEndpointError && error.status === 401 || error instanceof LlmError && error.code === "AUTH";
+}
+/**
+* Run a catalog fetch, retrying once after a forced token refresh when the
+* first attempt is a 401/AUTH. Only {@link ModelCatalogCache.invalidate}s
+* when the retry is also an auth failure, so a refresh race cannot erase
+* last-known capability metadata.
+*/
+async function discoverOrRetryAuth(session, catalog, run) {
+	try {
+		return await run();
+	} catch (error) {
+		if (isMissingOrInvalidCredential(error) || !isDiscoveryAuthFailure(error)) throw error;
+		try {
+			await session(true);
+			return await run();
+		} catch (retryError) {
+			if (!isMissingOrInvalidCredential(retryError) && isDiscoveryAuthFailure(retryError)) catalog.invalidate();
+			throw retryError;
+		}
+	}
+}
 
 //#endregion
 //#region src/providers/catalog-store.ts
@@ -1031,6 +1672,12 @@ function sanitizeModel(value) {
 	if (thinkingType !== void 0 && thinkingType !== "enabled" && thinkingType !== "adaptive") return void 0;
 	const fastTier = raw.fastTier;
 	if (fastTier !== void 0 && typeof fastTier !== "boolean") return void 0;
+	const copilotWire = raw.copilotWire;
+	if (copilotWire !== void 0 && copilotWire !== "chat-completions" && copilotWire !== "responses") return;
+	const copilotResponses = raw.copilotResponses;
+	if (copilotResponses !== void 0 && typeof copilotResponses !== "boolean") return void 0;
+	const inputModalities = raw.inputModalities;
+	if (inputModalities !== void 0 && (!Array.isArray(inputModalities) || inputModalities.length === 0 || inputModalities.some((modality) => modality !== "text" && modality !== "image"))) return void 0;
 	return {
 		id: raw.id,
 		name: raw.name,
@@ -1039,7 +1686,10 @@ function sanitizeModel(value) {
 		...raw.priority === void 0 ? {} : { priority: raw.priority },
 		...reasoning === void 0 ? {} : { reasoning },
 		...thinkingType === void 0 ? {} : { thinkingType },
-		...fastTier === void 0 ? {} : { fastTier }
+		...fastTier === void 0 ? {} : { fastTier },
+		...copilotWire === void 0 ? {} : { copilotWire },
+		...copilotResponses === void 0 ? {} : { copilotResponses },
+		...inputModalities === void 0 ? {} : { inputModalities: [...inputModalities] }
 	};
 }
 /**
@@ -1221,22 +1871,31 @@ async function* parseSse(stream, onActivity) {
 //#endregion
 //#region src/translate/responses.ts
 /** Flatten a tool result's content to plain text for `function_call_output`. */
-function toolResultText$1(block) {
+function toolResultText$2(block) {
 	return block.content.map((part) => part.type === "text" ? part.text : "").join("");
 }
 /**
 * Convert harness messages into Responses `instructions` + `input` items.
 * System-role messages become `instructions`; an explicit `system` argument
-* wins over them when both exist. Reasoning blocks are not replayed (v1).
-* Images must arrive pre-resolved ({@link TranslatableMessage}); an unresolved
-* ImageBlock is skipped because its bytes are unreachable here.
+* wins over them when both exist. Reasoning blocks are never replayed in
+* their text form: a Responses model continuing past a tool call needs its
+* reasoning back as the provider's completed reasoning items (id, summary,
+* and the ENCRYPTED payload), so `reasoningFor` may resolve per-call
+* captured items, replayed ahead of the matching function_call item. Images
+* must arrive pre-resolved
+* ({@link TranslatableMessage}); an unresolved ImageBlock is skipped because
+* its bytes are unreachable here.
 * @param messages - ordered conversation messages with resolved images.
 * @param system - explicit system prompt, which takes precedence.
+* @param reasoningFor - resolves one tool call id to the COMPLETED reasoning
+*   items captured for it (id, summary, status, encrypted payload), replayed
+*   ahead of the matching function_call item, when the adapter kept them.
 * @returns request fields ready to merge into the request body.
 */
-function toResponsesInput(messages, system) {
+function toResponsesInput(messages, system, reasoningFor) {
 	const input = [];
 	const systemTexts = [];
+	let lastReplay;
 	for (const message of messages) {
 		if (message.role === "system") {
 			for (const block of message.content) if (block.type === "text") systemTexts.push(block.text);
@@ -1260,8 +1919,19 @@ function toResponsesInput(messages, system) {
 					text: block.text
 				});
 				break;
-			case "tool-call":
+			case "tool-call": {
 				flushMessage();
+				const encrypted = reasoningFor?.(String(block.id));
+				if (encrypted !== void 0 && encrypted !== lastReplay) {
+					for (const item of encrypted) input.push({
+						type: "reasoning",
+						...item.id === void 0 ? {} : { id: item.id },
+						...item.summary === void 0 ? {} : { summary: item.summary },
+						...item.status === void 0 ? {} : { status: item.status },
+						encrypted_content: item.encrypted_content
+					});
+					lastReplay = encrypted;
+				}
 				input.push({
 					type: "function_call",
 					call_id: String(block.id),
@@ -1269,12 +1939,13 @@ function toResponsesInput(messages, system) {
 					arguments: block.arguments
 				});
 				break;
+			}
 			case "tool-result":
 				flushMessage();
 				input.push({
 					type: "function_call_output",
 					call_id: String(block.toolCallId),
-					output: toolResultText$1(block)
+					output: toolResultText$2(block)
 				});
 				break;
 			case "image":
@@ -1336,7 +2007,7 @@ function responsesFailure(code, message) {
 	return new LlmError(text, "SERVER");
 }
 /** Assemble the final ContentBlock for one open block. */
-function closeBlock$1(block) {
+function closeBlock$2(block) {
 	switch (block.kind) {
 		case "text": return {
 			type: "text",
@@ -1398,7 +2069,7 @@ var ResponsesStreamTranslator = class {
 		chunks.push({
 			type: "block-end",
 			index: block.index,
-			block: closeBlock$1(block)
+			block: closeBlock$2(block)
 		});
 	}
 	/** Close every still-open block for one output item (prefix match on the key). */
@@ -1415,7 +2086,7 @@ var ResponsesStreamTranslator = class {
 			chunks.push({
 				type: "block-end",
 				index: block.index,
-				block: closeBlock$1(block)
+				block: closeBlock$2(block)
 			});
 			return;
 		}
@@ -1540,9 +2211,12 @@ var ResponsesStreamTranslator = class {
 * Consume a Responses SSE byte stream and yield harness StreamChunks.
 * @param stream - raw response body.
 * @param onActivity - transport-activity callback for the idle watchdog.
+* @param transform - optional per-event rewrite applied before translation
+*   (Copilot's gateway mints a fresh item id per event; the adapter rewrites
+*   them into stable per-item keys).
 * @returns the chunk stream; throws when the stream ends before `response.completed`.
 */
-async function* streamResponses(stream, onActivity) {
+async function* streamResponses(stream, onActivity, transform) {
 	const translator = new ResponsesStreamTranslator();
 	for await (const sseEvent of parseSse(stream, onActivity)) {
 		let event;
@@ -1551,6 +2225,7 @@ async function* streamResponses(stream, onActivity) {
 		} catch {
 			throw new LlmError(`malformed SSE payload: ${sseEvent.data.slice(0, 120)}`, "MALFORMED_RESPONSE");
 		}
+		if (transform !== void 0) event = transform(event);
 		yield* translator.push(event);
 		if (translator.terminated) return;
 	}
@@ -1697,7 +2372,7 @@ function codexSession(tokens, fallback) {
 * @returns the session to store.
 */
 async function exchangeCodexCode(code, verifier, redirectUri) {
-	const response = await fetch(CODEX_TOKEN_URL, {
+	const response = await proxiedFetch(CODEX_TOKEN_URL, {
 		method: "POST",
 		headers: { "content-type": "application/x-www-form-urlencoded" },
 		body: new URLSearchParams({
@@ -1717,7 +2392,7 @@ async function exchangeCodexCode(code, verifier, redirectUri) {
 * @returns the fresh session to store.
 */
 async function refreshCodex(session) {
-	const response = await fetch(CODEX_TOKEN_URL, {
+	const response = await proxiedFetch(CODEX_TOKEN_URL, {
 		method: "POST",
 		headers: { "content-type": "application/json" },
 		body: JSON.stringify({
@@ -1785,7 +2460,7 @@ function codexUsageWindow(value, fallbackKind) {
 * @param signal - caller cancellation from the RPC transport.
 * @returns the mapped usage snapshot.
 */
-async function fetchCodexUsage(session, fetchFn = fetch, signal) {
+async function fetchCodexUsage(session, fetchFn = proxiedFetch, signal) {
 	const response = await fetchFn(CODEX_USAGE_URL, {
 		headers: {
 			"authorization": `Bearer ${session.accessToken}`,
@@ -1835,7 +2510,7 @@ function supportsFastTier(entry) {
 * @param fetchFn - fetch implementation (injectable for tests).
 * @returns discovered models: hidden entries dropped, sorted by priority.
 */
-async function fetchCodexModels(session, fetchFn = fetch) {
+async function fetchCodexModels(session, fetchFn = proxiedFetch) {
 	const response = await fetchFn(`${CODEX_MODELS_URL}?client_version=${CODEX_CLIENT_VERSION}`, { headers: {
 		"authorization": `Bearer ${session.accessToken}`,
 		"chatgpt-account-id": session.accountId,
@@ -1874,6 +2549,50 @@ async function fetchCodexModels(session, fetchFn = fetch) {
 	if (discovered.length === 0) throw new Error(`codex models endpoint returned an empty catalog (client_version ${CODEX_CLIENT_VERSION})`);
 	return discovered;
 }
+const CODEX_CALL_ID_MAX_LENGTH = 64;
+const CODEX_CALL_ID_PREFIX = "call_";
+/**
+* Bound tool-call ids at the Codex wire boundary without changing the shared
+* Responses translation used by Grok. Short ids stay verbatim. Oversized ids
+* become deterministic hashes, and every id already present in this request
+* is reserved first so a generated id cannot collide with a legitimate short
+* one (or another oversized id).
+*/
+function normalizeCodexCallIds(input) {
+	const mapping = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	const callId = (item) => (item.type === "function_call" || item.type === "function_call_output") && typeof item.call_id === "string" ? item.call_id : void 0;
+	for (const item of input) {
+		const id = callId(item);
+		if (id !== void 0 && id.length <= CODEX_CALL_ID_MAX_LENGTH) {
+			mapping.set(id, id);
+			used.add(id);
+		}
+	}
+	for (const item of input) {
+		const id = callId(item);
+		if (id === void 0 || mapping.has(id)) continue;
+		let attempt = 0;
+		let normalized;
+		do {
+			const hash = createHash("sha256");
+			if (attempt > 0) hash.update(String(attempt)).update("\0");
+			normalized = `${CODEX_CALL_ID_PREFIX}${hash.update(id).digest("hex").slice(0, CODEX_CALL_ID_MAX_LENGTH - 5)}`;
+			attempt += 1;
+		} while (used.has(normalized));
+		mapping.set(id, normalized);
+		used.add(normalized);
+	}
+	return input.map((item) => {
+		const id = callId(item);
+		if (id === void 0) return item;
+		const normalized = mapping.get(id) ?? id;
+		return normalized === id ? item : {
+			...item,
+			call_id: normalized
+		};
+	});
+}
 /**
 * The Responses request body for one generation. A fast-tier request (the
 * composer Speed toggle, the codex CLI's fast mode) carries
@@ -1884,7 +2603,7 @@ function codexRequestBody(options, resolved, fast) {
 	return {
 		model: options.model,
 		instructions: resolved.instructions ?? DEFAULT_CODEX_INSTRUCTIONS,
-		input: resolved.input,
+		input: normalizeCodexCallIds(resolved.input),
 		...options.tools !== void 0 && options.tools.length > 0 ? { tools: toResponsesTools(options.tools) } : {},
 		tool_choice: "auto",
 		parallel_tool_calls: true,
@@ -1929,7 +2648,7 @@ var CodexAdapter = class extends LlmAdapter {
 		if (await this.options.tokens.peek() === void 0) return [];
 		if (!this.options.discovery) return this.staticModels(provider);
 		try {
-			return (await this.catalog.get(() => this.fetchCatalog())).map((model) => ({
+			return (await discoverOrRetryAuth((force) => this.options.tokens.session(force), this.catalog, () => this.catalog.get(() => this.fetchCatalog()))).map((model) => ({
 				provider,
 				id: model.id,
 				name: model.name,
@@ -1937,8 +2656,7 @@ var CodexAdapter = class extends LlmAdapter {
 				inputModalities: CODEX_MODALITIES
 			}));
 		} catch (error) {
-			if (error instanceof LlmError && (error.code === "MISSING_CREDENTIAL" || error.code === "INVALID_CREDENTIAL")) return [];
-			if (error instanceof OAuthEndpointError && error.status === 401) this.catalog.invalidate();
+			if (isMissingOrInvalidCredential(error)) return [];
 			this.options.onWarn?.(`codex model discovery failed; using the built-in catalog (${errorChain(error)})`);
 			return this.staticModels(provider);
 		}
@@ -2005,7 +2723,7 @@ var CodexAdapter = class extends LlmAdapter {
 		const messages = await resolveImages(options.messages, this.options.resolveAttachments?.(), signal);
 		const fast = this.options.speedFor !== void 0 && await this.options.speedFor(options.sessionId, options.model);
 		const body = codexRequestBody(options, toResponsesInput(messages, options.system), fast);
-		return fetch(CODEX_API_URL, {
+		return proxiedFetch(CODEX_API_URL, {
 			method: "POST",
 			headers: {
 				"authorization": `Bearer ${session.accessToken}`,
@@ -2030,8 +2748,27 @@ var CodexAdapter = class extends LlmAdapter {
 * system entry on every request.
 */
 const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
+/** Tags wrapping a mid-conversation system message where it sits in the history. */
+const SYSTEM_REMINDER_OPEN = "<system-reminder>";
+const SYSTEM_REMINDER_CLOSE = "</system-reminder>";
+/**
+* How far apart consecutive message breakpoints sit, in content blocks.
+*
+* A breakpoint looks back at most 20 blocks for an entry an earlier request
+* wrote, so marks must stay closer than that: one agentic turn can append a
+* dozen tool_use/tool_result blocks at once, and a single trailing mark would
+* silently fall out of range and rebuild the whole prefix.
+*/
+const CACHE_BLOCK_STRIDE = 15;
+/**
+* Message breakpoints per request. Anthropic allows four in total and the
+* last `system` block takes the fourth, so three are left for the history —
+* enough to tolerate a turn appending roughly {@link CACHE_BLOCK_STRIDE} × 3
+* blocks before a read is lost.
+*/
+const MESSAGE_CACHE_BREAKPOINTS = 3;
 /** Flatten a tool result's content to plain text for `tool_result`. */
-function toolResultText(block) {
+function toolResultText$1(block) {
 	return block.content.map((part) => part.type === "text" ? part.text : "").join("");
 }
 /** Parse a tool call's raw JSON arguments into Anthropic's object-shaped `input`. */
@@ -2045,11 +2782,49 @@ function parseToolInput(raw) {
 	}
 }
 /**
+* Move a user message's `tool_result` blocks into one contiguous run at the
+* front, preserving the relative order of both groups.
+*
+* Anthropic answers every `tool_use` against the blocks that *lead* the next
+* message, so a block of any other kind before or between the results reads
+* as a call left unanswered and the request is rejected. The harness merges
+* everything queued for one user turn into a single message, and a parallel
+* tool batch arrives as one result message per call, so any context spliced
+* mid-batch lands between two results. Restoring the run here keeps that
+* independent of delivery order. Order *among* the results does not matter.
+* @param message - one assembled user message, reordered in place.
+*/
+function leadWithToolResults(message) {
+	const firstOther = message.content.findIndex((block) => block.type !== "tool_result");
+	if (firstOther === -1) return;
+	if (!message.content.slice(firstOther).some((block) => block.type === "tool_result")) return;
+	message.content = [...message.content.filter((block) => block.type === "tool_result"), ...message.content.filter((block) => block.type !== "tool_result")];
+}
+/**
+* Index of the first non-system message; `messages.length` when every message
+* is a system one.
+*
+* A system message before the conversation starts is the operator's opening
+* instruction and belongs in the `system` slot. One that arrives later is
+* mid-conversation context, and hoisting it into `system` would move bytes in
+* front of the whole history — invalidating every cached turn behind it — so
+* it stays where it is, as a reminder block in `messages`.
+* @param messages - ordered conversation messages.
+* @returns the boundary index separating the two.
+*/
+function conversationStart(messages) {
+	const index = messages.findIndex((message) => message.role !== "system");
+	return index === -1 ? messages.length : index;
+}
+/**
 * Convert harness messages into Anthropic messages. Consecutive same-role
 * messages merge into one message with multiple content blocks; tool results
-* arrive as user messages with `tool_result` blocks; system-role messages are
-* handled by {@link toAnthropicSystem} and skipped here. Reasoning blocks are
-* not replayed (v1). Images must arrive pre-resolved
+* arrive as user messages with `tool_result` blocks, which a merged user
+* message keeps in one leading run ({@link leadWithToolResults}); system-role
+* messages before the conversation starts are handled by
+* {@link toAnthropicSystem} and skipped here, while a later one rides in
+* place as a user-role `<system-reminder>` block.
+* Reasoning blocks are not replayed (v1). Images must arrive pre-resolved
 * ({@link TranslatableMessage}); an unresolved ImageBlock is skipped because
 * its bytes are unreachable here.
 * @param messages - ordered conversation messages with resolved images.
@@ -2057,30 +2832,34 @@ function parseToolInput(raw) {
 */
 function toAnthropicMessages(messages) {
 	const out = [];
-	for (const message of messages) {
-		if (message.role === "system") continue;
-		const role = message.role;
+	const start = conversationStart(messages);
+	for (const [index, message] of messages.entries()) {
+		if (message.role === "system" && index < start) continue;
+		const role = message.role === "system" ? "user" : message.role;
 		const blocks = [];
 		for (const block of message.content) switch (block.type) {
 			case "text":
 				blocks.push({
 					type: "text",
-					text: block.text
+					text: message.role === "system" ? `${SYSTEM_REMINDER_OPEN}${block.text}${SYSTEM_REMINDER_CLOSE}` : block.text
 				});
 				break;
 			case "tool-call":
-				blocks.push({
+				blocks.push(role === "assistant" ? {
 					type: "tool_use",
 					id: String(block.id),
 					name: block.name,
 					input: parseToolInput(block.arguments)
+				} : {
+					type: "text",
+					text: `[tool call ${block.name}: ${block.arguments}]`
 				});
 				break;
 			case "tool-result":
 				blocks.push({
 					type: "tool_result",
 					tool_use_id: String(block.toolCallId),
-					content: toolResultText(block),
+					content: toolResultText$1(block),
 					...block.isError === true ? { is_error: true } : {}
 				});
 				break;
@@ -2104,13 +2883,34 @@ function toAnthropicMessages(messages) {
 			content: blocks
 		});
 	}
+	for (const message of out) if (message.role === "user") leadWithToolResults(message);
 	return out;
 }
 /**
+* Mark the conversation's cache breakpoints in place: the last content block,
+* then one every {@link CACHE_BLOCK_STRIDE} blocks backwards, {@link
+* MESSAGE_CACHE_BREAKPOINTS} in total.
+*
+* The history is append-only, so the block one request marks last is
+* byte-identical in the next — that entry is what the next request reads.
+* Marks are counted across the flattened block sequence, not per message,
+* because the lookback window Anthropic walks counts blocks the same way.
+* @param messages - assembled Anthropic messages, marked in place.
+*/
+function markMessageCache(messages) {
+	const blocks = messages.flatMap((message) => message.content);
+	for (let mark = 0; mark < MESSAGE_CACHE_BREAKPOINTS; mark++) {
+		const at = blocks.length - 1 - mark * CACHE_BLOCK_STRIDE;
+		if (at < 0) return;
+		blocks[at].cache_control = { type: "ephemeral" };
+	}
+}
+/**
 * Build the Anthropic `system` array: the mandatory Claude Code identity
 * block, then the explicit system prompt, then any system-role messages.
 * @param system - explicit system prompt, when set.
-* @param messages - conversation messages; their system-role text is appended.
+* @param messages - conversation messages; the system-role text preceding the
+* conversation is appended, and a later one is left to {@link toAnthropicMessages}.
 * @returns the system content blocks.
 */
 function toAnthropicSystem(system, messages) {
@@ -2122,29 +2922,34 @@ function toAnthropicSystem(system, messages) {
 		type: "text",
 		text: system
 	});
-	for (const message of messages ?? []) {
-		if (message.role !== "system") continue;
-		for (const block of message.content) if (block.type === "text") blocks.push({
-			type: "text",
-			text: block.text
-		});
-	}
+	const history = messages ?? [];
+	for (const message of history.slice(0, conversationStart(history))) for (const block of message.content) if (block.type === "text") blocks.push({
+		type: "text",
+		text: block.text
+	});
+	blocks[blocks.length - 1].cache_control = { type: "ephemeral" };
 	return blocks;
 }
 /**
-* Map harness tool schemas to Anthropic tools.
+* Map harness tool schemas to Anthropic tools, in name order.
+*
+* `tools` renders at position 0 of the cached prefix, so any reordering
+* invalidates every cache entry behind it — `system` and the whole
+* conversation included. Registration order belongs to the caller and plugin
+* load order can differ between processes, so the wire order is fixed here
+* instead. Anthropic selects a tool by name; the array order carries nothing.
 * @param tools - tool schemas from the request.
-* @returns Anthropic `tools` array entries.
+* @returns Anthropic `tools` array entries, ordered by tool name.
 */
 function toAnthropicTools(tools) {
-	return tools.map((tool) => ({
+	return [...tools].sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0).map((tool) => ({
 		name: tool.name,
 		description: tool.description,
 		input_schema: tool.parameters
 	}));
 }
 /** Assemble the final ContentBlock for one open block. */
-function closeBlock(block) {
+function closeBlock$1(block) {
 	switch (block.kind) {
 		case "text": return {
 			type: "text",
@@ -2313,7 +3118,7 @@ var AnthropicStreamTranslator = class {
 				chunks.push({
 					type: "block-end",
 					index: block.index,
-					block: closeBlock(block)
+					block: closeBlock$1(block)
 				});
 				return chunks;
 			}
@@ -2340,7 +3145,7 @@ var AnthropicStreamTranslator = class {
 					chunks.push({
 						type: "block-end",
 						index: block.index,
-						block: closeBlock(block)
+						block: closeBlock$1(block)
 					});
 				}
 				this.emitUsage(chunks);
@@ -2388,11 +3193,13 @@ async function* streamAnthropic(stream, onActivity) {
 //#endregion
 //#region src/providers/claude.ts
 const CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const CLAUDE_AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
 const CLAUDE_TOKEN_URL = "https://claude.ai/v1/oauth/token";
 const CLAUDE_API_URL = "https://api.anthropic.com/v1/messages?beta=true";
 const CLAUDE_PROFILE_URL = "https://api.anthropic.com/api/oauth/profile";
 const CLAUDE_MODELS_URL = "https://api.anthropic.com/v1/models?beta=true";
 const CLAUDE_SCOPE = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
+const CLAUDE_CALLBACK_PATH = "/callback";
 const CLAUDE_CONTEXT_WINDOW = 2e5;
 const CLAUDE_DEFAULT_MAX_TOKENS = 32e3;
 /** Refresh when the access token has less than this much life left. */
@@ -2428,10 +3235,30 @@ const CLAUDE_BETA_FALLBACK = [
 	"files-api-2025-04-14"
 ].join(",");
 const CLAUDE_BETA_FLAGS = CLAUDE_BETA_FALLBACK;
+/** Static claude flow facts for the OAuth flow engine. */
+const claudeFlow = {
+	callbackPath: CLAUDE_CALLBACK_PATH,
+	listen: {
+		host: "localhost",
+		ports: [0]
+	},
+	buildAuthorizeUrl({ redirectUri, state, pkce }) {
+		return `${CLAUDE_AUTHORIZE_URL}?${new URLSearchParams({
+			code: "true",
+			client_id: CLAUDE_CLIENT_ID,
+			response_type: "code",
+			redirect_uri: redirectUri,
+			scope: CLAUDE_SCOPE,
+			code_challenge: pkce.challenge,
+			code_challenge_method: "S256",
+			state
+		}).toString()}`;
+	}
+};
 /** Best-effort account profile; login must not fail when this does. */
 async function fetchClaudeProfile(accessToken) {
 	try {
-		const response = await fetch(CLAUDE_PROFILE_URL, { headers: { authorization: `Bearer ${accessToken}` } });
+		const response = await proxiedFetch(CLAUDE_PROFILE_URL, { headers: { authorization: `Bearer ${accessToken}` } });
 		if (!response.ok) return {};
 		const profile = await response.json();
 		const account = typeof profile.account === "object" && profile.account !== null ? profile.account : {};
@@ -2469,7 +3296,7 @@ async function claudeSession(tokens, fallbackRefreshToken, withProfile) {
 * @returns the session to store.
 */
 async function exchangeClaudeCode(code, verifier, redirectUri, state) {
-	const response = await fetch(CLAUDE_TOKEN_URL, {
+	const response = await proxiedFetch(CLAUDE_TOKEN_URL, {
 		method: "POST",
 		headers: { "content-type": "application/json" },
 		body: JSON.stringify({
@@ -2490,7 +3317,7 @@ async function exchangeClaudeCode(code, verifier, redirectUri, state) {
 * @returns the fresh session to store.
 */
 async function refreshClaude(session) {
-	const response = await fetch(CLAUDE_TOKEN_URL, {
+	const response = await proxiedFetch(CLAUDE_TOKEN_URL, {
 		method: "POST",
 		headers: { "content-type": "application/json" },
 		body: JSON.stringify({
@@ -2565,7 +3392,7 @@ function claudeLimitsWindows(value) {
 * @param signal - caller cancellation from the RPC transport.
 * @returns the mapped usage snapshot.
 */
-async function fetchClaudeUsage(session, fetchFn = fetch, signal) {
+async function fetchClaudeUsage(session, fetchFn = proxiedFetch, signal) {
 	const response = await fetchFn(CLAUDE_USAGE_URL, {
 		headers: {
 			"authorization": `Bearer ${session.accessToken}`,
@@ -2618,7 +3445,7 @@ function claudeReasoning(capabilities) {
 	return efforts.length > 0 ? { efforts } : void 0;
 }
 /** Fetch the live model catalog from the subscription endpoint. */
-async function fetchClaudeModels(session, fetchFn = fetch) {
+async function fetchClaudeModels(session, fetchFn = proxiedFetch) {
 	const response = await fetchFn(CLAUDE_MODELS_URL, { headers: {
 		"authorization": `Bearer ${session.accessToken}`,
 		"anthropic-version": "2023-06-01",
@@ -2652,6 +3479,36 @@ const CLAUDE_RETRY_MAX_DELAY_MS = 6e4;
 const CLAUDE_RETRY_JITTER_RATIO = .2;
 /** The Claude 4.5 family accepts image input. */
 const CLAUDE_MODALITIES = ["text", "image"];
+/**
+* Assemble the Anthropic request body.
+*
+* Extracted from the adapter so the wire shape — cache breakpoints above all —
+* is testable without a network round trip. The message array is marked before
+* it is placed so the breakpoints land on the blocks the body ships: one on the
+* last `system` block (covering `tools` + `system`, which render ahead of it)
+* and up to three across the history, Anthropic's four-slot maximum.
+* @param options - the generate request.
+* @param messages - conversation messages with images already resolved.
+* @param maxTokens - the resolved output cap.
+* @param thinking - the thinking parameter, when the model takes one.
+* @param effort - the reasoning effort, when the model advertises efforts.
+* @returns the JSON body to POST.
+*/
+function claudeRequestBody(options, messages, maxTokens, thinking, effort) {
+	const anthropicMessages = toAnthropicMessages(messages);
+	markMessageCache(anthropicMessages);
+	return {
+		model: options.model,
+		max_tokens: maxTokens,
+		system: toAnthropicSystem(options.system, messages),
+		messages: anthropicMessages,
+		...options.tools !== void 0 && options.tools.length > 0 ? { tools: toAnthropicTools(options.tools) } : {},
+		...thinking === void 0 ? {} : { thinking },
+		...effort === void 0 ? {} : { output_config: { effort } },
+		stream: true,
+		...options.sessionId !== void 0 ? { metadata: { user_id: String(options.sessionId) } } : {}
+	};
+}
 /** Claude wire adapter: one instance serves the `claude` provider route. */
 var ClaudeAdapter = class extends LlmAdapter {
 	catalog;
@@ -2697,15 +3554,14 @@ var ClaudeAdapter = class extends LlmAdapter {
 		if (await this.options.tokens.peek() === void 0) return [];
 		if (!this.options.discovery) return this.staticModels(provider);
 		try {
-			return (await this.catalog.get(() => this.fetchCatalog())).map((model) => ({
+			return (await discoverOrRetryAuth((force) => this.options.tokens.session(force), this.catalog, () => this.catalog.get(() => this.fetchCatalog()))).map((model) => ({
 				provider,
 				id: model.id,
 				name: model.name,
 				inputModalities: CLAUDE_MODALITIES
 			}));
 		} catch (error) {
-			if (error instanceof LlmError && (error.code === "MISSING_CREDENTIAL" || error.code === "INVALID_CREDENTIAL")) return [];
-			if (error instanceof LlmError && error.code === "AUTH") this.catalog.invalidate();
+			if (isMissingOrInvalidCredential(error)) return [];
 			this.options.onWarn?.(`claude model discovery failed; using the built-in catalog (${errorChain(error)})`);
 			return this.staticModels(provider);
 		}
@@ -2770,20 +3626,8 @@ var ClaudeAdapter = class extends LlmAdapter {
 		const messages = await resolveImages(options.messages, this.options.resolveAttachments?.(), signal);
 		const maxTokens = options.maxTokens ?? this.options.models.find((entry) => entry.id === options.model)?.maxTokens ?? CLAUDE_DEFAULT_MAX_TOKENS;
 		const disc = await this.discovered(options.model);
-		const thinking = this.thinkingParam(disc?.thinkingType, maxTokens);
-		const effort = options.reasoningEffort !== void 0 && disc?.reasoning !== void 0 ? { output_config: { effort: String(options.reasoningEffort) } } : {};
-		const body = {
-			model: options.model,
-			max_tokens: maxTokens,
-			system: toAnthropicSystem(options.system, messages),
-			messages: toAnthropicMessages(messages),
-			...options.tools !== void 0 && options.tools.length > 0 ? { tools: toAnthropicTools(options.tools) } : {},
-			...thinking === void 0 ? {} : { thinking },
-			...effort,
-			stream: true,
-			...options.sessionId !== void 0 ? { metadata: { user_id: String(options.sessionId) } } : {}
-		};
-		return fetch(CLAUDE_API_URL, {
+		const body = claudeRequestBody(options, messages, maxTokens, this.thinkingParam(disc?.thinkingType, maxTokens), options.reasoningEffort !== void 0 && disc?.reasoning !== void 0 ? String(options.reasoningEffort) : void 0);
+		return proxiedFetch(CLAUDE_API_URL, {
 			method: "POST",
 			headers: {
 				"authorization": `Bearer ${session.accessToken}`,
@@ -2830,7 +3674,7 @@ let discoveryCache;
 */
 async function grokDiscovery() {
 	if (discoveryCache !== void 0) return discoveryCache;
-	const response = await fetch(GROK_DISCOVERY_URL);
+	const response = await proxiedFetch(GROK_DISCOVERY_URL);
 	if (!response.ok) throw await oauthEndpointError(response, "grok OIDC discovery");
 	const document = await response.json();
 	if (typeof document.authorization_endpoint !== "string" || typeof document.token_endpoint !== "string") throw new Error("grok OIDC discovery document is missing endpoints");
@@ -2931,7 +3775,7 @@ function grokSession(tokens, tokenEndpoint, fallbackRefreshToken) {
 */
 async function exchangeGrokCode(code, verifier, redirectUri, challenge) {
 	const discovery = await grokDiscovery();
-	const response = await fetch(discovery.tokenEndpoint, {
+	const response = await proxiedFetch(discovery.tokenEndpoint, {
 		method: "POST",
 		headers: { "content-type": "application/x-www-form-urlencoded" },
 		body: new URLSearchParams({
@@ -2954,7 +3798,7 @@ async function exchangeGrokCode(code, verifier, redirectUri, challenge) {
 * @returns the fresh session to store.
 */
 async function refreshGrok(session) {
-	const response = await fetch(session.tokenEndpoint, {
+	const response = await proxiedFetch(session.tokenEndpoint, {
 		method: "POST",
 		headers: { "content-type": "application/x-www-form-urlencoded" },
 		body: new URLSearchParams({
@@ -3001,7 +3845,7 @@ function grokResetsAt(value) {
 * @param signal - caller cancellation from the RPC transport.
 * @returns the mapped usage snapshot.
 */
-async function fetchGrokUsage(session, fetchFn = fetch, signal) {
+async function fetchGrokUsage(session, fetchFn = proxiedFetch, signal) {
 	const response = await fetchFn(GROK_BILLING_URL, {
 		headers: {
 			"authorization": `Bearer ${session.accessToken}`,
@@ -3034,120 +3878,1067 @@ async function fetchGrokUsage(session, fetchFn = fetch, signal) {
 	}
 	const plan = typeof payload.subscriptionTier === "string" && payload.subscriptionTier.length > 0 ? payload.subscriptionTier : grokTierName(session.accessToken);
 	return {
-		supported: true,
-		windows,
-		...plan === void 0 ? {} : { plan }
+		supported: true,
+		windows,
+		...plan === void 0 ? {} : { plan }
+	};
+}
+const GROK_MODELS_URL = "https://api.x.ai/v1/models";
+/**
+* Input modalities for one grok model: chat models (grok-4 family) accept
+* images; code and embedding models are text-only.
+*/
+function grokModalities(id) {
+	return /code|embed/i.test(id) ? ["text"] : ["text", "image"];
+}
+/**
+* The Grok Build CLI chat proxy's model catalog — the only grok endpoint that
+* advertises reasoning capability. The `api.x.ai/v1/models` and
+* `/v1/language-models` payloads carry pricing, context, and aliases only, so
+* effort metadata must come from here (the same source the official CLI's
+* picker uses).
+*/
+const GROK_CLI_MODELS_URL = "https://cli-chat-proxy.grok.com/v1/models";
+/** Map one CLI catalog entry's reasoning fields, or undefined when unsupported. */
+function grokCliReasoning(entry) {
+	if (entry.supports_reasoning_effort !== true) return void 0;
+	const efforts = (entry.reasoning_efforts ?? []).filter((level) => typeof level.value === "string" && level.value.length > 0).map((level) => ({
+		id: ReasoningEffortId(level.value),
+		name: typeof level.label === "string" && level.label.length > 0 ? level.label : level.value,
+		...typeof level.description === "string" && level.description.length > 0 ? { description: level.description } : {}
+	}));
+	if (efforts.length === 0) return void 0;
+	const defaultEffort = typeof entry.reasoning_effort === "string" && efforts.some((effort) => effort.id === ReasoningEffortId(entry.reasoning_effort)) ? ReasoningEffortId(entry.reasoning_effort) : void 0;
+	return {
+		efforts,
+		...defaultEffort === void 0 ? {} : { defaultEffort }
+	};
+}
+/**
+* Fetch the CLI catalog and index its per-model metadata by model id.
+* @param session - the stored session (used as-is; never refreshed here).
+* @param fetchFn - fetch implementation (injectable for tests).
+* @returns model id → contributed metadata.
+*/
+async function fetchGrokCliCatalog(session, fetchFn = proxiedFetch) {
+	const response = await fetchFn(GROK_CLI_MODELS_URL, { headers: {
+		"authorization": `Bearer ${session.accessToken}`,
+		"x-xai-token-auth": "xai-grok-cli",
+		"accept": "application/json",
+		...attributionHeaders()
+	} });
+	if (!response.ok) throw await oauthEndpointError(response, "grok CLI catalog");
+	const payload = await response.json();
+	if (!Array.isArray(payload.data)) throw new Error("grok CLI catalog returned no data array");
+	const catalog = /* @__PURE__ */ new Map();
+	for (const entry of payload.data) {
+		if (typeof entry.id !== "string" || entry.id.length === 0) continue;
+		const reasoning = grokCliReasoning(entry);
+		catalog.set(entry.id, {
+			...typeof entry.name === "string" && entry.name.length > 0 ? { name: entry.name } : {},
+			...typeof entry.description === "string" && entry.description.length > 0 ? { description: entry.description } : {},
+			...typeof entry.context_window === "number" && entry.context_window > 0 ? { contextWindow: entry.context_window } : {},
+			...reasoning === void 0 ? {} : { reasoning }
+		});
+	}
+	return catalog;
+}
+/**
+* The /v1/models list also serves generation models that cannot chat
+* (grok-imagine-image*, grok-imagine-video*) and embedding models; the picker
+* must not offer them. Heuristic over the id substring, verified against the
+* live catalog (grok-build-0.1 and the grok-4 family pass).
+*/
+function isChatModel(id) {
+	return !/imagine|image-|video|embed/i.test(id);
+}
+/**
+* CLI-contributed fields carried forward from a previously discovered model.
+* @param prior - the last-known entry for this id, if any.
+* @returns enrichment to apply when the live CLI catalog cannot contribute.
+*/
+function grokPriorMeta(prior) {
+	if (prior === void 0) return {};
+	return {
+		...prior.name.length > 0 ? { name: prior.name } : {},
+		...prior.description === void 0 ? {} : { description: prior.description },
+		...prior.contextWindow === void 0 ? {} : { contextWindow: prior.contextWindow },
+		...prior.reasoning === void 0 ? {} : { reasoning: prior.reasoning }
+	};
+}
+/**
+* Fetch the live grok model list, enriched with the CLI catalog's per-model
+* metadata (display name, context window, reasoning efforts). The api.x.ai
+* list stays authoritative for which models exist; the CLI catalog is
+* enrichment only, so its failure degrades to a plain list instead of taking
+* discovery down. When enrichment is missing, last-known capability metadata
+* is carried forward so a transient CLI outage cannot strip efforts a
+* session already selected.
+* @param session - the stored session (used as-is; never refreshed here).
+* @param fetchFn - fetch implementation (injectable for tests).
+* @param onWarn - warning sink for a failed CLI catalog fetch.
+* @param previous - last-known catalog used to keep enrichment when the CLI
+*   catalog is down or omits a model.
+* @returns discovered chat models in endpoint order.
+*/
+async function fetchGrokModels(session, fetchFn = proxiedFetch, onWarn, previous) {
+	const previousById = previous === void 0 || previous.length === 0 ? void 0 : new Map(previous.map((model) => [model.id, model]));
+	const [response, cliCatalog] = await Promise.all([fetchFn(GROK_MODELS_URL, { headers: {
+		"authorization": `Bearer ${session.accessToken}`,
+		"accept": "application/json",
+		...attributionHeaders()
+	} }), fetchGrokCliCatalog(session, fetchFn).catch((error) => {
+		onWarn?.(previousById === void 0 ? `grok CLI catalog fetch failed; reasoning efforts are unavailable (${errorChain(error)})` : `grok CLI catalog fetch failed; keeping last-known reasoning efforts (${errorChain(error)})`);
+	})]);
+	if (!response.ok) throw await oauthEndpointError(response, "grok models");
+	const payload = await response.json();
+	if (!Array.isArray(payload.data)) throw new Error("grok models endpoint returned no data array");
+	const seen = /* @__PURE__ */ new Set();
+	const discovered = [];
+	for (const entry of payload.data) {
+		if (typeof entry.id !== "string" || entry.id.length === 0 || seen.has(entry.id)) continue;
+		if (!isChatModel(entry.id)) continue;
+		seen.add(entry.id);
+		const cli = cliCatalog?.get(entry.id);
+		discovered.push({
+			id: entry.id,
+			name: entry.id,
+			...cli ?? grokPriorMeta(previousById?.get(entry.id))
+		});
+	}
+	if (discovered.length === 0) throw new Error("grok models endpoint returned an empty catalog");
+	return discovered;
+}
+/** Grok wire adapter: one instance serves the `grok` provider route. */
+var GrokAdapter = class extends LlmAdapter {
+	catalog;
+	constructor(options) {
+		super();
+		this.options = options;
+		this.catalog = new ModelCatalogCache(options.catalogStore);
+	}
+	/** Discovery fetcher: resolves the session through the refresh-aware path. */
+	async fetchCatalog() {
+		return fetchGrokModels(await this.options.tokens.session(), this.options.fetchFn, this.options.onWarn, this.catalog.lastKnown());
+	}
+	listed(provider, discovered) {
+		return discovered.map((model) => ({
+			provider,
+			id: model.id,
+			name: model.name,
+			...model.description === void 0 ? {} : { description: model.description },
+			inputModalities: grokModalities(model.id)
+		}));
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: "Grok (Subscription)"
+		};
+	}
+	staticModels(provider) {
+		return this.options.models.map((model) => ({
+			provider,
+			id: model.id,
+			name: model.name ?? model.id,
+			inputModalities: model.inputModalities ?? grokModalities(model.id)
+		}));
+	}
+	async listModels(provider) {
+		if (await this.options.tokens.peek() === void 0) return [];
+		if (!this.options.discovery) return this.staticModels(provider);
+		try {
+			return this.listed(provider, await discoverOrRetryAuth((force) => this.options.tokens.session(force), this.catalog, () => this.catalog.get(() => this.fetchCatalog())));
+		} catch (error) {
+			if (isMissingOrInvalidCredential(error)) return [];
+			this.options.onWarn?.(`grok model discovery failed; using the built-in catalog (${errorChain(error)})`);
+			return this.staticModels(provider);
+		}
+	}
+	/**
+	* The discovered entry for one model. Resolved through the cache's
+	* stale-while-revalidate path: capability metadata must stay stable across
+	* a long conversation — a session that selected a reasoning effort calls
+	* this on EVERY step, and forgetting the efforts just because the TTL
+	* lapsed mid-turn would fail the call with UNSUPPORTED_REASONING_EFFORT
+	* before provider I/O.
+	*/
+	async discovered(model) {
+		if (!this.options.discovery) return void 0;
+		return (await this.catalog.resolve(() => this.fetchCatalog()))?.find((entry) => entry.id === model);
+	}
+	async resolveModel(provider, model) {
+		const discovered = await this.discovered(model);
+		const configured = this.options.models.find((entry) => entry.id === model);
+		return {
+			provider,
+			id: model,
+			name: discovered?.name ?? configured?.name ?? model,
+			...discovered?.description === void 0 ? {} : { description: discovered.description },
+			inputModalities: configured?.inputModalities ?? grokModalities(model),
+			context: { contextWindow: discovered?.contextWindow ?? configured?.contextWindow ?? GROK_CONTEXT_WINDOW },
+			defaultMaxTokens: configured?.maxTokens ?? GROK_DEFAULT_MAX_TOKENS,
+			...discovered?.reasoning === void 0 ? {} : { reasoning: discovered.reasoning }
+		};
+	}
+	async *stream(options) {
+		const watchdog = idleWatchdog(options.signal, this.options.streamIdleTimeoutMs);
+		try {
+			let session = await this.options.tokens.session();
+			let response = await this.request(options, session, watchdog.signal);
+			if (response.status === 401) {
+				session = await this.options.tokens.session(true);
+				response = await this.request(options, session, watchdog.signal);
+			}
+			if (!response.ok) throw await httpLlmError(response, "grok API");
+			if (response.body === null) throw new LlmError("grok API returned no response body", EMPTY_RESPONSE_CODE);
+			yield* streamResponses(response.body, () => {
+				watchdog.pulse();
+			});
+		} catch (error) {
+			throw mapFetchFailure("grok API", error, watchdog, options.signal);
+		} finally {
+			watchdog.stop();
+		}
+	}
+	async request(options, session, signal) {
+		const { instructions, input } = toResponsesInput(await resolveImages(options.messages, this.options.resolveAttachments?.(), signal), options.system);
+		const body = {
+			model: options.model,
+			...instructions === void 0 ? {} : { instructions },
+			input,
+			...options.tools !== void 0 && options.tools.length > 0 ? { tools: toResponsesTools(options.tools) } : {},
+			tool_choice: "auto",
+			parallel_tool_calls: true,
+			...options.maxTokens !== void 0 ? { max_output_tokens: options.maxTokens } : {},
+			...options.reasoningEffort !== void 0 ? { reasoning: { effort: String(options.reasoningEffort) } } : {},
+			store: false,
+			stream: true
+		};
+		return proxiedFetch(GROK_API_URL, {
+			method: "POST",
+			headers: {
+				"authorization": `Bearer ${session.accessToken}`,
+				"accept": "text/event-stream",
+				"content-type": "application/json",
+				...attributionHeaders()
+			},
+			body: JSON.stringify(body),
+			signal
+		});
+	}
+};
+
+//#endregion
+//#region src/translate/chat-completions.ts
+/** Flatten a tool result's content to plain text for a `tool` message. */
+function toolResultText(block) {
+	return block.content.map((part) => part.type === "text" ? part.text : "").join("");
+}
+/**
+* Convert harness messages into chat completions `messages`. System-role
+* messages become one leading `system` message; an explicit `system` argument
+* wins over them when both exist. Reasoning blocks are not replayed (matching
+* the Responses translator). Images must arrive pre-resolved; an unresolved
+* ImageBlock is skipped because its bytes are unreachable here. A user message
+* carrying only text collapses to a plain string body (some endpoints still
+* reject content-part arrays); tool results become separate `tool` messages.
+* @param messages - ordered conversation messages with resolved images.
+* @param system - explicit system prompt, which takes precedence.
+* @returns the wire `messages` array.
+*/
+function toChatMessages(messages, system) {
+	const out = [];
+	const systemTexts = [];
+	for (const message of messages) {
+		if (message.role === "system") {
+			for (const block of message.content) if (block.type === "text") systemTexts.push(block.text);
+			continue;
+		}
+		if (message.role === "user") {
+			let texts$1 = [];
+			let parts = [];
+			const flushUser = () => {
+				if (parts.length > 0) {
+					if (texts$1.length > 0) parts.unshift({
+						type: "text",
+						text: texts$1.join("\n")
+					});
+					out.push({
+						role: "user",
+						content: parts
+					});
+				} else if (texts$1.length > 0) out.push({
+					role: "user",
+					content: texts$1.join("\n")
+				});
+				texts$1 = [];
+				parts = [];
+			};
+			for (const block of message.content) switch (block.type) {
+				case "text":
+					texts$1.push(block.text);
+					break;
+				case "image":
+					if ("dataBase64" in block) parts.push({
+						type: "image_url",
+						image_url: { url: `data:${block.mediaType};base64,${block.dataBase64}` }
+					});
+					break;
+				case "tool-result":
+					flushUser();
+					out.push({
+						role: "tool",
+						tool_call_id: String(block.toolCallId),
+						content: toolResultText(block)
+					});
+					break;
+				default: break;
+			}
+			flushUser();
+			continue;
+		}
+		const texts = [];
+		const toolCalls = [];
+		for (const block of message.content) switch (block.type) {
+			case "text":
+				texts.push(block.text);
+				break;
+			case "tool-call":
+				toolCalls.push({
+					id: String(block.id),
+					type: "function",
+					function: {
+						name: block.name,
+						arguments: block.arguments
+					}
+				});
+				break;
+			default: break;
+		}
+		if (texts.length === 0 && toolCalls.length === 0) continue;
+		out.push({
+			role: "assistant",
+			content: texts.join("\n"),
+			...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+		});
+	}
+	const systemText = system ?? (systemTexts.length > 0 ? systemTexts.join("\n\n") : void 0);
+	if (systemText !== void 0) out.unshift({
+		role: "system",
+		content: systemText
+	});
+	return out;
+}
+/**
+* Map harness tool schemas to chat completions function tools.
+* @param tools - tool schemas from the request.
+* @returns the wire `tools` array.
+*/
+function toChatTools(tools) {
+	return tools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters
+		}
+	}));
+}
+/**
+* Map chat completions usage to disjoint harness counts (cached input is
+* subtracted out of `inputTokens` and reported as `cacheReadTokens`).
+* @param usage - wire usage from the terminal chunk.
+* @returns harness token usage.
+*/
+function mapChatCompletionsUsage(usage) {
+	const cached = usage.prompt_tokens_details?.cached_tokens;
+	const reasoning = usage.completion_tokens_details?.reasoning_tokens;
+	return {
+		inputTokens: usage.prompt_tokens - (cached ?? 0),
+		outputTokens: usage.completion_tokens,
+		...cached !== void 0 ? { cacheReadTokens: cached } : {},
+		...reasoning !== void 0 ? { reasoningTokens: reasoning } : {}
+	};
+}
+/** Assemble the final ContentBlock for one open block. */
+function closeBlock(block) {
+	switch (block.kind) {
+		case "text": return {
+			type: "text",
+			text: block.text
+		};
+		case "reasoning": return {
+			type: "reasoning",
+			text: block.text
+		};
+		case "tool-call": return {
+			type: "tool-call",
+			id: CallId(block.callId),
+			name: block.name ?? "",
+			arguments: block.text
+		};
+	}
+}
+/**
+* Push-model chat completions SSE translator: feed each parsed chunk object
+* to {@link push} and collect the emitted harness StreamChunks. The terminal
+* `finish_reason` chunk closes every block but only ARMS the finish chunk —
+* usage must precede the terminal finish, and where usage lives differs by
+* upstream: OpenAI-style streams send a trailing usage-only chunk
+* (stream_options.include_usage), while Copilot's Gemini models attach a
+* (zero) usage object to EVERY chunk and fold the real usage into the
+* finish chunk itself. A chunk therefore never early-returns on `usage`
+* alone: its deltas are always processed, and the terminal pair is drained
+* when the finish is armed and usage arrived (or when a usage-only chunk
+* follows an armed finish). `flush()` emits whatever remains when the
+* stream's `[DONE]` (or EOF) arrives.
+*/
+var ChatCompletionsStreamTranslator = class {
+	/** Text/reasoning blocks keyed by kind; tool calls keyed by their wire index. */
+	blocks = /* @__PURE__ */ new Map();
+	order = [];
+	nextIndex = 0;
+	sawToolCall = false;
+	pendingUsage;
+	armedFinish;
+	/** Set once the terminal finish chunk was emitted. */
+	terminated = false;
+	open(key, kind, chunks, callId = "", name$1) {
+		const block = {
+			index: this.nextIndex++,
+			kind,
+			text: "",
+			callId,
+			...name$1 === void 0 ? {} : { name: name$1 }
+		};
+		this.blocks.set(key, block);
+		this.order.push(block);
+		chunks.push({
+			type: "block-start",
+			index: block.index,
+			blockType: kind
+		});
+		return block;
+	}
+	close(key, chunks) {
+		const block = this.blocks.get(key);
+		if (block === void 0) return;
+		this.blocks.delete(key);
+		chunks.push({
+			type: "block-end",
+			index: block.index,
+			block: closeBlock(block)
+		});
+	}
+	closeAll(chunks) {
+		for (const key of [...this.blocks.keys()]) this.close(key, chunks);
+	}
+	/** Build the terminal finish chunk for one wire finish reason. */
+	finishChunk(finishReason) {
+		if (this.order.length === 0) return {
+			type: "finish",
+			reason: {
+				kind: "error",
+				failure: {
+					message: "model returned a completed response with no content",
+					code: EMPTY_RESPONSE_CODE
+				}
+			}
+		};
+		switch (finishReason) {
+			case "tool_calls": return {
+				type: "finish",
+				reason: { kind: "tool-calls" }
+			};
+			case "length": return {
+				type: "finish",
+				reason: { kind: "max-tokens" }
+			};
+			case "content_filter": return {
+				type: "finish",
+				reason: {
+					kind: "error",
+					failure: {
+						message: "the response was blocked by the provider content filter",
+						code: "CONTENT_FILTER"
+					}
+				}
+			};
+			default: return {
+				type: "finish",
+				reason: { kind: this.sawToolCall ? "tool-calls" : "stop" }
+			};
+		}
+	}
+	/** Usage, then the armed finish: the only order the harness accepts. */
+	drainTerminal(chunks) {
+		if (this.pendingUsage !== void 0) {
+			chunks.push({
+				type: "usage",
+				usage: mapChatCompletionsUsage(this.pendingUsage)
+			});
+			this.pendingUsage = void 0;
+		}
+		if (this.armedFinish !== void 0) {
+			chunks.push(this.armedFinish);
+			this.armedFinish = void 0;
+			this.terminated = true;
+		}
+	}
+	/**
+	* Process one parsed chat-completion chunk.
+	* @param event - the parsed chunk object.
+	* @returns the StreamChunks this event produced (possibly none).
+	*/
+	push(event) {
+		if (this.terminated) return [];
+		const chunks = [];
+		const usage = event.usage;
+		const hasUsage = usage !== void 0 && usage !== null;
+		if (hasUsage) this.pendingUsage = usage;
+		const choice = event.choices?.[0];
+		const delta = choice?.delta;
+		if (delta !== void 0) {
+			if (typeof delta.content === "string" && delta.content.length > 0) {
+				const block = this.blocks.get("content") ?? this.open("content", "text", chunks);
+				block.text += delta.content;
+				chunks.push({
+					type: "text-delta",
+					index: block.index,
+					text: delta.content
+				});
+			}
+			const reasoning = typeof delta.reasoning_content === "string" ? delta.reasoning_content : typeof delta.reasoning_text === "string" ? delta.reasoning_text : void 0;
+			if (reasoning !== void 0 && reasoning.length > 0) {
+				const block = this.blocks.get("reasoning") ?? this.open("reasoning", "reasoning", chunks);
+				block.text += reasoning;
+				chunks.push({
+					type: "reasoning-delta",
+					index: block.index,
+					text: reasoning
+				});
+			}
+			for (const call of delta.tool_calls ?? []) {
+				const key = `call:${String(call.index ?? 0)}`;
+				let block = this.blocks.get(key);
+				if (block === void 0) {
+					this.sawToolCall = true;
+					block = this.open(key, "tool-call", chunks, call.id ?? "", call.function?.name);
+					chunks.push({
+						type: "tool-call-delta",
+						index: block.index,
+						id: CallId(block.callId),
+						...block.name === void 0 ? {} : { name: block.name },
+						argumentsDelta: ""
+					});
+				}
+				if (call.function?.arguments !== void 0 && call.function.arguments.length > 0) {
+					block.text += call.function.arguments;
+					chunks.push({
+						type: "tool-call-delta",
+						index: block.index,
+						id: CallId(block.callId),
+						argumentsDelta: call.function.arguments
+					});
+				}
+			}
+		}
+		if (choice?.finish_reason !== void 0 && choice.finish_reason !== null) {
+			this.closeAll(chunks);
+			if (this.armedFinish === void 0) this.armedFinish = this.finishChunk(choice.finish_reason);
+		}
+		if (hasUsage && (this.armedFinish !== void 0 || choice === void 0)) this.drainTerminal(chunks);
+		return chunks;
+	}
+	/**
+	* Emit whatever the stream left pending (`[DONE]` or EOF without a final
+	* usage chunk). Safe to call repeatedly.
+	* @returns the remaining terminal chunks.
+	*/
+	flush() {
+		const chunks = [];
+		this.drainTerminal(chunks);
+		return chunks;
+	}
+};
+/**
+* Consume a chat completions SSE byte stream and yield harness StreamChunks.
+* @param stream - raw response body.
+* @param onActivity - transport-activity callback for the idle watchdog.
+* @returns the chunk stream; throws when the stream ends before any finish chunk.
+*/
+async function* streamChatCompletions(stream, onActivity) {
+	const translator = new ChatCompletionsStreamTranslator();
+	for await (const sseEvent of parseSse(stream, onActivity)) {
+		if (sseEvent.data === "[DONE]") {
+			yield* translator.flush();
+			return;
+		}
+		let event;
+		try {
+			event = JSON.parse(sseEvent.data);
+		} catch {
+			throw new LlmError(`malformed SSE payload: ${sseEvent.data.slice(0, 120)}`, "MALFORMED_RESPONSE");
+		}
+		yield* translator.push(event);
+		if (translator.terminated) return;
+	}
+	yield* translator.flush();
+	if (!translator.terminated) throw new LlmError("chat completions SSE stream ended before a finish chunk", "STREAM_CLOSED");
+}
+
+//#endregion
+//#region src/providers/copilot.ts
+/**
+* Client id of the VS Code Copilot Chat GitHub App (pi-mono and
+* copilot2api-go use the same value): the app is pre-authorized for the
+* Copilot internal token exchange, a self-registered OAuth App is not.
+*/
+const COPILOT_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+const COPILOT_DEVICE_CODE_URL = "https://github.com/login/device/code";
+const COPILOT_DEVICE_TOKEN_URL = "https://github.com/login/oauth/access_token";
+const COPILOT_TOKEN_URL = "https://api.github.com/copilot_internal/v2/token";
+const GITHUB_USER_URL = "https://api.github.com/user";
+const COPILOT_API_URL = "https://api.githubcopilot.com/chat/completions";
+/** Responses endpoint for models whose catalog entry only lists `/responses`. */
+const COPILOT_RESPONSES_URL = "https://api.githubcopilot.com/responses";
+const COPILOT_MODELS_URL = "https://api.githubcopilot.com/models";
+const COPILOT_SCOPE = "read:user";
+const COPILOT_CONTEXT_WINDOW = 128e3;
+const COPILOT_DEFAULT_MAX_TOKENS = 16e3;
+/** Refresh when the Copilot API token has less than this much life left. */
+const COPILOT_PREEMPT_MS = 5 * 6e4;
+/**
+* The VS Code update feed answers a JSON array of version strings, latest
+* stable first. The Copilot API rejects requests whose Editor-Version is too
+* old with `401 IDE token expired`, so the version is resolved live (cached
+* for a day) instead of hardcoded — a stale hardcode bricks every request.
+*/
+const VSCODE_RELEASES_URL = "https://update.code.visualstudio.com/api/releases/stable";
+/** Last-known-good VS Code version when the feed is unreachable. */
+const FALLBACK_VSCODE_VERSION = "1.107.0";
+const VSCODE_VERSION_TTL_MS = 24 * 36e5;
+let vscodeVersionCache;
+let vscodeVersionInflight;
+/**
+* Resolve the VS Code version presented as Editor-Version: the latest stable
+* from the update feed, cached for a day, falling back to a pinned version
+* when the feed fails. Concurrent resolves coalesce behind one fetch.
+* @param fetchFn - fetch implementation (injectable for tests).
+* @param forceRefresh - bypass the cache (a 401 `IDE token expired` retry).
+* @returns a `major.minor.patch` version string.
+*/
+async function latestVsCodeVersion(fetchFn = proxiedFetch, forceRefresh = false) {
+	if (!forceRefresh && vscodeVersionCache !== void 0 && Date.now() - vscodeVersionCache.at < VSCODE_VERSION_TTL_MS) return vscodeVersionCache.version;
+	vscodeVersionInflight ??= (async () => {
+		try {
+			const response = await fetchFn(VSCODE_RELEASES_URL, { headers: { accept: "application/json" } });
+			if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
+			const releases = await response.json();
+			const version = Array.isArray(releases) ? releases.find((entry) => typeof entry === "string" && /^\d+\.\d+\.\d+$/.test(entry)) : void 0;
+			if (version === void 0) throw new Error("no version string in the feed");
+			vscodeVersionCache = {
+				version,
+				at: Date.now()
+			};
+			return version;
+		} catch {
+			return vscodeVersionCache?.version ?? FALLBACK_VSCODE_VERSION;
+		}
+	})().finally(() => {
+		vscodeVersionInflight = void 0;
+	});
+	return vscodeVersionInflight;
+}
+/**
+* The device-flow facts for the auth controller's DeviceFlowManager.
+* @returns the flow spec for one attempt.
+*/
+function copilotDeviceFlow() {
+	return {
+		clientId: COPILOT_CLIENT_ID,
+		scope: COPILOT_SCOPE,
+		deviceCodeUrl: COPILOT_DEVICE_CODE_URL,
+		tokenUrl: COPILOT_DEVICE_TOKEN_URL
+	};
+}
+/**
+* Header set presenting requests as the VS Code Copilot Chat extension; the
+* Copilot API rejects traffic without an editor identity.
+* @param hasVision - whether the request carries image input.
+* @param vscodeVersion - Editor-Version value from {@link latestVsCodeVersion}.
+* @returns headers to merge into Copilot API requests.
+*/
+function copilotHeaders(hasVision = false, vscodeVersion = FALLBACK_VSCODE_VERSION) {
+	return {
+		"user-agent": "GitHubCopilotChat/0.35.0",
+		"editor-version": `vscode/${vscodeVersion}`,
+		"editor-plugin-version": "copilot-chat/0.35.0",
+		"copilot-integration-id": "vscode-chat",
+		"openai-intent": "conversation-edits",
+		"x-github-api-version": "2026-06-01",
+		...hasVision ? { "copilot-vision-request": "true" } : {}
 	};
 }
-const GROK_MODELS_URL = "https://api.x.ai/v1/models";
 /**
-* Input modalities for one grok model: chat models (grok-4 family) accept
-* images; code and embedding models are text-only.
+* Exchange a long-lived GitHub OAuth token for a short-lived Copilot API
+* token. A 401/403 means the GitHub token is revoked or the account lost its
+* Copilot subscription — permanent, re-login required.
+* @param githubToken - the GitHub OAuth token from the device flow.
+* @param fetchFn - fetch implementation (injectable for tests).
+* @returns the Copilot API token and its expiry.
 */
-function grokModalities(id) {
-	return /code|embed/i.test(id) ? ["text"] : ["text", "image"];
+async function exchangeCopilotToken(githubToken, fetchFn = proxiedFetch) {
+	const response = await fetchFn(COPILOT_TOKEN_URL, { headers: {
+		"authorization": `Bearer ${githubToken}`,
+		"accept": "application/json",
+		...copilotHeaders(false, await latestVsCodeVersion(fetchFn))
+	} });
+	if (!response.ok) throw await oauthEndpointError(response, "copilot");
+	const wire = await response.json();
+	if (typeof wire.token !== "string" || wire.token.length === 0) throw new Error("copilot token endpoint returned no token");
+	return {
+		accessToken: wire.token,
+		expiresAt: typeof wire.expires_at === "number" && wire.expires_at > 0 ? wire.expires_at * 1e3 : Date.now() + 25 * 6e4
+	};
 }
 /**
-* The Grok Build CLI chat proxy's model catalog — the only grok endpoint that
-* advertises reasoning capability. The `api.x.ai/v1/models` and
-* `/v1/language-models` payloads carry pricing, context, and aliases only, so
-* effort metadata must come from here (the same source the official CLI's
-* picker uses).
+* Complete a device-flow login: exchange the GitHub token for a Copilot API
+* token and read the GitHub login name for the status display.
+* @param githubToken - the GitHub OAuth token the device flow released.
+* @param fetchFn - fetch implementation (injectable for tests).
+* @returns the session to store.
 */
-const GROK_CLI_MODELS_URL = "https://cli-chat-proxy.grok.com/v1/models";
-/** Map one CLI catalog entry's reasoning fields, or undefined when unsupported. */
-function grokCliReasoning(entry) {
-	if (entry.supports_reasoning_effort !== true) return void 0;
-	const efforts = (entry.reasoning_efforts ?? []).filter((level) => typeof level.value === "string" && level.value.length > 0).map((level) => ({
-		id: ReasoningEffortId(level.value),
-		name: typeof level.label === "string" && level.label.length > 0 ? level.label : level.value,
-		...typeof level.description === "string" && level.description.length > 0 ? { description: level.description } : {}
-	}));
-	if (efforts.length === 0) return void 0;
-	const defaultEffort = typeof entry.reasoning_effort === "string" && efforts.some((effort) => effort.id === ReasoningEffortId(entry.reasoning_effort)) ? ReasoningEffortId(entry.reasoning_effort) : void 0;
+async function completeCopilotLogin(githubToken, fetchFn = proxiedFetch) {
+	const pair = await exchangeCopilotToken(githubToken, fetchFn);
+	let account;
+	try {
+		const response = await fetchFn(GITHUB_USER_URL, { headers: {
+			"authorization": `Bearer ${githubToken}`,
+			"accept": "application/json",
+			"user-agent": "GitHubCopilotChat/0.35.0"
+		} });
+		if (response.ok) {
+			const profile = await response.json();
+			if (typeof profile.login === "string" && profile.login.length > 0) account = profile.login;
+		}
+	} catch {}
 	return {
-		efforts,
-		...defaultEffort === void 0 ? {} : { defaultEffort }
+		accessToken: pair.accessToken,
+		refreshToken: githubToken,
+		expiresAt: pair.expiresAt,
+		...account === void 0 ? {} : { account }
 	};
 }
 /**
-* Fetch the CLI catalog and index its per-model metadata by model id.
-* @param session - the stored session (used as-is; never refreshed here).
+* Refresh a copilot session: re-exchange the long-lived GitHub token for a
+* fresh Copilot API token.
+* @param session - the stored session.
 * @param fetchFn - fetch implementation (injectable for tests).
-* @returns model id → contributed metadata.
+* @returns the fresh session to store.
 */
-async function fetchGrokCliCatalog(session, fetchFn = fetch) {
-	const response = await fetchFn(GROK_CLI_MODELS_URL, { headers: {
-		"authorization": `Bearer ${session.accessToken}`,
-		"x-xai-token-auth": "xai-grok-cli",
-		"accept": "application/json",
-		...attributionHeaders()
-	} });
-	if (!response.ok) throw await oauthEndpointError(response, "grok CLI catalog");
-	const payload = await response.json();
-	if (!Array.isArray(payload.data)) throw new Error("grok CLI catalog returned no data array");
-	const catalog = /* @__PURE__ */ new Map();
-	for (const entry of payload.data) {
-		if (typeof entry.id !== "string" || entry.id.length === 0) continue;
-		const reasoning = grokCliReasoning(entry);
-		catalog.set(entry.id, {
-			...typeof entry.name === "string" && entry.name.length > 0 ? { name: entry.name } : {},
-			...typeof entry.description === "string" && entry.description.length > 0 ? { description: entry.description } : {},
-			...typeof entry.context_window === "number" && entry.context_window > 0 ? { contextWindow: entry.context_window } : {},
-			...reasoning === void 0 ? {} : { reasoning }
-		});
-	}
-	return catalog;
+async function refreshCopilot(session, fetchFn = proxiedFetch) {
+	const pair = await exchangeCopilotToken(session.refreshToken, fetchFn);
+	return {
+		accessToken: pair.accessToken,
+		refreshToken: session.refreshToken,
+		expiresAt: pair.expiresAt,
+		...session.account === void 0 ? {} : { account: session.account }
+	};
 }
 /**
-* The /v1/models list also serves generation models that cannot chat
-* (grok-imagine-image*, grok-imagine-video*) and embedding models; the picker
-* must not offer them. Heuristic over the id substring, verified against the
-* live catalog (grok-build-0.1 and the grok-4 family pass).
+* Whether a copilot refresh failure means the login is permanently gone.
+* @param error - the thrown refresh error.
+* @returns true when re-login is the only fix (GitHub token revoked or the subscription lost).
 */
-function isChatModel(id) {
-	return !/imagine|image-|video|embed/i.test(id);
+function isCopilotPermanentRefreshError(error) {
+	return error instanceof OAuthEndpointError && (error.status === 401 || error.status === 403);
+}
+/** Display name for one Copilot wire reasoning-effort value. */
+function copilotEffortName(effort) {
+	return effort === "xhigh" ? "Extra High" : effort.charAt(0).toUpperCase() + effort.slice(1);
 }
 /**
-* Fetch the live grok model list, enriched with the CLI catalog's per-model
-* metadata (display name, context window, reasoning efforts). The api.x.ai
-* list stays authoritative for which models exist; the CLI catalog is
-* enrichment only, so its failure degrades to a plain list instead of taking
-* discovery down — models it does not cover simply expose no efforts.
+* Map a catalog entry's `supports.reasoning_effort` array into selectable
+* efforts. The endpoint discloses no default effort, so none is claimed
+* (absence preserves the provider's own default). Duplicates and non-string
+* entries are dropped: the harness rejects duplicate effort ids outright.
+*/
+function copilotReasoning(entry) {
+	const wire = entry.capabilities?.supports?.reasoning_effort;
+	if (!Array.isArray(wire)) return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	const efforts = [];
+	for (const value of wire) {
+		if (typeof value !== "string" || value.length === 0 || seen.has(value)) continue;
+		seen.add(value);
+		efforts.push({
+			id: ReasoningEffortId(value),
+			name: copilotEffortName(value)
+		});
+	}
+	return efforts.length > 0 ? { efforts } : void 0;
+}
+/**
+* Fetch the live Copilot model list. Models hidden from the picker or
+* disabled by policy are excluded, as are models able to speak neither
+* protocol this adapter knows: an entry listing `/chat/completions` speaks
+* the chat wire, one listing only `/responses` (the newer GPT families,
+* e.g. gpt-5.6) speaks the Responses wire, and the choice is recorded on the
+* discovered entry so requests pick the matching endpoint; an entry listing
+* BOTH endpoints additionally records `/responses` availability, which
+* {@link copilotRequestWire} uses to reroute tools+effort requests. Vision
+* support from the catalog becomes the model's input modalities, and a
+* non-empty `supports.reasoning_effort` array becomes the model's selectable
+* reasoning efforts (the endpoint discloses no default, so none is claimed).
 * @param session - the stored session (used as-is; never refreshed here).
 * @param fetchFn - fetch implementation (injectable for tests).
-* @param onWarn - warning sink for a failed CLI catalog fetch.
 * @returns discovered chat models in endpoint order.
 */
-async function fetchGrokModels(session, fetchFn = fetch, onWarn) {
-	const [response, cliCatalog] = await Promise.all([fetchFn(GROK_MODELS_URL, { headers: {
+async function fetchCopilotModels(session, fetchFn = proxiedFetch) {
+	const response = await fetchFn(COPILOT_MODELS_URL, { headers: {
 		"authorization": `Bearer ${session.accessToken}`,
 		"accept": "application/json",
-		...attributionHeaders()
-	} }), fetchGrokCliCatalog(session, fetchFn).catch((error) => {
-		onWarn?.(`grok CLI catalog fetch failed; reasoning efforts are unavailable (${errorChain(error)})`);
-	})]);
-	if (!response.ok) throw await oauthEndpointError(response, "grok models");
+		...copilotHeaders(false, await latestVsCodeVersion(fetchFn))
+	} });
+	if (!response.ok) throw await oauthEndpointError(response, "copilot models");
 	const payload = await response.json();
-	if (!Array.isArray(payload.data)) throw new Error("grok models endpoint returned no data array");
+	if (!Array.isArray(payload.data)) throw new Error("copilot models endpoint returned no data array");
 	const seen = /* @__PURE__ */ new Set();
 	const discovered = [];
 	for (const entry of payload.data) {
 		if (typeof entry.id !== "string" || entry.id.length === 0 || seen.has(entry.id)) continue;
-		if (!isChatModel(entry.id)) continue;
+		if (entry.model_picker_enabled !== true || entry.policy?.state === "disabled") continue;
+		let wire;
+		let responsesSupported = false;
+		if (Array.isArray(entry.supported_endpoints)) {
+			responsesSupported = entry.supported_endpoints.includes("/responses");
+			if (entry.supported_endpoints.includes("/chat/completions")) wire = "chat-completions";
+			else if (responsesSupported) wire = "responses";
+			else continue;
+		}
 		seen.add(entry.id);
+		const reasoning = copilotReasoning(entry);
 		discovered.push({
 			id: entry.id,
-			name: entry.id,
-			...cliCatalog?.get(entry.id)
+			name: typeof entry.name === "string" && entry.name.length > 0 ? entry.name : entry.id,
+			...typeof entry.capabilities?.limits?.max_context_window_tokens === "number" && entry.capabilities.limits.max_context_window_tokens > 0 ? { contextWindow: entry.capabilities.limits.max_context_window_tokens } : {},
+			inputModalities: entry.capabilities?.supports?.vision === true ? ["text", "image"] : ["text"],
+			...reasoning === void 0 ? {} : { reasoning },
+			...wire === void 0 ? {} : { copilotWire: wire },
+			...responsesSupported ? { copilotResponses: true } : {}
 		});
 	}
-	if (discovered.length === 0) throw new Error("grok models endpoint returned an empty catalog");
+	if (discovered.length === 0) throw new Error("copilot models endpoint returned an empty catalog");
 	return discovered;
 }
-/** Grok wire adapter: one instance serves the `grok` provider route. */
-var GrokAdapter = class extends LlmAdapter {
+/**
+* The wire protocol for one model: the discovered catalog entry's recorded
+* choice, defaulting to chat completions for unknown models (static-catalog
+* and no-discovery configurations, and models listing both endpoints).
+* @param entry - the discovered catalog entry, when known.
+* @returns the protocol the request for this model must speak.
+*/
+function copilotWireFor(entry) {
+	return entry?.copilotWire === "responses" ? "responses" : "chat-completions";
+}
+/**
+* The upstream protocol for ONE REQUEST: the model's default wire, except
+* that a dual-protocol model defaulting to chat completions must reroute to
+* Responses when the request combines function tools with a reasoning effort
+* — Copilot rejects exactly that combination on /chat/completions with
+* HTTP 400 invalid_request_body ("Function tools with reasoning_effort are
+* not supported … use /v1/responses or set reasoning_effort to 'none'",
+* observed on gpt-5.4) while /responses serves it. Effort 'none' stays on
+* the chat wire (the API allows the combination there), and models not
+* listing /responses never reroute.
+* @param entry - the discovered catalog entry, when known.
+* @param options - the harness generate options (tools + effort only).
+* @returns the protocol the request for this model must speak.
+*/
+function copilotRequestWire(entry, options) {
+	const wire = copilotWireFor(entry);
+	if (wire !== "chat-completions") return wire;
+	if (entry?.copilotResponses !== true) return wire;
+	if (options.tools === void 0 || options.tools.length === 0) return wire;
+	if (options.reasoningEffort === void 0 || options.reasoningEffort === "none") return wire;
+	return "responses";
+}
+/**
+* The chat completions request body for one generation. The output cap rides
+* `max_completion_tokens` — the newer OpenAI-family models on Copilot reject
+* the legacy `max_tokens` parameter outright (HTTP 400 "Unsupported
+* parameter"), and the rest of the catalog accepts the new spelling.
+* @param options - the harness generate options.
+* @param messages - translated wire messages (images pre-resolved).
+* @returns the JSON body.
+*/
+function copilotChatRequestBody(options, messages) {
+	return {
+		model: options.model,
+		messages,
+		...options.tools !== void 0 && options.tools.length > 0 ? {
+			tools: toChatTools(options.tools),
+			tool_choice: "auto"
+		} : {},
+		...options.maxTokens !== void 0 ? { max_completion_tokens: options.maxTokens } : {},
+		...options.reasoningEffort !== void 0 ? { reasoning_effort: String(options.reasoningEffort) } : {},
+		stream: true,
+		stream_options: { include_usage: true }
+	};
+}
+/**
+* The Responses request body for one generation (the wire the `/responses`-
+* only model families speak). Usage arrives on `response.completed`.
+* @param options - the harness generate options.
+* @param resolved - translated instructions + input (images pre-resolved).
+* @returns the JSON body.
+*/
+function copilotResponsesRequestBody(options, resolved) {
+	return {
+		model: options.model,
+		...resolved.instructions !== void 0 ? { instructions: resolved.instructions } : {},
+		input: resolved.input,
+		...options.tools !== void 0 && options.tools.length > 0 ? {
+			tools: toResponsesTools(options.tools),
+			tool_choice: "auto"
+		} : {},
+		...options.maxTokens !== void 0 ? { max_output_tokens: options.maxTokens } : {},
+		...options.reasoningEffort !== void 0 ? { reasoning: { effort: String(options.reasoningEffort) } } : {},
+		include: ["reasoning.encrypted_content"],
+		stream: true
+	};
+}
+/**
+* The replayable form of one completed reasoning item: the COMPLETE item as
+* the gateway delivered it on `response.output_item.done` — its ORIGINAL id
+* (captured before the stable-key rewrite), summary parts, status, and the
+* encrypted payload. A reasoning item's `id` and `summary` are not optional
+* in the Responses input schema, so an item missing its id or its blob is
+* not replayable and degrades to the no-replay path instead of risking an
+* invalid input item.
+*/
+function completedReasoningItem(item) {
+	if (typeof item.encrypted_content !== "string" || item.encrypted_content.length === 0) return void 0;
+	if (typeof item.id !== "string" || item.id.length === 0) return void 0;
+	return {
+		type: "reasoning",
+		id: item.id,
+		...Array.isArray(item.summary) ? { summary: item.summary } : {},
+		...typeof item.status === "string" && item.status.length > 0 ? { status: item.status } : {},
+		encrypted_content: item.encrypted_content
+	};
+}
+/**
+* Rewrite Copilot's Responses-gateway item ids into stable per-item keys.
+* Unlike chatgpt.com's Responses backend, the Copilot gateway mints a FRESH
+* opaque `item.id`/`item_id` on every event of one response (the `added`,
+* each delta, and the `done` all differ), which defeats id-keyed block
+* assembly in the shared translator: text fragments would each open their
+* own block, `done` would synthesize duplicates, and a function call whose
+* arguments arrive whole only on `done` (the deltas carry empty strings)
+* would close empty. The stable key derives from the event's `output_index`
+* — the item's position in the response's output array, which survives the
+* gateway's per-event id churn even when two items' events interleave on
+* the wire (parallel tool calls do exactly that). Events without an
+* `output_index` fall back to the key of the last `output_item.added`, which
+* is only correct while one item's events stay contiguous — the pre-
+* interleaving behavior, kept for gateways that omit the field; with no
+* `added` seen yet they key to `copilot-item-0` as before. Function-call
+* identity additionally rides the gateway-stable `call_id`.
+*/
+var CopilotResponsesItemNormalizer = class {
+	adds = 0;
+	lastKey = "copilot-item-0";
+	/** Call ids and completed reasoning items collected for the open response. */
+	capturedCallIds = [];
+	capturedReasoning = [];
+	/**
+	* @param onCaptured - fired at each `response.completed` that produced BOTH
+	*   function calls and completed reasoning items, receiving the response's
+	*   call ids and replayable reasoning items so the adapter can replay them
+	*   on the next request.
+	*/
+	constructor(onCaptured) {
+		this.onCaptured = onCaptured;
+	}
+	/**
+	* [2026-08-23]-[a single arrival-order ordinal mis-buckets every event after
+	* a second item's `added`, mangling interleaved parallel tool calls;
+	* output_index is the only correlator the gateway keeps stable]-[changes
+	* keys only for streams that carry output_index; no-index streams keep the
+	* old last-added-key behavior byte for byte]
+	*/
+	keyFor(event) {
+		return event.output_index !== void 0 ? `copilot-item-${String(event.output_index)}` : this.lastKey;
+	}
+	/**
+	* Rewrite one parsed Responses event.
+	* @param event - the event as parsed off the wire.
+	* @returns the event with a stable item key.
+	*/
+	push(event) {
+		if (event.type === "response.output_item.added") {
+			this.adds += 1;
+			const key = event.output_index !== void 0 ? `copilot-item-${String(event.output_index)}` : `copilot-item-${String(this.adds)}`;
+			this.lastKey = key;
+			const item = event.item;
+			if (item?.type === "function_call" && typeof item.call_id === "string" && item.call_id.length > 0) this.capturedCallIds.push(item.call_id);
+			return item === void 0 ? event : {
+				...event,
+				item: {
+					...item,
+					id: key
+				}
+			};
+		}
+		if (event.type === "response.output_item.done") {
+			const item = event.item;
+			if (item?.type === "reasoning") {
+				const captured = completedReasoningItem(item);
+				if (captured !== void 0) this.capturedReasoning.push(captured);
+			}
+			return item === void 0 ? event : {
+				...event,
+				item: {
+					...item,
+					id: this.keyFor(event)
+				}
+			};
+		}
+		if (event.type === "response.completed") {
+			if (this.capturedCallIds.length > 0 && this.capturedReasoning.length > 0) this.onCaptured?.(this.capturedCallIds, this.capturedReasoning);
+			this.capturedCallIds = [];
+			this.capturedReasoning = [];
+			return event;
+		}
+		if (event.item_id === void 0) return event;
+		return {
+			...event,
+			item_id: this.keyFor(event)
+		};
+	}
+};
+/** Copilot wire adapter: one instance serves the `copilot` provider route. */
+var CopilotAdapter = class CopilotAdapter extends LlmAdapter {
 	catalog;
+	/**
+	* [2026-08-23]-[a reasoning model continuing a tool chain must get its
+	* reasoning back or it restarts from scratch every tool round trip; the
+	* items live in ADAPTER memory because dsh-llm's reasoning ContentBlock is
+	* a closed shape that cannot carry them through the harness]-[entries are
+	* namespaced per ACCOUNT × CONVERSATION × MODEL, idle out via a sliding
+	* TTL, and the whole store is dropped on auth transitions, so replay
+	* degrades to the old behavior instead of leaking across contexts]
+	*/
+	replayByScope = /* @__PURE__ */ new Map();
+	/** Call-id entries kept per scope; see {@link captureReasoning}. */
+	static REPLAY_CALL_LIMIT = 64;
+	/** Conversation scopes kept at once; bounds memory when many sessions interleave. */
+	static REPLAY_SCOPE_LIMIT = 32;
+	/** How long a captured entry stays replayable; tool round trips take minutes, not hours. */
+	static REPLAY_TTL_MS = 30 * 6e4;
 	constructor(options) {
 		super();
 		this.options = options;
@@ -3155,12 +4946,12 @@ var GrokAdapter = class extends LlmAdapter {
 	}
 	/** Discovery fetcher: resolves the session through the refresh-aware path. */
 	async fetchCatalog() {
-		return fetchGrokModels(await this.options.tokens.session(), this.options.fetchFn, this.options.onWarn);
+		return fetchCopilotModels(await this.options.tokens.session(), this.options.fetchFn);
 	}
 	providerInfo(provider) {
 		return {
 			id: provider,
-			name: "Grok (Subscription)"
+			name: "GitHub Copilot"
 		};
 	}
 	staticModels(provider) {
@@ -3168,39 +4959,133 @@ var GrokAdapter = class extends LlmAdapter {
 			provider,
 			id: model.id,
 			name: model.name ?? model.id,
-			inputModalities: model.inputModalities ?? grokModalities(model.id)
+			inputModalities: model.inputModalities ?? ["text"]
 		}));
 	}
 	async listModels(provider) {
 		if (await this.options.tokens.peek() === void 0) return [];
 		if (!this.options.discovery) return this.staticModels(provider);
 		try {
-			return (await this.catalog.get(() => this.fetchCatalog())).map((model) => ({
+			return (await discoverOrRetryAuth((force) => this.options.tokens.session(force), this.catalog, () => this.catalog.get(() => this.fetchCatalog()))).map((model) => ({
 				provider,
 				id: model.id,
 				name: model.name,
 				...model.description === void 0 ? {} : { description: model.description },
-				inputModalities: grokModalities(model.id)
+				...model.inputModalities === void 0 ? {} : { inputModalities: model.inputModalities }
 			}));
 		} catch (error) {
-			if (error instanceof LlmError && (error.code === "MISSING_CREDENTIAL" || error.code === "INVALID_CREDENTIAL")) return [];
-			if (error instanceof OAuthEndpointError && error.status === 401) this.catalog.invalidate();
-			this.options.onWarn?.(`grok model discovery failed; using the built-in catalog (${errorChain(error)})`);
+			if (isMissingOrInvalidCredential(error)) return [];
+			this.options.onWarn?.(`copilot model discovery failed; using the built-in catalog (${errorChain(error)})`);
 			return this.staticModels(provider);
 		}
 	}
 	/**
 	* The discovered entry for one model. Resolved through the cache's
 	* stale-while-revalidate path: capability metadata must stay stable across
-	* a long conversation — a session that selected a reasoning effort calls
-	* this on EVERY step, and forgetting the efforts just because the TTL
-	* lapsed mid-turn would fail the call with UNSUPPORTED_REASONING_EFFORT
-	* before provider I/O.
+	* a long conversation — a mid-turn refetch must neither block nor fail the
+	* call before provider I/O.
 	*/
 	async discovered(model) {
 		if (!this.options.discovery) return void 0;
 		return (await this.catalog.resolve(() => this.fetchCatalog()))?.find((entry) => entry.id === model);
 	}
+	/**
+	* [2026-08-23]-[a manually configured responses-only model combined with
+	* `discovery:false` left discovered() undefined, so copilotRequestWire
+	* silently defaulted to /chat/completions and the request 404/400'd at the
+	* gateway; an explicit config wire must win over catalog inference]-[config
+	* `models[].wire` now routes the request even without discovery]
+	*/
+	configuredWireEntry(model) {
+		const configured = this.options.models.find((entry) => entry.id === model);
+		return configured?.wire === void 0 ? void 0 : {
+			id: configured.id,
+			name: configured.name ?? configured.id,
+			copilotWire: configured.wire
+		};
+	}
+	/**
+	* The replay scope isolating one ACCOUNT × CONVERSATION × MODEL. The
+	* account identity is the session's long-lived GitHub token (stable across
+	* Copilot-token refreshes, different per GitHub login); the conversation is
+	* the loop-stamped `sessionId`, falling back to the first message's id
+	* when a hand-built request carries no session stamp; the model separates
+	* wire families. A call id captured in one scope is invisible to every
+	* other scope, so reused ids cannot leak reasoning across accounts,
+	* conversations, or models.
+	*/
+	replayScope(tokenKey, options) {
+		return `${tokenKey}\u0000${options.sessionId !== void 0 ? `session:${String(options.sessionId)}` : options.messages[0] !== void 0 ? `anchor:${String(options.messages[0].id)}` : "conversation:none"}\u0000${options.model}`;
+	}
+	/**
+	* Store one response's completed reasoning items behind every call id it
+	* produced, inside one replay scope. Retention: a CONSUMED entry is kept —
+	* every later round of the same conversation replays ALL its earlier
+	* function_calls — until it idles out of the TTL (see {@link replayFor})
+	* or the per-scope entry cap evicts it oldest-first. All calls of one
+	* response share ONE entry object: toResponsesInput dedupes replays by
+	* array reference, so parallel calls replay the items once instead of once
+	* per call.
+	*/
+	captureReasoning(scope, callIds, items) {
+		let entries = this.replayByScope.get(scope);
+		if (entries === void 0) {
+			entries = /* @__PURE__ */ new Map();
+			this.replayByScope.set(scope, entries);
+		} else {
+			this.replayByScope.delete(scope);
+			this.replayByScope.set(scope, entries);
+		}
+		const now = Date.now();
+		for (const [callId, entry$1] of entries) if (now - entry$1.at >= CopilotAdapter.REPLAY_TTL_MS) entries.delete(callId);
+		const entry = {
+			items: [...items],
+			at: now
+		};
+		for (const callId of callIds) entries.set(callId, entry);
+		while (entries.size > CopilotAdapter.REPLAY_CALL_LIMIT) {
+			const oldest = entries.keys().next().value;
+			if (oldest === void 0) break;
+			entries.delete(oldest);
+		}
+		while (this.replayByScope.size > CopilotAdapter.REPLAY_SCOPE_LIMIT) {
+			const oldest = this.replayByScope.keys().next().value;
+			if (oldest === void 0) break;
+			this.replayByScope.delete(oldest);
+		}
+	}
+	/**
+	* The replay items for one call id in one scope, when still fresh. The TTL
+	* bounds IDLE time, not total age: a hit refreshes the entry (and its
+	* eviction recency), so an ongoing conversation keeps its chain alive
+	* while a conversation that stopped asking forgets within the TTL. An
+	* absent or aged-out entry answers `undefined` — the no-replay
+	* degradation, never an error.
+	*/
+	replayFor(scope, callId) {
+		const entries = this.replayByScope.get(scope);
+		const entry = entries?.get(callId);
+		if (entries === void 0 || entry === void 0) return void 0;
+		const now = Date.now();
+		if (now - entry.at >= CopilotAdapter.REPLAY_TTL_MS) return void 0;
+		entry.at = now;
+		entries.delete(callId);
+		entries.set(callId, entry);
+		this.replayByScope.delete(scope);
+		this.replayByScope.set(scope, entries);
+		return entry.items;
+	}
+	/**
+	* Drop every captured replay entry. Lookup correctness never depends on
+	* the call — the scope already carries the account identity — but the host
+	* wiring invokes this on every copilot auth transition (login, logout,
+	* credential death) so a switched account's memory never holds the
+	* previous account's encrypted reasoning at all; conversation teardown is
+	* bounded by the TTL and the caps.
+	*/
+	clearReplayState() {
+		this.replayByScope.clear();
+	}
 	async resolveModel(provider, model) {
 		const discovered = await this.discovered(model);
 		const configured = this.options.models.find((entry) => entry.id === model);
@@ -3209,53 +5094,52 @@ var GrokAdapter = class extends LlmAdapter {
 			id: model,
 			name: discovered?.name ?? configured?.name ?? model,
 			...discovered?.description === void 0 ? {} : { description: discovered.description },
-			inputModalities: configured?.inputModalities ?? grokModalities(model),
-			context: { contextWindow: discovered?.contextWindow ?? configured?.contextWindow ?? GROK_CONTEXT_WINDOW },
-			defaultMaxTokens: configured?.maxTokens ?? GROK_DEFAULT_MAX_TOKENS,
+			inputModalities: discovered?.inputModalities ?? configured?.inputModalities ?? ["text"],
+			context: { contextWindow: discovered?.contextWindow ?? configured?.contextWindow ?? COPILOT_CONTEXT_WINDOW },
+			defaultMaxTokens: configured?.maxTokens ?? COPILOT_DEFAULT_MAX_TOKENS,
 			...discovered?.reasoning === void 0 ? {} : { reasoning: discovered.reasoning }
 		};
 	}
 	async *stream(options) {
 		const watchdog = idleWatchdog(options.signal, this.options.streamIdleTimeoutMs);
 		try {
+			const wire = copilotRequestWire(this.configuredWireEntry(options.model) ?? await this.discovered(options.model), options);
 			let session = await this.options.tokens.session();
-			let response = await this.request(options, session, watchdog.signal);
+			const scope = this.replayScope(session.refreshToken, options);
+			let response = await this.request(options, session, watchdog.signal, wire, scope);
 			if (response.status === 401) {
+				await latestVsCodeVersion(this.options.fetchFn ?? proxiedFetch, true);
 				session = await this.options.tokens.session(true);
-				response = await this.request(options, session, watchdog.signal);
+				response = await this.request(options, session, watchdog.signal, wire, scope);
 			}
-			if (!response.ok) throw await httpLlmError(response, "grok API");
-			if (response.body === null) throw new LlmError("grok API returned no response body", EMPTY_RESPONSE_CODE);
-			yield* streamResponses(response.body, () => {
+			if (!response.ok) throw await httpLlmError(response, "copilot API");
+			if (response.body === null) throw new LlmError("copilot API returned no response body", EMPTY_RESPONSE_CODE);
+			const pulse = () => {
 				watchdog.pulse();
-			});
+			};
+			if (wire === "responses") {
+				const normalizer = new CopilotResponsesItemNormalizer((callIds, items) => {
+					this.captureReasoning(scope, callIds, items);
+				});
+				yield* streamResponses(response.body, pulse, (event) => normalizer.push(event));
+			} else yield* streamChatCompletions(response.body, pulse);
 		} catch (error) {
-			throw mapFetchFailure("grok API", error, watchdog, options.signal);
+			throw mapFetchFailure("copilot API", error, watchdog, options.signal);
 		} finally {
 			watchdog.stop();
 		}
 	}
-	async request(options, session, signal) {
-		const { instructions, input } = toResponsesInput(await resolveImages(options.messages, this.options.resolveAttachments?.(), signal), options.system);
-		const body = {
-			model: options.model,
-			...instructions === void 0 ? {} : { instructions },
-			input,
-			...options.tools !== void 0 && options.tools.length > 0 ? { tools: toResponsesTools(options.tools) } : {},
-			tool_choice: "auto",
-			parallel_tool_calls: true,
-			...options.maxTokens !== void 0 ? { max_output_tokens: options.maxTokens } : {},
-			...options.reasoningEffort !== void 0 ? { reasoning: { effort: String(options.reasoningEffort) } } : {},
-			store: false,
-			stream: true
-		};
-		return fetch(GROK_API_URL, {
+	async request(options, session, signal, wire, replayScopeKey) {
+		const messages = await resolveImages(options.messages, this.options.resolveAttachments?.(), signal);
+		const hasVision = messages.some((message) => message.content.some((block) => block.type === "image"));
+		const body = wire === "responses" ? copilotResponsesRequestBody(options, toResponsesInput(messages, options.system, (callId) => this.replayFor(replayScopeKey, callId))) : copilotChatRequestBody(options, toChatMessages(messages, options.system));
+		return proxiedFetch(wire === "responses" ? COPILOT_RESPONSES_URL : COPILOT_API_URL, {
 			method: "POST",
 			headers: {
 				"authorization": `Bearer ${session.accessToken}`,
 				"accept": "text/event-stream",
 				"content-type": "application/json",
-				...attributionHeaders()
+				...copilotHeaders(hasVision, await latestVsCodeVersion(this.options.fetchFn ?? proxiedFetch))
 			},
 			body: JSON.stringify(body),
 			signal
@@ -3423,7 +5307,7 @@ function createXSearchTool(options) {
 		async execute(args, exec) {
 			const request = buildXSearchRequest(args);
 			const session = await options.tokens.session();
-			const response = await (options.fetchFn ?? fetch)(X_SEARCH_URL, {
+			const response = await (options.fetchFn ?? proxiedFetch)(X_SEARCH_URL, {
 				method: "POST",
 				headers: {
 					"authorization": `Bearer ${session.accessToken}`,
@@ -3688,7 +5572,7 @@ function createImageGenerateTool(options) {
 			content: result.content.filter((block) => block.type === "text")
 		}),
 		async execute(args, exec) {
-			const fetchFn = options.fetchFn ?? fetch;
+			const fetchFn = options.fetchFn ?? proxiedFetch;
 			const preferGrok = args.provider === "grok";
 			const codexReady = options.codexTokens !== void 0 && await options.codexTokens.hasSession();
 			const grokReady = options.grokTokens !== void 0 && await options.grokTokens.hasSession();
@@ -3958,7 +5842,7 @@ function createVideoGenerateTool(options) {
 		async execute(args, exec) {
 			const body = buildVideoGenerateBody(args);
 			const session = await options.tokens.session();
-			const fetchFn = options.fetchFn ?? fetch;
+			const fetchFn = options.fetchFn ?? proxiedFetch;
 			const headers = {
 				"authorization": `Bearer ${session.accessToken}`,
 				"accept": "application/json"
@@ -4020,26 +5904,30 @@ const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
 const providerIdSchema = z.union([
 	"codex",
 	"claude",
-	"grok"
+	"grok",
+	"copilot"
 ]);
 const modelEntrySchema = z.object({
 	id: z.string().required(),
 	name: z.string(),
 	contextWindow: z.number().step(1).min(1),
 	maxTokens: z.number().step(1).min(1),
-	inputModalities: z.array(z.union(["text", "image"]))
+	inputModalities: z.array(z.union(["text", "image"])),
+	wire: z.union(["chat-completions", "responses"])
 });
 const Config = z.object({
 	providers: z.array(providerIdSchema).default([
 		"codex",
 		"claude",
-		"grok"
+		"grok",
+		"copilot"
 	]),
 	streamIdleTimeoutMs: z.number().min(1).default(DEFAULT_STREAM_IDLE_TIMEOUT_MS),
 	models: z.object({
 		codex: z.array(modelEntrySchema),
 		claude: z.array(modelEntrySchema),
-		grok: z.array(modelEntrySchema)
+		grok: z.array(modelEntrySchema),
+		copilot: z.array(modelEntrySchema)
 	})
 });
 /** Built-in catalogs used when the config does not override a provider's models. */
@@ -4096,6 +5984,28 @@ const DEFAULT_MODELS = {
 			id: "grok-code-fast-1",
 			name: "Grok Code Fast 1"
 		}
+	],
+	copilot: [
+		{
+			id: "gpt-4.1",
+			name: "GPT-4.1",
+			inputModalities: ["text", "image"]
+		},
+		{
+			id: "gpt-4o",
+			name: "GPT-4o",
+			inputModalities: ["text", "image"]
+		},
+		{
+			id: "claude-sonnet-4.5",
+			name: "Claude Sonnet 4.5",
+			inputModalities: ["text", "image"]
+		},
+		{
+			id: "gemini-2.5-pro",
+			name: "Gemini 2.5 Pro",
+			inputModalities: ["text", "image"]
+		}
 	]
 };
 /** Validate and detach the model catalog for every provider. */
@@ -4107,7 +6017,8 @@ function resolveCatalog(models) {
 	return {
 		codex: resolve("codex"),
 		claude: resolve("claude"),
-		grok: resolve("grok")
+		grok: resolve("grok"),
+		copilot: resolve("copilot")
 	};
 }
 /** The display account of a stored session, for the status endpoint. */
@@ -4120,21 +6031,49 @@ function accountOf(provider, session) {
 		}
 		case "claude": return session.emailAddress;
 		case "grok": return session.account;
+		case "copilot": return session.account;
 	}
 }
 /**
 * Auth operations behind the `/subscriptions-auth` RPC channel: start/complete
 * OAuth attempts in the background, feed pasted codes, cancel, log out, and
 * answer usage lookups.
+*
+* @internal Exported for tests only; not part of the plugin's public surface.
 */
 var SubscriptionsAuthController = class {
 	/** Last login failure per provider, surfaced as `detail` until the next success. */
 	lastError = /* @__PURE__ */ new Map();
-	constructor(flows, onAuthChanged, resolveAttachments, usageFetchers = {}) {
+	/**
+	* Device-flow logins whose poll already settled but whose token exchange +
+	* persist is still running. Between those two moments the attempt is gone
+	* from the flow manager (busy=false) while no session exists yet
+	* (loggedIn=false) — counting this window as busy keeps the Settings page
+	* polling until the card can show the real outcome.
+	*/
+	finalizing = /* @__PURE__ */ new Set();
+	/** In-flight OAuth completions, one per provider at most. */
+	completions = /* @__PURE__ */ new Map();
+	/**
+	* Per-provider claim counter. Everything that takes ownership of a
+	* provider's session — starting a login, importing Claude Code credentials,
+	* cancelling, logging out — bumps it, and a session write carrying an older
+	* number has been superseded and is dropped.
+	*
+	* The counter is what makes a late OAuth completion safe: an attempt leaves
+	* `OAuthFlowManager`'s pending map the moment its callback delivers the
+	* code, while the token exchange that follows can still run for seconds. For
+	* that whole window `pending(provider)?.cancel()` is a no-op, so ownership
+	* cannot be read off the flow manager.
+	*/
+	claims = /* @__PURE__ */ new Map();
+	constructor(flows, deviceFlows, onAuthChanged, resolveAttachments, usageFetchers = {}, readClaudeCreds = readClaudeCodeCredentials) {
 		this.flows = flows;
+		this.deviceFlows = deviceFlows;
 		this.onAuthChanged = onAuthChanged;
 		this.resolveAttachments = resolveAttachments;
 		this.usageFetchers = usageFetchers;
+		this.readClaudeCreds = readClaudeCreds;
 	}
 	usage(provider, signal) {
 		const fetcher = this.usageFetchers[provider];
@@ -4162,7 +6101,7 @@ var SubscriptionsAuthController = class {
 		const detail = this.lastError.get(provider);
 		return {
 			loggedIn: session !== void 0,
-			busy: this.flows.isBusy(provider),
+			busy: this.flows.isBusy(provider) || this.deviceFlows.isBusy(provider) || this.finalizing.has(provider),
 			...session === void 0 ? {} : { expiresAt: session.expiresAt },
 			...account === void 0 ? {} : { account },
 			...detail === void 0 ? {} : { detail }
@@ -4170,30 +6109,73 @@ var SubscriptionsAuthController = class {
 	}
 	async login(provider) {
 		if (provider === "claude") {
-			const session = readClaudeCodeCredentials();
-			if (session) {
-				await this.persist("claude", session);
+			const imported = this.readClaudeCreds();
+			if (imported !== void 0) {
+				this.claim("claude");
+				this.flows.pending("claude")?.cancel();
+				await this.persist("claude", imported);
 				this.lastError.delete("claude");
 				this.onAuthChanged("claude");
 				return { authorizeUrl: "" };
 			}
-			throw new Error("Claude Code credentials not found. Run \"claude\" first to log in.");
+			const attempt$1 = await this.flows.start("claude", claudeFlow);
+			this.completions.set("claude", this.complete("claude", attempt$1, this.claim("claude")));
+			return { authorizeUrl: attempt$1.authorizeUrl };
+		}
+		if (provider === "copilot") {
+			const attempt$1 = await this.deviceFlows.start(provider, copilotDeviceFlow());
+			this.finalizing.add(provider);
+			this.completeDevice(provider, attempt$1);
+			return {
+				authorizeUrl: attempt$1.verificationUrl,
+				userCode: attempt$1.userCode
+			};
 		}
 		const spec = provider === "grok" ? await grokFlow() : codexFlow;
 		const attempt = await this.flows.start(provider, spec);
-		this.complete(provider, attempt);
+		this.completions.set(provider, this.complete(provider, attempt, this.claim(provider)));
 		return { authorizeUrl: attempt.authorizeUrl };
 	}
-	/** Drive one attempt to a stored session; records failures for the status endpoint. */
-	async complete(provider, attempt) {
+	/**
+	* Take ownership of a provider's session, superseding every older claim.
+	* @param provider - the provider route.
+	* @returns the claim number a later write checks itself against.
+	*/
+	claim(provider) {
+		const next = (this.claims.get(provider) ?? 0) + 1;
+		this.claims.set(provider, next);
+		return next;
+	}
+	/**
+	* Drive one attempt to a stored session; records failures for the status
+	* endpoint. The exchange runs unsupervised — the attempt is gone from the
+	* flow manager as soon as its code arrives — so the result is stored only
+	* while `claim` still owns the provider's session.
+	*/
+	async complete(provider, attempt, claim) {
 		try {
 			const code = await attempt.waitCode();
 			const session = await this.exchange(provider, code, attempt);
+			if (this.claims.get(provider) !== claim) return;
+			await this.persist(provider, session);
+			this.lastError.delete(provider);
+			this.onAuthChanged(provider);
+		} catch (error) {
+			if (this.claims.get(provider) !== claim) return;
+			if (!(error instanceof Error && error.message === "login cancelled")) this.lastError.set(provider, errorChain(error));
+		}
+	}
+	/** Drive one device-flow attempt to a stored session (the copilot path of {@link complete}). */
+	async completeDevice(provider, attempt) {
+		try {
+			const session = await completeCopilotLogin(await attempt.waitToken());
 			await this.persist(provider, session);
 			this.lastError.delete(provider);
 			this.onAuthChanged(provider);
 		} catch (error) {
 			if (!(error instanceof Error && error.message === "login cancelled")) this.lastError.set(provider, errorChain(error));
+		} finally {
+			this.finalizing.delete(provider);
 		}
 	}
 	exchange(provider, code, attempt) {
@@ -4201,6 +6183,7 @@ var SubscriptionsAuthController = class {
 			case "codex": return exchangeCodexCode(code, attempt.pkce.verifier, attempt.redirectUri);
 			case "claude": return exchangeClaudeCode(code, attempt.pkce.verifier, attempt.redirectUri, attempt.state);
 			case "grok": return exchangeGrokCode(code, attempt.pkce.verifier, attempt.redirectUri, attempt.pkce.challenge);
+			case "copilot": return Promise.reject(/* @__PURE__ */ new Error("copilot uses the device flow; no authorization code to exchange"));
 		}
 	}
 	persist(provider, session) {
@@ -4208,8 +6191,19 @@ var SubscriptionsAuthController = class {
 			case "codex": return saveSession("codex", session);
 			case "claude": return saveSession("claude", session);
 			case "grok": return saveSession("grok", session);
+			case "copilot": return saveSession("copilot", session);
 		}
 	}
+	/**
+	* Settle once no OAuth completion is running for a provider.
+	*
+	* @internal Exported for tests only: a login's token exchange outlives the
+	* `login()` call that started it, and a test asserting on what it stored
+	* would otherwise have to guess at a timeout.
+	*/
+	async settled(provider) {
+		await this.completions.get(provider);
+	}
 	manual(provider, input) {
 		const attempt = this.flows.pending(provider);
 		if (attempt === void 0) return Promise.reject(/* @__PURE__ */ new Error(`no ${provider} login attempt is in progress`));
@@ -4217,11 +6211,15 @@ var SubscriptionsAuthController = class {
 		return Promise.resolve();
 	}
 	cancel(provider) {
+		this.claim(provider);
 		this.flows.pending(provider)?.cancel();
+		this.deviceFlows.pending(provider)?.cancel();
 		return Promise.resolve();
 	}
 	async logout(provider) {
+		this.claim(provider);
 		this.flows.pending(provider)?.cancel();
+		this.deviceFlows.pending(provider)?.cancel();
 		await deleteSession(provider);
 		this.lastError.delete(provider);
 		this.onAuthChanged(provider);
@@ -4234,12 +6232,14 @@ function apply(ctx, config) {
 	const catalog = resolveCatalog(config.models);
 	const overridden = new Set(PROVIDER_IDS.filter((provider) => (config.models?.[provider]?.length ?? 0) > 0));
 	const flows = new OAuthFlowManager();
+	const deviceFlows = new DeviceFlowManager();
 	const onWarn = (message) => {
 		ctx.logger.warn(`dsh-plugin-subscriptions: ${message}`);
 	};
 	const resolveAttachments = () => ctx.get("attachments");
 	const handles = /* @__PURE__ */ new Map();
 	const authChanged = (provider) => {
+		if (provider === "copilot") copilotAdapter?.clearReplayState();
 		handles.get(provider)?.replace([provider]);
 	};
 	let codexTokens;
@@ -4248,6 +6248,7 @@ function apply(ctx, config) {
 	const usageFetchers = {};
 	const speedBySession = /* @__PURE__ */ new Map();
 	let codexAdapter;
+	let copilotAdapter;
 	for (const provider of providers) switch (provider) {
 		case "codex": {
 			const tokens = new TokenManager({
@@ -4263,7 +6264,7 @@ function apply(ctx, config) {
 				}
 			});
 			codexTokens = tokens;
-			usageFetchers.codex = async (signal) => fetchCodexUsage(await tokens.session(), fetch, signal);
+			usageFetchers.codex = async (signal) => fetchCodexUsage(await tokens.session(), proxiedFetch, signal);
 			let adapter;
 			adapter = new CodexAdapter({
 				models: catalog.codex,
@@ -4293,7 +6294,7 @@ function apply(ctx, config) {
 				}
 			});
 			claudeTokens = tokens;
-			usageFetchers.claude = async (signal) => fetchClaudeUsage(await tokens.session(), fetch, signal);
+			usageFetchers.claude = async (signal) => fetchClaudeUsage(await tokens.session(), proxiedFetch, signal);
 			handles.set("claude", ctx.llm.registerAdapter(["claude"], new ClaudeAdapter({
 				models: catalog.claude,
 				streamIdleTimeoutMs,
@@ -4320,7 +6321,7 @@ function apply(ctx, config) {
 				}
 			});
 			grokTokens = tokens;
-			usageFetchers.grok = async (signal) => fetchGrokUsage(await tokens.session(), fetch, signal);
+			usageFetchers.grok = async (signal) => fetchGrokUsage(await tokens.session(), proxiedFetch, signal);
 			handles.set("grok", ctx.llm.registerAdapter(["grok"], new GrokAdapter({
 				models: catalog.grok,
 				streamIdleTimeoutMs,
@@ -4332,8 +6333,33 @@ function apply(ctx, config) {
 			})));
 			break;
 		}
+		case "copilot": {
+			const tokens = new TokenManager({
+				displayName: "GitHub Copilot",
+				preemptMs: COPILOT_PREEMPT_MS,
+				load: () => getSession("copilot"),
+				save: (session) => saveSession("copilot", session),
+				remove: () => deleteSession("copilot"),
+				refresh: refreshCopilot,
+				isPermanent: isCopilotPermanentRefreshError,
+				onRemoved: () => {
+					authChanged("copilot");
+				}
+			});
+			copilotAdapter = new CopilotAdapter({
+				models: catalog.copilot,
+				streamIdleTimeoutMs,
+				tokens,
+				discovery: !overridden.has("copilot"),
+				onWarn,
+				resolveAttachments,
+				catalogStore: catalogStore("copilot")
+			});
+			handles.set("copilot", ctx.llm.registerAdapter(["copilot"], copilotAdapter));
+			break;
+		}
 	}
-	registerAuthRpc(ctx, new SubscriptionsAuthController(flows, authChanged, resolveAttachments, usageFetchers), {
+	registerAuthRpc(ctx, new SubscriptionsAuthController(flows, deviceFlows, authChanged, resolveAttachments, usageFetchers), {
 		async speed(sessionId) {
 			return {
 				tier: speedBySession.get(sessionId) ?? "standard",
@@ -4344,6 +6370,10 @@ function apply(ctx, config) {
 			if (tier === "standard") speedBySession.delete(sessionId);
 			else speedBySession.set(sessionId, tier);
 		}
+	}, {
+		get: () => proxyGetConfig(),
+		set: (input) => proxySetConfig(input),
+		test: (payload) => proxyTestConnection(payload.url, payload.proxy)
 	});
 	if (claudeTokens !== void 0) {
 		const syncTimer = setInterval(() => {
@@ -4368,4 +6398,4 @@ function apply(ctx, config) {
 }
 
 //#endregion
-export { Config, DEFAULT_STREAM_IDLE_TIMEOUT_MS, apply, inject, name };
+export { Config, DEFAULT_STREAM_IDLE_TIMEOUT_MS, SubscriptionsAuthController, apply, inject, name };