dsh-plugin-subscriptions 0.4.2 → 0.5.1

package/lib/index.js

@@ -1,5 +1,5 @@
 import z from "@deepseek-ai/schemastery";
-import { CONTEXT_WINDOW_EXCEEDED_CODE, CallId, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, QUOTA_EXCEEDED_CODE, ReasoningEffortId, attributionHeaders, createUserMessage, errorChain, isContextWindowExceededError, isQuotaExceededError, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
+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 { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
@@ -155,7 +155,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 +250,164 @@ var OAuthFlowManager = class {
 	}
 };
 
+//#endregion
+//#region src/auth/device-flow.ts
+/**
+* GitHub OAuth device-authorization flow (RFC 8628) for providers that cannot
+* use the loopback redirect engine: no redirect URI, no PKCE, no client
+* secret. The user opens a verification URL and types a short code while the
+* plugin polls the token endpoint until GitHub releases the access token.
+* The management model (one attempt per provider, `isBusy`/`pending`/`cancel`)
+* mirrors {@link OAuthFlowManager} so the auth controller can treat both
+* engines uniformly.
+*/
+/** 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 ?? fetch;
+		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 +595,8 @@ async function refreshClaudeSynced(session, doRefresh) {
 const PROVIDER_IDS = [
 	"codex",
 	"claude",
-	"grok"
+	"grok",
+	"copilot"
 ];
 /**
 * Absolute path of the auth store file.
@@ -513,6 +672,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 +715,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 +727,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
@@ -595,6 +786,12 @@ function readString(payload, field) {
 	if (typeof value !== "string" || value.length === 0) throw new BadRequest(`payload.${field} must be a non-empty string`);
 	return value;
 }
+/** Validate the `setSpeed` endpoint's tier. */
+function readSpeedTier(payload) {
+	const tier = payload.tier;
+	if (tier !== "standard" && tier !== "fast") throw new BadRequest("payload.tier must be \"standard\" or \"fast\"");
+	return tier;
+}
 /** Validate the `image` endpoint's payload into a full attachment reference. */
 function readImageRef(payload) {
 	if (typeof payload !== "object" || payload === null) throw new BadRequest("payload must be an object");
@@ -633,7 +830,12 @@ function readVideoName(payload) {
 	if (typeof name$1 !== "string" || !VIDEO_NAME_PATTERN.test(name$1)) throw new BadRequest("payload.name must be a bare .mp4 file name");
 	return name$1;
 }
-async function dispatch(controller, endpoint, payload, signal) {
+/** Validate the session id both speed endpoints carry. */
+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) {
 	switch (endpoint) {
 		case "status": {
 			const entries = await Promise.all(PROVIDER_IDS.map(async (provider) => [provider, await controller.status(provider)]));
@@ -654,6 +856,10 @@ async function dispatch(controller, endpoint, payload, signal) {
 		case "usage": return ok(await controller.usage(readProvider(payload), signal));
 		case "image": return ok(await controller.readImage(readImageRef(payload), signal));
 		case "video": return ok(await controller.readVideo(readVideoName(payload), signal));
+		case "speed": return ok(await speed.speed(readSessionId(payload)));
+		case "setSpeed":
+			await speed.setSpeed(readSessionId(payload), readSpeedTier(payload));
+			return ok({ ok: true });
 		default: throw new BadRequest(`unknown /subscriptions-auth endpoint "${endpoint}"`);
 	}
 }
@@ -661,13 +867,14 @@ async function dispatch(controller, endpoint, payload, signal) {
 * Register the `/subscriptions-auth` RPC channel when a host connection exists.
 * @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.
 */
-function registerAuthRpc(ctx, controller) {
+function registerAuthRpc(ctx, controller, speed) {
 	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, endpoint, payload, signal);
+				return await dispatch(controller, speed, endpoint, payload, signal);
 			} catch (error) {
 				return failure(error);
 			}
@@ -691,6 +898,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 {
@@ -698,7 +906,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 }
 		};
 	});
 }
@@ -885,7 +1094,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;
@@ -906,6 +1115,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();
@@ -970,6 +1187,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
@@ -1013,6 +1258,14 @@ function sanitizeModel(value) {
 	if (raw.reasoning !== void 0 && reasoning === void 0) return void 0;
 	const thinkingType = raw.thinkingType;
 	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,
@@ -1020,7 +1273,11 @@ function sanitizeModel(value) {
 		...raw.contextWindow === void 0 ? {} : { contextWindow: raw.contextWindow },
 		...raw.priority === void 0 ? {} : { priority: raw.priority },
 		...reasoning === void 0 ? {} : { reasoning },
-		...thinkingType === void 0 ? {} : { thinkingType }
+		...thinkingType === void 0 ? {} : { thinkingType },
+		...fastTier === void 0 ? {} : { fastTier },
+		...copilotWire === void 0 ? {} : { copilotWire },
+		...copilotResponses === void 0 ? {} : { copilotResponses },
+		...inputModalities === void 0 ? {} : { inputModalities: [...inputModalities] }
 	};
 }
 /**
@@ -1202,22 +1459,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);
@@ -1241,8 +1507,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),
@@ -1250,12 +1527,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":
@@ -1317,7 +1595,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",
@@ -1379,7 +1657,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). */
@@ -1396,7 +1674,7 @@ var ResponsesStreamTranslator = class {
 			chunks.push({
 				type: "block-end",
 				index: block.index,
-				block: closeBlock$1(block)
+				block: closeBlock$2(block)
 			});
 			return;
 		}
@@ -1521,9 +1799,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;
@@ -1532,6 +1813,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;
 	}
@@ -1584,6 +1866,14 @@ const CODEX_EFFORTS = [
 const CODEX_DEFAULT_EFFORT = ReasoningEffortId("high");
 /** Every gpt-5.x codex model accepts image input. */
 const CODEX_MODALITIES = ["text", "image"];
+/**
+* Fast tier (the codex CLI's "fast mode"): the Responses `service_tier` wire
+* value for priority processing, mirroring codex-rs
+* `ServiceTier::Fast.request_value()`. The legacy catalog spelling is the
+* `additional_speed_tiers` entry "fast".
+*/
+const CODEX_FAST_SERVICE_TIER = "priority";
+const CODEX_FAST_SPEED_TIER = "fast";
 /** Static codex flow facts for the OAuth flow engine. */
 const codexFlow = {
 	callbackPath: CODEX_CALLBACK_PATH,
@@ -1795,6 +2085,14 @@ function effortName(effort) {
 	return effort === "xhigh" ? "Extra High" : effort.charAt(0).toUpperCase() + effort.slice(1);
 }
 /**
+* Whether a catalog entry advertises the fast tier. Mirrors codex-rs
+* `ModelPreset::supports_fast_mode`: a `service_tiers` id matching the fast
+* wire value, or the legacy `additional_speed_tiers` "fast" entry.
+*/
+function supportsFastTier(entry) {
+	return (entry.service_tiers ?? []).some((tier) => tier.id === CODEX_FAST_SERVICE_TIER) || (entry.additional_speed_tiers ?? []).includes(CODEX_FAST_SPEED_TIER);
+}
+/**
 * Fetch the live codex model catalog with the session's auth headers.
 * @param session - the stored session (used as-is; never refreshed here).
 * @param fetchFn - fetch implementation (injectable for tests).
@@ -1821,7 +2119,7 @@ async function fetchCodexModels(session, fetchFn = fetch) {
 			...level.description === void 0 ? {} : { description: level.description }
 		}));
 		const defaultEffort = typeof entry.default_reasoning_level === "string" && entry.default_reasoning_level.length > 0 && efforts.some((effort) => effort.id === ReasoningEffortId(entry.default_reasoning_level)) ? ReasoningEffortId(entry.default_reasoning_level) : void 0;
-		discovered.push({
+		const model = {
 			id: entry.slug,
 			name: typeof entry.display_name === "string" && entry.display_name.length > 0 ? entry.display_name : entry.slug,
 			...typeof entry.description === "string" && entry.description.length > 0 ? { description: entry.description } : {},
@@ -1830,13 +2128,84 @@ async function fetchCodexModels(session, fetchFn = fetch) {
 			...efforts.length > 0 ? { reasoning: {
 				efforts,
 				...defaultEffort === void 0 ? {} : { defaultEffort }
-			} } : {}
-		});
+			} } : {},
+			...supportsFastTier(entry) ? { fastTier: true } : {}
+		};
+		discovered.push(model);
 	}
 	discovered.sort((a, b) => (a.priority ?? Number.MAX_SAFE_INTEGER) - (b.priority ?? Number.MAX_SAFE_INTEGER));
 	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
+* `service_tier: priority`; the tier field is omitted entirely otherwise,
+* matching the CLI (it never sends an explicit standard tier).
+*/
+function codexRequestBody(options, resolved, fast) {
+	return {
+		model: options.model,
+		instructions: resolved.instructions ?? DEFAULT_CODEX_INSTRUCTIONS,
+		input: normalizeCodexCallIds(resolved.input),
+		...options.tools !== void 0 && options.tools.length > 0 ? { tools: toResponsesTools(options.tools) } : {},
+		tool_choice: "auto",
+		parallel_tool_calls: true,
+		...options.reasoningEffort !== void 0 ? { reasoning: {
+			effort: String(options.reasoningEffort),
+			summary: "auto"
+		} } : {},
+		store: false,
+		stream: true,
+		include: ["reasoning.encrypted_content"],
+		...options.sessionId !== void 0 ? { prompt_cache_key: String(options.sessionId) } : {},
+		...fast ? { service_tier: CODEX_FAST_SERVICE_TIER } : {}
+	};
+}
 /** Codex wire adapter: one instance serves the `codex` provider route. */
 var CodexAdapter = class extends LlmAdapter {
 	catalog;
@@ -1867,7 +2236,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,
@@ -1875,8 +2244,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);
 		}
@@ -1892,6 +2260,16 @@ var CodexAdapter = class extends LlmAdapter {
 		if (!this.options.discovery) return void 0;
 		return (await this.catalog.resolve(() => this.fetchCatalog()))?.find((entry) => entry.id === model);
 	}
+	/** Whether the discovered catalog advertises a fast tier for this model. */
+	async supportsFastTier(model) {
+		return (await this.discovered(model))?.fastTier === true;
+	}
+	/** Ids of every discovered model with a fast tier (the Speed toggle's visibility list). */
+	async fastCapableModels() {
+		if (!this.options.discovery) return [];
+		if (await this.options.tokens.peek() === void 0) return [];
+		return (await this.catalog.resolve(() => this.fetchCatalog()) ?? []).filter((model) => model.fastTier === true).map((model) => model.id);
+	}
 	async resolveModel(provider, model) {
 		const discovered = await this.discovered(model);
 		const configured = this.options.models.find((entry) => entry.id === model);
@@ -1930,23 +2308,9 @@ var CodexAdapter = class extends LlmAdapter {
 		}
 	}
 	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: instructions ?? DEFAULT_CODEX_INSTRUCTIONS,
-			input,
-			...options.tools !== void 0 && options.tools.length > 0 ? { tools: toResponsesTools(options.tools) } : {},
-			tool_choice: "auto",
-			parallel_tool_calls: true,
-			...options.reasoningEffort !== void 0 ? { reasoning: {
-				effort: String(options.reasoningEffort),
-				summary: "auto"
-			} } : {},
-			store: false,
-			stream: true,
-			include: ["reasoning.encrypted_content"],
-			...options.sessionId !== void 0 ? { prompt_cache_key: String(options.sessionId) } : {}
-		};
+		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, {
 			method: "POST",
 			headers: {
@@ -1972,8 +2336,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`. */
@@ -1987,11 +2370,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.
@@ -1999,30 +2420,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;
@@ -2046,13 +2471,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) {
@@ -2064,29 +2510,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",
@@ -2255,7 +2706,7 @@ var AnthropicStreamTranslator = class {
 				chunks.push({
 					type: "block-end",
 					index: block.index,
-					block: closeBlock(block)
+					block: closeBlock$1(block)
 				});
 				return chunks;
 			}
@@ -2282,7 +2733,7 @@ var AnthropicStreamTranslator = class {
 					chunks.push({
 						type: "block-end",
 						index: block.index,
-						block: closeBlock(block)
+						block: closeBlock$1(block)
 					});
 				}
 				this.emitUsage(chunks);
@@ -2330,11 +2781,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. */
@@ -2355,7 +2808,11 @@ function detectClaudeVersion() {
 	} catch {}
 	return CLAUDE_CLI_FALLBACK_VERSION;
 }
-const CLAUDE_CLI_USER_AGENT = `claude-cli/${detectClaudeVersion()} (external, cli)`;
+let claudeCliUserAgent;
+function getClaudeCliUserAgent() {
+	if (claudeCliUserAgent === void 0) claudeCliUserAgent = `claude-cli/${detectClaudeVersion()} (external, cli)`;
+	return claudeCliUserAgent;
+}
 const CLAUDE_BETA_FALLBACK = [
 	"claude-code-20250219",
 	"oauth-2025-04-20",
@@ -2366,6 +2823,26 @@ 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 {
@@ -2508,7 +2985,7 @@ async function fetchClaudeUsage(session, fetchFn = fetch, signal) {
 		headers: {
 			"authorization": `Bearer ${session.accessToken}`,
 			"anthropic-beta": "oauth-2025-04-20",
-			"user-agent": CLAUDE_CLI_USER_AGENT,
+			"user-agent": getClaudeCliUserAgent(),
 			"accept": "application/json"
 		},
 		...signal === void 0 ? {} : { signal }
@@ -2560,7 +3037,7 @@ async function fetchClaudeModels(session, fetchFn = fetch) {
 	const response = await fetchFn(CLAUDE_MODELS_URL, { headers: {
 		"authorization": `Bearer ${session.accessToken}`,
 		"anthropic-version": "2023-06-01",
-		"user-agent": CLAUDE_CLI_USER_AGENT,
+		"user-agent": getClaudeCliUserAgent(),
 		"anthropic-dangerous-direct-browser-access": "true",
 		"accept": "application/json"
 	} });
@@ -2590,6 +3067,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;
@@ -2635,15 +3142,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);
 		}
@@ -2708,26 +3214,14 @@ 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) } } : {}
-		};
+		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 fetch(CLAUDE_API_URL, {
 			method: "POST",
 			headers: {
 				"authorization": `Bearer ${session.accessToken}`,
 				"anthropic-version": "2023-06-01",
 				"anthropic-beta": CLAUDE_BETA_FLAGS,
-				"user-agent": CLAUDE_CLI_USER_AGENT,
+				"user-agent": getClaudeCliUserAgent(),
 				"x-app": "cli",
 				"anthropic-dangerous-direct-browser-access": "true",
 				"accept": "text/event-stream",
@@ -3047,23 +3541,42 @@ 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 — models it does not cover simply expose no efforts.
+* 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 = fetch, onWarn) {
+async function fetchGrokModels(session, fetchFn = fetch, 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?.(`grok CLI catalog fetch failed; reasoning efforts are unavailable (${errorChain(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();
@@ -3074,10 +3587,11 @@ async function fetchGrokModels(session, fetchFn = fetch, onWarn) {
 		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,
-			...cliCatalog?.get(entry.id)
+			...cli ?? grokPriorMeta(previousById?.get(entry.id))
 		});
 	}
 	if (discovered.length === 0) throw new Error("grok models endpoint returned an empty catalog");
@@ -3093,7 +3607,16 @@ 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 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 {
@@ -3113,16 +3636,9 @@ var GrokAdapter = 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) => ({
-				provider,
-				id: model.id,
-				name: model.name,
-				...model.description === void 0 ? {} : { description: model.description },
-				inputModalities: grokModalities(model.id)
-			}));
+			return this.listed(provider, await discoverOrRetryAuth((force) => this.options.tokens.session(force), this.catalog, () => this.catalog.get(() => this.fetchCatalog())));
 		} 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?.(`grok model discovery failed; using the built-in catalog (${errorChain(error)})`);
 			return this.staticModels(provider);
 		}
@@ -3202,56 +3718,1074 @@ var GrokAdapter = class extends LlmAdapter {
 };
 
 //#endregion
-//#region src/tools/x-search.ts
-/** Endpoint the search request is posted to. */
-const X_SEARCH_URL = "https://api.x.ai/v1/responses";
-/** Grok model the search runs on (a catalog model of the grok provider). */
-const X_SEARCH_MODEL = "grok-4";
-/** xAI caps each handle filter list at ten entries. */
-const MAX_HANDLES = 10;
-/**
-* Validate and assemble the request facts from tool arguments. Throws plain
-* Errors for argument problems the schema DSL cannot express (non-empty
-* query, handle caps, mutually exclusive filters).
-*/
-function buildXSearchRequest(args) {
-	const query = args.query.trim();
-	if (query.length === 0) throw new Error("x_search: query must be a non-empty string");
-	const allowed = normalizeHandles(args.allowed_x_handles, "allowed_x_handles");
-	const excluded = normalizeHandles(args.excluded_x_handles, "excluded_x_handles");
-	if (allowed.length > 0 && excluded.length > 0) throw new Error("x_search: allowed_x_handles and excluded_x_handles cannot be used together");
-	const tool = { type: "x_search" };
-	if (allowed.length > 0) tool.allowed_x_handles = allowed;
-	if (excluded.length > 0) tool.excluded_x_handles = excluded;
-	if (args.from_date !== void 0 && args.from_date.trim().length > 0) tool.from_date = args.from_date.trim();
-	if (args.to_date !== void 0 && args.to_date.trim().length > 0) tool.to_date = args.to_date.trim();
-	if (args.enable_image_understanding === true) tool.enable_image_understanding = true;
-	if (args.enable_video_understanding === true) tool.enable_video_understanding = true;
-	return {
-		query,
-		tool
-	};
-}
-/** Strip `@` prefixes, drop blanks, and enforce the provider's handle cap. */
-function normalizeHandles(value, field) {
-	if (value === void 0) return [];
-	const handles = value.map((handle) => handle.trim().replace(/^@+/, "")).filter((handle) => handle.length > 0);
-	if (handles.length > MAX_HANDLES) throw new Error(`x_search: ${field} supports at most ${MAX_HANDLES} handles`);
-	return handles;
-}
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+//#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("");
 }
 /**
-* Extract the answer text and citation URLs from a Responses payload: the
-* `output_text` shortcut or message output parts for the answer, and both
-* top-level `citations` and inline `url_citation` annotations for sources.
+* 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 parseXSearchResponse(payload) {
-	const body = isRecord$1(payload) ? payload : {};
-	let answer = typeof body.output_text === "string" ? body.output_text.trim() : "";
-	const citations = [];
-	const push = (url) => {
+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 = fetch, 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" } : {}
+	};
+}
+/**
+* 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.
+*/
+async function exchangeCopilotToken(githubToken, fetchFn = fetch) {
+	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
+	};
+}
+/**
+* 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.
+*/
+async function completeCopilotLogin(githubToken, fetchFn = fetch) {
+	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 {
+		accessToken: pair.accessToken,
+		refreshToken: githubToken,
+		expiresAt: pair.expiresAt,
+		...account === void 0 ? {} : { account }
+	};
+}
+/**
+* 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 the fresh session to store.
+*/
+async function refreshCopilot(session, fetchFn = fetch) {
+	const pair = await exchangeCopilotToken(session.refreshToken, fetchFn);
+	return {
+		accessToken: pair.accessToken,
+		refreshToken: session.refreshToken,
+		expiresAt: pair.expiresAt,
+		...session.account === void 0 ? {} : { account: session.account }
+	};
+}
+/**
+* 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 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);
+}
+/**
+* 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).
+* @returns discovered chat models in endpoint order.
+*/
+async function fetchCopilotModels(session, fetchFn = fetch) {
+	const response = await fetchFn(COPILOT_MODELS_URL, { headers: {
+		"authorization": `Bearer ${session.accessToken}`,
+		"accept": "application/json",
+		...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("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 (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: 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("copilot models endpoint returned an empty catalog");
+	return discovered;
+}
+/**
+* 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;
+		this.catalog = new ModelCatalogCache(options.catalogStore);
+	}
+	/** Discovery fetcher: resolves the session through the refresh-aware path. */
+	async fetchCatalog() {
+		return fetchCopilotModels(await this.options.tokens.session(), this.options.fetchFn);
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: "GitHub Copilot"
+		};
+	}
+	staticModels(provider) {
+		return this.options.models.map((model) => ({
+			provider,
+			id: model.id,
+			name: model.name ?? 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 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 },
+				...model.inputModalities === void 0 ? {} : { inputModalities: model.inputModalities }
+			}));
+		} catch (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 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);
+		return {
+			provider,
+			id: model,
+			name: discovered?.name ?? configured?.name ?? model,
+			...discovered?.description === void 0 ? {} : { description: discovered.description },
+			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();
+			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 ?? fetch, true);
+				session = await this.options.tokens.session(true);
+				response = await this.request(options, session, watchdog.signal, wire, scope);
+			}
+			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("copilot API", error, watchdog, options.signal);
+		} finally {
+			watchdog.stop();
+		}
+	}
+	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 fetch(wire === "responses" ? COPILOT_RESPONSES_URL : COPILOT_API_URL, {
+			method: "POST",
+			headers: {
+				"authorization": `Bearer ${session.accessToken}`,
+				"accept": "text/event-stream",
+				"content-type": "application/json",
+				...copilotHeaders(hasVision, await latestVsCodeVersion(this.options.fetchFn ?? fetch))
+			},
+			body: JSON.stringify(body),
+			signal
+		});
+	}
+};
+
+//#endregion
+//#region src/tools/x-search.ts
+/** Endpoint the search request is posted to. */
+const X_SEARCH_URL = "https://api.x.ai/v1/responses";
+/** Grok model the search runs on (a catalog model of the grok provider). */
+const X_SEARCH_MODEL = "grok-4";
+/** xAI caps each handle filter list at ten entries. */
+const MAX_HANDLES = 10;
+/**
+* Validate and assemble the request facts from tool arguments. Throws plain
+* Errors for argument problems the schema DSL cannot express (non-empty
+* query, handle caps, mutually exclusive filters).
+*/
+function buildXSearchRequest(args) {
+	const query = args.query.trim();
+	if (query.length === 0) throw new Error("x_search: query must be a non-empty string");
+	const allowed = normalizeHandles(args.allowed_x_handles, "allowed_x_handles");
+	const excluded = normalizeHandles(args.excluded_x_handles, "excluded_x_handles");
+	if (allowed.length > 0 && excluded.length > 0) throw new Error("x_search: allowed_x_handles and excluded_x_handles cannot be used together");
+	const tool = { type: "x_search" };
+	if (allowed.length > 0) tool.allowed_x_handles = allowed;
+	if (excluded.length > 0) tool.excluded_x_handles = excluded;
+	if (args.from_date !== void 0 && args.from_date.trim().length > 0) tool.from_date = args.from_date.trim();
+	if (args.to_date !== void 0 && args.to_date.trim().length > 0) tool.to_date = args.to_date.trim();
+	if (args.enable_image_understanding === true) tool.enable_image_understanding = true;
+	if (args.enable_video_understanding === true) tool.enable_video_understanding = true;
+	return {
+		query,
+		tool
+	};
+}
+/** Strip `@` prefixes, drop blanks, and enforce the provider's handle cap. */
+function normalizeHandles(value, field) {
+	if (value === void 0) return [];
+	const handles = value.map((handle) => handle.trim().replace(/^@+/, "")).filter((handle) => handle.length > 0);
+	if (handles.length > MAX_HANDLES) throw new Error(`x_search: ${field} supports at most ${MAX_HANDLES} handles`);
+	return handles;
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Extract the answer text and citation URLs from a Responses payload: the
+* `output_text` shortcut or message output parts for the answer, and both
+* top-level `citations` and inline `url_citation` annotations for sources.
+*/
+function parseXSearchResponse(payload) {
+	const body = isRecord$1(payload) ? payload : {};
+	let answer = typeof body.output_text === "string" ? body.output_text.trim() : "";
+	const citations = [];
+	const push = (url) => {
 		if (typeof url === "string" && url.length > 0 && !citations.includes(url)) citations.push(url);
 	};
 	if (Array.isArray(body.citations)) for (const citation of body.citations) push(citation);
@@ -3697,19 +5231,11 @@ function createImageGenerateTool(options) {
 				});
 			}
 			const revisedPrompt = images.find((image) => image.revisedPrompt !== void 0)?.revisedPrompt;
-			const value = {
+			return {
 				paths,
 				...refs.length > 0 ? { images: refs } : {},
 				...revisedPrompt === void 0 ? {} : { revisedPrompt }
 			};
-			if (exec.parent !== void 0 && refs.length > 0) exec.deferContext(createUserMessage({
-				content: imageGenerateContent(value),
-				source: {
-					kind: "plugin",
-					plugin: "dsh-plugin-subscriptions"
-				}
-			}));
-			return value;
 		}
 	});
 }
@@ -3966,26 +5492,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. */
@@ -4042,6 +5572,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. */
@@ -4053,7 +5605,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. */
@@ -4066,21 +5619,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];
@@ -4108,7 +5689,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 }
@@ -4116,30 +5697,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) {
@@ -4147,6 +5771,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) {
@@ -4154,8 +5779,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`));
@@ -4163,11 +5799,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);
@@ -4180,18 +5820,23 @@ 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;
 	let claudeTokens;
 	let grokTokens;
 	const usageFetchers = {};
+	const speedBySession = /* @__PURE__ */ new Map();
+	let codexAdapter;
+	let copilotAdapter;
 	for (const provider of providers) switch (provider) {
 		case "codex": {
 			const tokens = new TokenManager({
@@ -4208,15 +5853,19 @@ function apply(ctx, config) {
 			});
 			codexTokens = tokens;
 			usageFetchers.codex = async (signal) => fetchCodexUsage(await tokens.session(), fetch, signal);
-			handles.set("codex", ctx.llm.registerAdapter(["codex"], new CodexAdapter({
+			let adapter;
+			adapter = new CodexAdapter({
 				models: catalog.codex,
 				streamIdleTimeoutMs,
 				tokens,
 				discovery: !overridden.has("codex"),
 				onWarn,
 				resolveAttachments,
-				catalogStore: catalogStore("codex")
-			})));
+				catalogStore: catalogStore("codex"),
+				speedFor: (sessionId, model) => sessionId !== void 0 && speedBySession.get(sessionId) === "fast" && adapter.supportsFastTier(model)
+			});
+			codexAdapter = adapter;
+			handles.set("codex", ctx.llm.registerAdapter(["codex"], adapter));
 			break;
 		}
 		case "claude": {
@@ -4272,8 +5921,44 @@ 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",
+				fastModels: await codexAdapter?.fastCapableModels() ?? []
+			};
+		},
+		async setSpeed(sessionId, tier) {
+			if (tier === "standard") speedBySession.delete(sessionId);
+			else speedBySession.set(sessionId, tier);
+		}
+	});
 	if (claudeTokens !== void 0) {
 		const syncTimer = setInterval(() => {
 			claudeTokens?.session().catch(() => {});
@@ -4297,4 +5982,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 };